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>

3 files changed, 1169 insertions, 29 deletions

diff --git a/rpc/xdr/src/glusterfs3.h b/rpc/xdr/src/glusterfs3.h
index eef39416b5c..bbe231139b3 100644
--- a/rpc/xdr/src/glusterfs3.h
+++ b/rpc/xdr/src/glusterfs3.h
@@ -314,7 +314,6 @@ gf_stat_to_iatt (struct gf_iatt *gf_stat, struct iatt *iatt)
 	iatt->ia_ctime_nsec = gf_stat->ia_ctime_nsec ;
 }
 
-
 static inline void
 gf_stat_from_iatt (struct gf_iatt *gf_stat, struct iatt *iatt)
 {
@@ -324,7 +323,7 @@ gf_stat_from_iatt (struct gf_iatt *gf_stat, struct iatt *iatt)
         memcpy (gf_stat->ia_gfid, iatt->ia_gfid, 16);
 	gf_stat->ia_ino = iatt->ia_ino ;
 	gf_stat->ia_dev = iatt->ia_dev ;
-	gf_stat->mode   = st_mode_from_ia (iatt->ia_prot, iatt->ia_type);
+	gf_stat->mode = st_mode_from_ia (iatt->ia_prot, iatt->ia_type);
 	gf_stat->ia_nlink = iatt->ia_nlink ;
 	gf_stat->ia_uid = iatt->ia_uid ;
 	gf_stat->ia_gid = iatt->ia_gid ;
@@ -575,7 +574,303 @@ out:
         return ret;
 }
 
-extern int dict_to_xdr (dict_t *this, gfx_dict *xdict);
-extern int xdr_to_dict (gfx_dict *xdict, dict_t **to);
+static inline void
+gfx_stat_to_iattx (struct gfx_iattx *gf_stat, struct iatt *iatt)
+{
+        if (!iatt || !gf_stat)
+                return;
+
+        memcpy (iatt->ia_gfid, gf_stat->ia_gfid, 16);
+
+        iatt->ia_flags = gf_stat->ia_flags;
+	iatt->ia_ino = gf_stat->ia_ino ;
+	iatt->ia_dev = gf_stat->ia_dev ;
+	iatt->ia_rdev = gf_stat->ia_rdev ;
+	iatt->ia_size = gf_stat->ia_size ;
+	iatt->ia_nlink = gf_stat->ia_nlink ;
+	iatt->ia_uid = gf_stat->ia_uid ;
+	iatt->ia_gid = gf_stat->ia_gid ;
+	iatt->ia_blksize = gf_stat->ia_blksize ;
+	iatt->ia_blocks = gf_stat->ia_blocks ;
+	iatt->ia_atime = gf_stat->ia_atime ;
+	iatt->ia_atime_nsec = gf_stat->ia_atime_nsec ;
+	iatt->ia_mtime = gf_stat->ia_mtime ;
+	iatt->ia_mtime_nsec = gf_stat->ia_mtime_nsec ;
+	iatt->ia_ctime = gf_stat->ia_ctime ;
+	iatt->ia_ctime_nsec = gf_stat->ia_ctime_nsec ;
+	iatt->ia_btime = gf_stat->ia_btime ;
+	iatt->ia_btime_nsec = gf_stat->ia_btime_nsec ;
+        iatt->ia_attributes = gf_stat->ia_attributes;
+        iatt->ia_attributes_mask = gf_stat->ia_attributes_mask;
+
+	iatt->ia_type = ia_type_from_st_mode (gf_stat->mode);
+	iatt->ia_prot = ia_prot_from_st_mode (gf_stat->mode);
+}
+
+
+static inline void
+gfx_stat_from_iattx (struct gfx_iattx *gf_stat, struct iatt *iatt)
+{
+        if (!iatt || !gf_stat)
+                return;
+
+        memcpy (gf_stat->ia_gfid, iatt->ia_gfid, 16);
+	gf_stat->ia_ino = iatt->ia_ino ;
+	gf_stat->ia_dev = iatt->ia_dev ;
+
+	gf_stat->ia_nlink = iatt->ia_nlink ;
+	gf_stat->ia_uid = iatt->ia_uid ;
+	gf_stat->ia_gid = iatt->ia_gid ;
+	gf_stat->ia_rdev = iatt->ia_rdev ;
+	gf_stat->ia_size = iatt->ia_size ;
+	gf_stat->ia_blksize = iatt->ia_blksize ;
+	gf_stat->ia_blocks = iatt->ia_blocks ;
+	gf_stat->ia_atime = iatt->ia_atime ;
+	gf_stat->ia_atime_nsec = iatt->ia_atime_nsec ;
+	gf_stat->ia_mtime = iatt->ia_mtime ;
+	gf_stat->ia_mtime_nsec = iatt->ia_mtime_nsec ;
+	gf_stat->ia_ctime = iatt->ia_ctime ;
+	gf_stat->ia_ctime_nsec = iatt->ia_ctime_nsec ;
+
+        gf_stat->ia_flags = iatt->ia_flags;
+        gf_stat->ia_btime = iatt->ia_btime ;
+	gf_stat->ia_btime_nsec = iatt->ia_btime_nsec ;
+        gf_stat->ia_attributes = iatt->ia_attributes;
+        gf_stat->ia_attributes_mask = iatt->ia_attributes_mask;
+
+        gf_stat->mode   = st_mode_from_ia (iatt->ia_prot, iatt->ia_type);
+}
+
+/* dict_to_xdr () */
+static inline int
+dict_to_xdr (dict_t *this, gfx_dict *dict)
+{
+        int ret = -1;
+        int i = 0;
+        int index = 0;
+        data_pair_t *dpair = NULL;
+        gfx_dict_pair *xpair = NULL;
+        ssize_t size = 0;
+
+        /* This is a failure as we expect destination to be valid */
+        if (!dict)
+                goto out;
+
+        /* This is OK as dictionary can be null, in which case, destination
+           should also know that it is NULL. */
+        if (!this) {
+                /* encode special meaning data here,
+                   while decoding, you know it is NULL dict */
+                dict->count = -1;
+                /* everything else is normal */
+                dict->pairs.pairs_len = 0;
+                ret = 0;
+                goto out;
+        }
+
+        dict->pairs.pairs_val = GF_CALLOC (1, (this->count *
+                                               sizeof (gfx_dict_pair)),
+                                           gf_common_mt_char);
+        if (!dict->pairs.pairs_val)
+                goto out;
+
+        dpair = this->members_list;
+        for (i = 0; i < this->count; i++) {
+                xpair = &dict->pairs.pairs_val[index];
+
+                xpair->key.key_val = dpair->key;
+                xpair->key.key_len = strlen (dpair->key) + 1;
+                xpair->value.type = dpair->value->data_type;
+                switch (dpair->value->data_type) {
+                        /* Add more type here */
+                case GF_DATA_TYPE_INT:
+                        index++;
+                        xpair->value.gfx_value_u.value_int =
+                                strtoll (dpair->value->data, NULL, 0);
+                        break;
+                case GF_DATA_TYPE_UINT:
+                        index++;
+                        xpair->value.gfx_value_u.value_uint =
+                                strtoull (dpair->value->data, NULL, 0);
+                        break;
+                case GF_DATA_TYPE_DOUBLE:
+                        index++;
+                        xpair->value.gfx_value_u.value_dbl =
+                                strtod (dpair->value->data, NULL);
+                        break;
+                case GF_DATA_TYPE_STR:
+                        index++;
+                        xpair->value.gfx_value_u.val_string.val_string_val = dpair->value->data;
+                        xpair->value.gfx_value_u.val_string.val_string_len = dpair->value->len;
+                        break;
+                case GF_DATA_TYPE_IATT:
+                        index++;
+                        gfx_stat_from_iattx (&xpair->value.gfx_value_u.iatt,
+                                             (struct iatt *)dpair->value->data);
+                        break;
+                case GF_DATA_TYPE_GFUUID:
+                        index++;
+                        memcpy (&xpair->value.gfx_value_u.uuid,
+                                dpair->value->data, sizeof (uuid_t));
+                        break;
+
+                case GF_DATA_TYPE_PTR:
+                        index++;
+                        /* Ideally, each type of data stored in dictionary
+                           should have type. A pointer type shouldn't be
+                           sent on wire */
+
+                        /* This is done for backward compatibility as dict is
+                           heavily used for transporting data over wire.
+                           Ideally, whereever there is an issue, fix and move on */
+                        xpair->value.gfx_value_u.other.other_val =
+                                dpair->value->data;
+                        xpair->value.gfx_value_u.other.other_len =
+                                dpair->value->len;
+
+                        /* Change this to INFO, after taking the above down */
+                        gf_msg ("dict", GF_LOG_INFO, EINVAL,
+                                LG_MSG_DICT_SERIAL_FAILED,
+                                "key '%s' is would not be sent on wire in future",
+                                dpair->key);
+                        break;
+                default:
+                        /* Unknown type and ptr type is not sent on wire */
+                        gf_msg ("dict", GF_LOG_WARNING, EINVAL, LG_MSG_DICT_SERIAL_FAILED,
+                                "key '%s' is not sent on wire", dpair->key);
+                        break;
+                }
+                dpair = dpair->next;
+        }
+
+        dict->pairs.pairs_len = index;
+        dict->count = index;
+
+        /* This is required mainly in the RPC layer to understand the
+           boundary for proper payload. Hence only send the size of
+           variable XDR size. ie, the formula should be:
+           xdr_size = total size - (xdr_size + count + pairs.pairs_len))  */
+        size = xdr_sizeof ((xdrproc_t) xdr_gfx_dict, dict);
+
+        dict->xdr_size = (size > 12) ? (size - 12) : 0;
+
+        ret = 0;
+out:
+        return ret;
+}
+
+static inline int
+xdr_to_dict (gfx_dict *dict, dict_t **to)
+{
+        int ret = -1;
+        int index = 0;
+        char *key = NULL;
+        char *value = NULL;
+        gfx_dict_pair *xpair = NULL;
+        dict_t *this = NULL;
+        unsigned char *uuid = NULL;
+        struct iatt *iatt = NULL;
+
+        if (!to || !dict)
+                goto out;
+
+        if (dict->count < 0) {
+                /* indicates NULL dict was passed for encoding */
+                ret = 0;
+                goto out;
+        }
+
+        this = dict_new();
+        if (!this)
+                goto out;
+
+        for (index = 0; index < dict->pairs.pairs_len; index++) {
+                ret = -1;
+                xpair = &dict->pairs.pairs_val[index];
+
+                key = xpair->key.key_val;
+                switch (xpair->value.type) {
+                        /* Add more type here */
+                case GF_DATA_TYPE_INT:
+                        ret = dict_set_int64 (this, key,
+                                    xpair->value.gfx_value_u.value_int);
+                        break;
+                case GF_DATA_TYPE_UINT:
+                        ret = dict_set_uint64 (this, key,
+                                    xpair->value.gfx_value_u.value_uint);
+                        break;
+                case GF_DATA_TYPE_DOUBLE:
+                        ret = dict_set_double (this, key,
+                                    xpair->value.gfx_value_u.value_dbl);
+                        break;
+                case GF_DATA_TYPE_STR:
+                        value = GF_CALLOC (1, xpair->value.gfx_value_u.val_string.val_string_len + 1,
+                                           gf_common_mt_char);
+                        if (!value) {
+                                errno = ENOMEM;
+                                goto out;
+                        }
+                        memcpy (value, xpair->value.gfx_value_u.val_string.val_string_val,
+                                xpair->value.gfx_value_u.val_string.val_string_len);
+                        free (xpair->value.gfx_value_u.val_string.val_string_val);
+                        ret = dict_set_dynstr (this, key, value);
+                        break;
+                case GF_DATA_TYPE_GFUUID:
+                        uuid = GF_CALLOC (1, sizeof (uuid_t), gf_common_mt_uuid_t);
+                        if (!uuid) {
+                                errno = ENOMEM;
+                                goto out;
+                        }
+                        memcpy (uuid, xpair->value.gfx_value_u.uuid, sizeof (uuid_t));
+                        ret = dict_set_gfuuid (this, key, uuid, false);
+                        break;
+                case GF_DATA_TYPE_IATT:
+                        iatt = GF_CALLOC (1, sizeof (struct iatt), gf_common_mt_char);
+                        if (!iatt) {
+                                errno = ENOMEM;
+                                goto out;
+                        }
+                        gfx_stat_to_iattx (&xpair->value.gfx_value_u.iatt, iatt);
+                        ret = dict_set_iatt (this, key, iatt, false);
+                        break;
+                case GF_DATA_TYPE_PTR:
+                        value = GF_CALLOC (1, xpair->value.gfx_value_u.other.other_len + 1,
+                                           gf_common_mt_char);
+                        if (!value) {
+                                errno = ENOMEM;
+                                goto out;
+                        }
+                        memcpy (value, xpair->value.gfx_value_u.other.other_val,
+                                xpair->value.gfx_value_u.other.other_len);
+                        free (xpair->value.gfx_value_u.other.other_val);
+                        ret = dict_set_dynptr (this, key, value,
+                                               xpair->value.gfx_value_u.other.other_len);
+                        break;
+                default:
+                        ret = 0;
+                        /* Unknown type and ptr type is not sent on wire */
+                        break;
+                }
+                if (ret) {
+                        gf_msg_debug (THIS->name, ENOMEM,
+                                      "failed to set the key (%s) into dict",
+                                      key);
+                }
+                free (xpair->key.key_val);
+        }
+
+        free (dict->pairs.pairs_val);
+        ret = 0;
+
+        /* If everything is fine, assign the dictionary to target */
+        *to = this;
+        this = NULL;
+
+out:
+        if (this)
+                dict_unref (this);
+
+        return ret;
+}
 
 #endif /* !_GLUSTERFS3_H */
diff --git a/rpc/xdr/src/glusterfs4-xdr.x b/rpc/xdr/src/glusterfs4-xdr.x
index 9e3223b58b5..bf92c8db9de 100644
--- a/rpc/xdr/src/glusterfs4-xdr.x
+++ b/rpc/xdr/src/glusterfs4-xdr.x
@@ -16,6 +16,36 @@
 %#include "glusterfs3-xdr.h"
 
 
+/* Need to consume iattx and new dict in all the fops */
+struct gfx_iattx {
+        opaque       ia_gfid[16];
+
+        unsigned hyper     ia_flags;
+        unsigned hyper     ia_ino;        /* inode number */
+        unsigned hyper     ia_dev;        /* backing device ID */
+        unsigned hyper     ia_rdev;       /* device ID (if special file) */
+        unsigned hyper     ia_size;       /* file size in bytes */
+        unsigned hyper     ia_blocks;     /* number of 512B blocks allocated */
+        unsigned hyper     ia_attributes; /* chattr related:compressed, immutable,
+                                     * append only, encrypted etc.*/
+        unsigned hyper     ia_attributes_mask; /* Mask for the attributes */
+
+        hyper      ia_atime;      /* last access time */
+        hyper      ia_mtime;      /* last modification time */
+        hyper      ia_ctime;      /* last status change time */
+        hyper      ia_btime;      /* creation time. Fill using statx */
+
+        unsigned int     ia_atime_nsec;
+        unsigned int     ia_mtime_nsec;
+        unsigned int     ia_ctime_nsec;
+        unsigned int     ia_btime_nsec;
+        unsigned int     ia_nlink;      /* Link count */
+        unsigned int     ia_uid;        /* user ID of owner */
+        unsigned int     ia_gid;        /* group ID of owner */
+        unsigned int     ia_blksize;    /* blocksize for filesystem I/O */
+        unsigned int     mode;          /* type of file and rwx mode */
+};
+
 union gfx_value switch (gf_dict_data_type_t type) {
         case GF_DATA_TYPE_INT:
                 hyper value_int;
@@ -26,9 +56,9 @@ union gfx_value switch (gf_dict_data_type_t type) {
         case GF_DATA_TYPE_STR:
                 opaque val_string<>;
         case GF_DATA_TYPE_IATT:
-                gf_iatt iatt;
+                gfx_iattx iatt;
         case GF_DATA_TYPE_GFUUID:
-                opaque uuid[20];
+                opaque uuid[16];
         case GF_DATA_TYPE_PTR:
                 opaque other<>;
 };
@@ -64,52 +94,773 @@ struct gfx_dict_pair {
 };
 
 struct gfx_dict {
-       unsigned int count;
+       unsigned int xdr_size;
+       int count;
        gfx_dict_pair pairs<>;
 };
 
-/* fops */
- struct gfs3_fsetattr_req_v2 {
+/* FOPS */
+struct gfx_common_rsp {
+       int    op_ret;
+       int    op_errno;
+       gfx_dict xdata; /* Extra data */
+};
+
+struct gfx_common_iatt_rsp {
+       int op_ret;
+       int op_errno;
+       gfx_dict xdata;
+       gfx_iattx stat;
+};
+
+struct gfx_common_2iatt_rsp {
+       int op_ret;
+       int op_errno;
+       gfx_dict xdata;
+       gfx_iattx prestat;
+       gfx_iattx poststat;
+};
+
+struct gfx_common_3iatt_rsp {
+        int    op_ret;
+        int    op_errno;
+        gfx_dict xdata; /* Extra data */
+        gfx_iattx stat;
+        gfx_iattx preparent;
+        gfx_iattx postparent;
+};
+
+struct gfx_fsetattr_req {
         opaque gfid[16];
         hyper        fd;
-        struct gf_iatt stbuf;
+        gfx_iattx stbuf;
         int        valid;
-        opaque   xdata<>; /* Extra data */
-}  ;
+        gfx_dict xdata; /* Extra data */
+};
 
- struct gfs3_rchecksum_req_v2 {
+struct gfx_rchecksum_req {
         opaque gfid[16];
         hyper   fd;
         unsigned hyper  offset;
         unsigned int  len;
-        opaque   xdata<>; /* Extra data */
+        unsigned int  flags;
+        gfx_dict xdata; /* Extra data */
+};
+
+struct gfx_icreate_req {
+       opaque gfid[16];
+       unsigned int mode;
+       gfx_dict xdata;
+};
+
+struct gfx_namelink_req {
+       opaque pargfid[16];
+       string bname<>;
+       gfx_dict xdata;
+};
+
+/* Define every fops */
+/* Changes from Version 3:
+  1. Dict has its own type instead of being opaque
+  2. Iattx instead of iatt on wire
+  3. gfid has 4 extra bytes so it can be used for future
+*/
+struct gfx_stat_req {
+        opaque gfid[16];
+        gfx_dict xdata;
+};
+
+struct gfx_readlink_req {
+        opaque gfid[16];
+        unsigned int   size;
+        gfx_dict xdata; /* Extra data */
+};
+
+struct gfx_readlink_rsp {
+        int    op_ret;
+        int    op_errno;
+        gfx_dict xdata; /* Extra data */
+        gfx_iattx buf;
+        string path<>; /* NULL terminated */
+};
+
+struct gfx_mknod_req {
+        opaque  pargfid[16];
+        u_quad_t dev;
+        unsigned int mode;
+        unsigned int umask;
+        string     bname<>; /* NULL terminated */
+        gfx_dict xdata; /* Extra data */
+};
+
+struct  gfx_mkdir_req {
+        opaque  pargfid[16];
+        unsigned int mode;
+        unsigned int umask;
+        string     bname<>; /* NULL terminated */
+        gfx_dict xdata; /* Extra data */
+};
+
+struct gfx_unlink_req {
+        opaque  pargfid[16];
+        string     bname<>; /* NULL terminated */
+        unsigned int xflags;
+        gfx_dict xdata; /* Extra data */
+};
+
+
+struct gfx_rmdir_req {
+        opaque  pargfid[16];
+        int        xflags;
+        string     bname<>; /* NULL terminated */
+        gfx_dict xdata; /* Extra data */
+};
+
+struct gfx_symlink_req {
+        opaque  pargfid[16];
+        string     bname<>;
+        unsigned int umask;
+        string     linkname<>;
+        gfx_dict xdata; /* Extra data */
+};
+
+struct  gfx_rename_req {
+        opaque  oldgfid[16];
+        opaque  newgfid[16];
+        string       oldbname<>; /* NULL terminated */
+        string       newbname<>; /* NULL terminated */
+        gfx_dict xdata; /* Extra data */
+};
+
+struct   gfx_rename_rsp {
+        int    op_ret;
+        int    op_errno;
+        gfx_dict xdata; /* Extra data */
+        gfx_iattx stat;
+        gfx_iattx preoldparent;
+        gfx_iattx postoldparent;
+        gfx_iattx prenewparent;
+        gfx_iattx postnewparent;
+};
+
+
+ struct  gfx_link_req {
+        opaque  oldgfid[16];
+        opaque  newgfid[16];
+        string       newbname<>;
+        gfx_dict xdata; /* Extra data */
+};
+
+ struct   gfx_truncate_req {
+        opaque gfid[16];
+        u_quad_t offset;
+        gfx_dict xdata; /* Extra data */
+};
+
+ struct   gfx_open_req {
+        opaque gfid[16];
+        unsigned int flags;
+        gfx_dict xdata; /* Extra data */
+};
+
+struct   gfx_open_rsp {
+        int    op_ret;
+        int    op_errno;
+        gfx_dict xdata; /* Extra data */
+        quad_t fd;
+};
+
+struct gfx_opendir_req {
+        opaque gfid[16];
+        gfx_dict xdata; /* Extra data */
+}  ;
+
+
+ struct   gfx_read_req {
+        opaque gfid[16];
+        quad_t  fd;
+        u_quad_t offset;
+        unsigned int size;
+        unsigned int flag;
+        gfx_dict xdata; /* Extra data */
+};
+ struct  gfx_read_rsp {
+        int    op_ret;
+        int    op_errno;
+        gfx_iattx stat;
+        unsigned int size;
+        gfx_dict xdata; /* Extra data */
+} ;
+
+struct   gfx_lookup_req {
+        opaque gfid[16];
+        opaque  pargfid[16];
+        unsigned int flags;
+        string     bname<>;
+        gfx_dict xdata; /* Extra data */
+};
+
+
+ struct   gfx_write_req {
+        opaque gfid[16];
+        quad_t  fd;
+        u_quad_t offset;
+        unsigned int size;
+        unsigned int flag;
+        gfx_dict xdata; /* Extra data */
+};
+
+ struct gfx_statfs_req  {
+        opaque gfid[16];
+        gfx_dict xdata; /* Extra data */
+}  ;
+ struct gfx_statfs_rsp {
+        int    op_ret;
+        int    op_errno;
+        gfx_dict xdata; /* Extra data */
+        gf_statfs statfs;
+}  ;
+
+ struct gfx_lk_req {
+        opaque gfid[16];
+        int64_t         fd;
+        unsigned int        cmd;
+        unsigned int        type;
+        gf_proto_flock flock;
+        gfx_dict xdata; /* Extra data */
+}  ;
+ struct gfx_lk_rsp {
+        int    op_ret;
+        int    op_errno;
+        gfx_dict xdata; /* Extra data */
+        gf_proto_flock flock;
+}  ;
+
+struct gfx_lease_req {
+        opaque gfid[16];
+        gf_proto_lease lease;
+        gfx_dict xdata; /* Extra data */
+}  ;
+
+struct gfx_lease_rsp {
+        int    op_ret;
+        int    op_errno;
+        gfx_dict xdata; /* Extra data */
+        gf_proto_lease lease;
+}  ;
+
+struct gfx_recall_lease_req {
+        opaque       gfid[16];
+        unsigned int lease_type;
+        opaque       tid[16];
+        gfx_dict xdata; /* Extra data */
+}  ;
+
+ struct gfx_inodelk_req {
+        opaque gfid[16];
+        unsigned int cmd;
+        unsigned int type;
+        gf_proto_flock flock;
+        string     volume<>;
+        gfx_dict xdata; /* Extra data */
+}  ;
+
+struct   gfx_finodelk_req {
+        opaque gfid[16];
+        quad_t  fd;
+        unsigned int cmd;
+        unsigned int type;
+        gf_proto_flock flock;
+        string volume<>;
+        gfx_dict xdata; /* Extra data */
+} ;
+
+
+ struct gfx_flush_req {
+        opaque gfid[16];
+        quad_t  fd;
+        gfx_dict xdata; /* Extra data */
+}  ;
+
+
+ struct gfx_fsync_req {
+        opaque gfid[16];
+        quad_t  fd;
+        unsigned int data;
+        gfx_dict xdata; /* Extra data */
+}  ;
+
+ struct gfx_setxattr_req {
+        opaque gfid[16];
+        unsigned int flags;
+        gfx_dict dict;
+        gfx_dict xdata; /* Extra data */
+}  ;
+
+
+
+ struct gfx_fsetxattr_req {
+        opaque gfid[16];
+        int64_t  fd;
+        unsigned int flags;
+        gfx_dict dict;
+        gfx_dict xdata; /* Extra data */
+}  ;
+
+
+
+ struct gfx_xattrop_req {
+        opaque gfid[16];
+        unsigned int flags;
+        gfx_dict dict;
+        gfx_dict xdata; /* Extra data */
 }  ;
 
-struct gfs4_icreate_rsp {
+struct gfx_common_dict_rsp  {
+        int    op_ret;
+        int    op_errno;
+        gfx_dict xdata; /* Extra data */
+        gfx_dict dict;
+        gfx_iattx prestat;
+        gfx_iattx poststat;
+};
+
+
+ struct gfx_fxattrop_req {
+        opaque gfid[16];
+        quad_t  fd;
+        unsigned int flags;
+        gfx_dict dict;
+        gfx_dict xdata; /* Extra data */
+}  ;
+
+ struct gfx_getxattr_req  {
+        opaque gfid[16];
+        unsigned int namelen;
+        string     name<>;
+        gfx_dict xdata; /* Extra data */
+}  ;
+
+
+ struct gfx_fgetxattr_req  {
+        opaque gfid[16];
+        quad_t  fd;
+        unsigned int namelen;
+        string     name<>;
+        gfx_dict xdata; /* Extra data */
+}  ;
+
+ struct gfx_removexattr_req {
+        opaque gfid[16];
+        string     name<>;
+        gfx_dict xdata; /* Extra data */
+}  ;
+
+ struct gfx_fremovexattr_req {
+        opaque gfid[16];
+        quad_t  fd;
+        string     name<>;
+        gfx_dict xdata; /* Extra data */
+}  ;
+
+
+ struct gfx_fsyncdir_req {
+        opaque gfid[16];
+        quad_t  fd;
+        int  data;
+        gfx_dict xdata; /* Extra data */
+}  ;
+
+ struct   gfx_readdir_req  {
+        opaque gfid[16];
+        quad_t  fd;
+        u_quad_t offset;
+        unsigned int size;
+        gfx_dict xdata; /* Extra data */
+};
+
+ struct gfx_readdirp_req {
+        opaque gfid[16];
+        quad_t  fd;
+        u_quad_t offset;
+        unsigned int size;
+        gfx_dict xdata;
+}  ;
+
+
+struct gfx_access_req  {
+        opaque gfid[16];
+        unsigned int mask;
+        gfx_dict xdata; /* Extra data */
+} ;
+
+
+struct gfx_create_req {
+        opaque  pargfid[16];
+        unsigned int flags;
+        unsigned int mode;
+        unsigned int umask;
+        string     bname<>;
+        gfx_dict xdata; /* Extra data */
+}  ;
+struct  gfx_create_rsp {
+        int    op_ret;
+        int    op_errno;
+        gfx_dict xdata; /* Extra data */
+        gfx_iattx stat;
+        u_quad_t       fd;
+        gfx_iattx preparent;
+        gfx_iattx postparent;
+} ;
+
+struct   gfx_ftruncate_req  {
+        opaque gfid[16];
+        quad_t  fd;
+        u_quad_t offset;
+        gfx_dict xdata; /* Extra data */
+} ;
+
+
+struct gfx_fstat_req {
+        opaque gfid[16];
+        quad_t  fd;
+        gfx_dict xdata; /* Extra data */
+}  ;
+
+
+struct gfx_entrylk_req {
+        opaque gfid[16];
+        unsigned int  cmd;
+        unsigned int  type;
+        u_quad_t  namelen;
+        string      name<>;
+        string      volume<>;
+        gfx_dict xdata; /* Extra data */
+};
+
+struct gfx_fentrylk_req {
+        opaque gfid[16];
+        quad_t   fd;
+        unsigned int  cmd;
+        unsigned int  type;
+        u_quad_t  namelen;
+        string      name<>;
+        string      volume<>;
+        gfx_dict xdata; /* Extra data */
+};
+
+ struct gfx_setattr_req {
+        opaque gfid[16];
+        gfx_iattx stbuf;
+        int        valid;
+        gfx_dict xdata; /* Extra data */
+}  ;
+
+ struct gfx_fallocate_req {
+        opaque          gfid[16];
+        quad_t          fd;
+        unsigned int    flags;
+        u_quad_t        offset;
+        u_quad_t        size;
+        gfx_dict xdata; /* Extra data */
+}  ;
+
+struct gfx_discard_req {
+        opaque          gfid[16];
+        quad_t          fd;
+        u_quad_t        offset;
+        u_quad_t        size;
+        gfx_dict xdata; /* Extra data */
+}  ;
+
+struct gfx_zerofill_req {
+        opaque          gfid[16];
+        quad_t           fd;
+        u_quad_t  offset;
+        u_quad_t  size;
+        gfx_dict xdata;
+}  ;
+
+struct gfx_rchecksum_rsp {
+        int    op_ret;
+        int    op_errno;
+        gfx_dict xdata; /* Extra data */
+        unsigned int flags;
+        unsigned int weak_checksum;
+        opaque   strong_checksum<>;
+}  ;
+
+
+struct gfx_ipc_req {
+        int     op;
+        gfx_dict xdata;
+};
+
+
+struct gfx_seek_req {
+        opaque    gfid[16];
+        quad_t    fd;
+        u_quad_t  offset;
+        int       what;
+        gfx_dict xdata;
+};
+
+struct gfx_seek_rsp {
+        int       op_ret;
+        int       op_errno;
+        gfx_dict xdata;
+        u_quad_t  offset;
+};
+
+
+ struct gfx_setvolume_req {
+        gfx_dict dict;
+}  ;
+ struct  gfx_setvolume_rsp {
+        int    op_ret;
+        int    op_errno;
+        gfx_dict dict;
+} ;
+
+
+ struct gfx_getspec_req {
+        unsigned int flags;
+        string     key<>;
+        gfx_dict xdata; /* Extra data */
+}  ;
+ struct  gfx_getspec_rsp {
+        int    op_ret;
+        int    op_errno;
+        string spec<>;
+        gfx_dict xdata; /* Extra data */
+} ;
+
+
+ struct gfx_notify_req {
+        unsigned int  flags;
+        string buf<>;
+        gfx_dict xdata; /* Extra data */
+}  ;
+ struct gfx_notify_rsp {
+        int    op_ret;
+        int    op_errno;
+        unsigned int  flags;
+        string buf<>;
+        gfx_dict xdata; /* Extra data */
+}  ;
+
+struct gfx_releasedir_req {
+        opaque gfid[16];
+        quad_t  fd;
+        gfx_dict xdata; /* Extra data */
+}  ;
+
+struct gfx_release_req {
+        opaque gfid[16];
+        quad_t  fd;
+        gfx_dict xdata; /* Extra data */
+}  ;
+
+struct gfx_dirlist {
+       u_quad_t d_ino;
+       u_quad_t d_off;
+       unsigned int d_len;
+       unsigned int d_type;
+       string name<>;
+       gfx_dirlist *nextentry;
+};
+
+
+struct gfx_readdir_rsp {
        int op_ret;
        int op_errno;
-       gf_iatt stat;
-       opaque xdata<>;
+       gfx_dict xdata; /* Extra data */
+       gfx_dirlist *reply;
 };
 
-struct gfs4_icreate_req {
-       opaque gfid[16];
-       unsigned int mode;
-       opaque xdata<>;
+struct gfx_dirplist {
+       u_quad_t d_ino;
+       u_quad_t d_off;
+       unsigned int d_len;
+       unsigned int d_type;
+       string name<>;
+       gfx_iattx stat;
+       gfx_dict dict;
+       gfx_dirplist *nextentry;
 };
 
-struct gfs4_namelink_rsp {
+struct gfx_readdirp_rsp {
        int op_ret;
        int op_errno;
-       gf_iatt preparent;
-       gf_iatt postparent;
-       opaque xdata<>;
+       gfx_dict xdata; /* Extra data */
+       gfx_dirplist *reply;
 };
 
-struct gfs4_namelink_req {
-       opaque pargfid[16];
-       string bname<>;
-       opaque xdata<>;
+struct gfx_set_lk_ver_rsp {
+       int op_ret;
+       int op_errno;
+       gfx_dict xdata;
+       int lk_ver;
+};
+
+struct gfx_set_lk_ver_req {
+       string uid<>;
+       int lk_ver;
+};
+
+struct gfx_event_notify_req {
+        int op;
+        gfx_dict dict;
+};
+
+
+struct gfx_getsnap_name_uuid_req {
+        gfx_dict dict;
+};
+
+struct gfx_getsnap_name_uuid_rsp {
+        int op_ret;
+        int op_errno;
+        gfx_dict dict;
+        string op_errstr<>;
+};
+
+struct gfx_getactivelk_rsp {
+        int op_ret;
+        int op_errno;
+        gfx_dict xdata;
+        gfs3_locklist *reply;
+};
+
+struct gfx_getactivelk_req {
+        opaque gfid[16];
+        gfx_dict xdata;
+};
+
+struct gfx_setactivelk_req {
+        opaque gfid[16];
+        gfs3_locklist *request;
+        gfx_dict xdata;
+};
+
+union compound_req_v2 switch (glusterfs_fop_t fop_enum) {
+        case GF_FOP_STAT:         gfx_stat_req compound_stat_req;
+        case GF_FOP_READLINK:     gfx_readlink_req compound_readlink_req;
+        case GF_FOP_MKNOD:        gfx_mknod_req compound_mknod_req;
+        case GF_FOP_MKDIR:        gfx_mkdir_req compound_mkdir_req;
+        case GF_FOP_UNLINK:       gfx_unlink_req compound_unlink_req;
+        case GF_FOP_RMDIR:        gfx_rmdir_req compound_rmdir_req;
+        case GF_FOP_SYMLINK:      gfx_symlink_req compound_symlink_req;
+        case GF_FOP_RENAME:       gfx_rename_req compound_rename_req;
+        case GF_FOP_LINK:         gfx_link_req compound_link_req;
+        case GF_FOP_TRUNCATE:     gfx_truncate_req compound_truncate_req;
+        case GF_FOP_OPEN:         gfx_open_req compound_open_req;
+        case GF_FOP_READ:         gfx_read_req compound_read_req;
+        case GF_FOP_WRITE:        gfx_write_req compound_write_req;
+        case GF_FOP_STATFS:       gfx_statfs_req compound_statfs_req;
+        case GF_FOP_FLUSH:        gfx_flush_req compound_flush_req;
+        case GF_FOP_FSYNC:        gfx_fsync_req compound_fsync_req;
+        case GF_FOP_GETXATTR:     gfx_getxattr_req compound_getxattr_req;
+        case GF_FOP_SETXATTR:     gfx_setxattr_req compound_setxattr_req;
+        case GF_FOP_REMOVEXATTR:  gfx_removexattr_req compound_removexattr_req;
+        case GF_FOP_OPENDIR:      gfx_opendir_req compound_opendir_req;
+        case GF_FOP_FSYNCDIR:     gfx_fsyncdir_req compound_fsyncdir_req;
+        case GF_FOP_ACCESS:       gfx_access_req compound_access_req;
+        case GF_FOP_CREATE:       gfx_create_req compound_create_req;
+        case GF_FOP_FTRUNCATE:    gfx_ftruncate_req compound_ftruncate_req;
+        case GF_FOP_FSTAT:        gfx_fstat_req compound_fstat_req;
+        case GF_FOP_LK:           gfx_lk_req compound_lk_req;
+        case GF_FOP_LOOKUP:       gfx_lookup_req compound_lookup_req;
+        case GF_FOP_READDIR:      gfx_readdir_req compound_readdir_req;
+        case GF_FOP_INODELK:      gfx_inodelk_req compound_inodelk_req;
+        case GF_FOP_FINODELK:     gfx_finodelk_req compound_finodelk_req;
+        case GF_FOP_ENTRYLK:      gfx_entrylk_req compound_entrylk_req;
+        case GF_FOP_FENTRYLK:     gfx_fentrylk_req compound_fentrylk_req;
+        case GF_FOP_XATTROP:      gfx_xattrop_req compound_xattrop_req;
+        case GF_FOP_FXATTROP:     gfx_fxattrop_req compound_fxattrop_req;
+        case GF_FOP_FGETXATTR:    gfx_fgetxattr_req compound_fgetxattr_req;
+        case GF_FOP_FSETXATTR:    gfx_fsetxattr_req compound_fsetxattr_req;
+        case GF_FOP_RCHECKSUM:    gfx_rchecksum_req compound_rchecksum_req;
+        case GF_FOP_SETATTR:      gfx_setattr_req compound_setattr_req;
+        case GF_FOP_FSETATTR:     gfx_fsetattr_req compound_fsetattr_req;
+        case GF_FOP_READDIRP:     gfx_readdirp_req compound_readdirp_req;
+        case GF_FOP_RELEASE:      gfx_release_req compound_release_req;
+        case GF_FOP_RELEASEDIR:   gfx_releasedir_req compound_releasedir_req;
+        case GF_FOP_FREMOVEXATTR: gfx_fremovexattr_req compound_fremovexattr_req;
+        case GF_FOP_FALLOCATE:    gfx_fallocate_req compound_fallocate_req;
+        case GF_FOP_DISCARD:      gfx_discard_req compound_discard_req;
+        case GF_FOP_ZEROFILL:     gfx_zerofill_req compound_zerofill_req;
+        case GF_FOP_IPC:          gfx_ipc_req compound_ipc_req;
+        case GF_FOP_SEEK:         gfx_seek_req compound_seek_req;
+        case GF_FOP_LEASE:         gfx_lease_req compound_lease_req;
+        default:                  void;
+};
+
+struct gfx_compound_req {
+        int                       compound_version;
+        glusterfs_compound_fop_t  compound_fop_enum;
+        compound_req_v2           compound_req_array<>;
+        gfx_dict                  xdata;
+};
+
+union compound_rsp_v2 switch (glusterfs_fop_t fop_enum) {
+        case GF_FOP_STAT:         gfx_common_iatt_rsp compound_stat_rsp;
+        case GF_FOP_READLINK:     gfx_readlink_rsp compound_readlink_rsp;
+        case GF_FOP_MKNOD:        gfx_common_3iatt_rsp compound_mknod_rsp;
+        case GF_FOP_MKDIR:        gfx_common_3iatt_rsp compound_mkdir_rsp;
+        case GF_FOP_UNLINK:       gfx_common_2iatt_rsp compound_unlink_rsp;
+        case GF_FOP_RMDIR:        gfx_common_2iatt_rsp compound_rmdir_rsp;
+        case GF_FOP_SYMLINK:      gfx_common_3iatt_rsp compound_symlink_rsp;
+        case GF_FOP_RENAME:       gfx_rename_rsp compound_rename_rsp;
+        case GF_FOP_LINK:         gfx_common_3iatt_rsp compound_link_rsp;
+        case GF_FOP_TRUNCATE:     gfx_common_2iatt_rsp compound_truncate_rsp;
+        case GF_FOP_OPEN:         gfx_open_rsp compound_open_rsp;
+        case GF_FOP_READ:         gfx_read_rsp compound_read_rsp;
+        case GF_FOP_WRITE:        gfx_common_2iatt_rsp compound_write_rsp;
+        case GF_FOP_STATFS:       gfx_statfs_rsp compound_statfs_rsp;
+        case GF_FOP_FLUSH:        gfx_common_rsp compound_flush_rsp;
+        case GF_FOP_FSYNC:        gfx_common_2iatt_rsp compound_fsync_rsp;
+        case GF_FOP_GETXATTR:     gfx_common_dict_rsp compound_getxattr_rsp;
+        case GF_FOP_SETXATTR:     gfx_common_rsp compound_setxattr_rsp;
+        case GF_FOP_REMOVEXATTR:  gfx_common_rsp compound_removexattr_rsp;
+        case GF_FOP_OPENDIR:      gfx_open_rsp compound_opendir_rsp;
+        case GF_FOP_FSYNCDIR:     gfx_common_rsp compound_fsyncdir_rsp;
+        case GF_FOP_ACCESS:       gfx_common_rsp compound_access_rsp;
+        case GF_FOP_CREATE:       gfx_create_rsp compound_create_rsp;
+        case GF_FOP_FTRUNCATE:    gfx_common_2iatt_rsp compound_ftruncate_rsp;
+        case GF_FOP_FSTAT:        gfx_common_iatt_rsp compound_fstat_rsp;
+        case GF_FOP_LK:           gfx_lk_rsp compound_lk_rsp;
+        case GF_FOP_LOOKUP:       gfx_common_2iatt_rsp compound_lookup_rsp;
+        case GF_FOP_READDIR:      gfx_readdir_rsp compound_readdir_rsp;
+        case GF_FOP_INODELK:      gfx_common_rsp compound_inodelk_rsp;
+        case GF_FOP_FINODELK:     gfx_common_rsp compound_finodelk_rsp;
+        case GF_FOP_ENTRYLK:      gfx_common_rsp compound_entrylk_rsp;
+        case GF_FOP_FENTRYLK:     gfx_common_rsp compound_fentrylk_rsp;
+        case GF_FOP_XATTROP:      gfx_common_dict_rsp compound_xattrop_rsp;
+        case GF_FOP_FXATTROP:     gfx_common_dict_rsp compound_fxattrop_rsp;
+        case GF_FOP_FGETXATTR:    gfx_common_dict_rsp compound_fgetxattr_rsp;
+        case GF_FOP_FSETXATTR:    gfx_common_rsp compound_fsetxattr_rsp;
+        case GF_FOP_RCHECKSUM:    gfx_rchecksum_rsp compound_rchecksum_rsp;
+        case GF_FOP_SETATTR:      gfx_common_2iatt_rsp compound_setattr_rsp;
+        case GF_FOP_FSETATTR:     gfx_common_2iatt_rsp compound_fsetattr_rsp;
+        case GF_FOP_READDIRP:     gfx_readdirp_rsp compound_readdirp_rsp;
+        case GF_FOP_RELEASE:      gfx_common_rsp compound_release_rsp;
+        case GF_FOP_RELEASEDIR:   gfx_common_rsp compound_releasedir_rsp;
+        case GF_FOP_FREMOVEXATTR: gfx_common_rsp compound_fremovexattr_rsp;
+        case GF_FOP_FALLOCATE:    gfx_common_2iatt_rsp compound_fallocate_rsp;
+        case GF_FOP_DISCARD:      gfx_common_2iatt_rsp compound_discard_rsp;
+        case GF_FOP_ZEROFILL:     gfx_common_2iatt_rsp compound_zerofill_rsp;
+        case GF_FOP_IPC:          gfx_common_rsp compound_ipc_rsp;
+        case GF_FOP_SEEK:         gfx_seek_rsp compound_seek_rsp;
+        case GF_FOP_LEASE:        gfx_lease_rsp compound_lease_rsp;
+        default:                  void;
+};
+
+struct gfx_compound_rsp {
+        int           op_ret;
+        int           op_errno;
+        compound_rsp_v2  compound_rsp_array<>;
+        gfx_dict      xdata;
 };
 
 struct gfs4_inodelk_contention_req {
diff --git a/rpc/xdr/src/libgfxdr.sym b/rpc/xdr/src/libgfxdr.sym
index f6aa300544a..89fc513eda7 100644
--- a/rpc/xdr/src/libgfxdr.sym
+++ b/rpc/xdr/src/libgfxdr.sym
@@ -249,3 +249,97 @@ xdr_to_setattr3args
 xdr_to_symlink3args
 xdr_to_write3args
 xdr_vector_round_up
+xdr_gfx_read_rsp
+xdr_gfx_iattx
+xdr_gfx_value
+xdr_gfx_dict_pair
+xdr_gfx_dict
+xdr_gfx_common_rsp
+xdr_gfx_common_iatt_rsp
+xdr_gfx_common_2iatt_rsp
+xdr_gfx_common_3iatt_rsp
+xdr_gfx_fsetattr_req
+xdr_gfx_rchecksum_req
+xdr_gfx_icreate_req
+xdr_gfx_namelink_req
+xdr_gfx_stat_req
+xdr_gfx_readlink_req
+xdr_gfx_readlink_rsp
+xdr_gfx_mknod_req
+xdr_gfx_mkdir_req
+xdr_gfx_unlink_req
+xdr_gfx_rmdir_req
+xdr_gfx_symlink_req
+xdr_gfx_rename_req
+xdr_gfx_rename_rsp
+xdr_gfx_link_req
+xdr_gfx_truncate_req
+xdr_gfx_open_req
+xdr_gfx_open_rsp
+xdr_gfx_opendir_req
+xdr_gfx_read_req
+xdr_gfx_read_rsp
+xdr_gfx_lookup_req
+xdr_gfx_write_req
+xdr_gfx_statfs_req
+xdr_gfx_statfs_rsp
+xdr_gfx_lk_req
+xdr_gfx_lk_rsp
+xdr_gfx_lease_req
+xdr_gfx_lease_rsp
+xdr_gfx_recall_lease_req
+xdr_gfx_inodelk_req
+xdr_gfx_finodelk_req
+xdr_gfx_flush_req
+xdr_gfx_fsync_req
+xdr_gfx_setxattr_req
+xdr_gfx_fsetxattr_req
+xdr_gfx_xattrop_req
+xdr_gfx_common_dict_rsp
+xdr_gfx_fxattrop_req
+xdr_gfx_getxattr_req
+xdr_gfx_fgetxattr_req
+xdr_gfx_removexattr_req
+xdr_gfx_fremovexattr_req
+xdr_gfx_fsyncdir_req
+xdr_gfx_readdir_req
+xdr_gfx_readdirp_req
+xdr_gfx_access_req
+xdr_gfx_create_req
+xdr_gfx_create_rsp
+xdr_gfx_ftruncate_req
+xdr_gfx_fstat_req
+xdr_gfx_entrylk_req
+xdr_gfx_fentrylk_req
+xdr_gfx_setattr_req
+xdr_gfx_fallocate_req
+xdr_gfx_discard_req
+xdr_gfx_zerofill_req
+xdr_gfx_rchecksum_rsp
+xdr_gfx_ipc_req
+xdr_gfx_seek_req
+xdr_gfx_seek_rsp
+xdr_gfx_setvolume_req
+xdr_gfx_setvolume_rsp
+xdr_gfx_getspec_req
+xdr_gfx_getspec_rsp
+xdr_gfx_notify_req
+xdr_gfx_notify_rsp
+xdr_gfx_releasedir_req
+xdr_gfx_release_req
+xdr_gfx_dirlist
+xdr_gfx_readdir_rsp
+xdr_gfx_dirplist
+xdr_gfx_readdirp_rsp
+xdr_gfx_set_lk_ver_rsp
+xdr_gfx_set_lk_ver_req
+xdr_gfx_event_notify_req
+xdr_gfx_getsnap_name_uuid_req
+xdr_gfx_getsnap_name_uuid_rsp
+xdr_gfx_getactivelk_rsp
+xdr_gfx_getactivelk_req
+xdr_gfx_setactivelk_req
+xdr_compound_req_v2
+xdr_gfx_compound_req
+xdr_compound_rsp_v2
+xdr_gfx_compound_rsp