diff options
Diffstat (limited to 'rpc')
| -rw-r--r-- | rpc/xdr/src/glusterfs3.h | 303 | ||||
| -rw-r--r-- | rpc/xdr/src/glusterfs4-xdr.x | 801 | ||||
| -rw-r--r-- | rpc/xdr/src/libgfxdr.sym | 94 |
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 |