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

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

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

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

Updates #384

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

1 files changed, 1441 insertions, 0 deletions

diff --git a/xlators/protocol/client/src/client-common.c b/xlators/protocol/client/src/client-common.c
index 873b0f0f4ae..3b4dea1aff1 100644
--- a/xlators/protocol/client/src/client-common.c
+++ b/xlators/protocol/client/src/client-common.c
@@ -12,6 +12,7 @@
 #include "xlator.h"
 #include "rpc-common-xdr.h"
 #include "glusterfs3-xdr.h"
+#include "glusterfs4-xdr.h"
 #include "glusterfs3.h"
 #include "client.h"
 
@@ -2159,3 +2160,1443 @@ client_post_lease (xlator_t *this, gfs3_lease_rsp *rsp, struct gf_lease *lease,
 out:
         return ret;
 }
+
+
+/* New PRE and POST functions */
+
+int
+client_post_common_iatt (xlator_t *this, gfx_common_iatt_rsp *rsp, struct iatt *iatt,
+                         dict_t **xdata)
+{
+        if (-1 != rsp->op_ret) {
+                gfx_stat_to_iattx (&rsp->stat, iatt);
+        }
+
+        return xdr_to_dict (&rsp->xdata, xdata);
+}
+
+int
+client_post_common_2iatt (xlator_t *this, gfx_common_2iatt_rsp *rsp, struct iatt *iatt,
+                          struct iatt *iatt2, dict_t **xdata)
+{
+        if (-1 != rsp->op_ret) {
+                gfx_stat_to_iattx (&rsp->prestat, iatt);
+                gfx_stat_to_iattx (&rsp->poststat, iatt2);
+        }
+
+        return xdr_to_dict (&rsp->xdata, xdata);
+}
+
+int
+client_post_common_3iatt (xlator_t *this, gfx_common_3iatt_rsp *rsp, struct iatt *iatt,
+                          struct iatt *iatt2, struct iatt *iatt3, dict_t **xdata)
+{
+        if (-1 != rsp->op_ret) {
+                gfx_stat_to_iattx (&rsp->stat, iatt);
+                gfx_stat_to_iattx (&rsp->preparent, iatt2);
+                gfx_stat_to_iattx (&rsp->postparent, iatt3);
+        }
+
+        return xdr_to_dict (&rsp->xdata, xdata);
+}
+
+int
+client_post_common_dict (xlator_t *this, gfx_common_dict_rsp *rsp, dict_t **dict,
+                         dict_t **xdata)
+{
+        int ret = 0;
+        ret = xdr_to_dict (&rsp->dict, dict);
+        if (ret)
+                gf_msg_debug (this->name, EINVAL,
+                              "while decoding found empty dictionary");
+        xdr_to_dict (&rsp->xdata, xdata);
+
+        return ret;
+}
+
+int
+client_post_readv_v2 (xlator_t *this, gfx_read_rsp *rsp, struct iobref **iobref,
+                      struct iobref *rsp_iobref, struct iatt *stat,
+                      struct iovec *vector, struct iovec *rsp_vector,
+                      int *rspcount, dict_t **xdata)
+{
+        int ret = -1;
+
+        if (rsp->op_ret != -1) {
+                *iobref = rsp_iobref;
+                gfx_stat_to_iattx (&rsp->stat, stat);
+
+                vector[0].iov_len = rsp->op_ret;
+                if (rsp->op_ret > 0)
+                        vector[0].iov_base = rsp_vector->iov_base;
+                *rspcount = 1;
+        }
+
+        ret = xdr_to_dict (&rsp->xdata, xdata);
+
+#ifdef GF_TESTING_IO_XDATA
+        dict_dump_to_log (xdata);
+#endif
+        return ret;
+}
+
+int
+client_pre_stat_v2 (xlator_t *this, gfx_stat_req *req, loc_t *loc,
+                    dict_t *xdata)
+{
+        int            op_errno = ESTALE;
+
+        if (!(loc && loc->inode))
+                goto out;
+
+        if (!gf_uuid_is_null (loc->inode->gfid))
+                memcpy (req->gfid,  loc->inode->gfid, 16);
+        else
+                memcpy (req->gfid, loc->gfid, 16);
+
+        GF_ASSERT_AND_GOTO_WITH_ERROR (this->name,
+                                      !gf_uuid_is_null (*((uuid_t *)req->gfid)),
+                                      out, op_errno, EINVAL);
+
+        dict_to_xdr (xdata, &req->xdata);
+
+        return 0;
+out:
+        return -op_errno;
+}
+
+int
+client_pre_readlink_v2 (xlator_t *this, gfx_readlink_req *req, loc_t *loc,
+                     size_t size, dict_t *xdata)
+{
+        int                op_errno          = ESTALE;
+
+        if (!(loc && loc->inode))
+                goto out;
+
+        if (!gf_uuid_is_null (loc->inode->gfid))
+                memcpy (req->gfid,  loc->inode->gfid, 16);
+        else
+                memcpy (req->gfid, loc->gfid, 16);
+
+        GF_ASSERT_AND_GOTO_WITH_ERROR (this->name,
+                                      !gf_uuid_is_null (*((uuid_t *)req->gfid)),
+                                      out, op_errno, EINVAL);
+        req->size = size;
+        dict_to_xdr (xdata, &req->xdata);
+        return 0;
+out:
+        return -op_errno;
+}
+
+int
+client_pre_mknod_v2 (xlator_t *this, gfx_mknod_req *req, loc_t *loc,
+                   mode_t mode, dev_t rdev, mode_t umask, dict_t *xdata)
+{
+        int             op_errno = ESTALE;
+
+        if (!(loc && loc->parent))
+                goto out;
+
+        if (!gf_uuid_is_null (loc->parent->gfid))
+                memcpy (req->pargfid,  loc->parent->gfid, 16);
+        else
+                memcpy (req->pargfid, loc->pargfid, 16);
+
+        GF_ASSERT_AND_GOTO_WITH_ERROR (this->name,
+                                   !gf_uuid_is_null (*((uuid_t *)req->pargfid)),
+                                   out, op_errno, EINVAL);
+        req->bname  = (char *)loc->name;
+        req->mode   = mode;
+        req->dev    = rdev;
+        req->umask = umask;
+
+
+        dict_to_xdr (xdata, &req->xdata);
+
+        return 0;
+out:
+        return -op_errno;
+}
+
+int
+client_pre_mkdir_v2 (xlator_t *this, gfx_mkdir_req *req, loc_t *loc,
+                   mode_t mode, mode_t umask, dict_t *xdata)
+{
+        int             op_errno = ESTALE;
+
+        if (!(loc && loc->parent))
+                goto out;
+
+        if (!gf_uuid_is_null (loc->parent->gfid))
+                memcpy (req->pargfid,  loc->parent->gfid, 16);
+        else
+                memcpy (req->pargfid, loc->pargfid, 16);
+
+        GF_ASSERT_AND_GOTO_WITH_ERROR (this->name,
+                                   !gf_uuid_is_null (*((uuid_t *)req->pargfid)),
+                                   out, op_errno, EINVAL);
+
+        req->bname = (char *)loc->name;
+        req->mode  = mode;
+        req->umask = umask;
+
+        dict_to_xdr (xdata, &req->xdata);
+
+        return 0;
+out:
+        return -op_errno;
+}
+
+int
+client_pre_unlink_v2 (xlator_t *this, gfx_unlink_req *req, loc_t *loc,
+                    int32_t flags, dict_t *xdata)
+{
+        int              op_errno = 0;
+
+        if (!(loc && loc->parent))
+                goto out;
+
+        if (!gf_uuid_is_null (loc->parent->gfid))
+                memcpy (req->pargfid,  loc->parent->gfid, 16);
+        else
+                memcpy (req->pargfid, loc->pargfid, 16);
+
+        GF_ASSERT_AND_GOTO_WITH_ERROR (this->name,
+                                   !gf_uuid_is_null (*((uuid_t *)req->pargfid)),
+                                   out, op_errno, EINVAL);
+        req->bname = (char *)loc->name;
+        req->xflags = flags;
+
+        dict_to_xdr (xdata, &req->xdata);
+
+        return 0;
+out:
+        return -op_errno;
+}
+
+int
+client_pre_rmdir_v2 (xlator_t *this, gfx_rmdir_req *req, loc_t *loc,
+                   int32_t flags, dict_t *xdata)
+{
+        int             op_errno = ESTALE;
+
+        if (!(loc && loc->parent))
+                goto out;
+
+        if (!gf_uuid_is_null (loc->parent->gfid))
+                memcpy (req->pargfid,  loc->parent->gfid, 16);
+        else
+                memcpy (req->pargfid, loc->pargfid, 16);
+
+        GF_ASSERT_AND_GOTO_WITH_ERROR (this->name,
+                                   !gf_uuid_is_null (*((uuid_t *)req->pargfid)),
+                                   out, op_errno, EINVAL);
+        req->bname = (char *)loc->name;
+        req->xflags = flags;
+
+        dict_to_xdr (xdata, &req->xdata);
+
+        return 0;
+out:
+        return -op_errno;
+}
+
+int
+client_pre_symlink_v2 (xlator_t *this, gfx_symlink_req *req, loc_t *loc,
+                     const char *linkname, mode_t umask, dict_t *xdata)
+{
+        int               op_errno = ESTALE;
+
+        if (!(loc && loc->parent))
+                goto out;
+
+        if (!gf_uuid_is_null (loc->parent->gfid))
+                memcpy (req->pargfid,  loc->parent->gfid, 16);
+        else
+                memcpy (req->pargfid, loc->pargfid, 16);
+
+        GF_ASSERT_AND_GOTO_WITH_ERROR (this->name,
+                                   !gf_uuid_is_null (*((uuid_t *)req->pargfid)),
+                                   out, op_errno, EINVAL);
+        req->linkname = (char *)linkname;
+        req->bname    = (char *)loc->name;
+        req->umask = umask;
+
+        dict_to_xdr (xdata, &req->xdata);
+        return 0;
+out:
+        return -op_errno;
+}
+
+int
+client_pre_rename_v2 (xlator_t *this, gfx_rename_req *req, loc_t *oldloc,
+                    loc_t *newloc, dict_t *xdata)
+{
+        int              op_errno = ESTALE;
+
+        if (!(oldloc && newloc && oldloc->parent &&
+              newloc->parent))
+                goto out;
+
+        if (!gf_uuid_is_null (oldloc->parent->gfid))
+                memcpy (req->oldgfid,  oldloc->parent->gfid, 16);
+        else
+                memcpy (req->oldgfid, oldloc->pargfid, 16);
+
+        if (!gf_uuid_is_null (newloc->parent->gfid))
+                memcpy (req->newgfid, newloc->parent->gfid, 16);
+        else
+                memcpy (req->newgfid, newloc->pargfid, 16);
+
+        GF_ASSERT_AND_GOTO_WITH_ERROR (this->name,
+                                   !gf_uuid_is_null (*((uuid_t *)req->oldgfid)),
+                                   out, op_errno, EINVAL);
+        GF_ASSERT_AND_GOTO_WITH_ERROR (this->name,
+                                   !gf_uuid_is_null (*((uuid_t *)req->newgfid)),
+                                   out, op_errno, EINVAL);
+        req->oldbname =  (char *)oldloc->name;
+        req->newbname = (char *)newloc->name;
+
+        dict_to_xdr (xdata, &req->xdata);
+
+        return 0;
+out:
+        return -op_errno;
+}
+
+int
+client_pre_link_v2 (xlator_t *this,
+                  gfx_link_req *req, loc_t *oldloc, loc_t *newloc,
+                  dict_t *xdata)
+{
+        int            op_errno = ESTALE;
+
+        if (!(oldloc && oldloc->inode && newloc &&
+              newloc->parent))
+                goto out;
+
+        if (!gf_uuid_is_null (oldloc->inode->gfid))
+                memcpy (req->oldgfid,  oldloc->inode->gfid, 16);
+        else
+                memcpy (req->oldgfid, oldloc->gfid, 16);
+
+        if (!gf_uuid_is_null (newloc->parent->gfid))
+                memcpy (req->newgfid, newloc->parent->gfid, 16);
+        else
+                memcpy (req->newgfid, newloc->pargfid, 16);
+
+        GF_ASSERT_AND_GOTO_WITH_ERROR (this->name,
+                                   !gf_uuid_is_null (*((uuid_t *)req->oldgfid)),
+                                   out, op_errno, EINVAL);
+        GF_ASSERT_AND_GOTO_WITH_ERROR (this->name,
+                                   !gf_uuid_is_null (*((uuid_t *)req->newgfid)),
+                                   out, op_errno, EINVAL);
+        req->newbname = (char *)newloc->name;
+
+        dict_to_xdr (xdata, &req->xdata);
+
+        return 0;
+out:
+        return -op_errno;
+}
+
+int
+client_pre_truncate_v2 (xlator_t *this, gfx_truncate_req *req,
+                     loc_t *loc, off_t offset, dict_t *xdata)
+{
+        int             op_errno = ESTALE;
+
+        if (!(loc && loc->inode))
+                goto out;
+
+        if (!gf_uuid_is_null (loc->inode->gfid))
+                memcpy (req->gfid,  loc->inode->gfid, 16);
+        else
+                memcpy (req->gfid, loc->gfid, 16);
+
+        GF_ASSERT_AND_GOTO_WITH_ERROR (this->name,
+                                      !gf_uuid_is_null (*((uuid_t *)req->gfid)),
+                                      out, op_errno, EINVAL);
+        req->offset = offset;
+
+        dict_to_xdr (xdata, &req->xdata);
+        return 0;
+out:
+        return -op_errno;
+}
+
+int
+client_pre_open_v2 (xlator_t *this, gfx_open_req *req, loc_t *loc, fd_t *fd,
+                  int32_t flags, dict_t *xdata)
+{
+        int            op_errno = ESTALE;
+
+        if (!(loc && loc->inode))
+                goto out;
+
+        if (!gf_uuid_is_null (loc->inode->gfid))
+                memcpy (req->gfid,  loc->inode->gfid, 16);
+        else
+                memcpy (req->gfid, loc->gfid, 16);
+
+        GF_ASSERT_AND_GOTO_WITH_ERROR (this->name,
+                                      !gf_uuid_is_null (*((uuid_t *)req->gfid)),
+                                      out, op_errno, EINVAL);
+        req->flags = gf_flags_from_flags (flags);
+
+        dict_to_xdr (xdata, &req->xdata);
+
+        return 0;
+out:
+        return -op_errno;
+}
+
+int
+client_pre_readv_v2 (xlator_t *this, gfx_read_req *req, fd_t *fd, size_t size,
+                  off_t offset, int32_t flags, dict_t *xdata)
+{
+        int64_t         remote_fd  = -1;
+        int             op_errno   = ESTALE;
+
+        CLIENT_GET_REMOTE_FD (this, fd, FALLBACK_TO_ANON_FD,
+                              remote_fd, op_errno, out);
+
+        req->size   = size;
+        req->offset = offset;
+        req->fd     = remote_fd;
+        req->flag   = flags;
+
+        memcpy (req->gfid, fd->inode->gfid, 16);
+
+        dict_to_xdr (xdata, &req->xdata);
+
+        return 0;
+out:
+        return -op_errno;
+}
+
+int
+client_pre_writev_v2 (xlator_t *this, gfx_write_req *req,
+                   fd_t *fd, size_t size, off_t offset, int32_t flags,
+                   dict_t **xdata)
+{
+        int64_t         remote_fd = -1;
+        int             op_errno = ESTALE;
+
+        CLIENT_GET_REMOTE_FD (this, fd, FALLBACK_TO_ANON_FD,
+                              remote_fd, op_errno, out);
+
+        req->size   = size;
+        req->offset = offset;
+        req->fd     = remote_fd;
+        req->flag   = flags;
+
+        memcpy (req->gfid, fd->inode->gfid, 16);
+
+#ifdef GF_TESTING_IO_XDATA
+        if (!*xdata)
+                *xdata = dict_new ();
+
+        ret = dict_set_str (*xdata, "testing-the-xdata-key",
+                            "testing-the-xdata-value");
+#endif
+
+        dict_to_xdr (*xdata, &req->xdata);
+
+        return 0;
+out:
+        return -op_errno;
+}
+
+int
+client_pre_statfs_v2 (xlator_t *this, gfx_statfs_req *req, loc_t *loc,
+                   dict_t *xdata)
+{
+        int            op_errno = ESTALE;
+
+        if (!loc)
+                goto out;
+
+        if (loc->inode) {
+                if (!gf_uuid_is_null (loc->inode->gfid))
+                        memcpy (req->gfid,  loc->inode->gfid, 16);
+                else
+                        memcpy (req->gfid, loc->gfid, 16);
+        } else {
+                req->gfid[15] = 1;
+        }
+
+        GF_ASSERT_AND_GOTO_WITH_ERROR (this->name,
+                                      !gf_uuid_is_null (*((uuid_t *)req->gfid)),
+                                      out, op_errno, EINVAL);
+
+        dict_to_xdr (xdata, &req->xdata);
+
+        return 0;
+out:
+        return -op_errno;
+}
+
+int
+client_pre_flush_v2 (xlator_t *this, gfx_flush_req *req, fd_t *fd, dict_t *xdata)
+{
+        int64_t         remote_fd = -1;
+        int             op_errno = ESTALE;
+
+        CLIENT_GET_REMOTE_FD (this, fd, DEFAULT_REMOTE_FD,
+                              remote_fd, op_errno, out);
+
+        req->fd = remote_fd;
+        memcpy (req->gfid, fd->inode->gfid, 16);
+
+        dict_to_xdr (xdata, &req->xdata);
+
+        return 0;
+out:
+        return -op_errno;
+}
+
+int
+client_pre_fsync_v2 (xlator_t *this, gfx_fsync_req *req, fd_t *fd,
+                   int32_t flags, dict_t *xdata)
+{
+        int64_t         remote_fd = -1;
+        int             op_errno  = 0;
+
+        CLIENT_GET_REMOTE_FD (this, fd, DEFAULT_REMOTE_FD,
+                              remote_fd, op_errno, out);
+
+        req->fd   = remote_fd;
+        req->data = flags;
+        memcpy (req->gfid, fd->inode->gfid, 16);
+
+        dict_to_xdr (xdata, &req->xdata);
+
+        return 0;
+out:
+        return -op_errno;
+}
+
+int
+client_pre_setxattr_v2 (xlator_t *this, gfx_setxattr_req *req, loc_t *loc,
+                      dict_t *xattr, int32_t flags, dict_t *xdata)
+{
+        int                op_errno = ESTALE;
+
+        if (!(loc && loc->inode))
+                goto out;
+
+        if (!gf_uuid_is_null (loc->inode->gfid))
+                memcpy (req->gfid,  loc->inode->gfid, 16);
+        else
+                memcpy (req->gfid, loc->gfid, 16);
+
+        GF_ASSERT_AND_GOTO_WITH_ERROR (this->name,
+                                      !gf_uuid_is_null (*((uuid_t *)req->gfid)),
+                                      out, op_errno, EINVAL);
+        if (xattr) {
+                dict_to_xdr (xattr, &req->dict);
+        }
+
+        req->flags = flags;
+
+        dict_to_xdr (xdata, &req->xdata);
+
+        return 0;
+out:
+        return -op_errno;
+}
+
+int
+client_pre_getxattr_v2 (xlator_t *this, gfx_getxattr_req *req, loc_t *loc,
+                     const char *name, dict_t *xdata)
+{
+        int                op_errno   = ESTALE;
+
+        if (!loc) {
+                op_errno = EINVAL;
+                goto out;
+        }
+
+        if (loc->inode && !gf_uuid_is_null (loc->inode->gfid))
+                memcpy (req->gfid,  loc->inode->gfid, 16);
+        else
+                memcpy (req->gfid, loc->gfid, 16);
+
+        GF_ASSERT_AND_GOTO_WITH_ERROR (this->name,
+                                      !gf_uuid_is_null (*((uuid_t *)req->gfid)),
+                                      out, op_errno, EINVAL);
+        req->namelen = 1; /* Use it as a flag */
+
+        req->name = (char *)name;
+        if (!req->name) {
+                req->name = "";
+                req->namelen = 0;
+        }
+
+        dict_to_xdr (xdata, &req->xdata);
+
+        return 0;
+out:
+        return -op_errno;
+}
+
+int
+client_pre_removexattr_v2 (xlator_t *this, gfx_removexattr_req *req,
+                         loc_t *loc, const char *name, dict_t *xdata)
+{
+        int                   op_errno = ESTALE;
+
+        if (!(loc && loc->inode))
+                goto out;
+
+        if (!gf_uuid_is_null (loc->inode->gfid))
+                memcpy (req->gfid,  loc->inode->gfid, 16);
+        else
+                memcpy (req->gfid, loc->gfid, 16);
+
+        GF_ASSERT_AND_GOTO_WITH_ERROR (this->name,
+                                      !gf_uuid_is_null (*((uuid_t *)req->gfid)),
+                                      out, op_errno, EINVAL);
+        req->name = (char *)name;
+
+        dict_to_xdr (xdata, &req->xdata);
+
+        return 0;
+out:
+        return -op_errno;
+}
+
+int
+client_pre_opendir_v2 (xlator_t *this,
+                    gfx_opendir_req *req, loc_t *loc,
+                    fd_t *fd, dict_t *xdata)
+{
+        int               op_errno = ESTALE;
+
+        if (!(loc && loc->inode))
+                goto out;
+
+        if (!gf_uuid_is_null (loc->inode->gfid))
+                memcpy (req->gfid,  loc->inode->gfid, 16);
+        else
+                memcpy (req->gfid, loc->gfid, 16);
+
+        GF_ASSERT_AND_GOTO_WITH_ERROR (this->name,
+                                      !gf_uuid_is_null (*((uuid_t *)req->gfid)),
+                                      out, op_errno, EINVAL);
+
+        dict_to_xdr (xdata, &req->xdata);
+
+        return 0;
+out:
+        return -op_errno;
+}
+
+int
+client_pre_fsyncdir_v2 (xlator_t *this, gfx_fsyncdir_req *req, fd_t *fd,
+                      int32_t flags, dict_t *xdata)
+{
+        int32_t            op_errno  = ESTALE;
+        int64_t            remote_fd = -1;
+
+        CLIENT_GET_REMOTE_FD (this, fd, DEFAULT_REMOTE_FD,
+                              remote_fd, op_errno, out);
+
+        req->fd   = remote_fd;
+        req->data = flags;
+        memcpy (req->gfid, fd->inode->gfid, 16);
+
+        dict_to_xdr (xdata, &req->xdata);
+
+        return 0;
+out:
+        return -op_errno;
+}
+
+int
+client_pre_access_v2 (xlator_t *this, gfx_access_req *req, loc_t *loc,
+                   int32_t mask, dict_t *xdata)
+{
+        int              op_errno = ESTALE;
+
+        if (!(loc && loc->inode))
+                goto out;
+
+        if (!gf_uuid_is_null (loc->inode->gfid))
+                memcpy (req->gfid,  loc->inode->gfid, 16);
+        else
+                memcpy (req->gfid, loc->gfid, 16);
+
+        GF_ASSERT_AND_GOTO_WITH_ERROR (this->name,
+                                      !gf_uuid_is_null (*((uuid_t *)req->gfid)),
+                                      out, op_errno, EINVAL);
+        req->mask = mask;
+
+        dict_to_xdr (xdata, &req->xdata);
+        return 0;
+out:
+        return -op_errno;
+}
+
+int
+client_pre_create_v2 (xlator_t *this, gfx_create_req *req,
+                    loc_t *loc, fd_t *fd, mode_t mode,
+                    int32_t flags, mode_t umask, dict_t *xdata)
+{
+        int              op_errno = ESTALE;
+
+        if (!(loc && loc->parent))
+                goto out;
+
+        if (!gf_uuid_is_null (loc->parent->gfid))
+                memcpy (req->pargfid,  loc->parent->gfid, 16);
+        else
+                memcpy (req->pargfid, loc->pargfid, 16);
+
+        GF_ASSERT_AND_GOTO_WITH_ERROR (this->name,
+                                   !gf_uuid_is_null (*((uuid_t *)req->pargfid)),
+                                   out, op_errno, EINVAL);
+        req->bname = (char *)loc->name;
+        req->mode  = mode;
+        req->flags = gf_flags_from_flags (flags);
+        req->umask = umask;
+
+        dict_to_xdr (xdata, &req->xdata);
+
+        return 0;
+out:
+        return -op_errno;
+}
+
+int
+client_pre_ftruncate_v2 (xlator_t *this, gfx_ftruncate_req *req, fd_t *fd,
+                       off_t offset, dict_t *xdata)
+{
+        int64_t             remote_fd = -1;
+        int                 op_errno = EINVAL;
+
+        CLIENT_GET_REMOTE_FD (this, fd, DEFAULT_REMOTE_FD,
+                              remote_fd, op_errno, out);
+
+        req->offset = offset;
+        req->fd     = remote_fd;
+        memcpy (req->gfid, fd->inode->gfid, 16);
+
+        dict_to_xdr (xdata, &req->xdata);
+        return 0;
+out:
+        return -op_errno;
+}
+
+int
+client_pre_fstat_v2 (xlator_t *this, gfx_fstat_req *req, fd_t *fd,
+                   dict_t *xdata)
+{
+        int64_t         remote_fd = -1;
+        int             op_errno = ESTALE;
+
+        CLIENT_GET_REMOTE_FD (this, fd, DEFAULT_REMOTE_FD,
+                              remote_fd, op_errno, out);
+
+        req->fd = remote_fd;
+        memcpy (req->gfid, fd->inode->gfid, 16);
+
+        dict_to_xdr (xdata, &req->xdata);
+
+        return 0;
+out:
+        return -op_errno;
+}
+
+int
+client_pre_lk_v2 (xlator_t *this, gfx_lk_req *req,
+               int32_t cmd, struct gf_flock *flock, fd_t *fd, dict_t *xdata)
+{
+        int64_t          remote_fd  = -1;
+        int              op_errno   = ESTALE;
+        int32_t          gf_cmd     = 0;
+        int32_t          gf_type    = 0;
+        int              ret        = 0;
+
+        CLIENT_GET_REMOTE_FD (this, fd, DEFAULT_REMOTE_FD,
+                              remote_fd, op_errno, out);
+
+        ret = client_cmd_to_gf_cmd (cmd, &gf_cmd);
+        if (ret) {
+                op_errno = EINVAL;
+                gf_msg (this->name, GF_LOG_WARNING, EINVAL,
+                        PC_MSG_INVALID_ENTRY, "Unknown cmd (%d)!", gf_cmd);
+                goto out;
+        }
+
+        switch (flock->l_type) {
+        case F_RDLCK:
+                gf_type = GF_LK_F_RDLCK;
+                break;
+        case F_WRLCK:
+                gf_type = GF_LK_F_WRLCK;
+                break;
+        case F_UNLCK:
+                gf_type = GF_LK_F_UNLCK;
+                break;
+        }
+
+        req->fd    = remote_fd;
+        req->cmd   = gf_cmd;
+        req->type  = gf_type;
+        gf_proto_flock_from_flock (&req->flock, flock);
+
+        memcpy (req->gfid, fd->inode->gfid, 16);
+
+        dict_to_xdr (xdata, &req->xdata);
+
+        return 0;
+out:
+        return -op_errno;
+}
+
+int
+client_pre_lookup_v2 (xlator_t *this, gfx_lookup_req *req, loc_t *loc,
+                   dict_t *xdata)
+{
+        int              op_errno          = ESTALE;
+
+        if (!(loc && loc->inode))
+                goto out;
+
+        if ((loc->parent) && (!gf_uuid_is_null (loc->parent->gfid)))
+                        memcpy (req->pargfid, loc->parent->gfid, 16);
+                else
+                        memcpy (req->pargfid, loc->pargfid, 16);
+
+        if ((loc->inode) && (!gf_uuid_is_null (loc->inode->gfid)))
+                memcpy (req->gfid, loc->inode->gfid, 16);
+        else
+                memcpy (req->gfid, loc->gfid, 16);
+
+
+        if (loc->name)
+                req->bname = (char *)loc->name;
+        else
+                req->bname = "";
+
+        if (xdata) {
+                dict_to_xdr (xdata, &req->xdata);
+        }
+        return 0;
+out:
+        return -op_errno;
+}
+
+int
+client_pre_readdir_v2 (xlator_t *this, gfx_readdir_req *req, fd_t *fd,
+                    size_t size, off_t offset, dict_t *xdata)
+{
+        int64_t           remote_fd  = -1;
+        int               op_errno   = ESTALE;
+
+        CLIENT_GET_REMOTE_FD (this, fd, DEFAULT_REMOTE_FD,
+                              remote_fd, op_errno, out);
+
+        req->size = size;
+        req->offset = offset;
+        req->fd = remote_fd;
+
+        memcpy (req->gfid, fd->inode->gfid, 16);
+        dict_to_xdr (xdata, &req->xdata);
+
+        return 0;
+out:
+        return -op_errno;
+}
+
+int
+client_pre_inodelk_v2 (xlator_t *this, gfx_inodelk_req *req, loc_t *loc,
+                     int cmd, struct gf_flock *flock, const char *volume,
+                     dict_t *xdata)
+{
+        int               op_errno = ESTALE;
+        int32_t           gf_cmd  = 0;
+        int32_t           gf_type = 0;
+
+        if (!(loc && loc->inode))
+                goto out;
+
+        if (!gf_uuid_is_null (loc->gfid))
+                memcpy (req->gfid,  loc->gfid, 16);
+        else
+                memcpy (req->gfid, loc->inode->gfid, 16);
+
+        GF_ASSERT_AND_GOTO_WITH_ERROR (this->name,
+                                      !gf_uuid_is_null (*((uuid_t *)req->gfid)),
+                                      out, op_errno, EINVAL);
+        if (cmd == F_GETLK || cmd == F_GETLK64)
+                gf_cmd = GF_LK_GETLK;
+        else if (cmd == F_SETLK || cmd == F_SETLK64)
+                gf_cmd = GF_LK_SETLK;
+        else if (cmd == F_SETLKW || cmd == F_SETLKW64)
+                gf_cmd = GF_LK_SETLKW;
+        else {
+                gf_msg (this->name, GF_LOG_WARNING, EINVAL,
+                        PC_MSG_INVALID_ENTRY, "Unknown cmd (%d)!", gf_cmd);
+                op_errno = EINVAL;
+                goto out;
+        }
+
+        switch (flock->l_type) {
+        case F_RDLCK:
+                gf_type = GF_LK_F_RDLCK;
+                break;
+        case F_WRLCK:
+                gf_type = GF_LK_F_WRLCK;
+                break;
+        case F_UNLCK:
+                gf_type = GF_LK_F_UNLCK;
+                break;
+        }
+
+        req->volume = (char *)volume;
+        req->cmd    = gf_cmd;
+        req->type   = gf_type;
+        gf_proto_flock_from_flock (&req->flock, flock);
+
+        dict_to_xdr (xdata, &req->xdata);
+
+        return 0;
+out:
+        return -op_errno;
+}
+
+int
+client_pre_finodelk_v2 (xlator_t *this, gfx_finodelk_req *req, fd_t *fd,
+                     int cmd, struct gf_flock *flock, const char *volume,
+                     dict_t *xdata)
+{
+        int                op_errno = ESTALE;
+        int64_t            remote_fd = -1;
+        int32_t            gf_type  = 0;
+        int32_t            gf_cmd   = 0;
+
+        CLIENT_GET_REMOTE_FD (this, fd, FALLBACK_TO_ANON_FD,
+                              remote_fd, op_errno, out);
+
+        if (cmd == F_GETLK || cmd == F_GETLK64)
+                gf_cmd = GF_LK_GETLK;
+        else if (cmd == F_SETLK || cmd == F_SETLK64)
+                gf_cmd = GF_LK_SETLK;
+        else if (cmd == F_SETLKW || cmd == F_SETLKW64)
+                gf_cmd = GF_LK_SETLKW;
+        else {
+                gf_msg (this->name, GF_LOG_WARNING, EINVAL,
+                        PC_MSG_INVALID_ENTRY, "Unknown cmd (%d)!", gf_cmd);
+                goto out;
+        }
+
+        switch (flock->l_type) {
+        case F_RDLCK:
+                gf_type = GF_LK_F_RDLCK;
+                break;
+        case F_WRLCK:
+                gf_type = GF_LK_F_WRLCK;
+                break;
+        case F_UNLCK:
+                gf_type = GF_LK_F_UNLCK;
+                break;
+        }
+
+        req->volume = (char *)volume;
+        req->fd    = remote_fd;
+        req->cmd   = gf_cmd;
+        req->type  = gf_type;
+        gf_proto_flock_from_flock (&req->flock, flock);
+        memcpy (req->gfid, fd->inode->gfid, 16);
+
+        dict_to_xdr (xdata, &req->xdata);
+        return 0;
+out:
+        return -op_errno;
+}
+
+int
+client_pre_entrylk_v2 (xlator_t *this, gfx_entrylk_req *req, loc_t *loc,
+                     entrylk_cmd cmd_entrylk, entrylk_type type,
+                     const char *volume, const char *basename, dict_t *xdata)
+{
+        int               op_errno = ESTALE;
+
+        if (!(loc && loc->inode))
+                goto out;
+
+        if (!gf_uuid_is_null (loc->gfid))
+                memcpy (req->gfid,  loc->gfid, 16);
+        else
+                memcpy (req->gfid, loc->inode->gfid, 16);
+
+        GF_ASSERT_AND_GOTO_WITH_ERROR (this->name,
+                                      !gf_uuid_is_null (*((uuid_t *)req->gfid)),
+                                      out, op_errno, EINVAL);
+        req->cmd = cmd_entrylk;
+        req->type = type;
+        req->volume = (char *)volume;
+        req->name = "";
+        if (basename) {
+                req->name = (char *)basename;
+                req->namelen = 1;
+        }
+
+        dict_to_xdr (xdata, &req->xdata);
+
+        return 0;
+out:
+        return -op_errno;
+}
+
+int
+client_pre_fentrylk_v2 (xlator_t *this, gfx_fentrylk_req *req, fd_t *fd,
+                      entrylk_cmd cmd_entrylk, entrylk_type type,
+                      const char *volume, const char *basename, dict_t *xdata)
+{
+        int64_t            remote_fd = -1;
+        int                op_errno = ESTALE;
+
+        CLIENT_GET_REMOTE_FD (this, fd, DEFAULT_REMOTE_FD,
+                              remote_fd, op_errno, out);
+
+        req->fd  = remote_fd;
+        req->cmd = cmd_entrylk;
+        req->type = type;
+        req->volume = (char *)volume;
+        req->name = "";
+        if (basename) {
+                req->name = (char *)basename;
+                req->namelen = 1;
+        }
+        memcpy (req->gfid, fd->inode->gfid, 16);
+
+        dict_to_xdr (xdata, &req->xdata);
+
+        return 0;
+out:
+        return -op_errno;
+}
+
+int
+client_pre_xattrop_v2 (xlator_t *this, gfx_xattrop_req *req, loc_t *loc,
+                    dict_t *xattr, int32_t flags, dict_t *xdata)
+{
+        int               op_errno   = ESTALE;
+
+        if (!(loc && loc->inode))
+                goto out;
+
+        if (!gf_uuid_is_null (loc->inode->gfid))
+                memcpy (req->gfid,  loc->inode->gfid, 16);
+        else
+                memcpy (req->gfid, loc->gfid, 16);
+
+        GF_ASSERT_AND_GOTO_WITH_ERROR (this->name,
+                                      !gf_uuid_is_null (*((uuid_t *)req->gfid)),
+                                      out, op_errno, EINVAL);
+        dict_to_xdr (xattr, &req->dict);
+
+        req->flags = flags;
+
+        dict_to_xdr (xdata, &req->xdata);
+
+        return 0;
+out:
+        return -op_errno;
+}
+
+int
+client_pre_fxattrop_v2 (xlator_t *this, gfx_fxattrop_req *req, fd_t *fd,
+                    dict_t *xattr, int32_t flags, dict_t *xdata)
+{
+        int               op_errno   = ESTALE;
+        int64_t           remote_fd  = -1;
+
+        CLIENT_GET_REMOTE_FD (this, fd, FALLBACK_TO_ANON_FD,
+                              remote_fd, op_errno, out);
+
+        req->fd     = remote_fd;
+        req->flags  = flags;
+        memcpy (req->gfid, fd->inode->gfid, 16);
+
+        dict_to_xdr (xattr, &req->dict);
+
+        dict_to_xdr (xdata, &req->xdata);
+
+        return 0;
+out:
+        return -op_errno;
+}
+
+int
+client_pre_fgetxattr_v2 (xlator_t *this, gfx_fgetxattr_req *req, fd_t *fd,
+                      const char *name, dict_t *xdata)
+{
+        int64_t             remote_fd  = -1;
+        int                 op_errno   = ESTALE;
+
+        CLIENT_GET_REMOTE_FD (this, fd, DEFAULT_REMOTE_FD,
+                              remote_fd, op_errno, out);
+
+        req->namelen = 1; /* Use it as a flag */
+        req->fd   = remote_fd;
+        req->name = (char *)name;
+        if (!req->name) {
+                req->name = "";
+                req->namelen = 0;
+        }
+        memcpy (req->gfid, fd->inode->gfid, 16);
+
+        dict_to_xdr (xdata, &req->xdata);
+
+        return 0;
+out:
+        return -op_errno;
+}
+
+int
+client_pre_fsetxattr_v2 (xlator_t *this, gfx_fsetxattr_req *req, fd_t *fd,
+                       int32_t flags, dict_t *xattr, dict_t *xdata)
+{
+        int64_t             remote_fd = -1;
+        int                 op_errno = ESTALE;
+
+        CLIENT_GET_REMOTE_FD (this, fd, DEFAULT_REMOTE_FD,
+                              remote_fd, op_errno, out);
+
+        req->fd    = remote_fd;
+        req->flags = flags;
+        memcpy (req->gfid, fd->inode->gfid, 16);
+
+        if (xattr) {
+                dict_to_xdr (xattr, &req->dict);
+        }
+
+        dict_to_xdr (xdata, &req->xdata);
+
+        return 0;
+out:
+        return -op_errno;
+}
+
+int
+client_pre_rchecksum_v2 (xlator_t *this, gfx_rchecksum_req *req, fd_t *fd,
+                       int32_t len, off_t offset, dict_t *xdata)
+{
+        int64_t             remote_fd = -1;
+        int                 op_errno = ESTALE;
+
+        CLIENT_GET_REMOTE_FD (this, fd, DEFAULT_REMOTE_FD,
+                              remote_fd, op_errno, out);
+
+        req->len    = len;
+        req->offset = offset;
+        req->fd     = remote_fd;
+
+        dict_to_xdr (xdata, &req->xdata);
+
+        return 0;
+out:
+        return -op_errno;
+}
+
+int
+client_pre_setattr_v2 (xlator_t *this, gfx_setattr_req *req, loc_t *loc,
+                     int32_t valid, struct iatt *stbuf, dict_t *xdata)
+{
+        int               op_errno = ESTALE;
+
+        if (!(loc && loc->inode))
+                return -op_errno;
+
+        if (!gf_uuid_is_null (loc->inode->gfid))
+                memcpy (req->gfid, loc->inode->gfid, 16);
+        else
+                memcpy (req->gfid, loc->gfid, 16);
+
+        GF_ASSERT_AND_GOTO_WITH_ERROR (this->name,
+                                      !gf_uuid_is_null (*((uuid_t *)req->gfid)),
+                                      out, op_errno, EINVAL);
+
+        req->valid = valid;
+        gfx_stat_from_iattx (&req->stbuf, stbuf);
+
+        dict_to_xdr (xdata, &req->xdata);
+
+        return 0;
+out:
+        return -op_errno;
+}
+
+int
+client_pre_fsetattr_v2 (xlator_t *this, gfx_fsetattr_req *req, fd_t *fd,
+                        int32_t valid, struct iatt *stbuf, dict_t *xdata)
+{
+        int                op_errno    = ESTALE;
+        int64_t            remote_fd   = -1;
+
+        CLIENT_GET_REMOTE_FD (this, fd, DEFAULT_REMOTE_FD,
+                              remote_fd, op_errno, out);
+
+        memcpy (req->gfid, fd->inode->gfid, 16);
+        req->fd = remote_fd;
+        req->valid = valid;
+        gfx_stat_from_iattx (&req->stbuf, stbuf);
+
+        dict_to_xdr (xdata, &req->xdata);
+        return 0;
+out:
+        return -op_errno;
+}
+
+int
+client_pre_readdirp_v2 (xlator_t *this, gfx_readdirp_req *req, fd_t *fd,
+                     size_t size, off_t offset, dict_t *xdata)
+{
+        int               op_errno          = ESTALE;
+        int64_t           remote_fd         = -1;
+
+        CLIENT_GET_REMOTE_FD (this, fd, DEFAULT_REMOTE_FD,
+                              remote_fd, op_errno, out);
+
+        req->size = size;
+        req->offset = offset;
+        req->fd = remote_fd;
+        memcpy (req->gfid, fd->inode->gfid, 16);
+
+        /* dict itself is 'xdata' here */
+        dict_to_xdr (xdata, &req->xdata);
+
+        return 0;
+out:
+        return -op_errno;
+}
+
+int
+client_pre_fremovexattr_v2 (xlator_t *this, gfx_fremovexattr_req *req, fd_t *fd,
+                          const char *name, dict_t *xdata)
+{
+        int64_t                remote_fd = -1;
+        int                    op_errno = ESTALE;
+
+        if (!(fd && fd->inode))
+                goto out;
+
+        CLIENT_GET_REMOTE_FD (this, fd, DEFAULT_REMOTE_FD,
+                              remote_fd, op_errno, out);
+
+        memcpy (req->gfid,  fd->inode->gfid, 16);
+        req->name = (char *)name;
+        req->fd = remote_fd;
+
+        dict_to_xdr (xdata, &req->xdata);
+
+        return 0;
+out:
+        return -op_errno;
+}
+
+int
+client_pre_fallocate_v2 (xlator_t *this, gfx_fallocate_req *req, fd_t *fd,
+                      int32_t flags, off_t offset, size_t size, dict_t *xdata)
+{
+        int                op_errno    = ESTALE;
+        int64_t            remote_fd   = -1;
+
+        CLIENT_GET_REMOTE_FD (this, fd, DEFAULT_REMOTE_FD,
+                              remote_fd, op_errno, out);
+
+        req->fd = remote_fd;
+	req->flags = flags;
+	req->offset = offset;
+	req->size = size;
+	memcpy(req->gfid, fd->inode->gfid, 16);
+
+        dict_to_xdr (xdata, &req->xdata);
+        return 0;
+out:
+        return -op_errno;
+}
+
+int
+client_pre_discard_v2 (xlator_t *this, gfx_discard_req *req, fd_t *fd,
+                    off_t offset, size_t size, dict_t *xdata)
+{
+        int                op_errno    = ESTALE;
+        int64_t            remote_fd   = -1;
+
+        CLIENT_GET_REMOTE_FD (this, fd, DEFAULT_REMOTE_FD,
+                              remote_fd, op_errno, out);
+
+        req->fd = remote_fd;
+	req->offset = offset;
+	req->size = size;
+	memcpy(req->gfid, fd->inode->gfid, 16);
+
+        dict_to_xdr (xdata, &req->xdata);
+        return 0;
+out:
+        return -op_errno;
+}
+
+int
+client_pre_zerofill_v2 (xlator_t *this, gfx_zerofill_req *req, fd_t *fd,
+                     off_t offset, size_t size, dict_t *xdata)
+{
+        int                op_errno    = ESTALE;
+        int64_t            remote_fd   = -1;
+
+        CLIENT_GET_REMOTE_FD (this, fd, DEFAULT_REMOTE_FD,
+                              remote_fd, op_errno, out);
+
+        req->fd = remote_fd;
+        req->offset = offset;
+        req->size = size;
+        memcpy(req->gfid, fd->inode->gfid, 16);
+
+        dict_to_xdr (xdata, &req->xdata);
+        return 0;
+out:
+        return -op_errno;
+}
+
+int
+client_pre_ipc_v2 (xlator_t *this, gfx_ipc_req *req, int32_t cmd,
+                 dict_t *xdata)
+{
+        req->op = cmd;
+
+        dict_to_xdr (xdata, &req->xdata);
+        return 0;
+}
+
+int
+client_pre_seek_v2 (xlator_t *this, gfx_seek_req *req, fd_t *fd,
+                 off_t offset, gf_seek_what_t what, dict_t *xdata)
+{
+        int64_t                 remote_fd   = -1;
+        int                     op_errno    = ESTALE;
+
+        CLIENT_GET_REMOTE_FD (this, fd, DEFAULT_REMOTE_FD,
+                              remote_fd, op_errno, out);
+
+        memcpy (req->gfid, fd->inode->gfid, 16);
+        req->fd = remote_fd;
+        req->offset = offset;
+        req->what = what;
+
+        dict_to_xdr (xdata, &req->xdata);
+
+        return 0;
+out:
+        return -op_errno;
+}
+
+int
+client_pre_lease_v2 (xlator_t *this, gfx_lease_req *req, loc_t *loc,
+                  struct gf_lease *lease, dict_t *xdata)
+{
+        int op_errno = 0;
+
+        if (!(loc && loc->inode))
+                goto out;
+
+        if (!gf_uuid_is_null (loc->inode->gfid))
+                memcpy (req->gfid, loc->inode->gfid, 16);
+        else
+                memcpy (req->gfid, loc->gfid, 16);
+
+        GF_ASSERT_AND_GOTO_WITH_ERROR (this->name,
+                                      !gf_uuid_is_null (*((uuid_t *)req->gfid)),
+                                      out, op_errno, EINVAL);
+
+        gf_proto_lease_from_lease (&req->lease, lease);
+
+        dict_to_xdr (xdata, &req->xdata);
+out:
+        return -op_errno;
+}
+
+int
+client_post_create_v2 (xlator_t *this, gfx_create_rsp *rsp,
+                       struct iatt *stbuf, struct iatt *preparent,
+                       struct iatt *postparent,
+                       clnt_local_t *local, dict_t **xdata)
+{
+        if (-1 != rsp->op_ret) {
+                gfx_stat_to_iattx (&rsp->stat, stbuf);
+
+                gfx_stat_to_iattx (&rsp->preparent, preparent);
+                gfx_stat_to_iattx (&rsp->postparent, postparent);
+                gf_uuid_copy (local->loc.gfid, stbuf->ia_gfid);
+        }
+        return xdr_to_dict (&rsp->xdata, xdata);
+}
+
+int
+client_post_lease_v2 (xlator_t *this, gfx_lease_rsp *rsp, struct gf_lease *lease,
+                      dict_t **xdata)
+{
+        if (rsp->op_ret >= 0) {
+                gf_proto_lease_to_lease (&rsp->lease, lease);
+        }
+
+        return xdr_to_dict (&rsp->xdata, xdata);
+}
+
+int
+client_post_lk_v2 (xlator_t *this, gfx_lk_rsp *rsp, struct gf_flock *lock,
+                   dict_t **xdata)
+{
+        if (rsp->op_ret >= 0) {
+                gf_proto_flock_to_flock (&rsp->flock, lock);
+        }
+        return xdr_to_dict (&rsp->xdata, xdata);
+}
+
+int
+client_post_readdir_v2 (xlator_t *this, gfx_readdir_rsp *rsp,
+                        gf_dirent_t *entries, dict_t **xdata)
+{
+        if (rsp->op_ret > 0) {
+                unserialize_rsp_dirent_v2 (this, rsp, entries);
+        }
+        return xdr_to_dict (&rsp->xdata, xdata);
+}
+
+int
+client_post_readdirp_v2 (xlator_t *this, gfx_readdirp_rsp *rsp,
+                         fd_t *fd, gf_dirent_t *entries,
+                         dict_t **xdata)
+{
+        if (rsp->op_ret > 0) {
+                unserialize_rsp_direntp_v2 (this, fd, rsp, entries);
+        }
+        return xdr_to_dict (&rsp->xdata, xdata);
+}
+
+
+
+int
+client_post_rename_v2 (xlator_t *this, gfx_rename_rsp *rsp, struct iatt *stbuf,
+                       struct iatt *preoldparent, struct iatt *postoldparent,
+                       struct iatt *prenewparent, struct iatt *postnewparent,
+                       dict_t **xdata)
+{
+        if (-1 != rsp->op_ret) {
+                gfx_stat_to_iattx (&rsp->stat, stbuf);
+
+                gfx_stat_to_iattx (&rsp->preoldparent, preoldparent);
+                gfx_stat_to_iattx (&rsp->postoldparent, postoldparent);
+
+                gfx_stat_to_iattx (&rsp->prenewparent, prenewparent);
+                gfx_stat_to_iattx (&rsp->postnewparent, postnewparent);
+        }
+
+        return xdr_to_dict (&rsp->xdata, xdata);
+}