diff options
Diffstat (limited to 'xlators/performance/io-threads/src/io-threads.c')
| -rw-r--r-- | xlators/performance/io-threads/src/io-threads.c | 1020 |
1 files changed, 701 insertions, 319 deletions
diff --git a/xlators/performance/io-threads/src/io-threads.c b/xlators/performance/io-threads/src/io-threads.c index d6d0ada23..bbcf4ed26 100644 --- a/xlators/performance/io-threads/src/io-threads.c +++ b/xlators/performance/io-threads/src/io-threads.c @@ -1,20 +1,11 @@ /* - Copyright (c) 2006-2011 Gluster, Inc. <http://www.gluster.com> + Copyright (c) 2008-2012 Red Hat, Inc. <http://www.redhat.com> This file is part of GlusterFS. - GlusterFS is free software; you can redistribute it and/or modify - it under the terms of the GNU General Public License as published - by the Free Software Foundation; either version 3 of the License, - or (at your option) any later version. - - GlusterFS is distributed in the hope that it will be useful, but - WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - General Public License for more details. - - You should have received a copy of the GNU General Public License - along with this program. If not, see - <http://www.gnu.org/licenses/>. + This file is licensed to you under your choice of the GNU Lesser + General Public License, version 3 or any later version (LGPLv3 or + later), or the GNU General Public License, version 2 (GPLv2), in all + cases as published by the Free Software Foundation. */ #ifndef _CONFIG_H @@ -39,16 +30,69 @@ int __iot_workers_scale (iot_conf_t *conf); struct volume_options options[]; call_stub_t * -__iot_dequeue (iot_conf_t *conf, int *pri) +__iot_dequeue (iot_conf_t *conf, int *pri, struct timespec *sleep) { call_stub_t *stub = NULL; int i = 0; + struct timeval curtv = {0,}, difftv = {0,}; *pri = -1; + sleep->tv_sec = 0; + sleep->tv_nsec = 0; for (i = 0; i < IOT_PRI_MAX; i++) { if (list_empty (&conf->reqs[i]) || (conf->ac_iot_count[i] >= conf->ac_iot_limit[i])) continue; + + if (i == IOT_PRI_LEAST) { + pthread_mutex_lock(&conf->throttle.lock); + if (!conf->throttle.sample_time.tv_sec) { + /* initialize */ + gettimeofday(&conf->throttle.sample_time, NULL); + } else { + /* + * Maintain a running count of least priority + * operations that are handled over a particular + * time interval. The count is provided via + * state dump and is used as a measure against + * least priority op throttling. + */ + gettimeofday(&curtv, NULL); + timersub(&curtv, &conf->throttle.sample_time, + &difftv); + if (difftv.tv_sec >= IOT_LEAST_THROTTLE_DELAY) { + conf->throttle.cached_rate = + conf->throttle.sample_cnt; + conf->throttle.sample_cnt = 0; + conf->throttle.sample_time = curtv; + } + + /* + * If we're over the configured rate limit, + * provide an absolute time to the caller that + * represents the soonest we're allowed to + * return another least priority request. + */ + if (conf->throttle.rate_limit && + conf->throttle.sample_cnt >= + conf->throttle.rate_limit) { + struct timeval delay; + delay.tv_sec = IOT_LEAST_THROTTLE_DELAY; + delay.tv_usec = 0; + + timeradd(&conf->throttle.sample_time, + &delay, &curtv); + TIMEVAL_TO_TIMESPEC(&curtv, sleep); + + pthread_mutex_unlock( + &conf->throttle.lock); + break; + } + } + conf->throttle.sample_cnt++; + pthread_mutex_unlock(&conf->throttle.lock); + } + stub = list_entry (conf->reqs[i].next, call_stub_t, list); conf->ac_iot_count[i]++; *pri = i; @@ -59,6 +103,7 @@ __iot_dequeue (iot_conf_t *conf, int *pri) return NULL; conf->queue_size--; + conf->queue_sizes[*pri]--; list_del_init (&stub->list); return stub; @@ -74,6 +119,7 @@ __iot_enqueue (iot_conf_t *conf, call_stub_t *stub, int pri) list_add_tail (&stub->list, &conf->reqs[pri]); conf->queue_size++; + conf->queue_sizes[pri]++; return; } @@ -90,6 +136,7 @@ iot_worker (void *data) int pri = -1; char timeout = 0; char bye = 0; + struct timespec sleep = {0,}; conf = data; this = conf->this; @@ -130,7 +177,13 @@ iot_worker (void *data) } } - stub = __iot_dequeue (conf, &pri); + stub = __iot_dequeue (conf, &pri, &sleep); + if (!stub && (sleep.tv_sec || sleep.tv_nsec)) { + pthread_cond_timedwait(&conf->cond, + &conf->mutex, &sleep); + pthread_mutex_unlock(&conf->mutex); + continue; + } } pthread_mutex_unlock (&conf->mutex); @@ -199,8 +252,9 @@ iot_schedule (call_frame_t *frame, xlator_t *this, call_stub_t *stub) { int ret = -1; iot_pri_t pri = IOT_PRI_MAX - 1; + iot_conf_t *conf = this->private; - if (frame->root->pid < 0) { + if ((frame->root->pid < GF_CLIENT_PID_MAX) && conf->least_priority) { pri = IOT_PRI_LEAST; goto out; } @@ -240,6 +294,7 @@ iot_schedule (call_frame_t *frame, xlator_t *this, call_stub_t *stub) case GF_FOP_FGETXATTR: case GF_FOP_FSETXATTR: case GF_FOP_REMOVEXATTR: + case GF_FOP_FREMOVEXATTR: pri = IOT_PRI_NORMAL; break; @@ -251,11 +306,11 @@ iot_schedule (call_frame_t *frame, xlator_t *this, call_stub_t *stub) case GF_FOP_FSYNCDIR: case GF_FOP_XATTROP: case GF_FOP_FXATTROP: - pri = IOT_PRI_LO; - break; - case GF_FOP_RCHECKSUM: - pri = IOT_PRI_LEAST; + case GF_FOP_FALLOCATE: + case GF_FOP_DISCARD: + case GF_FOP_ZEROFILL: + pri = IOT_PRI_LO; break; case GF_FOP_NULL: @@ -269,19 +324,19 @@ iot_schedule (call_frame_t *frame, xlator_t *this, call_stub_t *stub) break; } out: - ret = do_iot_schedule (this->private, stub, pri); gf_log (this->name, GF_LOG_DEBUG, "%s scheduled as %s fop", gf_fop_list[stub->fop], iot_get_pri_meaning (pri)); + ret = do_iot_schedule (this->private, stub, pri); return ret; } int iot_lookup_cbk (call_frame_t *frame, void * cookie, xlator_t *this, int32_t op_ret, int32_t op_errno, - inode_t *inode, struct iatt *buf, dict_t *xattr, + inode_t *inode, struct iatt *buf, dict_t *xdata, struct iatt *postparent) { - STACK_UNWIND_STRICT (lookup, frame, op_ret, op_errno, inode, buf, xattr, + STACK_UNWIND_STRICT (lookup, frame, op_ret, op_errno, inode, buf, xdata, postparent); return 0; } @@ -289,23 +344,23 @@ iot_lookup_cbk (call_frame_t *frame, void * cookie, xlator_t *this, int iot_lookup_wrapper (call_frame_t *frame, xlator_t *this, loc_t *loc, - dict_t *xattr_req) + dict_t *xdata) { STACK_WIND (frame, iot_lookup_cbk, FIRST_CHILD (this), FIRST_CHILD (this)->fops->lookup, - loc, xattr_req); + loc, xdata); return 0; } int -iot_lookup (call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *xattr_req) +iot_lookup (call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *xdata) { call_stub_t *stub = NULL; int ret = -1; - stub = fop_lookup_stub (frame, iot_lookup_wrapper, loc, xattr_req); + stub = fop_lookup_stub (frame, iot_lookup_wrapper, loc, xdata); if (!stub) { gf_log (this->name, GF_LOG_ERROR, "cannot create lookup stub (out of memory)"); @@ -331,33 +386,35 @@ out: int iot_setattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this, int32_t op_ret, int32_t op_errno, - struct iatt *preop, struct iatt *postop) + struct iatt *preop, struct iatt *postop, dict_t *xdata) { - STACK_UNWIND_STRICT (setattr, frame, op_ret, op_errno, preop, postop); + STACK_UNWIND_STRICT (setattr, frame, op_ret, op_errno, preop, postop, + xdata); return 0; } int iot_setattr_wrapper (call_frame_t *frame, xlator_t *this, loc_t *loc, - struct iatt *stbuf, int32_t valid) + struct iatt *stbuf, int32_t valid, dict_t *xdata) { STACK_WIND (frame, iot_setattr_cbk, FIRST_CHILD (this), FIRST_CHILD (this)->fops->setattr, - loc, stbuf, valid); + loc, stbuf, valid, xdata); return 0; } int iot_setattr (call_frame_t *frame, xlator_t *this, loc_t *loc, - struct iatt *stbuf, int32_t valid) + struct iatt *stbuf, int32_t valid, dict_t *xdata) { call_stub_t *stub = NULL; int ret = -1; - stub = fop_setattr_stub (frame, iot_setattr_wrapper, loc, stbuf, valid); + stub = fop_setattr_stub (frame, iot_setattr_wrapper, loc, stbuf, valid, + xdata); if (!stub) { gf_log (this->name, GF_LOG_ERROR, "Cannot create setattr stub" "(Out of memory)"); @@ -373,7 +430,7 @@ out: call_stub_destroy (stub); } - STACK_UNWIND_STRICT (setattr, frame, -1, -ret, NULL, NULL); + STACK_UNWIND_STRICT (setattr, frame, -1, -ret, NULL, NULL, NULL); } return 0; @@ -383,32 +440,34 @@ out: int iot_fsetattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this, int32_t op_ret, int32_t op_errno, - struct iatt *preop, struct iatt *postop) + struct iatt *preop, struct iatt *postop, dict_t *xdata) { - STACK_UNWIND_STRICT (fsetattr, frame, op_ret, op_errno, preop, postop); + STACK_UNWIND_STRICT (fsetattr, frame, op_ret, op_errno, preop, postop, + xdata); return 0; } int iot_fsetattr_wrapper (call_frame_t *frame, xlator_t *this, - fd_t *fd, struct iatt *stbuf, int32_t valid) + fd_t *fd, struct iatt *stbuf, int32_t valid, dict_t *xdata) { STACK_WIND (frame, iot_fsetattr_cbk, FIRST_CHILD (this), - FIRST_CHILD (this)->fops->fsetattr, fd, stbuf, valid); + FIRST_CHILD (this)->fops->fsetattr, fd, stbuf, valid, + xdata); return 0; } int iot_fsetattr (call_frame_t *frame, xlator_t *this, fd_t *fd, - struct iatt *stbuf, int32_t valid) + struct iatt *stbuf, int32_t valid, dict_t *xdata) { call_stub_t *stub = NULL; int ret = -1; stub = fop_fsetattr_stub (frame, iot_fsetattr_wrapper, fd, stbuf, - valid); + valid, xdata); if (!stub) { gf_log (this->name, GF_LOG_ERROR, "cannot create fsetattr stub" "(out of memory)"); @@ -420,7 +479,8 @@ iot_fsetattr (call_frame_t *frame, xlator_t *this, fd_t *fd, out: if (ret < 0) { - STACK_UNWIND_STRICT (fsetattr, frame, -1, -ret, NULL, NULL); + STACK_UNWIND_STRICT (fsetattr, frame, -1, -ret, NULL, NULL, + NULL); if (stub != NULL) { call_stub_destroy (stub); } @@ -431,30 +491,31 @@ out: int iot_access_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno) + int32_t op_ret, int32_t op_errno, dict_t *xdata) { - STACK_UNWIND_STRICT (access, frame, op_ret, op_errno); + STACK_UNWIND_STRICT (access, frame, op_ret, op_errno, xdata); return 0; } int iot_access_wrapper (call_frame_t *frame, xlator_t *this, loc_t *loc, - int32_t mask) + int32_t mask, dict_t *xdata) { STACK_WIND (frame, iot_access_cbk, FIRST_CHILD (this), - FIRST_CHILD (this)->fops->access, loc, mask); + FIRST_CHILD (this)->fops->access, loc, mask, xdata); return 0; } int -iot_access (call_frame_t *frame, xlator_t *this, loc_t *loc, int32_t mask) +iot_access (call_frame_t *frame, xlator_t *this, loc_t *loc, int32_t mask, + dict_t *xdata) { call_stub_t *stub = NULL; int ret = -1; - stub = fop_access_stub (frame, iot_access_wrapper, loc, mask); + stub = fop_access_stub (frame, iot_access_wrapper, loc, mask, xdata); if (!stub) { gf_log (this->name, GF_LOG_ERROR, "cannot create access stub" "(out of memory)"); @@ -465,7 +526,7 @@ iot_access (call_frame_t *frame, xlator_t *this, loc_t *loc, int32_t mask) ret = iot_schedule (frame, this, stub); out: if (ret < 0) { - STACK_UNWIND_STRICT (access, frame, -1, -ret); + STACK_UNWIND_STRICT (access, frame, -1, -ret, NULL); if (stub != NULL) { call_stub_destroy (stub); @@ -478,32 +539,33 @@ out: int iot_readlink_cbk (call_frame_t *frame, void *cookie, xlator_t *this, int32_t op_ret, int32_t op_errno, const char *path, - struct iatt *stbuf) + struct iatt *stbuf, dict_t *xdata) { - STACK_UNWIND_STRICT (readlink, frame, op_ret, op_errno, path, stbuf); + STACK_UNWIND_STRICT (readlink, frame, op_ret, op_errno, path, stbuf, + xdata); return 0; } int iot_readlink_wrapper (call_frame_t *frame, xlator_t *this, loc_t *loc, - size_t size) + size_t size, dict_t *xdata) { STACK_WIND (frame, iot_readlink_cbk, FIRST_CHILD (this), FIRST_CHILD (this)->fops->readlink, - loc, size); + loc, size, xdata); return 0; } int -iot_readlink (call_frame_t *frame, xlator_t *this, loc_t *loc, size_t size) +iot_readlink (call_frame_t *frame, xlator_t *this, loc_t *loc, size_t size, dict_t *xdata) { call_stub_t *stub = NULL; int ret = -1; - stub = fop_readlink_stub (frame, iot_readlink_wrapper, loc, size); + stub = fop_readlink_stub (frame, iot_readlink_wrapper, loc, size, xdata); if (!stub) { gf_log (this->name, GF_LOG_ERROR, "cannot create readlink stub" "(out of memory)"); @@ -515,7 +577,7 @@ iot_readlink (call_frame_t *frame, xlator_t *this, loc_t *loc, size_t size) out: if (ret < 0) { - STACK_UNWIND_STRICT (readlink, frame, -1, -ret, NULL, NULL); + STACK_UNWIND_STRICT (readlink, frame, -1, -ret, NULL, NULL, NULL); if (stub != NULL) { call_stub_destroy (stub); @@ -530,33 +592,34 @@ int iot_mknod_cbk (call_frame_t *frame, void *cookie, xlator_t *this, int32_t op_ret, int32_t op_errno, inode_t *inode, struct iatt *buf, struct iatt *preparent, - struct iatt *postparent) + struct iatt *postparent, dict_t *xdata) { STACK_UNWIND_STRICT (mknod, frame, op_ret, op_errno, inode, buf, - preparent, postparent); + preparent, postparent, xdata); return 0; } int iot_mknod_wrapper (call_frame_t *frame, xlator_t *this, loc_t *loc, mode_t mode, - dev_t rdev, dict_t *params) + dev_t rdev, mode_t umask, dict_t *xdata) { STACK_WIND (frame, iot_mknod_cbk, FIRST_CHILD (this), - FIRST_CHILD (this)->fops->mknod, loc, mode, rdev, params); + FIRST_CHILD (this)->fops->mknod, loc, mode, rdev, umask, + xdata); return 0; } int iot_mknod (call_frame_t *frame, xlator_t *this, loc_t *loc, mode_t mode, - dev_t rdev, dict_t *params) + dev_t rdev, mode_t umask, dict_t *xdata) { call_stub_t *stub = NULL; int ret = -1; stub = fop_mknod_stub (frame, iot_mknod_wrapper, loc, mode, rdev, - params); + umask, xdata); if (!stub) { gf_log (this->name, GF_LOG_ERROR, "cannot create mknod stub" "(out of memory)"); @@ -569,7 +632,7 @@ iot_mknod (call_frame_t *frame, xlator_t *this, loc_t *loc, mode_t mode, out: if (ret < 0) { STACK_UNWIND_STRICT (mknod, frame, -1, -ret, NULL, NULL, NULL, - NULL); + NULL, NULL); if (stub != NULL) { call_stub_destroy (stub); @@ -583,32 +646,33 @@ int iot_mkdir_cbk (call_frame_t *frame, void * cookie, xlator_t *this, int32_t op_ret, int32_t op_errno, inode_t *inode, struct iatt *buf, struct iatt *preparent, - struct iatt *postparent) + struct iatt *postparent, dict_t *xdata) { STACK_UNWIND_STRICT (mkdir, frame, op_ret, op_errno, inode, buf, - preparent, postparent); + preparent, postparent, xdata); return 0; } int iot_mkdir_wrapper (call_frame_t *frame, xlator_t *this, loc_t *loc, mode_t mode, - dict_t *params) + mode_t umask, dict_t *xdata) { STACK_WIND (frame, iot_mkdir_cbk, FIRST_CHILD (this), - FIRST_CHILD (this)->fops->mkdir, loc, mode, params); + FIRST_CHILD (this)->fops->mkdir, loc, mode, umask, xdata); return 0; } int iot_mkdir (call_frame_t *frame, xlator_t *this, loc_t *loc, mode_t mode, - dict_t *params) + mode_t umask, dict_t *xdata) { call_stub_t *stub = NULL; int ret = -1; - stub = fop_mkdir_stub (frame, iot_mkdir_wrapper, loc, mode, params); + stub = fop_mkdir_stub (frame, iot_mkdir_wrapper, loc, mode, umask, + xdata); if (!stub) { gf_log (this->name, GF_LOG_ERROR, "cannot create mkdir stub" "(out of memory)"); @@ -621,7 +685,7 @@ iot_mkdir (call_frame_t *frame, xlator_t *this, loc_t *loc, mode_t mode, out: if (ret < 0) { STACK_UNWIND_STRICT (mkdir, frame, -1, -ret, NULL, NULL, NULL, - NULL); + NULL, NULL); if (stub != NULL) { call_stub_destroy (stub); @@ -634,30 +698,30 @@ out: int iot_rmdir_cbk (call_frame_t *frame, void *cookie, xlator_t *this, int32_t op_ret, int32_t op_errno, struct iatt *preparent, - struct iatt *postparent) + struct iatt *postparent, dict_t *xdata) { STACK_UNWIND_STRICT (rmdir, frame, op_ret, op_errno, preparent, - postparent); + postparent, xdata); return 0; } int -iot_rmdir_wrapper (call_frame_t *frame, xlator_t *this, loc_t *loc, int flags) +iot_rmdir_wrapper (call_frame_t *frame, xlator_t *this, loc_t *loc, int flags, dict_t *xdata) { STACK_WIND (frame, iot_rmdir_cbk, FIRST_CHILD (this), - FIRST_CHILD (this)->fops->rmdir, loc, flags); + FIRST_CHILD (this)->fops->rmdir, loc, flags, xdata); return 0; } int -iot_rmdir (call_frame_t *frame, xlator_t *this, loc_t *loc, int flags) +iot_rmdir (call_frame_t *frame, xlator_t *this, loc_t *loc, int flags, dict_t *xdata) { call_stub_t *stub = NULL; int ret = -1; - stub = fop_rmdir_stub (frame, iot_rmdir_wrapper, loc, flags); + stub = fop_rmdir_stub (frame, iot_rmdir_wrapper, loc, flags, xdata); if (!stub) { gf_log (this->name, GF_LOG_ERROR, "cannot create rmdir stub" "(out of memory)"); @@ -668,7 +732,7 @@ iot_rmdir (call_frame_t *frame, xlator_t *this, loc_t *loc, int flags) ret = iot_schedule (frame, this, stub); out: if (ret < 0) { - STACK_UNWIND_STRICT (rmdir, frame, -1, -ret, NULL, NULL); + STACK_UNWIND_STRICT (rmdir, frame, -1, -ret, NULL, NULL, NULL); if (stub != NULL) { call_stub_destroy (stub); @@ -682,33 +746,34 @@ int iot_symlink_cbk (call_frame_t *frame, void * cookie, xlator_t *this, int32_t op_ret, int32_t op_errno, inode_t *inode, struct iatt *buf, struct iatt *preparent, - struct iatt *postparent) + struct iatt *postparent, dict_t *xdata) { STACK_UNWIND_STRICT (symlink, frame, op_ret, op_errno, inode, buf, - preparent, postparent); + preparent, postparent, xdata); return 0; } int iot_symlink_wrapper (call_frame_t *frame, xlator_t *this, const char *linkname, - loc_t *loc, dict_t *params) + loc_t *loc, mode_t umask, dict_t *xdata) { STACK_WIND (frame, iot_symlink_cbk, FIRST_CHILD (this), - FIRST_CHILD (this)->fops->symlink, linkname, loc, params); + FIRST_CHILD (this)->fops->symlink, linkname, loc, umask, + xdata); return 0; } int iot_symlink (call_frame_t *frame, xlator_t *this, const char *linkname, - loc_t *loc, dict_t *params) + loc_t *loc, mode_t umask, dict_t *xdata) { call_stub_t *stub = NULL; int ret = -1; stub = fop_symlink_stub (frame, iot_symlink_wrapper, linkname, loc, - params); + umask, xdata); if (!stub) { gf_log (this->name, GF_LOG_ERROR, "cannot create symlink stub" "(out of memory)"); @@ -721,7 +786,7 @@ iot_symlink (call_frame_t *frame, xlator_t *this, const char *linkname, out: if (ret < 0) { STACK_UNWIND_STRICT (symlink, frame, -1, -ret, NULL, NULL, NULL, - NULL); + NULL, NULL); if (stub != NULL) { call_stub_destroy (stub); } @@ -735,31 +800,33 @@ int iot_rename_cbk (call_frame_t *frame, void * cookie, xlator_t *this, int32_t op_ret, int32_t op_errno, struct iatt *buf, struct iatt *preoldparent, struct iatt *postoldparent, - struct iatt *prenewparent, struct iatt *postnewparent) + struct iatt *prenewparent, struct iatt *postnewparent, + dict_t *xdata) { STACK_UNWIND_STRICT (rename, frame, op_ret, op_errno, buf, preoldparent, - postoldparent, prenewparent, postnewparent); + postoldparent, prenewparent, postnewparent, xdata); return 0; } int iot_rename_wrapper (call_frame_t *frame, xlator_t *this, loc_t *oldloc, - loc_t *newloc) + loc_t *newloc, dict_t *xdata) { STACK_WIND (frame, iot_rename_cbk, FIRST_CHILD (this), - FIRST_CHILD (this)->fops->rename, oldloc, newloc); + FIRST_CHILD (this)->fops->rename, oldloc, newloc, xdata); return 0; } int -iot_rename (call_frame_t *frame, xlator_t *this, loc_t *oldloc, loc_t *newloc) +iot_rename (call_frame_t *frame, xlator_t *this, loc_t *oldloc, loc_t *newloc, + dict_t *xdata) { call_stub_t *stub = NULL; int ret = -1; - stub = fop_rename_stub (frame, iot_rename_wrapper, oldloc, newloc); + stub = fop_rename_stub (frame, iot_rename_wrapper, oldloc, newloc, xdata); if (!stub) { gf_log (this->name, GF_LOG_DEBUG, "cannot create rename stub" "(out of memory)"); @@ -772,7 +839,7 @@ iot_rename (call_frame_t *frame, xlator_t *this, loc_t *oldloc, loc_t *newloc) out: if (ret < 0) { STACK_UNWIND_STRICT (rename, frame, -1, -ret, NULL, NULL, NULL, - NULL, NULL); + NULL, NULL, NULL); if (stub != NULL) { call_stub_destroy (stub); } @@ -784,31 +851,33 @@ out: int iot_open_cbk (call_frame_t *frame, void *cookie, xlator_t *this, int32_t op_ret, - int32_t op_errno, fd_t *fd) + int32_t op_errno, fd_t *fd, dict_t *xdata) { - STACK_UNWIND_STRICT (open, frame, op_ret, op_errno, fd); + STACK_UNWIND_STRICT (open, frame, op_ret, op_errno, fd, xdata); return 0; } int iot_open_wrapper (call_frame_t * frame, xlator_t * this, loc_t *loc, - int32_t flags, fd_t * fd, int32_t wbflags) + int32_t flags, fd_t * fd, dict_t *xdata) { STACK_WIND (frame, iot_open_cbk, FIRST_CHILD (this), - FIRST_CHILD (this)->fops->open, loc, flags, fd, wbflags); + FIRST_CHILD (this)->fops->open, loc, flags, fd, + xdata); return 0; } int iot_open (call_frame_t *frame, xlator_t *this, loc_t *loc, int32_t flags, - fd_t *fd, int32_t wbflags) + fd_t *fd, dict_t *xdata) { call_stub_t *stub = NULL; int ret = -1; - stub = fop_open_stub (frame, iot_open_wrapper, loc, flags, fd, wbflags); + stub = fop_open_stub (frame, iot_open_wrapper, loc, flags, fd, + xdata); if (!stub) { gf_log (this->name, GF_LOG_ERROR, "cannot create open call stub" @@ -821,7 +890,7 @@ iot_open (call_frame_t *frame, xlator_t *this, loc_t *loc, int32_t flags, out: if (ret < 0) { - STACK_UNWIND_STRICT (open, frame, -1, -ret, NULL); + STACK_UNWIND_STRICT (open, frame, -1, -ret, NULL, NULL); if (stub != NULL) { call_stub_destroy (stub); @@ -836,35 +905,36 @@ int iot_create_cbk (call_frame_t *frame, void *cookie, xlator_t *this, int32_t op_ret, int32_t op_errno, fd_t *fd, inode_t *inode, struct iatt *stbuf, struct iatt *preparent, - struct iatt *postparent) + struct iatt *postparent, dict_t *xdata) { STACK_UNWIND_STRICT (create, frame, op_ret, op_errno, fd, inode, stbuf, - preparent, postparent); + preparent, postparent, xdata); return 0; } int iot_create_wrapper (call_frame_t *frame, xlator_t *this, loc_t *loc, - int32_t flags, mode_t mode, fd_t *fd, dict_t *params) + int32_t flags, mode_t mode, mode_t umask, fd_t *fd, + dict_t *xdata) { STACK_WIND (frame, iot_create_cbk, FIRST_CHILD(this), FIRST_CHILD(this)->fops->create, - loc, flags, mode, fd, params); + loc, flags, mode, umask, fd, xdata); return 0; } int iot_create (call_frame_t *frame, xlator_t *this, loc_t *loc, int32_t flags, - mode_t mode, fd_t *fd, dict_t *params) + mode_t mode, mode_t umask, fd_t *fd, dict_t *xdata) { call_stub_t *stub = NULL; int ret = -1; stub = fop_create_stub (frame, iot_create_wrapper, loc, flags, mode, - fd, params); + umask, fd, xdata); if (!stub) { gf_log (this->name, GF_LOG_ERROR, "cannot create \"create\" call stub" @@ -878,7 +948,7 @@ iot_create (call_frame_t *frame, xlator_t *this, loc_t *loc, int32_t flags, out: if (ret < 0) { STACK_UNWIND_STRICT (create, frame, -1, -ret, NULL, NULL, NULL, - NULL, NULL); + NULL, NULL, NULL); if (stub != NULL) { call_stub_destroy (stub); @@ -892,10 +962,11 @@ out: int iot_readv_cbk (call_frame_t *frame, void *cookie, xlator_t *this, int32_t op_ret, int32_t op_errno, struct iovec *vector, - int32_t count, struct iatt *stbuf, struct iobref *iobref) + int32_t count, struct iatt *stbuf, struct iobref *iobref, + dict_t *xdata) { STACK_UNWIND_STRICT (readv, frame, op_ret, op_errno, vector, count, - stbuf, iobref); + stbuf, iobref, xdata); return 0; } @@ -903,24 +974,25 @@ iot_readv_cbk (call_frame_t *frame, void *cookie, xlator_t *this, int iot_readv_wrapper (call_frame_t *frame, xlator_t *this, fd_t *fd, size_t size, - off_t offset) + off_t offset, uint32_t flags, dict_t *xdata) { STACK_WIND (frame, iot_readv_cbk, FIRST_CHILD(this), FIRST_CHILD(this)->fops->readv, - fd, size, offset); + fd, size, offset, flags, xdata); return 0; } int iot_readv (call_frame_t *frame, xlator_t *this, fd_t *fd, size_t size, - off_t offset) + off_t offset, uint32_t flags, dict_t *xdata) { call_stub_t *stub = NULL; int ret = -1; - stub = fop_readv_stub (frame, iot_readv_wrapper, fd, size, offset); + stub = fop_readv_stub (frame, iot_readv_wrapper, fd, size, offset, + flags, xdata); if (!stub) { gf_log (this->name, GF_LOG_ERROR, "cannot create readv call stub" @@ -934,7 +1006,7 @@ iot_readv (call_frame_t *frame, xlator_t *this, fd_t *fd, size_t size, out: if (ret < 0) { STACK_UNWIND_STRICT (readv, frame, -1, -ret, NULL, -1, NULL, - NULL); + NULL, NULL); if (stub != NULL) { call_stub_destroy (stub); } @@ -945,31 +1017,31 @@ out: int iot_flush_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno) + int32_t op_ret, int32_t op_errno, dict_t *xdata) { - STACK_UNWIND_STRICT (flush, frame, op_ret, op_errno); + STACK_UNWIND_STRICT (flush, frame, op_ret, op_errno, xdata); return 0; } int -iot_flush_wrapper (call_frame_t *frame, xlator_t *this, fd_t *fd) +iot_flush_wrapper (call_frame_t *frame, xlator_t *this, fd_t *fd, dict_t *xdata) { STACK_WIND (frame, iot_flush_cbk, FIRST_CHILD(this), FIRST_CHILD(this)->fops->flush, - fd); + fd, xdata); return 0; } int -iot_flush (call_frame_t *frame, xlator_t *this, fd_t *fd) +iot_flush (call_frame_t *frame, xlator_t *this, fd_t *fd, dict_t *xdata) { call_stub_t *stub = NULL; int ret = -1; - stub = fop_flush_stub (frame, iot_flush_wrapper, fd); + stub = fop_flush_stub (frame, iot_flush_wrapper, fd, xdata); if (!stub) { gf_log (this->name, GF_LOG_ERROR, "cannot create flush_cbk call stub" @@ -981,7 +1053,7 @@ iot_flush (call_frame_t *frame, xlator_t *this, fd_t *fd) ret = iot_schedule (frame, this, stub); out: if (ret < 0) { - STACK_UNWIND_STRICT (flush, frame, -1, -ret); + STACK_UNWIND_STRICT (flush, frame, -1, -ret, NULL); if (stub != NULL) { call_stub_destroy (stub); @@ -994,32 +1066,34 @@ out: int iot_fsync_cbk (call_frame_t *frame, void *cookie, xlator_t *this, int32_t op_ret, int32_t op_errno, struct iatt *prebuf, - struct iatt *postbuf) + struct iatt *postbuf, dict_t *xdata) { - STACK_UNWIND_STRICT (fsync, frame, op_ret, op_errno, prebuf, postbuf); + STACK_UNWIND_STRICT (fsync, frame, op_ret, op_errno, prebuf, postbuf, + xdata); return 0; } int iot_fsync_wrapper (call_frame_t *frame, xlator_t *this, fd_t *fd, - int32_t datasync) + int32_t datasync, dict_t *xdata) { STACK_WIND (frame, iot_fsync_cbk, FIRST_CHILD (this), FIRST_CHILD (this)->fops->fsync, - fd, datasync); + fd, datasync, xdata); return 0; } int -iot_fsync (call_frame_t *frame, xlator_t *this, fd_t *fd, int32_t datasync) +iot_fsync (call_frame_t *frame, xlator_t *this, fd_t *fd, int32_t datasync, + dict_t *xdata) { call_stub_t *stub = NULL; int ret = -1; - stub = fop_fsync_stub (frame, iot_fsync_wrapper, fd, datasync); + stub = fop_fsync_stub (frame, iot_fsync_wrapper, fd, datasync, xdata); if (!stub) { gf_log (this->name, GF_LOG_ERROR, "cannot create fsync_cbk call stub" @@ -1032,7 +1106,7 @@ iot_fsync (call_frame_t *frame, xlator_t *this, fd_t *fd, int32_t datasync) out: if (ret < 0) { - STACK_UNWIND_STRICT (fsync, frame, -1, -ret, NULL, NULL); + STACK_UNWIND_STRICT (fsync, frame, -1, -ret, NULL, NULL, NULL); if (stub != NULL) { call_stub_destroy (stub); @@ -1045,9 +1119,10 @@ out: int iot_writev_cbk (call_frame_t *frame, void *cookie, xlator_t *this, int32_t op_ret, int32_t op_errno, struct iatt *prebuf, - struct iatt *postbuf) + struct iatt *postbuf, dict_t *xdata) { - STACK_UNWIND_STRICT (writev, frame, op_ret, op_errno, prebuf, postbuf); + STACK_UNWIND_STRICT (writev, frame, op_ret, op_errno, prebuf, postbuf, + xdata); return 0; } @@ -1055,12 +1130,13 @@ iot_writev_cbk (call_frame_t *frame, void *cookie, xlator_t *this, int iot_writev_wrapper (call_frame_t *frame, xlator_t *this, fd_t *fd, struct iovec *vector, int32_t count, - off_t offset, struct iobref *iobref) + off_t offset, uint32_t flags, struct iobref *iobref, + dict_t *xdata) { STACK_WIND (frame, iot_writev_cbk, FIRST_CHILD(this), FIRST_CHILD(this)->fops->writev, - fd, vector, count, offset, iobref); + fd, vector, count, offset, flags, iobref, xdata); return 0; } @@ -1068,13 +1144,13 @@ iot_writev_wrapper (call_frame_t *frame, xlator_t *this, fd_t *fd, int iot_writev (call_frame_t *frame, xlator_t *this, fd_t *fd, struct iovec *vector, int32_t count, off_t offset, - struct iobref *iobref) + uint32_t flags, struct iobref *iobref, dict_t *xdata) { call_stub_t *stub = NULL; int ret = -1; - stub = fop_writev_stub (frame, iot_writev_wrapper, - fd, vector, count, offset, iobref); + stub = fop_writev_stub (frame, iot_writev_wrapper, fd, vector, + count, offset, flags, iobref, xdata); if (!stub) { gf_log (this->name, GF_LOG_ERROR, @@ -1087,7 +1163,7 @@ iot_writev (call_frame_t *frame, xlator_t *this, fd_t *fd, ret = iot_schedule (frame, this, stub); out: if (ret < 0) { - STACK_UNWIND_STRICT (writev, frame, -1, -ret, NULL, NULL); + STACK_UNWIND_STRICT (writev, frame, -1, -ret, NULL, NULL, NULL); if (stub != NULL) { call_stub_destroy (stub); @@ -1100,33 +1176,34 @@ out: int32_t iot_lk_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, struct gf_flock *flock) + int32_t op_ret, int32_t op_errno, struct gf_flock *flock, + dict_t *xdata) { - STACK_UNWIND_STRICT (lk, frame, op_ret, op_errno, flock); + STACK_UNWIND_STRICT (lk, frame, op_ret, op_errno, flock, xdata); return 0; } int iot_lk_wrapper (call_frame_t *frame, xlator_t *this, fd_t *fd, - int32_t cmd, struct gf_flock *flock) + int32_t cmd, struct gf_flock *flock, dict_t *xdata) { STACK_WIND (frame, iot_lk_cbk, FIRST_CHILD(this), FIRST_CHILD(this)->fops->lk, - fd, cmd, flock); + fd, cmd, flock, xdata); return 0; } int iot_lk (call_frame_t *frame, xlator_t *this, fd_t *fd, int32_t cmd, - struct gf_flock *flock) + struct gf_flock *flock, dict_t *xdata) { call_stub_t *stub = NULL; int ret = -1; - stub = fop_lk_stub (frame, iot_lk_wrapper, fd, cmd, flock); + stub = fop_lk_stub (frame, iot_lk_wrapper, fd, cmd, flock, xdata); if (!stub) { gf_log (this->name, GF_LOG_ERROR, @@ -1139,7 +1216,7 @@ iot_lk (call_frame_t *frame, xlator_t *this, fd_t *fd, int32_t cmd, ret = iot_schedule (frame, this, stub); out: if (ret < 0) { - STACK_UNWIND_STRICT (lk, frame, -1, -ret, NULL); + STACK_UNWIND_STRICT (lk, frame, -1, -ret, NULL, NULL); if (stub != NULL) { call_stub_destroy (stub); @@ -1151,31 +1228,31 @@ out: int iot_stat_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, struct iatt *buf) + int32_t op_ret, int32_t op_errno, struct iatt *buf, dict_t *xdata) { - STACK_UNWIND_STRICT (stat, frame, op_ret, op_errno, buf); + STACK_UNWIND_STRICT (stat, frame, op_ret, op_errno, buf, xdata); return 0; } int -iot_stat_wrapper (call_frame_t *frame, xlator_t *this, loc_t *loc) +iot_stat_wrapper (call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *xdata) { STACK_WIND (frame, iot_stat_cbk, FIRST_CHILD(this), FIRST_CHILD(this)->fops->stat, - loc); + loc, xdata); return 0; } int -iot_stat (call_frame_t *frame, xlator_t *this, loc_t *loc) +iot_stat (call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *xdata) { call_stub_t *stub = NULL; int ret = -1; - stub = fop_stat_stub (frame, iot_stat_wrapper, loc); + stub = fop_stat_stub (frame, iot_stat_wrapper, loc, xdata); if (!stub) { gf_log (this->name, GF_LOG_ERROR, "cannot create fop_stat call stub" @@ -1188,7 +1265,7 @@ iot_stat (call_frame_t *frame, xlator_t *this, loc_t *loc) out: if (ret < 0) { - STACK_UNWIND_STRICT (stat, frame, -1, -ret, NULL); + STACK_UNWIND_STRICT (stat, frame, -1, -ret, NULL, NULL); if (stub != NULL) { call_stub_destroy (stub); @@ -1200,31 +1277,31 @@ out: int iot_fstat_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, struct iatt *buf) + int32_t op_ret, int32_t op_errno, struct iatt *buf, dict_t *xdata) { - STACK_UNWIND_STRICT (fstat, frame, op_ret, op_errno, buf); + STACK_UNWIND_STRICT (fstat, frame, op_ret, op_errno, buf, xdata); return 0; } int -iot_fstat_wrapper (call_frame_t *frame, xlator_t *this, fd_t *fd) +iot_fstat_wrapper (call_frame_t *frame, xlator_t *this, fd_t *fd, dict_t *xdata) { STACK_WIND (frame, iot_fstat_cbk, FIRST_CHILD(this), FIRST_CHILD(this)->fops->fstat, - fd); + fd, xdata); return 0; } int -iot_fstat (call_frame_t *frame, xlator_t *this, fd_t *fd) +iot_fstat (call_frame_t *frame, xlator_t *this, fd_t *fd, dict_t *xdata) { call_stub_t *stub = NULL; int ret = -1; - stub = fop_fstat_stub (frame, iot_fstat_wrapper, fd); + stub = fop_fstat_stub (frame, iot_fstat_wrapper, fd, xdata); if (!stub) { gf_log (this->name, GF_LOG_ERROR, "cannot create fop_fstat call stub" @@ -1236,7 +1313,7 @@ iot_fstat (call_frame_t *frame, xlator_t *this, fd_t *fd) ret = iot_schedule (frame, this, stub); out: if (ret < 0) { - STACK_UNWIND_STRICT (fstat, frame, -1, -ret, NULL); + STACK_UNWIND_STRICT (fstat, frame, -1, -ret, NULL, NULL); if (stub != NULL) { call_stub_destroy (stub); @@ -1249,34 +1326,35 @@ out: int iot_truncate_cbk (call_frame_t *frame, void *cookie, xlator_t *this, int32_t op_ret, int32_t op_errno, struct iatt *prebuf, - struct iatt *postbuf) + struct iatt *postbuf, dict_t *xdata) { STACK_UNWIND_STRICT (truncate, frame, op_ret, op_errno, prebuf, - postbuf); + postbuf, xdata); return 0; } int iot_truncate_wrapper (call_frame_t *frame, xlator_t *this, loc_t *loc, - off_t offset) + off_t offset, dict_t *xdata) { STACK_WIND (frame, iot_truncate_cbk, FIRST_CHILD(this), FIRST_CHILD(this)->fops->truncate, - loc, offset); + loc, offset, xdata); return 0; } int -iot_truncate (call_frame_t *frame, xlator_t *this, loc_t *loc, off_t offset) +iot_truncate (call_frame_t *frame, xlator_t *this, loc_t *loc, off_t offset, + dict_t *xdata) { call_stub_t *stub; int ret = -1; - stub = fop_truncate_stub (frame, iot_truncate_wrapper, loc, offset); - + stub = fop_truncate_stub (frame, iot_truncate_wrapper, loc, offset, + xdata); if (!stub) { gf_log (this->name, GF_LOG_ERROR, "cannot create fop_stat call stub" @@ -1289,7 +1367,8 @@ iot_truncate (call_frame_t *frame, xlator_t *this, loc_t *loc, off_t offset) out: if (ret < 0) { - STACK_UNWIND_STRICT (truncate, frame, -1, -ret, NULL, NULL); + STACK_UNWIND_STRICT (truncate, frame, -1, -ret, NULL, NULL, + NULL); if (stub != NULL) { call_stub_destroy (stub); @@ -1303,33 +1382,35 @@ out: int iot_ftruncate_cbk (call_frame_t *frame, void *cookie, xlator_t *this, int32_t op_ret, int32_t op_errno, struct iatt *prebuf, - struct iatt *postbuf) + struct iatt *postbuf, dict_t *xdata) { STACK_UNWIND_STRICT (ftruncate, frame, op_ret, op_errno, prebuf, - postbuf); + postbuf, xdata); return 0; } int iot_ftruncate_wrapper (call_frame_t *frame, xlator_t *this, fd_t *fd, - off_t offset) + off_t offset, dict_t *xdata) { STACK_WIND (frame, iot_ftruncate_cbk, FIRST_CHILD(this), FIRST_CHILD(this)->fops->ftruncate, - fd, offset); + fd, offset, xdata); return 0; } int -iot_ftruncate (call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset) +iot_ftruncate (call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset, + dict_t *xdata) { call_stub_t *stub = NULL; int ret = -1; - stub = fop_ftruncate_stub (frame, iot_ftruncate_wrapper, fd, offset); + stub = fop_ftruncate_stub (frame, iot_ftruncate_wrapper, fd, offset, + xdata); if (!stub) { gf_log (this->name, GF_LOG_ERROR, "cannot create fop_ftruncate call stub" @@ -1341,7 +1422,7 @@ iot_ftruncate (call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset) ret = iot_schedule (frame, this, stub); out: if (ret < 0) { - STACK_UNWIND_STRICT (ftruncate, frame, -1, -ret, NULL, NULL); + STACK_UNWIND_STRICT (ftruncate, frame, -1, -ret, NULL, NULL, NULL); if (stub != NULL) { call_stub_destroy (stub); @@ -1355,32 +1436,34 @@ out: int iot_unlink_cbk (call_frame_t *frame, void *cookie, xlator_t *this, int32_t op_ret, int32_t op_errno, struct iatt *preparent, - struct iatt *postparent) + struct iatt *postparent, dict_t *xdata) { STACK_UNWIND_STRICT (unlink, frame, op_ret, op_errno, preparent, - postparent); + postparent, xdata); return 0; } int -iot_unlink_wrapper (call_frame_t *frame, xlator_t *this, loc_t *loc) +iot_unlink_wrapper (call_frame_t *frame, xlator_t *this, loc_t *loc, + int32_t xflag, dict_t *xdata) { STACK_WIND (frame, iot_unlink_cbk, FIRST_CHILD(this), FIRST_CHILD(this)->fops->unlink, - loc); + loc, xflag, xdata); return 0; } int -iot_unlink (call_frame_t *frame, xlator_t *this, loc_t *loc) +iot_unlink (call_frame_t *frame, xlator_t *this, loc_t *loc, int32_t xflag, + dict_t *xdata) { call_stub_t *stub = NULL; int ret = -1; - stub = fop_unlink_stub (frame, iot_unlink_wrapper, loc); + stub = fop_unlink_stub (frame, iot_unlink_wrapper, loc, xflag, xdata); if (!stub) { gf_log (this->name, GF_LOG_ERROR, "cannot create fop_unlink call stub" @@ -1393,7 +1476,7 @@ iot_unlink (call_frame_t *frame, xlator_t *this, loc_t *loc) out: if (ret < 0) { - STACK_UNWIND_STRICT (unlink, frame, -1, -ret, NULL, NULL); + STACK_UNWIND_STRICT (unlink, frame, -1, -ret, NULL, NULL, NULL); if (stub != NULL) { call_stub_destroy (stub); @@ -1407,31 +1490,34 @@ out: int iot_link_cbk (call_frame_t *frame, void *cookie, xlator_t *this, int32_t op_ret, int32_t op_errno, inode_t *inode, - struct iatt *buf, struct iatt *preparent, struct iatt *postparent) + struct iatt *buf, struct iatt *preparent, struct iatt *postparent, + dict_t *xdata) { STACK_UNWIND_STRICT (link, frame, op_ret, op_errno, inode, buf, - preparent, postparent); + preparent, postparent, xdata); return 0; } int -iot_link_wrapper (call_frame_t *frame, xlator_t *this, loc_t *old, loc_t *new) +iot_link_wrapper (call_frame_t *frame, xlator_t *this, loc_t *old, loc_t *new, + dict_t *xdata) { STACK_WIND (frame, iot_link_cbk, FIRST_CHILD (this), - FIRST_CHILD (this)->fops->link, old, new); + FIRST_CHILD (this)->fops->link, old, new, xdata); return 0; } int -iot_link (call_frame_t *frame, xlator_t *this, loc_t *oldloc, loc_t *newloc) +iot_link (call_frame_t *frame, xlator_t *this, loc_t *oldloc, loc_t *newloc, + dict_t *xdata) { call_stub_t *stub = NULL; int ret = -1; - stub = fop_link_stub (frame, iot_link_wrapper, oldloc, newloc); + stub = fop_link_stub (frame, iot_link_wrapper, oldloc, newloc, xdata); if (!stub) { gf_log (this->name, GF_LOG_ERROR, "cannot create link stub" "(out of memory)"); @@ -1443,7 +1529,7 @@ iot_link (call_frame_t *frame, xlator_t *this, loc_t *oldloc, loc_t *newloc) out: if (ret < 0) { STACK_UNWIND_STRICT (link, frame, -1, -ret, NULL, NULL, NULL, - NULL); + NULL, NULL); if (stub != NULL) { call_stub_destroy (stub); @@ -1455,29 +1541,31 @@ out: int iot_opendir_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, fd_t *fd) + int32_t op_ret, int32_t op_errno, fd_t *fd, dict_t *xdata) { - STACK_UNWIND_STRICT (opendir, frame, op_ret, op_errno, fd); + STACK_UNWIND_STRICT (opendir, frame, op_ret, op_errno, fd, xdata); return 0; } int -iot_opendir_wrapper (call_frame_t *frame, xlator_t *this, loc_t *loc, fd_t *fd) +iot_opendir_wrapper (call_frame_t *frame, xlator_t *this, loc_t *loc, fd_t *fd, + dict_t *xdata) { STACK_WIND (frame, iot_opendir_cbk, FIRST_CHILD (this), - FIRST_CHILD (this)->fops->opendir, loc, fd); + FIRST_CHILD (this)->fops->opendir, loc, fd, xdata); return 0; } int -iot_opendir (call_frame_t *frame, xlator_t *this, loc_t *loc, fd_t *fd) +iot_opendir (call_frame_t *frame, xlator_t *this, loc_t *loc, fd_t *fd, + dict_t *xdata) { call_stub_t *stub = NULL; int ret = -1; - stub = fop_opendir_stub (frame, iot_opendir_wrapper, loc, fd); + stub = fop_opendir_stub (frame, iot_opendir_wrapper, loc, fd, xdata); if (!stub) { gf_log (this->name, GF_LOG_ERROR, "cannot create opendir stub" "(out of memory)"); @@ -1488,7 +1576,7 @@ iot_opendir (call_frame_t *frame, xlator_t *this, loc_t *loc, fd_t *fd) ret = iot_schedule (frame, this, stub); out: if (ret < 0) { - STACK_UNWIND_STRICT (opendir, frame, -1, -ret, NULL); + STACK_UNWIND_STRICT (opendir, frame, -1, -ret, NULL, NULL); if (stub != NULL) { call_stub_destroy (stub); @@ -1500,30 +1588,32 @@ out: int iot_fsyncdir_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno) + int32_t op_ret, int32_t op_errno, dict_t *xdata) { - STACK_UNWIND_STRICT (fsyncdir, frame, op_ret, op_errno); + STACK_UNWIND_STRICT (fsyncdir, frame, op_ret, op_errno, xdata); return 0; } int iot_fsyncdir_wrapper (call_frame_t *frame, xlator_t *this, fd_t *fd, - int datasync) + int datasync, dict_t *xdata) { STACK_WIND (frame, iot_fsyncdir_cbk, FIRST_CHILD (this), - FIRST_CHILD (this)->fops->fsyncdir, fd, datasync); + FIRST_CHILD (this)->fops->fsyncdir, fd, datasync, xdata); return 0; } int -iot_fsyncdir (call_frame_t *frame, xlator_t *this, fd_t *fd, int datasync) +iot_fsyncdir (call_frame_t *frame, xlator_t *this, fd_t *fd, int datasync, + dict_t *xdata) { call_stub_t *stub = NULL; int ret = -1; - stub = fop_fsyncdir_stub (frame, iot_fsyncdir_wrapper, fd, datasync); + stub = fop_fsyncdir_stub (frame, iot_fsyncdir_wrapper, fd, datasync, + xdata); if (!stub) { gf_log (this->name, GF_LOG_ERROR, "cannot create fsyncdir stub" "(out of memory)"); @@ -1534,7 +1624,7 @@ iot_fsyncdir (call_frame_t *frame, xlator_t *this, fd_t *fd, int datasync) ret = iot_schedule (frame, this, stub); out: if (ret < 0) { - STACK_UNWIND_STRICT (fsyncdir, frame, -1, -ret); + STACK_UNWIND_STRICT (fsyncdir, frame, -1, -ret, NULL); if (stub != NULL) { call_stub_destroy (stub); @@ -1546,29 +1636,31 @@ out: int iot_statfs_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, struct statvfs *buf) + int32_t op_ret, int32_t op_errno, struct statvfs *buf, + dict_t *xdata) { - STACK_UNWIND_STRICT (statfs, frame, op_ret, op_errno, buf); + STACK_UNWIND_STRICT (statfs, frame, op_ret, op_errno, buf, xdata); return 0; } int -iot_statfs_wrapper (call_frame_t *frame, xlator_t *this, loc_t *loc) +iot_statfs_wrapper (call_frame_t *frame, xlator_t *this, loc_t *loc, + dict_t *xdata) { STACK_WIND (frame, iot_statfs_cbk, FIRST_CHILD (this), - FIRST_CHILD (this)->fops->statfs, loc); + FIRST_CHILD (this)->fops->statfs, loc, xdata); return 0; } int -iot_statfs (call_frame_t *frame, xlator_t *this, loc_t *loc) +iot_statfs (call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *xdata) { call_stub_t *stub = NULL; int ret = -1; - stub = fop_statfs_stub (frame, iot_statfs_wrapper, loc); + stub = fop_statfs_stub (frame, iot_statfs_wrapper, loc, xdata); if (!stub) { gf_log (this->name, GF_LOG_ERROR, "cannot create statfs stub" "(out of memory)"); @@ -1579,7 +1671,7 @@ iot_statfs (call_frame_t *frame, xlator_t *this, loc_t *loc) ret = iot_schedule (frame, this, stub); out: if (ret < 0) { - STACK_UNWIND_STRICT (statfs, frame, -1, -ret, NULL); + STACK_UNWIND_STRICT (statfs, frame, -1, -ret, NULL, NULL); if (stub != NULL) { call_stub_destroy (stub); @@ -1591,32 +1683,32 @@ out: int iot_setxattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno) + int32_t op_ret, int32_t op_errno, dict_t *xdata) { - STACK_UNWIND_STRICT (setxattr, frame, op_ret, op_errno); + STACK_UNWIND_STRICT (setxattr, frame, op_ret, op_errno, xdata); return 0; } int iot_setxattr_wrapper (call_frame_t *frame, xlator_t *this, loc_t *loc, - dict_t *dict, int32_t flags) + dict_t *dict, int32_t flags, dict_t *xdata) { STACK_WIND (frame, iot_setxattr_cbk, FIRST_CHILD (this), - FIRST_CHILD (this)->fops->setxattr, loc, dict, flags); + FIRST_CHILD (this)->fops->setxattr, loc, dict, flags, xdata); return 0; } int iot_setxattr (call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *dict, - int32_t flags) + int32_t flags, dict_t *xdata) { call_stub_t *stub = NULL; int ret = -1; stub = fop_setxattr_stub (frame, iot_setxattr_wrapper, loc, dict, - flags); + flags, xdata); if (!stub) { gf_log (this->name, GF_LOG_ERROR, "cannot create setxattr stub" "(out of memory)"); @@ -1628,7 +1720,7 @@ iot_setxattr (call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *dict, out: if (ret < 0) { - STACK_UNWIND_STRICT (setxattr, frame, -1, -ret); + STACK_UNWIND_STRICT (setxattr, frame, -1, -ret, NULL); if (stub != NULL) { call_stub_destroy (stub); @@ -1640,31 +1732,31 @@ out: int iot_getxattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, dict_t *dict) + int32_t op_ret, int32_t op_errno, dict_t *dict, dict_t *xdata) { - STACK_UNWIND_STRICT (getxattr, frame, op_ret, op_errno, dict); + STACK_UNWIND_STRICT (getxattr, frame, op_ret, op_errno, dict, xdata); return 0; } int iot_getxattr_wrapper (call_frame_t *frame, xlator_t *this, loc_t *loc, - const char *name) + const char *name, dict_t *xdata) { STACK_WIND (frame, iot_getxattr_cbk, FIRST_CHILD (this), - FIRST_CHILD (this)->fops->getxattr, loc, name); + FIRST_CHILD (this)->fops->getxattr, loc, name, xdata); return 0; } int iot_getxattr (call_frame_t *frame, xlator_t *this, loc_t *loc, - const char *name) + const char *name, dict_t *xdata) { call_stub_t *stub = NULL; int ret = -1; - stub = fop_getxattr_stub (frame, iot_getxattr_wrapper, loc, name); + stub = fop_getxattr_stub (frame, iot_getxattr_wrapper, loc, name, xdata); if (!stub) { gf_log (this->name, GF_LOG_ERROR, "cannot create getxattr stub" "(out of memory)"); @@ -1676,7 +1768,7 @@ iot_getxattr (call_frame_t *frame, xlator_t *this, loc_t *loc, out: if (ret < 0) { - STACK_UNWIND_STRICT (getxattr, frame, -1, -ret, NULL); + STACK_UNWIND_STRICT (getxattr, frame, -1, -ret, NULL, NULL); if (stub != NULL) { call_stub_destroy (stub); @@ -1688,31 +1780,32 @@ out: int iot_fgetxattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, dict_t *dict) + int32_t op_ret, int32_t op_errno, dict_t *dict, + dict_t *xdata) { - STACK_UNWIND_STRICT (fgetxattr, frame, op_ret, op_errno, dict); + STACK_UNWIND_STRICT (fgetxattr, frame, op_ret, op_errno, dict, xdata); return 0; } int iot_fgetxattr_wrapper (call_frame_t *frame, xlator_t *this, fd_t *fd, - const char *name) + const char *name, dict_t *xdata) { STACK_WIND (frame, iot_fgetxattr_cbk, FIRST_CHILD (this), - FIRST_CHILD (this)->fops->fgetxattr, fd, name); + FIRST_CHILD (this)->fops->fgetxattr, fd, name, xdata); return 0; } int iot_fgetxattr (call_frame_t *frame, xlator_t *this, fd_t *fd, - const char *name) + const char *name, dict_t *xdata) { call_stub_t *stub = NULL; int ret = -1; - stub = fop_fgetxattr_stub (frame, iot_fgetxattr_wrapper, fd, name); + stub = fop_fgetxattr_stub (frame, iot_fgetxattr_wrapper, fd, name, xdata); if (!stub) { gf_log (this->name, GF_LOG_ERROR, "cannot create fgetxattr stub" "(out of memory)"); @@ -1723,7 +1816,7 @@ iot_fgetxattr (call_frame_t *frame, xlator_t *this, fd_t *fd, ret = iot_schedule (frame, this, stub); out: if (ret < 0) { - STACK_UNWIND_STRICT (fgetxattr, frame, -1, -ret, NULL); + STACK_UNWIND_STRICT (fgetxattr, frame, -1, -ret, NULL, NULL); if (stub != NULL) { call_stub_destroy (stub); @@ -1735,32 +1828,33 @@ out: int iot_fsetxattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno) + int32_t op_ret, int32_t op_errno, dict_t *xdata) { - STACK_UNWIND_STRICT (fsetxattr, frame, op_ret, op_errno); + STACK_UNWIND_STRICT (fsetxattr, frame, op_ret, op_errno, xdata); return 0; } int iot_fsetxattr_wrapper (call_frame_t *frame, xlator_t *this, fd_t *fd, - dict_t *dict, int32_t flags) + dict_t *dict, int32_t flags, dict_t *xdata) { STACK_WIND (frame, iot_fsetxattr_cbk, FIRST_CHILD (this), - FIRST_CHILD (this)->fops->fsetxattr, fd, dict, flags); + FIRST_CHILD (this)->fops->fsetxattr, fd, dict, flags, + xdata); return 0; } int iot_fsetxattr (call_frame_t *frame, xlator_t *this, fd_t *fd, dict_t *dict, - int32_t flags) + int32_t flags, dict_t *xdata) { call_stub_t *stub = NULL; int ret = -1; stub = fop_fsetxattr_stub (frame, iot_fsetxattr_wrapper, fd, dict, - flags); + flags, xdata); if (!stub) { gf_log (this->name, GF_LOG_ERROR, "cannot create fsetxattr stub" "(out of memory)"); @@ -1771,7 +1865,7 @@ iot_fsetxattr (call_frame_t *frame, xlator_t *this, fd_t *fd, dict_t *dict, ret = iot_schedule (frame, this, stub); out: if (ret < 0) { - STACK_UNWIND_STRICT (fsetxattr, frame, -1, -ret); + STACK_UNWIND_STRICT (fsetxattr, frame, -1, -ret, NULL); if (stub != NULL) { call_stub_destroy (stub); @@ -1783,32 +1877,32 @@ out: int iot_removexattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno) + int32_t op_ret, int32_t op_errno, dict_t *xdata) { - STACK_UNWIND_STRICT (removexattr, frame, op_ret, op_errno); + STACK_UNWIND_STRICT (removexattr, frame, op_ret, op_errno, xdata); return 0; } int iot_removexattr_wrapper (call_frame_t *frame, xlator_t *this, loc_t *loc, - const char *name) + const char *name, dict_t *xdata) { STACK_WIND (frame, iot_removexattr_cbk, FIRST_CHILD (this), - FIRST_CHILD (this)->fops->removexattr, loc, name); + FIRST_CHILD (this)->fops->removexattr, loc, name, xdata); return 0; } int iot_removexattr (call_frame_t *frame, xlator_t *this, loc_t *loc, - const char *name) + const char *name, dict_t *xdata) { call_stub_t *stub = NULL; int ret = -1; stub = fop_removexattr_stub (frame, iot_removexattr_wrapper, loc, - name); + name, xdata); if (!stub) { gf_log (this->name, GF_LOG_ERROR,"cannot get removexattr fop" "(out of memory)"); @@ -1819,7 +1913,54 @@ iot_removexattr (call_frame_t *frame, xlator_t *this, loc_t *loc, ret = iot_schedule (frame, this, stub); out: if (ret < 0) { - STACK_UNWIND_STRICT (removexattr, frame, -1, -ret); + STACK_UNWIND_STRICT (removexattr, frame, -1, -ret, NULL); + + if (stub != NULL) { + call_stub_destroy (stub); + } + } + return 0; +} + +int +iot_fremovexattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, dict_t *xdata) +{ + STACK_UNWIND_STRICT (fremovexattr, frame, op_ret, op_errno, xdata); + return 0; +} + + +int +iot_fremovexattr_wrapper (call_frame_t *frame, xlator_t *this, fd_t *fd, + const char *name, dict_t *xdata) +{ + STACK_WIND (frame, iot_fremovexattr_cbk, FIRST_CHILD (this), + FIRST_CHILD (this)->fops->fremovexattr, fd, name, xdata); + return 0; +} + + +int +iot_fremovexattr (call_frame_t *frame, xlator_t *this, fd_t *fd, + const char *name, dict_t *xdata) +{ + call_stub_t *stub = NULL; + int ret = -1; + + stub = fop_fremovexattr_stub (frame, iot_fremovexattr_wrapper, fd, + name, xdata); + if (!stub) { + gf_log (this->name, GF_LOG_ERROR,"cannot get fremovexattr fop" + "(out of memory)"); + ret = -ENOMEM; + goto out; + } + + ret = iot_schedule (frame, this, stub); +out: + if (ret < 0) { + STACK_UNWIND_STRICT (fremovexattr, frame, -1, -ret, NULL); if (stub != NULL) { call_stub_destroy (stub); @@ -1831,32 +1972,33 @@ out: int iot_readdirp_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, gf_dirent_t *entries) + int32_t op_ret, int32_t op_errno, gf_dirent_t *entries, + dict_t *xdata) { - STACK_UNWIND_STRICT (readdirp, frame, op_ret, op_errno, entries); + STACK_UNWIND_STRICT (readdirp, frame, op_ret, op_errno, entries, xdata); return 0; } int iot_readdirp_wrapper (call_frame_t *frame, xlator_t *this, fd_t *fd, - size_t size, off_t offset) + size_t size, off_t offset, dict_t *xdata) { STACK_WIND (frame, iot_readdirp_cbk, FIRST_CHILD (this), - FIRST_CHILD (this)->fops->readdirp, fd, size, offset); + FIRST_CHILD (this)->fops->readdirp, fd, size, offset, xdata); return 0; } int iot_readdirp (call_frame_t *frame, xlator_t *this, fd_t *fd, size_t size, - off_t offset) + off_t offset, dict_t *xdata) { call_stub_t *stub = NULL; int ret = -1; stub = fop_readdirp_stub (frame, iot_readdirp_wrapper, fd, size, - offset); + offset, xdata); if (!stub) { gf_log (this->private, GF_LOG_ERROR,"cannot get readdir stub" "(out of memory)"); @@ -1867,7 +2009,7 @@ iot_readdirp (call_frame_t *frame, xlator_t *this, fd_t *fd, size_t size, ret = iot_schedule (frame, this, stub); out: if (ret < 0) { - STACK_UNWIND_STRICT (readdirp, frame, -1, -ret, NULL); + STACK_UNWIND_STRICT (readdirp, frame, -1, -ret, NULL, NULL); if (stub != NULL) { call_stub_destroy (stub); @@ -1879,31 +2021,33 @@ out: int iot_readdir_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, gf_dirent_t *entries) + int32_t op_ret, int32_t op_errno, gf_dirent_t *entries, + dict_t *xdata) { - STACK_UNWIND_STRICT (readdir, frame, op_ret, op_errno, entries); + STACK_UNWIND_STRICT (readdir, frame, op_ret, op_errno, entries, xdata); return 0; } int iot_readdir_wrapper (call_frame_t *frame, xlator_t *this, fd_t *fd, - size_t size, off_t offset) + size_t size, off_t offset, dict_t *xdata) { STACK_WIND (frame, iot_readdir_cbk, FIRST_CHILD (this), - FIRST_CHILD (this)->fops->readdir, fd, size, offset); + FIRST_CHILD (this)->fops->readdir, fd, size, offset, xdata); return 0; } int iot_readdir (call_frame_t *frame, xlator_t *this, fd_t *fd, size_t size, - off_t offset) + off_t offset, dict_t *xdata) { call_stub_t *stub = NULL; int ret = -1; - stub = fop_readdir_stub (frame, iot_readdir_wrapper, fd, size, offset); + stub = fop_readdir_stub (frame, iot_readdir_wrapper, fd, size, offset, + xdata); if (!stub) { gf_log (this->private, GF_LOG_ERROR,"cannot get readdir stub" "(out of memory)"); @@ -1914,7 +2058,7 @@ iot_readdir (call_frame_t *frame, xlator_t *this, fd_t *fd, size_t size, ret = iot_schedule (frame, this, stub); out: if (ret < 0) { - STACK_UNWIND_STRICT (readdir, frame, -1, -ret, NULL); + STACK_UNWIND_STRICT (readdir, frame, -1, -ret, NULL, NULL); if (stub != NULL) { call_stub_destroy (stub); @@ -1924,33 +2068,36 @@ out: } int -iot_inodelk_cbk (call_frame_t *frame, void *cookie, - xlator_t *this, int32_t op_ret, int32_t op_errno) +iot_inodelk_cbk (call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, dict_t *xdata) { - STACK_UNWIND_STRICT (inodelk, frame, op_ret, op_errno); + STACK_UNWIND_STRICT (inodelk, frame, op_ret, op_errno, xdata); return 0; } int iot_inodelk_wrapper (call_frame_t *frame, xlator_t *this, const char *volume, - loc_t *loc, int32_t cmd, struct gf_flock *lock) + loc_t *loc, int32_t cmd, struct gf_flock *lock, + dict_t *xdata) { STACK_WIND (frame, iot_inodelk_cbk, FIRST_CHILD (this), - FIRST_CHILD (this)->fops->inodelk, volume, loc, cmd, lock); + FIRST_CHILD (this)->fops->inodelk, volume, loc, cmd, lock, + xdata); return 0; } int iot_inodelk (call_frame_t *frame, xlator_t *this, - const char *volume, loc_t *loc, int32_t cmd, struct gf_flock *lock) + const char *volume, loc_t *loc, int32_t cmd, struct gf_flock *lock, + dict_t *xdata) { call_stub_t *stub = NULL; int ret = -1; stub = fop_inodelk_stub (frame, iot_inodelk_wrapper, - volume, loc, cmd, lock); + volume, loc, cmd, lock, xdata); if (!stub) { ret = -ENOMEM; goto out; @@ -1959,7 +2106,7 @@ iot_inodelk (call_frame_t *frame, xlator_t *this, ret = iot_schedule (frame, this, stub); out: if (ret < 0) { - STACK_UNWIND_STRICT (inodelk, frame, -1, -ret); + STACK_UNWIND_STRICT (inodelk, frame, -1, -ret, NULL); if (stub != NULL) { call_stub_destroy (stub); @@ -1970,9 +2117,9 @@ out: int iot_finodelk_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno) + int32_t op_ret, int32_t op_errno, dict_t *xdata) { - STACK_UNWIND_STRICT (finodelk, frame, op_ret, op_errno); + STACK_UNWIND_STRICT (finodelk, frame, op_ret, op_errno, xdata); return 0; } @@ -1980,23 +2127,25 @@ iot_finodelk_cbk (call_frame_t *frame, void *cookie, xlator_t *this, int iot_finodelk_wrapper (call_frame_t *frame, xlator_t *this, const char *volume, fd_t *fd, int32_t cmd, - struct gf_flock *lock) + struct gf_flock *lock, dict_t *xdata) { STACK_WIND (frame, iot_finodelk_cbk, FIRST_CHILD (this), - FIRST_CHILD (this)->fops->finodelk, volume, fd, cmd, lock); + FIRST_CHILD (this)->fops->finodelk, volume, fd, cmd, lock, + xdata); return 0; } int iot_finodelk (call_frame_t *frame, xlator_t *this, - const char *volume, fd_t *fd, int32_t cmd, struct gf_flock *lock) + const char *volume, fd_t *fd, int32_t cmd, struct gf_flock *lock, + dict_t *xdata) { call_stub_t *stub = NULL; int ret = -1; stub = fop_finodelk_stub (frame, iot_finodelk_wrapper, - volume, fd, cmd, lock); + volume, fd, cmd, lock, xdata); if (!stub) { gf_log (this->private, GF_LOG_ERROR,"cannot get finodelk stub" "(out of memory)"); @@ -2007,7 +2156,7 @@ iot_finodelk (call_frame_t *frame, xlator_t *this, ret = iot_schedule (frame, this, stub); out: if (ret < 0) { - STACK_UNWIND_STRICT (finodelk, frame, -1, -ret); + STACK_UNWIND_STRICT (finodelk, frame, -1, -ret, NULL); if (stub != NULL) { call_stub_destroy (stub); @@ -2018,9 +2167,9 @@ out: int iot_entrylk_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno) + int32_t op_ret, int32_t op_errno, dict_t *xdata) { - STACK_UNWIND_STRICT (entrylk, frame, op_ret, op_errno); + STACK_UNWIND_STRICT (entrylk, frame, op_ret, op_errno, xdata); return 0; } @@ -2028,11 +2177,11 @@ iot_entrylk_cbk (call_frame_t *frame, void *cookie, xlator_t *this, int iot_entrylk_wrapper (call_frame_t *frame, xlator_t *this, const char *volume, loc_t *loc, const char *basename, - entrylk_cmd cmd, entrylk_type type) + entrylk_cmd cmd, entrylk_type type, dict_t *xdata) { STACK_WIND (frame, iot_entrylk_cbk, FIRST_CHILD (this), FIRST_CHILD (this)->fops->entrylk, - volume, loc, basename, cmd, type); + volume, loc, basename, cmd, type, xdata); return 0; } @@ -2040,13 +2189,13 @@ iot_entrylk_wrapper (call_frame_t *frame, xlator_t *this, int iot_entrylk (call_frame_t *frame, xlator_t *this, const char *volume, loc_t *loc, const char *basename, - entrylk_cmd cmd, entrylk_type type) + entrylk_cmd cmd, entrylk_type type, dict_t *xdata) { call_stub_t *stub = NULL; int ret = -1; stub = fop_entrylk_stub (frame, iot_entrylk_wrapper, - volume, loc, basename, cmd, type); + volume, loc, basename, cmd, type, xdata); if (!stub) { gf_log (this->private, GF_LOG_ERROR,"cannot get entrylk stub" "(out of memory)"); @@ -2057,7 +2206,7 @@ iot_entrylk (call_frame_t *frame, xlator_t *this, ret = iot_schedule (frame, this, stub); out: if (ret < 0) { - STACK_UNWIND_STRICT (entrylk, frame, -1, -ret); + STACK_UNWIND_STRICT (entrylk, frame, -1, -ret, NULL); if (stub != NULL) { call_stub_destroy (stub); @@ -2068,9 +2217,9 @@ out: int iot_fentrylk_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno) + int32_t op_ret, int32_t op_errno, dict_t *xdata) { - STACK_UNWIND_STRICT (fentrylk, frame, op_ret, op_errno); + STACK_UNWIND_STRICT (fentrylk, frame, op_ret, op_errno, xdata); return 0; } @@ -2078,11 +2227,11 @@ iot_fentrylk_cbk (call_frame_t *frame, void *cookie, xlator_t *this, int iot_fentrylk_wrapper (call_frame_t *frame, xlator_t *this, const char *volume, fd_t *fd, const char *basename, - entrylk_cmd cmd, entrylk_type type) + entrylk_cmd cmd, entrylk_type type, dict_t *xdata) { STACK_WIND (frame, iot_fentrylk_cbk, FIRST_CHILD (this), FIRST_CHILD (this)->fops->fentrylk, - volume, fd, basename, cmd, type); + volume, fd, basename, cmd, type, xdata); return 0; } @@ -2090,13 +2239,13 @@ iot_fentrylk_wrapper (call_frame_t *frame, xlator_t *this, int iot_fentrylk (call_frame_t *frame, xlator_t *this, const char *volume, fd_t *fd, const char *basename, - entrylk_cmd cmd, entrylk_type type) + entrylk_cmd cmd, entrylk_type type, dict_t *xdata) { call_stub_t *stub = NULL; int ret = -1; stub = fop_fentrylk_stub (frame, iot_fentrylk_wrapper, - volume, fd, basename, cmd, type); + volume, fd, basename, cmd, type, xdata); if (!stub) { gf_log (this->private, GF_LOG_ERROR,"cannot get fentrylk stub" "(out of memory)"); @@ -2107,7 +2256,7 @@ iot_fentrylk (call_frame_t *frame, xlator_t *this, ret = iot_schedule (frame, this, stub); out: if (ret < 0) { - STACK_UNWIND_STRICT (fentrylk, frame, -1, -ret); + STACK_UNWIND_STRICT (fentrylk, frame, -1, -ret, NULL); if (stub != NULL) { call_stub_destroy (stub); @@ -2119,32 +2268,32 @@ out: int iot_xattrop_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, dict_t *xattr) + int32_t op_ret, int32_t op_errno, dict_t *xattr, dict_t *xdata) { - STACK_UNWIND_STRICT (xattrop, frame, op_ret, op_errno, xattr); + STACK_UNWIND_STRICT (xattrop, frame, op_ret, op_errno, xattr, xdata); return 0; } int iot_xattrop_wrapper (call_frame_t *frame, xlator_t *this, loc_t *loc, - gf_xattrop_flags_t optype, dict_t *xattr) + gf_xattrop_flags_t optype, dict_t *xattr, dict_t *xdata) { STACK_WIND (frame, iot_xattrop_cbk, FIRST_CHILD (this), - FIRST_CHILD (this)->fops->xattrop, loc, optype, xattr); + FIRST_CHILD (this)->fops->xattrop, loc, optype, xattr, xdata); return 0; } int iot_xattrop (call_frame_t *frame, xlator_t *this, loc_t *loc, - gf_xattrop_flags_t optype, dict_t *xattr) + gf_xattrop_flags_t optype, dict_t *xattr, dict_t *xdata) { call_stub_t *stub = NULL; int ret = -1; stub = fop_xattrop_stub (frame, iot_xattrop_wrapper, loc, optype, - xattr); + xattr, xdata); if (!stub) { gf_log (this->name, GF_LOG_ERROR, "cannot create xattrop stub" "(out of memory)"); @@ -2155,7 +2304,7 @@ iot_xattrop (call_frame_t *frame, xlator_t *this, loc_t *loc, ret = iot_schedule (frame, this, stub); out: if (ret < 0) { - STACK_UNWIND_STRICT (xattrop, frame, -1, -ret, NULL); + STACK_UNWIND_STRICT (xattrop, frame, -1, -ret, NULL, NULL); if (stub != NULL) { call_stub_destroy (stub); @@ -2167,31 +2316,31 @@ out: int iot_fxattrop_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, dict_t *xattr) + int32_t op_ret, int32_t op_errno, dict_t *xattr, dict_t *xdata) { - STACK_UNWIND_STRICT (fxattrop, frame, op_ret, op_errno, xattr); + STACK_UNWIND_STRICT (fxattrop, frame, op_ret, op_errno, xattr, xdata); return 0; } int iot_fxattrop_wrapper (call_frame_t *frame, xlator_t *this, fd_t *fd, - gf_xattrop_flags_t optype, dict_t *xattr) + gf_xattrop_flags_t optype, dict_t *xattr, dict_t *xdata) { STACK_WIND (frame, iot_fxattrop_cbk, FIRST_CHILD (this), - FIRST_CHILD (this)->fops->fxattrop, fd, optype, xattr); + FIRST_CHILD (this)->fops->fxattrop, fd, optype, xattr, xdata); return 0; } int iot_fxattrop (call_frame_t *frame, xlator_t *this, fd_t *fd, - gf_xattrop_flags_t optype, dict_t *xattr) + gf_xattrop_flags_t optype, dict_t *xattr, dict_t *xdata) { call_stub_t *stub = NULL; int ret = -1; stub = fop_fxattrop_stub (frame, iot_fxattrop_wrapper, fd, optype, - xattr); + xattr, xdata); if (!stub) { gf_log (this->name, GF_LOG_ERROR, "cannot create fxattrop stub" "(out of memory)"); @@ -2202,7 +2351,7 @@ iot_fxattrop (call_frame_t *frame, xlator_t *this, fd_t *fd, ret = iot_schedule (frame, this, stub); out: if (ret < 0) { - STACK_UNWIND_STRICT (fxattrop, frame, -1, -ret, NULL); + STACK_UNWIND_STRICT (fxattrop, frame, -1, -ret, NULL, NULL); if (stub != NULL) { call_stub_destroy (stub); } @@ -2214,33 +2363,33 @@ out: int32_t iot_rchecksum_cbk (call_frame_t *frame, void *cookie, xlator_t *this, int32_t op_ret, int32_t op_errno, uint32_t weak_checksum, - uint8_t *strong_checksum) + uint8_t *strong_checksum, dict_t *xdata) { STACK_UNWIND_STRICT (rchecksum, frame, op_ret, op_errno, weak_checksum, - strong_checksum); + strong_checksum, xdata); return 0; } int32_t iot_rchecksum_wrapper (call_frame_t *frame, xlator_t *this, fd_t *fd, - off_t offset, int32_t len) + off_t offset, int32_t len, dict_t *xdata) { STACK_WIND (frame, iot_rchecksum_cbk, FIRST_CHILD(this), - FIRST_CHILD(this)->fops->rchecksum, fd, offset, len); + FIRST_CHILD(this)->fops->rchecksum, fd, offset, len, xdata); return 0; } int32_t iot_rchecksum (call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset, - int32_t len) + int32_t len, dict_t *xdata) { call_stub_t *stub = NULL; int ret = -1; stub = fop_rchecksum_stub (frame, iot_rchecksum_wrapper, fd, offset, - len); + len, xdata); if (!stub) { gf_log (this->name, GF_LOG_ERROR, "cannot create rchecksum stub" "(out of memory)"); @@ -2251,7 +2400,7 @@ iot_rchecksum (call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset, ret = iot_schedule (frame, this, stub); out: if (ret < 0) { - STACK_UNWIND_STRICT (rchecksum, frame, -1, -ret, -1, NULL); + STACK_UNWIND_STRICT (rchecksum, frame, -1, -ret, -1, NULL, NULL); if (stub != NULL) { call_stub_destroy (stub); } @@ -2260,24 +2409,172 @@ out: return 0; } +int +iot_fallocate_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, + struct iatt *preop, struct iatt *postop, dict_t *xdata) +{ + STACK_UNWIND_STRICT (fallocate, frame, op_ret, op_errno, preop, postop, + xdata); + return 0; +} + + +int +iot_fallocate_wrapper(call_frame_t *frame, xlator_t *this, fd_t *fd, int32_t mode, + off_t offset, size_t len, dict_t *xdata) +{ + STACK_WIND (frame, iot_fallocate_cbk, FIRST_CHILD (this), + FIRST_CHILD (this)->fops->fallocate, fd, mode, offset, len, + xdata); + return 0; +} + + +int +iot_fallocate(call_frame_t *frame, xlator_t *this, fd_t *fd, int32_t mode, + off_t offset, size_t len, dict_t *xdata) +{ + call_stub_t *stub = NULL; + int ret = -1; + + stub = fop_fallocate_stub(frame, iot_fallocate_wrapper, fd, mode, offset, + len, xdata); + if (!stub) { + gf_log (this->name, GF_LOG_ERROR, "cannot create fallocate stub" + "(out of memory)"); + ret = -ENOMEM; + goto out; + } + + ret = iot_schedule (frame, this, stub); + +out: + if (ret < 0) { + STACK_UNWIND_STRICT (fallocate, frame, -1, -ret, NULL, NULL, + NULL); + if (stub != NULL) { + call_stub_destroy (stub); + } + } + return 0; +} + +int +iot_discard_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, + struct iatt *preop, struct iatt *postop, dict_t *xdata) +{ + STACK_UNWIND_STRICT (discard, frame, op_ret, op_errno, preop, postop, + xdata); + return 0; +} + + +int +iot_discard_wrapper(call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset, + size_t len, dict_t *xdata) +{ + STACK_WIND (frame, iot_discard_cbk, FIRST_CHILD (this), + FIRST_CHILD (this)->fops->discard, fd, offset, len, xdata); + return 0; +} + + +int +iot_discard(call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset, + size_t len, dict_t *xdata) +{ + call_stub_t *stub = NULL; + int ret = -1; + + stub = fop_discard_stub(frame, iot_discard_wrapper, fd, offset, len, + xdata); + if (!stub) { + gf_log (this->name, GF_LOG_ERROR, "cannot create discard stub" + "(out of memory)"); + ret = -ENOMEM; + goto out; + } + + ret = iot_schedule (frame, this, stub); + +out: + if (ret < 0) { + STACK_UNWIND_STRICT (discard, frame, -1, -ret, NULL, NULL, + NULL); + if (stub != NULL) { + call_stub_destroy (stub); + } + } + return 0; +} + +int +iot_zerofill_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, + struct iatt *preop, struct iatt *postop, dict_t *xdata) +{ + STACK_UNWIND_STRICT (zerofill, frame, op_ret, op_errno, preop, postop, + xdata); + return 0; +} + +int +iot_zerofill_wrapper(call_frame_t *frame, xlator_t *this, fd_t *fd, + off_t offset, size_t len, dict_t *xdata) +{ + STACK_WIND (frame, iot_zerofill_cbk, FIRST_CHILD (this), + FIRST_CHILD (this)->fops->zerofill, fd, offset, len, xdata); + return 0; +} + +int +iot_zerofill(call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset, + size_t len, dict_t *xdata) +{ + call_stub_t *stub = NULL; + int ret = -1; + + stub = fop_zerofill_stub(frame, iot_zerofill_wrapper, fd, + offset, len, xdata); + if (!stub) { + gf_log (this->name, GF_LOG_ERROR, "cannot create zerofill stub" + "(out of memory)"); + ret = -ENOMEM; + goto out; + } + + ret = iot_schedule (frame, this, stub); + +out: + if (ret < 0) { + STACK_UNWIND_STRICT (zerofill, frame, -1, -ret, NULL, NULL, + NULL); + if (stub != NULL) { + call_stub_destroy (stub); + } + } + return 0; +} + int __iot_workers_scale (iot_conf_t *conf) { - int log2 = 0; int scale = 0; int diff = 0; pthread_t thread; int ret = 0; + int i = 0; - log2 = log_base2 (conf->queue_size); - - scale = log2; + for (i = 0; i < IOT_PRI_MAX; i++) + scale += min (conf->queue_sizes[i], conf->ac_iot_limit[i]); - if (log2 < IOT_MIN_THREADS) + if (scale < IOT_MIN_THREADS) scale = IOT_MIN_THREADS; - if (log2 > conf->max_count) + if (scale > conf->max_count) scale = conf->max_count; if (conf->curr_count < scale) { @@ -2287,7 +2584,7 @@ __iot_workers_scale (iot_conf_t *conf) while (diff) { diff --; - ret = pthread_create (&thread, &conf->w_attr, iot_worker, conf); + ret = gf_thread_create (&thread, &conf->w_attr, iot_worker, conf); if (ret == 0) { conf->curr_count++; gf_log (conf->this->name, GF_LOG_DEBUG, @@ -2328,13 +2625,24 @@ set_stack_size (iot_conf_t *conf) { int err = 0; size_t stacksize = IOT_THREAD_STACK_SIZE; + xlator_t *this = NULL; + + this = THIS; pthread_attr_init (&conf->w_attr); err = pthread_attr_setstacksize (&conf->w_attr, stacksize); if (err == EINVAL) { - gf_log (conf->this->name, GF_LOG_WARNING, - "Using default thread stack size"); + err = pthread_attr_getstacksize (&conf->w_attr, &stacksize); + if (!err) + gf_log (this->name, GF_LOG_WARNING, + "Using default thread stack size %zd", + stacksize); + else + gf_log (this->name, GF_LOG_WARNING, + "Using default thread stack size"); } + + conf->stack_size = stacksize; } @@ -2357,6 +2665,44 @@ mem_acct_init (xlator_t *this) return ret; } +int +iot_priv_dump (xlator_t *this) +{ + iot_conf_t *conf = NULL; + char key_prefix[GF_DUMP_MAX_BUF_LEN]; + + if (!this) + return 0; + + conf = this->private; + if (!conf) + return 0; + + snprintf (key_prefix, GF_DUMP_MAX_BUF_LEN, "%s.%s", this->type, + this->name); + + gf_proc_dump_add_section(key_prefix); + + gf_proc_dump_write("maximum_threads_count", "%d", conf->max_count); + gf_proc_dump_write("current_threads_count", "%d", conf->curr_count); + gf_proc_dump_write("sleep_count", "%d", conf->sleep_count); + gf_proc_dump_write("idle_time", "%d", conf->idle_time); + gf_proc_dump_write("stack_size", "%zd", conf->stack_size); + gf_proc_dump_write("high_priority_threads", "%d", + conf->ac_iot_limit[IOT_PRI_HI]); + gf_proc_dump_write("normal_priority_threads", "%d", + conf->ac_iot_limit[IOT_PRI_NORMAL]); + gf_proc_dump_write("low_priority_threads", "%d", + conf->ac_iot_limit[IOT_PRI_LO]); + gf_proc_dump_write("least_priority_threads", "%d", + conf->ac_iot_limit[IOT_PRI_LEAST]); + + gf_proc_dump_write("cached least rate", "%u", + conf->throttle.cached_rate); + gf_proc_dump_write("least rate limit", "%u", conf->throttle.rate_limit); + + return 0; +} int reconfigure (xlator_t *this, dict_t *options) @@ -2383,6 +2729,11 @@ reconfigure (xlator_t *this, dict_t *options) GF_OPTION_RECONF ("least-prio-threads", conf->ac_iot_limit[IOT_PRI_LEAST], options, int32, out); + GF_OPTION_RECONF ("enable-least-priority", conf->least_priority, + options, bool, out); + + GF_OPTION_RECONF("least-rate-limit", conf->throttle.rate_limit, options, + int32, out); ret = 0; out: @@ -2393,9 +2744,9 @@ out: int init (xlator_t *this) { - iot_conf_t *conf = NULL; - int ret = -1; - int i = 0; + iot_conf_t *conf = NULL; + int ret = -1; + int i = 0; if (!this->children || this->children->next) { gf_log ("io-threads", GF_LOG_ERROR, @@ -2445,6 +2796,16 @@ init (xlator_t *this) conf->ac_iot_limit[IOT_PRI_LEAST], int32, out); GF_OPTION_INIT ("idle-time", conf->idle_time, int32, out); + GF_OPTION_INIT ("enable-least-priority", conf->least_priority, + bool, out); + + GF_OPTION_INIT("least-rate-limit", conf->throttle.rate_limit, int32, + out); + if ((ret = pthread_mutex_init(&conf->throttle.lock, NULL)) != 0) { + gf_log (this->name, GF_LOG_ERROR, + "pthread_mutex_init failed (%d)", ret); + goto out; + } conf->this = this; @@ -2457,13 +2818,15 @@ init (xlator_t *this) if (ret == -1) { gf_log (this->name, GF_LOG_ERROR, "cannot initialize worker threads, exiting init"); - GF_FREE (conf); goto out; } this->private = conf; ret = 0; out: + if (ret) + GF_FREE (conf); + return ret; } @@ -2479,6 +2842,9 @@ fini (xlator_t *this) return; } +struct xlator_dumpops dumpops = { + .priv = iot_priv_dump, +}; struct xlator_fops fops = { .open = iot_open, @@ -2512,6 +2878,7 @@ struct xlator_fops fops = { .fgetxattr = iot_fgetxattr, .fsetxattr = iot_fsetxattr, .removexattr = iot_removexattr, + .fremovexattr = iot_fremovexattr, .readdir = iot_readdir, .readdirp = iot_readdirp, .inodelk = iot_inodelk, @@ -2521,10 +2888,12 @@ struct xlator_fops fops = { .xattrop = iot_xattrop, .fxattrop = iot_fxattrop, .rchecksum = iot_rchecksum, + .fallocate = iot_fallocate, + .discard = iot_discard, + .zerofill = iot_zerofill, }; -struct xlator_cbks cbks = { -}; +struct xlator_cbks cbks; struct volume_options options[] = { { .key = {"thread-count"}, @@ -2571,12 +2940,25 @@ struct volume_options options[] = { .description = "Max number of threads in IO threads translator which " "perform least priority IO operations at a given time" }, + { .key = {"enable-least-priority"}, + .type = GF_OPTION_TYPE_BOOL, + .default_value = "on", + .description = "Enable/Disable least priority" + }, {.key = {"idle-time"}, .type = GF_OPTION_TYPE_INT, .min = 1, .max = 0x7fffffff, .default_value = "120", }, + {.key = {"least-rate-limit"}, + .type = GF_OPTION_TYPE_INT, + .min = 0, + .max = INT_MAX, + .default_value = "0", + .description = "Max number of least priority operations to handle " + "per-second" + }, { .key = {NULL}, }, }; |