fuse resolve related changes

Now fuse is fully complaint with DVM, as even if there is a fop
request on inode belonging to old graph, it will be resolved
corresponding to new graph and operations will be performed wrt.
new graph, which makes DVM truely spontaneous.

Signed-off-by: Amar Tumballi <amar@gluster.com>
Signed-off-by: Anand V. Avati <avati@dev.gluster.com>

BUG: 1240 (DVM: after graph change, inodes should resolve to new inode-table)
URL: http://bugs.gluster.com/cgi-bin/bugzilla3/show_bug.cgi?id=1240

1 files changed, 559 insertions, 733 deletions

diff --git a/xlators/mount/fuse/src/fuse-bridge.c b/xlators/mount/fuse/src/fuse-bridge.c
index b1de4692a10..ea5b5ae38ad 100644
--- a/xlators/mount/fuse/src/fuse-bridge.c
+++ b/xlators/mount/fuse/src/fuse-bridge.c
@@ -25,283 +25,11 @@
  * fuse_loc_fill() and inode_path() return success/failure.
  */
 
-
-#include <stdint.h>
-#include <signal.h>
-#include <pthread.h>
-#include <stddef.h>
-#include <dirent.h>
-#include <sys/mount.h>
-#include <sys/time.h>
-
-#ifndef _CONFIG_H
-#define _CONFIG_H
-#include "config.h"
-#endif /* _CONFIG_H */
-
-#include "glusterfs.h"
-#include "logging.h"
-#include "xlator.h"
-#include "defaults.h"
-#include "common-utils.h"
-#include "glusterfsd-common.h"
-#include "statedump.h"
-
-#ifdef GF_DARWIN_HOST_OS
-/* This is MacFUSE's marker for MacFUSE-specific code */
-#define __FreeBSD__ 10
-#include "fuse_kernel_macfuse.h"
-#else
-#include "fuse_kernel.h"
-#endif
-#include "fuse-misc.h"
-#include "fuse-mount.h"
-#include "fuse-mem-types.h"
-
-#include "list.h"
-#include "dict.h"
-
-/* TODO: when supporting posix acl, remove this definition */
-#define DISABLE_POSIX_ACL
-
-#ifdef GF_LINUX_HOST_OS
-#define FUSE_OP_HIGH (FUSE_POLL + 1)
-#endif
-#ifdef GF_DARWIN_HOST_OS
-#define FUSE_OP_HIGH (FUSE_DESTROY + 1)
-#endif
-#define GLUSTERFS_XATTR_LEN_MAX  65536
-
-#define MAX_FUSE_PROC_DELAY 1
+#include "fuse-bridge.h"
 
 static int gf_fuse_conn_err_log;
 static int gf_fuse_xattr_enotsup_log;
 
-typedef struct fuse_in_header fuse_in_header_t;
-typedef void (fuse_handler_t) (xlator_t *this, fuse_in_header_t *finh,
-                               void *msg);
-
-struct fuse_private {
-        int                  fd;
-        uint32_t             proto_minor;
-        char                *volfile;
-        size_t               volfile_size;
-        char                *mount_point;
-        struct iobuf        *iobuf;
-
-        pthread_t            fuse_thread;
-        char                 fuse_thread_started;
-
-        uint32_t             direct_io_mode;
-        size_t              *msg0_len_p;
-
-        double               entry_timeout;
-        double               attribute_timeout;
-
-        pthread_cond_t       sync_cond;
-        pthread_mutex_t      sync_mutex;
-        char                 child_up;
-
-        char                 init_recvd;
-
-        gf_boolean_t         strict_volfile_check;
-
-        fuse_handler_t     **fuse_ops;
-        fuse_handler_t     **fuse_ops0;
-        pthread_mutex_t      fuse_dump_mutex;
-        int                  fuse_dump_fd;
-
-        glusterfs_graph_t   *next_graph;
-        xlator_t            *active_subvol;
-};
-typedef struct fuse_private fuse_private_t;
-
-#define _FH_TO_FD(fh) ((fd_t *)(uintptr_t)(fh))
-
-#define FH_TO_FD(fh) ((_FH_TO_FD (fh))?(fd_ref (_FH_TO_FD (fh))):((fd_t *) 0))
-
-#define FUSE_FOP(state, ret, op_num, fop, args ...)                     \
-        do {                                                            \
-                call_frame_t *frame = NULL;                             \
-                xlator_t *xl = NULL;                                    \
-                                                                        \
-                frame = get_call_frame_for_req (state);                 \
-                if (!frame) {                                           \
-                         /* This is not completely clean, as some       \
-                          * earlier allocations might remain unfreed    \
-                          * if we return at this point, but still       \
-                          * better than trying to go on with a NULL     \
-                          * frame ...                                   \
-                          */                                            \
-                        gf_log ("glusterfs-fuse",                       \
-                                GF_LOG_ERROR,                           \
-                                "FUSE message"                          \
-                                " unique %"PRIu64" opcode %d:"          \
-                                " frame allocation failed",             \
-                                state->finh->unique,                    \
-                                state->finh->opcode);                   \
-                        free_state (state);                             \
-                        return;                                         \
-                }                                                       \
-                xl = fuse_state_subvol (state);                         \
-                                                                        \
-                frame->root->state = state;                             \
-                frame->root->op    = op_num;                            \
-		frame->op          = op_num;				\
-                STACK_WIND (frame, ret, xl, xl->fops->fop, args);       \
-        } while (0)
-
-#define GF_SELECT_LOG_LEVEL(_errno)                     \
-        (((_errno == ENOENT) || (_errno == ESTALE))?    \
-         GF_LOG_DEBUG)
-
-#define GET_STATE(this, finh, state)                                       \
-        do {                                                               \
-                state = get_state (this, finh);                            \
-                if (!state) {                                              \
-                        gf_log ("glusterfs-fuse",                          \
-                                GF_LOG_ERROR,                              \
-                                "FUSE message unique %"PRIu64" opcode %d:" \
-                                " state allocation failed",                \
-                                finh->unique, finh->opcode);               \
-                                                                           \
-                        send_fuse_err (this, finh, ENOMEM);                \
-                        GF_FREE (finh);                                       \
-                                                                           \
-                        return;                                            \
-                }                                                          \
-        } while (0)
-
-
-typedef struct {
-        void          *pool;
-        xlator_t      *this;
-        inode_table_t *itable;
-        loc_t          loc;
-        loc_t          loc2;
-        fuse_in_header_t *finh;
-        int32_t        flags;
-        off_t          off;
-        size_t         size;
-        unsigned long  nlookup;
-        fd_t          *fd;
-        dict_t        *dict;
-        char          *name;
-        char           is_revalidate;
-        gf_boolean_t   truncate_needed;
-        gf_lock_t      lock;
-        uint64_t       lk_owner;
-} fuse_state_t;
-
-
-xlator_t *
-fuse_state_subvol (fuse_state_t *state)
-{
-        xlator_t *subvol = NULL;
-
-        if (!state)
-                return NULL;
-
-        if (state->loc.inode)
-                subvol = state->loc.inode->table->xl;
-
-        if (state->fd)
-                subvol = state->fd->inode->table->xl;
-
-        return subvol;
-}
-
-
-xlator_t *
-fuse_active_subvol (xlator_t *fuse)
-{
-        fuse_private_t *priv = NULL;
-
-        priv = fuse->private;
-
-        return priv->active_subvol;
-}
-
-
-static void
-free_state (fuse_state_t *state)
-{
-        loc_wipe (&state->loc);
-
-        loc_wipe (&state->loc2);
-
-        if (state->dict) {
-                dict_unref (state->dict);
-                state->dict = (void *)0xaaaaeeee;
-        }
-        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;
-        }
-#ifdef DEBUG
-        memset (state, 0x90, sizeof (*state));
-#endif
-        GF_FREE (state);
-        state = NULL;
-}
-
-
-fuse_state_t *
-get_state (xlator_t *this, fuse_in_header_t *finh)
-{
-        fuse_state_t *state = NULL;
-
-        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;
-
-        LOCK_INIT (&state->lock);
-
-        return state;
-}
-
-
-static call_frame_t *
-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;
-
-        pool = state->pool;
-        finh = state->finh;
-        this = state->this;
-
-        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->lk_owner = state->lk_owner;
-                frame->root->unique   = finh->unique;
-        }
-
-        frame->root->type = GF_OP_TYPE_FOP;
-
-        return frame;
-}
-
 
 /*
  * iov_out should contain a fuse_out_header at zeroth position.
@@ -378,142 +106,6 @@ send_fuse_err (xlator_t *this, fuse_in_header_t *finh, int error)
         return send_fuse_iov (this, finh, &iov_out, 1);
 }
 
-static inode_t *
-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);
-                inode = active_subvol->itable->root;
-        } else {
-                inode = (inode_t *) (unsigned long) ino;
-                inode_ref (inode);
-        }
-
-        return inode;
-}
-
-static uint64_t
-inode_to_nodeid (inode_t *inode)
-{
-        if (!inode || inode->ino == 1)
-                return 1;
-
-        return (unsigned long) inode;
-}
-
-
-GF_MUST_CHECK static int32_t
-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;
-
-        /* 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;
-                }
-
-                inode = loc->inode;
-                if (!inode) {
-                        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 %"PRId64"/%s",
-                                parent->ino, name);
-                        goto fail;
-                }
-                loc->path = path;
-        } else {
-                inode = loc->inode;
-                if (!inode) {
-                        inode = fuse_ino_to_inode (ino, state->this);
-                        loc->inode = inode;
-                }
-
-                parent = loc->parent;
-                if (!parent) {
-                        parent = inode_parent (inode, par, name);
-                        loc->parent = parent;
-                }
-
-                ret = inode_path (inode, NULL, &path);
-                if (ret <= 0) {
-                        gf_log ("glusterfs-fuse", GF_LOG_DEBUG,
-                                "inode_path failed for %"PRId64,
-                                inode->ino);
-                        goto fail;
-                }
-                loc->path = path;
-        }
-
-        if (inode)
-                loc->ino = inode->ino;
-
-        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:
-        return ret;
-}
-
-
-/* courtesy of folly */
-static void
-stat2attr (struct iatt *st, struct fuse_attr *fa)
-{
-        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       = st->ia_rdev;
-#if FUSE_KERNEL_MINOR_VERSION >= 9
-        fa->blksize    = st->ia_blksize;
-#endif
-#ifdef GF_DARWIN_HOST_OS
-        fa->crtime     = (uint64_t)-1;
-        fa->crtimensec = (uint32_t)-1;
-        fa->flags      = 0;
-#endif
-}
-
-
 static int
 fuse_entry_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
                 int32_t op_ret, int32_t op_errno,
@@ -540,7 +132,7 @@ fuse_entry_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
                         state->loc.path, buf->ia_ino, state->loc.ino);
 
                 buf->ia_blksize = this->ctx->page_size;
-                stat2attr (buf, &feo.attr);
+                gf_fuse_stat2attr (buf, &feo.attr);
 
                 if (!buf->ia_ino) {
                         gf_log ("glusterfs-fuse", GF_LOG_WARNING,
@@ -566,7 +158,8 @@ fuse_entry_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
                 inode_lookup (linked_inode);
 
                 /* TODO: make these timeouts configurable (via meta?) */
-                feo.nodeid = inode_to_nodeid (linked_inode);
+                /* should we do linked_node or inode */
+                feo.nodeid = inode_to_fuse_nodeid (linked_inode);
 
                 feo.generation = linked_inode->generation;
 
@@ -598,7 +191,7 @@ fuse_entry_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
                 send_fuse_err (this, state->finh, op_errno);
         }
 
-        free_state (state);
+        free_fuse_state (state);
         STACK_DESTROY (frame->root);
         return 0;
 }
@@ -644,14 +237,24 @@ fuse_lookup_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
         return 0;
 }
 
+void
+fuse_lookup_resume (fuse_state_t *state)
+{
+        if (!state->loc.inode)
+                state->loc.inode = inode_new (state->loc.parent->table);
+
+        state->dict = dict_new ();
+
+        FUSE_FOP (state, fuse_lookup_cbk, GF_FOP_LOOKUP,
+                  lookup, &state->loc, state->dict);
+}
 
 static void
 fuse_lookup (xlator_t *this, fuse_in_header_t *finh, void *msg)
 {
-        char *name = msg;
-
-        fuse_state_t *state = NULL;
-        int32_t       ret = -1;
+        char         *name      = msg;
+        fuse_state_t *state     = NULL;
+        int32_t       ret       = -1;
 
         GET_STATE (this, finh, state);
 
@@ -662,27 +265,23 @@ fuse_lookup (xlator_t *this, fuse_in_header_t *finh, void *msg)
                         "%"PRIu64": LOOKUP %"PRIu64"/%s (fuse_loc_fill() failed)",
                         finh->unique, finh->nodeid, name);
                 send_fuse_err (this, finh, ENOENT);
-                free_state (state);
+                free_fuse_state (state);
                 return;
         }
 
-        if (!state->loc.inode) {
-                gf_log ("glusterfs-fuse", GF_LOG_TRACE,
-                        "%"PRIu64": LOOKUP %s", finh->unique,
-                        state->loc.path);
-
-                state->loc.inode = inode_new (state->loc.parent->table);
-        } else {
+        if (state->loc.inode) {
                 gf_log ("glusterfs-fuse", GF_LOG_TRACE,
                         "%"PRIu64": LOOKUP %s(%"PRId64")", finh->unique,
                         state->loc.path, state->loc.inode->ino);
                 state->is_revalidate = 1;
+        } else {
+                gf_log ("glusterfs-fuse", GF_LOG_TRACE,
+                        "%"PRIu64": LOOKUP %s", finh->unique,
+                        state->loc.path);
         }
 
-        state->dict = dict_new ();
+        fuse_resolve_and_resume (state, fuse_lookup_resume);
 
-        FUSE_FOP (state, fuse_lookup_cbk, GF_FOP_LOOKUP,
-                  lookup, &state->loc, state->dict);
 }
 
 
@@ -732,7 +331,7 @@ fuse_truncate_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
                 /* TODO: make these timeouts configurable via meta */
                 /* TODO: what if the inode number has changed by now */
                 postbuf->ia_blksize = this->ctx->page_size;
-                stat2attr (postbuf, &fao.attr);
+                gf_fuse_stat2attr (postbuf, &fao.attr);
 
                 fao.attr_valid = calc_timeout_sec (priv->attribute_timeout);
                 fao.attr_valid_nsec =
@@ -756,7 +355,7 @@ fuse_truncate_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
                 send_fuse_err (this, finh, op_errno);
         }
 
-        free_state (state);
+        free_fuse_state (state);
         STACK_DESTROY (frame->root);
 
         return 0;
@@ -786,7 +385,7 @@ fuse_attr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
                 /* TODO: make these timeouts configurable via meta */
                 /* TODO: what if the inode number has changed by now */
                 buf->ia_blksize = this->ctx->page_size;
-                stat2attr (buf, &fao.attr);
+                gf_fuse_stat2attr (buf, &fao.attr);
 
                 fao.attr_valid = calc_timeout_sec (priv->attribute_timeout);
                 fao.attr_valid_nsec =
@@ -812,7 +411,7 @@ fuse_attr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
                 send_fuse_err (this, finh, op_errno);
         }
 
-        free_state (state);
+        free_fuse_state (state);
         STACK_DESTROY (frame->root);
 
         return 0;
@@ -830,6 +429,28 @@ fuse_root_lookup_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
         return 0;
 }
 
+void
+fuse_getattr_resume (fuse_state_t *state)
+{
+        if (!state->fd || IA_ISDIR (state->loc.inode->ia_type)) {
+                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);
+        } else {
+
+                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);
+        }
+}
 
 static void
 fuse_getattr (xlator_t *this, fuse_in_header_t *finh, void *msg)
@@ -844,10 +465,10 @@ fuse_getattr (xlator_t *this, fuse_in_header_t *finh, void *msg)
                 ret = fuse_loc_fill (&state->loc, state, finh->nodeid, 0, NULL);
                 if (ret < 0) {
                         gf_log ("glusterfs-fuse", GF_LOG_WARNING,
-                                "%"PRIu64": GETATTR %"PRIu64" (fuse_loc_fill() failed)",
-                                finh->unique, finh->nodeid);
+                                "%"PRIu64": GETATTR on / (fuse_loc_fill() failed)",
+                                finh->unique);
                         send_fuse_err (this, finh, ENOENT);
-                        free_state (state);
+                        free_fuse_state (state);
                         return;
                 }
 
@@ -858,18 +479,18 @@ fuse_getattr (xlator_t *this, fuse_in_header_t *finh, void *msg)
                 return;
         }
 
-        ret = fuse_loc_fill (&state->loc, state, finh->nodeid, 0, NULL);
+        ret = fuse_loc_fill (&state->loc, state, state->finh->nodeid, 0, NULL);
 
         if (!state->loc.inode) {
                 gf_log ("glusterfs-fuse", GF_LOG_WARNING,
                         "%"PRIu64": GETATTR %"PRIu64" (%s) (fuse_loc_fill() returned NULL inode)",
-                        finh->unique, finh->nodeid, state->loc.path);
-                send_fuse_err (this, finh, ENOENT);
-                free_state (state);
+                        state->finh->unique, state->finh->nodeid, state->loc.path);
+                send_fuse_err (state->this, state->finh, ENOENT);
+                free_fuse_state (state);
                 return;
         }
 
-        fd = fd_lookup (state->loc.inode, finh->pid);
+        fd = fd_lookup (state->loc.inode, state->finh->pid);
         state->fd = fd;
         if (!fd || IA_ISDIR (state->loc.inode->ia_type)) {
                 /* this is the @ret of fuse_loc_fill, checked here
@@ -878,28 +499,15 @@ fuse_getattr (xlator_t *this, fuse_in_header_t *finh, void *msg)
                 if (ret < 0) {
                         gf_log ("glusterfs-fuse", GF_LOG_WARNING,
                                 "%"PRIu64": GETATTR %"PRIu64" (fuse_loc_fill() failed)",
-                                finh->unique, finh->nodeid);
-                        send_fuse_err (this, finh, ENOENT);
-                        free_state (state);
+                                state->finh->unique, state->finh->nodeid);
+                        send_fuse_err (state->this, state->finh, ENOENT);
+                        free_fuse_state (state);
                         return;
                 }
-
-                gf_log ("glusterfs-fuse", GF_LOG_TRACE,
-                        "%"PRIu64": GETATTR %"PRIu64" (%s)",
-                        finh->unique, finh->nodeid, state->loc.path);
-
-
-                FUSE_FOP (state, fuse_attr_cbk, GF_FOP_STAT,
-                          stat, &state->loc);
-        } else {
-
-                gf_log ("glusterfs-fuse", GF_LOG_TRACE,
-                        "%"PRIu64": FGETATTR %"PRIu64" (%s/%p)",
-                        finh->unique, finh->nodeid, state->loc.path, fd);
-
-                FUSE_FOP (state,fuse_attr_cbk, GF_FOP_FSTAT,
-                          fstat, fd);
+                state->fd = NULL;
         }
+
+        fuse_resolve_and_resume (state, fuse_getattr_resume);
 }
 
 
@@ -960,7 +568,7 @@ fuse_fd_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
                 send_fuse_err (this, finh, op_errno);
         }
 out:
-        free_state (state);
+        free_fuse_state (state);
         STACK_DESTROY (frame->root);
         return 0;
 }
@@ -1009,7 +617,7 @@ fuse_setattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
 
                 statpost->ia_blksize = this->ctx->page_size;
 
-                stat2attr (statpost, &fao.attr);
+                gf_fuse_stat2attr (statpost, &fao.attr);
 
                 fao.attr_valid = calc_timeout_sec (priv->attribute_timeout);
                 fao.attr_valid_nsec =
@@ -1040,7 +648,7 @@ fuse_setattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
         }
 
         if (op_done) {
-                free_state (state);
+                free_fuse_state (state);
         }
 
         STACK_DESTROY (frame->root);
@@ -1081,18 +689,40 @@ fattr_to_gf_set_attr (int32_t valid)
                       | FATTR_ATIME | FATTR_MTIME       \
                       | FATTR_MODE)
 
+void
+fuse_setattr_resume (fuse_state_t *state)
+{
+        if ((state->valid & (FATTR_MASK)) != FATTR_SIZE) {
+                if (state->fd &&
+                    !((state->valid & FATTR_ATIME) ||
+                      (state->valid & FATTR_MTIME))) {
+                        /*
+                            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));
+                } else {
+                        FUSE_FOP (state, fuse_setattr_cbk, GF_FOP_SETATTR,
+                                  setattr, &state->loc, &state->attr,
+                                  fattr_to_gf_set_attr (state->valid));
+                }
+        } else {
+                fuse_do_truncate (state, state->size);
+        }
+
+}
 
 static void
 fuse_setattr (xlator_t *this, fuse_in_header_t *finh, void *msg)
 {
         struct fuse_setattr_in *fsi = msg;
 
-        struct iatt attr = {0, };
-
         fuse_private_t  *priv = NULL;
         fuse_state_t *state = NULL;
         int32_t       ret   = -1;
-        int32_t       valid = 0;
 
         GET_STATE (this, finh, state);
 
@@ -1132,7 +762,7 @@ fuse_setattr (xlator_t *this, fuse_in_header_t *finh, void *msg)
                         finh->unique, state->loc.path);
 
                 send_fuse_err (this, finh, ENOENT);
-                free_state (state);
+                free_fuse_state (state);
 
                 return;
         }
@@ -1141,48 +771,32 @@ fuse_setattr (xlator_t *this, fuse_in_header_t *finh, void *msg)
                 "%"PRIu64": SETATTR (%"PRIu64")%s", finh->unique,
                 finh->nodeid, state->loc.path);
 
-        valid = fsi->valid;
+        state->valid = fsi->valid;
 
         if (fsi->valid & FATTR_FH) {
                 state->fd = FH_TO_FD (fsi->fh);
         }
 
-        if ((valid & (FATTR_MASK)) != FATTR_SIZE) {
-                if (valid & FATTR_SIZE) {
+        if ((fsi->valid & (FATTR_MASK)) != FATTR_SIZE) {
+                if (fsi->valid & FATTR_SIZE) {
                         state->size            = fsi->size;
                         state->truncate_needed = _gf_true;
                 }
 
-                attr.ia_size  = fsi->size;
-                attr.ia_atime = fsi->atime;
-                attr.ia_mtime = fsi->mtime;
-                attr.ia_atime_nsec = fsi->atimensec;
-                attr.ia_mtime_nsec = fsi->mtimensec;
+                state->attr.ia_size  = fsi->size;
+                state->attr.ia_atime = fsi->atime;
+                state->attr.ia_mtime = fsi->mtime;
+                state->attr.ia_atime_nsec = fsi->atimensec;
+                state->attr.ia_mtime_nsec = fsi->mtimensec;
 
-                attr.ia_prot = ia_prot_from_st_mode (fsi->mode);
-                attr.ia_uid  = fsi->uid;
-                attr.ia_gid  = fsi->gid;
-
-                if (state->fd &&
-                    !((fsi->valid & FATTR_ATIME) || (fsi->valid & FATTR_MTIME))) {
-
-                         /*
-                            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, &attr,
-                                  fattr_to_gf_set_attr (fsi->valid));
-                } else {
-                        FUSE_FOP (state, fuse_setattr_cbk, GF_FOP_SETATTR,
-                                  setattr, &state->loc, &attr,
-                                  fattr_to_gf_set_attr (fsi->valid));
-                }
+                state->attr.ia_prot = ia_prot_from_st_mode (fsi->mode);
+                state->attr.ia_uid  = fsi->uid;
+                state->attr.ia_gid  = fsi->gid;
         } else {
-                fuse_do_truncate (state, fsi->size);
+                state->size = fsi->size;
         }
 
+        fuse_resolve_and_resume (state, fuse_setattr_resume);
 }
 
 
@@ -1211,7 +825,7 @@ fuse_err_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
                 send_fuse_err (this, finh, op_errno);
         }
 
-        free_state (state);
+        free_fuse_state (state);
         STACK_DESTROY (frame->root);
 
         return 0;
@@ -1272,12 +886,24 @@ fuse_unlink_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
                 send_fuse_err (this, finh, op_errno);
         }
 
-        free_state (state);
+        free_fuse_state (state);
         STACK_DESTROY (frame->root);
 
         return 0;
 }
 
+void
+fuse_access_resume (fuse_state_t *state)
+{
+        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);
+
+}
 
 static void
 fuse_access (xlator_t *this, fuse_in_header_t *finh, void *msg)
@@ -1296,18 +922,13 @@ fuse_access (xlator_t *this, fuse_in_header_t *finh, void *msg)
                         "%"PRIu64": ACCESS %"PRIu64" (%s) (fuse_loc_fill() failed)",
                         finh->unique, finh->nodeid, state->loc.path);
                 send_fuse_err (this, finh, ENOENT);
-                free_state (state);
+                free_fuse_state (state);
                 return;
         }
 
-        gf_log ("glusterfs-fuse", GF_LOG_TRACE,
-                "%"PRIu64" ACCESS %s/%"PRIu64" mask=%d", finh->unique,
-                state->loc.path, finh->nodeid, fai->mask);
-
-        FUSE_FOP (state, fuse_err_cbk,
-                  GF_FOP_ACCESS, access,
-                  &state->loc, fai->mask);
+        state->mask = fai->mask;
 
+        fuse_resolve_and_resume (state, fuse_access_resume);
         return;
 }
 
@@ -1339,12 +960,23 @@ fuse_readlink_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
                 send_fuse_err (this, finh, op_errno);
         }
 
-        free_state (state);
+        free_fuse_state (state);
         STACK_DESTROY (frame->root);
 
         return 0;
 }
 
+void
+fuse_readlink_resume (fuse_state_t *state)
+{
+        gf_log ("glusterfs-fuse", GF_LOG_TRACE,
+                "%"PRIu64" READLINK %s/%"PRId64, state->finh->unique,
+                state->loc.path, state->loc.inode->ino);
+
+        FUSE_FOP (state, fuse_readlink_cbk, GF_FOP_READLINK,
+                  readlink, &state->loc, 4096);
+
+}
 
 static void
 fuse_readlink (xlator_t *this, fuse_in_header_t *finh, void *msg)
@@ -1360,20 +992,31 @@ fuse_readlink (xlator_t *this, fuse_in_header_t *finh, void *msg)
                         "%"PRIu64" READLINK %s (fuse_loc_fill() returned NULL inode)",
                         finh->unique, state->loc.path);
                 send_fuse_err (this, finh, ENOENT);
-                free_state (state);
+                free_fuse_state (state);
                 return;
         }
 
-        gf_log ("glusterfs-fuse", GF_LOG_TRACE,
-                "%"PRIu64" READLINK %s/%"PRId64, finh->unique,
-                state->loc.path, state->loc.inode->ino);
-
-        FUSE_FOP (state, fuse_readlink_cbk, GF_FOP_READLINK,
-                  readlink, &state->loc, 4096);
+        fuse_resolve_and_resume (state, fuse_readlink_resume);
 
         return;
 }
 
+void
+fuse_mknod_resume (fuse_state_t *state)
+{
+        if (!state->loc.inode)
+                state->loc.inode = inode_new (state->loc.parent->table);
+        else
+                gf_log (state->this->name, GF_LOG_ERROR, "inode already present");
+
+        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);
+
+}
 
 static void
 fuse_mknod (xlator_t *this, fuse_in_header_t *finh, void *msg)
@@ -1398,22 +1041,33 @@ fuse_mknod (xlator_t *this, fuse_in_header_t *finh, void *msg)
                         "%"PRIu64" MKNOD %s (fuse_loc_fill() failed)",
                         finh->unique, state->loc.path);
                 send_fuse_err (this, finh, ENOENT);
-                free_state (state);
+                free_fuse_state (state);
                 return;
         }
 
-        state->loc.inode = inode_new (state->loc.parent->table);
-
-        gf_log ("glusterfs-fuse", GF_LOG_TRACE,
-                "%"PRIu64": MKNOD %s", finh->unique,
-                state->loc.path);
+        state->mode = fmi->mode;
+        state->rdev = fmi->rdev;
 
-        FUSE_FOP (state, fuse_newentry_cbk, GF_FOP_MKNOD,
-                  mknod, &state->loc, fmi->mode, fmi->rdev);
+        fuse_resolve_and_resume (state, fuse_mknod_resume);
 
         return;
 }
 
+void
+fuse_mkdir_resume (fuse_state_t *state)
+{
+        if (!state->loc.inode)
+                state->loc.inode = inode_new (state->loc.parent->table);
+        else
+                gf_log (state->this->name, GF_LOG_ERROR, "inode already present");
+
+        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);
+}
 
 static void
 fuse_mkdir (xlator_t *this, fuse_in_header_t *finh, void *msg)
@@ -1431,23 +1085,35 @@ fuse_mkdir (xlator_t *this, fuse_in_header_t *finh, void *msg)
                         "%"PRIu64" MKDIR %s (fuse_loc_fill() failed)",
                         finh->unique, state->loc.path);
                 send_fuse_err (this, finh, ENOENT);
-                free_state (state);
+                free_fuse_state (state);
                 return;
         }
 
-        state->loc.inode = inode_new (state->loc.parent->table);
+        state->mode = fmi->mode;
+
+        fuse_resolve_and_resume (state, fuse_mkdir_resume);
 
+        return;
+}
+
+void
+fuse_unlink_resume (fuse_state_t *state)
+{
+        if (!state->loc.inode) {
+                gf_log ("fuse", GF_LOG_WARNING, "path resolving failed");
+                send_fuse_err (state->this, state->finh, ENOENT);
+                free_fuse_state (state);
+                return;
+        }
         gf_log ("glusterfs-fuse", GF_LOG_TRACE,
-                "%"PRIu64": MKDIR %s", finh->unique,
+                "%"PRIu64": UNLINK %s", state->finh->unique,
                 state->loc.path);
 
-        FUSE_FOP (state, fuse_newentry_cbk, GF_FOP_MKDIR,
-                  mkdir, &state->loc, fmi->mode);
+        FUSE_FOP (state, fuse_unlink_cbk, GF_FOP_UNLINK,
+                  unlink, &state->loc);
 
-        return;
 }
 
-
 static void
 fuse_unlink (xlator_t *this, fuse_in_header_t *finh, void *msg)
 {
@@ -1457,29 +1123,38 @@ fuse_unlink (xlator_t *this, fuse_in_header_t *finh, void *msg)
         int32_t       ret = -1;
 
         GET_STATE (this, finh, state);
-
         ret = fuse_loc_fill (&state->loc, state, 0, finh->nodeid, name);
-
-        if ((state->loc.inode == NULL) ||
-            (ret < 0)) {
+        if (ret < 0) {
                 gf_log ("glusterfs-fuse", GF_LOG_WARNING,
                         "%"PRIu64": UNLINK %s (fuse_loc_fill() returned NULL inode)",
                         finh->unique, state->loc.path);
                 send_fuse_err (this, finh, ENOENT);
-                free_state (state);
+                free_fuse_state (state);
                 return;
         }
 
-        gf_log ("glusterfs-fuse", GF_LOG_TRACE,
-                "%"PRIu64": UNLINK %s", finh->unique,
-                state->loc.path);
-
-        FUSE_FOP (state, fuse_unlink_cbk, GF_FOP_UNLINK,
-                  unlink, &state->loc);
+        fuse_resolve_and_resume (state, fuse_unlink_resume);
 
         return;
 }
 
+void
+fuse_rmdir_resume (fuse_state_t *state)
+{
+        if (!state->loc.inode) {
+                gf_log ("fuse", GF_LOG_WARNING, "path resolving failed");
+                send_fuse_err (state->this, state->finh, ENOENT);
+                free_fuse_state (state);
+                return;
+        }
+
+        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);
+}
 
 static void
 fuse_rmdir (xlator_t *this, fuse_in_header_t *finh, void *msg)
@@ -1491,26 +1166,34 @@ fuse_rmdir (xlator_t *this, fuse_in_header_t *finh, void *msg)
 
         GET_STATE (this, finh, state);
         ret = fuse_loc_fill (&state->loc, state, 0, finh->nodeid, name);
-        if ((state->loc.inode == NULL) ||
-            (ret < 0)) {
+        if (ret < 0) {
                 gf_log ("glusterfs-fuse", GF_LOG_WARNING,
                         "%"PRIu64": RMDIR %s (fuse_loc_fill() failed)",
                         finh->unique, state->loc.path);
                 send_fuse_err (this, finh, ENOENT);
-                free_state (state);
+                free_fuse_state (state);
                 return;
         }
 
-        gf_log ("glusterfs-fuse", GF_LOG_TRACE,
-                "%"PRIu64": RMDIR %s", finh->unique,
-                state->loc.path);
-
-        FUSE_FOP (state, fuse_unlink_cbk, GF_FOP_RMDIR,
-                  rmdir, &state->loc);
-
+        fuse_resolve_and_resume (state, fuse_rmdir_resume);
         return;
 }
 
+void
+fuse_symlink_resume (fuse_state_t *state)
+{
+        if (!state->loc.inode)
+                state->loc.inode = inode_new (state->loc.parent->table);
+        else
+                gf_log (state->this->name, GF_LOG_ERROR, "inode already present");
+
+        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);
+}
 
 static void
 fuse_symlink (xlator_t *this, fuse_in_header_t *finh, void *msg)
@@ -1528,19 +1211,12 @@ fuse_symlink (xlator_t *this, fuse_in_header_t *finh, void *msg)
                         "%"PRIu64" SYMLINK %s -> %s (fuse_loc_fill() failed)",
                         finh->unique, state->loc.path, linkname);
                 send_fuse_err (this, finh, ENOENT);
-                free_state (state);
+                free_fuse_state (state);
                 return;
         }
 
-        state->loc.inode = inode_new (state->loc.parent->table);
-
-        gf_log ("glusterfs-fuse", GF_LOG_TRACE,
-                "%"PRIu64": SYMLINK %s -> %s", finh->unique,
-                state->loc.path, linkname);
-
-        FUSE_FOP (state, fuse_newentry_cbk, GF_FOP_SYMLINK,
-                  symlink, linkname, &state->loc);
-
+        state->name = gf_strdup (linkname);
+        fuse_resolve_and_resume (state, fuse_symlink_resume);
         return;
 }
 
@@ -1586,11 +1262,28 @@ fuse_rename_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
                 send_fuse_err (this, finh, op_errno);
         }
 
-        free_state (state);
+        free_fuse_state (state);
         STACK_DESTROY (frame->root);
         return 0;
 }
 
+void
+fuse_rename_resume (fuse_state_t *state)
+{
+        if (!state->loc.inode) {
+                send_fuse_err (state->this, state->finh, ENOENT);
+                free_fuse_state (state);
+                return;
+        }
+
+        gf_log ("glusterfs-fuse", GF_LOG_TRACE,
+                "%"PRIu64": RENAME `%s (%"PRId64")' -> `%s (%"PRId64")'",
+                state->finh->unique, state->loc.path, state->loc.ino,
+                state->loc2.path, state->loc2.ino);
+
+        FUSE_FOP (state, fuse_rename_cbk, GF_FOP_RENAME,
+                  rename, &state->loc, &state->loc2);
+}
 
 static void
 fuse_rename (xlator_t *this, fuse_in_header_t *finh, void *msg)
@@ -1605,15 +1298,14 @@ fuse_rename (xlator_t *this, fuse_in_header_t *finh, void *msg)
         GET_STATE (this, finh, state);
 
         ret = fuse_loc_fill (&state->loc, state, 0, finh->nodeid, oldname);
-        if ((state->loc.inode == NULL) ||
-            (ret < 0)) {
+        if (ret < 0) {
                 gf_log ("glusterfs-fuse", GF_LOG_WARNING,
                         "for %s %"PRIu64": RENAME `%s' -> `%s' (fuse_loc_fill() failed)",
                         state->loc.path, finh->unique, state->loc.path,
                         state->loc2.path);
 
                 send_fuse_err (this, finh, ENOENT);
-                free_state (state);
+                free_fuse_state (state);
                 return;
         }
 
@@ -1625,21 +1317,31 @@ fuse_rename (xlator_t *this, fuse_in_header_t *finh, void *msg)
                         state->loc2.path);
 
                 send_fuse_err (this, finh, ENOENT);
-                free_state (state);
+                free_fuse_state (state);
                 return;
-               }
-
-        gf_log ("glusterfs-fuse", GF_LOG_TRACE,
-                "%"PRIu64": RENAME `%s (%"PRId64")' -> `%s (%"PRId64")'",
-                finh->unique, state->loc.path, state->loc.ino,
-                state->loc2.path, state->loc2.ino);
+        }
 
-        FUSE_FOP (state, fuse_rename_cbk, GF_FOP_RENAME,
-                  rename, &state->loc, &state->loc2);
+        fuse_resolve_and_resume (state, fuse_rename_resume);
 
         return;
 }
 
+void
+fuse_link_resume (fuse_state_t *state)
+{
+        if (!state->loc.inode)
+                state->loc.inode = inode_ref (state->loc2.inode);
+        else
+                gf_log (state->this->name, GF_LOG_ERROR, "inode already present");
+
+        gf_log ("glusterfs-fuse", GF_LOG_TRACE,
+                "%"PRIu64": LINK() %s (%"PRId64") -> %s (%"PRId64")",
+                state->finh->unique, state->loc2.path, state->loc2.ino,
+                state->loc.path, state->loc.ino);
+
+        FUSE_FOP (state, fuse_newentry_cbk, GF_FOP_LINK,
+                  link, &state->loc2, &state->loc);
+}
 
 static void
 fuse_link (xlator_t *this, fuse_in_header_t *finh, void *msg)
@@ -1664,18 +1366,11 @@ fuse_link (xlator_t *this, fuse_in_header_t *finh, void *msg)
                         state->loc2.path, finh->unique,
                         state->loc2.path, state->loc.path);
                 send_fuse_err (this, finh, ENOENT);
-                free_state (state);
+                free_fuse_state (state);
                 return;
         }
 
-        state->loc.inode = inode_ref (state->loc2.inode);
-        gf_log ("glusterfs-fuse", GF_LOG_TRACE,
-                "%"PRIu64": LINK() %s (%"PRId64") -> %s (%"PRId64")",
-                finh->unique, state->loc2.path, state->loc2.ino,
-                state->loc.path, state->loc.ino);
-
-        FUSE_FOP (state, fuse_newentry_cbk, GF_FOP_LINK,
-                  link, &state->loc2, &state->loc);
+        fuse_resolve_and_resume (state, fuse_link_resume);
 
         return;
 }
@@ -1696,7 +1391,6 @@ fuse_create_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
         struct iovec             iov_out[3];
         inode_t                 *linked_inode = NULL;
 
-
         state    = frame->root->state;
         priv     = this->private;
         finh     = state->finh;
@@ -1714,7 +1408,7 @@ fuse_create_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
                         state->loc.path, fd, buf->ia_ino);
 
                 buf->ia_blksize = this->ctx->page_size;
-                stat2attr (buf, &feo.attr);
+                gf_fuse_stat2attr (buf, &feo.attr);
 
                 linked_inode = inode_link (inode, state->loc.parent,
                                            state->loc.name, buf);
@@ -1738,11 +1432,12 @@ fuse_create_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
 
                 inode_lookup (linked_inode);
 
+                inode_ref (state->loc.parent);
                 inode_unref (linked_inode);
 
                 fd_ref (fd);
 
-                feo.nodeid = inode_to_nodeid (linked_inode);
+                feo.nodeid = inode_to_fuse_nodeid (linked_inode);
 
                 feo.generation = linked_inode->generation;
 
@@ -1780,12 +1475,34 @@ fuse_create_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
                 send_fuse_err (this, finh, op_errno);
         }
 out:
-        free_state (state);
+        free_fuse_state (state);
         STACK_DESTROY (frame->root);
 
         return 0;
 }
 
+void
+fuse_create_resume (fuse_state_t *state)
+{
+        fd_t *fd = NULL;
+
+        if (!state->loc.inode)
+                state->loc.inode = inode_new (state->loc.parent->table);
+        else
+                gf_log (state->this->name, GF_LOG_ERROR, "inode already present");
+
+        fd = fd_create (state->loc.inode, state->finh->pid);
+        state->fd = fd;
+        fd->flags = state->flags;
+
+        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, fd);
+
+}
 
 static void
 fuse_create (xlator_t *this, fuse_in_header_t *finh, void *msg)
@@ -1799,7 +1516,6 @@ fuse_create (xlator_t *this, fuse_in_header_t *finh, void *msg)
 
         fuse_private_t        *priv = NULL;
         fuse_state_t *state = NULL;
-        fd_t         *fd = NULL;
         int32_t       ret = -1;
 
         priv = this->private;
@@ -1809,7 +1525,6 @@ fuse_create (xlator_t *this, fuse_in_header_t *finh, void *msg)
 #endif
 
         GET_STATE (this, finh, state);
-        state->flags = fci->flags;
 
         ret = fuse_loc_fill (&state->loc, state, 0, finh->nodeid, name);
         if (ret < 0) {
@@ -1817,38 +1532,44 @@ fuse_create (xlator_t *this, fuse_in_header_t *finh, void *msg)
                         "%"PRIu64" CREATE %s (fuse_loc_fill() failed)",
                         finh->unique, state->loc.path);
                 send_fuse_err (this, finh, ENOENT);
-                free_state (state);
+                free_fuse_state (state);
                 return;
         }
 
-        state->loc.inode = inode_new (state->loc.parent->table);
+        state->mode = fci->mode;
+        state->flags = fci->flags;
+
+        fuse_resolve_and_resume (state, fuse_create_resume);
+
+        return;
+}
+
+void
+fuse_open_resume (fuse_state_t *state)
+{
+        fd_t *fd = NULL;
 
-        fd = fd_create (state->loc.inode, finh->pid);
+        fd = fd_create (state->loc.inode, state->finh->pid);
         state->fd = fd;
         fd->flags = state->flags;
 
         gf_log ("glusterfs-fuse", GF_LOG_TRACE,
-                "%"PRIu64": CREATE %s", finh->unique,
+                "%"PRIu64": OPEN %s", state->finh->unique,
                 state->loc.path);
 
-        FUSE_FOP (state, fuse_create_cbk, GF_FOP_CREATE,
-                  create, &state->loc, state->flags, fci->mode, fd);
-
-        return;
+        FUSE_FOP (state, fuse_fd_cbk, GF_FOP_OPEN,
+                  open, &state->loc, state->flags, fd, 0);
 }
 
-
 static void
 fuse_open (xlator_t *this, fuse_in_header_t *finh, void *msg)
 {
         struct fuse_open_in *foi = msg;
 
         fuse_state_t *state = NULL;
-        fd_t         *fd = NULL;
         int32_t       ret = -1;
 
         GET_STATE (this, finh, state);
-        state->flags = foi->flags;
 
         ret = fuse_loc_fill (&state->loc, state, finh->nodeid, 0, NULL);
         if ((state->loc.inode == NULL) ||
@@ -1858,20 +1579,12 @@ fuse_open (xlator_t *this, fuse_in_header_t *finh, void *msg)
                         finh->unique, state->loc.path);
 
                 send_fuse_err (this, finh, ENOENT);
-                free_state (state);
+                free_fuse_state (state);
                 return;
         }
 
-        fd = fd_create (state->loc.inode, finh->pid);
-        state->fd = fd;
-        fd->flags = foi->flags;
-
-        gf_log ("glusterfs-fuse", GF_LOG_TRACE,
-                "%"PRIu64": OPEN %s", finh->unique,
-                state->loc.path);
-
-        FUSE_FOP (state, fuse_fd_cbk, GF_FOP_OPEN,
-                  open, &state->loc, foi->flags, fd, 0);
+        state->flags = foi->flags;
+        fuse_resolve_and_resume (state, fuse_open_resume);
 
         return;
 }
@@ -1915,12 +1628,22 @@ fuse_readv_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
                 send_fuse_err (this, finh, op_errno);
         }
 
-        free_state (state);
+        free_fuse_state (state);
         STACK_DESTROY (frame->root);
 
         return 0;
 }
 
+void
+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);
+
+        FUSE_FOP (state, fuse_readv_cbk, GF_FOP_READ,
+                  readv, state->fd, state->size, state->off);
+}
 
 static void
 fuse_readv (xlator_t *this, fuse_in_header_t *finh, void *msg)
@@ -1933,8 +1656,6 @@ fuse_readv (xlator_t *this, fuse_in_header_t *finh, void *msg)
 
         GET_STATE (this, finh, state);
 
-        state->size = fri->size;
-        state->off = fri->offset;
 
         fd = FH_TO_FD (fri->fh);
         state->fd = fd;
@@ -1946,13 +1667,10 @@ fuse_readv (xlator_t *this, fuse_in_header_t *finh, void *msg)
                 state->lk_owner = fri->lock_owner;
 #endif
 
-        gf_log ("glusterfs-fuse", GF_LOG_TRACE,
-                "%"PRIu64": READ (%p, size=%"PRIu32", offset=%"PRIu64")",
-                finh->unique, fd, fri->size, fri->offset);
-
-        FUSE_FOP (state, fuse_readv_cbk, GF_FOP_READ,
-                  readv, fd, fri->size, fri->offset);
+        state->size = fri->size;
+        state->off = fri->offset;
 
+        fuse_resolve_and_resume (state, fuse_readv_resume);
 }
 
 
@@ -1984,12 +1702,43 @@ fuse_writev_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
                 send_fuse_err (this, finh, op_errno);
         }
 
-        free_state (state);
+        free_fuse_state (state);
         STACK_DESTROY (frame->root);
 
         return 0;
 }
 
+void
+fuse_write_resume (fuse_state_t *state)
+{
+        struct iobref *iobref = NULL;
+        struct iobuf  *iobuf = NULL;
+
+        if (!state->fd || !state->fd->inode) {
+                send_fuse_err (state->this, state->finh, EBADFD);
+                free_fuse_state (state);
+                return;
+        }
+
+        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;
+        }
+
+        iobuf = ((fuse_private_t *) (state->this->private))->iobuf;
+        iobref_add (iobref, iobuf);
+
+        FUSE_FOP (state, fuse_writev_cbk, GF_FOP_WRITE, writev, state->fd,
+                  &state->vector, 1, state->off, iobref);
+
+        iobref_unref (iobref);
+}
 
 static void
 fuse_write (xlator_t *this, fuse_in_header_t *finh, void *msg)
@@ -2002,20 +1751,15 @@ fuse_write (xlator_t *this, fuse_in_header_t *finh, void *msg)
 
         fuse_private_t  *priv = NULL;
         fuse_state_t    *state = NULL;
-        struct iovec     vector;
         fd_t            *fd = NULL;
-        struct iobref   *iobref = NULL;
-        struct iobuf    *iobuf = NULL;
 
         priv = this->private;
 
         GET_STATE (this, finh, state);
-        state->size = fwi->size;
-        state->off  = fwi->offset;
         fd          = FH_TO_FD (fwi->fh);
         state->fd   = fd;
-        vector.iov_base = msg;
-        vector.iov_len  = fwi->size;
+        state->size = fwi->size;
+        state->off  = fwi->offset;
 
         /* See comment by similar code in fuse_settatr */
         priv = this->private;
@@ -2028,25 +1772,20 @@ fuse_write (xlator_t *this, fuse_in_header_t *finh, void *msg)
                 "%"PRIu64": WRITE (%p, size=%"PRIu32", offset=%"PRId64")",
                 finh->unique, fd, fwi->size, fwi->offset);
 
-        iobref = iobref_new ();
-        if (!iobref) {
-                gf_log ("glusterfs-fuse", GF_LOG_ERROR,
-                        "%"PRIu64": WRITE iobref allocation failed",
-                        finh->unique);
-
-                free_state (state);
-                return;
-        }
-        iobuf = ((fuse_private_t *) (state->this->private))->iobuf;
-        iobref_add (iobref, iobuf);
+        state->vector.iov_base = msg;
+        state->vector.iov_len  = fwi->size;
 
-        FUSE_FOP (state, fuse_writev_cbk, GF_FOP_WRITE,
-                  writev, fd, &vector, 1, fwi->offset, iobref);
+        fuse_resolve_and_resume (state, fuse_write_resume);
 
-        iobref_unref (iobref);
         return;
 }
 
+void
+fuse_flush_resume (fuse_state_t *state)
+{
+        FUSE_FOP (state, fuse_err_cbk, GF_FOP_FLUSH,
+                  flush, state->fd);
+}
 
 static void
 fuse_flush (xlator_t *this, fuse_in_header_t *finh, void *msg)
@@ -2067,22 +1806,30 @@ fuse_flush (xlator_t *this, fuse_in_header_t *finh, void *msg)
         gf_log ("glusterfs-fuse", GF_LOG_TRACE,
                 "%"PRIu64": FLUSH %p", finh->unique, fd);
 
-        FUSE_FOP (state, fuse_err_cbk, GF_FOP_FLUSH,
-                  flush, fd);
+        fuse_resolve_and_resume (state, fuse_flush_resume);
 
         return;
 }
 
+static int
+fuse_release_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
+                  int32_t op_ret, int32_t op_errno)
+{
+        STACK_DESTROY (frame->root);
+
+        return 0;
+}
 
 static void
 fuse_release (xlator_t *this, fuse_in_header_t *finh, void *msg)
 {
-        struct fuse_release_in *fri = msg;
-
-        fd_t     *fd = NULL;
-        int do_flush = 0;
-
-        fuse_state_t *state = NULL;
+        struct fuse_release_in *fri        = msg;
+        fd_t                   *new_fd     = NULL;
+        fd_t                   *fd         = NULL;
+        int                     do_flush   = 0;
+        uint64_t                tmp_fd_ctx = 0;
+        int                     ret        = 0;
+        fuse_state_t           *state      = NULL;
 
         GET_STATE (this, finh, state);
         fd = FH_TO_FD (fri->fh);
@@ -2122,25 +1869,47 @@ fuse_release (xlator_t *this, fuse_in_header_t *finh, void *msg)
                 do_flush = 1;
 #endif
 
+        /* TODO */
         gf_log ("glusterfs-fuse", GF_LOG_TRACE,
                 "%"PRIu64": RELEASE %p%s", finh->unique, fd,
                 do_flush ? " (FLUSH implied)" : "");
 
         if (do_flush) {
                 state->lk_owner = (uint64_t)-1;
+                ret = fd_ctx_get (fd, this, &tmp_fd_ctx);
+                if (!ret) {
+                        new_fd = (fd_t *)(long)tmp_fd_ctx;
+                        FUSE_FOP (state, fuse_release_cbk, GF_FOP_FLUSH, flush,
+                                  new_fd);
+                        fd_unref (new_fd);
+                }
+
                 FUSE_FOP (state, fuse_err_cbk, GF_FOP_FLUSH, flush, fd);
+
                 fd_unref (fd);
         } else {
+                ret = fd_ctx_get (fd, this, &tmp_fd_ctx);
+                if (!ret) {
+                        new_fd = (fd_t *)(long)tmp_fd_ctx;
+                        fd_unref (new_fd);
+                }
                 fd_unref (fd);
 
                 send_fuse_err (this, finh, 0);
 
-                free_state (state);
+                free_fuse_state (state);
         }
 
         return;
 }
 
+void
+fuse_fsync_resume (fuse_state_t *state)
+{
+        /* fsync_flags: 1 means "datasync" (no defines for this) */
+        FUSE_FOP (state, fuse_fsync_cbk, GF_FOP_FSYNC,
+                  fsync, state->fd, state->flags & 1);
+}
 
 static void
 fuse_fsync (xlator_t *this, fuse_in_header_t *finh, void *msg)
@@ -2157,13 +1926,26 @@ fuse_fsync (xlator_t *this, fuse_in_header_t *finh, void *msg)
         gf_log ("glusterfs-fuse", GF_LOG_TRACE,
                 "%"PRIu64": FSYNC %p", finh->unique, fd);
 
-        /* fsync_flags: 1 means "datasync" (no defines for this) */
-        FUSE_FOP (state, fuse_fsync_cbk, GF_FOP_FSYNC,
-                  fsync, fd, fsi->fsync_flags & 1);
-
+        state->flags = fsi->fsync_flags;
+        fuse_resolve_and_resume (state, fuse_fsync_resume);
         return;
 }
 
+void
+fuse_opendir_resume (fuse_state_t *state)
+{
+        fd_t *fd = NULL;
+
+        fd = fd_create (state->loc.inode, state->finh->pid);
+        state->fd = fd;
+
+        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);
+}
 
 static void
 fuse_opendir (xlator_t *this, fuse_in_header_t *finh, void *msg)
@@ -2173,31 +1955,21 @@ fuse_opendir (xlator_t *this, fuse_in_header_t *finh, void *msg)
          */
 
         fuse_state_t *state = NULL;
-        fd_t         *fd = NULL;
         int32_t       ret = -1;
 
         GET_STATE (this, finh, state);
         ret = fuse_loc_fill (&state->loc, state, finh->nodeid, 0, NULL);
-        if ((state->loc.inode == NULL) ||
-            (ret < 0)) {
+        if ((state->loc.inode == NULL) || (ret < 0)) {
                 gf_log ("glusterfs-fuse", GF_LOG_WARNING,
                         "%"PRIu64": OPENDIR %s (fuse_loc_fill() failed)",
                         finh->unique, state->loc.path);
 
                 send_fuse_err (this, finh, ENOENT);
-                free_state (state);
+                free_fuse_state (state);
                 return;
         }
 
-        fd = fd_create (state->loc.inode, finh->pid);
-        state->fd = fd;
-
-        gf_log ("glusterfs-fuse", GF_LOG_TRACE,
-                "%"PRIu64": OPENDIR %s", finh->unique,
-                state->loc.path);
-
-        FUSE_FOP (state, fuse_fd_cbk, GF_FOP_OPENDIR,
-                  opendir, &state->loc, fd);
+        fuse_resolve_and_resume (state, fuse_opendir_resume);
 }
 
 
@@ -2289,7 +2061,7 @@ fuse_readdir_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
         send_fuse_data (this, finh, buf, size);
 
 out:
-        free_state (state);
+        free_fuse_state (state);
         STACK_DESTROY (frame->root);
         if (buf)
                 GF_FREE (buf);
@@ -2297,6 +2069,16 @@ out:
 
 }
 
+void
+fuse_readdir_resume (fuse_state_t *state)
+{
+        gf_log ("glusterfs-fuse", GF_LOG_TRACE,
+                "%"PRIu64": READDIR (%p, size=%zu, 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);
+}
 
 static void
 fuse_readdir (xlator_t *this, fuse_in_header_t *finh, void *msg)
@@ -2312,37 +2094,48 @@ fuse_readdir (xlator_t *this, fuse_in_header_t *finh, void *msg)
         fd = FH_TO_FD (fri->fh);
         state->fd = fd;
 
-        gf_log ("glusterfs-fuse", GF_LOG_TRACE,
-                "%"PRIu64": READDIR (%p, size=%"PRIu32", offset=%"PRId64")",
-                finh->unique, fd, fri->size, fri->offset);
-
-        FUSE_FOP (state, fuse_readdir_cbk, GF_FOP_READDIR,
-                  readdir, fd, fri->size, fri->offset);
+        fuse_resolve_and_resume (state, fuse_readdir_resume);
 }
 
 
 static void
 fuse_releasedir (xlator_t *this, fuse_in_header_t *finh, void *msg)
 {
-        struct fuse_release_in *fri = msg;
-
-        fuse_state_t *state = NULL;
+        struct fuse_release_in *fri        = msg;
+        fd_t                   *new_fd     = NULL;
+        uint64_t                tmp_fd_ctx = 0;
+        int                     ret        = 0;
+        fuse_state_t           *state      = NULL;
 
         GET_STATE (this, finh, state);
         state->fd = FH_TO_FD (fri->fh);
 
+        /* TODO: free 'new-fd' in the ctx */
         gf_log ("glusterfs-fuse", GF_LOG_TRACE,
                 "%"PRIu64": RELEASEDIR %p", finh->unique, state->fd);
 
+        ret = fd_ctx_get (state->fd, this, &tmp_fd_ctx);
+        if (!ret) {
+                new_fd = (fd_t *)(long)tmp_fd_ctx;
+                fd_unref (new_fd);
+        }
+
         fd_unref (state->fd);
 
         send_fuse_err (this, finh, 0);
 
-        free_state (state);
+        free_fuse_state (state);
 
         return;
 }
 
+void
+fuse_fsyncdir_resume (fuse_state_t *state)
+{
+        FUSE_FOP (state, fuse_err_cbk, GF_FOP_FSYNCDIR,
+                  fsyncdir, state->fd, state->flags & 1);
+
+}
 
 static void
 fuse_fsyncdir (xlator_t *this, fuse_in_header_t *finh, void *msg)
@@ -2357,8 +2150,8 @@ fuse_fsyncdir (xlator_t *this, fuse_in_header_t *finh, void *msg)
         GET_STATE (this, finh, state);
         state->fd = fd;
 
-        FUSE_FOP (state, fuse_err_cbk, GF_FOP_FSYNCDIR,
-                  fsyncdir, fd, fsi->fsync_flags & 1);
+        state->flags = fsi->fsync_flags;
+        fuse_resolve_and_resume (state, fuse_fsyncdir_resume);
 
         return;
 }
@@ -2423,13 +2216,12 @@ fuse_statfs_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
                 send_fuse_err (this, finh, op_errno);
         }
 
-        free_state (state);
+        free_fuse_state (state);
         STACK_DESTROY (frame->root);
 
         return 0;
 }
 
-
 static void
 fuse_statfs (xlator_t *this, fuse_in_header_t *finh, void *msg)
 {
@@ -2445,7 +2237,7 @@ fuse_statfs (xlator_t *this, fuse_in_header_t *finh, void *msg)
                         finh->unique);
 
                 send_fuse_err (this, finh, ENOENT);
-                free_state (state);
+                free_fuse_state (state);
                 return;
         }
 
@@ -2456,6 +2248,16 @@ fuse_statfs (xlator_t *this, fuse_in_header_t *finh, void *msg)
                   statfs, &state->loc);
 }
 
+void
+fuse_setxattr_resume (fuse_state_t *state)
+{
+        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->dict, state->flags);
+}
 
 static void
 fuse_setxattr (xlator_t *this, fuse_in_header_t *finh, void *msg)
@@ -2499,7 +2301,7 @@ fuse_setxattr (xlator_t *this, fuse_in_header_t *finh, void *msg)
                         state->loc.path, finh->nodeid, name);
 
                 send_fuse_err (this, finh, ENOENT);
-                free_state (state);
+                free_fuse_state (state);
                 return;
         }
 
@@ -2509,7 +2311,7 @@ fuse_setxattr (xlator_t *this, fuse_in_header_t *finh, void *msg)
                         "%"PRIu64": SETXATTR dict allocation failed",
                         finh->unique);
 
-                free_state (state);
+                free_fuse_state (state);
                 return;
         }
 
@@ -2518,12 +2320,10 @@ fuse_setxattr (xlator_t *this, fuse_in_header_t *finh, void *msg)
                   data_from_dynptr ((void *)dict_value, fsi->size));
         dict_ref (state->dict);
 
-        gf_log ("glusterfs-fuse", GF_LOG_TRACE,
-                "%"PRIu64": SETXATTR %s/%"PRIu64" (%s)", finh->unique,
-                state->loc.path, finh->nodeid, name);
+        state->flags = fsi->flags;
+        state->name = gf_strdup (name);
 
-        FUSE_FOP (state, fuse_setxattr_cbk, GF_FOP_SETXATTR,
-                  setxattr, &state->loc, state->dict, fsi->flags);
+        fuse_resolve_and_resume (state, fuse_setxattr_resume);
 
         return;
 }
@@ -2638,12 +2438,22 @@ out:
         if (need_to_free_dict)
                 dict_unref (dict);
 
-        free_state (state);
+        free_fuse_state (state);
         STACK_DESTROY (frame->root);
 
         return 0;
 }
 
+void
+fuse_getxattr_resume (fuse_state_t *state)
+{
+        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);
+}
 
 static void
 fuse_getxattr (xlator_t *this, fuse_in_header_t *finh, void *msg)
@@ -2683,8 +2493,6 @@ fuse_getxattr (xlator_t *this, fuse_in_header_t *finh, void *msg)
 #endif
 
         GET_STATE (this, finh, state);
-        state->size = fgxi->size;
-        state->name = gf_strdup (name);
 
         ret = fuse_loc_fill (&state->loc, state, finh->nodeid, 0, NULL);
         if ((state->loc.inode == NULL) ||
@@ -2694,20 +2502,27 @@ fuse_getxattr (xlator_t *this, fuse_in_header_t *finh, void *msg)
                         finh->unique, state->loc.path, finh->nodeid, name);
 
                 send_fuse_err (this, finh, ENOENT);
-                free_state (state);
+                free_fuse_state (state);
                 return;
         }
 
-        gf_log ("glusterfs-fuse", GF_LOG_TRACE,
-                "%"PRIu64": GETXATTR %s/%"PRIu64" (%s)", finh->unique,
-                state->loc.path, finh->nodeid, name);
-
-        FUSE_FOP (state, fuse_xattr_cbk, GF_FOP_GETXATTR,
-                  getxattr, &state->loc, name);
+        state->size = fgxi->size;
+        state->name = gf_strdup (name);
 
+        fuse_resolve_and_resume (state, fuse_getxattr_resume);
         return;
 }
 
+void
+fuse_listxattr_resume (fuse_state_t *state)
+{
+        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);
+}
 
 static void
 fuse_listxattr (xlator_t *this, fuse_in_header_t *finh, void *msg)
@@ -2718,7 +2533,7 @@ fuse_listxattr (xlator_t *this, fuse_in_header_t *finh, void *msg)
         int32_t       ret = -1;
 
         GET_STATE (this, finh, state);
-        state->size = fgxi->size;
+
         ret = fuse_loc_fill (&state->loc, state, finh->nodeid, 0, NULL);
         if ((state->loc.inode == NULL) ||
             (ret < 0)) {
@@ -2727,20 +2542,26 @@ fuse_listxattr (xlator_t *this, fuse_in_header_t *finh, void *msg)
                         finh->unique, state->loc.path, finh->nodeid);
 
                 send_fuse_err (this, finh, ENOENT);
-                free_state (state);
+                free_fuse_state (state);
                 return;
         }
 
-        gf_log ("glusterfs-fuse", GF_LOG_TRACE,
-                "%"PRIu64": LISTXATTR %s/%"PRIu64, finh->unique,
-                state->loc.path, finh->nodeid);
-
-        FUSE_FOP (state, fuse_xattr_cbk, GF_FOP_GETXATTR,
-                  getxattr, &state->loc, NULL);
+        state->size = fgxi->size;
+        fuse_resolve_and_resume (state, fuse_listxattr_resume);
 
         return;
 }
 
+void
+fuse_removexattr_resume (fuse_state_t *state)
+{
+        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_err_cbk, GF_FOP_REMOVEXATTR,
+                  removexattr, &state->loc, state->name);
+}
 
 static void
 fuse_removexattr (xlator_t *this, fuse_in_header_t *finh, void *msg)
@@ -2760,17 +2581,12 @@ fuse_removexattr (xlator_t *this, fuse_in_header_t *finh, void *msg)
                         finh->unique, state->loc.path, finh->nodeid, name);
 
                 send_fuse_err (this, finh, ENOENT);
-                free_state (state);
+                free_fuse_state (state);
                 return;
         }
 
-        gf_log ("glusterfs-fuse", GF_LOG_TRACE,
-                "%"PRIu64": REMOVEXATTR %s/%"PRIu64" (%s)", finh->unique,
-                state->loc.path, finh->nodeid, name);
-
-        FUSE_FOP (state, fuse_err_cbk, GF_FOP_REMOVEXATTR,
-                  removexattr, &state->loc, name);
-
+        state->name = gf_strdup (name);
+        fuse_resolve_and_resume (state, fuse_removexattr_resume);
         return;
 }
 
@@ -2817,12 +2633,21 @@ fuse_getlk_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
                 send_fuse_err (this, state->finh, op_errno);
         }
 
-        free_state (state);
+        free_fuse_state (state);
         STACK_DESTROY (frame->root);
 
         return 0;
 }
 
+void
+fuse_getlk_resume (fuse_state_t *state)
+{
+        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);
+}
 
 static void
 fuse_getlk (xlator_t *this, fuse_in_header_t *finh, void *msg)
@@ -2831,20 +2656,15 @@ fuse_getlk (xlator_t *this, fuse_in_header_t *finh, void *msg)
 
         fuse_state_t *state = NULL;
         fd_t         *fd = NULL;
-        struct flock  lock = {0, };
 
         fd = FH_TO_FD (fli->fh);
         GET_STATE (this, finh, state);
         state->fd = fd;
-        convert_fuse_file_lock (&fli->lk, &lock);
+        convert_fuse_file_lock (&fli->lk, &state->lk_lock);
 
         state->lk_owner = fli->owner;
 
-        gf_log ("glusterfs-fuse", GF_LOG_TRACE,
-                "%"PRIu64": GETLK %p", finh->unique, fd);
-
-        FUSE_FOP (state, fuse_getlk_cbk, GF_FOP_LK,
-                  lk, fd, F_GETLK, &lock);
+        fuse_resolve_and_resume (state, fuse_getlk_resume);
 
         return;
 }
@@ -2889,13 +2709,25 @@ fuse_setlk_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
                 send_fuse_err (this, state->finh, op_errno);
         }
 
-        free_state (state);
+        free_fuse_state (state);
         STACK_DESTROY (frame->root);
 
         return 0;
 }
 
 
+void
+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);
+
+        FUSE_FOP (state, fuse_setlk_cbk, GF_FOP_LK, lk, state->fd,
+                  state->finh->opcode == FUSE_SETLK ? F_SETLK : F_SETLKW,
+                  &state->lk_lock);
+}
+
 static void
 fuse_setlk (xlator_t *this, fuse_in_header_t *finh, void *msg)
 {
@@ -2903,23 +2735,16 @@ fuse_setlk (xlator_t *this, fuse_in_header_t *finh, void *msg)
 
         fuse_state_t *state = NULL;
         fd_t         *fd = NULL;
-        struct flock  lock = {0, };
 
         fd = FH_TO_FD (fli->fh);
         GET_STATE (this, finh, state);
         state->finh = finh;
         state->fd = fd;
-        convert_fuse_file_lock (&fli->lk, &lock);
+        convert_fuse_file_lock (&fli->lk, &state->lk_lock);
 
         state->lk_owner = fli->owner;
 
-        gf_log ("glusterfs-fuse", GF_LOG_TRACE,
-                "%"PRIu64": SETLK%s %p", finh->unique,
-                finh->opcode == FUSE_SETLK ? "" : "W", fd);
-
-        FUSE_FOP (state, fuse_setlk_cbk, GF_FOP_LK,
-                  lk, fd, finh->opcode == FUSE_SETLK ? F_SETLK : F_SETLKW,
-                  &lock);
+        fuse_resolve_and_resume (state, fuse_setlk_resume);
 
         return;
 }
@@ -3142,8 +2967,9 @@ fuse_graph_sync (xlator_t *this)
 unlock:
         pthread_mutex_unlock (&priv->sync_mutex);
 
-        if (need_first_lookup)
+        if (need_first_lookup) {
                 fuse_first_lookup (this);
+        }
 
         return 0;
 }