minor improvements in protocol

* rpc_clnt_submit() now takes 'cbkfn' as an argument.
* readdir xdr now uses dirent structure directly instead of
  using 'opaque' buffer through which it was serializing /
  unserializing the dirent structure.
* 'gfs_id' field (currently used for debugging) is properly updated

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

BUG: 875 (Implement a new protocol to provide proper backward/forward compatibility)
URL: http://bugs.gluster.com/cgi-bin/bugzilla3/show_bug.cgi?id=875

1 files changed, 2380 insertions, 2235 deletions

diff --git a/xlators/protocol/client/src/client3_1-fops.c b/xlators/protocol/client/src/client3_1-fops.c
index 01b78436c..891aa019e 100644
--- a/xlators/protocol/client/src/client3_1-fops.c
+++ b/xlators/protocol/client/src/client3_1-fops.c
@@ -28,12 +28,13 @@
 #include "msg-xdr.h"
 #include "compat-errno.h"
 
+int32_t client3_getspec (call_frame_t *frame, xlator_t *this, void *data);
 void client_start_ping (void *data);
 rpc_clnt_prog_t clnt3_1_fop_prog;
 
 int
-client_submit_vec_request (xlator_t      *this, void *req,
-                           call_frame_t  *frame, rpc_clnt_prog_t *prog, int procnum,
+client_submit_vec_request (xlator_t  *this, void *req, call_frame_t  *frame,
+                           rpc_clnt_prog_t *prog, int procnum, fop_cbk_fn_t cbk,
                            struct iovec  *payload, int payloadcnt,
                            struct iobref *iobref, gfs_serialize_t sfunc)
 {
@@ -78,7 +79,7 @@ client_submit_vec_request (xlator_t      *this, void *req,
                 count = 1;
         }
         /* Send the msg */
-        ret = rpc_clnt_submit (conf->rpc, prog, procnum, &iov, count,
+        ret = rpc_clnt_submit (conf->rpc, prog, procnum, cbk, &iov, count,
                                payload, payloadcnt, iobref, frame);
 
         if (ret == 0) {
@@ -104,6 +105,1985 @@ out:
         return 0;
 }
 
+/* CBK */
+
+int
+client3_1_symlink_cbk (struct rpc_req *req, struct iovec *iov, int count,
+                       void *myframe)
+{
+        call_frame_t     *frame      = NULL;
+        gfs3_symlink_rsp  rsp        = {0,};
+        struct iatt       stbuf      = {0,};
+        struct iatt       preparent  = {0,};
+        struct iatt       postparent = {0,};
+        int               ret        = 0;
+        clnt_local_t     *local      = NULL;
+        inode_t          *inode      = NULL;
+
+        frame = myframe;
+
+        local = frame->local;
+        frame->local = NULL;
+        inode = local->loc.inode;
+
+        if (-1 == req->rpc_status) {
+                rsp.op_ret   = -1;
+                rsp.op_errno = ENOTCONN;
+                goto out;
+        }
+        ret = xdr_to_symlink_rsp (*iov, &rsp);
+        if (ret < 0) {
+                gf_log ("", GF_LOG_ERROR, "error");
+                rsp.op_ret   = -1;
+                rsp.op_errno = EINVAL;
+                goto out;
+        }
+
+        if (-1 != rsp.op_ret) {
+                gf_stat_to_iatt (&rsp.stat, &stbuf);
+
+                ret = inode_ctx_put2 (inode, frame->this,
+                                      stbuf.ia_ino, stbuf.ia_gen);
+                if (ret < 0) {
+                        gf_log (frame->this->name, GF_LOG_DEBUG,
+                                "SYMLINK %"PRId64"/%s (%s): failed to set "
+                                "remote inode number to inode ctx",
+                                local->loc.parent->ino, local->loc.name,
+                                local->loc.path);
+                }
+
+                gf_stat_to_iatt (&rsp.preparent, &preparent);
+                gf_stat_to_iatt (&rsp.postparent, &postparent);
+        }
+
+out:
+        frame->local = NULL;
+        STACK_UNWIND_STRICT (symlink, frame, rsp.op_ret,
+                             gf_error_to_errno (rsp.op_errno), inode, &stbuf,
+                             &preparent, &postparent);
+
+        if (local)
+                client_local_wipe (local);
+
+        return 0;
+}
+
+
+int
+client3_1_mknod_cbk (struct rpc_req *req, struct iovec *iov, int count,
+                     void *myframe)
+{
+        call_frame_t     *frame      = NULL;
+        gfs3_mknod_rsp  rsp        = {0,};
+        struct iatt       stbuf      = {0,};
+        struct iatt       preparent  = {0,};
+        struct iatt       postparent = {0,};
+        int               ret        = 0;
+        clnt_local_t     *local      = NULL;
+        inode_t          *inode      = NULL;
+
+        frame = myframe;
+
+        local = frame->local;
+        frame->local = NULL;
+        inode = local->loc.inode;
+
+        if (-1 == req->rpc_status) {
+                rsp.op_ret   = -1;
+                rsp.op_errno = ENOTCONN;
+                goto out;
+        }
+        ret = xdr_to_mknod_rsp (*iov, &rsp);
+        if (ret < 0) {
+                gf_log ("", GF_LOG_ERROR, "error");
+                rsp.op_ret   = -1;
+                rsp.op_errno = EINVAL;
+                goto out;
+        }
+
+        if (-1 != rsp.op_ret) {
+                gf_stat_to_iatt (&rsp.stat, &stbuf);
+
+                ret = inode_ctx_put2 (inode, frame->this,
+                                      stbuf.ia_ino, stbuf.ia_gen);
+                if (ret < 0) {
+                        gf_log (frame->this->name, GF_LOG_DEBUG,
+                                "MKNOD %"PRId64"/%s (%s): failed to set "
+                                "remote inode number to inode ctx",
+                                local->loc.parent->ino, local->loc.name,
+                                local->loc.path);
+                }
+
+                gf_stat_to_iatt (&rsp.preparent, &preparent);
+                gf_stat_to_iatt (&rsp.postparent, &postparent);
+        }
+
+out:
+        frame->local = NULL;
+        STACK_UNWIND_STRICT (mknod, frame, rsp.op_ret,
+                             gf_error_to_errno (rsp.op_errno), inode,
+                             &stbuf, &preparent, &postparent);
+
+        if (local)
+                client_local_wipe (local);
+
+        return 0;
+}
+
+int
+client3_1_mkdir_cbk (struct rpc_req *req, struct iovec *iov, int count,
+                     void *myframe)
+{
+        call_frame_t     *frame      = NULL;
+        gfs3_mkdir_rsp  rsp        = {0,};
+        struct iatt       stbuf      = {0,};
+        struct iatt       preparent  = {0,};
+        struct iatt       postparent = {0,};
+        int               ret        = 0;
+        clnt_local_t     *local      = NULL;
+        inode_t          *inode      = NULL;
+
+        frame = myframe;
+
+        local = frame->local;
+        frame->local = NULL;
+        inode = local->loc.inode;
+
+        if (-1 == req->rpc_status) {
+                rsp.op_ret   = -1;
+                rsp.op_errno = ENOTCONN;
+                goto out;
+        }
+        ret = xdr_to_mkdir_rsp (*iov, &rsp);
+        if (ret < 0) {
+                gf_log ("", GF_LOG_ERROR, "error");
+                rsp.op_ret   = -1;
+                rsp.op_errno = EINVAL;
+                goto out;
+        }
+
+        if (-1 != rsp.op_ret) {
+                gf_stat_to_iatt (&rsp.stat, &stbuf);
+
+                ret = inode_ctx_put2 (inode, frame->this,
+                                      stbuf.ia_ino, stbuf.ia_gen);
+                if (ret < 0) {
+                        gf_log (frame->this->name, GF_LOG_DEBUG,
+                                "MKDIR %"PRId64"/%s (%s): failed to set "
+                                "remote inode number to inode ctx",
+                                local->loc.parent->ino, local->loc.name,
+                                local->loc.path);
+                }
+
+                gf_stat_to_iatt (&rsp.preparent, &preparent);
+                gf_stat_to_iatt (&rsp.postparent, &postparent);
+        }
+
+out:
+        frame->local = NULL;
+        STACK_UNWIND_STRICT (mkdir, frame, rsp.op_ret,
+                             gf_error_to_errno (rsp.op_errno), inode,
+                             &stbuf, &preparent, &postparent);
+
+        if (local)
+                client_local_wipe (local);
+
+        return 0;
+}
+
+int
+client3_1_open_cbk (struct rpc_req *req, struct iovec *iov, int count,
+                    void *myframe)
+{
+        clnt_local_t  *local = NULL;
+        clnt_conf_t   *conf  = NULL;
+        clnt_fd_ctx_t *fdctx = NULL;
+        call_frame_t  *frame = NULL;
+        fd_t          *fd    = NULL;
+        ino_t          ino   = 0;
+        uint64_t       gen   = 0;
+        int            ret   = 0;
+        gfs3_open_rsp  rsp   = {0,};
+
+        frame = myframe;
+        local = frame->local;
+
+        if (local->op) {
+                local->op (req, iov, 1, myframe);
+                return 0;
+        }
+
+        frame->local = NULL;
+        conf  = frame->this->private;
+        fd    = local->fd;
+
+        if (-1 == req->rpc_status) {
+                rsp.op_ret   = -1;
+                rsp.op_errno = ENOTCONN;
+                goto out;
+        }
+        ret = xdr_to_open_rsp (*iov, &rsp);
+        if (ret < 0) {
+                gf_log ("", GF_LOG_ERROR, "error");
+                rsp.op_ret   = -1;
+                rsp.op_errno = EINVAL;
+                goto out;
+        }
+
+        if (-1 != rsp.op_ret) {
+                fdctx = GF_CALLOC (1, sizeof (*fdctx),
+                                   gf_client_mt_clnt_fdctx_t);
+                if (!fdctx) {
+                        rsp.op_ret = -1;
+                        rsp.op_errno = ENOMEM;
+                        goto out;
+                }
+
+                inode_ctx_get2 (fd->inode, frame->this, &ino, &gen);
+
+                fdctx->remote_fd = rsp.fd;
+                fdctx->inode     = inode_ref (fd->inode);
+                fdctx->ino       = ino;
+                fdctx->gen       = gen;
+                fdctx->flags     = local->flags;
+                fdctx->wbflags   = local->wbflags;
+
+                INIT_LIST_HEAD (&fdctx->sfd_pos);
+
+                this_fd_set_ctx (fd, frame->this, &local->loc, fdctx);
+
+                pthread_mutex_lock (&conf->lock);
+                {
+                        list_add_tail (&fdctx->sfd_pos, &conf->saved_fds);
+                }
+                pthread_mutex_unlock (&conf->lock);
+        }
+
+out:
+        frame->local = NULL;
+        STACK_UNWIND_STRICT (open, frame, rsp.op_ret,
+                             gf_error_to_errno (rsp.op_errno), fd);
+
+        client_local_wipe (local);
+
+        return 0;
+}
+
+
+int
+client3_1_stat_cbk (struct rpc_req *req, struct iovec *iov, int count,
+                    void *myframe)
+{
+        gfs3_stat_rsp rsp = {0,};
+        call_frame_t   *frame = NULL;
+        struct iatt  iatt = {0,};
+        int ret = 0;
+
+        frame = myframe;
+
+        if (-1 == req->rpc_status) {
+                rsp.op_ret   = -1;
+                rsp.op_errno = ENOTCONN;
+                goto out;
+        }
+        ret = xdr_to_stat_rsp (*iov, &rsp);
+        if (ret < 0) {
+                gf_log ("", GF_LOG_ERROR, "error");
+                rsp.op_ret   = -1;
+                rsp.op_errno = EINVAL;
+                goto out;
+        }
+
+        if (-1 != rsp.op_ret) {
+                gf_stat_to_iatt (&rsp.stat, &iatt);
+        }
+
+out:
+        STACK_UNWIND_STRICT (stat, frame, rsp.op_ret,
+                             gf_error_to_errno (rsp.op_errno), &iatt);
+
+        return 0;
+}
+
+int
+client3_1_readlink_cbk (struct rpc_req *req, struct iovec *iov, int count,
+                        void *myframe)
+{
+        gfs3_readlink_rsp rsp = {0,};
+        call_frame_t   *frame = NULL;
+        struct iatt  iatt = {0,};
+        int ret = 0;
+
+        frame = myframe;
+
+        if (-1 == req->rpc_status) {
+                rsp.op_ret   = -1;
+                rsp.op_errno = ENOTCONN;
+                goto out;
+        }
+        ret = xdr_to_readlink_rsp (*iov, &rsp);
+        if (ret < 0) {
+                gf_log ("", GF_LOG_ERROR, "error");
+                rsp.op_ret   = -1;
+                rsp.op_errno = EINVAL;
+                goto out;
+        }
+
+        if (-1 != rsp.op_ret) {
+                gf_stat_to_iatt (&rsp.buf, &iatt);
+        }
+
+out:
+        STACK_UNWIND_STRICT (readlink, frame, rsp.op_ret,
+                             gf_error_to_errno (rsp.op_errno), rsp.path, &iatt);
+
+        /* This is allocated by the libc while decoding RPC msg */
+        /* Hence no 'GF_FREE', but just 'free' */
+        if (rsp.path)
+                free (rsp.path);
+
+        return 0;
+}
+
+int
+client3_1_unlink_cbk (struct rpc_req *req, struct iovec *iov, int count,
+                      void *myframe)
+{
+        call_frame_t    *frame      = NULL;
+        gfs3_unlink_rsp  rsp        = {0,};
+        struct iatt      preparent  = {0,};
+        struct iatt      postparent = {0,};
+        int              ret        = 0;
+
+        frame = myframe;
+
+        if (-1 == req->rpc_status) {
+                rsp.op_ret   = -1;
+                rsp.op_errno = ENOTCONN;
+                goto out;
+        }
+        ret = xdr_to_unlink_rsp (*iov, &rsp);
+        if (ret < 0) {
+                gf_log ("", GF_LOG_ERROR, "error");
+                rsp.op_ret   = -1;
+                rsp.op_errno = EINVAL;
+                goto out;
+        }
+
+        if (-1 != rsp.op_ret) {
+                gf_stat_to_iatt (&rsp.preparent, &preparent);
+                gf_stat_to_iatt (&rsp.postparent, &postparent);
+        }
+
+out:
+        STACK_UNWIND_STRICT (unlink, frame, rsp.op_ret,
+                             gf_error_to_errno (rsp.op_errno), &preparent,
+                             &postparent);
+
+        return 0;
+}
+
+int
+client3_1_rmdir_cbk (struct rpc_req *req, struct iovec *iov, int count,
+                     void *myframe)
+{
+        gfs3_rmdir_rsp rsp = {0,};
+        call_frame_t   *frame = NULL;
+        struct iatt  preparent  = {0,};
+        struct iatt  postparent = {0,};
+        int ret = 0;
+
+        frame = myframe;
+
+        if (-1 == req->rpc_status) {
+                rsp.op_ret   = -1;
+                rsp.op_errno = ENOTCONN;
+                goto out;
+        }
+        ret = xdr_to_rmdir_rsp (*iov, &rsp);
+        if (ret < 0) {
+                gf_log ("", GF_LOG_ERROR, "error");
+                rsp.op_ret   = -1;
+                rsp.op_errno = EINVAL;
+                goto out;
+        }
+
+        if (-1 != rsp.op_ret) {
+                gf_stat_to_iatt (&rsp.preparent, &preparent);
+                gf_stat_to_iatt (&rsp.postparent, &postparent);
+        }
+
+out:
+        STACK_UNWIND_STRICT (rmdir, frame, rsp.op_ret,
+                             gf_error_to_errno (rsp.op_errno), &preparent,
+                             &postparent);
+
+        return 0;
+}
+
+
+int
+client3_1_truncate_cbk (struct rpc_req *req, struct iovec *iov, int count,
+                        void *myframe)
+{
+        gfs3_truncate_rsp rsp = {0,};
+        call_frame_t   *frame = NULL;
+        struct iatt  prestat  = {0,};
+        struct iatt  poststat = {0,};
+        int ret = 0;
+
+        frame = myframe;
+
+        if (-1 == req->rpc_status) {
+                rsp.op_ret   = -1;
+                rsp.op_errno = ENOTCONN;
+                goto out;
+        }
+        ret = xdr_to_truncate_rsp (*iov, &rsp);
+        if (ret < 0) {
+                gf_log ("", GF_LOG_ERROR, "error");
+                rsp.op_ret   = -1;
+                rsp.op_errno = EINVAL;
+                goto out;
+        }
+
+        if (-1 != rsp.op_ret) {
+                gf_stat_to_iatt (&rsp.prestat, &prestat);
+                gf_stat_to_iatt (&rsp.poststat, &poststat);
+        }
+
+out:
+        STACK_UNWIND_STRICT (truncate, frame, rsp.op_ret,
+                             gf_error_to_errno (rsp.op_errno), &prestat,
+                             &poststat);
+
+        return 0;
+}
+
+
+int
+client3_1_statfs_cbk (struct rpc_req *req, struct iovec *iov, int count,
+                      void *myframe)
+{
+        gfs3_statfs_rsp rsp = {0,};
+        call_frame_t   *frame = NULL;
+        struct statvfs  statfs = {0,};
+        int ret = 0;
+
+        frame = myframe;
+
+        if (-1 == req->rpc_status) {
+                rsp.op_ret   = -1;
+                rsp.op_errno = ENOTCONN;
+                goto out;
+        }
+        ret = xdr_to_statfs_rsp (*iov, &rsp);
+        if (ret < 0) {
+                gf_log ("", GF_LOG_ERROR, "error");
+                rsp.op_ret   = -1;
+                rsp.op_errno = EINVAL;
+                goto out;
+        }
+
+        if (-1 != rsp.op_ret) {
+                gf_statfs_to_statfs (&rsp.statfs, &statfs);
+        }
+
+out:
+        STACK_UNWIND_STRICT (statfs, frame, rsp.op_ret,
+                             gf_error_to_errno (rsp.op_errno), &statfs);
+
+        return 0;
+}
+
+
+int
+client3_1_writev_cbk (struct rpc_req *req, struct iovec *iov, int count,
+                      void *myframe)
+{
+        gfs3_write_rsp rsp = {0,};
+        call_frame_t   *frame = NULL;
+        struct iatt  prestat  = {0,};
+        struct iatt  poststat = {0,};
+        int ret = 0;
+
+        frame = myframe;
+
+        if (-1 == req->rpc_status) {
+                rsp.op_ret   = -1;
+                rsp.op_errno = ENOTCONN;
+                goto out;
+        }
+
+        ret = xdr_to_truncate_rsp (*iov, &rsp);
+        if (ret < 0) {
+                gf_log ("", GF_LOG_ERROR, "error");
+                rsp.op_ret   = -1;
+                rsp.op_errno = EINVAL;
+                goto out;
+        }
+
+        if (-1 != rsp.op_ret) {
+                gf_stat_to_iatt (&rsp.prestat, &prestat);
+                gf_stat_to_iatt (&rsp.poststat, &poststat);
+        }
+
+out:
+        STACK_UNWIND_STRICT (writev, frame, rsp.op_ret,
+                             gf_error_to_errno (rsp.op_errno), &prestat,
+                             &poststat);
+
+        return 0;
+}
+
+int
+client3_1_flush_cbk (struct rpc_req *req, struct iovec *iov, int count,
+                     void *myframe)
+{
+        call_frame_t    *frame      = NULL;
+        gf_common_rsp    rsp        = {0,};
+        int              ret        = 0;
+
+        frame = myframe;
+
+        if (-1 == req->rpc_status) {
+                rsp.op_ret   = -1;
+                rsp.op_errno = ENOTCONN;
+                goto out;
+        }
+        ret = xdr_to_common_rsp (*iov, &rsp);
+        if (ret < 0) {
+                gf_log ("", GF_LOG_ERROR, "error");
+                rsp.op_ret   = -1;
+                rsp.op_errno = EINVAL;
+                goto out;
+        }
+
+out:
+        STACK_UNWIND_STRICT (flush, frame, rsp.op_ret,
+                             gf_error_to_errno (rsp.op_errno));
+
+        return 0;
+}
+
+int
+client3_1_fsync_cbk (struct rpc_req *req, struct iovec *iov, int count,
+                     void *myframe)
+{
+        gfs3_fsync_rsp rsp = {0,};
+        call_frame_t   *frame = NULL;
+        struct iatt  prestat  = {0,};
+        struct iatt  poststat = {0,};
+        int ret = 0;
+
+        frame = myframe;
+
+        if (-1 == req->rpc_status) {
+                rsp.op_ret   = -1;
+                rsp.op_errno = ENOTCONN;
+                goto out;
+        }
+
+        ret = xdr_to_truncate_rsp (*iov, &rsp);
+        if (ret < 0) {
+                gf_log ("", GF_LOG_ERROR, "error");
+                rsp.op_ret   = -1;
+                rsp.op_errno = EINVAL;
+                goto out;
+        }
+
+        if (-1 != rsp.op_ret) {
+                gf_stat_to_iatt (&rsp.prestat, &prestat);
+                gf_stat_to_iatt (&rsp.poststat, &poststat);
+        }
+
+out:
+        STACK_UNWIND_STRICT (fsync, frame, rsp.op_ret,
+                             gf_error_to_errno (rsp.op_errno), &prestat,
+                             &poststat);
+
+        return 0;
+}
+
+int
+client3_1_setxattr_cbk (struct rpc_req *req, struct iovec *iov, int count,
+                        void *myframe)
+{
+        call_frame_t    *frame      = NULL;
+        gf_common_rsp    rsp        = {0,};
+        int              ret        = 0;
+
+        frame = myframe;
+
+        if (-1 == req->rpc_status) {
+                rsp.op_ret   = -1;
+                rsp.op_errno = ENOTCONN;
+                goto out;
+        }
+
+        ret = xdr_to_common_rsp (*iov, &rsp);
+        if (ret < 0) {
+                gf_log ("", GF_LOG_ERROR, "error");
+                rsp.op_ret   = -1;
+                rsp.op_errno = EINVAL;
+                goto out;
+        }
+
+out:
+        STACK_UNWIND_STRICT (setxattr, frame, rsp.op_ret,
+                             gf_error_to_errno (rsp.op_errno));
+
+        return 0;
+}
+
+int
+client3_1_getxattr_cbk (struct rpc_req *req, struct iovec *iov, int count,
+                        void *myframe)
+{
+        call_frame_t      *frame    = NULL;
+        dict_t            *dict     = NULL;
+        char              *buf      = NULL;
+        int                dict_len = 0;
+        int                op_ret   = 0;
+        int                op_errno = 0;
+        gfs3_getxattr_rsp  rsp      = {0,};
+        int                ret      = 0;
+
+        frame = myframe;
+
+        if (-1 == req->rpc_status) {
+                op_ret   = -1;
+                op_errno = ENOTCONN;
+                goto out;
+        }
+
+        ret = xdr_to_getxattr_rsp (*iov, &rsp);
+        if (ret < 0) {
+                gf_log ("", GF_LOG_ERROR, "error");
+                op_ret   = -1;
+                op_errno = EINVAL;
+                goto out;
+        }
+
+        op_errno = gf_error_to_errno (rsp.op_errno);
+        op_ret = rsp.op_ret;
+        if (-1 != op_ret) {
+                op_ret = -1;
+                dict_len = rsp.dict.dict_len;
+
+                if (dict_len > 0) {
+                        dict = dict_new();
+                        buf = memdup (rsp.dict.dict_val, rsp.dict.dict_len);
+
+                        GF_VALIDATE_OR_GOTO (frame->this->name, dict, out);
+                        GF_VALIDATE_OR_GOTO (frame->this->name, buf, out);
+
+                        ret = dict_unserialize (buf, dict_len, &dict);
+                        if (ret < 0) {
+                                gf_log (frame->this->name, GF_LOG_DEBUG,
+                                        "failed to unserialize xattr dict");
+                                op_errno = EINVAL;
+                                goto out;
+                        }
+                        dict->extra_free = buf;
+                        buf = NULL;
+                }
+                op_ret = 0;
+        }
+
+out:
+        STACK_UNWIND_STRICT (getxattr, frame, op_ret, op_errno, dict);
+
+        if (rsp.dict.dict_val) {
+                /* don't use GF_FREE, this memory was allocated by libc
+                 */
+                free (rsp.dict.dict_val);
+                rsp.dict.dict_val = NULL;
+        }
+
+        if (buf)
+                GF_FREE (buf);
+
+        if (dict)
+                dict_unref (dict);
+
+        return 0;
+}
+
+int
+client3_1_fgetxattr_cbk (struct rpc_req *req, struct iovec *iov, int count,
+                         void *myframe)
+{
+        call_frame_t       *frame    = NULL;
+        char               *buf      = NULL;
+        dict_t             *dict     = NULL;
+        gfs3_fgetxattr_rsp  rsp      = {0,};
+        int                 ret      = 0;
+        int                 dict_len = 0;
+        int                 op_ret   = 0;
+        int                 op_errno = 0;
+
+        frame = myframe;
+
+        if (-1 == req->rpc_status) {
+                op_ret   = -1;
+                op_errno = ENOTCONN;
+                goto out;
+        }
+        ret = xdr_to_fgetxattr_rsp (*iov, &rsp);
+        if (ret < 0) {
+                gf_log ("", GF_LOG_ERROR, "error");
+                op_ret   = -1;
+                op_errno = EINVAL;
+                goto out;
+        }
+
+        op_errno = gf_error_to_errno (rsp.op_errno);
+        op_ret = rsp.op_ret;
+        if (-1 != op_ret) {
+                op_ret = -1;
+                dict_len = rsp.dict.dict_len;
+
+                if (dict_len > 0) {
+                        dict = dict_new();
+                        GF_VALIDATE_OR_GOTO (frame->this->name, dict, out);
+                        buf = memdup (rsp.dict.dict_val, rsp.dict.dict_len);
+                        GF_VALIDATE_OR_GOTO (frame->this->name, buf, out);
+
+                        ret = dict_unserialize (buf, dict_len, &dict);
+                        if (ret < 0) {
+                                gf_log (frame->this->name, GF_LOG_DEBUG,
+                                        "failed to unserialize xattr dict");
+                                op_errno = EINVAL;
+                                goto out;
+                        }
+                        dict->extra_free = buf;
+                        buf = NULL;
+                }
+                op_ret = 0;
+        }
+out:
+        STACK_UNWIND_STRICT (fgetxattr, frame, op_ret, op_errno, dict);
+        if (rsp.dict.dict_val) {
+                /* don't use GF_FREE, this memory was allocated by libc
+                 */
+                free (rsp.dict.dict_val);
+                rsp.dict.dict_val = NULL;
+        }
+
+        if (buf)
+                GF_FREE (buf);
+
+        if (dict)
+                dict_unref (dict);
+
+        return 0;
+}
+
+int
+client3_1_removexattr_cbk (struct rpc_req *req, struct iovec *iov, int count,
+                           void *myframe)
+{
+        call_frame_t    *frame      = NULL;
+        gf_common_rsp    rsp        = {0,};
+        int              ret        = 0;
+
+        frame = myframe;
+
+        if (-1 == req->rpc_status) {
+                rsp.op_ret   = -1;
+                rsp.op_errno = ENOTCONN;
+                goto out;
+        }
+
+        ret = xdr_to_common_rsp (*iov, &rsp);
+        if (ret < 0) {
+                gf_log ("", GF_LOG_ERROR, "error");
+                rsp.op_ret   = -1;
+                rsp.op_errno = EINVAL;
+                goto out;
+        }
+
+out:
+        STACK_UNWIND_STRICT (removexattr, frame, rsp.op_ret,
+                             gf_error_to_errno (rsp.op_errno));
+
+        return 0;
+}
+
+int
+client3_1_fsyncdir_cbk (struct rpc_req *req, struct iovec *iov, int count,
+                        void *myframe)
+{
+        call_frame_t    *frame      = NULL;
+        gf_common_rsp    rsp        = {0,};
+        int              ret        = 0;
+
+        frame = myframe;
+
+        if (-1 == req->rpc_status) {
+                rsp.op_ret   = -1;
+                rsp.op_errno = ENOTCONN;
+                goto out;
+        }
+        ret = xdr_to_common_rsp (*iov, &rsp);
+        if (ret < 0) {
+                gf_log ("", GF_LOG_ERROR, "error");
+                rsp.op_ret   = -1;
+                rsp.op_errno = EINVAL;
+                goto out;
+        }
+
+out:
+        STACK_UNWIND_STRICT (fsyncdir, frame, rsp.op_ret,
+                             gf_error_to_errno (rsp.op_errno));
+
+        return 0;
+}
+
+int
+client3_1_access_cbk (struct rpc_req *req, struct iovec *iov, int count,
+                      void *myframe)
+{
+        call_frame_t    *frame      = NULL;
+        gf_common_rsp    rsp        = {0,};
+        int              ret        = 0;
+
+        frame = myframe;
+
+        if (-1 == req->rpc_status) {
+                rsp.op_ret   = -1;
+                rsp.op_errno = ENOTCONN;
+                goto out;
+        }
+        ret = xdr_to_common_rsp (*iov, &rsp);
+        if (ret < 0) {
+                gf_log ("", GF_LOG_ERROR, "error");
+                rsp.op_ret   = -1;
+                rsp.op_errno = EINVAL;
+                goto out;
+        }
+
+out:
+        STACK_UNWIND_STRICT (access, frame, rsp.op_ret,
+                             gf_error_to_errno (rsp.op_errno));
+
+        return 0;
+}
+
+
+int
+client3_1_ftruncate_cbk (struct rpc_req *req, struct iovec *iov, int count,
+                         void *myframe)
+{
+        gfs3_ftruncate_rsp rsp = {0,};
+        call_frame_t   *frame = NULL;
+        struct iatt  prestat  = {0,};
+        struct iatt  poststat = {0,};
+        int ret = 0;
+
+        frame = myframe;
+
+        if (-1 == req->rpc_status) {
+                rsp.op_ret   = -1;
+                rsp.op_errno = ENOTCONN;
+                goto out;
+        }
+        ret = xdr_to_ftruncate_rsp (*iov, &rsp);
+        if (ret < 0) {
+                gf_log ("", GF_LOG_ERROR, "error");
+                rsp.op_ret   = -1;
+                rsp.op_errno = EINVAL;
+                goto out;
+        }
+
+        if (-1 != rsp.op_ret) {
+                gf_stat_to_iatt (&rsp.prestat, &prestat);
+                gf_stat_to_iatt (&rsp.poststat, &poststat);
+        }
+
+out:
+        STACK_UNWIND_STRICT (ftruncate, frame, rsp.op_ret,
+                             gf_error_to_errno (rsp.op_errno), &prestat,
+                             &poststat);
+
+        return 0;
+}
+
+int
+client3_1_fstat_cbk (struct rpc_req *req, struct iovec *iov, int count,
+                     void *myframe)
+{
+        gfs3_fstat_rsp rsp = {0,};
+        call_frame_t   *frame = NULL;
+        struct iatt  stat  = {0,};
+        int ret = 0;
+
+        frame = myframe;
+
+        if (-1 == req->rpc_status) {
+                rsp.op_ret   = -1;
+                rsp.op_errno = ENOTCONN;
+                goto out;
+        }
+        ret = xdr_to_fstat_rsp (*iov, &rsp);
+        if (ret < 0) {
+                gf_log ("", GF_LOG_ERROR, "error");
+                rsp.op_ret   = -1;
+                rsp.op_errno = EINVAL;
+                goto out;
+        }
+
+        if (-1 != rsp.op_ret) {
+                gf_stat_to_iatt (&rsp.stat, &stat);
+        }
+
+out:
+        STACK_UNWIND_STRICT (fstat, frame, rsp.op_ret,
+                             gf_error_to_errno (rsp.op_errno), &stat);
+
+        return 0;
+}
+
+
+int
+client3_1_inodelk_cbk (struct rpc_req *req, struct iovec *iov, int count,
+                       void *myframe)
+{
+        call_frame_t    *frame      = NULL;
+        gf_common_rsp    rsp        = {0,};
+        int              ret        = 0;
+
+        frame = myframe;
+
+        if (-1 == req->rpc_status) {
+                rsp.op_ret   = -1;
+                rsp.op_errno = ENOTCONN;
+                goto out;
+        }
+        ret = xdr_to_common_rsp (*iov, &rsp);
+        if (ret < 0) {
+                gf_log ("", GF_LOG_ERROR, "error");
+                rsp.op_ret   = -1;
+                rsp.op_errno = EINVAL;
+                goto out;
+        }
+
+out:
+        STACK_UNWIND_STRICT (inodelk, frame, rsp.op_ret,
+                             gf_error_to_errno (rsp.op_errno));
+
+        return 0;
+}
+
+int
+client3_1_finodelk_cbk (struct rpc_req *req, struct iovec *iov, int count,
+                        void *myframe)
+{
+        call_frame_t    *frame      = NULL;
+        gf_common_rsp    rsp        = {0,};
+        int              ret        = 0;
+
+        frame = myframe;
+
+        if (-1 == req->rpc_status) {
+                rsp.op_ret   = -1;
+                rsp.op_errno = ENOTCONN;
+                goto out;
+        }
+        ret = xdr_to_common_rsp (*iov, &rsp);
+        if (ret < 0) {
+                gf_log ("", GF_LOG_ERROR, "error");
+                rsp.op_ret   = -1;
+                rsp.op_errno = EINVAL;
+                goto out;
+        }
+
+out:
+        STACK_UNWIND_STRICT (finodelk, frame, rsp.op_ret,
+                             gf_error_to_errno (rsp.op_errno));
+
+        return 0;
+}
+
+int
+client3_1_entrylk_cbk (struct rpc_req *req, struct iovec *iov, int count,
+                       void *myframe)
+{
+        call_frame_t    *frame      = NULL;
+        gf_common_rsp    rsp        = {0,};
+        int              ret        = 0;
+
+        frame = myframe;
+
+        if (-1 == req->rpc_status) {
+                rsp.op_ret   = -1;
+                rsp.op_errno = ENOTCONN;
+                goto out;
+        }
+        ret = xdr_to_common_rsp (*iov, &rsp);
+        if (ret < 0) {
+                gf_log ("", GF_LOG_ERROR, "error");
+                rsp.op_ret   = -1;
+                rsp.op_errno = EINVAL;
+                goto out;
+        }
+
+out:
+
+        STACK_UNWIND_STRICT (entrylk, frame, rsp.op_ret,
+                             gf_error_to_errno (rsp.op_errno));
+
+        return 0;
+}
+
+int
+client3_1_fentrylk_cbk (struct rpc_req *req, struct iovec *iov, int count,
+                        void *myframe)
+{
+        call_frame_t    *frame      = NULL;
+        gf_common_rsp    rsp        = {0,};
+        int              ret        = 0;
+
+        frame = myframe;
+
+        if (-1 == req->rpc_status) {
+                rsp.op_ret   = -1;
+                rsp.op_errno = ENOTCONN;
+                goto out;
+        }
+        ret = xdr_to_common_rsp (*iov, &rsp);
+        if (ret < 0) {
+                gf_log ("", GF_LOG_ERROR, "error");
+                rsp.op_ret   = -1;
+                rsp.op_errno = EINVAL;
+                goto out;
+        }
+
+out:
+        STACK_UNWIND_STRICT (fentrylk, frame, rsp.op_ret,
+                             gf_error_to_errno (rsp.op_errno));
+
+        return 0;
+}
+
+int
+client3_1_xattrop_cbk (struct rpc_req *req, struct iovec *iov, int count,
+                       void *myframe)
+{
+        call_frame_t     *frame    = NULL;
+        dict_t           *dict     = NULL;
+        char             *buf      = NULL;
+        gfs3_xattrop_rsp  rsp      = {0,};
+        int               ret      = 0;
+        int               op_ret   = 0;
+        int               dict_len = 0;
+        int               op_errno = 0;
+
+        frame = myframe;
+
+        if (-1 == req->rpc_status) {
+                op_ret   = -1;
+                op_errno = ENOTCONN;
+                goto out;
+        }
+        ret = xdr_to_xattrop_rsp (*iov, &rsp);
+        if (ret < 0) {
+                gf_log ("", GF_LOG_ERROR, "error");
+                op_ret   = -1;
+                op_errno = EINVAL;
+                goto out;
+        }
+
+        op_ret = rsp.op_ret;
+        if (-1 != op_ret) {
+                op_ret = -1;
+                dict_len = rsp.dict.dict_len;
+
+                if (dict_len > 0) {
+                        dict = dict_new();
+                        GF_VALIDATE_OR_GOTO (frame->this->name, dict, out);
+
+                        buf = memdup (rsp.dict.dict_val, rsp.dict.dict_len);
+                        GF_VALIDATE_OR_GOTO (frame->this->name, buf, out);
+                        op_ret = dict_unserialize (buf, dict_len, &dict);
+                        if (op_ret < 0) {
+                                gf_log (frame->this->name, GF_LOG_DEBUG,
+                                        "failed to unserialize xattr dict");
+                                op_errno = EINVAL;
+                                goto out;
+                        }
+                        dict->extra_free = buf;
+                        buf = NULL;
+                }
+                op_ret = 0;
+        }
+
+out:
+
+        STACK_UNWIND_STRICT (xattrop, frame, op_ret,
+                             gf_error_to_errno (rsp.op_errno), dict);
+
+        if (rsp.dict.dict_val) {
+                /* don't use GF_FREE, this memory was allocated by libc
+                 */
+                free (rsp.dict.dict_val);
+                rsp.dict.dict_val = NULL;
+        }
+
+        if (buf)
+                GF_FREE (buf);
+
+        if (dict)
+                dict_unref (dict);
+
+        return 0;
+}
+
+int
+client3_1_fxattrop_cbk (struct rpc_req *req, struct iovec *iov, int count,
+                        void *myframe)
+{
+        call_frame_t      *frame    = NULL;
+        dict_t            *dict     = NULL;
+        char              *buf      = NULL;
+        gfs3_fxattrop_rsp  rsp      = {0,};
+        int                ret      = 0;
+        int                op_ret   = 0;
+        int                dict_len = 0;
+        int                op_errno = 0;
+
+        frame = myframe;
+
+        if (-1 == req->rpc_status) {
+                op_ret   = -1;
+                op_errno = ENOTCONN;
+                goto out;
+        }
+
+        ret = xdr_to_fxattrop_rsp (*iov, &rsp);
+        if (ret < 0) {
+                op_ret = -1;
+                op_errno = EINVAL;
+                gf_log ("", GF_LOG_ERROR, "error");
+                goto out;
+        }
+
+        op_ret = rsp.op_ret;
+        if (-1 != op_ret) {
+                op_ret = -1;
+                dict_len = rsp.dict.dict_len;
+
+                if (dict_len > 0) {
+                        dict = dict_new();
+                        GF_VALIDATE_OR_GOTO (frame->this->name, dict, out);
+
+                        buf = memdup (rsp.dict.dict_val, rsp.dict.dict_len);
+                        GF_VALIDATE_OR_GOTO (frame->this->name, buf, out);
+                        op_ret = dict_unserialize (buf, dict_len, &dict);
+                        if (op_ret < 0) {
+                                gf_log (frame->this->name, GF_LOG_DEBUG,
+                                        "failed to unserialize xattr dict");
+                                op_errno = EINVAL;
+                                goto out;
+                        }
+                        dict->extra_free = buf;
+                        buf = NULL;
+                }
+                op_ret = 0;
+        }
+
+out:
+
+        STACK_UNWIND_STRICT (fxattrop, frame, op_ret,
+                             gf_error_to_errno (rsp.op_errno), dict);
+
+        if (rsp.dict.dict_val) {
+                /* don't use GF_FREE, this memory was allocated by libc
+                 */
+                free (rsp.dict.dict_val);
+                rsp.dict.dict_val = NULL;
+        }
+
+        if (buf)
+                GF_FREE (buf);
+
+        if (dict)
+                dict_unref (dict);
+
+        return 0;
+}
+
+int
+client3_1_fsetxattr_cbk (struct rpc_req *req, struct iovec *iov, int count,
+                         void *myframe)
+{
+        call_frame_t    *frame      = NULL;
+        gf_common_rsp    rsp        = {0,};
+        int              ret        = 0;
+
+        frame = myframe;
+
+        if (-1 == req->rpc_status) {
+                rsp.op_ret   = -1;
+                rsp.op_errno = ENOTCONN;
+                goto out;
+        }
+        ret = xdr_to_common_rsp (*iov, &rsp);
+        if (ret < 0) {
+                gf_log ("", GF_LOG_ERROR, "error");
+                rsp.op_ret   = -1;
+                rsp.op_errno = EINVAL;
+                goto out;
+        }
+
+out:
+        STACK_UNWIND_STRICT (fsetxattr, frame, rsp.op_ret,
+                             gf_error_to_errno (rsp.op_errno));
+
+        return 0;
+}
+
+int
+client3_1_fsetattr_cbk (struct rpc_req *req, struct iovec *iov, int count,
+                        void *myframe)
+{
+        call_frame_t    *frame      = NULL;
+        gfs3_fsetattr_rsp rsp        = {0,};
+        struct iatt      prestat    = {0,};
+        struct iatt      poststat   = {0,};
+        int              ret        = 0;
+
+        frame = myframe;
+
+        if (-1 == req->rpc_status) {
+                rsp.op_ret   = -1;
+                rsp.op_errno = ENOTCONN;
+                goto out;
+        }
+        ret = xdr_to_fsetattr_rsp (*iov, &rsp);
+        if (ret < 0) {
+                gf_log ("", GF_LOG_ERROR, "error");
+                rsp.op_ret   = -1;
+                rsp.op_errno = EINVAL;
+                goto out;
+        }
+
+        if (-1 != rsp.op_ret) {
+                gf_stat_to_iatt (&rsp.statpre, &prestat);
+                gf_stat_to_iatt (&rsp.statpost, &poststat);
+        }
+
+out:
+        STACK_UNWIND_STRICT (fsetattr, frame, rsp.op_ret,
+                             gf_error_to_errno (rsp.op_errno), &prestat,
+                             &poststat);
+
+        return 0;
+}
+
+
+int
+client3_1_setattr_cbk (struct rpc_req *req, struct iovec *iov, int count,
+                       void *myframe)
+{
+        call_frame_t    *frame      = NULL;
+        gfs3_setattr_rsp rsp        = {0,};
+        struct iatt      prestat    = {0,};
+        struct iatt      poststat   = {0,};
+        int              ret        = 0;
+
+        frame = myframe;
+
+        if (-1 == req->rpc_status) {
+                rsp.op_ret   = -1;
+                rsp.op_errno = ENOTCONN;
+                goto out;
+        }
+
+        ret = xdr_to_setattr_rsp (*iov, &rsp);
+        if (ret < 0) {
+                gf_log ("", GF_LOG_ERROR, "error");
+                rsp.op_ret   = -1;
+                rsp.op_errno = EINVAL;
+                goto out;
+        }
+
+        if (-1 != rsp.op_ret) {
+                gf_stat_to_iatt (&rsp.statpre, &prestat);
+                gf_stat_to_iatt (&rsp.statpost, &poststat);
+        }
+
+out:
+        STACK_UNWIND_STRICT (setattr, frame, rsp.op_ret,
+                             gf_error_to_errno (rsp.op_errno), &prestat,
+                             &poststat);
+
+        return 0;
+}
+
+int
+client3_1_create_cbk (struct rpc_req *req, struct iovec *iov, int count,
+                      void *myframe)
+{
+        call_frame_t    *frame      = NULL;
+        fd_t            *fd         = NULL;
+        inode_t         *inode      = NULL;
+        struct iatt      stbuf      = {0, };
+        struct iatt      preparent  = {0, };
+        struct iatt      postparent = {0, };
+        int32_t          ret        = -1;
+        clnt_local_t    *local      = NULL;
+        clnt_conf_t     *conf       = NULL;
+        clnt_fd_ctx_t   *fdctx      = NULL;
+        gfs3_create_rsp  rsp        = {0,};
+
+        frame = myframe;
+        local = frame->local; frame->local = NULL;
+        conf  = frame->this->private;
+        fd    = local->fd;
+        inode = local->loc.inode;
+
+        if (-1 == req->rpc_status) {
+                rsp.op_ret   = -1;
+                rsp.op_errno = ENOTCONN;
+                goto out;
+        }
+
+        ret = xdr_to_create_rsp (*iov, &rsp);
+        if (ret < 0) {
+                gf_log ("", GF_LOG_ERROR, "error");
+                rsp.op_ret   = -1;
+                rsp.op_errno = EINVAL;
+                goto out;
+        }
+
+        if (-1 != rsp.op_ret) {
+                gf_stat_to_iatt (&rsp.stat, &stbuf);
+
+                ret = inode_ctx_put2 (inode, frame->this,
+                                      stbuf.ia_ino, stbuf.ia_gen);
+                if (ret < 0) {
+                        gf_log (frame->this->name, GF_LOG_DEBUG,
+                                "CREATE %"PRId64"/%s (%s): failed to set "
+                                "remote inode number to inode ctx",
+                                local->loc.parent->ino, local->loc.name,
+                                local->loc.path);
+                }
+
+                gf_stat_to_iatt (&rsp.preparent, &preparent);
+                gf_stat_to_iatt (&rsp.postparent, &postparent);
+
+                fdctx = GF_CALLOC (1, sizeof (*fdctx),
+                                   gf_client_mt_clnt_fdctx_t);
+                if (!fdctx) {
+                        rsp.op_ret = -1;
+                        rsp.op_errno = ENOMEM;
+                        goto out;
+                }
+
+                fdctx->remote_fd = rsp.fd;
+                fdctx->inode     = inode_ref (inode);
+                fdctx->ino       = stbuf.ia_ino;
+                fdctx->gen       = stbuf.ia_gen;
+                fdctx->flags     = local->flags;
+
+                INIT_LIST_HEAD (&fdctx->sfd_pos);
+
+                this_fd_set_ctx (fd, frame->this, &local->loc, fdctx);
+
+                pthread_mutex_lock (&conf->lock);
+                {
+                        list_add_tail (&fdctx->sfd_pos, &conf->saved_fds);
+                }
+                pthread_mutex_unlock (&conf->lock);
+        }
+
+out:
+        frame->local = NULL;
+        STACK_UNWIND_STRICT (create, frame, rsp.op_ret,
+                             gf_error_to_errno (rsp.op_errno), fd, inode,
+                             &stbuf, &preparent, &postparent);
+
+        client_local_wipe (local);
+        return 0;
+}
+
+
+int
+client3_1_rchecksum_cbk (struct rpc_req *req, struct iovec *iov, int count,
+                         void *myframe)
+{
+        call_frame_t *frame = NULL;
+        gfs3_rchecksum_rsp rsp        = {0,};
+        int              ret        = 0;
+
+        frame = myframe;
+
+        if (-1 == req->rpc_status) {
+                rsp.op_ret   = -1;
+                rsp.op_errno = ENOTCONN;
+                goto out;
+        }
+
+        ret = xdr_to_rchecksum_rsp (*iov, &rsp);
+        if (ret < 0) {
+                gf_log ("", GF_LOG_ERROR, "error");
+                rsp.op_ret   = -1;
+                rsp.op_errno = EINVAL;
+                goto out;
+        }
+
+out:
+        STACK_UNWIND_STRICT (rchecksum, frame, rsp.op_ret,
+                             gf_error_to_errno (rsp.op_errno),
+                             rsp.weak_checksum,
+                             (uint8_t *)rsp.strong_checksum.strong_checksum_val);
+
+        if (rsp.strong_checksum.strong_checksum_val) {
+                /* This is allocated by the libc while decoding RPC msg */
+                /* Hence no 'GF_FREE', but just 'free' */
+                free (rsp.strong_checksum.strong_checksum_val);
+        }
+
+        return 0;
+}
+
+int
+client3_1_checksum_cbk (struct rpc_req *req, struct iovec *iov, int count,
+                        void *myframe)
+{
+        call_frame_t *frame = NULL;
+        gfs3_checksum_rsp rsp        = {0,};
+        int              ret        = 0;
+
+        frame = myframe;
+
+        if (-1 == req->rpc_status) {
+                rsp.op_ret   = -1;
+                rsp.op_errno = ENOTCONN;
+                goto out;
+        }
+
+        ret = xdr_to_checksum_rsp (*iov, &rsp);
+        if (ret < 0) {
+                gf_log ("", GF_LOG_ERROR, "error");
+                rsp.op_ret   = -1;
+                rsp.op_errno = EINVAL;
+                goto out;
+        }
+
+out:
+        STACK_UNWIND_STRICT (checksum, frame, rsp.op_ret,
+                             gf_error_to_errno (rsp.op_errno),
+                             (uint8_t *)rsp.fchecksum.fchecksum_val,
+                             (uint8_t *)rsp.dchecksum.dchecksum_val);
+
+        /* This is allocated by the libc while decoding RPC msg */
+        /* Hence no 'GF_FREE', but just 'free' */
+        if (rsp.fchecksum.fchecksum_val) {
+                free (rsp.fchecksum.fchecksum_val);
+        }
+        if (rsp.dchecksum.dchecksum_val) {
+                free (rsp.dchecksum.dchecksum_val);
+        }
+        return 0;
+}
+
+int
+client3_1_lk_cbk (struct rpc_req *req, struct iovec *iov, int count,
+                  void *myframe)
+{
+        call_frame_t  *frame = NULL;
+        struct flock   lock = {0,};
+        gfs3_lk_rsp    rsp        = {0,};
+        int            ret        = 0;
+
+        frame = myframe;
+
+        if (-1 == req->rpc_status) {
+                rsp.op_ret   = -1;
+                rsp.op_errno = ENOTCONN;
+                goto out;
+        }
+
+        ret = xdr_to_lk_rsp (*iov, &rsp);
+        if (ret < 0) {
+                gf_log ("", GF_LOG_ERROR, "error");
+                rsp.op_ret   = -1;
+                rsp.op_errno = EINVAL;
+                goto out;
+        }
+
+        if (rsp.op_ret >= 0) {
+                gf_flock_to_flock (&rsp.flock, &lock);
+        }
+
+out:
+        STACK_UNWIND_STRICT (lk, frame, rsp.op_ret,
+                             gf_error_to_errno (rsp.op_errno), &lock);
+
+        return 0;
+}
+
+int
+client3_1_readdir_cbk (struct rpc_req *req, struct iovec *iov, int count,
+                       void *myframe)
+{
+        call_frame_t           *frame = NULL;
+        gfs3_readdir_rsp        rsp = {0,};
+        int32_t                 ret = 0;
+        gf_dirent_t             entries;
+
+        frame = myframe;
+
+        if (-1 == req->rpc_status) {
+                rsp.op_ret   = -1;
+                rsp.op_errno = ENOTCONN;
+                goto out;
+        }
+
+        ret = xdr_to_readdir_rsp (*iov, &rsp);
+        if (ret < 0) {
+                gf_log ("", GF_LOG_ERROR, "error");
+                rsp.op_ret   = -1;
+                rsp.op_errno = EINVAL;
+                goto out;
+        }
+
+        INIT_LIST_HEAD (&entries.list);
+        if (rsp.op_ret > 0) {
+                unserialize_rsp_dirent (&rsp, &entries);
+        }
+
+out:
+        STACK_UNWIND_STRICT (readdir, frame, rsp.op_ret,
+                             gf_error_to_errno (rsp.op_errno), &entries);
+
+        if (rsp.op_ret != -1) {
+                gf_dirent_free (&entries);
+        }
+
+        clnt_readdir_rsp_cleanup (&rsp);
+
+        return 0;
+}
+
+
+int
+client3_1_readdirp_cbk (struct rpc_req *req, struct iovec *iov, int count,
+                        void *myframe)
+{
+        call_frame_t           *frame = NULL;
+        gfs3_readdirp_rsp       rsp = {0,};
+        int32_t                 ret = 0;
+        gf_dirent_t             entries;
+
+        frame = myframe;
+
+        if (-1 == req->rpc_status) {
+                rsp.op_ret   = -1;
+                rsp.op_errno = ENOTCONN;
+                goto out;
+        }
+
+        ret = xdr_to_readdirp_rsp (*iov, &rsp);
+        if (ret < 0) {
+                gf_log ("", GF_LOG_ERROR, "error");
+                rsp.op_ret   = -1;
+                rsp.op_errno = EINVAL;
+                goto out;
+        }
+
+        INIT_LIST_HEAD (&entries.list);
+        if (rsp.op_ret > 0) {
+                unserialize_rsp_direntp (&rsp, &entries);
+        }
+
+out:
+        STACK_UNWIND_STRICT (readdirp, frame, rsp.op_ret,
+                             gf_error_to_errno (rsp.op_errno), &entries);
+
+        if (rsp.op_ret != -1) {
+                gf_dirent_free (&entries);
+        }
+
+        clnt_readdirp_rsp_cleanup (&rsp);
+
+        return 0;
+}
+
+
+int
+client3_1_rename_cbk (struct rpc_req *req, struct iovec *iov, int count,
+                      void *myframe)
+{
+        call_frame_t     *frame      = NULL;
+        gfs3_rename_rsp   rsp        = {0,};
+        struct iatt       stbuf      = {0,};
+        struct iatt       preoldparent  = {0,};
+        struct iatt       postoldparent = {0,};
+        struct iatt       prenewparent  = {0,};
+        struct iatt       postnewparent = {0,};
+        int               ret        = 0;
+
+        frame = myframe;
+
+        if (-1 == req->rpc_status) {
+                rsp.op_ret   = -1;
+                rsp.op_errno = ENOTCONN;
+                goto out;
+        }
+
+        ret = xdr_to_rename_rsp (*iov, &rsp);
+        if (ret < 0) {
+                gf_log ("", GF_LOG_ERROR, "error");
+                rsp.op_ret   = -1;
+                rsp.op_errno = EINVAL;
+                goto out;
+        }
+
+        if (-1 != rsp.op_ret) {
+                gf_stat_to_iatt (&rsp.stat, &stbuf);
+
+                gf_stat_to_iatt (&rsp.preoldparent, &preoldparent);
+                gf_stat_to_iatt (&rsp.postoldparent, &postoldparent);
+
+                gf_stat_to_iatt (&rsp.prenewparent, &prenewparent);
+                gf_stat_to_iatt (&rsp.postnewparent, &postnewparent);
+        }
+
+out:
+        STACK_UNWIND_STRICT (rename, frame, rsp.op_ret,
+                             gf_error_to_errno (rsp.op_errno),
+                             &stbuf, &preoldparent, &postoldparent,
+                             &preoldparent, &postoldparent);
+
+        return 0;
+}
+
+int
+client3_1_link_cbk (struct rpc_req *req, struct iovec *iov, int count,
+                    void *myframe)
+{
+        call_frame_t     *frame      = NULL;
+        gfs3_link_rsp     rsp        = {0,};
+        struct iatt       stbuf      = {0,};
+        struct iatt       preparent  = {0,};
+        struct iatt       postparent = {0,};
+        int               ret        = 0;
+        clnt_local_t     *local      = NULL;
+        inode_t          *inode      = NULL;
+
+        frame = myframe;
+
+        local = frame->local;
+        frame->local = NULL;
+        inode = local->loc.inode;
+
+        if (-1 == req->rpc_status) {
+                rsp.op_ret   = -1;
+                rsp.op_errno = ENOTCONN;
+                goto out;
+        }
+
+        ret = xdr_to_link_rsp (*iov, &rsp);
+        if (ret < 0) {
+                gf_log ("", GF_LOG_ERROR, "error");
+                rsp.op_ret   = -1;
+                rsp.op_errno = EINVAL;
+                goto out;
+        }
+
+        if (-1 != rsp.op_ret) {
+                gf_stat_to_iatt (&rsp.stat, &stbuf);
+
+                gf_stat_to_iatt (&rsp.preparent, &preparent);
+                gf_stat_to_iatt (&rsp.postparent, &postparent);
+        }
+
+out:
+        frame->local = NULL;
+        STACK_UNWIND_STRICT (link, frame, rsp.op_ret,
+                             gf_error_to_errno (rsp.op_errno), inode,
+                             &stbuf, &preparent, &postparent);
+
+        client_local_wipe (local);
+        return 0;
+}
+
+
+int
+client3_1_opendir_cbk (struct rpc_req *req, struct iovec *iov, int count,
+                       void *myframe)
+{
+        clnt_local_t      *local = NULL;
+        clnt_conf_t       *conf = NULL;
+        clnt_fd_ctx_t     *fdctx = NULL;
+        ino_t                ino = 0;
+        uint64_t             gen = 0;
+        call_frame_t   *frame = NULL;
+        fd_t             *fd = NULL;
+        int ret = 0;
+        gfs3_opendir_rsp  rsp = {0,};
+
+        frame = myframe;
+        local = frame->local;
+
+        if (local->op) {
+                local->op (req, iov, 1, myframe);
+                return 0;
+        }
+
+        frame->local = NULL;
+        conf  = frame->this->private;
+        fd    = local->fd;
+
+        if (-1 == req->rpc_status) {
+                rsp.op_ret   = -1;
+                rsp.op_errno = ENOTCONN;
+                goto out;
+        }
+
+        ret = xdr_to_opendir_rsp (*iov, &rsp);
+        if (ret < 0) {
+                gf_log ("", GF_LOG_ERROR, "error");
+                rsp.op_ret   = -1;
+                rsp.op_errno = EINVAL;
+                goto out;
+        }
+
+        if (-1 != rsp.op_ret) {
+                fdctx = GF_CALLOC (1, sizeof (*fdctx),
+                                   gf_client_mt_clnt_fdctx_t);
+                if (!fdctx) {
+                        rsp.op_ret = -1;
+                        rsp.op_errno = ENOMEM;
+                        goto out;
+                }
+
+                inode_ctx_get2 (fd->inode, frame->this, &ino, &gen);
+
+                fdctx->remote_fd = rsp.fd;
+                fdctx->inode     = inode_ref (fd->inode);
+                fdctx->ino       = ino;
+                fdctx->gen       = gen;
+
+                fdctx->is_dir    = 1;
+
+                INIT_LIST_HEAD (&fdctx->sfd_pos);
+
+                this_fd_set_ctx (fd, frame->this, &local->loc, fdctx);
+
+                pthread_mutex_lock (&conf->lock);
+                {
+                        list_add_tail (&fdctx->sfd_pos, &conf->saved_fds);
+                }
+                pthread_mutex_unlock (&conf->lock);
+        }
+
+out:
+        frame->local = NULL;
+        STACK_UNWIND_STRICT (opendir, frame, rsp.op_ret,
+                             gf_error_to_errno (rsp.op_errno), fd);
+
+        client_local_wipe (local);
+
+        return 0;
+}
+
+
+int
+client3_1_lookup_cbk (struct rpc_req *req, struct iovec *iov, int count,
+                      void *myframe)
+{
+        clnt_local_t    *local      = NULL;
+        call_frame_t    *frame      = NULL;
+        int              ret        = 0;
+        gfs3_lookup_rsp  rsp        = {0,};
+        struct iatt      stbuf      = {0,};
+        struct iatt      postparent = {0,};
+        int              op_errno   = 0;
+        ino_t            oldino     = 0;
+        uint64_t         oldgen     = 0;
+        dict_t          *xattr      = NULL;
+        inode_t         *inode      = NULL;
+        char            *buf        = NULL;
+
+        frame = myframe;
+        local = frame->local;
+        inode = local->loc.inode;
+        frame->local = NULL;
+
+        if (-1 == req->rpc_status) {
+                rsp.op_ret   = -1;
+                rsp.op_errno = ENOTCONN;
+                goto out;
+        }
+
+        ret = xdr_to_lookup_rsp (*iov, &rsp);
+        if (ret < 0) {
+                gf_log ("", GF_LOG_ERROR, "error");
+                rsp.op_ret   = -1;
+                rsp.op_errno = EINVAL;
+                goto out;
+        }
+
+        op_errno = gf_error_to_errno (rsp.op_errno);
+        gf_stat_to_iatt (&rsp.postparent, &postparent);
+
+        if (rsp.op_ret == 0) {
+                rsp.op_ret = -1;
+                gf_stat_to_iatt (&rsp.stat, &stbuf);
+
+                ret = inode_ctx_get2 (inode, frame->this, &oldino, &oldgen);
+                if (oldino != stbuf.ia_ino || oldgen != stbuf.ia_gen) {
+                        if (oldino) {
+                                gf_log (frame->this->name, GF_LOG_DEBUG,
+                                        "LOOKUP %"PRId64"/%s (%s): "
+                                        "inode number changed from "
+                                        "{%"PRId64",%"PRId64"} to {%"PRId64",%"PRId64"}",
+                                        local->loc.parent ?
+                                        local->loc.parent->ino : (uint64_t) 0,
+                                        local->loc.name,
+                                        local->loc.path,
+                                        oldgen, oldino, stbuf.ia_gen, stbuf.ia_ino);
+                                op_errno = ESTALE;
+                                goto out;
+                        }
+
+                        ret = inode_ctx_put2 (inode, frame->this,
+                                              stbuf.ia_ino, stbuf.ia_gen);
+                        if (ret < 0) {
+                                gf_log (frame->this->name, GF_LOG_DEBUG,
+                                        "LOOKUP %"PRId64"/%s (%s) : "
+                                        "failed to set remote inode "
+                                        "number to inode ctx",
+                                        local->loc.parent ?
+                                        local->loc.parent->ino : (uint64_t) 0,
+                                        local->loc.name,
+                                        local->loc.path);
+                        }
+                }
+
+                if (rsp.dict.dict_len > 0) {
+                        xattr = dict_new();
+                        GF_VALIDATE_OR_GOTO (frame->this->name, xattr, out);
+
+                        buf = memdup (rsp.dict.dict_val, rsp.dict.dict_len);
+                        GF_VALIDATE_OR_GOTO (frame->this->name, buf, out);
+
+                        ret = dict_unserialize (buf, rsp.dict.dict_len, &xattr);
+                        if (ret < 0) {
+                                gf_log (frame->this->name, GF_LOG_DEBUG,
+                                        "%s (%"PRId64"): failed to "
+                                        "unserialize dictionary",
+                                        local->loc.path, inode->ino);
+                                op_errno = EINVAL;
+                                goto out;
+                        }
+
+                        xattr->extra_free = buf;
+                        buf = NULL;
+                }
+
+                rsp.op_ret = 0;
+        }
+
+out:
+        frame->local = NULL;
+        STACK_UNWIND_STRICT (lookup, frame, rsp.op_ret, rsp.op_errno, inode,
+                             &stbuf, xattr, &postparent);
+
+        client_local_wipe (local);
+
+        if (xattr)
+                dict_unref (xattr);
+
+        if (rsp.dict.dict_val) {
+                /* don't use GF_FREE, this memory was allocated by libc
+                 */
+                free (rsp.dict.dict_val);
+                rsp.dict.dict_val = NULL;
+        }
+
+        if (buf) {
+                GF_FREE (buf);
+        }
+
+        return 0;
+}
+
+int
+client3_1_readv_cbk (struct rpc_req *req, struct iovec *iov, int count,
+                     void *myframe)
+{
+        call_frame_t  *frame  = NULL;
+        struct iobref *iobref = NULL;
+        struct iovec   vector = {0,};
+        struct iatt    stat   = {0,};
+        gfs3_read_rsp  rsp    = {0,};
+        int            ret    = 0;
+
+        frame = myframe;
+
+        if (-1 == req->rpc_status) {
+                rsp.op_ret   = -1;
+                rsp.op_errno = ENOTCONN;
+                goto out;
+        }
+
+        ret = xdr_to_readv_rsp (*iov, &rsp);
+        if (ret < 0) {
+                gf_log ("", GF_LOG_ERROR, "error");
+                rsp.op_ret   = -1;
+                rsp.op_errno = EINVAL;
+                goto out;
+        }
+
+        if (rsp.op_ret != -1) {
+                iobref = iobref_new ();
+                gf_stat_to_iatt (&rsp.stat, &stat);
+                vector.iov_len  = rsp.op_ret;
+
+                if (rsp.op_ret > 0) {
+                        vector.iov_base = req->rsp_procpayload->ptr;
+                        iobref_add (iobref, req->rsp_procpayload);
+                }
+        }
+out:
+        STACK_UNWIND_STRICT (readv, frame, rsp.op_ret,
+                             gf_error_to_errno (rsp.op_errno), &vector, 1,
+                             &stat, iobref);
+
+        if (iobref) {
+                iobref_unref (iobref);
+        }
+
+        return 0;
+}
+
+int
+client3_1_release_cbk (struct rpc_req *req, struct iovec *iov, int count,
+                       void *myframe)
+{
+        call_frame_t   *frame = NULL;
+
+        frame = myframe;
+        STACK_DESTROY (frame->root);
+        return 0;
+}
+int
+client3_1_releasedir_cbk (struct rpc_req *req, struct iovec *iov, int count,
+                          void *myframe)
+{
+        call_frame_t   *frame = NULL;
+
+        frame = myframe;
+        STACK_DESTROY (frame->root);
+        return 0;
+}
+
 int
 client_fdctx_destroy (xlator_t *this, clnt_fd_ctx_t *fdctx)
 {
@@ -121,14 +2101,16 @@ client_fdctx_destroy (xlator_t *this, clnt_fd_ctx_t *fdctx)
         if (fdctx->is_dir) {
                 gfs3_releasedir_req  req = {0,};
                 req.fd = fdctx->remote_fd;
+                req.gfs_id = GFS3_OP_RELEASEDIR;
                 client_submit_request (this, &req, fr, &clnt3_1_fop_prog,
-                                       GFS3_OP_RELEASEDIR, NULL,
-                                       xdr_from_releasedir_req);
+                                       GFS3_OP_RELEASEDIR, client3_1_releasedir_cbk,
+                                       NULL, xdr_from_releasedir_req);
         } else {
                 gfs3_release_req  req = {0,};
                 req.fd = fdctx->remote_fd;
+                req.gfs_id = GFS3_OP_RELEASE;
                 client_submit_request (this, &req, fr, &clnt3_1_fop_prog,
-                                       GFS3_OP_RELEASE, NULL,
+                                       GFS3_OP_RELEASE, client3_1_release_cbk, NULL,
                                        xdr_from_release_req);
         }
 
@@ -303,14 +2285,15 @@ protocol_client_reopendir (xlator_t *this, clnt_fd_ctx_t *fdctx)
         req.ino   = fdctx->ino;
         req.gen   = fdctx->gen;
         req.path  = (char *)local->loc.path;
+        req.gfs_id = GFS3_OP_OPENDIR;
 
         gf_log (frame->this->name, GF_LOG_DEBUG,
                 "attempting reopen on %s", local->loc.path);
 
         frame->local = local; local = NULL;
 
-        client_submit_request (this, &req, frame, conf->fops,
-                               GFS3_OP_OPENDIR, NULL, xdr_from_opendir_req);
+        client_submit_request (this, &req, frame, conf->fops, GFS3_OP_OPENDIR,
+                               client3_1_opendir_cbk, NULL, xdr_from_opendir_req);
 
         return ret;
 
@@ -373,13 +2356,14 @@ protocol_client_reopen (xlator_t *this, clnt_fd_ctx_t *fdctx)
         req.flags    = gf_flags_from_flags (fdctx->flags);
         req.wbflags  = fdctx->wbflags;
         req.path     = (char *)local->loc.path;
+        req.gfs_id = GFS3_OP_OPEN;
 
         gf_log (frame->this->name, GF_LOG_DEBUG,
                 "attempting reopen on %s", local->loc.path);
 
         local = NULL;
-        client_submit_request (this, &req, frame, conf->fops,
-                               GFS3_OP_OPEN, NULL, xdr_from_open_req);
+        client_submit_request (this, &req, frame, conf->fops, GFS3_OP_OPEN,
+                               client3_1_open_cbk, NULL, xdr_from_open_req);
 
         return ret;
 
@@ -402,7 +2386,7 @@ out:
 
 
 int32_t
-client3_1_releasedir (call_frame_t *frame, xlator_t *this, rpc_clnt_prog_t *prog,
+client3_1_releasedir (call_frame_t *frame, xlator_t *this,
                       void *data)
 {
         clnt_conf_t         *conf = NULL;
@@ -411,7 +2395,7 @@ client3_1_releasedir (call_frame_t *frame, xlator_t *this, rpc_clnt_prog_t *prog
         gfs3_releasedir_req  req = {0,};
         int64_t              remote_fd = -1;
 
-        if (!frame || !this || !prog || !data)
+        if (!frame || !this || !data)
                 goto unwind;
 
         args = data;
@@ -438,8 +2422,9 @@ client3_1_releasedir (call_frame_t *frame, xlator_t *this, rpc_clnt_prog_t *prog
 
         if (remote_fd != -1) {
                 req.fd = remote_fd;
-                client_submit_request (this, &req, frame, prog,
-                                       GFS3_OP_RELEASEDIR,
+                req.gfs_id = GFS3_OP_RELEASEDIR;
+                client_submit_request (this, &req, frame, conf->fops,
+                                       GFS3_OP_RELEASEDIR, client3_1_releasedir_cbk,
                                        NULL, xdr_from_releasedir_req);
                 inode_unref (fdctx->inode);
                 GF_FREE (fdctx);
@@ -451,7 +2436,7 @@ unwind:
 }
 
 int32_t
-client3_1_release (call_frame_t *frame, xlator_t *this, rpc_clnt_prog_t *prog,
+client3_1_release (call_frame_t *frame, xlator_t *this,
                    void *data)
 {
         int64_t           remote_fd = -1;
@@ -460,7 +2445,7 @@ client3_1_release (call_frame_t *frame, xlator_t *this, rpc_clnt_prog_t *prog,
         clnt_args_t      *args      = NULL;
         gfs3_release_req  req       = {0,};
 
-        if (!frame || !this || !prog || !data)
+        if (!frame || !this || !data)
                 goto unwind;
 
         args = data;
@@ -487,8 +2472,9 @@ client3_1_release (call_frame_t *frame, xlator_t *this, rpc_clnt_prog_t *prog,
 
         if (remote_fd != -1) {
                 req.fd = remote_fd;
-                client_submit_request (this, &req, frame, prog,
-                                       GFS3_OP_RELEASE, NULL,
+                req.gfs_id = GFS3_OP_RELEASE;
+                client_submit_request (this, &req, frame, conf->fops,
+                                       GFS3_OP_RELEASE, client3_1_release_cbk, NULL,
                                        xdr_from_release_req);
                 inode_unref (fdctx->inode);
                 GF_FREE (fdctx);
@@ -500,9 +2486,10 @@ unwind:
 
 
 int32_t
-client3_1_lookup (call_frame_t *frame, xlator_t *this, rpc_clnt_prog_t *prog,
+client3_1_lookup (call_frame_t *frame, xlator_t *this,
                   void *data)
 {
+        clnt_conf_t     *conf     = NULL;
         clnt_local_t    *local    = NULL;
         clnt_args_t     *args     = NULL;
         gfs3_lookup_req  req      = {0,};
@@ -510,9 +2497,10 @@ client3_1_lookup (call_frame_t *frame, xlator_t *this, rpc_clnt_prog_t *prog,
         size_t           dict_len = 0;
         int              op_errno = ESTALE;
 
-        if (!frame || !this || !prog || !data)
+        if (!frame || !this || !data)
                 goto unwind;
 
+        conf = this->private;
         args = data;
         local = GF_CALLOC (1, sizeof (*local), gf_client_mt_clnt_local_t);
         if (!local) {
@@ -554,9 +2542,11 @@ client3_1_lookup (call_frame_t *frame, xlator_t *this, rpc_clnt_prog_t *prog,
         req.path          = (char *)args->loc->path;
         req.bname         = (char *)args->loc->name;
         req.dict.dict_len = dict_len;
+        req.gfs_id        = GFS3_OP_LOOKUP;
 
-        client_submit_request (this, &req, frame,prog,
-                               GFS3_OP_LOOKUP, NULL, xdr_from_lookup_req);
+        client_submit_request (this, &req, frame, conf->fops,
+                               GFS3_OP_LOOKUP, client3_1_lookup_cbk,
+                               NULL, xdr_from_lookup_req);
 
         if (req.dict.dict_val) {
                 GF_FREE (req.dict.dict_val);
@@ -581,15 +2571,16 @@ unwind:
 
 
 int32_t
-client3_1_stat (call_frame_t *frame, xlator_t *this, rpc_clnt_prog_t *prog,
+client3_1_stat (call_frame_t *frame, xlator_t *this,
                 void *data)
 {
+        clnt_conf_t   *conf     = NULL;
         clnt_args_t   *args     = NULL;
         gfs3_stat_req  req      = {0,};
         int            ret      = 0;
         int            op_errno = ESTALE;
 
-        if (!frame || !this || !prog || !data)
+        if (!frame || !this || !data)
                 goto unwind;
 
         args = data;
@@ -603,9 +2594,11 @@ client3_1_stat (call_frame_t *frame, xlator_t *this, rpc_clnt_prog_t *prog,
                         goto unwind;
         }
         req.path = (char *)args->loc->path;
+        req.gfs_id = GFS3_OP_STAT;
+        conf = this->private;
 
-        client_submit_request (this, &req, frame,prog, GFS3_OP_STAT,
-                               NULL, xdr_from_stat_req);
+        client_submit_request (this, &req, frame, conf->fops, GFS3_OP_STAT,
+                               client3_1_stat_cbk, NULL, xdr_from_stat_req);
 
         return 0;
 unwind:
@@ -615,15 +2608,16 @@ unwind:
 
 
 int32_t
-client3_1_truncate (call_frame_t *frame, xlator_t *this, rpc_clnt_prog_t *prog,
+client3_1_truncate (call_frame_t *frame, xlator_t *this,
                     void *data)
 {
+        clnt_conf_t       *conf     = NULL;
         clnt_args_t       *args     = NULL;
         gfs3_truncate_req  req      = {0,};
         int                ret      = 0;
         int                op_errno = ESTALE;
 
-        if (!frame || !this || !prog || !data)
+        if (!frame || !this || !data)
                 goto unwind;
 
         args = data;
@@ -638,9 +2632,12 @@ client3_1_truncate (call_frame_t *frame, xlator_t *this, rpc_clnt_prog_t *prog,
         }
         req.path = (char *)args->loc->path;
         req.offset = args->offset;
+        req.gfs_id = GFS3_OP_TRUNCATE;
+
+        conf = this->private;
 
-        client_submit_request (this, &req, frame,prog, GFS3_OP_TRUNCATE,
-                               NULL, xdr_from_truncate_req);
+        client_submit_request (this, &req, frame, conf->fops, GFS3_OP_TRUNCATE,
+                               client3_1_truncate_cbk, NULL, xdr_from_truncate_req);
 
         return 0;
 unwind:
@@ -650,7 +2647,7 @@ unwind:
 
 
 int32_t
-client3_1_ftruncate (call_frame_t *frame, xlator_t *this, rpc_clnt_prog_t *prog,
+client3_1_ftruncate (call_frame_t *frame, xlator_t *this,
                      void *data)
 {
         clnt_args_t        *args     = NULL;
@@ -659,7 +2656,7 @@ client3_1_ftruncate (call_frame_t *frame, xlator_t *this, rpc_clnt_prog_t *prog,
         gfs3_ftruncate_req  req      = {0,};
         int                 op_errno = EINVAL;
 
-        if (!frame || !this || !prog || !data)
+        if (!frame || !this || !data)
                 goto unwind;
 
         args = data;
@@ -689,9 +2686,10 @@ client3_1_ftruncate (call_frame_t *frame, xlator_t *this, rpc_clnt_prog_t *prog,
 
         req.offset = args->offset;
         req.fd     = fdctx->remote_fd;
+        req.gfs_id = GFS3_OP_FTRUNCATE;
 
-        client_submit_request (this, &req, frame,prog, GFS3_OP_FTRUNCATE,
-                               NULL, xdr_from_ftruncate_req);
+        client_submit_request (this, &req, frame, conf->fops, GFS3_OP_FTRUNCATE,
+                               client3_1_ftruncate_cbk, NULL, xdr_from_ftruncate_req);
 
         return 0;
 unwind:
@@ -702,15 +2700,16 @@ unwind:
 
 
 int32_t
-client3_1_access (call_frame_t *frame, xlator_t *this, rpc_clnt_prog_t *prog,
+client3_1_access (call_frame_t *frame, xlator_t *this,
                   void *data)
 {
+        clnt_conf_t     *conf     = NULL;
         clnt_args_t     *args     = NULL;
         gfs3_access_req  req      = {0,};
         int              ret      = 0;
         int              op_errno = ESTALE;
 
-        if (!frame || !this || !prog || !data)
+        if (!frame || !this || !data)
                 goto unwind;
 
         args = data;
@@ -725,9 +2724,12 @@ client3_1_access (call_frame_t *frame, xlator_t *this, rpc_clnt_prog_t *prog,
         }
         req.path = (char *)args->loc->path;
         req.mask = args->mask;
+        req.gfs_id = GFS3_OP_ACCESS;
+
+        conf = this->private;
 
-        client_submit_request (this, &req, frame,prog, GFS3_OP_ACCESS,
-                               NULL, xdr_from_access_req);
+        client_submit_request (this, &req, frame, conf->fops, GFS3_OP_ACCESS,
+                               client3_1_access_cbk, NULL, xdr_from_access_req);
 
         return 0;
 unwind:
@@ -736,15 +2738,16 @@ unwind:
 }
 
 int32_t
-client3_1_readlink (call_frame_t *frame, xlator_t *this, rpc_clnt_prog_t *prog,
+client3_1_readlink (call_frame_t *frame, xlator_t *this,
                     void *data)
 {
+        clnt_conf_t       *conf     = NULL;
         clnt_args_t       *args     = NULL;
         gfs3_readlink_req  req      = {0,};
         int                ret      = 0;
         int                op_errno = ESTALE;
 
-        if (!frame || !this || !prog || !data)
+        if (!frame || !this || !data)
                 goto unwind;
 
         args = data;
@@ -759,9 +2762,11 @@ client3_1_readlink (call_frame_t *frame, xlator_t *this, rpc_clnt_prog_t *prog,
         }
         req.path = (char *)args->loc->path;
         req.size = args->size;
+        req.gfs_id = GFS3_OP_READLINK;
+        conf = this->private;
 
-        client_submit_request (this, &req, frame,prog, GFS3_OP_READLINK,
-                               NULL, xdr_from_readlink_req);
+        client_submit_request (this, &req, frame, conf->fops, GFS3_OP_READLINK,
+                               client3_1_readlink_cbk, NULL, xdr_from_readlink_req);
 
         return 0;
 unwind:
@@ -773,15 +2778,16 @@ unwind:
 
 
 int32_t
-client3_1_unlink (call_frame_t *frame, xlator_t *this, rpc_clnt_prog_t *prog,
+client3_1_unlink (call_frame_t *frame, xlator_t *this,
                   void *data)
 {
+        clnt_conf_t     *conf     = NULL;
         clnt_args_t     *args     = NULL;
         gfs3_unlink_req  req      = {0,};
         int              ret      = 0;
         int              op_errno = 0;
 
-        if (!frame || !this || !prog || !data)
+        if (!frame || !this || !data)
                 goto unwind;
 
         args = data;
@@ -796,9 +2802,11 @@ client3_1_unlink (call_frame_t *frame, xlator_t *this, rpc_clnt_prog_t *prog,
         }
         req.path  = (char *)args->loc->path;
         req.bname = (char *)args->loc->name;
+        req.gfs_id = GFS3_OP_UNLINK;
+        conf = this->private;
 
-        client_submit_request (this, &req, frame,prog, GFS3_OP_UNLINK,
-                               NULL, xdr_from_unlink_req);
+        client_submit_request (this, &req, frame, conf->fops, GFS3_OP_UNLINK,
+                               client3_1_unlink_cbk, NULL, xdr_from_unlink_req);
 
         return 0;
 unwind:
@@ -809,15 +2817,16 @@ unwind:
 
 
 int32_t
-client3_1_rmdir (call_frame_t *frame, xlator_t *this, rpc_clnt_prog_t *prog,
+client3_1_rmdir (call_frame_t *frame, xlator_t *this,
                  void *data)
 {
+        clnt_conf_t    *conf     = NULL;
         clnt_args_t    *args     = NULL;
         gfs3_rmdir_req  req      = {0,};
         int             ret      = 0;
         int             op_errno = ESTALE;
 
-        if (!frame || !this || !prog || !data)
+        if (!frame || !this || !data)
                 goto unwind;
 
         args = data;
@@ -832,9 +2841,11 @@ client3_1_rmdir (call_frame_t *frame, xlator_t *this, rpc_clnt_prog_t *prog,
         }
         req.path  = (char *)args->loc->path;
         req.bname = (char *)args->loc->name;
+        req.gfs_id = GFS3_OP_RMDIR;
+        conf = this->private;
 
-        client_submit_request (this, &req, frame,prog, GFS3_OP_RMDIR,
-                               NULL, xdr_from_rmdir_req);
+        client_submit_request (this, &req, frame, conf->fops, GFS3_OP_RMDIR,
+                               client3_1_rmdir_cbk, NULL, xdr_from_rmdir_req);
 
         return 0;
 unwind:
@@ -845,16 +2856,17 @@ unwind:
 
 
 int32_t
-client3_1_symlink (call_frame_t *frame, xlator_t *this, rpc_clnt_prog_t *prog,
+client3_1_symlink (call_frame_t *frame, xlator_t *this,
                    void *data)
 {
         clnt_local_t     *local    = NULL;
+        clnt_conf_t      *conf     = NULL;
         clnt_args_t      *args     = NULL;
         gfs3_symlink_req  req      = {0,};
         int               ret      = 0;
         int               op_errno = ESTALE;
 
-        if (!frame || !this || !prog || !data)
+        if (!frame || !this || !data)
                 goto unwind;
 
         args = data;
@@ -880,9 +2892,11 @@ client3_1_symlink (call_frame_t *frame, xlator_t *this, rpc_clnt_prog_t *prog,
         req.path     = (char *)args->loc->path;
         req.linkname = (char *)args->linkname;
         req.bname    = (char *)args->loc->name;
+        req.gfs_id = GFS3_OP_SYMLINK;
+        conf = this->private;
 
-        client_submit_request (this, &req, frame,prog, GFS3_OP_SYMLINK,
-                               NULL, xdr_from_symlink_req);
+        client_submit_request (this, &req, frame, conf->fops, GFS3_OP_SYMLINK,
+                               client3_1_symlink_cbk, NULL, xdr_from_symlink_req);
 
         return 0;
 unwind:
@@ -896,15 +2910,16 @@ unwind:
 
 
 int32_t
-client3_1_rename (call_frame_t *frame, xlator_t *this, rpc_clnt_prog_t *prog,
+client3_1_rename (call_frame_t *frame, xlator_t *this,
                   void *data)
 {
+        clnt_conf_t     *conf     = NULL;
         clnt_args_t     *args     = NULL;
         gfs3_rename_req  req      = {0,};
         int              ret      = 0;
         int              op_errno = ESTALE;
 
-        if (!frame || !this || !prog || !data)
+        if (!frame || !this || !data)
                 goto unwind;
 
         args = data;
@@ -934,9 +2949,11 @@ client3_1_rename (call_frame_t *frame, xlator_t *this, rpc_clnt_prog_t *prog,
         req.oldbname =  (char *)args->oldloc->name;
         req.newpath = (char *)args->newloc->path;
         req.newbname = (char *)args->newloc->name;
+        req.gfs_id = GFS3_OP_RENAME;
+        conf = this->private;
 
-        client_submit_request (this, &req, frame,prog, GFS3_OP_RENAME,
-                               NULL, xdr_from_rename_req);
+        client_submit_request (this, &req, frame, conf->fops, GFS3_OP_RENAME,
+                               client3_1_rename_cbk, NULL, xdr_from_rename_req);
 
         return 0;
 unwind:
@@ -947,16 +2964,17 @@ unwind:
 
 
 int32_t
-client3_1_link (call_frame_t *frame, xlator_t *this, rpc_clnt_prog_t *prog,
+client3_1_link (call_frame_t *frame, xlator_t *this,
                 void *data)
 {
         clnt_local_t  *local    = NULL;
+        clnt_conf_t   *conf     = NULL;
         clnt_args_t   *args     = NULL;
         gfs3_link_req  req      = {0,};
         int            ret      = 0;
         int            op_errno = ESTALE;
 
-        if (!frame || !this || !prog || !data)
+        if (!frame || !this || !data)
                 goto unwind;
 
         args = data;
@@ -994,9 +3012,11 @@ client3_1_link (call_frame_t *frame, xlator_t *this, rpc_clnt_prog_t *prog,
         req.oldpath = (char *)args->oldloc->path;
         req.newpath = (char *)args->newloc->path;
         req.newbname = (char *)args->newloc->name;
+        req.gfs_id = GFS3_OP_LINK;
+        conf = this->private;
 
-        client_submit_request (this, &req, frame,prog, GFS3_OP_LINK,
-                               NULL, xdr_from_link_req);
+        client_submit_request (this, &req, frame, conf->fops, GFS3_OP_LINK,
+                               client3_1_link_cbk, NULL, xdr_from_link_req);
 
         return 0;
 unwind:
@@ -1007,16 +3027,17 @@ unwind:
 
 
 int32_t
-client3_1_mknod (call_frame_t *frame, xlator_t *this, rpc_clnt_prog_t *prog,
+client3_1_mknod (call_frame_t *frame, xlator_t *this,
                  void *data)
 {
         clnt_local_t   *local    = NULL;
+        clnt_conf_t    *conf     = NULL;
         clnt_args_t    *args     = NULL;
         gfs3_mknod_req  req      = {0,};
         int             ret      = 0;
         int             op_errno = ESTALE;
 
-        if (!frame || !this || !prog || !data)
+        if (!frame || !this || !data)
                 goto unwind;
 
         args = data;
@@ -1044,9 +3065,12 @@ client3_1_mknod (call_frame_t *frame, xlator_t *this, rpc_clnt_prog_t *prog,
         req.bname  = (char *)args->loc->name;
         req.mode   = args->mode;
         req.dev    = args->rdev;
+        req.gfs_id = GFS3_OP_MKNOD;
 
-        client_submit_request (this, &req, frame,prog, GFS3_OP_MKNOD,
-                               NULL, xdr_from_mknod_req);
+        conf = this->private;
+
+        client_submit_request (this, &req, frame, conf->fops, GFS3_OP_MKNOD,
+                               client3_1_mknod_cbk, NULL, xdr_from_mknod_req);
 
         return 0;
 unwind:
@@ -1060,16 +3084,17 @@ unwind:
 
 
 int32_t
-client3_1_mkdir (call_frame_t *frame, xlator_t *this, rpc_clnt_prog_t *prog,
+client3_1_mkdir (call_frame_t *frame, xlator_t *this,
                  void *data)
 {
         clnt_local_t   *local    = NULL;
+        clnt_conf_t    *conf     = NULL;
         clnt_args_t    *args     = NULL;
         gfs3_mkdir_req  req      = {0,};
         int             ret      = 0;
         int             op_errno = ESTALE;
 
-        if (!frame || !this || !prog || !data)
+        if (!frame || !this || !data)
                 goto unwind;
 
         args = data;
@@ -1096,9 +3121,12 @@ client3_1_mkdir (call_frame_t *frame, xlator_t *this, rpc_clnt_prog_t *prog,
         req.path  = (char *)args->loc->path;
         req.bname = (char *)args->loc->name;
         req.mode  = args->mode;
+        req.gfs_id = GFS3_OP_MKDIR;
+
+        conf = this->private;
 
-        client_submit_request (this, &req, frame,prog, GFS3_OP_MKDIR,
-                               NULL, xdr_from_mkdir_req);
+        client_submit_request (this, &req, frame, conf->fops, GFS3_OP_MKDIR,
+                               client3_1_mkdir_cbk, NULL, xdr_from_mkdir_req);
 
         return 0;
 unwind:
@@ -1111,16 +3139,17 @@ unwind:
 
 
 int32_t
-client3_1_create (call_frame_t *frame, xlator_t *this, rpc_clnt_prog_t *prog,
+client3_1_create (call_frame_t *frame, xlator_t *this,
                   void *data)
 {
         clnt_local_t    *local    = NULL;
+        clnt_conf_t     *conf     = NULL;
         clnt_args_t     *args     = NULL;
         gfs3_create_req  req      = {0,};
         int              ret      = 0;
         int              op_errno = ESTALE;
 
-        if (!frame || !this || !prog || !data)
+        if (!frame || !this || !data)
                 goto unwind;
 
         args = data;
@@ -1149,9 +3178,12 @@ client3_1_create (call_frame_t *frame, xlator_t *this, rpc_clnt_prog_t *prog,
         req.bname = (char *)args->loc->name;
         req.mode  = args->mode;
         req.flags = gf_flags_from_flags (args->flags);
+        req.gfs_id = GFS3_OP_CREATE;
+
+        conf = this->private;
 
-        client_submit_request (this, &req, frame,prog, GFS3_OP_CREATE,
-                               NULL, xdr_from_create_req);
+        client_submit_request (this, &req, frame, conf->fops, GFS3_OP_CREATE,
+                               client3_1_create_cbk, NULL, xdr_from_create_req);
 
         return 0;
 unwind:
@@ -1165,16 +3197,17 @@ unwind:
 
 
 int32_t
-client3_1_open (call_frame_t *frame, xlator_t *this, rpc_clnt_prog_t *prog,
+client3_1_open (call_frame_t *frame, xlator_t *this,
                 void *data)
 {
         clnt_local_t  *local    = NULL;
+        clnt_conf_t   *conf     = NULL;
         clnt_args_t   *args     = NULL;
         gfs3_open_req  req      = {0,};
         int            ret      = 0;
         int            op_errno = ESTALE;
 
-        if (!frame || !this || !prog || !data)
+        if (!frame || !this || !data)
                 goto unwind;
 
         args = data;
@@ -1201,9 +3234,12 @@ client3_1_open (call_frame_t *frame, xlator_t *this, rpc_clnt_prog_t *prog,
         req.flags = gf_flags_from_flags (args->flags);
         req.wbflags = args->wbflags;
         req.path = (char *)args->loc->path;
+        req.gfs_id = GFS3_OP_OPEN;
 
-        client_submit_request (this, &req, frame,prog, GFS3_OP_OPEN,
-                               NULL, xdr_from_open_req);
+        conf = this->private;
+
+        client_submit_request (this, &req, frame, conf->fops, GFS3_OP_OPEN,
+                               client3_1_open_cbk, NULL, xdr_from_open_req);
 
         return 0;
 unwind:
@@ -1217,7 +3253,7 @@ unwind:
 
 
 int32_t
-client3_1_readv (call_frame_t *frame, xlator_t *this, rpc_clnt_prog_t *prog,
+client3_1_readv (call_frame_t *frame, xlator_t *this,
                  void *data)
 {
         clnt_args_t   *args     = NULL;
@@ -1226,7 +3262,7 @@ client3_1_readv (call_frame_t *frame, xlator_t *this, rpc_clnt_prog_t *prog,
         int            op_errno = ESTALE;
         gfs3_read_req  req      = {0,};
 
-        if (!frame || !this || !prog || !data)
+        if (!frame || !this || !data)
                 goto unwind;
 
         args = data;
@@ -1256,9 +3292,10 @@ client3_1_readv (call_frame_t *frame, xlator_t *this, rpc_clnt_prog_t *prog,
         req.size   = args->size;
         req.offset = args->offset;
         req.fd     = fdctx->remote_fd;
+        req.gfs_id = GFS3_OP_READ;
 
-        client_submit_request (this, &req, frame,prog, GFS3_OP_READ,
-                               NULL, xdr_from_readv_req);
+        client_submit_request (this, &req, frame, conf->fops, GFS3_OP_READ,
+                               client3_1_readv_cbk, NULL, xdr_from_readv_req);
 
         return 0;
 unwind:
@@ -1268,8 +3305,7 @@ unwind:
 
 
 int32_t
-client3_1_writev (call_frame_t *frame, xlator_t *this, rpc_clnt_prog_t *prog,
-                  void *data)
+client3_1_writev (call_frame_t *frame, xlator_t *this, void *data)
 {
         clnt_args_t    *args     = NULL;
         clnt_fd_ctx_t  *fdctx    = NULL;
@@ -1277,7 +3313,7 @@ client3_1_writev (call_frame_t *frame, xlator_t *this, rpc_clnt_prog_t *prog,
         gfs3_write_req  req      = {0,};
         int             op_errno = ESTALE;
 
-        if (!frame || !this || !prog || !data)
+        if (!frame || !this || !data)
                 goto unwind;
 
         args = data;
@@ -1307,10 +3343,10 @@ client3_1_writev (call_frame_t *frame, xlator_t *this, rpc_clnt_prog_t *prog,
         req.size   = args->size;
         req.offset = args->offset;
         req.fd     = fdctx->remote_fd;
+        req.gfs_id = GFS3_OP_WRITE;
 
-        /* TODO: Buffer */
-
-        client_submit_vec_request (this, &req, frame,prog, GFS3_OP_WRITE,
+        client_submit_vec_request (this, &req, frame, conf->fops, GFS3_OP_WRITE,
+                                   client3_1_writev_cbk,
                                    args->vector, args->count,
                                    args->iobref, xdr_from_writev_req);
 
@@ -1323,7 +3359,7 @@ unwind:
 
 
 int32_t
-client3_1_flush (call_frame_t *frame, xlator_t *this, rpc_clnt_prog_t *prog,
+client3_1_flush (call_frame_t *frame, xlator_t *this,
                  void *data)
 {
         clnt_args_t    *args     = NULL;
@@ -1332,7 +3368,7 @@ client3_1_flush (call_frame_t *frame, xlator_t *this, rpc_clnt_prog_t *prog,
         clnt_conf_t    *conf     = NULL;
         int             op_errno = ESTALE;
 
-        if (!frame || !this || !prog || !data)
+        if (!frame || !this || !data)
                 goto unwind;
 
         args = data;
@@ -1360,9 +3396,10 @@ client3_1_flush (call_frame_t *frame, xlator_t *this, rpc_clnt_prog_t *prog,
         }
 
         req.fd = fdctx->remote_fd;
+        req.gfs_id = GFS3_OP_FLUSH;
 
-        client_submit_request (this, &req, frame,prog, GFS3_OP_FLUSH,
-                               NULL, xdr_from_flush_req);
+        client_submit_request (this, &req, frame, conf->fops, GFS3_OP_FLUSH,
+                               client3_1_flush_cbk, NULL, xdr_from_flush_req);
 
         return 0;
 unwind:
@@ -1373,7 +3410,7 @@ unwind:
 
 
 int32_t
-client3_1_fsync (call_frame_t *frame, xlator_t *this, rpc_clnt_prog_t *prog,
+client3_1_fsync (call_frame_t *frame, xlator_t *this,
                  void *data)
 {
         clnt_args_t    *args     = NULL;
@@ -1382,7 +3419,7 @@ client3_1_fsync (call_frame_t *frame, xlator_t *this, rpc_clnt_prog_t *prog,
         clnt_conf_t    *conf     = NULL;
         int             op_errno = 0;
 
-        if (!frame || !this || !prog || !data)
+        if (!frame || !this || !data)
                 goto unwind;
 
         args = data;
@@ -1411,9 +3448,10 @@ client3_1_fsync (call_frame_t *frame, xlator_t *this, rpc_clnt_prog_t *prog,
 
         req.fd   = fdctx->remote_fd;
         req.data = args->flags;
+        req.gfs_id = GFS3_OP_FSYNC;
 
-        client_submit_request (this, &req, frame,prog, GFS3_OP_FSYNC,
-                               NULL, xdr_from_fsync_req);
+        client_submit_request (this, &req, frame, conf->fops, GFS3_OP_FSYNC,
+                               client3_1_fsync_cbk, NULL, xdr_from_fsync_req);
 
         return 0;
 unwind:
@@ -1424,7 +3462,7 @@ unwind:
 
 
 int32_t
-client3_1_fstat (call_frame_t *frame, xlator_t *this, rpc_clnt_prog_t *prog,
+client3_1_fstat (call_frame_t *frame, xlator_t *this,
                  void *data)
 {
         clnt_args_t    *args     = NULL;
@@ -1433,7 +3471,7 @@ client3_1_fstat (call_frame_t *frame, xlator_t *this, rpc_clnt_prog_t *prog,
         clnt_conf_t    *conf     = NULL;
         int             op_errno = ESTALE;
 
-        if (!frame || !this || !prog || !data)
+        if (!frame || !this || !data)
                 goto unwind;
 
         args = data;
@@ -1461,9 +3499,10 @@ client3_1_fstat (call_frame_t *frame, xlator_t *this, rpc_clnt_prog_t *prog,
         }
 
         req.fd = fdctx->remote_fd;
+        req.gfs_id = GFS3_OP_FSTAT;
 
-        client_submit_request (this, &req, frame,prog, GFS3_OP_FSTAT,
-                               NULL, xdr_from_fstat_req);
+        client_submit_request (this, &req, frame, conf->fops, GFS3_OP_FSTAT,
+                               client3_1_fstat_cbk, NULL, xdr_from_fstat_req);
 
         return 0;
 unwind:
@@ -1474,16 +3513,17 @@ unwind:
 
 
 int32_t
-client3_1_opendir (call_frame_t *frame, xlator_t *this, rpc_clnt_prog_t *prog,
+client3_1_opendir (call_frame_t *frame, xlator_t *this,
                    void *data)
 {
-        clnt_local_t     *local = NULL;
-        clnt_args_t      *args = NULL;
-        gfs3_opendir_req  req = {0,};
-        int               ret       = 0;
-        int               op_errno  = ESTALE;
+        clnt_local_t     *local    = NULL;
+        clnt_conf_t      *conf     = NULL;
+        clnt_args_t      *args     = NULL;
+        gfs3_opendir_req  req      = {0,};
+        int               ret      = 0;
+        int               op_errno = ESTALE;
 
-        if (!frame || !this || !prog || !data)
+        if (!frame || !this || !data)
                 goto unwind;
 
         args = data;
@@ -1506,9 +3546,12 @@ client3_1_opendir (call_frame_t *frame, xlator_t *this, rpc_clnt_prog_t *prog,
                         goto unwind;
         }
         req.path = (char *)args->loc->path;
+        req.gfs_id = GFS3_OP_OPENDIR;
+
+        conf = this->private;
 
-        client_submit_request (this, &req, frame,prog, GFS3_OP_OPENDIR,
-                               NULL, xdr_from_opendir_req);
+        client_submit_request (this, &req, frame, conf->fops, GFS3_OP_OPENDIR,
+                               client3_1_opendir_cbk, NULL, xdr_from_opendir_req);
 
         return 0;
 unwind:
@@ -1522,9 +3565,7 @@ unwind:
 
 
 int32_t
-client3_1_fsyncdir (call_frame_t *frame, xlator_t *this, rpc_clnt_prog_t *prog,
-                    void *data)
-
+client3_1_fsyncdir (call_frame_t *frame, xlator_t *this, void *data)
 {
         clnt_args_t       *args     = NULL;
         clnt_fd_ctx_t     *fdctx    = NULL;
@@ -1532,7 +3573,7 @@ client3_1_fsyncdir (call_frame_t *frame, xlator_t *this, rpc_clnt_prog_t *prog,
         int                op_errno = ESTALE;
         gfs3_fsyncdir_req  req      = {0,};
 
-        if (!frame || !this || !prog || !data)
+        if (!frame || !this || !data)
                 goto unwind;
 
         args = data;
@@ -1561,9 +3602,12 @@ client3_1_fsyncdir (call_frame_t *frame, xlator_t *this, rpc_clnt_prog_t *prog,
 
         req.fd   = fdctx->remote_fd;
         req.data = args->flags;
+        req.gfs_id = GFS3_OP_FSYNCDIR;
+
+        conf = this->private;
 
-        client_submit_request (this, &req, frame,prog, GFS3_OP_FSYNCDIR,
-                               NULL, xdr_from_fsyncdir_req);
+        client_submit_request (this, &req, frame, conf->fops, GFS3_OP_FSYNCDIR,
+                               client3_1_fsyncdir_cbk, NULL, xdr_from_fsyncdir_req);
 
         return 0;
 unwind:
@@ -1574,15 +3618,16 @@ unwind:
 
 
 int32_t
-client3_1_statfs (call_frame_t *frame, xlator_t *this, rpc_clnt_prog_t *prog,
+client3_1_statfs (call_frame_t *frame, xlator_t *this,
                   void *data)
 {
+        clnt_conf_t     *conf     = NULL;
         clnt_args_t     *args     = NULL;
         gfs3_statfs_req  req      = {0,};
         int              ret      = 0;
         int              op_errno = ESTALE;
 
-        if (!frame || !this || !prog || !data)
+        if (!frame || !this || !data)
                 goto unwind;
 
         args = data;
@@ -1599,9 +3644,12 @@ client3_1_statfs (call_frame_t *frame, xlator_t *this, rpc_clnt_prog_t *prog,
                 }
         }
         req.path = (char *)args->loc->path;
+        req.gfs_id = GFS3_OP_STATFS;
+
+        conf = this->private;
 
-        client_submit_request (this, &req, frame,prog, GFS3_OP_STATFS,
-                               NULL, xdr_from_statfs_req);
+        client_submit_request (this, &req, frame, conf->fops, GFS3_OP_STATFS,
+                               client3_1_statfs_cbk, NULL, xdr_from_statfs_req);
 
         return 0;
 unwind:
@@ -1612,16 +3660,17 @@ unwind:
 
 
 int32_t
-client3_1_setxattr (call_frame_t *frame, xlator_t *this, rpc_clnt_prog_t *prog,
+client3_1_setxattr (call_frame_t *frame, xlator_t *this,
                     void *data)
 {
+        clnt_conf_t       *conf     = NULL;
         clnt_args_t       *args     = NULL;
         gfs3_setxattr_req  req      = {0,};
         int                ret      = 0;
         size_t             dict_len = 0;
         int                op_errno = ESTALE;
 
-        if (!frame || !this || !prog || !data)
+        if (!frame || !this || !data)
                 goto unwind;
 
         args = data;
@@ -1648,9 +3697,12 @@ client3_1_setxattr (call_frame_t *frame, xlator_t *this, rpc_clnt_prog_t *prog,
         }
         req.flags = args->flags;
         req.path  = (char *)args->loc->path;
+        req.gfs_id = GFS3_OP_SETXATTR;
 
-        client_submit_request (this, &req, frame,prog, GFS3_OP_SETXATTR,
-                               NULL, xdr_from_setxattr_req);
+        conf = this->private;
+
+        client_submit_request (this, &req, frame, conf->fops, GFS3_OP_SETXATTR,
+                               client3_1_setxattr_cbk, NULL, xdr_from_setxattr_req);
 
         if (req.dict.dict_val) {
                 GF_FREE (req.dict.dict_val);
@@ -1668,7 +3720,7 @@ unwind:
 
 
 int32_t
-client3_1_fsetxattr (call_frame_t *frame, xlator_t *this, rpc_clnt_prog_t *prog,
+client3_1_fsetxattr (call_frame_t *frame, xlator_t *this,
                      void *data)
 {
         clnt_args_t        *args     = NULL;
@@ -1679,7 +3731,7 @@ client3_1_fsetxattr (call_frame_t *frame, xlator_t *this, rpc_clnt_prog_t *prog,
         int                 ret      = 0;
         size_t              dict_len = 0;
 
-        if (!frame || !this || !prog || !data)
+        if (!frame || !this || !data)
                 goto unwind;
 
         args = data;
@@ -1709,6 +3761,7 @@ client3_1_fsetxattr (call_frame_t *frame, xlator_t *this, rpc_clnt_prog_t *prog,
         req.fd    = fdctx->remote_fd;
         req.flags = args->flags;
         req.ino   = args->fd->inode->ino;
+        req.gfs_id = GFS3_OP_FSETXATTR;
 
         if (args->dict) {
                 ret = dict_allocate_and_serialize (args->dict,
@@ -1722,8 +3775,8 @@ client3_1_fsetxattr (call_frame_t *frame, xlator_t *this, rpc_clnt_prog_t *prog,
                 req.dict.dict_len = dict_len;
         }
 
-        client_submit_request (this, &req, frame,prog, GFS3_OP_FSETXATTR,
-                               NULL, xdr_from_fsetxattr_req);
+        client_submit_request (this, &req, frame, conf->fops, GFS3_OP_FSETXATTR,
+                               client3_1_fsetxattr_cbk, NULL, xdr_from_fsetxattr_req);
 
         if (req.dict.dict_val) {
                 GF_FREE (req.dict.dict_val);
@@ -1742,7 +3795,7 @@ unwind:
 
 
 int32_t
-client3_1_fgetxattr (call_frame_t *frame, xlator_t *this, rpc_clnt_prog_t *prog,
+client3_1_fgetxattr (call_frame_t *frame, xlator_t *this,
                      void *data)
 {
         clnt_args_t        *args     = NULL;
@@ -1751,7 +3804,7 @@ client3_1_fgetxattr (call_frame_t *frame, xlator_t *this, rpc_clnt_prog_t *prog,
         gfs3_fgetxattr_req  req      = {0,};
         int                 op_errno = ESTALE;
 
-        if (!frame || !this || !prog || !data)
+        if (!frame || !this || !data)
                 goto unwind;
 
         args = data;
@@ -1785,9 +3838,10 @@ client3_1_fgetxattr (call_frame_t *frame, xlator_t *this, rpc_clnt_prog_t *prog,
                 req.name = "";
                 req.namelen = 0;
         }
+        req.gfs_id = GFS3_OP_FGETXATTR;
 
-        client_submit_request (this, &req, frame,prog, GFS3_OP_FGETXATTR,
-                               NULL, xdr_from_fgetxattr_req);
+        client_submit_request (this, &req, frame, conf->fops, GFS3_OP_FGETXATTR,
+                               client3_1_fgetxattr_cbk, NULL, xdr_from_fgetxattr_req);
 
         return 0;
 unwind:
@@ -1798,15 +3852,16 @@ unwind:
 
 
 int32_t
-client3_1_getxattr (call_frame_t *frame, xlator_t *this, rpc_clnt_prog_t *prog,
+client3_1_getxattr (call_frame_t *frame, xlator_t *this,
                     void *data)
 {
+        clnt_conf_t       *conf     = NULL;
         clnt_args_t       *args     = NULL;
         gfs3_getxattr_req  req      = {0,};
         int                ret      = 0;
         int                op_errno = ESTALE;
 
-        if (!frame || !this || !prog || !data)
+        if (!frame || !this || !data)
                 goto unwind;
 
         args = data;
@@ -1827,9 +3882,12 @@ client3_1_getxattr (call_frame_t *frame, xlator_t *this, rpc_clnt_prog_t *prog,
                 req.name = "";
                 req.namelen = 0;
         }
+        req.gfs_id = GFS3_OP_GETXATTR;
+
+        conf = this->private;
 
-        client_submit_request (this, &req, frame,prog, GFS3_OP_GETXATTR,
-                               NULL, xdr_from_getxattr_req);
+        client_submit_request (this, &req, frame, conf->fops, GFS3_OP_GETXATTR,
+                               client3_1_getxattr_cbk, NULL, xdr_from_getxattr_req);
 
         return 0;
 unwind:
@@ -1840,16 +3898,17 @@ unwind:
 
 
 int32_t
-client3_1_xattrop (call_frame_t *frame, xlator_t *this, rpc_clnt_prog_t *prog,
+client3_1_xattrop (call_frame_t *frame, xlator_t *this,
                    void *data)
 {
+        clnt_conf_t      *conf     = NULL;
         clnt_args_t      *args     = NULL;
         gfs3_xattrop_req  req      = {0,};
         int               ret      = 0;
         size_t            dict_len = 0;
         int               op_errno = ESTALE;
 
-        if (!frame || !this || !prog || !data)
+        if (!frame || !this || !data)
                 goto unwind;
 
         args = data;
@@ -1876,9 +3935,12 @@ client3_1_xattrop (call_frame_t *frame, xlator_t *this, rpc_clnt_prog_t *prog,
         }
         req.flags = args->flags;
         req.path  = (char *)args->loc->path;
+        req.gfs_id = GFS3_OP_XATTROP;
+
+        conf = this->private;
 
-        client_submit_request (this, &req, frame,prog, GFS3_OP_XATTROP,
-                               NULL, xdr_from_xattrop_req);
+        client_submit_request (this, &req, frame, conf->fops, GFS3_OP_XATTROP,
+                               client3_1_xattrop_cbk, NULL, xdr_from_xattrop_req);
 
         if (req.dict.dict_val) {
                 GF_FREE (req.dict.dict_val);
@@ -1895,7 +3957,7 @@ unwind:
 
 
 int32_t
-client3_1_fxattrop (call_frame_t *frame, xlator_t *this, rpc_clnt_prog_t *prog,
+client3_1_fxattrop (call_frame_t *frame, xlator_t *this,
                     void *data)
 {
         clnt_args_t       *args     = NULL;
@@ -1906,7 +3968,7 @@ client3_1_fxattrop (call_frame_t *frame, xlator_t *this, rpc_clnt_prog_t *prog,
         int                ret      = 0;
         size_t             dict_len = 0;
 
-        if (!frame || !this || !prog || !data)
+        if (!frame || !this || !data)
                 goto unwind;
 
         args = data;
@@ -1936,6 +3998,7 @@ client3_1_fxattrop (call_frame_t *frame, xlator_t *this, rpc_clnt_prog_t *prog,
         req.fd    = fdctx->remote_fd;
         req.flags = args->flags;
         req.ino   = args->fd->inode->ino;
+        req.gfs_id = GFS3_OP_FXATTROP;
 
         if (args->dict) {
                 ret = dict_allocate_and_serialize (args->dict,
@@ -1949,8 +4012,8 @@ client3_1_fxattrop (call_frame_t *frame, xlator_t *this, rpc_clnt_prog_t *prog,
                 req.dict.dict_len = dict_len;
         }
 
-        client_submit_request (this, &req, frame,prog, GFS3_OP_FXATTROP,
-                               NULL, xdr_from_fxattrop_req);
+        client_submit_request (this, &req, frame, conf->fops, GFS3_OP_FXATTROP,
+                               client3_1_fxattrop_cbk, NULL, xdr_from_fxattrop_req);
         if (req.dict.dict_val) {
                 GF_FREE (req.dict.dict_val);
         }
@@ -1967,15 +4030,16 @@ unwind:
 
 
 int32_t
-client3_1_removexattr (call_frame_t *frame, xlator_t *this, rpc_clnt_prog_t *prog,
+client3_1_removexattr (call_frame_t *frame, xlator_t *this,
                        void *data)
 {
+        clnt_conf_t          *conf     = NULL;
         clnt_args_t          *args     = NULL;
         gfs3_removexattr_req  req      = {0,};
         int                   ret      = 0;
         int                   op_errno = ESTALE;
 
-        if (!frame || !this || !prog || !data)
+        if (!frame || !this || !data)
                 goto unwind;
 
         args = data;
@@ -1990,9 +4054,12 @@ client3_1_removexattr (call_frame_t *frame, xlator_t *this, rpc_clnt_prog_t *pro
         }
         req.path = (char *)args->loc->path;
         req.name = (char *)args->name;
+        req.gfs_id = GFS3_OP_REMOVEXATTR;
 
-        client_submit_request (this, &req, frame,prog, GFS3_OP_REMOVEXATTR,
-                               NULL, xdr_from_removexattr_req);
+        conf = this->private;
+
+        client_submit_request (this, &req, frame, conf->fops, GFS3_OP_REMOVEXATTR,
+                               client3_1_removexattr_cbk, NULL, xdr_from_removexattr_req);
 
         return 0;
 unwind:
@@ -2002,7 +4069,7 @@ unwind:
 
 
 int32_t
-client3_1_lk (call_frame_t *frame, xlator_t *this, rpc_clnt_prog_t *prog,
+client3_1_lk (call_frame_t *frame, xlator_t *this,
               void *data)
 {
         clnt_args_t   *args     = NULL;
@@ -2013,7 +4080,7 @@ client3_1_lk (call_frame_t *frame, xlator_t *this, rpc_clnt_prog_t *prog,
         clnt_conf_t   *conf     = NULL;
         int            op_errno = ESTALE;
 
-        if (!frame || !this || !prog || !data)
+        if (!frame || !this || !data)
                 goto unwind;
 
         args = data;
@@ -2068,9 +4135,10 @@ client3_1_lk (call_frame_t *frame, xlator_t *this, rpc_clnt_prog_t *prog,
         req.cmd   = gf_cmd;
         req.type  = gf_type;
         gf_flock_from_flock (&req.flock, args->flock);
+        req.gfs_id = GFS3_OP_LK;
 
-        client_submit_request (this, &req, frame,prog, GFS3_OP_LK,
-                               NULL, xdr_from_lk_req);
+        client_submit_request (this, &req, frame, conf->fops, GFS3_OP_LK,
+                               client3_1_lk_cbk, NULL, xdr_from_lk_req);
 
         return 0;
 unwind:
@@ -2080,9 +4148,10 @@ unwind:
 
 
 int32_t
-client3_1_inodelk (call_frame_t *frame, xlator_t *this, rpc_clnt_prog_t *prog,
+client3_1_inodelk (call_frame_t *frame, xlator_t *this,
                    void *data)
 {
+        clnt_conf_t      *conf     = NULL;
         clnt_args_t      *args    = NULL;
         gfs3_inodelk_req  req     = {0,};
         int               ret     = 0;
@@ -2090,7 +4159,7 @@ client3_1_inodelk (call_frame_t *frame, xlator_t *this, rpc_clnt_prog_t *prog,
         int32_t           gf_type = 0;
         int               op_errno = ESTALE;
 
-        if (!frame || !this || !prog || !data)
+        if (!frame || !this || !data)
                 goto unwind;
 
         args = data;
@@ -2133,9 +4202,12 @@ client3_1_inodelk (call_frame_t *frame, xlator_t *this, rpc_clnt_prog_t *prog,
         req.cmd    = gf_cmd;
         req.type   = gf_type;
         gf_flock_from_flock (&req.flock, args->flock);
+        req.gfs_id = GFS3_OP_INODELK;
+
+        conf = this->private;
 
-        client_submit_request (this, &req, frame, prog, GFS3_OP_INODELK,
-                               NULL, xdr_from_inodelk_req);
+        client_submit_request (this, &req, frame, conf->fops, GFS3_OP_INODELK,
+                               client3_1_inodelk_cbk, NULL, xdr_from_inodelk_req);
 
         return 0;
 unwind:
@@ -2146,7 +4218,7 @@ unwind:
 
 
 int32_t
-client3_1_finodelk (call_frame_t *frame, xlator_t *this, rpc_clnt_prog_t *prog,
+client3_1_finodelk (call_frame_t *frame, xlator_t *this,
                     void *data)
 {
         clnt_args_t       *args     = NULL;
@@ -2157,7 +4229,7 @@ client3_1_finodelk (call_frame_t *frame, xlator_t *this, rpc_clnt_prog_t *prog,
         clnt_conf_t       *conf     = NULL;
         int                op_errno = ESTALE;
 
-        if (!frame || !this || !prog || !data)
+        if (!frame || !this || !data)
                 goto unwind;
 
         args = data;
@@ -2213,9 +4285,10 @@ client3_1_finodelk (call_frame_t *frame, xlator_t *this, rpc_clnt_prog_t *prog,
         req.cmd   = gf_cmd;
         req.type  = gf_type;
         gf_flock_from_flock (&req.flock, args->flock);
+        req.gfs_id = GFS3_OP_FINODELK;
 
-        client_submit_request (this, &req, frame,prog, GFS3_OP_FINODELK,
-                               NULL, xdr_from_finodelk_req);
+        client_submit_request (this, &req, frame, conf->fops, GFS3_OP_FINODELK,
+                               client3_1_finodelk_cbk, NULL, xdr_from_finodelk_req);
 
         return 0;
 unwind:
@@ -2225,15 +4298,16 @@ unwind:
 
 
 int32_t
-client3_1_entrylk (call_frame_t *frame, xlator_t *this, rpc_clnt_prog_t *prog,
+client3_1_entrylk (call_frame_t *frame, xlator_t *this,
                    void *data)
 {
+        clnt_conf_t      *conf     = NULL;
         clnt_args_t      *args     = NULL;
         gfs3_entrylk_req  req      = {0,};
         int               ret      = 0;
         int               op_errno = ESTALE;
 
-        if (!frame || !this || !prog || !data)
+        if (!frame || !this || !data)
                 goto unwind;
 
         args = data;
@@ -2255,9 +4329,12 @@ client3_1_entrylk (call_frame_t *frame, xlator_t *this, rpc_clnt_prog_t *prog,
                 req.name = (char *)args->basename;
                 req.namelen = 1;
         }
+        req.gfs_id = GFS3_OP_ENTRYLK;
+
+        conf = this->private;
 
-        client_submit_request (this, &req, frame,prog, GFS3_OP_ENTRYLK,
-                               NULL, xdr_from_entrylk_req);
+        client_submit_request (this, &req, frame, conf->fops, GFS3_OP_ENTRYLK,
+                               client3_1_entrylk_cbk, NULL, xdr_from_entrylk_req);
 
         return 0;
 unwind:
@@ -2268,7 +4345,7 @@ unwind:
 
 
 int32_t
-client3_1_fentrylk (call_frame_t *frame, xlator_t *this, rpc_clnt_prog_t *prog,
+client3_1_fentrylk (call_frame_t *frame, xlator_t *this,
                     void *data)
 {
         clnt_args_t       *args     = NULL;
@@ -2277,7 +4354,7 @@ client3_1_fentrylk (call_frame_t *frame, xlator_t *this, rpc_clnt_prog_t *prog,
         clnt_conf_t       *conf     = NULL;
         int                op_errno = ESTALE;
 
-        if (!frame || !this || !prog || !data)
+        if (!frame || !this || !data)
                 goto unwind;
 
         args = data;
@@ -2313,9 +4390,10 @@ client3_1_fentrylk (call_frame_t *frame, xlator_t *this, rpc_clnt_prog_t *prog,
                 req.name = (char *)args->basename;
                 req.namelen = 1;
         }
+        req.gfs_id = GFS3_OP_FENTRYLK;
 
-        client_submit_request (this, &req, frame,prog, GFS3_OP_FENTRYLK,
-                               NULL, xdr_from_fentrylk_req);
+        client_submit_request (this, &req, frame, conf->fops, GFS3_OP_FENTRYLK,
+                               client3_1_fentrylk_cbk, NULL, xdr_from_fentrylk_req);
 
         return 0;
 unwind:
@@ -2327,15 +4405,16 @@ unwind:
 
 
 int32_t
-client3_1_checksum (call_frame_t *frame, xlator_t *this, rpc_clnt_prog_t *prog,
+client3_1_checksum (call_frame_t *frame, xlator_t *this,
                     void *data)
 {
+        clnt_conf_t       *conf     = NULL;
         clnt_args_t       *args     = NULL;
         gfs3_checksum_req  req      = {0,};
         int                ret      = 0;
         int                op_errno = ESTALE;
 
-        if (!frame || !this || !prog || !data)
+        if (!frame || !this || !data)
                 goto unwind;
 
         args = data;
@@ -2350,9 +4429,12 @@ client3_1_checksum (call_frame_t *frame, xlator_t *this, rpc_clnt_prog_t *prog,
         }
         req.path = (char *)args->loc->path;
         req.flag = args->flags;
+        req.gfs_id = GFS3_OP_CHECKSUM;
+
+        conf = this->private;
 
-        client_submit_request (this, &req, frame,prog, GFS3_OP_CHECKSUM,
-                               NULL, xdr_from_checksum_req);
+        client_submit_request (this, &req, frame, conf->fops, GFS3_OP_CHECKSUM,
+                               client3_1_checksum_cbk, NULL, xdr_from_checksum_req);
 
         return 0;
 unwind:
@@ -2363,7 +4445,7 @@ unwind:
 
 
 int32_t
-client3_1_rchecksum (call_frame_t *frame, xlator_t *this, rpc_clnt_prog_t *prog,
+client3_1_rchecksum (call_frame_t *frame, xlator_t *this,
                      void *data)
 {
         clnt_args_t        *args     = NULL;
@@ -2372,7 +4454,7 @@ client3_1_rchecksum (call_frame_t *frame, xlator_t *this, rpc_clnt_prog_t *prog,
         gfs3_rchecksum_req  req      = {0,};
         int                 op_errno = ESTALE;
 
-        if (!frame || !this || !prog || !data)
+        if (!frame || !this || !data)
                 goto unwind;
 
         args = data;
@@ -2402,9 +4484,10 @@ client3_1_rchecksum (call_frame_t *frame, xlator_t *this, rpc_clnt_prog_t *prog,
         req.len    = args->len;
         req.offset = args->offset;
         req.fd     = fdctx->remote_fd;
+        req.gfs_id = GFS3_OP_RCHECKSUM;
 
-        client_submit_request (this, &req, frame,prog, GFS3_OP_RCHECKSUM,
-                               NULL, xdr_from_rchecksum_req);
+        client_submit_request (this, &req, frame, conf->fops, GFS3_OP_RCHECKSUM,
+                               client3_1_rchecksum_cbk, NULL, xdr_from_rchecksum_req);
 
         return 0;
 unwind:
@@ -2415,7 +4498,7 @@ unwind:
 
 
 int32_t
-client3_1_readdir (call_frame_t *frame, xlator_t *this, rpc_clnt_prog_t *prog,
+client3_1_readdir (call_frame_t *frame, xlator_t *this,
                    void *data)
 {
         clnt_args_t      *args     = NULL;
@@ -2424,7 +4507,7 @@ client3_1_readdir (call_frame_t *frame, xlator_t *this, rpc_clnt_prog_t *prog,
         gfs3_readdir_req  req      = {0,};
         int               op_errno = ESTALE;
 
-        if (!frame || !this || !prog || !data)
+        if (!frame || !this || !data)
                 goto unwind;
 
         args = data;
@@ -2454,9 +4537,10 @@ client3_1_readdir (call_frame_t *frame, xlator_t *this, rpc_clnt_prog_t *prog,
         req.size = args->size;
         req.offset = args->offset;
         req.fd = fdctx->remote_fd;
+        req.gfs_id = GFS3_OP_READDIR;
 
-        client_submit_request (this, &req, frame,prog, GFS3_OP_READDIR,
-                               NULL, xdr_from_readdir_req);
+        client_submit_request (this, &req, frame, conf->fops, GFS3_OP_READDIR,
+                               client3_1_readdir_cbk, NULL, xdr_from_readdir_req);
 
         return 0;
 unwind:
@@ -2466,7 +4550,7 @@ unwind:
 
 
 int32_t
-client3_1_readdirp (call_frame_t *frame, xlator_t *this, rpc_clnt_prog_t *prog,
+client3_1_readdirp (call_frame_t *frame, xlator_t *this,
                     void *data)
 {
         clnt_args_t       *args     = NULL;
@@ -2475,7 +4559,7 @@ client3_1_readdirp (call_frame_t *frame, xlator_t *this, rpc_clnt_prog_t *prog,
         clnt_conf_t       *conf     = NULL;
         int                op_errno = ESTALE;
 
-        if (!frame || !this || !prog || !data)
+        if (!frame || !this || !data)
                 goto unwind;
 
         args = data;
@@ -2505,9 +4589,10 @@ client3_1_readdirp (call_frame_t *frame, xlator_t *this, rpc_clnt_prog_t *prog,
         req.size = args->size;
         req.offset = args->offset;
         req.fd = fdctx->remote_fd;
+        req.gfs_id = GFS3_OP_READDIRP;
 
-        client_submit_request (this, &req, frame,prog, GFS3_OP_READDIRP,
-                               NULL, xdr_from_readdirp_req);
+        client_submit_request (this, &req, frame, conf->fops, GFS3_OP_READDIRP,
+                               client3_1_readdirp_cbk, NULL, xdr_from_readdirp_req);
 
         return 0;
 unwind:
@@ -2517,15 +4602,16 @@ unwind:
 
 
 int32_t
-client3_1_setattr (call_frame_t *frame, xlator_t *this, rpc_clnt_prog_t *prog,
+client3_1_setattr (call_frame_t *frame, xlator_t *this,
                    void *data)
 {
+        clnt_conf_t      *conf     = NULL;
         clnt_args_t      *args     = NULL;
         gfs3_setattr_req  req      = {0,};
         int               ret      = 0;
         int               op_errno = ESTALE;
 
-        if (!frame || !this || !prog || !data)
+        if (!frame || !this || !data)
                 goto unwind;
 
         args = data;
@@ -2541,9 +4627,12 @@ client3_1_setattr (call_frame_t *frame, xlator_t *this, rpc_clnt_prog_t *prog,
         req.path = (char *)args->loc->path;
         req.valid = args->valid;
         gf_stat_from_iatt (&req.stbuf, args->stbuf);
+        req.gfs_id = GFS3_OP_SETATTR;
 
-        client_submit_request (this, &req, frame,prog, GFS3_OP_SETATTR,
-                               NULL, xdr_from_setattr_req);
+        conf = this->private;
+
+        client_submit_request (this, &req, frame, conf->fops, GFS3_OP_SETATTR,
+                               client3_1_setattr_cbk, NULL, xdr_from_setattr_req);
 
         return 0;
 unwind:
@@ -2552,8 +4641,7 @@ unwind:
 }
 
 int32_t
-client3_1_fsetattr (call_frame_t *frame, xlator_t *this, rpc_clnt_prog_t *prog,
-                    void *data)
+client3_1_fsetattr (call_frame_t *frame, xlator_t *this, void *data)
 {
         clnt_args_t       *args     = NULL;
         clnt_fd_ctx_t     *fdctx    = NULL;
@@ -2561,7 +4649,7 @@ client3_1_fsetattr (call_frame_t *frame, xlator_t *this, rpc_clnt_prog_t *prog,
         gfs3_fsetattr_req  req      = {0,};
         int                op_errno = ESTALE;
 
-        if (!frame || !this || !prog || !data)
+        if (!frame || !this || !data)
                 goto unwind;
 
         args = data;
@@ -2591,9 +4679,10 @@ client3_1_fsetattr (call_frame_t *frame, xlator_t *this, rpc_clnt_prog_t *prog,
         req.fd = fdctx->remote_fd;
         req.valid = args->valid;
         gf_stat_from_iatt (&req.stbuf, args->stbuf);
+        req.gfs_id = GFS3_OP_FSETATTR;
 
-        client_submit_request (this, &req, frame,prog, GFS3_OP_FSETATTR,
-                               NULL, xdr_from_fsetattr_req);
+        client_submit_request (this, &req, frame, conf->fops, GFS3_OP_FSETATTR,
+                               client3_1_fsetattr_cbk, NULL, xdr_from_fsetattr_req);
 
         return 0;
 unwind:
@@ -2601,2062 +4690,118 @@ unwind:
         return 0;
 }
 
-/* CBK */
-int
-client3_1_release_cbk (struct rpc_req *req, struct iovec *iov, int count,
-                       void *myframe)
-{
-        call_frame_t   *frame = NULL;
-
-        frame = myframe;
-        STACK_DESTROY (frame->root);
-        return 0;
-}
-int
-client3_1_releasedir_cbk (struct rpc_req *req, struct iovec *iov, int count,
-                          void *myframe)
-{
-        call_frame_t   *frame = NULL;
-
-        frame = myframe;
-        STACK_DESTROY (frame->root);
-        return 0;
-}
-
-
-int
-client3_1_symlink_cbk (struct rpc_req *req, struct iovec *iov, int count,
-                       void *myframe)
-{
-        call_frame_t     *frame      = NULL;
-        gfs3_symlink_rsp  rsp        = {0,};
-        struct iatt       stbuf      = {0,};
-        struct iatt       preparent  = {0,};
-        struct iatt       postparent = {0,};
-        int               ret        = 0;
-        clnt_local_t     *local      = NULL;
-        inode_t          *inode      = NULL;
-
-        frame = myframe;
-
-        local = frame->local;
-        frame->local = NULL;
-        inode = local->loc.inode;
-
-        if (-1 == req->rpc_status) {
-                rsp.op_ret   = -1;
-                rsp.op_errno = ENOTCONN;
-                goto out;
-        }
-        ret = xdr_to_symlink_rsp (*iov, &rsp);
-        if (ret < 0) {
-                gf_log ("", GF_LOG_ERROR, "error");
-                rsp.op_ret   = -1;
-                rsp.op_errno = EINVAL;
-                goto out;
-        }
-
-        if (-1 != rsp.op_ret) {
-                gf_stat_to_iatt (&rsp.stat, &stbuf);
-
-                ret = inode_ctx_put2 (inode, frame->this,
-                                      stbuf.ia_ino, stbuf.ia_gen);
-                if (ret < 0) {
-                        gf_log (frame->this->name, GF_LOG_DEBUG,
-                                "SYMLINK %"PRId64"/%s (%s): failed to set "
-                                "remote inode number to inode ctx",
-                                local->loc.parent->ino, local->loc.name,
-                                local->loc.path);
-                }
-
-                gf_stat_to_iatt (&rsp.preparent, &preparent);
-                gf_stat_to_iatt (&rsp.postparent, &postparent);
-        }
-
-out:
-        frame->local = NULL;
-        STACK_UNWIND_STRICT (symlink, frame, rsp.op_ret,
-                             gf_error_to_errno (rsp.op_errno), inode, &stbuf,
-                             &preparent, &postparent);
-
-        if (local)
-                client_local_wipe (local);
-
-        return 0;
-}
-
-
-int
-client3_1_mknod_cbk (struct rpc_req *req, struct iovec *iov, int count,
-                     void *myframe)
-{
-        call_frame_t     *frame      = NULL;
-        gfs3_mknod_rsp  rsp        = {0,};
-        struct iatt       stbuf      = {0,};
-        struct iatt       preparent  = {0,};
-        struct iatt       postparent = {0,};
-        int               ret        = 0;
-        clnt_local_t     *local      = NULL;
-        inode_t          *inode      = NULL;
-
-        frame = myframe;
-
-        local = frame->local;
-        frame->local = NULL;
-        inode = local->loc.inode;
-
-        if (-1 == req->rpc_status) {
-                rsp.op_ret   = -1;
-                rsp.op_errno = ENOTCONN;
-                goto out;
-        }
-        ret = xdr_to_mknod_rsp (*iov, &rsp);
-        if (ret < 0) {
-                gf_log ("", GF_LOG_ERROR, "error");
-                rsp.op_ret   = -1;
-                rsp.op_errno = EINVAL;
-                goto out;
-        }
-
-        if (-1 != rsp.op_ret) {
-                gf_stat_to_iatt (&rsp.stat, &stbuf);
-
-                ret = inode_ctx_put2 (inode, frame->this,
-                                      stbuf.ia_ino, stbuf.ia_gen);
-                if (ret < 0) {
-                        gf_log (frame->this->name, GF_LOG_DEBUG,
-                                "MKNOD %"PRId64"/%s (%s): failed to set "
-                                "remote inode number to inode ctx",
-                                local->loc.parent->ino, local->loc.name,
-                                local->loc.path);
-                }
-
-                gf_stat_to_iatt (&rsp.preparent, &preparent);
-                gf_stat_to_iatt (&rsp.postparent, &postparent);
-        }
-
-out:
-        frame->local = NULL;
-        STACK_UNWIND_STRICT (mknod, frame, rsp.op_ret,
-                             gf_error_to_errno (rsp.op_errno), inode,
-                             &stbuf, &preparent, &postparent);
-
-        if (local)
-                client_local_wipe (local);
-
-        return 0;
-}
-
-int
-client3_1_mkdir_cbk (struct rpc_req *req, struct iovec *iov, int count,
-                     void *myframe)
-{
-        call_frame_t     *frame      = NULL;
-        gfs3_mkdir_rsp  rsp        = {0,};
-        struct iatt       stbuf      = {0,};
-        struct iatt       preparent  = {0,};
-        struct iatt       postparent = {0,};
-        int               ret        = 0;
-        clnt_local_t     *local      = NULL;
-        inode_t          *inode      = NULL;
-
-        frame = myframe;
-
-        local = frame->local;
-        frame->local = NULL;
-        inode = local->loc.inode;
-
-        if (-1 == req->rpc_status) {
-                rsp.op_ret   = -1;
-                rsp.op_errno = ENOTCONN;
-                goto out;
-        }
-        ret = xdr_to_mkdir_rsp (*iov, &rsp);
-        if (ret < 0) {
-                gf_log ("", GF_LOG_ERROR, "error");
-                rsp.op_ret   = -1;
-                rsp.op_errno = EINVAL;
-                goto out;
-        }
-
-        if (-1 != rsp.op_ret) {
-                gf_stat_to_iatt (&rsp.stat, &stbuf);
-
-                ret = inode_ctx_put2 (inode, frame->this,
-                                      stbuf.ia_ino, stbuf.ia_gen);
-                if (ret < 0) {
-                        gf_log (frame->this->name, GF_LOG_DEBUG,
-                                "MKDIR %"PRId64"/%s (%s): failed to set "
-                                "remote inode number to inode ctx",
-                                local->loc.parent->ino, local->loc.name,
-                                local->loc.path);
-                }
-
-                gf_stat_to_iatt (&rsp.preparent, &preparent);
-                gf_stat_to_iatt (&rsp.postparent, &postparent);
-        }
-
-out:
-        frame->local = NULL;
-        STACK_UNWIND_STRICT (mkdir, frame, rsp.op_ret,
-                             gf_error_to_errno (rsp.op_errno), inode,
-                             &stbuf, &preparent, &postparent);
-
-        if (local)
-                client_local_wipe (local);
-
-        return 0;
-}
-
-int
-client3_1_open_cbk (struct rpc_req *req, struct iovec *iov, int count,
-                    void *myframe)
-{
-        clnt_local_t  *local = NULL;
-        clnt_conf_t   *conf  = NULL;
-        clnt_fd_ctx_t *fdctx = NULL;
-        call_frame_t  *frame = NULL;
-        fd_t          *fd    = NULL;
-        ino_t          ino   = 0;
-        uint64_t       gen   = 0;
-        int            ret   = 0;
-        gfs3_open_rsp  rsp   = {0,};
-
-        frame = myframe;
-        local = frame->local;
-
-        if (local->op) {
-                local->op (req, iov, 1, myframe);
-                return 0;
-        }
-
-        frame->local = NULL;
-        conf  = frame->this->private;
-        fd    = local->fd;
-
-        if (-1 == req->rpc_status) {
-                rsp.op_ret   = -1;
-                rsp.op_errno = ENOTCONN;
-                goto out;
-        }
-        ret = xdr_to_open_rsp (*iov, &rsp);
-        if (ret < 0) {
-                gf_log ("", GF_LOG_ERROR, "error");
-                rsp.op_ret   = -1;
-                rsp.op_errno = EINVAL;
-                goto out;
-        }
-
-        if (-1 != rsp.op_ret) {
-                fdctx = GF_CALLOC (1, sizeof (*fdctx),
-                                   gf_client_mt_clnt_fdctx_t);
-                if (!fdctx) {
-                        rsp.op_ret = -1;
-                        rsp.op_errno = ENOMEM;
-                        goto out;
-                }
-
-                inode_ctx_get2 (fd->inode, frame->this, &ino, &gen);
-
-                fdctx->remote_fd = rsp.fd;
-                fdctx->inode     = inode_ref (fd->inode);
-                fdctx->ino       = ino;
-                fdctx->gen       = gen;
-                fdctx->flags     = local->flags;
-                fdctx->wbflags   = local->wbflags;
-
-                INIT_LIST_HEAD (&fdctx->sfd_pos);
-
-                this_fd_set_ctx (fd, frame->this, &local->loc, fdctx);
-
-                pthread_mutex_lock (&conf->lock);
-                {
-                        list_add_tail (&fdctx->sfd_pos, &conf->saved_fds);
-                }
-                pthread_mutex_unlock (&conf->lock);
-        }
-
-out:
-        frame->local = NULL;
-        STACK_UNWIND_STRICT (open, frame, rsp.op_ret,
-                             gf_error_to_errno (rsp.op_errno), fd);
-
-        client_local_wipe (local);
-
-        return 0;
-}
-
-
-int
-client3_1_stat_cbk (struct rpc_req *req, struct iovec *iov, int count,
-                    void *myframe)
-{
-        gfs3_stat_rsp rsp = {0,};
-        call_frame_t   *frame = NULL;
-        struct iatt  iatt = {0,};
-        int ret = 0;
-
-        frame = myframe;
-
-        if (-1 == req->rpc_status) {
-                rsp.op_ret   = -1;
-                rsp.op_errno = ENOTCONN;
-                goto out;
-        }
-        ret = xdr_to_stat_rsp (*iov, &rsp);
-        if (ret < 0) {
-                gf_log ("", GF_LOG_ERROR, "error");
-                rsp.op_ret   = -1;
-                rsp.op_errno = EINVAL;
-                goto out;
-        }
-
-        if (-1 != rsp.op_ret) {
-                gf_stat_to_iatt (&rsp.stat, &iatt);
-        }
-
-out:
-        STACK_UNWIND_STRICT (stat, frame, rsp.op_ret,
-                             gf_error_to_errno (rsp.op_errno), &iatt);
-
-        return 0;
-}
-
-int
-client3_1_readlink_cbk (struct rpc_req *req, struct iovec *iov, int count,
-                        void *myframe)
-{
-        gfs3_readlink_rsp rsp = {0,};
-        call_frame_t   *frame = NULL;
-        struct iatt  iatt = {0,};
-        int ret = 0;
-
-        frame = myframe;
-
-        if (-1 == req->rpc_status) {
-                rsp.op_ret   = -1;
-                rsp.op_errno = ENOTCONN;
-                goto out;
-        }
-        ret = xdr_to_readlink_rsp (*iov, &rsp);
-        if (ret < 0) {
-                gf_log ("", GF_LOG_ERROR, "error");
-                rsp.op_ret   = -1;
-                rsp.op_errno = EINVAL;
-                goto out;
-        }
-
-        if (-1 != rsp.op_ret) {
-                gf_stat_to_iatt (&rsp.buf, &iatt);
-        }
-
-out:
-        STACK_UNWIND_STRICT (readlink, frame, rsp.op_ret,
-                             gf_error_to_errno (rsp.op_errno), rsp.path, &iatt);
-
-        /* This is allocated by the libc while decoding RPC msg */
-        /* Hence no 'GF_FREE', but just 'free' */
-        if (rsp.path)
-                free (rsp.path);
-
-        return 0;
-}
-
-int
-client3_1_unlink_cbk (struct rpc_req *req, struct iovec *iov, int count,
-                      void *myframe)
-{
-        call_frame_t    *frame      = NULL;
-        gfs3_unlink_rsp  rsp        = {0,};
-        struct iatt      preparent  = {0,};
-        struct iatt      postparent = {0,};
-        int              ret        = 0;
-
-        frame = myframe;
-
-        if (-1 == req->rpc_status) {
-                rsp.op_ret   = -1;
-                rsp.op_errno = ENOTCONN;
-                goto out;
-        }
-        ret = xdr_to_unlink_rsp (*iov, &rsp);
-        if (ret < 0) {
-                gf_log ("", GF_LOG_ERROR, "error");
-                rsp.op_ret   = -1;
-                rsp.op_errno = EINVAL;
-                goto out;
-        }
-
-        if (-1 != rsp.op_ret) {
-                gf_stat_to_iatt (&rsp.preparent, &preparent);
-                gf_stat_to_iatt (&rsp.postparent, &postparent);
-        }
-
-out:
-        STACK_UNWIND_STRICT (unlink, frame, rsp.op_ret,
-                             gf_error_to_errno (rsp.op_errno), &preparent,
-                             &postparent);
-
-        return 0;
-}
-
-int
-client3_1_rmdir_cbk (struct rpc_req *req, struct iovec *iov, int count,
-                     void *myframe)
-{
-        gfs3_rmdir_rsp rsp = {0,};
-        call_frame_t   *frame = NULL;
-        struct iatt  preparent  = {0,};
-        struct iatt  postparent = {0,};
-        int ret = 0;
-
-        frame = myframe;
-
-        if (-1 == req->rpc_status) {
-                rsp.op_ret   = -1;
-                rsp.op_errno = ENOTCONN;
-                goto out;
-        }
-        ret = xdr_to_rmdir_rsp (*iov, &rsp);
-        if (ret < 0) {
-                gf_log ("", GF_LOG_ERROR, "error");
-                rsp.op_ret   = -1;
-                rsp.op_errno = EINVAL;
-                goto out;
-        }
-
-        if (-1 != rsp.op_ret) {
-                gf_stat_to_iatt (&rsp.preparent, &preparent);
-                gf_stat_to_iatt (&rsp.postparent, &postparent);
-        }
-
-out:
-        STACK_UNWIND_STRICT (rmdir, frame, rsp.op_ret,
-                             gf_error_to_errno (rsp.op_errno), &preparent,
-                             &postparent);
-
-        return 0;
-}
-
 
-int
-client3_1_truncate_cbk (struct rpc_req *req, struct iovec *iov, int count,
-                        void *myframe)
-{
-        gfs3_truncate_rsp rsp = {0,};
-        call_frame_t   *frame = NULL;
-        struct iatt  prestat  = {0,};
-        struct iatt  poststat = {0,};
-        int ret = 0;
-
-        frame = myframe;
-
-        if (-1 == req->rpc_status) {
-                rsp.op_ret   = -1;
-                rsp.op_errno = ENOTCONN;
-                goto out;
-        }
-        ret = xdr_to_truncate_rsp (*iov, &rsp);
-        if (ret < 0) {
-                gf_log ("", GF_LOG_ERROR, "error");
-                rsp.op_ret   = -1;
-                rsp.op_errno = EINVAL;
-                goto out;
-        }
-
-        if (-1 != rsp.op_ret) {
-                gf_stat_to_iatt (&rsp.prestat, &prestat);
-                gf_stat_to_iatt (&rsp.poststat, &poststat);
-        }
-
-out:
-        STACK_UNWIND_STRICT (truncate, frame, rsp.op_ret,
-                             gf_error_to_errno (rsp.op_errno), &prestat,
-                             &poststat);
-
-        return 0;
-}
-
-
-int
-client3_1_statfs_cbk (struct rpc_req *req, struct iovec *iov, int count,
-                      void *myframe)
-{
-        gfs3_statfs_rsp rsp = {0,};
-        call_frame_t   *frame = NULL;
-        struct statvfs  statfs = {0,};
-        int ret = 0;
-
-        frame = myframe;
-
-        if (-1 == req->rpc_status) {
-                rsp.op_ret   = -1;
-                rsp.op_errno = ENOTCONN;
-                goto out;
-        }
-        ret = xdr_to_statfs_rsp (*iov, &rsp);
-        if (ret < 0) {
-                gf_log ("", GF_LOG_ERROR, "error");
-                rsp.op_ret   = -1;
-                rsp.op_errno = EINVAL;
-                goto out;
-        }
-
-        if (-1 != rsp.op_ret) {
-                gf_statfs_to_statfs (&rsp.statfs, &statfs);
-        }
-
-out:
-        STACK_UNWIND_STRICT (statfs, frame, rsp.op_ret,
-                             gf_error_to_errno (rsp.op_errno), &statfs);
-
-        return 0;
-}
-
-
-int
-client3_1_writev_cbk (struct rpc_req *req, struct iovec *iov, int count,
-                      void *myframe)
-{
-        gfs3_write_rsp rsp = {0,};
-        call_frame_t   *frame = NULL;
-        struct iatt  prestat  = {0,};
-        struct iatt  poststat = {0,};
-        int ret = 0;
-
-        frame = myframe;
-
-        if (-1 == req->rpc_status) {
-                rsp.op_ret   = -1;
-                rsp.op_errno = ENOTCONN;
-                goto out;
-        }
-
-        ret = xdr_to_truncate_rsp (*iov, &rsp);
-        if (ret < 0) {
-                gf_log ("", GF_LOG_ERROR, "error");
-                rsp.op_ret   = -1;
-                rsp.op_errno = EINVAL;
-                goto out;
-        }
-
-        if (-1 != rsp.op_ret) {
-                gf_stat_to_iatt (&rsp.prestat, &prestat);
-                gf_stat_to_iatt (&rsp.poststat, &poststat);
-        }
-
-out:
-        STACK_UNWIND_STRICT (writev, frame, rsp.op_ret,
-                             gf_error_to_errno (rsp.op_errno), &prestat,
-                             &poststat);
-
-        return 0;
-}
-
-int
-client3_1_flush_cbk (struct rpc_req *req, struct iovec *iov, int count,
-                     void *myframe)
-{
-        call_frame_t    *frame      = NULL;
-        gf_common_rsp    rsp        = {0,};
-        int              ret        = 0;
-
-        frame = myframe;
-
-        if (-1 == req->rpc_status) {
-                rsp.op_ret   = -1;
-                rsp.op_errno = ENOTCONN;
-                goto out;
-        }
-        ret = xdr_to_common_rsp (*iov, &rsp);
-        if (ret < 0) {
-                gf_log ("", GF_LOG_ERROR, "error");
-                rsp.op_ret   = -1;
-                rsp.op_errno = EINVAL;
-                goto out;
-        }
-
-out:
-        STACK_UNWIND_STRICT (flush, frame, rsp.op_ret,
-                             gf_error_to_errno (rsp.op_errno));
-
-        return 0;
-}
-
-int
-client3_1_fsync_cbk (struct rpc_req *req, struct iovec *iov, int count,
-                     void *myframe)
-{
-        gfs3_fsync_rsp rsp = {0,};
-        call_frame_t   *frame = NULL;
-        struct iatt  prestat  = {0,};
-        struct iatt  poststat = {0,};
-        int ret = 0;
-
-        frame = myframe;
-
-        if (-1 == req->rpc_status) {
-                rsp.op_ret   = -1;
-                rsp.op_errno = ENOTCONN;
-                goto out;
-        }
-
-        ret = xdr_to_truncate_rsp (*iov, &rsp);
-        if (ret < 0) {
-                gf_log ("", GF_LOG_ERROR, "error");
-                rsp.op_ret   = -1;
-                rsp.op_errno = EINVAL;
-                goto out;
-        }
-
-        if (-1 != rsp.op_ret) {
-                gf_stat_to_iatt (&rsp.prestat, &prestat);
-                gf_stat_to_iatt (&rsp.poststat, &poststat);
-        }
-
-out:
-        STACK_UNWIND_STRICT (fsync, frame, rsp.op_ret,
-                             gf_error_to_errno (rsp.op_errno), &prestat,
-                             &poststat);
-
-        return 0;
-}
-
-int
-client3_1_setxattr_cbk (struct rpc_req *req, struct iovec *iov, int count,
-                        void *myframe)
-{
-        call_frame_t    *frame      = NULL;
-        gf_common_rsp    rsp        = {0,};
-        int              ret        = 0;
-
-        frame = myframe;
-
-        if (-1 == req->rpc_status) {
-                rsp.op_ret   = -1;
-                rsp.op_errno = ENOTCONN;
-                goto out;
-        }
-
-        ret = xdr_to_common_rsp (*iov, &rsp);
-        if (ret < 0) {
-                gf_log ("", GF_LOG_ERROR, "error");
-                rsp.op_ret   = -1;
-                rsp.op_errno = EINVAL;
-                goto out;
-        }
-
-out:
-        STACK_UNWIND_STRICT (setxattr, frame, rsp.op_ret,
-                             gf_error_to_errno (rsp.op_errno));
-
-        return 0;
-}
-
-int
-client3_1_getxattr_cbk (struct rpc_req *req, struct iovec *iov, int count,
-                        void *myframe)
-{
-        call_frame_t      *frame    = NULL;
-        dict_t            *dict     = NULL;
-        char              *buf      = NULL;
-        int                dict_len = 0;
-        int                op_ret   = 0;
-        int                op_errno = 0;
-        gfs3_getxattr_rsp  rsp      = {0,};
-        int                ret      = 0;
-
-        frame = myframe;
-
-        if (-1 == req->rpc_status) {
-                op_ret   = -1;
-                op_errno = ENOTCONN;
-                goto out;
-        }
-
-        ret = xdr_to_getxattr_rsp (*iov, &rsp);
-        if (ret < 0) {
-                gf_log ("", GF_LOG_ERROR, "error");
-                op_ret   = -1;
-                op_errno = EINVAL;
-                goto out;
-        }
-
-        op_errno = gf_error_to_errno (rsp.op_errno);
-        op_ret = rsp.op_ret;
-        if (-1 != op_ret) {
-                op_ret = -1;
-                dict_len = rsp.dict.dict_len;
-
-                if (dict_len > 0) {
-                        dict = dict_new();
-                        buf = memdup (rsp.dict.dict_val, rsp.dict.dict_len);
-
-                        GF_VALIDATE_OR_GOTO (frame->this->name, dict, out);
-                        GF_VALIDATE_OR_GOTO (frame->this->name, buf, out);
-
-                        ret = dict_unserialize (buf, dict_len, &dict);
-                        if (ret < 0) {
-                                gf_log (frame->this->name, GF_LOG_DEBUG,
-                                        "failed to unserialize xattr dict");
-                                op_errno = EINVAL;
-                                goto out;
-                        }
-                        dict->extra_free = buf;
-                        buf = NULL;
-                }
-                op_ret = 0;
-        }
-
-out:
-        STACK_UNWIND_STRICT (getxattr, frame, op_ret, op_errno, dict);
-
-        if (rsp.dict.dict_val) {
-                /* don't use GF_FREE, this memory was allocated by libc
-                 */
-                free (rsp.dict.dict_val);
-                rsp.dict.dict_val = NULL;
-        }
-
-        if (buf)
-                GF_FREE (buf);
-
-        if (dict)
-                dict_unref (dict);
-
-        return 0;
-}
-
-int
-client3_1_fgetxattr_cbk (struct rpc_req *req, struct iovec *iov, int count,
-                         void *myframe)
-{
-        call_frame_t       *frame    = NULL;
-        char               *buf      = NULL;
-        dict_t             *dict     = NULL;
-        gfs3_fgetxattr_rsp  rsp      = {0,};
-        int                 ret      = 0;
-        int                 dict_len = 0;
-        int                 op_ret   = 0;
-        int                 op_errno = 0;
-
-        frame = myframe;
-
-        if (-1 == req->rpc_status) {
-                op_ret   = -1;
-                op_errno = ENOTCONN;
-                goto out;
-        }
-        ret = xdr_to_fgetxattr_rsp (*iov, &rsp);
-        if (ret < 0) {
-                gf_log ("", GF_LOG_ERROR, "error");
-                op_ret   = -1;
-                op_errno = EINVAL;
-                goto out;
-        }
-
-        op_errno = gf_error_to_errno (rsp.op_errno);
-        op_ret = rsp.op_ret;
-        if (-1 != op_ret) {
-                op_ret = -1;
-                dict_len = rsp.dict.dict_len;
-
-                if (dict_len > 0) {
-                        dict = dict_new();
-                        GF_VALIDATE_OR_GOTO (frame->this->name, dict, out);
-                        buf = memdup (rsp.dict.dict_val, rsp.dict.dict_len);
-                        GF_VALIDATE_OR_GOTO (frame->this->name, buf, out);
-
-                        ret = dict_unserialize (buf, dict_len, &dict);
-                        if (ret < 0) {
-                                gf_log (frame->this->name, GF_LOG_DEBUG,
-                                        "failed to unserialize xattr dict");
-                                op_errno = EINVAL;
-                                goto out;
-                        }
-                        dict->extra_free = buf;
-                        buf = NULL;
-                }
-                op_ret = 0;
-        }
-out:
-        STACK_UNWIND_STRICT (fgetxattr, frame, op_ret, op_errno, dict);
-        if (rsp.dict.dict_val) {
-                /* don't use GF_FREE, this memory was allocated by libc
-                 */
-                free (rsp.dict.dict_val);
-                rsp.dict.dict_val = NULL;
-        }
-
-        if (buf)
-                GF_FREE (buf);
-
-        if (dict)
-                dict_unref (dict);
-
-        return 0;
-}
-
-int
-client3_1_removexattr_cbk (struct rpc_req *req, struct iovec *iov, int count,
-                           void *myframe)
-{
-        call_frame_t    *frame      = NULL;
-        gf_common_rsp    rsp        = {0,};
-        int              ret        = 0;
-
-        frame = myframe;
-
-        if (-1 == req->rpc_status) {
-                rsp.op_ret   = -1;
-                rsp.op_errno = ENOTCONN;
-                goto out;
-        }
-
-        ret = xdr_to_common_rsp (*iov, &rsp);
-        if (ret < 0) {
-                gf_log ("", GF_LOG_ERROR, "error");
-                rsp.op_ret   = -1;
-                rsp.op_errno = EINVAL;
-                goto out;
-        }
-
-out:
-        STACK_UNWIND_STRICT (removexattr, frame, rsp.op_ret,
-                             gf_error_to_errno (rsp.op_errno));
-
-        return 0;
-}
-
-int
-client3_1_fsyncdir_cbk (struct rpc_req *req, struct iovec *iov, int count,
-                        void *myframe)
-{
-        call_frame_t    *frame      = NULL;
-        gf_common_rsp    rsp        = {0,};
-        int              ret        = 0;
-
-        frame = myframe;
-
-        if (-1 == req->rpc_status) {
-                rsp.op_ret   = -1;
-                rsp.op_errno = ENOTCONN;
-                goto out;
-        }
-        ret = xdr_to_common_rsp (*iov, &rsp);
-        if (ret < 0) {
-                gf_log ("", GF_LOG_ERROR, "error");
-                rsp.op_ret   = -1;
-                rsp.op_errno = EINVAL;
-                goto out;
-        }
-
-out:
-        STACK_UNWIND_STRICT (fsyncdir, frame, rsp.op_ret,
-                             gf_error_to_errno (rsp.op_errno));
-
-        return 0;
-}
-
-int
-client3_1_access_cbk (struct rpc_req *req, struct iovec *iov, int count,
-                      void *myframe)
-{
-        call_frame_t    *frame      = NULL;
-        gf_common_rsp    rsp        = {0,};
-        int              ret        = 0;
-
-        frame = myframe;
-
-        if (-1 == req->rpc_status) {
-                rsp.op_ret   = -1;
-                rsp.op_errno = ENOTCONN;
-                goto out;
-        }
-        ret = xdr_to_common_rsp (*iov, &rsp);
-        if (ret < 0) {
-                gf_log ("", GF_LOG_ERROR, "error");
-                rsp.op_ret   = -1;
-                rsp.op_errno = EINVAL;
-                goto out;
-        }
-
-out:
-        STACK_UNWIND_STRICT (access, frame, rsp.op_ret,
-                             gf_error_to_errno (rsp.op_errno));
-
-        return 0;
-}
-
-
-int
-client3_1_ftruncate_cbk (struct rpc_req *req, struct iovec *iov, int count,
-                         void *myframe)
-{
-        gfs3_ftruncate_rsp rsp = {0,};
-        call_frame_t   *frame = NULL;
-        struct iatt  prestat  = {0,};
-        struct iatt  poststat = {0,};
-        int ret = 0;
-
-        frame = myframe;
-
-        if (-1 == req->rpc_status) {
-                rsp.op_ret   = -1;
-                rsp.op_errno = ENOTCONN;
-                goto out;
-        }
-        ret = xdr_to_ftruncate_rsp (*iov, &rsp);
-        if (ret < 0) {
-                gf_log ("", GF_LOG_ERROR, "error");
-                rsp.op_ret   = -1;
-                rsp.op_errno = EINVAL;
-                goto out;
-        }
-
-        if (-1 != rsp.op_ret) {
-                gf_stat_to_iatt (&rsp.prestat, &prestat);
-                gf_stat_to_iatt (&rsp.poststat, &poststat);
-        }
-
-out:
-        STACK_UNWIND_STRICT (ftruncate, frame, rsp.op_ret,
-                             gf_error_to_errno (rsp.op_errno), &prestat,
-                             &poststat);
-
-        return 0;
-}
-
-int
-client3_1_fstat_cbk (struct rpc_req *req, struct iovec *iov, int count,
-                     void *myframe)
-{
-        gfs3_fstat_rsp rsp = {0,};
-        call_frame_t   *frame = NULL;
-        struct iatt  stat  = {0,};
-        int ret = 0;
-
-        frame = myframe;
-
-        if (-1 == req->rpc_status) {
-                rsp.op_ret   = -1;
-                rsp.op_errno = ENOTCONN;
-                goto out;
-        }
-        ret = xdr_to_fstat_rsp (*iov, &rsp);
-        if (ret < 0) {
-                gf_log ("", GF_LOG_ERROR, "error");
-                rsp.op_ret   = -1;
-                rsp.op_errno = EINVAL;
-                goto out;
-        }
-
-        if (-1 != rsp.op_ret) {
-                gf_stat_to_iatt (&rsp.stat, &stat);
-        }
-
-out:
-        STACK_UNWIND_STRICT (fstat, frame, rsp.op_ret,
-                             gf_error_to_errno (rsp.op_errno), &stat);
-
-        return 0;
-}
-
-
-int
-client3_1_inodelk_cbk (struct rpc_req *req, struct iovec *iov, int count,
-                       void *myframe)
-{
-        call_frame_t    *frame      = NULL;
-        gf_common_rsp    rsp        = {0,};
-        int              ret        = 0;
-
-        frame = myframe;
-
-        if (-1 == req->rpc_status) {
-                rsp.op_ret   = -1;
-                rsp.op_errno = ENOTCONN;
-                goto out;
-        }
-        ret = xdr_to_common_rsp (*iov, &rsp);
-        if (ret < 0) {
-                gf_log ("", GF_LOG_ERROR, "error");
-                rsp.op_ret   = -1;
-                rsp.op_errno = EINVAL;
-                goto out;
-        }
-
-out:
-        STACK_UNWIND_STRICT (inodelk, frame, rsp.op_ret,
-                             gf_error_to_errno (rsp.op_errno));
-
-        return 0;
-}
-
-int
-client3_1_finodelk_cbk (struct rpc_req *req, struct iovec *iov, int count,
-                        void *myframe)
-{
-        call_frame_t    *frame      = NULL;
-        gf_common_rsp    rsp        = {0,};
-        int              ret        = 0;
-
-        frame = myframe;
-
-        if (-1 == req->rpc_status) {
-                rsp.op_ret   = -1;
-                rsp.op_errno = ENOTCONN;
-                goto out;
-        }
-        ret = xdr_to_common_rsp (*iov, &rsp);
-        if (ret < 0) {
-                gf_log ("", GF_LOG_ERROR, "error");
-                rsp.op_ret   = -1;
-                rsp.op_errno = EINVAL;
-                goto out;
-        }
-
-out:
-        STACK_UNWIND_STRICT (finodelk, frame, rsp.op_ret,
-                             gf_error_to_errno (rsp.op_errno));
-
-        return 0;
-}
-
-int
-client3_1_entrylk_cbk (struct rpc_req *req, struct iovec *iov, int count,
-                       void *myframe)
-{
-        call_frame_t    *frame      = NULL;
-        gf_common_rsp    rsp        = {0,};
-        int              ret        = 0;
-
-        frame = myframe;
-
-        if (-1 == req->rpc_status) {
-                rsp.op_ret   = -1;
-                rsp.op_errno = ENOTCONN;
-                goto out;
-        }
-        ret = xdr_to_common_rsp (*iov, &rsp);
-        if (ret < 0) {
-                gf_log ("", GF_LOG_ERROR, "error");
-                rsp.op_ret   = -1;
-                rsp.op_errno = EINVAL;
-                goto out;
-        }
-
-out:
-
-        STACK_UNWIND_STRICT (entrylk, frame, rsp.op_ret,
-                             gf_error_to_errno (rsp.op_errno));
-
-        return 0;
-}
-
-int
-client3_1_fentrylk_cbk (struct rpc_req *req, struct iovec *iov, int count,
-                        void *myframe)
-{
-        call_frame_t    *frame      = NULL;
-        gf_common_rsp    rsp        = {0,};
-        int              ret        = 0;
-
-        frame = myframe;
-
-        if (-1 == req->rpc_status) {
-                rsp.op_ret   = -1;
-                rsp.op_errno = ENOTCONN;
-                goto out;
-        }
-        ret = xdr_to_common_rsp (*iov, &rsp);
-        if (ret < 0) {
-                gf_log ("", GF_LOG_ERROR, "error");
-                rsp.op_ret   = -1;
-                rsp.op_errno = EINVAL;
-                goto out;
-        }
-
-out:
-        STACK_UNWIND_STRICT (fentrylk, frame, rsp.op_ret,
-                             gf_error_to_errno (rsp.op_errno));
-
-        return 0;
-}
-
-int
-client3_1_xattrop_cbk (struct rpc_req *req, struct iovec *iov, int count,
-                       void *myframe)
-{
-        call_frame_t     *frame    = NULL;
-        dict_t           *dict     = NULL;
-        char             *buf      = NULL;
-        gfs3_xattrop_rsp  rsp      = {0,};
-        int               ret      = 0;
-        int               op_ret   = 0;
-        int               dict_len = 0;
-        int               op_errno = 0;
-
-        frame = myframe;
-
-        if (-1 == req->rpc_status) {
-                op_ret   = -1;
-                op_errno = ENOTCONN;
-                goto out;
-        }
-        ret = xdr_to_xattrop_rsp (*iov, &rsp);
-        if (ret < 0) {
-                gf_log ("", GF_LOG_ERROR, "error");
-                op_ret   = -1;
-                op_errno = EINVAL;
-                goto out;
-        }
-
-        op_ret = rsp.op_ret;
-        if (-1 != op_ret) {
-                op_ret = -1;
-                dict_len = rsp.dict.dict_len;
-
-                if (dict_len > 0) {
-                        dict = dict_new();
-                        GF_VALIDATE_OR_GOTO (frame->this->name, dict, out);
-
-                        buf = memdup (rsp.dict.dict_val, rsp.dict.dict_len);
-                        GF_VALIDATE_OR_GOTO (frame->this->name, buf, out);
-                        op_ret = dict_unserialize (buf, dict_len, &dict);
-                        if (op_ret < 0) {
-                                gf_log (frame->this->name, GF_LOG_DEBUG,
-                                        "failed to unserialize xattr dict");
-                                op_errno = EINVAL;
-                                goto out;
-                        }
-                        dict->extra_free = buf;
-                        buf = NULL;
-                }
-                op_ret = 0;
-        }
-
-out:
-
-        STACK_UNWIND_STRICT (xattrop, frame, op_ret,
-                             gf_error_to_errno (rsp.op_errno), dict);
-
-        if (rsp.dict.dict_val) {
-                /* don't use GF_FREE, this memory was allocated by libc
-                 */
-                free (rsp.dict.dict_val);
-                rsp.dict.dict_val = NULL;
-        }
-
-        if (buf)
-                GF_FREE (buf);
-
-        if (dict)
-                dict_unref (dict);
-
-        return 0;
-}
-
-int
-client3_1_fxattrop_cbk (struct rpc_req *req, struct iovec *iov, int count,
-                        void *myframe)
-{
-        call_frame_t      *frame    = NULL;
-        dict_t            *dict     = NULL;
-        char              *buf      = NULL;
-        gfs3_fxattrop_rsp  rsp      = {0,};
-        int                ret      = 0;
-        int                op_ret   = 0;
-        int                dict_len = 0;
-        int                op_errno = 0;
-
-        frame = myframe;
-
-        if (-1 == req->rpc_status) {
-                op_ret   = -1;
-                op_errno = ENOTCONN;
-                goto out;
-        }
-
-        ret = xdr_to_fxattrop_rsp (*iov, &rsp);
-        if (ret < 0) {
-                op_ret = -1;
-                op_errno = EINVAL;
-                gf_log ("", GF_LOG_ERROR, "error");
-                goto out;
-        }
-
-        op_ret = rsp.op_ret;
-        if (-1 != op_ret) {
-                op_ret = -1;
-                dict_len = rsp.dict.dict_len;
-
-                if (dict_len > 0) {
-                        dict = dict_new();
-                        GF_VALIDATE_OR_GOTO (frame->this->name, dict, out);
-
-                        buf = memdup (rsp.dict.dict_val, rsp.dict.dict_len);
-                        GF_VALIDATE_OR_GOTO (frame->this->name, buf, out);
-                        op_ret = dict_unserialize (buf, dict_len, &dict);
-                        if (op_ret < 0) {
-                                gf_log (frame->this->name, GF_LOG_DEBUG,
-                                        "failed to unserialize xattr dict");
-                                op_errno = EINVAL;
-                                goto out;
-                        }
-                        dict->extra_free = buf;
-                        buf = NULL;
-                }
-                op_ret = 0;
-        }
-
-out:
-
-        STACK_UNWIND_STRICT (fxattrop, frame, op_ret,
-                             gf_error_to_errno (rsp.op_errno), dict);
-
-        if (rsp.dict.dict_val) {
-                /* don't use GF_FREE, this memory was allocated by libc
-                 */
-                free (rsp.dict.dict_val);
-                rsp.dict.dict_val = NULL;
-        }
-
-        if (buf)
-                GF_FREE (buf);
-
-        if (dict)
-                dict_unref (dict);
-
-        return 0;
-}
-
-int
-client3_1_fsetxattr_cbk (struct rpc_req *req, struct iovec *iov, int count,
-                         void *myframe)
-{
-        call_frame_t    *frame      = NULL;
-        gf_common_rsp    rsp        = {0,};
-        int              ret        = 0;
-
-        frame = myframe;
-
-        if (-1 == req->rpc_status) {
-                rsp.op_ret   = -1;
-                rsp.op_errno = ENOTCONN;
-                goto out;
-        }
-        ret = xdr_to_common_rsp (*iov, &rsp);
-        if (ret < 0) {
-                gf_log ("", GF_LOG_ERROR, "error");
-                rsp.op_ret   = -1;
-                rsp.op_errno = EINVAL;
-                goto out;
-        }
-
-out:
-        STACK_UNWIND_STRICT (fsetxattr, frame, rsp.op_ret,
-                             gf_error_to_errno (rsp.op_errno));
-
-        return 0;
-}
-
-int
-client3_1_fsetattr_cbk (struct rpc_req *req, struct iovec *iov, int count,
-                        void *myframe)
-{
-        call_frame_t    *frame      = NULL;
-        gfs3_fsetattr_rsp rsp        = {0,};
-        struct iatt      prestat    = {0,};
-        struct iatt      poststat   = {0,};
-        int              ret        = 0;
-
-        frame = myframe;
-
-        if (-1 == req->rpc_status) {
-                rsp.op_ret   = -1;
-                rsp.op_errno = ENOTCONN;
-                goto out;
-        }
-        ret = xdr_to_fsetattr_rsp (*iov, &rsp);
-        if (ret < 0) {
-                gf_log ("", GF_LOG_ERROR, "error");
-                rsp.op_ret   = -1;
-                rsp.op_errno = EINVAL;
-                goto out;
-        }
-
-        if (-1 != rsp.op_ret) {
-                gf_stat_to_iatt (&rsp.statpre, &prestat);
-                gf_stat_to_iatt (&rsp.statpost, &poststat);
-        }
-
-out:
-        STACK_UNWIND_STRICT (fsetattr, frame, rsp.op_ret,
-                             gf_error_to_errno (rsp.op_errno), &prestat,
-                             &poststat);
-
-        return 0;
-}
-
-
-int
-client3_1_setattr_cbk (struct rpc_req *req, struct iovec *iov, int count,
-                       void *myframe)
-{
-        call_frame_t    *frame      = NULL;
-        gfs3_setattr_rsp rsp        = {0,};
-        struct iatt      prestat    = {0,};
-        struct iatt      poststat   = {0,};
-        int              ret        = 0;
-
-        frame = myframe;
-
-        if (-1 == req->rpc_status) {
-                rsp.op_ret   = -1;
-                rsp.op_errno = ENOTCONN;
-                goto out;
-        }
-
-        ret = xdr_to_setattr_rsp (*iov, &rsp);
-        if (ret < 0) {
-                gf_log ("", GF_LOG_ERROR, "error");
-                rsp.op_ret   = -1;
-                rsp.op_errno = EINVAL;
-                goto out;
-        }
-
-        if (-1 != rsp.op_ret) {
-                gf_stat_to_iatt (&rsp.statpre, &prestat);
-                gf_stat_to_iatt (&rsp.statpost, &poststat);
-        }
-
-out:
-        STACK_UNWIND_STRICT (setattr, frame, rsp.op_ret,
-                             gf_error_to_errno (rsp.op_errno), &prestat,
-                             &poststat);
-
-        return 0;
-}
-
-int
-client3_1_create_cbk (struct rpc_req *req, struct iovec *iov, int count,
-                      void *myframe)
-{
-        call_frame_t    *frame      = NULL;
-        fd_t            *fd         = NULL;
-        inode_t         *inode      = NULL;
-        struct iatt      stbuf      = {0, };
-        struct iatt      preparent  = {0, };
-        struct iatt      postparent = {0, };
-        int32_t          ret        = -1;
-        clnt_local_t    *local      = NULL;
-        clnt_conf_t     *conf       = NULL;
-        clnt_fd_ctx_t   *fdctx      = NULL;
-        gfs3_create_rsp  rsp        = {0,};
-
-        frame = myframe;
-        local = frame->local; frame->local = NULL;
-        conf  = frame->this->private;
-        fd    = local->fd;
-        inode = local->loc.inode;
-
-        if (-1 == req->rpc_status) {
-                rsp.op_ret   = -1;
-                rsp.op_errno = ENOTCONN;
-                goto out;
-        }
-
-        ret = xdr_to_create_rsp (*iov, &rsp);
-        if (ret < 0) {
-                gf_log ("", GF_LOG_ERROR, "error");
-                rsp.op_ret   = -1;
-                rsp.op_errno = EINVAL;
-                goto out;
-        }
-
-        if (-1 != rsp.op_ret) {
-                gf_stat_to_iatt (&rsp.stat, &stbuf);
-
-                ret = inode_ctx_put2 (inode, frame->this,
-                                      stbuf.ia_ino, stbuf.ia_gen);
-                if (ret < 0) {
-                        gf_log (frame->this->name, GF_LOG_DEBUG,
-                                "CREATE %"PRId64"/%s (%s): failed to set "
-                                "remote inode number to inode ctx",
-                                local->loc.parent->ino, local->loc.name,
-                                local->loc.path);
-                }
-
-                gf_stat_to_iatt (&rsp.preparent, &preparent);
-                gf_stat_to_iatt (&rsp.postparent, &postparent);
-
-                fdctx = GF_CALLOC (1, sizeof (*fdctx),
-                                   gf_client_mt_clnt_fdctx_t);
-                if (!fdctx) {
-                        rsp.op_ret = -1;
-                        rsp.op_errno = ENOMEM;
-                        goto out;
-                }
-
-                fdctx->remote_fd = rsp.fd;
-                fdctx->inode     = inode_ref (inode);
-                fdctx->ino       = stbuf.ia_ino;
-                fdctx->gen       = stbuf.ia_gen;
-                fdctx->flags     = local->flags;
-
-                INIT_LIST_HEAD (&fdctx->sfd_pos);
-
-                this_fd_set_ctx (fd, frame->this, &local->loc, fdctx);
-
-                pthread_mutex_lock (&conf->lock);
-                {
-                        list_add_tail (&fdctx->sfd_pos, &conf->saved_fds);
-                }
-                pthread_mutex_unlock (&conf->lock);
-        }
-
-out:
-        frame->local = NULL;
-        STACK_UNWIND_STRICT (create, frame, rsp.op_ret,
-                             gf_error_to_errno (rsp.op_errno), fd, inode,
-                             &stbuf, &preparent, &postparent);
-
-        client_local_wipe (local);
-        return 0;
-}
-
-
-int
-client3_1_rchecksum_cbk (struct rpc_req *req, struct iovec *iov, int count,
-                         void *myframe)
-{
-        call_frame_t *frame = NULL;
-        gfs3_rchecksum_rsp rsp        = {0,};
-        int              ret        = 0;
-
-        frame = myframe;
-
-        if (-1 == req->rpc_status) {
-                rsp.op_ret   = -1;
-                rsp.op_errno = ENOTCONN;
-                goto out;
-        }
-
-        ret = xdr_to_rchecksum_rsp (*iov, &rsp);
-        if (ret < 0) {
-                gf_log ("", GF_LOG_ERROR, "error");
-                rsp.op_ret   = -1;
-                rsp.op_errno = EINVAL;
-                goto out;
-        }
-
-out:
-        STACK_UNWIND_STRICT (rchecksum, frame, rsp.op_ret,
-                             gf_error_to_errno (rsp.op_errno),
-                             rsp.weak_checksum,
-                             (uint8_t *)rsp.strong_checksum.strong_checksum_val);
-
-        if (rsp.strong_checksum.strong_checksum_val) {
-                /* This is allocated by the libc while decoding RPC msg */
-                /* Hence no 'GF_FREE', but just 'free' */
-                free (rsp.strong_checksum.strong_checksum_val);
-        }
-
-        return 0;
-}
-
-int
-client3_1_checksum_cbk (struct rpc_req *req, struct iovec *iov, int count,
-                        void *myframe)
-{
-        call_frame_t *frame = NULL;
-        gfs3_checksum_rsp rsp        = {0,};
-        int              ret        = 0;
-
-        frame = myframe;
-
-        if (-1 == req->rpc_status) {
-                rsp.op_ret   = -1;
-                rsp.op_errno = ENOTCONN;
-                goto out;
-        }
-
-        ret = xdr_to_checksum_rsp (*iov, &rsp);
-        if (ret < 0) {
-                gf_log ("", GF_LOG_ERROR, "error");
-                rsp.op_ret   = -1;
-                rsp.op_errno = EINVAL;
-                goto out;
-        }
-
-out:
-        STACK_UNWIND_STRICT (checksum, frame, rsp.op_ret,
-                             gf_error_to_errno (rsp.op_errno),
-                             (uint8_t *)rsp.fchecksum.fchecksum_val,
-                             (uint8_t *)rsp.dchecksum.dchecksum_val);
-
-        /* This is allocated by the libc while decoding RPC msg */
-        /* Hence no 'GF_FREE', but just 'free' */
-        if (rsp.fchecksum.fchecksum_val) {
-                free (rsp.fchecksum.fchecksum_val);
-        }
-        if (rsp.dchecksum.dchecksum_val) {
-                free (rsp.dchecksum.dchecksum_val);
-        }
-        return 0;
-}
-
-int
-client3_1_lk_cbk (struct rpc_req *req, struct iovec *iov, int count,
-                  void *myframe)
-{
-        call_frame_t  *frame = NULL;
-        struct flock   lock = {0,};
-        gfs3_lk_rsp    rsp        = {0,};
-        int            ret        = 0;
-
-        frame = myframe;
-
-        if (-1 == req->rpc_status) {
-                rsp.op_ret   = -1;
-                rsp.op_errno = ENOTCONN;
-                goto out;
-        }
-
-        ret = xdr_to_lk_rsp (*iov, &rsp);
-        if (ret < 0) {
-                gf_log ("", GF_LOG_ERROR, "error");
-                rsp.op_ret   = -1;
-                rsp.op_errno = EINVAL;
-                goto out;
-        }
-
-        if (rsp.op_ret >= 0) {
-                gf_flock_to_flock (&rsp.flock, &lock);
-        }
-
-out:
-        STACK_UNWIND_STRICT (lk, frame, rsp.op_ret,
-                             gf_error_to_errno (rsp.op_errno), &lock);
-
-        return 0;
-}
-
-int
-client3_1_readdir_cbk (struct rpc_req *req, struct iovec *iov, int count,
-                       void *myframe)
-{
-        call_frame_t           *frame = NULL;
-        gfs3_readdir_rsp        rsp = {0,};
-        int32_t                 ret = 0;
-        gf_dirent_t             entries;
-
-        frame = myframe;
-
-        if (-1 == req->rpc_status) {
-                rsp.op_ret   = -1;
-                rsp.op_errno = ENOTCONN;
-                goto out;
-        }
-
-        ret = xdr_to_readdir_rsp (*iov, &rsp);
-        if (ret < 0) {
-                gf_log ("", GF_LOG_ERROR, "error");
-                rsp.op_ret   = -1;
-                rsp.op_errno = EINVAL;
-                goto out;
-        }
-
-        INIT_LIST_HEAD (&entries.list);
-        if (rsp.op_ret > 0) {
-                gf_dirent_unserialize (&entries, rsp.buf.buf_val,
-                                       rsp.buf.buf_len);
-        }
-
-out:
-        STACK_UNWIND_STRICT (readdir, frame, rsp.op_ret,
-                             gf_error_to_errno (rsp.op_errno), &entries);
-
-        if (rsp.op_ret != -1) {
-                gf_dirent_free (&entries);
-        }
-
-        /* This is allocated by the libc while decoding RPC msg */
-        /* Hence no 'GF_FREE', but just 'free' */
-        if (rsp.buf.buf_val)
-                free (rsp.buf.buf_val);
-
-        return 0;
-}
-
-
-int
-client3_1_readdirp_cbk (struct rpc_req *req, struct iovec *iov, int count,
-                        void *myframe)
-{
-        call_frame_t           *frame = NULL;
-        gfs3_readdirp_rsp       rsp = {0,};
-        int32_t                 ret = 0;
-        gf_dirent_t             entries;
-
-        frame = myframe;
-
-        if (-1 == req->rpc_status) {
-                rsp.op_ret   = -1;
-                rsp.op_errno = ENOTCONN;
-                goto out;
-        }
-
-        ret = xdr_to_readdirp_rsp (*iov, &rsp);
-        if (ret < 0) {
-                gf_log ("", GF_LOG_ERROR, "error");
-                rsp.op_ret   = -1;
-                rsp.op_errno = EINVAL;
-                goto out;
-        }
-
-        INIT_LIST_HEAD (&entries.list);
-        if (rsp.op_ret > 0) {
-                gf_dirent_unserialize (&entries, rsp.buf.buf_val,
-                                       rsp.buf.buf_len);
-        }
-
-out:
-        STACK_UNWIND_STRICT (readdirp, frame, rsp.op_ret,
-                             gf_error_to_errno (rsp.op_errno), &entries);
-
-        if (rsp.op_ret != -1) {
-                gf_dirent_free (&entries);
-        }
-
-        if (rsp.buf.buf_val) {
-                /* don't use GF_FREE as this memory was allocated by libc */
-                free (rsp.buf.buf_val);
-        }
-
-        return 0;
-}
-
-
-int
-client3_1_rename_cbk (struct rpc_req *req, struct iovec *iov, int count,
-                      void *myframe)
-{
-        call_frame_t     *frame      = NULL;
-        gfs3_rename_rsp   rsp        = {0,};
-        struct iatt       stbuf      = {0,};
-        struct iatt       preoldparent  = {0,};
-        struct iatt       postoldparent = {0,};
-        struct iatt       prenewparent  = {0,};
-        struct iatt       postnewparent = {0,};
-        int               ret        = 0;
-
-        frame = myframe;
-
-        if (-1 == req->rpc_status) {
-                rsp.op_ret   = -1;
-                rsp.op_errno = ENOTCONN;
-                goto out;
-        }
-
-        ret = xdr_to_rename_rsp (*iov, &rsp);
-        if (ret < 0) {
-                gf_log ("", GF_LOG_ERROR, "error");
-                rsp.op_ret   = -1;
-                rsp.op_errno = EINVAL;
-                goto out;
-        }
-
-        if (-1 != rsp.op_ret) {
-                gf_stat_to_iatt (&rsp.stat, &stbuf);
-
-                gf_stat_to_iatt (&rsp.preoldparent, &preoldparent);
-                gf_stat_to_iatt (&rsp.postoldparent, &postoldparent);
-
-                gf_stat_to_iatt (&rsp.prenewparent, &prenewparent);
-                gf_stat_to_iatt (&rsp.postnewparent, &postnewparent);
-        }
-
-out:
-        STACK_UNWIND_STRICT (rename, frame, rsp.op_ret,
-                             gf_error_to_errno (rsp.op_errno),
-                             &stbuf, &preoldparent, &postoldparent,
-                             &preoldparent, &postoldparent);
-
-        return 0;
-}
-
-int
-client3_1_link_cbk (struct rpc_req *req, struct iovec *iov, int count,
-                    void *myframe)
-{
-        call_frame_t     *frame      = NULL;
-        gfs3_link_rsp     rsp        = {0,};
-        struct iatt       stbuf      = {0,};
-        struct iatt       preparent  = {0,};
-        struct iatt       postparent = {0,};
-        int               ret        = 0;
-        clnt_local_t     *local      = NULL;
-        inode_t          *inode      = NULL;
-
-        frame = myframe;
-
-        local = frame->local;
-        frame->local = NULL;
-        inode = local->loc.inode;
-
-        if (-1 == req->rpc_status) {
-                rsp.op_ret   = -1;
-                rsp.op_errno = ENOTCONN;
-                goto out;
-        }
-
-        ret = xdr_to_link_rsp (*iov, &rsp);
-        if (ret < 0) {
-                gf_log ("", GF_LOG_ERROR, "error");
-                rsp.op_ret   = -1;
-                rsp.op_errno = EINVAL;
-                goto out;
-        }
-
-        if (-1 != rsp.op_ret) {
-                gf_stat_to_iatt (&rsp.stat, &stbuf);
-
-                gf_stat_to_iatt (&rsp.preparent, &preparent);
-                gf_stat_to_iatt (&rsp.postparent, &postparent);
-        }
-
-out:
-        frame->local = NULL;
-        STACK_UNWIND_STRICT (link, frame, rsp.op_ret,
-                             gf_error_to_errno (rsp.op_errno), inode,
-                             &stbuf, &preparent, &postparent);
-
-        client_local_wipe (local);
-        return 0;
-}
-
-
-int
-client3_1_opendir_cbk (struct rpc_req *req, struct iovec *iov, int count,
-                       void *myframe)
-{
-        clnt_local_t      *local = NULL;
-        clnt_conf_t       *conf = NULL;
-        clnt_fd_ctx_t     *fdctx = NULL;
-        ino_t                ino = 0;
-        uint64_t             gen = 0;
-        call_frame_t   *frame = NULL;
-        fd_t             *fd = NULL;
-        int ret = 0;
-        gfs3_opendir_rsp  rsp = {0,};
-
-        frame = myframe;
-        local = frame->local;
-
-        if (local->op) {
-                local->op (req, iov, 1, myframe);
-                return 0;
-        }
-
-        frame->local = NULL;
-        conf  = frame->this->private;
-        fd    = local->fd;
-
-        if (-1 == req->rpc_status) {
-                rsp.op_ret   = -1;
-                rsp.op_errno = ENOTCONN;
-                goto out;
-        }
-
-        ret = xdr_to_opendir_rsp (*iov, &rsp);
-        if (ret < 0) {
-                gf_log ("", GF_LOG_ERROR, "error");
-                rsp.op_ret   = -1;
-                rsp.op_errno = EINVAL;
-                goto out;
-        }
-
-        if (-1 != rsp.op_ret) {
-                fdctx = GF_CALLOC (1, sizeof (*fdctx),
-                                   gf_client_mt_clnt_fdctx_t);
-                if (!fdctx) {
-                        rsp.op_ret = -1;
-                        rsp.op_errno = ENOMEM;
-                        goto out;
-                }
-
-                inode_ctx_get2 (fd->inode, frame->this, &ino, &gen);
-
-                fdctx->remote_fd = rsp.fd;
-                fdctx->inode     = inode_ref (fd->inode);
-                fdctx->ino       = ino;
-                fdctx->gen       = gen;
-
-                fdctx->is_dir    = 1;
-
-                INIT_LIST_HEAD (&fdctx->sfd_pos);
-
-                this_fd_set_ctx (fd, frame->this, &local->loc, fdctx);
-
-                pthread_mutex_lock (&conf->lock);
-                {
-                        list_add_tail (&fdctx->sfd_pos, &conf->saved_fds);
-                }
-                pthread_mutex_unlock (&conf->lock);
-        }
-
-out:
-        frame->local = NULL;
-        STACK_UNWIND_STRICT (opendir, frame, rsp.op_ret,
-                             gf_error_to_errno (rsp.op_errno), fd);
-
-        client_local_wipe (local);
-
-        return 0;
-}
-
-
-int
-client3_1_lookup_cbk (struct rpc_req *req, struct iovec *iov, int count,
-                      void *myframe)
-{
-        clnt_local_t    *local      = NULL;
-        call_frame_t    *frame      = NULL;
-        int              ret        = 0;
-        gfs3_lookup_rsp  rsp        = {0,};
-        struct iatt      stbuf      = {0,};
-        struct iatt      postparent = {0,};
-        int              op_errno   = 0;
-        ino_t            oldino     = 0;
-        uint64_t         oldgen     = 0;
-        dict_t          *xattr      = NULL;
-        inode_t         *inode      = NULL;
-        char            *buf        = NULL;
-
-        frame = myframe;
-        local = frame->local;
-        inode = local->loc.inode;
-        frame->local = NULL;
-
-        if (-1 == req->rpc_status) {
-                rsp.op_ret   = -1;
-                rsp.op_errno = ENOTCONN;
-                goto out;
-        }
-
-        ret = xdr_to_lookup_rsp (*iov, &rsp);
-        if (ret < 0) {
-                gf_log ("", GF_LOG_ERROR, "error");
-                rsp.op_ret   = -1;
-                rsp.op_errno = EINVAL;
-                goto out;
-        }
-
-        op_errno = gf_error_to_errno (rsp.op_errno);
-        gf_stat_to_iatt (&rsp.postparent, &postparent);
-
-        if (rsp.op_ret == 0) {
-                rsp.op_ret = -1;
-                gf_stat_to_iatt (&rsp.stat, &stbuf);
-
-                ret = inode_ctx_get2 (inode, frame->this, &oldino, &oldgen);
-                if (oldino != stbuf.ia_ino || oldgen != stbuf.ia_gen) {
-                        if (oldino) {
-                                gf_log (frame->this->name, GF_LOG_DEBUG,
-                                        "LOOKUP %"PRId64"/%s (%s): "
-                                        "inode number changed from "
-                                        "{%"PRId64",%"PRId64"} to {%"PRId64",%"PRId64"}",
-                                        local->loc.parent ?
-                                        local->loc.parent->ino : (uint64_t) 0,
-                                        local->loc.name,
-                                        local->loc.path,
-                                        oldgen, oldino, stbuf.ia_gen, stbuf.ia_ino);
-                                op_errno = ESTALE;
-                                goto out;
-                        }
-
-                        ret = inode_ctx_put2 (inode, frame->this,
-                                              stbuf.ia_ino, stbuf.ia_gen);
-                        if (ret < 0) {
-                                gf_log (frame->this->name, GF_LOG_DEBUG,
-                                        "LOOKUP %"PRId64"/%s (%s) : "
-                                        "failed to set remote inode "
-                                        "number to inode ctx",
-                                        local->loc.parent ?
-                                        local->loc.parent->ino : (uint64_t) 0,
-                                        local->loc.name,
-                                        local->loc.path);
-                        }
-                }
-
-                if (rsp.dict.dict_len > 0) {
-                        xattr = dict_new();
-                        GF_VALIDATE_OR_GOTO (frame->this->name, xattr, out);
-
-                        buf = memdup (rsp.dict.dict_val, rsp.dict.dict_len);
-                        GF_VALIDATE_OR_GOTO (frame->this->name, buf, out);
-
-                        ret = dict_unserialize (buf, rsp.dict.dict_len, &xattr);
-                        if (ret < 0) {
-                                gf_log (frame->this->name, GF_LOG_DEBUG,
-                                        "%s (%"PRId64"): failed to "
-                                        "unserialize dictionary",
-                                        local->loc.path, inode->ino);
-                                op_errno = EINVAL;
-                                goto out;
-                        }
-
-                        xattr->extra_free = buf;
-                        buf = NULL;
-                }
-
-                rsp.op_ret = 0;
-        }
-
-out:
-        frame->local = NULL;
-        STACK_UNWIND_STRICT (lookup, frame, rsp.op_ret, rsp.op_errno, inode,
-                             &stbuf, xattr, &postparent);
-
-        client_local_wipe (local);
-
-        if (xattr)
-                dict_unref (xattr);
-
-        if (rsp.dict.dict_val) {
-                /* don't use GF_FREE, this memory was allocated by libc
-                 */
-                free (rsp.dict.dict_val);
-                rsp.dict.dict_val = NULL;
-        }
-
-        if (buf) {
-                GF_FREE (buf);
-        }
-
-        return 0;
-}
-
-int
-client3_1_readv_cbk (struct rpc_req *req, struct iovec *iov, int count,
-                     void *myframe)
-{
-        call_frame_t  *frame  = NULL;
-        struct iobref *iobref = NULL;
-        struct iovec   vector = {0,};
-        struct iatt    stat   = {0,};
-        gfs3_read_rsp  rsp    = {0,};
-        int            ret    = 0;
-
-        frame = myframe;
-
-        if (-1 == req->rpc_status) {
-                rsp.op_ret   = -1;
-                rsp.op_errno = ENOTCONN;
-                goto out;
-        }
-
-        ret = xdr_to_readv_rsp (*iov, &rsp);
-        if (ret < 0) {
-                gf_log ("", GF_LOG_ERROR, "error");
-                rsp.op_ret   = -1;
-                rsp.op_errno = EINVAL;
-                goto out;
-        }
-
-        if (rsp.op_ret != -1) {
-                iobref = iobref_new ();
-                gf_stat_to_iatt (&rsp.stat, &stat);
-                vector.iov_len  = rsp.op_ret;
-
-                if (rsp.op_ret > 0) {
-                        vector.iov_base = req->rsp_procpayload->ptr;
-                        iobref_add (iobref, req->rsp_procpayload);
-                }
-        }
-out:
-        STACK_UNWIND_STRICT (readv, frame, rsp.op_ret,
-                             gf_error_to_errno (rsp.op_errno), &vector, 1,
-                             &stat, iobref);
-
-        if (iobref) {
-                iobref_unref (iobref);
-        }
-
-        return 0;
-}
 
 /* Table Specific to FOPS */
 
 
 rpc_clnt_procedure_t clnt3_1_fop_actors[GF_FOP_MAXVALUE] = {
-        [GF_FOP_NULL]        = {"NULL", NULL, NULL },
-        [GF_FOP_STAT]        = { "STAT", client3_1_stat, client3_1_stat_cbk },
-        [GF_FOP_READLINK]    = { "READLINK", client3_1_readlink, client3_1_readlink_cbk },
-        [GF_FOP_MKNOD]       = { "MKNOD", client3_1_mknod, client3_1_mknod_cbk },
-        [GF_FOP_MKDIR]       = { "MKDIR", client3_1_mkdir, client3_1_mkdir_cbk },
-        [GF_FOP_UNLINK]      = { "UNLINK", client3_1_unlink, client3_1_unlink_cbk },
-        [GF_FOP_RMDIR]       = { "RMDIR", client3_1_rmdir, client3_1_rmdir_cbk },
-        [GF_FOP_SYMLINK]     = { "SYMLINK", client3_1_symlink, client3_1_symlink_cbk },
-        [GF_FOP_RENAME]      = { "RENAME", client3_1_rename, client3_1_rename_cbk },
-        [GF_FOP_LINK]        = { "LINK",  client3_1_link, client3_1_link_cbk },
-        [GF_FOP_TRUNCATE]    = { "TRUNCATE",  client3_1_truncate, client3_1_truncate_cbk },
-        [GF_FOP_OPEN]        = { "OPEN",  client3_1_open, client3_1_open_cbk },
-        [GF_FOP_READ]        = { "READ",  client3_1_readv, client3_1_readv_cbk },
-        [GF_FOP_WRITE]       = { "WRITE", client3_1_writev, client3_1_writev_cbk },
-        [GF_FOP_STATFS]      = { "STATFS", client3_1_statfs, client3_1_statfs_cbk },
-        [GF_FOP_FLUSH]       = { "FLUSH", client3_1_flush, client3_1_flush_cbk },
-        [GF_FOP_FSYNC]       = { "FSYNC",         client3_1_fsync, client3_1_fsync_cbk },
-        [GF_FOP_SETXATTR]    = { "SETXATTR",     client3_1_setxattr, client3_1_setxattr_cbk },
-        [GF_FOP_GETXATTR]    = { "GETXATTR",     client3_1_getxattr, client3_1_getxattr_cbk },
-        [GF_FOP_REMOVEXATTR] = { "REMOVEXATTR",  client3_1_removexattr, client3_1_removexattr_cbk },
-        [GF_FOP_OPENDIR]     = { "OPENDIR",     client3_1_opendir, client3_1_opendir_cbk },
-        [GF_FOP_FSYNCDIR]    = { "FSYNCDIR",    client3_1_fsyncdir, client3_1_fsyncdir_cbk },
-        [GF_FOP_ACCESS]      = { "ACCESS",      client3_1_access, client3_1_access_cbk },
-        [GF_FOP_CREATE]      = { "CREATE",      client3_1_create, client3_1_create_cbk },
-        [GF_FOP_FTRUNCATE]   = { "FTRUNCATE",   client3_1_ftruncate, client3_1_ftruncate_cbk },
-        [GF_FOP_FSTAT]       = { "FSTAT",       client3_1_fstat, client3_1_fstat_cbk },
-        [GF_FOP_LK]          = { "LK",          client3_1_lk, client3_1_lk_cbk },
-        [GF_FOP_LOOKUP]      = { "LOOKUP",      client3_1_lookup, client3_1_lookup_cbk },
-        [GF_FOP_READDIR]     = { "READDIR",     client3_1_readdir, client3_1_readdir_cbk },
-        [GF_FOP_INODELK]     = { "INODELK",     client3_1_inodelk, client3_1_inodelk_cbk },
-        [GF_FOP_FINODELK]    = { "FINODELK",    client3_1_finodelk, client3_1_finodelk_cbk },
-        [GF_FOP_ENTRYLK]     = { "ENTRYLK",     client3_1_entrylk, client3_1_entrylk_cbk },
-        [GF_FOP_FENTRYLK]    = { "FENTRYLK",    client3_1_fentrylk, client3_1_fentrylk_cbk },
-        [GF_FOP_CHECKSUM]    = { "CHECKSUM",    client3_1_checksum, client3_1_checksum_cbk },
-        [GF_FOP_XATTROP]     = { "XATTROP",     client3_1_xattrop, client3_1_xattrop_cbk },
-        [GF_FOP_FXATTROP]    = { "FXATTROP",    client3_1_fxattrop, client3_1_fxattrop_cbk },
-        [GF_FOP_FGETXATTR]   = { "FGETXATTR",   client3_1_fgetxattr, client3_1_fgetxattr_cbk },
-        [GF_FOP_FSETXATTR]   = { "FSETXATTR",   client3_1_fsetxattr, client3_1_fsetxattr_cbk },
-        [GF_FOP_RCHECKSUM]   = { "RCHECKSUM",   client3_1_rchecksum, client3_1_rchecksum_cbk },
-        [GF_FOP_SETATTR]     = { "SETATTR",     client3_1_setattr, client3_1_setattr_cbk },
-        [GF_FOP_FSETATTR]    = { "FSETATTR",    client3_1_fsetattr, client3_1_fsetattr_cbk },
-        [GF_FOP_READDIRP]    = { "READDIRP",    client3_1_readdirp, client3_1_readdirp_cbk },
-        [GF_FOP_FORGET]      = { "FORGET",      NULL, client3_1_release_cbk },
-        [GF_FOP_RELEASE]     = { "RELEASE",     client3_1_release, client3_1_release_cbk },
-        [GF_FOP_RELEASEDIR]  = { "RELEASEDIR",  client3_1_releasedir, client3_1_releasedir_cbk },
-//        [GF_FOP_GETSPEC]     = { "GETSPEC",   client_getspec, client_getspec_cbk },
+        [GF_FOP_NULL]        = { "NULL",        NULL},
+        [GF_FOP_STAT]        = { "STAT",        client3_1_stat },
+        [GF_FOP_READLINK]    = { "READLINK",    client3_1_readlink },
+        [GF_FOP_MKNOD]       = { "MKNOD",       client3_1_mknod },
+        [GF_FOP_MKDIR]       = { "MKDIR",       client3_1_mkdir },
+        [GF_FOP_UNLINK]      = { "UNLINK",      client3_1_unlink },
+        [GF_FOP_RMDIR]       = { "RMDIR",       client3_1_rmdir },
+        [GF_FOP_SYMLINK]     = { "SYMLINK",     client3_1_symlink },
+        [GF_FOP_RENAME]      = { "RENAME",      client3_1_rename },
+        [GF_FOP_LINK]        = { "LINK",        client3_1_link },
+        [GF_FOP_TRUNCATE]    = { "TRUNCATE",    client3_1_truncate },
+        [GF_FOP_OPEN]        = { "OPEN",        client3_1_open },
+        [GF_FOP_READ]        = { "READ",        client3_1_readv },
+        [GF_FOP_WRITE]       = { "WRITE",       client3_1_writev },
+        [GF_FOP_STATFS]      = { "STATFS",      client3_1_statfs },
+        [GF_FOP_FLUSH]       = { "FLUSH",       client3_1_flush },
+        [GF_FOP_FSYNC]       = { "FSYNC",       client3_1_fsync },
+        [GF_FOP_SETXATTR]    = { "SETXATTR",    client3_1_setxattr },
+        [GF_FOP_GETXATTR]    = { "GETXATTR",    client3_1_getxattr },
+        [GF_FOP_REMOVEXATTR] = { "REMOVEXATTR", client3_1_removexattr },
+        [GF_FOP_OPENDIR]     = { "OPENDIR",     client3_1_opendir },
+        [GF_FOP_FSYNCDIR]    = { "FSYNCDIR",    client3_1_fsyncdir },
+        [GF_FOP_ACCESS]      = { "ACCESS",      client3_1_access },
+        [GF_FOP_CREATE]      = { "CREATE",      client3_1_create },
+        [GF_FOP_FTRUNCATE]   = { "FTRUNCATE",   client3_1_ftruncate },
+        [GF_FOP_FSTAT]       = { "FSTAT",       client3_1_fstat },
+        [GF_FOP_LK]          = { "LK",          client3_1_lk },
+        [GF_FOP_LOOKUP]      = { "LOOKUP",      client3_1_lookup },
+        [GF_FOP_READDIR]     = { "READDIR",     client3_1_readdir },
+        [GF_FOP_INODELK]     = { "INODELK",     client3_1_inodelk },
+        [GF_FOP_FINODELK]    = { "FINODELK",    client3_1_finodelk },
+        [GF_FOP_ENTRYLK]     = { "ENTRYLK",     client3_1_entrylk },
+        [GF_FOP_FENTRYLK]    = { "FENTRYLK",    client3_1_fentrylk },
+        [GF_FOP_CHECKSUM]    = { "CHECKSUM",    client3_1_checksum },
+        [GF_FOP_XATTROP]     = { "XATTROP",     client3_1_xattrop },
+        [GF_FOP_FXATTROP]    = { "FXATTROP",    client3_1_fxattrop },
+        [GF_FOP_FGETXATTR]   = { "FGETXATTR",   client3_1_fgetxattr },
+        [GF_FOP_FSETXATTR]   = { "FSETXATTR",   client3_1_fsetxattr },
+        [GF_FOP_RCHECKSUM]   = { "RCHECKSUM",   client3_1_rchecksum },
+        [GF_FOP_SETATTR]     = { "SETATTR",     client3_1_setattr },
+        [GF_FOP_FSETATTR]    = { "FSETATTR",    client3_1_fsetattr },
+        [GF_FOP_READDIRP]    = { "READDIRP",    client3_1_readdirp },
+        [GF_FOP_RELEASE]     = { "RELEASE",     client3_1_release },
+        [GF_FOP_RELEASEDIR]  = { "RELEASEDIR",  client3_1_releasedir },
+        [GF_FOP_GETSPEC]     = { "GETSPEC",     client3_getspec },
 };
 
-rpc_clnt_prog_t clnt3_1_fop_prog = {
-        .progname = "GlusterFS 3.1",
-        .prognum  = GLUSTER3_1_FOP_PROGRAM,
-        .progver  = GLUSTER3_1_FOP_VERSION,
-        .numproc  = GLUSTER3_1_FOP_PROCCNT,
-        .actor    = clnt3_1_fop_actors,
+/* Used From RPC-CLNT library to log proper name of procedure based on number */
+char *clnt3_1_fop_names[GFS3_OP_MAXVALUE] = {
+        [GFS3_OP_NULL]        = "NULL",
+        [GFS3_OP_STAT]        = "STAT",
+        [GFS3_OP_READLINK]    = "READLINK",
+        [GFS3_OP_MKNOD]       = "MKNOD",
+        [GFS3_OP_MKDIR]       = "MKDIR",
+        [GFS3_OP_UNLINK]      = "UNLINK",
+        [GFS3_OP_RMDIR]       = "RMDIR",
+        [GFS3_OP_SYMLINK]     = "SYMLINK",
+        [GFS3_OP_RENAME]      = "RENAME",
+        [GFS3_OP_LINK]        = "LINK",
+        [GFS3_OP_TRUNCATE]    = "TRUNCATE",
+        [GFS3_OP_OPEN]        = "OPEN",
+        [GFS3_OP_READ]        = "READ",
+        [GFS3_OP_WRITE]       = "WRITE",
+        [GFS3_OP_STATFS]      = "STATFS",
+        [GFS3_OP_FLUSH]       = "FLUSH",
+        [GFS3_OP_FSYNC]       = "FSYNC",
+        [GFS3_OP_SETXATTR]    = "SETXATTR",
+        [GFS3_OP_GETXATTR]    = "GETXATTR",
+        [GFS3_OP_REMOVEXATTR] = "REMOVEXATTR",
+        [GFS3_OP_OPENDIR]     = "OPENDIR",
+        [GFS3_OP_FSYNCDIR]    = "FSYNCDIR",
+        [GFS3_OP_ACCESS]      = "ACCESS",
+        [GFS3_OP_CREATE]      = "CREATE",
+        [GFS3_OP_FTRUNCATE]   = "FTRUNCATE",
+        [GFS3_OP_FSTAT]       = "FSTAT",
+        [GFS3_OP_LK]          = "LK",
+        [GFS3_OP_LOOKUP]      = "LOOKUP",
+        [GFS3_OP_READDIR]     = "READDIR",
+        [GFS3_OP_INODELK]     = "INODELK",
+        [GFS3_OP_FINODELK]    = "FINODELK",
+        [GFS3_OP_ENTRYLK]     = "ENTRYLK",
+        [GFS3_OP_FENTRYLK]    = "FENTRYLK",
+        [GFS3_OP_CHECKSUM]    = "CHECKSUM",
+        [GFS3_OP_XATTROP]     = "XATTROP",
+        [GFS3_OP_FXATTROP]    = "FXATTROP",
+        [GFS3_OP_FGETXATTR]   = "FGETXATTR",
+        [GFS3_OP_FSETXATTR]   = "FSETXATTR",
+        [GFS3_OP_RCHECKSUM]   = "RCHECKSUM",
+        [GFS3_OP_SETATTR]     = "SETATTR",
+        [GFS3_OP_FSETATTR]    = "FSETATTR",
+        [GFS3_OP_READDIRP]    = "READDIRP",
+        [GFS3_OP_RELEASE]     = "RELEASE",
+        [GFS3_OP_RELEASEDIR]  = "RELEASEDIR",
 };
 
-rpc_clnt_procedure_t clnt3_1_mgmt_actors[] = {
-        {0,}
+rpc_clnt_prog_t clnt3_1_fop_prog = {
+        .progname  = "GlusterFS 3.1",
+        .prognum   = GLUSTER3_1_FOP_PROGRAM,
+        .progver   = GLUSTER3_1_FOP_VERSION,
+        .numproc   = GLUSTER3_1_FOP_PROCCNT,
+        .proctable = clnt3_1_fop_actors,
+        .procnames = clnt3_1_fop_names,
 };
 
 rpc_clnt_prog_t clnt3_1_mgmt_prog = {
-        .progname = "Mgmt 3.1",
+        .progname = "Gluster Mgmt 3.1",
         .prognum  = GLUSTER1_MGMT_PROGRAM,
         .progver  = GLUSTER1_MGMT_VERSION,
-        .actor    = clnt3_1_mgmt_actors,
-        .numproc  = (sizeof (*clnt3_1_mgmt_actors) /
-                     sizeof (rpc_clnt_procedure_t)),
 };