Land part 2 of clang-format changes

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

3 files changed, 5624 insertions, 5816 deletions

diff --git a/xlators/mount/fuse/src/fuse-bridge.c b/xlators/mount/fuse/src/fuse-bridge.c
index cd163781462..e4e64dd4a96 100644
--- a/xlators/mount/fuse/src/fuse-bridge.c
+++ b/xlators/mount/fuse/src/fuse-bridge.c
@@ -22,9 +22,11 @@
 
 static int gf_fuse_xattr_enotsup_log;
 
-void fini (xlator_t *this_xl);
+void
+fini(xlator_t *this_xl);
 
-static void fuse_invalidate_inode(xlator_t *this, uint64_t fuse_ino);
+static void
+fuse_invalidate_inode(xlator_t *this, uint64_t fuse_ino);
 
 /*
  * Send an invalidate notification up to fuse to purge the file from local
@@ -34,218 +36,220 @@ static void fuse_invalidate_inode(xlator_t *this, uint64_t fuse_ino);
 static int32_t
 fuse_invalidate(xlator_t *this, inode_t *inode)
 {
-        fuse_private_t *priv = this->private;
-        uint64_t nodeid;
+    fuse_private_t *priv = this->private;
+    uint64_t nodeid;
 
-        /*
-         * NOTE: We only invalidate at the moment if fopen_keep_cache is
-         * enabled because otherwise this is a departure from default
-         * behavior. Specifically, the performance/write-behind xlator
-         * causes unconditional invalidations on write requests.
-         */
-        if (!priv->fopen_keep_cache)
-                return 0;
+    /*
+     * NOTE: We only invalidate at the moment if fopen_keep_cache is
+     * enabled because otherwise this is a departure from default
+     * behavior. Specifically, the performance/write-behind xlator
+     * causes unconditional invalidations on write requests.
+     */
+    if (!priv->fopen_keep_cache)
+        return 0;
 
-        nodeid = inode_to_fuse_nodeid(inode);
-        gf_log(this->name, GF_LOG_DEBUG, "Invalidate inode id %"GF_PRI_INODE"." , nodeid);
-        fuse_log_eh (this, "Sending invalidate inode id: %"GF_PRI_INODE" gfid: %s", nodeid,
-                     uuid_utoa (inode->gfid));
-        fuse_invalidate_inode(this, nodeid);
+    nodeid = inode_to_fuse_nodeid(inode);
+    gf_log(this->name, GF_LOG_DEBUG, "Invalidate inode id %" GF_PRI_INODE ".",
+           nodeid);
+    fuse_log_eh(this, "Sending invalidate inode id: %" GF_PRI_INODE " gfid: %s",
+                nodeid, uuid_utoa(inode->gfid));
+    fuse_invalidate_inode(this, nodeid);
 
-        return 0;
+    return 0;
 }
 
 static int32_t
-fuse_forget_cbk (xlator_t *this, inode_t *inode)
+fuse_forget_cbk(xlator_t *this, inode_t *inode)
 {
-        //Nothing to free in inode ctx, hence return.
-        return 0;
+    // Nothing to free in inode ctx, hence return.
+    return 0;
 }
 
 fuse_fd_ctx_t *
-__fuse_fd_ctx_check_n_create (xlator_t *this, fd_t *fd)
+__fuse_fd_ctx_check_n_create(xlator_t *this, fd_t *fd)
 {
-        uint64_t       val    = 0;
-        int32_t        ret    = 0;
-        fuse_fd_ctx_t *fd_ctx = NULL;
+    uint64_t val = 0;
+    int32_t ret = 0;
+    fuse_fd_ctx_t *fd_ctx = NULL;
 
-        ret = __fd_ctx_get (fd, this, &val);
+    ret = __fd_ctx_get(fd, this, &val);
 
-        fd_ctx = (fuse_fd_ctx_t *)(unsigned long) val;
+    fd_ctx = (fuse_fd_ctx_t *)(unsigned long)val;
 
-        if (fd_ctx == NULL) {
-                fd_ctx = GF_CALLOC (1, sizeof (*fd_ctx),
-                                    gf_fuse_mt_fd_ctx_t);
-                if (!fd_ctx) {
-                    goto out;
-                }
-                ret = __fd_ctx_set (fd, this,
-                                    (uint64_t)(unsigned long)fd_ctx);
-                if (ret < 0) {
-                        gf_log ("glusterfs-fuse", GF_LOG_DEBUG,
-                                "fd-ctx-set failed");
-                        GF_FREE (fd_ctx);
-                        fd_ctx = NULL;
-                }
+    if (fd_ctx == NULL) {
+        fd_ctx = GF_CALLOC(1, sizeof(*fd_ctx), gf_fuse_mt_fd_ctx_t);
+        if (!fd_ctx) {
+            goto out;
+        }
+        ret = __fd_ctx_set(fd, this, (uint64_t)(unsigned long)fd_ctx);
+        if (ret < 0) {
+            gf_log("glusterfs-fuse", GF_LOG_DEBUG, "fd-ctx-set failed");
+            GF_FREE(fd_ctx);
+            fd_ctx = NULL;
         }
+    }
 out:
-        return fd_ctx;
+    return fd_ctx;
 }
 
 fuse_fd_ctx_t *
-fuse_fd_ctx_check_n_create (xlator_t *this, fd_t *fd)
+fuse_fd_ctx_check_n_create(xlator_t *this, fd_t *fd)
 {
-        fuse_fd_ctx_t *fd_ctx = NULL;
+    fuse_fd_ctx_t *fd_ctx = NULL;
 
-        if ((fd == NULL) || (this == NULL)) {
-                goto out;
-        }
+    if ((fd == NULL) || (this == NULL)) {
+        goto out;
+    }
 
-        LOCK (&fd->lock);
-        {
-                fd_ctx = __fuse_fd_ctx_check_n_create (this, fd);
-        }
-        UNLOCK (&fd->lock);
+    LOCK(&fd->lock);
+    {
+        fd_ctx = __fuse_fd_ctx_check_n_create(this, fd);
+    }
+    UNLOCK(&fd->lock);
 
 out:
-        return fd_ctx;
+    return fd_ctx;
 }
 
 static void
-fuse_fd_ctx_destroy (xlator_t *this, fd_t *fd)
-{
-        fd_t                   *activefd  = NULL;
-        uint64_t                val       = 0;
-        int                     ret       = 0;
-        fuse_fd_ctx_t          *fdctx     = NULL;
-
-        ret = fd_ctx_del (fd, this, &val);
-        if (!ret) {
-                fdctx = (fuse_fd_ctx_t *)(unsigned long)val;
-                if (fdctx) {
-                        activefd = fdctx->activefd;
-                        if (activefd) {
-                                fd_unref (activefd);
-                        }
-
-                        GF_FREE (fdctx);
-                }
+fuse_fd_ctx_destroy(xlator_t *this, fd_t *fd)
+{
+    fd_t *activefd = NULL;
+    uint64_t val = 0;
+    int ret = 0;
+    fuse_fd_ctx_t *fdctx = NULL;
+
+    ret = fd_ctx_del(fd, this, &val);
+    if (!ret) {
+        fdctx = (fuse_fd_ctx_t *)(unsigned long)val;
+        if (fdctx) {
+            activefd = fdctx->activefd;
+            if (activefd) {
+                fd_unref(activefd);
+            }
+
+            GF_FREE(fdctx);
         }
+    }
 }
 
 fuse_fd_ctx_t *
-fuse_fd_ctx_get (xlator_t *this, fd_t *fd)
+fuse_fd_ctx_get(xlator_t *this, fd_t *fd)
 {
-        fuse_fd_ctx_t *fdctx = NULL;
-        uint64_t       value = 0;
-        int            ret   = 0;
+    fuse_fd_ctx_t *fdctx = NULL;
+    uint64_t value = 0;
+    int ret = 0;
 
-        ret = fd_ctx_get (fd, this, &value);
-        if (ret < 0) {
-                goto out;
-        }
+    ret = fd_ctx_get(fd, this, &value);
+    if (ret < 0) {
+        goto out;
+    }
 
-        fdctx = (fuse_fd_ctx_t *) (unsigned long)value;
+    fdctx = (fuse_fd_ctx_t *)(unsigned long)value;
 
 out:
-        return fdctx;
+    return fdctx;
 }
 
-
 struct fusedump_timespec {
-        uint32_t len;
-        uint64_t sec;
-        uint32_t nsec;
+    uint32_t len;
+    uint64_t sec;
+    uint32_t nsec;
 } __attribute__((packed));
 
 struct fusedump_signature {
-        uint32_t len;
-        char sig[8];
+    uint32_t len;
+    char sig[8];
 } __attribute__((packed));
 
 static void
-fusedump_gettime (struct fusedump_timespec *fts)
+fusedump_gettime(struct fusedump_timespec *fts)
 {
-        struct timespec ts = {0,};
+    struct timespec ts = {
+        0,
+    };
 
-        clock_gettime (CLOCK_REALTIME, &ts);
+    clock_gettime(CLOCK_REALTIME, &ts);
 
-        fts->sec  = ts.tv_sec;
-        fts->nsec = ts.tv_nsec;
+    fts->sec = ts.tv_sec;
+    fts->nsec = ts.tv_nsec;
 }
 
 static void
-fusedump_setup_meta (struct iovec *iovs, char *dir,
-                     uint32_t *fusedump_item_count,
-                     struct fusedump_timespec *fts,
-                     struct fusedump_signature *fsig)
+fusedump_setup_meta(struct iovec *iovs, char *dir,
+                    uint32_t *fusedump_item_count,
+                    struct fusedump_timespec *fts,
+                    struct fusedump_signature *fsig)
 {
-        char glustersig[8] = {'G', 'L', 'U', 'S', 'T', 'E', 'R', 0xF5};
+    char glustersig[8] = {'G', 'L', 'U', 'S', 'T', 'E', 'R', 0xF5};
 
-        *fusedump_item_count = 3;
-        fts->len = sizeof (*fts);
-        fusedump_gettime (fts);
-        fsig->len = sizeof (*fsig);
-        memcpy (fsig->sig, glustersig, 8);
+    *fusedump_item_count = 3;
+    fts->len = sizeof(*fts);
+    fusedump_gettime(fts);
+    fsig->len = sizeof(*fsig);
+    memcpy(fsig->sig, glustersig, 8);
 
-        iovs[0] = (struct iovec){ dir, sizeof (*dir) };
-        iovs[1] = (struct iovec){ fusedump_item_count,
-                                  sizeof (*fusedump_item_count) };
-        iovs[2] = (struct iovec){ fts, fts->len };
-        iovs[3] = (struct iovec){ fsig, fsig->len };
+    iovs[0] = (struct iovec){dir, sizeof(*dir)};
+    iovs[1] = (struct iovec){fusedump_item_count, sizeof(*fusedump_item_count)};
+    iovs[2] = (struct iovec){fts, fts->len};
+    iovs[3] = (struct iovec){fsig, fsig->len};
 }
 
 static int
-check_and_dump_fuse_W (fuse_private_t *priv, struct iovec *iov_out, int count,
-                       ssize_t res)
+check_and_dump_fuse_W(fuse_private_t *priv, struct iovec *iov_out, int count,
+                      ssize_t res)
 {
-        char w                         = 'W';
-        struct iovec diov[4]           = {{0,},};
-        uint32_t fusedump_item_count   = 3;
-        struct fusedump_timespec fts   = {0,};
-        struct fusedump_signature fsig = {0,};
-        struct fuse_out_header *fouh   = NULL;
-
-        if (res == -1) {
-                gf_log ("glusterfs-fuse", GF_LOG_ERROR,
-                        "writing to fuse device failed: %s",
-                        strerror (errno));
-                return errno;
-        }
-
-        fouh = iov_out[0].iov_base;
-        if (res != fouh->len) {
-                gf_log ("glusterfs-fuse", GF_LOG_ERROR,
-                        "inconsistent write to fuse device: "
-                        "written %zd, expectd %d",
-                        res, fouh->len);
-                return EINVAL;
-        }
-
-        if (priv->fuse_dump_fd == -1)
-                return 0;
+    char w = 'W';
+    struct iovec diov[4] = {
+        {
+            0,
+        },
+    };
+    uint32_t fusedump_item_count = 3;
+    struct fusedump_timespec fts = {
+        0,
+    };
+    struct fusedump_signature fsig = {
+        0,
+    };
+    struct fuse_out_header *fouh = NULL;
+
+    if (res == -1) {
+        gf_log("glusterfs-fuse", GF_LOG_ERROR,
+               "writing to fuse device failed: %s", strerror(errno));
+        return errno;
+    }
+
+    fouh = iov_out[0].iov_base;
+    if (res != fouh->len) {
+        gf_log("glusterfs-fuse", GF_LOG_ERROR,
+               "inconsistent write to fuse device: "
+               "written %zd, expectd %d",
+               res, fouh->len);
+        return EINVAL;
+    }
+
+    if (priv->fuse_dump_fd == -1)
+        return 0;
 
-        fusedump_setup_meta (diov, &w, &fusedump_item_count,
-                             &fts, &fsig);
+    fusedump_setup_meta(diov, &w, &fusedump_item_count, &fts, &fsig);
 
-        pthread_mutex_lock (&priv->fuse_dump_mutex);
-        res = sys_writev (priv->fuse_dump_fd, diov,
-                          sizeof (diov)/sizeof (diov[0]));
-        if (res != -1)
-                res = sys_writev (priv->fuse_dump_fd, iov_out, count);
-        pthread_mutex_unlock (&priv->fuse_dump_mutex);
+    pthread_mutex_lock(&priv->fuse_dump_mutex);
+    res = sys_writev(priv->fuse_dump_fd, diov, sizeof(diov) / sizeof(diov[0]));
+    if (res != -1)
+        res = sys_writev(priv->fuse_dump_fd, iov_out, count);
+    pthread_mutex_unlock(&priv->fuse_dump_mutex);
 
-        if (res == -1)
-                gf_log ("glusterfs-fuse", GF_LOG_ERROR,
-                        "failed to dump fuse message (W): %s",
-                        strerror (errno));
+    if (res == -1)
+        gf_log("glusterfs-fuse", GF_LOG_ERROR,
+               "failed to dump fuse message (W): %s", strerror(errno));
 
-        /*
-         * Return value reflects check on write to /dev/fuse,
-         * so ignore issues with dumping.
-         */
+    /*
+     * Return value reflects check on write to /dev/fuse,
+     * so ignore issues with dumping.
+     */
 
-         return 0;
+    return 0;
 }
 
 /*
@@ -253,123 +257,126 @@ check_and_dump_fuse_W (fuse_private_t *priv, struct iovec *iov_out, int count,
  * The error value of this header is sent to kernel.
  */
 static int
-send_fuse_iov (xlator_t *this, fuse_in_header_t *finh, struct iovec *iov_out,
-               int count)
+send_fuse_iov(xlator_t *this, fuse_in_header_t *finh, struct iovec *iov_out,
+              int count)
 {
-        fuse_private_t *priv = NULL;
-        struct fuse_out_header *fouh = NULL;
-        int res, i;
+    fuse_private_t *priv = NULL;
+    struct fuse_out_header *fouh = NULL;
+    int res, i;
 
-        if (!this || !finh || !iov_out) {
-                gf_log ("send_fuse_iov", GF_LOG_ERROR,"Invalid arguments");
-                return EINVAL;
-        }
-        priv = this->private;
+    if (!this || !finh || !iov_out) {
+        gf_log("send_fuse_iov", GF_LOG_ERROR, "Invalid arguments");
+        return EINVAL;
+    }
+    priv = this->private;
 
-        fouh = iov_out[0].iov_base;
-        iov_out[0].iov_len = sizeof (*fouh);
-        fouh->len = 0;
-        for (i = 0; i < count; i++)
-                fouh->len += iov_out[i].iov_len;
-        fouh->unique = finh->unique;
+    fouh = iov_out[0].iov_base;
+    iov_out[0].iov_len = sizeof(*fouh);
+    fouh->len = 0;
+    for (i = 0; i < count; i++)
+        fouh->len += iov_out[i].iov_len;
+    fouh->unique = finh->unique;
 
-        res = sys_writev (priv->fd, iov_out, count);
-        gf_log ("glusterfs-fuse", GF_LOG_TRACE, "writev() result %d/%d %s",
-                res, fouh->len, res == -1 ? strerror (errno) : "");
+    res = sys_writev(priv->fd, iov_out, count);
+    gf_log("glusterfs-fuse", GF_LOG_TRACE, "writev() result %d/%d %s", res,
+           fouh->len, res == -1 ? strerror(errno) : "");
 
-        return check_and_dump_fuse_W (priv, iov_out, count, res);
+    return check_and_dump_fuse_W(priv, iov_out, count, res);
 }
 
 static int
-send_fuse_data (xlator_t *this, fuse_in_header_t *finh, void *data, size_t size)
+send_fuse_data(xlator_t *this, fuse_in_header_t *finh, void *data, size_t size)
 {
-        struct fuse_out_header fouh = {0, };
-        struct iovec iov_out[2];
-        int ret = 0;
+    struct fuse_out_header fouh = {
+        0,
+    };
+    struct iovec iov_out[2];
+    int ret = 0;
 
-        fouh.error = 0;
-        iov_out[0].iov_base = &fouh;
-        iov_out[1].iov_base = data;
-        iov_out[1].iov_len = size;
+    fouh.error = 0;
+    iov_out[0].iov_base = &fouh;
+    iov_out[1].iov_base = data;
+    iov_out[1].iov_len = size;
 
-        ret = send_fuse_iov (this, finh, iov_out, 2);
-        if (ret != 0)
-                gf_log ("glusterfs-fuse", GF_LOG_ERROR, "send_fuse_iov() "
-                        "failed: %s", strerror (ret));
+    ret = send_fuse_iov(this, finh, iov_out, 2);
+    if (ret != 0)
+        gf_log("glusterfs-fuse", GF_LOG_ERROR,
+               "send_fuse_iov() "
+               "failed: %s",
+               strerror(ret));
 
-        return ret;
+    return ret;
 }
 
-#define send_fuse_obj(this, finh, obj) \
-        send_fuse_data (this, finh, obj, sizeof (*(obj)))
-
+#define send_fuse_obj(this, finh, obj)                                         \
+    send_fuse_data(this, finh, obj, sizeof(*(obj)))
 
 #if FUSE_KERNEL_MINOR_VERSION >= 11
 static void
-fuse_invalidate_entry (xlator_t *this, uint64_t fuse_ino)
+fuse_invalidate_entry(xlator_t *this, uint64_t fuse_ino)
 {
-        struct fuse_out_header             *fouh   = NULL;
-        struct fuse_notify_inval_entry_out *fnieo  = NULL;
-        fuse_private_t                     *priv   = NULL;
-        dentry_t                           *dentry = NULL;
-        inode_t                            *inode  = NULL;
-        size_t                              nlen   = 0;
-        fuse_invalidate_node_t             *node   = NULL;
+    struct fuse_out_header *fouh = NULL;
+    struct fuse_notify_inval_entry_out *fnieo = NULL;
+    fuse_private_t *priv = NULL;
+    dentry_t *dentry = NULL;
+    inode_t *inode = NULL;
+    size_t nlen = 0;
+    fuse_invalidate_node_t *node = NULL;
 
-        priv = this->private;
+    priv = this->private;
 
-        if (!priv->reverse_fuse_thread_started)
-                return;
+    if (!priv->reverse_fuse_thread_started)
+        return;
 
-        inode = fuse_ino_to_inode(fuse_ino, this);
-        if (inode == NULL) {
-                return;
-        }
+    inode = fuse_ino_to_inode(fuse_ino, this);
+    if (inode == NULL) {
+        return;
+    }
 
-        list_for_each_entry (dentry, &inode->dentry_list, inode_list) {
-                node = GF_CALLOC (1, sizeof (*node),
-                                  gf_fuse_mt_invalidate_node_t);
-                if (node == NULL)
-                        break;
+    list_for_each_entry(dentry, &inode->dentry_list, inode_list)
+    {
+        node = GF_CALLOC(1, sizeof(*node), gf_fuse_mt_invalidate_node_t);
+        if (node == NULL)
+            break;
 
-                INIT_LIST_HEAD (&node->next);
+        INIT_LIST_HEAD(&node->next);
 
-                fouh  = (struct fuse_out_header *)node->inval_buf;
-                fnieo = (struct fuse_notify_inval_entry_out *)(fouh + 1);
+        fouh = (struct fuse_out_header *)node->inval_buf;
+        fnieo = (struct fuse_notify_inval_entry_out *)(fouh + 1);
 
-                fouh->unique = 0;
-                fouh->error = FUSE_NOTIFY_INVAL_ENTRY;
+        fouh->unique = 0;
+        fouh->error = FUSE_NOTIFY_INVAL_ENTRY;
 
-                nlen = strlen (dentry->name);
-                fouh->len = sizeof (*fouh) + sizeof (*fnieo) + nlen + 1;
-                fnieo->parent = inode_to_fuse_nodeid (dentry->parent);
+        nlen = strlen(dentry->name);
+        fouh->len = sizeof(*fouh) + sizeof(*fnieo) + nlen + 1;
+        fnieo->parent = inode_to_fuse_nodeid(dentry->parent);
 
-                fnieo->namelen = nlen;
-                strcpy (node->inval_buf + sizeof (*fouh) + sizeof (*fnieo),
-                        dentry->name);
+        fnieo->namelen = nlen;
+        strcpy(node->inval_buf + sizeof(*fouh) + sizeof(*fnieo), dentry->name);
 
-                pthread_mutex_lock (&priv->invalidate_mutex);
-                {
-                        list_add_tail (&node->next, &priv->invalidate_list);
-                        pthread_cond_signal (&priv->invalidate_cond);
-                }
-                pthread_mutex_unlock (&priv->invalidate_mutex);
+        pthread_mutex_lock(&priv->invalidate_mutex);
+        {
+            list_add_tail(&node->next, &priv->invalidate_list);
+            pthread_cond_signal(&priv->invalidate_cond);
+        }
+        pthread_mutex_unlock(&priv->invalidate_mutex);
 
-                gf_log ("glusterfs-fuse", GF_LOG_TRACE, "INVALIDATE entry: "
-                        "%"PRIu64"/%s", fnieo->parent, dentry->name);
+        gf_log("glusterfs-fuse", GF_LOG_TRACE,
+               "INVALIDATE entry: "
+               "%" PRIu64 "/%s",
+               fnieo->parent, dentry->name);
 
-                if (dentry->parent) {
-                        fuse_log_eh (this, "Invalidated entry %s (parent: %s)",
-                                     dentry->name,
-                                     uuid_utoa (dentry->parent->gfid));
-                } else {
-                        fuse_log_eh (this, "Invalidated entry %s(nodeid: %" PRIu64 ")",
-                                     dentry->name, fnieo->parent);
-                }
+        if (dentry->parent) {
+            fuse_log_eh(this, "Invalidated entry %s (parent: %s)", dentry->name,
+                        uuid_utoa(dentry->parent->gfid));
+        } else {
+            fuse_log_eh(this, "Invalidated entry %s(nodeid: %" PRIu64 ")",
+                        dentry->name, fnieo->parent);
         }
+    }
 
-        if (inode)
-                inode_unref (inode);
+    if (inode)
+        inode_unref(inode);
 }
 #endif
 
@@ -381,362 +388,351 @@ static void
 fuse_invalidate_inode(xlator_t *this, uint64_t fuse_ino)
 {
 #if FUSE_KERNEL_MINOR_VERSION >= 11
-        struct fuse_out_header *fouh = NULL;
-        struct fuse_notify_inval_inode_out *fniio = NULL;
-        fuse_private_t *priv = NULL;
-        fuse_invalidate_node_t *node = NULL;
-        inode_t    *inode = NULL;
+    struct fuse_out_header *fouh = NULL;
+    struct fuse_notify_inval_inode_out *fniio = NULL;
+    fuse_private_t *priv = NULL;
+    fuse_invalidate_node_t *node = NULL;
+    inode_t *inode = NULL;
 
-        priv = this->private;
+    priv = this->private;
 
-        if (!priv->reverse_fuse_thread_started)
-                return;
+    if (!priv->reverse_fuse_thread_started)
+        return;
 
-        node = GF_CALLOC (1, sizeof (*node), gf_fuse_mt_invalidate_node_t);
-        if (node == NULL)
-                return;
+    node = GF_CALLOC(1, sizeof(*node), gf_fuse_mt_invalidate_node_t);
+    if (node == NULL)
+        return;
 
-        INIT_LIST_HEAD (&node->next);
+    INIT_LIST_HEAD(&node->next);
 
-        fouh = (struct fuse_out_header *) node->inval_buf;
-        fniio = (struct fuse_notify_inval_inode_out *) (fouh + 1);
+    fouh = (struct fuse_out_header *)node->inval_buf;
+    fniio = (struct fuse_notify_inval_inode_out *)(fouh + 1);
 
-        fouh->unique = 0;
-        fouh->error = FUSE_NOTIFY_INVAL_INODE;
-        fouh->len = sizeof(struct fuse_out_header) +
+    fouh->unique = 0;
+    fouh->error = FUSE_NOTIFY_INVAL_INODE;
+    fouh->len = sizeof(struct fuse_out_header) +
                 sizeof(struct fuse_notify_inval_inode_out);
 
-        /* inval the entire mapping until we learn how to be more granular */
-        fniio->ino = fuse_ino;
-        fniio->off = 0;
-        fniio->len = -1;
+    /* inval the entire mapping until we learn how to be more granular */
+    fniio->ino = fuse_ino;
+    fniio->off = 0;
+    fniio->len = -1;
 
-        inode = fuse_ino_to_inode (fuse_ino, this);
+    inode = fuse_ino_to_inode(fuse_ino, this);
 
-        pthread_mutex_lock (&priv->invalidate_mutex);
-        {
-                list_add_tail (&node->next, &priv->invalidate_list);
-                pthread_cond_signal (&priv->invalidate_cond);
-        }
-        pthread_mutex_unlock (&priv->invalidate_mutex);
+    pthread_mutex_lock(&priv->invalidate_mutex);
+    {
+        list_add_tail(&node->next, &priv->invalidate_list);
+        pthread_cond_signal(&priv->invalidate_cond);
+    }
+    pthread_mutex_unlock(&priv->invalidate_mutex);
 
-        gf_log ("glusterfs-fuse", GF_LOG_TRACE, "INVALIDATE inode: %" PRIu64,
-                fuse_ino);
+    gf_log("glusterfs-fuse", GF_LOG_TRACE, "INVALIDATE inode: %" PRIu64,
+           fuse_ino);
 
-        if (inode) {
-                fuse_log_eh (this, "Invalidated inode %" PRIu64 " (gfid: %s)",
-                             fuse_ino, uuid_utoa (inode->gfid));
-        } else {
-                fuse_log_eh (this, "Invalidated inode %" PRIu64, fuse_ino);
-        }
+    if (inode) {
+        fuse_log_eh(this, "Invalidated inode %" PRIu64 " (gfid: %s)", fuse_ino,
+                    uuid_utoa(inode->gfid));
+    } else {
+        fuse_log_eh(this, "Invalidated inode %" PRIu64, fuse_ino);
+    }
 
-        if (inode)
-                inode_unref (inode);
+    if (inode)
+        inode_unref(inode);
 #else
-	gf_log ("glusterfs-fuse", GF_LOG_WARNING,
-		"fuse_invalidate_inode not implemented on OS X due to missing FUSE notification");
+    gf_log("glusterfs-fuse", GF_LOG_WARNING,
+           "fuse_invalidate_inode not implemented on OS X due to missing FUSE "
+           "notification");
 #endif
 }
 
-
 int
-send_fuse_err (xlator_t *this, fuse_in_header_t *finh, int error)
+send_fuse_err(xlator_t *this, fuse_in_header_t *finh, int error)
 {
-        struct fuse_out_header fouh = {0, };
-        struct iovec iov_out;
-        inode_t  *inode = NULL;
+    struct fuse_out_header fouh = {
+        0,
+    };
+    struct iovec iov_out;
+    inode_t *inode = NULL;
 
-        fouh.error = -error;
-        iov_out.iov_base = &fouh;
+    fouh.error = -error;
+    iov_out.iov_base = &fouh;
 
-        inode = fuse_ino_to_inode (finh->nodeid, this);
+    inode = fuse_ino_to_inode(finh->nodeid, this);
 
-        // filter out ENOENT
-        if (error != ENOENT) {
-                if (inode) {
-                        fuse_log_eh (this,"Sending %s for operation %d on "
-                                     "inode %s", strerror (error), finh->opcode,
-                                     uuid_utoa (inode->gfid));
-                } else {
-                        fuse_log_eh (this, "Sending %s for operation %d on "
-                                     "inode %" GF_PRI_INODE,  strerror (error),
-                                     finh->opcode, finh->nodeid);
-                }
+    // filter out ENOENT
+    if (error != ENOENT) {
+        if (inode) {
+            fuse_log_eh(this,
+                        "Sending %s for operation %d on "
+                        "inode %s",
+                        strerror(error), finh->opcode, uuid_utoa(inode->gfid));
+        } else {
+            fuse_log_eh(this,
+                        "Sending %s for operation %d on "
+                        "inode %" GF_PRI_INODE,
+                        strerror(error), finh->opcode, finh->nodeid);
         }
+    }
 
-        if (inode)
-                inode_unref (inode);
+    if (inode)
+        inode_unref(inode);
 
-        return send_fuse_iov (this, finh, &iov_out, 1);
+    return send_fuse_iov(this, finh, &iov_out, 1);
 }
 
 static int
-fuse_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, dict_t *xdata)
-{
-        fuse_state_t          *state        = NULL;
-        fuse_in_header_t      *finh         = NULL;
-        struct fuse_entry_out  feo          = {0, };
-        fuse_private_t        *priv         = NULL;
-        inode_t               *linked_inode = NULL;
-        uint64_t               ctx_value    = LOOKUP_NOT_NEEDED;
-
-        priv = this->private;
-        state = frame->root->state;
-        finh = state->finh;
-
-        if (op_ret == 0) {
-                if (__is_root_gfid (state->loc.inode->gfid))
-                        buf->ia_ino = 1;
-                if (gf_uuid_is_null (buf->ia_gfid)) {
-                        /* With a NULL gfid inode linking is
-                           not possible. Let's not pretend this
-                           call was a "success".
-                        */
-                        gf_log ("glusterfs-fuse", GF_LOG_WARNING,
-                                "Received NULL gfid for %s. Forcing EIO",
-                                state->loc.path);
-                        op_ret = -1;
-                        op_errno = EIO;
-                }
-        }
-
-        /* log into the event-history after the null uuid check is done, since
-         * the op_ret and op_errno are being changed if the gfid is NULL.
-         */
-        fuse_log_eh (this, "op_ret: %d op_errno: %d "
-                     "%"PRIu64": %s() %s => %s", op_ret, op_errno,
-                     frame->root->unique, gf_fop_list[frame->root->op],
-                     state->loc.path, (op_ret == 0)?
-                     uuid_utoa(buf->ia_gfid):uuid_utoa(state->loc.gfid));
-
-        if (op_ret == 0) {
-                gf_log ("glusterfs-fuse", GF_LOG_TRACE,
-                        "%"PRIu64": %s() %s => %"PRIu64,
-                        frame->root->unique, gf_fop_list[frame->root->op],
-                        state->loc.path, buf->ia_ino);
-
-                buf->ia_blksize = this->ctx->page_size;
-                gf_fuse_stat2attr (buf, &feo.attr, priv->enable_ino32);
-
-                if (!buf->ia_ino) {
-                        gf_log ("glusterfs-fuse", GF_LOG_WARNING,
-                                "%"PRIu64": %s() %s returning inode 0",
-                                frame->root->unique,
-                                gf_fop_list[frame->root->op], state->loc.path);
-                }
-
-                linked_inode = inode_link (inode, state->loc.parent,
-                                           state->loc.name, buf);
-
-                if (linked_inode == inode) {
-                        inode_ctx_set (linked_inode, this, &ctx_value);
-                }
-
-                inode_lookup (linked_inode);
-
-                feo.nodeid = inode_to_fuse_nodeid (linked_inode);
-
-                inode_unref (linked_inode);
-
-                feo.entry_valid =
-                        calc_timeout_sec (priv->entry_timeout);
-                feo.entry_valid_nsec =
-                        calc_timeout_nsec (priv->entry_timeout);
-                feo.attr_valid =
-                        calc_timeout_sec (priv->attribute_timeout);
-                feo.attr_valid_nsec =
-                        calc_timeout_nsec (priv->attribute_timeout);
+fuse_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, dict_t *xdata)
+{
+    fuse_state_t *state = NULL;
+    fuse_in_header_t *finh = NULL;
+    struct fuse_entry_out feo = {
+        0,
+    };
+    fuse_private_t *priv = NULL;
+    inode_t *linked_inode = NULL;
+    uint64_t ctx_value = LOOKUP_NOT_NEEDED;
+
+    priv = this->private;
+    state = frame->root->state;
+    finh = state->finh;
+
+    if (op_ret == 0) {
+        if (__is_root_gfid(state->loc.inode->gfid))
+            buf->ia_ino = 1;
+        if (gf_uuid_is_null(buf->ia_gfid)) {
+            /* With a NULL gfid inode linking is
+               not possible. Let's not pretend this
+               call was a "success".
+            */
+            gf_log("glusterfs-fuse", GF_LOG_WARNING,
+                   "Received NULL gfid for %s. Forcing EIO", state->loc.path);
+            op_ret = -1;
+            op_errno = EIO;
+        }
+    }
+
+    /* log into the event-history after the null uuid check is done, since
+     * the op_ret and op_errno are being changed if the gfid is NULL.
+     */
+    fuse_log_eh(
+        this,
+        "op_ret: %d op_errno: %d "
+        "%" PRIu64 ": %s() %s => %s",
+        op_ret, op_errno, frame->root->unique, gf_fop_list[frame->root->op],
+        state->loc.path,
+        (op_ret == 0) ? uuid_utoa(buf->ia_gfid) : uuid_utoa(state->loc.gfid));
+
+    if (op_ret == 0) {
+        gf_log("glusterfs-fuse", GF_LOG_TRACE,
+               "%" PRIu64 ": %s() %s => %" PRIu64, frame->root->unique,
+               gf_fop_list[frame->root->op], state->loc.path, buf->ia_ino);
+
+        buf->ia_blksize = this->ctx->page_size;
+        gf_fuse_stat2attr(buf, &feo.attr, priv->enable_ino32);
+
+        if (!buf->ia_ino) {
+            gf_log("glusterfs-fuse", GF_LOG_WARNING,
+                   "%" PRIu64 ": %s() %s returning inode 0",
+                   frame->root->unique, gf_fop_list[frame->root->op],
+                   state->loc.path);
+        }
+
+        linked_inode = inode_link(inode, state->loc.parent, state->loc.name,
+                                  buf);
+
+        if (linked_inode == inode) {
+            inode_ctx_set(linked_inode, this, &ctx_value);
+        }
+
+        inode_lookup(linked_inode);
+
+        feo.nodeid = inode_to_fuse_nodeid(linked_inode);
+
+        inode_unref(linked_inode);
+
+        feo.entry_valid = calc_timeout_sec(priv->entry_timeout);
+        feo.entry_valid_nsec = calc_timeout_nsec(priv->entry_timeout);
+        feo.attr_valid = calc_timeout_sec(priv->attribute_timeout);
+        feo.attr_valid_nsec = calc_timeout_nsec(priv->attribute_timeout);
 
 #if FUSE_KERNEL_MINOR_VERSION >= 9
-                priv->proto_minor >= 9 ?
-                send_fuse_obj (this, finh, &feo) :
-                send_fuse_data (this, finh, &feo,
-                                FUSE_COMPAT_ENTRY_OUT_SIZE);
+        priv->proto_minor >= 9
+            ? send_fuse_obj(this, finh, &feo)
+            : send_fuse_data(this, finh, &feo, FUSE_COMPAT_ENTRY_OUT_SIZE);
 #else
-                send_fuse_obj (this, finh, &feo);
+        send_fuse_obj(this, finh, &feo);
 #endif
+    } else {
+        gf_log("glusterfs-fuse",
+               (op_errno == ENOENT ? GF_LOG_TRACE : GF_LOG_WARNING),
+               "%" PRIu64 ": %s() %s => -1 (%s)", frame->root->unique,
+               gf_fop_list[frame->root->op], state->loc.path,
+               strerror(op_errno));
+
+        if ((op_errno == ENOENT) && (priv->negative_timeout != 0)) {
+            feo.entry_valid = calc_timeout_sec(priv->negative_timeout);
+            feo.entry_valid_nsec = calc_timeout_nsec(priv->negative_timeout);
+            send_fuse_obj(this, finh, &feo);
         } else {
-                gf_log ("glusterfs-fuse",
-                        (op_errno == ENOENT ? GF_LOG_TRACE : GF_LOG_WARNING),
-                        "%"PRIu64": %s() %s => -1 (%s)", frame->root->unique,
-                        gf_fop_list[frame->root->op], state->loc.path,
-                        strerror (op_errno));
-
-		if ((op_errno == ENOENT) && (priv->negative_timeout != 0)) {
-			feo.entry_valid =
-				calc_timeout_sec (priv->negative_timeout);
-			feo.entry_valid_nsec =
-				calc_timeout_nsec (priv->negative_timeout);
-			send_fuse_obj (this, finh, &feo);
-		} else {
-			send_fuse_err (this, state->finh, op_errno);
-                }
+            send_fuse_err(this, state->finh, op_errno);
         }
+    }
 
-        free_fuse_state (state);
-        STACK_DESTROY (frame->root);
-        return 0;
+    free_fuse_state(state);
+    STACK_DESTROY(frame->root);
+    return 0;
 }
 
 static int
-fuse_newentry_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)
+fuse_newentry_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)
 {
-        fuse_entry_cbk (frame, cookie, this, op_ret, op_errno, inode, buf,
-                        xdata);
-        return 0;
+    fuse_entry_cbk(frame, cookie, this, op_ret, op_errno, inode, buf, xdata);
+    return 0;
 }
 
 static int
-fuse_lookup_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                 int32_t op_ret, int32_t op_errno,
-                 inode_t *inode, struct iatt *stat, dict_t *dict,
-                 struct iatt *postparent)
-{
-        fuse_state_t            *state = NULL;
-        call_frame_t            *prev = NULL;
-        inode_table_t           *itable = NULL;
-
-        state = frame->root->state;
-        prev  = cookie;
-
-        if (op_ret == -1 && state->is_revalidate == 1) {
-                itable = state->itable;
-		/*
-		 * A stale mapping might exist for a dentry/inode that has been
-		 * removed from another client.
-		 */
-		if (op_errno == ENOENT)
-			inode_unlink(state->loc.inode, state->loc.parent,
-				     state->loc.name);
-                inode_unref (state->loc.inode);
-                state->loc.inode = inode_new (itable);
-                state->is_revalidate = 2;
-                if (gf_uuid_is_null (state->gfid))
-                        gf_uuid_generate (state->gfid);
-                fuse_gfid_set (state);
-
-                STACK_WIND (frame, fuse_lookup_cbk,
-                            prev->this, prev->this->fops->lookup,
-                            &state->loc, state->xdata);
-                return 0;
-        }
+fuse_lookup_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                int32_t op_ret, int32_t op_errno, inode_t *inode,
+                struct iatt *stat, dict_t *dict, struct iatt *postparent)
+{
+    fuse_state_t *state = NULL;
+    call_frame_t *prev = NULL;
+    inode_table_t *itable = NULL;
+
+    state = frame->root->state;
+    prev = cookie;
 
-        fuse_entry_cbk (frame, cookie, this, op_ret, op_errno, inode, stat,
-                        dict);
+    if (op_ret == -1 && state->is_revalidate == 1) {
+        itable = state->itable;
+        /*
+         * A stale mapping might exist for a dentry/inode that has been
+         * removed from another client.
+         */
+        if (op_errno == ENOENT)
+            inode_unlink(state->loc.inode, state->loc.parent, state->loc.name);
+        inode_unref(state->loc.inode);
+        state->loc.inode = inode_new(itable);
+        state->is_revalidate = 2;
+        if (gf_uuid_is_null(state->gfid))
+            gf_uuid_generate(state->gfid);
+        fuse_gfid_set(state);
+
+        STACK_WIND(frame, fuse_lookup_cbk, prev->this, prev->this->fops->lookup,
+                   &state->loc, state->xdata);
         return 0;
+    }
+
+    fuse_entry_cbk(frame, cookie, this, op_ret, op_errno, inode, stat, dict);
+    return 0;
 }
 
 void
-fuse_fop_resume (fuse_state_t *state)
+fuse_fop_resume(fuse_state_t *state)
 {
-        fuse_resume_fn_t fn = NULL;
+    fuse_resume_fn_t fn = NULL;
 
-        /*
-         * Fail fd resolution failures right away.
-         */
-        if (state->resolve.fd && state->resolve.op_ret < 0) {
-                send_fuse_err (state->this, state->finh,
-                               state->resolve.op_errno);
-                free_fuse_state (state);
-                return;
-        }
+    /*
+     * Fail fd resolution failures right away.
+     */
+    if (state->resolve.fd && state->resolve.op_ret < 0) {
+        send_fuse_err(state->this, state->finh, state->resolve.op_errno);
+        free_fuse_state(state);
+        return;
+    }
 
-        fn = state->resume_fn;
-        fn (state);
+    fn = state->resume_fn;
+    fn(state);
 }
 
 void
-fuse_lookup_resume (fuse_state_t *state)
-{
-        if (!state->loc.parent && !state->loc.inode) {
-                gf_log ("fuse", GF_LOG_ERROR, "failed to resolve path %s",
-                        state->loc.path);
-                send_fuse_err (state->this, state->finh,
-                               state->resolve.op_errno);
-                free_fuse_state (state);
-                return;
-        }
-
-        /* parent was resolved, entry could not, may be a missing gfid?
-         * Hence try to do a regular lookup
-         */
-        if ((state->resolve.op_ret == -1)
-            && (state->resolve.op_errno == ENODATA)) {
-                state->resolve.op_ret = 0;
-        }
-
-        if (state->loc.inode) {
-                gf_log ("glusterfs-fuse", GF_LOG_TRACE,
-                        "%"PRIu64": LOOKUP %s(%s)", state->finh->unique,
-                        state->loc.path, uuid_utoa (state->loc.inode->gfid));
-                state->is_revalidate = 1;
-        } else {
-                gf_log ("glusterfs-fuse", GF_LOG_TRACE,
-                        "%"PRIu64": LOOKUP %s", state->finh->unique,
-                        state->loc.path);
-                state->loc.inode = inode_new (state->loc.parent->table);
-                if (gf_uuid_is_null (state->gfid))
-                        gf_uuid_generate (state->gfid);
-                fuse_gfid_set (state);
-        }
+fuse_lookup_resume(fuse_state_t *state)
+{
+    if (!state->loc.parent && !state->loc.inode) {
+        gf_log("fuse", GF_LOG_ERROR, "failed to resolve path %s",
+               state->loc.path);
+        send_fuse_err(state->this, state->finh, state->resolve.op_errno);
+        free_fuse_state(state);
+        return;
+    }
 
-        FUSE_FOP (state, fuse_lookup_cbk, GF_FOP_LOOKUP,
-                  lookup, &state->loc, state->xdata);
+    /* parent was resolved, entry could not, may be a missing gfid?
+     * Hence try to do a regular lookup
+     */
+    if ((state->resolve.op_ret == -1) && (state->resolve.op_errno == ENODATA)) {
+        state->resolve.op_ret = 0;
+    }
+
+    if (state->loc.inode) {
+        gf_log("glusterfs-fuse", GF_LOG_TRACE, "%" PRIu64 ": LOOKUP %s(%s)",
+               state->finh->unique, state->loc.path,
+               uuid_utoa(state->loc.inode->gfid));
+        state->is_revalidate = 1;
+    } else {
+        gf_log("glusterfs-fuse", GF_LOG_TRACE, "%" PRIu64 ": LOOKUP %s",
+               state->finh->unique, state->loc.path);
+        state->loc.inode = inode_new(state->loc.parent->table);
+        if (gf_uuid_is_null(state->gfid))
+            gf_uuid_generate(state->gfid);
+        fuse_gfid_set(state);
+    }
+
+    FUSE_FOP(state, fuse_lookup_cbk, GF_FOP_LOOKUP, lookup, &state->loc,
+             state->xdata);
 }
 
 static void
-fuse_lookup (xlator_t *this, fuse_in_header_t *finh, void *msg,
-             struct iobuf *iobuf)
+fuse_lookup(xlator_t *this, fuse_in_header_t *finh, void *msg,
+            struct iobuf *iobuf)
 {
-        char           *name     = msg;
-        fuse_state_t   *state    = NULL;
+    char *name = msg;
+    fuse_state_t *state = NULL;
 
-        GET_STATE (this, finh, state);
+    GET_STATE(this, finh, state);
 
-        (void) fuse_resolve_entry_init (state, &state->resolve,
-                                        finh->nodeid, name);
+    (void)fuse_resolve_entry_init(state, &state->resolve, finh->nodeid, name);
 
-        fuse_resolve_and_resume (state, fuse_lookup_resume);
+    fuse_resolve_and_resume(state, fuse_lookup_resume);
 
-        return;
+    return;
 }
 
 static void
 do_forget(xlator_t *this, uint64_t unique, uint64_t nodeid, uint64_t nlookup)
 {
-	inode_t *fuse_inode = fuse_ino_to_inode(nodeid, this);
+    inode_t *fuse_inode = fuse_ino_to_inode(nodeid, this);
 
-	fuse_log_eh(this, "%"PRIu64": FORGET %"PRIu64"/%"PRIu64" gfid: (%s)",
-		    unique, nodeid, nlookup, uuid_utoa(fuse_inode->gfid));
+    fuse_log_eh(this, "%" PRIu64 ": FORGET %" PRIu64 "/%" PRIu64 " gfid: (%s)",
+                unique, nodeid, nlookup, uuid_utoa(fuse_inode->gfid));
 
-	inode_forget(fuse_inode, nlookup);
-	inode_unref(fuse_inode);
+    inode_forget(fuse_inode, nlookup);
+    inode_unref(fuse_inode);
 }
 
 static void
-fuse_forget (xlator_t *this, fuse_in_header_t *finh, void *msg,
-             struct iobuf *iobuf)
+fuse_forget(xlator_t *this, fuse_in_header_t *finh, void *msg,
+            struct iobuf *iobuf)
 
 {
-        struct fuse_forget_in *ffi        = msg;
+    struct fuse_forget_in *ffi = msg;
 
-        if (finh->nodeid == 1) {
-                GF_FREE (finh);
-                return;
-        }
+    if (finh->nodeid == 1) {
+        GF_FREE(finh);
+        return;
+    }
 
-        gf_log ("glusterfs-fuse", GF_LOG_TRACE,
-                "%"PRIu64": FORGET %"PRIu64"/%"PRIu64,
-                finh->unique, finh->nodeid, ffi->nlookup);
+    gf_log("glusterfs-fuse", GF_LOG_TRACE,
+           "%" PRIu64 ": FORGET %" PRIu64 "/%" PRIu64, finh->unique,
+           finh->nodeid, ffi->nlookup);
 
-	do_forget(this, finh->unique, finh->nodeid, ffi->nlookup);
+    do_forget(this, finh->unique, finh->nodeid, ffi->nlookup);
 
-        GF_FREE (finh);
+    GF_FREE(finh);
 }
 
 #if FUSE_KERNEL_MINOR_VERSION >= 16
@@ -744,2398 +740,2350 @@ static void
 fuse_batch_forget(xlator_t *this, fuse_in_header_t *finh, void *msg,
                   struct iobuf *iobuf)
 {
-	struct fuse_batch_forget_in *fbfi = msg;
-	struct fuse_forget_one *ffo = (struct fuse_forget_one *) (fbfi + 1);
-	int i;
+    struct fuse_batch_forget_in *fbfi = msg;
+    struct fuse_forget_one *ffo = (struct fuse_forget_one *)(fbfi + 1);
+    int i;
 
-	gf_log("glusterfs-fuse", GF_LOG_TRACE,
-		"%"PRIu64": BATCH_FORGET %"PRIu64"/%"PRIu32,
-		finh->unique, finh->nodeid, fbfi->count);
+    gf_log("glusterfs-fuse", GF_LOG_TRACE,
+           "%" PRIu64 ": BATCH_FORGET %" PRIu64 "/%" PRIu32, finh->unique,
+           finh->nodeid, fbfi->count);
 
-	for (i = 0; i < fbfi->count; i++) {
-                if (ffo[i].nodeid == 1)
-                        continue;
-		do_forget(this, finh->unique, ffo[i].nodeid, ffo[i].nlookup);
-        }
-	GF_FREE(finh);
+    for (i = 0; i < fbfi->count; i++) {
+        if (ffo[i].nodeid == 1)
+            continue;
+        do_forget(this, finh->unique, ffo[i].nodeid, ffo[i].nlookup);
+    }
+    GF_FREE(finh);
 }
 #endif
 
 static int
-fuse_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)
+fuse_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)
 {
-        fuse_state_t     *state;
-        fuse_in_header_t *finh;
-        fuse_private_t   *priv = NULL;
-        struct fuse_attr_out fao;
+    fuse_state_t *state;
+    fuse_in_header_t *finh;
+    fuse_private_t *priv = NULL;
+    struct fuse_attr_out fao;
 
-        priv  = this->private;
-        state = frame->root->state;
-        finh  = state->finh;
+    priv = this->private;
+    state = frame->root->state;
+    finh = state->finh;
 
-        fuse_log_eh_fop(this, state, frame, op_ret, op_errno);
+    fuse_log_eh_fop(this, state, frame, op_ret, op_errno);
 
-        if (op_ret == 0) {
-                gf_log ("glusterfs-fuse", GF_LOG_TRACE,
-                        "%"PRIu64": %s() %s => %"PRIu64, frame->root->unique,
-                        gf_fop_list[frame->root->op],
-                        state->loc.path ? state->loc.path : "ERR",
-                        prebuf->ia_ino);
+    if (op_ret == 0) {
+        gf_log("glusterfs-fuse", GF_LOG_TRACE,
+               "%" PRIu64 ": %s() %s => %" PRIu64, frame->root->unique,
+               gf_fop_list[frame->root->op],
+               state->loc.path ? state->loc.path : "ERR", prebuf->ia_ino);
 
-                postbuf->ia_blksize = this->ctx->page_size;
-                gf_fuse_stat2attr (postbuf, &fao.attr, priv->enable_ino32);
+        postbuf->ia_blksize = this->ctx->page_size;
+        gf_fuse_stat2attr(postbuf, &fao.attr, priv->enable_ino32);
 
-                fao.attr_valid = calc_timeout_sec (priv->attribute_timeout);
-                fao.attr_valid_nsec =
-                  calc_timeout_nsec (priv->attribute_timeout);
+        fao.attr_valid = calc_timeout_sec(priv->attribute_timeout);
+        fao.attr_valid_nsec = calc_timeout_nsec(priv->attribute_timeout);
 
 #if FUSE_KERNEL_MINOR_VERSION >= 9
-                priv->proto_minor >= 9 ?
-                send_fuse_obj (this, finh, &fao) :
-                send_fuse_data (this, finh, &fao,
-                                FUSE_COMPAT_ATTR_OUT_SIZE);
+        priv->proto_minor >= 9
+            ? send_fuse_obj(this, finh, &fao)
+            : send_fuse_data(this, finh, &fao, FUSE_COMPAT_ATTR_OUT_SIZE);
 #else
-                send_fuse_obj (this, finh, &fao);
+        send_fuse_obj(this, finh, &fao);
 #endif
-        } else {
-                gf_log ("glusterfs-fuse", GF_LOG_WARNING,
-                        "%"PRIu64": %s() %s => -1 (%s)", frame->root->unique,
-                        gf_fop_list[frame->root->op],
-                        state->loc.path ? state->loc.path : "ERR",
-                        strerror (op_errno));
+    } else {
+        gf_log("glusterfs-fuse", GF_LOG_WARNING,
+               "%" PRIu64 ": %s() %s => -1 (%s)", frame->root->unique,
+               gf_fop_list[frame->root->op],
+               state->loc.path ? state->loc.path : "ERR", strerror(op_errno));
 
-                send_fuse_err (this, finh, op_errno);
-        }
+        send_fuse_err(this, finh, op_errno);
+    }
 
-        free_fuse_state (state);
-        STACK_DESTROY (frame->root);
+    free_fuse_state(state);
+    STACK_DESTROY(frame->root);
 
-        return 0;
+    return 0;
 }
 
 static int
-fuse_root_lookup_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                      int32_t op_ret, int32_t op_errno,
-                      inode_t *inode, struct iatt *stat, dict_t *dict,
-                      struct iatt *postparent);
+fuse_root_lookup_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                     int32_t op_ret, int32_t op_errno, inode_t *inode,
+                     struct iatt *stat, dict_t *dict, struct iatt *postparent);
 
 static int
-fuse_attr_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           ret = 0;
-        fuse_state_t     *state;
-        fuse_in_header_t *finh;
-        fuse_private_t   *priv = NULL;
-        struct fuse_attr_out fao;
-
-        priv  = this->private;
-        state = frame->root->state;
-        finh  = state->finh;
-
-        fuse_log_eh (this, "op_ret: %d, op_errno: %d, %"PRIu64": %s() %s => "
-                   "gfid: %s", op_ret, op_errno, frame->root->unique,
-                   gf_fop_list[frame->root->op], state->loc.path,
-                   state->loc.inode ? uuid_utoa (state->loc.inode->gfid) : "");
-        if (op_ret == 0) {
-                gf_log ("glusterfs-fuse", GF_LOG_TRACE,
-                        "%"PRIu64": %s() %s => %"PRIu64, frame->root->unique,
-                        gf_fop_list[frame->root->op],
-                        state->loc.path ? state->loc.path : "ERR",
-                        buf->ia_ino);
-
-                buf->ia_blksize = this->ctx->page_size;
-                gf_fuse_stat2attr (buf, &fao.attr, priv->enable_ino32);
-
-                fao.attr_valid = calc_timeout_sec (priv->attribute_timeout);
-                fao.attr_valid_nsec =
-                  calc_timeout_nsec (priv->attribute_timeout);
+fuse_attr_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 ret = 0;
+    fuse_state_t *state;
+    fuse_in_header_t *finh;
+    fuse_private_t *priv = NULL;
+    struct fuse_attr_out fao;
+
+    priv = this->private;
+    state = frame->root->state;
+    finh = state->finh;
+
+    fuse_log_eh(this,
+                "op_ret: %d, op_errno: %d, %" PRIu64
+                ": %s() %s => "
+                "gfid: %s",
+                op_ret, op_errno, frame->root->unique,
+                gf_fop_list[frame->root->op], state->loc.path,
+                state->loc.inode ? uuid_utoa(state->loc.inode->gfid) : "");
+    if (op_ret == 0) {
+        gf_log("glusterfs-fuse", GF_LOG_TRACE,
+               "%" PRIu64 ": %s() %s => %" PRIu64, frame->root->unique,
+               gf_fop_list[frame->root->op],
+               state->loc.path ? state->loc.path : "ERR", buf->ia_ino);
+
+        buf->ia_blksize = this->ctx->page_size;
+        gf_fuse_stat2attr(buf, &fao.attr, priv->enable_ino32);
+
+        fao.attr_valid = calc_timeout_sec(priv->attribute_timeout);
+        fao.attr_valid_nsec = calc_timeout_nsec(priv->attribute_timeout);
 
 #if FUSE_KERNEL_MINOR_VERSION >= 9
-                priv->proto_minor >= 9 ?
-                send_fuse_obj (this, finh, &fao) :
-                send_fuse_data (this, finh, &fao,
-                                FUSE_COMPAT_ATTR_OUT_SIZE);
+        priv->proto_minor >= 9
+            ? send_fuse_obj(this, finh, &fao)
+            : send_fuse_data(this, finh, &fao, FUSE_COMPAT_ATTR_OUT_SIZE);
 #else
-                send_fuse_obj (this, finh, &fao);
+        send_fuse_obj(this, finh, &fao);
 #endif
-        } else {
-                /* This is moved here from fuse_getattr(). It makes sense as
-                   in few cases, like the self-heal processes, some
-                   translators expect a lookup() to come on root inode
-                   (inode number 1). This will make sure we don't fail in any
-                   case, but the positive path will get better performance,
-                   by following common path for all the cases */
-                if ((finh->nodeid == 1) && (state->gfid[15] != 1)) {
-                        /* The 'state->gfid[15]' check is added to prevent the
-                           infinite recursions */
-                        state->gfid[15] = 1;
-
-                        ret = fuse_loc_fill (&state->loc, state, finh->nodeid,
-                                             0, NULL);
-                        if (ret < 0) {
-                                gf_log ("glusterfs-fuse", GF_LOG_WARNING,
-                                        "%"PRIu64": loc_fill() on / failed",
-                                        finh->unique);
-                                send_fuse_err (this, finh, ENOENT);
-                                free_fuse_state (state);
-                                return 0;
-                        }
-
-                        fuse_gfid_set (state);
-
-                        FUSE_FOP (state, fuse_root_lookup_cbk, GF_FOP_LOOKUP,
-                                  lookup, &state->loc, state->xdata);
-
-                        return 0;
-                }
+    } else {
+        /* This is moved here from fuse_getattr(). It makes sense as
+           in few cases, like the self-heal processes, some
+           translators expect a lookup() to come on root inode
+           (inode number 1). This will make sure we don't fail in any
+           case, but the positive path will get better performance,
+           by following common path for all the cases */
+        if ((finh->nodeid == 1) && (state->gfid[15] != 1)) {
+            /* The 'state->gfid[15]' check is added to prevent the
+               infinite recursions */
+            state->gfid[15] = 1;
+
+            ret = fuse_loc_fill(&state->loc, state, finh->nodeid, 0, NULL);
+            if (ret < 0) {
+                gf_log("glusterfs-fuse", GF_LOG_WARNING,
+                       "%" PRIu64 ": loc_fill() on / failed", finh->unique);
+                send_fuse_err(this, finh, ENOENT);
+                free_fuse_state(state);
+                return 0;
+            }
 
-                gf_log ("glusterfs-fuse", GF_LOG_WARNING, "%"PRIu64": %s() "
-                        "%s => -1 (%s)", frame->root->unique,
-                                      gf_fop_list[frame->root->op],
-                                      state->loc.path ? state->loc.path : "ERR",
-                                      strerror (op_errno));
+            fuse_gfid_set(state);
 
-                send_fuse_err (this, finh, op_errno);
+            FUSE_FOP(state, fuse_root_lookup_cbk, GF_FOP_LOOKUP, lookup,
+                     &state->loc, state->xdata);
+
+            return 0;
         }
 
-        free_fuse_state (state);
-        STACK_DESTROY (frame->root);
+        gf_log("glusterfs-fuse", GF_LOG_WARNING,
+               "%" PRIu64
+               ": %s() "
+               "%s => -1 (%s)",
+               frame->root->unique, gf_fop_list[frame->root->op],
+               state->loc.path ? state->loc.path : "ERR", strerror(op_errno));
 
-        return 0;
+        send_fuse_err(this, finh, op_errno);
+    }
+
+    free_fuse_state(state);
+    STACK_DESTROY(frame->root);
+
+    return 0;
 }
 
 static int
-fuse_root_lookup_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                      int32_t op_ret, int32_t op_errno,
-                      inode_t *inode, struct iatt *stat, dict_t *dict,
-                      struct iatt *postparent)
+fuse_root_lookup_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                     int32_t op_ret, int32_t op_errno, inode_t *inode,
+                     struct iatt *stat, dict_t *dict, struct iatt *postparent)
 {
-        fuse_attr_cbk (frame, cookie, this, op_ret, op_errno, stat, dict);
+    fuse_attr_cbk(frame, cookie, this, op_ret, op_errno, stat, dict);
 
-        return 0;
+    return 0;
 }
 
 void
-fuse_getattr_resume (fuse_state_t *state)
-{
-        if (!state->loc.inode && !(state->fd && state->fd->inode)) {
-                gf_log ("glusterfs-fuse", GF_LOG_ERROR,
-                        "%"PRIu64": GETATTR %"PRIu64" (%s) resolution failed",
-                        state->finh->unique, state->finh->nodeid,
-                        uuid_utoa (state->resolve.gfid));
-                send_fuse_err (state->this, state->finh,
-                               state->resolve.op_errno);
-                free_fuse_state (state);
-                return;
-        }
+fuse_getattr_resume(fuse_state_t *state)
+{
+    if (!state->loc.inode && !(state->fd && state->fd->inode)) {
+        gf_log("glusterfs-fuse", GF_LOG_ERROR,
+               "%" PRIu64 ": GETATTR %" PRIu64 " (%s) resolution failed",
+               state->finh->unique, state->finh->nodeid,
+               uuid_utoa(state->resolve.gfid));
+        send_fuse_err(state->this, state->finh, state->resolve.op_errno);
+        free_fuse_state(state);
+        return;
+    }
 
-        if (state->fd == NULL && !IA_ISDIR (state->loc.inode->ia_type)) {
-                state->fd = fd_lookup (state->loc.inode, state->finh->pid);
+    if (state->fd == NULL && !IA_ISDIR(state->loc.inode->ia_type)) {
+        state->fd = fd_lookup(state->loc.inode, state->finh->pid);
 
-                if (state->fd == NULL)
-                        state->fd = fd_lookup (state->loc.inode, 0);
-        }
+        if (state->fd == NULL)
+            state->fd = fd_lookup(state->loc.inode, 0);
+    }
 
-        if (!state->fd) {
-                gf_log ("glusterfs-fuse", GF_LOG_TRACE,
-                        "%"PRIu64": GETATTR %"PRIu64" (%s)",
-                        state->finh->unique, state->finh->nodeid,
-                        state->loc.path);
+    if (!state->fd) {
+        gf_log("glusterfs-fuse", GF_LOG_TRACE,
+               "%" PRIu64 ": GETATTR %" PRIu64 " (%s)", state->finh->unique,
+               state->finh->nodeid, state->loc.path);
 
-                FUSE_FOP (state, fuse_attr_cbk, GF_FOP_STAT,
-                          stat, &state->loc, state->xdata);
-        } else {
+        FUSE_FOP(state, fuse_attr_cbk, GF_FOP_STAT, stat, &state->loc,
+                 state->xdata);
+    } else {
+        gf_log("glusterfs-fuse", GF_LOG_TRACE,
+               "%" PRIu64 ": FGETATTR %" PRIu64 " (%s/%p)", state->finh->unique,
+               state->finh->nodeid, state->loc.path, state->fd);
 
-                gf_log ("glusterfs-fuse", GF_LOG_TRACE,
-                        "%"PRIu64": FGETATTR %"PRIu64" (%s/%p)",
-                        state->finh->unique, state->finh->nodeid,
-                        state->loc.path, state->fd);
-
-                FUSE_FOP (state, fuse_attr_cbk, GF_FOP_FSTAT,
-                          fstat, state->fd, state->xdata);
-        }
+        FUSE_FOP(state, fuse_attr_cbk, GF_FOP_FSTAT, fstat, state->fd,
+                 state->xdata);
+    }
 }
 
 static void
-fuse_getattr (xlator_t *this, fuse_in_header_t *finh, void *msg,
-              struct iobuf *iobuf)
+fuse_getattr(xlator_t *this, fuse_in_header_t *finh, void *msg,
+             struct iobuf *iobuf)
 {
 #if FUSE_KERNEL_MINOR_VERSION >= 9
-        struct fuse_getattr_in *fgi  = msg;
-        fuse_private_t         *priv = NULL;
+    struct fuse_getattr_in *fgi = msg;
+    fuse_private_t *priv = NULL;
 #endif
-        fuse_state_t *state;
-        int ret = -1;
+    fuse_state_t *state;
+    int ret = -1;
 
-        GET_STATE (this, finh, state);
+    GET_STATE(this, finh, state);
 #if FUSE_KERNEL_MINOR_VERSION >= 9
-        priv = this->private;
-        if (priv->proto_minor >= 9 && fgi->getattr_flags & FUSE_GETATTR_FH)
-                state->fd = fd_ref ((fd_t *)fgi->fh);
+    priv = this->private;
+    if (priv->proto_minor >= 9 && fgi->getattr_flags & FUSE_GETATTR_FH)
+        state->fd = fd_ref((fd_t *)fgi->fh);
 #endif
-        if (finh->nodeid == 1) {
-                state->gfid[15] = 1;
-
-                ret = fuse_loc_fill (&state->loc, state, finh->nodeid, 0, NULL);
-                if (ret < 0) {
-                        gf_log ("glusterfs-fuse", GF_LOG_WARNING,
-                                "%"PRIu64": GETATTR on / (fuse_loc_fill() failed)",
-                                finh->unique);
-                        send_fuse_err (this, finh, ENOENT);
-                        free_fuse_state (state);
-                        return;
-                }
-
-                fuse_gfid_set (state);
+    if (finh->nodeid == 1) {
+        state->gfid[15] = 1;
 
-                FUSE_FOP (state, fuse_root_lookup_cbk, GF_FOP_LOOKUP,
-                          lookup, &state->loc, state->xdata);
-                return;
+        ret = fuse_loc_fill(&state->loc, state, finh->nodeid, 0, NULL);
+        if (ret < 0) {
+            gf_log("glusterfs-fuse", GF_LOG_WARNING,
+                   "%" PRIu64 ": GETATTR on / (fuse_loc_fill() failed)",
+                   finh->unique);
+            send_fuse_err(this, finh, ENOENT);
+            free_fuse_state(state);
+            return;
         }
 
-        if (state->fd)
-                fuse_resolve_fd_init (state, &state->resolve, state->fd);
-        else
-                fuse_resolve_inode_init (state, &state->resolve, state->finh->nodeid);
+        fuse_gfid_set(state);
 
-        fuse_resolve_and_resume (state, fuse_getattr_resume);
+        FUSE_FOP(state, fuse_root_lookup_cbk, GF_FOP_LOOKUP, lookup,
+                 &state->loc, state->xdata);
+        return;
+    }
+
+    if (state->fd)
+        fuse_resolve_fd_init(state, &state->resolve, state->fd);
+    else
+        fuse_resolve_inode_init(state, &state->resolve, state->finh->nodeid);
+
+    fuse_resolve_and_resume(state, fuse_getattr_resume);
 }
 
 static int32_t
-fuse_fd_inherit_directio (xlator_t *this, fd_t *fd, struct fuse_open_out *foo)
-{
-        int32_t        ret    = 0;
-        fuse_fd_ctx_t *fdctx  = NULL, *tmp_fdctx = NULL;
-        fd_t          *tmp_fd = NULL;
-
-        GF_VALIDATE_OR_GOTO_WITH_ERROR ("glusterfs-fuse", this, out, ret,
-                                        -EINVAL);
-        GF_VALIDATE_OR_GOTO_WITH_ERROR ("glusterfs-fuse", fd, out, ret,
-                                        -EINVAL);
-        GF_VALIDATE_OR_GOTO_WITH_ERROR ("glusterfs-fuse", foo, out, ret,
-                                        -EINVAL);
-
-        fdctx = fuse_fd_ctx_get (this, fd);
-        if (!fdctx) {
-                ret = -ENOMEM;
-                goto out;
-        }
+fuse_fd_inherit_directio(xlator_t *this, fd_t *fd, struct fuse_open_out *foo)
+{
+    int32_t ret = 0;
+    fuse_fd_ctx_t *fdctx = NULL, *tmp_fdctx = NULL;
+    fd_t *tmp_fd = NULL;
 
-        tmp_fd = fd_lookup (fd->inode, 0);
-        if (tmp_fd) {
-                tmp_fdctx = fuse_fd_ctx_get (this, tmp_fd);
-                if (tmp_fdctx) {
-                        foo->open_flags &= ~FOPEN_DIRECT_IO;
-                        foo->open_flags |= (tmp_fdctx->open_flags
-                                            & FOPEN_DIRECT_IO);
-                }
-        }
+    GF_VALIDATE_OR_GOTO_WITH_ERROR("glusterfs-fuse", this, out, ret, -EINVAL);
+    GF_VALIDATE_OR_GOTO_WITH_ERROR("glusterfs-fuse", fd, out, ret, -EINVAL);
+    GF_VALIDATE_OR_GOTO_WITH_ERROR("glusterfs-fuse", foo, out, ret, -EINVAL);
 
-        fdctx->open_flags |= (foo->open_flags & FOPEN_DIRECT_IO);
+    fdctx = fuse_fd_ctx_get(this, fd);
+    if (!fdctx) {
+        ret = -ENOMEM;
+        goto out;
+    }
 
-        if (tmp_fd != NULL) {
-                fd_unref (tmp_fd);
+    tmp_fd = fd_lookup(fd->inode, 0);
+    if (tmp_fd) {
+        tmp_fdctx = fuse_fd_ctx_get(this, tmp_fd);
+        if (tmp_fdctx) {
+            foo->open_flags &= ~FOPEN_DIRECT_IO;
+            foo->open_flags |= (tmp_fdctx->open_flags & FOPEN_DIRECT_IO);
         }
+    }
 
-        ret = 0;
+    fdctx->open_flags |= (foo->open_flags & FOPEN_DIRECT_IO);
+
+    if (tmp_fd != NULL) {
+        fd_unref(tmp_fd);
+    }
+
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
 
-
 gf_boolean_t
-direct_io_mode (dict_t *xdata)
+direct_io_mode(dict_t *xdata)
 {
-	if (xdata && dict_get (xdata, "direct-io-mode"))
-		return _gf_true;
-	return _gf_false;
+    if (xdata && dict_get(xdata, "direct-io-mode"))
+        return _gf_true;
+    return _gf_false;
 }
 
-
 static int
-fuse_fd_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-             int32_t op_ret, int32_t op_errno, fd_t *fd, dict_t *xdata)
-{
-        fuse_state_t         *state  = NULL;
-        fuse_in_header_t     *finh   = NULL;
-        fuse_private_t       *priv   = NULL;
-        int32_t               ret    = 0;
-        struct fuse_open_out  foo    = {0, };
-
-        priv = this->private;
-        state = frame->root->state;
-        finh = state->finh;
-
-        fuse_log_eh_fop(this, state, frame, op_ret, op_errno);
-
-        if (op_ret >= 0) {
-                foo.fh = (uintptr_t) fd;
-                foo.open_flags = 0;
-
-                if (!IA_ISDIR (fd->inode->ia_type)) {
-                        if (((priv->direct_io_mode == 2)
-                             && ((state->flags & O_ACCMODE) != O_RDONLY))
-                            || (priv->direct_io_mode == 1)
-			    || (direct_io_mode (xdata)))
-                                foo.open_flags |= FOPEN_DIRECT_IO;
+fuse_fd_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int32_t op_ret,
+            int32_t op_errno, fd_t *fd, dict_t *xdata)
+{
+    fuse_state_t *state = NULL;
+    fuse_in_header_t *finh = NULL;
+    fuse_private_t *priv = NULL;
+    int32_t ret = 0;
+    struct fuse_open_out foo = {
+        0,
+    };
+
+    priv = this->private;
+    state = frame->root->state;
+    finh = state->finh;
+
+    fuse_log_eh_fop(this, state, frame, op_ret, op_errno);
+
+    if (op_ret >= 0) {
+        foo.fh = (uintptr_t)fd;
+        foo.open_flags = 0;
+
+        if (!IA_ISDIR(fd->inode->ia_type)) {
+            if (((priv->direct_io_mode == 2) &&
+                 ((state->flags & O_ACCMODE) != O_RDONLY)) ||
+                (priv->direct_io_mode == 1) || (direct_io_mode(xdata)))
+                foo.open_flags |= FOPEN_DIRECT_IO;
 #ifdef GF_DARWIN_HOST_OS
-                        /* In Linux: by default, buffer cache
-                         * is purged upon open, setting
-                         * FOPEN_KEEP_CACHE implies no-purge
-                         *
-                         * In MacFUSE: by default, buffer cache
-                         * is left intact upon open, setting
-                         * FOPEN_PURGE_UBC implies purge
-                         *
-                         * [[Interesting...]]
-                         */
-                        if (!priv->fopen_keep_cache)
-                                foo.open_flags |= FOPEN_PURGE_UBC;
+            /* In Linux: by default, buffer cache
+             * is purged upon open, setting
+             * FOPEN_KEEP_CACHE implies no-purge
+             *
+             * In MacFUSE: by default, buffer cache
+             * is left intact upon open, setting
+             * FOPEN_PURGE_UBC implies purge
+             *
+             * [[Interesting...]]
+             */
+            if (!priv->fopen_keep_cache)
+                foo.open_flags |= FOPEN_PURGE_UBC;
 #else
-                        /*
-                         * If fopen-keep-cache is enabled, we set the associated
-                         * flag here such that files are not invalidated on open.
-                         * File invalidations occur either in fuse or explicitly
-                         * when the cache is set invalid on the inode.
-                         */
-                        if (priv->fopen_keep_cache)
-                                foo.open_flags |= FOPEN_KEEP_CACHE;
+            /*
+             * If fopen-keep-cache is enabled, we set the associated
+             * flag here such that files are not invalidated on open.
+             * File invalidations occur either in fuse or explicitly
+             * when the cache is set invalid on the inode.
+             */
+            if (priv->fopen_keep_cache)
+                foo.open_flags |= FOPEN_KEEP_CACHE;
 #endif
-                }
+        }
 
-                gf_log ("glusterfs-fuse", GF_LOG_TRACE,
-                        "%"PRIu64": %s() %s => %p", frame->root->unique,
-                        gf_fop_list[frame->root->op], state->loc.path, fd);
-
-                ret = fuse_fd_inherit_directio (this, fd, &foo);
-                if (ret < 0) {
-                        op_errno = -ret;
-                        gf_log ("glusterfs-fuse", GF_LOG_WARNING,
-                                "cannot inherit direct-io values for fd "
-                                "(ptr:%p inode-gfid:%s) from fds already "
-                                "opened", fd, uuid_utoa (fd->inode->gfid));
-                        goto err;
-                }
+        gf_log("glusterfs-fuse", GF_LOG_TRACE, "%" PRIu64 ": %s() %s => %p",
+               frame->root->unique, gf_fop_list[frame->root->op],
+               state->loc.path, fd);
 
-                if (send_fuse_obj (this, finh, &foo) == ENOENT) {
-                        gf_log ("glusterfs-fuse", GF_LOG_DEBUG,
-                                "open(%s) got EINTR", state->loc.path);
-                        gf_fd_put (priv->fdtable, state->fd_no);
-                        goto out;
-                }
+        ret = fuse_fd_inherit_directio(this, fd, &foo);
+        if (ret < 0) {
+            op_errno = -ret;
+            gf_log("glusterfs-fuse", GF_LOG_WARNING,
+                   "cannot inherit direct-io values for fd "
+                   "(ptr:%p inode-gfid:%s) from fds already "
+                   "opened",
+                   fd, uuid_utoa(fd->inode->gfid));
+            goto err;
+        }
+
+        if (send_fuse_obj(this, finh, &foo) == ENOENT) {
+            gf_log("glusterfs-fuse", GF_LOG_DEBUG, "open(%s) got EINTR",
+                   state->loc.path);
+            gf_fd_put(priv->fdtable, state->fd_no);
+            goto out;
+        }
+
+        fd_bind(fd);
+    } else {
+    err:
+        /* OPEN(DIR) being an operation on inode should never fail with
+         * ENOENT. If gfid is not present, the appropriate error is
+         * ESTALE.
+         */
+        if (op_errno == ENOENT)
+            op_errno = ESTALE;
 
-                fd_bind (fd);
-        } else {
-        err:
-                /* OPEN(DIR) being an operation on inode should never fail with
-                 * ENOENT. If gfid is not present, the appropriate error is
-                 * ESTALE.
-                 */
-                if (op_errno == ENOENT)
-                        op_errno = ESTALE;
-
-                gf_log ("glusterfs-fuse", GF_LOG_WARNING,
-                        "%"PRIu64": %s() %s => -1 (%s)", frame->root->unique,
-                        gf_fop_list[frame->root->op], state->loc.path,
-                        strerror (op_errno));
-
-                send_fuse_err (this, finh, op_errno);
-                gf_fd_put (priv->fdtable, state->fd_no);
-        }
+        gf_log("glusterfs-fuse", GF_LOG_WARNING,
+               "%" PRIu64 ": %s() %s => -1 (%s)", frame->root->unique,
+               gf_fop_list[frame->root->op], state->loc.path,
+               strerror(op_errno));
+
+        send_fuse_err(this, finh, op_errno);
+        gf_fd_put(priv->fdtable, state->fd_no);
+    }
 out:
-        free_fuse_state (state);
-        STACK_DESTROY (frame->root);
-        return 0;
+    free_fuse_state(state);
+    STACK_DESTROY(frame->root);
+    return 0;
 }
 
 static void
-fuse_do_truncate (fuse_state_t *state)
+fuse_do_truncate(fuse_state_t *state)
 {
-        if (state->fd) {
-                FUSE_FOP (state, fuse_truncate_cbk, GF_FOP_FTRUNCATE,
-                          ftruncate, state->fd, state->off, state->xdata);
-        } else {
-                FUSE_FOP (state, fuse_truncate_cbk, GF_FOP_TRUNCATE,
-                          truncate, &state->loc, state->off, state->xdata);
-        }
+    if (state->fd) {
+        FUSE_FOP(state, fuse_truncate_cbk, GF_FOP_FTRUNCATE, ftruncate,
+                 state->fd, state->off, state->xdata);
+    } else {
+        FUSE_FOP(state, fuse_truncate_cbk, GF_FOP_TRUNCATE, truncate,
+                 &state->loc, state->off, state->xdata);
+    }
 
-        return;
+    return;
 }
 
 static int
-fuse_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)
-{
-        fuse_state_t     *state;
-        fuse_in_header_t *finh;
-        fuse_private_t   *priv = NULL;
-        struct fuse_attr_out fao;
-
-        int op_done = 0;
-
-        priv  = this->private;
-        state = frame->root->state;
-        finh  = state->finh;
-
-        fuse_log_eh(this, "op_ret: %d, op_errno: %d, %"PRIu64", %s() %s => "
-                    "gfid: %s", op_ret, op_errno, frame->root->unique,
-                    gf_fop_list[frame->root->op], state->loc.path,
-                    state->loc.inode ? uuid_utoa (state->loc.inode->gfid) : "");
-
-        if (op_ret == 0) {
-                gf_log ("glusterfs-fuse", GF_LOG_TRACE,
-                        "%"PRIu64": %s() %s => %"PRIu64, frame->root->unique,
-                        gf_fop_list[frame->root->op],
-                        state->loc.path ? state->loc.path : "ERR",
-                        statpost->ia_ino);
-
-                statpost->ia_blksize = this->ctx->page_size;
-                gf_fuse_stat2attr (statpost, &fao.attr, priv->enable_ino32);
-
-                fao.attr_valid = calc_timeout_sec (priv->attribute_timeout);
-                fao.attr_valid_nsec =
-                        calc_timeout_nsec (priv->attribute_timeout);
-
-                if (state->truncate_needed) {
-                        fuse_do_truncate (state);
-                } else {
+fuse_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)
+{
+    fuse_state_t *state;
+    fuse_in_header_t *finh;
+    fuse_private_t *priv = NULL;
+    struct fuse_attr_out fao;
+
+    int op_done = 0;
+
+    priv = this->private;
+    state = frame->root->state;
+    finh = state->finh;
+
+    fuse_log_eh(this,
+                "op_ret: %d, op_errno: %d, %" PRIu64
+                ", %s() %s => "
+                "gfid: %s",
+                op_ret, op_errno, frame->root->unique,
+                gf_fop_list[frame->root->op], state->loc.path,
+                state->loc.inode ? uuid_utoa(state->loc.inode->gfid) : "");
+
+    if (op_ret == 0) {
+        gf_log("glusterfs-fuse", GF_LOG_TRACE,
+               "%" PRIu64 ": %s() %s => %" PRIu64, frame->root->unique,
+               gf_fop_list[frame->root->op],
+               state->loc.path ? state->loc.path : "ERR", statpost->ia_ino);
+
+        statpost->ia_blksize = this->ctx->page_size;
+        gf_fuse_stat2attr(statpost, &fao.attr, priv->enable_ino32);
+
+        fao.attr_valid = calc_timeout_sec(priv->attribute_timeout);
+        fao.attr_valid_nsec = calc_timeout_nsec(priv->attribute_timeout);
+
+        if (state->truncate_needed) {
+            fuse_do_truncate(state);
+        } else {
 #if FUSE_KERNEL_MINOR_VERSION >= 9
-                        priv->proto_minor >= 9 ?
-                        send_fuse_obj (this, finh, &fao) :
-                        send_fuse_data (this, finh, &fao,
-                                        FUSE_COMPAT_ATTR_OUT_SIZE);
+            priv->proto_minor >= 9
+                ? send_fuse_obj(this, finh, &fao)
+                : send_fuse_data(this, finh, &fao, FUSE_COMPAT_ATTR_OUT_SIZE);
 #else
-                        send_fuse_obj (this, finh, &fao);
+            send_fuse_obj(this, finh, &fao);
 #endif
-                        op_done = 1;
-                }
-        } else {
-                gf_log ("glusterfs-fuse", GF_LOG_WARNING,
-                        "%"PRIu64": %s() %s => -1 (%s)", frame->root->unique,
-                        gf_fop_list[frame->root->op],
-                        state->loc.path ? state->loc.path : "ERR",
-                        strerror (op_errno));
-
-                send_fuse_err (this, finh, op_errno);
-                op_done = 1;
+            op_done = 1;
         }
+    } else {
+        gf_log("glusterfs-fuse", GF_LOG_WARNING,
+               "%" PRIu64 ": %s() %s => -1 (%s)", frame->root->unique,
+               gf_fop_list[frame->root->op],
+               state->loc.path ? state->loc.path : "ERR", strerror(op_errno));
 
-        if (op_done) {
-                free_fuse_state (state);
-        }
+        send_fuse_err(this, finh, op_errno);
+        op_done = 1;
+    }
 
-        STACK_DESTROY (frame->root);
+    if (op_done) {
+        free_fuse_state(state);
+    }
 
-        return 0;
+    STACK_DESTROY(frame->root);
+
+    return 0;
 }
 
 static int32_t
-fattr_to_gf_set_attr (int32_t valid)
+fattr_to_gf_set_attr(int32_t valid)
 {
-        int32_t gf_valid = 0;
+    int32_t gf_valid = 0;
 
-        if (valid & FATTR_MODE)
-                gf_valid |= GF_SET_ATTR_MODE;
+    if (valid & FATTR_MODE)
+        gf_valid |= GF_SET_ATTR_MODE;
 
-        if (valid & FATTR_UID)
-                gf_valid |= GF_SET_ATTR_UID;
+    if (valid & FATTR_UID)
+        gf_valid |= GF_SET_ATTR_UID;
 
-        if (valid & FATTR_GID)
-                gf_valid |= GF_SET_ATTR_GID;
+    if (valid & FATTR_GID)
+        gf_valid |= GF_SET_ATTR_GID;
 
-        if (valid & FATTR_ATIME)
-                gf_valid |= GF_SET_ATTR_ATIME;
+    if (valid & FATTR_ATIME)
+        gf_valid |= GF_SET_ATTR_ATIME;
 
-        if (valid & FATTR_MTIME)
-                gf_valid |= GF_SET_ATTR_MTIME;
+    if (valid & FATTR_MTIME)
+        gf_valid |= GF_SET_ATTR_MTIME;
 
 #if FUSE_KERNEL_MINOR_VERSION >= 23
-        if (valid & FATTR_CTIME)
-                gf_valid |= GF_SET_ATTR_CTIME;
+    if (valid & FATTR_CTIME)
+        gf_valid |= GF_SET_ATTR_CTIME;
 #endif
 
-        if (valid & FATTR_SIZE)
-                gf_valid |= GF_SET_ATTR_SIZE;
+    if (valid & FATTR_SIZE)
+        gf_valid |= GF_SET_ATTR_SIZE;
 
-        return gf_valid;
+    return gf_valid;
 }
 
-#define FATTR_MASK   (FATTR_SIZE                        \
-                      | FATTR_UID | FATTR_GID           \
-                      | FATTR_ATIME | FATTR_MTIME       \
-                      | FATTR_MODE)
+#define FATTR_MASK                                                             \
+    (FATTR_SIZE | FATTR_UID | FATTR_GID | FATTR_ATIME | FATTR_MTIME |          \
+     FATTR_MODE)
 
 void
-fuse_setattr_resume (fuse_state_t *state)
-{
-        if (!state->fd && !state->loc.inode) {
-                gf_log ("glusterfs-fuse", GF_LOG_ERROR,
-                        "%"PRIu64": SETATTR %"PRIu64" (%s) resolution failed",
-                        state->finh->unique, state->finh->nodeid,
-                        uuid_utoa (state->resolve.gfid));
-                send_fuse_err (state->this, state->finh,
-                               state->resolve.op_errno);
-                free_fuse_state (state);
-                return;
-        }
+fuse_setattr_resume(fuse_state_t *state)
+{
+    if (!state->fd && !state->loc.inode) {
+        gf_log("glusterfs-fuse", GF_LOG_ERROR,
+               "%" PRIu64 ": SETATTR %" PRIu64 " (%s) resolution failed",
+               state->finh->unique, state->finh->nodeid,
+               uuid_utoa(state->resolve.gfid));
+        send_fuse_err(state->this, state->finh, state->resolve.op_errno);
+        free_fuse_state(state);
+        return;
+    }
 
-        gf_log ("glusterfs-fuse", GF_LOG_TRACE,
-                "%"PRIu64": SETATTR (%"PRIu64")%s", state->finh->unique,
-                state->finh->nodeid, state->loc.path);
+    gf_log("glusterfs-fuse", GF_LOG_TRACE,
+           "%" PRIu64 ": SETATTR (%" PRIu64 ")%s", state->finh->unique,
+           state->finh->nodeid, state->loc.path);
 
 #ifdef GF_TEST_FFOP
-        /* this is for calls like 'fchmod()' */
-        if (!state->fd)
-                state->fd = fd_lookup (state->loc.inode, state->finh->pid);
+    /* this is for calls like 'fchmod()' */
+    if (!state->fd)
+        state->fd = fd_lookup(state->loc.inode, state->finh->pid);
 #endif /* GF_TEST_FFOP */
 
-        if ((state->valid & (FATTR_MASK)) != FATTR_SIZE) {
-                if (state->fd &&
-                    !((state->valid & FATTR_ATIME) ||
-                      (state->valid & FATTR_MTIME)
+    if ((state->valid & (FATTR_MASK)) != FATTR_SIZE) {
+        if (state->fd &&
+            !((state->valid & FATTR_ATIME) || (state->valid & FATTR_MTIME)
 #if FUSE_KERNEL_MINOR_VERSION >= 23
-                       || (state->valid & FATTR_CTIME)
+              || (state->valid & FATTR_CTIME)
 #endif
-                     )) {
-                        /*
-                            there is no "futimes" call, so don't send
-                            fsetattr if ATIME or MTIME is set
-                         */
-
-                        FUSE_FOP (state, fuse_setattr_cbk, GF_FOP_FSETATTR,
-                                  fsetattr, state->fd, &state->attr,
-                                  fattr_to_gf_set_attr (state->valid),
-                                  state->xdata);
-                } else {
-                        FUSE_FOP (state, fuse_setattr_cbk, GF_FOP_SETATTR,
-                                  setattr, &state->loc, &state->attr,
-                                  fattr_to_gf_set_attr (state->valid),
-                                  state->xdata);
-                }
+                  )) {
+            /*
+                there is no "futimes" call, so don't send
+                fsetattr if ATIME or MTIME is set
+             */
+
+            FUSE_FOP(state, fuse_setattr_cbk, GF_FOP_FSETATTR, fsetattr,
+                     state->fd, &state->attr,
+                     fattr_to_gf_set_attr(state->valid), state->xdata);
         } else {
-                fuse_do_truncate (state);
+            FUSE_FOP(state, fuse_setattr_cbk, GF_FOP_SETATTR, setattr,
+                     &state->loc, &state->attr,
+                     fattr_to_gf_set_attr(state->valid), state->xdata);
         }
-
+    } else {
+        fuse_do_truncate(state);
+    }
 }
 
 static void
-fuse_setattr (xlator_t *this, fuse_in_header_t *finh, void *msg,
-              struct iobuf *iobuf)
+fuse_setattr(xlator_t *this, fuse_in_header_t *finh, void *msg,
+             struct iobuf *iobuf)
 {
-        struct fuse_setattr_in *fsi = msg;
+    struct fuse_setattr_in *fsi = msg;
 
 #if FUSE_KERNEL_MINOR_VERSION >= 9
-        fuse_private_t  *priv = NULL;
+    fuse_private_t *priv = NULL;
 #endif
-        fuse_state_t *state = NULL;
-
-        GET_STATE (this, finh, state);
-
-        if (fsi->valid & FATTR_FH &&
-            !(fsi->valid & (FATTR_ATIME|FATTR_MTIME))) {
-                /* We need no loc if kernel sent us an fd and
-                 * we are not fiddling with times */
-                state->fd = FH_TO_FD (fsi->fh);
-                fuse_resolve_fd_init (state, &state->resolve, state->fd);
-        } else {
-                fuse_resolve_inode_init (state, &state->resolve, finh->nodeid);
-        }
-
-        /*
-         * This is just stub code demonstrating how to retrieve
-         * lock_owner in setattr, according to the FUSE proto.
-         * We do not make use of ATM. Its purpose is supporting
-         * mandatory locking, but getting that right is further
-         * down the road. Cf.
-         *
-         * http://thread.gmane.org/gmane.comp.file-systems.fuse.devel/
-         * 4962/focus=4982
-         *
-         * http://git.kernel.org/?p=linux/kernel/git/torvalds/
-         * linux-2.6.git;a=commit;h=v2.6.23-5896-gf333211
-         */
+    fuse_state_t *state = NULL;
+
+    GET_STATE(this, finh, state);
+
+    if (fsi->valid & FATTR_FH && !(fsi->valid & (FATTR_ATIME | FATTR_MTIME))) {
+        /* We need no loc if kernel sent us an fd and
+         * we are not fiddling with times */
+        state->fd = FH_TO_FD(fsi->fh);
+        fuse_resolve_fd_init(state, &state->resolve, state->fd);
+    } else {
+        fuse_resolve_inode_init(state, &state->resolve, finh->nodeid);
+    }
+
+    /*
+     * This is just stub code demonstrating how to retrieve
+     * lock_owner in setattr, according to the FUSE proto.
+     * We do not make use of ATM. Its purpose is supporting
+     * mandatory locking, but getting that right is further
+     * down the road. Cf.
+     *
+     * http://thread.gmane.org/gmane.comp.file-systems.fuse.devel/
+     * 4962/focus=4982
+     *
+     * http://git.kernel.org/?p=linux/kernel/git/torvalds/
+     * linux-2.6.git;a=commit;h=v2.6.23-5896-gf333211
+     */
 #if FUSE_KERNEL_MINOR_VERSION >= 9
-        priv = this->private;
-        if (priv->proto_minor >= 9 && fsi->valid & FATTR_LOCKOWNER)
-                state->lk_owner = fsi->lock_owner;
+    priv = this->private;
+    if (priv->proto_minor >= 9 && fsi->valid & FATTR_LOCKOWNER)
+        state->lk_owner = fsi->lock_owner;
 #endif
 
-        state->valid = fsi->valid;
+    state->valid = fsi->valid;
 
-        if ((fsi->valid & (FATTR_MASK)) != FATTR_SIZE) {
-                if (fsi->valid & FATTR_SIZE) {
-                        state->off             = fsi->size;
-                        state->truncate_needed = _gf_true;
-                }
+    if ((fsi->valid & (FATTR_MASK)) != FATTR_SIZE) {
+        if (fsi->valid & FATTR_SIZE) {
+            state->off = fsi->size;
+            state->truncate_needed = _gf_true;
+        }
 
-                state->attr.ia_size  = fsi->size;
-                state->attr.ia_atime = fsi->atime;
-                state->attr.ia_mtime = fsi->mtime;
+        state->attr.ia_size = fsi->size;
+        state->attr.ia_atime = fsi->atime;
+        state->attr.ia_mtime = fsi->mtime;
 #if FUSE_KERNEL_MINOR_VERSION >= 23
-                state->attr.ia_ctime = fsi->ctime;
+        state->attr.ia_ctime = fsi->ctime;
 #endif
-                state->attr.ia_atime_nsec = fsi->atimensec;
-                state->attr.ia_mtime_nsec = fsi->mtimensec;
+        state->attr.ia_atime_nsec = fsi->atimensec;
+        state->attr.ia_mtime_nsec = fsi->mtimensec;
 #if FUSE_KERNEL_MINOR_VERSION >= 23
-                state->attr.ia_ctime_nsec = fsi->ctimensec;
+        state->attr.ia_ctime_nsec = fsi->ctimensec;
 #endif
 
-                state->attr.ia_prot = ia_prot_from_st_mode (fsi->mode);
-                state->attr.ia_uid  = fsi->uid;
-                state->attr.ia_gid  = fsi->gid;
-        } else {
-                state->off = fsi->size;
-        }
+        state->attr.ia_prot = ia_prot_from_st_mode(fsi->mode);
+        state->attr.ia_uid = fsi->uid;
+        state->attr.ia_gid = fsi->gid;
+    } else {
+        state->off = fsi->size;
+    }
 
-        fuse_resolve_and_resume (state, fuse_setattr_resume);
+    fuse_resolve_and_resume(state, fuse_setattr_resume);
 }
 
 static int
-fuse_removexattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                      int32_t op_ret, int32_t op_errno, dict_t *xdata)
+fuse_removexattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                     int32_t op_ret, int32_t op_errno, dict_t *xdata)
 {
-        fuse_state_t *state = NULL;
-        fuse_in_header_t *finh = NULL;
+    fuse_state_t *state = NULL;
+    fuse_in_header_t *finh = NULL;
 
-        GF_ASSERT (frame);
-        GF_ASSERT (frame->root);
+    GF_ASSERT(frame);
+    GF_ASSERT(frame->root);
 
-        state =  frame->root->state;
-        finh  =  state->finh;
+    state = frame->root->state;
+    finh = state->finh;
 
-        fuse_log_eh_fop(this, state, frame, op_ret, op_errno);
+    fuse_log_eh_fop(this, state, frame, op_ret, op_errno);
 
-        if (op_ret == 0) {
-                gf_log ("glusterfs-fuse", GF_LOG_TRACE,
-                        "%"PRIu64": %s() %s => 0", frame->root->unique,
-                        gf_fop_list[frame->root->op],
-                        state->loc.path ? state->loc.path : "ERR");
+    if (op_ret == 0) {
+        gf_log("glusterfs-fuse", GF_LOG_TRACE, "%" PRIu64 ": %s() %s => 0",
+               frame->root->unique, gf_fop_list[frame->root->op],
+               state->loc.path ? state->loc.path : "ERR");
 
-                send_fuse_err (this, finh, 0);
-        } else {
-                gf_log ("glusterfs-fuse",
-                        (ENODATA == op_errno) ? GF_LOG_DEBUG : GF_LOG_WARNING,
-                        "%"PRIu64": %s() of %s on %s => -1 (%s)",
-                        frame->root->unique,
-                        gf_fop_list[frame->root->op],
-                        state->name ? state->name : "",
-                        state->loc.path ? state->loc.path : "ERR",
-                        strerror (op_errno));
-
-                send_fuse_err (this, finh, op_errno);
-        }
+        send_fuse_err(this, finh, 0);
+    } else {
+        gf_log("glusterfs-fuse",
+               (ENODATA == op_errno) ? GF_LOG_DEBUG : GF_LOG_WARNING,
+               "%" PRIu64 ": %s() of %s on %s => -1 (%s)", frame->root->unique,
+               gf_fop_list[frame->root->op], state->name ? state->name : "",
+               state->loc.path ? state->loc.path : "ERR", strerror(op_errno));
+
+        send_fuse_err(this, finh, op_errno);
+    }
 
-        free_fuse_state (state);
-        STACK_DESTROY (frame->root);
+    free_fuse_state(state);
+    STACK_DESTROY(frame->root);
 
-        return 0;
+    return 0;
 }
 
 static int
-fuse_err_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-              int32_t op_ret, int32_t op_errno, dict_t *xdata)
+fuse_err_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int32_t op_ret,
+             int32_t op_errno, dict_t *xdata)
 {
-        fuse_state_t *state = frame->root->state;
-        fuse_in_header_t *finh = state->finh;
+    fuse_state_t *state = frame->root->state;
+    fuse_in_header_t *finh = state->finh;
 
-        fuse_log_eh_fop(this, state, frame, op_ret, op_errno);
+    fuse_log_eh_fop(this, state, frame, op_ret, op_errno);
 
-        if (op_ret == 0) {
-                gf_log ("glusterfs-fuse", GF_LOG_TRACE,
-                        "%"PRIu64": %s() %s => 0", frame->root->unique,
-                        gf_fop_list[frame->root->op],
-                        state->loc.path ? state->loc.path : "ERR");
+    if (op_ret == 0) {
+        gf_log("glusterfs-fuse", GF_LOG_TRACE, "%" PRIu64 ": %s() %s => 0",
+               frame->root->unique, gf_fop_list[frame->root->op],
+               state->loc.path ? state->loc.path : "ERR");
 
-                send_fuse_err (this, finh, 0);
-        } else {
-                if (GF_IGNORE_IF_GSYNCD_SAFE_ERROR(frame, op_errno)) {
-                        gf_log ("glusterfs-fuse", GF_LOG_WARNING,
-                                "%"PRIu64": %s() %s => -1 (%s)",
-                                frame->root->unique,
-                                gf_fop_list[frame->root->op],
-                                state->loc.path ? state->loc.path : "ERR",
-                                strerror (op_errno));
-                }
-
-                send_fuse_err (this, finh, op_errno);
+        send_fuse_err(this, finh, 0);
+    } else {
+        if (GF_IGNORE_IF_GSYNCD_SAFE_ERROR(frame, op_errno)) {
+            gf_log("glusterfs-fuse", GF_LOG_WARNING,
+                   "%" PRIu64 ": %s() %s => -1 (%s)", frame->root->unique,
+                   gf_fop_list[frame->root->op],
+                   state->loc.path ? state->loc.path : "ERR",
+                   strerror(op_errno));
         }
 
-        free_fuse_state (state);
-        STACK_DESTROY (frame->root);
+        send_fuse_err(this, finh, op_errno);
+    }
+
+    free_fuse_state(state);
+    STACK_DESTROY(frame->root);
 
-        return 0;
+    return 0;
 }
 
 static int
-fuse_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)
+fuse_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)
 {
-        return fuse_err_cbk (frame, cookie, this, op_ret, op_errno, xdata);
+    return fuse_err_cbk(frame, cookie, this, op_ret, op_errno, xdata);
 }
 
 static int
-fuse_setxattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                   int32_t op_ret, int32_t op_errno, dict_t *xdata)
+fuse_setxattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                  int32_t op_ret, int32_t op_errno, dict_t *xdata)
 {
-        if (op_ret == -1 && op_errno == ENOTSUP)
-                GF_LOG_OCCASIONALLY (gf_fuse_xattr_enotsup_log,
-                                     "glusterfs-fuse", GF_LOG_CRITICAL,
-                                     "extended attribute not supported "
-                                     "by the backend storage");
+    if (op_ret == -1 && op_errno == ENOTSUP)
+        GF_LOG_OCCASIONALLY(gf_fuse_xattr_enotsup_log, "glusterfs-fuse",
+                            GF_LOG_CRITICAL,
+                            "extended attribute not supported "
+                            "by the backend storage");
 
-        return fuse_err_cbk (frame, cookie, this, op_ret, op_errno, xdata);
+    return fuse_err_cbk(frame, cookie, this, op_ret, op_errno, xdata);
 }
 
 static int
-fuse_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)
-{
-        fuse_state_t     *state = NULL;
-        fuse_in_header_t *finh = NULL;
-
-        state = frame->root->state;
-        finh = state->finh;
-
-        fuse_log_eh (this, "op_ret: %d, op_errno: %d, %"PRIu64": %s() %s => "
-                     "gfid: %s", op_ret, op_errno, frame->root->unique,
-                     gf_fop_list[frame->root->op], state->loc.path,
-                     state->loc.inode ? uuid_utoa (state->loc.inode->gfid) : "");
-
-        if (op_ret == 0) {
-                inode_unlink (state->loc.inode, state->loc.parent,
-                              state->loc.name);
-                gf_log ("glusterfs-fuse", GF_LOG_TRACE,
-                        "%"PRIu64": %s() %s => 0", frame->root->unique,
-                        gf_fop_list[frame->root->op], state->loc.path);
-
-                send_fuse_err (this, finh, 0);
-        } else {
-                if (GF_IGNORE_IF_GSYNCD_SAFE_ERROR(frame, op_errno)) {
-                        gf_log ("glusterfs-fuse",
-                                op_errno == ENOTEMPTY ? GF_LOG_DEBUG :
-                                GF_LOG_WARNING, "%"PRIu64": %s() %s => -1 (%s)",
-                                frame->root->unique,
-                                gf_fop_list[frame->root->op], state->loc.path,
-                                strerror (op_errno));
-                }
-                send_fuse_err (this, finh, op_errno);
+fuse_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)
+{
+    fuse_state_t *state = NULL;
+    fuse_in_header_t *finh = NULL;
+
+    state = frame->root->state;
+    finh = state->finh;
+
+    fuse_log_eh(this,
+                "op_ret: %d, op_errno: %d, %" PRIu64
+                ": %s() %s => "
+                "gfid: %s",
+                op_ret, op_errno, frame->root->unique,
+                gf_fop_list[frame->root->op], state->loc.path,
+                state->loc.inode ? uuid_utoa(state->loc.inode->gfid) : "");
+
+    if (op_ret == 0) {
+        inode_unlink(state->loc.inode, state->loc.parent, state->loc.name);
+        gf_log("glusterfs-fuse", GF_LOG_TRACE, "%" PRIu64 ": %s() %s => 0",
+               frame->root->unique, gf_fop_list[frame->root->op],
+               state->loc.path);
+
+        send_fuse_err(this, finh, 0);
+    } else {
+        if (GF_IGNORE_IF_GSYNCD_SAFE_ERROR(frame, op_errno)) {
+            gf_log("glusterfs-fuse",
+                   op_errno == ENOTEMPTY ? GF_LOG_DEBUG : GF_LOG_WARNING,
+                   "%" PRIu64 ": %s() %s => -1 (%s)", frame->root->unique,
+                   gf_fop_list[frame->root->op], state->loc.path,
+                   strerror(op_errno));
         }
+        send_fuse_err(this, finh, op_errno);
+    }
 
-        free_fuse_state (state);
-        STACK_DESTROY (frame->root);
+    free_fuse_state(state);
+    STACK_DESTROY(frame->root);
 
-        return 0;
+    return 0;
 }
 
 void
-fuse_access_resume (fuse_state_t *state)
-{
-        if (!state->loc.inode) {
-                gf_log ("glusterfs-fuse", GF_LOG_ERROR,
-                        "%"PRIu64": ACCESS %"PRIu64" (%s) resolution failed",
-                        state->finh->unique, state->finh->nodeid,
-                        uuid_utoa (state->resolve.gfid));
-                send_fuse_err (state->this, state->finh,
-                               state->resolve.op_errno);
-                free_fuse_state (state);
-                return;
-        }
+fuse_access_resume(fuse_state_t *state)
+{
+    if (!state->loc.inode) {
+        gf_log("glusterfs-fuse", GF_LOG_ERROR,
+               "%" PRIu64 ": ACCESS %" PRIu64 " (%s) resolution failed",
+               state->finh->unique, state->finh->nodeid,
+               uuid_utoa(state->resolve.gfid));
+        send_fuse_err(state->this, state->finh, state->resolve.op_errno);
+        free_fuse_state(state);
+        return;
+    }
 
-        gf_log ("glusterfs-fuse", GF_LOG_TRACE,
-                "%"PRIu64" ACCESS %s/%"PRIu64" mask=%d",
-                state->finh->unique, state->loc.path,
-                state->finh->nodeid, state->mask);
+    gf_log("glusterfs-fuse", GF_LOG_TRACE,
+           "%" PRIu64 " ACCESS %s/%" PRIu64 " mask=%d", state->finh->unique,
+           state->loc.path, state->finh->nodeid, state->mask);
 
-        FUSE_FOP (state, fuse_err_cbk, GF_FOP_ACCESS, access,
-                  &state->loc, state->mask, state->xdata);
+    FUSE_FOP(state, fuse_err_cbk, GF_FOP_ACCESS, access, &state->loc,
+             state->mask, state->xdata);
 }
 
 static void
-fuse_access (xlator_t *this, fuse_in_header_t *finh, void *msg,
-             struct iobuf *iobuf)
+fuse_access(xlator_t *this, fuse_in_header_t *finh, void *msg,
+            struct iobuf *iobuf)
 {
-        struct fuse_access_in *fai = msg;
-        fuse_state_t *state = NULL;
+    struct fuse_access_in *fai = msg;
+    fuse_state_t *state = NULL;
 
-        GET_STATE (this, finh, state);
+    GET_STATE(this, finh, state);
 
-        fuse_resolve_inode_init (state, &state->resolve, finh->nodeid);
+    fuse_resolve_inode_init(state, &state->resolve, finh->nodeid);
 
-        state->mask = fai->mask;
+    state->mask = fai->mask;
 
-        fuse_resolve_and_resume (state, fuse_access_resume);
+    fuse_resolve_and_resume(state, fuse_access_resume);
 
-        return;
+    return;
 }
 
 static int
-fuse_readlink_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                   int32_t op_ret, int32_t op_errno, const char *linkname,
-                   struct iatt *buf, dict_t *xdata)
-{
-        fuse_state_t     *state = NULL;
-        fuse_in_header_t *finh = NULL;
-
-        state = frame->root->state;
-        finh = state->finh;
-
-        fuse_log_eh (this, "op_ret: %d, op_errno: %d %"PRIu64": %s() => %s"
-                     " linkname: %s, gfid: %s", op_ret, op_errno,
-                     frame->root->unique, gf_fop_list[frame->root->op],
-                     state->loc.gfid, linkname,
-                     uuid_utoa (state->loc.gfid));
-
-        if (op_ret > 0) {
-                gf_log ("glusterfs-fuse", GF_LOG_TRACE,
-                        "%"PRIu64": %s => %s (size:%d)", frame->root->unique,
-                        state->loc.path, linkname, op_ret);
-                send_fuse_data (this, finh, (void *)linkname, op_ret);
-        } else {
-                gf_log ("glusterfs-fuse", GF_LOG_WARNING,
-                        "%"PRIu64": %s => -1 (%s)", frame->root->unique,
-                        state->loc.path, strerror (op_errno));
+fuse_readlink_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                  int32_t op_ret, int32_t op_errno, const char *linkname,
+                  struct iatt *buf, dict_t *xdata)
+{
+    fuse_state_t *state = NULL;
+    fuse_in_header_t *finh = NULL;
+
+    state = frame->root->state;
+    finh = state->finh;
+
+    fuse_log_eh(this,
+                "op_ret: %d, op_errno: %d %" PRIu64
+                ": %s() => %s"
+                " linkname: %s, gfid: %s",
+                op_ret, op_errno, frame->root->unique,
+                gf_fop_list[frame->root->op], state->loc.gfid, linkname,
+                uuid_utoa(state->loc.gfid));
+
+    if (op_ret > 0) {
+        gf_log("glusterfs-fuse", GF_LOG_TRACE,
+               "%" PRIu64 ": %s => %s (size:%d)", frame->root->unique,
+               state->loc.path, linkname, op_ret);
+        send_fuse_data(this, finh, (void *)linkname, op_ret);
+    } else {
+        gf_log("glusterfs-fuse", GF_LOG_WARNING, "%" PRIu64 ": %s => -1 (%s)",
+               frame->root->unique, state->loc.path, strerror(op_errno));
 
-                send_fuse_err (this, finh, op_errno);
-        }
+        send_fuse_err(this, finh, op_errno);
+    }
 
-        free_fuse_state (state);
-        STACK_DESTROY (frame->root);
+    free_fuse_state(state);
+    STACK_DESTROY(frame->root);
 
-        return 0;
+    return 0;
 }
 
 void
-fuse_readlink_resume (fuse_state_t *state)
-{
-        if (!state->loc.inode) {
-                gf_log ("glusterfs-fuse", GF_LOG_ERROR,
-                        "READLINK %"PRIu64" (%s) resolution failed",
-                        state->finh->unique, uuid_utoa (state->resolve.gfid));
-                send_fuse_err (state->this, state->finh,
-                               state->resolve.op_errno);
-                free_fuse_state (state);
-                return;
-        }
+fuse_readlink_resume(fuse_state_t *state)
+{
+    if (!state->loc.inode) {
+        gf_log("glusterfs-fuse", GF_LOG_ERROR,
+               "READLINK %" PRIu64 " (%s) resolution failed",
+               state->finh->unique, uuid_utoa(state->resolve.gfid));
+        send_fuse_err(state->this, state->finh, state->resolve.op_errno);
+        free_fuse_state(state);
+        return;
+    }
 
-        gf_log ("glusterfs-fuse", GF_LOG_TRACE,
-                "%"PRIu64" READLINK %s/%s", state->finh->unique,
-                state->loc.path, uuid_utoa (state->loc.inode->gfid));
+    gf_log("glusterfs-fuse", GF_LOG_TRACE, "%" PRIu64 " READLINK %s/%s",
+           state->finh->unique, state->loc.path,
+           uuid_utoa(state->loc.inode->gfid));
 
-        FUSE_FOP (state, fuse_readlink_cbk, GF_FOP_READLINK,
-                  readlink, &state->loc, 4096, state->xdata);
+    FUSE_FOP(state, fuse_readlink_cbk, GF_FOP_READLINK, readlink, &state->loc,
+             4096, state->xdata);
 }
 
 static void
-fuse_readlink (xlator_t *this, fuse_in_header_t *finh, void *msg,
-               struct iobuf *iobuf)
+fuse_readlink(xlator_t *this, fuse_in_header_t *finh, void *msg,
+              struct iobuf *iobuf)
 {
-        fuse_state_t *state = NULL;
+    fuse_state_t *state = NULL;
 
-        GET_STATE (this, finh, state);
+    GET_STATE(this, finh, state);
 
-        fuse_resolve_inode_init (state, &state->resolve, finh->nodeid);
+    fuse_resolve_inode_init(state, &state->resolve, finh->nodeid);
 
-        fuse_resolve_and_resume (state, fuse_readlink_resume);
+    fuse_resolve_and_resume(state, fuse_readlink_resume);
 
-        return;
+    return;
 }
 
 void
-fuse_mknod_resume (fuse_state_t *state)
-{
-        if (!state->loc.parent) {
-                gf_log ("glusterfs-fuse", GF_LOG_ERROR,
-                        "MKNOD %"PRIu64"/%s (%s/%s) resolution failed",
-                        state->finh->nodeid, state->resolve.bname,
-                        uuid_utoa (state->resolve.gfid), state->resolve.bname);
-                send_fuse_err (state->this, state->finh,
-                               state->resolve.op_errno);
-                free_fuse_state (state);
-                return;
-        }
+fuse_mknod_resume(fuse_state_t *state)
+{
+    if (!state->loc.parent) {
+        gf_log("glusterfs-fuse", GF_LOG_ERROR,
+               "MKNOD %" PRIu64 "/%s (%s/%s) resolution failed",
+               state->finh->nodeid, state->resolve.bname,
+               uuid_utoa(state->resolve.gfid), state->resolve.bname);
+        send_fuse_err(state->this, state->finh, state->resolve.op_errno);
+        free_fuse_state(state);
+        return;
+    }
 
-        if (state->resolve.op_errno == ENOENT) {
-                state->resolve.op_ret = 0;
-                state->resolve.op_errno = 0;
-        }
+    if (state->resolve.op_errno == ENOENT) {
+        state->resolve.op_ret = 0;
+        state->resolve.op_errno = 0;
+    }
 
-        if (state->loc.inode) {
-                gf_log (state->this->name, GF_LOG_DEBUG, "inode already present");
-                inode_unref (state->loc.inode);
-                state->loc.inode = NULL;
-        }
+    if (state->loc.inode) {
+        gf_log(state->this->name, GF_LOG_DEBUG, "inode already present");
+        inode_unref(state->loc.inode);
+        state->loc.inode = NULL;
+    }
 
-        state->loc.inode = inode_new (state->loc.parent->table);
+    state->loc.inode = inode_new(state->loc.parent->table);
 
-        gf_log ("glusterfs-fuse", GF_LOG_TRACE,
-                "%"PRIu64": MKNOD %s", state->finh->unique,
-                state->loc.path);
+    gf_log("glusterfs-fuse", GF_LOG_TRACE, "%" PRIu64 ": MKNOD %s",
+           state->finh->unique, state->loc.path);
 
-        FUSE_FOP (state, fuse_newentry_cbk, GF_FOP_MKNOD,
-                  mknod, &state->loc, state->mode, state->rdev, state->umask,
-                  state->xdata);
+    FUSE_FOP(state, fuse_newentry_cbk, GF_FOP_MKNOD, mknod, &state->loc,
+             state->mode, state->rdev, state->umask, state->xdata);
 }
 
 static void
-fuse_mknod (xlator_t *this, fuse_in_header_t *finh, void *msg,
-            struct iobuf *iobuf)
+fuse_mknod(xlator_t *this, fuse_in_header_t *finh, void *msg,
+           struct iobuf *iobuf)
 {
-        struct fuse_mknod_in *fmi = msg;
-        char         *name = (char *)(fmi + 1);
+    struct fuse_mknod_in *fmi = msg;
+    char *name = (char *)(fmi + 1);
 
-        fuse_state_t   *state = NULL;
+    fuse_state_t *state = NULL;
 #if FUSE_KERNEL_MINOR_VERSION >= 12
-        fuse_private_t *priv = NULL;
-        int32_t         ret  = -1;
+    fuse_private_t *priv = NULL;
+    int32_t ret = -1;
 
-        priv = this->private;
-        if (priv->proto_minor < 12)
-                name = (char *)msg + FUSE_COMPAT_MKNOD_IN_SIZE;
+    priv = this->private;
+    if (priv->proto_minor < 12)
+        name = (char *)msg + FUSE_COMPAT_MKNOD_IN_SIZE;
 #endif
 
-        GET_STATE (this, finh, state);
+    GET_STATE(this, finh, state);
 
-        gf_uuid_generate (state->gfid);
+    gf_uuid_generate(state->gfid);
 
-        fuse_resolve_entry_init (state, &state->resolve, finh->nodeid, name);
+    fuse_resolve_entry_init(state, &state->resolve, finh->nodeid, name);
 
-        state->mode = fmi->mode;
-        state->rdev = fmi->rdev;
+    state->mode = fmi->mode;
+    state->rdev = fmi->rdev;
 
-#if FUSE_KERNEL_MINOR_VERSION >=12
-        priv = this->private;
-        FUSE_ENTRY_CREATE(this, priv, finh, state, fmi, "MKNOD");
+#if FUSE_KERNEL_MINOR_VERSION >= 12
+    priv = this->private;
+    FUSE_ENTRY_CREATE(this, priv, finh, state, fmi, "MKNOD");
 #endif
 
-        fuse_resolve_and_resume (state, fuse_mknod_resume);
+    fuse_resolve_and_resume(state, fuse_mknod_resume);
 
-        return;
+    return;
 }
 
 void
-fuse_mkdir_resume (fuse_state_t *state)
-{
-        if (!state->loc.parent) {
-                gf_log ("glusterfs-fuse", GF_LOG_ERROR,
-                        "MKDIR %"PRIu64" (%s/%s) resolution failed",
-                        state->finh->nodeid, uuid_utoa (state->resolve.gfid),
-                        state->resolve.bname);
-                send_fuse_err (state->this, state->finh,
-                               state->resolve.op_errno);
-                free_fuse_state (state);
-                return;
-        }
+fuse_mkdir_resume(fuse_state_t *state)
+{
+    if (!state->loc.parent) {
+        gf_log("glusterfs-fuse", GF_LOG_ERROR,
+               "MKDIR %" PRIu64 " (%s/%s) resolution failed",
+               state->finh->nodeid, uuid_utoa(state->resolve.gfid),
+               state->resolve.bname);
+        send_fuse_err(state->this, state->finh, state->resolve.op_errno);
+        free_fuse_state(state);
+        return;
+    }
 
-        if (state->resolve.op_errno == ENOENT) {
-                state->resolve.op_ret = 0;
-                state->resolve.op_errno = 0;
-        }
+    if (state->resolve.op_errno == ENOENT) {
+        state->resolve.op_ret = 0;
+        state->resolve.op_errno = 0;
+    }
 
-        if (state->loc.inode) {
-                gf_log (state->this->name, GF_LOG_DEBUG, "inode already present");
-                inode_unref (state->loc.inode);
-                state->loc.inode = NULL;
-        }
+    if (state->loc.inode) {
+        gf_log(state->this->name, GF_LOG_DEBUG, "inode already present");
+        inode_unref(state->loc.inode);
+        state->loc.inode = NULL;
+    }
 
-        state->loc.inode = inode_new (state->loc.parent->table);
+    state->loc.inode = inode_new(state->loc.parent->table);
 
-        gf_log ("glusterfs-fuse", GF_LOG_TRACE,
-                "%"PRIu64": MKDIR %s", state->finh->unique,
-                state->loc.path);
+    gf_log("glusterfs-fuse", GF_LOG_TRACE, "%" PRIu64 ": MKDIR %s",
+           state->finh->unique, state->loc.path);
 
-        FUSE_FOP (state, fuse_newentry_cbk, GF_FOP_MKDIR,
-                  mkdir, &state->loc, state->mode, state->umask, state->xdata);
+    FUSE_FOP(state, fuse_newentry_cbk, GF_FOP_MKDIR, mkdir, &state->loc,
+             state->mode, state->umask, state->xdata);
 }
 
 static void
-fuse_mkdir (xlator_t *this, fuse_in_header_t *finh, void *msg,
-            struct iobuf *iobuf)
+fuse_mkdir(xlator_t *this, fuse_in_header_t *finh, void *msg,
+           struct iobuf *iobuf)
 {
-        struct fuse_mkdir_in *fmi = msg;
-        char *name = (char *)(fmi + 1);
-#if FUSE_KERNEL_MINOR_VERSION >=12
-        fuse_private_t *priv = NULL;
-        int32_t         ret = -1;
+    struct fuse_mkdir_in *fmi = msg;
+    char *name = (char *)(fmi + 1);
+#if FUSE_KERNEL_MINOR_VERSION >= 12
+    fuse_private_t *priv = NULL;
+    int32_t ret = -1;
 #endif
 
-        fuse_state_t *state;
+    fuse_state_t *state;
 
-        GET_STATE (this, finh, state);
+    GET_STATE(this, finh, state);
 
-        gf_uuid_generate (state->gfid);
+    gf_uuid_generate(state->gfid);
 
-        fuse_resolve_entry_init (state, &state->resolve, finh->nodeid, name);
+    fuse_resolve_entry_init(state, &state->resolve, finh->nodeid, name);
 
-        state->mode = fmi->mode;
+    state->mode = fmi->mode;
 
-#if FUSE_KERNEL_MINOR_VERSION >=12
-        priv = this->private;
-        FUSE_ENTRY_CREATE(this, priv, finh, state, fmi, "MKDIR");
+#if FUSE_KERNEL_MINOR_VERSION >= 12
+    priv = this->private;
+    FUSE_ENTRY_CREATE(this, priv, finh, state, fmi, "MKDIR");
 #endif
 
-        fuse_resolve_and_resume (state, fuse_mkdir_resume);
+    fuse_resolve_and_resume(state, fuse_mkdir_resume);
 
-        return;
+    return;
 }
 
 void
-fuse_unlink_resume (fuse_state_t *state)
-{
-        if (!state->loc.parent || !state->loc.inode) {
-                gf_log ("glusterfs-fuse", GF_LOG_ERROR,
-                        "UNLINK %"PRIu64" (%s/%s) resolution failed",
-                        state->finh->nodeid, uuid_utoa (state->resolve.gfid),
-                        state->resolve.bname);
-                send_fuse_err (state->this, state->finh,
-                               state->resolve.op_errno);
-                free_fuse_state (state);
-                return;
-        }
+fuse_unlink_resume(fuse_state_t *state)
+{
+    if (!state->loc.parent || !state->loc.inode) {
+        gf_log("glusterfs-fuse", GF_LOG_ERROR,
+               "UNLINK %" PRIu64 " (%s/%s) resolution failed",
+               state->finh->nodeid, uuid_utoa(state->resolve.gfid),
+               state->resolve.bname);
+        send_fuse_err(state->this, state->finh, state->resolve.op_errno);
+        free_fuse_state(state);
+        return;
+    }
 
-        gf_log ("glusterfs-fuse", GF_LOG_TRACE,
-                "%"PRIu64": UNLINK %s", state->finh->unique,
-                state->loc.path);
+    gf_log("glusterfs-fuse", GF_LOG_TRACE, "%" PRIu64 ": UNLINK %s",
+           state->finh->unique, state->loc.path);
 
-        FUSE_FOP (state, fuse_unlink_cbk, GF_FOP_UNLINK,
-                  unlink, &state->loc, 0, state->xdata);
+    FUSE_FOP(state, fuse_unlink_cbk, GF_FOP_UNLINK, unlink, &state->loc, 0,
+             state->xdata);
 }
 
 static void
-fuse_unlink (xlator_t *this, fuse_in_header_t *finh, void *msg,
-             struct iobuf *iobuf)
+fuse_unlink(xlator_t *this, fuse_in_header_t *finh, void *msg,
+            struct iobuf *iobuf)
 {
-        char         *name = msg;
-        fuse_state_t *state = NULL;
+    char *name = msg;
+    fuse_state_t *state = NULL;
 
-        GET_STATE (this, finh, state);
+    GET_STATE(this, finh, state);
 
-        fuse_resolve_entry_init (state, &state->resolve, finh->nodeid, name);
+    fuse_resolve_entry_init(state, &state->resolve, finh->nodeid, name);
 
-        fuse_resolve_and_resume (state, fuse_unlink_resume);
+    fuse_resolve_and_resume(state, fuse_unlink_resume);
 
-        return;
+    return;
 }
 
 void
-fuse_rmdir_resume (fuse_state_t *state)
-{
-        if (!state->loc.parent || !state->loc.inode) {
-                gf_log ("glusterfs-fuse", GF_LOG_ERROR,
-                        "RMDIR %"PRIu64" (%s/%s) resolution failed",
-                        state->finh->nodeid, uuid_utoa (state->resolve.gfid),
-                        state->resolve.bname);
-                send_fuse_err (state->this, state->finh,
-                               state->resolve.op_errno);
-                free_fuse_state (state);
-                return;
-        }
+fuse_rmdir_resume(fuse_state_t *state)
+{
+    if (!state->loc.parent || !state->loc.inode) {
+        gf_log("glusterfs-fuse", GF_LOG_ERROR,
+               "RMDIR %" PRIu64 " (%s/%s) resolution failed",
+               state->finh->nodeid, uuid_utoa(state->resolve.gfid),
+               state->resolve.bname);
+        send_fuse_err(state->this, state->finh, state->resolve.op_errno);
+        free_fuse_state(state);
+        return;
+    }
 
-        gf_log ("glusterfs-fuse", GF_LOG_TRACE,
-                "%"PRIu64": RMDIR %s", state->finh->unique,
-                state->loc.path);
+    gf_log("glusterfs-fuse", GF_LOG_TRACE, "%" PRIu64 ": RMDIR %s",
+           state->finh->unique, state->loc.path);
 
-        FUSE_FOP (state, fuse_unlink_cbk, GF_FOP_RMDIR,
-                  rmdir, &state->loc, 0, state->xdata);
+    FUSE_FOP(state, fuse_unlink_cbk, GF_FOP_RMDIR, rmdir, &state->loc, 0,
+             state->xdata);
 }
 
 static void
-fuse_rmdir (xlator_t *this, fuse_in_header_t *finh, void *msg,
-            struct iobuf *iobuf)
+fuse_rmdir(xlator_t *this, fuse_in_header_t *finh, void *msg,
+           struct iobuf *iobuf)
 {
-        char         *name = msg;
-        fuse_state_t *state = NULL;
+    char *name = msg;
+    fuse_state_t *state = NULL;
 
-        GET_STATE (this, finh, state);
+    GET_STATE(this, finh, state);
 
-        fuse_resolve_entry_init (state, &state->resolve, finh->nodeid, name);
+    fuse_resolve_entry_init(state, &state->resolve, finh->nodeid, name);
 
-        fuse_resolve_and_resume (state, fuse_rmdir_resume);
+    fuse_resolve_and_resume(state, fuse_rmdir_resume);
 
-        return;
+    return;
 }
 
 void
-fuse_symlink_resume (fuse_state_t *state)
-{
-        if (!state->loc.parent) {
-                gf_log ("glusterfs-fuse", GF_LOG_ERROR,
-                        "SYMLINK %"PRIu64" (%s/%s) -> %s resolution failed",
-                        state->finh->nodeid, uuid_utoa (state->resolve.gfid),
-                        state->resolve.bname, state->name);
-                send_fuse_err (state->this, state->finh,
-                               state->resolve.op_errno);
-                free_fuse_state (state);
-                return;
-        }
+fuse_symlink_resume(fuse_state_t *state)
+{
+    if (!state->loc.parent) {
+        gf_log("glusterfs-fuse", GF_LOG_ERROR,
+               "SYMLINK %" PRIu64 " (%s/%s) -> %s resolution failed",
+               state->finh->nodeid, uuid_utoa(state->resolve.gfid),
+               state->resolve.bname, state->name);
+        send_fuse_err(state->this, state->finh, state->resolve.op_errno);
+        free_fuse_state(state);
+        return;
+    }
 
-        if (state->resolve.op_errno == ENOENT) {
-                state->resolve.op_ret = 0;
-                state->resolve.op_errno = 0;
-        }
+    if (state->resolve.op_errno == ENOENT) {
+        state->resolve.op_ret = 0;
+        state->resolve.op_errno = 0;
+    }
 
-        if (state->loc.inode) {
-                gf_log (state->this->name, GF_LOG_DEBUG, "inode already present");
-                inode_unref (state->loc.inode);
-                state->loc.inode = NULL;
-        }
+    if (state->loc.inode) {
+        gf_log(state->this->name, GF_LOG_DEBUG, "inode already present");
+        inode_unref(state->loc.inode);
+        state->loc.inode = NULL;
+    }
 
-        state->loc.inode = inode_new (state->loc.parent->table);
+    state->loc.inode = inode_new(state->loc.parent->table);
 
-        gf_log ("glusterfs-fuse", GF_LOG_TRACE,
-                "%"PRIu64": SYMLINK %s -> %s", state->finh->unique,
-                state->loc.path, state->name);
+    gf_log("glusterfs-fuse", GF_LOG_TRACE, "%" PRIu64 ": SYMLINK %s -> %s",
+           state->finh->unique, state->loc.path, state->name);
 
-        FUSE_FOP (state, fuse_newentry_cbk, GF_FOP_SYMLINK,
-                  symlink, state->name, &state->loc, state->umask, state->xdata);
+    FUSE_FOP(state, fuse_newentry_cbk, GF_FOP_SYMLINK, symlink, state->name,
+             &state->loc, state->umask, state->xdata);
 }
 
 static void
-fuse_symlink (xlator_t *this, fuse_in_header_t *finh, void *msg,
-              struct iobuf *iobuf)
+fuse_symlink(xlator_t *this, fuse_in_header_t *finh, void *msg,
+             struct iobuf *iobuf)
 {
-        char         *name = msg;
-        char         *linkname = name + strlen (name) + 1;
-        fuse_state_t *state = NULL;
+    char *name = msg;
+    char *linkname = name + strlen(name) + 1;
+    fuse_state_t *state = NULL;
 
-        GET_STATE (this, finh, state);
+    GET_STATE(this, finh, state);
 
-        gf_uuid_generate (state->gfid);
+    gf_uuid_generate(state->gfid);
 
-        fuse_resolve_entry_init (state, &state->resolve, finh->nodeid, name);
+    fuse_resolve_entry_init(state, &state->resolve, finh->nodeid, name);
 
-        state->name = gf_strdup (linkname);
+    state->name = gf_strdup(linkname);
 
-        fuse_resolve_and_resume (state, fuse_symlink_resume);
+    fuse_resolve_and_resume(state, fuse_symlink_resume);
 
-        return;
+    return;
 }
 
 int
-fuse_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)
+fuse_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)
 {
-        fuse_state_t     *state = NULL;
-        fuse_in_header_t *finh = NULL;
-
-        state = frame->root->state;
-        finh  = state->finh;
-
-        fuse_log_eh (this, "op_ret: %d, op_errno: %d, %"PRIu64": %s() "
-                     "path: %s parent: %s ==> path: %s parent: %s"
-                     "gfid: %s", op_ret, op_errno, frame->root->unique,
-                     gf_fop_list[frame->root->op], state->loc.path,
-                     state->loc.parent?uuid_utoa (state->loc.parent->gfid):"",
-                     state->loc2.path,
-                     state->loc2.parent?uuid_utoa (state->loc2.parent->gfid):"",
-                     state->loc.inode?uuid_utoa (state->loc.inode->gfid):"");
+    fuse_state_t *state = NULL;
+    fuse_in_header_t *finh = NULL;
+
+    state = frame->root->state;
+    finh = state->finh;
+
+    fuse_log_eh(this,
+                "op_ret: %d, op_errno: %d, %" PRIu64
+                ": %s() "
+                "path: %s parent: %s ==> path: %s parent: %s"
+                "gfid: %s",
+                op_ret, op_errno, frame->root->unique,
+                gf_fop_list[frame->root->op], state->loc.path,
+                state->loc.parent ? uuid_utoa(state->loc.parent->gfid) : "",
+                state->loc2.path,
+                state->loc2.parent ? uuid_utoa(state->loc2.parent->gfid) : "",
+                state->loc.inode ? uuid_utoa(state->loc.inode->gfid) : "");
+
+    if (op_ret == 0) {
+        gf_log("glusterfs-fuse", GF_LOG_TRACE,
+               "%" PRIu64 ": %s -> %s => 0 (buf->ia_ino=%" PRIu64 ")",
+               frame->root->unique, state->loc.path, state->loc2.path,
+               buf->ia_ino);
 
-        if (op_ret == 0) {
-                gf_log ("glusterfs-fuse", GF_LOG_TRACE,
-                        "%"PRIu64": %s -> %s => 0 (buf->ia_ino=%"PRIu64")",
-                        frame->root->unique, state->loc.path, state->loc2.path,
-                        buf->ia_ino);
-
-                {
-                        /* ugly ugly - to stay blind to situation where
-                           rename happens on a new inode
-                        */
-                        buf->ia_type = state->loc.inode->ia_type;
-                }
-                buf->ia_blksize = this->ctx->page_size;
-
-                inode_rename (state->loc.parent->table,
-                              state->loc.parent, state->loc.name,
-                              state->loc2.parent, state->loc2.name,
-                              state->loc.inode, buf);
-
-                send_fuse_err (this, finh, 0);
-        } else {
-                gf_log ("glusterfs-fuse", GF_LOG_WARNING,
-                        "%"PRIu64": %s -> %s => -1 (%s)", frame->root->unique,
-                        state->loc.path, state->loc2.path,
-                        strerror (op_errno));
-                send_fuse_err (this, finh, op_errno);
-        }
+        {
+            /* ugly ugly - to stay blind to situation where
+               rename happens on a new inode
+            */
+            buf->ia_type = state->loc.inode->ia_type;
+        }
+        buf->ia_blksize = this->ctx->page_size;
+
+        inode_rename(state->loc.parent->table, state->loc.parent,
+                     state->loc.name, state->loc2.parent, state->loc2.name,
+                     state->loc.inode, buf);
+
+        send_fuse_err(this, finh, 0);
+    } else {
+        gf_log("glusterfs-fuse", GF_LOG_WARNING,
+               "%" PRIu64 ": %s -> %s => -1 (%s)", frame->root->unique,
+               state->loc.path, state->loc2.path, strerror(op_errno));
+        send_fuse_err(this, finh, op_errno);
+    }
 
-        free_fuse_state (state);
-        STACK_DESTROY (frame->root);
-        return 0;
+    free_fuse_state(state);
+    STACK_DESTROY(frame->root);
+    return 0;
 }
 
 void
-fuse_rename_resume (fuse_state_t *state)
-{
-        char loc_uuid[64]  = {0,};
-        char loc2_uuid[64] = {0,};
-
-        if (!state->loc.parent || !state->loc.inode) {
-                gf_log ("glusterfs-fuse", GF_LOG_ERROR,
-                        "RENAME %"PRIu64" %s/%s -> %s/%s src resolution failed",
-                        state->finh->unique,
-                        uuid_utoa_r (state->resolve.gfid, loc_uuid),
-                        state->resolve.bname,
-                        uuid_utoa_r (state->resolve2.gfid, loc2_uuid),
-                        state->resolve2.bname);
-
-                send_fuse_err (state->this, state->finh,
-                               state->resolve.op_errno);
-                free_fuse_state (state);
-                return;
-        }
+fuse_rename_resume(fuse_state_t *state)
+{
+    char loc_uuid[64] = {
+        0,
+    };
+    char loc2_uuid[64] = {
+        0,
+    };
+
+    if (!state->loc.parent || !state->loc.inode) {
+        gf_log("glusterfs-fuse", GF_LOG_ERROR,
+               "RENAME %" PRIu64 " %s/%s -> %s/%s src resolution failed",
+               state->finh->unique, uuid_utoa_r(state->resolve.gfid, loc_uuid),
+               state->resolve.bname,
+               uuid_utoa_r(state->resolve2.gfid, loc2_uuid),
+               state->resolve2.bname);
+
+        send_fuse_err(state->this, state->finh, state->resolve.op_errno);
+        free_fuse_state(state);
+        return;
+    }
 
-        if (!state->loc2.parent) {
-                gf_log ("glusterfs-fuse", GF_LOG_ERROR,
-                        "RENAME %"PRIu64" %s/%s -> %s/%s dst resolution failed",
-                        state->finh->unique,
-                        uuid_utoa_r (state->resolve.gfid, loc_uuid),
-                        state->resolve.bname,
-                        uuid_utoa_r (state->resolve2.gfid, loc2_uuid),
-                        state->resolve2.bname);
-
-                send_fuse_err (state->this, state->finh, ENOENT);
-                free_fuse_state (state);
-                return;
-        }
+    if (!state->loc2.parent) {
+        gf_log("glusterfs-fuse", GF_LOG_ERROR,
+               "RENAME %" PRIu64 " %s/%s -> %s/%s dst resolution failed",
+               state->finh->unique, uuid_utoa_r(state->resolve.gfid, loc_uuid),
+               state->resolve.bname,
+               uuid_utoa_r(state->resolve2.gfid, loc2_uuid),
+               state->resolve2.bname);
 
-        state->resolve.op_ret = 0;
-        state->resolve2.op_ret = 0;
+        send_fuse_err(state->this, state->finh, ENOENT);
+        free_fuse_state(state);
+        return;
+    }
 
-        gf_log ("glusterfs-fuse", GF_LOG_TRACE,
-                "%"PRIu64": RENAME `%s (%s)' -> `%s (%s)'",
-                state->finh->unique, state->loc.path, loc_uuid,
-                state->loc2.path, loc2_uuid);
+    state->resolve.op_ret = 0;
+    state->resolve2.op_ret = 0;
 
-        FUSE_FOP (state, fuse_rename_cbk, GF_FOP_RENAME,
-                  rename, &state->loc, &state->loc2, state->xdata);
+    gf_log("glusterfs-fuse", GF_LOG_TRACE,
+           "%" PRIu64 ": RENAME `%s (%s)' -> `%s (%s)'", state->finh->unique,
+           state->loc.path, loc_uuid, state->loc2.path, loc2_uuid);
+
+    FUSE_FOP(state, fuse_rename_cbk, GF_FOP_RENAME, rename, &state->loc,
+             &state->loc2, state->xdata);
 }
 
 static void
-fuse_rename (xlator_t *this, fuse_in_header_t *finh, void *msg,
-             struct iobuf *iobuf)
+fuse_rename(xlator_t *this, fuse_in_header_t *finh, void *msg,
+            struct iobuf *iobuf)
 {
-        struct fuse_rename_in  *fri = msg;
-        char *oldname = (char *)(fri + 1);
-        char *newname = oldname + strlen (oldname) + 1;
-        fuse_state_t *state = NULL;
+    struct fuse_rename_in *fri = msg;
+    char *oldname = (char *)(fri + 1);
+    char *newname = oldname + strlen(oldname) + 1;
+    fuse_state_t *state = NULL;
 
-        GET_STATE (this, finh, state);
+    GET_STATE(this, finh, state);
 
-        fuse_resolve_entry_init (state, &state->resolve, finh->nodeid, oldname);
+    fuse_resolve_entry_init(state, &state->resolve, finh->nodeid, oldname);
 
-        fuse_resolve_entry_init (state, &state->resolve2, fri->newdir, newname);
+    fuse_resolve_entry_init(state, &state->resolve2, fri->newdir, newname);
 
-        fuse_resolve_and_resume (state, fuse_rename_resume);
+    fuse_resolve_and_resume(state, fuse_rename_resume);
 
-        return;
+    return;
 }
 
 void
-fuse_link_resume (fuse_state_t *state)
-{
-        if (!state->loc2.inode || !state->loc.parent) {
-                gf_log ("glusterfs-fuse", GF_LOG_WARNING,
-                        "fuse_loc_fill() failed %"PRIu64": LINK %s %s",
-                        state->finh->unique, state->loc2.path, state->loc.path);
-                send_fuse_err (state->this, state->finh,
-                               state->resolve.op_errno);
-                free_fuse_state (state);
-                return;
-        }
+fuse_link_resume(fuse_state_t *state)
+{
+    if (!state->loc2.inode || !state->loc.parent) {
+        gf_log("glusterfs-fuse", GF_LOG_WARNING,
+               "fuse_loc_fill() failed %" PRIu64 ": LINK %s %s",
+               state->finh->unique, state->loc2.path, state->loc.path);
+        send_fuse_err(state->this, state->finh, state->resolve.op_errno);
+        free_fuse_state(state);
+        return;
+    }
 
-        state->resolve.op_ret = 0;
-        state->resolve2.op_ret = 0;
+    state->resolve.op_ret = 0;
+    state->resolve2.op_ret = 0;
 
-        if (state->loc.inode) {
-                inode_unref (state->loc.inode);
-                state->loc.inode = NULL;
-        }
-        state->loc.inode = inode_ref (state->loc2.inode);
+    if (state->loc.inode) {
+        inode_unref(state->loc.inode);
+        state->loc.inode = NULL;
+    }
+    state->loc.inode = inode_ref(state->loc2.inode);
 
-        gf_log ("glusterfs-fuse", GF_LOG_TRACE,
-                "%"PRIu64": LINK() %s -> %s",
-                state->finh->unique, state->loc2.path,
-                state->loc.path);
+    gf_log("glusterfs-fuse", GF_LOG_TRACE, "%" PRIu64 ": LINK() %s -> %s",
+           state->finh->unique, state->loc2.path, state->loc.path);
 
-        FUSE_FOP (state, fuse_newentry_cbk, GF_FOP_LINK,
-                  link, &state->loc2, &state->loc, state->xdata);
+    FUSE_FOP(state, fuse_newentry_cbk, GF_FOP_LINK, link, &state->loc2,
+             &state->loc, state->xdata);
 }
 
 static void
-fuse_link (xlator_t *this, fuse_in_header_t *finh, void *msg,
-           struct iobuf *iobuf)
+fuse_link(xlator_t *this, fuse_in_header_t *finh, void *msg,
+          struct iobuf *iobuf)
 {
-        struct fuse_link_in *fli = msg;
-        char         *name = (char *)(fli + 1);
-        fuse_state_t *state = NULL;
+    struct fuse_link_in *fli = msg;
+    char *name = (char *)(fli + 1);
+    fuse_state_t *state = NULL;
 
-        GET_STATE (this, finh, state);
+    GET_STATE(this, finh, state);
 
-        fuse_resolve_inode_init (state, &state->resolve2, fli->oldnodeid);
+    fuse_resolve_inode_init(state, &state->resolve2, fli->oldnodeid);
 
-        fuse_resolve_entry_init (state, &state->resolve, finh->nodeid, name);
+    fuse_resolve_entry_init(state, &state->resolve, finh->nodeid, name);
 
-        fuse_resolve_and_resume (state, fuse_link_resume);
+    fuse_resolve_and_resume(state, fuse_link_resume);
 
-        return;
+    return;
 }
 
 static int
-fuse_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)
-{
-        fuse_state_t           *state        = NULL;
-        fuse_in_header_t       *finh         = NULL;
-        fuse_private_t         *priv         = NULL;
-        struct fuse_out_header  fouh         = {0, };
-        struct fuse_entry_out   feo          = {0, };
-        struct fuse_open_out    foo          = {0, };
-        struct iovec            iov_out[3];
-        inode_t                *linked_inode = NULL;
-        uint64_t                ctx_value    = LOOKUP_NOT_NEEDED;
-
-        state    = frame->root->state;
-        priv     = this->private;
-        finh     = state->finh;
-        foo.open_flags = 0;
-
-        fuse_log_eh_fop(this, state, frame, op_ret, op_errno);
-
-        if (op_ret >= 0) {
-                foo.fh = (uintptr_t) fd;
-
-                if (((priv->direct_io_mode == 2)
-                     && ((state->flags & O_ACCMODE) != O_RDONLY))
-                    || (priv->direct_io_mode == 1)
-		    || direct_io_mode (xdata))
-                        foo.open_flags |= FOPEN_DIRECT_IO;
-
-                gf_log ("glusterfs-fuse", GF_LOG_TRACE,
-                        "%"PRIu64": %s() %s => %p (ino=%"PRIu64")",
-                        frame->root->unique, gf_fop_list[frame->root->op],
-                        state->loc.path, fd, buf->ia_ino);
-
-                buf->ia_blksize = this->ctx->page_size;
-                gf_fuse_stat2attr (buf, &feo.attr, priv->enable_ino32);
-
-                linked_inode = inode_link (inode, state->loc.parent,
-                                           state->loc.name, buf);
-
-                if (linked_inode != inode) {
-                        /*
-                           VERY racy code (if used anywhere else)
-                           -- don't do this without understanding
-                        */
-                        inode_unref (fd->inode);
-                        fd->inode = inode_ref (linked_inode);
-                } else {
-                        inode_ctx_set (linked_inode, this, &ctx_value);
-                }
+fuse_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)
+{
+    fuse_state_t *state = NULL;
+    fuse_in_header_t *finh = NULL;
+    fuse_private_t *priv = NULL;
+    struct fuse_out_header fouh = {
+        0,
+    };
+    struct fuse_entry_out feo = {
+        0,
+    };
+    struct fuse_open_out foo = {
+        0,
+    };
+    struct iovec iov_out[3];
+    inode_t *linked_inode = NULL;
+    uint64_t ctx_value = LOOKUP_NOT_NEEDED;
+
+    state = frame->root->state;
+    priv = this->private;
+    finh = state->finh;
+    foo.open_flags = 0;
+
+    fuse_log_eh_fop(this, state, frame, op_ret, op_errno);
+
+    if (op_ret >= 0) {
+        foo.fh = (uintptr_t)fd;
+
+        if (((priv->direct_io_mode == 2) &&
+             ((state->flags & O_ACCMODE) != O_RDONLY)) ||
+            (priv->direct_io_mode == 1) || direct_io_mode(xdata))
+            foo.open_flags |= FOPEN_DIRECT_IO;
+
+        gf_log("glusterfs-fuse", GF_LOG_TRACE,
+               "%" PRIu64 ": %s() %s => %p (ino=%" PRIu64 ")",
+               frame->root->unique, gf_fop_list[frame->root->op],
+               state->loc.path, fd, buf->ia_ino);
+
+        buf->ia_blksize = this->ctx->page_size;
+        gf_fuse_stat2attr(buf, &feo.attr, priv->enable_ino32);
+
+        linked_inode = inode_link(inode, state->loc.parent, state->loc.name,
+                                  buf);
+
+        if (linked_inode != inode) {
+            /*
+               VERY racy code (if used anywhere else)
+               -- don't do this without understanding
+            */
+            inode_unref(fd->inode);
+            fd->inode = inode_ref(linked_inode);
+        } else {
+            inode_ctx_set(linked_inode, this, &ctx_value);
+        }
 
-                inode_lookup (linked_inode);
+        inode_lookup(linked_inode);
 
-                inode_unref (linked_inode);
+        inode_unref(linked_inode);
 
-                feo.nodeid = inode_to_fuse_nodeid (linked_inode);
+        feo.nodeid = inode_to_fuse_nodeid(linked_inode);
 
-                feo.entry_valid = calc_timeout_sec (priv->entry_timeout);
-                feo.entry_valid_nsec = calc_timeout_nsec (priv->entry_timeout);
-                feo.attr_valid = calc_timeout_sec (priv->attribute_timeout);
-                feo.attr_valid_nsec =
-                  calc_timeout_nsec (priv->attribute_timeout);
+        feo.entry_valid = calc_timeout_sec(priv->entry_timeout);
+        feo.entry_valid_nsec = calc_timeout_nsec(priv->entry_timeout);
+        feo.attr_valid = calc_timeout_sec(priv->attribute_timeout);
+        feo.attr_valid_nsec = calc_timeout_nsec(priv->attribute_timeout);
 
-                fouh.error = 0;
-                iov_out[0].iov_base = &fouh;
-                iov_out[1].iov_base = &feo;
+        fouh.error = 0;
+        iov_out[0].iov_base = &fouh;
+        iov_out[1].iov_base = &feo;
 #if FUSE_KERNEL_MINOR_VERSION >= 9
-                iov_out[1].iov_len = priv->proto_minor >= 9 ?
-                                     sizeof (feo) :
-                                     FUSE_COMPAT_ENTRY_OUT_SIZE;
+        iov_out[1].iov_len = priv->proto_minor >= 9
+                                 ? sizeof(feo)
+                                 : FUSE_COMPAT_ENTRY_OUT_SIZE;
 #else
-                iov_out[1].iov_len = sizeof (feo);
+        iov_out[1].iov_len = sizeof(feo);
 #endif
-                iov_out[2].iov_base = &foo;
-                iov_out[2].iov_len = sizeof (foo);
-
-                if (send_fuse_iov (this, finh, iov_out, 3) == ENOENT) {
-                        gf_log ("glusterfs-fuse", GF_LOG_DEBUG,
-                                "create(%s) got EINTR", state->loc.path);
-                        inode_forget (inode, 1);
-                        gf_fd_put (priv->fdtable, state->fd_no);
-                        goto out;
-                }
+        iov_out[2].iov_base = &foo;
+        iov_out[2].iov_len = sizeof(foo);
 
-                fd_bind (fd);
-        } else {
-                gf_log ("glusterfs-fuse", GF_LOG_WARNING,
-                        "%"PRIu64": %s => -1 (%s)", finh->unique,
-                        state->loc.path, strerror (op_errno));
-                send_fuse_err (this, finh, op_errno);
-                gf_fd_put (priv->fdtable, state->fd_no);
+        if (send_fuse_iov(this, finh, iov_out, 3) == ENOENT) {
+            gf_log("glusterfs-fuse", GF_LOG_DEBUG, "create(%s) got EINTR",
+                   state->loc.path);
+            inode_forget(inode, 1);
+            gf_fd_put(priv->fdtable, state->fd_no);
+            goto out;
         }
+
+        fd_bind(fd);
+    } else {
+        gf_log("glusterfs-fuse", GF_LOG_WARNING, "%" PRIu64 ": %s => -1 (%s)",
+               finh->unique, state->loc.path, strerror(op_errno));
+        send_fuse_err(this, finh, op_errno);
+        gf_fd_put(priv->fdtable, state->fd_no);
+    }
 out:
-        free_fuse_state (state);
-        STACK_DESTROY (frame->root);
+    free_fuse_state(state);
+    STACK_DESTROY(frame->root);
 
-        return 0;
+    return 0;
 }
 
 void
-fuse_create_resume (fuse_state_t *state)
-{
-        fd_t           *fd    = NULL;
-        fuse_private_t *priv  = NULL;
-        fuse_fd_ctx_t  *fdctx = NULL;
-
-        if (!state->loc.parent) {
-                gf_log ("glusterfs-fuse", GF_LOG_WARNING,
-                        "%"PRIu64" CREATE %s/%s resolution failed",
-                        state->finh->unique, uuid_utoa (state->resolve.gfid),
-                        state->resolve.bname);
-                send_fuse_err (state->this, state->finh,
-                               state->resolve.op_errno);
-                free_fuse_state (state);
-                return;
-        }
-
-        if (state->resolve.op_errno == ENOENT) {
-                state->resolve.op_ret = 0;
-                state->resolve.op_errno = 0;
-        }
-
-        if (state->loc.inode) {
-                gf_log (state->this->name, GF_LOG_DEBUG,
-                        "inode already present");
-                inode_unref (state->loc.inode);
-        }
-
-        state->loc.inode = inode_new (state->loc.parent->table);
-
-        fd = fd_create (state->loc.inode, state->finh->pid);
-        if (fd == NULL) {
-                gf_log ("glusterfs-fuse", GF_LOG_WARNING,
-                        "%"PRIu64" CREATE cannot create a new fd",
-                        state->finh->unique);
-                send_fuse_err (state->this, state->finh, ENOMEM);
-                free_fuse_state (state);
-                return;
-        }
-
-        fdctx = fuse_fd_ctx_check_n_create (state->this, fd);
-        if (fdctx == NULL) {
-                gf_log ("glusterfs-fuse", GF_LOG_WARNING,
-                        "%"PRIu64" CREATE creation of fdctx failed",
-                        state->finh->unique);
-                fd_unref (fd);
-                send_fuse_err (state->this, state->finh, ENOMEM);
-                free_fuse_state (state);
-                return;
-        }
+fuse_create_resume(fuse_state_t *state)
+{
+    fd_t *fd = NULL;
+    fuse_private_t *priv = NULL;
+    fuse_fd_ctx_t *fdctx = NULL;
+
+    if (!state->loc.parent) {
+        gf_log("glusterfs-fuse", GF_LOG_WARNING,
+               "%" PRIu64 " CREATE %s/%s resolution failed",
+               state->finh->unique, uuid_utoa(state->resolve.gfid),
+               state->resolve.bname);
+        send_fuse_err(state->this, state->finh, state->resolve.op_errno);
+        free_fuse_state(state);
+        return;
+    }
 
-        priv = state->this->private;
+    if (state->resolve.op_errno == ENOENT) {
+        state->resolve.op_ret = 0;
+        state->resolve.op_errno = 0;
+    }
+
+    if (state->loc.inode) {
+        gf_log(state->this->name, GF_LOG_DEBUG, "inode already present");
+        inode_unref(state->loc.inode);
+    }
+
+    state->loc.inode = inode_new(state->loc.parent->table);
+
+    fd = fd_create(state->loc.inode, state->finh->pid);
+    if (fd == NULL) {
+        gf_log("glusterfs-fuse", GF_LOG_WARNING,
+               "%" PRIu64 " CREATE cannot create a new fd",
+               state->finh->unique);
+        send_fuse_err(state->this, state->finh, ENOMEM);
+        free_fuse_state(state);
+        return;
+    }
+
+    fdctx = fuse_fd_ctx_check_n_create(state->this, fd);
+    if (fdctx == NULL) {
+        gf_log("glusterfs-fuse", GF_LOG_WARNING,
+               "%" PRIu64 " CREATE creation of fdctx failed",
+               state->finh->unique);
+        fd_unref(fd);
+        send_fuse_err(state->this, state->finh, ENOMEM);
+        free_fuse_state(state);
+        return;
+    }
 
-        state->fd_no = gf_fd_unused_get (priv->fdtable, fd);
+    priv = state->this->private;
 
-        state->fd = fd_ref (fd);
-        fd->flags = state->flags;
+    state->fd_no = gf_fd_unused_get(priv->fdtable, fd);
 
-        gf_log ("glusterfs-fuse", GF_LOG_TRACE,
-                "%"PRIu64": CREATE %s", state->finh->unique,
-                state->loc.path);
+    state->fd = fd_ref(fd);
+    fd->flags = state->flags;
 
-        FUSE_FOP (state, fuse_create_cbk, GF_FOP_CREATE,
-                  create, &state->loc, state->flags, state->mode,
-                  state->umask, fd, state->xdata);
+    gf_log("glusterfs-fuse", GF_LOG_TRACE, "%" PRIu64 ": CREATE %s",
+           state->finh->unique, state->loc.path);
 
+    FUSE_FOP(state, fuse_create_cbk, GF_FOP_CREATE, create, &state->loc,
+             state->flags, state->mode, state->umask, fd, state->xdata);
 }
 
 static void
-fuse_create (xlator_t *this, fuse_in_header_t *finh, void *msg,
-             struct iobuf *iobuf)
+fuse_create(xlator_t *this, fuse_in_header_t *finh, void *msg,
+            struct iobuf *iobuf)
 {
 #if FUSE_KERNEL_MINOR_VERSION >= 12
-        struct fuse_create_in *fci = msg;
-        fuse_private_t        *priv = NULL;
-	int32_t                ret = -1;
+    struct fuse_create_in *fci = msg;
+    fuse_private_t *priv = NULL;
+    int32_t ret = -1;
 #else
-        struct fuse_open_in *fci = msg;
+    struct fuse_open_in *fci = msg;
 #endif
-        char         *name = (char *)(fci + 1);
+    char *name = (char *)(fci + 1);
 
-        fuse_state_t *state = NULL;
+    fuse_state_t *state = NULL;
 
 #if FUSE_KERNEL_MINOR_VERSION >= 12
-        priv = this->private;
-        if (priv->proto_minor < 12)
-                name = (char *)((struct fuse_open_in *)msg + 1);
+    priv = this->private;
+    if (priv->proto_minor < 12)
+        name = (char *)((struct fuse_open_in *)msg + 1);
 #endif
 
-        GET_STATE (this, finh, state);
+    GET_STATE(this, finh, state);
 
-        gf_uuid_generate (state->gfid);
+    gf_uuid_generate(state->gfid);
 
-        fuse_resolve_entry_init (state, &state->resolve, finh->nodeid, name);
+    fuse_resolve_entry_init(state, &state->resolve, finh->nodeid, name);
 
-        state->mode = fci->mode;
-        state->flags = fci->flags;
+    state->mode = fci->mode;
+    state->flags = fci->flags;
 
-#if FUSE_KERNEL_MINOR_VERSION >=12
-        priv = this->private;
-        FUSE_ENTRY_CREATE(this, priv, finh, state, fci, "CREATE");
+#if FUSE_KERNEL_MINOR_VERSION >= 12
+    priv = this->private;
+    FUSE_ENTRY_CREATE(this, priv, finh, state, fci, "CREATE");
 #endif
-        fuse_resolve_and_resume (state, fuse_create_resume);
+    fuse_resolve_and_resume(state, fuse_create_resume);
 
-        return;
+    return;
 }
 
 void
-fuse_open_resume (fuse_state_t *state)
+fuse_open_resume(fuse_state_t *state)
 {
-        fd_t           *fd    = NULL;
-        fuse_private_t *priv  = NULL;
-        fuse_fd_ctx_t  *fdctx = NULL;
-
-        if (!state->loc.inode) {
-                gf_log ("glusterfs-fuse", GF_LOG_ERROR,
-                        "%"PRIu64": OPEN %s resolution failed",
-                        state->finh->unique, uuid_utoa (state->resolve.gfid));
+    fd_t *fd = NULL;
+    fuse_private_t *priv = NULL;
+    fuse_fd_ctx_t *fdctx = NULL;
 
-                /* facilitate retry from VFS */
-                if (state->resolve.op_errno == ENOENT)
-                        state->resolve.op_errno = ESTALE;
+    if (!state->loc.inode) {
+        gf_log("glusterfs-fuse", GF_LOG_ERROR,
+               "%" PRIu64 ": OPEN %s resolution failed", state->finh->unique,
+               uuid_utoa(state->resolve.gfid));
 
-                send_fuse_err (state->this, state->finh,
-                               state->resolve.op_errno);
-                free_fuse_state (state);
-                return;
-        }
+        /* facilitate retry from VFS */
+        if (state->resolve.op_errno == ENOENT)
+            state->resolve.op_errno = ESTALE;
 
-        fd = fd_create (state->loc.inode, state->finh->pid);
-        if (!fd) {
-                gf_log ("fuse", GF_LOG_ERROR,
-                        "fd is NULL");
-                send_fuse_err (state->this, state->finh, ENOENT);
-                free_fuse_state (state);
-                return;
-        }
+        send_fuse_err(state->this, state->finh, state->resolve.op_errno);
+        free_fuse_state(state);
+        return;
+    }
 
-        fdctx = fuse_fd_ctx_check_n_create (state->this, fd);
-        if (fdctx == NULL) {
-                gf_log ("glusterfs-fuse", GF_LOG_WARNING,
-                        "%"PRIu64": OPEN creation of fdctx failed",
-                        state->finh->unique);
-                fd_unref (fd);
-                send_fuse_err (state->this, state->finh, ENOMEM);
-                free_fuse_state (state);
-                return;
-        }
+    fd = fd_create(state->loc.inode, state->finh->pid);
+    if (!fd) {
+        gf_log("fuse", GF_LOG_ERROR, "fd is NULL");
+        send_fuse_err(state->this, state->finh, ENOENT);
+        free_fuse_state(state);
+        return;
+    }
+
+    fdctx = fuse_fd_ctx_check_n_create(state->this, fd);
+    if (fdctx == NULL) {
+        gf_log("glusterfs-fuse", GF_LOG_WARNING,
+               "%" PRIu64 ": OPEN creation of fdctx failed",
+               state->finh->unique);
+        fd_unref(fd);
+        send_fuse_err(state->this, state->finh, ENOMEM);
+        free_fuse_state(state);
+        return;
+    }
 
-        priv = state->this->private;
+    priv = state->this->private;
 
-        state->fd_no = gf_fd_unused_get (priv->fdtable, fd);
-        state->fd = fd_ref (fd);
-        fd->flags = state->flags;
+    state->fd_no = gf_fd_unused_get(priv->fdtable, fd);
+    state->fd = fd_ref(fd);
+    fd->flags = state->flags;
 
-        gf_log ("glusterfs-fuse", GF_LOG_TRACE,
-                "%"PRIu64": OPEN %s", state->finh->unique,
-                state->loc.path);
+    gf_log("glusterfs-fuse", GF_LOG_TRACE, "%" PRIu64 ": OPEN %s",
+           state->finh->unique, state->loc.path);
 
-        FUSE_FOP (state, fuse_fd_cbk, GF_FOP_OPEN,
-                  open, &state->loc, state->flags, fd, state->xdata);
+    FUSE_FOP(state, fuse_fd_cbk, GF_FOP_OPEN, open, &state->loc, state->flags,
+             fd, state->xdata);
 }
 
 static void
-fuse_open (xlator_t *this, fuse_in_header_t *finh, void *msg,
-           struct iobuf *iobuf)
+fuse_open(xlator_t *this, fuse_in_header_t *finh, void *msg,
+          struct iobuf *iobuf)
 {
-        struct fuse_open_in *foi = msg;
-        fuse_state_t *state = NULL;
+    struct fuse_open_in *foi = msg;
+    fuse_state_t *state = NULL;
 
-        GET_STATE (this, finh, state);
+    GET_STATE(this, finh, state);
 
-        fuse_resolve_inode_init (state, &state->resolve, finh->nodeid);
+    fuse_resolve_inode_init(state, &state->resolve, finh->nodeid);
 
-        state->flags = foi->flags;
+    state->flags = foi->flags;
 
-        fuse_resolve_and_resume (state, fuse_open_resume);
+    fuse_resolve_and_resume(state, fuse_open_resume);
 
-        return;
+    return;
 }
 
 static int
-fuse_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)
-{
-        fuse_state_t *state = NULL;
-        fuse_in_header_t *finh = NULL;
-        struct fuse_out_header fouh = {0, };
-        struct iovec *iov_out = NULL;
-
-        state = frame->root->state;
-        finh = state->finh;
-
-        fuse_log_eh_fop(this, state, frame, op_ret, op_errno);
-
-        if (op_ret >= 0) {
-                gf_log ("glusterfs-fuse", GF_LOG_TRACE,
-                        "%"PRIu64": READ => %d/%"GF_PRI_SIZET",%"PRId64"/%"PRIu64,
-                        frame->root->unique,
-                        op_ret, state->size, state->off, stbuf->ia_size);
-
-                iov_out = GF_CALLOC (count + 1, sizeof (*iov_out),
-                                     gf_fuse_mt_iovec);
-                if (iov_out) {
-                        fouh.error = 0;
-                        iov_out[0].iov_base = &fouh;
-                        memcpy (iov_out + 1, vector, count * sizeof (*iov_out));
-                        send_fuse_iov (this, finh, iov_out, count + 1);
-                        GF_FREE (iov_out);
-                } else
-                        send_fuse_err (this, finh, ENOMEM);
-        } else {
-                gf_log ("glusterfs-fuse", GF_LOG_WARNING,
-                        "%"PRIu64": READ => %d gfid=%s fd=%p (%s)",
-                        frame->root->unique, op_ret,
-                        (state->fd && state->fd->inode) ?
-                        uuid_utoa (state->fd->inode->gfid) : "nil",
-                        state->fd, strerror (op_errno));
-
-                send_fuse_err (this, finh, op_errno);
-        }
+fuse_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)
+{
+    fuse_state_t *state = NULL;
+    fuse_in_header_t *finh = NULL;
+    struct fuse_out_header fouh = {
+        0,
+    };
+    struct iovec *iov_out = NULL;
+
+    state = frame->root->state;
+    finh = state->finh;
+
+    fuse_log_eh_fop(this, state, frame, op_ret, op_errno);
+
+    if (op_ret >= 0) {
+        gf_log("glusterfs-fuse", GF_LOG_TRACE,
+               "%" PRIu64 ": READ => %d/%" GF_PRI_SIZET ",%" PRId64 "/%" PRIu64,
+               frame->root->unique, op_ret, state->size, state->off,
+               stbuf->ia_size);
+
+        iov_out = GF_CALLOC(count + 1, sizeof(*iov_out), gf_fuse_mt_iovec);
+        if (iov_out) {
+            fouh.error = 0;
+            iov_out[0].iov_base = &fouh;
+            memcpy(iov_out + 1, vector, count * sizeof(*iov_out));
+            send_fuse_iov(this, finh, iov_out, count + 1);
+            GF_FREE(iov_out);
+        } else
+            send_fuse_err(this, finh, ENOMEM);
+    } else {
+        gf_log("glusterfs-fuse", GF_LOG_WARNING,
+               "%" PRIu64 ": READ => %d gfid=%s fd=%p (%s)",
+               frame->root->unique, op_ret,
+               (state->fd && state->fd->inode)
+                   ? uuid_utoa(state->fd->inode->gfid)
+                   : "nil",
+               state->fd, strerror(op_errno));
 
-        free_fuse_state (state);
-        STACK_DESTROY (frame->root);
+        send_fuse_err(this, finh, op_errno);
+    }
 
-        return 0;
+    free_fuse_state(state);
+    STACK_DESTROY(frame->root);
+
+    return 0;
 }
 
 void
-fuse_readv_resume (fuse_state_t *state)
+fuse_readv_resume(fuse_state_t *state)
 {
-        gf_log ("glusterfs-fuse", GF_LOG_TRACE,
-                "%"PRIu64": READ (%p, size=%zu, offset=%"PRIu64")",
-                state->finh->unique, state->fd, state->size, state->off);
+    gf_log("glusterfs-fuse", GF_LOG_TRACE,
+           "%" PRIu64 ": READ (%p, size=%zu, offset=%" PRIu64 ")",
+           state->finh->unique, state->fd, state->size, state->off);
 
-        FUSE_FOP (state, fuse_readv_cbk, GF_FOP_READ, readv, state->fd,
-                  state->size, state->off, state->io_flags, state->xdata);
+    FUSE_FOP(state, fuse_readv_cbk, GF_FOP_READ, readv, state->fd, state->size,
+             state->off, state->io_flags, state->xdata);
 }
 
 static void
-fuse_readv (xlator_t *this, fuse_in_header_t *finh, void *msg,
-            struct iobuf *iobuf)
+fuse_readv(xlator_t *this, fuse_in_header_t *finh, void *msg,
+           struct iobuf *iobuf)
 {
-        struct fuse_read_in *fri = msg;
+    struct fuse_read_in *fri = msg;
 
 #if FUSE_KERNEL_MINOR_VERSION >= 9
-        fuse_private_t  *priv = NULL;
+    fuse_private_t *priv = NULL;
 #endif
-        fuse_state_t *state = NULL;
-        fd_t         *fd = NULL;
+    fuse_state_t *state = NULL;
+    fd_t *fd = NULL;
 
-        GET_STATE (this, finh, state);
+    GET_STATE(this, finh, state);
 
-        fd = FH_TO_FD (fri->fh);
-        state->fd = fd;
+    fd = FH_TO_FD(fri->fh);
+    state->fd = fd;
 
-        fuse_resolve_fd_init (state, &state->resolve, fd);
+    fuse_resolve_fd_init(state, &state->resolve, fd);
 
-        /* See comment by similar code in fuse_settatr */
+    /* See comment by similar code in fuse_settatr */
 #if FUSE_KERNEL_MINOR_VERSION >= 9
-        priv = this->private;
-        if (priv->proto_minor >= 9 && fri->read_flags & FUSE_READ_LOCKOWNER)
-                state->lk_owner = fri->lock_owner;
+    priv = this->private;
+    if (priv->proto_minor >= 9 && fri->read_flags & FUSE_READ_LOCKOWNER)
+        state->lk_owner = fri->lock_owner;
 #endif
 
-        state->size = fri->size;
-        state->off = fri->offset;
-        /* lets ignore 'fri->read_flags', but just consider 'fri->flags' */
+    state->size = fri->size;
+    state->off = fri->offset;
+    /* lets ignore 'fri->read_flags', but just consider 'fri->flags' */
 #if FUSE_KERNEL_MINOR_VERSION >= 9
-        state->io_flags = fri->flags;
+    state->io_flags = fri->flags;
 #endif
-        fuse_resolve_and_resume (state, fuse_readv_resume);
+    fuse_resolve_and_resume(state, fuse_readv_resume);
 }
 
 static int
-fuse_writev_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                 int32_t op_ret, int32_t op_errno,
-                 struct iatt *stbuf, struct iatt *postbuf, dict_t *xdata)
+fuse_writev_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                int32_t op_ret, int32_t op_errno, struct iatt *stbuf,
+                struct iatt *postbuf, dict_t *xdata)
 {
-        fuse_state_t *state = NULL;
-        fuse_in_header_t *finh = NULL;
-        struct fuse_write_out fwo = {0, };
+    fuse_state_t *state = NULL;
+    fuse_in_header_t *finh = NULL;
+    struct fuse_write_out fwo = {
+        0,
+    };
+
+    state = frame->root->state;
+    finh = state->finh;
+
+    fuse_log_eh_fop(this, state, frame, op_ret, op_errno);
+
+    if (op_ret >= 0) {
+        gf_log("glusterfs-fuse", GF_LOG_TRACE,
+               "%" PRIu64 ": WRITE => %d/%" GF_PRI_SIZET ",%" PRId64
+               "/%" PRIu64,
+               frame->root->unique, op_ret, state->size, state->off,
+               stbuf->ia_size);
+
+        fwo.size = op_ret;
+        send_fuse_obj(this, finh, &fwo);
+    } else {
+        gf_log(
+            "glusterfs-fuse", GF_LOG_WARNING,
+            "%" PRIu64 ": WRITE => -1 gfid=%s fd=%p (%s)", frame->root->unique,
+            (state->fd && state->fd->inode) ? uuid_utoa(state->fd->inode->gfid)
+                                            : "nil",
+            state->fd, strerror(op_errno));
 
-        state = frame->root->state;
-        finh = state->finh;
-
-        fuse_log_eh_fop(this, state, frame, op_ret, op_errno);
-
-        if (op_ret >= 0) {
-                gf_log ("glusterfs-fuse", GF_LOG_TRACE,
-                        "%"PRIu64": WRITE => %d/%"GF_PRI_SIZET",%"PRId64"/%"PRIu64,
-                        frame->root->unique,
-                        op_ret, state->size, state->off, stbuf->ia_size);
-
-                fwo.size = op_ret;
-                send_fuse_obj (this, finh, &fwo);
-        } else {
-                gf_log ("glusterfs-fuse", GF_LOG_WARNING,
-                        "%"PRIu64": WRITE => -1 gfid=%s fd=%p (%s)",
-                        frame->root->unique,
-                        (state->fd && state->fd->inode) ?
-                        uuid_utoa (state->fd->inode->gfid) : "nil", state->fd,
-                        strerror (op_errno));
-
-                send_fuse_err (this, finh, op_errno);
-        }
+        send_fuse_err(this, finh, op_errno);
+    }
 
-        free_fuse_state (state);
-        STACK_DESTROY (frame->root);
+    free_fuse_state(state);
+    STACK_DESTROY(frame->root);
 
-        return 0;
+    return 0;
 }
 
 void
-fuse_write_resume (fuse_state_t *state)
+fuse_write_resume(fuse_state_t *state)
 {
-        struct iobref *iobref = NULL;
+    struct iobref *iobref = NULL;
 
-        iobref = iobref_new ();
-        if (!iobref) {
-                gf_log ("glusterfs-fuse", GF_LOG_ERROR,
-                        "%"PRIu64": WRITE iobref allocation failed",
-                        state->finh->unique);
-                send_fuse_err (state->this, state->finh, ENOMEM);
+    iobref = iobref_new();
+    if (!iobref) {
+        gf_log("glusterfs-fuse", GF_LOG_ERROR,
+               "%" PRIu64 ": WRITE iobref allocation failed",
+               state->finh->unique);
+        send_fuse_err(state->this, state->finh, ENOMEM);
 
-                free_fuse_state (state);
-                return;
-        }
+        free_fuse_state(state);
+        return;
+    }
 
-        iobref_add (iobref, state->iobuf);
+    iobref_add(iobref, state->iobuf);
 
-        gf_log ("glusterfs-fuse", GF_LOG_TRACE,
-                "%"PRIu64": WRITE (%p, size=%"GF_PRI_SIZET", offset=%"PRId64")",
-                state->finh->unique, state->fd, state->size, state->off);
+    gf_log("glusterfs-fuse", GF_LOG_TRACE,
+           "%" PRIu64 ": WRITE (%p, size=%" GF_PRI_SIZET ", offset=%" PRId64
+           ")",
+           state->finh->unique, state->fd, state->size, state->off);
 
-        FUSE_FOP (state, fuse_writev_cbk, GF_FOP_WRITE, writev, state->fd,
-                  &state->vector, 1, state->off, state->io_flags, iobref,
-                  state->xdata);
+    FUSE_FOP(state, fuse_writev_cbk, GF_FOP_WRITE, writev, state->fd,
+             &state->vector, 1, state->off, state->io_flags, iobref,
+             state->xdata);
 
-        iobref_unref (iobref);
+    iobref_unref(iobref);
 }
 
 static void
-fuse_write (xlator_t *this, fuse_in_header_t *finh, void *msg,
-            struct iobuf *iobuf)
+fuse_write(xlator_t *this, fuse_in_header_t *finh, void *msg,
+           struct iobuf *iobuf)
 {
-        /* WRITE is special, metadata is attached to in_header,
-         * and msg is the payload as-is.
-         */
-        struct fuse_write_in *fwi = (struct fuse_write_in *)
-                                      (finh + 1);
+    /* WRITE is special, metadata is attached to in_header,
+     * and msg is the payload as-is.
+     */
+    struct fuse_write_in *fwi = (struct fuse_write_in *)(finh + 1);
 
-        fuse_state_t    *state = NULL;
-        fd_t            *fd = NULL;
+    fuse_state_t *state = NULL;
+    fd_t *fd = NULL;
 #if FUSE_KERNEL_MINOR_VERSION >= 9
-        fuse_private_t  *priv = NULL;
-        priv = this->private;
+    fuse_private_t *priv = NULL;
+    priv = this->private;
 #endif
 
-        GET_STATE (this, finh, state);
-        fd          = FH_TO_FD (fwi->fh);
-        state->fd   = fd;
-        state->size = fwi->size;
-        state->off  = fwi->offset;
+    GET_STATE(this, finh, state);
+    fd = FH_TO_FD(fwi->fh);
+    state->fd = fd;
+    state->size = fwi->size;
+    state->off = fwi->offset;
 
-        /* lets ignore 'fwi->write_flags', but just consider 'fwi->flags' */
+    /* lets ignore 'fwi->write_flags', but just consider 'fwi->flags' */
 #if FUSE_KERNEL_MINOR_VERSION >= 9
-        state->io_flags = fwi->flags;
+    state->io_flags = fwi->flags;
 #else
-	state->io_flags = fwi->write_flags;
+    state->io_flags = fwi->write_flags;
 #endif
-        /* TODO: may need to handle below flag
-           (fwi->write_flags & FUSE_WRITE_CACHE);
-        */
+    /* TODO: may need to handle below flag
+       (fwi->write_flags & FUSE_WRITE_CACHE);
+    */
 
+    fuse_resolve_fd_init(state, &state->resolve, fd);
 
-        fuse_resolve_fd_init (state, &state->resolve, fd);
-
-        /* See comment by similar code in fuse_settatr */
+    /* See comment by similar code in fuse_settatr */
 #if FUSE_KERNEL_MINOR_VERSION >= 9
-        priv = this->private;
-        if (priv->proto_minor >= 9 && fwi->write_flags & FUSE_WRITE_LOCKOWNER)
-                state->lk_owner = fwi->lock_owner;
+    priv = this->private;
+    if (priv->proto_minor >= 9 && fwi->write_flags & FUSE_WRITE_LOCKOWNER)
+        state->lk_owner = fwi->lock_owner;
 #endif
 
-        state->vector.iov_base = msg;
-        state->vector.iov_len  = fwi->size;
-        state->iobuf = iobuf;
+    state->vector.iov_base = msg;
+    state->vector.iov_len = fwi->size;
+    state->iobuf = iobuf;
 
-        fuse_resolve_and_resume (state, fuse_write_resume);
+    fuse_resolve_and_resume(state, fuse_write_resume);
 
-        return;
+    return;
 }
 
 #if FUSE_KERNEL_MINOR_VERSION >= 24 && HAVE_SEEK_HOLE
 static int
-fuse_lseek_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                int32_t op_ret, int32_t op_errno, off_t offset, dict_t *xdata)
+fuse_lseek_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+               int32_t op_ret, int32_t op_errno, off_t offset, dict_t *xdata)
 {
-        fuse_state_t           *state = frame->root->state;
-        fuse_in_header_t       *finh  = state->finh;
-        struct fuse_lseek_out   flo   = {0, };
+    fuse_state_t *state = frame->root->state;
+    fuse_in_header_t *finh = state->finh;
+    struct fuse_lseek_out flo = {
+        0,
+    };
 
-        fuse_log_eh_fop (this, state, frame, op_ret, op_errno);
+    fuse_log_eh_fop(this, state, frame, op_ret, op_errno);
 
-        if (op_ret >= 0) {
-                flo.offset = offset;
-                send_fuse_obj (this, finh, &flo);
-        } else {
-                send_fuse_err (this, finh, op_errno);
-        }
+    if (op_ret >= 0) {
+        flo.offset = offset;
+        send_fuse_obj(this, finh, &flo);
+    } else {
+        send_fuse_err(this, finh, op_errno);
+    }
 
-        free_fuse_state (state);
-        STACK_DESTROY (frame->root);
+    free_fuse_state(state);
+    STACK_DESTROY(frame->root);
 
-        return 0;
+    return 0;
 }
 
 static void
-fuse_lseek_resume (fuse_state_t *state)
+fuse_lseek_resume(fuse_state_t *state)
 {
-        FUSE_FOP (state, fuse_lseek_cbk, GF_FOP_SEEK, seek, state->fd,
-                  state->off, state->whence, state->xdata);
+    FUSE_FOP(state, fuse_lseek_cbk, GF_FOP_SEEK, seek, state->fd, state->off,
+             state->whence, state->xdata);
 }
 
 static void
-fuse_lseek (xlator_t *this, fuse_in_header_t *finh, void *msg,
-            struct iobuf *iobuf)
+fuse_lseek(xlator_t *this, fuse_in_header_t *finh, void *msg,
+           struct iobuf *iobuf)
 {
-        struct fuse_lseek_in *ffi   = msg;
-        fuse_state_t         *state = NULL;
+    struct fuse_lseek_in *ffi = msg;
+    fuse_state_t *state = NULL;
 
-        GET_STATE (this, finh, state);
-        state->fd = FH_TO_FD (ffi->fh);
-        state->off = ffi->offset;
+    GET_STATE(this, finh, state);
+    state->fd = FH_TO_FD(ffi->fh);
+    state->off = ffi->offset;
 
-        switch (ffi->whence) {
+    switch (ffi->whence) {
         case SEEK_DATA:
-                state->whence = GF_SEEK_DATA;
-                break;
+            state->whence = GF_SEEK_DATA;
+            break;
         case SEEK_HOLE:
-                state->whence = GF_SEEK_HOLE;
-                break;
+            state->whence = GF_SEEK_HOLE;
+            break;
         default:
-                /* fuse should handle other whence internally */
-                send_fuse_err (this, finh, EINVAL);
-                free_fuse_state (state);
-                return;
-        }
+            /* fuse should handle other whence internally */
+            send_fuse_err(this, finh, EINVAL);
+            free_fuse_state(state);
+            return;
+    }
 
-        fuse_resolve_fd_init (state, &state->resolve, state->fd);
-        fuse_resolve_and_resume (state, fuse_lseek_resume);
+    fuse_resolve_fd_init(state, &state->resolve, state->fd);
+    fuse_resolve_and_resume(state, fuse_lseek_resume);
 }
 #endif /* FUSE_KERNEL_MINOR_VERSION >= 24 && HAVE_SEEK_HOLE */
 
 void
-fuse_flush_resume (fuse_state_t *state)
+fuse_flush_resume(fuse_state_t *state)
 {
-        FUSE_FOP (state, fuse_err_cbk, GF_FOP_FLUSH,
-                  flush, state->fd, state->xdata);
+    FUSE_FOP(state, fuse_err_cbk, GF_FOP_FLUSH, flush, state->fd, state->xdata);
 }
 
 static void
-fuse_flush (xlator_t *this, fuse_in_header_t *finh, void *msg,
-            struct iobuf *iobuf)
+fuse_flush(xlator_t *this, fuse_in_header_t *finh, void *msg,
+           struct iobuf *iobuf)
 {
-        struct fuse_flush_in *ffi = msg;
+    struct fuse_flush_in *ffi = msg;
 
-        fuse_state_t *state = NULL;
-        fd_t         *fd = NULL;
+    fuse_state_t *state = NULL;
+    fd_t *fd = NULL;
 
-        GET_STATE (this, finh, state);
-        fd = FH_TO_FD (ffi->fh);
-        state->fd = fd;
+    GET_STATE(this, finh, state);
+    fd = FH_TO_FD(ffi->fh);
+    state->fd = fd;
 
-        fuse_resolve_fd_init (state, &state->resolve, fd);
+    fuse_resolve_fd_init(state, &state->resolve, fd);
 
-        state->lk_owner = ffi->lock_owner;
+    state->lk_owner = ffi->lock_owner;
 
-        gf_log ("glusterfs-fuse", GF_LOG_TRACE,
-                "%"PRIu64": FLUSH %p", finh->unique, fd);
+    gf_log("glusterfs-fuse", GF_LOG_TRACE, "%" PRIu64 ": FLUSH %p",
+           finh->unique, fd);
 
-        fuse_resolve_and_resume (state, fuse_flush_resume);
+    fuse_resolve_and_resume(state, fuse_flush_resume);
 
-        return;
+    return;
 }
 
 int
-fuse_internal_release (xlator_t *this, fd_t *fd)
+fuse_internal_release(xlator_t *this, fd_t *fd)
 {
-        /* This is important we cleanup our context here to avoid a leak
-           in case an error occurs and we get cleanup up by
-           call_unwind_error->...->args_wipe instead of the normal path.
-        */
-        fuse_fd_ctx_destroy(this, fd);
+    /* This is important we cleanup our context here to avoid a leak
+       in case an error occurs and we get cleanup up by
+       call_unwind_error->...->args_wipe instead of the normal path.
+    */
+    fuse_fd_ctx_destroy(this, fd);
 
-        return 0;
+    return 0;
 }
 
 static void
-fuse_release (xlator_t *this, fuse_in_header_t *finh, void *msg,
-              struct iobuf *iobuf)
+fuse_release(xlator_t *this, fuse_in_header_t *finh, void *msg,
+             struct iobuf *iobuf)
 {
-        struct fuse_release_in *fri       = msg;
-        fd_t                   *fd        = NULL;
-        fuse_state_t           *state     = NULL;
-        fuse_private_t         *priv      = NULL;
+    struct fuse_release_in *fri = msg;
+    fd_t *fd = NULL;
+    fuse_state_t *state = NULL;
+    fuse_private_t *priv = NULL;
 
-        GET_STATE (this, finh, state);
-        fd = FH_TO_FD (fri->fh);
-        state->fd = fd;
+    GET_STATE(this, finh, state);
+    fd = FH_TO_FD(fri->fh);
+    state->fd = fd;
 
-        priv = this->private;
+    priv = this->private;
 
-        fuse_log_eh (this, "RELEASE(): %"PRIu64":, fd: %p, gfid: %s",
-                     finh->unique, fd, uuid_utoa (fd->inode->gfid));
+    fuse_log_eh(this, "RELEASE(): %" PRIu64 ":, fd: %p, gfid: %s", finh->unique,
+                fd, uuid_utoa(fd->inode->gfid));
 
-        gf_log ("glusterfs-fuse", GF_LOG_TRACE,
-                "%"PRIu64": RELEASE %p", finh->unique, state->fd);
+    gf_log("glusterfs-fuse", GF_LOG_TRACE, "%" PRIu64 ": RELEASE %p",
+           finh->unique, state->fd);
 
-        fuse_fd_ctx_destroy(this, state->fd);
-        fd_unref (fd);
+    fuse_fd_ctx_destroy(this, state->fd);
+    fd_unref(fd);
 
-        state->fd = NULL;
+    state->fd = NULL;
 
-        gf_fdptr_put (priv->fdtable, fd);
+    gf_fdptr_put(priv->fdtable, fd);
 
-        send_fuse_err (this, finh, 0);
+    send_fuse_err(this, finh, 0);
 
-        free_fuse_state (state);
-        return;
+    free_fuse_state(state);
+    return;
 }
 
 void
-fuse_fsync_resume (fuse_state_t *state)
+fuse_fsync_resume(fuse_state_t *state)
 {
-        gf_log ("glusterfs-fuse", GF_LOG_TRACE,
-                "%"PRIu64": FSYNC %p", state->finh->unique,
-                state->fd);
+    gf_log("glusterfs-fuse", GF_LOG_TRACE, "%" PRIu64 ": FSYNC %p",
+           state->finh->unique, state->fd);
 
-        /* fsync_flags: 1 means "datasync" (no defines for this) */
-        FUSE_FOP (state, fuse_fsync_cbk, GF_FOP_FSYNC,
-                  fsync, state->fd, (state->flags & 1), state->xdata);
+    /* fsync_flags: 1 means "datasync" (no defines for this) */
+    FUSE_FOP(state, fuse_fsync_cbk, GF_FOP_FSYNC, fsync, state->fd,
+             (state->flags & 1), state->xdata);
 }
 
 static void
-fuse_fsync (xlator_t *this, fuse_in_header_t *finh, void *msg,
-            struct iobuf *iobuf)
+fuse_fsync(xlator_t *this, fuse_in_header_t *finh, void *msg,
+           struct iobuf *iobuf)
 {
-        struct fuse_fsync_in *fsi = msg;
+    struct fuse_fsync_in *fsi = msg;
 
-        fuse_state_t *state = NULL;
-        fd_t         *fd = NULL;
+    fuse_state_t *state = NULL;
+    fd_t *fd = NULL;
 
-        GET_STATE (this, finh, state);
-        fd = FH_TO_FD (fsi->fh);
-        state->fd = fd;
+    GET_STATE(this, finh, state);
+    fd = FH_TO_FD(fsi->fh);
+    state->fd = fd;
 
-        fuse_resolve_fd_init (state, &state->resolve, fd);
+    fuse_resolve_fd_init(state, &state->resolve, fd);
 
-        state->flags = fsi->fsync_flags;
-        fuse_resolve_and_resume (state, fuse_fsync_resume);
-        return;
+    state->flags = fsi->fsync_flags;
+    fuse_resolve_and_resume(state, fuse_fsync_resume);
+    return;
 }
 
 void
-fuse_opendir_resume (fuse_state_t *state)
+fuse_opendir_resume(fuse_state_t *state)
 {
-        fd_t           *fd    = NULL;
-        fuse_private_t *priv  = NULL;
-        fuse_fd_ctx_t  *fdctx = NULL;
-
-        priv = state->this->private;
+    fd_t *fd = NULL;
+    fuse_private_t *priv = NULL;
+    fuse_fd_ctx_t *fdctx = NULL;
 
-        if (!state->loc.inode) {
-                gf_log ("glusterfs-fuse", GF_LOG_WARNING,
-                        "%"PRIu64": OPENDIR (%s) resolution failed",
-                        state->finh->unique, uuid_utoa (state->resolve.gfid));
+    priv = state->this->private;
 
-                /* facilitate retry from VFS */
-                if (state->resolve.op_errno == ENOENT)
-                        state->resolve.op_errno = ESTALE;
+    if (!state->loc.inode) {
+        gf_log("glusterfs-fuse", GF_LOG_WARNING,
+               "%" PRIu64 ": OPENDIR (%s) resolution failed",
+               state->finh->unique, uuid_utoa(state->resolve.gfid));
 
-                send_fuse_err (state->this, state->finh,
-                               state->resolve.op_errno);
-                free_fuse_state (state);
-                return;
-        }
+        /* facilitate retry from VFS */
+        if (state->resolve.op_errno == ENOENT)
+            state->resolve.op_errno = ESTALE;
 
-        fd = fd_create (state->loc.inode, state->finh->pid);
-        if (fd == NULL) {
-                gf_log ("glusterfs-fuse", GF_LOG_WARNING,
-                        "%"PRIu64": OPENDIR fd creation failed",
-                        state->finh->unique);
-                send_fuse_err (state->this, state->finh, ENOMEM);
-                free_fuse_state (state);
-                return;
-        }
+        send_fuse_err(state->this, state->finh, state->resolve.op_errno);
+        free_fuse_state(state);
+        return;
+    }
 
-        fdctx = fuse_fd_ctx_check_n_create (state->this, fd);
-        if (fdctx == NULL) {
-                gf_log ("glusterfs-fuse", GF_LOG_WARNING,
-                        "%"PRIu64": OPENDIR creation of fdctx failed",
-                        state->finh->unique);
-                fd_unref (fd);
-                send_fuse_err (state->this, state->finh, ENOMEM);
-                free_fuse_state (state);
-                return;
-        }
+    fd = fd_create(state->loc.inode, state->finh->pid);
+    if (fd == NULL) {
+        gf_log("glusterfs-fuse", GF_LOG_WARNING,
+               "%" PRIu64 ": OPENDIR fd creation failed", state->finh->unique);
+        send_fuse_err(state->this, state->finh, ENOMEM);
+        free_fuse_state(state);
+        return;
+    }
+
+    fdctx = fuse_fd_ctx_check_n_create(state->this, fd);
+    if (fdctx == NULL) {
+        gf_log("glusterfs-fuse", GF_LOG_WARNING,
+               "%" PRIu64 ": OPENDIR creation of fdctx failed",
+               state->finh->unique);
+        fd_unref(fd);
+        send_fuse_err(state->this, state->finh, ENOMEM);
+        free_fuse_state(state);
+        return;
+    }
 
-        state->fd = fd_ref (fd);
-        state->fd_no = gf_fd_unused_get (priv->fdtable, fd);
+    state->fd = fd_ref(fd);
+    state->fd_no = gf_fd_unused_get(priv->fdtable, fd);
 
-        gf_log ("glusterfs-fuse", GF_LOG_TRACE,
-                "%"PRIu64": OPENDIR %s", state->finh->unique,
-                state->loc.path);
+    gf_log("glusterfs-fuse", GF_LOG_TRACE, "%" PRIu64 ": OPENDIR %s",
+           state->finh->unique, state->loc.path);
 
-        FUSE_FOP (state, fuse_fd_cbk, GF_FOP_OPENDIR,
-                  opendir, &state->loc, fd, state->xdata);
+    FUSE_FOP(state, fuse_fd_cbk, GF_FOP_OPENDIR, opendir, &state->loc, fd,
+             state->xdata);
 }
 
 static void
-fuse_opendir (xlator_t *this, fuse_in_header_t *finh, void *msg,
-              struct iobuf *iobuf)
+fuse_opendir(xlator_t *this, fuse_in_header_t *finh, void *msg,
+             struct iobuf *iobuf)
 {
-        /*
-        struct fuse_open_in *foi = msg;
-         */
+    /*
+    struct fuse_open_in *foi = msg;
+     */
 
-        fuse_state_t *state = NULL;
+    fuse_state_t *state = NULL;
 
-        GET_STATE (this, finh, state);
+    GET_STATE(this, finh, state);
 
-        fuse_resolve_inode_init (state, &state->resolve, finh->nodeid);
+    fuse_resolve_inode_init(state, &state->resolve, finh->nodeid);
 
-        fuse_resolve_and_resume (state, fuse_opendir_resume);
+    fuse_resolve_and_resume(state, fuse_opendir_resume);
 }
 
 unsigned char
-d_type_from_stat (struct iatt *buf)
+d_type_from_stat(struct iatt *buf)
 {
-        unsigned char d_type;
+    unsigned char d_type;
 
-        if (IA_ISLNK (buf->ia_type)) {
-                d_type = DT_LNK;
+    if (IA_ISLNK(buf->ia_type)) {
+        d_type = DT_LNK;
 
-        } else if (IA_ISDIR (buf->ia_type)) {
-                d_type = DT_DIR;
+    } else if (IA_ISDIR(buf->ia_type)) {
+        d_type = DT_DIR;
 
-        } else if (IA_ISFIFO (buf->ia_type)) {
-                d_type = DT_FIFO;
+    } else if (IA_ISFIFO(buf->ia_type)) {
+        d_type = DT_FIFO;
 
-        } else if (IA_ISSOCK (buf->ia_type)) {
-                d_type = DT_SOCK;
+    } else if (IA_ISSOCK(buf->ia_type)) {
+        d_type = DT_SOCK;
 
-        } else if (IA_ISCHR (buf->ia_type)) {
-                d_type = DT_CHR;
+    } else if (IA_ISCHR(buf->ia_type)) {
+        d_type = DT_CHR;
 
-        } else if (IA_ISBLK (buf->ia_type)) {
-                d_type = DT_BLK;
+    } else if (IA_ISBLK(buf->ia_type)) {
+        d_type = DT_BLK;
 
-        } else if (IA_ISREG (buf->ia_type)) {
-                d_type = DT_REG;
+    } else if (IA_ISREG(buf->ia_type)) {
+        d_type = DT_REG;
 
-        } else {
-                d_type = DT_UNKNOWN;
-        }
+    } else {
+        d_type = DT_UNKNOWN;
+    }
 
-        return d_type;
+    return d_type;
 }
 
 static int
-fuse_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)
+fuse_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)
 {
-        fuse_state_t *state = NULL;
-        fuse_in_header_t *finh = NULL;
-        size_t        size = 0;
-        size_t        max_size = 0;
-        char         *buf = NULL;
-        gf_dirent_t  *entry = NULL;
-        struct fuse_dirent *fde = NULL;
-        fuse_private_t *priv = NULL;
-
-        state = frame->root->state;
-        finh  = state->finh;
-        priv = state->this->private;
-
-        fuse_log_eh_fop(this, state, frame, op_ret, op_errno);
+    fuse_state_t *state = NULL;
+    fuse_in_header_t *finh = NULL;
+    size_t size = 0;
+    size_t max_size = 0;
+    char *buf = NULL;
+    gf_dirent_t *entry = NULL;
+    struct fuse_dirent *fde = NULL;
+    fuse_private_t *priv = NULL;
 
-        if (op_ret < 0) {
-                gf_log ("glusterfs-fuse", GF_LOG_WARNING,
-                        "%"PRIu64": READDIR => -1 (%s)", frame->root->unique,
-                        strerror (op_errno));
+    state = frame->root->state;
+    finh = state->finh;
+    priv = state->this->private;
 
-                send_fuse_err (this, finh, op_errno);
-                goto out;
-        }
-
-        gf_log ("glusterfs-fuse", GF_LOG_TRACE,
-                "%"PRIu64": READDIR => %d/%"GF_PRI_SIZET",%"PRId64,
-                frame->root->unique, op_ret, state->size, state->off);
-
-        list_for_each_entry (entry, &entries->list, list) {
-                size_t fde_size = FUSE_DIRENT_ALIGN (FUSE_NAME_OFFSET +
-                                                     strlen (entry->d_name));
-                max_size += fde_size;
-
-                if (max_size > state->size) {
-                        /* we received too many entries to fit in the reply */
-                        max_size -= fde_size;
-                        break;
-                }
-        }
-
-        if (max_size == 0) {
-                send_fuse_data (this, finh, 0, 0);
-                goto out;
-        }
-
-        buf = GF_CALLOC (1, max_size, gf_fuse_mt_char);
-        if (!buf) {
-                gf_log ("glusterfs-fuse", GF_LOG_DEBUG,
-                        "%"PRIu64": READDIR => -1 (%s)", frame->root->unique,
-                        strerror (ENOMEM));
-                send_fuse_err (this, finh, ENOMEM);
-                goto out;
-        }
+    fuse_log_eh_fop(this, state, frame, op_ret, op_errno);
 
-        size = 0;
-        list_for_each_entry (entry, &entries->list, list) {
-                fde = (struct fuse_dirent *)(buf + size);
-                gf_fuse_fill_dirent (entry, fde, priv->enable_ino32);
-                size += FUSE_DIRENT_SIZE (fde);
+    if (op_ret < 0) {
+        gf_log("glusterfs-fuse", GF_LOG_WARNING,
+               "%" PRIu64 ": READDIR => -1 (%s)", frame->root->unique,
+               strerror(op_errno));
 
-                if (size == max_size)
-                        break;
-        }
-
-        send_fuse_data (this, finh, buf, size);
-
-        /* TODO: */
-        /* gf_link_inodes_from_dirent (this, state->fd->inode, entries); */
+        send_fuse_err(this, finh, op_errno);
+        goto out;
+    }
+
+    gf_log("glusterfs-fuse", GF_LOG_TRACE,
+           "%" PRIu64 ": READDIR => %d/%" GF_PRI_SIZET ",%" PRId64,
+           frame->root->unique, op_ret, state->size, state->off);
+
+    list_for_each_entry(entry, &entries->list, list)
+    {
+        size_t fde_size = FUSE_DIRENT_ALIGN(FUSE_NAME_OFFSET +
+                                            strlen(entry->d_name));
+        max_size += fde_size;
+
+        if (max_size > state->size) {
+            /* we received too many entries to fit in the reply */
+            max_size -= fde_size;
+            break;
+        }
+    }
+
+    if (max_size == 0) {
+        send_fuse_data(this, finh, 0, 0);
+        goto out;
+    }
+
+    buf = GF_CALLOC(1, max_size, gf_fuse_mt_char);
+    if (!buf) {
+        gf_log("glusterfs-fuse", GF_LOG_DEBUG,
+               "%" PRIu64 ": READDIR => -1 (%s)", frame->root->unique,
+               strerror(ENOMEM));
+        send_fuse_err(this, finh, ENOMEM);
+        goto out;
+    }
+
+    size = 0;
+    list_for_each_entry(entry, &entries->list, list)
+    {
+        fde = (struct fuse_dirent *)(buf + size);
+        gf_fuse_fill_dirent(entry, fde, priv->enable_ino32);
+        size += FUSE_DIRENT_SIZE(fde);
+
+        if (size == max_size)
+            break;
+    }
+
+    send_fuse_data(this, finh, buf, size);
+
+    /* TODO: */
+    /* gf_link_inodes_from_dirent (this, state->fd->inode, entries); */
 
 out:
-        free_fuse_state (state);
-        STACK_DESTROY (frame->root);
-        GF_FREE (buf);
-        return 0;
-
+    free_fuse_state(state);
+    STACK_DESTROY(frame->root);
+    GF_FREE(buf);
+    return 0;
 }
 
 void
-fuse_readdir_resume (fuse_state_t *state)
+fuse_readdir_resume(fuse_state_t *state)
 {
-        gf_log ("glusterfs-fuse", GF_LOG_TRACE,
-                "%"PRIu64": READDIR (%p, size=%"GF_PRI_SIZET", offset=%"PRId64")",
-                state->finh->unique, state->fd, state->size, state->off);
+    gf_log("glusterfs-fuse", GF_LOG_TRACE,
+           "%" PRIu64 ": READDIR (%p, size=%" GF_PRI_SIZET ", offset=%" PRId64
+           ")",
+           state->finh->unique, state->fd, state->size, state->off);
 
-        FUSE_FOP (state, fuse_readdir_cbk, GF_FOP_READDIR,
-                  readdir, state->fd, state->size, state->off, state->xdata);
+    FUSE_FOP(state, fuse_readdir_cbk, GF_FOP_READDIR, readdir, state->fd,
+             state->size, state->off, state->xdata);
 }
 
 static void
-fuse_readdir (xlator_t *this, fuse_in_header_t *finh, void *msg,
-              struct iobuf *iobuf)
+fuse_readdir(xlator_t *this, fuse_in_header_t *finh, void *msg,
+             struct iobuf *iobuf)
 {
-        struct fuse_read_in *fri = msg;
+    struct fuse_read_in *fri = msg;
 
-        fuse_state_t *state = NULL;
-        fd_t         *fd = NULL;
+    fuse_state_t *state = NULL;
+    fd_t *fd = NULL;
 
-        GET_STATE (this, finh, state);
-        state->size = fri->size;
-        state->off = fri->offset;
-        fd = FH_TO_FD (fri->fh);
-        state->fd = fd;
+    GET_STATE(this, finh, state);
+    state->size = fri->size;
+    state->off = fri->offset;
+    fd = FH_TO_FD(fri->fh);
+    state->fd = fd;
 
-        fuse_resolve_fd_init (state, &state->resolve, fd);
+    fuse_resolve_fd_init(state, &state->resolve, fd);
 
-        fuse_resolve_and_resume (state, fuse_readdir_resume);
+    fuse_resolve_and_resume(state, fuse_readdir_resume);
 }
 
 #if FUSE_KERNEL_MINOR_VERSION >= 20
 static int
-fuse_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)
-{
-	fuse_state_t *state = NULL;
-	fuse_in_header_t *finh = NULL;
-        size_t        max_size = 0;
-        size_t        size = 0;
-	char         *buf = NULL;
-	gf_dirent_t  *entry = NULL;
-	struct fuse_direntplus *fde = NULL;
-	struct fuse_entry_out *feo = NULL;
-	fuse_private_t         *priv   = NULL;
-
-	state = frame->root->state;
-	finh  = state->finh;
-	priv = this->private;
-
-	if (op_ret < 0) {
-		gf_log ("glusterfs-fuse", GF_LOG_WARNING,
-			"%"PRIu64": READDIRP => -1 (%s)", frame->root->unique,
-			strerror (op_errno));
-
-		send_fuse_err (this, finh, op_errno);
-		goto out;
-	}
-
-	gf_log ("glusterfs-fuse", GF_LOG_TRACE,
-		"%"PRIu64": READDIRP => %d/%"GF_PRI_SIZET",%"PRId64,
-		frame->root->unique, op_ret, state->size, state->off);
-
-	list_for_each_entry (entry, &entries->list, list) {
-                size_t fdes = FUSE_DIRENT_ALIGN (FUSE_NAME_OFFSET_DIRENTPLUS +
-                                                 strlen (entry->d_name));
-                max_size += fdes;
-
-                if (max_size > state->size) {
-                        /* we received too many entries to fit in the reply */
-                        max_size -= fdes;
-                        break;
-                }
-	}
-
-	if (max_size == 0) {
-		send_fuse_data (this, finh, 0, 0);
-		goto out;
-	}
-
-	buf = GF_CALLOC (1, max_size, gf_fuse_mt_char);
-	if (!buf) {
-		gf_log ("glusterfs-fuse", GF_LOG_DEBUG,
-			"%"PRIu64": READDIRP => -1 (%s)", frame->root->unique,
-			strerror (ENOMEM));
-		send_fuse_err (this, finh, ENOMEM);
-		goto out;
-	}
-
-	size = 0;
-	list_for_each_entry (entry, &entries->list, list) {
-		inode_t *linked_inode;
-
-		fde = (struct fuse_direntplus *)(buf + size);
-		feo = &fde->entry_out;
-
-		if (priv->enable_ino32)
-			fde->dirent.ino = GF_FUSE_SQUASH_INO(entry->d_ino);
-		else
-			fde->dirent.ino = entry->d_ino;
-
-		fde->dirent.off = entry->d_off;
-		fde->dirent.type = entry->d_type;
-		fde->dirent.namelen = strlen (entry->d_name);
-		strncpy (fde->dirent.name, entry->d_name, fde->dirent.namelen);
-		size += FUSE_DIRENTPLUS_SIZE (fde);
-
-		if (!entry->inode)
-			goto next_entry;
-
-		entry->d_stat.ia_blksize = this->ctx->page_size;
-		gf_fuse_stat2attr (&entry->d_stat, &feo->attr, priv->enable_ino32);
-
-		linked_inode = inode_link (entry->inode, state->fd->inode,
-					   entry->d_name, &entry->d_stat);
-		if (!linked_inode)
-			goto next_entry;
-
-                if (entry->inode != linked_inode) {
-                        memset (&entry->d_stat, 0, sizeof (entry->d_stat));
-                }
+fuse_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)
+{
+    fuse_state_t *state = NULL;
+    fuse_in_header_t *finh = NULL;
+    size_t max_size = 0;
+    size_t size = 0;
+    char *buf = NULL;
+    gf_dirent_t *entry = NULL;
+    struct fuse_direntplus *fde = NULL;
+    struct fuse_entry_out *feo = NULL;
+    fuse_private_t *priv = NULL;
+
+    state = frame->root->state;
+    finh = state->finh;
+    priv = this->private;
+
+    if (op_ret < 0) {
+        gf_log("glusterfs-fuse", GF_LOG_WARNING,
+               "%" PRIu64 ": READDIRP => -1 (%s)", frame->root->unique,
+               strerror(op_errno));
+
+        send_fuse_err(this, finh, op_errno);
+        goto out;
+    }
+
+    gf_log("glusterfs-fuse", GF_LOG_TRACE,
+           "%" PRIu64 ": READDIRP => %d/%" GF_PRI_SIZET ",%" PRId64,
+           frame->root->unique, op_ret, state->size, state->off);
+
+    list_for_each_entry(entry, &entries->list, list)
+    {
+        size_t fdes = FUSE_DIRENT_ALIGN(FUSE_NAME_OFFSET_DIRENTPLUS +
+                                        strlen(entry->d_name));
+        max_size += fdes;
+
+        if (max_size > state->size) {
+            /* we received too many entries to fit in the reply */
+            max_size -= fdes;
+            break;
+        }
+    }
+
+    if (max_size == 0) {
+        send_fuse_data(this, finh, 0, 0);
+        goto out;
+    }
+
+    buf = GF_CALLOC(1, max_size, gf_fuse_mt_char);
+    if (!buf) {
+        gf_log("glusterfs-fuse", GF_LOG_DEBUG,
+               "%" PRIu64 ": READDIRP => -1 (%s)", frame->root->unique,
+               strerror(ENOMEM));
+        send_fuse_err(this, finh, ENOMEM);
+        goto out;
+    }
+
+    size = 0;
+    list_for_each_entry(entry, &entries->list, list)
+    {
+        inode_t *linked_inode;
+
+        fde = (struct fuse_direntplus *)(buf + size);
+        feo = &fde->entry_out;
+
+        if (priv->enable_ino32)
+            fde->dirent.ino = GF_FUSE_SQUASH_INO(entry->d_ino);
+        else
+            fde->dirent.ino = entry->d_ino;
 
-		feo->nodeid = inode_to_fuse_nodeid (linked_inode);
+        fde->dirent.off = entry->d_off;
+        fde->dirent.type = entry->d_type;
+        fde->dirent.namelen = strlen(entry->d_name);
+        strncpy(fde->dirent.name, entry->d_name, fde->dirent.namelen);
+        size += FUSE_DIRENTPLUS_SIZE(fde);
 
-                if (!((strcmp (entry->d_name, ".") == 0) ||
-                      (strcmp (entry->d_name, "..") == 0))) {
-                        inode_lookup (linked_inode);
-                }
+        if (!entry->inode)
+            goto next_entry;
 
-		inode_unref (linked_inode);
+        entry->d_stat.ia_blksize = this->ctx->page_size;
+        gf_fuse_stat2attr(&entry->d_stat, &feo->attr, priv->enable_ino32);
 
-		feo->entry_valid =
-			calc_timeout_sec (priv->entry_timeout);
-		feo->entry_valid_nsec =
-			calc_timeout_nsec (priv->entry_timeout);
+        linked_inode = inode_link(entry->inode, state->fd->inode, entry->d_name,
+                                  &entry->d_stat);
+        if (!linked_inode)
+            goto next_entry;
 
-                if (entry->d_stat.ia_ctime) {
-                        feo->attr_valid =
-                                calc_timeout_sec (priv->attribute_timeout);
-                        feo->attr_valid_nsec =
-                                calc_timeout_nsec (priv->attribute_timeout);
-                } else {
-                        feo->attr_valid = feo->attr_valid_nsec = 0;
-                }
+        if (entry->inode != linked_inode) {
+            memset(&entry->d_stat, 0, sizeof(entry->d_stat));
+        }
 
-next_entry:
-                if (size == max_size)
-                        break;
-	}
+        feo->nodeid = inode_to_fuse_nodeid(linked_inode);
 
-	send_fuse_data (this, finh, buf, size);
-out:
-	free_fuse_state (state);
-	STACK_DESTROY (frame->root);
-	GF_FREE (buf);
-	return 0;
+        if (!((strcmp(entry->d_name, ".") == 0) ||
+              (strcmp(entry->d_name, "..") == 0))) {
+            inode_lookup(linked_inode);
+        }
 
+        inode_unref(linked_inode);
+
+        feo->entry_valid = calc_timeout_sec(priv->entry_timeout);
+        feo->entry_valid_nsec = calc_timeout_nsec(priv->entry_timeout);
+
+        if (entry->d_stat.ia_ctime) {
+            feo->attr_valid = calc_timeout_sec(priv->attribute_timeout);
+            feo->attr_valid_nsec = calc_timeout_nsec(priv->attribute_timeout);
+        } else {
+            feo->attr_valid = feo->attr_valid_nsec = 0;
+        }
+
+    next_entry:
+        if (size == max_size)
+            break;
+    }
+
+    send_fuse_data(this, finh, buf, size);
+out:
+    free_fuse_state(state);
+    STACK_DESTROY(frame->root);
+    GF_FREE(buf);
+    return 0;
 }
 
 void
-fuse_readdirp_resume (fuse_state_t *state)
+fuse_readdirp_resume(fuse_state_t *state)
 {
-	gf_log ("glusterfs-fuse", GF_LOG_TRACE,
-		"%"PRIu64": READDIRP (%p, size=%"GF_PRI_SIZET", offset=%"PRId64")",
-		state->finh->unique, state->fd, state->size, state->off);
+    gf_log("glusterfs-fuse", GF_LOG_TRACE,
+           "%" PRIu64 ": READDIRP (%p, size=%" GF_PRI_SIZET ", offset=%" PRId64
+           ")",
+           state->finh->unique, state->fd, state->size, state->off);
 
-	FUSE_FOP (state, fuse_readdirp_cbk, GF_FOP_READDIRP,
-		  readdirp, state->fd, state->size, state->off, state->xdata);
+    FUSE_FOP(state, fuse_readdirp_cbk, GF_FOP_READDIRP, readdirp, state->fd,
+             state->size, state->off, state->xdata);
 }
 
-
 static void
-fuse_readdirp (xlator_t *this, fuse_in_header_t *finh, void *msg,
-               struct iobuf *iobuf)
+fuse_readdirp(xlator_t *this, fuse_in_header_t *finh, void *msg,
+              struct iobuf *iobuf)
 {
-	struct fuse_read_in *fri = msg;
+    struct fuse_read_in *fri = msg;
 
-	fuse_state_t *state = NULL;
-	fd_t         *fd = NULL;
+    fuse_state_t *state = NULL;
+    fd_t *fd = NULL;
 
-	GET_STATE (this, finh, state);
-	state->size = fri->size;
-	state->off = fri->offset;
-	fd = FH_TO_FD (fri->fh);
-	state->fd = fd;
+    GET_STATE(this, finh, state);
+    state->size = fri->size;
+    state->off = fri->offset;
+    fd = FH_TO_FD(fri->fh);
+    state->fd = fd;
 
-	fuse_resolve_fd_init (state, &state->resolve, fd);
+    fuse_resolve_fd_init(state, &state->resolve, fd);
 
-	fuse_resolve_and_resume (state, fuse_readdirp_resume);
+    fuse_resolve_and_resume(state, fuse_readdirp_resume);
 }
 #endif
 
@@ -3143,367 +3091,360 @@ fuse_readdirp (xlator_t *this, fuse_in_header_t *finh, void *msg,
 #ifdef FALLOC_FL_KEEP_SIZE
 static int
 fuse_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 op_ret, int32_t op_errno, struct iatt *prebuf,
+                   struct iatt *postbuf, dict_t *xdata)
 {
-	return fuse_err_cbk(frame, cookie, this, op_ret, op_errno, xdata);
+    return fuse_err_cbk(frame, cookie, this, op_ret, op_errno, xdata);
 }
 
 static void
 fuse_fallocate_resume(fuse_state_t *state)
 {
-	gf_log("glusterfs-fuse", GF_LOG_TRACE,
-	       "%"PRIu64": FALLOCATE (%p, flags=%d, size=%zu, offset=%"PRId64")",
-	       state->finh->unique, state->fd, state->flags, state->size,
-	       state->off);
+    gf_log(
+        "glusterfs-fuse", GF_LOG_TRACE,
+        "%" PRIu64 ": FALLOCATE (%p, flags=%d, size=%zu, offset=%" PRId64 ")",
+        state->finh->unique, state->fd, state->flags, state->size, state->off);
 
-	if (state->flags & FALLOC_FL_PUNCH_HOLE)
-		FUSE_FOP(state, fuse_fallocate_cbk, GF_FOP_DISCARD, discard,
-			 state->fd, state->off, state->size, state->xdata);
-	else
-		FUSE_FOP(state, fuse_fallocate_cbk, GF_FOP_FALLOCATE, fallocate,
-			 state->fd, (state->flags & FALLOC_FL_KEEP_SIZE),
-			 state->off, state->size, state->xdata);
+    if (state->flags & FALLOC_FL_PUNCH_HOLE)
+        FUSE_FOP(state, fuse_fallocate_cbk, GF_FOP_DISCARD, discard, state->fd,
+                 state->off, state->size, state->xdata);
+    else
+        FUSE_FOP(state, fuse_fallocate_cbk, GF_FOP_FALLOCATE, fallocate,
+                 state->fd, (state->flags & FALLOC_FL_KEEP_SIZE), state->off,
+                 state->size, state->xdata);
 }
 
 static void
 fuse_fallocate(xlator_t *this, fuse_in_header_t *finh, void *msg,
                struct iobuf *iobuf)
 {
-	struct fuse_fallocate_in *ffi = msg;
-	fuse_state_t *state = NULL;
+    struct fuse_fallocate_in *ffi = msg;
+    fuse_state_t *state = NULL;
 
-	GET_STATE(this, finh, state);
-	state->off = ffi->offset;
-	state->size = ffi->length;
-	state->flags = ffi->mode;
-	state->fd = FH_TO_FD(ffi->fh);
+    GET_STATE(this, finh, state);
+    state->off = ffi->offset;
+    state->size = ffi->length;
+    state->flags = ffi->mode;
+    state->fd = FH_TO_FD(ffi->fh);
 
-	fuse_resolve_fd_init(state, &state->resolve, state->fd);
-	fuse_resolve_and_resume(state, fuse_fallocate_resume);
+    fuse_resolve_fd_init(state, &state->resolve, state->fd);
+    fuse_resolve_and_resume(state, fuse_fallocate_resume);
 }
 #endif /* FALLOC_FL_KEEP_SIZE */
 #endif /* FUSE minor version >= 19 */
 
 static void
-fuse_releasedir (xlator_t *this, fuse_in_header_t *finh, void *msg,
-                 struct iobuf *iobuf)
+fuse_releasedir(xlator_t *this, fuse_in_header_t *finh, void *msg,
+                struct iobuf *iobuf)
 {
-        struct fuse_release_in *fri       = msg;
-        fuse_state_t           *state     = NULL;
-        fuse_private_t         *priv      = NULL;
+    struct fuse_release_in *fri = msg;
+    fuse_state_t *state = NULL;
+    fuse_private_t *priv = NULL;
 
-        GET_STATE (this, finh, state);
-        state->fd = FH_TO_FD (fri->fh);
+    GET_STATE(this, finh, state);
+    state->fd = FH_TO_FD(fri->fh);
 
-        priv = this->private;
+    priv = this->private;
 
-        fuse_log_eh (this, "RELEASEDIR (): %"PRIu64": fd: %p, gfid: %s",
-                     finh->unique, state->fd,
-                     uuid_utoa (state->fd->inode->gfid));
+    fuse_log_eh(this, "RELEASEDIR (): %" PRIu64 ": fd: %p, gfid: %s",
+                finh->unique, state->fd, uuid_utoa(state->fd->inode->gfid));
 
-        gf_log ("glusterfs-fuse", GF_LOG_TRACE,
-                "%"PRIu64": RELEASEDIR %p", finh->unique, state->fd);
+    gf_log("glusterfs-fuse", GF_LOG_TRACE, "%" PRIu64 ": RELEASEDIR %p",
+           finh->unique, state->fd);
 
-        fuse_fd_ctx_destroy(this, state->fd);
-        fd_unref (state->fd);
+    fuse_fd_ctx_destroy(this, state->fd);
+    fd_unref(state->fd);
 
-        gf_fdptr_put (priv->fdtable, state->fd);
+    gf_fdptr_put(priv->fdtable, state->fd);
 
-        state->fd = NULL;
+    state->fd = NULL;
 
-        send_fuse_err (this, finh, 0);
+    send_fuse_err(this, finh, 0);
 
-        free_fuse_state (state);
+    free_fuse_state(state);
 
-        return;
+    return;
 }
 
 void
-fuse_fsyncdir_resume (fuse_state_t *state)
+fuse_fsyncdir_resume(fuse_state_t *state)
 {
-        FUSE_FOP (state, fuse_err_cbk, GF_FOP_FSYNCDIR,
-                  fsyncdir, state->fd, (state->flags & 1), state->xdata);
-
+    FUSE_FOP(state, fuse_err_cbk, GF_FOP_FSYNCDIR, fsyncdir, state->fd,
+             (state->flags & 1), state->xdata);
 }
 
 static void
-fuse_fsyncdir (xlator_t *this, fuse_in_header_t *finh, void *msg,
-               struct iobuf *iobuf)
+fuse_fsyncdir(xlator_t *this, fuse_in_header_t *finh, void *msg,
+              struct iobuf *iobuf)
 {
-        struct fuse_fsync_in *fsi = msg;
+    struct fuse_fsync_in *fsi = msg;
 
-        fuse_state_t *state = NULL;
-        fd_t         *fd = NULL;
+    fuse_state_t *state = NULL;
+    fd_t *fd = NULL;
 
-        fd = FH_TO_FD (fsi->fh);
+    fd = FH_TO_FD(fsi->fh);
 
-        GET_STATE (this, finh, state);
-        state->fd = fd;
+    GET_STATE(this, finh, state);
+    state->fd = fd;
 
-        fuse_resolve_fd_init (state, &state->resolve, fd);
+    fuse_resolve_fd_init(state, &state->resolve, fd);
 
-        state->flags = fsi->fsync_flags;
-        fuse_resolve_and_resume (state, fuse_fsyncdir_resume);
+    state->flags = fsi->fsync_flags;
+    fuse_resolve_and_resume(state, fuse_fsyncdir_resume);
 
-        return;
+    return;
 }
 
 static int
-fuse_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)
+fuse_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)
 {
-        fuse_state_t *state = NULL;
-        fuse_in_header_t *finh = NULL;
-        fuse_private_t   *priv = NULL;
-        struct fuse_statfs_out fso = {{0, }, };
-
-        state = frame->root->state;
-        priv  = this->private;
-        finh  = state->finh;
-
-        fuse_log_eh (this, "op_ret: %d, op_errno: %d, %"PRIu64": %s()",
-                     op_ret, op_errno, frame->root->unique,
-                     gf_fop_list[frame->root->op]);
-
-        if (op_ret == 0) {
-                fso.st.bsize   = buf->f_bsize;
-                fso.st.frsize  = buf->f_frsize;
-                fso.st.blocks  = buf->f_blocks;
-                fso.st.bfree   = buf->f_bfree;
-                fso.st.bavail  = buf->f_bavail;
-                fso.st.files   = buf->f_files;
-                fso.st.ffree   = buf->f_ffree;
-                fso.st.namelen = buf->f_namemax;
-
-                priv->proto_minor >= 4 ?
-                send_fuse_obj (this, finh, &fso) :
-                send_fuse_data (this, finh, &fso, FUSE_COMPAT_STATFS_SIZE);
-        } else {
-                gf_log ("glusterfs-fuse", GF_LOG_WARNING,
-                        "%"PRIu64": ERR => -1 (%s)", frame->root->unique,
-                        strerror (op_errno));
-                send_fuse_err (this, finh, op_errno);
-        }
+    fuse_state_t *state = NULL;
+    fuse_in_header_t *finh = NULL;
+    fuse_private_t *priv = NULL;
+    struct fuse_statfs_out fso = {
+        {
+            0,
+        },
+    };
+
+    state = frame->root->state;
+    priv = this->private;
+    finh = state->finh;
+
+    fuse_log_eh(this, "op_ret: %d, op_errno: %d, %" PRIu64 ": %s()", op_ret,
+                op_errno, frame->root->unique, gf_fop_list[frame->root->op]);
+
+    if (op_ret == 0) {
+        fso.st.bsize = buf->f_bsize;
+        fso.st.frsize = buf->f_frsize;
+        fso.st.blocks = buf->f_blocks;
+        fso.st.bfree = buf->f_bfree;
+        fso.st.bavail = buf->f_bavail;
+        fso.st.files = buf->f_files;
+        fso.st.ffree = buf->f_ffree;
+        fso.st.namelen = buf->f_namemax;
+
+        priv->proto_minor >= 4
+            ? send_fuse_obj(this, finh, &fso)
+            : send_fuse_data(this, finh, &fso, FUSE_COMPAT_STATFS_SIZE);
+    } else {
+        gf_log("glusterfs-fuse", GF_LOG_WARNING, "%" PRIu64 ": ERR => -1 (%s)",
+               frame->root->unique, strerror(op_errno));
+        send_fuse_err(this, finh, op_errno);
+    }
 
-        free_fuse_state (state);
-        STACK_DESTROY (frame->root);
+    free_fuse_state(state);
+    STACK_DESTROY(frame->root);
 
-        return 0;
+    return 0;
 }
 
 void
-fuse_statfs_resume (fuse_state_t *state)
+fuse_statfs_resume(fuse_state_t *state)
 {
-        if (!state->loc.inode) {
-                gf_log ("glusterfs-fuse", GF_LOG_WARNING,
-                        "%"PRIu64": STATFS (%s) resolution fail",
-                        state->finh->unique, uuid_utoa (state->resolve.gfid));
+    if (!state->loc.inode) {
+        gf_log("glusterfs-fuse", GF_LOG_WARNING,
+               "%" PRIu64 ": STATFS (%s) resolution fail", state->finh->unique,
+               uuid_utoa(state->resolve.gfid));
 
-                send_fuse_err (state->this, state->finh,
-                               state->resolve.op_errno);
-                free_fuse_state (state);
-                return;
-        }
+        send_fuse_err(state->this, state->finh, state->resolve.op_errno);
+        free_fuse_state(state);
+        return;
+    }
 
-        gf_log ("glusterfs-fuse", GF_LOG_TRACE,
-                "%"PRIu64": STATFS", state->finh->unique);
+    gf_log("glusterfs-fuse", GF_LOG_TRACE, "%" PRIu64 ": STATFS",
+           state->finh->unique);
 
-        FUSE_FOP (state, fuse_statfs_cbk, GF_FOP_STATFS,
-                  statfs, &state->loc, state->xdata);
+    FUSE_FOP(state, fuse_statfs_cbk, GF_FOP_STATFS, statfs, &state->loc,
+             state->xdata);
 }
 
-
 static void
-fuse_statfs (xlator_t *this, fuse_in_header_t *finh, void *msg,
-             struct iobuf *iobuf)
+fuse_statfs(xlator_t *this, fuse_in_header_t *finh, void *msg,
+            struct iobuf *iobuf)
 {
-        fuse_state_t *state = NULL;
+    fuse_state_t *state = NULL;
 
-        GET_STATE (this, finh, state);
+    GET_STATE(this, finh, state);
 
-        fuse_resolve_inode_init (state, &state->resolve, finh->nodeid);
+    fuse_resolve_inode_init(state, &state->resolve, finh->nodeid);
 
-        fuse_resolve_and_resume (state, fuse_statfs_resume);
+    fuse_resolve_and_resume(state, fuse_statfs_resume);
 }
 
-
 void
-fuse_setxattr_resume (fuse_state_t *state)
-{
-        if (!state->loc.inode) {
-                gf_log ("glusterfs-fuse", GF_LOG_WARNING,
-                        "%"PRIu64": SETXATTR %s/%"PRIu64" (%s) "
-                        "resolution failed",
-                        state->finh->unique, uuid_utoa (state->resolve.gfid),
-                        state->finh->nodeid, state->name);
-                send_fuse_err (state->this, state->finh,
-                               state->resolve.op_errno);
-                free_fuse_state (state);
-                return;
-        }
+fuse_setxattr_resume(fuse_state_t *state)
+{
+    if (!state->loc.inode) {
+        gf_log("glusterfs-fuse", GF_LOG_WARNING,
+               "%" PRIu64 ": SETXATTR %s/%" PRIu64
+               " (%s) "
+               "resolution failed",
+               state->finh->unique, uuid_utoa(state->resolve.gfid),
+               state->finh->nodeid, state->name);
+        send_fuse_err(state->this, state->finh, state->resolve.op_errno);
+        free_fuse_state(state);
+        return;
+    }
 
 #ifdef GF_TEST_FFOP
-        state->fd = fd_lookup (state->loc.inode, state->finh->pid);
+    state->fd = fd_lookup(state->loc.inode, state->finh->pid);
 #endif /* GF_TEST_FFOP */
 
-        if (state->fd) {
-                gf_log ("glusterfs-fuse", GF_LOG_TRACE,
-                        "%"PRIu64": SETXATTR %p/%"PRIu64" (%s)", state->finh->unique,
-                        state->fd, state->finh->nodeid, state->name);
+    if (state->fd) {
+        gf_log("glusterfs-fuse", GF_LOG_TRACE,
+               "%" PRIu64 ": SETXATTR %p/%" PRIu64 " (%s)", state->finh->unique,
+               state->fd, state->finh->nodeid, state->name);
 
-                FUSE_FOP (state, fuse_setxattr_cbk, GF_FOP_FSETXATTR,
-                          fsetxattr, state->fd, state->xattr, state->flags,
-                          state->xdata);
-        } else {
-                gf_log ("glusterfs-fuse", GF_LOG_TRACE,
-                        "%"PRIu64": SETXATTR %s/%"PRIu64" (%s)", state->finh->unique,
-                        state->loc.path, state->finh->nodeid, state->name);
+        FUSE_FOP(state, fuse_setxattr_cbk, GF_FOP_FSETXATTR, fsetxattr,
+                 state->fd, state->xattr, state->flags, state->xdata);
+    } else {
+        gf_log("glusterfs-fuse", GF_LOG_TRACE,
+               "%" PRIu64 ": SETXATTR %s/%" PRIu64 " (%s)", state->finh->unique,
+               state->loc.path, state->finh->nodeid, state->name);
 
-                FUSE_FOP (state, fuse_setxattr_cbk, GF_FOP_SETXATTR,
-                          setxattr, &state->loc, state->xattr, state->flags,
-                          state->xdata);
-        }
+        FUSE_FOP(state, fuse_setxattr_cbk, GF_FOP_SETXATTR, setxattr,
+                 &state->loc, state->xattr, state->flags, state->xdata);
+    }
 }
 
-
 static void
-fuse_setxattr (xlator_t *this, fuse_in_header_t *finh, void *msg,
-               struct iobuf *iobuf)
+fuse_setxattr(xlator_t *this, fuse_in_header_t *finh, void *msg,
+              struct iobuf *iobuf)
 {
-        struct fuse_setxattr_in *fsi = msg;
-        char         *name = (char *)(fsi + 1);
-        char         *value = name + strlen (name) + 1;
-        struct fuse_private *priv = NULL;
+    struct fuse_setxattr_in *fsi = msg;
+    char *name = (char *)(fsi + 1);
+    char *value = name + strlen(name) + 1;
+    struct fuse_private *priv = NULL;
 
-        fuse_state_t *state = NULL;
-        char         *dict_value = NULL;
-        int32_t       ret = -1;
-        int32_t       op_errno = 0;
-        char *newkey = NULL;
+    fuse_state_t *state = NULL;
+    char *dict_value = NULL;
+    int32_t ret = -1;
+    int32_t op_errno = 0;
+    char *newkey = NULL;
 
-        priv = this->private;
+    priv = this->private;
 
-        GET_STATE (this, finh, state);
+    GET_STATE(this, finh, state);
 
 #ifdef GF_DARWIN_HOST_OS
-        if (fsi->position) {
-                gf_log ("glusterfs-fuse", GF_LOG_WARNING,
-                        "%"PRIu64": SETXATTR %s/%"PRIu64" (%s):"
-                        "refusing positioned setxattr",
-                        finh->unique, state->loc.path, finh->nodeid, name);
-                op_errno = EINVAL;
-                goto done;
-        }
+    if (fsi->position) {
+        gf_log("glusterfs-fuse", GF_LOG_WARNING,
+               "%" PRIu64 ": SETXATTR %s/%" PRIu64
+               " (%s):"
+               "refusing positioned setxattr",
+               finh->unique, state->loc.path, finh->nodeid, name);
+        op_errno = EINVAL;
+        goto done;
+    }
 #endif
 
-        if (fuse_ignore_xattr_set (priv, name)) {
-                goto done;
-        }
-
-        if (!priv->acl) {
-                if ((strcmp (name, POSIX_ACL_ACCESS_XATTR) == 0) ||
-                    (strcmp (name, POSIX_ACL_DEFAULT_XATTR) == 0)) {
-                        op_errno = EOPNOTSUPP;
-                        goto done;
-                }
-        }
-
-        ret = fuse_check_selinux_cap_xattr (priv, name);
-        if (ret) {
-                op_errno = EOPNOTSUPP;
-                goto done;
-        }
-
-        /* Check if the command is for changing the log
-           level of process or specific xlator */
-        ret = is_gf_log_command (this, name, value);
-        if (ret >= 0) {
-                op_errno = ret;
-                goto done;
-        }
-
-        if (!strcmp ("inode-invalidate", name)) {
-                gf_log ("fuse", GF_LOG_TRACE,
-                        "got request to invalidate %"PRIu64, finh->nodeid);
+    if (fuse_ignore_xattr_set(priv, name)) {
+        goto done;
+    }
+
+    if (!priv->acl) {
+        if ((strcmp(name, POSIX_ACL_ACCESS_XATTR) == 0) ||
+            (strcmp(name, POSIX_ACL_DEFAULT_XATTR) == 0)) {
+            op_errno = EOPNOTSUPP;
+            goto done;
+        }
+    }
+
+    ret = fuse_check_selinux_cap_xattr(priv, name);
+    if (ret) {
+        op_errno = EOPNOTSUPP;
+        goto done;
+    }
+
+    /* Check if the command is for changing the log
+       level of process or specific xlator */
+    ret = is_gf_log_command(this, name, value);
+    if (ret >= 0) {
+        op_errno = ret;
+        goto done;
+    }
+
+    if (!strcmp("inode-invalidate", name)) {
+        gf_log("fuse", GF_LOG_TRACE, "got request to invalidate %" PRIu64,
+               finh->nodeid);
 #if FUSE_KERNEL_MINOR_VERSION >= 11
-                fuse_invalidate_entry (this, finh->nodeid);
+        fuse_invalidate_entry(this, finh->nodeid);
 #endif
-                goto done;
-        }
+        goto done;
+    }
 
-        if (!strcmp (GFID_XATTR_KEY, name) || !strcmp (GF_XATTR_VOL_ID_KEY, name)) {
-                op_errno = EPERM;
-                goto done;
-        }
+    if (!strcmp(GFID_XATTR_KEY, name) || !strcmp(GF_XATTR_VOL_ID_KEY, name)) {
+        op_errno = EPERM;
+        goto done;
+    }
 
-        state->size = fsi->size;
+    state->size = fsi->size;
 
-        fuse_resolve_inode_init (state, &state->resolve, finh->nodeid);
+    fuse_resolve_inode_init(state, &state->resolve, finh->nodeid);
 
-        state->xattr = dict_new ();
-        if (!state->xattr) {
-                gf_log ("glusterfs-fuse", GF_LOG_ERROR,
-                        "%"PRIu64": SETXATTR dict allocation failed",
-                        finh->unique);
-                op_errno = ENOMEM;
-                goto done;
-        }
+    state->xattr = dict_new();
+    if (!state->xattr) {
+        gf_log("glusterfs-fuse", GF_LOG_ERROR,
+               "%" PRIu64 ": SETXATTR dict allocation failed", finh->unique);
+        op_errno = ENOMEM;
+        goto done;
+    }
 
-        ret = fuse_flip_xattr_ns (priv, name, &newkey);
-        if (ret) {
-                op_errno = ENOMEM;
-                goto done;
-        }
+    ret = fuse_flip_xattr_ns(priv, name, &newkey);
+    if (ret) {
+        op_errno = ENOMEM;
+        goto done;
+    }
 
-        if (fsi->size > 0) {
-                /*
-                 * Many translators expect setxattr values to be strings, but
-                 * neither dict_get_str nor data_to_str do any checking or
-                 * fixups to make sure that's the case.  To avoid nasty
-                 * surprises, allocate an extra byte and add a NUL here.
-                 */
-                dict_value = memdup (value, fsi->size+1);
-                dict_value[fsi->size] = '\0';
-        }
-        dict_set (state->xattr, newkey,
-                  data_from_dynptr ((void *)dict_value, fsi->size));
+    if (fsi->size > 0) {
+        /*
+         * Many translators expect setxattr values to be strings, but
+         * neither dict_get_str nor data_to_str do any checking or
+         * fixups to make sure that's the case.  To avoid nasty
+         * surprises, allocate an extra byte and add a NUL here.
+         */
+        dict_value = memdup(value, fsi->size + 1);
+        dict_value[fsi->size] = '\0';
+    }
+    dict_set(state->xattr, newkey,
+             data_from_dynptr((void *)dict_value, fsi->size));
 
-        state->flags = fsi->flags;
-        state->name = newkey;
+    state->flags = fsi->flags;
+    state->name = newkey;
 
-        fuse_resolve_and_resume (state, fuse_setxattr_resume);
+    fuse_resolve_and_resume(state, fuse_setxattr_resume);
 
-        return;
+    return;
 
 done:
-        send_fuse_err(this, finh, op_errno);
-        free_fuse_state(state);
+    send_fuse_err(this, finh, op_errno);
+    free_fuse_state(state);
 }
 
-
 static void
-send_fuse_xattr (xlator_t *this, fuse_in_header_t *finh, const char *value,
-                 size_t size, size_t expected)
-{
-        struct fuse_getxattr_out fgxo;
-
-        /* linux kernel limits the size of xattr value to 64k */
-        if (size > GLUSTERFS_XATTR_LEN_MAX)
-                send_fuse_err (this, finh, E2BIG);
-        else if (expected) {
-                /* if callback for getxattr and asks for value */
-                if (size > expected)
-                        /* reply would be bigger than
-                         * what was asked by kernel */
-                        send_fuse_err (this, finh, ERANGE);
-                else
-                        send_fuse_data (this, finh, (void *)value, size);
-        } else {
-                fgxo.size = size;
-                send_fuse_obj (this, finh, &fgxo);
-        }
+send_fuse_xattr(xlator_t *this, fuse_in_header_t *finh, const char *value,
+                size_t size, size_t expected)
+{
+    struct fuse_getxattr_out fgxo;
+
+    /* linux kernel limits the size of xattr value to 64k */
+    if (size > GLUSTERFS_XATTR_LEN_MAX)
+        send_fuse_err(this, finh, E2BIG);
+    else if (expected) {
+        /* if callback for getxattr and asks for value */
+        if (size > expected)
+            /* reply would be bigger than
+             * what was asked by kernel */
+            send_fuse_err(this, finh, ERANGE);
+        else
+            send_fuse_data(this, finh, (void *)value, size);
+    } else {
+        fgxo.size = size;
+        send_fuse_obj(this, finh, &fgxo);
+    }
 }
 
 /* filter out xattrs that need not be visible on the
@@ -3514,2665 +3455,2575 @@ send_fuse_xattr (xlator_t *this, fuse_in_header_t *finh, const char *value,
 static int
 fuse_filter_xattr(char *key)
 {
-        int need_filter = 0;
-        struct fuse_private *priv = THIS->private;
+    int need_filter = 0;
+    struct fuse_private *priv = THIS->private;
 
-        if ((priv->client_pid == GF_CLIENT_PID_GSYNCD)
-            && fnmatch ("*.selinux*", key, FNM_PERIOD) == 0)
-                need_filter = 1;
+    if ((priv->client_pid == GF_CLIENT_PID_GSYNCD) &&
+        fnmatch("*.selinux*", key, FNM_PERIOD) == 0)
+        need_filter = 1;
 
-        return need_filter;
+    return need_filter;
 }
 
-
 static int
-fuse_xattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                int32_t op_ret, int32_t op_errno, dict_t *dict, dict_t *xdata)
-{
-        char           *value = "";
-        fuse_state_t   *state = NULL;
-        fuse_in_header_t *finh = NULL;
-        data_t         *value_data = NULL;
-        int             ret = -1;
-        int32_t         len = 0;
-        int32_t         len_next = 0;
-
-        state = frame->root->state;
-        finh  = state->finh;
-
-        fuse_log_eh_fop(this, state, frame, op_ret, op_errno);
-
-        if (op_ret >= 0) {
-                gf_log ("glusterfs-fuse", GF_LOG_TRACE,
-                        "%"PRIu64": %s() %s => %d", frame->root->unique,
-                        gf_fop_list[frame->root->op], state->loc.path, op_ret);
-
-                /* if successful */
-                if (state->name) {
-                        /* if callback for getxattr */
-                        value_data = dict_get (dict, state->name);
-                        if (value_data) {
-
-                                ret = value_data->len; /* Don't return the value for '\0' */
-                                value = value_data->data;
-
-                                send_fuse_xattr (this, finh, value, ret, state->size);
-                                /* if(ret >...)...else if...else */
-                        } else {
-                                send_fuse_err (this, finh, ENODATA);
-                        } /* if(value_data)...else */
-                } else {
-                        /* if callback for listxattr */
-                        /* we need to invoke fuse_filter_xattr() twice. Once
-                         * while counting size and then while filling buffer
-                         */
-                        len = dict_keys_join (NULL, 0, dict, fuse_filter_xattr);
-                        if (len < 0)
-                                goto out;
-
-                        value = alloca (len + 1);
-                        if (!value)
-                                goto out;
-
-                        len_next = dict_keys_join (value, len, dict,
-                                                   fuse_filter_xattr);
-                        if (len_next != len)
-                                gf_log (THIS->name, GF_LOG_ERROR,
-                                        "sizes not equal %d != %d",
-                                        len, len_next);
-
-                        send_fuse_xattr (this, finh, value, len, state->size);
-                } /* if(state->name)...else */
+fuse_xattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+               int32_t op_ret, int32_t op_errno, dict_t *dict, dict_t *xdata)
+{
+    char *value = "";
+    fuse_state_t *state = NULL;
+    fuse_in_header_t *finh = NULL;
+    data_t *value_data = NULL;
+    int ret = -1;
+    int32_t len = 0;
+    int32_t len_next = 0;
+
+    state = frame->root->state;
+    finh = state->finh;
+
+    fuse_log_eh_fop(this, state, frame, op_ret, op_errno);
+
+    if (op_ret >= 0) {
+        gf_log("glusterfs-fuse", GF_LOG_TRACE, "%" PRIu64 ": %s() %s => %d",
+               frame->root->unique, gf_fop_list[frame->root->op],
+               state->loc.path, op_ret);
+
+        /* if successful */
+        if (state->name) {
+            /* if callback for getxattr */
+            value_data = dict_get(dict, state->name);
+            if (value_data) {
+                ret = value_data->len; /* Don't return the value for '\0' */
+                value = value_data->data;
+
+                send_fuse_xattr(this, finh, value, ret, state->size);
+                /* if(ret >...)...else if...else */
+            } else {
+                send_fuse_err(this, finh, ENODATA);
+            } /* if(value_data)...else */
         } else {
-                /* if failure - no need to check if listxattr or getxattr */
-                if (op_errno != ENODATA && op_errno != ENOATTR) {
-                        if (op_errno == ENOTSUP) {
-                                GF_LOG_OCCASIONALLY (gf_fuse_xattr_enotsup_log,
-                                                     "glusterfs-fuse",
-                                                     GF_LOG_ERROR,
-                                                     "extended attribute not "
-                                                     "supported by the backend "
-                                                     "storage");
-                        } else {
-                                gf_log ("glusterfs-fuse", GF_LOG_WARNING,
-                                        "%"PRIu64": %s(%s) %s => -1 (%s)",
-                                        frame->root->unique,
-                                        gf_fop_list[frame->root->op], state->name,
-                                        state->loc.path, strerror (op_errno));
-                        }
-                } else {
-                        gf_log ("glusterfs-fuse", GF_LOG_DEBUG,
-                                "%"PRIu64": %s(%s) %s => -1 (%s)",
-                                frame->root->unique,
-                                gf_fop_list[frame->root->op], state->name,
-                                state->loc.path, strerror (op_errno));
-                } /* if(op_errno!= ENODATA)...else */
+            /* if callback for listxattr */
+            /* we need to invoke fuse_filter_xattr() twice. Once
+             * while counting size and then while filling buffer
+             */
+            len = dict_keys_join(NULL, 0, dict, fuse_filter_xattr);
+            if (len < 0)
+                goto out;
+
+            value = alloca(len + 1);
+            if (!value)
+                goto out;
+
+            len_next = dict_keys_join(value, len, dict, fuse_filter_xattr);
+            if (len_next != len)
+                gf_log(THIS->name, GF_LOG_ERROR, "sizes not equal %d != %d",
+                       len, len_next);
+
+            send_fuse_xattr(this, finh, value, len, state->size);
+        } /* if(state->name)...else */
+    } else {
+        /* if failure - no need to check if listxattr or getxattr */
+        if (op_errno != ENODATA && op_errno != ENOATTR) {
+            if (op_errno == ENOTSUP) {
+                GF_LOG_OCCASIONALLY(gf_fuse_xattr_enotsup_log, "glusterfs-fuse",
+                                    GF_LOG_ERROR,
+                                    "extended attribute not "
+                                    "supported by the backend "
+                                    "storage");
+            } else {
+                gf_log("glusterfs-fuse", GF_LOG_WARNING,
+                       "%" PRIu64 ": %s(%s) %s => -1 (%s)", frame->root->unique,
+                       gf_fop_list[frame->root->op], state->name,
+                       state->loc.path, strerror(op_errno));
+            }
+        } else {
+            gf_log("glusterfs-fuse", GF_LOG_DEBUG,
+                   "%" PRIu64 ": %s(%s) %s => -1 (%s)", frame->root->unique,
+                   gf_fop_list[frame->root->op], state->name, state->loc.path,
+                   strerror(op_errno));
+        } /* if(op_errno!= ENODATA)...else */
 
-                send_fuse_err (this, finh, op_errno);
-        } /* if(op_ret>=0)...else */
+        send_fuse_err(this, finh, op_errno);
+    } /* if(op_ret>=0)...else */
 
 out:
-        free_fuse_state (state);
-        STACK_DESTROY (frame->root);
+    free_fuse_state(state);
+    STACK_DESTROY(frame->root);
 
-        return 0;
+    return 0;
 }
 
-
 void
-fuse_getxattr_resume (fuse_state_t *state)
-{
-        char *value  = NULL;
-
-        if (!state->loc.inode) {
-                gf_log ("glusterfs-fuse", GF_LOG_WARNING,
-                        "%"PRIu64": GETXATTR %s/%"PRIu64" (%s) "
-                        "resolution failed",
-                        state->finh->unique,
-                        uuid_utoa (state->resolve.gfid),
-                        state->finh->nodeid, state->name);
-
-                send_fuse_err (state->this, state->finh,
-                               state->resolve.op_errno);
-                free_fuse_state (state);
-                return;
-        }
+fuse_getxattr_resume(fuse_state_t *state)
+{
+    char *value = NULL;
+
+    if (!state->loc.inode) {
+        gf_log("glusterfs-fuse", GF_LOG_WARNING,
+               "%" PRIu64 ": GETXATTR %s/%" PRIu64
+               " (%s) "
+               "resolution failed",
+               state->finh->unique, uuid_utoa(state->resolve.gfid),
+               state->finh->nodeid, state->name);
+
+        send_fuse_err(state->this, state->finh, state->resolve.op_errno);
+        free_fuse_state(state);
+        return;
+    }
 
 #ifdef GF_TEST_FFOP
-        state->fd = fd_lookup (state->loc.inode, state->finh->pid);
+    state->fd = fd_lookup(state->loc.inode, state->finh->pid);
 #endif /* GF_TEST_FFOP */
 
-        if (state->name &&
-            (strcmp (state->name, VIRTUAL_GFID_XATTR_KEY) == 0)) {
-                /* send glusterfs gfid in binary form */
+    if (state->name && (strcmp(state->name, VIRTUAL_GFID_XATTR_KEY) == 0)) {
+        /* send glusterfs gfid in binary form */
 
-                value = GF_MALLOC (16 + 1,
-                                   gf_common_mt_char);
-                if (!value) {
-                        send_fuse_err (state->this, state->finh, ENOMEM);
-                        goto internal_out;
-                }
-                memcpy (value, state->loc.inode->gfid, 16);
-                value[16] = '\0';
-
-                send_fuse_xattr (THIS, state->finh, value, 16, state->size);
-                GF_FREE (value);
-        internal_out:
-                free_fuse_state (state);
-                return;
+        value = GF_MALLOC(16 + 1, gf_common_mt_char);
+        if (!value) {
+            send_fuse_err(state->this, state->finh, ENOMEM);
+            goto internal_out;
         }
+        memcpy(value, state->loc.inode->gfid, 16);
+        value[16] = '\0';
 
-        if (state->name &&
-            (strcmp (state->name, VIRTUAL_GFID_XATTR_KEY_STR) == 0)) {
-                /* transform binary gfid to canonical form */
+        send_fuse_xattr(THIS, state->finh, value, 16, state->size);
+        GF_FREE(value);
+    internal_out:
+        free_fuse_state(state);
+        return;
+    }
 
-                value = GF_CALLOC (UUID_CANONICAL_FORM_LEN + 1, sizeof(char),
-                                   gf_common_mt_char);
-                if (!value) {
-                        send_fuse_err (state->this, state->finh, ENOMEM);
-                        goto internal_out1;
-                }
-                uuid_utoa_r (state->loc.inode->gfid, value);
-
-                send_fuse_xattr (THIS, state->finh, value,
-                                 UUID_CANONICAL_FORM_LEN, state->size);
-                GF_FREE (value);
-        internal_out1:
-                free_fuse_state (state);
-                return;
+    if (state->name && (strcmp(state->name, VIRTUAL_GFID_XATTR_KEY_STR) == 0)) {
+        /* transform binary gfid to canonical form */
+
+        value = GF_CALLOC(UUID_CANONICAL_FORM_LEN + 1, sizeof(char),
+                          gf_common_mt_char);
+        if (!value) {
+            send_fuse_err(state->this, state->finh, ENOMEM);
+            goto internal_out1;
         }
+        uuid_utoa_r(state->loc.inode->gfid, value);
 
+        send_fuse_xattr(THIS, state->finh, value, UUID_CANONICAL_FORM_LEN,
+                        state->size);
+        GF_FREE(value);
+    internal_out1:
+        free_fuse_state(state);
+        return;
+    }
 
-        if (state->fd) {
-                gf_log ("glusterfs-fuse", GF_LOG_TRACE,
-                        "%"PRIu64": GETXATTR %p/%"PRIu64" (%s)", state->finh->unique,
-                        state->fd, state->finh->nodeid, state->name);
+    if (state->fd) {
+        gf_log("glusterfs-fuse", GF_LOG_TRACE,
+               "%" PRIu64 ": GETXATTR %p/%" PRIu64 " (%s)", state->finh->unique,
+               state->fd, state->finh->nodeid, state->name);
 
-                FUSE_FOP (state, fuse_xattr_cbk, GF_FOP_FGETXATTR,
-                          fgetxattr, state->fd, state->name, state->xdata);
-        } else {
-                gf_log ("glusterfs-fuse", GF_LOG_TRACE,
-                        "%"PRIu64": GETXATTR %s/%"PRIu64" (%s)", state->finh->unique,
-                        state->loc.path, state->finh->nodeid, state->name);
+        FUSE_FOP(state, fuse_xattr_cbk, GF_FOP_FGETXATTR, fgetxattr, state->fd,
+                 state->name, state->xdata);
+    } else {
+        gf_log("glusterfs-fuse", GF_LOG_TRACE,
+               "%" PRIu64 ": GETXATTR %s/%" PRIu64 " (%s)", state->finh->unique,
+               state->loc.path, state->finh->nodeid, state->name);
 
-                FUSE_FOP (state, fuse_xattr_cbk, GF_FOP_GETXATTR,
-                          getxattr, &state->loc, state->name, state->xdata);
-        }
+        FUSE_FOP(state, fuse_xattr_cbk, GF_FOP_GETXATTR, getxattr, &state->loc,
+                 state->name, state->xdata);
+    }
 }
 
-
 static void
-fuse_getxattr (xlator_t *this, fuse_in_header_t *finh, void *msg,
-               struct iobuf *iobuf)
+fuse_getxattr(xlator_t *this, fuse_in_header_t *finh, void *msg,
+              struct iobuf *iobuf)
 {
-        struct fuse_getxattr_in *fgxi     = msg;
-        char                    *name     = (char *)(fgxi + 1);
-        fuse_state_t            *state    = NULL;
-        struct fuse_private     *priv     = NULL;
-        int                      rv       = 0;
-        int                     op_errno  = EINVAL;
-        char                    *newkey   = NULL;
-        int                      ret      = 0;
+    struct fuse_getxattr_in *fgxi = msg;
+    char *name = (char *)(fgxi + 1);
+    fuse_state_t *state = NULL;
+    struct fuse_private *priv = NULL;
+    int rv = 0;
+    int op_errno = EINVAL;
+    char *newkey = NULL;
+    int ret = 0;
 
-        priv = this->private;
-        GET_STATE (this, finh, state);
+    priv = this->private;
+    GET_STATE(this, finh, state);
 
 #ifdef GF_DARWIN_HOST_OS
-        if (fgxi->position) {
-                /* position can be used only for
-                 * resource fork queries which we
-                 * don't support anyway... so handling
-                 * it separately is just sort of a
-                 * matter of aesthetics, not strictly
-                 * necessary.
-                 */
-
-                gf_log ("glusterfs-fuse", GF_LOG_WARNING,
-                        "%"PRIu64": GETXATTR %s/%"PRIu64" (%s):"
-                        "refusing positioned getxattr",
-                        finh->unique, state->loc.path, finh->nodeid, name);
-                op_errno = EINVAL;
-                goto err;
-        }
+    if (fgxi->position) {
+        /* position can be used only for
+         * resource fork queries which we
+         * don't support anyway... so handling
+         * it separately is just sort of a
+         * matter of aesthetics, not strictly
+         * necessary.
+         */
+
+        gf_log("glusterfs-fuse", GF_LOG_WARNING,
+               "%" PRIu64 ": GETXATTR %s/%" PRIu64
+               " (%s):"
+               "refusing positioned getxattr",
+               finh->unique, state->loc.path, finh->nodeid, name);
+        op_errno = EINVAL;
+        goto err;
+    }
 #endif
 
-        if (!priv->acl) {
-                if ((strcmp (name, POSIX_ACL_ACCESS_XATTR) == 0) ||
-                    (strcmp (name, POSIX_ACL_DEFAULT_XATTR) == 0)) {
-                        op_errno = ENOTSUP;
-                        goto err;
-                }
+    if (!priv->acl) {
+        if ((strcmp(name, POSIX_ACL_ACCESS_XATTR) == 0) ||
+            (strcmp(name, POSIX_ACL_DEFAULT_XATTR) == 0)) {
+            op_errno = ENOTSUP;
+            goto err;
         }
+    }
 
-        ret = fuse_check_selinux_cap_xattr (priv, name);
-        if (ret) {
-                op_errno = ENODATA;
-                goto err;
-        }
+    ret = fuse_check_selinux_cap_xattr(priv, name);
+    if (ret) {
+        op_errno = ENODATA;
+        goto err;
+    }
 
-        fuse_resolve_inode_init (state, &state->resolve, finh->nodeid);
+    fuse_resolve_inode_init(state, &state->resolve, finh->nodeid);
 
-        rv = fuse_flip_xattr_ns (priv, name, &newkey);
-        if (rv) {
-                op_errno = ENOMEM;
-                goto err;
-        }
+    rv = fuse_flip_xattr_ns(priv, name, &newkey);
+    if (rv) {
+        op_errno = ENOMEM;
+        goto err;
+    }
 
-        state->size = fgxi->size;
-        state->name = newkey;
+    state->size = fgxi->size;
+    state->name = newkey;
 
-        fuse_resolve_and_resume (state, fuse_getxattr_resume);
+    fuse_resolve_and_resume(state, fuse_getxattr_resume);
 
-        return;
- err:
-        send_fuse_err (this, finh, op_errno);
-        free_fuse_state (state);
-        return;
+    return;
+err:
+    send_fuse_err(this, finh, op_errno);
+    free_fuse_state(state);
+    return;
 }
 
-
 void
-fuse_listxattr_resume (fuse_state_t *state)
-{
-        if (!state->loc.inode) {
-                gf_log ("glusterfs-fuse", GF_LOG_WARNING,
-                        "%"PRIu64": LISTXATTR %s/%"PRIu64
-                        "resolution failed", state->finh->unique,
-                        uuid_utoa (state->resolve.gfid), state->finh->nodeid);
-
-                send_fuse_err (state->this, state->finh,
-                               state->resolve.op_errno);
-                free_fuse_state (state);
-                return;
-        }
+fuse_listxattr_resume(fuse_state_t *state)
+{
+    if (!state->loc.inode) {
+        gf_log("glusterfs-fuse", GF_LOG_WARNING,
+               "%" PRIu64 ": LISTXATTR %s/%" PRIu64 "resolution failed",
+               state->finh->unique, uuid_utoa(state->resolve.gfid),
+               state->finh->nodeid);
+
+        send_fuse_err(state->this, state->finh, state->resolve.op_errno);
+        free_fuse_state(state);
+        return;
+    }
 
 #ifdef GF_TEST_FFOP
-        state->fd = fd_lookup (state->loc.inode, state->finh->pid);
+    state->fd = fd_lookup(state->loc.inode, state->finh->pid);
 #endif /* GF_TEST_FFOP */
 
-        if (state->fd) {
-                gf_log ("glusterfs-fuse", GF_LOG_TRACE,
-                        "%"PRIu64": LISTXATTR %p/%"PRIu64, state->finh->unique,
-                        state->fd, state->finh->nodeid);
+    if (state->fd) {
+        gf_log("glusterfs-fuse", GF_LOG_TRACE,
+               "%" PRIu64 ": LISTXATTR %p/%" PRIu64, state->finh->unique,
+               state->fd, state->finh->nodeid);
 
-                FUSE_FOP (state, fuse_xattr_cbk, GF_FOP_FGETXATTR,
-                          fgetxattr, state->fd, NULL, state->xdata);
-        } else {
-                gf_log ("glusterfs-fuse", GF_LOG_TRACE,
-                        "%"PRIu64": LISTXATTR %s/%"PRIu64, state->finh->unique,
-                        state->loc.path, state->finh->nodeid);
+        FUSE_FOP(state, fuse_xattr_cbk, GF_FOP_FGETXATTR, fgetxattr, state->fd,
+                 NULL, state->xdata);
+    } else {
+        gf_log("glusterfs-fuse", GF_LOG_TRACE,
+               "%" PRIu64 ": LISTXATTR %s/%" PRIu64, state->finh->unique,
+               state->loc.path, state->finh->nodeid);
 
-                FUSE_FOP (state, fuse_xattr_cbk, GF_FOP_GETXATTR,
-                          getxattr, &state->loc, NULL, state->xdata);
-        }
+        FUSE_FOP(state, fuse_xattr_cbk, GF_FOP_GETXATTR, getxattr, &state->loc,
+                 NULL, state->xdata);
+    }
 }
 
-
 static void
-fuse_listxattr (xlator_t *this, fuse_in_header_t *finh, void *msg,
-                struct iobuf *iobuf)
+fuse_listxattr(xlator_t *this, fuse_in_header_t *finh, void *msg,
+               struct iobuf *iobuf)
 {
-        struct fuse_getxattr_in *fgxi = msg;
-        fuse_state_t *state = NULL;
+    struct fuse_getxattr_in *fgxi = msg;
+    fuse_state_t *state = NULL;
 
-        GET_STATE (this, finh, state);
+    GET_STATE(this, finh, state);
 
-        fuse_resolve_inode_init (state, &state->resolve, finh->nodeid);
+    fuse_resolve_inode_init(state, &state->resolve, finh->nodeid);
 
-        state->size = fgxi->size;
+    state->size = fgxi->size;
 
-        fuse_resolve_and_resume (state, fuse_listxattr_resume);
+    fuse_resolve_and_resume(state, fuse_listxattr_resume);
 
-        return;
+    return;
 }
 
-
 void
-fuse_removexattr_resume (fuse_state_t *state)
-{
-         if (!state->loc.inode) {
-                gf_log ("glusterfs-fuse", GF_LOG_DEBUG,
-                        "%"PRIu64": REMOVEXATTR %s/%"PRIu64" (%s) "
-                        "resolution failed",
-                        state->finh->unique, uuid_utoa (state->resolve.gfid),
-                        state->finh->nodeid, state->name);
-
-                send_fuse_err (state->this, state->finh,
-                               state->resolve.op_errno);
-                free_fuse_state (state);
-                return;
-        }
+fuse_removexattr_resume(fuse_state_t *state)
+{
+    if (!state->loc.inode) {
+        gf_log("glusterfs-fuse", GF_LOG_DEBUG,
+               "%" PRIu64 ": REMOVEXATTR %s/%" PRIu64
+               " (%s) "
+               "resolution failed",
+               state->finh->unique, uuid_utoa(state->resolve.gfid),
+               state->finh->nodeid, state->name);
+
+        send_fuse_err(state->this, state->finh, state->resolve.op_errno);
+        free_fuse_state(state);
+        return;
+    }
 
 #ifdef GF_TEST_FFOP
-        state->fd = fd_lookup (state->loc.inode, state->finh->pid);
+    state->fd = fd_lookup(state->loc.inode, state->finh->pid);
 #endif /* GF_TEST_FFOP */
 
-        if (state->fd) {
-                gf_log ("glusterfs-fuse", GF_LOG_TRACE,
-                        "%"PRIu64": REMOVEXATTR %p/%"PRIu64" (%s)", state->finh->unique,
-                        state->fd, state->finh->nodeid, state->name);
+    if (state->fd) {
+        gf_log("glusterfs-fuse", GF_LOG_TRACE,
+               "%" PRIu64 ": REMOVEXATTR %p/%" PRIu64 " (%s)",
+               state->finh->unique, state->fd, state->finh->nodeid,
+               state->name);
 
-                FUSE_FOP (state, fuse_removexattr_cbk, GF_FOP_FREMOVEXATTR,
-                          fremovexattr, state->fd, state->name, state->xdata);
-        } else {
-                gf_log ("glusterfs-fuse", GF_LOG_TRACE,
-                        "%"PRIu64": REMOVEXATTR %s/%"PRIu64" (%s)", state->finh->unique,
-                        state->loc.path, state->finh->nodeid, state->name);
+        FUSE_FOP(state, fuse_removexattr_cbk, GF_FOP_FREMOVEXATTR, fremovexattr,
+                 state->fd, state->name, state->xdata);
+    } else {
+        gf_log("glusterfs-fuse", GF_LOG_TRACE,
+               "%" PRIu64 ": REMOVEXATTR %s/%" PRIu64 " (%s)",
+               state->finh->unique, state->loc.path, state->finh->nodeid,
+               state->name);
 
-                FUSE_FOP (state, fuse_removexattr_cbk, GF_FOP_REMOVEXATTR,
-                          removexattr, &state->loc, state->name, state->xdata);
-        }
+        FUSE_FOP(state, fuse_removexattr_cbk, GF_FOP_REMOVEXATTR, removexattr,
+                 &state->loc, state->name, state->xdata);
+    }
 }
 
-
 static void
-fuse_removexattr (xlator_t *this, fuse_in_header_t *finh, void *msg,
-                  struct iobuf *iobuf)
+fuse_removexattr(xlator_t *this, fuse_in_header_t *finh, void *msg,
+                 struct iobuf *iobuf)
 {
-        char *name = msg;
+    char *name = msg;
 
-        fuse_state_t *state = NULL;
-        fuse_private_t *priv = NULL;
-        int32_t       ret = -1;
-        char *newkey = NULL;
+    fuse_state_t *state = NULL;
+    fuse_private_t *priv = NULL;
+    int32_t ret = -1;
+    char *newkey = NULL;
 
-        if (!strcmp (GFID_XATTR_KEY, name) || !strcmp (GF_XATTR_VOL_ID_KEY, name)) {
-                send_fuse_err (this, finh, EPERM);
-                GF_FREE (finh);
-                return;
-        }
+    if (!strcmp(GFID_XATTR_KEY, name) || !strcmp(GF_XATTR_VOL_ID_KEY, name)) {
+        send_fuse_err(this, finh, EPERM);
+        GF_FREE(finh);
+        return;
+    }
 
-        priv = this->private;
+    priv = this->private;
 
-        GET_STATE (this, finh, state);
+    GET_STATE(this, finh, state);
 
-        fuse_resolve_inode_init (state, &state->resolve, finh->nodeid);
+    fuse_resolve_inode_init(state, &state->resolve, finh->nodeid);
 
-        ret = fuse_flip_xattr_ns (priv, name, &newkey);
-        if (ret) {
-                send_fuse_err (this, finh, ENOMEM);
-                free_fuse_state (state);
-                return;
-        }
+    ret = fuse_flip_xattr_ns(priv, name, &newkey);
+    if (ret) {
+        send_fuse_err(this, finh, ENOMEM);
+        free_fuse_state(state);
+        return;
+    }
 
-        state->name = newkey;
+    state->name = newkey;
 
-        fuse_resolve_and_resume (state, fuse_removexattr_resume);
-        return;
+    fuse_resolve_and_resume(state, fuse_removexattr_resume);
+    return;
 }
 
-
 static int gf_fuse_lk_enosys_log;
 
 static int
-fuse_getlk_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)
+fuse_getlk_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)
 {
-        fuse_state_t *state = NULL;
-
-        state = frame->root->state;
-        struct fuse_lk_out flo = {{0, }, };
-
-        fuse_log_eh_fop(this, state, frame, op_ret, op_errno);
-
-        if (op_ret == 0) {
-                gf_log ("glusterfs-fuse", GF_LOG_TRACE,
-                        "%"PRIu64": ERR => 0", frame->root->unique);
-                flo.lk.type = lock->l_type;
-                flo.lk.pid  = lock->l_pid;
-                if (lock->l_type == F_UNLCK)
-                        flo.lk.start = flo.lk.end = 0;
-                else {
-                        flo.lk.start = lock->l_start;
-                        flo.lk.end = lock->l_len ?
-                                     (lock->l_start + lock->l_len - 1) :
-                                     OFFSET_MAX;
-                }
-                send_fuse_obj (this, state->finh, &flo);
+    fuse_state_t *state = NULL;
+
+    state = frame->root->state;
+    struct fuse_lk_out flo = {
+        {
+            0,
+        },
+    };
+
+    fuse_log_eh_fop(this, state, frame, op_ret, op_errno);
+
+    if (op_ret == 0) {
+        gf_log("glusterfs-fuse", GF_LOG_TRACE, "%" PRIu64 ": ERR => 0",
+               frame->root->unique);
+        flo.lk.type = lock->l_type;
+        flo.lk.pid = lock->l_pid;
+        if (lock->l_type == F_UNLCK)
+            flo.lk.start = flo.lk.end = 0;
+        else {
+            flo.lk.start = lock->l_start;
+            flo.lk.end = lock->l_len ? (lock->l_start + lock->l_len - 1)
+                                     : OFFSET_MAX;
+        }
+        send_fuse_obj(this, state->finh, &flo);
+    } else {
+        if (op_errno == ENOSYS) {
+            gf_fuse_lk_enosys_log++;
+            if (!(gf_fuse_lk_enosys_log % GF_UNIVERSAL_ANSWER)) {
+                gf_log("glusterfs-fuse", GF_LOG_ERROR,
+                       "GETLK not supported. loading "
+                       "'features/posix-locks' on server side "
+                       "will add GETLK support.");
+            }
         } else {
-                if (op_errno == ENOSYS) {
-                        gf_fuse_lk_enosys_log++;
-                        if (!(gf_fuse_lk_enosys_log % GF_UNIVERSAL_ANSWER)) {
-                                gf_log ("glusterfs-fuse", GF_LOG_ERROR,
-                                        "GETLK not supported. loading "
-                                        "'features/posix-locks' on server side "
-                                        "will add GETLK support.");
-                        }
-                } else {
-                        gf_log ("glusterfs-fuse", GF_LOG_WARNING,
-                                "%"PRIu64": ERR => -1 (%s)",
-                                frame->root->unique, strerror (op_errno));
-                }
-                send_fuse_err (this, state->finh, op_errno);
+            gf_log("glusterfs-fuse", GF_LOG_WARNING,
+                   "%" PRIu64 ": ERR => -1 (%s)", frame->root->unique,
+                   strerror(op_errno));
         }
+        send_fuse_err(this, state->finh, op_errno);
+    }
 
-        free_fuse_state (state);
-        STACK_DESTROY (frame->root);
+    free_fuse_state(state);
+    STACK_DESTROY(frame->root);
 
-        return 0;
+    return 0;
 }
 
-
 void
-fuse_getlk_resume (fuse_state_t *state)
+fuse_getlk_resume(fuse_state_t *state)
 {
-        gf_log ("glusterfs-fuse", GF_LOG_TRACE,
-                "%"PRIu64": GETLK %p", state->finh->unique, state->fd);
+    gf_log("glusterfs-fuse", GF_LOG_TRACE, "%" PRIu64 ": GETLK %p",
+           state->finh->unique, state->fd);
 
-        FUSE_FOP (state, fuse_getlk_cbk, GF_FOP_LK,
-                  lk, state->fd, F_GETLK, &state->lk_lock, state->xdata);
+    FUSE_FOP(state, fuse_getlk_cbk, GF_FOP_LK, lk, state->fd, F_GETLK,
+             &state->lk_lock, state->xdata);
 }
 
-
 static void
-fuse_getlk (xlator_t *this, fuse_in_header_t *finh, void *msg,
-            struct iobuf *iobuf)
+fuse_getlk(xlator_t *this, fuse_in_header_t *finh, void *msg,
+           struct iobuf *iobuf)
 {
-        struct fuse_lk_in *fli = msg;
+    struct fuse_lk_in *fli = msg;
 
-        fuse_state_t *state = NULL;
-        fd_t         *fd = NULL;
+    fuse_state_t *state = NULL;
+    fd_t *fd = NULL;
 
-        fd = FH_TO_FD (fli->fh);
-        GET_STATE (this, finh, state);
-        state->fd = fd;
+    fd = FH_TO_FD(fli->fh);
+    GET_STATE(this, finh, state);
+    state->fd = fd;
 
-        fuse_resolve_fd_init (state, &state->resolve, fd);
+    fuse_resolve_fd_init(state, &state->resolve, fd);
 
-        convert_fuse_file_lock (&fli->lk, &state->lk_lock,
-                                fli->owner);
+    convert_fuse_file_lock(&fli->lk, &state->lk_lock, fli->owner);
 
-        state->lk_owner = fli->owner;
+    state->lk_owner = fli->owner;
 
-        fuse_resolve_and_resume (state, fuse_getlk_resume);
+    fuse_resolve_and_resume(state, fuse_getlk_resume);
 
-        return;
+    return;
 }
 
-
 static int
-fuse_setlk_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)
-{
-        uint32_t      op    = 0;
-        fuse_state_t *state = NULL;
-
-        state = frame->root->state;
-        op    = state->finh->opcode;
-
-        fuse_log_eh_fop(this, state, frame, op_ret, op_errno);
-
-        if (op_ret == 0) {
-                gf_log ("glusterfs-fuse", GF_LOG_TRACE,
-                        "%"PRIu64": ERR => 0", frame->root->unique);
-                fd_lk_insert_and_merge (state->fd,
-                                        (op == FUSE_SETLK) ? F_SETLK : F_SETLKW,
-                                        &state->lk_lock);
-
-                send_fuse_err (this, state->finh, 0);
+fuse_setlk_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)
+{
+    uint32_t op = 0;
+    fuse_state_t *state = NULL;
+
+    state = frame->root->state;
+    op = state->finh->opcode;
+
+    fuse_log_eh_fop(this, state, frame, op_ret, op_errno);
+
+    if (op_ret == 0) {
+        gf_log("glusterfs-fuse", GF_LOG_TRACE, "%" PRIu64 ": ERR => 0",
+               frame->root->unique);
+        fd_lk_insert_and_merge(state->fd,
+                               (op == FUSE_SETLK) ? F_SETLK : F_SETLKW,
+                               &state->lk_lock);
+
+        send_fuse_err(this, state->finh, 0);
+    } else {
+        if (op_errno == ENOSYS) {
+            gf_fuse_lk_enosys_log++;
+            if (!(gf_fuse_lk_enosys_log % GF_UNIVERSAL_ANSWER)) {
+                gf_log("glusterfs-fuse", GF_LOG_ERROR,
+                       "SETLK not supported. loading "
+                       "'features/posix-locks' on server side "
+                       "will add SETLK support.");
+            }
+        } else if (op_errno == EAGAIN) {
+            gf_log("glusterfs-fuse", GF_LOG_DEBUG,
+                   "Returning EAGAIN Flock: "
+                   "start=%llu, len=%llu, pid=%llu, lk-owner=%s",
+                   (unsigned long long)state->lk_lock.l_start,
+                   (unsigned long long)state->lk_lock.l_len,
+                   (unsigned long long)state->lk_lock.l_pid,
+                   lkowner_utoa(&frame->root->lk_owner));
         } else {
-                if (op_errno == ENOSYS) {
-                        gf_fuse_lk_enosys_log++;
-                        if (!(gf_fuse_lk_enosys_log % GF_UNIVERSAL_ANSWER)) {
-                                gf_log ("glusterfs-fuse", GF_LOG_ERROR,
-                                        "SETLK not supported. loading "
-                                        "'features/posix-locks' on server side "
-                                        "will add SETLK support.");
-                        }
-                } else if (op_errno == EAGAIN) {
-                        gf_log ("glusterfs-fuse", GF_LOG_DEBUG,
-                                "Returning EAGAIN Flock: "
-                                "start=%llu, len=%llu, pid=%llu, lk-owner=%s",
-                                (unsigned long long) state->lk_lock.l_start,
-                                (unsigned long long) state->lk_lock.l_len,
-                                (unsigned long long) state->lk_lock.l_pid,
-                                lkowner_utoa (&frame->root->lk_owner));
-                } else  {
-                        gf_log ("glusterfs-fuse", GF_LOG_WARNING,
-                                "%"PRIu64": ERR => -1 (%s)",
-                                frame->root->unique, strerror (op_errno));
-                }
-
-                send_fuse_err (this, state->finh, op_errno);
+            gf_log("glusterfs-fuse", GF_LOG_WARNING,
+                   "%" PRIu64 ": ERR => -1 (%s)", frame->root->unique,
+                   strerror(op_errno));
         }
 
-        free_fuse_state (state);
-        STACK_DESTROY (frame->root);
+        send_fuse_err(this, state->finh, op_errno);
+    }
 
-        return 0;
-}
+    free_fuse_state(state);
+    STACK_DESTROY(frame->root);
 
+    return 0;
+}
 
 void
-fuse_setlk_resume (fuse_state_t *state)
+fuse_setlk_resume(fuse_state_t *state)
 {
-        gf_log ("glusterfs-fuse", GF_LOG_TRACE,
-                "%"PRIu64": SETLK%s %p", state->finh->unique,
-                state->finh->opcode == FUSE_SETLK ? "" : "W", state->fd);
+    gf_log("glusterfs-fuse", GF_LOG_TRACE, "%" PRIu64 ": SETLK%s %p",
+           state->finh->unique, state->finh->opcode == FUSE_SETLK ? "" : "W",
+           state->fd);
 
-        FUSE_FOP (state, fuse_setlk_cbk, GF_FOP_LK, lk, state->fd,
-                  state->finh->opcode == FUSE_SETLK ? F_SETLK : F_SETLKW,
-                  &state->lk_lock, state->xdata);
+    FUSE_FOP(state, fuse_setlk_cbk, GF_FOP_LK, lk, state->fd,
+             state->finh->opcode == FUSE_SETLK ? F_SETLK : F_SETLKW,
+             &state->lk_lock, state->xdata);
 }
 
-
 static void
-fuse_setlk (xlator_t *this, fuse_in_header_t *finh, void *msg,
-            struct iobuf *iobuf)
+fuse_setlk(xlator_t *this, fuse_in_header_t *finh, void *msg,
+           struct iobuf *iobuf)
 {
-        struct fuse_lk_in *fli = msg;
+    struct fuse_lk_in *fli = msg;
 
-        fuse_state_t *state = NULL;
-        fd_t         *fd = NULL;
+    fuse_state_t *state = NULL;
+    fd_t *fd = NULL;
 
-        fd = FH_TO_FD (fli->fh);
-        GET_STATE (this, finh, state);
-        state->finh = finh;
-        state->fd = fd;
+    fd = FH_TO_FD(fli->fh);
+    GET_STATE(this, finh, state);
+    state->finh = finh;
+    state->fd = fd;
 
-        fuse_resolve_fd_init (state, &state->resolve, fd);
+    fuse_resolve_fd_init(state, &state->resolve, fd);
 
-        convert_fuse_file_lock (&fli->lk, &state->lk_lock,
-                                fli->owner);
+    convert_fuse_file_lock(&fli->lk, &state->lk_lock, fli->owner);
 
-        state->lk_owner = fli->owner;
+    state->lk_owner = fli->owner;
 
-        fuse_resolve_and_resume (state, fuse_setlk_resume);
+    fuse_resolve_and_resume(state, fuse_setlk_resume);
 
-        return;
+    return;
 }
 
 #if FUSE_KERNEL_MINOR_VERSION >= 11
 static void *
-notify_kernel_loop (void *data)
-{
-        uint32_t                 len = 0;
-        ssize_t                   rv = 0;
-        xlator_t               *this = NULL;
-        fuse_private_t         *priv = NULL;
-        fuse_invalidate_node_t *node = NULL;
-        fuse_invalidate_node_t  *tmp = NULL;
-        struct fuse_out_header *pfoh = NULL;
-        struct iovec         iov_out = {0,};
-
-        this = data;
-        priv = this->private;
-
-        for (;;) {
-                pthread_mutex_lock (&priv->invalidate_mutex);
-                {
-                        while (list_empty (&priv->invalidate_list))
-                                pthread_cond_wait (&priv->invalidate_cond,
-                                                   &priv->invalidate_mutex);
+notify_kernel_loop(void *data)
+{
+    uint32_t len = 0;
+    ssize_t rv = 0;
+    xlator_t *this = NULL;
+    fuse_private_t *priv = NULL;
+    fuse_invalidate_node_t *node = NULL;
+    fuse_invalidate_node_t *tmp = NULL;
+    struct fuse_out_header *pfoh = NULL;
+    struct iovec iov_out = {
+        0,
+    };
+
+    this = data;
+    priv = this->private;
+
+    for (;;) {
+        pthread_mutex_lock(&priv->invalidate_mutex);
+        {
+            while (list_empty(&priv->invalidate_list))
+                pthread_cond_wait(&priv->invalidate_cond,
+                                  &priv->invalidate_mutex);
 
-                        node = list_entry (priv->invalidate_list.next,
-                                           fuse_invalidate_node_t, next);
+            node = list_entry(priv->invalidate_list.next,
+                              fuse_invalidate_node_t, next);
 
-                        list_del_init (&node->next);
-                }
-                pthread_mutex_unlock (&priv->invalidate_mutex);
-
-                pfoh = (struct fuse_out_header *)node->inval_buf;
-                memcpy (&len, &pfoh->len, sizeof(len));
-                /*
-                 * a simple
-                 *         len = pfoh->len;
-                 * works on x86, but takes a multiple insn cycle hit
-                 * when pfoh->len is not correctly aligned, possibly
-                 * even stalling the insn pipeline.
-                 * Other architectures will not be so forgiving. If
-                 * we're lucky the memcpy will be inlined by the
-                 * compiler, and might be as fast or faster without
-                 * the risk of stalling the insn pipeline.
-                 */
-
-                iov_out.iov_base = node->inval_buf;
-                iov_out.iov_len = len;
-                rv = sys_writev (priv->fd, &iov_out, 1);
-                check_and_dump_fuse_W (priv, &iov_out, 1, rv);
-
-                GF_FREE (node);
-
-                if (rv == -1 && errno == EBADF)
-                        break;
+            list_del_init(&node->next);
+        }
+        pthread_mutex_unlock(&priv->invalidate_mutex);
 
-                if (rv != len && !(rv == -1 && errno == ENOENT)) {
-                        gf_log ("glusterfs-fuse", GF_LOG_INFO,
-                                "len: %u, rv: %zd, errno: %d", len, rv, errno);
-                }
+        pfoh = (struct fuse_out_header *)node->inval_buf;
+        memcpy(&len, &pfoh->len, sizeof(len));
+        /*
+         * a simple
+         *         len = pfoh->len;
+         * works on x86, but takes a multiple insn cycle hit
+         * when pfoh->len is not correctly aligned, possibly
+         * even stalling the insn pipeline.
+         * Other architectures will not be so forgiving. If
+         * we're lucky the memcpy will be inlined by the
+         * compiler, and might be as fast or faster without
+         * the risk of stalling the insn pipeline.
+         */
+
+        iov_out.iov_base = node->inval_buf;
+        iov_out.iov_len = len;
+        rv = sys_writev(priv->fd, &iov_out, 1);
+        check_and_dump_fuse_W(priv, &iov_out, 1, rv);
+
+        GF_FREE(node);
+
+        if (rv == -1 && errno == EBADF)
+            break;
+
+        if (rv != len && !(rv == -1 && errno == ENOENT)) {
+            gf_log("glusterfs-fuse", GF_LOG_INFO, "len: %u, rv: %zd, errno: %d",
+                   len, rv, errno);
         }
+    }
 
-        gf_log ("glusterfs-fuse", GF_LOG_ERROR,
-                "kernel notifier loop terminated");
+    gf_log("glusterfs-fuse", GF_LOG_ERROR, "kernel notifier loop terminated");
 
-        pthread_mutex_lock (&priv->invalidate_mutex);
+    pthread_mutex_lock(&priv->invalidate_mutex);
+    {
+        priv->reverse_fuse_thread_started = _gf_false;
+        list_for_each_entry_safe(node, tmp, &priv->invalidate_list, next)
         {
-                priv->reverse_fuse_thread_started = _gf_false;
-                list_for_each_entry_safe (node, tmp, &priv->invalidate_list,
-                                          next) {
-                        list_del_init (&node->next);
-                        GF_FREE (node);
-                }
+            list_del_init(&node->next);
+            GF_FREE(node);
         }
-        pthread_mutex_unlock (&priv->invalidate_mutex);
+    }
+    pthread_mutex_unlock(&priv->invalidate_mutex);
 
-        return NULL;
+    return NULL;
 }
 #endif
 
 static void
-fuse_init (xlator_t *this, fuse_in_header_t *finh, void *msg,
-           struct iobuf *iobuf)
-{
-        struct fuse_init_in  *fini      = msg;
-        struct fuse_init_out  fino      = {0,};
-        fuse_private_t       *priv      = NULL;
-        size_t                size      = 0;
-        int                   ret       = 0;
+fuse_init(xlator_t *this, fuse_in_header_t *finh, void *msg,
+          struct iobuf *iobuf)
+{
+    struct fuse_init_in *fini = msg;
+    struct fuse_init_out fino = {
+        0,
+    };
+    fuse_private_t *priv = NULL;
+    size_t size = 0;
+    int ret = 0;
 #if FUSE_KERNEL_MINOR_VERSION >= 9
-        pthread_t             messenger;
+    pthread_t messenger;
 #endif
 
-        priv = this->private;
+    priv = this->private;
 
-        if (priv->init_recvd) {
-                gf_log ("glusterfs-fuse", GF_LOG_ERROR,
-                        "got INIT after first message");
+    if (priv->init_recvd) {
+        gf_log("glusterfs-fuse", GF_LOG_ERROR, "got INIT after first message");
 
-                sys_close (priv->fd);
-                goto out;
-        }
+        sys_close(priv->fd);
+        goto out;
+    }
 
-        priv->init_recvd = 1;
+    priv->init_recvd = 1;
 
-        if (fini->major != FUSE_KERNEL_VERSION) {
-                gf_log ("glusterfs-fuse", GF_LOG_ERROR,
-                        "unsupported FUSE protocol version %d.%d",
-                        fini->major, fini->minor);
+    if (fini->major != FUSE_KERNEL_VERSION) {
+        gf_log("glusterfs-fuse", GF_LOG_ERROR,
+               "unsupported FUSE protocol version %d.%d", fini->major,
+               fini->minor);
 
-                sys_close (priv->fd);
-                goto out;
-        }
-        priv->proto_minor = fini->minor;
+        sys_close(priv->fd);
+        goto out;
+    }
+    priv->proto_minor = fini->minor;
 
-        fino.major = FUSE_KERNEL_VERSION;
-        fino.minor = FUSE_KERNEL_MINOR_VERSION;
-        fino.max_readahead = 1 << 17;
-        fino.max_write = 1 << 17;
-        fino.flags = FUSE_ASYNC_READ | FUSE_POSIX_LOCKS;
+    fino.major = FUSE_KERNEL_VERSION;
+    fino.minor = FUSE_KERNEL_MINOR_VERSION;
+    fino.max_readahead = 1 << 17;
+    fino.max_write = 1 << 17;
+    fino.flags = FUSE_ASYNC_READ | FUSE_POSIX_LOCKS;
 #if FUSE_KERNEL_MINOR_VERSION >= 17
-	if (fini->minor >= 17)
-		fino.flags |= FUSE_FLOCK_LOCKS;
+    if (fini->minor >= 17)
+        fino.flags |= FUSE_FLOCK_LOCKS;
 #endif
 #if FUSE_KERNEL_MINOR_VERSION >= 12
-        if (fini->minor >= 12) {
-            /* let fuse leave the umask processing to us, so that it does not
-             * break extended POSIX ACL defaults on server */
-            fino.flags |= FUSE_DONT_MASK;
-        }
+    if (fini->minor >= 12) {
+        /* let fuse leave the umask processing to us, so that it does not
+         * break extended POSIX ACL defaults on server */
+        fino.flags |= FUSE_DONT_MASK;
+    }
 #endif
 #if FUSE_KERNEL_MINOR_VERSION >= 9
-        if (fini->minor >= 6 /* fuse_init_in has flags */ &&
-            fini->flags & FUSE_BIG_WRITES) {
-                /* no need for direct I/O mode by default if big writes are supported */
-                if (priv->direct_io_mode == 2)
-                        priv->direct_io_mode = 0;
-                fino.flags |= FUSE_BIG_WRITES;
-        }
-
-        /* Used for 'reverse invalidation of inode' */
-        if (fini->minor >= 12) {
-                ret = gf_thread_create (&messenger, NULL, notify_kernel_loop,
-                                        this, "fusenoti");
-                if (ret != 0) {
-                        gf_log ("glusterfs-fuse", GF_LOG_ERROR,
-                                "failed to start messenger daemon (%s)",
-                                strerror(errno));
-
-                        sys_close (priv->fd);
-                        goto out;
-                }
-                priv->reverse_fuse_thread_started = _gf_true;
-        } else {
-                /*
-                 * FUSE minor < 12 does not implement invalidate notifications.
-                 * This mechanism is required for fopen-keep-cache to operate
-                 * correctly. Disable and warn the user.
-                 */
-                if (priv->fopen_keep_cache) {
-                        gf_log("glusterfs-fuse", GF_LOG_WARNING, "FUSE version "
-                                "%d.%d does not support inval notifications. "
-                                "fopen-keep-cache disabled.", fini->major,
-                                fini->minor);
-                        priv->fopen_keep_cache = 0;
-                }
-        }
-
-        if (fini->minor >= 13) {
-                fino.max_background = priv->background_qlen;
-                fino.congestion_threshold = priv->congestion_threshold;
-        }
-        if (fini->minor < 9)
-                *priv->msg0_len_p = sizeof(*finh) + FUSE_COMPAT_WRITE_IN_SIZE;
+    if (fini->minor >= 6 /* fuse_init_in has flags */ &&
+        fini->flags & FUSE_BIG_WRITES) {
+        /* no need for direct I/O mode by default if big writes are supported */
+        if (priv->direct_io_mode == 2)
+            priv->direct_io_mode = 0;
+        fino.flags |= FUSE_BIG_WRITES;
+    }
+
+    /* Used for 'reverse invalidation of inode' */
+    if (fini->minor >= 12) {
+        ret = gf_thread_create(&messenger, NULL, notify_kernel_loop, this,
+                               "fusenoti");
+        if (ret != 0) {
+            gf_log("glusterfs-fuse", GF_LOG_ERROR,
+                   "failed to start messenger daemon (%s)", strerror(errno));
 
-        if (priv->use_readdirp) {
-                if (fini->flags & FUSE_DO_READDIRPLUS)
-                        fino.flags |= FUSE_DO_READDIRPLUS;
+            sys_close(priv->fd);
+            goto out;
         }
+        priv->reverse_fuse_thread_started = _gf_true;
+    } else {
+        /*
+         * FUSE minor < 12 does not implement invalidate notifications.
+         * This mechanism is required for fopen-keep-cache to operate
+         * correctly. Disable and warn the user.
+         */
+        if (priv->fopen_keep_cache) {
+            gf_log("glusterfs-fuse", GF_LOG_WARNING,
+                   "FUSE version "
+                   "%d.%d does not support inval notifications. "
+                   "fopen-keep-cache disabled.",
+                   fini->major, fini->minor);
+            priv->fopen_keep_cache = 0;
+        }
+    }
+
+    if (fini->minor >= 13) {
+        fino.max_background = priv->background_qlen;
+        fino.congestion_threshold = priv->congestion_threshold;
+    }
+    if (fini->minor < 9)
+        *priv->msg0_len_p = sizeof(*finh) + FUSE_COMPAT_WRITE_IN_SIZE;
+
+    if (priv->use_readdirp) {
+        if (fini->flags & FUSE_DO_READDIRPLUS)
+            fino.flags |= FUSE_DO_READDIRPLUS;
+    }
 #endif
-	if (priv->fopen_keep_cache == 2) {
-		/* If user did not explicitly set --fopen-keep-cache[=off],
-		   then check if kernel support FUSE_AUTO_INVAL_DATA and ...
-		*/
+    if (priv->fopen_keep_cache == 2) {
+        /* If user did not explicitly set --fopen-keep-cache[=off],
+           then check if kernel support FUSE_AUTO_INVAL_DATA and ...
+        */
 #if FUSE_KERNEL_MINOR_VERSION >= 20
-		if (fini->flags & FUSE_AUTO_INVAL_DATA) {
-			/* ... enable fopen_keep_cache mode if supported.
-			*/
-			gf_log ("glusterfs-fuse", GF_LOG_DEBUG, "Detected "
-				"support for FUSE_AUTO_INVAL_DATA. Enabling "
-				"fopen_keep_cache automatically.");
-			fino.flags |= FUSE_AUTO_INVAL_DATA;
-			priv->fopen_keep_cache = 1;
-		} else
+        if (fini->flags & FUSE_AUTO_INVAL_DATA) {
+            /* ... enable fopen_keep_cache mode if supported.
+             */
+            gf_log("glusterfs-fuse", GF_LOG_DEBUG,
+                   "Detected "
+                   "support for FUSE_AUTO_INVAL_DATA. Enabling "
+                   "fopen_keep_cache automatically.");
+            fino.flags |= FUSE_AUTO_INVAL_DATA;
+            priv->fopen_keep_cache = 1;
+        } else
 #endif
-		{
-
-			gf_log ("glusterfs-fuse", GF_LOG_DEBUG, "No support "
-				"for FUSE_AUTO_INVAL_DATA. Disabling "
-				"fopen_keep_cache.");
-			/* ... else disable. */
-			priv->fopen_keep_cache = 0;
-		}
-	} else if (priv->fopen_keep_cache == 1) {
-		/* If user explicitly set --fopen-keep-cache[=on],
-		   then enable FUSE_AUTO_INVAL_DATA if possible.
-		*/
+        {
+
+            gf_log("glusterfs-fuse", GF_LOG_DEBUG,
+                   "No support "
+                   "for FUSE_AUTO_INVAL_DATA. Disabling "
+                   "fopen_keep_cache.");
+            /* ... else disable. */
+            priv->fopen_keep_cache = 0;
+        }
+    } else if (priv->fopen_keep_cache == 1) {
+        /* If user explicitly set --fopen-keep-cache[=on],
+           then enable FUSE_AUTO_INVAL_DATA if possible.
+        */
 #if FUSE_KERNEL_MINOR_VERSION >= 20
-		if (fini->flags & FUSE_AUTO_INVAL_DATA) {
-			gf_log ("glusterfs-fuse", GF_LOG_DEBUG, "fopen_keep_cache "
-				"is explicitly set. Enabling FUSE_AUTO_INVAL_DATA");
-			fino.flags |= FUSE_AUTO_INVAL_DATA;
-		} else
+        if (fini->flags & FUSE_AUTO_INVAL_DATA) {
+            gf_log("glusterfs-fuse", GF_LOG_DEBUG,
+                   "fopen_keep_cache "
+                   "is explicitly set. Enabling FUSE_AUTO_INVAL_DATA");
+            fino.flags |= FUSE_AUTO_INVAL_DATA;
+        } else
 #endif
-		{
-			gf_log ("glusterfs-fuse", GF_LOG_WARNING, "fopen_keep_cache "
-				"is explicitly set. Support for "
-				"FUSE_AUTO_INVAL_DATA is missing");
-		}
-	}
+        {
+            gf_log("glusterfs-fuse", GF_LOG_WARNING,
+                   "fopen_keep_cache "
+                   "is explicitly set. Support for "
+                   "FUSE_AUTO_INVAL_DATA is missing");
+        }
+    }
 
 #if FUSE_KERNEL_MINOR_VERSION >= 22
-	if (fini->flags & FUSE_ASYNC_DIO)
-		fino.flags |= FUSE_ASYNC_DIO;
+    if (fini->flags & FUSE_ASYNC_DIO)
+        fino.flags |= FUSE_ASYNC_DIO;
 #endif
 
-        size = sizeof (fino);
+    size = sizeof(fino);
 #if FUSE_KERNEL_MINOR_VERSION >= 23
-        /* FUSE 7.23 and newer added attributes to the fuse_init_out struct */
-        if (fini->minor < 23) {
-                /* reduce the size, chop off unused attributes from &fino */
-                size = FUSE_COMPAT_22_INIT_OUT_SIZE;
-        }
-
-        /* Writeback cache support */
-        if (fini->minor >= 23) {
-                if (priv->kernel_writeback_cache)
-                        fino.flags |= FUSE_WRITEBACK_CACHE;
-                fino.time_gran = priv->attr_times_granularity;
-        }
+    /* FUSE 7.23 and newer added attributes to the fuse_init_out struct */
+    if (fini->minor < 23) {
+        /* reduce the size, chop off unused attributes from &fino */
+        size = FUSE_COMPAT_22_INIT_OUT_SIZE;
+    }
+
+    /* Writeback cache support */
+    if (fini->minor >= 23) {
+        if (priv->kernel_writeback_cache)
+            fino.flags |= FUSE_WRITEBACK_CACHE;
+        fino.time_gran = priv->attr_times_granularity;
+    }
 #endif
 
-        ret = send_fuse_data (this, finh, &fino, size);
-        if (ret == 0)
-                gf_log ("glusterfs-fuse", GF_LOG_INFO,
-                        "FUSE inited with protocol versions:"
-                        " glusterfs %d.%d kernel %d.%d",
-                        FUSE_KERNEL_VERSION, FUSE_KERNEL_MINOR_VERSION,
-                        fini->major, fini->minor);
-        else {
-                gf_log ("glusterfs-fuse", GF_LOG_ERROR,
-                        "FUSE init failed (%s)", strerror (ret));
+    ret = send_fuse_data(this, finh, &fino, size);
+    if (ret == 0)
+        gf_log("glusterfs-fuse", GF_LOG_INFO,
+               "FUSE inited with protocol versions:"
+               " glusterfs %d.%d kernel %d.%d",
+               FUSE_KERNEL_VERSION, FUSE_KERNEL_MINOR_VERSION, fini->major,
+               fini->minor);
+    else {
+        gf_log("glusterfs-fuse", GF_LOG_ERROR, "FUSE init failed (%s)",
+               strerror(ret));
 
-                sys_close (priv->fd);
-        }
+        sys_close(priv->fd);
+    }
 
- out:
-        GF_FREE (finh);
+out:
+    GF_FREE(finh);
 }
 
-
 static void
-fuse_enosys (xlator_t *this, fuse_in_header_t *finh, void *msg,
-             struct iobuf *iobuf)
+fuse_enosys(xlator_t *this, fuse_in_header_t *finh, void *msg,
+            struct iobuf *iobuf)
 {
-        send_fuse_err (this, finh, ENOSYS);
+    send_fuse_err(this, finh, ENOSYS);
 
-        GF_FREE (finh);
+    GF_FREE(finh);
 }
 
-
 static void
-fuse_destroy (xlator_t *this, fuse_in_header_t *finh, void *msg,
-              struct iobuf *iobuf)
+fuse_destroy(xlator_t *this, fuse_in_header_t *finh, void *msg,
+             struct iobuf *iobuf)
 {
-        send_fuse_err (this, finh, 0);
+    send_fuse_err(this, finh, 0);
 
-        GF_FREE (finh);
+    GF_FREE(finh);
 }
 
 int
-fuse_first_lookup (xlator_t *this)
-{
-        fuse_private_t            *priv = NULL;
-        loc_t                      loc = {0, };
-        xlator_t                  *xl = NULL;
-        dict_t                    *dict = NULL;
-        uuid_t                     gfid;
-        int                        ret = -1;
-        struct iatt                iatt = {0,};
-
-        priv = this->private;
-
-        loc.path = "/";
-        loc.name = "";
-        loc.inode = fuse_ino_to_inode (1, this);
-        gf_uuid_copy (loc.gfid, loc.inode->gfid);
-        loc.parent = NULL;
-
-        dict = dict_new ();
-
-        xl = priv->active_subvol;
-
-        memset (gfid, 0, 16);
-        gfid[15] = 1;
-        ret = dict_set_gfuuid (dict, "gfid-req", gfid, true);
-        if (ret) {
-                gf_log (xl->name, GF_LOG_ERROR, "failed to set 'gfid-req'");
-                goto out;
-        }
-
-        ret = syncop_lookup (xl, &loc, &iatt, NULL, dict, NULL);
-        DECODE_SYNCOP_ERR (ret);
-        if (ret < 0) {
-                gf_log (this->name, GF_LOG_ERROR,
-                        "first lookup on root failed (%s)",
-                        strerror (errno));
-                /* NOTE: Treat it as an error case. */
-                /* goto out; */ /* commented for preventing coverity warning */
-        }
-        /* Remove comment of above goto statement if you are adding any
-           more code here, before 'out' label */
+fuse_first_lookup(xlator_t *this)
+{
+    fuse_private_t *priv = NULL;
+    loc_t loc = {
+        0,
+    };
+    xlator_t *xl = NULL;
+    dict_t *dict = NULL;
+    uuid_t gfid;
+    int ret = -1;
+    struct iatt iatt = {
+        0,
+    };
+
+    priv = this->private;
+
+    loc.path = "/";
+    loc.name = "";
+    loc.inode = fuse_ino_to_inode(1, this);
+    gf_uuid_copy(loc.gfid, loc.inode->gfid);
+    loc.parent = NULL;
+
+    dict = dict_new();
+
+    xl = priv->active_subvol;
+
+    memset(gfid, 0, 16);
+    gfid[15] = 1;
+    ret = dict_set_gfuuid(dict, "gfid-req", gfid, true);
+    if (ret) {
+        gf_log(xl->name, GF_LOG_ERROR, "failed to set 'gfid-req'");
+        goto out;
+    }
+
+    ret = syncop_lookup(xl, &loc, &iatt, NULL, dict, NULL);
+    DECODE_SYNCOP_ERR(ret);
+    if (ret < 0) {
+        gf_log(this->name, GF_LOG_ERROR, "first lookup on root failed (%s)",
+               strerror(errno));
+        /* NOTE: Treat it as an error case. */
+        /* goto out; */ /* commented for preventing coverity warning */
+    }
+    /* Remove comment of above goto statement if you are adding any
+       more code here, before 'out' label */
 
 out:
-        dict_unref (dict);
-        inode_unref(loc.inode);
+    dict_unref(dict);
+    inode_unref(loc.inode);
 
-        return ret;
+    return ret;
 }
 
-
 int
-fuse_nameless_lookup (xlator_t *this, xlator_t *xl, uuid_t gfid, loc_t *loc)
-{
-        int          ret          = -1;
-        dict_t      *xattr_req    = NULL;
-        struct iatt  iatt         = {0, };
-        inode_t     *linked_inode = NULL;
-        uint64_t     ctx_value    = LOOKUP_NOT_NEEDED;
-
-        if ((loc == NULL) || (xl == NULL)) {
-                ret = -EINVAL;
-                goto out;
-        }
-
+fuse_nameless_lookup(xlator_t *this, xlator_t *xl, uuid_t gfid, loc_t *loc)
+{
+    int ret = -1;
+    dict_t *xattr_req = NULL;
+    struct iatt iatt = {
+        0,
+    };
+    inode_t *linked_inode = NULL;
+    uint64_t ctx_value = LOOKUP_NOT_NEEDED;
+
+    if ((loc == NULL) || (xl == NULL)) {
+        ret = -EINVAL;
+        goto out;
+    }
+
+    if (loc->inode == NULL) {
+        loc->inode = inode_new(xl->itable);
         if (loc->inode == NULL) {
-                loc->inode = inode_new (xl->itable);
-                if (loc->inode == NULL) {
-                        ret = -ENOMEM;
-                        goto out;
-                }
+            ret = -ENOMEM;
+            goto out;
         }
+    }
 
-        gf_uuid_copy (loc->gfid, gfid);
+    gf_uuid_copy(loc->gfid, gfid);
 
-        xattr_req = dict_new ();
-        if (xattr_req == NULL) {
-                ret = -ENOMEM;
-                goto out;
-        }
+    xattr_req = dict_new();
+    if (xattr_req == NULL) {
+        ret = -ENOMEM;
+        goto out;
+    }
 
-        ret = syncop_lookup (xl, loc, &iatt, NULL, xattr_req, NULL);
-        if (ret < 0)
-                goto out;
+    ret = syncop_lookup(xl, loc, &iatt, NULL, xattr_req, NULL);
+    if (ret < 0)
+        goto out;
 
-        linked_inode = inode_link (loc->inode, NULL, NULL, &iatt);
-        if (linked_inode == loc->inode)
-                inode_ctx_set (linked_inode, this, &ctx_value);
+    linked_inode = inode_link(loc->inode, NULL, NULL, &iatt);
+    if (linked_inode == loc->inode)
+        inode_ctx_set(linked_inode, this, &ctx_value);
 
-        inode_unref (loc->inode);
-        loc->inode = linked_inode;
+    inode_unref(loc->inode);
+    loc->inode = linked_inode;
 
-        ret = 0;
+    ret = 0;
 out:
-        if (xattr_req != NULL) {
-                dict_unref (xattr_req);
-        }
+    if (xattr_req != NULL) {
+        dict_unref(xattr_req);
+    }
 
-        return ret;
+    return ret;
 }
 
-
 int
-fuse_migrate_fd_open (xlator_t *this, fd_t *basefd, fd_t *oldfd,
-                      xlator_t *old_subvol, xlator_t *new_subvol)
-{
-        loc_t          loc       = {0, };
-        fd_t          *newfd     = NULL, *old_activefd = NULL;
-        fuse_fd_ctx_t *basefd_ctx = NULL;
-        fuse_fd_ctx_t *newfd_ctx = NULL;
-        int            ret       = 0, flags = 0;
-
-        ret = inode_path (basefd->inode, NULL, (char **)&loc.path);
-        if (ret < 0) {
-                gf_log ("glusterfs-fuse", GF_LOG_WARNING,
-                        "cannot construct path of gfid (%s) failed"
-                        "(old-subvolume:%s-%d new-subvolume:%s-%d)",
-                        uuid_utoa (basefd->inode->gfid),
-                        old_subvol->name, old_subvol->graph->id,
-                        new_subvol->name, new_subvol->graph->id);
-                goto out;
-        }
-
-        gf_uuid_copy (loc.gfid, basefd->inode->gfid);
-
-        loc.inode = inode_find (new_subvol->itable, basefd->inode->gfid);
-
-        if (loc.inode == NULL) {
-                ret = fuse_nameless_lookup (this, new_subvol,
-                                            basefd->inode->gfid, &loc);
-                if (ret < 0) {
-                        gf_log ("glusterfs-fuse", GF_LOG_WARNING,
-                                "name-less lookup of gfid (%s) failed (%s)"
-                                "(old-subvolume:%s-%d new-subvolume:%s-%d)",
-                                uuid_utoa (basefd->inode->gfid),
-                                strerror (-ret),
-                                old_subvol->name, old_subvol->graph->id,
-                                new_subvol->name, new_subvol->graph->id);
-                        ret = -1;
-                        goto out;
-                }
-
-        }
-
-        basefd_ctx = fuse_fd_ctx_get (this, basefd);
-        GF_VALIDATE_OR_GOTO ("glusterfs-fuse", basefd_ctx, out);
-
-        newfd = fd_create (loc.inode, basefd->pid);
-        if (newfd == NULL) {
-                gf_log ("glusterfs-fuse", GF_LOG_WARNING,
-                        "cannot create new fd, hence not migrating basefd "
-                        "(ptr:%p inode-gfid:%s) "
-                        "(old-subvolume:%s-%d new-subvolume:%s-%d)", basefd,
-                        uuid_utoa (loc.inode->gfid),
-                        old_subvol->name, old_subvol->graph->id,
-                        new_subvol->name, new_subvol->graph->id);
-                ret = -1;
-                goto out;
-        }
-
-        newfd->flags = basefd->flags;
-	if (newfd->lk_ctx)
-		fd_lk_ctx_unref (newfd->lk_ctx);
-
-        newfd->lk_ctx = fd_lk_ctx_ref (oldfd->lk_ctx);
-
-        newfd_ctx = fuse_fd_ctx_check_n_create (this, newfd);
-        GF_VALIDATE_OR_GOTO ("glusterfs-fuse", newfd_ctx, out);
-
-        if (IA_ISDIR (basefd->inode->ia_type)) {
-                ret = syncop_opendir (new_subvol, &loc, newfd, NULL, NULL);
-        } else {
-                flags = basefd->flags & ~(O_CREAT | O_EXCL | O_TRUNC);
-                ret = syncop_open (new_subvol, &loc, flags, newfd, NULL, NULL);
-        }
-
+fuse_migrate_fd_open(xlator_t *this, fd_t *basefd, fd_t *oldfd,
+                     xlator_t *old_subvol, xlator_t *new_subvol)
+{
+    loc_t loc = {
+        0,
+    };
+    fd_t *newfd = NULL, *old_activefd = NULL;
+    fuse_fd_ctx_t *basefd_ctx = NULL;
+    fuse_fd_ctx_t *newfd_ctx = NULL;
+    int ret = 0, flags = 0;
+
+    ret = inode_path(basefd->inode, NULL, (char **)&loc.path);
+    if (ret < 0) {
+        gf_log("glusterfs-fuse", GF_LOG_WARNING,
+               "cannot construct path of gfid (%s) failed"
+               "(old-subvolume:%s-%d new-subvolume:%s-%d)",
+               uuid_utoa(basefd->inode->gfid), old_subvol->name,
+               old_subvol->graph->id, new_subvol->name, new_subvol->graph->id);
+        goto out;
+    }
+
+    gf_uuid_copy(loc.gfid, basefd->inode->gfid);
+
+    loc.inode = inode_find(new_subvol->itable, basefd->inode->gfid);
+
+    if (loc.inode == NULL) {
+        ret = fuse_nameless_lookup(this, new_subvol, basefd->inode->gfid, &loc);
         if (ret < 0) {
-                gf_log ("glusterfs-fuse", GF_LOG_WARNING,
-                        "open on basefd (ptr:%p inode-gfid:%s) failed (%s)"
-                        "(old-subvolume:%s-%d new-subvolume:%s-%d)", basefd,
-                        uuid_utoa (basefd->inode->gfid), strerror (-ret),
-                        old_subvol->name, old_subvol->graph->id,
-                        new_subvol->name, new_subvol->graph->id);
-                ret = -1;
-                goto out;
-        }
-
-        fd_bind (newfd);
-
-        LOCK (&basefd->lock);
-        {
-                if (basefd_ctx->activefd != NULL) {
-                        old_activefd = basefd_ctx->activefd;
-                }
-
-                basefd_ctx->activefd = newfd;
-        }
-        UNLOCK (&basefd->lock);
-
-        if (old_activefd != NULL) {
-                fd_unref (old_activefd);
-        }
-
-        gf_log ("glusterfs-fuse", GF_LOG_INFO,
-                "migrated basefd (%p) to newfd (%p) (inode-gfid:%s)"
-                "(old-subvolume:%s-%d new-subvolume:%s-%d)", basefd, newfd,
-                uuid_utoa (basefd->inode->gfid),
-		old_subvol->name, old_subvol->graph->id,
-                new_subvol->name, new_subvol->graph->id);
-
-        ret = 0;
+            gf_log("glusterfs-fuse", GF_LOG_WARNING,
+                   "name-less lookup of gfid (%s) failed (%s)"
+                   "(old-subvolume:%s-%d new-subvolume:%s-%d)",
+                   uuid_utoa(basefd->inode->gfid), strerror(-ret),
+                   old_subvol->name, old_subvol->graph->id, new_subvol->name,
+                   new_subvol->graph->id);
+            ret = -1;
+            goto out;
+        }
+    }
+
+    basefd_ctx = fuse_fd_ctx_get(this, basefd);
+    GF_VALIDATE_OR_GOTO("glusterfs-fuse", basefd_ctx, out);
+
+    newfd = fd_create(loc.inode, basefd->pid);
+    if (newfd == NULL) {
+        gf_log("glusterfs-fuse", GF_LOG_WARNING,
+               "cannot create new fd, hence not migrating basefd "
+               "(ptr:%p inode-gfid:%s) "
+               "(old-subvolume:%s-%d new-subvolume:%s-%d)",
+               basefd, uuid_utoa(loc.inode->gfid), old_subvol->name,
+               old_subvol->graph->id, new_subvol->name, new_subvol->graph->id);
+        ret = -1;
+        goto out;
+    }
+
+    newfd->flags = basefd->flags;
+    if (newfd->lk_ctx)
+        fd_lk_ctx_unref(newfd->lk_ctx);
+
+    newfd->lk_ctx = fd_lk_ctx_ref(oldfd->lk_ctx);
+
+    newfd_ctx = fuse_fd_ctx_check_n_create(this, newfd);
+    GF_VALIDATE_OR_GOTO("glusterfs-fuse", newfd_ctx, out);
+
+    if (IA_ISDIR(basefd->inode->ia_type)) {
+        ret = syncop_opendir(new_subvol, &loc, newfd, NULL, NULL);
+    } else {
+        flags = basefd->flags & ~(O_CREAT | O_EXCL | O_TRUNC);
+        ret = syncop_open(new_subvol, &loc, flags, newfd, NULL, NULL);
+    }
+
+    if (ret < 0) {
+        gf_log("glusterfs-fuse", GF_LOG_WARNING,
+               "open on basefd (ptr:%p inode-gfid:%s) failed (%s)"
+               "(old-subvolume:%s-%d new-subvolume:%s-%d)",
+               basefd, uuid_utoa(basefd->inode->gfid), strerror(-ret),
+               old_subvol->name, old_subvol->graph->id, new_subvol->name,
+               new_subvol->graph->id);
+        ret = -1;
+        goto out;
+    }
+
+    fd_bind(newfd);
+
+    LOCK(&basefd->lock);
+    {
+        if (basefd_ctx->activefd != NULL) {
+            old_activefd = basefd_ctx->activefd;
+        }
+
+        basefd_ctx->activefd = newfd;
+    }
+    UNLOCK(&basefd->lock);
+
+    if (old_activefd != NULL) {
+        fd_unref(old_activefd);
+    }
+
+    gf_log("glusterfs-fuse", GF_LOG_INFO,
+           "migrated basefd (%p) to newfd (%p) (inode-gfid:%s)"
+           "(old-subvolume:%s-%d new-subvolume:%s-%d)",
+           basefd, newfd, uuid_utoa(basefd->inode->gfid), old_subvol->name,
+           old_subvol->graph->id, new_subvol->name, new_subvol->graph->id);
+
+    ret = 0;
 
 out:
-        loc_wipe (&loc);
+    loc_wipe(&loc);
 
-        return ret;
+    return ret;
 }
 
 int
-fuse_migrate_locks (xlator_t *this, fd_t *basefd, fd_t *oldfd,
-                    xlator_t *old_subvol, xlator_t *new_subvol)
+fuse_migrate_locks(xlator_t *this, fd_t *basefd, fd_t *oldfd,
+                   xlator_t *old_subvol, xlator_t *new_subvol)
 {
-        int	 ret      = -1;
-        dict_t	*lockinfo = NULL;
-        void    *ptr      = NULL;
-	fd_t    *newfd    = NULL;
-        fuse_fd_ctx_t *basefd_ctx         = NULL;
-
-
-	if (!oldfd->lk_ctx || fd_lk_ctx_empty (oldfd->lk_ctx))
-		return 0;
-
-        basefd_ctx = fuse_fd_ctx_get (this, basefd);
-        GF_VALIDATE_OR_GOTO ("glusterfs-fuse", basefd_ctx, out);
+    int ret = -1;
+    dict_t *lockinfo = NULL;
+    void *ptr = NULL;
+    fd_t *newfd = NULL;
+    fuse_fd_ctx_t *basefd_ctx = NULL;
 
-        LOCK (&basefd->lock);
-        {
-                newfd = fd_ref (basefd_ctx->activefd);
-        }
-        UNLOCK (&basefd->lock);
-
-        ret = syncop_fgetxattr (old_subvol, oldfd, &lockinfo,
-                                GF_XATTR_LOCKINFO_KEY, NULL, NULL);
-        if (ret < 0) {
-                gf_log (this->name, GF_LOG_WARNING,
-			"getting lockinfo failed while migrating locks"
-			"(oldfd:%p newfd:%p inode-gfid:%s)"
-			"(old-subvol:%s-%d new-subvol:%s-%d)",
-			oldfd, newfd, uuid_utoa (newfd->inode->gfid),
-			old_subvol->name, old_subvol->graph->id,
-			new_subvol->name, new_subvol->graph->id);
-                ret = -1;
-                goto out;
-        }
-
-        ret = dict_get_ptr (lockinfo, GF_XATTR_LOCKINFO_KEY, &ptr);
-        if (ptr == NULL) {
-                ret = 0;
-                gf_log (this->name, GF_LOG_INFO,
-                        "No lockinfo present on any of the bricks "
-			"(oldfd: %p newfd:%p inode-gfid:%s) "
-                        "(old-subvol:%s-%d new-subvol:%s-%d)",
-			oldfd, newfd, uuid_utoa (newfd->inode->gfid),
-			old_subvol->name, old_subvol->graph->id,
-			new_subvol->name, new_subvol->graph->id);
-
-                goto out;
-        }
+    if (!oldfd->lk_ctx || fd_lk_ctx_empty(oldfd->lk_ctx))
+        return 0;
 
-        ret = syncop_fsetxattr (new_subvol, newfd, lockinfo, 0, NULL, NULL);
-        if (ret < 0) {
-                gf_log (this->name, GF_LOG_WARNING,
-			"migrating locks failed (oldfd:%p newfd:%p "
-			"inode-gfid:%s) (old-subvol:%s-%d new-subvol:%s-%d)",
-			oldfd, newfd, uuid_utoa (newfd->inode->gfid),
-			old_subvol->name, old_subvol->graph->id,
-			new_subvol->name, new_subvol->graph->id);
-                ret = -1;
-                goto out;
-        }
+    basefd_ctx = fuse_fd_ctx_get(this, basefd);
+    GF_VALIDATE_OR_GOTO("glusterfs-fuse", basefd_ctx, out);
+
+    LOCK(&basefd->lock);
+    {
+        newfd = fd_ref(basefd_ctx->activefd);
+    }
+    UNLOCK(&basefd->lock);
+
+    ret = syncop_fgetxattr(old_subvol, oldfd, &lockinfo, GF_XATTR_LOCKINFO_KEY,
+                           NULL, NULL);
+    if (ret < 0) {
+        gf_log(this->name, GF_LOG_WARNING,
+               "getting lockinfo failed while migrating locks"
+               "(oldfd:%p newfd:%p inode-gfid:%s)"
+               "(old-subvol:%s-%d new-subvol:%s-%d)",
+               oldfd, newfd, uuid_utoa(newfd->inode->gfid), old_subvol->name,
+               old_subvol->graph->id, new_subvol->name, new_subvol->graph->id);
+        ret = -1;
+        goto out;
+    }
+
+    ret = dict_get_ptr(lockinfo, GF_XATTR_LOCKINFO_KEY, &ptr);
+    if (ptr == NULL) {
+        ret = 0;
+        gf_log(this->name, GF_LOG_INFO,
+               "No lockinfo present on any of the bricks "
+               "(oldfd: %p newfd:%p inode-gfid:%s) "
+               "(old-subvol:%s-%d new-subvol:%s-%d)",
+               oldfd, newfd, uuid_utoa(newfd->inode->gfid), old_subvol->name,
+               old_subvol->graph->id, new_subvol->name, new_subvol->graph->id);
+
+        goto out;
+    }
+
+    ret = syncop_fsetxattr(new_subvol, newfd, lockinfo, 0, NULL, NULL);
+    if (ret < 0) {
+        gf_log(this->name, GF_LOG_WARNING,
+               "migrating locks failed (oldfd:%p newfd:%p "
+               "inode-gfid:%s) (old-subvol:%s-%d new-subvol:%s-%d)",
+               oldfd, newfd, uuid_utoa(newfd->inode->gfid), old_subvol->name,
+               old_subvol->graph->id, new_subvol->name, new_subvol->graph->id);
+        ret = -1;
+        goto out;
+    }
 
 out:
-	if (newfd)
-		fd_unref (newfd);
+    if (newfd)
+        fd_unref(newfd);
 
-        if (lockinfo != NULL) {
-                dict_unref (lockinfo);
-        }
+    if (lockinfo != NULL) {
+        dict_unref(lockinfo);
+    }
 
-        return ret;
+    return ret;
 }
 
-
 int
-fuse_migrate_fd (xlator_t *this, fd_t *basefd, xlator_t *old_subvol,
-                 xlator_t *new_subvol)
-{
-        int            ret                = -1;
-        char           create_in_progress = 0;
-        fuse_fd_ctx_t *basefd_ctx         = NULL;
-        fd_t          *oldfd              = NULL;
-
-        basefd_ctx = fuse_fd_ctx_get (this, basefd);
-        GF_VALIDATE_OR_GOTO ("glusterfs-fuse", basefd_ctx, out);
-
-        LOCK (&basefd->lock);
-        {
-                oldfd = basefd_ctx->activefd ? basefd_ctx->activefd
-                        : basefd;
-                fd_ref (oldfd);
+fuse_migrate_fd(xlator_t *this, fd_t *basefd, xlator_t *old_subvol,
+                xlator_t *new_subvol)
+{
+    int ret = -1;
+    char create_in_progress = 0;
+    fuse_fd_ctx_t *basefd_ctx = NULL;
+    fd_t *oldfd = NULL;
+
+    basefd_ctx = fuse_fd_ctx_get(this, basefd);
+    GF_VALIDATE_OR_GOTO("glusterfs-fuse", basefd_ctx, out);
+
+    LOCK(&basefd->lock);
+    {
+        oldfd = basefd_ctx->activefd ? basefd_ctx->activefd : basefd;
+        fd_ref(oldfd);
+    }
+    UNLOCK(&basefd->lock);
+
+    LOCK(&oldfd->inode->lock);
+    {
+        if (gf_uuid_is_null(oldfd->inode->gfid)) {
+            create_in_progress = 1;
+        } else {
+            create_in_progress = 0;
         }
-        UNLOCK (&basefd->lock);
+    }
+    UNLOCK(&oldfd->inode->lock);
 
-        LOCK (&oldfd->inode->lock);
-        {
-                if (gf_uuid_is_null (oldfd->inode->gfid)) {
-                        create_in_progress = 1;
-                } else {
-                        create_in_progress = 0;
-                }
-        }
-        UNLOCK (&oldfd->inode->lock);
-
-        if (create_in_progress) {
-                gf_log ("glusterfs-fuse", GF_LOG_INFO,
-                        "create call on fd (%p) is in progress "
-                        "(basefd-ptr:%p basefd-inode.gfid:%s), "
-                        "hence deferring migration till application does an "
-                        "fd based operation on this fd"
-                        "(old-subvolume:%s-%d, new-subvolume:%s-%d)",
-                        oldfd, basefd, uuid_utoa (basefd->inode->gfid),
-                        old_subvol->name, old_subvol->graph->id,
-                        new_subvol->name, new_subvol->graph->id);
-
-                ret = 0;
-                goto out;
-        }
+    if (create_in_progress) {
+        gf_log("glusterfs-fuse", GF_LOG_INFO,
+               "create call on fd (%p) is in progress "
+               "(basefd-ptr:%p basefd-inode.gfid:%s), "
+               "hence deferring migration till application does an "
+               "fd based operation on this fd"
+               "(old-subvolume:%s-%d, new-subvolume:%s-%d)",
+               oldfd, basefd, uuid_utoa(basefd->inode->gfid), old_subvol->name,
+               old_subvol->graph->id, new_subvol->name, new_subvol->graph->id);
 
-        if (oldfd->inode->table->xl == old_subvol) {
-                if (IA_ISDIR (oldfd->inode->ia_type))
-                        ret = syncop_fsyncdir (old_subvol, oldfd, 0, NULL,
-                                               NULL);
-                else
-                        ret = syncop_fsync (old_subvol, oldfd, 0, NULL, NULL,
-                                            NULL, NULL);
-
-                if (ret < 0) {
-                        gf_log ("glusterfs-fuse", GF_LOG_WARNING,
-                                "syncop_fsync(dir) failed (%s) on fd (%p)"
-                                "(basefd:%p basefd-inode.gfid:%s) "
-                                "(old-subvolume:%s-%d new-subvolume:%s-%d)",
-                                strerror (-ret), oldfd, basefd,
-                                uuid_utoa (basefd->inode->gfid),
-                                old_subvol->name, old_subvol->graph->id,
-                                new_subvol->name, new_subvol->graph->id);
-                }
-        } else {
-                gf_log ("glusterfs-fuse", GF_LOG_WARNING,
-                        "basefd (ptr:%p inode-gfid:%s) was not "
-                        "migrated during previous graph switch"
-                        "(old-subvolume:%s-%d new-subvolume: %s-%d)", basefd,
-                        basefd->inode->gfid,
-                        old_subvol->name, old_subvol->graph->id,
-                        new_subvol->name, new_subvol->graph->id);
-        }
+        ret = 0;
+        goto out;
+    }
 
-        ret = fuse_migrate_fd_open (this, basefd, oldfd, old_subvol,
-                                    new_subvol);
-        if (ret < 0) {
-                gf_log (this->name, GF_LOG_WARNING, "open corresponding to "
-                        "basefd (ptr:%p inode-gfid:%s) in new graph failed "
-                        "(old-subvolume:%s-%d new-subvolume:%s-%d)", basefd,
-                        uuid_utoa (basefd->inode->gfid), old_subvol->name,
-                        old_subvol->graph->id, new_subvol->name,
-                        new_subvol->graph->id);
-                goto out;
-        }
+    if (oldfd->inode->table->xl == old_subvol) {
+        if (IA_ISDIR(oldfd->inode->ia_type))
+            ret = syncop_fsyncdir(old_subvol, oldfd, 0, NULL, NULL);
+        else
+            ret = syncop_fsync(old_subvol, oldfd, 0, NULL, NULL, NULL, NULL);
 
-        ret = fuse_migrate_locks (this, basefd, oldfd, old_subvol,
-                                  new_subvol);
         if (ret < 0) {
-                gf_log (this->name, GF_LOG_WARNING,
-                        "migrating locks from old-subvolume (%s-%d) to "
-                        "new-subvolume (%s-%d) failed (inode-gfid:%s oldfd:%p "
-                        "basefd:%p)", old_subvol->name, old_subvol->graph->id,
-                        new_subvol->name, new_subvol->graph->id,
-                        uuid_utoa (basefd->inode->gfid), oldfd, basefd);
-
-        }
+            gf_log("glusterfs-fuse", GF_LOG_WARNING,
+                   "syncop_fsync(dir) failed (%s) on fd (%p)"
+                   "(basefd:%p basefd-inode.gfid:%s) "
+                   "(old-subvolume:%s-%d new-subvolume:%s-%d)",
+                   strerror(-ret), oldfd, basefd,
+                   uuid_utoa(basefd->inode->gfid), old_subvol->name,
+                   old_subvol->graph->id, new_subvol->name,
+                   new_subvol->graph->id);
+        }
+    } else {
+        gf_log("glusterfs-fuse", GF_LOG_WARNING,
+               "basefd (ptr:%p inode-gfid:%s) was not "
+               "migrated during previous graph switch"
+               "(old-subvolume:%s-%d new-subvolume: %s-%d)",
+               basefd, basefd->inode->gfid, old_subvol->name,
+               old_subvol->graph->id, new_subvol->name, new_subvol->graph->id);
+    }
+
+    ret = fuse_migrate_fd_open(this, basefd, oldfd, old_subvol, new_subvol);
+    if (ret < 0) {
+        gf_log(this->name, GF_LOG_WARNING,
+               "open corresponding to "
+               "basefd (ptr:%p inode-gfid:%s) in new graph failed "
+               "(old-subvolume:%s-%d new-subvolume:%s-%d)",
+               basefd, uuid_utoa(basefd->inode->gfid), old_subvol->name,
+               old_subvol->graph->id, new_subvol->name, new_subvol->graph->id);
+        goto out;
+    }
+
+    ret = fuse_migrate_locks(this, basefd, oldfd, old_subvol, new_subvol);
+    if (ret < 0) {
+        gf_log(this->name, GF_LOG_WARNING,
+               "migrating locks from old-subvolume (%s-%d) to "
+               "new-subvolume (%s-%d) failed (inode-gfid:%s oldfd:%p "
+               "basefd:%p)",
+               old_subvol->name, old_subvol->graph->id, new_subvol->name,
+               new_subvol->graph->id, uuid_utoa(basefd->inode->gfid), oldfd,
+               basefd);
+    }
 out:
-        if (ret < 0) {
-                gf_log (this->name, GF_LOG_WARNING, "migration of basefd "
-                        "(ptr:%p inode-gfid:%s) failed"
-                        "(old-subvolume:%s-%d new-subvolume:%s-%d)", basefd,
-                        oldfd ? uuid_utoa (oldfd->inode->gfid) : NULL,
-                        old_subvol->name, old_subvol->graph->id,
-                        new_subvol->name, new_subvol->graph->id);
-        }
+    if (ret < 0) {
+        gf_log(this->name, GF_LOG_WARNING,
+               "migration of basefd "
+               "(ptr:%p inode-gfid:%s) failed"
+               "(old-subvolume:%s-%d new-subvolume:%s-%d)",
+               basefd, oldfd ? uuid_utoa(oldfd->inode->gfid) : NULL,
+               old_subvol->name, old_subvol->graph->id, new_subvol->name,
+               new_subvol->graph->id);
+    }
 
-        fd_unref (oldfd);
+    fd_unref(oldfd);
 
-        return ret;
+    return ret;
 }
 
-
 int
-fuse_handle_opened_fds (xlator_t *this, xlator_t *old_subvol,
-                        xlator_t *new_subvol)
-{
-        fuse_private_t *priv      = NULL;
-        fdentry_t      *fdentries = NULL;
-        uint32_t        count     = 0;
-        fdtable_t      *fdtable   = NULL;
-        int             i         = 0;
-        fd_t           *fd        = NULL;
-        int32_t         ret       = 0;
-        fuse_fd_ctx_t  *fdctx     = NULL;
-
-        priv = this->private;
-
-        fdtable = priv->fdtable;
-
-        fdentries = gf_fd_fdtable_copy_all_fds (fdtable, &count);
-        if (fdentries != NULL) {
-                for (i = 0; i < count; i++) {
-                        fd = fdentries[i].fd;
-                        if (fd == NULL)
-                                continue;
-
-                        ret = fuse_migrate_fd (this, fd, old_subvol,
-                                               new_subvol);
-
-                        fdctx = fuse_fd_ctx_get (this, fd);
-                        if (fdctx) {
-                                LOCK (&fd->lock);
-                                {
-                                        if (ret < 0) {
-                                                fdctx->migration_failed = 1;
-                                        } else {
-                                                fdctx->migration_failed = 0;
-                                        }
-                                }
-                                UNLOCK (&fd->lock);
-                        }
-                }
+fuse_handle_opened_fds(xlator_t *this, xlator_t *old_subvol,
+                       xlator_t *new_subvol)
+{
+    fuse_private_t *priv = NULL;
+    fdentry_t *fdentries = NULL;
+    uint32_t count = 0;
+    fdtable_t *fdtable = NULL;
+    int i = 0;
+    fd_t *fd = NULL;
+    int32_t ret = 0;
+    fuse_fd_ctx_t *fdctx = NULL;
+
+    priv = this->private;
+
+    fdtable = priv->fdtable;
+
+    fdentries = gf_fd_fdtable_copy_all_fds(fdtable, &count);
+    if (fdentries != NULL) {
+        for (i = 0; i < count; i++) {
+            fd = fdentries[i].fd;
+            if (fd == NULL)
+                continue;
+
+            ret = fuse_migrate_fd(this, fd, old_subvol, new_subvol);
 
-                for (i = 0; i < count ; i++) {
-                        fd = fdentries[i].fd;
-                        if (fd)
-                                fd_unref (fd);
+            fdctx = fuse_fd_ctx_get(this, fd);
+            if (fdctx) {
+                LOCK(&fd->lock);
+                {
+                    if (ret < 0) {
+                        fdctx->migration_failed = 1;
+                    } else {
+                        fdctx->migration_failed = 0;
+                    }
                 }
+                UNLOCK(&fd->lock);
+            }
+        }
 
-                GF_FREE (fdentries);
+        for (i = 0; i < count; i++) {
+            fd = fdentries[i].fd;
+            if (fd)
+                fd_unref(fd);
         }
 
-        return 0;
-}
+        GF_FREE(fdentries);
+    }
 
+    return 0;
+}
 
 static int
-fuse_handle_blocked_locks (xlator_t *this, xlator_t *old_subvol,
-                           xlator_t *new_subvol)
+fuse_handle_blocked_locks(xlator_t *this, xlator_t *old_subvol,
+                          xlator_t *new_subvol)
 {
-        return 0;
+    return 0;
 }
 
-
 static int
-fuse_graph_switch_task (void *data)
+fuse_graph_switch_task(void *data)
 {
-        fuse_graph_switch_args_t *args = NULL;
+    fuse_graph_switch_args_t *args = NULL;
 
-        args = data;
-        if (args == NULL) {
-                goto out;
-        }
+    args = data;
+    if (args == NULL) {
+        goto out;
+    }
 
-        /* don't change the order of handling open fds and blocked locks, since
-         * the act of opening files also reacquires granted locks in new graph.
-         */
-        fuse_handle_opened_fds (args->this, args->old_subvol, args->new_subvol);
+    /* don't change the order of handling open fds and blocked locks, since
+     * the act of opening files also reacquires granted locks in new graph.
+     */
+    fuse_handle_opened_fds(args->this, args->old_subvol, args->new_subvol);
 
-        fuse_handle_blocked_locks (args->this, args->old_subvol,
-                                   args->new_subvol);
+    fuse_handle_blocked_locks(args->this, args->old_subvol, args->new_subvol);
 
 out:
-        return 0;
+    return 0;
 }
 
-
 fuse_graph_switch_args_t *
-fuse_graph_switch_args_alloc (void)
+fuse_graph_switch_args_alloc(void)
 {
-        fuse_graph_switch_args_t *args = NULL;
+    fuse_graph_switch_args_t *args = NULL;
 
-        args = GF_CALLOC (1, sizeof (*args), gf_fuse_mt_graph_switch_args_t);
-        if (args == NULL) {
-                goto out;
-        }
+    args = GF_CALLOC(1, sizeof(*args), gf_fuse_mt_graph_switch_args_t);
+    if (args == NULL) {
+        goto out;
+    }
 
 out:
-        return args;
+    return args;
 }
 
-
 void
-fuse_graph_switch_args_destroy (fuse_graph_switch_args_t *args)
+fuse_graph_switch_args_destroy(fuse_graph_switch_args_t *args)
 {
-        if (args == NULL) {
-                goto out;
-        }
+    if (args == NULL) {
+        goto out;
+    }
 
-        GF_FREE (args);
+    GF_FREE(args);
 out:
-        return;
+    return;
 }
 
-
 int
-fuse_handle_graph_switch (xlator_t *this, xlator_t *old_subvol,
-                          xlator_t *new_subvol)
-{
-        call_frame_t             *frame = NULL;
-        int32_t                   ret   = -1;
-        fuse_graph_switch_args_t *args  = NULL;
+fuse_handle_graph_switch(xlator_t *this, xlator_t *old_subvol,
+                         xlator_t *new_subvol)
+{
+    call_frame_t *frame = NULL;
+    int32_t ret = -1;
+    fuse_graph_switch_args_t *args = NULL;
+
+    frame = create_frame(this, this->ctx->pool);
+    if (frame == NULL) {
+        goto out;
+    }
+
+    args = fuse_graph_switch_args_alloc();
+    if (args == NULL) {
+        goto out;
+    }
+
+    args->this = this;
+    args->old_subvol = old_subvol;
+    args->new_subvol = new_subvol;
+
+    ret = synctask_new(this->ctx->env, fuse_graph_switch_task, NULL, frame,
+                       args);
+    if (ret == -1) {
+        gf_log(this->name, GF_LOG_WARNING,
+               "starting sync-task to "
+               "handle graph switch failed");
+        goto out;
+    }
+
+    ret = 0;
+out:
+    if (args != NULL) {
+        fuse_graph_switch_args_destroy(args);
+    }
 
-        frame = create_frame (this, this->ctx->pool);
-        if (frame == NULL) {
-                goto out;
-        }
+    if (frame != NULL) {
+        STACK_DESTROY(frame->root);
+    }
 
-        args = fuse_graph_switch_args_alloc ();
-        if (args == NULL) {
-                goto out;
+    return ret;
+}
+
+int
+fuse_graph_sync(xlator_t *this)
+{
+    fuse_private_t *priv = NULL;
+    int need_first_lookup = 0;
+    int ret = 0;
+    int new_graph_id = 0;
+    xlator_t *old_subvol = NULL, *new_subvol = NULL;
+    uint64_t winds_on_old_subvol = 0;
+
+    priv = this->private;
+
+    pthread_mutex_lock(&priv->sync_mutex);
+    {
+        if (!priv->next_graph)
+            goto unlock;
+
+        old_subvol = priv->active_subvol;
+        new_subvol = priv->active_subvol = priv->next_graph->top;
+        new_graph_id = priv->next_graph->id;
+        priv->next_graph = NULL;
+        need_first_lookup = 1;
+        priv->handle_graph_switch = _gf_true;
+
+        while (!priv->event_recvd) {
+            ret = pthread_cond_wait(&priv->sync_cond, &priv->sync_mutex);
+            if (ret != 0) {
+                gf_log(this->name, GF_LOG_DEBUG,
+                       "timedwait returned non zero value "
+                       "ret: %d errno: %d",
+                       ret, errno);
+                break;
+            }
         }
+    }
+unlock:
+    pthread_mutex_unlock(&priv->sync_mutex);
 
-        args->this = this;
-        args->old_subvol = old_subvol;
-        args->new_subvol = new_subvol;
+    if (need_first_lookup) {
+        gf_log("fuse", GF_LOG_INFO, "switched to graph %d", new_graph_id);
+        fuse_first_lookup(this);
+    }
 
-        ret = synctask_new (this->ctx->env, fuse_graph_switch_task, NULL, frame,
-                            args);
-        if (ret == -1) {
-                gf_log (this->name, GF_LOG_WARNING, "starting sync-task to "
-                        "handle graph switch failed");
-                goto out;
-        }
+    if ((old_subvol != NULL) && (new_subvol != NULL)) {
+        fuse_handle_graph_switch(this, old_subvol, new_subvol);
 
-        ret = 0;
-out:
-        if (args != NULL) {
-                fuse_graph_switch_args_destroy (args);
+        pthread_mutex_lock(&priv->sync_mutex);
+        {
+            old_subvol->switched = 1;
+            winds_on_old_subvol = old_subvol->winds;
+            priv->handle_graph_switch = _gf_false;
+            pthread_cond_broadcast(&priv->migrate_cond);
         }
+        pthread_mutex_unlock(&priv->sync_mutex);
 
-        if (frame != NULL) {
-                STACK_DESTROY (frame->root);
+        if (winds_on_old_subvol == 0) {
+            xlator_notify(old_subvol, GF_EVENT_PARENT_DOWN, old_subvol, NULL);
+        }
+    } else {
+        pthread_mutex_lock(&priv->sync_mutex);
+        {
+            priv->handle_graph_switch = _gf_false;
+            pthread_cond_broadcast(&priv->migrate_cond);
         }
+        pthread_mutex_unlock(&priv->sync_mutex);
+    }
 
-        return ret;
+    return 0;
 }
 
-
 int
-fuse_graph_sync (xlator_t *this)
+fuse_get_mount_status(xlator_t *this)
 {
-        fuse_private_t *priv                = NULL;
-        int             need_first_lookup   = 0;
-        int             ret                 = 0;
-        int             new_graph_id        = 0;
-        xlator_t       *old_subvol          = NULL, *new_subvol = NULL;
-        uint64_t        winds_on_old_subvol = 0;
+    int kid_status = -1;
+    fuse_private_t *priv = this->private;
 
-        priv = this->private;
+    if (sys_read(priv->status_pipe[0], &kid_status, sizeof(kid_status)) < 0) {
+        gf_log(this->name, GF_LOG_ERROR, "could not get mount status");
+        kid_status = -1;
+    }
+    gf_log(this->name, GF_LOG_DEBUG, "mount status is %d", kid_status);
 
-        pthread_mutex_lock (&priv->sync_mutex);
-        {
-                if (!priv->next_graph)
-                        goto unlock;
-
-                old_subvol = priv->active_subvol;
-                new_subvol = priv->active_subvol = priv->next_graph->top;
-                new_graph_id = priv->next_graph->id;
-                priv->next_graph = NULL;
-                need_first_lookup = 1;
-                priv->handle_graph_switch = _gf_true;
-
-                while (!priv->event_recvd) {
-                        ret = pthread_cond_wait (&priv->sync_cond,
-                                                 &priv->sync_mutex);
-                        if (ret != 0) {
-                                  gf_log (this->name, GF_LOG_DEBUG,
-                                          "timedwait returned non zero value "
-                                          "ret: %d errno: %d", ret, errno);
-                                  break;
-                        }
-                }
-        }
-unlock:
-        pthread_mutex_unlock (&priv->sync_mutex);
-
-        if (need_first_lookup) {
-                gf_log ("fuse", GF_LOG_INFO, "switched to graph %d",
-                        new_graph_id);
-                fuse_first_lookup (this);
-        }
+    sys_close(priv->status_pipe[0]);
+    sys_close(priv->status_pipe[1]);
+    return kid_status;
+}
 
-        if ((old_subvol != NULL) && (new_subvol != NULL)) {
-                fuse_handle_graph_switch (this, old_subvol, new_subvol);
+static void *
+fuse_thread_proc(void *data)
+{
+    char *mount_point = NULL;
+    xlator_t *this = NULL;
+    fuse_private_t *priv = NULL;
+    ssize_t res = 0;
+    struct iobuf *iobuf = NULL;
+    fuse_in_header_t *finh = NULL;
+    struct iovec iov_in[2];
+    void *msg = NULL;
+    const size_t msg0_size = sizeof(*finh) + 128;
+    fuse_handler_t **fuse_ops = NULL;
+    struct pollfd pfd[2] = {{
+        0,
+    }};
+
+    this = data;
+    priv = this->private;
+    fuse_ops = priv->fuse_ops;
+
+    THIS = this;
+
+    iov_in[0].iov_len = sizeof(*finh) + sizeof(struct fuse_write_in);
+    iov_in[1].iov_len = ((struct iobuf_pool *)this->ctx->iobuf_pool)
+                            ->default_page_size;
+    priv->msg0_len_p = &iov_in[0].iov_len;
+
+    for (;;) {
+        /* THIS has to be reset here */
+        THIS = this;
 
-                pthread_mutex_lock (&priv->sync_mutex);
-                {
-                        old_subvol->switched = 1;
-                        winds_on_old_subvol = old_subvol->winds;
-                        priv->handle_graph_switch = _gf_false;
-                        pthread_cond_broadcast (&priv->migrate_cond);
+        pthread_mutex_lock(&priv->sync_mutex);
+        {
+            if (!priv->mount_finished) {
+                memset(pfd, 0, sizeof(pfd));
+                pfd[0].fd = priv->status_pipe[0];
+                pfd[0].events = POLLIN | POLLHUP | POLLERR;
+                pfd[1].fd = priv->fd;
+                pfd[1].events = POLLIN | POLLHUP | POLLERR;
+                if (poll(pfd, 2, -1) < 0) {
+                    gf_log(this->name, GF_LOG_ERROR, "poll error %s",
+                           strerror(errno));
+                    pthread_mutex_unlock(&priv->sync_mutex);
+                    break;
                 }
-                pthread_mutex_unlock (&priv->sync_mutex);
-
-                if (winds_on_old_subvol == 0) {
-                        xlator_notify (old_subvol, GF_EVENT_PARENT_DOWN,
-                                       old_subvol, NULL);
+                if (pfd[0].revents & POLLIN) {
+                    if (fuse_get_mount_status(this) != 0) {
+                        pthread_mutex_unlock(&priv->sync_mutex);
+                        break;
+                    }
+                    priv->mount_finished = _gf_true;
+                } else if (pfd[0].revents) {
+                    gf_log(this->name, GF_LOG_ERROR,
+                           "mount pipe closed without status");
+                    pthread_mutex_unlock(&priv->sync_mutex);
+                    break;
                 }
-        } else {
-                pthread_mutex_lock (&priv->sync_mutex);
-                {
-                        priv->handle_graph_switch = _gf_false;
-                        pthread_cond_broadcast (&priv->migrate_cond);
+                if (!pfd[1].revents) {
+                    pthread_mutex_unlock(&priv->sync_mutex);
+                    continue;
                 }
-                pthread_mutex_unlock (&priv->sync_mutex);
+            }
         }
+        pthread_mutex_unlock(&priv->sync_mutex);
 
-        return 0;
-}
+        /*
+         * We don't want to block on readv while we're still waiting
+         * for mount status.  That means we only want to get here if
+         * mount_status is true (meaning that our wait completed
+         * already) or if we already called poll(2) on priv->fd to
+         * make sure it's ready.
+         */
 
-int
-fuse_get_mount_status (xlator_t *this)
-{
-        int             kid_status = -1;
-        fuse_private_t *priv = this->private;
+        if (priv->init_recvd)
+            fuse_graph_sync(this);
+
+        /* TODO: This place should always get maximum supported buffer
+           size from 'fuse', which is as of today 128KB. If we bring in
+           support for higher block sizes support, then we should be
+           changing this one too */
+        iobuf = iobuf_get(this->ctx->iobuf_pool);
+
+        /* Add extra 128 byte to the first iov so that it can
+         * accommodate "ordinary" non-write requests. It's not
+         * guaranteed to be big enough, as SETXATTR and namespace
+         * operations with very long names may grow behind it,
+         * but it's good enough in most cases (and we can handle
+         * rest via realloc).
+         */
+        iov_in[0].iov_base = GF_CALLOC(1, msg0_size, gf_fuse_mt_iov_base);
 
-        if (sys_read (priv->status_pipe[0], &kid_status, sizeof(kid_status)) < 0) {
-                gf_log (this->name, GF_LOG_ERROR, "could not get mount status");
-                kid_status = -1;
+        if (!iobuf || !iov_in[0].iov_base) {
+            gf_log(this->name, GF_LOG_ERROR, "Out of memory");
+            if (iobuf)
+                iobuf_unref(iobuf);
+            GF_FREE(iov_in[0].iov_base);
+            sleep(10);
+            continue;
         }
-        gf_log (this->name, GF_LOG_DEBUG, "mount status is %d", kid_status);
 
-        sys_close(priv->status_pipe[0]);
-        sys_close(priv->status_pipe[1]);
-        return kid_status;
-}
+        iov_in[1].iov_base = iobuf->ptr;
 
-static void *
-fuse_thread_proc (void *data)
-{
-        char                     *mount_point = NULL;
-        xlator_t                 *this = NULL;
-        fuse_private_t           *priv = NULL;
-        ssize_t                   res = 0;
-        struct iobuf             *iobuf = NULL;
-        fuse_in_header_t         *finh = NULL;
-        struct iovec              iov_in[2];
-        void                     *msg = NULL;
-        const size_t              msg0_size = sizeof (*finh) + 128;
-        fuse_handler_t          **fuse_ops = NULL;
-        struct pollfd             pfd[2] = {{0,}};
-
-        this = data;
-        priv = this->private;
-        fuse_ops = priv->fuse_ops;
+        res = sys_readv(priv->fd, iov_in, 2);
 
-        THIS = this;
+        if (res == -1) {
+            if (errno == ENODEV || errno == EBADF) {
+                gf_log("glusterfs-fuse", GF_LOG_DEBUG,
+                       "terminating upon getting %s when "
+                       "reading /dev/fuse",
+                       errno == ENODEV ? "ENODEV" : "EBADF");
+                fuse_log_eh(this,
+                            "glusterfs-fuse: terminating"
+                            " upon getting %s when "
+                            "reading /dev/fuse",
+                            errno == ENODEV ? "ENODEV" : "EBADF");
+                break;
+            }
+            if (errno != EINTR) {
+                gf_log("glusterfs-fuse", GF_LOG_WARNING,
+                       "read from /dev/fuse returned -1 (%s)", strerror(errno));
+                fuse_log_eh(this,
+                            "glusterfs-fuse: read from "
+                            "/dev/fuse returned -1 (%s)",
+                            strerror(errno));
+            }
 
-        iov_in[0].iov_len = sizeof (*finh) + sizeof (struct fuse_write_in);
-        iov_in[1].iov_len = ((struct iobuf_pool *)this->ctx->iobuf_pool)
-                              ->default_page_size;
-        priv->msg0_len_p = &iov_in[0].iov_len;
+            goto cont_err;
+        }
+        if (res < sizeof(finh)) {
+            gf_log("glusterfs-fuse", GF_LOG_WARNING, "short read on /dev/fuse");
+            fuse_log_eh(this,
+                        "glusterfs-fuse: short read on "
+                        "/dev/fuse");
+            break;
+        }
 
-        for (;;) {
-                /* THIS has to be reset here */
-                THIS = this;
+        finh = (fuse_in_header_t *)iov_in[0].iov_base;
 
-                pthread_mutex_lock (&priv->sync_mutex);
-                {
-                        if (!priv->mount_finished) {
-                                memset(pfd, 0, sizeof(pfd));
-                                pfd[0].fd = priv->status_pipe[0];
-                                pfd[0].events = POLLIN | POLLHUP | POLLERR;
-                                pfd[1].fd = priv->fd;
-                                pfd[1].events = POLLIN | POLLHUP | POLLERR;
-                                if (poll(pfd, 2, -1) < 0) {
-                                        gf_log (this->name, GF_LOG_ERROR,
-                                                "poll error %s",
-                                                strerror(errno));
-                                        pthread_mutex_unlock (&priv->sync_mutex);
-                                        break;
-                                }
-                                if (pfd[0].revents & POLLIN) {
-                                        if (fuse_get_mount_status(this) != 0) {
-                                                pthread_mutex_unlock (&priv->sync_mutex);
-                                                break;
-                                        }
-                                        priv->mount_finished = _gf_true;
-                                } else if (pfd[0].revents) {
-                                        gf_log (this->name, GF_LOG_ERROR,
-                                                "mount pipe closed without status");
-                                        pthread_mutex_unlock (&priv->sync_mutex);
-                                        break;
-                                }
-                                if (!pfd[1].revents) {
-                                        pthread_mutex_unlock (&priv->sync_mutex);
-                                        continue;
-                                }
-                        }
-                }
-                pthread_mutex_unlock (&priv->sync_mutex);
-
-                /*
-                 * We don't want to block on readv while we're still waiting
-                 * for mount status.  That means we only want to get here if
-                 * mount_status is true (meaning that our wait completed
-                 * already) or if we already called poll(2) on priv->fd to
-                 * make sure it's ready.
-                 */
-
-                if (priv->init_recvd)
-                        fuse_graph_sync (this);
-
-                /* TODO: This place should always get maximum supported buffer
-                   size from 'fuse', which is as of today 128KB. If we bring in
-                   support for higher block sizes support, then we should be
-                   changing this one too */
-                iobuf = iobuf_get (this->ctx->iobuf_pool);
-
-                /* Add extra 128 byte to the first iov so that it can
-                 * accommodate "ordinary" non-write requests. It's not
-                 * guaranteed to be big enough, as SETXATTR and namespace
-                 * operations with very long names may grow behind it,
-                 * but it's good enough in most cases (and we can handle
-                 * rest via realloc).
-                 */
-                iov_in[0].iov_base = GF_CALLOC (1, msg0_size,
-                                                gf_fuse_mt_iov_base);
-
-                if (!iobuf || !iov_in[0].iov_base) {
-                        gf_log (this->name, GF_LOG_ERROR,
-                                "Out of memory");
-                        if (iobuf)
-                                iobuf_unref (iobuf);
-                        GF_FREE (iov_in[0].iov_base);
-                        sleep (10);
-                        continue;
-                }
+        if (res != finh->len
+#ifdef GF_DARWIN_HOST_OS
+            /* work around fuse4bsd/MacFUSE msg size miscalculation bug,
+             * that is, payload size is not taken into account for
+             * buffered writes
+             */
+            && !(finh->opcode == FUSE_WRITE &&
+                 finh->len == sizeof(*finh) + sizeof(struct fuse_write_in) &&
+                 res == finh->len + ((struct fuse_write_in *)(finh + 1))->size)
+#endif
+        ) {
+            gf_log("glusterfs-fuse", GF_LOG_WARNING,
+                   "inconsistent read on /dev/fuse");
+            fuse_log_eh(this,
+                        "glusterfs-fuse: inconsistent read "
+                        "on /dev/fuse");
+            break;
+        }
 
-                iov_in[1].iov_base = iobuf->ptr;
-
-                res = sys_readv (priv->fd, iov_in, 2);
-
-                if (res == -1) {
-                        if (errno == ENODEV || errno == EBADF) {
-                                gf_log ("glusterfs-fuse", GF_LOG_DEBUG,
-                                        "terminating upon getting %s when "
-                                        "reading /dev/fuse",
-                                        errno == ENODEV ? "ENODEV" : "EBADF");
-                                fuse_log_eh (this, "glusterfs-fuse: terminating"
-                                             " upon getting %s when "
-                                             "reading /dev/fuse",
-                                             errno == ENODEV ? "ENODEV":
-                                             "EBADF");
-                                break;
-                        }
-                        if (errno != EINTR) {
-                                gf_log ("glusterfs-fuse", GF_LOG_WARNING,
-                                        "read from /dev/fuse returned -1 (%s)",
-                                        strerror (errno));
-                                fuse_log_eh (this, "glusterfs-fuse: read from "
-                                             "/dev/fuse returned -1 (%s)",
-                                             strerror (errno));
-                        }
-
-                        goto cont_err;
-                }
-                if (res < sizeof (finh)) {
-                        gf_log ("glusterfs-fuse", GF_LOG_WARNING,
-                                "short read on /dev/fuse");
-                        fuse_log_eh (this, "glusterfs-fuse: short read on "
-                                     "/dev/fuse");
-                        break;
-                }
+        /*
+         * This can be moved around a bit, but it's important to do it
+         * *after* the readv.  Otherwise, a graph switch could occur
+         * while we're in readv and we'll process the next request on
+         * the old graph before we come to the part of the loop above
+         * readv and check again.  That would be wrong.
+         */
+        if (priv->init_recvd)
+            fuse_graph_sync(this);
 
-                finh = (fuse_in_header_t *)iov_in[0].iov_base;
+        if (finh->opcode == FUSE_WRITE)
+            msg = iov_in[1].iov_base;
+        else {
+            if (res > msg0_size) {
+                void *b = GF_REALLOC(iov_in[0].iov_base, res);
+                if (b) {
+                    iov_in[0].iov_base = b;
+                    finh = (fuse_in_header_t *)iov_in[0].iov_base;
+                } else {
+                    gf_log("glusterfs-fuse", GF_LOG_ERROR, "Out of memory");
+                    send_fuse_err(this, finh, ENOMEM);
 
-                if (res != finh->len
-#ifdef GF_DARWIN_HOST_OS
-                    /* work around fuse4bsd/MacFUSE msg size miscalculation bug,
-                     * that is, payload size is not taken into account for
-                     * buffered writes
-                     */
-                    && !(finh->opcode == FUSE_WRITE &&
-                         finh->len == sizeof(*finh) + sizeof(struct fuse_write_in) &&
-                         res == finh->len + ((struct fuse_write_in *)(finh + 1))->size)
-#endif
-                   ) {
-                        gf_log ("glusterfs-fuse", GF_LOG_WARNING,
-                                "inconsistent read on /dev/fuse");
-                        fuse_log_eh (this, "glusterfs-fuse: inconsistent read "
-                                     "on /dev/fuse");
-                        break;
+                    goto cont_err;
                 }
+            }
 
-                /*
-                 * This can be moved around a bit, but it's important to do it
-                 * *after* the readv.  Otherwise, a graph switch could occur
-                 * while we're in readv and we'll process the next request on
-                 * the old graph before we come to the part of the loop above
-                 * readv and check again.  That would be wrong.
-                 */
-                if (priv->init_recvd)
-                        fuse_graph_sync (this);
-
-                if (finh->opcode == FUSE_WRITE)
-                        msg = iov_in[1].iov_base;
-                else {
-                        if (res > msg0_size) {
-                                void *b = GF_REALLOC (iov_in[0].iov_base, res);
-                                if (b) {
-                                        iov_in[0].iov_base = b;
-                                        finh = (fuse_in_header_t *)
-                                                 iov_in[0].iov_base;
-                                }
-                                else {
-                                        gf_log ("glusterfs-fuse", GF_LOG_ERROR,
-                                                "Out of memory");
-                                        send_fuse_err (this, finh, ENOMEM);
-
-                                        goto cont_err;
-                                }
-                        }
-
-                        if (res > iov_in[0].iov_len)
-                                memcpy (iov_in[0].iov_base + iov_in[0].iov_len,
-                                        iov_in[1].iov_base,
-                                        res - iov_in[0].iov_len);
-
-                        msg = finh + 1;
-                }
-                if (priv->uid_map_root &&
-                    finh->uid == priv->uid_map_root)
-                        finh->uid = 0;
+            if (res > iov_in[0].iov_len)
+                memcpy(iov_in[0].iov_base + iov_in[0].iov_len,
+                       iov_in[1].iov_base, res - iov_in[0].iov_len);
 
-                if (finh->opcode >= FUSE_OP_HIGH)
-                        /* turn down MacFUSE specific messages */
-                        fuse_enosys (this, finh, msg, NULL);
-                else
-                        fuse_ops[finh->opcode] (this, finh, msg, iobuf);
+            msg = finh + 1;
+        }
+        if (priv->uid_map_root && finh->uid == priv->uid_map_root)
+            finh->uid = 0;
 
-                iobuf_unref (iobuf);
-                continue;
+        if (finh->opcode >= FUSE_OP_HIGH)
+            /* turn down MacFUSE specific messages */
+            fuse_enosys(this, finh, msg, NULL);
+        else
+            fuse_ops[finh->opcode](this, finh, msg, iobuf);
 
- cont_err:
-                iobuf_unref (iobuf);
-                GF_FREE (iov_in[0].iov_base);
-        }
+        iobuf_unref(iobuf);
+        continue;
 
-        /*
-         * We could be in all sorts of states with respect to iobuf and iov_in
-         * by the time we get here, and it's just not worth untangling them if
-         * we're about to kill ourselves anyway.
-         */
+    cont_err:
+        iobuf_unref(iobuf);
+        GF_FREE(iov_in[0].iov_base);
+    }
 
-        if (dict_get (this->options, ZR_MOUNTPOINT_OPT))
-                mount_point = data_to_str (dict_get (this->options,
-                                                     ZR_MOUNTPOINT_OPT));
-        if (mount_point) {
-                gf_log (this->name, GF_LOG_INFO,
-                        "initating unmount of %s", mount_point);
-        }
+    /*
+     * We could be in all sorts of states with respect to iobuf and iov_in
+     * by the time we get here, and it's just not worth untangling them if
+     * we're about to kill ourselves anyway.
+     */
 
-        /* Kill the whole process, not just this thread. */
-        kill (getpid(), SIGTERM);
-        return NULL;
-}
+    if (dict_get(this->options, ZR_MOUNTPOINT_OPT))
+        mount_point = data_to_str(dict_get(this->options, ZR_MOUNTPOINT_OPT));
+    if (mount_point) {
+        gf_log(this->name, GF_LOG_INFO, "initating unmount of %s", mount_point);
+    }
 
+    /* Kill the whole process, not just this thread. */
+    kill(getpid(), SIGTERM);
+    return NULL;
+}
 
 int32_t
-fuse_itable_dump (xlator_t  *this)
+fuse_itable_dump(xlator_t *this)
 {
-        fuse_private_t *priv = NULL;
+    fuse_private_t *priv = NULL;
 
-        if (!this)
-                 return -1;
+    if (!this)
+        return -1;
 
-        priv = this->private;
+    priv = this->private;
 
-        if (priv && priv->active_subvol) {
-                gf_proc_dump_add_section("xlator.mount.fuse.itable");
-                inode_table_dump(priv->active_subvol->itable,
-                                 "xlator.mount.fuse.itable");
-        }
-        return 0;
+    if (priv && priv->active_subvol) {
+        gf_proc_dump_add_section("xlator.mount.fuse.itable");
+        inode_table_dump(priv->active_subvol->itable,
+                         "xlator.mount.fuse.itable");
+    }
+    return 0;
 }
 
 int32_t
-fuse_priv_dump (xlator_t  *this)
-{
-        fuse_private_t  *private = NULL;
-
-        if (!this)
-                return -1;
-
-        private = this->private;
-
-        if (!private)
-                return -1;
-
-        gf_proc_dump_add_section("xlator.mount.fuse.priv");
-
-        gf_proc_dump_write("fd", "%d", private->fd);
-        gf_proc_dump_write("proto_minor", "%u",
-                            private->proto_minor);
-        gf_proc_dump_write("volfile", "%s",
-                            private->volfile?private->volfile:"None");
-        gf_proc_dump_write("volfile_size", "%d",
-                            private->volfile_size);
-        gf_proc_dump_write("mount_point", "%s",
-                            private->mount_point);
-        gf_proc_dump_write("fuse_thread_started", "%d",
-                            (int)private->fuse_thread_started);
-        gf_proc_dump_write("direct_io_mode", "%d",
-                            private->direct_io_mode);
-        gf_proc_dump_write("entry_timeout", "%lf",
-                            private->entry_timeout);
-        gf_proc_dump_write("attribute_timeout", "%lf",
-                            private->attribute_timeout);
-        gf_proc_dump_write("init_recvd", "%d",
-                            (int)private->init_recvd);
-        gf_proc_dump_write("strict_volfile_check", "%d",
-                            (int)private->strict_volfile_check);
-        gf_proc_dump_write("reverse_thread_started", "%d",
-                           (int)private->reverse_fuse_thread_started);
-        gf_proc_dump_write("use_readdirp", "%d", private->use_readdirp);
+fuse_priv_dump(xlator_t *this)
+{
+    fuse_private_t *private = NULL;
 
-        return 0;
+    if (!this)
+        return -1;
+
+   private
+    = this->private;
+
+    if (!private)
+        return -1;
+
+    gf_proc_dump_add_section("xlator.mount.fuse.priv");
+
+    gf_proc_dump_write("fd", "%d", private->fd);
+    gf_proc_dump_write("proto_minor", "%u", private->proto_minor);
+    gf_proc_dump_write("volfile", "%s",
+                       private->volfile ? private->volfile : "None");
+    gf_proc_dump_write("volfile_size", "%d", private->volfile_size);
+    gf_proc_dump_write("mount_point", "%s", private->mount_point);
+    gf_proc_dump_write("fuse_thread_started", "%d",
+                       (int)private->fuse_thread_started);
+    gf_proc_dump_write("direct_io_mode", "%d", private->direct_io_mode);
+    gf_proc_dump_write("entry_timeout", "%lf", private->entry_timeout);
+    gf_proc_dump_write("attribute_timeout", "%lf", private->attribute_timeout);
+    gf_proc_dump_write("init_recvd", "%d", (int)private->init_recvd);
+    gf_proc_dump_write("strict_volfile_check", "%d",
+                       (int)private->strict_volfile_check);
+    gf_proc_dump_write("reverse_thread_started", "%d",
+                       (int)private->reverse_fuse_thread_started);
+    gf_proc_dump_write("use_readdirp", "%d", private->use_readdirp);
+
+    return 0;
 }
 
 int
-fuse_history_dump (xlator_t *this)
+fuse_history_dump(xlator_t *this)
 {
-        int             ret                             = -1;
-        char            key_prefix[GF_DUMP_MAX_BUF_LEN] = {0,};
-        fuse_private_t *priv                            = this->private;
+    int ret = -1;
+    char key_prefix[GF_DUMP_MAX_BUF_LEN] = {
+        0,
+    };
+    fuse_private_t *priv = this->private;
 
-        GF_VALIDATE_OR_GOTO ("fuse", this, out);
+    GF_VALIDATE_OR_GOTO("fuse", this, out);
 
-        if (!priv->event_history)
-                goto out;
+    if (!priv->event_history)
+        goto out;
 
-        GF_VALIDATE_OR_GOTO (this->name, this->history, out);
+    GF_VALIDATE_OR_GOTO(this->name, this->history, out);
 
-        gf_proc_dump_build_key (key_prefix, "xlator.mount.fuse",
-                                "history");
-        gf_proc_dump_add_section (key_prefix);
-        eh_dump (this->history, NULL, dump_history_fuse);
+    gf_proc_dump_build_key(key_prefix, "xlator.mount.fuse", "history");
+    gf_proc_dump_add_section(key_prefix);
+    eh_dump(this->history, NULL, dump_history_fuse);
 
-        ret = 0;
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
 
 int
-dump_history_fuse (circular_buffer_t *cb, void *data)
+dump_history_fuse(circular_buffer_t *cb, void *data)
 {
-        char       timestr[256] = {0,};
+    char timestr[256] = {
+        0,
+    };
 
-        gf_time_fmt (timestr, sizeof timestr, cb->tv.tv_sec, gf_timefmt_F_HMS);
+    gf_time_fmt(timestr, sizeof timestr, cb->tv.tv_sec, gf_timefmt_F_HMS);
 
-        snprintf (timestr + strlen (timestr), 256 - strlen (timestr),
-                  ".%"GF_PRI_SUSECONDS, cb->tv.tv_usec);
-        gf_proc_dump_write ("TIME", "%s", timestr);
+    snprintf(timestr + strlen(timestr), 256 - strlen(timestr),
+             ".%" GF_PRI_SUSECONDS, cb->tv.tv_usec);
+    gf_proc_dump_write("TIME", "%s", timestr);
 
-        gf_proc_dump_write ("message", "%s\n", cb->data);
+    gf_proc_dump_write("message", "%s\n", cb->data);
 
-        return 0;
+    return 0;
 }
 
 int
-fuse_graph_setup (xlator_t *this, glusterfs_graph_t *graph)
+fuse_graph_setup(xlator_t *this, glusterfs_graph_t *graph)
 {
-        inode_table_t     *itable     = NULL;
-        int                ret        = 0, winds = 0;
-        fuse_private_t    *priv       = NULL;
-        glusterfs_graph_t *prev_graph = NULL;
+    inode_table_t *itable = NULL;
+    int ret = 0, winds = 0;
+    fuse_private_t *priv = NULL;
+    glusterfs_graph_t *prev_graph = NULL;
 
-        priv = this->private;
+    priv = this->private;
 
-        pthread_mutex_lock (&priv->sync_mutex);
-        {
-                /* 1. handle the case of more than one CHILD_UP on same graph.
-                 * 2. make sure graph is newer than current active_subvol.
-                 */
-                if ((priv->active_subvol == graph->top) || graph->used
-                    || ((priv->active_subvol)
-                        && (priv->active_subvol->graph->id > graph->id))) {
-                        goto unlock;
-                }
+    pthread_mutex_lock(&priv->sync_mutex);
+    {
+        /* 1. handle the case of more than one CHILD_UP on same graph.
+         * 2. make sure graph is newer than current active_subvol.
+         */
+        if ((priv->active_subvol == graph->top) || graph->used ||
+            ((priv->active_subvol) &&
+             (priv->active_subvol->graph->id > graph->id))) {
+            goto unlock;
+        }
 
-                itable = inode_table_new (0, graph->top);
-                if (!itable) {
-                        ret = -1;
-                        goto unlock;
-                }
+        itable = inode_table_new(0, graph->top);
+        if (!itable) {
+            ret = -1;
+            goto unlock;
+        }
 
-                ((xlator_t *)graph->top)->itable = itable;
+        ((xlator_t *)graph->top)->itable = itable;
 
-                prev_graph = priv->next_graph;
+        prev_graph = priv->next_graph;
 
-                if ((prev_graph != NULL) && (prev_graph->id > graph->id)) {
-                        /* there was a race and an old graph was initialised
-                         * before new one.
-                         */
-                        prev_graph = graph;
-                } else {
-                        priv->next_graph = graph;
-                        priv->event_recvd = 0;
-                }
+        if ((prev_graph != NULL) && (prev_graph->id > graph->id)) {
+            /* there was a race and an old graph was initialised
+             * before new one.
+             */
+            prev_graph = graph;
+        } else {
+            priv->next_graph = graph;
+            priv->event_recvd = 0;
+        }
 
-                if (prev_graph != NULL)
-                        winds = ((xlator_t *)prev_graph->top)->winds;
+        if (prev_graph != NULL)
+            winds = ((xlator_t *)prev_graph->top)->winds;
 
-		/* set post initializing next_graph i to preserve
-                 * critical section update and bails on error */
-                graph->used = 1;
-        }
-        pthread_mutex_unlock (&priv->sync_mutex);
+        /* set post initializing next_graph i to preserve
+         * critical section update and bails on error */
+        graph->used = 1;
+    }
+    pthread_mutex_unlock(&priv->sync_mutex);
 
-        if ((prev_graph != NULL) && (winds == 0)) {
-                xlator_notify (prev_graph->top, GF_EVENT_PARENT_DOWN,
-                               prev_graph->top, NULL);
-        }
+    if ((prev_graph != NULL) && (winds == 0)) {
+        xlator_notify(prev_graph->top, GF_EVENT_PARENT_DOWN, prev_graph->top,
+                      NULL);
+    }
 
-        return ret;
+    return ret;
 unlock:
-        pthread_mutex_unlock (&priv->sync_mutex);
+    pthread_mutex_unlock(&priv->sync_mutex);
 
-        return ret;
+    return ret;
 }
 
-
 int
-notify (xlator_t *this, int32_t event, void *data, ...)
+notify(xlator_t *this, int32_t event, void *data, ...)
 {
-        int                 i       = 0;
-        int32_t             ret     = 0;
-        fuse_private_t     *private = NULL;
-        gf_boolean_t        start_thread = _gf_false;
-        glusterfs_graph_t  *graph = NULL;
+    int i = 0;
+    int32_t ret = 0;
+    fuse_private_t *private = NULL;
+    gf_boolean_t start_thread = _gf_false;
+    glusterfs_graph_t *graph = NULL;
 
-        private = this->private;
+   private
+    = this->private;
 
-        graph = data;
+    graph = data;
 
-        gf_log ("fuse", GF_LOG_DEBUG, "got event %d on graph %d",
-                event, ((graph) ? graph->id : 0));
+    gf_log("fuse", GF_LOG_DEBUG, "got event %d on graph %d", event,
+           ((graph) ? graph->id : 0));
 
-        switch (event)
-        {
+    switch (event) {
         case GF_EVENT_GRAPH_NEW:
-                break;
+            break;
 
         case GF_EVENT_CHILD_UP:
         case GF_EVENT_CHILD_DOWN:
-        case GF_EVENT_CHILD_CONNECTING:
-        {
-                if (graph) {
-                        ret = fuse_graph_setup (this, graph);
-                        if (ret)
-                                gf_log (this->name, GF_LOG_WARNING,
-                                        "failed to setup the graph");
-                }
-
-                if ((event == GF_EVENT_CHILD_UP)
-                    || (event == GF_EVENT_CHILD_DOWN)) {
-                        pthread_mutex_lock (&private->sync_mutex);
-                        {
-                                private->event_recvd = 1;
-                                pthread_cond_broadcast (&private->sync_cond);
-                        }
-                        pthread_mutex_unlock (&private->sync_mutex);
-                }
-
-                pthread_mutex_lock (&private->sync_mutex);
+        case GF_EVENT_CHILD_CONNECTING: {
+            if (graph) {
+                ret = fuse_graph_setup(this, graph);
+                if (ret)
+                    gf_log(this->name, GF_LOG_WARNING,
+                           "failed to setup the graph");
+            }
+
+            if ((event == GF_EVENT_CHILD_UP) ||
+                (event == GF_EVENT_CHILD_DOWN)) {
+                pthread_mutex_lock(&private->sync_mutex);
                 {
-                        if (!private->fuse_thread_started) {
-                                private->fuse_thread_started = 1;
-                                start_thread = _gf_true;
-                        }
+                   private
+                    ->event_recvd = 1;
+                    pthread_cond_broadcast(&private->sync_cond);
+                }
+                pthread_mutex_unlock(&private->sync_mutex);
+            }
+
+            pthread_mutex_lock(&private->sync_mutex);
+            {
+                if (!private->fuse_thread_started) {
+                   private
+                    ->fuse_thread_started = 1;
+                    start_thread = _gf_true;
                 }
-                pthread_mutex_unlock (&private->sync_mutex);
-
-                if (start_thread) {
-                        private->fuse_thread = GF_CALLOC (private->reader_thread_count,
-                                                          sizeof (pthread_t),
-                                                          gf_fuse_mt_pthread_t);
-                        for (i = 0; i < private->reader_thread_count; i++) {
-
-                                ret = gf_thread_create (&private->fuse_thread[i],
-                                                        NULL,
-                                                        fuse_thread_proc, this,
-                                                        "fuseproc");
-                                if (ret != 0) {
-                                        gf_log (this->name, GF_LOG_DEBUG,
-                                                "pthread_create() failed (%s)",
-                                                strerror (errno));
-                                        break;
-                                }
-                        }
+            }
+            pthread_mutex_unlock(&private->sync_mutex);
+
+            if (start_thread) {
+               private
+                ->fuse_thread = GF_CALLOC(private->reader_thread_count,
+                                          sizeof(pthread_t),
+                                          gf_fuse_mt_pthread_t);
+                for (i = 0; i < private->reader_thread_count; i++) {
+                    ret = gf_thread_create(&private->fuse_thread[i], NULL,
+                                           fuse_thread_proc, this, "fuseproc");
+                    if (ret != 0) {
+                        gf_log(this->name, GF_LOG_DEBUG,
+                               "pthread_create() failed (%s)", strerror(errno));
+                        break;
+                    }
                 }
+            }
 
-                break;
+            break;
         }
 
-        case GF_EVENT_AUTH_FAILED:
-        {
-                /* Authentication failure is an error and glusterfs should stop */
-               gf_log (this->name, GF_LOG_ERROR, "Server authenication failed. Shutting down.");
-               fini (this);
-               break;
+        case GF_EVENT_AUTH_FAILED: {
+            /* Authentication failure is an error and glusterfs should stop */
+            gf_log(this->name, GF_LOG_ERROR,
+                   "Server authenication failed. Shutting down.");
+            fini(this);
+            break;
         }
 
         default:
-                break;
-        }
+            break;
+    }
 
-        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;
+    if (!this)
+        return ret;
 
-        ret = xlator_mem_acct_init (this, gf_fuse_mt_end + 1);
-
-        if (ret != 0) {
-                gf_log (this->name, GF_LOG_ERROR, "Memory accounting init"
-                                "failed");
-                return ret;
-        }
+    ret = xlator_mem_acct_init(this, gf_fuse_mt_end + 1);
 
+    if (ret != 0) {
+        gf_log(this->name, GF_LOG_ERROR,
+               "Memory accounting init"
+               "failed");
         return ret;
-}
+    }
 
+    return ret;
+}
 
 static fuse_handler_t *fuse_std_ops[FUSE_OP_HIGH] = {
-        [FUSE_LOOKUP]      = fuse_lookup,
-        [FUSE_FORGET]      = fuse_forget,
-        [FUSE_GETATTR]     = fuse_getattr,
-        [FUSE_SETATTR]     = fuse_setattr,
-        [FUSE_READLINK]    = fuse_readlink,
-        [FUSE_SYMLINK]     = fuse_symlink,
-        [FUSE_MKNOD]       = fuse_mknod,
-        [FUSE_MKDIR]       = fuse_mkdir,
-        [FUSE_UNLINK]      = fuse_unlink,
-        [FUSE_RMDIR]       = fuse_rmdir,
-        [FUSE_RENAME]      = fuse_rename,
-        [FUSE_LINK]        = fuse_link,
-        [FUSE_OPEN]        = fuse_open,
-        [FUSE_READ]        = fuse_readv,
-        [FUSE_WRITE]       = fuse_write,
-        [FUSE_STATFS]      = fuse_statfs,
-        [FUSE_RELEASE]     = fuse_release,
-        [FUSE_FSYNC]       = fuse_fsync,
-        [FUSE_SETXATTR]    = fuse_setxattr,
-        [FUSE_GETXATTR]    = fuse_getxattr,
-        [FUSE_LISTXATTR]   = fuse_listxattr,
-        [FUSE_REMOVEXATTR] = fuse_removexattr,
-        [FUSE_FLUSH]       = fuse_flush,
-        [FUSE_INIT]        = fuse_init,
-        [FUSE_OPENDIR]     = fuse_opendir,
-        [FUSE_READDIR]     = fuse_readdir,
-        [FUSE_RELEASEDIR]  = fuse_releasedir,
-        [FUSE_FSYNCDIR]    = fuse_fsyncdir,
-        [FUSE_GETLK]       = fuse_getlk,
-        [FUSE_SETLK]       = fuse_setlk,
-        [FUSE_SETLKW]      = fuse_setlk,
-        [FUSE_ACCESS]      = fuse_access,
-        [FUSE_CREATE]      = fuse_create,
-     /* [FUSE_INTERRUPT] */
-     /* [FUSE_BMAP] */
-        [FUSE_DESTROY]     = fuse_destroy,
-     /* [FUSE_IOCTL] */
-     /* [FUSE_POLL] */
-     /* [FUSE_NOTIFY_REPLY] */
+    [FUSE_LOOKUP] = fuse_lookup,
+    [FUSE_FORGET] = fuse_forget,
+    [FUSE_GETATTR] = fuse_getattr,
+    [FUSE_SETATTR] = fuse_setattr,
+    [FUSE_READLINK] = fuse_readlink,
+    [FUSE_SYMLINK] = fuse_symlink,
+    [FUSE_MKNOD] = fuse_mknod,
+    [FUSE_MKDIR] = fuse_mkdir,
+    [FUSE_UNLINK] = fuse_unlink,
+    [FUSE_RMDIR] = fuse_rmdir,
+    [FUSE_RENAME] = fuse_rename,
+    [FUSE_LINK] = fuse_link,
+    [FUSE_OPEN] = fuse_open,
+    [FUSE_READ] = fuse_readv,
+    [FUSE_WRITE] = fuse_write,
+    [FUSE_STATFS] = fuse_statfs,
+    [FUSE_RELEASE] = fuse_release,
+    [FUSE_FSYNC] = fuse_fsync,
+    [FUSE_SETXATTR] = fuse_setxattr,
+    [FUSE_GETXATTR] = fuse_getxattr,
+    [FUSE_LISTXATTR] = fuse_listxattr,
+    [FUSE_REMOVEXATTR] = fuse_removexattr,
+    [FUSE_FLUSH] = fuse_flush,
+    [FUSE_INIT] = fuse_init,
+    [FUSE_OPENDIR] = fuse_opendir,
+    [FUSE_READDIR] = fuse_readdir,
+    [FUSE_RELEASEDIR] = fuse_releasedir,
+    [FUSE_FSYNCDIR] = fuse_fsyncdir,
+    [FUSE_GETLK] = fuse_getlk,
+    [FUSE_SETLK] = fuse_setlk,
+    [FUSE_SETLKW] = fuse_setlk,
+    [FUSE_ACCESS] = fuse_access,
+    [FUSE_CREATE] = fuse_create,
+    /* [FUSE_INTERRUPT] */
+    /* [FUSE_BMAP] */
+    [FUSE_DESTROY] = fuse_destroy,
+/* [FUSE_IOCTL] */
+/* [FUSE_POLL] */
+/* [FUSE_NOTIFY_REPLY] */
 
 #if FUSE_KERNEL_MINOR_VERSION >= 16
-	[FUSE_BATCH_FORGET]= fuse_batch_forget,
+    [FUSE_BATCH_FORGET] = fuse_batch_forget,
 #endif
 
 #if FUSE_KERNEL_MINOR_VERSION >= 19
 #ifdef FALLOC_FL_KEEP_SIZE
-	[FUSE_FALLOCATE]   = fuse_fallocate,
+    [FUSE_FALLOCATE] = fuse_fallocate,
 #endif /* FALLOC_FL_KEEP_SIZE */
 #endif
 
 #if FUSE_KERNEL_MINOR_VERSION >= 21
-	[FUSE_READDIRPLUS] = fuse_readdirp,
+    [FUSE_READDIRPLUS] = fuse_readdirp,
 #endif
 
 #if FUSE_KERNEL_MINOR_VERSION >= 24 && HAVE_SEEK_HOLE
-        [FUSE_LSEEK]        = fuse_lseek,
+    [FUSE_LSEEK] = fuse_lseek,
 #endif
 };
 
-
 static fuse_handler_t *fuse_dump_ops[FUSE_OP_HIGH];
 
-
 static void
-fuse_dumper (xlator_t *this, fuse_in_header_t *finh, void *msg,
-             struct iobuf *iobuf)
+fuse_dumper(xlator_t *this, fuse_in_header_t *finh, void *msg,
+            struct iobuf *iobuf)
 {
-        fuse_private_t *priv = NULL;
-        struct iovec diov[6]           = {{0,},};
-        char r                         = 'R';
-        uint32_t fusedump_item_count   = 3;
-        struct fusedump_timespec fts   = {0,};
-        struct fusedump_signature fsig = {0,};
-
-        int ret = 0;
-
-        priv = this->private;
-
-        fusedump_setup_meta (diov, &r, &fusedump_item_count,
-                             &fts, &fsig);
-        diov[4] = (struct iovec){ finh, sizeof (*finh) };
-        if (finh->opcode == FUSE_WRITE) {
-                /* WRITE has special data alignment, see comment in
-                   fuse_write(). */
-                diov[4].iov_len += sizeof (struct fuse_write_in);
-        }
-        diov[5] = (struct iovec){ msg, finh->len - diov[4].iov_len };
-
-        pthread_mutex_lock (&priv->fuse_dump_mutex);
-        ret = sys_writev (priv->fuse_dump_fd, diov,
-                          sizeof (diov) / sizeof (diov[0]));
-        pthread_mutex_unlock (&priv->fuse_dump_mutex);
-        if (ret == -1)
-                gf_log ("glusterfs-fuse", GF_LOG_ERROR,
-                        "failed to dump fuse message (R): %s",
-                        strerror (errno));
-
-        priv->fuse_ops0[finh->opcode] (this, finh, msg, NULL);
+    fuse_private_t *priv = NULL;
+    struct iovec diov[6] = {
+        {
+            0,
+        },
+    };
+    char r = 'R';
+    uint32_t fusedump_item_count = 3;
+    struct fusedump_timespec fts = {
+        0,
+    };
+    struct fusedump_signature fsig = {
+        0,
+    };
+
+    int ret = 0;
+
+    priv = this->private;
+
+    fusedump_setup_meta(diov, &r, &fusedump_item_count, &fts, &fsig);
+    diov[4] = (struct iovec){finh, sizeof(*finh)};
+    if (finh->opcode == FUSE_WRITE) {
+        /* WRITE has special data alignment, see comment in
+           fuse_write(). */
+        diov[4].iov_len += sizeof(struct fuse_write_in);
+    }
+    diov[5] = (struct iovec){msg, finh->len - diov[4].iov_len};
+
+    pthread_mutex_lock(&priv->fuse_dump_mutex);
+    ret = sys_writev(priv->fuse_dump_fd, diov, sizeof(diov) / sizeof(diov[0]));
+    pthread_mutex_unlock(&priv->fuse_dump_mutex);
+    if (ret == -1)
+        gf_log("glusterfs-fuse", GF_LOG_ERROR,
+               "failed to dump fuse message (R): %s", strerror(errno));
+
+    priv->fuse_ops0[finh->opcode](this, finh, msg, NULL);
 }
 
-
 int
-init (xlator_t *this_xl)
-{
-        int                ret = 0;
-        dict_t            *options = NULL;
-        char              *value_string = NULL;
-        cmd_args_t        *cmd_args = NULL;
-        char              *fsname = NULL;
-        fuse_private_t    *priv = NULL;
-        struct stat        stbuf = {0,};
-        int                i = 0;
-        int                xl_name_allocated = 0;
-        int                fsname_allocated = 0;
-        glusterfs_ctx_t   *ctx = NULL;
-        gf_boolean_t       sync_to_mount = _gf_false;
-        gf_boolean_t       fopen_keep_cache = _gf_false;
-        char              *mnt_args = NULL;
-        eh_t              *event = NULL;
-
-        if (this_xl == NULL)
-                return -1;
-
-        if (this_xl->options == NULL)
-                return -1;
-
-        ctx = this_xl->ctx;
-        if (!ctx)
-                return -1;
-
-        options = this_xl->options;
-
-        if (this_xl->name == NULL) {
-                this_xl->name = gf_strdup ("fuse");
-                if (!this_xl->name) {
-                        gf_log ("glusterfs-fuse", GF_LOG_ERROR,
-                                "Out of memory");
-
-                        goto cleanup_exit;
-                }
-                xl_name_allocated = 1;
-        }
+init(xlator_t *this_xl)
+{
+    int ret = 0;
+    dict_t *options = NULL;
+    char *value_string = NULL;
+    cmd_args_t *cmd_args = NULL;
+    char *fsname = NULL;
+    fuse_private_t *priv = NULL;
+    struct stat stbuf = {
+        0,
+    };
+    int i = 0;
+    int xl_name_allocated = 0;
+    int fsname_allocated = 0;
+    glusterfs_ctx_t *ctx = NULL;
+    gf_boolean_t sync_to_mount = _gf_false;
+    gf_boolean_t fopen_keep_cache = _gf_false;
+    char *mnt_args = NULL;
+    eh_t *event = NULL;
+
+    if (this_xl == NULL)
+        return -1;
 
-        priv = GF_CALLOC (1, sizeof (*priv), gf_fuse_mt_fuse_private_t);
-        if (!priv) {
-                gf_log ("glusterfs-fuse", GF_LOG_ERROR,
-                        "Out of memory");
+    if (this_xl->options == NULL)
+        return -1;
 
-                goto cleanup_exit;
-        }
-        this_xl->private = (void *) priv;
-        priv->mount_point = NULL;
-        priv->fd = -1;
-
-        INIT_LIST_HEAD (&priv->invalidate_list);
-        pthread_cond_init (&priv->invalidate_cond, NULL);
-        pthread_mutex_init (&priv->invalidate_mutex, NULL);
-
-        /* get options from option dictionary */
-        ret = dict_get_str (options, ZR_MOUNTPOINT_OPT, &value_string);
-        if (ret == -1 || value_string == NULL) {
-                gf_log ("fuse", GF_LOG_ERROR,
-                        "Mandatory option 'mountpoint' is not specified.");
-                goto cleanup_exit;
-        }
+    ctx = this_xl->ctx;
+    if (!ctx)
+        return -1;
 
-        if (sys_stat (value_string, &stbuf) != 0) {
-                if (errno == ENOENT) {
-                        gf_log (this_xl->name, GF_LOG_ERROR,
-                                "%s %s does not exist",
-                                ZR_MOUNTPOINT_OPT, value_string);
-                } else if (errno == ENOTCONN) {
-                        gf_log (this_xl->name, GF_LOG_ERROR,
-                                "Mountpoint %s seems to have a stale "
-                                "mount, run 'umount %s' and try again.",
-                                value_string, value_string);
-                } else {
-                        gf_log (this_xl->name, GF_LOG_DEBUG,
-                                "%s %s : stat returned %s",
-                                ZR_MOUNTPOINT_OPT,
-                                value_string, strerror (errno));
-                }
-                goto cleanup_exit;
+    options = this_xl->options;
+
+    if (this_xl->name == NULL) {
+        this_xl->name = gf_strdup("fuse");
+        if (!this_xl->name) {
+            gf_log("glusterfs-fuse", GF_LOG_ERROR, "Out of memory");
+
+            goto cleanup_exit;
+        }
+        xl_name_allocated = 1;
+    }
+
+    priv = GF_CALLOC(1, sizeof(*priv), gf_fuse_mt_fuse_private_t);
+    if (!priv) {
+        gf_log("glusterfs-fuse", GF_LOG_ERROR, "Out of memory");
+
+        goto cleanup_exit;
+    }
+    this_xl->private = (void *)priv;
+    priv->mount_point = NULL;
+    priv->fd = -1;
+
+    INIT_LIST_HEAD(&priv->invalidate_list);
+    pthread_cond_init(&priv->invalidate_cond, NULL);
+    pthread_mutex_init(&priv->invalidate_mutex, NULL);
+
+    /* get options from option dictionary */
+    ret = dict_get_str(options, ZR_MOUNTPOINT_OPT, &value_string);
+    if (ret == -1 || value_string == NULL) {
+        gf_log("fuse", GF_LOG_ERROR,
+               "Mandatory option 'mountpoint' is not specified.");
+        goto cleanup_exit;
+    }
+
+    if (sys_stat(value_string, &stbuf) != 0) {
+        if (errno == ENOENT) {
+            gf_log(this_xl->name, GF_LOG_ERROR, "%s %s does not exist",
+                   ZR_MOUNTPOINT_OPT, value_string);
+        } else if (errno == ENOTCONN) {
+            gf_log(this_xl->name, GF_LOG_ERROR,
+                   "Mountpoint %s seems to have a stale "
+                   "mount, run 'umount %s' and try again.",
+                   value_string, value_string);
+        } else {
+            gf_log(this_xl->name, GF_LOG_DEBUG, "%s %s : stat returned %s",
+                   ZR_MOUNTPOINT_OPT, value_string, strerror(errno));
         }
+        goto cleanup_exit;
+    }
 
-        if (S_ISDIR (stbuf.st_mode) == 0) {
-                gf_log (this_xl->name, GF_LOG_ERROR,
-                        "%s %s is not a directory",
-                        ZR_MOUNTPOINT_OPT, value_string);
-                goto cleanup_exit;
-        }
-        priv->mount_point = gf_strdup (value_string);
-        if (!priv->mount_point) {
-                gf_log ("glusterfs-fuse", GF_LOG_ERROR,
-                        "Out of memory");
+    if (S_ISDIR(stbuf.st_mode) == 0) {
+        gf_log(this_xl->name, GF_LOG_ERROR, "%s %s is not a directory",
+               ZR_MOUNTPOINT_OPT, value_string);
+        goto cleanup_exit;
+    }
+    priv->mount_point = gf_strdup(value_string);
+    if (!priv->mount_point) {
+        gf_log("glusterfs-fuse", GF_LOG_ERROR, "Out of memory");
 
-                goto cleanup_exit;
-        }
+        goto cleanup_exit;
+    }
 
-        GF_OPTION_INIT (ZR_ATTR_TIMEOUT_OPT, priv->attribute_timeout, double,
-                        cleanup_exit);
+    GF_OPTION_INIT(ZR_ATTR_TIMEOUT_OPT, priv->attribute_timeout, double,
+                   cleanup_exit);
 
-        GF_OPTION_INIT ("reader-thread-count", priv->reader_thread_count, uint32,
-                        cleanup_exit);
+    GF_OPTION_INIT("reader-thread-count", priv->reader_thread_count, uint32,
+                   cleanup_exit);
 
-        GF_OPTION_INIT (ZR_ENTRY_TIMEOUT_OPT, priv->entry_timeout, double,
-                        cleanup_exit);
+    GF_OPTION_INIT(ZR_ENTRY_TIMEOUT_OPT, priv->entry_timeout, double,
+                   cleanup_exit);
 
-        GF_OPTION_INIT (ZR_NEGATIVE_TIMEOUT_OPT, priv->negative_timeout, double,
-                        cleanup_exit);
+    GF_OPTION_INIT(ZR_NEGATIVE_TIMEOUT_OPT, priv->negative_timeout, double,
+                   cleanup_exit);
 
-        GF_OPTION_INIT ("client-pid", priv->client_pid, int32, cleanup_exit);
-        /* have to check & register the presence of client-pid manually */
-        priv->client_pid_set = !!dict_get (this_xl->options, "client-pid");
+    GF_OPTION_INIT("client-pid", priv->client_pid, int32, cleanup_exit);
+    /* have to check & register the presence of client-pid manually */
+    priv->client_pid_set = !!dict_get(this_xl->options, "client-pid");
 
-        GF_OPTION_INIT ("uid-map-root", priv->uid_map_root, uint32,
-                        cleanup_exit);
+    GF_OPTION_INIT("uid-map-root", priv->uid_map_root, uint32, cleanup_exit);
 
-        priv->direct_io_mode = 2;
-        ret = dict_get_str (options, ZR_DIRECT_IO_OPT, &value_string);
+    priv->direct_io_mode = 2;
+    ret = dict_get_str(options, ZR_DIRECT_IO_OPT, &value_string);
+    if (ret == 0) {
+        gf_boolean_t direct_io_mode_bool;
+        ret = gf_string2boolean(value_string, &direct_io_mode_bool);
         if (ret == 0) {
-                gf_boolean_t direct_io_mode_bool;
-                ret = gf_string2boolean (value_string, &direct_io_mode_bool);
-                if (ret == 0) {
-                        priv->direct_io_mode = direct_io_mode_bool ? 1 : 0;
-                }
+            priv->direct_io_mode = direct_io_mode_bool ? 1 : 0;
         }
+    }
 
-        GF_OPTION_INIT (ZR_STRICT_VOLFILE_CHECK, priv->strict_volfile_check,
-                        bool, cleanup_exit);
-
-        GF_OPTION_INIT ("acl", priv->acl, bool, cleanup_exit);
+    GF_OPTION_INIT(ZR_STRICT_VOLFILE_CHECK, priv->strict_volfile_check, bool,
+                   cleanup_exit);
 
-        if (priv->uid_map_root)
-                priv->acl = 1;
+    GF_OPTION_INIT("acl", priv->acl, bool, cleanup_exit);
 
-        GF_OPTION_INIT ("selinux", priv->selinux, bool, cleanup_exit);
+    if (priv->uid_map_root)
+        priv->acl = 1;
 
-        GF_OPTION_INIT ("capability", priv->capability, bool, cleanup_exit);
+    GF_OPTION_INIT("selinux", priv->selinux, bool, cleanup_exit);
 
-        GF_OPTION_INIT ("read-only", priv->read_only, bool, cleanup_exit);
+    GF_OPTION_INIT("capability", priv->capability, bool, cleanup_exit);
 
-        GF_OPTION_INIT ("enable-ino32", priv->enable_ino32, bool, cleanup_exit);
+    GF_OPTION_INIT("read-only", priv->read_only, bool, cleanup_exit);
 
-        GF_OPTION_INIT ("use-readdirp", priv->use_readdirp, bool, cleanup_exit);
-
-        priv->fuse_dump_fd = -1;
-        ret = dict_get_str (options, "dump-fuse", &value_string);
-        if (ret == 0) {
-                ret = sys_unlink (value_string);
-                if (ret != -1 || errno == ENOENT)
-                        ret = open (value_string, O_RDWR|O_CREAT|O_EXCL,
-                                    S_IRUSR|S_IWUSR);
-                if (ret == -1) {
-                        gf_log ("glusterfs-fuse", GF_LOG_ERROR,
-                                "cannot open fuse dump file %s",
-                                 value_string);
-
-                        goto cleanup_exit;
-                }
-                priv->fuse_dump_fd = ret;
-        }
+    GF_OPTION_INIT("enable-ino32", priv->enable_ino32, bool, cleanup_exit);
 
-        sync_to_mount = _gf_false;
-        ret = dict_get_str (options, "sync-to-mount", &value_string);
-        if (ret == 0) {
-                ret = gf_string2boolean (value_string,
-                                         &sync_to_mount);
-                GF_ASSERT (ret == 0);
-        }
-
-	priv->fopen_keep_cache = 2;
-	if (dict_get (options, "fopen-keep-cache")) {
-		GF_OPTION_INIT("fopen-keep-cache", fopen_keep_cache, bool,
-			       cleanup_exit);
-		priv->fopen_keep_cache = fopen_keep_cache;
-	}
-
-        GF_OPTION_INIT("gid-timeout", priv->gid_cache_timeout, int32,
-                cleanup_exit);
-
-        GF_OPTION_INIT ("fuse-mountopts", priv->fuse_mountopts, str, cleanup_exit);
-
-        if (gid_cache_init(&priv->gid_cache, priv->gid_cache_timeout) < 0) {
-                gf_log("glusterfs-fuse", GF_LOG_ERROR, "Failed to initialize "
-                        "group cache.");
-                goto cleanup_exit;
-        }
+    GF_OPTION_INIT("use-readdirp", priv->use_readdirp, bool, cleanup_exit);
 
-        GF_OPTION_INIT("resolve-gids", priv->resolve_gids, bool, cleanup_exit);
-
-        /* default values seemed to work fine during testing */
-        GF_OPTION_INIT ("background-qlen", priv->background_qlen, int32,
-                        cleanup_exit);
-        GF_OPTION_INIT ("congestion-threshold", priv->congestion_threshold,
-                        int32, cleanup_exit);
+    priv->fuse_dump_fd = -1;
+    ret = dict_get_str(options, "dump-fuse", &value_string);
+    if (ret == 0) {
+        ret = sys_unlink(value_string);
+        if (ret != -1 || errno == ENOENT)
+            ret = open(value_string, O_RDWR | O_CREAT | O_EXCL,
+                       S_IRUSR | S_IWUSR);
+        if (ret == -1) {
+            gf_log("glusterfs-fuse", GF_LOG_ERROR,
+                   "cannot open fuse dump file %s", value_string);
 
-        GF_OPTION_INIT("no-root-squash", priv->no_root_squash, bool,
-                       cleanup_exit);
-        /* change the client_pid to no-root-squash pid only if the
-           client is none of defrag process, hadoop access and gsyncd process.
-        */
-        if (!priv->client_pid_set) {
-                if (priv->no_root_squash == _gf_true) {
-                        priv->client_pid_set = _gf_true;
-                        priv->client_pid = GF_CLIENT_PID_NO_ROOT_SQUASH;
-                }
+            goto cleanup_exit;
         }
+        priv->fuse_dump_fd = ret;
+    }
 
-        GF_OPTION_INIT("event-history", priv->event_history, bool,
-                       cleanup_exit);
+    sync_to_mount = _gf_false;
+    ret = dict_get_str(options, "sync-to-mount", &value_string);
+    if (ret == 0) {
+        ret = gf_string2boolean(value_string, &sync_to_mount);
+        GF_ASSERT(ret == 0);
+    }
 
-        GF_OPTION_INIT("thin-client", priv->thin_client, bool,
+    priv->fopen_keep_cache = 2;
+    if (dict_get(options, "fopen-keep-cache")) {
+        GF_OPTION_INIT("fopen-keep-cache", fopen_keep_cache, bool,
                        cleanup_exit);
-
-        /* Writeback cache support */
-        GF_OPTION_INIT("kernel-writeback-cache", priv->kernel_writeback_cache,
-                       bool, cleanup_exit);
-        GF_OPTION_INIT("attr-times-granularity", priv->attr_times_granularity,
-	               int32, cleanup_exit);
-
-        /* user has set only background-qlen, not congestion-threshold,
-           use the fuse kernel driver formula to set congestion. ie, 75% */
-        if (dict_get (this_xl->options, "background-qlen") &&
-            !dict_get (this_xl->options, "congestion-threshold")) {
-                priv->congestion_threshold = (priv->background_qlen * 3) / 4;
-                gf_log (this_xl->name, GF_LOG_INFO,
-                        "setting congestion control as 75%% of "
-                        "background-queue length (ie, (.75 * %d) = %d",
-                        priv->background_qlen, priv->congestion_threshold);
-        }
-
-        /* congestion should not be higher than background queue length */
-        if (priv->congestion_threshold > priv->background_qlen) {
-                gf_log (this_xl->name, GF_LOG_INFO,
-                        "setting congestion control same as "
-                        "background-queue length (%d)",
-                        priv->background_qlen);
-                priv->congestion_threshold = priv->background_qlen;
-        }
-
-        cmd_args = &this_xl->ctx->cmd_args;
-        fsname = cmd_args->volfile;
-        if (!fsname && cmd_args->volfile_server) {
-                if (cmd_args->volfile_id) {
-                        int dir_len = 0;
-                        if (cmd_args->subdir_mount)
-                                dir_len = strlen (cmd_args->subdir_mount) + 1;
-                        fsname = GF_MALLOC (
-                                   strlen (cmd_args->volfile_server) + 1 +
-                                   strlen (cmd_args->volfile_id) + 1 +
-                                   dir_len,
-                                   gf_fuse_mt_fuse_private_t);
-                        if (!fsname) {
-                                gf_log ("glusterfs-fuse", GF_LOG_ERROR,
-                                        "Out of memory");
-                                goto cleanup_exit;
-                        }
-                        fsname_allocated = 1;
-                        strcpy (fsname, cmd_args->volfile_server);
-                        strcat (fsname, ":");
-                        strcat (fsname, cmd_args->volfile_id);
-                        if (dir_len)
-                                strcat (fsname, cmd_args->subdir_mount);
-                } else
-                        fsname = cmd_args->volfile_server;
-        }
-        if (!fsname)
-                fsname = "glusterfs";
-
-        priv->fdtable = gf_fd_fdtable_alloc ();
-        if (priv->fdtable == NULL) {
-                gf_log ("glusterfs-fuse", GF_LOG_ERROR, "Out of memory");
-                goto cleanup_exit;
-        }
-
-        gf_asprintf (&mnt_args, "%s%s%s%sallow_other,max_read=131072",
-                     priv->acl ? "" : "default_permissions,",
-                     priv->read_only ? "ro," : "",
-                     priv->fuse_mountopts ? priv->fuse_mountopts : "",
-                     priv->fuse_mountopts ? "," : "");
-        if (!mnt_args)
+        priv->fopen_keep_cache = fopen_keep_cache;
+    }
+
+    GF_OPTION_INIT("gid-timeout", priv->gid_cache_timeout, int32, cleanup_exit);
+
+    GF_OPTION_INIT("fuse-mountopts", priv->fuse_mountopts, str, cleanup_exit);
+
+    if (gid_cache_init(&priv->gid_cache, priv->gid_cache_timeout) < 0) {
+        gf_log("glusterfs-fuse", GF_LOG_ERROR,
+               "Failed to initialize "
+               "group cache.");
+        goto cleanup_exit;
+    }
+
+    GF_OPTION_INIT("resolve-gids", priv->resolve_gids, bool, cleanup_exit);
+
+    /* default values seemed to work fine during testing */
+    GF_OPTION_INIT("background-qlen", priv->background_qlen, int32,
+                   cleanup_exit);
+    GF_OPTION_INIT("congestion-threshold", priv->congestion_threshold, int32,
+                   cleanup_exit);
+
+    GF_OPTION_INIT("no-root-squash", priv->no_root_squash, bool, cleanup_exit);
+    /* change the client_pid to no-root-squash pid only if the
+       client is none of defrag process, hadoop access and gsyncd process.
+    */
+    if (!priv->client_pid_set) {
+        if (priv->no_root_squash == _gf_true) {
+            priv->client_pid_set = _gf_true;
+            priv->client_pid = GF_CLIENT_PID_NO_ROOT_SQUASH;
+        }
+    }
+
+    GF_OPTION_INIT("event-history", priv->event_history, bool, cleanup_exit);
+
+    GF_OPTION_INIT("thin-client", priv->thin_client, bool, cleanup_exit);
+
+    /* Writeback cache support */
+    GF_OPTION_INIT("kernel-writeback-cache", priv->kernel_writeback_cache, bool,
+                   cleanup_exit);
+    GF_OPTION_INIT("attr-times-granularity", priv->attr_times_granularity,
+                   int32, cleanup_exit);
+
+    /* user has set only background-qlen, not congestion-threshold,
+       use the fuse kernel driver formula to set congestion. ie, 75% */
+    if (dict_get(this_xl->options, "background-qlen") &&
+        !dict_get(this_xl->options, "congestion-threshold")) {
+        priv->congestion_threshold = (priv->background_qlen * 3) / 4;
+        gf_log(this_xl->name, GF_LOG_INFO,
+               "setting congestion control as 75%% of "
+               "background-queue length (ie, (.75 * %d) = %d",
+               priv->background_qlen, priv->congestion_threshold);
+    }
+
+    /* congestion should not be higher than background queue length */
+    if (priv->congestion_threshold > priv->background_qlen) {
+        gf_log(this_xl->name, GF_LOG_INFO,
+               "setting congestion control same as "
+               "background-queue length (%d)",
+               priv->background_qlen);
+        priv->congestion_threshold = priv->background_qlen;
+    }
+
+    cmd_args = &this_xl->ctx->cmd_args;
+    fsname = cmd_args->volfile;
+    if (!fsname && cmd_args->volfile_server) {
+        if (cmd_args->volfile_id) {
+            int dir_len = 0;
+            if (cmd_args->subdir_mount)
+                dir_len = strlen(cmd_args->subdir_mount) + 1;
+            fsname = GF_MALLOC(strlen(cmd_args->volfile_server) + 1 +
+                                   strlen(cmd_args->volfile_id) + 1 + dir_len,
+                               gf_fuse_mt_fuse_private_t);
+            if (!fsname) {
+                gf_log("glusterfs-fuse", GF_LOG_ERROR, "Out of memory");
                 goto cleanup_exit;
-
-        {
-                char *mnt_tok         = NULL;
-                token_iter_t tit      = {0,};
-                gf_boolean_t iter_end = _gf_false;
-
-                for (mnt_tok = token_iter_init (mnt_args, ',', &tit) ;;) {
-                        iter_end = next_token (&mnt_tok, &tit);
-
-                        if (strcmp (mnt_tok, "auto_unmount") == 0) {
-                                priv->auto_unmount = _gf_true;
-                                drop_token (mnt_tok, &tit);
-                        }
-
-                        if (iter_end)
-                                break;
-                }
-        }
-
-        if (pipe(priv->status_pipe) < 0) {
-                gf_log (this_xl->name, GF_LOG_ERROR,
-                        "could not create pipe to separate mount process");
-                goto cleanup_exit;
-        }
-
-        priv->fd = gf_fuse_mount (priv->mount_point, fsname, mnt_args,
-                                  sync_to_mount ? &ctx->mnt_pid : NULL,
-                                  priv->status_pipe[1]);
-        if (priv->fd == -1)
-                goto cleanup_exit;
-        if (priv->auto_unmount) {
-                ret = gf_fuse_unmount_daemon (priv->mount_point, priv->fd);
-                if (ret ==-1)
-                        goto cleanup_exit;
-        }
-
-        if (priv->event_history) {
-                event = eh_new (FUSE_EVENT_HISTORY_SIZE, _gf_false, NULL);
-                if (!event) {
-                        gf_log (this_xl->name, GF_LOG_ERROR,
-                                "could not create a new event history");
-                        goto cleanup_exit;
-                }
-
-                this_xl->history = event;
-        }
-
-        pthread_mutex_init (&priv->fuse_dump_mutex, NULL);
-        pthread_cond_init (&priv->sync_cond, NULL);
-        pthread_cond_init (&priv->migrate_cond, NULL);
-        pthread_mutex_init (&priv->sync_mutex, NULL);
-        priv->event_recvd = 0;
-
-        for (i = 0; i < FUSE_OP_HIGH; i++) {
-                if (!fuse_std_ops[i])
-                        fuse_std_ops[i] = fuse_enosys;
-                if (!fuse_dump_ops[i])
-                        fuse_dump_ops[i] = fuse_dumper;
-        }
-        priv->fuse_ops = fuse_std_ops;
-        if (priv->fuse_dump_fd != -1) {
-                priv->fuse_ops0 = priv->fuse_ops;
-                priv->fuse_ops  = fuse_dump_ops;
+            }
+            fsname_allocated = 1;
+            strcpy(fsname, cmd_args->volfile_server);
+            strcat(fsname, ":");
+            strcat(fsname, cmd_args->volfile_id);
+            if (dir_len)
+                strcat(fsname, cmd_args->subdir_mount);
+        } else
+            fsname = cmd_args->volfile_server;
+    }
+    if (!fsname)
+        fsname = "glusterfs";
+
+    priv->fdtable = gf_fd_fdtable_alloc();
+    if (priv->fdtable == NULL) {
+        gf_log("glusterfs-fuse", GF_LOG_ERROR, "Out of memory");
+        goto cleanup_exit;
+    }
+
+    gf_asprintf(&mnt_args, "%s%s%s%sallow_other,max_read=131072",
+                priv->acl ? "" : "default_permissions,",
+                priv->read_only ? "ro," : "",
+                priv->fuse_mountopts ? priv->fuse_mountopts : "",
+                priv->fuse_mountopts ? "," : "");
+    if (!mnt_args)
+        goto cleanup_exit;
+
+    {
+        char *mnt_tok = NULL;
+        token_iter_t tit = {
+            0,
+        };
+        gf_boolean_t iter_end = _gf_false;
+
+        for (mnt_tok = token_iter_init(mnt_args, ',', &tit);;) {
+            iter_end = next_token(&mnt_tok, &tit);
+
+            if (strcmp(mnt_tok, "auto_unmount") == 0) {
+                priv->auto_unmount = _gf_true;
+                drop_token(mnt_tok, &tit);
+            }
+
+            if (iter_end)
+                break;
         }
-
-        if (fsname_allocated)
-                GF_FREE (fsname);
-        GF_FREE (mnt_args);
-        return 0;
+    }
+
+    if (pipe(priv->status_pipe) < 0) {
+        gf_log(this_xl->name, GF_LOG_ERROR,
+               "could not create pipe to separate mount process");
+        goto cleanup_exit;
+    }
+
+    priv->fd = gf_fuse_mount(priv->mount_point, fsname, mnt_args,
+                             sync_to_mount ? &ctx->mnt_pid : NULL,
+                             priv->status_pipe[1]);
+    if (priv->fd == -1)
+        goto cleanup_exit;
+    if (priv->auto_unmount) {
+        ret = gf_fuse_unmount_daemon(priv->mount_point, priv->fd);
+        if (ret == -1)
+            goto cleanup_exit;
+    }
+
+    if (priv->event_history) {
+        event = eh_new(FUSE_EVENT_HISTORY_SIZE, _gf_false, NULL);
+        if (!event) {
+            gf_log(this_xl->name, GF_LOG_ERROR,
+                   "could not create a new event history");
+            goto cleanup_exit;
+        }
+
+        this_xl->history = event;
+    }
+
+    pthread_mutex_init(&priv->fuse_dump_mutex, NULL);
+    pthread_cond_init(&priv->sync_cond, NULL);
+    pthread_cond_init(&priv->migrate_cond, NULL);
+    pthread_mutex_init(&priv->sync_mutex, NULL);
+    priv->event_recvd = 0;
+
+    for (i = 0; i < FUSE_OP_HIGH; i++) {
+        if (!fuse_std_ops[i])
+            fuse_std_ops[i] = fuse_enosys;
+        if (!fuse_dump_ops[i])
+            fuse_dump_ops[i] = fuse_dumper;
+    }
+    priv->fuse_ops = fuse_std_ops;
+    if (priv->fuse_dump_fd != -1) {
+        priv->fuse_ops0 = priv->fuse_ops;
+        priv->fuse_ops = fuse_dump_ops;
+    }
+
+    if (fsname_allocated)
+        GF_FREE(fsname);
+    GF_FREE(mnt_args);
+    return 0;
 
 cleanup_exit:
-        if (xl_name_allocated)
-                GF_FREE (this_xl->name);
-        if (fsname_allocated)
-                GF_FREE (fsname);
-        if (priv) {
-                GF_FREE (priv->mount_point);
-                if (priv->fd != -1)
-                        sys_close (priv->fd);
-                if (priv->fuse_dump_fd != -1)
-                        sys_close (priv->fuse_dump_fd);
-                GF_FREE (priv);
-        }
-        GF_FREE (mnt_args);
-        return -1;
+    if (xl_name_allocated)
+        GF_FREE(this_xl->name);
+    if (fsname_allocated)
+        GF_FREE(fsname);
+    if (priv) {
+        GF_FREE(priv->mount_point);
+        if (priv->fd != -1)
+            sys_close(priv->fd);
+        if (priv->fuse_dump_fd != -1)
+            sys_close(priv->fuse_dump_fd);
+        GF_FREE(priv);
+    }
+    GF_FREE(mnt_args);
+    return -1;
 }
 
-
 void
-fini (xlator_t *this_xl)
+fini(xlator_t *this_xl)
 {
-        fuse_private_t *priv = NULL;
-        char *mount_point = NULL;
+    fuse_private_t *priv = NULL;
+    char *mount_point = NULL;
 
-        if (this_xl == NULL)
-                return;
+    if (this_xl == NULL)
+        return;
 
-        if ((priv = this_xl->private) == NULL)
-                return;
+    if ((priv = this_xl->private) == NULL)
+        return;
 
-        pthread_mutex_lock (&priv->sync_mutex);
-        {
-                if (!(priv->fini_invoked)) {
-                        priv->fini_invoked = _gf_true;
-                } else {
-                        pthread_mutex_unlock (&priv->sync_mutex);
-                        return;
-                }
+    pthread_mutex_lock(&priv->sync_mutex);
+    {
+        if (!(priv->fini_invoked)) {
+            priv->fini_invoked = _gf_true;
+        } else {
+            pthread_mutex_unlock(&priv->sync_mutex);
+            return;
         }
-        pthread_mutex_unlock (&priv->sync_mutex);
-
-        if (dict_get (this_xl->options, ZR_MOUNTPOINT_OPT))
-                mount_point = data_to_str (dict_get (this_xl->options,
-                                                     ZR_MOUNTPOINT_OPT));
-        if (mount_point != NULL) {
-                if (!priv->auto_unmount) {
-                        gf_log (this_xl->name, GF_LOG_INFO,
-                                "Unmounting '%s'.", mount_point);
-                        gf_fuse_unmount (mount_point, priv->fd);
-                }
-
-                gf_log (this_xl->name, GF_LOG_INFO,
-                        "Closing fuse connection to '%s'.", mount_point);
+    }
+    pthread_mutex_unlock(&priv->sync_mutex);
 
-                sys_close (priv->fuse_dump_fd);
-                dict_del (this_xl->options, ZR_MOUNTPOINT_OPT);
+    if (dict_get(this_xl->options, ZR_MOUNTPOINT_OPT))
+        mount_point = data_to_str(
+            dict_get(this_xl->options, ZR_MOUNTPOINT_OPT));
+    if (mount_point != NULL) {
+        if (!priv->auto_unmount) {
+            gf_log(this_xl->name, GF_LOG_INFO, "Unmounting '%s'.", mount_point);
+            gf_fuse_unmount(mount_point, priv->fd);
         }
-        /* Process should terminate once fuse xlator is finished.
-         * Required for AUTH_FAILED event.
-         */
-        kill (getpid (), SIGTERM);
+
+        gf_log(this_xl->name, GF_LOG_INFO, "Closing fuse connection to '%s'.",
+               mount_point);
+
+        sys_close(priv->fuse_dump_fd);
+        dict_del(this_xl->options, ZR_MOUNTPOINT_OPT);
+    }
+    /* Process should terminate once fuse xlator is finished.
+     * Required for AUTH_FAILED event.
+     */
+    kill(getpid(), SIGTERM);
 }
 
 struct xlator_fops fops;
 
-struct xlator_cbks cbks = {
-        .invalidate = fuse_invalidate,
-        .forget     = fuse_forget_cbk,
-        .release    = fuse_internal_release
-};
-
+struct xlator_cbks cbks = {.invalidate = fuse_invalidate,
+                           .forget = fuse_forget_cbk,
+                           .release = fuse_internal_release};
 
 struct xlator_dumpops dumpops = {
-        .priv  = fuse_priv_dump,
-        .inode = fuse_itable_dump,
-        .history = fuse_history_dump,
+    .priv = fuse_priv_dump,
+    .inode = fuse_itable_dump,
+    .history = fuse_history_dump,
 };
 
 struct volume_options options[] = {
-        { .key  = {"direct-io-mode"},
-          .type = GF_OPTION_TYPE_BOOL
-        },
-        { .key  = {ZR_MOUNTPOINT_OPT, "mount-point"},
-          .type = GF_OPTION_TYPE_PATH
-        },
-        { .key  = {ZR_DUMP_FUSE, "fuse-dumpfile"},
-          .type = GF_OPTION_TYPE_PATH
-        },
-        { .key  = {ZR_ATTR_TIMEOUT_OPT},
-          .type = GF_OPTION_TYPE_DOUBLE,
-          .default_value = "1.0"
-        },
-        { .key  = {ZR_ENTRY_TIMEOUT_OPT},
-          .type = GF_OPTION_TYPE_DOUBLE,
-          .default_value = "1.0"
-        },
-        { .key  = {ZR_NEGATIVE_TIMEOUT_OPT},
-          .type = GF_OPTION_TYPE_DOUBLE,
-          .default_value = "0.0"
-        },
-        { .key  = {ZR_STRICT_VOLFILE_CHECK},
-          .type = GF_OPTION_TYPE_BOOL,
-          .default_value = "false"
-        },
-        { .key  = {"client-pid"},
-          .type = GF_OPTION_TYPE_INT
-        },
-        { .key  = {"uid-map-root"},
-          .type = GF_OPTION_TYPE_INT
-        },
-        { .key  = {"sync-to-mount"},
-          .type = GF_OPTION_TYPE_BOOL
-        },
-        { .key = {"read-only"},
-          .type = GF_OPTION_TYPE_BOOL
-        },
-        { .key = {"fopen-keep-cache"},
-          .type = GF_OPTION_TYPE_BOOL,
-          .default_value = "false"
-        },
-        { .key = {"gid-timeout"},
-          .type = GF_OPTION_TYPE_INT,
-          .default_value = "300"
-        },
-        { .key = {"resolve-gids"},
-          .type = GF_OPTION_TYPE_BOOL,
-          .default_value = "false"
-        },
-        { .key = {"acl"},
-          .type = GF_OPTION_TYPE_BOOL,
-          .default_value = "false"
-        },
-        { .key = {"selinux"},
-          .type = GF_OPTION_TYPE_BOOL,
-          .default_value = "false"
-        },
-        { .key = {"enable-ino32"},
-          .type = GF_OPTION_TYPE_BOOL,
-          .default_value = "false"
-        },
-        { .key  = {"background-qlen"},
-          .type = GF_OPTION_TYPE_INT,
-          .default_value = "64",
-          .min = 16,
-          .max = (64 * GF_UNIT_KB),
-        },
-        { .key  = {"congestion-threshold"},
-          .type = GF_OPTION_TYPE_INT,
-          .default_value = "48",
-          .min = 12,
-          .max = (64 * GF_UNIT_KB),
-        },
-        { .key = {"fuse-mountopts"},
-          .type = GF_OPTION_TYPE_STR
-        },
-        { .key = {"use-readdirp"},
-          .type = GF_OPTION_TYPE_BOOL,
-          .default_value = "yes"
-        },
-        { .key = {"no-root-squash"},
-          .type = GF_OPTION_TYPE_BOOL,
-          .default_value = "false",
-          .description = "This is the mount option for disabling the "
-          "root squash for the client irrespective of whether the root-squash "
-          "option for the volume is set or not. But this option is honoured "
-          "only for the trusted clients. For non trusted clients this value "
-          "does not have any affect and the volume option for root-squash is "
-          "honoured.",
-        },
-        { .key = {"capability"},
-          .type = GF_OPTION_TYPE_BOOL,
-          .default_value = "false"
-        },
-        { .key = {"event-history"},
-          .type = GF_OPTION_TYPE_BOOL,
-          .default_value = "false",
-          .description = "This option can be used to enable or disable fuse "
-          "event history.",
-        },
-        { .key = {"thin-client"},
-          .type = GF_OPTION_TYPE_BOOL,
-          .default_value = "false",
-          .description = "Enables thin mount and connects via gfproxyd daemon.",
-        },
-        { .key = {"reader-thread-count"},
-          .type = GF_OPTION_TYPE_INT,
-          .default_value = "1",
-          .min = 1,
-          .max = 64,
-          .description = "Sets fuse reader thread count.",
-        },
-        { .key = {"kernel-writeback-cache"},
-          .type = GF_OPTION_TYPE_BOOL,
-          .default_value = "false",
-          .description = "Enables fuse in-kernel writeback cache.",
-        },
-        { .key = {"attr-times-granularity"},
-          .type = GF_OPTION_TYPE_INT,
-          .default_value = "0",
-          .min = 0,
-          .max = 1000000000,
-          .description = "Supported granularity of file attribute times.",
-        },
-        { .key = {NULL} },
+    {.key = {"direct-io-mode"}, .type = GF_OPTION_TYPE_BOOL},
+    {.key = {ZR_MOUNTPOINT_OPT, "mount-point"}, .type = GF_OPTION_TYPE_PATH},
+    {.key = {ZR_DUMP_FUSE, "fuse-dumpfile"}, .type = GF_OPTION_TYPE_PATH},
+    {.key = {ZR_ATTR_TIMEOUT_OPT},
+     .type = GF_OPTION_TYPE_DOUBLE,
+     .default_value = "1.0"},
+    {.key = {ZR_ENTRY_TIMEOUT_OPT},
+     .type = GF_OPTION_TYPE_DOUBLE,
+     .default_value = "1.0"},
+    {.key = {ZR_NEGATIVE_TIMEOUT_OPT},
+     .type = GF_OPTION_TYPE_DOUBLE,
+     .default_value = "0.0"},
+    {.key = {ZR_STRICT_VOLFILE_CHECK},
+     .type = GF_OPTION_TYPE_BOOL,
+     .default_value = "false"},
+    {.key = {"client-pid"}, .type = GF_OPTION_TYPE_INT},
+    {.key = {"uid-map-root"}, .type = GF_OPTION_TYPE_INT},
+    {.key = {"sync-to-mount"}, .type = GF_OPTION_TYPE_BOOL},
+    {.key = {"read-only"}, .type = GF_OPTION_TYPE_BOOL},
+    {.key = {"fopen-keep-cache"},
+     .type = GF_OPTION_TYPE_BOOL,
+     .default_value = "false"},
+    {.key = {"gid-timeout"},
+     .type = GF_OPTION_TYPE_INT,
+     .default_value = "300"},
+    {.key = {"resolve-gids"},
+     .type = GF_OPTION_TYPE_BOOL,
+     .default_value = "false"},
+    {.key = {"acl"}, .type = GF_OPTION_TYPE_BOOL, .default_value = "false"},
+    {.key = {"selinux"}, .type = GF_OPTION_TYPE_BOOL, .default_value = "false"},
+    {.key = {"enable-ino32"},
+     .type = GF_OPTION_TYPE_BOOL,
+     .default_value = "false"},
+    {
+        .key = {"background-qlen"},
+        .type = GF_OPTION_TYPE_INT,
+        .default_value = "64",
+        .min = 16,
+        .max = (64 * GF_UNIT_KB),
+    },
+    {
+        .key = {"congestion-threshold"},
+        .type = GF_OPTION_TYPE_INT,
+        .default_value = "48",
+        .min = 12,
+        .max = (64 * GF_UNIT_KB),
+    },
+    {.key = {"fuse-mountopts"}, .type = GF_OPTION_TYPE_STR},
+    {.key = {"use-readdirp"},
+     .type = GF_OPTION_TYPE_BOOL,
+     .default_value = "yes"},
+    {
+        .key = {"no-root-squash"},
+        .type = GF_OPTION_TYPE_BOOL,
+        .default_value = "false",
+        .description =
+            "This is the mount option for disabling the "
+            "root squash for the client irrespective of whether the "
+            "root-squash "
+            "option for the volume is set or not. But this option is honoured "
+            "only for the trusted clients. For non trusted clients this value "
+            "does not have any affect and the volume option for root-squash is "
+            "honoured.",
+    },
+    {.key = {"capability"},
+     .type = GF_OPTION_TYPE_BOOL,
+     .default_value = "false"},
+    {
+        .key = {"event-history"},
+        .type = GF_OPTION_TYPE_BOOL,
+        .default_value = "false",
+        .description = "This option can be used to enable or disable fuse "
+                       "event history.",
+    },
+    {
+        .key = {"thin-client"},
+        .type = GF_OPTION_TYPE_BOOL,
+        .default_value = "false",
+        .description = "Enables thin mount and connects via gfproxyd daemon.",
+    },
+    {
+        .key = {"reader-thread-count"},
+        .type = GF_OPTION_TYPE_INT,
+        .default_value = "1",
+        .min = 1,
+        .max = 64,
+        .description = "Sets fuse reader thread count.",
+    },
+    {
+        .key = {"kernel-writeback-cache"},
+        .type = GF_OPTION_TYPE_BOOL,
+        .default_value = "false",
+        .description = "Enables fuse in-kernel writeback cache.",
+    },
+    {
+        .key = {"attr-times-granularity"},
+        .type = GF_OPTION_TYPE_INT,
+        .default_value = "0",
+        .min = 0,
+        .max = 1000000000,
+        .description = "Supported granularity of file attribute times.",
+    },
+    {.key = {NULL}},
 };
diff --git a/xlators/mount/fuse/src/fuse-helpers.c b/xlators/mount/fuse/src/fuse-helpers.c
index a4e80b385dd..2145a951c4e 100644
--- a/xlators/mount/fuse/src/fuse-helpers.c
+++ b/xlators/mount/fuse/src/fuse-helpers.c
@@ -24,267 +24,264 @@
 #include "fuse-bridge.h"
 
 static void
-fuse_resolve_wipe (fuse_resolve_t *resolve)
+fuse_resolve_wipe(fuse_resolve_t *resolve)
 {
-        GF_FREE ((void *)resolve->path);
+    GF_FREE((void *)resolve->path);
 
-        GF_FREE ((void *)resolve->bname);
+    GF_FREE((void *)resolve->bname);
 
-        if (resolve->fd)
-                fd_unref (resolve->fd);
+    if (resolve->fd)
+        fd_unref(resolve->fd);
 
-        loc_wipe (&resolve->resolve_loc);
+    loc_wipe(&resolve->resolve_loc);
 
-	if (resolve->hint) {
-		inode_unref (resolve->hint);
-		resolve->hint = 0;
-	}
+    if (resolve->hint) {
+        inode_unref(resolve->hint);
+        resolve->hint = 0;
+    }
 
-	if (resolve->parhint) {
-		inode_unref (resolve->parhint);
-		resolve->parhint = 0;
-	}
+    if (resolve->parhint) {
+        inode_unref(resolve->parhint);
+        resolve->parhint = 0;
+    }
 }
 
-
 void
-free_fuse_state (fuse_state_t *state)
+free_fuse_state(fuse_state_t *state)
 {
-        xlator_t       *this     = NULL;
-        fuse_private_t *priv     = NULL;
-        uint64_t        winds    = 0;
-        char            switched = 0;
-
-        this = state->this;
-
-        priv = this->private;
-
-        loc_wipe (&state->loc);
-
-        loc_wipe (&state->loc2);
-
-        if (state->xdata) {
-                dict_unref (state->xdata);
-                state->xdata = (void *)0xaaaaeeee;
-        }
-        if (state->xattr)
-                dict_unref (state->xattr);
-
-        if (state->name) {
-                GF_FREE (state->name);
-                state->name = NULL;
-        }
-        if (state->fd) {
-                fd_unref (state->fd);
-                state->fd = (void *)0xfdfdfdfd;
-        }
-        if (state->finh) {
-                GF_FREE (state->finh);
-                state->finh = NULL;
-        }
-
-        fuse_resolve_wipe (&state->resolve);
-        fuse_resolve_wipe (&state->resolve2);
-
-        pthread_mutex_lock (&priv->sync_mutex);
-        {
-                winds = --state->active_subvol->winds;
-                switched = state->active_subvol->switched;
-        }
-        pthread_mutex_unlock (&priv->sync_mutex);
-
-        if ((winds == 0) && (switched)) {
-                xlator_notify (state->active_subvol, GF_EVENT_PARENT_DOWN,
-                               state->active_subvol, NULL);
-        }
+    xlator_t *this = NULL;
+    fuse_private_t *priv = NULL;
+    uint64_t winds = 0;
+    char switched = 0;
+
+    this = state->this;
+
+    priv = this->private;
+
+    loc_wipe(&state->loc);
+
+    loc_wipe(&state->loc2);
+
+    if (state->xdata) {
+        dict_unref(state->xdata);
+        state->xdata = (void *)0xaaaaeeee;
+    }
+    if (state->xattr)
+        dict_unref(state->xattr);
+
+    if (state->name) {
+        GF_FREE(state->name);
+        state->name = NULL;
+    }
+    if (state->fd) {
+        fd_unref(state->fd);
+        state->fd = (void *)0xfdfdfdfd;
+    }
+    if (state->finh) {
+        GF_FREE(state->finh);
+        state->finh = NULL;
+    }
+
+    fuse_resolve_wipe(&state->resolve);
+    fuse_resolve_wipe(&state->resolve2);
+
+    pthread_mutex_lock(&priv->sync_mutex);
+    {
+        winds = --state->active_subvol->winds;
+        switched = state->active_subvol->switched;
+    }
+    pthread_mutex_unlock(&priv->sync_mutex);
+
+    if ((winds == 0) && (switched)) {
+        xlator_notify(state->active_subvol, GF_EVENT_PARENT_DOWN,
+                      state->active_subvol, NULL);
+    }
 
 #ifdef DEBUG
-        memset (state, 0x90, sizeof (*state));
+    memset(state, 0x90, sizeof(*state));
 #endif
-        GF_FREE (state);
-        state = NULL;
+    GF_FREE(state);
+    state = NULL;
 }
 
-
 fuse_state_t *
-get_fuse_state (xlator_t *this, fuse_in_header_t *finh)
+get_fuse_state(xlator_t *this, fuse_in_header_t *finh)
 {
-        fuse_state_t   *state         = NULL;
-	xlator_t       *active_subvol = NULL;
-        fuse_private_t *priv          = NULL;
-
-        state = (void *)GF_CALLOC (1, sizeof (*state),
-                                   gf_fuse_mt_fuse_state_t);
-        if (!state)
-                return NULL;
-
-	state->this = THIS;
-        priv = this->private;
-
-        pthread_mutex_lock (&priv->sync_mutex);
-        {
-                while (priv->handle_graph_switch)
-                        pthread_cond_wait (&priv->migrate_cond,
-                                           &priv->sync_mutex);
-                active_subvol = fuse_active_subvol (state->this);
-                active_subvol->winds++;
-        }
-        pthread_mutex_unlock (&priv->sync_mutex);
+    fuse_state_t *state = NULL;
+    xlator_t *active_subvol = NULL;
+    fuse_private_t *priv = NULL;
 
-	state->active_subvol = active_subvol;
-	state->itable = active_subvol->itable;
+    state = (void *)GF_CALLOC(1, sizeof(*state), gf_fuse_mt_fuse_state_t);
+    if (!state)
+        return NULL;
 
-        state->pool = this->ctx->pool;
-        state->finh = finh;
-        state->this = this;
+    state->this = THIS;
+    priv = this->private;
 
-        LOCK_INIT (&state->lock);
+    pthread_mutex_lock(&priv->sync_mutex);
+    {
+        while (priv->handle_graph_switch)
+            pthread_cond_wait(&priv->migrate_cond, &priv->sync_mutex);
+        active_subvol = fuse_active_subvol(state->this);
+        active_subvol->winds++;
+    }
+    pthread_mutex_unlock(&priv->sync_mutex);
 
-        return state;
-}
+    state->active_subvol = active_subvol;
+    state->itable = active_subvol->itable;
 
+    state->pool = this->ctx->pool;
+    state->finh = finh;
+    state->this = this;
 
-#define FUSE_MAX_AUX_GROUPS 32 /* We can get only up to 32 aux groups from /proc */
+    LOCK_INIT(&state->lock);
+
+    return state;
+}
+
+#define FUSE_MAX_AUX_GROUPS                                                    \
+    32 /* We can get only up to 32 aux groups from /proc */
 void
-frame_fill_groups (call_frame_t *frame)
+frame_fill_groups(call_frame_t *frame)
 {
 #if defined(GF_LINUX_HOST_OS)
-        xlator_t       *this          = frame->this;
-        fuse_private_t *priv          = this->private;
-        char            filename[32];
-        char            line[4096];
-        char           *ptr           = NULL;
-        FILE           *fp            = NULL;
-        int             idx           = 0;
-        long int        id            = 0;
-        char           *saveptr       = NULL;
-        char           *endptr        = NULL;
-        int             ret           = 0;
-        int             ngroups       = 0;
-        gid_t          *mygroups      = NULL;
-
-        if (priv->resolve_gids) {
-                struct passwd    pwent;
-                char             mystrs[1024];
-                struct passwd   *result;
-
-                if (getpwuid_r (frame->root->uid, &pwent, mystrs,
-                                sizeof(mystrs), &result) != 0) {
-                        gf_log (this->name, GF_LOG_ERROR, "getpwuid_r(%u) "
-                                "failed", frame->root->uid);
-                        return;
-                }
-                if (result == 0) {
-                        gf_log (this->name, GF_LOG_ERROR, "getpwuid_r(%u): "
-                                "no matching record", frame->root->uid);
-                        return;
-                }
+    xlator_t *this = frame->this;
+    fuse_private_t *priv = this->private;
+    char filename[32];
+    char line[4096];
+    char *ptr = NULL;
+    FILE *fp = NULL;
+    int idx = 0;
+    long int id = 0;
+    char *saveptr = NULL;
+    char *endptr = NULL;
+    int ret = 0;
+    int ngroups = 0;
+    gid_t *mygroups = NULL;
+
+    if (priv->resolve_gids) {
+        struct passwd pwent;
+        char mystrs[1024];
+        struct passwd *result;
+
+        if (getpwuid_r(frame->root->uid, &pwent, mystrs, sizeof(mystrs),
+                       &result) != 0) {
+            gf_log(this->name, GF_LOG_ERROR,
+                   "getpwuid_r(%u) "
+                   "failed",
+                   frame->root->uid);
+            return;
+        }
+        if (result == 0) {
+            gf_log(this->name, GF_LOG_ERROR,
+                   "getpwuid_r(%u): "
+                   "no matching record",
+                   frame->root->uid);
+            return;
+        }
 
-                ngroups = gf_getgrouplist (result->pw_name, frame->root->gid,
-                                           &mygroups);
-                if (ngroups == -1) {
-                        gf_log (this->name, GF_LOG_ERROR, "could not map %s to "
-                                "group list (ngroups %d, max %d)",
-                                result->pw_name, ngroups, GF_MAX_AUX_GROUPS);
-                        return;
-                }
+        ngroups = gf_getgrouplist(result->pw_name, frame->root->gid, &mygroups);
+        if (ngroups == -1) {
+            gf_log(this->name, GF_LOG_ERROR,
+                   "could not map %s to "
+                   "group list (ngroups %d, max %d)",
+                   result->pw_name, ngroups, GF_MAX_AUX_GROUPS);
+            return;
+        }
 
-                call_stack_set_groups (frame->root, ngroups, &mygroups);
-        } else {
-                ret = snprintf (filename, sizeof filename, "/proc/%d/status",
-                                frame->root->pid);
-                if (ret >= sizeof filename)
-                        goto out;
-
-                fp = fopen (filename, "r");
-                if (!fp)
-                        goto out;
-
-                if (call_stack_alloc_groups (frame->root, ngroups) != 0)
-                        goto out;
-
-                while ((ptr = fgets (line, sizeof line, fp))) {
-                        if (strncmp (ptr, "Groups:", 7) != 0)
-                                continue;
-
-                        ptr = line + 8;
-
-                        for (ptr = strtok_r (ptr, " \t\r\n", &saveptr);
-                             ptr;
-                             ptr = strtok_r (NULL, " \t\r\n", &saveptr)) {
-                                errno = 0;
-                                id = strtol (ptr, &endptr, 0);
-                                if (errno == ERANGE)
-                                        break;
-                                if (!endptr || *endptr)
-                                        break;
-                                frame->root->groups[idx++] = id;
-                                if (idx == FUSE_MAX_AUX_GROUPS)
-                                        break;
-                        }
-
-                        frame->root->ngrps = idx;
-                        break;
-                }
+        call_stack_set_groups(frame->root, ngroups, &mygroups);
+    } else {
+        ret = snprintf(filename, sizeof filename, "/proc/%d/status",
+                       frame->root->pid);
+        if (ret >= sizeof filename)
+            goto out;
+
+        fp = fopen(filename, "r");
+        if (!fp)
+            goto out;
+
+        if (call_stack_alloc_groups(frame->root, ngroups) != 0)
+            goto out;
+
+        while ((ptr = fgets(line, sizeof line, fp))) {
+            if (strncmp(ptr, "Groups:", 7) != 0)
+                continue;
+
+            ptr = line + 8;
+
+            for (ptr = strtok_r(ptr, " \t\r\n", &saveptr); ptr;
+                 ptr = strtok_r(NULL, " \t\r\n", &saveptr)) {
+                errno = 0;
+                id = strtol(ptr, &endptr, 0);
+                if (errno == ERANGE)
+                    break;
+                if (!endptr || *endptr)
+                    break;
+                frame->root->groups[idx++] = id;
+                if (idx == FUSE_MAX_AUX_GROUPS)
+                    break;
+            }
+
+            frame->root->ngrps = idx;
+            break;
         }
+    }
 
 out:
-        if (fp)
-                fclose (fp);
+    if (fp)
+        fclose(fp);
 #elif defined(GF_SOLARIS_HOST_OS)
-        char         filename[32];
-        char         scratch[128];
-        prcred_t    *prcred = (prcred_t *) scratch;
-        FILE        *fp = NULL;
-        int          ret = 0;
-        int          ngrps;
-
-        ret = snprintf (filename, sizeof filename,
-                        "/proc/%d/cred", frame->root->pid);
-
-        if (ret < sizeof filename) {
-                fp = fopen (filename, "r");
-                if (fp != NULL) {
-                        if (fgets (scratch, sizeof scratch, fp) != NULL) {
-                                ngrps = MIN(prcred->pr_ngroups,
-                                            FUSE_MAX_AUX_GROUPS);
-                                if (call_stack_alloc_groups (frame->root,
-                                                             ngrps) != 0) {
-                                        fclose (fp);
-                                        return;
-                                }
-                        }
-                        fclose (fp);
-                 }
-         }
+    char filename[32];
+    char scratch[128];
+    prcred_t *prcred = (prcred_t *)scratch;
+    FILE *fp = NULL;
+    int ret = 0;
+    int ngrps;
+
+    ret = snprintf(filename, sizeof filename, "/proc/%d/cred",
+                   frame->root->pid);
+
+    if (ret < sizeof filename) {
+        fp = fopen(filename, "r");
+        if (fp != NULL) {
+            if (fgets(scratch, sizeof scratch, fp) != NULL) {
+                ngrps = MIN(prcred->pr_ngroups, FUSE_MAX_AUX_GROUPS);
+                if (call_stack_alloc_groups(frame->root, ngrps) != 0) {
+                    fclose(fp);
+                    return;
+                }
+            }
+            fclose(fp);
+        }
+    }
 #elif defined(CTL_KERN) /* DARWIN and *BSD */
-        /*
-           N.B. CTL_KERN is an enum on Linux. (Meaning, if it's not
-           obvious, that it's not subject to preprocessor directives
-           like '#if defined'.)
-           Unlike Linux, on Mac OS and the BSDs it is a #define. We
-           could test to see that KERN_PROC is defined, but, barring any
-           evidence to the contrary, I think that's overkill.
-           We might also test that GF_DARWIN_HOST_OS is defined, why
-           limit this to just Mac OS. It's equally valid for the BSDs
-           and we do have people building on NetBSD and FreeBSD.
-        */
-        int name[] = { CTL_KERN, KERN_PROC, KERN_PROC_PID, frame->root->pid };
-        size_t namelen = sizeof name / sizeof name[0];
-        struct kinfo_proc kp;
-        size_t kplen = sizeof(kp);
-        int i, ngroups;
-
-        if (sysctl(name, namelen, &kp, &kplen, NULL, 0) != 0)
-                return;
-        ngroups = MIN(kp.kp_eproc.e_ucred.cr_ngroups, NGROUPS_MAX);
-        if (call_stack_alloc_groups (frame->root, ngroups) != 0)
-                return;
-        for (i = 0; i < ngroups; i++)
-                frame->root->groups[i] = kp.kp_eproc.e_ucred.cr_groups[i];
-        frame->root->ngrps = ngroups;
+    /*
+       N.B. CTL_KERN is an enum on Linux. (Meaning, if it's not
+       obvious, that it's not subject to preprocessor directives
+       like '#if defined'.)
+       Unlike Linux, on Mac OS and the BSDs it is a #define. We
+       could test to see that KERN_PROC is defined, but, barring any
+       evidence to the contrary, I think that's overkill.
+       We might also test that GF_DARWIN_HOST_OS is defined, why
+       limit this to just Mac OS. It's equally valid for the BSDs
+       and we do have people building on NetBSD and FreeBSD.
+    */
+    int name[] = {CTL_KERN, KERN_PROC, KERN_PROC_PID, frame->root->pid};
+    size_t namelen = sizeof name / sizeof name[0];
+    struct kinfo_proc kp;
+    size_t kplen = sizeof(kp);
+    int i, ngroups;
+
+    if (sysctl(name, namelen, &kp, &kplen, NULL, 0) != 0)
+        return;
+    ngroups = MIN(kp.kp_eproc.e_ucred.cr_ngroups, NGROUPS_MAX);
+    if (call_stack_alloc_groups(frame->root, ngroups) != 0)
+        return;
+    for (i = 0; i < ngroups; i++)
+        frame->root->groups[i] = kp.kp_eproc.e_ucred.cr_groups[i];
+    frame->root->ngrps = ngroups;
 #else
-        frame->root->ngrps = 0;
+    frame->root->ngrps = 0;
 #endif /* GF_LINUX_HOST_OS */
 }
 
@@ -292,391 +289,389 @@ out:
  * Get the groups for the PID associated with this frame. If enabled,
  * use the gid cache to reduce group list collection.
  */
-static void get_groups(fuse_private_t *priv, call_frame_t *frame)
+static void
+get_groups(fuse_private_t *priv, call_frame_t *frame)
 {
-	int i;
-	const gid_list_t *gl;
-	gid_list_t agl;
-
-	if (!priv || !priv->gid_cache_timeout) {
-		frame_fill_groups(frame);
-		return;
-	}
-
-        if (-1 == priv->gid_cache_timeout) {
-                frame->root->ngrps = 0;
-                return;
-        }
+    int i;
+    const gid_list_t *gl;
+    gid_list_t agl;
 
-	gl = gid_cache_lookup(&priv->gid_cache, frame->root->pid,
-			      frame->root->uid, frame->root->gid);
-	if (gl) {
-		if (call_stack_alloc_groups (frame->root, gl->gl_count) != 0)
-			return;
-		frame->root->ngrps = gl->gl_count;
-		for (i = 0; i < gl->gl_count; i++)
-			frame->root->groups[i] = gl->gl_list[i];
-		gid_cache_release(&priv->gid_cache, gl);
-		return;
-	}
-
-	frame_fill_groups (frame);
-
-	agl.gl_id = frame->root->pid;
-	agl.gl_uid = frame->root->uid;
-	agl.gl_gid = frame->root->gid;
-	agl.gl_count = frame->root->ngrps;
-	agl.gl_list = GF_CALLOC(frame->root->ngrps, sizeof(gid_t),
-			gf_fuse_mt_gids_t);
-	if (!agl.gl_list)
-		return;
-
-	for (i = 0; i < frame->root->ngrps; i++)
-		agl.gl_list[i] = frame->root->groups[i];
-
-	if (gid_cache_add(&priv->gid_cache, &agl) != 1)
-		GF_FREE(agl.gl_list);
+    if (!priv || !priv->gid_cache_timeout) {
+        frame_fill_groups(frame);
+        return;
+    }
+
+    if (-1 == priv->gid_cache_timeout) {
+        frame->root->ngrps = 0;
+        return;
+    }
+
+    gl = gid_cache_lookup(&priv->gid_cache, frame->root->pid, frame->root->uid,
+                          frame->root->gid);
+    if (gl) {
+        if (call_stack_alloc_groups(frame->root, gl->gl_count) != 0)
+            return;
+        frame->root->ngrps = gl->gl_count;
+        for (i = 0; i < gl->gl_count; i++)
+            frame->root->groups[i] = gl->gl_list[i];
+        gid_cache_release(&priv->gid_cache, gl);
+        return;
+    }
+
+    frame_fill_groups(frame);
+
+    agl.gl_id = frame->root->pid;
+    agl.gl_uid = frame->root->uid;
+    agl.gl_gid = frame->root->gid;
+    agl.gl_count = frame->root->ngrps;
+    agl.gl_list = GF_CALLOC(frame->root->ngrps, sizeof(gid_t),
+                            gf_fuse_mt_gids_t);
+    if (!agl.gl_list)
+        return;
+
+    for (i = 0; i < frame->root->ngrps; i++)
+        agl.gl_list[i] = frame->root->groups[i];
+
+    if (gid_cache_add(&priv->gid_cache, &agl) != 1)
+        GF_FREE(agl.gl_list);
 }
 
 call_frame_t *
-get_call_frame_for_req (fuse_state_t *state)
+get_call_frame_for_req(fuse_state_t *state)
 {
-        call_pool_t           *pool = NULL;
-        fuse_in_header_t      *finh = NULL;
-        call_frame_t          *frame = NULL;
-        xlator_t              *this = NULL;
-        fuse_private_t        *priv = NULL;
-
-        pool = state->pool;
-        finh = state->finh;
-        this = state->this;
-        priv = this->private;
-
-        frame = create_frame (this, pool);
-        if (!frame)
-                return NULL;
-
-        if (finh) {
-                frame->root->uid      = finh->uid;
-                frame->root->gid      = finh->gid;
-                frame->root->pid      = finh->pid;
-                frame->root->unique   = finh->unique;
-                set_lk_owner_from_uint64 (&frame->root->lk_owner,
-                                          state->lk_owner);
-        }
+    call_pool_t *pool = NULL;
+    fuse_in_header_t *finh = NULL;
+    call_frame_t *frame = NULL;
+    xlator_t *this = NULL;
+    fuse_private_t *priv = NULL;
 
-        get_groups(priv, frame);
+    pool = state->pool;
+    finh = state->finh;
+    this = state->this;
+    priv = this->private;
 
-        if (priv && priv->client_pid_set)
-                frame->root->pid = priv->client_pid;
+    frame = create_frame(this, pool);
+    if (!frame)
+        return NULL;
 
-        frame->root->type = GF_OP_TYPE_FOP;
+    if (finh) {
+        frame->root->uid = finh->uid;
+        frame->root->gid = finh->gid;
+        frame->root->pid = finh->pid;
+        frame->root->unique = finh->unique;
+        set_lk_owner_from_uint64(&frame->root->lk_owner, state->lk_owner);
+    }
 
-        return frame;
-}
+    get_groups(priv, frame);
+
+    if (priv && priv->client_pid_set)
+        frame->root->pid = priv->client_pid;
 
+    frame->root->type = GF_OP_TYPE_FOP;
+
+    return frame;
+}
 
 inode_t *
-fuse_ino_to_inode (uint64_t ino, xlator_t *fuse)
+fuse_ino_to_inode(uint64_t ino, xlator_t *fuse)
 {
-        inode_t  *inode = NULL;
-        xlator_t *active_subvol = NULL;
-
-        if (ino == 1) {
-                active_subvol = fuse_active_subvol (fuse);
-                if (active_subvol)
-                        inode = active_subvol->itable->root;
-        } else {
-                inode = (inode_t *) (unsigned long) ino;
-                inode_ref (inode);
-        }
-
-        return inode;
+    inode_t *inode = NULL;
+    xlator_t *active_subvol = NULL;
+
+    if (ino == 1) {
+        active_subvol = fuse_active_subvol(fuse);
+        if (active_subvol)
+            inode = active_subvol->itable->root;
+    } else {
+        inode = (inode_t *)(unsigned long)ino;
+        inode_ref(inode);
+    }
+
+    return inode;
 }
 
 uint64_t
-inode_to_fuse_nodeid (inode_t *inode)
+inode_to_fuse_nodeid(inode_t *inode)
 {
-        if (!inode)
-		return 0;
-	if (__is_root_gfid (inode->gfid))
-                return 1;
+    if (!inode)
+        return 0;
+    if (__is_root_gfid(inode->gfid))
+        return 1;
 
-        return (unsigned long) inode;
+    return (unsigned long)inode;
 }
 
-
 GF_MUST_CHECK int32_t
-fuse_loc_fill (loc_t *loc, fuse_state_t *state, ino_t ino,
-               ino_t par, const char *name)
+fuse_loc_fill(loc_t *loc, fuse_state_t *state, ino_t ino, ino_t par,
+              const char *name)
 {
-        inode_t  *inode = NULL;
-        inode_t  *parent = NULL;
-        int32_t   ret = -1;
-        char     *path = NULL;
-        uuid_t    null_gfid = {0,};
-
-        /* resistance against multiple invocation of loc_fill not to get
-           reference leaks via inode_search() */
-
-        if (name) {
-                parent = loc->parent;
-                if (!parent) {
-                        parent = fuse_ino_to_inode (par, state->this);
-                        loc->parent = parent;
-                        if (parent)
-                                gf_uuid_copy (loc->pargfid, parent->gfid);
-                }
-
-                inode = loc->inode;
-                if (!inode && parent) {
-                        inode = inode_grep (parent->table, parent, name);
-                        loc->inode = inode;
-                }
-
-                ret = inode_path (parent, name, &path);
-                if (ret <= 0) {
-                        gf_log ("glusterfs-fuse", GF_LOG_DEBUG,
-                                "inode_path failed for %s/%s",
-                                (parent)?uuid_utoa (parent->gfid):"0", name);
-                        goto fail;
-                }
-                loc->path = path;
-        } else {
-                inode = loc->inode;
-                if (!inode) {
-                        inode = fuse_ino_to_inode (ino, state->this);
-                        loc->inode = inode;
-                        if (inode)
-                                gf_uuid_copy (loc->gfid, inode->gfid);
-                }
-
-                parent = loc->parent;
-                if (!parent) {
-                        parent = inode_parent (inode, null_gfid, NULL);
-                        loc->parent = parent;
-                        if (parent)
-                                gf_uuid_copy (loc->pargfid, parent->gfid);
+    inode_t *inode = NULL;
+    inode_t *parent = NULL;
+    int32_t ret = -1;
+    char *path = NULL;
+    uuid_t null_gfid = {
+        0,
+    };
+
+    /* resistance against multiple invocation of loc_fill not to get
+       reference leaks via inode_search() */
+
+    if (name) {
+        parent = loc->parent;
+        if (!parent) {
+            parent = fuse_ino_to_inode(par, state->this);
+            loc->parent = parent;
+            if (parent)
+                gf_uuid_copy(loc->pargfid, parent->gfid);
+        }
 
-                }
+        inode = loc->inode;
+        if (!inode && parent) {
+            inode = inode_grep(parent->table, parent, name);
+            loc->inode = inode;
+        }
 
-                ret = inode_path (inode, NULL, &path);
-                if (ret <= 0) {
-                        gf_log ("glusterfs-fuse", GF_LOG_DEBUG,
-                                "inode_path failed for %s",
-                                (inode) ? uuid_utoa (inode->gfid) : "0");
-                        goto fail;
-                }
-                loc->path = path;
+        ret = inode_path(parent, name, &path);
+        if (ret <= 0) {
+            gf_log("glusterfs-fuse", GF_LOG_DEBUG,
+                   "inode_path failed for %s/%s",
+                   (parent) ? uuid_utoa(parent->gfid) : "0", name);
+            goto fail;
+        }
+        loc->path = path;
+    } else {
+        inode = loc->inode;
+        if (!inode) {
+            inode = fuse_ino_to_inode(ino, state->this);
+            loc->inode = inode;
+            if (inode)
+                gf_uuid_copy(loc->gfid, inode->gfid);
         }
 
-        if (loc->path) {
-                loc->name = strrchr (loc->path, '/');
-                if (loc->name)
-                        loc->name++;
-                else
-                        loc->name = "";
+        parent = loc->parent;
+        if (!parent) {
+            parent = inode_parent(inode, null_gfid, NULL);
+            loc->parent = parent;
+            if (parent)
+                gf_uuid_copy(loc->pargfid, parent->gfid);
         }
 
-        if ((ino != 1) && (parent == NULL)) {
-                gf_log ("fuse-bridge", GF_LOG_DEBUG,
-                        "failed to search parent for %"PRId64"/%s (%"PRId64")",
-                        (ino_t)par, name, (ino_t)ino);
-                ret = -1;
-                goto fail;
+        ret = inode_path(inode, NULL, &path);
+        if (ret <= 0) {
+            gf_log("glusterfs-fuse", GF_LOG_DEBUG, "inode_path failed for %s",
+                   (inode) ? uuid_utoa(inode->gfid) : "0");
+            goto fail;
         }
-        ret = 0;
+        loc->path = path;
+    }
+
+    if (loc->path) {
+        loc->name = strrchr(loc->path, '/');
+        if (loc->name)
+            loc->name++;
+        else
+            loc->name = "";
+    }
+
+    if ((ino != 1) && (parent == NULL)) {
+        gf_log("fuse-bridge", GF_LOG_DEBUG,
+               "failed to search parent for %" PRId64 "/%s (%" PRId64 ")",
+               (ino_t)par, name, (ino_t)ino);
+        ret = -1;
+        goto fail;
+    }
+    ret = 0;
 fail:
-        /* this should not happen as inode_path returns -1 when buf is NULL
-           for sure */
-        if (path && !loc->path)
-                GF_FREE (path);
-        return ret;
+    /* this should not happen as inode_path returns -1 when buf is NULL
+       for sure */
+    if (path && !loc->path)
+        GF_FREE(path);
+    return ret;
 }
 
 /* courtesy of folly */
 void
-gf_fuse_stat2attr (struct iatt *st, struct fuse_attr *fa, gf_boolean_t enable_ino32)
+gf_fuse_stat2attr(struct iatt *st, struct fuse_attr *fa,
+                  gf_boolean_t enable_ino32)
 {
-        if (enable_ino32)
-                fa->ino = GF_FUSE_SQUASH_INO(st->ia_ino);
-        else
-                fa->ino = st->ia_ino;
-
-        fa->size        = st->ia_size;
-        fa->blocks      = st->ia_blocks;
-        fa->atime       = st->ia_atime;
-        fa->mtime       = st->ia_mtime;
-        fa->ctime       = st->ia_ctime;
-        fa->atimensec   = st->ia_atime_nsec;
-        fa->mtimensec   = st->ia_mtime_nsec;
-        fa->ctimensec   = st->ia_ctime_nsec;
-        fa->mode        = st_mode_from_ia (st->ia_prot, st->ia_type);
-        fa->nlink       = st->ia_nlink;
-        fa->uid         = st->ia_uid;
-        fa->gid         = st->ia_gid;
-        fa->rdev        = makedev (ia_major (st->ia_rdev),
-                                   ia_minor (st->ia_rdev));
+    if (enable_ino32)
+        fa->ino = GF_FUSE_SQUASH_INO(st->ia_ino);
+    else
+        fa->ino = st->ia_ino;
+
+    fa->size = st->ia_size;
+    fa->blocks = st->ia_blocks;
+    fa->atime = st->ia_atime;
+    fa->mtime = st->ia_mtime;
+    fa->ctime = st->ia_ctime;
+    fa->atimensec = st->ia_atime_nsec;
+    fa->mtimensec = st->ia_mtime_nsec;
+    fa->ctimensec = st->ia_ctime_nsec;
+    fa->mode = st_mode_from_ia(st->ia_prot, st->ia_type);
+    fa->nlink = st->ia_nlink;
+    fa->uid = st->ia_uid;
+    fa->gid = st->ia_gid;
+    fa->rdev = makedev(ia_major(st->ia_rdev), ia_minor(st->ia_rdev));
 #if FUSE_KERNEL_MINOR_VERSION >= 9
-        fa->blksize     = st->ia_blksize;
+    fa->blksize = st->ia_blksize;
 #endif
 #ifdef GF_DARWIN_HOST_OS
-        fa->crtime      = (uint64_t)-1;
-        fa->crtimensec  = (uint32_t)-1;
-        fa->flags       = 0;
+    fa->crtime = (uint64_t)-1;
+    fa->crtimensec = (uint32_t)-1;
+    fa->flags = 0;
 #endif
 }
 
 void
-gf_fuse_fill_dirent (gf_dirent_t *entry, struct fuse_dirent *fde, gf_boolean_t enable_ino32)
+gf_fuse_fill_dirent(gf_dirent_t *entry, struct fuse_dirent *fde,
+                    gf_boolean_t enable_ino32)
 {
-        if (enable_ino32)
-                fde->ino = GF_FUSE_SQUASH_INO(entry->d_ino);
-        else
-                fde->ino = entry->d_ino;
-
-        fde->off         = entry->d_off;
-        fde->type        = entry->d_type;
-        fde->namelen     = strlen (entry->d_name);
-        strncpy (fde->name, entry->d_name, fde->namelen);
+    if (enable_ino32)
+        fde->ino = GF_FUSE_SQUASH_INO(entry->d_ino);
+    else
+        fde->ino = entry->d_ino;
+
+    fde->off = entry->d_off;
+    fde->type = entry->d_type;
+    fde->namelen = strlen(entry->d_name);
+    strncpy(fde->name, entry->d_name, fde->namelen);
 }
 
 static int
-fuse_do_flip_xattr_ns (char *okey, const char *nns, char **nkey)
+fuse_do_flip_xattr_ns(char *okey, const char *nns, char **nkey)
 {
-        int   ret = 0;
-        char *key = NULL;
-
-        okey = strchr (okey, '.');
-        GF_ASSERT (okey);
-
-        int key_len = strlen (nns) + strlen(okey);
-        key = GF_MALLOC (key_len + 1,
-                         gf_common_mt_char);
-        if (!key) {
-                ret = -1;
-                goto out;
-        }
+    int ret = 0;
+    char *key = NULL;
+
+    okey = strchr(okey, '.');
+    GF_ASSERT(okey);
+
+    int key_len = strlen(nns) + strlen(okey);
+    key = GF_MALLOC(key_len + 1, gf_common_mt_char);
+    if (!key) {
+        ret = -1;
+        goto out;
+    }
 
-        strcpy (key, nns);
-        strcat (key, okey);
+    strcpy(key, nns);
+    strcat(key, okey);
 
-        *nkey = key;
+    *nkey = key;
 
- out:
-        return ret;
+out:
+    return ret;
 }
 
 static int
-fuse_xattr_alloc_default (char *okey, char **nkey)
+fuse_xattr_alloc_default(char *okey, char **nkey)
 {
-        int ret = 0;
+    int ret = 0;
 
-        *nkey = gf_strdup (okey);
-        if (!*nkey)
-                ret = -1;
-        return ret;
+    *nkey = gf_strdup(okey);
+    if (!*nkey)
+        ret = -1;
+    return ret;
 }
 
-#define PRIV_XA_NS   "trusted"
+#define PRIV_XA_NS "trusted"
 #define UNPRIV_XA_NS "system"
 
 int
-fuse_flip_xattr_ns (fuse_private_t *priv, char *okey, char **nkey)
+fuse_flip_xattr_ns(fuse_private_t *priv, char *okey, char **nkey)
 {
-        int             ret       = 0;
-        gf_boolean_t    need_flip = _gf_false;
+    int ret = 0;
+    gf_boolean_t need_flip = _gf_false;
 
-        switch (priv->client_pid) {
+    switch (priv->client_pid) {
         case GF_CLIENT_PID_GSYNCD:
-                /* valid xattr(s): *xtime, volume-mark* */
-                gf_log("glusterfs-fuse", GF_LOG_DEBUG, "PID: %d, checking xattr(s): "
-                       "volume-mark*, *xtime", priv->client_pid);
-                if ( (strcmp (okey, UNPRIV_XA_NS".glusterfs.volume-mark") == 0)
-                     || (fnmatch (UNPRIV_XA_NS".glusterfs.volume-mark.*", okey, FNM_PERIOD) == 0)
-                     || (fnmatch (UNPRIV_XA_NS".glusterfs.*.xtime", okey, FNM_PERIOD) == 0) )
-                        need_flip = _gf_true;
-                break;
+            /* valid xattr(s): *xtime, volume-mark* */
+            gf_log("glusterfs-fuse", GF_LOG_DEBUG,
+                   "PID: %d, checking xattr(s): "
+                   "volume-mark*, *xtime",
+                   priv->client_pid);
+            if ((strcmp(okey, UNPRIV_XA_NS ".glusterfs.volume-mark") == 0) ||
+                (fnmatch(UNPRIV_XA_NS ".glusterfs.volume-mark.*", okey,
+                         FNM_PERIOD) == 0) ||
+                (fnmatch(UNPRIV_XA_NS ".glusterfs.*.xtime", okey, FNM_PERIOD) ==
+                 0))
+                need_flip = _gf_true;
+            break;
 
         case GF_CLIENT_PID_HADOOP:
-                /* valid xattr(s): pathinfo */
-                gf_log("glusterfs-fuse", GF_LOG_DEBUG, "PID: %d, checking xattr(s): "
-                       "pathinfo", priv->client_pid);
-                if (strcmp (okey, UNPRIV_XA_NS".glusterfs.pathinfo") == 0)
-                        need_flip = _gf_true;
-                break;
-        }
-
-        if (need_flip) {
-                gf_log ("glusterfs-fuse", GF_LOG_DEBUG, "flipping %s to "PRIV_XA_NS" equivalent",
-                        okey);
-                ret = fuse_do_flip_xattr_ns (okey, PRIV_XA_NS, nkey);
-        } else {
-                /* if we cannot match, continue with what we got */
-                ret = fuse_xattr_alloc_default (okey, nkey);
-        }
-
-        return ret;
+            /* valid xattr(s): pathinfo */
+            gf_log("glusterfs-fuse", GF_LOG_DEBUG,
+                   "PID: %d, checking xattr(s): "
+                   "pathinfo",
+                   priv->client_pid);
+            if (strcmp(okey, UNPRIV_XA_NS ".glusterfs.pathinfo") == 0)
+                need_flip = _gf_true;
+            break;
+    }
+
+    if (need_flip) {
+        gf_log("glusterfs-fuse", GF_LOG_DEBUG,
+               "flipping %s to " PRIV_XA_NS " equivalent", okey);
+        ret = fuse_do_flip_xattr_ns(okey, PRIV_XA_NS, nkey);
+    } else {
+        /* if we cannot match, continue with what we got */
+        ret = fuse_xattr_alloc_default(okey, nkey);
+    }
+
+    return ret;
 }
 
 int
-fuse_ignore_xattr_set (fuse_private_t *priv, char *key)
+fuse_ignore_xattr_set(fuse_private_t *priv, char *key)
 {
-        int ret = 0;
-
-        /* don't mess with user namespace */
-        if (fnmatch ("user.*", key, FNM_PERIOD) == 0)
-                goto out;
-
-        if (priv->client_pid != GF_CLIENT_PID_GSYNCD)
-                goto out;
-
-        /* trusted NS check */
-        if (!((fnmatch ("*.glusterfs.*.xtime", key, FNM_PERIOD) == 0)
-              || (fnmatch ("*.glusterfs.volume-mark",
-                           key, FNM_PERIOD) == 0)
-              || (fnmatch ("*.glusterfs.volume-mark.*",
-                           key, FNM_PERIOD) == 0)
-              || (fnmatch ("system.posix_acl_access",
-                           key, FNM_PERIOD) == 0)
-              || (fnmatch ("glusterfs.gfid.newfile",
-                           key, FNM_PERIOD) == 0)
-              || (fnmatch ("*.glusterfs.shard.block-size",
-                           key, FNM_PERIOD) == 0)
-              || (fnmatch ("*.glusterfs.shard.file-size",
-                           key, FNM_PERIOD) == 0)))
-                ret = -1;
-
- out:
-        gf_log ("glusterfs-fuse", GF_LOG_DEBUG, "%s setxattr: key [%s], "
-                " client pid [%d]", (ret ? "disallowing" : "allowing"), key,
-                priv->client_pid);
-
-        return ret;
+    int ret = 0;
+
+    /* don't mess with user namespace */
+    if (fnmatch("user.*", key, FNM_PERIOD) == 0)
+        goto out;
+
+    if (priv->client_pid != GF_CLIENT_PID_GSYNCD)
+        goto out;
+
+    /* trusted NS check */
+    if (!((fnmatch("*.glusterfs.*.xtime", key, FNM_PERIOD) == 0) ||
+          (fnmatch("*.glusterfs.volume-mark", key, FNM_PERIOD) == 0) ||
+          (fnmatch("*.glusterfs.volume-mark.*", key, FNM_PERIOD) == 0) ||
+          (fnmatch("system.posix_acl_access", key, FNM_PERIOD) == 0) ||
+          (fnmatch("glusterfs.gfid.newfile", key, FNM_PERIOD) == 0) ||
+          (fnmatch("*.glusterfs.shard.block-size", key, FNM_PERIOD) == 0) ||
+          (fnmatch("*.glusterfs.shard.file-size", key, FNM_PERIOD) == 0)))
+        ret = -1;
+
+out:
+    gf_log("glusterfs-fuse", GF_LOG_DEBUG,
+           "%s setxattr: key [%s], "
+           " client pid [%d]",
+           (ret ? "disallowing" : "allowing"), key, priv->client_pid);
+
+    return ret;
 }
 
 int
-fuse_check_selinux_cap_xattr (fuse_private_t *priv, char *name)
+fuse_check_selinux_cap_xattr(fuse_private_t *priv, char *name)
 {
-        int ret = -1;
+    int ret = -1;
 
-        if (strcmp (name, "security.selinux") &&
-                        strcmp (name, "security.capability")) {
-                /* if xattr name is not of interest, no validations needed */
-                ret = 0;
-                goto out;
-        }
+    if (strcmp(name, "security.selinux") &&
+        strcmp(name, "security.capability")) {
+        /* if xattr name is not of interest, no validations needed */
+        ret = 0;
+        goto out;
+    }
 
-        if ((strcmp (name, "security.selinux") == 0) &&
-            (priv->selinux)) {
-                ret = 0;
-        }
+    if ((strcmp(name, "security.selinux") == 0) && (priv->selinux)) {
+        ret = 0;
+    }
 
-        if ((strcmp (name, "security.capability") == 0) &&
-            ((priv->capability) || (priv->selinux))) {
-                ret = 0;
-        }
+    if ((strcmp(name, "security.capability") == 0) &&
+        ((priv->capability) || (priv->selinux))) {
+        ret = 0;
+    }
 
 out:
-        return ret;
+    return ret;
 }
diff --git a/xlators/mount/fuse/src/fuse-resolve.c b/xlators/mount/fuse/src/fuse-resolve.c
index ed25bf034b8..6206fd47325 100644
--- a/xlators/mount/fuse/src/fuse-resolve.c
+++ b/xlators/mount/fuse/src/fuse-resolve.c
@@ -10,213 +10,205 @@
 #include "fuse-bridge.h"
 
 static int
-fuse_resolve_all (fuse_state_t *state);
+fuse_resolve_all(fuse_state_t *state);
 
-int fuse_resolve_continue (fuse_state_t *state);
-int fuse_resolve_entry_simple (fuse_state_t *state);
-int fuse_resolve_inode_simple (fuse_state_t *state);
-int fuse_migrate_fd (xlator_t *this, fd_t *fd, xlator_t *old_subvol,
-                     xlator_t *new_subvol);
+int
+fuse_resolve_continue(fuse_state_t *state);
+int
+fuse_resolve_entry_simple(fuse_state_t *state);
+int
+fuse_resolve_inode_simple(fuse_state_t *state);
+int
+fuse_migrate_fd(xlator_t *this, fd_t *fd, xlator_t *old_subvol,
+                xlator_t *new_subvol);
 
 fuse_fd_ctx_t *
-fuse_fd_ctx_get (xlator_t *this, fd_t *fd);
+fuse_fd_ctx_get(xlator_t *this, fd_t *fd);
 
 static int
-fuse_resolve_loc_touchup (fuse_state_t *state)
+fuse_resolve_loc_touchup(fuse_state_t *state)
 {
-        fuse_resolve_t *resolve = NULL;
-        loc_t          *loc     = NULL;
+    fuse_resolve_t *resolve = NULL;
+    loc_t *loc = NULL;
 
-        resolve = state->resolve_now;
-        loc     = state->loc_now;
+    resolve = state->resolve_now;
+    loc = state->loc_now;
 
-        loc_touchup (loc, resolve->bname);
-        return 0;
+    loc_touchup(loc, resolve->bname);
+    return 0;
 }
 
-
 int
-fuse_resolve_entry_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-			int op_ret, int op_errno, inode_t *inode,
-			struct iatt *buf, dict_t *xattr,
-			struct iatt *postparent)
+fuse_resolve_entry_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                       int op_ret, int op_errno, inode_t *inode,
+                       struct iatt *buf, dict_t *xattr, struct iatt *postparent)
 {
-        fuse_state_t   *state      = NULL;
-        fuse_resolve_t *resolve    = NULL;
-        inode_t        *link_inode = NULL;
-        loc_t          *resolve_loc   = NULL;
-        uint64_t        ctx_value  = LOOKUP_NOT_NEEDED;
-
-        state = frame->root->state;
-        resolve = state->resolve_now;
-        resolve_loc = &resolve->resolve_loc;
-
-        STACK_DESTROY (frame->root);
-
-        if (op_ret == -1) {
-                gf_log (this->name, (op_errno == ENOENT)
-                        ? GF_LOG_DEBUG : GF_LOG_WARNING,
-                        "%s/%s: failed to resolve (%s)",
-                        uuid_utoa (resolve_loc->pargfid), resolve_loc->name,
-                        strerror (op_errno));
-                resolve->op_ret = -1;
-                resolve->op_errno = op_errno;
-                goto out;
-        }
-
-        link_inode = inode_link (inode, resolve_loc->parent,
-                                 resolve_loc->name, buf);
-        if (link_inode == inode)
-                inode_ctx_set (link_inode, this, &ctx_value);
-	state->loc_now->inode = link_inode;
+    fuse_state_t *state = NULL;
+    fuse_resolve_t *resolve = NULL;
+    inode_t *link_inode = NULL;
+    loc_t *resolve_loc = NULL;
+    uint64_t ctx_value = LOOKUP_NOT_NEEDED;
+
+    state = frame->root->state;
+    resolve = state->resolve_now;
+    resolve_loc = &resolve->resolve_loc;
+
+    STACK_DESTROY(frame->root);
+
+    if (op_ret == -1) {
+        gf_log(this->name, (op_errno == ENOENT) ? GF_LOG_DEBUG : GF_LOG_WARNING,
+               "%s/%s: failed to resolve (%s)", uuid_utoa(resolve_loc->pargfid),
+               resolve_loc->name, strerror(op_errno));
+        resolve->op_ret = -1;
+        resolve->op_errno = op_errno;
+        goto out;
+    }
+
+    link_inode = inode_link(inode, resolve_loc->parent, resolve_loc->name, buf);
+    if (link_inode == inode)
+        inode_ctx_set(link_inode, this, &ctx_value);
+    state->loc_now->inode = link_inode;
 
 out:
-        loc_wipe (resolve_loc);
+    loc_wipe(resolve_loc);
 
-        fuse_resolve_continue (state);
-        return 0;
+    fuse_resolve_continue(state);
+    return 0;
 }
 
-
 int
-fuse_resolve_entry (fuse_state_t *state)
+fuse_resolve_entry(fuse_state_t *state)
 {
-	fuse_resolve_t   *resolve = NULL;
-	loc_t            *resolve_loc = NULL;
+    fuse_resolve_t *resolve = NULL;
+    loc_t *resolve_loc = NULL;
 
-	resolve = state->resolve_now;
-	resolve_loc = &resolve->resolve_loc;
+    resolve = state->resolve_now;
+    resolve_loc = &resolve->resolve_loc;
 
-	resolve_loc->parent = inode_ref (state->loc_now->parent);
-	gf_uuid_copy (resolve_loc->pargfid, state->loc_now->pargfid);
-        resolve_loc->name = resolve->bname;
+    resolve_loc->parent = inode_ref(state->loc_now->parent);
+    gf_uuid_copy(resolve_loc->pargfid, state->loc_now->pargfid);
+    resolve_loc->name = resolve->bname;
 
-        resolve_loc->inode = inode_grep (state->itable, resolve->parhint,
-                                         resolve->bname);
-        if (!resolve_loc->inode) {
-                resolve_loc->inode = inode_new (state->itable);
-        }
-        inode_path (resolve_loc->parent, resolve_loc->name,
-                    (char **) &resolve_loc->path);
+    resolve_loc->inode = inode_grep(state->itable, resolve->parhint,
+                                    resolve->bname);
+    if (!resolve_loc->inode) {
+        resolve_loc->inode = inode_new(state->itable);
+    }
+    inode_path(resolve_loc->parent, resolve_loc->name,
+               (char **)&resolve_loc->path);
 
-        FUSE_FOP (state, fuse_resolve_entry_cbk, GF_FOP_LOOKUP,
-                  lookup, resolve_loc, NULL);
+    FUSE_FOP(state, fuse_resolve_entry_cbk, GF_FOP_LOOKUP, lookup, resolve_loc,
+             NULL);
 
-	return 0;
+    return 0;
 }
 
-
 int
-fuse_resolve_gfid_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                       int op_ret, int op_errno, inode_t *inode,
-                       struct iatt *buf, dict_t *xattr, struct iatt *postparent)
+fuse_resolve_gfid_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+                      int op_ret, int op_errno, inode_t *inode,
+                      struct iatt *buf, dict_t *xattr, struct iatt *postparent)
 {
-        fuse_state_t   *state      = NULL;
-        fuse_resolve_t *resolve    = NULL;
-        inode_t        *link_inode = NULL;
-        loc_t          *loc_now    = NULL;
-        inode_t        *tmp_inode  = NULL;
-        uint64_t        ctx_value  = LOOKUP_NOT_NEEDED;
-
-        state = frame->root->state;
-        resolve = state->resolve_now;
-	loc_now = state->loc_now;
-
-        STACK_DESTROY (frame->root);
-
-        if (op_ret == -1) {
-                gf_log (this->name, (op_errno == ENOENT)
-                        ? GF_LOG_DEBUG : GF_LOG_WARNING,
-                        "%s: failed to resolve (%s)",
-                        uuid_utoa (resolve->resolve_loc.gfid),
-			strerror (op_errno));
-                loc_wipe (&resolve->resolve_loc);
-
-                /* resolve->op_ret can have 3 values: 0, -1, -2.
-                 * 0 : resolution was successful.
-                 * -1: parent inode could not be resolved.
-                 * -2: entry (inode corresponding to path) could not be resolved
-                 */
-
-                if (gf_uuid_is_null (resolve->gfid)) {
-                        resolve->op_ret = -1;
-                } else {
-                        resolve->op_ret = -2;
-                }
-
-                resolve->op_errno = op_errno;
-                goto out;
+    fuse_state_t *state = NULL;
+    fuse_resolve_t *resolve = NULL;
+    inode_t *link_inode = NULL;
+    loc_t *loc_now = NULL;
+    inode_t *tmp_inode = NULL;
+    uint64_t ctx_value = LOOKUP_NOT_NEEDED;
+
+    state = frame->root->state;
+    resolve = state->resolve_now;
+    loc_now = state->loc_now;
+
+    STACK_DESTROY(frame->root);
+
+    if (op_ret == -1) {
+        gf_log(this->name, (op_errno == ENOENT) ? GF_LOG_DEBUG : GF_LOG_WARNING,
+               "%s: failed to resolve (%s)",
+               uuid_utoa(resolve->resolve_loc.gfid), strerror(op_errno));
+        loc_wipe(&resolve->resolve_loc);
+
+        /* resolve->op_ret can have 3 values: 0, -1, -2.
+         * 0 : resolution was successful.
+         * -1: parent inode could not be resolved.
+         * -2: entry (inode corresponding to path) could not be resolved
+         */
+
+        if (gf_uuid_is_null(resolve->gfid)) {
+            resolve->op_ret = -1;
+        } else {
+            resolve->op_ret = -2;
         }
 
-        link_inode = inode_link (inode, NULL, NULL, buf);
-        if (link_inode == inode)
-                inode_ctx_set (link_inode, this, &ctx_value);
+        resolve->op_errno = op_errno;
+        goto out;
+    }
 
-        loc_wipe (&resolve->resolve_loc);
+    link_inode = inode_link(inode, NULL, NULL, buf);
+    if (link_inode == inode)
+        inode_ctx_set(link_inode, this, &ctx_value);
 
-        if (!link_inode)
-                goto out;
+    loc_wipe(&resolve->resolve_loc);
 
-	if (!gf_uuid_is_null (resolve->gfid)) {
-		loc_now->inode = link_inode;
-		goto out;
-	}
+    if (!link_inode)
+        goto out;
 
-	loc_now->parent = link_inode;
-        gf_uuid_copy (loc_now->pargfid, link_inode->gfid);
+    if (!gf_uuid_is_null(resolve->gfid)) {
+        loc_now->inode = link_inode;
+        goto out;
+    }
 
-        tmp_inode = inode_grep (state->itable, link_inode, resolve->bname);
-        if (tmp_inode && (!inode_needs_lookup (tmp_inode, THIS))) {
-                loc_now->inode = tmp_inode;
-                goto out;
-        }
+    loc_now->parent = link_inode;
+    gf_uuid_copy(loc_now->pargfid, link_inode->gfid);
 
-        inode_unref (tmp_inode);
-	fuse_resolve_entry (state);
+    tmp_inode = inode_grep(state->itable, link_inode, resolve->bname);
+    if (tmp_inode && (!inode_needs_lookup(tmp_inode, THIS))) {
+        loc_now->inode = tmp_inode;
+        goto out;
+    }
 
-        return 0;
+    inode_unref(tmp_inode);
+    fuse_resolve_entry(state);
+
+    return 0;
 out:
-        fuse_resolve_continue (state);
-        return 0;
+    fuse_resolve_continue(state);
+    return 0;
 }
 
-
 int
-fuse_resolve_gfid (fuse_state_t *state)
+fuse_resolve_gfid(fuse_state_t *state)
 {
-        fuse_resolve_t *resolve  = NULL;
-        loc_t          *resolve_loc = NULL;
-        int             ret      = 0;
-
-        resolve = state->resolve_now;
-        resolve_loc = &resolve->resolve_loc;
-
-        if (!gf_uuid_is_null (resolve->pargfid)) {
-                gf_uuid_copy (resolve_loc->gfid, resolve->pargfid);
-        } else if (!gf_uuid_is_null (resolve->gfid)) {
-                gf_uuid_copy (resolve_loc->gfid, resolve->gfid);
-        }
-
-	/* inode may already exist in case we are looking up an inode which was
-	   linked through readdirplus */
-	resolve_loc->inode = inode_find (state->itable, resolve_loc->gfid);
-	if (!resolve_loc->inode)
-		resolve_loc->inode = inode_new (state->itable);
-	ret = loc_path (resolve_loc, NULL);
-
-        if (ret <= 0) {
-                gf_log (THIS->name, GF_LOG_WARNING,
-                        "failed to get the path for inode %s",
-                        uuid_utoa (resolve->gfid));
-        }
-
-        FUSE_FOP (state, fuse_resolve_gfid_cbk, GF_FOP_LOOKUP,
-                  lookup, resolve_loc, NULL);
-
-        return 0;
+    fuse_resolve_t *resolve = NULL;
+    loc_t *resolve_loc = NULL;
+    int ret = 0;
+
+    resolve = state->resolve_now;
+    resolve_loc = &resolve->resolve_loc;
+
+    if (!gf_uuid_is_null(resolve->pargfid)) {
+        gf_uuid_copy(resolve_loc->gfid, resolve->pargfid);
+    } else if (!gf_uuid_is_null(resolve->gfid)) {
+        gf_uuid_copy(resolve_loc->gfid, resolve->gfid);
+    }
+
+    /* inode may already exist in case we are looking up an inode which was
+       linked through readdirplus */
+    resolve_loc->inode = inode_find(state->itable, resolve_loc->gfid);
+    if (!resolve_loc->inode)
+        resolve_loc->inode = inode_new(state->itable);
+    ret = loc_path(resolve_loc, NULL);
+
+    if (ret <= 0) {
+        gf_log(THIS->name, GF_LOG_WARNING,
+               "failed to get the path for inode %s", uuid_utoa(resolve->gfid));
+    }
+
+    FUSE_FOP(state, fuse_resolve_gfid_cbk, GF_FOP_LOOKUP, lookup, resolve_loc,
+             NULL);
+
+    return 0;
 }
 
-
 /*
  * Return value:
  * 0 - resolved parent and entry (as necessary)
@@ -225,443 +217,417 @@ fuse_resolve_gfid (fuse_state_t *state)
  */
 
 int
-fuse_resolve_parent_simple (fuse_state_t *state)
+fuse_resolve_parent_simple(fuse_state_t *state)
 {
-        fuse_resolve_t *resolve   = NULL;
-	loc_t          *loc       = NULL;
-        inode_t        *parent    = NULL;
-        inode_t        *inode     = NULL;
-        xlator_t       *this      = NULL;
-
-        resolve = state->resolve_now;
-	loc = state->loc_now;
-        this = state->this;
-
-	loc->name = resolve->bname;
-
-	parent = resolve->parhint;
-	if (parent->table == state->itable) {
-		if (inode_needs_lookup (parent, THIS))
-			return 1;
-
-		/* no graph switches since */
-		loc->parent = inode_ref (parent);
-		gf_uuid_copy (loc->pargfid, parent->gfid);
-		loc->inode = inode_grep (state->itable, parent, loc->name);
-
-                /* nodeid for root is 1 and we blindly take the latest graph's
-                 * table->root as the parhint and because of this there is
-                 * ambiguity whether the entry should have existed or not, and
-                 * we took the conservative approach of assuming entry should
-                 * have been there even though it need not have (bug #804592).
-                 */
-
-                if (loc->inode && inode_needs_lookup (loc->inode, THIS)) {
-                        inode_unref (loc->inode);
-                        loc->inode = NULL;
-                        return -1;
-                }
-
-                if ((loc->inode == NULL)
-                    && __is_root_gfid (parent->gfid)) {
-                        /* non decisive result - entry missing */
-                        return -1;
-                }
-
-		/* decisive result - resolution success */
-		return 0;
-	}
-
-        parent = inode_find (state->itable, resolve->pargfid);
-	if (!parent) {
-		/* non decisive result - parent missing */
-		return 1;
-	}
-	if (inode_needs_lookup (parent, THIS)) {
-		inode_unref (parent);
-		return 1;
-	}
-
-	loc->parent = parent;
-        gf_uuid_copy (loc->pargfid, resolve->pargfid);
-
-	inode = inode_grep (state->itable, parent, loc->name);
-	if (inode && !inode_needs_lookup (inode, this)) {
-		loc->inode = inode;
-		/* decisive result - resolution success */
-		return 0;
-	}
-
-	/* non decisive result - entry missing */
-        return -1;
-}
-
-
-int
-fuse_resolve_parent (fuse_state_t *state)
-{
-        int    ret = 0;
-
-        ret = fuse_resolve_parent_simple (state);
-        if (ret > 0) {
-                fuse_resolve_gfid (state);
-                return 0;
+    fuse_resolve_t *resolve = NULL;
+    loc_t *loc = NULL;
+    inode_t *parent = NULL;
+    inode_t *inode = NULL;
+    xlator_t *this = NULL;
+
+    resolve = state->resolve_now;
+    loc = state->loc_now;
+    this = state->this;
+
+    loc->name = resolve->bname;
+
+    parent = resolve->parhint;
+    if (parent->table == state->itable) {
+        if (inode_needs_lookup(parent, THIS))
+            return 1;
+
+        /* no graph switches since */
+        loc->parent = inode_ref(parent);
+        gf_uuid_copy(loc->pargfid, parent->gfid);
+        loc->inode = inode_grep(state->itable, parent, loc->name);
+
+        /* nodeid for root is 1 and we blindly take the latest graph's
+         * table->root as the parhint and because of this there is
+         * ambiguity whether the entry should have existed or not, and
+         * we took the conservative approach of assuming entry should
+         * have been there even though it need not have (bug #804592).
+         */
+
+        if (loc->inode && inode_needs_lookup(loc->inode, THIS)) {
+            inode_unref(loc->inode);
+            loc->inode = NULL;
+            return -1;
         }
 
-	if (ret < 0) {
-		fuse_resolve_entry (state);
-		return 0;
-	}
-
-        fuse_resolve_continue (state);
+        if ((loc->inode == NULL) && __is_root_gfid(parent->gfid)) {
+            /* non decisive result - entry missing */
+            return -1;
+        }
 
+        /* decisive result - resolution success */
         return 0;
-}
+    }
 
+    parent = inode_find(state->itable, resolve->pargfid);
+    if (!parent) {
+        /* non decisive result - parent missing */
+        return 1;
+    }
+    if (inode_needs_lookup(parent, THIS)) {
+        inode_unref(parent);
+        return 1;
+    }
 
-int
-fuse_resolve_inode_simple (fuse_state_t *state)
-{
-        fuse_resolve_t *resolve   = NULL;
-	loc_t          *loc = NULL;
-        inode_t        *inode     = NULL;
-
-        resolve = state->resolve_now;
-	loc = state->loc_now;
-
-	inode = resolve->hint;
-	if (inode->table == state->itable)
-		inode_ref (inode);
-	else
-		inode = inode_find (state->itable, resolve->gfid);
-
-        if (inode) {
-		if (!inode_needs_lookup (inode, THIS))
-			goto found;
-		/* inode was linked through readdirplus */
-		inode_unref (inode);
-	}
+    loc->parent = parent;
+    gf_uuid_copy(loc->pargfid, resolve->pargfid);
 
-        return 1;
-found:
-	loc->inode = inode;
-	return 0;
-}
+    inode = inode_grep(state->itable, parent, loc->name);
+    if (inode && !inode_needs_lookup(inode, this)) {
+        loc->inode = inode;
+        /* decisive result - resolution success */
+        return 0;
+    }
 
+    /* non decisive result - entry missing */
+    return -1;
+}
 
 int
-fuse_resolve_inode (fuse_state_t *state)
+fuse_resolve_parent(fuse_state_t *state)
 {
-        int                 ret = 0;
+    int ret = 0;
 
-        ret = fuse_resolve_inode_simple (state);
+    ret = fuse_resolve_parent_simple(state);
+    if (ret > 0) {
+        fuse_resolve_gfid(state);
+        return 0;
+    }
 
-        if (ret > 0) {
-                fuse_resolve_gfid (state);
-                return 0;
-        }
+    if (ret < 0) {
+        fuse_resolve_entry(state);
+        return 0;
+    }
 
-        fuse_resolve_continue (state);
+    fuse_resolve_continue(state);
 
-        return 0;
+    return 0;
 }
 
-
 int
-fuse_migrate_fd_task (void *data)
+fuse_resolve_inode_simple(fuse_state_t *state)
 {
-        int            ret        = -1;
-        fuse_state_t  *state      = NULL;
-        fd_t          *basefd     = NULL, *oldfd = NULL;
-        fuse_fd_ctx_t *basefd_ctx = NULL;
-        xlator_t      *old_subvol = NULL;
-
-        state = data;
-        if (state == NULL) {
-                goto out;
-        }
+    fuse_resolve_t *resolve = NULL;
+    loc_t *loc = NULL;
+    inode_t *inode = NULL;
+
+    resolve = state->resolve_now;
+    loc = state->loc_now;
+
+    inode = resolve->hint;
+    if (inode->table == state->itable)
+        inode_ref(inode);
+    else
+        inode = inode_find(state->itable, resolve->gfid);
+
+    if (inode) {
+        if (!inode_needs_lookup(inode, THIS))
+            goto found;
+        /* inode was linked through readdirplus */
+        inode_unref(inode);
+    }
+
+    return 1;
+found:
+    loc->inode = inode;
+    return 0;
+}
 
-        basefd = state->fd;
+int
+fuse_resolve_inode(fuse_state_t *state)
+{
+    int ret = 0;
 
-        basefd_ctx = fuse_fd_ctx_get (state->this, basefd);
-        if (!basefd_ctx)
-                goto out;
+    ret = fuse_resolve_inode_simple(state);
 
-        LOCK (&basefd->lock);
-        {
-                oldfd = basefd_ctx->activefd ? basefd_ctx->activefd : basefd;
-                fd_ref (oldfd);
-        }
-        UNLOCK (&basefd->lock);
+    if (ret > 0) {
+        fuse_resolve_gfid(state);
+        return 0;
+    }
 
-        old_subvol = oldfd->inode->table->xl;
+    fuse_resolve_continue(state);
 
-        ret = fuse_migrate_fd (state->this, basefd, old_subvol,
-                               state->active_subvol);
+    return 0;
+}
 
-        LOCK (&basefd->lock);
-        {
-                if (ret < 0) {
-                        basefd_ctx->migration_failed = 1;
-                } else {
-                        basefd_ctx->migration_failed = 0;
-                }
+int
+fuse_migrate_fd_task(void *data)
+{
+    int ret = -1;
+    fuse_state_t *state = NULL;
+    fd_t *basefd = NULL, *oldfd = NULL;
+    fuse_fd_ctx_t *basefd_ctx = NULL;
+    xlator_t *old_subvol = NULL;
+
+    state = data;
+    if (state == NULL) {
+        goto out;
+    }
+
+    basefd = state->fd;
+
+    basefd_ctx = fuse_fd_ctx_get(state->this, basefd);
+    if (!basefd_ctx)
+        goto out;
+
+    LOCK(&basefd->lock);
+    {
+        oldfd = basefd_ctx->activefd ? basefd_ctx->activefd : basefd;
+        fd_ref(oldfd);
+    }
+    UNLOCK(&basefd->lock);
+
+    old_subvol = oldfd->inode->table->xl;
+
+    ret = fuse_migrate_fd(state->this, basefd, old_subvol,
+                          state->active_subvol);
+
+    LOCK(&basefd->lock);
+    {
+        if (ret < 0) {
+            basefd_ctx->migration_failed = 1;
+        } else {
+            basefd_ctx->migration_failed = 0;
         }
-        UNLOCK (&basefd->lock);
+    }
+    UNLOCK(&basefd->lock);
 
-        ret = 0;
+    ret = 0;
 
 out:
-        if (oldfd)
-                fd_unref (oldfd);
+    if (oldfd)
+        fd_unref(oldfd);
 
-        return ret;
+    return ret;
 }
 
-
 static int
-fuse_migrate_fd_error (xlator_t *this, fd_t *fd)
+fuse_migrate_fd_error(xlator_t *this, fd_t *fd)
 {
-        fuse_fd_ctx_t *fdctx = NULL;
-        char           error = 0;
-
-        fdctx = fuse_fd_ctx_get (this, fd);
-        if (fdctx != NULL) {
-                if (fdctx->migration_failed) {
-                        error = 1;
-                }
+    fuse_fd_ctx_t *fdctx = NULL;
+    char error = 0;
+
+    fdctx = fuse_fd_ctx_get(this, fd);
+    if (fdctx != NULL) {
+        if (fdctx->migration_failed) {
+            error = 1;
         }
+    }
 
-        return error;
+    return error;
 }
 
-#define FUSE_FD_GET_ACTIVE_FD(activefd, basefd)                 \
-        do {                                                    \
-                LOCK (&basefd->lock);                           \
-                {                                               \
-                        activefd = basefd_ctx->activefd ?       \
-                                basefd_ctx->activefd : basefd;  \
-                        if (activefd != basefd) {               \
-                                fd_ref (activefd);              \
-                        }                                       \
-                }                                               \
-                UNLOCK (&basefd->lock);                         \
-                                                                \
-                if (activefd == basefd) {                       \
-                        fd_ref (activefd);                      \
-                }                                               \
-        } while (0);
-
+#define FUSE_FD_GET_ACTIVE_FD(activefd, basefd)                                \
+    do {                                                                       \
+        LOCK(&basefd->lock);                                                   \
+        {                                                                      \
+            activefd = basefd_ctx->activefd ? basefd_ctx->activefd : basefd;   \
+            if (activefd != basefd) {                                          \
+                fd_ref(activefd);                                              \
+            }                                                                  \
+        }                                                                      \
+        UNLOCK(&basefd->lock);                                                 \
+                                                                               \
+        if (activefd == basefd) {                                              \
+            fd_ref(activefd);                                                  \
+        }                                                                      \
+    } while (0);
 
 static int
-fuse_resolve_fd (fuse_state_t *state)
+fuse_resolve_fd(fuse_state_t *state)
 {
-        fuse_resolve_t *resolve            = NULL;
-	fd_t           *basefd             = NULL, *activefd = NULL;
-	xlator_t       *active_subvol      = NULL, *this = NULL;
-        int             ret                = 0;
-        char            fd_migration_error = 0;
-        fuse_fd_ctx_t  *basefd_ctx         = NULL;
-
-        resolve = state->resolve_now;
-
-        this = state->this;
-
-        basefd = resolve->fd;
-        basefd_ctx = fuse_fd_ctx_get (this, basefd);
-        if (basefd_ctx == NULL) {
-                gf_log (state->this->name, GF_LOG_WARNING,
-                        "fdctx is NULL for basefd (ptr:%p inode-gfid:%s), "
-                        "resolver erroring out with errno EINVAL",
-                        basefd, uuid_utoa (basefd->inode->gfid));
-                resolve->op_ret = -1;
-                resolve->op_errno = EINVAL;
-                goto resolve_continue;
-        }
-
-        FUSE_FD_GET_ACTIVE_FD (activefd, basefd);
-
+    fuse_resolve_t *resolve = NULL;
+    fd_t *basefd = NULL, *activefd = NULL;
+    xlator_t *active_subvol = NULL, *this = NULL;
+    int ret = 0;
+    char fd_migration_error = 0;
+    fuse_fd_ctx_t *basefd_ctx = NULL;
+
+    resolve = state->resolve_now;
+
+    this = state->this;
+
+    basefd = resolve->fd;
+    basefd_ctx = fuse_fd_ctx_get(this, basefd);
+    if (basefd_ctx == NULL) {
+        gf_log(state->this->name, GF_LOG_WARNING,
+               "fdctx is NULL for basefd (ptr:%p inode-gfid:%s), "
+               "resolver erroring out with errno EINVAL",
+               basefd, uuid_utoa(basefd->inode->gfid));
+        resolve->op_ret = -1;
+        resolve->op_errno = EINVAL;
+        goto resolve_continue;
+    }
+
+    FUSE_FD_GET_ACTIVE_FD(activefd, basefd);
+
+    active_subvol = activefd->inode->table->xl;
+
+    fd_migration_error = fuse_migrate_fd_error(state->this, basefd);
+    if (fd_migration_error) {
+        resolve->op_ret = -1;
+        resolve->op_errno = EBADF;
+    } else if (state->active_subvol != active_subvol) {
+        ret = synctask_new(state->this->ctx->env, fuse_migrate_fd_task, NULL,
+                           NULL, state);
+
+        fd_migration_error = fuse_migrate_fd_error(state->this, basefd);
+        fd_unref(activefd);
+
+        FUSE_FD_GET_ACTIVE_FD(activefd, basefd);
         active_subvol = activefd->inode->table->xl;
 
-        fd_migration_error = fuse_migrate_fd_error (state->this, basefd);
-        if (fd_migration_error) {
-                resolve->op_ret = -1;
-                resolve->op_errno = EBADF;
-        } else if (state->active_subvol != active_subvol) {
-                ret = synctask_new (state->this->ctx->env, fuse_migrate_fd_task,
-                                    NULL, NULL, state);
-
-                fd_migration_error = fuse_migrate_fd_error (state->this,
-                                                            basefd);
-                fd_unref (activefd);
-
-                FUSE_FD_GET_ACTIVE_FD (activefd, basefd);
-                active_subvol = activefd->inode->table->xl;
-
-                if ((ret == -1) || fd_migration_error
-                    || (state->active_subvol != active_subvol)) {
-                        if (ret == -1) {
-                                gf_log (state->this->name, GF_LOG_WARNING,
-                                        "starting sync-task to migrate "
-                                        "basefd (ptr:%p inode-gfid:%s) failed "
-                                        "(old-subvolume:%s-%d "
-                                        "new-subvolume:%s-%d)",
-                                        basefd,
-                                        uuid_utoa (basefd->inode->gfid),
-                                        active_subvol->name,
-                                        active_subvol->graph->id,
-                                        state->active_subvol->name,
-                                        state->active_subvol->graph->id);
-                        } else {
-                                gf_log (state->this->name, GF_LOG_WARNING,
-                                        "fd migration of basefd "
-                                        "(ptr:%p inode-gfid:%s) failed "
-                                        "(old-subvolume:%s-%d "
-                                        "new-subvolume:%s-%d)",
-                                        basefd,
-                                        uuid_utoa (basefd->inode->gfid),
-                                        active_subvol->name,
-                                        active_subvol->graph->id,
-                                        state->active_subvol->name,
-                                        state->active_subvol->graph->id);
-                        }
-
-                        resolve->op_ret = -1;
-                        resolve->op_errno = EBADF;
-                } else {
-                        gf_log (state->this->name, GF_LOG_DEBUG,
-                                "basefd (ptr:%p inode-gfid:%s) migrated "
-                                "successfully in resolver "
-                                "(old-subvolume:%s-%d new-subvolume:%s-%d)",
-                                basefd, uuid_utoa (basefd->inode->gfid),
-                                active_subvol->name, active_subvol->graph->id,
-                                state->active_subvol->name,
-                                state->active_subvol->graph->id);
-                }
+        if ((ret == -1) || fd_migration_error ||
+            (state->active_subvol != active_subvol)) {
+            if (ret == -1) {
+                gf_log(state->this->name, GF_LOG_WARNING,
+                       "starting sync-task to migrate "
+                       "basefd (ptr:%p inode-gfid:%s) failed "
+                       "(old-subvolume:%s-%d "
+                       "new-subvolume:%s-%d)",
+                       basefd, uuid_utoa(basefd->inode->gfid),
+                       active_subvol->name, active_subvol->graph->id,
+                       state->active_subvol->name,
+                       state->active_subvol->graph->id);
+            } else {
+                gf_log(state->this->name, GF_LOG_WARNING,
+                       "fd migration of basefd "
+                       "(ptr:%p inode-gfid:%s) failed "
+                       "(old-subvolume:%s-%d "
+                       "new-subvolume:%s-%d)",
+                       basefd, uuid_utoa(basefd->inode->gfid),
+                       active_subvol->name, active_subvol->graph->id,
+                       state->active_subvol->name,
+                       state->active_subvol->graph->id);
+            }
+
+            resolve->op_ret = -1;
+            resolve->op_errno = EBADF;
+        } else {
+            gf_log(state->this->name, GF_LOG_DEBUG,
+                   "basefd (ptr:%p inode-gfid:%s) migrated "
+                   "successfully in resolver "
+                   "(old-subvolume:%s-%d new-subvolume:%s-%d)",
+                   basefd, uuid_utoa(basefd->inode->gfid), active_subvol->name,
+                   active_subvol->graph->id, state->active_subvol->name,
+                   state->active_subvol->graph->id);
         }
+    }
 
-        if ((resolve->op_ret == -1) && (resolve->op_errno == EBADF)) {
-                gf_log ("fuse-resolve", GF_LOG_WARNING,
-                        "migration of basefd (ptr:%p inode-gfid:%s) "
-                        "did not complete, failing fop with EBADF "
-                        "(old-subvolume:%s-%d new-subvolume:%s-%d)", basefd,
-                        uuid_utoa (basefd->inode->gfid),
-                        active_subvol->name, active_subvol->graph->id,
-                        state->active_subvol->name,
-                        state->active_subvol->graph->id);
-        }
+    if ((resolve->op_ret == -1) && (resolve->op_errno == EBADF)) {
+        gf_log("fuse-resolve", GF_LOG_WARNING,
+               "migration of basefd (ptr:%p inode-gfid:%s) "
+               "did not complete, failing fop with EBADF "
+               "(old-subvolume:%s-%d new-subvolume:%s-%d)",
+               basefd, uuid_utoa(basefd->inode->gfid), active_subvol->name,
+               active_subvol->graph->id, state->active_subvol->name,
+               state->active_subvol->graph->id);
+    }
 
-        if (activefd != basefd) {
-                state->fd = fd_ref (activefd);
-                fd_unref (basefd);
-        }
+    if (activefd != basefd) {
+        state->fd = fd_ref(activefd);
+        fd_unref(basefd);
+    }
 
-	/* state->active_subvol = active_subvol; */
+    /* state->active_subvol = active_subvol; */
 
 resolve_continue:
-        if (activefd != NULL) {
-                fd_unref (activefd);
-        }
+    if (activefd != NULL) {
+        fd_unref(activefd);
+    }
 
-        fuse_resolve_continue (state);
+    fuse_resolve_continue(state);
 
-        return 0;
+    return 0;
 }
 
-
 int
-fuse_gfid_set (fuse_state_t *state)
+fuse_gfid_set(fuse_state_t *state)
 {
-        int   ret = 0;
+    int ret = 0;
 
-        if (gf_uuid_is_null (state->gfid))
-                goto out;
+    if (gf_uuid_is_null(state->gfid))
+        goto out;
 
-        if (!state->xdata)
-                state->xdata = dict_new ();
+    if (!state->xdata)
+        state->xdata = dict_new();
 
-        if (!state->xdata) {
-                ret = -1;
-                goto out;
-        }
+    if (!state->xdata) {
+        ret = -1;
+        goto out;
+    }
 
-        ret = dict_set_gfuuid (state->xdata, "gfid-req",
-                               state->gfid, true);
+    ret = dict_set_gfuuid(state->xdata, "gfid-req", state->gfid, true);
 out:
-        return ret;
+    return ret;
 }
 
-
 int
-fuse_resolve_entry_init (fuse_state_t *state, fuse_resolve_t *resolve,
-			 ino_t par, char *name)
+fuse_resolve_entry_init(fuse_state_t *state, fuse_resolve_t *resolve, ino_t par,
+                        char *name)
 {
-	inode_t       *parent = NULL;
+    inode_t *parent = NULL;
 
-	parent = fuse_ino_to_inode (par, state->this);
-	gf_uuid_copy (resolve->pargfid, parent->gfid);
-	resolve->parhint = parent;
-	resolve->bname = gf_strdup (name);
+    parent = fuse_ino_to_inode(par, state->this);
+    gf_uuid_copy(resolve->pargfid, parent->gfid);
+    resolve->parhint = parent;
+    resolve->bname = gf_strdup(name);
 
-	return 0;
+    return 0;
 }
 
-
 int
-fuse_resolve_inode_init (fuse_state_t *state, fuse_resolve_t *resolve,
-			 ino_t ino)
+fuse_resolve_inode_init(fuse_state_t *state, fuse_resolve_t *resolve, ino_t ino)
 {
-	inode_t       *inode = NULL;
+    inode_t *inode = NULL;
 
-	inode = fuse_ino_to_inode (ino, state->this);
-	gf_uuid_copy (resolve->gfid, inode->gfid);
-	resolve->hint = inode;
+    inode = fuse_ino_to_inode(ino, state->this);
+    gf_uuid_copy(resolve->gfid, inode->gfid);
+    resolve->hint = inode;
 
-	return 0;
+    return 0;
 }
 
-
 int
-fuse_resolve_fd_init (fuse_state_t *state, fuse_resolve_t *resolve,
-		      fd_t *fd)
+fuse_resolve_fd_init(fuse_state_t *state, fuse_resolve_t *resolve, fd_t *fd)
 {
-	resolve->fd = fd_ref (fd);
+    resolve->fd = fd_ref(fd);
 
-	return 0;
+    return 0;
 }
 
-
 static int
-fuse_resolve (fuse_state_t *state)
+fuse_resolve(fuse_state_t *state)
 {
-        fuse_resolve_t   *resolve = NULL;
-
-        resolve = state->resolve_now;
+    fuse_resolve_t *resolve = NULL;
 
-        if (resolve->fd) {
+    resolve = state->resolve_now;
 
-                fuse_resolve_fd (state);
+    if (resolve->fd) {
+        fuse_resolve_fd(state);
 
-        } else if (!gf_uuid_is_null (resolve->pargfid)) {
+    } else if (!gf_uuid_is_null(resolve->pargfid)) {
+        fuse_resolve_parent(state);
 
-                fuse_resolve_parent (state);
+    } else if (!gf_uuid_is_null(resolve->gfid)) {
+        fuse_resolve_inode(state);
 
-        } else if (!gf_uuid_is_null (resolve->gfid)) {
-
-                fuse_resolve_inode (state);
-
-        } else {
-                fuse_resolve_all (state);
-        }
+    } else {
+        fuse_resolve_all(state);
+    }
 
-        return 0;
+    return 0;
 }
 
 static int
-fuse_resolve_done (fuse_state_t *state)
+fuse_resolve_done(fuse_state_t *state)
 {
-        fuse_fop_resume (state);
-        return 0;
+    fuse_fop_resume(state);
+    return 0;
 }
 
 /*
@@ -669,53 +635,49 @@ fuse_resolve_done (fuse_state_t *state)
  * state->resolve_now is used to decide which location/fd is to be resolved now
  */
 static int
-fuse_resolve_all (fuse_state_t *state)
+fuse_resolve_all(fuse_state_t *state)
 {
-        if (state->resolve_now == NULL) {
-
-                state->resolve_now = &state->resolve;
-                state->loc_now     = &state->loc;
-
-                fuse_resolve (state);
-
-        } else if (state->resolve_now == &state->resolve) {
+    if (state->resolve_now == NULL) {
+        state->resolve_now = &state->resolve;
+        state->loc_now = &state->loc;
 
-                state->resolve_now = &state->resolve2;
-                state->loc_now     = &state->loc2;
+        fuse_resolve(state);
 
-                fuse_resolve (state);
+    } else if (state->resolve_now == &state->resolve) {
+        state->resolve_now = &state->resolve2;
+        state->loc_now = &state->loc2;
 
-        } else if (state->resolve_now == &state->resolve2) {
+        fuse_resolve(state);
 
-                fuse_resolve_done (state);
+    } else if (state->resolve_now == &state->resolve2) {
+        fuse_resolve_done(state);
 
-        } else {
-                gf_log ("fuse-resolve", GF_LOG_ERROR,
-                        "Invalid pointer for state->resolve_now");
-        }
+    } else {
+        gf_log("fuse-resolve", GF_LOG_ERROR,
+               "Invalid pointer for state->resolve_now");
+    }
 
-        return 0;
+    return 0;
 }
 
-
 int
-fuse_resolve_continue (fuse_state_t *state)
+fuse_resolve_continue(fuse_state_t *state)
 {
-        fuse_resolve_loc_touchup (state);
+    fuse_resolve_loc_touchup(state);
 
-        fuse_resolve_all (state);
+    fuse_resolve_all(state);
 
-        return 0;
+    return 0;
 }
 
 int
-fuse_resolve_and_resume (fuse_state_t *state, fuse_resume_fn_t fn)
+fuse_resolve_and_resume(fuse_state_t *state, fuse_resume_fn_t fn)
 {
-        fuse_gfid_set (state);
+    fuse_gfid_set(state);
 
-        state->resume_fn = fn;
+    state->resume_fn = fn;
 
-        fuse_resolve_all (state);
+    fuse_resolve_all(state);
 
-        return 0;
+    return 0;
 }