protocol: make on-wire-change of protocol using new XDR definition.

With this patchset, some major things are changed in XDR, mainly:

* Naming: Instead of gfs3/gfs4 settle for gfx_ for xdr structures
* add iattx as a separate structure, and add conversion methods
* the *_rsp structure is now changed, and is also reduced in number
  (ie, no need for different strucutes if it is similar to other response).
* use proper XDR methods for sending dict on wire.

Also, with the change of xdr structure, there are changes needed
outside of xlator protocol layer to handle these properly. Mainly
because the abstraction was broken to support 0-copy RDMA with payload
for write and read FOP. This made transport layer know about the xdr
payload, hence with the change of xdr payload structure, transport layer
needed to know about the change.

Updates #384

Change-Id: I1448fbe9deab0a1b06cb8351f2f37488cefe461f
Signed-off-by: Amar Tumballi <amarts@redhat.com>

8 files changed, 8598 insertions, 346 deletions

diff --git a/xlators/protocol/server/src/Makefile.am b/xlators/protocol/server/src/Makefile.am
index 72f811e97fb..9c273cae222 100644
--- a/xlators/protocol/server/src/Makefile.am
+++ b/xlators/protocol/server/src/Makefile.am
@@ -8,7 +8,8 @@ server_la_LIBADD = $(top_builddir)/libglusterfs/src/libglusterfs.la \
 	$(top_builddir)/rpc/xdr/src/libgfxdr.la
 
 server_la_SOURCES = server.c server-resolve.c server-helpers.c  \
-	server-rpc-fops.c server-handshake.c authenticate.c server-common.c
+	server-rpc-fops.c server-handshake.c authenticate.c  \
+	server-common.c server-rpc-fops_v2.c
 
 server_la_HEADERS = server.h server-helpers.h server-mem-types.h \
 	authenticate.h server-messages.h server-common.h
diff --git a/xlators/protocol/server/src/server-common.c b/xlators/protocol/server/src/server-common.c
index 9c38706dbcb..17660ef475e 100644
--- a/xlators/protocol/server/src/server-common.c
+++ b/xlators/protocol/server/src/server-common.c
@@ -5,6 +5,7 @@
 #include "glusterfs3.h"
 #include "compat-errno.h"
 #include "server-messages.h"
+#include "server-helpers.h"
 #include "defaults.h"
 #include "fd.h"
 #include "xdr-nfs3.h"
@@ -229,9 +230,9 @@ server_post_lk (xlator_t *this, gfs3_lk_rsp *rsp, struct gf_flock *lock)
 int
 server_post_readdir (gfs3_readdir_rsp *rsp, gf_dirent_t *entries)
 {
-                int     ret = 0;
+        int     ret = 0;
 
-                ret = serialize_rsp_dirent (entries, rsp);
+        ret = serialize_rsp_dirent (entries, rsp);
 
         return ret;
 }
@@ -268,9 +269,9 @@ server_post_seek (gfs3_seek_rsp *rsp, off_t offset)
 int
 server_post_readdirp (gfs3_readdirp_rsp *rsp, gf_dirent_t *entries)
 {
-                int     ret = 0;
+        int     ret = 0;
 
-                ret = serialize_rsp_direntp (entries, rsp);
+        ret = serialize_rsp_direntp (entries, rsp);
 
         return ret;
 }
@@ -512,3 +513,368 @@ server_post_lease (gfs3_lease_rsp *rsp, struct gf_lease *lease)
 {
         gf_proto_lease_from_lease (&rsp->lease, lease);
 }
+
+
+/* Version 4 helpers */
+
+void
+server4_post_readlink (gfx_readlink_rsp *rsp, struct iatt *stbuf,
+                      const char *buf)
+{
+        gfx_stat_from_iattx (&rsp->buf, stbuf);
+        rsp->path = (char *)buf;
+}
+
+void
+server4_post_common_3iatt (server_state_t *state, gfx_common_3iatt_rsp *rsp,
+                           inode_t *inode, struct iatt *stbuf,
+                           struct iatt *preparent, struct iatt *postparent)
+{
+        inode_t             *link_inode = NULL;
+
+        gfx_stat_from_iattx (&rsp->stat, stbuf);
+        if (state->client->subdir_mount &&
+            !gf_uuid_compare (preparent->ia_gfid,
+                              state->client->subdir_gfid)) {
+                /* This is very important as when we send iatt of
+                   root-inode, fuse/client expect the gfid to be 1,
+                   along with inode number. As for subdirectory mount,
+                   we use inode table which is shared by everyone, but
+                   make sure we send fops only from subdir and below,
+                   we have to alter inode gfid and send it to client */
+                uuid_t gfid = {0,};
+
+                gfid[15] = 1;
+                preparent->ia_ino = 1;
+                postparent->ia_ino = 1;
+                gf_uuid_copy (preparent->ia_gfid, gfid);
+                gf_uuid_copy (postparent->ia_gfid, gfid);
+        }
+
+        gfx_stat_from_iattx (&rsp->preparent, preparent);
+        gfx_stat_from_iattx (&rsp->postparent, postparent);
+
+        link_inode = inode_link (inode, state->loc.parent,
+                                 state->loc.name, stbuf);
+        inode_lookup (link_inode);
+        inode_unref  (link_inode);
+}
+
+void
+server4_post_common_2iatt (gfx_common_2iatt_rsp *rsp, struct iatt *prebuf,
+                           struct iatt *postbuf)
+{
+        gfx_stat_from_iattx (&rsp->prestat, prebuf);
+        gfx_stat_from_iattx (&rsp->poststat, postbuf);
+}
+
+void
+server4_post_entry_remove (server_state_t *state, gfx_common_2iatt_rsp *rsp,
+                           struct iatt *prebuf, struct iatt *postbuf)
+{
+        inode_unlink (state->loc.inode, state->loc.parent,
+                      state->loc.name);
+        /* parent should not be found for directories after
+         * inode_unlink, since directories cannot have
+         * hardlinks.
+         */
+        forget_inode_if_no_dentry (state->loc.inode);
+
+        gfx_stat_from_iattx (&rsp->prestat, prebuf);
+        gfx_stat_from_iattx (&rsp->poststat, postbuf);
+}
+
+
+void
+server4_post_statfs (gfx_statfs_rsp *rsp, struct statvfs *stbuf)
+{
+        gf_statfs_from_statfs (&rsp->statfs, stbuf);
+}
+
+void
+server4_post_common_iatt (server_state_t *state, gfx_common_iatt_rsp *rsp,
+                          struct iatt *stbuf)
+{
+        if (state->client->subdir_mount &&
+            !gf_uuid_compare (stbuf->ia_gfid,
+                              state->client->subdir_gfid)) {
+                /* This is very important as when we send iatt of
+                   root-inode, fuse/client expect the gfid to be 1,
+                   along with inode number. As for subdirectory mount,
+                   we use inode table which is shared by everyone, but
+                   make sure we send fops only from subdir and below,
+                   we have to alter inode gfid and send it to client */
+                uuid_t gfid = {0,};
+
+                gfid[15] = 1;
+                stbuf->ia_ino = 1;
+                gf_uuid_copy (stbuf->ia_gfid, gfid);
+        }
+
+        gfx_stat_from_iattx (&rsp->stat, stbuf);
+}
+
+void
+server4_post_lk (xlator_t *this, gfx_lk_rsp *rsp, struct gf_flock *lock)
+{
+        switch (lock->l_type) {
+        case F_RDLCK:
+                lock->l_type = GF_LK_F_RDLCK;
+                break;
+        case F_WRLCK:
+                lock->l_type = GF_LK_F_WRLCK;
+                break;
+        case F_UNLCK:
+                lock->l_type = GF_LK_F_UNLCK;
+                break;
+        default:
+                gf_msg (this->name, GF_LOG_ERROR, 0, PS_MSG_LOCK_ERROR,
+                        "Unknown lock type: %"PRId32"!", lock->l_type);
+                break;
+        }
+
+        gf_proto_flock_from_flock (&rsp->flock, lock);
+}
+
+int
+server4_post_readdir (gfx_readdir_rsp *rsp, gf_dirent_t *entries)
+{
+        int     ret = 0;
+
+        ret = serialize_rsp_dirent_v2 (entries, rsp);
+
+        return ret;
+}
+
+void
+server4_post_seek (gfx_seek_rsp *rsp, off_t offset)
+{
+        rsp->offset = offset;
+}
+
+int
+server4_post_readdirp (gfx_readdirp_rsp *rsp, gf_dirent_t *entries)
+{
+        int     ret = 0;
+
+        ret = serialize_rsp_direntp_v2 (entries, rsp);
+
+        return ret;
+}
+
+void
+server4_post_rchecksum (gfx_rchecksum_rsp *rsp, uint32_t weak_checksum,
+                       uint8_t *strong_checksum)
+{
+        rsp->weak_checksum = weak_checksum;
+
+        rsp->strong_checksum.strong_checksum_val = (char *)strong_checksum;
+        rsp->strong_checksum.strong_checksum_len = SHA256_DIGEST_LENGTH;
+
+}
+
+void
+server4_post_rename (call_frame_t *frame,
+                    server_state_t *state, gfx_rename_rsp *rsp,
+                    struct iatt *stbuf,
+                    struct iatt *preoldparent,
+                    struct iatt *postoldparent,
+                    struct iatt *prenewparent,
+                    struct iatt *postnewparent)
+{
+        inode_t             *tmp_inode  = NULL;
+
+        stbuf->ia_type = state->loc.inode->ia_type;
+
+        /* TODO: log gfid of the inodes */
+        gf_msg_trace (frame->root->client->bound_xl->name, 0, "%"PRId64": "
+                      "RENAME_CBK %s ==> %s", frame->root->unique,
+                      state->loc.name, state->loc2.name);
+
+        /* Before renaming the inode, we have to get the inode for the
+         * destination entry (i.e. inode with state->loc2.parent as
+         * parent and state->loc2.name as name). If it exists, then
+         * unlink that inode, and send forget on that inode if the
+         * unlinked entry is the last entry. In case of fuse client
+         * the fuse kernel module itself sends the forget on the
+         * unlinked inode.
+         */
+        tmp_inode = inode_grep (state->loc.inode->table,
+                                state->loc2.parent, state->loc2.name);
+        if (tmp_inode) {
+                inode_unlink (tmp_inode, state->loc2.parent,
+                              state->loc2.name);
+                forget_inode_if_no_dentry (tmp_inode);
+                inode_unref (tmp_inode);
+        }
+
+        inode_rename (state->itable,
+                      state->loc.parent, state->loc.name,
+                      state->loc2.parent, state->loc2.name,
+                      state->loc.inode, stbuf);
+        gfx_stat_from_iattx (&rsp->stat, stbuf);
+
+        gfx_stat_from_iattx (&rsp->preoldparent, preoldparent);
+        gfx_stat_from_iattx (&rsp->postoldparent, postoldparent);
+
+        gfx_stat_from_iattx (&rsp->prenewparent, prenewparent);
+        gfx_stat_from_iattx (&rsp->postnewparent, postnewparent);
+
+}
+
+int
+server4_post_open (call_frame_t *frame, xlator_t *this,
+                  gfx_open_rsp *rsp, fd_t *fd)
+{
+        server_ctx_t        *serv_ctx = NULL;
+        uint64_t             fd_no    = 0;
+
+        serv_ctx = server_ctx_get (frame->root->client, this);
+        if (serv_ctx == NULL) {
+                gf_msg (this->name, GF_LOG_INFO, 0,
+                        PS_MSG_SERVER_CTX_GET_FAILED, "server_ctx_get() "
+                        "failed");
+                return -1;
+        }
+
+        fd_bind (fd);
+        fd_ref (fd);
+        fd_no = gf_fd_unused_get (serv_ctx->fdtable, fd);
+        rsp->fd = fd_no;
+
+        return 0;
+}
+
+void
+server4_post_readv (gfx_read_rsp *rsp, struct iatt *stbuf, int op_ret)
+{
+        gfx_stat_from_iattx (&rsp->stat, stbuf);
+        rsp->size = op_ret;
+}
+
+int
+server4_post_create (call_frame_t *frame, gfx_create_rsp *rsp,
+                    server_state_t *state,
+                    xlator_t *this, fd_t *fd, inode_t *inode,
+                    struct iatt *stbuf, struct iatt *preparent,
+                    struct iatt *postparent)
+{
+        server_ctx_t        *serv_ctx   = NULL;
+        inode_t             *link_inode = NULL;
+        uint64_t             fd_no      = 0;
+        int                  op_errno   = 0;
+
+        link_inode = inode_link (inode, state->loc.parent,
+                                 state->loc.name, stbuf);
+
+        if (!link_inode) {
+                op_errno = ENOENT;
+                goto out;
+        }
+
+        if (link_inode != inode) {
+                /*
+                  VERY racy code (if used anywhere else)
+                  -- don't do this without understanding
+                */
+
+                inode_ctx_merge (fd, fd->inode, link_inode);
+                inode_unref (fd->inode);
+                fd->inode = inode_ref (link_inode);
+        }
+
+        inode_lookup (link_inode);
+        inode_unref (link_inode);
+
+        serv_ctx = server_ctx_get (frame->root->client, this);
+        if (serv_ctx == NULL) {
+                gf_msg (this->name, GF_LOG_INFO, 0,
+                        PS_MSG_SERVER_CTX_GET_FAILED, "server_ctx_get() "
+                        "failed");
+                goto out;
+        }
+
+        fd_bind (fd);
+        fd_ref (fd);
+        fd_no = gf_fd_unused_get (serv_ctx->fdtable, fd);
+
+        if ((fd_no > UINT64_MAX) || (fd == 0)) {
+                op_errno = errno;
+        }
+
+        rsp->fd = fd_no;
+        gfx_stat_from_iattx (&rsp->stat, stbuf);
+        gfx_stat_from_iattx (&rsp->preparent, preparent);
+        gfx_stat_from_iattx (&rsp->postparent, postparent);
+
+        return 0;
+out:
+        return -op_errno;
+}
+
+/*TODO: Handle revalidate path */
+void
+server4_post_lookup (gfx_common_2iatt_rsp *rsp, call_frame_t *frame,
+                     server_state_t *state,
+                     inode_t *inode, struct iatt *stbuf)
+{
+        inode_t             *root_inode = NULL;
+        inode_t             *link_inode = NULL;
+        uuid_t               rootgfid   = {0,};
+
+        root_inode = frame->root->client->bound_xl->itable->root;
+
+        if (!__is_root_gfid (inode->gfid)) {
+                link_inode = inode_link (inode, state->loc.parent,
+                                         state->loc.name, stbuf);
+                if (link_inode) {
+                        inode_lookup (link_inode);
+                        inode_unref (link_inode);
+                }
+        }
+
+        if ((inode == root_inode) ||
+            (state->client->subdir_mount &&
+             (inode == state->client->subdir_inode))) {
+                /* we just looked up root ("/") OR
+                   subdir mount directory, which is root ('/') in client */
+                /* This is very important as when we send iatt of
+                   root-inode, fuse/client expect the gfid to be 1,
+                   along with inode number. As for subdirectory mount,
+                   we use inode table which is shared by everyone, but
+                   make sure we send fops only from subdir and below,
+                   we have to alter inode gfid and send it to client */
+                stbuf->ia_ino = 1;
+                rootgfid[15]  = 1;
+                gf_uuid_copy (stbuf->ia_gfid, rootgfid);
+                if (inode->ia_type == 0)
+                        inode->ia_type = stbuf->ia_type;
+        }
+
+        gfx_stat_from_iattx (&rsp->prestat, stbuf);
+}
+
+void
+server4_post_lease (gfx_lease_rsp *rsp, struct gf_lease *lease)
+{
+        gf_proto_lease_from_lease (&rsp->lease, lease);
+}
+
+void
+server4_post_link (server_state_t *state, gfx_common_3iatt_rsp *rsp,
+                   inode_t *inode,
+                   struct iatt *stbuf, struct iatt *preparent,
+                   struct iatt *postparent, dict_t *xdata)
+{
+        inode_t             *link_inode = NULL;
+
+        gfx_stat_from_iattx (&rsp->stat, stbuf);
+        gfx_stat_from_iattx (&rsp->preparent, preparent);
+        gfx_stat_from_iattx (&rsp->postparent, postparent);
+
+        link_inode = inode_link (inode, state->loc2.parent,
+                                 state->loc2.name, stbuf);
+        inode_lookup (link_inode);
+        inode_unref (link_inode);
+
+}
diff --git a/xlators/protocol/server/src/server-common.h b/xlators/protocol/server/src/server-common.h
index 3fa972e68db..e272235a192 100644
--- a/xlators/protocol/server/src/server-common.h
+++ b/xlators/protocol/server/src/server-common.h
@@ -135,3 +135,74 @@ server_post_lookup (gfs3_lookup_rsp *rsp, call_frame_t *frame,
 
 void
 server_post_lease (gfs3_lease_rsp *rsp, struct gf_lease *lease);
+
+void
+server4_post_readlink (gfx_readlink_rsp *rsp, struct iatt *stbuf,
+                      const char *buf);
+
+void
+server4_post_statfs (gfx_statfs_rsp *rsp, struct statvfs *stbuf);
+
+void
+server4_post_lk (xlator_t *this, gfx_lk_rsp *rsp, struct gf_flock *lock);
+
+int
+server4_post_readdir (gfx_readdir_rsp *rsp, gf_dirent_t *entries);
+
+void
+server4_post_seek (gfx_seek_rsp *rsp, off_t offset);
+
+int
+server4_post_readdirp (gfx_readdirp_rsp *rsp, gf_dirent_t *entries);
+
+void
+server4_post_rchecksum (gfx_rchecksum_rsp *rsp, uint32_t weak_checksum,
+                       uint8_t *strong_checksum);
+
+void
+server4_post_rename (call_frame_t *frame, server_state_t *state,
+                    gfx_rename_rsp *rsp,
+                    struct iatt *stbuf,
+                    struct iatt *preoldparent,
+                    struct iatt *postoldparent,
+                    struct iatt *prenewparent,
+                    struct iatt *postnewparent);
+
+int
+server4_post_open (call_frame_t *frame, xlator_t *this,
+                  gfx_open_rsp *rsp, fd_t *fd);
+void
+server4_post_readv (gfx_read_rsp *rsp, struct iatt *stbuf, int op_ret);
+
+int
+server4_post_create (call_frame_t *frame, gfx_create_rsp *rsp,
+                    server_state_t *state,
+                    xlator_t *this, fd_t *fd, inode_t *inode,
+                    struct iatt *stbuf, struct iatt *preparent,
+                    struct iatt *postparent);
+
+void
+server4_post_common_2iatt (gfx_common_2iatt_rsp *rsp,
+                           struct iatt *stbuf1, struct iatt *stbuf2);
+
+void
+server4_post_entry_remove (server_state_t *state, gfx_common_2iatt_rsp *rsp,
+                           struct iatt *stbuf1, struct iatt *stbuf2);
+
+void
+server4_post_common_3iatt (server_state_t *state, gfx_common_3iatt_rsp *rsp,
+                           inode_t *inode, struct iatt *stbuf, struct iatt *pre,
+                           struct iatt *post);
+void
+server4_post_common_iatt (server_state_t *state, gfx_common_iatt_rsp *rsp,
+                          struct iatt *stbuf);
+void
+server4_post_lease (gfx_lease_rsp *rsp, struct gf_lease *lease);
+void
+server4_post_lookup (gfx_common_2iatt_rsp *rsp, call_frame_t *frame,
+                     server_state_t *state,
+                     inode_t *inode, struct iatt *stbuf);
+void
+server4_post_link (server_state_t *state, gfx_common_3iatt_rsp *rsp,
+                   inode_t *inode, struct iatt *stbuf, struct iatt *pre,
+                   struct iatt *post);
diff --git a/xlators/protocol/server/src/server-helpers.c b/xlators/protocol/server/src/server-helpers.c
index 1f9e9e8acb2..7a58d2592ba 100644
--- a/xlators/protocol/server/src/server-helpers.c
+++ b/xlators/protocol/server/src/server-helpers.c
@@ -925,6 +925,48 @@ out:
 
 
 int
+serialize_rsp_direntp_v2 (gf_dirent_t *entries, gfx_readdirp_rsp *rsp)
+{
+        gf_dirent_t        *entry = NULL;
+        gfx_dirplist       *trav  = NULL;
+        gfx_dirplist       *prev  = NULL;
+        int                 ret   = -1;
+
+        GF_VALIDATE_OR_GOTO ("server", entries, out);
+        GF_VALIDATE_OR_GOTO ("server", rsp, out);
+
+        list_for_each_entry (entry, &entries->list, list) {
+                trav = GF_CALLOC (1, sizeof (*trav), gf_server_mt_dirent_rsp_t);
+                if (!trav)
+                        goto out;
+
+                trav->d_ino  = entry->d_ino;
+                trav->d_off  = entry->d_off;
+                trav->d_len  = entry->d_len;
+                trav->d_type = entry->d_type;
+                trav->name   = entry->d_name;
+
+                gfx_stat_from_iattx (&trav->stat, &entry->d_stat);
+                dict_to_xdr (entry->dict, &trav->dict);
+
+                if (prev)
+                        prev->nextentry = trav;
+                else
+                        rsp->reply = trav;
+
+                prev = trav;
+                trav = NULL;
+        }
+
+        ret = 0;
+out:
+        GF_FREE (trav);
+
+        return ret;
+}
+
+
+int
 serialize_rsp_dirent (gf_dirent_t *entries, gfs3_readdir_rsp *rsp)
 {
         gf_dirent_t   *entry = NULL;
@@ -932,8 +974,41 @@ serialize_rsp_dirent (gf_dirent_t *entries, gfs3_readdir_rsp *rsp)
         gfs3_dirlist  *prev  = NULL;
         int           ret    = -1;
 
+        GF_VALIDATE_OR_GOTO ("server", rsp, out);
         GF_VALIDATE_OR_GOTO ("server", entries, out);
+
+        list_for_each_entry (entry, &entries->list, list) {
+                trav = GF_CALLOC (1, sizeof (*trav), gf_server_mt_dirent_rsp_t);
+                if (!trav)
+                        goto out;
+                trav->d_ino  = entry->d_ino;
+                trav->d_off  = entry->d_off;
+                trav->d_len  = entry->d_len;
+                trav->d_type = entry->d_type;
+                trav->name   = entry->d_name;
+                if (prev)
+                        prev->nextentry = trav;
+                else
+                        rsp->reply = trav;
+
+                prev = trav;
+        }
+
+        ret = 0;
+out:
+        return ret;
+}
+
+int
+serialize_rsp_dirent_v2 (gf_dirent_t *entries, gfx_readdir_rsp *rsp)
+{
+        gf_dirent_t  *entry = NULL;
+        gfx_dirlist  *trav  = NULL;
+        gfx_dirlist  *prev  = NULL;
+        int           ret    = -1;
+
         GF_VALIDATE_OR_GOTO ("server", rsp, out);
+        GF_VALIDATE_OR_GOTO ("server", entries, out);
 
         list_for_each_entry (entry, &entries->list, list) {
                 trav = GF_CALLOC (1, sizeof (*trav), gf_server_mt_dirent_rsp_t);
@@ -958,6 +1033,7 @@ out:
 }
 
 
+
 int
 readdir_rsp_cleanup (gfs3_readdir_rsp *rsp)
 {
@@ -995,16 +1071,51 @@ readdirp_rsp_cleanup (gfs3_readdirp_rsp *rsp)
 }
 
 int
-serialize_rsp_locklist (lock_migration_info_t *locklist,
-                               gfs3_getactivelk_rsp *rsp)
+readdir_rsp_cleanup_v2 (gfx_readdir_rsp *rsp)
+{
+        gfx_dirlist  *prev = NULL;
+        gfx_dirlist  *trav = NULL;
+
+        trav = rsp->reply;
+        prev = trav;
+        while (trav) {
+                trav = trav->nextentry;
+                GF_FREE (prev);
+                prev = trav;
+        }
+
+        return 0;
+}
+
+
+int
+readdirp_rsp_cleanup_v2 (gfx_readdirp_rsp *rsp)
 {
+        gfx_dirplist *prev = NULL;
+        gfx_dirplist *trav = NULL;
+
+        trav = rsp->reply;
+        prev = trav;
+        while (trav) {
+                trav = trav->nextentry;
+                GF_FREE (prev->dict.pairs.pairs_val);
+                GF_FREE (prev);
+                prev = trav;
+        }
+
+        return 0;
+}
+
+
+static int
+common_rsp_locklist (lock_migration_info_t *locklist,
+                     gfs3_locklist **reply) {
         lock_migration_info_t   *tmp    = NULL;
         gfs3_locklist           *trav   = NULL;
         gfs3_locklist           *prev   = NULL;
         int                     ret     = -1;
 
         GF_VALIDATE_OR_GOTO ("server", locklist, out);
-        GF_VALIDATE_OR_GOTO ("server", rsp, out);
 
         list_for_each_entry (tmp, &locklist->list, list) {
                 trav = GF_CALLOC (1, sizeof (*trav), gf_server_mt_lock_mig_t);
@@ -1038,7 +1149,7 @@ serialize_rsp_locklist (lock_migration_info_t *locklist,
                 if (prev)
                         prev->nextentry = trav;
                 else
-                        rsp->reply = trav;
+                        *reply = trav;
 
                 prev = trav;
                 trav = NULL;
@@ -1051,6 +1162,30 @@ out:
 }
 
 int
+serialize_rsp_locklist (lock_migration_info_t *locklist,
+                        gfs3_getactivelk_rsp *rsp)
+{
+        int ret = 0;
+
+        GF_VALIDATE_OR_GOTO ("server", rsp, out);
+        ret = common_rsp_locklist (locklist, &rsp->reply);
+out:
+        return ret;
+}
+int
+serialize_rsp_locklist_v2 (lock_migration_info_t *locklist,
+                           gfx_getactivelk_rsp *rsp)
+{
+        int ret = 0;
+
+        GF_VALIDATE_OR_GOTO ("server", rsp, out);
+        ret = common_rsp_locklist (locklist, &rsp->reply);
+out:
+        return ret;
+}
+
+
+int
 getactivelkinfo_rsp_cleanup (gfs3_getactivelk_rsp  *rsp)
 {
         gfs3_locklist  *prev = NULL;
@@ -1067,6 +1202,23 @@ getactivelkinfo_rsp_cleanup (gfs3_getactivelk_rsp  *rsp)
 
         return 0;
 }
+int
+getactivelkinfo_rsp_cleanup_v2 (gfx_getactivelk_rsp  *rsp)
+{
+        gfs3_locklist  *prev = NULL;
+        gfs3_locklist  *trav = NULL;
+
+        trav = rsp->reply;
+        prev = trav;
+
+        while (trav) {
+                trav = trav->nextentry;
+                GF_FREE (prev);
+                prev = trav;
+        }
+
+        return 0;
+}
 
 int
 gf_server_check_getxattr_cmd (call_frame_t *frame, const char *key)
@@ -1360,6 +1512,43 @@ out:
 }
 
 int
+unserialize_req_locklist_v2 (gfx_setactivelk_req *req,
+                          lock_migration_info_t *lmi)
+{
+        struct gfs3_locklist            *trav      = NULL;
+        lock_migration_info_t           *temp    = NULL;
+        int                             ret       = -1;
+
+        trav = req->request;
+
+        INIT_LIST_HEAD (&lmi->list);
+
+        while (trav) {
+                temp = GF_CALLOC (1, sizeof (*lmi), gf_common_mt_lock_mig);
+                if (temp == NULL) {
+                        gf_msg (THIS->name, GF_LOG_ERROR, 0, 0, "No memory");
+                        goto out;
+                }
+
+                INIT_LIST_HEAD (&temp->list);
+
+                gf_proto_flock_to_flock (&trav->flock, &temp->flock);
+
+                temp->lk_flags = trav->lk_flags;
+
+                temp->client_uid =  gf_strdup (trav->client_uid);
+
+                list_add_tail (&temp->list, &lmi->list);
+
+                trav = trav->nextentry;
+        }
+
+        ret = 0;
+out:
+        return ret;
+}
+
+int
 server_populate_compound_request (gfs3_compound_req *req, call_frame_t *frame,
                                   default_args_t *this_args,
                                   int index)
@@ -4222,3 +4411,2027 @@ server_compound_req_cleanup (gfs3_compound_req *req, int len)
 
         return;
 }
+
+/* compound v2 */
+int
+server_populate_compound_request_v2 (gfx_compound_req *req, call_frame_t *frame,
+                                     default_args_t *this_args,
+                                     int index)
+{
+        int                     op_errno    = 0;
+        dict_t                 *xdata       = NULL;
+        dict_t                 *xattr       = NULL;
+        struct iovec req_iovec[MAX_IOVEC]   = { {0,} };
+        compound_req_v2        *this_req   = NULL;
+        server_state_t          *state      = CALL_STATE (frame);
+
+        this_req = &req->compound_req_array.compound_req_array_val[index];
+
+        switch (this_req->fop_enum) {
+        case GF_FOP_STAT:
+        {
+                gfx_stat_req *args = NULL;
+
+                args = &this_req->compound_req_v2_u.compound_stat_req;
+
+                xdr_to_dict (&args->xdata, &xdata);
+                args_stat_store (this_args, &state->loc, xdata);
+                break;
+        }
+        case GF_FOP_READLINK:
+        {
+                gfx_readlink_req *args = NULL;
+
+                args = &this_req->compound_req_v2_u.compound_readlink_req;
+
+                xdr_to_dict (&args->xdata, &xdata);
+                args_readlink_store (this_args, &state->loc, args->size, xdata);
+                break;
+        }
+        case GF_FOP_MKNOD:
+        {
+                gfx_mknod_req *args = NULL;
+
+                args = &this_req->compound_req_v2_u.compound_mknod_req;
+
+                xdr_to_dict (&args->xdata, &xdata);
+                args_mknod_store (this_args, &state->loc, args->mode, args->dev,
+                                  args->umask, xdata);
+                break;
+        }
+        case GF_FOP_MKDIR:
+        {
+                gfx_mkdir_req *args = NULL;
+
+                args = &this_req->compound_req_v2_u.compound_mkdir_req;
+
+                xdr_to_dict (&args->xdata, &xdata);
+                args_mkdir_store (this_args, &state->loc, args->mode,
+                                  args->umask, xdata);
+                break;
+        }
+        case GF_FOP_UNLINK:
+        {
+                gfx_unlink_req *args = NULL;
+
+                args = &this_req->compound_req_v2_u.compound_unlink_req;
+
+                xdr_to_dict (&args->xdata, &xdata);
+                args_unlink_store (this_args, &state->loc, args->xflags, xdata);
+                break;
+        }
+        case GF_FOP_RMDIR:
+        {
+                gfx_rmdir_req *args = NULL;
+
+                args = &this_req->compound_req_v2_u.compound_rmdir_req;
+
+                xdr_to_dict (&args->xdata, &xdata);
+                args_rmdir_store (this_args, &state->loc, args->xflags, xdata);
+                break;
+        }
+        case GF_FOP_SYMLINK:
+        {
+                gfx_symlink_req *args = NULL;
+
+                args = &this_req->compound_req_v2_u.compound_symlink_req;
+
+                xdr_to_dict (&args->xdata, &xdata);
+                args_symlink_store (this_args, args->linkname, &state->loc,
+                                    args->umask, xdata);
+
+                this_args->loc.inode = inode_new (state->itable);
+
+                break;
+        }
+        case GF_FOP_RENAME:
+        {
+                gfx_rename_req *args = NULL;
+
+                args = &this_req->compound_req_v2_u.compound_rename_req;
+
+                xdr_to_dict (&args->xdata, &xdata);
+
+                args_rename_store (this_args, &state->loc, &state->loc2, xdata);
+                break;
+        }
+        case GF_FOP_LINK:
+        {
+                gfx_link_req *args = NULL;
+
+                args = &this_req->compound_req_v2_u.compound_link_req;
+
+                xdr_to_dict (&args->xdata, &xdata);
+                args_link_store (this_args, &state->loc, &state->loc2, xdata);
+
+                this_args->loc2.inode = inode_ref (this_args->loc.inode);
+
+                break;
+        }
+        case GF_FOP_TRUNCATE:
+        {
+                gfx_truncate_req *args = NULL;
+
+                args = &this_req->compound_req_v2_u.compound_truncate_req;
+
+                xdr_to_dict (&args->xdata, &xdata);
+                args_truncate_store (this_args, &state->loc, args->offset,
+                                     xdata);
+                break;
+        }
+        case GF_FOP_OPEN:
+        {
+                gfx_open_req *args = NULL;
+
+                args = &this_req->compound_req_v2_u.compound_open_req;
+
+                xdr_to_dict (&args->xdata, &xdata);
+                args_open_store (this_args, &state->loc, args->flags, state->fd,
+                                 xdata);
+
+                this_args->fd = fd_create (this_args->loc.inode,
+                                           frame->root->pid);
+                this_args->fd->flags = this_args->flags;
+
+                break;
+        }
+        case GF_FOP_READ:
+        {
+                gfx_read_req *args = NULL;
+
+                args = &this_req->compound_req_v2_u.compound_read_req;
+
+                xdr_to_dict (&args->xdata, &xdata);
+                args_readv_store (this_args, state->fd, args->size,
+                                  args->offset, args->flag, xdata);
+                break;
+        }
+        case GF_FOP_WRITE:
+        {
+                gfx_write_req *args = NULL;
+
+                args = &this_req->compound_req_v2_u.compound_write_req;
+
+                /*TODO : What happens when payload count is more than one? */
+                req_iovec[0].iov_base = state->payload_vector[0].iov_base +
+                                        state->write_length;
+                req_iovec[0].iov_len  = args->size;
+
+                xdr_to_dict (&args->xdata, &xdata);
+                /* The way writev fop works :
+                 * xdr args of write along with other args contains
+                 * write length not count. But when the call is wound to posix,
+                 * this length is not used. It is taken from the request
+                 * write vector that is passed down. Posix needs the vector
+                 * count to determine the amount of write to be done.
+                 * This count for writes that come as part of compound fops
+                 * will be 1. The vectors are merged into one under
+                 * GF_FOP_WRITE section of client_handle_fop_requirements()
+                 * in protocol client.
+                 */
+                args_writev_store (this_args, state->fd, req_iovec, 1,
+                                   args->offset, args->flag, state->iobref,
+                                   xdata);
+                state->write_length += req_iovec[0].iov_len;
+                break;
+        }
+        case GF_FOP_STATFS:
+        {
+                gfx_statfs_req *args = NULL;
+
+                args = &this_req->compound_req_v2_u.compound_statfs_req;
+
+                xdr_to_dict (&args->xdata, &xdata);
+                args_statfs_store (this_args, &state->loc, xdata);
+                break;
+        }
+        case GF_FOP_FLUSH:
+        {
+                gfx_flush_req *args = NULL;
+
+                args = &this_req->compound_req_v2_u.compound_flush_req;
+
+                xdr_to_dict (&args->xdata, &xdata);
+                args_flush_store (this_args, state->fd, xdata);
+                break;
+        }
+        case GF_FOP_FSYNC:
+        {
+                gfx_fsync_req *args = NULL;
+
+                args = &this_req->compound_req_v2_u.compound_fsync_req;
+
+                xdr_to_dict (&args->xdata, &xdata);
+                args_fsync_store (this_args, state->fd, args->data, xdata);
+                break;
+        }
+        case GF_FOP_SETXATTR:
+        {
+                gfx_setxattr_req *args = NULL;
+
+                args = &this_req->compound_req_v2_u.compound_setxattr_req;
+
+                xdr_to_dict (&args->dict, &xattr);
+                xdr_to_dict (&args->xdata, &xdata);
+                args_setxattr_store (this_args, &state->loc, xattr, args->flags,
+                                     xdata);
+                break;
+        }
+        case GF_FOP_GETXATTR:
+        {
+                gfx_getxattr_req *args = NULL;
+
+                args = &this_req->compound_req_v2_u.compound_getxattr_req;
+
+                xdr_to_dict (&args->xdata, &xdata);
+                gf_server_check_getxattr_cmd (frame, args->name);
+
+                args_getxattr_store (this_args, &state->loc, args->name, xdata);
+                break;
+        }
+        case GF_FOP_REMOVEXATTR:
+        {
+                gfx_removexattr_req *args = NULL;
+
+                args = &this_req->compound_req_v2_u.compound_removexattr_req;
+
+                xdr_to_dict (&args->xdata, &xdata);
+                args_removexattr_store (this_args, &state->loc, args->name,
+                                        xdata);
+                break;
+        }
+        case GF_FOP_OPENDIR:
+        {
+                gfx_opendir_req *args = NULL;
+
+                args = &this_req->compound_req_v2_u.compound_opendir_req;
+
+                this_args->fd = fd_create (this_args->loc.inode,
+                                           frame->root->pid);
+                if (!this_args->fd) {
+                        gf_msg ("server", GF_LOG_ERROR, 0,
+                                PS_MSG_FD_CREATE_FAILED,
+                                "could not create the fd");
+                        goto out;
+                }
+                xdr_to_dict (&args->xdata, &xdata);
+
+                args_opendir_store (this_args, &state->loc, state->fd, xdata);
+                break;
+        }
+        case GF_FOP_FSYNCDIR:
+        {
+                gfx_fsyncdir_req *args = NULL;
+
+                args = &this_req->compound_req_v2_u.compound_fsyncdir_req;
+
+                xdr_to_dict (&args->xdata, &xdata);
+                args_fsyncdir_store (this_args, state->fd, args->data, xdata);
+                break;
+        }
+        case GF_FOP_ACCESS:
+        {
+                gfx_access_req *args = NULL;
+
+                args = &this_req->compound_req_v2_u.compound_access_req;
+
+                xdr_to_dict (&args->xdata, &xdata);
+                args_access_store (this_args, &state->loc, args->mask, xdata);
+                break;
+        }
+        case GF_FOP_CREATE:
+        {
+                gfx_create_req *args = NULL;
+
+                args = &this_req->compound_req_v2_u.compound_create_req;
+
+                state->loc.inode = inode_new (state->itable);
+
+                state->fd = fd_create (state->loc.inode, frame->root->pid);
+                if (!state->fd) {
+                        gf_msg ("server", GF_LOG_ERROR, 0,
+                                PS_MSG_FD_CREATE_FAILED,
+                                "fd creation for the inode %s failed",
+                                state->loc.inode ?
+                                uuid_utoa (state->loc.inode->gfid):NULL);
+                        goto out;
+                }
+                state->fd->flags = state->flags;
+
+                xdr_to_dict (&args->xdata, &xdata);
+                args_create_store (this_args, &state->loc, args->flags,
+                                   args->mode, args->umask, state->fd, xdata);
+                break;
+        }
+        case GF_FOP_FTRUNCATE:
+        {
+                gfx_ftruncate_req *args = NULL;
+
+                args = &this_req->compound_req_v2_u.compound_ftruncate_req;
+
+                xdr_to_dict (&args->xdata, &xdata);
+                args_ftruncate_store (this_args, state->fd, args->offset,
+                                      xdata);
+                break;
+        }
+        case GF_FOP_FSTAT:
+        {
+                gfx_fstat_req *args = NULL;
+
+                args = &this_req->compound_req_v2_u.compound_fstat_req;
+
+                xdr_to_dict (&args->xdata, &xdata);
+                args_fstat_store (this_args, state->fd, xdata);
+                break;
+        }
+        case GF_FOP_LK:
+        {
+                gfx_lk_req *args = NULL;
+
+                args = &this_req->compound_req_v2_u.compound_lk_req;
+
+                xdr_to_dict (&args->xdata, &xdata);
+
+                switch (args->cmd) {
+                case GF_LK_GETLK:
+                        this_args->cmd = F_GETLK;
+                        break;
+                case GF_LK_SETLK:
+                        this_args->cmd = F_SETLK;
+                        break;
+                case GF_LK_SETLKW:
+                        this_args->cmd = F_SETLKW;
+                        break;
+                case GF_LK_RESLK_LCK:
+                        this_args->cmd = F_RESLK_LCK;
+                        break;
+                case GF_LK_RESLK_LCKW:
+                        this_args->cmd = F_RESLK_LCKW;
+                        break;
+                case GF_LK_RESLK_UNLCK:
+                        this_args->cmd = F_RESLK_UNLCK;
+                        break;
+                case GF_LK_GETLK_FD:
+                        this_args->cmd = F_GETLK_FD;
+                        break;
+                }
+
+                gf_proto_flock_to_flock (&args->flock, &this_args->lock);
+
+                switch (args->type) {
+                case GF_LK_F_RDLCK:
+                        this_args->lock.l_type = F_RDLCK;
+                        break;
+                case GF_LK_F_WRLCK:
+                        this_args->lock.l_type = F_WRLCK;
+                        break;
+                case GF_LK_F_UNLCK:
+                        this_args->lock.l_type = F_UNLCK;
+                        break;
+                default:
+                        gf_msg (frame->root->client->bound_xl->name,
+                                GF_LOG_ERROR,
+                                0, PS_MSG_LOCK_ERROR, "fd - %"PRId64" (%s):"
+                                " Unknown "
+                                "lock type: %"PRId32"!", state->resolve.fd_no,
+                                uuid_utoa (state->fd->inode->gfid),
+                                args->type);
+                        break;
+                }
+                args_lk_store (this_args, state->fd, this_args->cmd,
+                               &this_args->lock, xdata);
+                break;
+        }
+        case GF_FOP_LOOKUP:
+        {
+                gfx_lookup_req *args = NULL;
+
+                args = &this_req->compound_req_v2_u.compound_lookup_req;
+
+                if (this_args->loc.inode)
+                        this_args->loc.inode = server_inode_new (state->itable,
+                                                             state->loc.gfid);
+                else
+                        state->is_revalidate = 1;
+
+                xdr_to_dict (&args->xdata, &xdata);
+                args_lookup_store (this_args, &state->loc, xdata);
+                break;
+        }
+        case GF_FOP_READDIR:
+        {
+                gfx_readdir_req *args = NULL;
+
+                args = &this_req->compound_req_v2_u.compound_readdir_req;
+
+                xdr_to_dict (&args->xdata, &xdata);
+                args_readdir_store (this_args, state->fd, args->size,
+                                    args->offset, xdata);
+                break;
+        }
+        case GF_FOP_INODELK:
+        {
+                gfx_inodelk_req *args = NULL;
+
+                args = &this_req->compound_req_v2_u.compound_inodelk_req;
+
+                switch (args->cmd) {
+                case GF_LK_GETLK:
+                        this_args->cmd = F_GETLK;
+                        break;
+                case GF_LK_SETLK:
+                        this_args->cmd = F_SETLK;
+                        break;
+                case GF_LK_SETLKW:
+                        this_args->cmd = F_SETLKW;
+                        break;
+                }
+
+                gf_proto_flock_to_flock (&args->flock, &this_args->lock);
+
+                switch (args->type) {
+                case GF_LK_F_RDLCK:
+                        this_args->lock.l_type = F_RDLCK;
+                        break;
+                case GF_LK_F_WRLCK:
+                        this_args->lock.l_type = F_WRLCK;
+                        break;
+                case GF_LK_F_UNLCK:
+                        this_args->lock.l_type = F_UNLCK;
+                        break;
+                }
+
+                xdr_to_dict (&args->xdata, &xdata);
+                args_inodelk_store (this_args, args->volume, &state->loc,
+                                    this_args->cmd, &this_args->lock, xdata);
+                break;
+        }
+        case GF_FOP_FINODELK:
+        {
+                gfx_finodelk_req *args = NULL;
+
+                args = &this_req->compound_req_v2_u.compound_finodelk_req;
+
+                xdr_to_dict (&args->xdata, &xdata);
+
+                switch (args->cmd) {
+                case GF_LK_GETLK:
+                        this_args->cmd = F_GETLK;
+                        break;
+                case GF_LK_SETLK:
+                        this_args->cmd = F_SETLK;
+                        break;
+                case GF_LK_SETLKW:
+                        this_args->cmd = F_SETLKW;
+                        break;
+                }
+
+                gf_proto_flock_to_flock (&args->flock, &this_args->lock);
+
+                switch (args->type) {
+                case GF_LK_F_RDLCK:
+                        this_args->lock.l_type = F_RDLCK;
+                        break;
+                case GF_LK_F_WRLCK:
+                        this_args->lock.l_type = F_WRLCK;
+                        break;
+                case GF_LK_F_UNLCK:
+                        this_args->lock.l_type = F_UNLCK;
+                        break;
+                }
+                args_finodelk_store (this_args, args->volume, state->fd,
+                                     this_args->cmd, &this_args->lock, xdata);
+                        break;
+        }
+        case GF_FOP_ENTRYLK:
+        {
+                gfx_entrylk_req *args = NULL;
+
+                args = &this_req->compound_req_v2_u.compound_entrylk_req;
+
+                xdr_to_dict (&args->xdata, &xdata);
+                args_entrylk_store (this_args, args->volume, &state->loc,
+                                    args->name, args->cmd, args->type, xdata);
+                break;
+        }
+        case GF_FOP_FENTRYLK:
+        {
+                gfx_fentrylk_req *args = NULL;
+
+                args = &this_req->compound_req_v2_u.compound_fentrylk_req;
+
+                xdr_to_dict (&args->xdata, &xdata);
+                args_fentrylk_store (this_args, args->volume, state->fd,
+                                     args->name, args->cmd, args->type, xdata);
+                break;
+        }
+        case GF_FOP_XATTROP:
+        {
+                gfx_xattrop_req *args = NULL;
+
+                args = &this_req->compound_req_v2_u.compound_xattrop_req;
+
+                xdr_to_dict (&args->dict, &xattr);
+
+                xdr_to_dict (&args->xdata, &xdata);
+                args_xattrop_store (this_args, &state->loc, args->flags,
+                                    xattr, xdata);
+                break;
+        }
+        case GF_FOP_FXATTROP:
+        {
+                gfx_fxattrop_req *args = NULL;
+
+                args = &this_req->compound_req_v2_u.compound_fxattrop_req;
+
+                xdr_to_dict (&args->dict, &xattr);
+
+                xdr_to_dict (&args->xdata, &xdata);
+
+                args_fxattrop_store (this_args, state->fd, args->flags, xattr,
+                                     xdata);
+                break;
+        }
+        case GF_FOP_FGETXATTR:
+        {
+                gfx_fgetxattr_req *args = NULL;
+
+                args = &this_req->compound_req_v2_u.compound_fgetxattr_req;
+
+                xdr_to_dict (&args->xdata, &xdata);
+
+                args_fgetxattr_store (this_args, state->fd, args->name, xdata);
+                break;
+        }
+        case GF_FOP_FSETXATTR:
+        {
+                gfx_fsetxattr_req *args = NULL;
+
+                args = &this_req->compound_req_v2_u.compound_fsetxattr_req;
+
+                xdr_to_dict (&args->dict, &xattr);
+
+                xdr_to_dict (&args->xdata, &xdata);
+
+                args_fsetxattr_store (this_args, state->fd, xattr, args->flags,
+                                      xdata);
+                break;
+        }
+        case GF_FOP_RCHECKSUM:
+        {
+                gfx_rchecksum_req *args = NULL;
+
+                args = &this_req->compound_req_v2_u.compound_rchecksum_req;
+
+                xdr_to_dict (&args->xdata, &xdata);
+
+                args_rchecksum_store (this_args, state->fd, args->offset,
+                                      args->len, xdata);
+                break;
+        }
+        case GF_FOP_SETATTR:
+        {
+                gfx_setattr_req *args = NULL;
+
+                args = &this_req->compound_req_v2_u.compound_setattr_req;
+
+                xdr_to_dict (&args->xdata, &xdata);
+
+                gfx_stat_to_iattx (&args->stbuf, &this_args->stat);
+
+                args_setattr_store (this_args, &state->loc, &this_args->stat,
+                                    args->valid, xdata);
+                break;
+        }
+        case GF_FOP_FSETATTR:
+        {
+                gfx_fsetattr_req *args = NULL;
+
+                args = &this_req->compound_req_v2_u.compound_fsetattr_req;
+
+                xdr_to_dict (&args->xdata, &xdata);
+
+                gfx_stat_to_iattx (&args->stbuf, &this_args->stat);
+
+                args_fsetattr_store (this_args, state->fd, &this_args->stat,
+                                     args->valid, xdata);
+                break;
+        }
+        case GF_FOP_READDIRP:
+        {
+                gfx_readdirp_req *args = NULL;
+
+                args = &this_req->compound_req_v2_u.compound_readdirp_req;
+
+                xdr_to_dict (&args->xdata, &xdata);
+
+                args_readdirp_store (this_args, state->fd, args->size,
+                                     args->offset, xattr);
+                break;
+        }
+        case GF_FOP_FREMOVEXATTR:
+        {
+                gfx_fremovexattr_req *args = NULL;
+
+                args = &this_req->compound_req_v2_u.compound_fremovexattr_req;
+
+                xdr_to_dict (&args->xdata, &xdata);
+
+                args_fremovexattr_store (this_args, state->fd, args->name,
+                                         xdata);
+                break;
+        }
+	case GF_FOP_FALLOCATE:
+        {
+                gfx_fallocate_req *args = NULL;
+
+                args = &this_req->compound_req_v2_u.compound_fallocate_req;
+
+                xdr_to_dict (&args->xdata, &xdata);
+                args_fallocate_store (this_args, state->fd, args->flags,
+                                      args->offset, args->size, xdata);
+                break;
+        }
+	case GF_FOP_DISCARD:
+        {
+                gfx_discard_req *args = NULL;
+
+                args = &this_req->compound_req_v2_u.compound_discard_req;
+
+                xdr_to_dict (&args->xdata, &xdata);
+
+                args_discard_store (this_args, state->fd, args->offset,
+                                    args->size, xdata);
+                break;
+        }
+        case GF_FOP_ZEROFILL:
+        {
+                gfx_zerofill_req *args = NULL;
+
+                args = &this_req->compound_req_v2_u.compound_zerofill_req;
+
+                xdr_to_dict (&args->xdata, &xdata);
+                args_zerofill_store (this_args, state->fd, args->offset,
+                                     args->size, xdata);
+                break;
+        }
+        case GF_FOP_SEEK:
+        {
+                gfx_seek_req *args = NULL;
+
+                args = &this_req->compound_req_v2_u.compound_seek_req;
+
+                xdr_to_dict (&args->xdata, &xdata);
+                args_seek_store (this_args, state->fd, args->offset, args->what,
+                                 xdata);
+                break;
+        }
+        case GF_FOP_LEASE:
+        {
+                gfx_lease_req *args = NULL;
+
+                args = &this_req->compound_req_v2_u.compound_lease_req;
+
+                xdr_to_dict (&args->xdata, &xdata);
+
+                gf_proto_lease_to_lease (&args->lease, &state->lease);
+
+                args_lease_store (this_args, &state->loc, &state->lease, xdata);
+                break;
+        }
+        default:
+                return ENOTSUP;
+        }
+out:
+        if (xattr)
+                dict_unref (xattr);
+        if (xdata)
+                dict_unref (xdata);
+        return op_errno;
+}
+
+int
+server_populate_compound_response_v2 (xlator_t *this, gfx_compound_rsp *rsp,
+                                      call_frame_t *frame,
+                                      compound_args_cbk_t *args_cbk, int index)
+{
+        int                     op_errno    = EINVAL;
+        default_args_cbk_t      *this_args_cbk = NULL;
+        compound_rsp_v2         *this_rsp   = NULL;
+        server_state_t          *state      = NULL;
+        int                     ret         = 0;
+
+        state = CALL_STATE (frame);
+        this_rsp = &rsp->compound_rsp_array.compound_rsp_array_val[index];
+
+        this_args_cbk = &args_cbk->rsp_list[index];
+        this_rsp->fop_enum = args_cbk->enum_list[index];
+
+        switch (this_rsp->fop_enum) {
+        case GF_FOP_FSTAT:
+        case GF_FOP_STAT:
+        {
+                gfx_common_iatt_rsp *rsp_args = NULL;
+
+                rsp_args = &this_rsp->compound_rsp_v2_u.compound_stat_rsp;
+
+                dict_to_xdr (this_args_cbk->xdata, &rsp_args->xdata);
+                if (!this_args_cbk->op_ret) {
+                        server4_post_common_iatt (state, rsp_args,
+                                                  &this_args_cbk->stat);
+                }
+                rsp_args->op_ret = this_args_cbk->op_ret;
+                rsp_args->op_errno  = gf_errno_to_error
+                                      (this_args_cbk->op_errno);
+                break;
+        }
+        case GF_FOP_READLINK:
+        {
+                gfx_readlink_rsp *rsp_args = NULL;
+
+                rsp_args = &this_rsp->compound_rsp_v2_u.compound_readlink_rsp;
+
+                dict_to_xdr (this_args_cbk->xdata, &rsp_args->xdata);
+                if (this_args_cbk->op_ret >= 0) {
+                        server4_post_readlink (rsp_args, &this_args_cbk->stat,
+                                              this_args_cbk->buf);
+                }
+                rsp_args->op_ret = this_args_cbk->op_ret;
+                rsp_args->op_errno  = gf_errno_to_error
+                                      (this_args_cbk->op_errno);
+                if (!rsp_args->path)
+                        rsp_args->path = "";
+                break;
+        }
+        case GF_FOP_MKNOD:
+        case GF_FOP_MKDIR:
+        case GF_FOP_SYMLINK:
+        case GF_FOP_LINK:
+        {
+                gfx_common_3iatt_rsp *rsp_args = NULL;
+
+                rsp_args = &this_rsp->compound_rsp_v2_u.compound_mknod_rsp;
+
+                dict_to_xdr (this_args_cbk->xdata, &rsp_args->xdata);
+                if (!this_args_cbk->op_ret) {
+                        server4_post_common_3iatt (state, rsp_args,
+                                                   this_args_cbk->inode,
+                                                   &this_args_cbk->stat,
+                                                   &this_args_cbk->preparent,
+                                                   &this_args_cbk->postparent);
+                }
+                rsp_args->op_ret = this_args_cbk->op_ret;
+                rsp_args->op_errno  = gf_errno_to_error
+                                      (this_args_cbk->op_errno);
+                break;
+        }
+        case GF_FOP_UNLINK:
+        case GF_FOP_RMDIR:
+        {
+                gfx_common_2iatt_rsp *rsp_args = NULL;
+
+                rsp_args = &this_rsp->compound_rsp_v2_u.compound_unlink_rsp;
+
+                dict_to_xdr (this_args_cbk->xdata, &rsp_args->xdata);
+                if (!this_args_cbk->op_ret) {
+                        server4_post_entry_remove (state, rsp_args,
+                                                   &this_args_cbk->preparent,
+                                                   &this_args_cbk->postparent);
+                }
+                rsp_args->op_ret = this_args_cbk->op_ret;
+                rsp_args->op_errno  = gf_errno_to_error
+                                      (this_args_cbk->op_errno);
+                break;
+        }
+        case GF_FOP_RENAME:
+        {
+                gfx_rename_rsp *rsp_args = NULL;
+
+                rsp_args = &this_rsp->compound_rsp_v2_u.compound_rename_rsp;
+
+                dict_to_xdr (this_args_cbk->xdata, &rsp_args->xdata);
+
+                if (!this_args_cbk->op_ret) {
+                        server4_post_rename (frame, state, rsp_args,
+                                            &this_args_cbk->stat,
+                                            &this_args_cbk->preparent,
+                                            &this_args_cbk->postparent,
+                                            &this_args_cbk->preparent2,
+                                            &this_args_cbk->postparent2);
+                }
+                rsp_args->op_ret = this_args_cbk->op_ret;
+                rsp_args->op_errno  = gf_errno_to_error
+                                      (this_args_cbk->op_errno);
+                break;
+        }
+	case GF_FOP_FALLOCATE:
+	case GF_FOP_ZEROFILL:
+	case GF_FOP_DISCARD:
+        case GF_FOP_SETATTR:
+        case GF_FOP_FSETATTR:
+        case GF_FOP_FTRUNCATE:
+        case GF_FOP_TRUNCATE:
+        case GF_FOP_WRITE:
+        case GF_FOP_FSYNC:
+        {
+                gfx_common_2iatt_rsp *rsp_args = NULL;
+
+                rsp_args = &this_rsp->compound_rsp_v2_u.compound_truncate_rsp;
+
+                dict_to_xdr (this_args_cbk->xdata, &rsp_args->xdata);
+
+                if (!this_args_cbk->op_ret) {
+                        server4_post_common_2iatt (rsp_args,
+                                                   &this_args_cbk->prestat,
+                                                   &this_args_cbk->poststat);
+                }
+                rsp_args->op_ret = this_args_cbk->op_ret;
+                rsp_args->op_errno  = gf_errno_to_error
+                                      (this_args_cbk->op_errno);
+                break;
+        }
+        case GF_FOP_OPEN:
+        case GF_FOP_OPENDIR:
+        {
+                gfx_open_rsp *rsp_args = NULL;
+
+                rsp_args = &this_rsp->compound_rsp_v2_u.compound_open_rsp;
+
+                dict_to_xdr (this_args_cbk->xdata, &rsp_args->xdata);
+
+                if (!this_args_cbk->op_ret) {
+                        server4_post_open (frame, this, rsp_args,
+                                          this_args_cbk->fd);
+
+                }
+                rsp_args->op_ret = this_args_cbk->op_ret;
+                rsp_args->op_errno = gf_errno_to_error
+                                     (this_args_cbk->op_errno);
+                break;
+        }
+        case GF_FOP_READ:
+        {
+                gfx_read_rsp *rsp_args = NULL;
+
+                rsp_args = &this_rsp->compound_rsp_v2_u.compound_read_rsp;
+
+                dict_to_xdr (this_args_cbk->xdata, &rsp_args->xdata);
+
+                if (this_args_cbk->op_ret >= 0) {
+                        server4_post_readv (rsp_args, &this_args_cbk->stat,
+                                           this_args_cbk->op_ret);
+
+                        if (!state->rsp_iobref) {
+                                state->rsp_iobref = this_args_cbk->iobref;
+                                state->rsp_count = 0;
+                        }
+                        iobref_merge (state->rsp_iobref,
+                                      this_args_cbk->iobref);
+                        memcpy (&state->rsp_vector[state->rsp_count],
+                                this_args_cbk->vector,
+                                (this_args_cbk->count *
+                                 sizeof(state->rsp_vector[0])));
+                        state->rsp_count += this_args_cbk->count;
+                }
+                rsp_args->op_ret = this_args_cbk->op_ret;
+                rsp_args->op_errno = gf_errno_to_error
+                                     (this_args_cbk->op_errno);
+                break;
+        }
+        case GF_FOP_STATFS:
+        {
+                gfx_statfs_rsp *rsp_args = NULL;
+
+                rsp_args = &this_rsp->compound_rsp_v2_u.compound_statfs_rsp;
+
+                dict_to_xdr (this_args_cbk->xdata, &rsp_args->xdata);
+                if (!this_args_cbk->op_ret) {
+                        server4_post_statfs (rsp_args,
+                                            &this_args_cbk->statvfs);
+                }
+                rsp_args->op_ret = this_args_cbk->op_ret;
+                rsp_args->op_errno  = gf_errno_to_error
+                                      (this_args_cbk->op_errno);
+                break;
+        }
+        case GF_FOP_FLUSH:
+        case GF_FOP_SETXATTR:
+        case GF_FOP_FSETXATTR:
+        case GF_FOP_REMOVEXATTR:
+        case GF_FOP_FREMOVEXATTR:
+        case GF_FOP_FSYNCDIR:
+        case GF_FOP_ACCESS:
+        case GF_FOP_INODELK:
+        case GF_FOP_FINODELK:
+        case GF_FOP_ENTRYLK:
+        case GF_FOP_FENTRYLK:
+        {
+                gfx_common_rsp *rsp_args = NULL;
+
+                rsp_args = &this_rsp->compound_rsp_v2_u.compound_flush_rsp;
+
+                dict_to_xdr (this_args_cbk->xdata, &rsp_args->xdata);
+                rsp_args->op_ret = this_args_cbk->op_ret;
+                rsp_args->op_errno  = gf_errno_to_error
+                                      (this_args_cbk->op_errno);
+                break;
+        }
+        case GF_FOP_FGETXATTR:
+        case GF_FOP_GETXATTR:
+        case GF_FOP_XATTROP:
+        case GF_FOP_FXATTROP:
+        {
+                gfx_common_dict_rsp *rsp_args = NULL;
+
+                rsp_args = &this_rsp->compound_rsp_v2_u.compound_getxattr_rsp;
+
+                dict_to_xdr (this_args_cbk->xdata, &rsp_args->xdata);
+
+                if (-1 != this_args_cbk->op_ret) {
+                        dict_to_xdr (this_args_cbk->xattr, &rsp_args->dict);
+                }
+                rsp_args->op_ret = this_args_cbk->op_ret;
+                rsp_args->op_errno  = gf_errno_to_error
+                                      (this_args_cbk->op_errno);
+                break;
+        }
+        case GF_FOP_CREATE:
+        {
+                gfx_create_rsp *rsp_args = NULL;
+
+                rsp_args = &this_rsp->compound_rsp_v2_u.compound_create_rsp;
+
+                dict_to_xdr (this_args_cbk->xdata, &rsp_args->xdata);
+
+                rsp_args->op_ret = this_args_cbk->op_ret;
+                rsp_args->op_errno  = gf_errno_to_error
+                                      (this_args_cbk->op_errno);
+
+                if (!this_args_cbk->op_ret) {
+                        rsp_args->op_ret = server4_post_create (frame,
+                                                rsp_args, state, this,
+                                                this_args_cbk->fd,
+                                                this_args_cbk->inode,
+                                                &this_args_cbk->stat,
+                                                &this_args_cbk->preparent,
+                                                &this_args_cbk->postparent);
+                        if (rsp_args->op_ret) {
+                                rsp_args->op_errno = -rsp_args->op_ret;
+                                rsp_args->op_ret = -1;
+                        }
+                }
+                break;
+        }
+        case GF_FOP_LK:
+        {
+                gfx_lk_rsp *rsp_args = NULL;
+
+                rsp_args = &this_rsp->compound_rsp_v2_u.compound_lk_rsp;
+
+                dict_to_xdr (this_args_cbk->xdata, &rsp_args->xdata);
+
+                if (!this_args_cbk->op_ret) {
+                        server4_post_lk (this, rsp_args, &this_args_cbk->lock);
+                }
+
+                rsp_args->op_ret = this_args_cbk->op_ret;
+                rsp_args->op_errno  = gf_errno_to_error
+                                      (this_args_cbk->op_errno);
+                break;
+        }
+        case GF_FOP_LOOKUP:
+        {
+                gfx_common_2iatt_rsp *rsp_args = NULL;
+
+                rsp_args = &this_rsp->compound_rsp_v2_u.compound_lookup_rsp;
+
+                dict_to_xdr (this_args_cbk->xdata, &rsp_args->xdata);
+                gfx_stat_from_iattx (&rsp_args->poststat,
+                                     &this_args_cbk->postparent);
+
+                if (!this_args_cbk->op_ret) {
+                        server4_post_lookup (rsp_args, frame, state,
+                                             this_args_cbk->inode,
+                                             &this_args_cbk->stat);
+                }
+                rsp_args->op_ret = this_args_cbk->op_ret;
+                rsp_args->op_errno  = gf_errno_to_error
+                                      (this_args_cbk->op_errno);
+                break;
+        }
+        case GF_FOP_READDIR:
+        {
+                gfx_readdir_rsp *rsp_args = NULL;
+
+                rsp_args = &this_rsp->compound_rsp_v2_u.compound_readdir_rsp;
+
+                dict_to_xdr (this_args_cbk->xdata, &rsp_args->xdata);
+
+                rsp_args->op_ret = this_args_cbk->op_ret;
+                rsp_args->op_errno  = gf_errno_to_error
+                                      (this_args_cbk->op_errno);
+
+                if (this_args_cbk->op_ret > 0) {
+                        ret = server4_post_readdir (rsp_args,
+                                                   &this_args_cbk->entries);
+                        if (ret < 0) {
+                                rsp_args->op_ret = ret;
+                                rsp_args->op_errno = ENOMEM;
+                        }
+                }
+                break;
+        }
+        case GF_FOP_RCHECKSUM:
+        {
+                gfx_rchecksum_rsp *rsp_args = NULL;
+
+                rsp_args = &this_rsp->compound_rsp_v2_u.compound_rchecksum_rsp;
+
+                dict_to_xdr (this_args_cbk->xdata, &rsp_args->xdata);
+
+                if (!this_args_cbk->op_ret) {
+                        server4_post_rchecksum (rsp_args,
+                                               this_args_cbk->weak_checksum,
+                                               this_args_cbk->strong_checksum);
+                }
+                rsp_args->op_ret = this_args_cbk->op_ret;
+                rsp_args->op_errno  = gf_errno_to_error
+                                      (this_args_cbk->op_errno);
+                break;
+        }
+        case GF_FOP_READDIRP:
+        {
+                gfx_readdirp_rsp *rsp_args = NULL;
+
+                rsp_args = &this_rsp->compound_rsp_v2_u.compound_readdirp_rsp;
+
+                dict_to_xdr (this_args_cbk->xdata, &rsp_args->xdata);
+
+                if (this_args_cbk->op_ret > 0) {
+                        ret = server4_post_readdirp (rsp_args,
+                                                   &this_args_cbk->entries);
+                        if (ret < 0) {
+                                rsp_args->op_ret = ret;
+                                rsp_args->op_errno = ENOMEM;
+                                goto out;
+                        }
+                        gf_link_inodes_from_dirent (this, state->fd->inode,
+                                                    &this_args_cbk->entries);
+                }
+                rsp_args->op_ret = this_args_cbk->op_ret;
+                rsp_args->op_errno  = gf_errno_to_error
+                                      (this_args_cbk->op_errno);
+                break;
+        }
+        case GF_FOP_SEEK:
+        {
+                gfx_seek_rsp *rsp_args = NULL;
+
+                rsp_args = &this_rsp->compound_rsp_v2_u.compound_seek_rsp;
+
+                dict_to_xdr (this_args_cbk->xdata, &rsp_args->xdata);
+                rsp_args->op_ret = this_args_cbk->op_ret;
+                rsp_args->op_errno  = gf_errno_to_error
+                                      (this_args_cbk->op_errno);
+                break;
+        }
+        case GF_FOP_LEASE:
+        {
+                gfx_lease_rsp *rsp_args = NULL;
+
+                rsp_args = &this_rsp->compound_rsp_v2_u.compound_lease_rsp;
+
+                dict_to_xdr (this_args_cbk->xdata, &rsp_args->xdata);
+
+                if (!this_args_cbk->op_ret) {
+                        server4_post_lease (rsp_args, &this_args_cbk->lease);
+                }
+
+                rsp_args->op_ret = this_args_cbk->op_ret;
+                rsp_args->op_errno  = gf_errno_to_error
+                                      (this_args_cbk->op_errno);
+                break;
+        }
+        default:
+                return ENOTSUP;
+        }
+        op_errno = 0;
+out:
+        return op_errno;
+}
+/* This works only when the compound fop acts on one loc/inode/gfid.
+ * If compound fops on more than one inode is required, multiple
+ * resolve and resumes will have to be done. This will have to change.
+ * Right now, multiple unlinks, rmdirs etc is are not supported.
+ * This can be added for future enhancements.
+ */
+int
+server_get_compound_resolve_v2 (server_state_t *state, gfx_compound_req *req)
+{
+        int           i     = 0;
+        compound_req_v2 *array = NULL;
+
+        array = &req->compound_req_array.compound_req_array_val[i];
+
+        switch (array->fop_enum) {
+        case GF_FOP_STAT:
+        {
+                gfx_stat_req this_req = { {0,} };
+
+                this_req = array[i].compound_req_v2_u.compound_stat_req;
+
+                state->resolve.type  = RESOLVE_MUST;
+                memcpy (state->resolve.gfid,
+                        this_req.gfid, 16);
+                break;
+        }
+        case GF_FOP_READLINK:
+        {
+                gfx_readlink_req this_req = { {0,} };
+
+                this_req = array[i].compound_req_v2_u.compound_readlink_req;
+
+                state->resolve.type  = RESOLVE_MUST;
+                memcpy (state->resolve.gfid,
+                        this_req.gfid, 16);
+                break;
+        }
+        case GF_FOP_MKNOD:
+        {
+                gfx_mknod_req this_req = { {0,} };
+
+                this_req = array[i].compound_req_v2_u.compound_mknod_req;
+
+                state->resolve.type    = RESOLVE_NOT;
+                memcpy (state->resolve.pargfid, this_req.pargfid, 16);
+                state->resolve.bname = gf_strdup
+                                       (this_req.bname);
+                break;
+        }
+        case GF_FOP_MKDIR:
+        {
+                gfx_mkdir_req this_req = { {0,} };
+
+                this_req = array[i].compound_req_v2_u.compound_mkdir_req;
+
+                state->resolve.type    = RESOLVE_NOT;
+                memcpy (state->resolve.pargfid, this_req.pargfid, 16);
+                state->resolve.bname = gf_strdup
+                                       (this_req.bname);
+                break;
+        }
+        case GF_FOP_UNLINK:
+        {
+                gfx_unlink_req this_req = { {0,} };
+
+                this_req = array[i].compound_req_v2_u.compound_unlink_req;
+
+                state->resolve.type    = RESOLVE_MUST;
+                memcpy (state->resolve.pargfid, this_req.pargfid, 16);
+                state->resolve.bname = gf_strdup
+                                       (this_req.bname);
+                break;
+        }
+        case GF_FOP_RMDIR:
+        {
+                gfx_rmdir_req this_req = { {0,} };
+
+                this_req = array[i].compound_req_v2_u.compound_rmdir_req;
+
+                state->resolve.type    = RESOLVE_MUST;
+                memcpy (state->resolve.pargfid, this_req.pargfid, 16);
+                state->resolve.bname = gf_strdup
+                                       (this_req.bname);
+                break;
+        }
+        case GF_FOP_SYMLINK:
+        {
+                gfx_symlink_req this_req = { {0,} };
+
+                this_req = array[i].compound_req_v2_u.compound_symlink_req;
+
+                state->resolve.type   = RESOLVE_NOT;
+                memcpy (state->resolve.pargfid, this_req.pargfid, 16);
+                state->resolve.bname = gf_strdup
+                                       (this_req.bname);
+                break;
+        }
+        case GF_FOP_RENAME:
+        {
+                gfx_rename_req this_req = { {0,} };
+
+                this_req = array[i].compound_req_v2_u.compound_rename_req;
+
+                state->resolve.type   = RESOLVE_MUST;
+                state->resolve.bname = gf_strdup
+                                       (this_req.oldbname);
+                memcpy (state->resolve.pargfid, this_req.oldgfid, 16);
+
+                state->resolve2.type  = RESOLVE_MAY;
+                state->resolve2.bname = gf_strdup
+                                       (this_req.newbname);
+                memcpy (state->resolve2.pargfid, this_req.newgfid, 16);
+                break;
+        }
+        case GF_FOP_LINK:
+        {
+                gfx_link_req this_req = { {0,} };
+
+                this_req = array[i].compound_req_v2_u.compound_link_req;
+
+                state->resolve.type    = RESOLVE_MUST;
+                memcpy (state->resolve.gfid, this_req.oldgfid, 16);
+
+                state->resolve2.type   = RESOLVE_NOT;
+                state->resolve2.bname = gf_strdup
+                                       (this_req.newbname);
+                memcpy (state->resolve2.pargfid, this_req.newgfid, 16);
+                break;
+        }
+        case GF_FOP_TRUNCATE:
+        {
+                gfx_truncate_req this_req = { {0,} };
+
+                this_req = array[i].compound_req_v2_u.compound_truncate_req;
+
+                state->resolve.type  = RESOLVE_MUST;
+                memcpy (state->resolve.gfid,
+                        this_req.gfid, 16);
+                break;
+        }
+        case GF_FOP_OPEN:
+        {
+                gfx_open_req this_req = { {0,} };
+
+                this_req = array[i].compound_req_v2_u.compound_open_req;
+
+                state->resolve.type  = RESOLVE_MUST;
+                memcpy (state->resolve.gfid,
+                        this_req.gfid, 16);
+                break;
+        }
+        case GF_FOP_READ:
+        {
+                gfx_read_req this_req = { {0,} };
+
+                this_req = array[i].compound_req_v2_u.compound_read_req;
+
+                state->resolve.type  = RESOLVE_MUST;
+                memcpy (state->resolve.gfid,
+                        this_req.gfid, 16);
+                break;
+        }
+        case GF_FOP_WRITE:
+        {
+                gfx_write_req this_req = { {0,} };
+
+                this_req = array[i].compound_req_v2_u.compound_write_req;
+
+                state->resolve.type  = RESOLVE_MUST;
+                memcpy (state->resolve.gfid,
+                        this_req.gfid, 16);
+                break;
+        }
+        case GF_FOP_STATFS:
+        {
+                gfx_statfs_req this_req = { {0,} };
+
+                this_req = array[i].compound_req_v2_u.compound_statfs_req;
+
+                state->resolve.type  = RESOLVE_MUST;
+                memcpy (state->resolve.gfid,
+                        this_req.gfid, 16);
+                break;
+        }
+        case GF_FOP_FLUSH:
+        {
+                gfx_flush_req this_req = { {0,} };
+
+                this_req = array[i].compound_req_v2_u.compound_flush_req;
+
+                state->resolve.type  = RESOLVE_MUST;
+                memcpy (state->resolve.gfid,
+                        this_req.gfid, 16);
+                state->resolve.fd_no = this_req.fd;
+                break;
+        }
+        case GF_FOP_FSYNC:
+        {
+                gfx_fsync_req this_req = { {0,} };
+
+                this_req = array[i].compound_req_v2_u.compound_fsync_req;
+
+                state->resolve.type  = RESOLVE_MUST;
+                memcpy (state->resolve.gfid,
+                        this_req.gfid, 16);
+                state->resolve.fd_no = this_req.fd;
+                break;
+        }
+        case GF_FOP_SETXATTR:
+        {
+                gfx_setxattr_req this_req = { {0,} };
+
+                this_req = array[i].compound_req_v2_u.compound_setxattr_req;
+
+                state->resolve.type  = RESOLVE_MUST;
+                memcpy (state->resolve.gfid,
+                        this_req.gfid, 16);
+                break;
+        }
+        case GF_FOP_GETXATTR:
+        {
+                gfx_getxattr_req this_req = { {0,} };
+
+                this_req = array[i].compound_req_v2_u.compound_getxattr_req;
+
+                state->resolve.type  = RESOLVE_MUST;
+                memcpy (state->resolve.gfid,
+                        this_req.gfid, 16);
+                break;
+        }
+        case GF_FOP_REMOVEXATTR:
+        {
+                gfx_removexattr_req this_req = { {0,} };
+
+                this_req = array[i].compound_req_v2_u.compound_removexattr_req;
+
+                state->resolve.type  = RESOLVE_MUST;
+                memcpy (state->resolve.gfid,
+                        this_req.gfid, 16);
+                break;
+        }
+        case GF_FOP_OPENDIR:
+        {
+                gfx_opendir_req this_req = { {0,} };
+
+                this_req = array[i].compound_req_v2_u.compound_opendir_req;
+
+                state->resolve.type  = RESOLVE_MUST;
+                memcpy (state->resolve.gfid,
+                        this_req.gfid, 16);
+                break;
+        }
+        case GF_FOP_FSYNCDIR:
+        {
+                gfx_fsyncdir_req this_req = { {0,} };
+
+                this_req = array[i].compound_req_v2_u.compound_fsyncdir_req;
+
+                state->resolve.type  = RESOLVE_MUST;
+                memcpy (state->resolve.gfid,
+                        this_req.gfid, 16);
+                state->resolve.fd_no = this_req.fd;
+                break;
+        }
+        case GF_FOP_ACCESS:
+        {
+                gfx_access_req this_req = { {0,} };
+
+                this_req = array[i].compound_req_v2_u.compound_access_req;
+
+                state->resolve.type  = RESOLVE_MUST;
+                memcpy (state->resolve.gfid,
+                        this_req.gfid, 16);
+                break;
+        }
+        case GF_FOP_CREATE:
+        {
+                gfx_create_req this_req = { {0,} };
+
+                this_req = array[i].compound_req_v2_u.compound_create_req;
+
+                state->flags = gf_flags_to_flags (this_req.flags);
+                if (state->flags & O_EXCL) {
+                        state->resolve.type = RESOLVE_NOT;
+                } else {
+                        state->resolve.type = RESOLVE_DONTCARE;
+                }
+
+                memcpy (state->resolve.pargfid, this_req.pargfid, 16);
+                state->resolve.bname = gf_strdup
+                                       (this_req.bname);
+                break;
+        }
+        case GF_FOP_FTRUNCATE:
+        {
+                gfx_ftruncate_req this_req = { {0,} };
+
+                this_req = array[i].compound_req_v2_u.compound_ftruncate_req;
+
+                state->resolve.type  = RESOLVE_MUST;
+                memcpy (state->resolve.gfid,
+                        this_req.gfid, 16);
+                state->resolve.fd_no = this_req.fd;
+                break;
+        }
+        case GF_FOP_FSTAT:
+        {
+                gfx_fstat_req this_req = { {0,} };
+
+                this_req = array[i].compound_req_v2_u.compound_fstat_req;
+
+                state->resolve.type  = RESOLVE_MUST;
+                memcpy (state->resolve.gfid,
+                        this_req.gfid, 16);
+                state->resolve.fd_no = this_req.fd;
+                break;
+        }
+        case GF_FOP_LK:
+        {
+                gfx_lk_req this_req = { {0,} };
+
+                this_req = array[i].compound_req_v2_u.compound_lk_req;
+
+                memcpy (state->resolve.gfid,
+                        this_req.gfid, 16);
+                state->resolve.fd_no = this_req.fd;
+                break;
+        }
+        case GF_FOP_LOOKUP:
+        {
+                gfx_lookup_req this_req = { {0,} };
+
+                this_req = array[i].compound_req_v2_u.compound_lookup_req;
+                state->resolve.type   = RESOLVE_DONTCARE;
+
+                if (this_req.bname && strcmp (this_req.bname, "")) {
+                        memcpy (state->resolve.pargfid, this_req.pargfid, 16);
+                        state->resolve.bname = gf_strdup
+                                               (this_req.bname);
+                } else {
+                        memcpy (state->resolve.gfid, this_req.gfid, 16);
+                }
+                break;
+        }
+        case GF_FOP_READDIR:
+        {
+                gfx_readdir_req this_req = { {0,} };
+
+                this_req = array[i].compound_req_v2_u.compound_readdir_req;
+
+                state->resolve.type  = RESOLVE_MUST;
+                memcpy (state->resolve.gfid,
+                        this_req.gfid, 16);
+                state->resolve.fd_no = this_req.fd;
+                break;
+        }
+        case GF_FOP_INODELK:
+        {
+                gfx_inodelk_req this_req = { {0,} };
+
+                this_req = array[i].compound_req_v2_u.compound_inodelk_req;
+
+                state->resolve.type  = RESOLVE_EXACT;
+                memcpy (state->resolve.gfid,
+                        this_req.gfid, 16);
+                break;
+        }
+        case GF_FOP_FINODELK:
+        {
+                gfx_finodelk_req this_req = { {0,} };
+
+                this_req = array[i].compound_req_v2_u.compound_finodelk_req;
+
+                state->resolve.type  = RESOLVE_EXACT;
+                memcpy (state->resolve.gfid,
+                        this_req.gfid, 16);
+                state->resolve.fd_no = this_req.fd;
+                break;
+        }
+        case GF_FOP_ENTRYLK:
+        {
+                gfx_entrylk_req this_req = { {0,} };
+
+                this_req = array[i].compound_req_v2_u.compound_entrylk_req;
+
+                state->resolve.type  = RESOLVE_EXACT;
+                memcpy (state->resolve.gfid,
+                        this_req.gfid, 16);
+                break;
+        }
+        case GF_FOP_FENTRYLK:
+        {
+                gfx_fentrylk_req this_req = { {0,} };
+
+                this_req = array[i].compound_req_v2_u.compound_fentrylk_req;
+
+                state->resolve.type  = RESOLVE_EXACT;
+                memcpy (state->resolve.gfid,
+                        this_req.gfid, 16);
+                state->resolve.fd_no = this_req.fd;
+                break;
+        }
+        case GF_FOP_XATTROP:
+        {
+                gfx_xattrop_req this_req = { {0,} };
+
+                this_req = array[i].compound_req_v2_u.compound_xattrop_req;
+
+                state->resolve.type  = RESOLVE_MUST;
+                memcpy (state->resolve.gfid,
+                        this_req.gfid, 16);
+                break;
+        }
+        case GF_FOP_FXATTROP:
+        {
+                gfx_fxattrop_req this_req = { {0,} };
+
+                this_req = array[i].compound_req_v2_u.compound_fxattrop_req;
+
+                state->resolve.type  = RESOLVE_MUST;
+                memcpy (state->resolve.gfid,
+                        this_req.gfid, 16);
+                state->resolve.fd_no = this_req.fd;
+                break;
+        }
+        case GF_FOP_FGETXATTR:
+        {
+                gfx_fgetxattr_req this_req = { {0,} };
+
+                this_req = array[i].compound_req_v2_u.compound_fgetxattr_req;
+
+                state->resolve.type  = RESOLVE_MUST;
+                memcpy (state->resolve.gfid,
+                        this_req.gfid, 16);
+                state->resolve.fd_no = this_req.fd;
+                break;
+        }
+        case GF_FOP_FSETXATTR:
+        {
+                gfx_fsetxattr_req this_req = { {0,} };
+
+                this_req = array[i].compound_req_v2_u.compound_fsetxattr_req;
+
+                state->resolve.type  = RESOLVE_MUST;
+                memcpy (state->resolve.gfid,
+                        this_req.gfid, 16);
+                state->resolve.fd_no = this_req.fd;
+                break;
+        }
+        case GF_FOP_RCHECKSUM:
+        {
+                gfx_rchecksum_req this_req = { {0,},};
+
+                this_req = array[i].compound_req_v2_u.compound_rchecksum_req;
+
+                state->resolve.type  = RESOLVE_MAY;
+                state->resolve.fd_no = this_req.fd;
+                break;
+        }
+        case GF_FOP_SETATTR:
+        {
+                gfx_setattr_req this_req = { {0,} };
+
+                this_req = array[i].compound_req_v2_u.compound_setattr_req;
+
+                state->resolve.type  = RESOLVE_MUST;
+                memcpy (state->resolve.gfid,
+                        this_req.gfid, 16);
+                break;
+        }
+        case GF_FOP_FSETATTR:
+        {
+                gfx_fsetattr_req this_req = { {0,} };
+
+                this_req = array[i].compound_req_v2_u.compound_fsetattr_req;
+
+                state->resolve.type  = RESOLVE_MUST;
+                state->resolve.fd_no = this_req.fd;
+                break;
+        }
+        case GF_FOP_READDIRP:
+        {
+                gfx_readdirp_req this_req = { {0,} };
+
+                this_req = array[i].compound_req_v2_u.compound_readdirp_req;
+
+                state->resolve.type  = RESOLVE_MUST;
+                memcpy (state->resolve.gfid,
+                        this_req.gfid, 16);
+                state->resolve.fd_no = this_req.fd;
+                break;
+        }
+        case GF_FOP_FREMOVEXATTR:
+        {
+                gfx_fremovexattr_req this_req = { {0,} };
+
+                this_req = array[i].compound_req_v2_u.compound_fremovexattr_req;
+
+                state->resolve.type  = RESOLVE_MUST;
+                memcpy (state->resolve.gfid,
+                        this_req.gfid, 16);
+                state->resolve.fd_no = this_req.fd;
+                break;
+        }
+        case GF_FOP_FALLOCATE:
+        {
+                gfx_fallocate_req this_req = { {0,} };
+
+                this_req = array[i].compound_req_v2_u.compound_fallocate_req;
+
+                state->resolve.type  = RESOLVE_MUST;
+                memcpy (state->resolve.gfid,
+                        this_req.gfid, 16);
+                state->resolve.fd_no = this_req.fd;
+                break;
+        }
+        case GF_FOP_DISCARD:
+        {
+                gfx_discard_req this_req = { {0,} };
+
+                this_req = array[i].compound_req_v2_u.compound_discard_req;
+
+                state->resolve.type  = RESOLVE_MUST;
+                memcpy (state->resolve.gfid,
+                        this_req.gfid, 16);
+                state->resolve.fd_no = this_req.fd;
+                break;
+        }
+        case GF_FOP_ZEROFILL:
+        {
+                gfx_zerofill_req this_req = { {0,} };
+
+                this_req = array[i].compound_req_v2_u.compound_zerofill_req;
+
+                state->resolve.type  = RESOLVE_MUST;
+                memcpy (state->resolve.gfid,
+                        this_req.gfid, 16);
+                state->resolve.fd_no = this_req.fd;
+                break;
+        }
+        case GF_FOP_SEEK:
+        {
+                gfx_seek_req this_req = { {0,} };
+
+                this_req = array[i].compound_req_v2_u.compound_seek_req;
+
+                state->resolve.type  = RESOLVE_MUST;
+                memcpy (state->resolve.gfid,
+                        this_req.gfid, 16);
+                state->resolve.fd_no = this_req.fd;
+                break;
+        }
+        case GF_FOP_LEASE:
+        {
+                gfx_lease_req this_req = { {0,} };
+
+                this_req = array[i].compound_req_v2_u.compound_lease_req;
+
+                state->resolve.type = RESOLVE_MUST;
+                memcpy (state->resolve.gfid, this_req.gfid, 16);
+                break;
+        }
+        default:
+                return ENOTSUP;
+        }
+        return 0;
+}
+
+void
+server_compound_rsp_cleanup_v2 (gfx_compound_rsp *rsp, compound_args_cbk_t *args)
+{
+        int                     i, len         = 0;
+        compound_rsp_v2        *this_rsp       = NULL;
+
+        if (!rsp->compound_rsp_array.compound_rsp_array_val)
+                return;
+
+        len = rsp->compound_rsp_array.compound_rsp_array_len;
+
+        for (i = 0; i < len; i++) {
+                this_rsp = &rsp->compound_rsp_array.compound_rsp_array_val[i];
+                switch (args->enum_list[i]) {
+                case GF_FOP_STAT:
+                        SERVER4_FOP_RSP_CLEANUP (rsp, stat, i, common_iatt);
+                        break;
+                case GF_FOP_MKNOD:
+                        SERVER4_FOP_RSP_CLEANUP (rsp, mknod, i, common_3iatt);
+                        break;
+                case GF_FOP_MKDIR:
+                        SERVER4_FOP_RSP_CLEANUP (rsp, mkdir, i, common_3iatt);
+                        break;
+                case GF_FOP_UNLINK:
+                        SERVER4_FOP_RSP_CLEANUP (rsp, unlink, i, common_2iatt);
+                        break;
+                case GF_FOP_RMDIR:
+                        SERVER4_FOP_RSP_CLEANUP (rsp, rmdir, i, common_2iatt);
+                        break;
+                case GF_FOP_SYMLINK:
+                        SERVER4_FOP_RSP_CLEANUP (rsp, symlink, i, common_3iatt);
+                        break;
+                case GF_FOP_RENAME:
+                        SERVER4_FOP_RSP_CLEANUP (rsp, rename, i, rename);
+                        break;
+                case GF_FOP_LINK:
+                        SERVER4_FOP_RSP_CLEANUP (rsp, link, i, common_3iatt);
+                        break;
+                case GF_FOP_TRUNCATE:
+                        SERVER4_FOP_RSP_CLEANUP (rsp, truncate, i, common_2iatt);
+                        break;
+                case GF_FOP_OPEN:
+                        SERVER4_FOP_RSP_CLEANUP (rsp, open, i, open);
+                        break;
+                case GF_FOP_READ:
+                        SERVER4_FOP_RSP_CLEANUP (rsp, read, i, read);
+                        break;
+                case GF_FOP_WRITE:
+                        SERVER4_FOP_RSP_CLEANUP (rsp, write, i, common_2iatt);
+                        break;
+                case GF_FOP_STATFS:
+                        SERVER4_FOP_RSP_CLEANUP (rsp, statfs, i, statfs);
+                        break;
+                case GF_FOP_FSYNC:
+                        SERVER4_FOP_RSP_CLEANUP (rsp, fsync, i, common_2iatt);
+                        break;
+                case GF_FOP_OPENDIR:
+                        SERVER4_FOP_RSP_CLEANUP (rsp, opendir, i, open);
+                        break;
+                case GF_FOP_CREATE:
+                        SERVER4_FOP_RSP_CLEANUP (rsp, create, i, create);
+                        break;
+                case GF_FOP_FTRUNCATE:
+                        SERVER4_FOP_RSP_CLEANUP (rsp, ftruncate, i, common_2iatt);
+                        break;
+                case GF_FOP_FSTAT:
+                        SERVER4_FOP_RSP_CLEANUP (rsp, fstat, i, common_iatt);
+                        break;
+                case GF_FOP_LK:
+                        SERVER4_FOP_RSP_CLEANUP (rsp, lk, i, lk);
+                        break;
+                case GF_FOP_LOOKUP:
+                        SERVER4_FOP_RSP_CLEANUP (rsp, lookup, i, common_2iatt);
+                        break;
+                case GF_FOP_SETATTR:
+                        SERVER4_FOP_RSP_CLEANUP (rsp, setattr, i, common_2iatt);
+                        break;
+                case GF_FOP_FSETATTR:
+                        SERVER4_FOP_RSP_CLEANUP (rsp, fsetattr, i, common_2iatt);
+                        break;
+                case GF_FOP_FALLOCATE:
+                        SERVER4_FOP_RSP_CLEANUP (rsp, fallocate, i, common_2iatt);
+                        break;
+                case GF_FOP_DISCARD:
+                        SERVER4_FOP_RSP_CLEANUP (rsp, discard, i, common_2iatt);
+                        break;
+                case GF_FOP_ZEROFILL:
+                        SERVER4_FOP_RSP_CLEANUP (rsp, zerofill, i, common_2iatt);
+                        break;
+                case GF_FOP_SEEK:
+                        SERVER4_FOP_RSP_CLEANUP (rsp, seek, i, seek);
+                        break;
+                case GF_FOP_LEASE:
+                        SERVER4_FOP_RSP_CLEANUP (rsp, lease, i, lease);
+                        break;
+                case GF_FOP_READLINK:
+                        SERVER4_FOP_RSP_CLEANUP (rsp, readlink, i, readlink);
+                        break;
+                case GF_FOP_RCHECKSUM:
+                        SERVER4_FOP_RSP_CLEANUP (rsp, rchecksum, i, rchecksum);
+                        break;
+                /* fops that use gfx_common_rsp */
+                case GF_FOP_IPC:
+                        SERVER4_COMMON_RSP_CLEANUP (rsp, ipc, i);
+                        break;
+                case GF_FOP_FLUSH:
+                        SERVER4_COMMON_RSP_CLEANUP (rsp, flush, i);
+                        break;
+                case GF_FOP_SETXATTR:
+                        SERVER4_COMMON_RSP_CLEANUP (rsp, setxattr, i);
+                        break;
+                case GF_FOP_REMOVEXATTR:
+                        SERVER4_COMMON_RSP_CLEANUP (rsp, removexattr, i);
+                        break;
+                case GF_FOP_FSETXATTR:
+                        SERVER4_COMMON_RSP_CLEANUP (rsp, fsetxattr, i);
+                        break;
+                case GF_FOP_FREMOVEXATTR:
+                        SERVER4_COMMON_RSP_CLEANUP (rsp, fremovexattr, i);
+                        break;
+                case GF_FOP_FSYNCDIR:
+                        SERVER4_COMMON_RSP_CLEANUP (rsp, fsyncdir, i);
+                        break;
+                case GF_FOP_ACCESS:
+                        SERVER4_COMMON_RSP_CLEANUP (rsp, access, i);
+                        break;
+                case GF_FOP_INODELK:
+                        SERVER4_COMMON_RSP_CLEANUP (rsp, inodelk, i);
+                        break;
+                case GF_FOP_FINODELK:
+                        SERVER4_COMMON_RSP_CLEANUP (rsp, finodelk, i);
+                        break;
+                case GF_FOP_ENTRYLK:
+                        SERVER4_COMMON_RSP_CLEANUP (rsp, entrylk, i);
+                        break;
+                case GF_FOP_FENTRYLK:
+                        SERVER4_COMMON_RSP_CLEANUP (rsp, fentrylk, i);
+                        break;
+                /* fops that need extra cleanup */
+                case GF_FOP_XATTROP:
+                {
+                        gfx_common_dict_rsp *tmp_rsp = &CPD4_RSP_FIELD(this_rsp,
+                                                    xattrop);
+                        SERVER4_FOP_RSP_CLEANUP (rsp, xattrop, i, common_dict);
+                        GF_FREE (tmp_rsp->dict.pairs.pairs_val);
+                        break;
+                }
+                case GF_FOP_FXATTROP:
+                {
+                        gfx_common_dict_rsp *tmp_rsp = &CPD4_RSP_FIELD(this_rsp,
+                                                                      fxattrop);
+                        SERVER4_FOP_RSP_CLEANUP (rsp, fxattrop, i, common_dict);
+                        GF_FREE (tmp_rsp->dict.pairs.pairs_val);
+                        break;
+                }
+                case GF_FOP_READDIR:
+                {
+                        gfx_readdir_rsp *tmp_rsp = &CPD4_RSP_FIELD(this_rsp,
+                                                    readdir);
+                        SERVER4_FOP_RSP_CLEANUP (rsp, readdir, i, readdir);
+                        readdir_rsp_cleanup_v2 (tmp_rsp);
+                        break;
+                }
+                case GF_FOP_READDIRP:
+                {
+                        gfx_readdirp_rsp *tmp_rsp = &CPD4_RSP_FIELD(this_rsp,
+                                                     readdirp);
+                        SERVER4_FOP_RSP_CLEANUP (rsp, readdirp, i, readdirp);
+                        readdirp_rsp_cleanup_v2 (tmp_rsp);
+                        break;
+                }
+                case GF_FOP_GETXATTR:
+                {
+                        gfx_common_dict_rsp *tmp_rsp = &CPD4_RSP_FIELD(this_rsp,
+                                                     getxattr);
+                        SERVER4_FOP_RSP_CLEANUP (rsp, getxattr, i, common_dict);
+                        GF_FREE (tmp_rsp->dict.pairs.pairs_val);
+                        break;
+                }
+                case GF_FOP_FGETXATTR:
+                {
+                        gfx_common_dict_rsp *tmp_rsp = &CPD4_RSP_FIELD(this_rsp,
+                                                      fgetxattr);
+                        SERVER4_FOP_RSP_CLEANUP (rsp, fgetxattr, i, common_dict);
+                        GF_FREE (tmp_rsp->dict.pairs.pairs_val);
+                        break;
+                }
+                default:
+                        break;
+                }
+        }
+        GF_FREE (rsp->compound_rsp_array.compound_rsp_array_val);
+        return;
+}
+
+void
+server_compound_req_cleanup_v2 (gfx_compound_req *req, int len)
+{
+        int             i        = 0;
+        compound_req_v2   *curr_req = NULL;
+
+
+        if (!req->compound_req_array.compound_req_array_val)
+                return;
+
+        for (i = 0; i < len; i++) {
+                curr_req = &req->compound_req_array.compound_req_array_val[i];
+
+                switch (curr_req->fop_enum) {
+                case GF_FOP_MKDIR:
+                {
+                        gfx_mkdir_req *args = &CPD4_REQ_FIELD (curr_req, mkdir);
+
+                        free (args->bname);
+                        break;
+                }
+                case GF_FOP_UNLINK:
+                {
+                        gfx_unlink_req *args = &CPD4_REQ_FIELD (curr_req,
+                                                unlink);
+                        free (args->bname);
+                        break;
+                }
+                case GF_FOP_RMDIR:
+                {
+                        gfx_rmdir_req *args = &CPD4_REQ_FIELD (curr_req,
+                                               rmdir);
+                        free (args->bname);
+                        break;
+                }
+                case GF_FOP_SYMLINK:
+                {
+                        gfx_symlink_req *args = &CPD4_REQ_FIELD (curr_req,
+                                                 symlink);
+                        free (args->bname);
+                        free (args->linkname);
+                        break;
+                }
+                case GF_FOP_RENAME:
+                {
+                        gfx_rename_req *args = &CPD4_REQ_FIELD (curr_req,
+                                                rename);
+                        free (args->oldbname);
+                        free (args->newbname);
+                        break;
+                }
+                case GF_FOP_LINK:
+                {
+                        gfx_link_req *args = &CPD4_REQ_FIELD (curr_req,
+                                              link);
+                        free (args->newbname);
+                        break;
+                }
+                case GF_FOP_GETXATTR:
+                {
+                        gfx_getxattr_req *args = &CPD4_REQ_FIELD (curr_req,
+                                                  getxattr);
+
+                        free (args->name);
+                        break;
+                }
+                case GF_FOP_REMOVEXATTR:
+                {
+                        gfx_removexattr_req *args = &CPD4_REQ_FIELD (curr_req,
+                                                     removexattr);
+
+                        free (args->name);
+                        break;
+                }
+                case GF_FOP_CREATE:
+                {
+                        gfx_create_req *args = &CPD4_REQ_FIELD (curr_req,
+                                                create);
+
+                        free (args->bname);
+                        break;
+                }
+                case GF_FOP_LK:
+                {
+                        gfx_lk_req *args = &CPD4_REQ_FIELD (curr_req, lk);
+                        free (args->flock.lk_owner.lk_owner_val);
+                        break;
+                }
+                case GF_FOP_LOOKUP:
+                {
+                        gfx_lookup_req *args = &CPD4_REQ_FIELD (curr_req,
+                                                                lookup);
+                        free (args->bname);
+                        break;
+                }
+                case GF_FOP_INODELK:
+                {
+                        gfx_inodelk_req *args = &CPD4_REQ_FIELD (curr_req,
+                                                                 inodelk);
+
+                        free (args->volume);
+                        free (args->flock.lk_owner.lk_owner_val);
+                        break;
+                }
+                case GF_FOP_FINODELK:
+                {
+                        gfx_finodelk_req *args = &CPD4_REQ_FIELD (curr_req,
+                                                                  finodelk);
+
+                        free (args->volume);
+                        free (args->flock.lk_owner.lk_owner_val);
+                        break;
+                }
+                case GF_FOP_ENTRYLK:
+                {
+                        gfx_entrylk_req *args = &CPD4_REQ_FIELD (curr_req,
+                                                                 entrylk);
+
+                        free (args->volume);
+                        free (args->name);
+                        break;
+                }
+                case GF_FOP_FENTRYLK:
+                {
+                        gfx_fentrylk_req *args = &CPD4_REQ_FIELD (curr_req,
+                                                                  fentrylk);
+
+                        free (args->volume);
+                        free (args->name);
+                        break;
+                }
+                case GF_FOP_FGETXATTR:
+                {
+                        gfx_fgetxattr_req *args = &CPD4_REQ_FIELD (curr_req,
+                                                   fgetxattr);
+
+                        free (args->name);
+                        break;
+                }
+                case GF_FOP_FREMOVEXATTR:
+                {
+                        gfx_fremovexattr_req *args = &CPD4_REQ_FIELD(curr_req,
+                                                      fremovexattr);
+                        free (args->name);
+                        break;
+                }
+                default:
+                        break;
+                }
+        }
+
+        return;
+}
diff --git a/xlators/protocol/server/src/server-helpers.h b/xlators/protocol/server/src/server-helpers.h
index 1f47bc9dff1..9fe60fd231b 100644
--- a/xlators/protocol/server/src/server-helpers.h
+++ b/xlators/protocol/server/src/server-helpers.h
@@ -54,6 +54,8 @@ int serialize_rsp_dirent (gf_dirent_t *entries, gfs3_readdir_rsp *rsp);
 int serialize_rsp_direntp (gf_dirent_t *entries, gfs3_readdirp_rsp *rsp);
 int readdirp_rsp_cleanup (gfs3_readdirp_rsp *rsp);
 int readdir_rsp_cleanup (gfs3_readdir_rsp *rsp);
+int readdirp_rsp_cleanup_v2 (gfx_readdirp_rsp *rsp);
+int readdir_rsp_cleanup_v2 (gfx_readdir_rsp *rsp);
 int auth_set_username_passwd (dict_t *input_params, dict_t *config_params,
                               struct _client *client);
 
@@ -65,10 +67,15 @@ server_inode_new (inode_table_t *itable, uuid_t gfid);
 
 int
 serialize_rsp_locklist (lock_migration_info_t *locklist,
-                                                 gfs3_getactivelk_rsp *rsp);
+                        gfs3_getactivelk_rsp *rsp);
+int
+serialize_rsp_locklist_v2 (lock_migration_info_t *locklist,
+                           gfx_getactivelk_rsp *rsp);
 
 int
 getactivelkinfo_rsp_cleanup (gfs3_getactivelk_rsp  *rsp);
+int
+getactivelkinfo_rsp_cleanup_v2 (gfx_getactivelk_rsp  *rsp);
 
 int
 server_populate_compound_response (xlator_t *this, gfs3_compound_rsp *rsp,
@@ -86,4 +93,43 @@ server_compound_rsp_cleanup (gfs3_compound_rsp *rsp, compound_args_cbk_t *args);
 
 void
 server_compound_req_cleanup (gfs3_compound_req *req, int len);
+
+int
+unserialize_req_locklist (gfs3_setactivelk_req *req,
+                          lock_migration_info_t *lmi);
+
+int
+unserialize_req_locklist_v2 (gfx_setactivelk_req *req,
+                             lock_migration_info_t *lmi);
+
+int
+serialize_rsp_dirent (gf_dirent_t *entries, gfs3_readdir_rsp *rsp);
+
+int
+serialize_rsp_direntp (gf_dirent_t *entries, gfs3_readdirp_rsp *rsp);
+
+int
+serialize_rsp_dirent_v2 (gf_dirent_t *entries, gfx_readdir_rsp *rsp);
+
+int
+serialize_rsp_direntp_v2 (gf_dirent_t *entries, gfx_readdirp_rsp *rsp);
+
+int
+server_populate_compound_response_v2 (xlator_t *this, gfx_compound_rsp *rsp,
+                                      call_frame_t *frame,
+                                      compound_args_cbk_t *args_cbk, int index);
+int
+server_get_compound_resolve_v2 (server_state_t *state, gfx_compound_req *req);
+
+int
+server_populate_compound_request_v2 (gfx_compound_req *req, call_frame_t *frame,
+                                     default_args_t *this_args,
+                                     int index);
+void
+server_compound_rsp_cleanup_v2 (gfx_compound_rsp *rsp, compound_args_cbk_t *args);
+
+void
+server_compound_req_cleanup_v2 (gfx_compound_req *req, int len);
+
+
 #endif /* !_SERVER_HELPERS_H */
diff --git a/xlators/protocol/server/src/server-rpc-fops.c b/xlators/protocol/server/src/server-rpc-fops.c
index 1b87abaafda..7f2bd5e0312 100644
--- a/xlators/protocol/server/src/server-rpc-fops.c
+++ b/xlators/protocol/server/src/server-rpc-fops.c
@@ -46,7 +46,7 @@ forget_inode_if_no_dentry (inode_t *inode)
         return;
 }
 
-static void
+void
 set_resolve_gfid (client_t *client, uuid_t resolve_gfid,
                   char *on_wire_gfid)
 {
@@ -882,7 +882,7 @@ out:
 }
 
 /* print every key */
-static int
+int
 _gf_server_log_setxattr_failure (dict_t *d, char *k, data_t *v,
                                  void *tmp)
 {
@@ -2207,97 +2207,6 @@ out:
         return 0;
 }
 
-int
-server_namelink_cbk (call_frame_t *frame,
-                     void *cookie, xlator_t *this,
-                     int32_t op_ret, int32_t op_errno,
-                     struct iatt *prebuf, struct iatt *postbuf, dict_t *xdata)
-{
-        gfs4_namelink_rsp       rsp        = {0,};
-        rpcsvc_request_t    *req        = NULL;
-
-        GF_PROTOCOL_DICT_SERIALIZE (this, xdata, &rsp.xdata.xdata_val,
-                                    rsp.xdata.xdata_len, op_errno, out);
-
-        if (op_ret < 0)
-                goto out;
-
-        gf_stat_from_iatt (&rsp.preparent, prebuf);
-        gf_stat_from_iatt (&rsp.postparent, postbuf);
-
-        /**
-         * no point in linking inode here -- there's no stbuf anyway and a
-         * lookup() for this name entry would be a negative lookup.
-         */
-
-out:
-        rsp.op_ret    = op_ret;
-        rsp.op_errno  = gf_errno_to_error (op_errno);
-
-        req = frame->local;
-        server_submit_reply (frame, req, &rsp, NULL, 0, NULL,
-                             (xdrproc_t)xdr_gfs4_namelink_rsp);
-
-        GF_FREE (rsp.xdata.xdata_val);
-
-        return 0;
-}
-
-int
-server_icreate_cbk (call_frame_t *frame,
-                    void *cookie, xlator_t *this,
-                    int32_t op_ret, int32_t op_errno,
-                    inode_t *inode, struct iatt *stbuf, dict_t *xdata)
-{
-        server_state_t      *state      = NULL;
-        inode_t             *link_inode = NULL;
-        rpcsvc_request_t    *req        = NULL;
-        gfs3_create_rsp      rsp        = {0,};
-
-        GF_PROTOCOL_DICT_SERIALIZE (this, xdata, &rsp.xdata.xdata_val,
-                                    rsp.xdata.xdata_len, op_errno, out);
-
-        state = CALL_STATE (frame);
-
-        if (op_ret < 0) {
-                gf_msg (this->name, GF_LOG_INFO, op_errno, PS_MSG_CREATE_INFO,
-                        "%"PRId64": ICREATE [%s] ==> (%s)",
-                        frame->root->unique, uuid_utoa (state->resolve.gfid),
-                        strerror (op_errno));
-                goto out;
-        }
-
-        gf_msg_trace (frame->root->client->bound_xl->name, 0, "%"PRId64": "
-                      "ICREATE [%s]", frame->root->unique,
-                      uuid_utoa (stbuf->ia_gfid));
-
-        link_inode = inode_link (inode,
-                                 state->loc.parent, state->loc.name, stbuf);
-
-        if (!link_inode) {
-                op_ret = -1;
-                op_errno = ENOENT;
-                goto out;
-        }
-
-        inode_lookup (link_inode);
-        inode_unref (link_inode);
-
-        gf_stat_from_iatt (&rsp.stat, stbuf);
-
-out:
-        rsp.op_ret    = op_ret;
-        rsp.op_errno  = gf_errno_to_error (op_errno);
-
-        req = frame->local;
-        server_submit_reply (frame, req, &rsp, NULL, 0, NULL,
-                             (xdrproc_t)xdr_gfs4_icreate_rsp);
-
-        GF_FREE (rsp.xdata.xdata_val);
-
-        return 0;
-}
-
 /* Resume function section */
 
 int
@@ -3543,56 +3452,8 @@ err:
         return ret;
 }
 
-int
-server_namelink_resume (call_frame_t *frame, xlator_t *bound_xl)
-{
-        server_state_t *state = NULL;
-
-        state = CALL_STATE (frame);
-
-        if (state->resolve.op_ret != 0)
-                goto err;
-
-        state->loc.inode = inode_new (state->itable);
-
-        STACK_WIND (frame, server_namelink_cbk,
-                    bound_xl, bound_xl->fops->namelink,
-                    &(state->loc), state->xdata);
-        return 0;
-
- err:
-        server_namelink_cbk (frame, NULL,
-                             frame->this,
-                             state->resolve.op_ret,
-                             state->resolve.op_errno, NULL, NULL, NULL);
-        return 0;
-}
-
-int
-server_icreate_resume (call_frame_t *frame, xlator_t *bound_xl)
-{
-        server_state_t *state = NULL;
-
-        state = CALL_STATE (frame);
-
-        if (state->resolve.op_ret != 0)
-                goto err;
-
-        state->loc.inode = inode_new (state->itable);
-
-        STACK_WIND (frame, server_icreate_cbk,
-                    bound_xl, bound_xl->fops->icreate,
-                    &(state->loc), state->mode, state->xdata);
-
-        return 0;
-err:
-        server_icreate_cbk (frame, NULL, frame->this, state->resolve.op_ret,
-                            state->resolve.op_errno, NULL, NULL, NULL);
-        return 0;
-}
-
 /* Fop section */
-static inline int
+int
 rpc_receive_common (rpcsvc_request_t *req, call_frame_t **fr,
                     server_state_t **st, ssize_t *xdrlen, void *args,
                     void *xdrfn, glusterfs_fop_t fop)
@@ -6228,186 +6089,6 @@ out:
         return ret;
 }
 
-int
-server3_3_namelink (rpcsvc_request_t *req)
-{
-        server_state_t    *state    = NULL;
-        call_frame_t      *frame    = NULL;
-        gfs4_namelink_req  args     = {{0,},};
-        int                ret      = -1;
-        int                op_errno = 0;
-
-        if (!req)
-                return ret;
-
-        ret = rpc_receive_common (req, &frame, &state, NULL, &args,
-                                  xdr_gfs4_namelink_req, GF_FOP_NAMELINK);
-
-        if (ret != 0)
-                goto out;
-
-        state->resolve.bname = gf_strdup (args.bname);
-        memcpy (state->resolve.pargfid, args.pargfid, sizeof (uuid_t));
-
-        state->resolve.type = RESOLVE_NOT;
-
-        /* TODO: can do alloca for xdata field instead of stdalloc */
-        GF_PROTOCOL_DICT_UNSERIALIZE (frame->root->client->bound_xl,
-                                      state->xdata,
-                                      args.xdata.xdata_val,
-                                      args.xdata.xdata_len, ret,
-                                      op_errno, out);
-
-        ret = 0;
-        resolve_and_resume (frame, server_namelink_resume);
-
-out:
-        /* memory allocated by libc, don't use GF_FREE */
-        free (args.xdata.xdata_val);
-
-        if (op_errno)
-                SERVER_REQ_SET_ERROR (req, ret);
-
-        return ret;
-
-}
-
-int
-server3_3_icreate (rpcsvc_request_t *req)
-{
-        server_state_t   *state    = NULL;
-        call_frame_t     *frame    = NULL;
-        gfs4_icreate_req  args     = {{0,},};
-        int               ret      = -1;
-        int               op_errno = 0;
-        uuid_t            gfid     = {0,};
-
-        if (!req)
-                return ret;
-
-        ret = rpc_receive_common (req, &frame, &state, NULL, &args,
-                                  xdr_gfs4_icreate_req, GF_FOP_ICREATE);
-
-        if (ret != 0)
-                goto out;
-
-        memcpy (gfid, args.gfid, sizeof (uuid_t));
-
-        state->mode  = args.mode;
-        gf_asprintf (&state->resolve.bname, INODE_PATH_FMT, uuid_utoa (gfid));
-
-        /* parent is an auxillary inode number */
-        memset (state->resolve.pargfid, 0, sizeof (uuid_t));
-        state->resolve.pargfid[15] = GF_AUXILLARY_PARGFID;
-
-        state->resolve.type = RESOLVE_NOT;
-
-        /* TODO: can do alloca for xdata field instead of stdalloc */
-        GF_PROTOCOL_DICT_UNSERIALIZE (frame->root->client->bound_xl,
-                                      state->xdata,
-                                      args.xdata.xdata_val,
-                                      args.xdata.xdata_len, ret,
-                                      op_errno, out);
-
-        ret = 0;
-        resolve_and_resume (frame, server_icreate_resume);
-
-out:
-        /* memory allocated by libc, don't use GF_FREE */
-        free (args.xdata.xdata_val);
-
-        if (op_errno)
-                SERVER_REQ_SET_ERROR (req, ret);
-
-        return ret;
-}
-
-int
-server4_0_fsetattr (rpcsvc_request_t *req)
-{
-        server_state_t       *state    = NULL;
-        call_frame_t         *frame    = NULL;
-        gfs3_fsetattr_req_v2  args     = {{0},};
-        int                   ret      = -1;
-        int                   op_errno = 0;
-
-        if (!req)
-                return ret;
-
-        ret = rpc_receive_common (req, &frame, &state, NULL, &args,
-                                  xdr_gfs3_fsetattr_req_v2,
-                                  GF_FOP_FSETATTR);
-        if (ret != 0) {
-                goto out;
-        }
-
-        state->resolve.type   = RESOLVE_MUST;
-        state->resolve.fd_no  = args.fd;
-        memcpy (state->resolve.gfid, args.gfid, 16);
-
-        gf_stat_to_iatt (&args.stbuf, &state->stbuf);
-        state->valid = args.valid;
-
-        GF_PROTOCOL_DICT_UNSERIALIZE (frame->root->client->bound_xl,
-                                      state->xdata, (args.xdata.xdata_val),
-                                      (args.xdata.xdata_len), ret,
-                                      op_errno, out);
-
-        ret = 0;
-        resolve_and_resume (frame, server_fsetattr_resume);
-
-out:
-        free (args.xdata.xdata_val);
-
-        if (op_errno)
-                SERVER_REQ_SET_ERROR (req, ret);
-
-        return ret;
-}
-
-int
-server4_0_rchecksum (rpcsvc_request_t *req)
-{
-        server_state_t        *state    = NULL;
-        call_frame_t          *frame    = NULL;
-        gfs3_rchecksum_req_v2  args     = {{0},};
-        int                    ret      = -1;
-        int                    op_errno = 0;
-
-        if (!req)
-                return ret;
-
-        ret = rpc_receive_common (req, &frame, &state, NULL, &args,
-                                  xdr_gfs3_rchecksum_req_v2,
-                                  GF_FOP_RCHECKSUM);
-        if (ret != 0) {
-                goto out;
-        }
-
-        state->resolve.type  = RESOLVE_MAY;
-        state->resolve.fd_no = args.fd;
-        state->offset        = args.offset;
-        state->size          = args.len;
-
-        memcpy (state->resolve.gfid, args.gfid, 16);
-
-        GF_PROTOCOL_DICT_UNSERIALIZE (frame->root->client->bound_xl,
-                                      state->xdata, (args.xdata.xdata_val),
-                                      (args.xdata.xdata_len), ret,
-                                      op_errno, out);
-
-        ret = 0;
-        resolve_and_resume (frame, server_rchecksum_resume);
-out:
-        free (args.xdata.xdata_val);
-
-        if (op_errno)
-                SERVER_REQ_SET_ERROR (req, ret);
-
-        return ret;
-}
-
-
 
 rpcsvc_actor_t glusterfs3_3_fop_actors[GLUSTER_FOP_PROCCNT] = {
         [GFS3_OP_NULL]         = {"NULL",         GFS3_OP_NULL,         server_null,            NULL, 0, DRC_NA},
@@ -6513,9 +6194,9 @@ rpcsvc_actor_t glusterfs4_0_fop_actors[] = {
         [GFS3_OP_FXATTROP]    = { "FXATTROP",   GFS3_OP_FXATTROP, server3_3_fxattrop, NULL, 0},
         [GFS3_OP_FGETXATTR]   = { "FGETXATTR",  GFS3_OP_FGETXATTR, server3_3_fgetxattr, NULL, 0},
         [GFS3_OP_FSETXATTR]   = { "FSETXATTR",  GFS3_OP_FSETXATTR, server3_3_fsetxattr, NULL, 0},
-        [GFS3_OP_RCHECKSUM]   = { "RCHECKSUM",  GFS3_OP_RCHECKSUM, server4_0_rchecksum, NULL, 0},
+        [GFS3_OP_RCHECKSUM]   = { "RCHECKSUM",  GFS3_OP_RCHECKSUM, server3_3_rchecksum, NULL, 0},
         [GFS3_OP_SETATTR]     = { "SETATTR",    GFS3_OP_SETATTR, server3_3_setattr, NULL, 0},
-        [GFS3_OP_FSETATTR]    = { "FSETATTR",   GFS3_OP_FSETATTR, server4_0_fsetattr, NULL, 0},
+        [GFS3_OP_FSETATTR]    = { "FSETATTR",   GFS3_OP_FSETATTR, server3_3_fsetattr, NULL, 0},
         [GFS3_OP_READDIRP]    = { "READDIRP",   GFS3_OP_READDIRP, server3_3_readdirp, NULL, 0},
         [GFS3_OP_RELEASE]     = { "RELEASE",    GFS3_OP_RELEASE, server3_3_release, NULL, 0},
         [GFS3_OP_RELEASEDIR]  = { "RELEASEDIR", GFS3_OP_RELEASEDIR, server3_3_releasedir, NULL, 0},
@@ -6529,8 +6210,6 @@ rpcsvc_actor_t glusterfs4_0_fop_actors[] = {
         [GFS3_OP_GETACTIVELK]  = {"GETACTIVELK",  GFS3_OP_GETACTIVELK,  server3_3_getactivelk,  NULL, 0, DRC_NA},
         [GFS3_OP_SETACTIVELK]  = {"SETACTIVELK",  GFS3_OP_SETACTIVELK,  server3_3_setactivelk,  NULL, 0, DRC_NA},
         [GFS3_OP_COMPOUND]     = {"COMPOUND",     GFS3_OP_COMPOUND,     server3_3_compound,     NULL, 0, DRC_NA},
-        [GFS3_OP_ICREATE]     =  {"ICREATE",      GFS3_OP_ICREATE,      server3_3_icreate,      NULL, 0, DRC_NA},
-        [GFS3_OP_NAMELINK]    =  {"NAMELINK",     GFS3_OP_NAMELINK,     server3_3_namelink,     NULL, 0, DRC_NA},
 };
 
 
diff --git a/xlators/protocol/server/src/server-rpc-fops_v2.c b/xlators/protocol/server/src/server-rpc-fops_v2.c
new file mode 100644
index 00000000000..dca88ab85f5
--- /dev/null
+++ b/xlators/protocol/server/src/server-rpc-fops_v2.c
@@ -0,0 +1,5859 @@
+/*
+  Copyright (c) 2017 Red Hat, Inc. <http://www.redhat.com>
+  This file is part of GlusterFS.
+
+  This file is licensed to you under your choice of the GNU Lesser
+  General Public License, version 3 or any later version (LGPLv3 or
+  later), or the GNU General Public License, version 2 (GPLv2), in all
+  cases as published by the Free Software Foundation.
+*/
+
+#include <openssl/md5.h>
+
+#include "server.h"
+#include "server-helpers.h"
+#include "rpc-common-xdr.h"
+#include "glusterfs4-xdr.h"
+#include "glusterfs3.h"
+#include "compat-errno.h"
+#include "server-messages.h"
+#include "defaults.h"
+#include "default-args.h"
+#include "server-common.h"
+#include "xlator.h"
+#include "compound-fop-utils.h"
+
+#include "xdr-nfs3.h"
+
+#define SERVER_REQ_SET_ERROR(req, ret)                          \
+        do {                                                    \
+                rpcsvc_request_seterr (req, GARBAGE_ARGS);      \
+                ret = RPCSVC_ACTOR_ERROR;                       \
+        } while (0)
+
+extern int
+server3_3_getxattr (rpcsvc_request_t *req);
+extern int
+server3_3_fgetxattr (rpcsvc_request_t *req);
+extern int
+server3_3_setxattr (rpcsvc_request_t *req);
+extern int
+server3_3_fsetxattr (rpcsvc_request_t *req);
+extern int
+server3_3_xattrop (rpcsvc_request_t *req);
+extern int
+server3_3_fxattrop (rpcsvc_request_t *req);
+
+extern void
+set_resolve_gfid (client_t *client, uuid_t resolve_gfid,
+                  char *on_wire_gfid);
+extern int
+_gf_server_log_setxattr_failure (dict_t *d, char *k, data_t *v,
+                                 void *tmp);
+extern int
+rpc_receive_common (rpcsvc_request_t *req, call_frame_t **fr,
+                    server_state_t **st, ssize_t *xdrlen, void *args,
+                    void *xdrfn, glusterfs_fop_t fop);
+
+
+/* Callback function section */
+int
+server4_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)
+{
+        gfx_statfs_rsp      rsp    = {0,};
+        rpcsvc_request_t    *req    = NULL;
+
+        dict_to_xdr (xdata, &rsp.xdata);
+
+        if (op_ret < 0) {
+                gf_msg (this->name, GF_LOG_WARNING, op_errno, PS_MSG_STATFS,
+                        "%"PRId64": STATFS, client: %s, error-xlator: %s",
+                        frame->root->unique, STACK_CLIENT_NAME (frame->root),
+                        STACK_ERR_XL_NAME (frame->root));
+                goto out;
+        }
+
+        server4_post_statfs (&rsp, buf);
+
+out:
+        rsp.op_ret    = op_ret;
+        rsp.op_errno  = gf_errno_to_error (op_errno);
+
+        req = frame->local;
+        server_submit_reply (frame, req, &rsp, NULL, 0, NULL,
+                             (xdrproc_t)xdr_gfx_statfs_rsp);
+
+        GF_FREE (rsp.xdata.pairs.pairs_val);
+
+        return 0;
+}
+
+int
+server4_lookup_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
+                   int32_t op_ret, int32_t op_errno,
+                   inode_t *inode, struct iatt *stbuf, dict_t *xdata,
+                   struct iatt *postparent)
+{
+        rpcsvc_request_t    *req        = NULL;
+        server_state_t      *state      = NULL;
+        loc_t                fresh_loc  = {0,};
+        gfx_common_2iatt_rsp      rsp        = {0,};
+
+        state = CALL_STATE (frame);
+
+        if (state->is_revalidate == 1 && op_ret == -1) {
+                state->is_revalidate = 2;
+                loc_copy (&fresh_loc, &state->loc);
+                inode_unref (fresh_loc.inode);
+                fresh_loc.inode = server_inode_new (state->itable,
+                                                    fresh_loc.gfid);
+
+                STACK_WIND (frame, server4_lookup_cbk,
+                            frame->root->client->bound_xl,
+                            frame->root->client->bound_xl->fops->lookup,
+                            &fresh_loc, state->xdata);
+
+                loc_wipe (&fresh_loc);
+                return 0;
+        }
+
+        gfx_stat_from_iattx (&rsp.poststat, postparent);
+
+        dict_to_xdr (xdata, &rsp.xdata);
+
+        if (op_ret) {
+                if (state->is_revalidate && op_errno == ENOENT) {
+                        if (!__is_root_gfid (state->resolve.gfid)) {
+                                inode_unlink (state->loc.inode,
+                                              state->loc.parent,
+                                              state->loc.name);
+                                /**
+                                 * If the entry is not present, then just
+                                 * unlinking the associated dentry is not
+                                 * suffecient. This condition should be
+                                 * treated as unlink of the entry. So along
+                                 * with deleting the entry, its also important
+                                 * to forget the inode for it (if the dentry
+                                 * being considered was the last dentry).
+                                 * Otherwise it might lead to inode leak.
+                                 * It also might lead to wrong decisions being
+                                 * taken if the future lookups on this inode are
+                                 * successful since they are able to find the
+                                 * inode in the inode table (atleast gfid based
+                                 * lookups will be successful, if the lookup
+                                 * is a soft lookup)
+                                 */
+                                forget_inode_if_no_dentry (state->loc.inode);
+                        }
+                }
+                goto out;
+        }
+
+        server4_post_lookup (&rsp, frame, state, inode, stbuf);
+out:
+        rsp.op_ret   = op_ret;
+        rsp.op_errno = gf_errno_to_error (op_errno);
+
+        if (op_ret) {
+                if (state->resolve.bname) {
+                        gf_msg (this->name,
+                                fop_log_level (GF_FOP_LOOKUP, op_errno),
+                                op_errno, PS_MSG_LOOKUP_INFO,
+                                "%"PRId64": LOOKUP %s (%s/%s), client: %s, "
+                                "error-xlator: %s", frame->root->unique,
+                                state->loc.path,
+                                uuid_utoa (state->resolve.pargfid),
+                                state->resolve.bname,
+                                STACK_CLIENT_NAME (frame->root),
+                                STACK_ERR_XL_NAME (frame->root));
+                } else {
+                        gf_msg (this->name,
+                                fop_log_level (GF_FOP_LOOKUP, op_errno),
+                                op_errno, PS_MSG_LOOKUP_INFO,
+                                "%"PRId64": LOOKUP %s (%s), client: %s, "
+                                "error-xlator: %s",
+                                frame->root->unique, state->loc.path,
+                                uuid_utoa (state->resolve.gfid),
+                                STACK_CLIENT_NAME (frame->root),
+                                STACK_ERR_XL_NAME (frame->root));
+                }
+        }
+
+        req = frame->local;
+        server_submit_reply (frame, req, &rsp, NULL, 0, NULL,
+                             (xdrproc_t)xdr_gfx_common_2iatt_rsp);
+
+        GF_FREE (rsp.xdata.pairs.pairs_val);
+
+        return 0;
+}
+
+int
+server4_lease_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
+                  int32_t op_ret, int32_t op_errno, struct gf_lease *lease,
+                  dict_t *xdata)
+{
+        gfx_lease_rsp       rsp   = {0,};
+        rpcsvc_request_t    *req   = NULL;
+        server_state_t      *state = NULL;
+
+        dict_to_xdr (xdata, &rsp.xdata);
+
+        if (op_ret) {
+                state = CALL_STATE (frame);
+                gf_msg (this->name, fop_log_level (GF_FOP_LEASE, op_errno),
+                        op_errno, PS_MSG_LK_INFO,
+                       "%"PRId64": LEASE %s (%s), client: %s, error-xlator: %s",
+                        frame->root->unique, state->loc.path,
+                        uuid_utoa (state->resolve.gfid),
+                        STACK_CLIENT_NAME (frame->root),
+                        STACK_ERR_XL_NAME (frame->root));
+                goto out;
+        }
+        server4_post_lease (&rsp, lease);
+
+out:
+        rsp.op_ret    = op_ret;
+        rsp.op_errno  = gf_errno_to_error (op_errno);
+
+        req = frame->local;
+        server_submit_reply (frame, req, &rsp, NULL, 0, NULL,
+                             (xdrproc_t)xdr_gfx_lease_rsp);
+
+        GF_FREE (rsp.xdata.pairs.pairs_val);
+
+        return 0;
+}
+
+int
+server4_lk_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
+               int32_t op_ret, int32_t op_errno, struct gf_flock *lock,
+               dict_t *xdata)
+{
+        gfx_lk_rsp          rsp   = {0,};
+        rpcsvc_request_t    *req   = NULL;
+        server_state_t      *state = NULL;
+
+        dict_to_xdr (xdata, &rsp.xdata);
+
+        if (op_ret) {
+                state = CALL_STATE (frame);
+                gf_msg (this->name, fop_log_level (GF_FOP_LK, op_errno),
+                        op_errno, PS_MSG_LK_INFO,
+                        "%"PRId64": LK %"PRId64" (%s), client: %s, "
+                        "error-xlator: %s", frame->root->unique,
+                        state->resolve.fd_no, uuid_utoa (state->resolve.gfid),
+                        STACK_CLIENT_NAME (frame->root),
+                        STACK_ERR_XL_NAME (frame->root));
+                goto out;
+        }
+
+        server4_post_lk (this, &rsp, lock);
+out:
+        rsp.op_ret    = op_ret;
+        rsp.op_errno  = gf_errno_to_error (op_errno);
+
+        req = frame->local;
+        server_submit_reply (frame, req, &rsp, NULL, 0, NULL,
+                             (xdrproc_t)xdr_gfx_lk_rsp);
+
+        GF_FREE (rsp.xdata.pairs.pairs_val);
+
+        return 0;
+}
+
+
+int
+server4_inodelk_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
+                    int32_t op_ret, int32_t op_errno, dict_t *xdata)
+{
+        gfx_common_rsp    rsp        = {0,};
+        server_state_t   *state     = NULL;
+        rpcsvc_request_t *req       = NULL;
+
+        dict_to_xdr (xdata, &rsp.xdata);
+
+        state = CALL_STATE (frame);
+
+        if (op_ret < 0) {
+                gf_msg (this->name, fop_log_level (GF_FOP_INODELK, op_errno),
+                        op_errno, PS_MSG_INODELK_INFO,
+                        "%"PRId64": INODELK %s (%s), client: %s, "
+                        "error-xlator: %s", frame->root->unique,
+                        state->loc.path, uuid_utoa (state->resolve.gfid),
+                        STACK_CLIENT_NAME (frame->root),
+                        STACK_ERR_XL_NAME (frame->root));
+                goto out;
+        }
+
+out:
+        rsp.op_ret    = op_ret;
+        rsp.op_errno  = gf_errno_to_error (op_errno);
+
+        req = frame->local;
+        server_submit_reply (frame, req, &rsp, NULL, 0, NULL,
+                             (xdrproc_t)xdr_gfx_common_rsp);
+
+        GF_FREE (rsp.xdata.pairs.pairs_val);
+
+        return 0;
+}
+
+
+int
+server4_finodelk_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
+                     int32_t op_ret, int32_t op_errno, dict_t *xdata)
+{
+        gfx_common_rsp     rsp       = {0,};
+        server_state_t   *state     = NULL;
+        rpcsvc_request_t *req       = NULL;
+
+        dict_to_xdr (xdata, &rsp.xdata);
+
+        state = CALL_STATE (frame);
+
+        if (op_ret < 0) {
+                gf_msg (this->name, fop_log_level (GF_FOP_FINODELK, op_errno),
+                        op_errno, PS_MSG_INODELK_INFO,
+                        "%"PRId64": FINODELK %"PRId64" (%s), client: %s, "
+                        "error-xlator: %s", frame->root->unique,
+                        state->resolve.fd_no, uuid_utoa (state->resolve.gfid),
+                        STACK_CLIENT_NAME (frame->root),
+                        STACK_ERR_XL_NAME (frame->root));
+                goto out;
+        }
+
+out:
+        rsp.op_ret    = op_ret;
+        rsp.op_errno  = gf_errno_to_error (op_errno);
+
+        req = frame->local;
+        server_submit_reply (frame, req, &rsp, NULL, 0, NULL,
+                             (xdrproc_t)xdr_gfx_common_rsp);
+
+        GF_FREE (rsp.xdata.pairs.pairs_val);
+
+        return 0;
+}
+
+int
+server4_entrylk_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
+                    int32_t op_ret, int32_t op_errno, dict_t *xdata)
+{
+        gfx_common_rsp     rsp       = {0,};
+        server_state_t   *state     = NULL;
+        rpcsvc_request_t *req       = NULL;
+
+        dict_to_xdr (xdata, &rsp.xdata);
+
+        state = CALL_STATE (frame);
+
+        if (op_ret < 0) {
+                gf_msg (this->name, fop_log_level (GF_FOP_ENTRYLK, op_errno),
+                        op_errno, PS_MSG_ENTRYLK_INFO,
+                        "%"PRId64": ENTRYLK %s (%s), client: %s, "
+                        "error-xlator: %s", frame->root->unique,
+                        state->loc.path, uuid_utoa (state->resolve.gfid),
+                        STACK_CLIENT_NAME (frame->root),
+                        STACK_ERR_XL_NAME (frame->root));
+                goto out;
+        }
+
+out:
+        rsp.op_ret    = op_ret;
+        rsp.op_errno  = gf_errno_to_error (op_errno);
+
+        req = frame->local;
+        server_submit_reply (frame, req, &rsp, NULL, 0, NULL,
+                             (xdrproc_t)xdr_gfx_common_rsp);
+
+        GF_FREE (rsp.xdata.pairs.pairs_val);
+
+        return 0;
+}
+
+
+int
+server4_fentrylk_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
+                     int32_t op_ret, int32_t op_errno, dict_t *xdata)
+{
+        gfx_common_rsp     rsp       = {0,};
+        server_state_t   *state     = NULL;
+        rpcsvc_request_t *req       = NULL;
+
+        dict_to_xdr (xdata, &rsp.xdata);
+
+        state = CALL_STATE (frame);
+
+        if (op_ret < 0) {
+                gf_msg (this->name, fop_log_level (GF_FOP_FENTRYLK, op_errno),
+                        op_errno, PS_MSG_ENTRYLK_INFO,
+                        "%"PRId64": FENTRYLK %"PRId64" (%s), client: %s, "
+                        "error-xlator: %s", frame->root->unique,
+                        state->resolve.fd_no, uuid_utoa (state->resolve.gfid),
+                        STACK_CLIENT_NAME (frame->root),
+                        STACK_ERR_XL_NAME (frame->root));
+                goto out;
+        }
+
+out:
+        rsp.op_ret    = op_ret;
+        rsp.op_errno  = gf_errno_to_error (op_errno);
+
+        req   = frame->local;
+        server_submit_reply (frame, req, &rsp, NULL, 0, NULL,
+                             (xdrproc_t)xdr_gfx_common_rsp);
+
+        GF_FREE (rsp.xdata.pairs.pairs_val);
+
+        return 0;
+}
+
+
+int
+server4_access_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
+                   int32_t op_ret, int32_t op_errno, dict_t *xdata)
+{
+        gfx_common_rsp        rsp   = {0,};
+        rpcsvc_request_t    *req   = NULL;
+        server_state_t      *state = NULL;
+
+        dict_to_xdr (xdata, &rsp.xdata);
+
+        if (op_ret) {
+                state = CALL_STATE (frame);
+                gf_msg (this->name, GF_LOG_INFO,
+                        op_errno, PS_MSG_ACCESS_INFO,
+                        "%"PRId64": ACCESS %s (%s), client: %s, "
+                        "error-xlator: %s", frame->root->unique,
+                        (state->loc.path) ? state->loc.path : "",
+                        uuid_utoa (state->resolve.gfid),
+                        STACK_CLIENT_NAME (frame->root),
+                        STACK_ERR_XL_NAME (frame->root));
+                goto out;
+        }
+
+out:
+        rsp.op_ret    = op_ret;
+        rsp.op_errno  = gf_errno_to_error (op_errno);
+
+        req = frame->local;
+        server_submit_reply (frame, req, &rsp, NULL, 0, NULL,
+                             (xdrproc_t)xdr_gfx_common_rsp);
+
+        GF_FREE (rsp.xdata.pairs.pairs_val);
+
+        return 0;
+}
+
+int
+server4_rmdir_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
+                  int32_t op_ret, int32_t op_errno, struct iatt *preparent,
+                  struct iatt *postparent, dict_t *xdata)
+{
+        gfx_common_2iatt_rsp       rsp    = {0,};
+        server_state_t      *state  = NULL;
+        rpcsvc_request_t    *req    = NULL;
+
+        dict_to_xdr (xdata, &rsp.xdata);
+
+        state = CALL_STATE (frame);
+
+        if (op_ret) {
+                gf_msg (this->name, GF_LOG_INFO,
+                        op_errno, PS_MSG_DIR_INFO,
+                        "%"PRId64": RMDIR %s (%s/%s), client: %s, "
+                        "error-xlator: %s", frame->root->unique,
+                        (state->loc.path) ? state->loc.path : "",
+                        uuid_utoa (state->resolve.pargfid),
+                        state->resolve.bname, STACK_CLIENT_NAME (frame->root),
+                        STACK_ERR_XL_NAME (frame->root));
+                goto out;
+        }
+
+        server4_post_entry_remove (state, &rsp, preparent, postparent);
+
+out:
+        rsp.op_ret    = op_ret;
+        rsp.op_errno  = gf_errno_to_error (op_errno);
+
+        req = frame->local;
+        server_submit_reply (frame, req, &rsp, NULL, 0, NULL,
+                             (xdrproc_t)xdr_gfx_common_2iatt_rsp);
+
+        GF_FREE (rsp.xdata.pairs.pairs_val);
+
+        return 0;
+}
+
+int
+server4_mkdir_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
+                  int32_t op_ret, int32_t op_errno, inode_t *inode,
+                  struct iatt *stbuf, struct iatt *preparent,
+                  struct iatt *postparent, dict_t *xdata)
+{
+        gfx_common_3iatt_rsp       rsp        = {0,};
+        server_state_t      *state      = NULL;
+        rpcsvc_request_t    *req        = NULL;
+
+        dict_to_xdr (xdata, &rsp.xdata);
+
+        state = CALL_STATE (frame);
+
+        if (op_ret < 0) {
+                gf_msg (this->name, fop_log_level (GF_FOP_MKDIR, op_errno),
+                        op_errno, PS_MSG_DIR_INFO,
+                        "%"PRId64": MKDIR %s (%s/%s) client: %s, "
+                        "error-xlator: %s", frame->root->unique,
+                        (state->loc.path) ? state->loc.path : "",
+                        uuid_utoa (state->resolve.pargfid),
+                        state->resolve.bname,
+                        STACK_CLIENT_NAME (frame->root),
+                        STACK_ERR_XL_NAME (frame->root));
+                goto out;
+        }
+
+        server4_post_common_3iatt (state, &rsp, inode, stbuf, preparent,
+                                   postparent);
+out:
+        rsp.op_ret    = op_ret;
+        rsp.op_errno  = gf_errno_to_error (op_errno);
+
+        req = frame->local;
+        server_submit_reply (frame, req, &rsp, NULL, 0, NULL,
+                             (xdrproc_t)xdr_gfx_common_3iatt_rsp);
+
+        GF_FREE (rsp.xdata.pairs.pairs_val);
+
+        return 0;
+}
+
+int
+server4_mknod_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
+                  int32_t op_ret, int32_t op_errno,
+                  inode_t *inode, struct iatt *stbuf, struct iatt *preparent,
+                  struct iatt *postparent, dict_t *xdata)
+{
+        gfx_common_3iatt_rsp       rsp        = {0,};
+        server_state_t      *state      = NULL;
+        rpcsvc_request_t    *req        = NULL;
+
+        dict_to_xdr (xdata, &rsp.xdata);
+
+        state = CALL_STATE (frame);
+
+        if (op_ret < 0) {
+                gf_msg (this->name, fop_log_level (GF_FOP_MKNOD, op_errno),
+                        op_errno, PS_MSG_MKNOD_INFO,
+                        "%"PRId64": MKNOD %s (%s/%s), client: %s, "
+                        "error-xlator: %s", frame->root->unique,
+                        state->loc.path, uuid_utoa (state->resolve.pargfid),
+                        state->resolve.bname, STACK_CLIENT_NAME (frame->root),
+                        STACK_ERR_XL_NAME (frame->root));
+                goto out;
+        }
+
+        server4_post_common_3iatt (state, &rsp, inode, stbuf, preparent,
+                                   postparent);
+out:
+        rsp.op_ret    = op_ret;
+        rsp.op_errno  = gf_errno_to_error (op_errno);
+
+        req = frame->local;
+        server_submit_reply (frame, req, &rsp, NULL, 0, NULL,
+                             (xdrproc_t)xdr_gfx_common_3iatt_rsp);
+
+        GF_FREE (rsp.xdata.pairs.pairs_val);
+
+        return 0;
+}
+
+int
+server4_fsyncdir_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
+                     int32_t op_ret, int32_t op_errno, dict_t *xdata)
+{
+        gfx_common_rsp        rsp   = {0,};
+        server_state_t      *state = NULL;
+        rpcsvc_request_t    *req   = NULL;
+
+        dict_to_xdr (xdata, &rsp.xdata);
+
+        if (op_ret < 0) {
+                state = CALL_STATE (frame);
+                gf_msg (this->name, fop_log_level (GF_FOP_FSYNCDIR, op_errno),
+                        op_errno, PS_MSG_DIR_INFO,
+                        "%"PRId64": FSYNCDIR %"PRId64" (%s), client: %s, "
+                        "error-xlator: %s", frame->root->unique,
+                        state->resolve.fd_no, uuid_utoa (state->resolve.gfid),
+                        STACK_CLIENT_NAME (frame->root),
+                        STACK_ERR_XL_NAME (frame->root));
+                goto out;
+        }
+
+out:
+        rsp.op_ret    = op_ret;
+        rsp.op_errno  = gf_errno_to_error (op_errno);
+
+        req = frame->local;
+        server_submit_reply (frame, req, &rsp, NULL, 0, NULL,
+                             (xdrproc_t)xdr_gfx_common_rsp);
+
+        GF_FREE (rsp.xdata.pairs.pairs_val);
+
+        return 0;
+}
+
+int
+server4_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)
+{
+        gfx_readdir_rsp     rsp   = {0,};
+        server_state_t      *state = NULL;
+        rpcsvc_request_t    *req   = NULL;
+        int                  ret   = 0;
+
+        dict_to_xdr (xdata, &rsp.xdata);
+
+        if (op_ret < 0) {
+                state = CALL_STATE (frame);
+                gf_msg (this->name, fop_log_level (GF_FOP_READDIR, op_errno),
+                        op_errno, PS_MSG_DIR_INFO,
+                        "%"PRId64": READDIR %"PRId64" (%s), client: %s, "
+                        "error-xlator: %s", frame->root->unique,
+                        state->resolve.fd_no, uuid_utoa (state->resolve.gfid),
+                        STACK_CLIENT_NAME (frame->root),
+                        STACK_ERR_XL_NAME (frame->root));
+                goto out;
+        }
+
+        /* (op_ret == 0) is valid, and means EOF */
+        if (op_ret) {
+                ret = server4_post_readdir (&rsp, entries);
+                if (ret == -1) {
+                        op_ret   = -1;
+                        op_errno = ENOMEM;
+                        goto out;
+                }
+        }
+
+out:
+        rsp.op_ret    = op_ret;
+        rsp.op_errno  = gf_errno_to_error (op_errno);
+
+        req = frame->local;
+        server_submit_reply (frame, req, &rsp, NULL, 0, NULL,
+                             (xdrproc_t)xdr_gfx_readdir_rsp);
+
+        GF_FREE (rsp.xdata.pairs.pairs_val);
+
+        readdir_rsp_cleanup_v2 (&rsp);
+
+        return 0;
+}
+
+int
+server4_opendir_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
+                    int32_t op_ret, int32_t op_errno, fd_t *fd, dict_t *xdata)
+{
+        server_state_t      *state    = NULL;
+        rpcsvc_request_t    *req      = NULL;
+        gfx_open_rsp         rsp      = {0,};
+        uint64_t             fd_no    = 0;
+
+        dict_to_xdr (xdata, &rsp.xdata);
+
+        if (op_ret < 0) {
+                state = CALL_STATE (frame);
+                gf_msg (this->name, fop_log_level (GF_FOP_OPENDIR, op_errno),
+                        op_errno, PS_MSG_DIR_INFO,
+                        "%"PRId64": OPENDIR %s (%s), client: %s, "
+                        "error-xlator: %s", frame->root->unique,
+                        (state->loc.path) ? state->loc.path : "",
+                        uuid_utoa (state->resolve.gfid),
+                        STACK_CLIENT_NAME (frame->root),
+                        STACK_ERR_XL_NAME (frame->root));
+                goto out;
+        }
+
+
+        op_ret = server4_post_open (frame, this, &rsp, fd);
+        if (op_ret)
+                goto out;
+out:
+        if (op_ret)
+                rsp.fd = fd_no;
+        rsp.op_ret    = op_ret;
+        rsp.op_errno  = gf_errno_to_error (op_errno);
+
+        req = frame->local;
+        server_submit_reply (frame, req, &rsp, NULL, 0, NULL,
+                             (xdrproc_t)xdr_gfx_open_rsp);
+
+        GF_FREE (rsp.xdata.pairs.pairs_val);
+
+        return 0;
+}
+
+int
+server4_removexattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
+                        int32_t op_ret, int32_t op_errno, dict_t *xdata)
+{
+        gfx_common_rsp        rsp   = {0,};
+        rpcsvc_request_t    *req   = NULL;
+        server_state_t      *state = NULL;
+        gf_loglevel_t        loglevel = GF_LOG_NONE;
+
+        dict_to_xdr (xdata, &rsp.xdata);
+
+        if (op_ret == -1) {
+                state = CALL_STATE (frame);
+                if (ENODATA == op_errno || ENOATTR == op_errno)
+                        loglevel = GF_LOG_DEBUG;
+                else
+                        loglevel = GF_LOG_INFO;
+
+                gf_msg (this->name, loglevel, op_errno,
+                        PS_MSG_REMOVEXATTR_INFO,
+                        "%"PRId64": REMOVEXATTR %s (%s) of key %s, client: %s, "
+                        "error-xlator: %s",
+                        frame->root->unique, state->loc.path,
+                        uuid_utoa (state->resolve.gfid),
+                        state->name, STACK_CLIENT_NAME (frame->root),
+                        STACK_ERR_XL_NAME (frame->root));
+                goto out;
+        }
+
+out:
+        rsp.op_ret    = op_ret;
+        rsp.op_errno  = gf_errno_to_error (op_errno);
+
+        req   = frame->local;
+        server_submit_reply (frame, req, &rsp, NULL, 0, NULL,
+                             (xdrproc_t)xdr_gfx_common_rsp);
+
+        GF_FREE (rsp.xdata.pairs.pairs_val);
+
+        return 0;
+}
+
+int
+server4_fremovexattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
+                         int32_t op_ret, int32_t op_errno, dict_t *xdata)
+{
+        gfx_common_rsp        rsp   = {0,};
+        rpcsvc_request_t    *req   = NULL;
+        server_state_t      *state = NULL;
+
+        dict_to_xdr (xdata, &rsp.xdata);
+
+        if (op_ret == -1) {
+                state = CALL_STATE (frame);
+                gf_msg (this->name,
+                        fop_log_level (GF_FOP_FREMOVEXATTR, op_errno), op_errno,
+                        PS_MSG_REMOVEXATTR_INFO,
+                        "%"PRId64": FREMOVEXATTR %"PRId64" (%s) (%s), "
+                        "client: %s, error-xlator: %s", frame->root->unique,
+                        state->resolve.fd_no, uuid_utoa (state->resolve.gfid),
+                        state->name, STACK_CLIENT_NAME (frame->root),
+                        STACK_ERR_XL_NAME (frame->root));
+                goto out;
+        }
+
+out:
+        rsp.op_ret    = op_ret;
+        rsp.op_errno  = gf_errno_to_error (op_errno);
+
+        req   = frame->local;
+        server_submit_reply (frame, req, &rsp, NULL, 0, NULL,
+                             (xdrproc_t)xdr_gfx_common_rsp);
+
+        GF_FREE (rsp.xdata.pairs.pairs_val);
+
+        return 0;
+}
+
+int
+server4_getxattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
+                     int32_t op_ret, int32_t op_errno, dict_t *dict,
+                     dict_t *xdata)
+{
+        gfx_common_dict_rsp    rsp   = {0,};
+        rpcsvc_request_t    *req   = NULL;
+        server_state_t      *state = NULL;
+
+        dict_to_xdr (xdata, &rsp.xdata);
+
+        if (op_ret == -1) {
+                state = CALL_STATE (frame);
+                gf_msg (this->name, fop_log_level (GF_FOP_GETXATTR, op_errno),
+                        op_errno, PS_MSG_GETXATTR_INFO,
+                        "%"PRId64": GETXATTR %s (%s) (%s), client: %s, "
+                        "error-xlator: %s", frame->root->unique,
+                        state->loc.path, uuid_utoa (state->resolve.gfid),
+                        state->name, STACK_CLIENT_NAME (frame->root),
+                        STACK_ERR_XL_NAME (frame->root));
+                goto out;
+        }
+
+        dict_to_xdr (dict, &rsp.dict);
+out:
+        rsp.op_ret        = op_ret;
+        rsp.op_errno      = gf_errno_to_error (op_errno);
+
+        req = frame->local;
+        server_submit_reply (frame, req, &rsp, NULL, 0, NULL,
+                             (xdrproc_t)xdr_gfx_common_dict_rsp);
+
+        GF_FREE (rsp.dict.pairs.pairs_val);
+
+        GF_FREE (rsp.xdata.pairs.pairs_val);
+
+        return 0;
+}
+
+
+int
+server4_fgetxattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
+                      int32_t op_ret, int32_t op_errno, dict_t *dict,
+                      dict_t *xdata)
+{
+        gfx_common_dict_rsp   rsp   = {0,};
+        server_state_t      *state = NULL;
+        rpcsvc_request_t    *req   = NULL;
+
+        dict_to_xdr (xdata, &rsp.xdata);
+
+        if (op_ret == -1) {
+                state = CALL_STATE (frame);
+                gf_msg (this->name, fop_log_level (GF_FOP_FGETXATTR, op_errno),
+                        op_errno, PS_MSG_GETXATTR_INFO,
+                        "%"PRId64": FGETXATTR %"PRId64" (%s) (%s), "
+                        "client: %s, error-xlator: %s", frame->root->unique,
+                        state->resolve.fd_no, uuid_utoa (state->resolve.gfid),
+                        state->name, STACK_CLIENT_NAME (frame->root),
+                        STACK_ERR_XL_NAME (frame->root));
+                goto out;
+        }
+
+        dict_to_xdr (dict, &rsp.dict);
+out:
+        rsp.op_ret        = op_ret;
+        rsp.op_errno      = gf_errno_to_error (op_errno);
+
+        req = frame->local;
+        server_submit_reply (frame, req, &rsp, NULL, 0, NULL,
+                             (xdrproc_t)xdr_gfx_common_dict_rsp);
+
+        GF_FREE (rsp.dict.pairs.pairs_val);
+
+        GF_FREE (rsp.xdata.pairs.pairs_val);
+
+        return 0;
+}
+
+int
+server4_setxattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
+                     int32_t op_ret, int32_t op_errno, dict_t *xdata)
+{
+        gfx_common_rsp     rsp = {0,};
+        rpcsvc_request_t *req = NULL;
+        server_state_t      *state = NULL;
+
+        dict_to_xdr (xdata, &rsp.xdata);
+
+        if (op_ret == -1) {
+                state = CALL_STATE (frame);
+                if (op_errno != ENOTSUP)
+                        dict_foreach (state->dict,
+                                      _gf_server_log_setxattr_failure,
+                                      frame);
+
+                if (op_errno == ENOTSUP) {
+                        gf_msg_debug (THIS->name, 0, "%s",
+                                      strerror (op_errno));
+                } else {
+                        gf_msg (THIS->name, GF_LOG_INFO, op_errno,
+                                PS_MSG_SETXATTR_INFO, "client: %s, "
+                                "error-xlator: %s",
+                                STACK_CLIENT_NAME (frame->root),
+                                STACK_ERR_XL_NAME (frame->root));
+                }
+                goto out;
+        }
+
+out:
+        rsp.op_ret    = op_ret;
+        rsp.op_errno  = gf_errno_to_error (op_errno);
+
+        req = frame->local;
+        server_submit_reply (frame, req, &rsp, NULL, 0, NULL,
+                             (xdrproc_t)xdr_gfx_common_rsp);
+
+        GF_FREE (rsp.xdata.pairs.pairs_val);
+
+        return 0;
+}
+
+int
+server4_fsetxattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
+                      int32_t op_ret, int32_t op_errno, dict_t *xdata)
+{
+        gfx_common_rsp     rsp = {0,};
+        rpcsvc_request_t *req = NULL;
+        server_state_t      *state = NULL;
+
+        dict_to_xdr (xdata, &rsp.xdata);
+
+        if (op_ret == -1) {
+                state = CALL_STATE (frame);
+                if (op_errno != ENOTSUP) {
+                        dict_foreach (state->dict,
+                                      _gf_server_log_setxattr_failure,
+                                      frame);
+                }
+                if (op_errno == ENOTSUP) {
+                        gf_msg_debug (THIS->name, 0, "%s",
+                                      strerror (op_errno));
+                } else {
+                        gf_msg (THIS->name, GF_LOG_INFO, op_errno,
+                                PS_MSG_SETXATTR_INFO, "client: %s, "
+                                "error-xlator: %s",
+                                STACK_CLIENT_NAME (frame->root),
+                                STACK_ERR_XL_NAME (frame->root));
+                }
+                goto out;
+        }
+
+out:
+        rsp.op_ret    = op_ret;
+        rsp.op_errno  = gf_errno_to_error (op_errno);
+
+        req = frame->local;
+        server_submit_reply (frame, req, &rsp, NULL, 0, NULL,
+                             (xdrproc_t)xdr_gfx_common_rsp);
+
+        GF_FREE (rsp.xdata.pairs.pairs_val);
+
+        return 0;
+}
+
+int
+server4_rename_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
+                   int32_t op_ret, int32_t op_errno, struct iatt *stbuf,
+                   struct iatt *preoldparent, struct iatt *postoldparent,
+                   struct iatt *prenewparent, struct iatt *postnewparent,
+                   dict_t *xdata)
+{
+        gfx_rename_rsp      rsp        = {0,};
+        server_state_t      *state      = NULL;
+        rpcsvc_request_t    *req        = NULL;
+        char         oldpar_str[50]     = {0,};
+        char         newpar_str[50]     = {0,};
+
+        dict_to_xdr (xdata, &rsp.xdata);
+
+        state = CALL_STATE (frame);
+
+        if (op_ret == -1) {
+                uuid_utoa_r (state->resolve.pargfid, oldpar_str);
+                uuid_utoa_r (state->resolve2.pargfid, newpar_str);
+                gf_msg (this->name, GF_LOG_INFO, op_errno, PS_MSG_RENAME_INFO,
+                        "%"PRId64": RENAME %s (%s/%s) -> %s (%s/%s), "
+                        "client: %s, error-xlator: %s", frame->root->unique,
+                        state->loc.path, oldpar_str, state->resolve.bname,
+                        state->loc2.path, newpar_str, state->resolve2.bname,
+                        STACK_CLIENT_NAME (frame->root),
+                        STACK_ERR_XL_NAME (frame->root));
+                goto out;
+        }
+
+        server4_post_rename (frame, state, &rsp, stbuf,
+                            preoldparent, postoldparent,
+                            prenewparent, postnewparent);
+out:
+        rsp.op_ret    = op_ret;
+        rsp.op_errno  = gf_errno_to_error (op_errno);
+
+        req   = frame->local;
+        server_submit_reply (frame, req, &rsp, NULL, 0, NULL,
+                             (xdrproc_t)xdr_gfx_rename_rsp);
+
+        GF_FREE (rsp.xdata.pairs.pairs_val);
+
+        return 0;
+}
+
+int
+server4_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)
+{
+        gfx_common_2iatt_rsp      rsp    = {0,};
+        server_state_t      *state  = NULL;
+        rpcsvc_request_t    *req    = NULL;
+
+        dict_to_xdr (xdata, &rsp.xdata);
+
+        state = CALL_STATE (frame);
+
+        if (op_ret) {
+                gf_msg (this->name, fop_log_level (GF_FOP_UNLINK, op_errno),
+                        op_errno, PS_MSG_LINK_INFO,
+                        "%"PRId64": UNLINK %s (%s/%s), client: %s, "
+                        "error-xlator: %s", frame->root->unique,
+                        state->loc.path, uuid_utoa (state->resolve.pargfid),
+                        state->resolve.bname,
+                        STACK_CLIENT_NAME (frame->root),
+                        STACK_ERR_XL_NAME (frame->root));
+                goto out;
+        }
+
+        /* TODO: log gfid of the inodes */
+        gf_msg_trace (frame->root->client->bound_xl->name, 0, "%"PRId64": "
+                      "UNLINK_CBK %s", frame->root->unique, state->loc.name);
+
+        server4_post_entry_remove (state, &rsp, preparent, postparent);
+
+out:
+        rsp.op_ret    = op_ret;
+        rsp.op_errno  = gf_errno_to_error (op_errno);
+
+        req = frame->local;
+        server_submit_reply (frame, req, &rsp, NULL, 0, NULL,
+                             (xdrproc_t)xdr_gfx_common_2iatt_rsp);
+
+        GF_FREE (rsp.xdata.pairs.pairs_val);
+
+        return 0;
+}
+
+int
+server4_symlink_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
+                    int32_t op_ret, int32_t op_errno, inode_t *inode,
+                    struct iatt *stbuf, struct iatt *preparent,
+                    struct iatt *postparent, dict_t *xdata)
+{
+        gfx_common_3iatt_rsp     rsp        = {0,};
+        server_state_t      *state      = NULL;
+        rpcsvc_request_t    *req        = NULL;
+
+        dict_to_xdr (xdata, &rsp.xdata);
+
+        state = CALL_STATE (frame);
+
+        if (op_ret < 0) {
+                gf_msg (this->name, GF_LOG_INFO, op_errno, PS_MSG_LINK_INFO,
+                        "%"PRId64": SYMLINK %s (%s/%s), client: %s, "
+                        "error-xlator:%s", frame->root->unique,
+                        (state->loc.path) ? state->loc.path : "",
+                        uuid_utoa (state->resolve.pargfid),
+                        state->resolve.bname,
+                        STACK_CLIENT_NAME (frame->root),
+                        STACK_ERR_XL_NAME (frame->root));
+                goto out;
+        }
+
+        server4_post_common_3iatt (state, &rsp, inode, stbuf, preparent,
+                                   postparent);
+
+out:
+        rsp.op_ret    = op_ret;
+        rsp.op_errno  = gf_errno_to_error (op_errno);
+
+        req = frame->local;
+        server_submit_reply (frame, req, &rsp, NULL, 0, NULL,
+                             (xdrproc_t)xdr_gfx_common_3iatt_rsp);
+
+        GF_FREE (rsp.xdata.pairs.pairs_val);
+
+        return 0;
+}
+
+
+int
+server4_link_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
+                 int32_t op_ret, int32_t op_errno, inode_t *inode,
+                 struct iatt *stbuf, struct iatt *preparent,
+                 struct iatt *postparent, dict_t *xdata)
+{
+        gfx_common_3iatt_rsp rsp         = {0,};
+        server_state_t      *state       = NULL;
+        rpcsvc_request_t    *req         = NULL;
+        char              gfid_str[50]   = {0,};
+        char              newpar_str[50] = {0,};
+
+        dict_to_xdr (xdata, &rsp.xdata);
+
+        state = CALL_STATE (frame);
+
+        if (op_ret) {
+                uuid_utoa_r (state->resolve.gfid, gfid_str);
+                uuid_utoa_r (state->resolve2.pargfid, newpar_str);
+
+                gf_msg (this->name, GF_LOG_INFO, op_errno, PS_MSG_LINK_INFO,
+                        "%"PRId64": LINK %s (%s) -> %s/%s, client: %s, "
+                        "error-xlator: %s", frame->root->unique,
+                        state->loc.path, gfid_str, newpar_str,
+                        state->resolve2.bname, STACK_CLIENT_NAME (frame->root),
+                        STACK_ERR_XL_NAME (frame->root));
+                goto out;
+        }
+
+        server4_post_link (state, &rsp, inode, stbuf, preparent,
+                           postparent);
+
+out:
+        rsp.op_ret    = op_ret;
+        rsp.op_errno  = gf_errno_to_error (op_errno);
+
+        req = frame->local;
+        server_submit_reply (frame, req, &rsp, NULL, 0, NULL,
+                             (xdrproc_t)xdr_gfx_common_3iatt_rsp);
+
+        GF_FREE (rsp.xdata.pairs.pairs_val);
+
+        return 0;
+}
+
+int
+server4_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)
+{
+        gfx_common_2iatt_rsp    rsp   = {0,};
+        server_state_t      *state = NULL;
+        rpcsvc_request_t    *req   = NULL;
+
+        dict_to_xdr (xdata, &rsp.xdata);
+
+        if (op_ret) {
+                state = CALL_STATE (frame);
+                gf_msg (this->name, GF_LOG_INFO, op_errno,
+                        PS_MSG_TRUNCATE_INFO,
+                        "%"PRId64": TRUNCATE %s (%s), client: %s, "
+                        "error-xlator: %s", frame->root->unique,
+                        state->loc.path, uuid_utoa (state->resolve.gfid),
+                        STACK_CLIENT_NAME (frame->root),
+                        STACK_ERR_XL_NAME (frame->root));
+                goto out;
+        }
+
+        server4_post_common_2iatt (&rsp, prebuf, postbuf);
+
+out:
+        rsp.op_ret    = op_ret;
+        rsp.op_errno  = gf_errno_to_error (op_errno);
+
+        req = frame->local;
+        server_submit_reply (frame, req, &rsp, NULL, 0, NULL,
+                             (xdrproc_t)xdr_gfx_common_2iatt_rsp);
+
+        GF_FREE (rsp.xdata.pairs.pairs_val);
+
+        return 0;
+}
+
+int
+server4_fstat_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
+                  int32_t op_ret, int32_t op_errno, struct iatt *stbuf,
+                  dict_t *xdata)
+{
+        gfx_common_iatt_rsp  rsp   = {0,};
+        server_state_t      *state = NULL;
+        rpcsvc_request_t    *req   = NULL;
+
+        dict_to_xdr (xdata, &rsp.xdata);
+
+        state = CALL_STATE (frame);
+        if (op_ret) {
+                gf_msg (this->name, fop_log_level (GF_FOP_FSTAT, op_errno),
+                        op_errno, PS_MSG_STAT_INFO,
+                        "%"PRId64": FSTAT %"PRId64" (%s), client: %s, "
+                        "error-xlator: %s", frame->root->unique,
+                        state->resolve.fd_no, uuid_utoa (state->resolve.gfid),
+                        STACK_CLIENT_NAME (frame->root),
+                        STACK_ERR_XL_NAME (frame->root));
+                goto out;
+        }
+
+        server4_post_common_iatt (state, &rsp, stbuf);
+
+out:
+        rsp.op_ret    = op_ret;
+        rsp.op_errno  = gf_errno_to_error (op_errno);
+
+        req = frame->local;
+        server_submit_reply (frame, req, &rsp, NULL, 0, NULL,
+                             (xdrproc_t)xdr_gfx_common_iatt_rsp);
+
+        GF_FREE (rsp.xdata.pairs.pairs_val);
+
+        return 0;
+}
+
+int
+server4_ftruncate_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
+                      int32_t op_ret, int32_t op_errno, struct iatt *prebuf,
+                      struct iatt *postbuf, dict_t *xdata)
+{
+        gfx_common_2iatt_rsp   rsp   = {0};
+        server_state_t      *state = NULL;
+        rpcsvc_request_t    *req   = NULL;
+
+        dict_to_xdr (xdata, &rsp.xdata);
+
+        if (op_ret) {
+                state = CALL_STATE (frame);
+                gf_msg (this->name, fop_log_level (GF_FOP_FTRUNCATE, op_errno),
+                        op_errno, PS_MSG_TRUNCATE_INFO,
+                        "%"PRId64": FTRUNCATE %"PRId64" (%s), client: %s, "
+                        "error-xlator: %s", frame->root->unique,
+                        state->resolve.fd_no, uuid_utoa (state->resolve.gfid),
+                        STACK_CLIENT_NAME (frame->root),
+                        STACK_ERR_XL_NAME (frame->root));
+                goto out;
+        }
+
+        server4_post_common_2iatt (&rsp, prebuf, postbuf);
+
+out:
+        rsp.op_ret    = op_ret;
+        rsp.op_errno  = gf_errno_to_error (op_errno);
+
+        req = frame->local;
+        server_submit_reply (frame, req, &rsp, NULL, 0, NULL,
+                             (xdrproc_t)xdr_gfx_common_2iatt_rsp);
+
+        GF_FREE (rsp.xdata.pairs.pairs_val);
+
+        return 0;
+}
+
+int
+server4_flush_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
+                  int32_t op_ret, int32_t op_errno, dict_t *xdata)
+{
+        gfx_common_rsp        rsp   = {0,};
+        server_state_t      *state = NULL;
+        rpcsvc_request_t    *req   = NULL;
+
+        dict_to_xdr (xdata, &rsp.xdata);
+
+        if (op_ret < 0) {
+                state = CALL_STATE (frame);
+                gf_msg (this->name, fop_log_level (GF_FOP_FLUSH, op_errno),
+                        op_errno, PS_MSG_FLUSH_INFO,
+                        "%"PRId64": FLUSH %"PRId64" (%s), client: %s, "
+                        "error-xlator: %s",
+                        frame->root->unique, state->resolve.fd_no,
+                        uuid_utoa (state->resolve.gfid),
+                        STACK_CLIENT_NAME (frame->root),
+                        STACK_ERR_XL_NAME (frame->root));
+                goto out;
+        }
+
+out:
+        rsp.op_ret    = op_ret;
+        rsp.op_errno  = gf_errno_to_error (op_errno);
+
+        req = frame->local;
+        server_submit_reply (frame, req, &rsp, NULL, 0, NULL,
+                             (xdrproc_t)xdr_gfx_common_rsp);
+
+        GF_FREE (rsp.xdata.pairs.pairs_val);
+
+        return 0;
+}
+
+int
+server4_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)
+{
+        gfx_common_2iatt_rsp       rsp   = {0,};
+        server_state_t      *state = NULL;
+        rpcsvc_request_t    *req   = NULL;
+
+        dict_to_xdr (xdata, &rsp.xdata);
+
+        if (op_ret < 0) {
+                state = CALL_STATE (frame);
+                gf_msg (this->name, fop_log_level (GF_FOP_FSYNC, op_errno),
+                        op_errno, PS_MSG_SYNC_INFO,
+                        "%"PRId64": FSYNC %"PRId64" (%s), client: %s, "
+                        "error-xlator: %s", frame->root->unique,
+                        state->resolve.fd_no, uuid_utoa (state->resolve.gfid),
+                        STACK_CLIENT_NAME (frame->root),
+                        STACK_ERR_XL_NAME (frame->root));
+                goto out;
+        }
+
+        server4_post_common_2iatt (&rsp, prebuf, postbuf);
+
+out:
+        rsp.op_ret    = op_ret;
+        rsp.op_errno  = gf_errno_to_error (op_errno);
+
+        req = frame->local;
+        server_submit_reply (frame, req, &rsp, NULL, 0, NULL,
+                             (xdrproc_t)xdr_gfx_common_2iatt_rsp);
+
+        GF_FREE (rsp.xdata.pairs.pairs_val);
+
+        return 0;
+}
+
+int
+server4_writev_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
+                   int32_t op_ret, int32_t op_errno, struct iatt *prebuf,
+                   struct iatt *postbuf, dict_t *xdata)
+{
+        gfx_common_2iatt_rsp       rsp   = {0,};
+        server_state_t      *state = NULL;
+        rpcsvc_request_t    *req   = NULL;
+
+        dict_to_xdr (xdata, &rsp.xdata);
+
+        if (op_ret < 0) {
+                state = CALL_STATE (frame);
+                gf_msg (this->name, fop_log_level (GF_FOP_WRITE, op_errno),
+                        op_errno, PS_MSG_WRITE_INFO,
+                        "%"PRId64": WRITEV %"PRId64" (%s), client: %s, "
+                        "error-xlator: %s", frame->root->unique,
+                        state->resolve.fd_no, uuid_utoa (state->resolve.gfid),
+                        STACK_CLIENT_NAME (frame->root),
+                        STACK_ERR_XL_NAME (frame->root));
+                goto out;
+        }
+
+        server4_post_common_2iatt (&rsp, prebuf, postbuf);
+
+out:
+        rsp.op_ret    = op_ret;
+        rsp.op_errno  = gf_errno_to_error (op_errno);
+
+        req = frame->local;
+        server_submit_reply (frame, req, &rsp, NULL, 0, NULL,
+                             (xdrproc_t)xdr_gfx_common_2iatt_rsp);
+
+        GF_FREE (rsp.xdata.pairs.pairs_val);
+
+        return 0;
+}
+
+
+int
+server4_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)
+{
+        gfx_read_rsp        rsp   = {0,};
+        server_state_t      *state = NULL;
+        rpcsvc_request_t    *req   = NULL;
+
+#ifdef GF_TESTING_IO_XDATA
+        {
+                int ret = 0;
+                if (!xdata)
+                        xdata = dict_new ();
+
+                ret = dict_set_str (xdata, "testing-the-xdata-key",
+                                       "testing-xdata-value");
+        }
+#endif
+        dict_to_xdr (xdata, &rsp.xdata);
+
+        if (op_ret < 0) {
+                state = CALL_STATE (frame);
+                gf_msg (this->name, fop_log_level (GF_FOP_READ, op_errno),
+                        op_errno, PS_MSG_READ_INFO,
+                        "%"PRId64": READV %"PRId64" (%s), client: %s, "
+                        "error-xlator: %s", frame->root->unique,
+                        state->resolve.fd_no, uuid_utoa (state->resolve.gfid),
+                        STACK_CLIENT_NAME (frame->root),
+                        STACK_ERR_XL_NAME (frame->root));
+                goto out;
+        }
+
+        server4_post_readv (&rsp, stbuf, op_ret);
+
+out:
+        rsp.op_ret    = op_ret;
+        rsp.op_errno  = gf_errno_to_error (op_errno);
+
+        req = frame->local;
+        server_submit_reply (frame, req, &rsp, vector, count, iobref,
+                             (xdrproc_t)xdr_gfx_read_rsp);
+
+        GF_FREE (rsp.xdata.pairs.pairs_val);
+
+        return 0;
+}
+
+int
+server4_rchecksum_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
+                      int32_t op_ret, int32_t op_errno,
+                      uint32_t weak_checksum, uint8_t *strong_checksum,
+                      dict_t *xdata)
+{
+        gfx_rchecksum_rsp   rsp   = {0,};
+        rpcsvc_request_t    *req   = NULL;
+        server_state_t      *state = NULL;
+
+        dict_to_xdr (xdata, &rsp.xdata);
+
+        if (op_ret < 0) {
+                state = CALL_STATE (frame);
+                gf_msg (this->name, fop_log_level (GF_FOP_RCHECKSUM, op_errno),
+                        op_errno, PS_MSG_CHKSUM_INFO,
+                        "%"PRId64": RCHECKSUM %"PRId64" (%s), client: %s, "
+                        "error-xlator: %s", frame->root->unique,
+                        state->resolve.fd_no, uuid_utoa (state->resolve.gfid),
+                        STACK_CLIENT_NAME (frame->root),
+                        STACK_ERR_XL_NAME (frame->root));
+                goto out;
+        }
+
+        server4_post_rchecksum (&rsp, weak_checksum, strong_checksum);
+out:
+        rsp.op_ret    = op_ret;
+        rsp.op_errno  = gf_errno_to_error (op_errno);
+
+        req = frame->local;
+        server_submit_reply (frame, req, &rsp, NULL, 0, NULL,
+                             (xdrproc_t)xdr_gfx_rchecksum_rsp);
+
+        GF_FREE (rsp.xdata.pairs.pairs_val);
+
+        return 0;
+}
+
+
+int
+server4_open_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
+                 int32_t op_ret, int32_t op_errno, fd_t *fd, dict_t *xdata)
+{
+        server_state_t      *state    = NULL;
+        rpcsvc_request_t    *req      = NULL;
+        gfx_open_rsp        rsp      = {0,};
+
+        dict_to_xdr (xdata, &rsp.xdata);
+
+        if (op_ret < 0) {
+                state = CALL_STATE (frame);
+                gf_msg (this->name, fop_log_level (GF_FOP_OPEN, op_errno),
+                        op_errno, PS_MSG_OPEN_INFO,
+                        "%"PRId64": OPEN %s (%s), client: %s, error-xlator: %s",
+                        frame->root->unique, state->loc.path,
+                        uuid_utoa (state->resolve.gfid),
+                        STACK_CLIENT_NAME (frame->root),
+                        STACK_ERR_XL_NAME (frame->root));
+                goto out;
+        }
+
+        op_ret = server4_post_open (frame, this, &rsp, fd);
+        if (op_ret)
+                goto out;
+out:
+        rsp.op_ret    = op_ret;
+        rsp.op_errno  = gf_errno_to_error (op_errno);
+
+        req = frame->local;
+        server_submit_reply (frame, req, &rsp, NULL, 0, NULL,
+                             (xdrproc_t)xdr_gfx_open_rsp);
+        GF_FREE (rsp.xdata.pairs.pairs_val);
+
+        return 0;
+}
+
+
+int
+server4_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 *stbuf, struct iatt *preparent,
+                   struct iatt *postparent, dict_t *xdata)
+{
+        server_state_t      *state      = NULL;
+        rpcsvc_request_t    *req        = NULL;
+        uint64_t             fd_no      = 0;
+        gfx_create_rsp      rsp        = {0,};
+
+        dict_to_xdr (xdata, &rsp.xdata);
+
+        state = CALL_STATE (frame);
+
+        if (op_ret < 0) {
+                gf_msg (this->name, GF_LOG_INFO, op_errno, PS_MSG_CREATE_INFO,
+                        "%"PRId64": CREATE %s (%s/%s), client: %s, "
+                        "error-xlator: %s", frame->root->unique,
+                        state->loc.path, uuid_utoa (state->resolve.pargfid),
+                        state->resolve.bname, STACK_CLIENT_NAME (frame->root),
+                        STACK_ERR_XL_NAME (frame->root));
+                goto out;
+        }
+
+        /* TODO: log gfid too */
+        gf_msg_trace (frame->root->client->bound_xl->name, 0, "%"PRId64": "
+                      "CREATE %s (%s)", frame->root->unique, state->loc.name,
+                      uuid_utoa (stbuf->ia_gfid));
+
+        op_ret = server4_post_create (frame, &rsp, state, this, fd, inode,
+                                     stbuf,
+                                     preparent, postparent);
+        if (op_ret) {
+                op_errno = -op_ret;
+                op_ret = -1;
+                goto out;
+        }
+
+out:
+        if (op_ret)
+                rsp.fd = fd_no;
+        rsp.op_ret    = op_ret;
+        rsp.op_errno  = gf_errno_to_error (op_errno);
+
+        req = frame->local;
+        server_submit_reply (frame, req, &rsp, NULL, 0, NULL,
+                             (xdrproc_t)xdr_gfx_create_rsp);
+
+        GF_FREE (rsp.xdata.pairs.pairs_val);
+
+        return 0;
+}
+
+int
+server4_readlink_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
+                     int32_t op_ret, int32_t op_errno, const char *buf,
+                     struct iatt *stbuf, dict_t *xdata)
+{
+        gfx_readlink_rsp    rsp   = {0,};
+        server_state_t      *state = NULL;
+        rpcsvc_request_t    *req   = NULL;
+
+        dict_to_xdr (xdata, &rsp.xdata);
+
+        if (op_ret < 0) {
+                state = CALL_STATE (frame);
+                gf_msg (this->name, GF_LOG_INFO, op_errno, PS_MSG_LINK_INFO,
+                        "%"PRId64": READLINK %s (%s), client: %s, "
+                        "error-xlator: %s", frame->root->unique,
+                        state->loc.path, uuid_utoa (state->resolve.gfid),
+                        STACK_CLIENT_NAME (frame->root),
+                        STACK_ERR_XL_NAME (frame->root));
+                goto out;
+        }
+
+        server4_post_readlink (&rsp, stbuf, buf);
+out:
+        rsp.op_ret    = op_ret;
+        rsp.op_errno  = gf_errno_to_error (op_errno);
+        if (!rsp.path)
+                rsp.path = "";
+
+        req = frame->local;
+        server_submit_reply (frame, req, &rsp, NULL, 0, NULL,
+                             (xdrproc_t)xdr_gfx_readlink_rsp);
+
+        GF_FREE (rsp.xdata.pairs.pairs_val);
+
+        return 0;
+}
+
+int
+server4_stat_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
+                 int32_t op_ret, int32_t op_errno, struct iatt *stbuf,
+                 dict_t *xdata)
+{
+        gfx_common_iatt_rsp  rsp   = {0,};
+        server_state_t      *state = NULL;
+        rpcsvc_request_t    *req   = NULL;
+
+        dict_to_xdr (xdata, &rsp.xdata);
+
+        state  = CALL_STATE (frame);
+        if (op_ret) {
+                gf_msg (this->name, fop_log_level (GF_FOP_STAT, op_errno),
+                        op_errno, PS_MSG_STAT_INFO,
+                        "%"PRId64": STAT %s (%s), client: %s, error-xlator: %s",
+                        frame->root->unique,
+                        (state->loc.path) ? state->loc.path : "",
+                        uuid_utoa (state->resolve.gfid),
+                        STACK_CLIENT_NAME (frame->root),
+                        STACK_ERR_XL_NAME (frame->root));
+                goto out;
+        }
+
+        server4_post_common_iatt (state, &rsp, stbuf);
+out:
+        rsp.op_ret    = op_ret;
+        rsp.op_errno  = gf_errno_to_error (op_errno);
+
+        req = frame->local;
+        server_submit_reply (frame, req, &rsp, NULL, 0, NULL,
+                             (xdrproc_t)xdr_gfx_common_iatt_rsp);
+
+        GF_FREE (rsp.xdata.pairs.pairs_val);
+
+        return 0;
+}
+
+
+int
+server4_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)
+{
+        gfx_common_2iatt_rsp     rsp   = {0,};
+        server_state_t      *state = NULL;
+        rpcsvc_request_t    *req   = NULL;
+
+        dict_to_xdr (xdata, &rsp.xdata);
+
+        if (op_ret) {
+                state = CALL_STATE (frame);
+                gf_msg (this->name, GF_LOG_INFO, op_errno, PS_MSG_SETATTR_INFO,
+                        "%"PRId64": SETATTR %s (%s), client: %s, "
+                        "error-xlator: %s", frame->root->unique,
+                        (state->loc.path) ? state->loc.path : "",
+                        uuid_utoa (state->resolve.gfid),
+                        STACK_CLIENT_NAME (frame->root),
+                        STACK_ERR_XL_NAME (frame->root));
+                goto out;
+        }
+
+        server4_post_common_2iatt (&rsp, statpre, statpost);
+
+out:
+        rsp.op_ret    = op_ret;
+        rsp.op_errno  = gf_errno_to_error (op_errno);
+
+        req = frame->local;
+        server_submit_reply (frame, req, &rsp, NULL, 0, NULL,
+                             (xdrproc_t)xdr_gfx_common_2iatt_rsp);
+
+        GF_FREE (rsp.xdata.pairs.pairs_val);
+
+        return 0;
+}
+
+int
+server4_fsetattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
+                     int32_t op_ret, int32_t op_errno,
+                     struct iatt *statpre, struct iatt *statpost, dict_t *xdata)
+{
+        gfx_common_2iatt_rsp    rsp   = {0,};
+        server_state_t      *state = NULL;
+        rpcsvc_request_t    *req   = NULL;
+
+        dict_to_xdr (xdata, &rsp.xdata);
+
+        if (op_ret) {
+                state  = CALL_STATE (frame);
+                gf_msg (this->name, fop_log_level (GF_FOP_FSETATTR, op_errno),
+                        op_errno, PS_MSG_SETATTR_INFO,
+                        "%"PRId64": FSETATTR %"PRId64" (%s), client: %s, "
+                        "error-xlator: %s", frame->root->unique,
+                        state->resolve.fd_no, uuid_utoa (state->resolve.gfid),
+                        STACK_CLIENT_NAME (frame->root),
+                        STACK_ERR_XL_NAME (frame->root));
+                goto out;
+        }
+
+        server4_post_common_2iatt (&rsp, statpre, statpost);
+
+out:
+        rsp.op_ret    = op_ret;
+        rsp.op_errno  = gf_errno_to_error (op_errno);
+
+        req = frame->local;
+        server_submit_reply (frame, req, &rsp, NULL, 0, NULL,
+                             (xdrproc_t)xdr_gfx_common_2iatt_rsp);
+
+        GF_FREE (rsp.xdata.pairs.pairs_val);
+
+        return 0;
+}
+
+
+int
+server4_xattrop_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
+                    int32_t op_ret, int32_t op_errno, dict_t *dict,
+                    dict_t *xdata)
+{
+        gfx_common_dict_rsp  rsp   = {0,};
+        server_state_t      *state = NULL;
+        rpcsvc_request_t    *req   = NULL;
+
+        dict_to_xdr (xdata, &rsp.xdata);
+
+        if (op_ret < 0) {
+                state = CALL_STATE (frame);
+                gf_msg (this->name, fop_log_level (GF_FOP_XATTROP, op_errno),
+                        op_errno, PS_MSG_XATTROP_INFO,
+                        "%"PRId64": XATTROP %s (%s), client: %s, "
+                        "error-xlator: %s", frame->root->unique,
+                        state->loc.path, uuid_utoa (state->resolve.gfid),
+                        STACK_CLIENT_NAME (frame->root),
+                        STACK_ERR_XL_NAME (frame->root));
+                goto out;
+        }
+
+        dict_to_xdr (dict, &rsp.dict);
+out:
+        rsp.op_ret        = op_ret;
+        rsp.op_errno      = gf_errno_to_error (op_errno);
+
+        req = frame->local;
+        server_submit_reply (frame, req, &rsp, NULL, 0, NULL,
+                             (xdrproc_t)xdr_gfx_common_dict_rsp);
+
+        GF_FREE (rsp.dict.pairs.pairs_val);
+
+        GF_FREE (rsp.xdata.pairs.pairs_val);
+
+        return 0;
+}
+
+
+int
+server4_fxattrop_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
+                     int32_t op_ret, int32_t op_errno, dict_t *dict,
+                     dict_t *xdata)
+{
+        gfx_common_dict_rsp     rsp   = {0,};
+        server_state_t      *state = NULL;
+        rpcsvc_request_t    *req   = NULL;
+
+        dict_to_xdr (xdata, &rsp.xdata);
+
+        if (op_ret < 0) {
+                state = CALL_STATE (frame);
+                gf_msg (this->name, fop_log_level (GF_FOP_FXATTROP, op_errno),
+                        op_errno, PS_MSG_XATTROP_INFO,
+                        "%"PRId64": FXATTROP %"PRId64" (%s), client: %s, "
+                        "error-xlator: %s", frame->root->unique,
+                        state->resolve.fd_no, uuid_utoa (state->resolve.gfid),
+                        STACK_CLIENT_NAME (frame->root),
+                        STACK_ERR_XL_NAME (frame->root));
+                goto out;
+        }
+
+        dict_to_xdr (dict, &rsp.dict);
+
+out:
+        rsp.op_ret        = op_ret;
+        rsp.op_errno      = gf_errno_to_error (op_errno);
+
+        req = frame->local;
+        server_submit_reply (frame, req, &rsp, NULL, 0, NULL,
+                             (xdrproc_t)xdr_gfx_common_dict_rsp);
+
+        GF_FREE (rsp.dict.pairs.pairs_val);
+
+        GF_FREE (rsp.xdata.pairs.pairs_val);
+
+        return 0;
+}
+
+
+int
+server4_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)
+{
+        gfx_readdirp_rsp    rsp   = {0,};
+        server_state_t      *state = NULL;
+        rpcsvc_request_t    *req   = NULL;
+        int                  ret   = 0;
+
+        state = CALL_STATE (frame);
+
+        dict_to_xdr (xdata, &rsp.xdata);
+
+        if (op_ret < 0) {
+                state = CALL_STATE (frame);
+                gf_msg (this->name, fop_log_level (GF_FOP_READDIRP, op_errno),
+                        op_errno, PS_MSG_DIR_INFO,
+                        "%"PRId64": READDIRP %"PRId64" (%s), client: %s, "
+                        "error-xlator: %s", frame->root->unique,
+                        state->resolve.fd_no, uuid_utoa (state->resolve.gfid),
+                        STACK_CLIENT_NAME (frame->root),
+                        STACK_ERR_XL_NAME (frame->root));
+                goto out;
+        }
+
+        /* (op_ret == 0) is valid, and means EOF */
+        if (op_ret) {
+                ret = server4_post_readdirp (&rsp, entries);
+                if (ret == -1) {
+                        op_ret   = -1;
+                        op_errno = ENOMEM;
+                        goto out;
+                }
+        }
+
+        gf_link_inodes_from_dirent (this, state->fd->inode, entries);
+
+out:
+        rsp.op_ret    = op_ret;
+        rsp.op_errno  = gf_errno_to_error (op_errno);
+
+        req = frame->local;
+        server_submit_reply (frame, req, &rsp, NULL, 0, NULL,
+                             (xdrproc_t)xdr_gfx_readdirp_rsp);
+
+        GF_FREE (rsp.xdata.pairs.pairs_val);
+
+        readdirp_rsp_cleanup_v2 (&rsp);
+
+        return 0;
+}
+
+int
+server4_fallocate_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)
+{
+        gfx_common_2iatt_rsp rsp   = {0,};
+        server_state_t    *state = NULL;
+        rpcsvc_request_t  *req   = NULL;
+
+        dict_to_xdr (xdata, &rsp.xdata);
+
+        if (op_ret) {
+                state  = CALL_STATE (frame);
+                gf_msg (this->name, fop_log_level (GF_FOP_FALLOCATE, op_errno),
+                        op_errno, PS_MSG_ALLOC_INFO,
+                        "%"PRId64": FALLOCATE %"PRId64" (%s), client: %s, "
+                        "error-xlator: %s", frame->root->unique,
+                        state->resolve.fd_no, uuid_utoa (state->resolve.gfid),
+                        STACK_CLIENT_NAME (frame->root),
+                        STACK_ERR_XL_NAME (frame->root));
+                goto out;
+        }
+
+        server4_post_common_2iatt (&rsp, statpre, statpost);
+
+out:
+        rsp.op_ret    = op_ret;
+        rsp.op_errno  = gf_errno_to_error (op_errno);
+
+        req = frame->local;
+        server_submit_reply(frame, req, &rsp, NULL, 0, NULL,
+                            (xdrproc_t) xdr_gfx_common_2iatt_rsp);
+
+        GF_FREE (rsp.xdata.pairs.pairs_val);
+
+        return 0;
+}
+
+int
+server4_discard_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)
+{
+        gfx_common_2iatt_rsp rsp     = {0,};
+        server_state_t    *state = NULL;
+        rpcsvc_request_t  *req   = NULL;
+
+        dict_to_xdr (xdata, &rsp.xdata);
+
+        if (op_ret) {
+                state  = CALL_STATE (frame);
+                gf_msg (this->name, fop_log_level (GF_FOP_DISCARD, op_errno),
+                        op_errno, PS_MSG_DISCARD_INFO,
+                        "%"PRId64": DISCARD %"PRId64" (%s), client: %s, "
+                        "error-xlator: %s", frame->root->unique,
+                        state->resolve.fd_no, uuid_utoa (state->resolve.gfid),
+                        STACK_CLIENT_NAME (frame->root),
+                        STACK_ERR_XL_NAME (frame->root));
+                goto out;
+        }
+
+        server4_post_common_2iatt (&rsp, statpre, statpost);
+
+out:
+        rsp.op_ret    = op_ret;
+        rsp.op_errno  = gf_errno_to_error (op_errno);
+
+        req = frame->local;
+        server_submit_reply(frame, req, &rsp, NULL, 0, NULL,
+                            (xdrproc_t) xdr_gfx_common_2iatt_rsp);
+
+        GF_FREE (rsp.xdata.pairs.pairs_val);
+
+        return 0;
+}
+
+int
+server4_zerofill_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)
+{
+        gfx_common_2iatt_rsp  rsp    = {0,};
+        server_state_t    *state  = NULL;
+        rpcsvc_request_t  *req    = NULL;
+
+        req = frame->local;
+        state  = CALL_STATE (frame);
+
+        dict_to_xdr (xdata, &rsp.xdata);
+
+        if (op_ret) {
+                gf_msg (this->name, fop_log_level (GF_FOP_ZEROFILL, op_errno),
+                        op_errno, PS_MSG_ZEROFILL_INFO,
+                        "%"PRId64": ZEROFILL%"PRId64" (%s), client: %s, "
+                        "error-xlator: %s",
+                        frame->root->unique, state->resolve.fd_no,
+                        uuid_utoa (state->resolve.gfid),
+                        STACK_CLIENT_NAME (frame->root),
+                        STACK_ERR_XL_NAME (frame->root));
+                goto out;
+        }
+
+        server4_post_common_2iatt (&rsp, statpre, statpost);
+
+out:
+        rsp.op_ret    = op_ret;
+        rsp.op_errno  = gf_errno_to_error (op_errno);
+
+        server_submit_reply(frame, req, &rsp, NULL, 0, NULL,
+                            (xdrproc_t) xdr_gfx_common_2iatt_rsp);
+
+        GF_FREE (rsp.xdata.pairs.pairs_val);
+
+        return 0;
+}
+
+
+int
+server4_ipc_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
+                int32_t op_ret, int32_t op_errno, dict_t *xdata)
+{
+        gfx_common_rsp      rsp   = {0,};
+        server_state_t    *state = NULL;
+        rpcsvc_request_t  *req   = NULL;
+
+        req = frame->local;
+        state  = CALL_STATE (frame);
+
+        dict_to_xdr (xdata, &rsp.xdata);
+
+        if (op_ret) {
+                gf_msg (this->name, GF_LOG_INFO, op_errno,
+                        PS_MSG_SERVER_IPC_INFO,
+                        "%"PRId64": IPC%"PRId64" (%s), client: %s, "
+                        "error-xlator: %s",
+                        frame->root->unique, state->resolve.fd_no,
+                        uuid_utoa (state->resolve.gfid),
+                        STACK_CLIENT_NAME (frame->root),
+                        STACK_ERR_XL_NAME (frame->root));
+                goto out;
+        }
+
+out:
+        rsp.op_ret    = op_ret;
+        rsp.op_errno  = gf_errno_to_error (op_errno);
+
+        server_submit_reply(frame, req, &rsp, NULL, 0, NULL,
+                            (xdrproc_t) xdr_gfx_common_rsp);
+
+        GF_FREE (rsp.xdata.pairs.pairs_val);
+
+        return 0;
+}
+
+
+int
+server4_seek_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
+                 int32_t op_ret, int32_t op_errno, off_t offset, dict_t *xdata)
+{
+        struct gfx_seek_rsp   rsp    = {0, };
+        server_state_t        *state  = NULL;
+        rpcsvc_request_t      *req    = NULL;
+
+        req = frame->local;
+        state  = CALL_STATE (frame);
+
+        dict_to_xdr (xdata, &rsp.xdata);
+
+        if (op_ret) {
+                gf_msg (this->name, fop_log_level (GF_FOP_SEEK, op_errno),
+                        op_errno, PS_MSG_SEEK_INFO,
+                        "%"PRId64": SEEK%"PRId64" (%s), client: %s, "
+                        "error-xlator: %s",
+                        frame->root->unique, state->resolve.fd_no,
+                        uuid_utoa (state->resolve.gfid),
+                        STACK_CLIENT_NAME (frame->root),
+                        STACK_ERR_XL_NAME (frame->root));
+                goto out;
+        }
+
+        server4_post_seek (&rsp, offset);
+out:
+        rsp.op_ret    = op_ret;
+        rsp.op_errno  = gf_errno_to_error (op_errno);
+
+        server_submit_reply (frame, req, &rsp, NULL, 0, NULL,
+                             (xdrproc_t) xdr_gfx_seek_rsp);
+
+        GF_FREE (rsp.xdata.pairs.pairs_val);
+
+        return 0;
+}
+
+static int
+server4_setactivelk_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
+                        int32_t op_ret, int32_t op_errno, dict_t *xdata)
+{
+        gfx_common_rsp   rsp     = {0,};
+        server_state_t          *state  = NULL;
+        rpcsvc_request_t        *req    = NULL;
+
+        state = CALL_STATE (frame);
+
+        dict_to_xdr (xdata, &rsp.xdata);
+
+        if (op_ret < 0) {
+                state = CALL_STATE (frame);
+                gf_msg (this->name, GF_LOG_INFO,
+                        op_errno, 0,
+                        "%"PRId64": SETACTIVELK %s (%s), client: %s, "
+                        "error-xlator: %s", frame->root->unique,
+                        state->loc.path, uuid_utoa (state->resolve.gfid),
+                        STACK_CLIENT_NAME (frame->root),
+                        STACK_ERR_XL_NAME (frame->root));
+                goto out;
+        }
+
+out:
+        rsp.op_ret    = op_ret;
+        rsp.op_errno  = gf_errno_to_error (op_errno);
+
+        req = frame->local;
+
+        server_submit_reply (frame, req, &rsp, NULL, 0, NULL,
+                             (xdrproc_t)xdr_gfx_common_rsp);
+
+        GF_FREE (rsp.xdata.pairs.pairs_val);
+
+        return 0;
+}
+
+int
+server4_namelink_cbk (call_frame_t *frame,
+                     void *cookie, xlator_t *this,
+                     int32_t op_ret, int32_t op_errno,
+                     struct iatt *prebuf, struct iatt *postbuf, dict_t *xdata)
+{
+        gfx_common_2iatt_rsp rsp        = {0,};
+        rpcsvc_request_t    *req        = NULL;
+
+        dict_to_xdr (xdata, &rsp.xdata);
+        if (op_ret < 0)
+                goto out;
+
+        gfx_stat_from_iattx (&rsp.prestat, prebuf);
+        gfx_stat_from_iattx (&rsp.poststat, postbuf);
+
+        /**
+         * no point in linking inode here -- there's no stbuf anyway and a
+         * lookup() for this name entry would be a negative lookup.
+         */
+
+out:
+        rsp.op_ret    = op_ret;
+        rsp.op_errno  = gf_errno_to_error (op_errno);
+
+        req = frame->local;
+        server_submit_reply (frame, req, &rsp, NULL, 0, NULL,
+                             (xdrproc_t)xdr_gfx_common_2iatt_rsp);
+
+        GF_FREE (rsp.xdata.pairs.pairs_val);
+
+        return 0;
+}
+
+int
+server4_icreate_cbk (call_frame_t *frame,
+                    void *cookie, xlator_t *this,
+                    int32_t op_ret, int32_t op_errno,
+                    inode_t *inode, struct iatt *stbuf, dict_t *xdata)
+{
+        server_state_t      *state      = NULL;
+        inode_t             *link_inode = NULL;
+        rpcsvc_request_t    *req        = NULL;
+        gfx_common_iatt_rsp  rsp        = {0,};
+
+        dict_to_xdr (xdata, &rsp.xdata);
+        state = CALL_STATE (frame);
+
+        if (op_ret < 0) {
+                gf_msg (this->name, GF_LOG_INFO, op_errno, PS_MSG_CREATE_INFO,
+                        "%"PRId64": ICREATE [%s] ==> (%s)",
+                        frame->root->unique, uuid_utoa (state->resolve.gfid),
+                        strerror (op_errno));
+                goto out;
+        }
+
+        gf_msg_trace (frame->root->client->bound_xl->name, 0, "%"PRId64": "
+                      "ICREATE [%s]", frame->root->unique,
+                      uuid_utoa (stbuf->ia_gfid));
+
+        link_inode = inode_link (inode,
+                                 state->loc.parent, state->loc.name, stbuf);
+
+        if (!link_inode) {
+                op_ret = -1;
+                op_errno = ENOENT;
+                goto out;
+        }
+
+        inode_lookup (link_inode);
+        inode_unref (link_inode);
+
+        gfx_stat_from_iattx (&rsp.stat, stbuf);
+
+out:
+        rsp.op_ret    = op_ret;
+        rsp.op_errno  = gf_errno_to_error (op_errno);
+
+        req = frame->local;
+        server_submit_reply (frame, req, &rsp, NULL, 0, NULL,
+                             (xdrproc_t)xdr_gfx_common_iatt_rsp);
+
+        GF_FREE (rsp.xdata.pairs.pairs_val);
+
+        return 0;
+}
+
+/* Resume function section */
+
+int
+server4_rchecksum_resume (call_frame_t *frame, xlator_t *bound_xl)
+{
+        server_state_t *state    = NULL;
+        int             op_ret   = 0;
+        int             op_errno = EINVAL;
+
+        state = CALL_STATE (frame);
+
+        if (state->resolve.op_ret != 0) {
+                op_ret   = state->resolve.op_ret;
+                op_errno = state->resolve.op_errno;
+                goto err;
+        }
+
+        STACK_WIND (frame, server4_rchecksum_cbk, bound_xl,
+                    bound_xl->fops->rchecksum, state->fd,
+                    state->offset, state->size, state->xdata);
+
+        return 0;
+err:
+        server4_rchecksum_cbk (frame, NULL, frame->this, op_ret, op_errno, 0,
+                              NULL, NULL);
+
+        return 0;
+
+}
+
+int
+server4_lease_resume (call_frame_t *frame, xlator_t *bound_xl)
+{
+        server_state_t *state = NULL;
+
+        state = CALL_STATE (frame);
+
+        if (state->resolve.op_ret != 0)
+                goto err;
+
+        STACK_WIND (frame, server4_lease_cbk, bound_xl, bound_xl->fops->lease,
+                    &state->loc, &state->lease, state->xdata);
+
+        return 0;
+
+err:
+        server4_lease_cbk (frame, NULL, frame->this, state->resolve.op_ret,
+                          state->resolve.op_errno, NULL, NULL);
+        return 0;
+}
+
+int
+server4_lk_resume (call_frame_t *frame, xlator_t *bound_xl)
+{
+        server_state_t *state = NULL;
+
+        state = CALL_STATE (frame);
+
+        if (state->resolve.op_ret != 0)
+                goto err;
+
+        STACK_WIND (frame, server4_lk_cbk, bound_xl, bound_xl->fops->lk,
+                    state->fd, state->cmd, &state->flock, state->xdata);
+
+        return 0;
+
+err:
+        server4_lk_cbk (frame, NULL, frame->this, state->resolve.op_ret,
+                       state->resolve.op_errno, NULL, NULL);
+        return 0;
+}
+
+int
+server4_rename_resume (call_frame_t *frame, xlator_t *bound_xl)
+{
+        server_state_t *state = NULL;
+        int             op_ret = 0;
+        int             op_errno = 0;
+
+        state = CALL_STATE (frame);
+
+        if (state->resolve.op_ret != 0) {
+                op_ret   = state->resolve.op_ret;
+                op_errno = state->resolve.op_errno;
+                goto err;
+        }
+
+        if (state->resolve2.op_ret != 0) {
+                op_ret   = state->resolve2.op_ret;
+                op_errno = state->resolve2.op_errno;
+                goto err;
+        }
+
+        STACK_WIND (frame, server4_rename_cbk,
+                    bound_xl, bound_xl->fops->rename,
+                    &state->loc, &state->loc2, state->xdata);
+        return 0;
+err:
+        server4_rename_cbk (frame, NULL, frame->this, op_ret, op_errno,
+                           NULL, NULL, NULL, NULL, NULL, NULL);
+        return 0;
+}
+
+
+int
+server4_link_resume (call_frame_t *frame, xlator_t *bound_xl)
+{
+        server_state_t *state = NULL;
+        int             op_ret = 0;
+        int             op_errno = 0;
+
+        state = CALL_STATE (frame);
+
+        if (state->resolve.op_ret != 0) {
+                op_ret   = state->resolve.op_ret;
+                op_errno = state->resolve.op_errno;
+                goto err;
+        }
+
+        if (state->resolve2.op_ret != 0) {
+                op_ret   = state->resolve2.op_ret;
+                op_errno = state->resolve2.op_errno;
+                goto err;
+        }
+
+        state->loc2.inode = inode_ref (state->loc.inode);
+
+        STACK_WIND (frame, server4_link_cbk, bound_xl, bound_xl->fops->link,
+                    &state->loc, &state->loc2, state->xdata);
+
+        return 0;
+err:
+        server4_link_cbk (frame, NULL, frame->this, op_ret, op_errno,
+                         NULL, NULL, NULL, NULL, NULL);
+        return 0;
+}
+
+int
+server4_symlink_resume (call_frame_t *frame, xlator_t *bound_xl)
+{
+        server_state_t *state = NULL;
+
+        state = CALL_STATE (frame);
+
+        if (state->resolve.op_ret != 0)
+                goto err;
+
+        state->loc.inode = inode_new (state->itable);
+
+        STACK_WIND (frame, server4_symlink_cbk,
+                    bound_xl, bound_xl->fops->symlink,
+                    state->name, &state->loc, state->umask, state->xdata);
+
+        return 0;
+err:
+        server4_symlink_cbk (frame, NULL, frame->this, state->resolve.op_ret,
+                            state->resolve.op_errno, NULL, NULL, NULL, NULL, NULL);
+        return 0;
+}
+
+
+int
+server4_access_resume (call_frame_t *frame, xlator_t *bound_xl)
+{
+        server_state_t *state = NULL;
+
+        state = CALL_STATE (frame);
+
+        if (state->resolve.op_ret != 0)
+                goto err;
+
+        STACK_WIND (frame, server4_access_cbk,
+                    bound_xl, bound_xl->fops->access,
+                    &state->loc, state->mask, state->xdata);
+        return 0;
+err:
+        server4_access_cbk (frame, NULL, frame->this, state->resolve.op_ret,
+                           state->resolve.op_errno, NULL);
+        return 0;
+}
+
+int
+server4_fentrylk_resume (call_frame_t *frame, xlator_t *bound_xl)
+{
+        GF_UNUSED  int  ret   = -1;
+        server_state_t *state = NULL;
+
+        state = CALL_STATE (frame);
+
+        if (state->resolve.op_ret != 0)
+                goto err;
+
+        if (!state->xdata)
+                state->xdata = dict_new ();
+
+        if (state->xdata)
+                ret = dict_set_str (state->xdata, "connection-id",
+                                    frame->root->client->client_uid);
+
+        STACK_WIND (frame, server4_fentrylk_cbk, bound_xl,
+                    bound_xl->fops->fentrylk,
+                    state->volume, state->fd, state->name,
+                    state->cmd, state->type, state->xdata);
+
+        return 0;
+err:
+        server4_fentrylk_cbk (frame, NULL, frame->this, state->resolve.op_ret,
+                             state->resolve.op_errno, NULL);
+        return 0;
+}
+
+
+int
+server4_entrylk_resume (call_frame_t *frame, xlator_t *bound_xl)
+{
+        GF_UNUSED int   ret   = -1;
+        server_state_t *state = NULL;
+
+        state = CALL_STATE (frame);
+
+        if (state->resolve.op_ret != 0)
+                goto err;
+
+        if (!state->xdata)
+                state->xdata = dict_new ();
+
+        if (state->xdata)
+                ret = dict_set_str (state->xdata, "connection-id",
+                                    frame->root->client->client_uid);
+
+        STACK_WIND (frame, server4_entrylk_cbk,
+                    bound_xl, bound_xl->fops->entrylk,
+                    state->volume, &state->loc, state->name,
+                    state->cmd, state->type, state->xdata);
+        return 0;
+err:
+        server4_entrylk_cbk (frame, NULL, frame->this, state->resolve.op_ret,
+                            state->resolve.op_errno, NULL);
+        return 0;
+}
+
+
+int
+server4_finodelk_resume (call_frame_t *frame, xlator_t *bound_xl)
+{
+        GF_UNUSED int   ret   = -1;
+        server_state_t *state = NULL;
+
+        gf_msg_debug (bound_xl->name, 0, "frame %p, xlator %p", frame,
+                      bound_xl);
+
+        state = CALL_STATE (frame);
+
+        if (state->resolve.op_ret != 0)
+                goto err;
+
+        if (!state->xdata)
+                state->xdata = dict_new ();
+
+        if (state->xdata)
+                ret = dict_set_str (state->xdata, "connection-id",
+                                    frame->root->client->client_uid);
+
+        STACK_WIND (frame, server4_finodelk_cbk, bound_xl,
+                    bound_xl->fops->finodelk, state->volume, state->fd,
+                    state->cmd, &state->flock, state->xdata);
+
+        return 0;
+err:
+        server4_finodelk_cbk (frame, NULL, frame->this, state->resolve.op_ret,
+                             state->resolve.op_errno, NULL);
+
+        return 0;
+}
+
+int
+server4_inodelk_resume (call_frame_t *frame, xlator_t *bound_xl)
+{
+        GF_UNUSED int   ret   = -1;
+        server_state_t *state = NULL;
+
+        gf_msg_debug (bound_xl->name, 0, "frame %p, xlator %p", frame,
+                      bound_xl);
+
+        state = CALL_STATE (frame);
+
+        if (state->resolve.op_ret != 0)
+                goto err;
+
+        if (!state->xdata)
+                state->xdata = dict_new ();
+
+        if (state->xdata)
+                ret = dict_set_str (state->xdata, "connection-id",
+                                    frame->root->client->client_uid);
+
+        STACK_WIND (frame, server4_inodelk_cbk, bound_xl,
+                    bound_xl->fops->inodelk, state->volume, &state->loc,
+                    state->cmd, &state->flock, state->xdata);
+        return 0;
+err:
+        server4_inodelk_cbk (frame, NULL, frame->this, state->resolve.op_ret,
+                            state->resolve.op_errno, NULL);
+        return 0;
+}
+
+int
+server4_rmdir_resume (call_frame_t *frame, xlator_t *bound_xl)
+{
+        server_state_t *state = NULL;
+
+        state = CALL_STATE (frame);
+
+        if (state->resolve.op_ret != 0)
+                goto err;
+
+        STACK_WIND (frame, server4_rmdir_cbk, bound_xl, bound_xl->fops->rmdir,
+                    &state->loc, state->flags, state->xdata);
+        return 0;
+err:
+        server4_rmdir_cbk (frame, NULL, frame->this, state->resolve.op_ret,
+                          state->resolve.op_errno, NULL, NULL, NULL);
+        return 0;
+}
+
+int
+server4_mkdir_resume (call_frame_t *frame, xlator_t *bound_xl)
+
+{
+        server_state_t *state = NULL;
+
+        state = CALL_STATE (frame);
+
+        if (state->resolve.op_ret != 0)
+                goto err;
+
+        state->loc.inode = inode_new (state->itable);
+
+        STACK_WIND (frame, server4_mkdir_cbk,
+                    bound_xl, bound_xl->fops->mkdir,
+                    &(state->loc), state->mode, state->umask, state->xdata);
+
+        return 0;
+err:
+        server4_mkdir_cbk (frame, NULL, frame->this, state->resolve.op_ret,
+                          state->resolve.op_errno, NULL, NULL, NULL, NULL, NULL);
+        return 0;
+}
+
+
+int
+server4_mknod_resume (call_frame_t *frame, xlator_t *bound_xl)
+{
+        server_state_t *state = NULL;
+
+        state = CALL_STATE (frame);
+
+        if (state->resolve.op_ret != 0)
+                goto err;
+
+        state->loc.inode = inode_new (state->itable);
+
+        STACK_WIND (frame, server4_mknod_cbk,
+                    bound_xl, bound_xl->fops->mknod,
+                    &(state->loc), state->mode, state->dev,
+                    state->umask, state->xdata);
+
+        return 0;
+err:
+        server4_mknod_cbk (frame, NULL, frame->this, state->resolve.op_ret,
+                          state->resolve.op_errno, NULL, NULL, NULL, NULL, NULL);
+        return 0;
+}
+
+
+int
+server4_fsyncdir_resume (call_frame_t *frame, xlator_t *bound_xl)
+{
+        server_state_t *state = NULL;
+
+        state = CALL_STATE (frame);
+
+        if (state->resolve.op_ret != 0)
+                goto err;
+
+        STACK_WIND (frame, server4_fsyncdir_cbk,
+                    bound_xl,
+                    bound_xl->fops->fsyncdir,
+                    state->fd, state->flags, state->xdata);
+        return 0;
+
+err:
+        server4_fsyncdir_cbk (frame, NULL, frame->this,
+                             state->resolve.op_ret,
+                             state->resolve.op_errno, NULL);
+        return 0;
+}
+
+
+int
+server4_readdir_resume (call_frame_t *frame, xlator_t *bound_xl)
+{
+        server_state_t  *state = NULL;
+
+        state = CALL_STATE (frame);
+
+        if (state->resolve.op_ret != 0)
+                goto err;
+
+        GF_ASSERT (state->fd);
+
+        STACK_WIND (frame, server4_readdir_cbk,
+                    bound_xl,
+                    bound_xl->fops->readdir,
+                    state->fd, state->size, state->offset, state->xdata);
+
+        return 0;
+err:
+        server4_readdir_cbk (frame, NULL, frame->this, state->resolve.op_ret,
+                            state->resolve.op_errno, NULL, NULL);
+        return 0;
+}
+
+int
+server4_readdirp_resume (call_frame_t *frame, xlator_t *bound_xl)
+{
+        server_state_t  *state = NULL;
+
+        state = CALL_STATE (frame);
+
+        if (state->resolve.op_ret != 0)
+                goto err;
+
+        STACK_WIND (frame, server4_readdirp_cbk, bound_xl,
+                    bound_xl->fops->readdirp, state->fd, state->size,
+                    state->offset, state->xdata);
+
+        return 0;
+err:
+        server4_readdirp_cbk (frame, NULL, frame->this, state->resolve.op_ret,
+                             state->resolve.op_errno, NULL, NULL);
+        return 0;
+}
+
+
+int
+server4_opendir_resume (call_frame_t *frame, xlator_t *bound_xl)
+{
+        server_state_t  *state = NULL;
+
+        state = CALL_STATE (frame);
+
+        if (state->resolve.op_ret != 0)
+                goto err;
+
+        state->fd = fd_create (state->loc.inode, frame->root->pid);
+        if (!state->fd) {
+                gf_msg ("server", GF_LOG_ERROR, 0, PS_MSG_FD_CREATE_FAILED,
+                        "could not create the fd");
+                goto err;
+        }
+
+        STACK_WIND (frame, server4_opendir_cbk,
+                    bound_xl, bound_xl->fops->opendir,
+                    &state->loc, state->fd, state->xdata);
+        return 0;
+err:
+        server4_opendir_cbk (frame, NULL, frame->this, state->resolve.op_ret,
+                            state->resolve.op_errno, NULL, NULL);
+        return 0;
+}
+
+
+int
+server4_statfs_resume (call_frame_t *frame, xlator_t *bound_xl)
+{
+        server_state_t      *state = NULL;
+
+        state = CALL_STATE (frame);
+
+        if (state->resolve.op_ret != 0)
+                goto err;
+
+        STACK_WIND (frame, server4_statfs_cbk,
+                    bound_xl, bound_xl->fops->statfs,
+                    &state->loc, state->xdata);
+        return 0;
+
+err:
+        server4_statfs_cbk (frame, NULL, frame->this, state->resolve.op_ret,
+                           state->resolve.op_errno, NULL, NULL);
+        return 0;
+}
+
+
+int
+server4_removexattr_resume (call_frame_t *frame, xlator_t *bound_xl)
+{
+        server_state_t *state = NULL;
+
+        state = CALL_STATE (frame);
+
+        if (state->resolve.op_ret != 0)
+                goto err;
+
+        STACK_WIND (frame, server4_removexattr_cbk,
+                    bound_xl, bound_xl->fops->removexattr,
+                    &state->loc, state->name, state->xdata);
+        return 0;
+err:
+        server4_removexattr_cbk (frame, NULL, frame->this, state->resolve.op_ret,
+                                state->resolve.op_errno, NULL);
+        return 0;
+}
+
+int
+server4_fremovexattr_resume (call_frame_t *frame, xlator_t *bound_xl)
+{
+        server_state_t *state = NULL;
+
+        state = CALL_STATE (frame);
+
+        if (state->resolve.op_ret != 0)
+                goto err;
+
+        STACK_WIND (frame, server4_fremovexattr_cbk,
+                    bound_xl, bound_xl->fops->fremovexattr,
+                    state->fd, state->name, state->xdata);
+        return 0;
+err:
+        server4_fremovexattr_cbk (frame, NULL, frame->this, state->resolve.op_ret,
+                                 state->resolve.op_errno, NULL);
+        return 0;
+}
+
+int
+server4_fgetxattr_resume (call_frame_t *frame, xlator_t *bound_xl)
+{
+        server_state_t *state = NULL;
+
+        state = CALL_STATE (frame);
+
+        if (state->resolve.op_ret != 0)
+                goto err;
+
+        STACK_WIND (frame, server4_fgetxattr_cbk,
+                    bound_xl, bound_xl->fops->fgetxattr,
+                    state->fd, state->name, state->xdata);
+        return 0;
+err:
+        server4_fgetxattr_cbk (frame, NULL, frame->this, state->resolve.op_ret,
+                              state->resolve.op_errno, NULL, NULL);
+        return 0;
+}
+
+
+int
+server4_xattrop_resume (call_frame_t *frame, xlator_t *bound_xl)
+{
+        server_state_t *state = NULL;
+
+        state = CALL_STATE (frame);
+
+        if (state->resolve.op_ret != 0)
+                goto err;
+
+        STACK_WIND (frame, server4_xattrop_cbk,
+                    bound_xl, bound_xl->fops->xattrop,
+                    &state->loc, state->flags, state->dict, state->xdata);
+        return 0;
+err:
+        server4_xattrop_cbk (frame, NULL, frame->this, state->resolve.op_ret,
+                            state->resolve.op_errno, NULL, NULL);
+        return 0;
+}
+
+int
+server4_fxattrop_resume (call_frame_t *frame, xlator_t *bound_xl)
+{
+        server_state_t *state = NULL;
+
+        state = CALL_STATE (frame);
+
+        if (state->resolve.op_ret != 0)
+                goto err;
+
+        STACK_WIND (frame, server4_fxattrop_cbk,
+                    bound_xl, bound_xl->fops->fxattrop,
+                    state->fd, state->flags, state->dict, state->xdata);
+        return 0;
+err:
+        server4_fxattrop_cbk (frame, NULL, frame->this, state->resolve.op_ret,
+                             state->resolve.op_errno, NULL, NULL);
+        return 0;
+}
+
+int
+server4_fsetxattr_resume (call_frame_t *frame, xlator_t *bound_xl)
+{
+        server_state_t *state = NULL;
+
+        state = CALL_STATE (frame);
+
+        if (state->resolve.op_ret != 0)
+                goto err;
+
+        STACK_WIND (frame, server4_setxattr_cbk,
+                    bound_xl, bound_xl->fops->fsetxattr,
+                    state->fd, state->dict, state->flags, state->xdata);
+        return 0;
+err:
+        server4_fsetxattr_cbk (frame, NULL, frame->this, state->resolve.op_ret,
+                              state->resolve.op_errno, NULL);
+
+        return 0;
+}
+
+int
+server4_unlink_resume (call_frame_t *frame, xlator_t *bound_xl)
+{
+        server_state_t *state = NULL;
+
+        state = CALL_STATE (frame);
+
+        if (state->resolve.op_ret != 0)
+                goto err;
+
+        STACK_WIND (frame, server4_unlink_cbk,
+                    bound_xl, bound_xl->fops->unlink,
+                    &state->loc, state->flags, state->xdata);
+        return 0;
+err:
+        server4_unlink_cbk (frame, NULL, frame->this, state->resolve.op_ret,
+                           state->resolve.op_errno, NULL, NULL, NULL);
+        return 0;
+}
+
+int
+server4_truncate_resume (call_frame_t *frame, xlator_t *bound_xl)
+{
+        server_state_t *state = NULL;
+
+        state = CALL_STATE (frame);
+
+        if (state->resolve.op_ret != 0)
+                goto err;
+
+        STACK_WIND (frame, server4_truncate_cbk,
+                    bound_xl, bound_xl->fops->truncate,
+                    &state->loc, state->offset, state->xdata);
+        return 0;
+err:
+        server4_truncate_cbk (frame, NULL, frame->this, state->resolve.op_ret,
+                             state->resolve.op_errno, NULL, NULL, NULL);
+        return 0;
+}
+
+
+
+int
+server4_fstat_resume (call_frame_t *frame, xlator_t *bound_xl)
+{
+        server_state_t     *state = NULL;
+
+        state = CALL_STATE (frame);
+
+        if (state->resolve.op_ret != 0)
+                goto err;
+
+        STACK_WIND (frame, server4_fstat_cbk,
+                    bound_xl, bound_xl->fops->fstat,
+                    state->fd, state->xdata);
+        return 0;
+err:
+        server4_fstat_cbk (frame, NULL, frame->this, state->resolve.op_ret,
+                          state->resolve.op_errno, NULL, NULL);
+        return 0;
+}
+
+
+int
+server4_setxattr_resume (call_frame_t *frame, xlator_t *bound_xl)
+{
+        server_state_t *state = NULL;
+
+        state = CALL_STATE (frame);
+
+        if (state->resolve.op_ret != 0)
+                goto err;
+
+        STACK_WIND (frame, server4_setxattr_cbk,
+                    bound_xl, bound_xl->fops->setxattr,
+                    &state->loc, state->dict, state->flags, state->xdata);
+        return 0;
+err:
+        server4_setxattr_cbk (frame, NULL, frame->this, state->resolve.op_ret,
+                             state->resolve.op_errno, NULL);
+
+        return 0;
+}
+
+
+int
+server4_getxattr_resume (call_frame_t *frame, xlator_t *bound_xl)
+{
+        server_state_t *state = NULL;
+
+        state = CALL_STATE (frame);
+
+        if (state->resolve.op_ret != 0)
+                goto err;
+
+        STACK_WIND (frame, server4_getxattr_cbk,
+                    bound_xl, bound_xl->fops->getxattr,
+                    &state->loc, state->name, state->xdata);
+        return 0;
+err:
+        server4_getxattr_cbk (frame, NULL, frame->this, state->resolve.op_ret,
+                             state->resolve.op_errno, NULL, NULL);
+        return 0;
+}
+
+
+int
+server4_ftruncate_resume (call_frame_t *frame, xlator_t *bound_xl)
+{
+        server_state_t    *state = NULL;
+
+        state = CALL_STATE (frame);
+
+        if (state->resolve.op_ret != 0)
+                goto err;
+
+        STACK_WIND (frame, server4_ftruncate_cbk,
+                    bound_xl, bound_xl->fops->ftruncate,
+                    state->fd, state->offset, state->xdata);
+        return 0;
+err:
+        server4_ftruncate_cbk (frame, NULL, frame->this, state->resolve.op_ret,
+                              state->resolve.op_errno, NULL, NULL, NULL);
+
+        return 0;
+}
+
+
+int
+server4_flush_resume (call_frame_t *frame, xlator_t *bound_xl)
+{
+        server_state_t    *state = NULL;
+
+        state = CALL_STATE (frame);
+
+        if (state->resolve.op_ret != 0)
+                goto err;
+
+        STACK_WIND (frame, server4_flush_cbk,
+                    bound_xl, bound_xl->fops->flush, state->fd, state->xdata);
+        return 0;
+err:
+        server4_flush_cbk (frame, NULL, frame->this, state->resolve.op_ret,
+                          state->resolve.op_errno, NULL);
+
+        return 0;
+}
+
+
+int
+server4_fsync_resume (call_frame_t *frame, xlator_t *bound_xl)
+{
+        server_state_t    *state = NULL;
+
+        state = CALL_STATE (frame);
+
+        if (state->resolve.op_ret != 0)
+                goto err;
+
+        STACK_WIND (frame, server4_fsync_cbk,
+                    bound_xl, bound_xl->fops->fsync,
+                    state->fd, state->flags, state->xdata);
+        return 0;
+err:
+        server4_fsync_cbk (frame, NULL, frame->this, state->resolve.op_ret,
+                          state->resolve.op_errno, NULL, NULL, NULL);
+
+        return 0;
+}
+
+int
+server4_writev_resume (call_frame_t *frame, xlator_t *bound_xl)
+{
+        server_state_t   *state = NULL;
+
+        state = CALL_STATE (frame);
+
+        if (state->resolve.op_ret != 0)
+                goto err;
+
+        STACK_WIND (frame, server4_writev_cbk,
+                    bound_xl, bound_xl->fops->writev,
+                    state->fd, state->payload_vector, state->payload_count,
+                    state->offset, state->flags, state->iobref, state->xdata);
+
+        return 0;
+err:
+        server4_writev_cbk (frame, NULL, frame->this, state->resolve.op_ret,
+                           state->resolve.op_errno, NULL, NULL, NULL);
+        return 0;
+}
+
+
+int
+server4_readv_resume (call_frame_t *frame, xlator_t *bound_xl)
+{
+        server_state_t    *state = NULL;
+
+        state = CALL_STATE (frame);
+
+        if (state->resolve.op_ret != 0)
+                goto err;
+
+        STACK_WIND (frame, server4_readv_cbk,
+                    bound_xl, bound_xl->fops->readv,
+                    state->fd, state->size, state->offset, state->flags, state->xdata);
+
+        return 0;
+err:
+        server4_readv_cbk (frame, NULL, frame->this, state->resolve.op_ret,
+                          state->resolve.op_errno, NULL, 0, NULL, NULL, NULL);
+        return 0;
+}
+
+
+int
+server4_create_resume (call_frame_t *frame, xlator_t *bound_xl)
+{
+        server_state_t *state = NULL;
+
+        state = CALL_STATE (frame);
+
+        if (state->resolve.op_ret != 0)
+                goto err;
+
+        state->loc.inode = inode_new (state->itable);
+
+        state->fd = fd_create (state->loc.inode, frame->root->pid);
+        if (!state->fd) {
+                gf_msg ("server", GF_LOG_ERROR, 0, PS_MSG_FD_CREATE_FAILED,
+                        "fd creation for the inode %s failed",
+                        state->loc.inode ?
+                        uuid_utoa (state->loc.inode->gfid):NULL);
+                state->resolve.op_ret = -1;
+                state->resolve.op_errno = ENOMEM;
+                goto err;
+        }
+        state->fd->flags = state->flags;
+
+        STACK_WIND (frame, server4_create_cbk,
+                    bound_xl, bound_xl->fops->create,
+                    &(state->loc), state->flags, state->mode,
+                    state->umask, state->fd, state->xdata);
+
+        return 0;
+err:
+        server4_create_cbk (frame, NULL, frame->this, state->resolve.op_ret,
+                           state->resolve.op_errno, NULL, NULL, NULL,
+                           NULL, NULL, NULL);
+        return 0;
+}
+
+
+int
+server4_open_resume (call_frame_t *frame, xlator_t *bound_xl)
+{
+        server_state_t  *state = NULL;
+
+        state = CALL_STATE (frame);
+
+        if (state->resolve.op_ret != 0)
+                goto err;
+
+        state->fd = fd_create (state->loc.inode, frame->root->pid);
+        state->fd->flags = state->flags;
+
+        STACK_WIND (frame, server4_open_cbk,
+                    bound_xl, bound_xl->fops->open,
+                    &state->loc, state->flags, state->fd, state->xdata);
+
+        return 0;
+err:
+        server4_open_cbk (frame, NULL, frame->this, state->resolve.op_ret,
+                         state->resolve.op_errno, NULL, NULL);
+        return 0;
+}
+
+
+int
+server4_readlink_resume (call_frame_t *frame, xlator_t *bound_xl)
+{
+        server_state_t *state = NULL;
+
+        state = CALL_STATE (frame);
+
+        if (state->resolve.op_ret != 0)
+                goto err;
+
+        STACK_WIND (frame, server4_readlink_cbk,
+                    bound_xl, bound_xl->fops->readlink,
+                    &state->loc, state->size, state->xdata);
+        return 0;
+err:
+        server4_readlink_cbk (frame, NULL, frame->this, state->resolve.op_ret,
+                             state->resolve.op_errno, NULL, NULL, NULL);
+        return 0;
+}
+
+
+int
+server4_fsetattr_resume (call_frame_t *frame, xlator_t *bound_xl)
+{
+        server_state_t *state = NULL;
+
+        state = CALL_STATE (frame);
+
+        if (state->resolve.op_ret != 0)
+                goto err;
+
+        STACK_WIND (frame, server4_fsetattr_cbk,
+                    bound_xl, bound_xl->fops->fsetattr,
+                    state->fd, &state->stbuf, state->valid, state->xdata);
+        return 0;
+err:
+        server4_fsetattr_cbk (frame, NULL, frame->this, state->resolve.op_ret,
+                             state->resolve.op_errno, NULL, NULL, NULL);
+
+        return 0;
+}
+
+
+int
+server4_setattr_resume (call_frame_t *frame, xlator_t *bound_xl)
+{
+        server_state_t *state = NULL;
+
+        state = CALL_STATE (frame);
+
+        if (state->resolve.op_ret != 0)
+                goto err;
+
+        STACK_WIND (frame, server4_setattr_cbk,
+                    bound_xl, bound_xl->fops->setattr,
+                    &state->loc, &state->stbuf, state->valid, state->xdata);
+        return 0;
+err:
+        server4_setattr_cbk (frame, NULL, frame->this, state->resolve.op_ret,
+                            state->resolve.op_errno, NULL, NULL, NULL);
+
+        return 0;
+}
+
+
+int
+server4_stat_resume (call_frame_t *frame, xlator_t *bound_xl)
+{
+        server_state_t *state = NULL;
+
+        state = CALL_STATE (frame);
+
+        if (state->resolve.op_ret != 0)
+                goto err;
+
+        STACK_WIND (frame, server4_stat_cbk,
+                    bound_xl, bound_xl->fops->stat, &state->loc, state->xdata);
+        return 0;
+err:
+        server4_stat_cbk (frame, NULL, frame->this, state->resolve.op_ret,
+                         state->resolve.op_errno, NULL, NULL);
+        return 0;
+}
+
+int
+server4_lookup_resume (call_frame_t *frame, xlator_t *bound_xl)
+{
+        server_state_t    *state = NULL;
+
+        state = CALL_STATE (frame);
+
+        if (state->resolve.op_ret != 0)
+                goto err;
+
+        if (!state->loc.inode)
+                state->loc.inode = server_inode_new (state->itable,
+                                                     state->loc.gfid);
+        else
+                state->is_revalidate = 1;
+
+        STACK_WIND (frame, server4_lookup_cbk,
+                    bound_xl, bound_xl->fops->lookup,
+                    &state->loc, state->xdata);
+
+        return 0;
+err:
+        server4_lookup_cbk (frame, NULL, frame->this, state->resolve.op_ret,
+                           state->resolve.op_errno, NULL, NULL, NULL, NULL);
+
+        return 0;
+}
+
+int
+server4_fallocate_resume (call_frame_t *frame, xlator_t *bound_xl)
+{
+        server_state_t *state = NULL;
+
+        state = CALL_STATE (frame);
+
+        if (state->resolve.op_ret != 0)
+                goto err;
+
+        STACK_WIND (frame, server4_fallocate_cbk,
+                    bound_xl, bound_xl->fops->fallocate,
+                    state->fd, state->flags, state->offset, state->size,
+                    state->xdata);
+        return 0;
+err:
+        server4_fallocate_cbk(frame, NULL, frame->this, state->resolve.op_ret,
+                             state->resolve.op_errno, NULL, NULL, NULL);
+
+        return 0;
+}
+
+int
+server4_discard_resume (call_frame_t *frame, xlator_t *bound_xl)
+{
+        server_state_t *state = NULL;
+
+        state = CALL_STATE (frame);
+
+        if (state->resolve.op_ret != 0)
+                goto err;
+
+        STACK_WIND (frame, server4_discard_cbk,
+                    bound_xl, bound_xl->fops->discard,
+                    state->fd, state->offset, state->size, state->xdata);
+        return 0;
+err:
+        server4_discard_cbk(frame, NULL, frame->this, state->resolve.op_ret,
+                           state->resolve.op_errno, NULL, NULL, NULL);
+
+        return 0;
+}
+
+int
+server4_zerofill_resume (call_frame_t *frame, xlator_t *bound_xl)
+{
+        server_state_t *state = NULL;
+
+        state = CALL_STATE (frame);
+
+        if (state->resolve.op_ret != 0)
+                goto err;
+
+        STACK_WIND (frame, server4_zerofill_cbk,
+                    bound_xl, bound_xl->fops->zerofill,
+                    state->fd, state->offset, state->size, state->xdata);
+        return 0;
+err:
+        server4_zerofill_cbk(frame, NULL, frame->this, state->resolve.op_ret,
+                           state->resolve.op_errno, NULL, NULL, NULL);
+
+        return 0;
+}
+
+int
+server4_seek_resume (call_frame_t *frame, xlator_t *bound_xl)
+{
+        server_state_t *state = NULL;
+
+        state = CALL_STATE (frame);
+
+        if (state->resolve.op_ret != 0)
+                goto err;
+
+        STACK_WIND (frame, server4_seek_cbk, bound_xl, bound_xl->fops->seek,
+                    state->fd, state->offset, state->what, state->xdata);
+        return 0;
+err:
+        server4_seek_cbk (frame, NULL, frame->this, state->resolve.op_ret,
+                         state->resolve.op_errno, 0, NULL);
+
+        return 0;
+}
+
+static int
+server4_getactivelk_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
+                        int32_t op_ret, int32_t op_errno,
+                        lock_migration_info_t *locklist, dict_t *xdata)
+{
+        gfx_getactivelk_rsp    rsp     = {0,};
+        server_state_t          *state  = NULL;
+        rpcsvc_request_t        *req    = NULL;
+        int                     ret     = 0;
+
+        state = CALL_STATE (frame);
+
+        dict_to_xdr (xdata, &rsp.xdata);
+
+        if (op_ret < 0) {
+                state = CALL_STATE (frame);
+
+                gf_msg (this->name, GF_LOG_INFO,
+                        op_errno, 0,
+                        "%"PRId64": GETACTIVELK %s (%s), client: %s, "
+                        "error-xlator: %s", frame->root->unique,
+                        state->loc.path, uuid_utoa (state->resolve.gfid),
+                        STACK_CLIENT_NAME (frame->root),
+                        STACK_ERR_XL_NAME (frame->root));
+
+                goto out;
+        }
+
+        /* (op_ret == 0) means there are no locks on the file*/
+        if (op_ret > 0) {
+                ret = serialize_rsp_locklist_v2 (locklist, &rsp);
+                if (ret == -1) {
+                        op_ret   = -1;
+                        op_errno = ENOMEM;
+                        goto out;
+                }
+        }
+
+out:
+        rsp.op_ret    = op_ret;
+        rsp.op_errno  = gf_errno_to_error (op_errno);
+
+        req = frame->local;
+
+        server_submit_reply (frame, req, &rsp, NULL, 0, NULL,
+                             (xdrproc_t)xdr_gfx_getactivelk_rsp);
+
+        GF_FREE (rsp.xdata.pairs.pairs_val);
+
+        getactivelkinfo_rsp_cleanup_v2 (&rsp);
+
+        return 0;
+}
+
+int
+server4_getactivelk_resume (call_frame_t *frame, xlator_t *bound_xl)
+{
+        server_state_t *state = NULL;
+
+        state = CALL_STATE (frame);
+
+        if (state->resolve.op_ret != 0)
+                goto err;
+
+        STACK_WIND (frame, server4_getactivelk_cbk, bound_xl,
+                    bound_xl->fops->getactivelk, &state->loc, state->xdata);
+        return 0;
+err:
+        server4_getactivelk_cbk (frame, NULL, frame->this, state->resolve.op_ret,
+                                state->resolve.op_errno, NULL, NULL);
+        return 0;
+
+}
+
+int
+server4_setactivelk_resume (call_frame_t *frame, xlator_t *bound_xl)
+{
+        server_state_t *state = NULL;
+
+        state = CALL_STATE (frame);
+
+        if (state->resolve.op_ret != 0)
+                goto err;
+
+        STACK_WIND (frame, server4_setactivelk_cbk,
+                    bound_xl, bound_xl->fops->setactivelk, &state->loc,
+                    &state->locklist, state->xdata);
+        return 0;
+err:
+        server4_setactivelk_cbk (frame, NULL, frame->this,
+                                 state->resolve.op_ret,
+                                 state->resolve.op_errno, NULL);
+        return 0;
+
+}
+int
+server4_namelink_resume (call_frame_t *frame, xlator_t *bound_xl)
+{
+        server_state_t *state = NULL;
+
+        state = CALL_STATE (frame);
+
+        if (state->resolve.op_ret != 0)
+                goto err;
+
+        state->loc.inode = inode_new (state->itable);
+
+        STACK_WIND (frame, server4_namelink_cbk,
+                    bound_xl, bound_xl->fops->namelink,
+                    &(state->loc), state->xdata);
+        return 0;
+
+ err:
+        server4_namelink_cbk (frame, NULL,
+                             frame->this,
+                             state->resolve.op_ret,
+                             state->resolve.op_errno, NULL, NULL, NULL);
+        return 0;
+}
+
+int
+server4_icreate_resume (call_frame_t *frame, xlator_t *bound_xl)
+{
+        server_state_t *state = NULL;
+
+        state = CALL_STATE (frame);
+
+        if (state->resolve.op_ret != 0)
+                goto err;
+
+        state->loc.inode = inode_new (state->itable);
+
+        STACK_WIND (frame, server4_icreate_cbk,
+                    bound_xl, bound_xl->fops->icreate,
+                    &(state->loc), state->mode, state->xdata);
+
+        return 0;
+err:
+        server4_icreate_cbk (frame, NULL, frame->this, state->resolve.op_ret,
+                            state->resolve.op_errno, NULL, NULL, NULL);
+        return 0;
+}
+
+
+int
+server4_0_stat (rpcsvc_request_t *req)
+{
+        server_state_t *state    = NULL;
+        call_frame_t   *frame    = NULL;
+        gfx_stat_req   args     = {{0,},};
+        int             ret      = -1;
+        int             op_errno = 0;
+
+        if (!req)
+                return 0;
+
+        /* Initialize args first, then decode */
+        ret = rpc_receive_common (req, &frame, &state, NULL, &args,
+                                  xdr_gfx_stat_req, GF_FOP_STAT);
+        if (ret != 0) {
+                goto out;
+        }
+
+        state->resolve.type  = RESOLVE_MUST;
+        set_resolve_gfid (frame->root->client, state->resolve.gfid, args.gfid);
+
+        xdr_to_dict (&args.xdata, &state->xdata);
+
+        ret = 0;
+        resolve_and_resume (frame, server4_stat_resume);
+
+out:
+
+
+        if (op_errno)
+                SERVER_REQ_SET_ERROR (req, ret);
+
+        return ret;
+}
+
+
+int
+server4_0_setattr (rpcsvc_request_t *req)
+{
+        server_state_t   *state                 = NULL;
+        call_frame_t     *frame                 = NULL;
+        gfx_setattr_req  args                  = {{0,},};
+        int               ret                   = -1;
+        int               op_errno = 0;
+
+        if (!req)
+                return 0;
+
+        ret = rpc_receive_common (req, &frame, &state, NULL, &args,
+                                  xdr_gfx_setattr_req, GF_FOP_SETATTR);
+        if (ret != 0) {
+                goto out;
+        }
+
+        state->resolve.type  = RESOLVE_MUST;
+        set_resolve_gfid (frame->root->client, state->resolve.gfid, args.gfid);
+
+        gfx_stat_to_iattx (&args.stbuf, &state->stbuf);
+        state->valid = args.valid;
+
+        xdr_to_dict (&args.xdata, &state->xdata);
+
+        ret = 0;
+        resolve_and_resume (frame, server4_setattr_resume);
+
+out:
+        if (op_errno)
+                SERVER_REQ_SET_ERROR (req, ret);
+
+
+
+        return ret;
+}
+
+
+int
+server4_0_fallocate(rpcsvc_request_t *req)
+{
+        server_state_t    *state = NULL;
+        call_frame_t      *frame = NULL;
+        gfx_fallocate_req args  = {{0},};
+        int                ret   = -1;
+        int                op_errno = 0;
+
+        if (!req)
+                return ret;
+
+        ret = rpc_receive_common (req, &frame, &state, NULL, &args,
+                                  xdr_gfx_fallocate_req, GF_FOP_FALLOCATE);
+        if (ret != 0) {
+                goto out;
+        }
+
+        state->resolve.type   = RESOLVE_MUST;
+        state->resolve.fd_no  = args.fd;
+
+        state->flags = args.flags;
+        state->offset = args.offset;
+        state->size = args.size;
+        memcpy(state->resolve.gfid, args.gfid, 16);
+
+        xdr_to_dict (&args.xdata, &state->xdata);
+
+        ret = 0;
+        resolve_and_resume (frame, server4_fallocate_resume);
+
+out:
+
+
+        if (op_errno)
+                SERVER_REQ_SET_ERROR (req, ret);
+
+        return ret;
+}
+
+
+int
+server4_0_discard(rpcsvc_request_t *req)
+{
+        server_state_t    *state = NULL;
+        call_frame_t      *frame = NULL;
+        gfx_discard_req args    = {{0},};
+        int                ret   = -1;
+        int                op_errno = 0;
+
+        if (!req)
+                return ret;
+
+        ret = rpc_receive_common (req, &frame, &state, NULL, &args,
+                                  xdr_gfx_discard_req, GF_FOP_DISCARD);
+        if (ret != 0) {
+                goto out;
+        }
+
+        state->resolve.type   = RESOLVE_MUST;
+        state->resolve.fd_no  = args.fd;
+
+        state->offset = args.offset;
+        state->size = args.size;
+        memcpy(state->resolve.gfid, args.gfid, 16);
+
+        xdr_to_dict (&args.xdata, &state->xdata);
+
+        ret = 0;
+        resolve_and_resume (frame, server4_discard_resume);
+
+out:
+
+
+        if (op_errno)
+                SERVER_REQ_SET_ERROR (req, ret);
+
+        return ret;
+}
+
+
+int
+server4_0_zerofill(rpcsvc_request_t *req)
+{
+        server_state_t       *state      = NULL;
+        call_frame_t         *frame      = NULL;
+        gfx_zerofill_req     args       = {{0},};
+        int                   ret        = -1;
+        int                   op_errno   = 0;
+
+        if (!req)
+                return ret;
+
+        ret = rpc_receive_common (req, &frame, &state, NULL, &args,
+                                  xdr_gfx_zerofill_req, GF_FOP_ZEROFILL);
+        if (ret != 0) {
+                goto out;
+        }
+
+        state->resolve.type   = RESOLVE_MUST;
+        state->resolve.fd_no  = args.fd;
+
+        state->offset = args.offset;
+        state->size = args.size;
+        memcpy(state->resolve.gfid, args.gfid, 16);
+
+        xdr_to_dict (&args.xdata, &state->xdata);
+        ret = 0;
+        resolve_and_resume (frame, server4_zerofill_resume);
+
+out:
+
+
+        if (op_errno)
+                req->rpc_err = GARBAGE_ARGS;
+
+        return ret;
+}
+
+int
+server4_0_ipc (rpcsvc_request_t *req)
+{
+        server_state_t  *state          = NULL;
+        call_frame_t    *frame          = NULL;
+        gfx_ipc_req     args           = {0,};
+        int              ret            = -1;
+        int              op_errno       = 0;
+        xlator_t        *bound_xl       = NULL;
+
+        if (!req)
+                return ret;
+
+        ret = rpc_receive_common (req, &frame, &state, NULL, &args,
+                                  xdr_gfx_ipc_req, GF_FOP_IPC);
+        if (ret != 0) {
+                goto out;
+        }
+
+        bound_xl = frame->root->client->bound_xl;
+        xdr_to_dict (&args.xdata, &state->xdata);
+        ret = 0;
+        STACK_WIND (frame, server4_ipc_cbk, bound_xl, bound_xl->fops->ipc,
+                    args.op, state->xdata);
+
+out:
+
+
+        if (op_errno)
+                req->rpc_err = GARBAGE_ARGS;
+
+        return ret;
+}
+
+int
+server4_0_seek (rpcsvc_request_t *req)
+{
+        server_state_t        *state          = NULL;
+        call_frame_t          *frame          = NULL;
+        gfx_seek_req           args           = {{0,},};
+        int                    ret            = -1;
+        int                    op_errno       = 0;
+
+        if (!req)
+                return ret;
+
+        ret = rpc_receive_common (req, &frame, &state, NULL, &args,
+                                  xdr_gfx_seek_req, GF_FOP_SEEK);
+        if (ret != 0) {
+                goto out;
+        }
+
+        state->resolve.type   = RESOLVE_MUST;
+        state->resolve.fd_no  = args.fd;
+
+        state->offset = args.offset;
+        state->what = args.what;
+        memcpy(state->resolve.gfid, args.gfid, 16);
+
+        xdr_to_dict (&args.xdata, &state->xdata);
+
+        ret = 0;
+        resolve_and_resume (frame, server4_seek_resume);
+
+out:
+        if (op_errno)
+                SERVER_REQ_SET_ERROR (req, ret);
+
+        return ret;
+}
+
+int
+server4_0_readlink (rpcsvc_request_t *req)
+{
+        server_state_t    *state                 = NULL;
+        call_frame_t      *frame                 = NULL;
+        gfx_readlink_req  args                  = {{0,},};
+        int                ret                   = -1;
+        int                op_errno = 0;
+
+        if (!req)
+                return ret;
+
+        ret = rpc_receive_common (req, &frame, &state, NULL, &args,
+                                  xdr_gfx_readlink_req, GF_FOP_READLINK);
+        if (ret != 0) {
+                goto out;
+        }
+
+        state->resolve.type = RESOLVE_MUST;
+        memcpy (state->resolve.gfid, args.gfid, 16);
+
+        state->size  = args.size;
+
+        xdr_to_dict (&args.xdata, &state->xdata);
+
+        ret = 0;
+        resolve_and_resume (frame, server4_readlink_resume);
+
+out:
+
+
+        if (op_errno)
+                SERVER_REQ_SET_ERROR (req, ret);
+
+        return ret;
+}
+
+
+int
+server4_0_create (rpcsvc_request_t *req)
+{
+        server_state_t  *state    = NULL;
+        call_frame_t    *frame    = NULL;
+        gfx_create_req  args     = {{0,},};
+        int              ret      = -1;
+        int              op_errno = 0;
+
+        if (!req)
+                return ret;
+
+        args.bname = alloca (req->msg[0].iov_len);
+
+        ret = rpc_receive_common (req, &frame, &state, NULL, &args,
+                                  xdr_gfx_create_req, GF_FOP_CREATE);
+        if (ret != 0) {
+                goto out;
+        }
+
+        state->resolve.bname  = gf_strdup (args.bname);
+        state->mode           = args.mode;
+        state->umask          = args.umask;
+        state->flags          = gf_flags_to_flags (args.flags);
+
+        set_resolve_gfid (frame->root->client, state->resolve.pargfid,
+                          args.pargfid);
+
+        if (state->flags & O_EXCL) {
+                state->resolve.type = RESOLVE_NOT;
+        } else {
+                state->resolve.type = RESOLVE_DONTCARE;
+        }
+
+        xdr_to_dict (&args.xdata, &state->xdata);
+
+        ret = 0;
+        resolve_and_resume (frame, server4_create_resume);
+
+out:
+        if (op_errno)
+                SERVER_REQ_SET_ERROR (req, ret);
+
+        return ret;
+}
+
+
+int
+server4_0_open (rpcsvc_request_t *req)
+{
+        server_state_t *state                 = NULL;
+        call_frame_t   *frame                 = NULL;
+        gfx_open_req   args                  = {{0,},};
+        int             ret                   = -1;
+        int             op_errno = 0;
+
+        if (!req)
+                return ret;
+
+        ret = rpc_receive_common (req, &frame, &state, NULL, &args,
+                                  xdr_gfx_open_req, GF_FOP_OPEN);
+        if (ret != 0) {
+                goto out;
+        }
+
+        state->resolve.type  = RESOLVE_MUST;
+        memcpy (state->resolve.gfid, args.gfid, 16);
+
+        state->flags = gf_flags_to_flags (args.flags);
+
+        xdr_to_dict (&args.xdata, &state->xdata);
+
+        ret = 0;
+        resolve_and_resume (frame, server4_open_resume);
+out:
+        if (op_errno)
+                SERVER_REQ_SET_ERROR (req, ret);
+
+
+
+        return ret;
+}
+
+
+int
+server4_0_readv (rpcsvc_request_t *req)
+{
+        server_state_t *state = NULL;
+        call_frame_t   *frame = NULL;
+        gfx_read_req   args  = {{0,},};
+        int             ret   = -1;
+        int             op_errno = 0;
+
+        if (!req)
+                goto out;
+
+        ret = rpc_receive_common (req, &frame, &state, NULL, &args,
+                                  xdr_gfx_read_req, GF_FOP_READ);
+        if (ret != 0) {
+                goto out;
+        }
+
+        state->resolve.type   = RESOLVE_MUST;
+        state->resolve.fd_no  = args.fd;
+        state->size           = args.size;
+        state->offset         = args.offset;
+        state->flags          = args.flag;
+
+        memcpy (state->resolve.gfid, args.gfid, 16);
+
+        xdr_to_dict (&args.xdata, &state->xdata);
+
+        ret = 0;
+        resolve_and_resume (frame, server4_readv_resume);
+out:
+        if (op_errno)
+                SERVER_REQ_SET_ERROR (req, ret);
+
+        return ret;
+}
+
+
+int
+server4_0_writev (rpcsvc_request_t *req)
+{
+        server_state_t      *state  = NULL;
+        call_frame_t        *frame  = NULL;
+        gfx_write_req       args   = {{0,},};
+        ssize_t              len    = 0;
+        int                  i      = 0;
+        int                  ret    = -1;
+        int                  op_errno = 0;
+
+        if (!req)
+                return ret;
+
+        ret = rpc_receive_common (req, &frame, &state, &len, &args,
+                                  xdr_gfx_write_req, GF_FOP_WRITE);
+        if (ret != 0) {
+                goto out;
+        }
+
+        state->resolve.type  = RESOLVE_MUST;
+        state->resolve.fd_no = args.fd;
+        state->offset        = args.offset;
+        state->size          = args.size;
+        state->flags         = args.flag;
+        state->iobref        = iobref_ref (req->iobref);
+        memcpy (state->resolve.gfid, args.gfid, 16);
+
+        if (len < req->msg[0].iov_len) {
+                state->payload_vector[0].iov_base
+                        = (req->msg[0].iov_base + len);
+                state->payload_vector[0].iov_len
+                        = req->msg[0].iov_len - len;
+                state->payload_count = 1;
+        }
+
+        for (i = 1; i < req->count; i++) {
+                state->payload_vector[state->payload_count++]
+                        = req->msg[i];
+        }
+
+        len = iov_length (state->payload_vector, state->payload_count);
+
+        GF_ASSERT (state->size == len);
+
+        xdr_to_dict (&args.xdata, &state->xdata);
+
+#ifdef GF_TESTING_IO_XDATA
+        dict_dump_to_log (state->xdata);
+#endif
+
+        ret = 0;
+        resolve_and_resume (frame, server4_writev_resume);
+out:
+
+
+        if (op_errno)
+                SERVER_REQ_SET_ERROR (req, ret);
+
+        return ret;
+}
+
+
+#define SERVER4_0_VECWRITE_START 0
+#define SERVER4_0_VECWRITE_READING_HDR 1
+#define SERVER4_0_VECWRITE_READING_OPAQUE 2
+
+int
+server4_0_writev_vecsizer (int state, ssize_t *readsize, char *base_addr,
+                           char *curr_addr)
+{
+        ssize_t         size = 0;
+        int             nextstate = 0;
+        gfx_write_req   write_req = {{0,},};
+        XDR             xdr;
+
+        switch (state) {
+        case SERVER4_0_VECWRITE_START:
+                size = xdr_sizeof ((xdrproc_t) xdr_gfx_write_req,
+                                   &write_req);
+                *readsize = size;
+
+                nextstate = SERVER4_0_VECWRITE_READING_HDR;
+                break;
+        case SERVER4_0_VECWRITE_READING_HDR:
+                size = xdr_sizeof ((xdrproc_t) xdr_gfx_write_req,
+                                           &write_req);
+
+                xdrmem_create (&xdr, base_addr, size, XDR_DECODE);
+
+                /* This will fail if there is xdata sent from client, if not,
+                   well and good */
+                xdr_gfx_write_req (&xdr, &write_req);
+
+                /* need to round off to proper roof (%4), as XDR packing pads
+                   the end of opaque object with '0' */
+                size = roof (write_req.xdata.xdr_size, 4);
+
+                *readsize = size;
+
+                if (!size)
+                        nextstate = SERVER4_0_VECWRITE_START;
+                else
+                        nextstate = SERVER4_0_VECWRITE_READING_OPAQUE;
+
+                free (write_req.xdata.pairs.pairs_val);
+
+                break;
+
+        case SERVER4_0_VECWRITE_READING_OPAQUE:
+                *readsize = 0;
+                nextstate = SERVER4_0_VECWRITE_START;
+                break;
+        }
+
+        return nextstate;
+}
+
+
+int
+server4_0_release (rpcsvc_request_t *req)
+{
+        client_t         *client   = NULL;
+        server_ctx_t     *serv_ctx = NULL;
+        gfx_release_req  args     = {{0,},};
+        gfx_common_rsp     rsp      = {0,};
+        int               ret      = -1;
+
+        ret = xdr_to_generic (req->msg[0], &args,
+                              (xdrproc_t)xdr_gfx_release_req);
+        if (ret < 0) {
+                SERVER_REQ_SET_ERROR (req, ret);
+                goto out;
+        }
+
+        client = req->trans->xl_private;
+        if (!client) {
+                /* Handshake is not complete yet. */
+                req->rpc_err = SYSTEM_ERR;
+                goto out;
+        }
+
+        serv_ctx = server_ctx_get (client, client->this);
+        if (serv_ctx == NULL) {
+                gf_msg (req->trans->name, GF_LOG_INFO, 0,
+                        PS_MSG_SERVER_CTX_GET_FAILED, "server_ctx_get() "
+                        "failed");
+                req->rpc_err = SYSTEM_ERR;
+                goto out;
+        }
+
+        gf_fd_put (serv_ctx->fdtable, args.fd);
+
+        server_submit_reply (NULL, req, &rsp, NULL, 0, NULL,
+                             (xdrproc_t)xdr_gfx_common_rsp);
+
+        ret = 0;
+out:
+        return ret;
+}
+
+int
+server4_0_releasedir (rpcsvc_request_t *req)
+{
+        client_t            *client   = NULL;
+        server_ctx_t        *serv_ctx = NULL;
+        gfx_releasedir_req  args     = {{0,},};
+        gfx_common_rsp        rsp      = {0,};
+        int                  ret      = -1;
+
+        ret = xdr_to_generic (req->msg[0], &args,
+                              (xdrproc_t)xdr_gfx_release_req);
+        if (ret < 0) {
+                SERVER_REQ_SET_ERROR (req, ret);
+                goto out;
+        }
+
+        client = req->trans->xl_private;
+        if (!client) {
+                SERVER_REQ_SET_ERROR (req, ret);
+                goto out;
+        }
+
+        serv_ctx = server_ctx_get (client, client->this);
+        if (serv_ctx == NULL) {
+                gf_msg (req->trans->name, GF_LOG_INFO, 0,
+                        PS_MSG_SERVER_CTX_GET_FAILED, "server_ctx_get() "
+                        "failed");
+                req->rpc_err = SYSTEM_ERR;
+                goto out;
+        }
+
+        gf_fd_put (serv_ctx->fdtable, args.fd);
+
+        server_submit_reply (NULL, req, &rsp, NULL, 0, NULL,
+                             (xdrproc_t)xdr_gfx_common_rsp);
+
+        ret = 0;
+out:
+        return ret;
+}
+
+
+int
+server4_0_fsync (rpcsvc_request_t *req)
+{
+        server_state_t *state = NULL;
+        call_frame_t   *frame = NULL;
+        gfx_fsync_req  args  = {{0,},};
+        int             ret   = -1;
+        int             op_errno = 0;
+
+        if (!req)
+                return ret;
+
+        ret = rpc_receive_common (req, &frame, &state, NULL, &args,
+                                  xdr_gfx_fsync_req, GF_FOP_FSYNC);
+        if (ret != 0) {
+                goto out;
+        }
+
+        state->resolve.type  = RESOLVE_MUST;
+        state->resolve.fd_no = args.fd;
+        state->flags         = args.data;
+        memcpy (state->resolve.gfid, args.gfid, 16);
+
+        xdr_to_dict (&args.xdata, &state->xdata);
+
+        ret = 0;
+        resolve_and_resume (frame, server4_fsync_resume);
+out:
+
+
+        if (op_errno)
+                SERVER_REQ_SET_ERROR (req, ret);
+
+        return ret;
+}
+
+
+
+int
+server4_0_flush (rpcsvc_request_t *req)
+{
+        server_state_t *state = NULL;
+        call_frame_t   *frame = NULL;
+        gfx_flush_req  args  = {{0,},};
+        int             ret   = -1;
+        int             op_errno = 0;
+
+        if (!req)
+                return ret;
+
+        ret = rpc_receive_common (req, &frame, &state, NULL, &args,
+                                  xdr_gfx_flush_req, GF_FOP_FLUSH);
+        if (ret != 0) {
+                goto out;
+        }
+
+        state->resolve.type  = RESOLVE_MUST;
+        state->resolve.fd_no = args.fd;
+        memcpy (state->resolve.gfid, args.gfid, 16);
+
+        xdr_to_dict (&args.xdata, &state->xdata);
+
+        ret = 0;
+        resolve_and_resume (frame, server4_flush_resume);
+out:
+
+
+        if (op_errno)
+                SERVER_REQ_SET_ERROR (req, ret);
+
+        return ret;
+}
+
+
+
+int
+server4_0_ftruncate (rpcsvc_request_t *req)
+{
+        server_state_t     *state = NULL;
+        call_frame_t       *frame = NULL;
+        gfx_ftruncate_req  args  = {{0,},};
+        int                 ret   = -1;
+        int                 op_errno = 0;
+
+        if (!req)
+                return ret;
+
+        ret = rpc_receive_common (req, &frame, &state, NULL, &args,
+                                  xdr_gfx_ftruncate_req, GF_FOP_FTRUNCATE);
+        if (ret != 0) {
+                goto out;
+        }
+
+        state->resolve.type   = RESOLVE_MUST;
+        state->resolve.fd_no  = args.fd;
+        state->offset         = args.offset;
+        memcpy (state->resolve.gfid, args.gfid, 16);
+
+        xdr_to_dict (&args.xdata, &state->xdata);
+
+        ret = 0;
+        resolve_and_resume (frame, server4_ftruncate_resume);
+out:
+
+
+        if (op_errno)
+                SERVER_REQ_SET_ERROR (req, ret);
+
+        return ret;
+}
+
+
+int
+server4_0_fstat (rpcsvc_request_t *req)
+{
+        server_state_t *state = NULL;
+        call_frame_t   *frame = NULL;
+        gfx_fstat_req  args  = {{0,},};
+        int             ret   = -1;
+        int             op_errno = 0;
+
+        if (!req)
+                return ret;
+
+        ret = rpc_receive_common (req, &frame, &state, NULL, &args,
+                                  xdr_gfx_fstat_req, GF_FOP_FSTAT);
+        if (ret != 0) {
+                goto out;
+        }
+
+        state->resolve.type    = RESOLVE_MUST;
+        state->resolve.fd_no   = args.fd;
+        set_resolve_gfid (frame->root->client, state->resolve.gfid, args.gfid);
+
+        xdr_to_dict (&args.xdata, &state->xdata);
+
+        ret = 0;
+        resolve_and_resume (frame, server4_fstat_resume);
+out:
+
+
+        if (op_errno)
+                SERVER_REQ_SET_ERROR (req, ret);
+
+        return ret;
+}
+
+
+int
+server4_0_truncate (rpcsvc_request_t *req)
+{
+        server_state_t    *state                 = NULL;
+        call_frame_t      *frame                 = NULL;
+        gfx_truncate_req  args                  = {{0,},};
+        int                ret                   = -1;
+        int                op_errno = 0;
+
+        if (!req)
+                return ret;
+
+        ret = rpc_receive_common (req, &frame, &state, NULL, &args,
+                                  xdr_gfx_truncate_req, GF_FOP_TRUNCATE);
+        if (ret != 0) {
+                goto out;
+        }
+
+        state->resolve.type  = RESOLVE_MUST;
+        memcpy (state->resolve.gfid, args.gfid, 16);
+        state->offset        = args.offset;
+
+        xdr_to_dict (&args.xdata, &state->xdata);
+
+        ret = 0;
+        resolve_and_resume (frame, server4_truncate_resume);
+out:
+
+
+        if (op_errno)
+                SERVER_REQ_SET_ERROR (req, ret);
+
+        return ret;
+}
+
+
+
+int
+server4_0_unlink (rpcsvc_request_t *req)
+{
+        server_state_t  *state                  = NULL;
+        call_frame_t    *frame                  = NULL;
+        gfx_unlink_req  args                   = {{0,},};
+        int              ret                    = -1;
+        int              op_errno = 0;
+
+        if (!req)
+                return ret;
+
+        args.bname = alloca (req->msg[0].iov_len);
+
+        ret = rpc_receive_common (req, &frame, &state, NULL, &args,
+                                  xdr_gfx_unlink_req, GF_FOP_UNLINK);
+        if (ret != 0) {
+                goto out;
+        }
+
+        state->resolve.type   = RESOLVE_MUST;
+        state->resolve.bname  = gf_strdup (args.bname);
+
+        set_resolve_gfid (frame->root->client, state->resolve.pargfid,
+                          args.pargfid);
+
+        state->flags = args.xflags;
+
+        xdr_to_dict (&args.xdata, &state->xdata);
+
+        ret = 0;
+        resolve_and_resume (frame, server4_unlink_resume);
+out:
+
+
+        if (op_errno)
+                SERVER_REQ_SET_ERROR (req, ret);
+
+        return ret;
+}
+
+
+int
+server4_0_setxattr (rpcsvc_request_t *req)
+{
+        server_state_t      *state                 = NULL;
+        call_frame_t        *frame                 = NULL;
+        gfx_setxattr_req    args                  = {{0,},};
+        int32_t              ret                   = -1;
+        int32_t              op_errno = 0;
+
+        if (!req)
+                return ret;
+
+        ret = rpc_receive_common (req, &frame, &state, NULL, &args,
+                                  xdr_gfx_setxattr_req, GF_FOP_SETXATTR);
+        if (ret != 0) {
+                goto out;
+        }
+
+        state->resolve.type     = RESOLVE_MUST;
+        state->flags            = args.flags;
+        set_resolve_gfid (frame->root->client, state->resolve.gfid, args.gfid);
+
+        ret = xdr_to_dict (&args.dict, &state->dict);
+        if (ret)
+                gf_msg_debug (THIS->name, EINVAL,
+                              "dictionary not received");
+
+        /* There can be some commands hidden in key, check and proceed */
+        gf_server_check_setxattr_cmd (frame, state->dict);
+
+        xdr_to_dict (&args.xdata, &state->xdata);
+
+        ret = 0;
+        resolve_and_resume (frame, server4_setxattr_resume);
+
+out:
+        if (op_errno)
+                SERVER_REQ_SET_ERROR (req, ret);
+
+        return ret;
+}
+
+
+
+int
+server4_0_fsetxattr (rpcsvc_request_t *req)
+{
+        server_state_t      *state                = NULL;
+        call_frame_t        *frame                = NULL;
+        gfx_fsetxattr_req   args                 = {{0,},};
+        int32_t              ret                  = -1;
+        int32_t              op_errno = 0;
+
+        if (!req)
+                return ret;
+
+        ret = rpc_receive_common (req, &frame, &state, NULL, &args,
+                                  xdr_gfx_fsetxattr_req, GF_FOP_FSETXATTR);
+        if (ret != 0) {
+                goto out;
+        }
+
+        state->resolve.type      = RESOLVE_MUST;
+        state->resolve.fd_no     = args.fd;
+        state->flags             = args.flags;
+        set_resolve_gfid (frame->root->client, state->resolve.gfid, args.gfid);
+
+        ret = xdr_to_dict (&args.dict, &state->dict);
+        if (ret)
+                gf_msg_debug (THIS->name, EINVAL,
+                              "dictionary not received");
+
+        xdr_to_dict (&args.xdata, &state->xdata);
+
+        ret = 0;
+        resolve_and_resume (frame, server4_fsetxattr_resume);
+
+out:
+        if (op_errno)
+                SERVER_REQ_SET_ERROR (req, ret);
+
+        return ret;
+}
+
+
+
+int
+server4_0_fxattrop (rpcsvc_request_t *req)
+{
+        server_state_t      *state                = NULL;
+        call_frame_t        *frame                = NULL;
+        gfx_fxattrop_req    args                 = {{0,},};
+        int32_t              ret                  = -1;
+        int32_t              op_errno = 0;
+
+        if (!req)
+                return ret;
+
+        ret = rpc_receive_common (req, &frame, &state, NULL, &args,
+                                  xdr_gfx_fxattrop_req, GF_FOP_FXATTROP);
+        if (ret != 0) {
+                goto out;
+        }
+
+        state->resolve.type    = RESOLVE_MUST;
+        state->resolve.fd_no   = args.fd;
+        state->flags           = args.flags;
+        set_resolve_gfid (frame->root->client, state->resolve.gfid, args.gfid);
+
+        ret = xdr_to_dict (&args.dict, &state->dict);
+        if (ret)
+                gf_msg_debug (THIS->name, EINVAL,
+                              "dictionary not received");
+
+        xdr_to_dict (&args.xdata, &state->xdata);
+
+        ret = 0;
+        resolve_and_resume (frame, server4_fxattrop_resume);
+
+out:
+        if (op_errno)
+                SERVER_REQ_SET_ERROR (req, ret);
+
+        return ret;
+}
+
+int
+server4_0_xattrop (rpcsvc_request_t *req)
+{
+        server_state_t      *state                 = NULL;
+        call_frame_t        *frame                 = NULL;
+        gfx_xattrop_req     args                  = {{0,},};
+        int32_t              ret                   = -1;
+        int32_t              op_errno = 0;
+
+        if (!req)
+                return ret;
+
+        ret = rpc_receive_common (req, &frame, &state, NULL, &args,
+                                  xdr_gfx_xattrop_req, GF_FOP_XATTROP);
+        if (ret != 0) {
+                goto out;
+        }
+
+        state->resolve.type    = RESOLVE_MUST;
+        state->flags           = args.flags;
+        set_resolve_gfid (frame->root->client, state->resolve.gfid, args.gfid);
+
+        ret = xdr_to_dict (&args.dict, &state->dict);
+        if (ret)
+                gf_msg_debug (THIS->name, EINVAL,
+                              "dictionary not received");
+
+        xdr_to_dict (&args.xdata, &state->xdata);
+
+        ret = 0;
+        resolve_and_resume (frame, server4_xattrop_resume);
+
+out:
+        if (op_errno)
+                SERVER_REQ_SET_ERROR (req, ret);
+
+        return ret;
+}
+
+
+int
+server4_0_getxattr (rpcsvc_request_t *req)
+{
+        server_state_t      *state                 = NULL;
+        call_frame_t        *frame                 = NULL;
+        gfx_getxattr_req    args                  = {{0,},};
+        int                  ret                   = -1;
+        int                  op_errno = 0;
+
+        if (!req)
+                return ret;
+
+        args.name = alloca (256);
+
+        ret = rpc_receive_common (req, &frame, &state, NULL, &args,
+                                  xdr_gfx_getxattr_req, GF_FOP_GETXATTR);
+        if (ret != 0) {
+                goto out;
+        }
+
+        state->resolve.type  = RESOLVE_MUST;
+        set_resolve_gfid (frame->root->client, state->resolve.gfid, args.gfid);
+
+        if (args.namelen) {
+                state->name = gf_strdup (args.name);
+                /* There can be some commands hidden in key, check and proceed */
+                gf_server_check_getxattr_cmd (frame, state->name);
+        }
+
+        xdr_to_dict (&args.xdata, &state->xdata);
+
+        ret = 0;
+        resolve_and_resume (frame, server4_getxattr_resume);
+out:
+
+
+        if (op_errno)
+                SERVER_REQ_SET_ERROR (req, ret);
+
+        return ret;
+}
+
+
+int
+server4_0_fgetxattr (rpcsvc_request_t *req)
+{
+        server_state_t      *state      = NULL;
+        call_frame_t        *frame      = NULL;
+        gfx_fgetxattr_req   args       = {{0,},};
+        int                  ret        = -1;
+        int                  op_errno = 0;
+
+        if (!req)
+                return ret;
+
+        args.name = alloca (256);
+
+        ret = rpc_receive_common (req, &frame, &state, NULL, &args,
+                                  xdr_gfx_fgetxattr_req, GF_FOP_FGETXATTR);
+        if (ret != 0) {
+                goto out;
+        }
+
+        state->resolve.type  = RESOLVE_MUST;
+        state->resolve.fd_no = args.fd;
+        set_resolve_gfid (frame->root->client, state->resolve.gfid, args.gfid);
+        if (args.namelen)
+                state->name = gf_strdup (args.name);
+
+        xdr_to_dict (&args.xdata, &state->xdata);
+
+        ret = 0;
+        resolve_and_resume (frame, server4_fgetxattr_resume);
+out:
+
+
+        if (op_errno)
+                SERVER_REQ_SET_ERROR (req, ret);
+
+        return ret;
+}
+
+
+
+int
+server4_0_removexattr (rpcsvc_request_t *req)
+{
+        server_state_t       *state                 = NULL;
+        call_frame_t         *frame                 = NULL;
+        gfx_removexattr_req  args                  = {{0,},};
+        int                   ret                   = -1;
+        int                   op_errno = 0;
+
+        if (!req)
+                return ret;
+
+        args.name = alloca (256);
+
+        ret = rpc_receive_common (req, &frame, &state, NULL, &args,
+                                  xdr_gfx_removexattr_req,
+                                  GF_FOP_REMOVEXATTR);
+        if (ret != 0) {
+                goto out;
+        }
+
+        state->resolve.type   = RESOLVE_MUST;
+        set_resolve_gfid (frame->root->client, state->resolve.gfid, args.gfid);
+        state->name           = gf_strdup (args.name);
+
+        xdr_to_dict (&args.xdata, &state->xdata);
+
+        ret = 0;
+        resolve_and_resume (frame, server4_removexattr_resume);
+out:
+
+
+        if (op_errno)
+                SERVER_REQ_SET_ERROR (req, ret);
+
+        return ret;
+}
+
+int
+server4_0_fremovexattr (rpcsvc_request_t *req)
+{
+        server_state_t       *state                 = NULL;
+        call_frame_t         *frame                 = NULL;
+        gfx_fremovexattr_req  args                  = {{0,},};
+        int                   ret                   = -1;
+        int                   op_errno = 0;
+
+        if (!req)
+                return ret;
+
+        args.name = alloca (256);
+
+        ret = rpc_receive_common (req, &frame, &state, NULL, &args,
+                                  xdr_gfx_fremovexattr_req,
+                                  GF_FOP_FREMOVEXATTR);
+        if (ret != 0) {
+                goto out;
+        }
+
+        state->resolve.type   = RESOLVE_MUST;
+        state->resolve.fd_no  = args.fd;
+        set_resolve_gfid (frame->root->client, state->resolve.gfid, args.gfid);
+        state->name           = gf_strdup (args.name);
+
+        xdr_to_dict (&args.xdata, &state->xdata);
+
+        ret = 0;
+        resolve_and_resume (frame, server4_fremovexattr_resume);
+out:
+
+
+        if (op_errno)
+                SERVER_REQ_SET_ERROR (req, ret);
+
+        return ret;
+}
+
+
+
+
+int
+server4_0_opendir (rpcsvc_request_t *req)
+{
+        server_state_t   *state                 = NULL;
+        call_frame_t     *frame                 = NULL;
+        gfx_opendir_req  args                  = {{0,},};
+        int               ret                   = -1;
+        int               op_errno = 0;
+
+        if (!req)
+                return ret;
+
+        ret = rpc_receive_common (req, &frame, &state, NULL, &args,
+                                  xdr_gfx_opendir_req, GF_FOP_OPENDIR);
+        if (ret != 0) {
+                goto out;
+        }
+
+        state->resolve.type   = RESOLVE_MUST;
+        set_resolve_gfid (frame->root->client, state->resolve.gfid, args.gfid);
+
+        xdr_to_dict (&args.xdata, &state->xdata);
+
+        ret = 0;
+        resolve_and_resume (frame, server4_opendir_resume);
+out:
+
+
+        if (op_errno)
+                SERVER_REQ_SET_ERROR (req, ret);
+
+        return ret;
+}
+
+
+int
+server4_0_readdirp (rpcsvc_request_t *req)
+{
+        server_state_t      *state        = NULL;
+        call_frame_t        *frame        = NULL;
+        gfx_readdirp_req    args         = {{0,},};
+        size_t               headers_size = 0;
+        int                  ret          = -1;
+        int                  op_errno = 0;
+
+        if (!req)
+                return ret;
+
+        ret = rpc_receive_common (req, &frame, &state, NULL, &args,
+                                  xdr_gfx_readdirp_req,
+                                  GF_FOP_READDIRP);
+        if (ret != 0) {
+                goto out;
+        }
+
+        /* FIXME: this should go away when variable sized iobufs are introduced
+         * and transport layer can send msgs bigger than current page-size.
+         */
+        headers_size = sizeof (struct rpc_msg) + sizeof (gfx_readdir_rsp);
+        if ((frame->this->ctx->page_size < args.size)
+            || ((frame->this->ctx->page_size - args.size) < headers_size)) {
+                state->size = frame->this->ctx->page_size - headers_size;
+        } else {
+                state->size   = args.size;
+        }
+
+        state->resolve.type = RESOLVE_MUST;
+        state->resolve.fd_no = args.fd;
+        state->offset = args.offset;
+        set_resolve_gfid (frame->root->client, state->resolve.gfid, args.gfid);
+
+        /* here, dict itself works as xdata */
+        xdr_to_dict (&args.xdata, &state->xdata);
+
+        ret = 0;
+        resolve_and_resume (frame, server4_readdirp_resume);
+out:
+        if (op_errno)
+                SERVER_REQ_SET_ERROR (req, ret);
+
+        return ret;
+}
+
+int
+server4_0_readdir (rpcsvc_request_t *req)
+{
+        server_state_t      *state        = NULL;
+        call_frame_t        *frame        = NULL;
+        gfx_readdir_req     args         = {{0,},};
+        size_t               headers_size = 0;
+        int                  ret          = -1;
+        int                  op_errno = 0;
+
+        if (!req)
+                return ret;
+
+        ret = rpc_receive_common (req, &frame, &state, NULL, &args,
+                                  xdr_gfx_readdir_req, GF_FOP_READDIR);
+        if (ret != 0) {
+                goto out;
+        }
+
+        /* FIXME: this should go away when variable sized iobufs are introduced
+         * and transport layer can send msgs bigger than current page-size.
+         */
+        headers_size = sizeof (struct rpc_msg) + sizeof (gfx_readdir_rsp);
+        if ((frame->this->ctx->page_size < args.size)
+            || ((frame->this->ctx->page_size - args.size) < headers_size)) {
+                state->size = frame->this->ctx->page_size - headers_size;
+        } else {
+                state->size   = args.size;
+        }
+
+        state->resolve.type = RESOLVE_MUST;
+        state->resolve.fd_no = args.fd;
+        state->offset = args.offset;
+        set_resolve_gfid (frame->root->client, state->resolve.gfid, args.gfid);
+
+        xdr_to_dict (&args.xdata, &state->xdata);
+
+        ret = 0;
+        resolve_and_resume (frame, server4_readdir_resume);
+out:
+
+
+        if (op_errno)
+                SERVER_REQ_SET_ERROR (req, ret);
+
+        return ret;
+}
+
+int
+server4_0_fsyncdir (rpcsvc_request_t *req)
+{
+        server_state_t      *state = NULL;
+        call_frame_t        *frame = NULL;
+        gfx_fsyncdir_req    args  = {{0,},};
+        int                  ret   = -1;
+        int                  op_errno = 0;
+
+        if (!req)
+                return ret;
+
+        ret = rpc_receive_common (req, &frame, &state, NULL, &args,
+                                  xdr_gfx_fsyncdir_req, GF_FOP_FSYNCDIR);
+        if (ret != 0) {
+                goto out;
+        }
+
+        state->resolve.type = RESOLVE_MUST;
+        state->resolve.fd_no = args.fd;
+        state->flags = args.data;
+        set_resolve_gfid (frame->root->client, state->resolve.gfid, args.gfid);
+
+        xdr_to_dict (&args.xdata, &state->xdata);
+
+        ret = 0;
+        resolve_and_resume (frame, server4_fsyncdir_resume);
+out:
+
+
+        if (op_errno)
+                SERVER_REQ_SET_ERROR (req, ret);
+
+        return ret;
+}
+
+
+
+int
+server4_0_mknod (rpcsvc_request_t *req)
+{
+        server_state_t      *state                  = NULL;
+        call_frame_t        *frame                  = NULL;
+        gfx_mknod_req       args                   = {{0,},};
+        int                  ret                    = -1;
+        int                  op_errno = 0;
+
+        if (!req)
+                return ret;
+
+        args.bname = alloca (req->msg[0].iov_len);
+
+        ret = rpc_receive_common (req, &frame, &state, NULL, &args,
+                                  xdr_gfx_mknod_req, GF_FOP_MKNOD);
+        if (ret != 0) {
+                goto out;
+        }
+
+        state->resolve.type    = RESOLVE_NOT;
+        set_resolve_gfid (frame->root->client, state->resolve.pargfid,
+                          args.pargfid);
+
+        state->resolve.bname   = gf_strdup (args.bname);
+
+        state->mode  = args.mode;
+        state->dev   = args.dev;
+        state->umask = args.umask;
+
+        xdr_to_dict (&args.xdata, &state->xdata);
+
+        ret = 0;
+        resolve_and_resume (frame, server4_mknod_resume);
+
+out:
+        if (op_errno)
+                SERVER_REQ_SET_ERROR (req, ret);
+
+        return ret;
+
+}
+
+
+int
+server4_0_mkdir (rpcsvc_request_t *req)
+{
+        server_state_t      *state                  = NULL;
+        call_frame_t        *frame                  = NULL;
+        gfx_mkdir_req       args                   = {{0,},};
+        int                  ret                    = -1;
+        int                  op_errno = 0;
+
+        if (!req)
+                return ret;
+
+        args.bname = alloca (req->msg[0].iov_len);
+
+        ret = rpc_receive_common (req, &frame, &state, NULL, &args,
+                                  xdr_gfx_mkdir_req, GF_FOP_MKDIR);
+        if (ret != 0) {
+                goto out;
+        }
+
+        state->resolve.type    = RESOLVE_NOT;
+        set_resolve_gfid (frame->root->client, state->resolve.pargfid,
+                          args.pargfid);
+        state->resolve.bname   = gf_strdup (args.bname);
+
+        state->mode  = args.mode;
+        state->umask = args.umask;
+
+        xdr_to_dict (&args.xdata, &state->xdata);
+
+        ret = 0;
+        resolve_and_resume (frame, server4_mkdir_resume);
+
+out:
+        if (op_errno)
+                SERVER_REQ_SET_ERROR (req, ret);
+
+
+
+        return ret;
+}
+
+
+int
+server4_0_rmdir (rpcsvc_request_t *req)
+{
+        server_state_t      *state                  = NULL;
+        call_frame_t        *frame                  = NULL;
+        gfx_rmdir_req       args                   = {{0,},};
+        int                  ret                    = -1;
+        int                  op_errno = 0;
+
+        if (!req)
+                return ret;
+
+        args.bname = alloca (req->msg[0].iov_len);
+
+        ret = rpc_receive_common (req, &frame, &state, NULL, &args,
+                                  xdr_gfx_rmdir_req, GF_FOP_RMDIR);
+        if (ret != 0) {
+                goto out;
+        }
+
+        state->resolve.type    = RESOLVE_MUST;
+        set_resolve_gfid (frame->root->client, state->resolve.pargfid,
+                          args.pargfid);
+        state->resolve.bname   = gf_strdup (args.bname);
+
+        state->flags = args.xflags;
+
+        xdr_to_dict (&args.xdata, &state->xdata);
+
+        ret = 0;
+        resolve_and_resume (frame, server4_rmdir_resume);
+out:
+
+
+        if (op_errno)
+                SERVER_REQ_SET_ERROR (req, ret);
+
+        return ret;
+}
+
+
+
+int
+server4_0_inodelk (rpcsvc_request_t *req)
+{
+        server_state_t      *state                 = NULL;
+        call_frame_t        *frame                 = NULL;
+        gfx_inodelk_req     args                  = {{0,},};
+        int                  cmd                   = 0;
+        int                  ret                   = -1;
+        int                  op_errno = 0;
+
+        if (!req)
+                return ret;
+
+        args.volume = alloca (256);
+
+        ret = rpc_receive_common (req, &frame, &state, NULL, &args,
+                                  xdr_gfx_inodelk_req, GF_FOP_INODELK);
+        if (ret != 0) {
+                goto out;
+        }
+
+        state->resolve.type    = RESOLVE_EXACT;
+        set_resolve_gfid (frame->root->client, state->resolve.gfid, args.gfid);
+
+        cmd = args.cmd;
+        switch (cmd) {
+        case GF_LK_GETLK:
+                state->cmd = F_GETLK;
+                break;
+        case GF_LK_SETLK:
+                state->cmd = F_SETLK;
+                break;
+        case GF_LK_SETLKW:
+                state->cmd = F_SETLKW;
+                break;
+        }
+
+        state->type = args.type;
+        state->volume = gf_strdup (args.volume);
+
+        gf_proto_flock_to_flock (&args.flock, &state->flock);
+
+        switch (state->type) {
+        case GF_LK_F_RDLCK:
+                state->flock.l_type = F_RDLCK;
+                break;
+        case GF_LK_F_WRLCK:
+                state->flock.l_type = F_WRLCK;
+                break;
+        case GF_LK_F_UNLCK:
+                state->flock.l_type = F_UNLCK;
+                break;
+        }
+
+        xdr_to_dict (&args.xdata, &state->xdata);
+
+        ret = 0;
+        resolve_and_resume (frame, server4_inodelk_resume);
+out:
+
+
+        free (args.flock.lk_owner.lk_owner_val);
+
+        if (op_errno)
+                SERVER_REQ_SET_ERROR (req, ret);
+
+        return ret;
+}
+
+int
+server4_0_finodelk (rpcsvc_request_t *req)
+{
+        server_state_t      *state        = NULL;
+        call_frame_t        *frame        = NULL;
+        gfx_finodelk_req    args         = {{0,},};
+        int                  ret          = -1;
+        int                  op_errno = 0;
+
+        if (!req)
+                return ret;
+
+        args.volume = alloca (256);
+
+        ret = rpc_receive_common (req, &frame, &state, NULL, &args,
+                                  xdr_gfx_finodelk_req,
+                                  GF_FOP_FINODELK);
+        if (ret != 0) {
+                goto out;
+        }
+
+        state->resolve.type = RESOLVE_EXACT;
+        state->volume = gf_strdup (args.volume);
+        state->resolve.fd_no = args.fd;
+        state->cmd = args.cmd;
+        set_resolve_gfid (frame->root->client, state->resolve.gfid, args.gfid);
+
+        switch (state->cmd) {
+        case GF_LK_GETLK:
+                state->cmd = F_GETLK;
+                break;
+        case GF_LK_SETLK:
+                state->cmd = F_SETLK;
+                break;
+        case GF_LK_SETLKW:
+                state->cmd = F_SETLKW;
+                break;
+        }
+
+        state->type = args.type;
+
+        gf_proto_flock_to_flock (&args.flock, &state->flock);
+
+        switch (state->type) {
+        case GF_LK_F_RDLCK:
+                state->flock.l_type = F_RDLCK;
+                break;
+        case GF_LK_F_WRLCK:
+                state->flock.l_type = F_WRLCK;
+                break;
+        case GF_LK_F_UNLCK:
+                state->flock.l_type = F_UNLCK;
+                break;
+        }
+
+        xdr_to_dict (&args.xdata, &state->xdata);
+
+        ret = 0;
+        resolve_and_resume (frame, server4_finodelk_resume);
+out:
+
+
+        free (args.flock.lk_owner.lk_owner_val);
+
+        if (op_errno)
+                SERVER_REQ_SET_ERROR (req, ret);
+
+        return ret;
+}
+
+
+int
+server4_0_entrylk (rpcsvc_request_t *req)
+{
+        server_state_t      *state                 = NULL;
+        call_frame_t        *frame                 = NULL;
+        gfx_entrylk_req     args                  = {{0,},};
+        int                  ret                   = -1;
+        int                  op_errno = 0;
+
+        if (!req)
+                return ret;
+
+        args.volume = alloca (256);
+        args.name   = alloca (256);
+
+        ret = rpc_receive_common (req, &frame, &state, NULL, &args,
+                                  xdr_gfx_entrylk_req,
+                                  GF_FOP_ENTRYLK);
+        if (ret != 0) {
+                goto out;
+        }
+
+        state->resolve.type   = RESOLVE_EXACT;
+        set_resolve_gfid (frame->root->client, state->resolve.gfid, args.gfid);
+
+        if (args.namelen)
+                state->name   = gf_strdup (args.name);
+        state->volume         = gf_strdup (args.volume);
+
+        state->cmd            = args.cmd;
+        state->type           = args.type;
+
+        xdr_to_dict (&args.xdata, &state->xdata);
+
+        ret = 0;
+        resolve_and_resume (frame, server4_entrylk_resume);
+out:
+
+
+        if (op_errno)
+                SERVER_REQ_SET_ERROR (req, ret);
+
+        return ret;
+}
+
+int
+server4_0_fentrylk (rpcsvc_request_t *req)
+{
+        server_state_t      *state        = NULL;
+        call_frame_t        *frame        = NULL;
+        gfx_fentrylk_req    args         = {{0,},};
+        int                  ret          = -1;
+        int                  op_errno = 0;
+
+        if (!req)
+                return ret;
+
+        args.name   = alloca (256);
+        args.volume = alloca (256);
+
+        ret = rpc_receive_common (req, &frame, &state, NULL, &args,
+                                  xdr_gfx_fentrylk_req,
+                                  GF_FOP_FENTRYLK);
+        if (ret != 0) {
+                goto out;
+        }
+
+        state->resolve.type = RESOLVE_EXACT;
+        state->resolve.fd_no = args.fd;
+        state->cmd  = args.cmd;
+        state->type = args.type;
+        set_resolve_gfid (frame->root->client, state->resolve.gfid, args.gfid);
+
+        if (args.namelen)
+                state->name = gf_strdup (args.name);
+        state->volume = gf_strdup (args.volume);
+
+        xdr_to_dict (&args.xdata, &state->xdata);
+
+        ret = 0;
+        resolve_and_resume (frame, server4_fentrylk_resume);
+out:
+
+
+        if (op_errno)
+                SERVER_REQ_SET_ERROR (req, ret);
+
+        return ret;
+}
+
+int
+server4_0_access (rpcsvc_request_t *req)
+{
+        server_state_t      *state                 = NULL;
+        call_frame_t        *frame                 = NULL;
+        gfx_access_req      args                  = {{0,},};
+        int                  ret                   = -1;
+        int                  op_errno = 0;
+
+        if (!req)
+                return ret;
+
+        ret = rpc_receive_common (req, &frame, &state, NULL, &args,
+                                  xdr_gfx_access_req, GF_FOP_ACCESS);
+        if (ret != 0) {
+                goto out;
+        }
+
+        state->resolve.type  = RESOLVE_MUST;
+        set_resolve_gfid (frame->root->client, state->resolve.gfid, args.gfid);
+        state->mask          = args.mask;
+
+        xdr_to_dict (&args.xdata, &state->xdata);
+
+        ret = 0;
+        resolve_and_resume (frame, server4_access_resume);
+out:
+
+
+        if (op_errno)
+                SERVER_REQ_SET_ERROR (req, ret);
+
+        return ret;
+}
+
+
+
+int
+server4_0_symlink (rpcsvc_request_t *req)
+{
+        server_state_t      *state                 = NULL;
+        call_frame_t        *frame                 = NULL;
+        gfx_symlink_req     args                  = {{0,},};
+        int                  ret                   = -1;
+        int                  op_errno = 0;
+
+        if (!req)
+                return ret;
+
+        args.bname    = alloca (req->msg[0].iov_len);
+        args.linkname = alloca (4096);
+
+        ret = rpc_receive_common (req, &frame, &state, NULL, &args,
+                                  xdr_gfx_symlink_req, GF_FOP_SYMLINK);
+        if (ret != 0) {
+                goto out;
+        }
+
+        state->resolve.type   = RESOLVE_NOT;
+        set_resolve_gfid (frame->root->client, state->resolve.pargfid,
+                          args.pargfid);
+        state->resolve.bname  = gf_strdup (args.bname);
+        state->name           = gf_strdup (args.linkname);
+        state->umask          = args.umask;
+
+        xdr_to_dict (&args.xdata, &state->xdata);
+
+        ret = 0;
+        resolve_and_resume (frame, server4_symlink_resume);
+
+out:
+        if (op_errno)
+                SERVER_REQ_SET_ERROR (req, ret);
+
+        return ret;
+}
+
+
+int
+server4_0_link (rpcsvc_request_t *req)
+{
+        server_state_t      *state                     = NULL;
+        call_frame_t        *frame                     = NULL;
+        gfx_link_req        args                      = {{0,},};
+        int                  ret                       = -1;
+        int                  op_errno = 0;
+
+        if (!req)
+                return ret;
+
+        args.newbname = alloca (req->msg[0].iov_len);
+
+        ret = rpc_receive_common (req, &frame, &state, NULL, &args,
+                                  xdr_gfx_link_req, GF_FOP_LINK);
+        if (ret != 0) {
+                goto out;
+        }
+
+        state->resolve.type    = RESOLVE_MUST;
+        memcpy (state->resolve.gfid, args.oldgfid, 16);
+
+        state->resolve2.type   = RESOLVE_NOT;
+        state->resolve2.bname  = gf_strdup (args.newbname);
+        set_resolve_gfid (frame->root->client, state->resolve2.pargfid,
+                          args.newgfid);
+
+        xdr_to_dict (&args.xdata, &state->xdata);
+
+        ret = 0;
+        resolve_and_resume (frame, server4_link_resume);
+out:
+
+
+        if (op_errno)
+                SERVER_REQ_SET_ERROR (req, ret);
+
+        return ret;
+}
+
+
+int
+server4_0_rename (rpcsvc_request_t *req)
+{
+        server_state_t      *state                     = NULL;
+        call_frame_t        *frame                     = NULL;
+        gfx_rename_req      args                      = {{0,},};
+        int                  ret                       = -1;
+        int                  op_errno = 0;
+
+        if (!req)
+                return ret;
+
+        args.oldbname = alloca (req->msg[0].iov_len);
+        args.newbname = alloca (req->msg[0].iov_len);
+
+        ret = rpc_receive_common (req, &frame, &state, NULL, &args,
+                                  xdr_gfx_rename_req, GF_FOP_RENAME);
+        if (ret != 0) {
+                goto out;
+        }
+
+        state->resolve.type   = RESOLVE_MUST;
+        state->resolve.bname  = gf_strdup (args.oldbname);
+        set_resolve_gfid (frame->root->client, state->resolve.pargfid,
+                          args.oldgfid);
+
+        state->resolve2.type  = RESOLVE_MAY;
+        state->resolve2.bname = gf_strdup (args.newbname);
+        set_resolve_gfid (frame->root->client, state->resolve2.pargfid,
+                          args.newgfid);
+
+        xdr_to_dict (&args.xdata, &state->xdata);
+
+        ret = 0;
+        resolve_and_resume (frame, server4_rename_resume);
+out:
+
+
+        if (op_errno)
+                SERVER_REQ_SET_ERROR (req, ret);
+
+        return ret;
+}
+
+int
+server4_0_lease (rpcsvc_request_t *req)
+{
+        server_state_t      *state = NULL;
+        call_frame_t        *frame = NULL;
+        gfx_lease_req       args  = {{0,},};
+        int                  ret   = -1;
+        int                  op_errno = 0;
+
+        if (!req)
+                return ret;
+
+        ret = rpc_receive_common (req, &frame, &state, NULL, &args,
+                                  xdr_gfx_lease_req, GF_FOP_LEASE);
+        if (ret != 0) {
+                goto out;
+        }
+
+        state->resolve.type = RESOLVE_MUST;
+        set_resolve_gfid (frame->root->client, state->resolve.gfid, args.gfid);
+        gf_proto_lease_to_lease (&args.lease, &state->lease);
+
+        xdr_to_dict (&args.xdata, &state->xdata);
+
+        ret = 0;
+        resolve_and_resume (frame, server4_lease_resume);
+out:
+
+
+        if (op_errno)
+                SERVER_REQ_SET_ERROR (req, ret);
+
+        return ret;
+}
+
+int
+server4_0_lk (rpcsvc_request_t *req)
+{
+        server_state_t      *state = NULL;
+        call_frame_t        *frame = NULL;
+        gfx_lk_req          args  = {{0,},};
+        int                  ret   = -1;
+        int                  op_errno = 0;
+
+        if (!req)
+                return ret;
+
+        ret = rpc_receive_common (req, &frame, &state, NULL, &args,
+                                  xdr_gfx_lk_req, GF_FOP_LK);
+        if (ret != 0) {
+                goto out;
+        }
+
+        state->resolve.fd_no = args.fd;
+        state->cmd =  args.cmd;
+        state->type = args.type;
+        set_resolve_gfid (frame->root->client, state->resolve.gfid, args.gfid);
+
+        switch (state->cmd) {
+        case GF_LK_GETLK:
+                state->cmd = F_GETLK;
+                break;
+        case GF_LK_SETLK:
+                state->cmd = F_SETLK;
+                break;
+        case GF_LK_SETLKW:
+                state->cmd = F_SETLKW;
+                break;
+        case GF_LK_RESLK_LCK:
+                state->cmd = F_RESLK_LCK;
+                break;
+        case GF_LK_RESLK_LCKW:
+                state->cmd = F_RESLK_LCKW;
+                break;
+        case GF_LK_RESLK_UNLCK:
+                state->cmd = F_RESLK_UNLCK;
+                break;
+        case GF_LK_GETLK_FD:
+                state->cmd = F_GETLK_FD;
+                break;
+
+        }
+
+
+        gf_proto_flock_to_flock (&args.flock, &state->flock);
+
+        switch (state->type) {
+        case GF_LK_F_RDLCK:
+                state->flock.l_type = F_RDLCK;
+                break;
+        case GF_LK_F_WRLCK:
+                state->flock.l_type = F_WRLCK;
+                break;
+        case GF_LK_F_UNLCK:
+                state->flock.l_type = F_UNLCK;
+                break;
+        default:
+                gf_msg (frame->root->client->bound_xl->name, GF_LOG_ERROR,
+                        0, PS_MSG_LOCK_ERROR, "fd - %"PRId64" (%s): Unknown "
+                        "lock type: %"PRId32"!", state->resolve.fd_no,
+                        uuid_utoa (state->fd->inode->gfid), state->type);
+                break;
+        }
+
+
+        xdr_to_dict (&args.xdata, &state->xdata);
+
+        ret = 0;
+        resolve_and_resume (frame, server4_lk_resume);
+out:
+
+
+        free (args.flock.lk_owner.lk_owner_val);
+
+        if (op_errno)
+                SERVER_REQ_SET_ERROR (req, ret);
+
+        return ret;
+}
+
+
+int
+server4_0_null (rpcsvc_request_t *req)
+{
+        gfx_common_rsp rsp = {0,};
+
+        /* Accepted */
+        rsp.op_ret = 0;
+
+        server_submit_reply (NULL, req, &rsp, NULL, 0, NULL,
+                             (xdrproc_t)xdr_gfx_common_rsp);
+
+        return 0;
+}
+
+int
+server4_0_lookup (rpcsvc_request_t *req)
+{
+        call_frame_t        *frame    = NULL;
+        server_state_t      *state    = NULL;
+        gfx_lookup_req      args     = {{0,},};
+        int                  ret      = -1;
+
+        GF_VALIDATE_OR_GOTO ("server", req, err);
+
+        args.bname = alloca (req->msg[0].iov_len);
+
+        ret = rpc_receive_common (req, &frame, &state, NULL, &args,
+                                  xdr_gfx_lookup_req, GF_FOP_LOOKUP);
+        if (ret != 0) {
+                goto err;
+        }
+
+        state->resolve.type   = RESOLVE_DONTCARE;
+
+        if (args.bname && strcmp (args.bname, "")) {
+                set_resolve_gfid (frame->root->client, state->resolve.pargfid,
+                                  args.pargfid);
+                state->resolve.bname = gf_strdup (args.bname);
+        } else {
+                set_resolve_gfid (frame->root->client,
+                                  state->resolve.gfid, args.gfid);
+        }
+
+        xdr_to_dict (&args.xdata, &state->xdata);
+
+        ret = 0;
+        resolve_and_resume (frame, server4_lookup_resume);
+
+err:
+        return ret;
+}
+
+int
+server4_0_statfs (rpcsvc_request_t *req)
+{
+        server_state_t      *state = NULL;
+        call_frame_t        *frame = NULL;
+        gfx_statfs_req      args  = {{0,},};
+        int                  ret   = -1;
+        int                  op_errno = 0;
+
+        if (!req)
+                return ret;
+
+        ret = rpc_receive_common (req, &frame, &state, NULL, &args,
+                                  xdr_gfx_statfs_req, GF_FOP_STATFS);
+        if (ret != 0) {
+                goto out;
+        }
+
+        state->resolve.type   = RESOLVE_MUST;
+        set_resolve_gfid (frame->root->client, state->resolve.gfid, args.gfid);
+
+        xdr_to_dict (&args.xdata, &state->xdata);
+
+        ret = 0;
+        resolve_and_resume (frame, server4_statfs_resume);
+out:
+
+
+        if (op_errno)
+                SERVER_REQ_SET_ERROR (req, ret);
+
+        return ret;
+}
+
+int
+server4_0_getactivelk (rpcsvc_request_t *req)
+{
+        server_state_t          *state          = NULL;
+        call_frame_t            *frame          = NULL;
+        gfx_getactivelk_req    args            = {{0,},};
+        int                     ret             = -1;
+        int                     op_errno        = 0;
+
+        if (!req)
+                return ret;
+
+        ret = rpc_receive_common (req, &frame, &state, NULL, &args,
+                                  xdr_gfx_getactivelk_req,
+                                  GF_FOP_GETACTIVELK);
+        if (ret != 0) {
+                goto out;
+        }
+
+        state->resolve.type = RESOLVE_MUST;
+        set_resolve_gfid (frame->root->client, state->resolve.gfid, args.gfid);
+
+        /* here, dict itself works as xdata */
+        xdr_to_dict (&args.xdata, &state->xdata);
+
+
+        ret = 0;
+        resolve_and_resume (frame, server4_getactivelk_resume);
+out:
+
+
+        if (op_errno)
+                SERVER_REQ_SET_ERROR (req, ret);
+
+        return ret;
+}
+
+
+int
+server4_0_setactivelk (rpcsvc_request_t *req)
+{
+        server_state_t          *state          = NULL;
+        call_frame_t            *frame          = NULL;
+        gfx_setactivelk_req   args            = {{0,},};
+        int                     ret             = -1;
+        int                     op_errno        = 0;
+
+        if (!req)
+                return ret;
+
+        ret = rpc_receive_common (req, &frame, &state, NULL, &args,
+                                  xdr_gfx_setactivelk_req,
+                                  GF_FOP_SETACTIVELK);
+        if (ret != 0) {
+                goto out;
+        }
+
+        state->resolve.type = RESOLVE_MUST;
+        set_resolve_gfid (frame->root->client, state->resolve.gfid, args.gfid);
+
+        /* here, dict itself works as xdata */
+        xdr_to_dict (&args.xdata, &state->xdata);
+
+        ret = unserialize_req_locklist_v2 (&args, &state->locklist);
+        if (ret)
+                goto out;
+
+        ret = 0;
+
+        resolve_and_resume (frame, server4_setactivelk_resume);
+out:
+        if (op_errno)
+                SERVER_REQ_SET_ERROR (req, ret);
+
+        return ret;
+}
+
+int
+server4_namelink (rpcsvc_request_t *req)
+{
+        server_state_t    *state    = NULL;
+        call_frame_t      *frame    = NULL;
+        gfx_namelink_req  args     = {{0,},};
+        int                ret      = -1;
+        int                op_errno = 0;
+
+        if (!req)
+                return ret;
+
+        ret = rpc_receive_common (req, &frame, &state, NULL, &args,
+                                  xdr_gfx_namelink_req, GF_FOP_NAMELINK);
+
+        if (ret != 0)
+                goto out;
+
+        state->resolve.bname = gf_strdup (args.bname);
+        memcpy (state->resolve.pargfid, args.pargfid, sizeof (uuid_t));
+
+        state->resolve.type = RESOLVE_NOT;
+
+        xdr_to_dict (&args.xdata, &state->xdata);
+        ret = 0;
+        resolve_and_resume (frame, server4_namelink_resume);
+
+out:
+        if (op_errno)
+                SERVER_REQ_SET_ERROR (req, ret);
+
+        return ret;
+
+}
+
+int
+server4_icreate (rpcsvc_request_t *req)
+{
+        server_state_t   *state    = NULL;
+        call_frame_t     *frame    = NULL;
+        gfx_icreate_req  args     = {{0,},};
+        int               ret      = -1;
+        int               op_errno = 0;
+        uuid_t            gfid     = {0,};
+
+        if (!req)
+                return ret;
+
+        ret = rpc_receive_common (req, &frame, &state, NULL, &args,
+                                  xdr_gfx_icreate_req, GF_FOP_ICREATE);
+
+        if (ret != 0)
+                goto out;
+
+        memcpy (gfid, args.gfid, sizeof (uuid_t));
+
+        state->mode  = args.mode;
+        gf_asprintf (&state->resolve.bname, INODE_PATH_FMT, uuid_utoa (gfid));
+
+        /* parent is an auxillary inode number */
+        memset (state->resolve.pargfid, 0, sizeof (uuid_t));
+        state->resolve.pargfid[15] = GF_AUXILLARY_PARGFID;
+
+        state->resolve.type = RESOLVE_NOT;
+
+        xdr_to_dict (&args.xdata, &state->xdata);
+        ret = 0;
+        resolve_and_resume (frame, server4_icreate_resume);
+
+out:
+        if (op_errno)
+                SERVER_REQ_SET_ERROR (req, ret);
+
+        return ret;
+}
+
+int
+server4_0_fsetattr (rpcsvc_request_t *req)
+{
+        server_state_t       *state    = NULL;
+        call_frame_t         *frame    = NULL;
+        gfx_fsetattr_req      args     = {{0},};
+        int                   ret      = -1;
+        int                   op_errno = 0;
+
+        if (!req)
+                return ret;
+
+        ret = rpc_receive_common (req, &frame, &state, NULL, &args,
+                                  xdr_gfx_fsetattr_req,
+                                  GF_FOP_FSETATTR);
+        if (ret != 0) {
+                goto out;
+        }
+
+        state->resolve.type   = RESOLVE_MUST;
+        state->resolve.fd_no  = args.fd;
+        memcpy (state->resolve.gfid, args.gfid, 16);
+
+        gfx_stat_to_iattx (&args.stbuf, &state->stbuf);
+        state->valid = args.valid;
+
+        xdr_to_dict (&args.xdata, &state->xdata);
+        ret = 0;
+        resolve_and_resume (frame, server4_fsetattr_resume);
+
+out:
+        if (op_errno)
+                SERVER_REQ_SET_ERROR (req, ret);
+
+        return ret;
+}
+
+int
+server4_0_rchecksum (rpcsvc_request_t *req)
+{
+        server_state_t        *state    = NULL;
+        call_frame_t          *frame    = NULL;
+        gfx_rchecksum_req      args     = {{0},};
+        int                    ret      = -1;
+        int                    op_errno = 0;
+
+        if (!req)
+                return ret;
+
+        ret = rpc_receive_common (req, &frame, &state, NULL, &args,
+                                  xdr_gfx_rchecksum_req,
+                                  GF_FOP_RCHECKSUM);
+        if (ret != 0) {
+                goto out;
+        }
+
+        state->resolve.type  = RESOLVE_MAY;
+        state->resolve.fd_no = args.fd;
+        state->offset        = args.offset;
+        state->size          = args.len;
+
+        memcpy (state->resolve.gfid, args.gfid, 16);
+
+        xdr_to_dict (&args.xdata, &state->xdata);
+        ret = 0;
+        resolve_and_resume (frame, server4_rchecksum_resume);
+out:
+        if (op_errno)
+                SERVER_REQ_SET_ERROR (req, ret);
+
+        return ret;
+}
+
+int
+server4_compound_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
+                     int32_t op_ret, int32_t op_errno, void *data,
+                     dict_t *xdata)
+{
+        struct gfx_compound_rsp   rsp    = {0,};
+        server_state_t             *state  = NULL;
+        rpcsvc_request_t           *req    = NULL;
+        compound_args_cbk_t        *args_cbk = data;
+        int                        i       = 0;
+
+        req = frame->local;
+        state  = CALL_STATE (frame);
+
+        dict_to_xdr (xdata, &rsp.xdata);
+
+        if (op_ret) {
+                gf_msg (this->name, fop_log_level (GF_FOP_COMPOUND, op_errno),
+                        op_errno, PS_MSG_COMPOUND_INFO,
+                        "%"PRId64": COMPOUND%"PRId64" (%s), client: %s, "
+                        "error-xlator: %s", frame->root->unique,
+                        state->resolve.fd_no, uuid_utoa (state->resolve.gfid),
+                        STACK_CLIENT_NAME (frame->root),
+                        STACK_ERR_XL_NAME (frame->root));
+        }
+
+        rsp.compound_rsp_array.compound_rsp_array_val = GF_CALLOC
+                                                        (args_cbk->fop_length,
+                                                         sizeof (compound_rsp_v2),
+                                                  gf_server_mt_compound_rsp_t);
+
+        if (!rsp.compound_rsp_array.compound_rsp_array_val) {
+                op_ret = -1;
+                op_errno = ENOMEM;
+                goto out;
+        }
+        rsp.compound_rsp_array.compound_rsp_array_len = args_cbk->fop_length;
+
+        for (i = 0; i < args_cbk->fop_length; i++) {
+                op_ret = server_populate_compound_response_v2 (this, &rsp,
+                                                               frame,
+                                                               args_cbk, i);
+
+                if (op_ret) {
+                        op_errno = op_ret;
+                        op_ret = -1;
+                        goto out;
+                }
+        }
+out:
+        rsp.op_ret    = op_ret;
+        rsp.op_errno  = gf_errno_to_error (op_errno);
+
+        server_submit_reply (frame, req, &rsp, NULL, 0, NULL,
+                             (xdrproc_t) xdr_gfx_compound_rsp);
+
+        server_compound_rsp_cleanup_v2 (&rsp, args_cbk);
+        GF_FREE (rsp.xdata.pairs.pairs_val);
+
+        return 0;
+}
+
+int
+server4_compound_resume (call_frame_t *frame, xlator_t *bound_xl)
+{
+        server_state_t          *state  = NULL;
+        gfx_compound_req        *req    = NULL;
+        compound_args_t         *args   = NULL;
+        int                     i       = 0;
+        int                     ret     = -1;
+        int                     length  = 0;
+        int                     op_errno = ENOMEM;
+        compound_req_v2        *c_req  = NULL;
+
+        state = CALL_STATE (frame);
+
+        if (state->resolve.op_ret != 0) {
+                ret = state->resolve.op_ret;
+                op_errno = state->resolve.op_errno;
+                goto err;
+        }
+
+        req = &state->req_v2;
+
+        length = req->compound_req_array.compound_req_array_len;
+        state->args = compound_fop_alloc (length, req->compound_fop_enum,
+                                          state->xdata);
+        args = state->args;
+
+        if (!args)
+                goto err;
+
+        for (i = 0; i < length; i++) {
+                c_req = &req->compound_req_array.compound_req_array_val[i];
+                args->enum_list[i] = c_req->fop_enum;
+
+                ret = server_populate_compound_request_v2 (req, frame,
+                                                           &args->req_list[i],
+                                                           i);
+
+                if (ret) {
+                        op_errno = ret;
+                        ret = -1;
+                        goto err;
+                }
+        }
+
+        STACK_WIND (frame, server4_compound_cbk,
+                    bound_xl, bound_xl->fops->compound,
+                    args, state->xdata);
+
+        return 0;
+err:
+        server4_compound_cbk (frame, NULL, frame->this, ret, op_errno,
+                             NULL, NULL);
+
+        return ret;
+}
+int
+server4_0_compound (rpcsvc_request_t *req)
+{
+        server_state_t      *state    = NULL;
+        call_frame_t        *frame    = NULL;
+        gfx_compound_req     args     = {0,};
+        ssize_t              len      = 0;
+        int                  length   = 0;
+        int                  i        = 0;
+        int                  ret      = -1;
+        int                  op_errno = 0;
+
+        if (!req)
+                return ret;
+
+        ret = rpc_receive_common (req, &frame, &state, &len, &args,
+                                  xdr_gfx_compound_req,
+                                  GF_FOP_COMPOUND);
+        if (ret != 0) {
+                goto out;
+        }
+
+        state->req_v2        = args;
+        state->iobref        = iobref_ref (req->iobref);
+
+        if (len < req->msg[0].iov_len) {
+                state->payload_vector[0].iov_base
+                        = (req->msg[0].iov_base + len);
+                state->payload_vector[0].iov_len
+                        = req->msg[0].iov_len - len;
+                state->payload_count = 1;
+        }
+
+        for (i = 1; i < req->count; i++) {
+                state->payload_vector[state->payload_count++]
+                        = req->msg[i];
+        }
+
+        state->size = iov_length (state->payload_vector, state->payload_count);
+
+        ret = server_get_compound_resolve_v2 (state, &args);
+
+        if (ret) {
+                SERVER_REQ_SET_ERROR (req, ret);
+                goto out;
+        }
+
+        xdr_to_dict (&args.xdata, &state->xdata);
+
+        ret = 0;
+        resolve_and_resume (frame, server4_compound_resume);
+out:
+
+        length = args.compound_req_array.compound_req_array_len;
+        server_compound_req_cleanup_v2 (&args, length);
+        free (args.compound_req_array.compound_req_array_val);
+
+        if (op_errno)
+                SERVER_REQ_SET_ERROR (req, ret);
+
+        return ret;
+}
diff --git a/xlators/protocol/server/src/server.h b/xlators/protocol/server/src/server.h
index 70af9fdecd3..fe407689ceb 100644
--- a/xlators/protocol/server/src/server.h
+++ b/xlators/protocol/server/src/server.h
@@ -58,6 +58,28 @@
                 free (_req->xdata.xdata_val);                                 \
         } while (0)
 
+#define CPD4_REQ_FIELD(v, f)  ((v)->compound_req_v2_u.compound_##f##_req)
+#define CPD4_RSP_FIELD(v, f)  ((v)->compound_rsp_v2_u.compound_##f##_rsp)
+
+#define SERVER4_COMMON_RSP_CLEANUP(rsp, fop, i)                         \
+        do {                                                            \
+                compound_rsp_v2  *this_rsp = NULL;                      \
+                this_rsp = &rsp->compound_rsp_array.compound_rsp_array_val[i]; \
+                gfx_common_rsp  *_this_rsp = &CPD4_RSP_FIELD(this_rsp, fop); \
+                                                                        \
+                GF_FREE (_this_rsp->xdata.pairs.pairs_val);             \
+        } while (0)
+
+#define SERVER4_FOP_RSP_CLEANUP(rsp, fop, i, rsp_type)                  \
+        do {                                                            \
+                compound_rsp_v2        *this_rsp = NULL;                \
+                this_rsp = &rsp->compound_rsp_array.compound_rsp_array_val[i]; \
+                gfx_##rsp_type##_rsp  *_this_rsp = &CPD4_RSP_FIELD(this_rsp, fop); \
+                                                                        \
+                GF_FREE (_this_rsp->xdata.pairs.pairs_val);             \
+        } while (0)
+
+
 typedef enum {
         INTERNAL_LOCKS = 1,
         POSIX_LOCKS = 2,
@@ -196,6 +218,11 @@ struct _server_state {
         lock_migration_info_t locklist;
         /* required for compound fops */
         gfs3_compound_req  req;
+        /* TODO: having xdr definition here
+           is not a good idea, but not taking
+           up the functionality right now */
+        gfx_compound_req  req_v2;
+
         /* last length till which iovec for compound
          * writes was processed */
         int               write_length;
@@ -233,16 +260,6 @@ int gf_server_check_getxattr_cmd (call_frame_t *frame, const char *name);
 void
 forget_inode_if_no_dentry (inode_t *inode);
 
-int
-unserialize_req_locklist (gfs3_setactivelk_req *req,
-                          lock_migration_info_t *lmi);
-
-int
-serialize_rsp_dirent (gf_dirent_t *entries, gfs3_readdir_rsp *rsp);
-
-int
-serialize_rsp_direntp (gf_dirent_t *entries, gfs3_readdirp_rsp *rsp);
-
 server_ctx_t*
 server_ctx_get (client_t *client, xlator_t *xlator);
 #endif /* !_SERVER_H */