diff options
Diffstat (limited to 'rpc/xdr/src/glusterfs3.h')
| -rw-r--r-- | rpc/xdr/src/glusterfs3.h | 1408 |
1 files changed, 709 insertions, 699 deletions
diff --git a/rpc/xdr/src/glusterfs3.h b/rpc/xdr/src/glusterfs3.h index 4ffad3c5b45..b8ef394abaf 100644 --- a/rpc/xdr/src/glusterfs3.h +++ b/rpc/xdr/src/glusterfs3.h @@ -20,867 +20,877 @@ #include "protocol-common.h" #include "upcall-utils.h" -#define xdr_decoded_remaining_addr(xdr) ((&xdr)->x_private) -#define xdr_decoded_remaining_len(xdr) ((&xdr)->x_handy) -#define xdr_encoded_length(xdr) (((size_t)(&xdr)->x_private) - ((size_t)(&xdr)->x_base)) -#define xdr_decoded_length(xdr) (((size_t)(&xdr)->x_private) - ((size_t)(&xdr)->x_base)) - - -#define GF_O_ACCMODE 003 -#define GF_O_RDONLY 00 -#define GF_O_WRONLY 01 -#define GF_O_RDWR 02 -#define GF_O_CREAT 0100 -#define GF_O_EXCL 0200 -#define GF_O_NOCTTY 0400 -#define GF_O_TRUNC 01000 -#define GF_O_APPEND 02000 -#define GF_O_NONBLOCK 04000 -#define GF_O_SYNC 010000 -#define GF_O_ASYNC 020000 - -#define GF_O_DIRECT 040000 -#define GF_O_DIRECTORY 0200000 -#define GF_O_NOFOLLOW 0400000 -#define GF_O_NOATIME 01000000 -#define GF_O_CLOEXEC 02000000 - -#define GF_O_LARGEFILE 0100000 - -#define GF_O_FMODE_EXEC 040 - -#define XLATE_BIT(from, to, bit) do { \ - if (from & bit) \ - to = to | GF_##bit; \ - } while (0) - -#define UNXLATE_BIT(from, to, bit) do { \ - if (from & GF_##bit) \ - to = to | bit; \ - } while (0) - -#define XLATE_ACCESSMODE(from, to) do { \ - switch (from & O_ACCMODE) { \ - case O_RDONLY: to |= GF_O_RDONLY; \ - break; \ - case O_WRONLY: to |= GF_O_WRONLY; \ - break; \ - case O_RDWR: to |= GF_O_RDWR; \ - break; \ - } \ - } while (0) - -#define UNXLATE_ACCESSMODE(from, to) do { \ - switch (from & GF_O_ACCMODE) { \ - case GF_O_RDONLY: to |= O_RDONLY; \ - break; \ - case GF_O_WRONLY: to |= O_WRONLY; \ - break; \ - case GF_O_RDWR: to |= O_RDWR; \ - break; \ - } \ - } while (0) +#define xdr_decoded_remaining_addr(xdr) ((&xdr)->x_private) +#define xdr_decoded_remaining_len(xdr) ((&xdr)->x_handy) +#define xdr_encoded_length(xdr) \ + (((size_t)(&xdr)->x_private) - ((size_t)(&xdr)->x_base)) +#define xdr_decoded_length(xdr) \ + (((size_t)(&xdr)->x_private) - ((size_t)(&xdr)->x_base)) + +#define GF_O_ACCMODE 003 +#define GF_O_RDONLY 00 +#define GF_O_WRONLY 01 +#define GF_O_RDWR 02 +#define GF_O_CREAT 0100 +#define GF_O_EXCL 0200 +#define GF_O_NOCTTY 0400 +#define GF_O_TRUNC 01000 +#define GF_O_APPEND 02000 +#define GF_O_NONBLOCK 04000 +#define GF_O_SYNC 010000 +#define GF_O_ASYNC 020000 + +#define GF_O_DIRECT 040000 +#define GF_O_DIRECTORY 0200000 +#define GF_O_NOFOLLOW 0400000 +#define GF_O_NOATIME 01000000 +#define GF_O_CLOEXEC 02000000 + +#define GF_O_LARGEFILE 0100000 + +#define GF_O_FMODE_EXEC 040 + +#define XLATE_BIT(from, to, bit) \ + do { \ + if (from & bit) \ + to = to | GF_##bit; \ + } while (0) + +#define UNXLATE_BIT(from, to, bit) \ + do { \ + if (from & GF_##bit) \ + to = to | bit; \ + } while (0) + +#define XLATE_ACCESSMODE(from, to) \ + do { \ + switch (from & O_ACCMODE) { \ + case O_RDONLY: \ + to |= GF_O_RDONLY; \ + break; \ + case O_WRONLY: \ + to |= GF_O_WRONLY; \ + break; \ + case O_RDWR: \ + to |= GF_O_RDWR; \ + break; \ + } \ + } while (0) + +#define UNXLATE_ACCESSMODE(from, to) \ + do { \ + switch (from & GF_O_ACCMODE) { \ + case GF_O_RDONLY: \ + to |= O_RDONLY; \ + break; \ + case GF_O_WRONLY: \ + to |= O_WRONLY; \ + break; \ + case GF_O_RDWR: \ + to |= O_RDWR; \ + break; \ + } \ + } while (0) static inline uint32_t -gf_flags_from_flags (uint32_t flags) +gf_flags_from_flags(uint32_t flags) { - uint32_t gf_flags = 0; - - XLATE_ACCESSMODE (flags, gf_flags); - - XLATE_BIT (flags, gf_flags, O_CREAT); - XLATE_BIT (flags, gf_flags, O_EXCL); - XLATE_BIT (flags, gf_flags, O_NOCTTY); - XLATE_BIT (flags, gf_flags, O_TRUNC); - XLATE_BIT (flags, gf_flags, O_APPEND); - XLATE_BIT (flags, gf_flags, O_NONBLOCK); - XLATE_BIT (flags, gf_flags, O_SYNC); - XLATE_BIT (flags, gf_flags, O_ASYNC); - - XLATE_BIT (flags, gf_flags, O_DIRECT); - XLATE_BIT (flags, gf_flags, O_DIRECTORY); - XLATE_BIT (flags, gf_flags, O_NOFOLLOW); + uint32_t gf_flags = 0; + + XLATE_ACCESSMODE(flags, gf_flags); + + XLATE_BIT(flags, gf_flags, O_CREAT); + XLATE_BIT(flags, gf_flags, O_EXCL); + XLATE_BIT(flags, gf_flags, O_NOCTTY); + XLATE_BIT(flags, gf_flags, O_TRUNC); + XLATE_BIT(flags, gf_flags, O_APPEND); + XLATE_BIT(flags, gf_flags, O_NONBLOCK); + XLATE_BIT(flags, gf_flags, O_SYNC); + XLATE_BIT(flags, gf_flags, O_ASYNC); + + XLATE_BIT(flags, gf_flags, O_DIRECT); + XLATE_BIT(flags, gf_flags, O_DIRECTORY); + XLATE_BIT(flags, gf_flags, O_NOFOLLOW); #ifdef O_NOATIME - XLATE_BIT (flags, gf_flags, O_NOATIME); + XLATE_BIT(flags, gf_flags, O_NOATIME); #endif #ifdef O_CLOEXEC - XLATE_BIT (flags, gf_flags, O_CLOEXEC); + XLATE_BIT(flags, gf_flags, O_CLOEXEC); #endif - XLATE_BIT (flags, gf_flags, O_LARGEFILE); - XLATE_BIT (flags, gf_flags, O_FMODE_EXEC); + XLATE_BIT(flags, gf_flags, O_LARGEFILE); + XLATE_BIT(flags, gf_flags, O_FMODE_EXEC); - return gf_flags; + return gf_flags; } static inline uint32_t -gf_flags_to_flags (uint32_t gf_flags) +gf_flags_to_flags(uint32_t gf_flags) { - uint32_t flags = 0; - - UNXLATE_ACCESSMODE (gf_flags, flags); - - UNXLATE_BIT (gf_flags, flags, O_CREAT); - UNXLATE_BIT (gf_flags, flags, O_EXCL); - UNXLATE_BIT (gf_flags, flags, O_NOCTTY); - UNXLATE_BIT (gf_flags, flags, O_TRUNC); - UNXLATE_BIT (gf_flags, flags, O_APPEND); - UNXLATE_BIT (gf_flags, flags, O_NONBLOCK); - UNXLATE_BIT (gf_flags, flags, O_SYNC); - UNXLATE_BIT (gf_flags, flags, O_ASYNC); - - UNXLATE_BIT (gf_flags, flags, O_DIRECT); - UNXLATE_BIT (gf_flags, flags, O_DIRECTORY); - UNXLATE_BIT (gf_flags, flags, O_NOFOLLOW); + uint32_t flags = 0; + + UNXLATE_ACCESSMODE(gf_flags, flags); + + UNXLATE_BIT(gf_flags, flags, O_CREAT); + UNXLATE_BIT(gf_flags, flags, O_EXCL); + UNXLATE_BIT(gf_flags, flags, O_NOCTTY); + UNXLATE_BIT(gf_flags, flags, O_TRUNC); + UNXLATE_BIT(gf_flags, flags, O_APPEND); + UNXLATE_BIT(gf_flags, flags, O_NONBLOCK); + UNXLATE_BIT(gf_flags, flags, O_SYNC); + UNXLATE_BIT(gf_flags, flags, O_ASYNC); + + UNXLATE_BIT(gf_flags, flags, O_DIRECT); + UNXLATE_BIT(gf_flags, flags, O_DIRECTORY); + UNXLATE_BIT(gf_flags, flags, O_NOFOLLOW); #ifdef O_NOATIME - UNXLATE_BIT (gf_flags, flags, O_NOATIME); + UNXLATE_BIT(gf_flags, flags, O_NOATIME); #endif #ifdef O_CLOEXEC - UNXLATE_BIT (gf_flags, flags, O_CLOEXEC); + UNXLATE_BIT(gf_flags, flags, O_CLOEXEC); #endif - UNXLATE_BIT (gf_flags, flags, O_LARGEFILE); - UNXLATE_BIT (gf_flags, flags, O_FMODE_EXEC); + UNXLATE_BIT(gf_flags, flags, O_LARGEFILE); + UNXLATE_BIT(gf_flags, flags, O_FMODE_EXEC); - return flags; + return flags; } - static inline void -gf_statfs_to_statfs (struct gf_statfs *gf_stat, struct statvfs *stat) +gf_statfs_to_statfs(struct gf_statfs *gf_stat, struct statvfs *stat) { - if (!stat || !gf_stat) - return; - - stat->f_bsize = (gf_stat->bsize); - stat->f_frsize = (gf_stat->frsize); - stat->f_blocks = (gf_stat->blocks); - stat->f_bfree = (gf_stat->bfree); - stat->f_bavail = (gf_stat->bavail); - stat->f_files = (gf_stat->files); - stat->f_ffree = (gf_stat->ffree); - stat->f_favail = (gf_stat->favail); - stat->f_fsid = (gf_stat->fsid); - stat->f_flag = (gf_stat->flag); - stat->f_namemax = (gf_stat->namemax); + if (!stat || !gf_stat) + return; + + stat->f_bsize = (gf_stat->bsize); + stat->f_frsize = (gf_stat->frsize); + stat->f_blocks = (gf_stat->blocks); + stat->f_bfree = (gf_stat->bfree); + stat->f_bavail = (gf_stat->bavail); + stat->f_files = (gf_stat->files); + stat->f_ffree = (gf_stat->ffree); + stat->f_favail = (gf_stat->favail); + stat->f_fsid = (gf_stat->fsid); + stat->f_flag = (gf_stat->flag); + stat->f_namemax = (gf_stat->namemax); } - static inline void -gf_statfs_from_statfs (struct gf_statfs *gf_stat, struct statvfs *stat) +gf_statfs_from_statfs(struct gf_statfs *gf_stat, struct statvfs *stat) { - if (!stat || !gf_stat) - return; - - gf_stat->bsize = stat->f_bsize; - gf_stat->frsize = stat->f_frsize; - gf_stat->blocks = stat->f_blocks; - gf_stat->bfree = stat->f_bfree; - gf_stat->bavail = stat->f_bavail; - gf_stat->files = stat->f_files; - gf_stat->ffree = stat->f_ffree; - gf_stat->favail = stat->f_favail; - gf_stat->fsid = stat->f_fsid; - gf_stat->flag = stat->f_flag; - gf_stat->namemax = stat->f_namemax; + if (!stat || !gf_stat) + return; + + gf_stat->bsize = stat->f_bsize; + gf_stat->frsize = stat->f_frsize; + gf_stat->blocks = stat->f_blocks; + gf_stat->bfree = stat->f_bfree; + gf_stat->bavail = stat->f_bavail; + gf_stat->files = stat->f_files; + gf_stat->ffree = stat->f_ffree; + gf_stat->favail = stat->f_favail; + gf_stat->fsid = stat->f_fsid; + gf_stat->flag = stat->f_flag; + gf_stat->namemax = stat->f_namemax; } static inline void -gf_proto_lease_to_lease (struct gf_proto_lease *gf_proto_lease, struct gf_lease *gf_lease) +gf_proto_lease_to_lease(struct gf_proto_lease *gf_proto_lease, + struct gf_lease *gf_lease) { - if (!gf_lease || !gf_proto_lease) - return; + if (!gf_lease || !gf_proto_lease) + return; - gf_lease->cmd = gf_proto_lease->cmd; - gf_lease->lease_type = gf_proto_lease->lease_type; - memcpy (gf_lease->lease_id, gf_proto_lease->lease_id, LEASE_ID_SIZE); + gf_lease->cmd = gf_proto_lease->cmd; + gf_lease->lease_type = gf_proto_lease->lease_type; + memcpy(gf_lease->lease_id, gf_proto_lease->lease_id, LEASE_ID_SIZE); } static inline void -gf_proto_lease_from_lease (struct gf_proto_lease *gf_proto_lease, struct gf_lease *gf_lease) +gf_proto_lease_from_lease(struct gf_proto_lease *gf_proto_lease, + struct gf_lease *gf_lease) { - if (!gf_lease || !gf_proto_lease) - return; + if (!gf_lease || !gf_proto_lease) + return; - gf_proto_lease->cmd = gf_lease->cmd; - gf_proto_lease->lease_type = gf_lease->lease_type; - memcpy (gf_proto_lease->lease_id, gf_lease->lease_id, LEASE_ID_SIZE); + gf_proto_lease->cmd = gf_lease->cmd; + gf_proto_lease->lease_type = gf_lease->lease_type; + memcpy(gf_proto_lease->lease_id, gf_lease->lease_id, LEASE_ID_SIZE); } static inline int -gf_proto_recall_lease_to_upcall (struct gfs3_recall_lease_req *recall_lease, - struct gf_upcall *gf_up_data) +gf_proto_recall_lease_to_upcall(struct gfs3_recall_lease_req *recall_lease, + struct gf_upcall *gf_up_data) { - struct gf_upcall_recall_lease *tmp = NULL; - int ret = 0; + struct gf_upcall_recall_lease *tmp = NULL; + int ret = 0; - GF_VALIDATE_OR_GOTO(THIS->name, recall_lease, out); - GF_VALIDATE_OR_GOTO(THIS->name, gf_up_data, out); + GF_VALIDATE_OR_GOTO(THIS->name, recall_lease, out); + GF_VALIDATE_OR_GOTO(THIS->name, gf_up_data, out); - tmp = (struct gf_upcall_recall_lease *)gf_up_data->data; - tmp->lease_type = recall_lease->lease_type; - memcpy (gf_up_data->gfid, recall_lease->gfid, 16); - memcpy (tmp->tid, recall_lease->tid, 16); + tmp = (struct gf_upcall_recall_lease *)gf_up_data->data; + tmp->lease_type = recall_lease->lease_type; + memcpy(gf_up_data->gfid, recall_lease->gfid, 16); + memcpy(tmp->tid, recall_lease->tid, 16); - GF_PROTOCOL_DICT_UNSERIALIZE (THIS, tmp->dict, - (recall_lease->xdata).xdata_val, - (recall_lease->xdata).xdata_len, ret, - errno, out); + GF_PROTOCOL_DICT_UNSERIALIZE( + THIS, tmp->dict, (recall_lease->xdata).xdata_val, + (recall_lease->xdata).xdata_len, ret, errno, out); out: - return ret; - + return ret; } static inline int -gf_proto_recall_lease_from_upcall (xlator_t *this, - struct gfs3_recall_lease_req *recall_lease, - struct gf_upcall *gf_up_data) +gf_proto_recall_lease_from_upcall(xlator_t *this, + struct gfs3_recall_lease_req *recall_lease, + struct gf_upcall *gf_up_data) { - struct gf_upcall_recall_lease *tmp = NULL; - int ret = 0; + struct gf_upcall_recall_lease *tmp = NULL; + int ret = 0; - GF_VALIDATE_OR_GOTO(this->name, recall_lease, out); - GF_VALIDATE_OR_GOTO(this->name, gf_up_data, out); + GF_VALIDATE_OR_GOTO(this->name, recall_lease, out); + GF_VALIDATE_OR_GOTO(this->name, gf_up_data, out); - tmp = (struct gf_upcall_recall_lease *)gf_up_data->data; - recall_lease->lease_type = tmp->lease_type; - memcpy (recall_lease->gfid, gf_up_data->gfid, 16); - memcpy (recall_lease->tid, tmp->tid, 16); + tmp = (struct gf_upcall_recall_lease *)gf_up_data->data; + recall_lease->lease_type = tmp->lease_type; + memcpy(recall_lease->gfid, gf_up_data->gfid, 16); + memcpy(recall_lease->tid, tmp->tid, 16); - GF_PROTOCOL_DICT_SERIALIZE (this, tmp->dict, - &(recall_lease->xdata).xdata_val, - (recall_lease->xdata).xdata_len, ret, out); + GF_PROTOCOL_DICT_SERIALIZE(this, tmp->dict, + &(recall_lease->xdata).xdata_val, + (recall_lease->xdata).xdata_len, ret, out); out: - return ret; - + return ret; } static inline void -gf_proto_flock_to_flock (struct gf_proto_flock *gf_proto_flock, struct gf_flock *gf_flock) +gf_proto_flock_to_flock(struct gf_proto_flock *gf_proto_flock, + struct gf_flock *gf_flock) { - if (!gf_flock || !gf_proto_flock) - return; - - gf_flock->l_type = gf_proto_flock->type; - gf_flock->l_whence = gf_proto_flock->whence; - gf_flock->l_start = gf_proto_flock->start; - gf_flock->l_len = gf_proto_flock->len; - gf_flock->l_pid = gf_proto_flock->pid; - gf_flock->l_owner.len = gf_proto_flock->lk_owner.lk_owner_len; - if (gf_flock->l_owner.len && - (gf_flock->l_owner.len < GF_MAX_LOCK_OWNER_LEN)) - memcpy (gf_flock->l_owner.data, gf_proto_flock->lk_owner.lk_owner_val, - gf_flock->l_owner.len); + if (!gf_flock || !gf_proto_flock) + return; + + gf_flock->l_type = gf_proto_flock->type; + gf_flock->l_whence = gf_proto_flock->whence; + gf_flock->l_start = gf_proto_flock->start; + gf_flock->l_len = gf_proto_flock->len; + gf_flock->l_pid = gf_proto_flock->pid; + gf_flock->l_owner.len = gf_proto_flock->lk_owner.lk_owner_len; + if (gf_flock->l_owner.len && + (gf_flock->l_owner.len < GF_MAX_LOCK_OWNER_LEN)) + memcpy(gf_flock->l_owner.data, gf_proto_flock->lk_owner.lk_owner_val, + gf_flock->l_owner.len); } - static inline void -gf_proto_flock_from_flock (struct gf_proto_flock *gf_proto_flock, struct gf_flock *gf_flock) +gf_proto_flock_from_flock(struct gf_proto_flock *gf_proto_flock, + struct gf_flock *gf_flock) { - if (!gf_flock || !gf_proto_flock) - return; - - gf_proto_flock->type = (gf_flock->l_type); - gf_proto_flock->whence = (gf_flock->l_whence); - gf_proto_flock->start = (gf_flock->l_start); - gf_proto_flock->len = (gf_flock->l_len); - gf_proto_flock->pid = (gf_flock->l_pid); - gf_proto_flock->lk_owner.lk_owner_len = gf_flock->l_owner.len; - if (gf_flock->l_owner.len) - gf_proto_flock->lk_owner.lk_owner_val = gf_flock->l_owner.data; + if (!gf_flock || !gf_proto_flock) + return; + + gf_proto_flock->type = (gf_flock->l_type); + gf_proto_flock->whence = (gf_flock->l_whence); + gf_proto_flock->start = (gf_flock->l_start); + gf_proto_flock->len = (gf_flock->l_len); + gf_proto_flock->pid = (gf_flock->l_pid); + gf_proto_flock->lk_owner.lk_owner_len = gf_flock->l_owner.len; + if (gf_flock->l_owner.len) + gf_proto_flock->lk_owner.lk_owner_val = gf_flock->l_owner.data; } static inline void -gf_stat_to_iatt (struct gf_iatt *gf_stat, struct iatt *iatt) +gf_stat_to_iatt(struct gf_iatt *gf_stat, struct iatt *iatt) { - if (!iatt || !gf_stat) - return; - - memcpy (iatt->ia_gfid, gf_stat->ia_gfid, 16); - iatt->ia_ino = gf_stat->ia_ino ; - iatt->ia_dev = gf_stat->ia_dev ; - iatt->ia_type = ia_type_from_st_mode (gf_stat->mode) ; - iatt->ia_prot = ia_prot_from_st_mode (gf_stat->mode) ; - iatt->ia_nlink = gf_stat->ia_nlink ; - iatt->ia_uid = gf_stat->ia_uid ; - iatt->ia_gid = gf_stat->ia_gid ; - iatt->ia_rdev = gf_stat->ia_rdev ; - iatt->ia_size = gf_stat->ia_size ; - 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 ; + if (!iatt || !gf_stat) + return; + + memcpy(iatt->ia_gfid, gf_stat->ia_gfid, 16); + iatt->ia_ino = gf_stat->ia_ino; + iatt->ia_dev = gf_stat->ia_dev; + iatt->ia_type = ia_type_from_st_mode(gf_stat->mode); + iatt->ia_prot = ia_prot_from_st_mode(gf_stat->mode); + iatt->ia_nlink = gf_stat->ia_nlink; + iatt->ia_uid = gf_stat->ia_uid; + iatt->ia_gid = gf_stat->ia_gid; + iatt->ia_rdev = gf_stat->ia_rdev; + iatt->ia_size = gf_stat->ia_size; + 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; } static inline void -gf_stat_from_iatt (struct gf_iatt *gf_stat, struct iatt *iatt) +gf_stat_from_iatt(struct gf_iatt *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->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 ; - 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 ; + 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->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; + 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; } static inline int -gf_proto_cache_invalidation_from_upcall (xlator_t *this, - gfs3_cbk_cache_invalidation_req *gf_c_req, - struct gf_upcall *gf_up_data) +gf_proto_cache_invalidation_from_upcall( + xlator_t *this, gfs3_cbk_cache_invalidation_req *gf_c_req, + struct gf_upcall *gf_up_data) { - struct gf_upcall_cache_invalidation *gf_c_data = NULL; - int is_cache_inval = 0; - int ret = -1; - - GF_VALIDATE_OR_GOTO(this->name, gf_c_req, out); - GF_VALIDATE_OR_GOTO(this->name, gf_up_data, out); - - is_cache_inval = ((gf_up_data->event_type == - GF_UPCALL_CACHE_INVALIDATION) ? 1 : 0); - GF_VALIDATE_OR_GOTO(this->name, is_cache_inval, out); - - gf_c_data = (struct gf_upcall_cache_invalidation *)gf_up_data->data; - GF_VALIDATE_OR_GOTO(this->name, gf_c_data, out); - - gf_c_req->gfid = uuid_utoa (gf_up_data->gfid); - gf_c_req->event_type = gf_up_data->event_type; - gf_c_req->flags = gf_c_data->flags; - gf_c_req->expire_time_attr = gf_c_data->expire_time_attr; - gf_stat_from_iatt (&gf_c_req->stat, &gf_c_data->stat); - gf_stat_from_iatt (&gf_c_req->parent_stat, &gf_c_data->p_stat); - gf_stat_from_iatt (&gf_c_req->oldparent_stat, &gf_c_data->oldp_stat); - - ret = 0; - GF_PROTOCOL_DICT_SERIALIZE (this, gf_c_data->dict, &(gf_c_req->xdata).xdata_val, - (gf_c_req->xdata).xdata_len, ret, out); + struct gf_upcall_cache_invalidation *gf_c_data = NULL; + int is_cache_inval = 0; + int ret = -1; + + GF_VALIDATE_OR_GOTO(this->name, gf_c_req, out); + GF_VALIDATE_OR_GOTO(this->name, gf_up_data, out); + + is_cache_inval = ((gf_up_data->event_type == GF_UPCALL_CACHE_INVALIDATION) + ? 1 + : 0); + GF_VALIDATE_OR_GOTO(this->name, is_cache_inval, out); + + gf_c_data = (struct gf_upcall_cache_invalidation *)gf_up_data->data; + GF_VALIDATE_OR_GOTO(this->name, gf_c_data, out); + + gf_c_req->gfid = uuid_utoa(gf_up_data->gfid); + gf_c_req->event_type = gf_up_data->event_type; + gf_c_req->flags = gf_c_data->flags; + gf_c_req->expire_time_attr = gf_c_data->expire_time_attr; + gf_stat_from_iatt(&gf_c_req->stat, &gf_c_data->stat); + gf_stat_from_iatt(&gf_c_req->parent_stat, &gf_c_data->p_stat); + gf_stat_from_iatt(&gf_c_req->oldparent_stat, &gf_c_data->oldp_stat); + + ret = 0; + GF_PROTOCOL_DICT_SERIALIZE(this, gf_c_data->dict, + &(gf_c_req->xdata).xdata_val, + (gf_c_req->xdata).xdata_len, ret, out); out: - return ret; + return ret; } static inline int -gf_proto_cache_invalidation_to_upcall (xlator_t *this, - gfs3_cbk_cache_invalidation_req *gf_c_req, - struct gf_upcall *gf_up_data) +gf_proto_cache_invalidation_to_upcall(xlator_t *this, + gfs3_cbk_cache_invalidation_req *gf_c_req, + struct gf_upcall *gf_up_data) { - struct gf_upcall_cache_invalidation *gf_c_data = NULL; - int ret = -1; - - GF_VALIDATE_OR_GOTO(this->name, gf_c_req, out); - GF_VALIDATE_OR_GOTO(this->name, gf_up_data, out); - - gf_c_data = (struct gf_upcall_cache_invalidation *)gf_up_data->data; - GF_VALIDATE_OR_GOTO(this->name, gf_c_data, out); - - ret = gf_uuid_parse (gf_c_req->gfid, gf_up_data->gfid); - if (ret) { - gf_log (this->name, GF_LOG_WARNING, "gf_uuid_parse(%s) failed", - gf_c_req->gfid); - gf_up_data->event_type = GF_UPCALL_EVENT_NULL; - goto out; - } - - gf_up_data->event_type = gf_c_req->event_type; - - gf_c_data->flags = gf_c_req->flags; - gf_c_data->expire_time_attr = gf_c_req->expire_time_attr; - gf_stat_to_iatt (&gf_c_req->stat, &gf_c_data->stat); - gf_stat_to_iatt (&gf_c_req->parent_stat, &gf_c_data->p_stat); - gf_stat_to_iatt (&gf_c_req->oldparent_stat, &gf_c_data->oldp_stat); - - ret = 0; - GF_PROTOCOL_DICT_UNSERIALIZE (this, gf_c_data->dict, - (gf_c_req->xdata).xdata_val, - (gf_c_req->xdata).xdata_len, ret, - ret, out); - - /* If no dict was sent, create an empty dict, so that each xlator - * need not check if empty then create new dict. Will be unref'd by the - * caller */ - if (!gf_c_data->dict) - gf_c_data->dict = dict_new (); - out: - return ret; + struct gf_upcall_cache_invalidation *gf_c_data = NULL; + int ret = -1; + + GF_VALIDATE_OR_GOTO(this->name, gf_c_req, out); + GF_VALIDATE_OR_GOTO(this->name, gf_up_data, out); + + gf_c_data = (struct gf_upcall_cache_invalidation *)gf_up_data->data; + GF_VALIDATE_OR_GOTO(this->name, gf_c_data, out); + + ret = gf_uuid_parse(gf_c_req->gfid, gf_up_data->gfid); + if (ret) { + gf_log(this->name, GF_LOG_WARNING, "gf_uuid_parse(%s) failed", + gf_c_req->gfid); + gf_up_data->event_type = GF_UPCALL_EVENT_NULL; + goto out; + } + + gf_up_data->event_type = gf_c_req->event_type; + + gf_c_data->flags = gf_c_req->flags; + gf_c_data->expire_time_attr = gf_c_req->expire_time_attr; + gf_stat_to_iatt(&gf_c_req->stat, &gf_c_data->stat); + gf_stat_to_iatt(&gf_c_req->parent_stat, &gf_c_data->p_stat); + gf_stat_to_iatt(&gf_c_req->oldparent_stat, &gf_c_data->oldp_stat); + + ret = 0; + GF_PROTOCOL_DICT_UNSERIALIZE(this, gf_c_data->dict, + (gf_c_req->xdata).xdata_val, + (gf_c_req->xdata).xdata_len, ret, ret, out); + + /* If no dict was sent, create an empty dict, so that each xlator + * need not check if empty then create new dict. Will be unref'd by the + * caller */ + if (!gf_c_data->dict) + gf_c_data->dict = dict_new(); +out: + return ret; } static inline int -gf_proto_inodelk_contention_to_upcall (struct gfs4_inodelk_contention_req *lc, - struct gf_upcall *gf_up_data) +gf_proto_inodelk_contention_to_upcall(struct gfs4_inodelk_contention_req *lc, + struct gf_upcall *gf_up_data) { - struct gf_upcall_inodelk_contention *tmp = NULL; - xlator_t *this = NULL; - int ret = -1; - int op_errno = EINVAL; + struct gf_upcall_inodelk_contention *tmp = NULL; + xlator_t *this = NULL; + int ret = -1; + int op_errno = EINVAL; - this = THIS; + this = THIS; - GF_VALIDATE_OR_GOTO(this->name, lc, out); - GF_VALIDATE_OR_GOTO(this->name, gf_up_data, out); + GF_VALIDATE_OR_GOTO(this->name, lc, out); + GF_VALIDATE_OR_GOTO(this->name, gf_up_data, out); - tmp = (struct gf_upcall_inodelk_contention *)gf_up_data->data; + tmp = (struct gf_upcall_inodelk_contention *)gf_up_data->data; - gf_uuid_copy(gf_up_data->gfid, (unsigned char *)lc->gfid); + gf_uuid_copy(gf_up_data->gfid, (unsigned char *)lc->gfid); - gf_proto_flock_to_flock(&lc->flock, &tmp->flock); - tmp->pid = lc->pid; - tmp->domain = lc->domain; - if ((tmp->domain != NULL) && (*tmp->domain == 0)) { - tmp->domain = NULL; - } + gf_proto_flock_to_flock(&lc->flock, &tmp->flock); + tmp->pid = lc->pid; + tmp->domain = lc->domain; + if ((tmp->domain != NULL) && (*tmp->domain == 0)) { + tmp->domain = NULL; + } - GF_PROTOCOL_DICT_UNSERIALIZE (this, tmp->xdata, lc->xdata.xdata_val, - lc->xdata.xdata_len, ret, op_errno, out); + GF_PROTOCOL_DICT_UNSERIALIZE(this, tmp->xdata, lc->xdata.xdata_val, + lc->xdata.xdata_len, ret, op_errno, out); - ret = 0; + ret = 0; out: - if (ret < 0) { - ret = -op_errno; - } + if (ret < 0) { + ret = -op_errno; + } - return ret; + return ret; } static inline int -gf_proto_inodelk_contention_from_upcall (xlator_t *this, - struct gfs4_inodelk_contention_req *lc, - struct gf_upcall *gf_up_data) +gf_proto_inodelk_contention_from_upcall(xlator_t *this, + struct gfs4_inodelk_contention_req *lc, + struct gf_upcall *gf_up_data) { - struct gf_upcall_inodelk_contention *tmp = NULL; - int ret = -1; - int op_errno = EINVAL; + struct gf_upcall_inodelk_contention *tmp = NULL; + int ret = -1; + int op_errno = EINVAL; - GF_VALIDATE_OR_GOTO(this->name, lc, out); - GF_VALIDATE_OR_GOTO(this->name, gf_up_data, out); + GF_VALIDATE_OR_GOTO(this->name, lc, out); + GF_VALIDATE_OR_GOTO(this->name, gf_up_data, out); - tmp = (struct gf_upcall_inodelk_contention *)gf_up_data->data; + tmp = (struct gf_upcall_inodelk_contention *)gf_up_data->data; - gf_uuid_copy((unsigned char *)lc->gfid, gf_up_data->gfid); + gf_uuid_copy((unsigned char *)lc->gfid, gf_up_data->gfid); - gf_proto_flock_from_flock(&lc->flock, &tmp->flock); - lc->pid = tmp->pid; - lc->domain = (char *)tmp->domain; - if (lc->domain == NULL) { - lc->domain = ""; - } + gf_proto_flock_from_flock(&lc->flock, &tmp->flock); + lc->pid = tmp->pid; + lc->domain = (char *)tmp->domain; + if (lc->domain == NULL) { + lc->domain = ""; + } - GF_PROTOCOL_DICT_SERIALIZE (this, tmp->xdata, &lc->xdata.xdata_val, - lc->xdata.xdata_len, op_errno, out); + GF_PROTOCOL_DICT_SERIALIZE(this, tmp->xdata, &lc->xdata.xdata_val, + lc->xdata.xdata_len, op_errno, out); - ret = 0; + ret = 0; out: - if (ret < 0) { - ret = -op_errno; - } + if (ret < 0) { + ret = -op_errno; + } - return ret; + return ret; } static inline int -gf_proto_entrylk_contention_to_upcall (struct gfs4_entrylk_contention_req *lc, - struct gf_upcall *gf_up_data) +gf_proto_entrylk_contention_to_upcall(struct gfs4_entrylk_contention_req *lc, + struct gf_upcall *gf_up_data) { - struct gf_upcall_entrylk_contention *tmp = NULL; - xlator_t *this = NULL; - int ret = -1; - int op_errno = EINVAL; + struct gf_upcall_entrylk_contention *tmp = NULL; + xlator_t *this = NULL; + int ret = -1; + int op_errno = EINVAL; - this = THIS; + this = THIS; - GF_VALIDATE_OR_GOTO(this->name, lc, out); - GF_VALIDATE_OR_GOTO(this->name, gf_up_data, out); + GF_VALIDATE_OR_GOTO(this->name, lc, out); + GF_VALIDATE_OR_GOTO(this->name, gf_up_data, out); - tmp = (struct gf_upcall_entrylk_contention *)gf_up_data->data; + tmp = (struct gf_upcall_entrylk_contention *)gf_up_data->data; - gf_uuid_copy(gf_up_data->gfid, (unsigned char *)lc->gfid); + gf_uuid_copy(gf_up_data->gfid, (unsigned char *)lc->gfid); - tmp->type = lc->type; - tmp->name = lc->name; - if ((tmp->name != NULL) && (*tmp->name == 0)) { - tmp->name = NULL; - } - tmp->pid = lc->pid; - tmp->domain = lc->domain; - if ((tmp->domain != NULL) && (*tmp->domain == 0)) { - tmp->domain = NULL; - } + tmp->type = lc->type; + tmp->name = lc->name; + if ((tmp->name != NULL) && (*tmp->name == 0)) { + tmp->name = NULL; + } + tmp->pid = lc->pid; + tmp->domain = lc->domain; + if ((tmp->domain != NULL) && (*tmp->domain == 0)) { + tmp->domain = NULL; + } - GF_PROTOCOL_DICT_UNSERIALIZE (this, tmp->xdata, lc->xdata.xdata_val, - lc->xdata.xdata_len, ret, op_errno, out); + GF_PROTOCOL_DICT_UNSERIALIZE(this, tmp->xdata, lc->xdata.xdata_val, + lc->xdata.xdata_len, ret, op_errno, out); - ret = 0; + ret = 0; out: - if (ret < 0) { - ret = -op_errno; - } + if (ret < 0) { + ret = -op_errno; + } - return ret; + return ret; } static inline int -gf_proto_entrylk_contention_from_upcall (xlator_t *this, - struct gfs4_entrylk_contention_req *lc, - struct gf_upcall *gf_up_data) +gf_proto_entrylk_contention_from_upcall(xlator_t *this, + struct gfs4_entrylk_contention_req *lc, + struct gf_upcall *gf_up_data) { - struct gf_upcall_entrylk_contention *tmp = NULL; - int ret = -1; - int op_errno = EINVAL; + struct gf_upcall_entrylk_contention *tmp = NULL; + int ret = -1; + int op_errno = EINVAL; - GF_VALIDATE_OR_GOTO(this->name, lc, out); - GF_VALIDATE_OR_GOTO(this->name, gf_up_data, out); + GF_VALIDATE_OR_GOTO(this->name, lc, out); + GF_VALIDATE_OR_GOTO(this->name, gf_up_data, out); - tmp = (struct gf_upcall_entrylk_contention *)gf_up_data->data; + tmp = (struct gf_upcall_entrylk_contention *)gf_up_data->data; - gf_uuid_copy((unsigned char *)lc->gfid, gf_up_data->gfid); + gf_uuid_copy((unsigned char *)lc->gfid, gf_up_data->gfid); - lc->type = tmp->type; - lc->name = (char *)tmp->name; - if (lc->name == NULL) { - lc->name = ""; - } - lc->pid = tmp->pid; - lc->domain = (char *)tmp->domain; - if (lc->domain == NULL) { - lc->domain = ""; - } + lc->type = tmp->type; + lc->name = (char *)tmp->name; + if (lc->name == NULL) { + lc->name = ""; + } + lc->pid = tmp->pid; + lc->domain = (char *)tmp->domain; + if (lc->domain == NULL) { + lc->domain = ""; + } - GF_PROTOCOL_DICT_SERIALIZE (this, tmp->xdata, &lc->xdata.xdata_val, - lc->xdata.xdata_len, op_errno, out); + GF_PROTOCOL_DICT_SERIALIZE(this, tmp->xdata, &lc->xdata.xdata_val, + lc->xdata.xdata_len, op_errno, out); - ret = 0; + ret = 0; out: - if (ret < 0) { - ret = -op_errno; - } + if (ret < 0) { + ret = -op_errno; + } - return ret; + return ret; } static inline void -gfx_stat_to_iattx (struct gfx_iattx *gf_stat, struct iatt *iatt) +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); + 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) +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); + 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) +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; - } - - /* Do the whole operation in locked region */ - LOCK (&this->lock); - - 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, wherever 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' would not be sent on wire in the 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; + 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; + } + + /* Do the whole operation in locked region */ + LOCK(&this->lock); + + 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, wherever 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' would not be sent on wire in the 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; + 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); + /* 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; + dict->xdr_size = (size > 12) ? (size - 12) : 0; - ret = 0; + ret = 0; out: - /* this can be null here, so unlock only if its not null */ - if (this) - UNLOCK (&this->lock); + /* this can be null here, so unlock only if its not null */ + if (this) + UNLOCK(&this->lock); - return ret; + return ret; } static inline int -xdr_to_dict (gfx_dict *dict, dict_t **to) +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_MALLOC (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); - value[xpair->value.gfx_value_u.val_string.val_string_len] = '\0'; - 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_MALLOC (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_MALLOC (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); - value[xpair->value.gfx_value_u.other.other_len] = '\0'; - 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; + 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_MALLOC( + xpair->value.gfx_value_u.val_string.val_string_len + 1, + gf_common_mt_char); + if (!value) { + errno = ENOMEM; + goto out; } - if (ret) { - gf_msg_debug (THIS->name, ENOMEM, - "failed to set the key (%s) into dict", - key); + memcpy(value, + xpair->value.gfx_value_u.val_string.val_string_val, + xpair->value.gfx_value_u.val_string.val_string_len); + value[xpair->value.gfx_value_u.val_string.val_string_len] = + '\0'; + 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_MALLOC(sizeof(uuid_t), gf_common_mt_uuid_t); + if (!uuid) { + errno = ENOMEM; + goto out; } - free (xpair->key.key_val); + 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_MALLOC(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); + value[xpair->value.gfx_value_u.other.other_len] = '\0'; + 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; + free(dict->pairs.pairs_val); + ret = 0; - /* If everything is fine, assign the dictionary to target */ - *to = this; - this = NULL; + /* If everything is fine, assign the dictionary to target */ + *to = this; + this = NULL; out: - if (this) - dict_unref (this); + if (this) + dict_unref(this); - return ret; + return ret; } #endif /* !_GLUSTERFS3_H */ |