diff options
Diffstat (limited to 'xlators/performance/md-cache/src/md-cache.c')
| -rw-r--r-- | xlators/performance/md-cache/src/md-cache.c | 5261 |
1 files changed, 2567 insertions, 2694 deletions
diff --git a/xlators/performance/md-cache/src/md-cache.c b/xlators/performance/md-cache/src/md-cache.c index 1e208b3638f..21cc9de081e 100644 --- a/xlators/performance/md-cache/src/md-cache.c +++ b/xlators/performance/md-cache/src/md-cache.c @@ -32,3835 +32,3708 @@ */ struct mdc_statfs_cache { - pthread_mutex_t lock; - gf_boolean_t initialized; - struct timespec last_refreshed; - struct statvfs buf; + pthread_mutex_t lock; + gf_boolean_t initialized; + struct timespec last_refreshed; + struct statvfs buf; }; struct mdc_statistics { - gf_atomic_t stat_hit; /* No. of times lookup/stat was served from - mdc */ + gf_atomic_t stat_hit; /* No. of times lookup/stat was served from + mdc */ - gf_atomic_t stat_miss; /* No. of times valid stat wasn't present in - mdc */ + gf_atomic_t stat_miss; /* No. of times valid stat wasn't present in + mdc */ - gf_atomic_t xattr_hit; /* No. of times getxattr was served from mdc, - Note: this doesn't count the xattr served - from lookup */ + gf_atomic_t xattr_hit; /* No. of times getxattr was served from mdc, + Note: this doesn't count the xattr served + from lookup */ - gf_atomic_t xattr_miss; /* No. of times xattr req was WIND from mdc */ - gf_atomic_t negative_lookup; /* No. of negative lookups */ - gf_atomic_t nameless_lookup; /* No. of negative lookups that were sent - to bricks */ + gf_atomic_t xattr_miss; /* No. of times xattr req was WIND from mdc */ + gf_atomic_t negative_lookup; /* No. of negative lookups */ + gf_atomic_t nameless_lookup; /* No. of negative lookups that were sent + to bricks */ - gf_atomic_t stat_invals; /* No. of invalidates received from upcall */ - gf_atomic_t xattr_invals; /* No. of invalidates received from upcall */ - gf_atomic_t need_lookup; /* No. of lookups issued, because other - xlators requested for explicit lookup */ + gf_atomic_t stat_invals; /* No. of invalidates received from upcall */ + gf_atomic_t xattr_invals; /* No. of invalidates received from upcall */ + gf_atomic_t need_lookup; /* No. of lookups issued, because other + xlators requested for explicit lookup */ }; - struct mdc_conf { - int timeout; - gf_boolean_t cache_posix_acl; - gf_boolean_t cache_selinux; - gf_boolean_t cache_capability; - gf_boolean_t cache_ima; - gf_boolean_t force_readdirp; - gf_boolean_t cache_swift_metadata; - gf_boolean_t cache_samba_metadata; - gf_boolean_t mdc_invalidation; - time_t last_child_down; - gf_lock_t lock; - struct mdc_statistics mdc_counter; - gf_boolean_t cache_statfs; - struct mdc_statfs_cache statfs_cache; - char *mdc_xattr_str; - gf_atomic_int32_t generation; + int timeout; + gf_boolean_t cache_posix_acl; + gf_boolean_t cache_selinux; + gf_boolean_t cache_capability; + gf_boolean_t cache_ima; + gf_boolean_t force_readdirp; + gf_boolean_t cache_swift_metadata; + gf_boolean_t cache_samba_metadata; + gf_boolean_t mdc_invalidation; + time_t last_child_down; + gf_lock_t lock; + struct mdc_statistics mdc_counter; + gf_boolean_t cache_statfs; + struct mdc_statfs_cache statfs_cache; + char *mdc_xattr_str; + gf_atomic_int32_t generation; }; - struct mdc_local; typedef struct mdc_local mdc_local_t; -#define MDC_STACK_UNWIND(fop, frame, params ...) do { \ - mdc_local_t *__local = NULL; \ - xlator_t *__xl = NULL; \ - if (frame) { \ - __xl = frame->this; \ - __local = frame->local; \ - frame->local = NULL; \ - } \ - STACK_UNWIND_STRICT (fop, frame, params); \ - mdc_local_wipe (__xl, __local); \ - } while (0) - +#define MDC_STACK_UNWIND(fop, frame, params...) \ + do { \ + mdc_local_t *__local = NULL; \ + xlator_t *__xl = NULL; \ + if (frame) { \ + __xl = frame->this; \ + __local = frame->local; \ + frame->local = NULL; \ + } \ + STACK_UNWIND_STRICT(fop, frame, params); \ + mdc_local_wipe(__xl, __local); \ + } while (0) struct md_cache { - ia_prot_t md_prot; - uint32_t md_nlink; - uint32_t md_uid; - uint32_t md_gid; - uint32_t md_atime; - uint32_t md_atime_nsec; - uint32_t md_mtime; - uint32_t md_mtime_nsec; - uint32_t md_ctime; - uint32_t md_ctime_nsec; - uint64_t md_rdev; - uint64_t md_size; - uint64_t md_blocks; - uint64_t invalidation_time; - uint64_t generation; - dict_t *xattr; - char *linkname; - time_t ia_time; - time_t xa_time; - gf_boolean_t need_lookup; - gf_boolean_t valid; - gf_boolean_t gen_rollover; - gf_boolean_t invalidation_rollover; - gf_lock_t lock; + ia_prot_t md_prot; + uint32_t md_nlink; + uint32_t md_uid; + uint32_t md_gid; + uint32_t md_atime; + uint32_t md_atime_nsec; + uint32_t md_mtime; + uint32_t md_mtime_nsec; + uint32_t md_ctime; + uint32_t md_ctime_nsec; + uint64_t md_rdev; + uint64_t md_size; + uint64_t md_blocks; + uint64_t invalidation_time; + uint64_t generation; + dict_t *xattr; + char *linkname; + time_t ia_time; + time_t xa_time; + gf_boolean_t need_lookup; + gf_boolean_t valid; + gf_boolean_t gen_rollover; + gf_boolean_t invalidation_rollover; + gf_lock_t lock; }; - struct mdc_local { - loc_t loc; - loc_t loc2; - fd_t *fd; - char *linkname; - char *key; - dict_t *xattr; - uint64_t incident_time; + loc_t loc; + loc_t loc2; + fd_t *fd; + char *linkname; + char *key; + dict_t *xattr; + uint64_t incident_time; }; - int -__mdc_inode_ctx_get (xlator_t *this, inode_t *inode, struct md_cache **mdc_p) +__mdc_inode_ctx_get(xlator_t *this, inode_t *inode, struct md_cache **mdc_p) { - int ret = 0; - struct md_cache *mdc = NULL; - uint64_t mdc_int = 0; + int ret = 0; + struct md_cache *mdc = NULL; + uint64_t mdc_int = 0; - ret = __inode_ctx_get (inode, this, &mdc_int); - mdc = (void *) (long) (mdc_int); - if (ret == 0 && mdc_p) - *mdc_p = mdc; + ret = __inode_ctx_get(inode, this, &mdc_int); + mdc = (void *)(long)(mdc_int); + if (ret == 0 && mdc_p) + *mdc_p = mdc; - return ret; + return ret; } - int -mdc_inode_ctx_get (xlator_t *this, inode_t *inode, struct md_cache **mdc_p) +mdc_inode_ctx_get(xlator_t *this, inode_t *inode, struct md_cache **mdc_p) { - int ret = -1; + int ret = -1; - if (!inode) - goto out; + if (!inode) + goto out; - LOCK(&inode->lock); - { - ret = __mdc_inode_ctx_get (this, inode, mdc_p); - } - UNLOCK(&inode->lock); + LOCK(&inode->lock); + { + ret = __mdc_inode_ctx_get(this, inode, mdc_p); + } + UNLOCK(&inode->lock); out: - return ret; + return ret; } uint64_t -__mdc_get_generation (xlator_t *this, struct md_cache *mdc) +__mdc_get_generation(xlator_t *this, struct md_cache *mdc) { - uint64_t gen = 0, rollover; - struct mdc_conf *conf = NULL; + uint64_t gen = 0, rollover; + struct mdc_conf *conf = NULL; - conf = this->private; + conf = this->private; - gen = GF_ATOMIC_INC (conf->generation); - if (gen == 0) { - mdc->gen_rollover = !mdc->gen_rollover; - gen = GF_ATOMIC_INC (conf->generation); - mdc->ia_time = 0; - mdc->generation = 0; - mdc->invalidation_time = gen - 1; - } + gen = GF_ATOMIC_INC(conf->generation); + if (gen == 0) { + mdc->gen_rollover = !mdc->gen_rollover; + gen = GF_ATOMIC_INC(conf->generation); + mdc->ia_time = 0; + mdc->generation = 0; + mdc->invalidation_time = gen - 1; + } - rollover = mdc->gen_rollover; - gen |= (rollover << 32); - return gen; + rollover = mdc->gen_rollover; + gen |= (rollover << 32); + return gen; } uint64_t -mdc_get_generation (xlator_t *this, inode_t *inode) +mdc_get_generation(xlator_t *this, inode_t *inode) { - struct mdc_conf *conf = NULL; - uint64_t gen = 0; - struct md_cache *mdc = NULL; + struct mdc_conf *conf = NULL; + uint64_t gen = 0; + struct md_cache *mdc = NULL; - conf = this->private; + conf = this->private; - mdc_inode_ctx_get (this, inode, &mdc); + mdc_inode_ctx_get(this, inode, &mdc); - if (mdc) { - LOCK (&mdc->lock); - { - gen = __mdc_get_generation (this, mdc); - } - UNLOCK (&mdc->lock); - } else { - gen = GF_ATOMIC_INC (conf->generation); - if (gen == 0) { - gen = GF_ATOMIC_INC (conf->generation); - } + if (mdc) { + LOCK(&mdc->lock); + { + gen = __mdc_get_generation(this, mdc); + } + UNLOCK(&mdc->lock); + } else { + gen = GF_ATOMIC_INC(conf->generation); + if (gen == 0) { + gen = GF_ATOMIC_INC(conf->generation); } + } - return gen; + return gen; } int -__mdc_inode_ctx_set (xlator_t *this, inode_t *inode, struct md_cache *mdc) +__mdc_inode_ctx_set(xlator_t *this, inode_t *inode, struct md_cache *mdc) { - int ret = 0; - uint64_t mdc_int = 0; + int ret = 0; + uint64_t mdc_int = 0; - mdc_int = (long) mdc; - ret = __inode_ctx_set (inode, this, &mdc_int); + mdc_int = (long)mdc; + ret = __inode_ctx_set(inode, this, &mdc_int); - return ret; + return ret; } - int -mdc_inode_ctx_set (xlator_t *this, inode_t *inode, struct md_cache *mdc) +mdc_inode_ctx_set(xlator_t *this, inode_t *inode, struct md_cache *mdc) { - int ret; + int ret; - LOCK(&inode->lock); - { - ret = __mdc_inode_ctx_set (this, inode, mdc); - } - UNLOCK(&inode->lock); + LOCK(&inode->lock); + { + ret = __mdc_inode_ctx_set(this, inode, mdc); + } + UNLOCK(&inode->lock); - return ret; + return ret; } - mdc_local_t * -mdc_local_get (call_frame_t *frame, inode_t *inode) +mdc_local_get(call_frame_t *frame, inode_t *inode) { - mdc_local_t *local = NULL; - - local = frame->local; - if (local) - goto out; + mdc_local_t *local = NULL; + local = frame->local; + if (local) + goto out; - local = GF_CALLOC (sizeof (*local), 1, gf_mdc_mt_mdc_local_t); - if (!local) - goto out; + local = GF_CALLOC(sizeof(*local), 1, gf_mdc_mt_mdc_local_t); + if (!local) + goto out; - local->incident_time = mdc_get_generation (frame->this, inode); - frame->local = local; + local->incident_time = mdc_get_generation(frame->this, inode); + frame->local = local; out: - return local; + return local; } - void -mdc_local_wipe (xlator_t *this, mdc_local_t *local) +mdc_local_wipe(xlator_t *this, mdc_local_t *local) { - if (!local) - return; + if (!local) + return; - loc_wipe (&local->loc); + loc_wipe(&local->loc); - loc_wipe (&local->loc2); + loc_wipe(&local->loc2); - if (local->fd) - fd_unref (local->fd); + if (local->fd) + fd_unref(local->fd); - GF_FREE (local->linkname); + GF_FREE(local->linkname); - GF_FREE (local->key); + GF_FREE(local->key); - if (local->xattr) - dict_unref (local->xattr); + if (local->xattr) + dict_unref(local->xattr); - GF_FREE (local); - return; + GF_FREE(local); + return; } - int -mdc_inode_wipe (xlator_t *this, inode_t *inode) +mdc_inode_wipe(xlator_t *this, inode_t *inode) { - int ret = 0; - uint64_t mdc_int = 0; - struct md_cache *mdc = NULL; + int ret = 0; + uint64_t mdc_int = 0; + struct md_cache *mdc = NULL; - ret = inode_ctx_del (inode, this, &mdc_int); - if (ret != 0) - goto out; + ret = inode_ctx_del(inode, this, &mdc_int); + if (ret != 0) + goto out; - mdc = (void *) (long) mdc_int; + mdc = (void *)(long)mdc_int; - if (mdc->xattr) - dict_unref (mdc->xattr); + if (mdc->xattr) + dict_unref(mdc->xattr); - GF_FREE (mdc->linkname); + GF_FREE(mdc->linkname); - GF_FREE (mdc); + GF_FREE(mdc); - ret = 0; + ret = 0; out: - return ret; + return ret; } - struct md_cache * -mdc_inode_prep (xlator_t *this, inode_t *inode) +mdc_inode_prep(xlator_t *this, inode_t *inode) { - int ret = 0; - struct md_cache *mdc = NULL; + int ret = 0; + struct md_cache *mdc = NULL; - LOCK (&inode->lock); - { - ret = __mdc_inode_ctx_get (this, inode, &mdc); - if (ret == 0) - goto unlock; - - mdc = GF_CALLOC (sizeof (*mdc), 1, gf_mdc_mt_md_cache_t); - if (!mdc) { - gf_msg (this->name, GF_LOG_ERROR, ENOMEM, - MD_CACHE_MSG_NO_MEMORY, "out of memory"); - goto unlock; - } - - LOCK_INIT (&mdc->lock); - - ret = __mdc_inode_ctx_set (this, inode, mdc); - if (ret) { - gf_msg (this->name, GF_LOG_ERROR, ENOMEM, - MD_CACHE_MSG_NO_MEMORY, "out of memory"); - GF_FREE (mdc); - mdc = NULL; - } + LOCK(&inode->lock); + { + ret = __mdc_inode_ctx_get(this, inode, &mdc); + if (ret == 0) + goto unlock; + + mdc = GF_CALLOC(sizeof(*mdc), 1, gf_mdc_mt_md_cache_t); + if (!mdc) { + gf_msg(this->name, GF_LOG_ERROR, ENOMEM, MD_CACHE_MSG_NO_MEMORY, + "out of memory"); + goto unlock; + } + + LOCK_INIT(&mdc->lock); + + ret = __mdc_inode_ctx_set(this, inode, mdc); + if (ret) { + gf_msg(this->name, GF_LOG_ERROR, ENOMEM, MD_CACHE_MSG_NO_MEMORY, + "out of memory"); + GF_FREE(mdc); + mdc = NULL; } + } unlock: - UNLOCK (&inode->lock); + UNLOCK(&inode->lock); - return mdc; + return mdc; } - /* Cache is valid if: * - It is not cached before any brick was down. Brick down case is handled by * invalidating all the cache when any brick went down. * - The cache time is not expired */ static gf_boolean_t -__is_cache_valid (xlator_t *this, time_t mdc_time) +__is_cache_valid(xlator_t *this, time_t mdc_time) { - time_t now = 0; - gf_boolean_t ret = _gf_true; - struct mdc_conf *conf = NULL; - int timeout = 0; - time_t last_child_down = 0; + time_t now = 0; + gf_boolean_t ret = _gf_true; + struct mdc_conf *conf = NULL; + int timeout = 0; + time_t last_child_down = 0; - conf = this->private; + conf = this->private; - /* conf->lock here is not taken deliberately, so that the multi - * threaded IO doesn't contend on a global lock. While updating - * the variable, the lock is taken, so that at least the writes are - * intact. The read of last_child_down may return junk, but that - * is for a very short period of time. - */ - last_child_down = conf->last_child_down; - timeout = conf->timeout; + /* conf->lock here is not taken deliberately, so that the multi + * threaded IO doesn't contend on a global lock. While updating + * the variable, the lock is taken, so that at least the writes are + * intact. The read of last_child_down may return junk, but that + * is for a very short period of time. + */ + last_child_down = conf->last_child_down; + timeout = conf->timeout; - time (&now); + time(&now); - if ((mdc_time == 0) || - ((last_child_down != 0) && (mdc_time < last_child_down))) { - ret = _gf_false; - goto out; - } + if ((mdc_time == 0) || + ((last_child_down != 0) && (mdc_time < last_child_down))) { + ret = _gf_false; + goto out; + } - if (now >= (mdc_time + timeout)) { - ret = _gf_false; - } + if (now >= (mdc_time + timeout)) { + ret = _gf_false; + } out: - return ret; + return ret; } - static gf_boolean_t -is_md_cache_iatt_valid (xlator_t *this, struct md_cache *mdc) +is_md_cache_iatt_valid(xlator_t *this, struct md_cache *mdc) { - gf_boolean_t ret = _gf_true; + gf_boolean_t ret = _gf_true; - LOCK (&mdc->lock); - { - if (mdc->valid == _gf_false) { - ret = mdc->valid; - } else { - ret = __is_cache_valid (this, mdc->ia_time); - if (ret == _gf_false) { - mdc->ia_time = 0; - mdc->invalidation_time - = __mdc_get_generation (this, mdc) - & 0xffffffff; - } - } + LOCK(&mdc->lock); + { + if (mdc->valid == _gf_false) { + ret = mdc->valid; + } else { + ret = __is_cache_valid(this, mdc->ia_time); + if (ret == _gf_false) { + mdc->ia_time = 0; + mdc->invalidation_time = __mdc_get_generation(this, mdc) & + 0xffffffff; + } } - UNLOCK (&mdc->lock); + } + UNLOCK(&mdc->lock); - return ret; + return ret; } - static gf_boolean_t -is_md_cache_xatt_valid (xlator_t *this, struct md_cache *mdc) +is_md_cache_xatt_valid(xlator_t *this, struct md_cache *mdc) { - gf_boolean_t ret = _gf_true; + gf_boolean_t ret = _gf_true; - LOCK (&mdc->lock); - { - ret = __is_cache_valid (this, mdc->xa_time); - if (ret == _gf_false) - mdc->xa_time = 0; - } - UNLOCK (&mdc->lock); + LOCK(&mdc->lock); + { + ret = __is_cache_valid(this, mdc->xa_time); + if (ret == _gf_false) + mdc->xa_time = 0; + } + UNLOCK(&mdc->lock); - return ret; + return ret; } - void -mdc_from_iatt (struct md_cache *mdc, struct iatt *iatt) -{ - mdc->md_prot = iatt->ia_prot; - mdc->md_nlink = iatt->ia_nlink; - mdc->md_uid = iatt->ia_uid; - mdc->md_gid = iatt->ia_gid; - mdc->md_atime = iatt->ia_atime; - mdc->md_atime_nsec = iatt->ia_atime_nsec; - mdc->md_mtime = iatt->ia_mtime; - mdc->md_mtime_nsec = iatt->ia_mtime_nsec; - mdc->md_ctime = iatt->ia_ctime; - mdc->md_ctime_nsec = iatt->ia_ctime_nsec; - mdc->md_rdev = iatt->ia_rdev; - mdc->md_size = iatt->ia_size; - mdc->md_blocks = iatt->ia_blocks; +mdc_from_iatt(struct md_cache *mdc, struct iatt *iatt) +{ + mdc->md_prot = iatt->ia_prot; + mdc->md_nlink = iatt->ia_nlink; + mdc->md_uid = iatt->ia_uid; + mdc->md_gid = iatt->ia_gid; + mdc->md_atime = iatt->ia_atime; + mdc->md_atime_nsec = iatt->ia_atime_nsec; + mdc->md_mtime = iatt->ia_mtime; + mdc->md_mtime_nsec = iatt->ia_mtime_nsec; + mdc->md_ctime = iatt->ia_ctime; + mdc->md_ctime_nsec = iatt->ia_ctime_nsec; + mdc->md_rdev = iatt->ia_rdev; + mdc->md_size = iatt->ia_size; + mdc->md_blocks = iatt->ia_blocks; } - void -mdc_to_iatt (struct md_cache *mdc, struct iatt *iatt) +mdc_to_iatt(struct md_cache *mdc, struct iatt *iatt) { - iatt->ia_prot = mdc->md_prot; - iatt->ia_nlink = mdc->md_nlink; - iatt->ia_uid = mdc->md_uid; - iatt->ia_gid = mdc->md_gid; - iatt->ia_atime = mdc->md_atime; - iatt->ia_atime_nsec = mdc->md_atime_nsec; - iatt->ia_mtime = mdc->md_mtime; - iatt->ia_mtime_nsec = mdc->md_mtime_nsec; - iatt->ia_ctime = mdc->md_ctime; - iatt->ia_ctime_nsec = mdc->md_ctime_nsec; - iatt->ia_rdev = mdc->md_rdev; - iatt->ia_size = mdc->md_size; - iatt->ia_blocks = mdc->md_blocks; + iatt->ia_prot = mdc->md_prot; + iatt->ia_nlink = mdc->md_nlink; + iatt->ia_uid = mdc->md_uid; + iatt->ia_gid = mdc->md_gid; + iatt->ia_atime = mdc->md_atime; + iatt->ia_atime_nsec = mdc->md_atime_nsec; + iatt->ia_mtime = mdc->md_mtime; + iatt->ia_mtime_nsec = mdc->md_mtime_nsec; + iatt->ia_ctime = mdc->md_ctime; + iatt->ia_ctime_nsec = mdc->md_ctime_nsec; + iatt->ia_rdev = mdc->md_rdev; + iatt->ia_size = mdc->md_size; + iatt->ia_blocks = mdc->md_blocks; } - int mdc_inode_iatt_set_validate(xlator_t *this, inode_t *inode, struct iatt *prebuf, - struct iatt *iatt, gf_boolean_t update_time, + struct iatt *iatt, gf_boolean_t update_time, uint64_t incident_time) { - int ret = 0; - struct md_cache *mdc = NULL; - uint32_t rollover = 0; - uint64_t gen = 0; - - mdc = mdc_inode_prep (this, inode); - if (!mdc) { - ret = -1; - goto out; - } - - rollover = incident_time >> 32; - incident_time = (incident_time & 0xffffffff); - - LOCK (&mdc->lock); - { - if (!iatt || !iatt->ia_ctime) { - gf_msg_callingfn ("md-cache", GF_LOG_TRACE, 0, 0, - "invalidating iatt(NULL)" - "(%s)", uuid_utoa (inode->gfid)); - mdc->ia_time = 0; - mdc->valid = 0; - - gen = __mdc_get_generation (this, mdc); - mdc->invalidation_time = (gen & 0xffffffff); - goto unlock; - } - - /* There could be a race in invalidation, where the - * invalidations in order A, B reaches md-cache in the order - * B, A. Hence, make sure the invalidation A is discarded if - * it comes after B. ctime of a file is always in ascending - * order unlike atime and mtime(which can be changed by user - * to any date), also ctime gets updates when atime/mtime - * changes, hence check for ctime only. - */ - if (mdc->md_ctime > iatt->ia_ctime) { - gf_msg_callingfn (this->name, GF_LOG_DEBUG, EINVAL, - MD_CACHE_MSG_DISCARD_UPDATE, - "discarding the iatt validate " - "request (%s)", - uuid_utoa (inode->gfid)); - ret = -1; - goto unlock; - - } - if ((mdc->md_ctime == iatt->ia_ctime) && - (mdc->md_ctime_nsec > iatt->ia_ctime_nsec)) { - gf_msg_callingfn (this->name, GF_LOG_DEBUG, EINVAL, - MD_CACHE_MSG_DISCARD_UPDATE, - "discarding the iatt validate " - "request(ctime_nsec) (%s)", - uuid_utoa (inode->gfid)); - ret = -1; - goto unlock; - } - - /* - * Invalidate the inode if the mtime or ctime has changed - * and the prebuf doesn't match the value we have cached. - * TODO: writev returns with a NULL iatt due to - * performance/write-behind, causing invalidation on writes. - */ - if (IA_ISREG(inode->ia_type) && - ((iatt->ia_mtime != mdc->md_mtime) || - (iatt->ia_mtime_nsec != mdc->md_mtime_nsec) || - (iatt->ia_ctime != mdc->md_ctime) || - (iatt->ia_ctime_nsec != mdc->md_ctime_nsec))) - if (!prebuf || (prebuf->ia_ctime != mdc->md_ctime) || - (prebuf->ia_ctime_nsec != mdc->md_ctime_nsec) || - (prebuf->ia_mtime != mdc->md_mtime) || - (prebuf->ia_mtime_nsec != mdc->md_mtime_nsec)) { - gf_msg_trace ("md-cache", 0, "prebuf doesn't " - "match the value we have cached," - " invalidate the inode(%s)", - uuid_utoa (inode->gfid)); - - inode_invalidate(inode); - } - - if ((mdc->gen_rollover == rollover) && - ((incident_time > mdc->generation) && - (mdc->valid || - (incident_time > mdc->invalidation_time)))) { - mdc_from_iatt (mdc, iatt); - mdc->generation = incident_time; - mdc->valid = _gf_true; - if (update_time) - time (&mdc->ia_time); - - gf_msg_callingfn ("md-cache", GF_LOG_TRACE, 0, - MD_CACHE_MSG_CACHE_UPDATE, - "Updated iatt(%s)" - " time:%lld generation=%lld", - uuid_utoa (iatt->ia_gfid), - (unsigned long long)mdc->ia_time, - (unsigned long long) mdc->generation); - } else { - gf_msg_callingfn ("md-cache", GF_LOG_TRACE, 0, 0, - "not updating cache (%s)" - "mdc-rollover=%u rollover=%u " - "mdc-generation=%llu " - "mdc-ia_time=%llu incident_time=%llu " - "mdc-invalidation-time=%llu", - uuid_utoa (iatt->ia_gfid), - mdc->gen_rollover, rollover, - (unsigned long long) mdc->generation, - (unsigned long long) mdc->ia_time, - (unsigned long long) incident_time, - (unsigned long long) mdc->invalidation_time); - } - } + int ret = 0; + struct md_cache *mdc = NULL; + uint32_t rollover = 0; + uint64_t gen = 0; + + mdc = mdc_inode_prep(this, inode); + if (!mdc) { + ret = -1; + goto out; + } + + rollover = incident_time >> 32; + incident_time = (incident_time & 0xffffffff); + + LOCK(&mdc->lock); + { + if (!iatt || !iatt->ia_ctime) { + gf_msg_callingfn("md-cache", GF_LOG_TRACE, 0, 0, + "invalidating iatt(NULL)" + "(%s)", + uuid_utoa(inode->gfid)); + mdc->ia_time = 0; + mdc->valid = 0; + + gen = __mdc_get_generation(this, mdc); + mdc->invalidation_time = (gen & 0xffffffff); + goto unlock; + } + + /* There could be a race in invalidation, where the + * invalidations in order A, B reaches md-cache in the order + * B, A. Hence, make sure the invalidation A is discarded if + * it comes after B. ctime of a file is always in ascending + * order unlike atime and mtime(which can be changed by user + * to any date), also ctime gets updates when atime/mtime + * changes, hence check for ctime only. + */ + if (mdc->md_ctime > iatt->ia_ctime) { + gf_msg_callingfn(this->name, GF_LOG_DEBUG, EINVAL, + MD_CACHE_MSG_DISCARD_UPDATE, + "discarding the iatt validate " + "request (%s)", + uuid_utoa(inode->gfid)); + ret = -1; + goto unlock; + } + if ((mdc->md_ctime == iatt->ia_ctime) && + (mdc->md_ctime_nsec > iatt->ia_ctime_nsec)) { + gf_msg_callingfn(this->name, GF_LOG_DEBUG, EINVAL, + MD_CACHE_MSG_DISCARD_UPDATE, + "discarding the iatt validate " + "request(ctime_nsec) (%s)", + uuid_utoa(inode->gfid)); + ret = -1; + goto unlock; + } + + /* + * Invalidate the inode if the mtime or ctime has changed + * and the prebuf doesn't match the value we have cached. + * TODO: writev returns with a NULL iatt due to + * performance/write-behind, causing invalidation on writes. + */ + if (IA_ISREG(inode->ia_type) && + ((iatt->ia_mtime != mdc->md_mtime) || + (iatt->ia_mtime_nsec != mdc->md_mtime_nsec) || + (iatt->ia_ctime != mdc->md_ctime) || + (iatt->ia_ctime_nsec != mdc->md_ctime_nsec))) + if (!prebuf || (prebuf->ia_ctime != mdc->md_ctime) || + (prebuf->ia_ctime_nsec != mdc->md_ctime_nsec) || + (prebuf->ia_mtime != mdc->md_mtime) || + (prebuf->ia_mtime_nsec != mdc->md_mtime_nsec)) { + gf_msg_trace("md-cache", 0, + "prebuf doesn't " + "match the value we have cached," + " invalidate the inode(%s)", + uuid_utoa(inode->gfid)); + + inode_invalidate(inode); + } + + if ((mdc->gen_rollover == rollover) && + ((incident_time > mdc->generation) && + (mdc->valid || (incident_time > mdc->invalidation_time)))) { + mdc_from_iatt(mdc, iatt); + mdc->generation = incident_time; + mdc->valid = _gf_true; + if (update_time) + time(&mdc->ia_time); + + gf_msg_callingfn( + "md-cache", GF_LOG_TRACE, 0, MD_CACHE_MSG_CACHE_UPDATE, + "Updated iatt(%s)" + " time:%lld generation=%lld", + uuid_utoa(iatt->ia_gfid), (unsigned long long)mdc->ia_time, + (unsigned long long)mdc->generation); + } else { + gf_msg_callingfn("md-cache", GF_LOG_TRACE, 0, 0, + "not updating cache (%s)" + "mdc-rollover=%u rollover=%u " + "mdc-generation=%llu " + "mdc-ia_time=%llu incident_time=%llu " + "mdc-invalidation-time=%llu", + uuid_utoa(iatt->ia_gfid), mdc->gen_rollover, + rollover, (unsigned long long)mdc->generation, + (unsigned long long)mdc->ia_time, + (unsigned long long)incident_time, + (unsigned long long)mdc->invalidation_time); + } + } unlock: - UNLOCK (&mdc->lock); + UNLOCK(&mdc->lock); out: - return ret; + return ret; } -int mdc_inode_iatt_set(xlator_t *this, inode_t *inode, struct iatt *iatt, - uint64_t incident_time) +int +mdc_inode_iatt_set(xlator_t *this, inode_t *inode, struct iatt *iatt, + uint64_t incident_time) { - return mdc_inode_iatt_set_validate(this, inode, NULL, iatt, _gf_true, - incident_time); + return mdc_inode_iatt_set_validate(this, inode, NULL, iatt, _gf_true, + incident_time); } int -mdc_inode_iatt_get (xlator_t *this, inode_t *inode, struct iatt *iatt) +mdc_inode_iatt_get(xlator_t *this, inode_t *inode, struct iatt *iatt) { - int ret = -1; - struct md_cache *mdc = NULL; + int ret = -1; + struct md_cache *mdc = NULL; - if (mdc_inode_ctx_get (this, inode, &mdc) != 0) { - gf_msg_trace ("md-cache", 0, "mdc_inode_ctx_get failed (%s)", - uuid_utoa (inode->gfid)); - goto out; - } + if (mdc_inode_ctx_get(this, inode, &mdc) != 0) { + gf_msg_trace("md-cache", 0, "mdc_inode_ctx_get failed (%s)", + uuid_utoa(inode->gfid)); + goto out; + } - if (!is_md_cache_iatt_valid (this, mdc)) { - gf_msg_trace ("md-cache", 0, "iatt cache not valid for (%s)", - uuid_utoa (inode->gfid)); - goto out; - } + if (!is_md_cache_iatt_valid(this, mdc)) { + gf_msg_trace("md-cache", 0, "iatt cache not valid for (%s)", + uuid_utoa(inode->gfid)); + goto out; + } - LOCK (&mdc->lock); - { - mdc_to_iatt (mdc, iatt); - } - UNLOCK (&mdc->lock); + LOCK(&mdc->lock); + { + mdc_to_iatt(mdc, iatt); + } + UNLOCK(&mdc->lock); - gf_uuid_copy (iatt->ia_gfid, inode->gfid); - iatt->ia_ino = gfid_to_ino (inode->gfid); - iatt->ia_dev = 42; - iatt->ia_type = inode->ia_type; + gf_uuid_copy(iatt->ia_gfid, inode->gfid); + iatt->ia_ino = gfid_to_ino(inode->gfid); + iatt->ia_dev = 42; + iatt->ia_type = inode->ia_type; - ret = 0; + ret = 0; out: - return ret; + return ret; } struct updatedict { - dict_t *dict; - int ret; + dict_t *dict; + int ret; }; static int -is_mdc_key_satisfied (xlator_t *this, const char *key) -{ - int ret = 0; - char *pattern = NULL; - struct mdc_conf *conf = this->private; - char *mdc_xattr_str = NULL; - char *tmp = NULL; - char *tmp1 = NULL; - - if (!key) - goto out; - - /* conf->mdc_xattr_str, is never freed and is hence safely used outside - * of lock*/ - tmp1 = conf->mdc_xattr_str; - if (!tmp1) - goto out; - - mdc_xattr_str = gf_strdup (tmp1); - if (!mdc_xattr_str) - goto out; - - pattern = strtok_r (mdc_xattr_str, ",", &tmp); - while (pattern) { - gf_strTrim (&pattern); - if (fnmatch (pattern, key, 0) == 0) { - ret = 1; - break; - } else { - gf_msg_trace ("md-cache", 0, "xattr key %s doesn't satisfy " - "caching requirements", key); - } - pattern = strtok_r (NULL, ",", &tmp); - } - GF_FREE (mdc_xattr_str); +is_mdc_key_satisfied(xlator_t *this, const char *key) +{ + int ret = 0; + char *pattern = NULL; + struct mdc_conf *conf = this->private; + char *mdc_xattr_str = NULL; + char *tmp = NULL; + char *tmp1 = NULL; + + if (!key) + goto out; + + /* conf->mdc_xattr_str, is never freed and is hence safely used outside + * of lock*/ + tmp1 = conf->mdc_xattr_str; + if (!tmp1) + goto out; + + mdc_xattr_str = gf_strdup(tmp1); + if (!mdc_xattr_str) + goto out; + + pattern = strtok_r(mdc_xattr_str, ",", &tmp); + while (pattern) { + gf_strTrim(&pattern); + if (fnmatch(pattern, key, 0) == 0) { + ret = 1; + break; + } else { + gf_msg_trace("md-cache", 0, + "xattr key %s doesn't satisfy " + "caching requirements", + key); + } + pattern = strtok_r(NULL, ",", &tmp); + } + GF_FREE(mdc_xattr_str); out: - return ret; + return ret; } static int updatefn(dict_t *dict, char *key, data_t *value, void *data) { - struct updatedict *u = data; - - if (is_mdc_key_satisfied (THIS, key)) { - if (!u->dict) { - u->dict = dict_new(); - if (!u->dict) { - u->ret = -1; - return -1; - } - } - - /* posix xlator as part of listxattr will send both names - * and values of the xattrs in the dict. But as per man page - * listxattr is mainly supposed to send names of the all the - * xattrs. gfapi, as of now will put all the keys it obtained - * in the dict (sent by posix) into a buffer provided by the - * caller (thus the values of those xattrs are lost). If some - * xlator makes gfapi based calls (ex: snapview-server), then - * it has to unwind the calls by putting those names it got - * in the buffer again into the dict. But now it would not be - * having the values for those xattrs. So it might just put - * a 0 byte value ("") into the dict for each xattr and unwind - * the call. So the xlators which cache the xattrs (as of now - * md-cache caches the acl and selinux related xattrs), should - * not update their cache if the value of a xattr is a 0 byte - * data (i.e. ""). - */ - if (value->len == 1 && value->data[0] == '\0') - return 0; - - if (dict_set(u->dict, key, value) < 0) { - u->ret = -1; - return -1; - } - } - return 0; + struct updatedict *u = data; + + if (is_mdc_key_satisfied(THIS, key)) { + if (!u->dict) { + u->dict = dict_new(); + if (!u->dict) { + u->ret = -1; + return -1; + } + } + + /* posix xlator as part of listxattr will send both names + * and values of the xattrs in the dict. But as per man page + * listxattr is mainly supposed to send names of the all the + * xattrs. gfapi, as of now will put all the keys it obtained + * in the dict (sent by posix) into a buffer provided by the + * caller (thus the values of those xattrs are lost). If some + * xlator makes gfapi based calls (ex: snapview-server), then + * it has to unwind the calls by putting those names it got + * in the buffer again into the dict. But now it would not be + * having the values for those xattrs. So it might just put + * a 0 byte value ("") into the dict for each xattr and unwind + * the call. So the xlators which cache the xattrs (as of now + * md-cache caches the acl and selinux related xattrs), should + * not update their cache if the value of a xattr is a 0 byte + * data (i.e. ""). + */ + if (value->len == 1 && value->data[0] == '\0') + return 0; + + if (dict_set(u->dict, key, value) < 0) { + u->ret = -1; + return -1; + } + } + return 0; } static int mdc_dict_update(dict_t **tgt, dict_t *src) { - struct updatedict u = { - .dict = *tgt, - .ret = 0, - }; + struct updatedict u = { + .dict = *tgt, + .ret = 0, + }; - dict_foreach(src, updatefn, &u); + dict_foreach(src, updatefn, &u); - if (*tgt) - return u.ret; + if (*tgt) + return u.ret; - if ((u.ret < 0) && u.dict) { - dict_unref(u.dict); - return u.ret; - } + if ((u.ret < 0) && u.dict) { + dict_unref(u.dict); + return u.ret; + } - *tgt = u.dict; + *tgt = u.dict; - return u.ret; + return u.ret; } int -mdc_inode_xatt_set (xlator_t *this, inode_t *inode, dict_t *dict) +mdc_inode_xatt_set(xlator_t *this, inode_t *inode, dict_t *dict) { - int ret = -1; - struct md_cache *mdc = NULL; - dict_t *newdict = NULL; + int ret = -1; + struct md_cache *mdc = NULL; + dict_t *newdict = NULL; - mdc = mdc_inode_prep (this, inode); - if (!mdc) - goto out; + mdc = mdc_inode_prep(this, inode); + if (!mdc) + goto out; - if (!dict) { - gf_msg_trace ("md-cache", 0, "mdc_inode_xatt_set failed (%s) " - "dict NULL", uuid_utoa (inode->gfid)); - goto out; - } + if (!dict) { + gf_msg_trace("md-cache", 0, + "mdc_inode_xatt_set failed (%s) " + "dict NULL", + uuid_utoa(inode->gfid)); + goto out; + } - LOCK (&mdc->lock); - { - if (mdc->xattr) { - gf_msg_trace ("md-cache", 0, "deleting the old xattr " - "cache (%s)", uuid_utoa (inode->gfid)); - dict_unref (mdc->xattr); - mdc->xattr = NULL; - } - - ret = mdc_dict_update(&newdict, dict); - if (ret < 0) { - UNLOCK(&mdc->lock); - goto out; - } - - if (newdict) - mdc->xattr = newdict; - - time (&mdc->xa_time); - gf_msg_trace ("md-cache", 0, "xatt cache set for (%s) time:%lld", - uuid_utoa (inode->gfid), (long long)mdc->xa_time); + LOCK(&mdc->lock); + { + if (mdc->xattr) { + gf_msg_trace("md-cache", 0, + "deleting the old xattr " + "cache (%s)", + uuid_utoa(inode->gfid)); + dict_unref(mdc->xattr); + mdc->xattr = NULL; + } + ret = mdc_dict_update(&newdict, dict); + if (ret < 0) { + UNLOCK(&mdc->lock); + goto out; } - UNLOCK (&mdc->lock); - ret = 0; + + if (newdict) + mdc->xattr = newdict; + + time(&mdc->xa_time); + gf_msg_trace("md-cache", 0, "xatt cache set for (%s) time:%lld", + uuid_utoa(inode->gfid), (long long)mdc->xa_time); + } + UNLOCK(&mdc->lock); + ret = 0; out: - return ret; + return ret; } - int -mdc_inode_xatt_update (xlator_t *this, inode_t *inode, dict_t *dict) +mdc_inode_xatt_update(xlator_t *this, inode_t *inode, dict_t *dict) { - int ret = -1; - struct md_cache *mdc = NULL; + int ret = -1; + struct md_cache *mdc = NULL; - mdc = mdc_inode_prep (this, inode); - if (!mdc) - goto out; + mdc = mdc_inode_prep(this, inode); + if (!mdc) + goto out; - if (!dict) - goto out; + if (!dict) + goto out; - LOCK (&mdc->lock); - { - ret = mdc_dict_update(&mdc->xattr, dict); - if (ret < 0) { - UNLOCK(&mdc->lock); - goto out; - } + LOCK(&mdc->lock); + { + ret = mdc_dict_update(&mdc->xattr, dict); + if (ret < 0) { + UNLOCK(&mdc->lock); + goto out; } - UNLOCK (&mdc->lock); + } + UNLOCK(&mdc->lock); - ret = 0; + ret = 0; out: - return ret; + return ret; } - int -mdc_inode_xatt_unset (xlator_t *this, inode_t *inode, char *name) +mdc_inode_xatt_unset(xlator_t *this, inode_t *inode, char *name) { - int ret = -1; - struct md_cache *mdc = NULL; + int ret = -1; + struct md_cache *mdc = NULL; - mdc = mdc_inode_prep (this, inode); - if (!mdc) - goto out; + mdc = mdc_inode_prep(this, inode); + if (!mdc) + goto out; - if (!name || !mdc->xattr) - goto out; + if (!name || !mdc->xattr) + goto out; - LOCK (&mdc->lock); - { - dict_del (mdc->xattr, name); - } - UNLOCK (&mdc->lock); + LOCK(&mdc->lock); + { + dict_del(mdc->xattr, name); + } + UNLOCK(&mdc->lock); - ret = 0; + ret = 0; out: - return ret; + return ret; } - int -mdc_inode_xatt_get (xlator_t *this, inode_t *inode, dict_t **dict) +mdc_inode_xatt_get(xlator_t *this, inode_t *inode, dict_t **dict) { - int ret = -1; - struct md_cache *mdc = NULL; + int ret = -1; + struct md_cache *mdc = NULL; - if (mdc_inode_ctx_get (this, inode, &mdc) != 0) { - gf_msg_trace ("md-cache", 0, "mdc_inode_ctx_get failed (%s)", - uuid_utoa (inode->gfid)); - goto out; - } + if (mdc_inode_ctx_get(this, inode, &mdc) != 0) { + gf_msg_trace("md-cache", 0, "mdc_inode_ctx_get failed (%s)", + uuid_utoa(inode->gfid)); + goto out; + } - if (!is_md_cache_xatt_valid (this, mdc)) { - gf_msg_trace ("md-cache", 0, "xattr cache not valid for (%s)", - uuid_utoa (inode->gfid)); - goto out; - } + if (!is_md_cache_xatt_valid(this, mdc)) { + gf_msg_trace("md-cache", 0, "xattr cache not valid for (%s)", + uuid_utoa(inode->gfid)); + goto out; + } - LOCK (&mdc->lock); - { - ret = 0; - /* Missing xattr only means no keys were there, i.e - a negative cache for the "loaded" keys - */ - if (!mdc->xattr) { - gf_msg_trace ("md-cache", 0, "xattr not present (%s)", - uuid_utoa (inode->gfid)); - goto unlock; - } - - if (dict) - *dict = dict_ref (mdc->xattr); - } + LOCK(&mdc->lock); + { + ret = 0; + /* Missing xattr only means no keys were there, i.e + a negative cache for the "loaded" keys + */ + if (!mdc->xattr) { + gf_msg_trace("md-cache", 0, "xattr not present (%s)", + uuid_utoa(inode->gfid)); + goto unlock; + } + + if (dict) + *dict = dict_ref(mdc->xattr); + } unlock: - UNLOCK (&mdc->lock); + UNLOCK(&mdc->lock); out: - return ret; + return ret; } gf_boolean_t -mdc_inode_reset_need_lookup (xlator_t *this, inode_t *inode) +mdc_inode_reset_need_lookup(xlator_t *this, inode_t *inode) { - struct md_cache *mdc = NULL; - gf_boolean_t need = _gf_false; + struct md_cache *mdc = NULL; + gf_boolean_t need = _gf_false; - if (mdc_inode_ctx_get (this, inode, &mdc) != 0) - goto out; + if (mdc_inode_ctx_get(this, inode, &mdc) != 0) + goto out; - LOCK (&mdc->lock); - { - need = mdc->need_lookup; - mdc->need_lookup = _gf_false; - } - UNLOCK (&mdc->lock); + LOCK(&mdc->lock); + { + need = mdc->need_lookup; + mdc->need_lookup = _gf_false; + } + UNLOCK(&mdc->lock); out: - return need; + return need; } void -mdc_inode_set_need_lookup (xlator_t *this, inode_t *inode, gf_boolean_t need) +mdc_inode_set_need_lookup(xlator_t *this, inode_t *inode, gf_boolean_t need) { - struct md_cache *mdc = NULL; + struct md_cache *mdc = NULL; - if (mdc_inode_ctx_get (this, inode, &mdc) != 0) - goto out; + if (mdc_inode_ctx_get(this, inode, &mdc) != 0) + goto out; - LOCK (&mdc->lock); - { - mdc->need_lookup = need; - } - UNLOCK (&mdc->lock); + LOCK(&mdc->lock); + { + mdc->need_lookup = need; + } + UNLOCK(&mdc->lock); out: - return; + return; } void -mdc_inode_iatt_invalidate (xlator_t *this, inode_t *inode) +mdc_inode_iatt_invalidate(xlator_t *this, inode_t *inode) { - struct md_cache *mdc = NULL; - uint32_t gen = 0; + struct md_cache *mdc = NULL; + uint32_t gen = 0; - if (mdc_inode_ctx_get (this, inode, &mdc) != 0) - goto out; + if (mdc_inode_ctx_get(this, inode, &mdc) != 0) + goto out; - gen = mdc_get_generation (this, inode) & 0xffffffff; + gen = mdc_get_generation(this, inode) & 0xffffffff; - LOCK (&mdc->lock); - { - mdc->ia_time = 0; - mdc->valid = _gf_false; - mdc->invalidation_time = gen; - } - UNLOCK (&mdc->lock); + LOCK(&mdc->lock); + { + mdc->ia_time = 0; + mdc->valid = _gf_false; + mdc->invalidation_time = gen; + } + UNLOCK(&mdc->lock); out: - return; + return; } - int -mdc_inode_xatt_invalidate (xlator_t *this, inode_t *inode) +mdc_inode_xatt_invalidate(xlator_t *this, inode_t *inode) { - int ret = -1; - struct md_cache *mdc = NULL; + int ret = -1; + struct md_cache *mdc = NULL; - if (mdc_inode_ctx_get (this, inode, &mdc) != 0) - goto out; + if (mdc_inode_ctx_get(this, inode, &mdc) != 0) + goto out; - LOCK (&mdc->lock); - { - mdc->xa_time = 0; - } - UNLOCK (&mdc->lock); + LOCK(&mdc->lock); + { + mdc->xa_time = 0; + } + UNLOCK(&mdc->lock); out: - return ret; + return ret; } - static int -mdc_update_gfid_stat (xlator_t *this, struct iatt *iatt) -{ - int ret = 0; - inode_table_t *itable = NULL; - inode_t *inode = NULL; - - itable = ((xlator_t *)this->graph->top)->itable; - inode = inode_find (itable, iatt->ia_gfid); - if (!inode) { - ret = -1; - goto out; - } - ret = mdc_inode_iatt_set_validate (this, inode, NULL, - iatt, _gf_true, - mdc_get_generation (this, inode)); +mdc_update_gfid_stat(xlator_t *this, struct iatt *iatt) +{ + int ret = 0; + inode_table_t *itable = NULL; + inode_t *inode = NULL; + + itable = ((xlator_t *)this->graph->top)->itable; + inode = inode_find(itable, iatt->ia_gfid); + if (!inode) { + ret = -1; + goto out; + } + ret = mdc_inode_iatt_set_validate(this, inode, NULL, iatt, _gf_true, + mdc_get_generation(this, inode)); out: - return ret; + return ret; } - void -mdc_load_reqs (xlator_t *this, dict_t *dict) -{ - struct mdc_conf *conf = this->private; - char *pattern = NULL; - char *mdc_xattr_str = NULL; - char *tmp = NULL; - char *tmp1 = NULL; - int ret = 0; - - tmp1 = conf->mdc_xattr_str; - if (!tmp1) - goto out; - - mdc_xattr_str = gf_strdup (tmp1); - if (!mdc_xattr_str) - goto out; - - pattern = strtok_r (mdc_xattr_str, ",", &tmp); - while (pattern) { - gf_strTrim (&pattern); - ret = dict_set_int8 (dict, pattern, 0); - if (ret) { - conf->mdc_xattr_str = NULL; - gf_msg ("md-cache", GF_LOG_ERROR, 0, - MD_CACHE_MSG_NO_XATTR_CACHE, - "Disabled cache for xattrs, dict_set failed"); - } - pattern = strtok_r (NULL, ",", &tmp); - } - - GF_FREE (mdc_xattr_str); +mdc_load_reqs(xlator_t *this, dict_t *dict) +{ + struct mdc_conf *conf = this->private; + char *pattern = NULL; + char *mdc_xattr_str = NULL; + char *tmp = NULL; + char *tmp1 = NULL; + int ret = 0; + + tmp1 = conf->mdc_xattr_str; + if (!tmp1) + goto out; + + mdc_xattr_str = gf_strdup(tmp1); + if (!mdc_xattr_str) + goto out; + + pattern = strtok_r(mdc_xattr_str, ",", &tmp); + while (pattern) { + gf_strTrim(&pattern); + ret = dict_set_int8(dict, pattern, 0); + if (ret) { + conf->mdc_xattr_str = NULL; + gf_msg("md-cache", GF_LOG_ERROR, 0, MD_CACHE_MSG_NO_XATTR_CACHE, + "Disabled cache for xattrs, dict_set failed"); + } + pattern = strtok_r(NULL, ",", &tmp); + } + + GF_FREE(mdc_xattr_str); out: - return; + return; } struct checkpair { - int ret; - dict_t *rsp; + int ret; + dict_t *rsp; }; - - static int -checkfn (dict_t *this, char *key, data_t *value, void *data) +checkfn(dict_t *this, char *key, data_t *value, void *data) { - struct checkpair *pair = data; + struct checkpair *pair = data; - if (!is_mdc_key_satisfied (THIS, key)) - pair->ret = 0; + if (!is_mdc_key_satisfied(THIS, key)) + pair->ret = 0; - return 0; + return 0; } - int -mdc_xattr_satisfied (xlator_t *this, dict_t *req, dict_t *rsp) +mdc_xattr_satisfied(xlator_t *this, dict_t *req, dict_t *rsp) { - struct checkpair pair = { - .ret = 1, - .rsp = rsp, - }; + struct checkpair pair = { + .ret = 1, + .rsp = rsp, + }; - dict_foreach (req, checkfn, &pair); + dict_foreach(req, checkfn, &pair); - return pair.ret; + return pair.ret; } static void -mdc_cache_statfs (xlator_t *this, struct statvfs *buf) +mdc_cache_statfs(xlator_t *this, struct statvfs *buf) { - struct mdc_conf *conf = this->private; + struct mdc_conf *conf = this->private; - pthread_mutex_lock (&conf->statfs_cache.lock); - { - memcpy (&conf->statfs_cache.buf, buf, sizeof (struct statvfs)); - clock_gettime (CLOCK_MONOTONIC, - &conf->statfs_cache.last_refreshed); - conf->statfs_cache.initialized = _gf_true; - } - pthread_mutex_unlock (&conf->statfs_cache.lock); + pthread_mutex_lock(&conf->statfs_cache.lock); + { + memcpy(&conf->statfs_cache.buf, buf, sizeof(struct statvfs)); + clock_gettime(CLOCK_MONOTONIC, &conf->statfs_cache.last_refreshed); + conf->statfs_cache.initialized = _gf_true; + } + pthread_mutex_unlock(&conf->statfs_cache.lock); } int -mdc_load_statfs_info_from_cache (xlator_t *this, struct statvfs **buf) +mdc_load_statfs_info_from_cache(xlator_t *this, struct statvfs **buf) { - struct mdc_conf *conf = this->private; - struct timespec now; - double cache_age = 0.0; - int ret = 0; + struct mdc_conf *conf = this->private; + struct timespec now; + double cache_age = 0.0; + int ret = 0; + + if (!buf || !conf) { + ret = -1; + goto err; + } - if (!buf || !conf) { - ret = -1; - goto err; + pthread_mutex_lock(&conf->statfs_cache.lock); + { + *buf = NULL; + + /* Skip if the cache is not initialized */ + if (!conf->statfs_cache.initialized) { + ret = -1; + goto unlock; } - pthread_mutex_lock (&conf->statfs_cache.lock); - { - *buf = NULL; - - /* Skip if the cache is not initialized */ - if (!conf->statfs_cache.initialized) { - ret = -1; - goto unlock; - } - - timespec_now (&now); - - cache_age = ( - now.tv_sec - conf->statfs_cache.last_refreshed.tv_sec); - - gf_log (this->name, GF_LOG_DEBUG, - "STATFS cache age = %lf", cache_age); - if (cache_age > conf->timeout) { - /* Expire the cache */ - gf_log (this->name, GF_LOG_DEBUG, - "Cache age %lf exceeded timeout %d", - cache_age, conf->timeout); - ret = -1; - goto unlock; - } - - *buf = &conf->statfs_cache.buf; + timespec_now(&now); + + cache_age = (now.tv_sec - conf->statfs_cache.last_refreshed.tv_sec); + + gf_log(this->name, GF_LOG_DEBUG, "STATFS cache age = %lf", cache_age); + if (cache_age > conf->timeout) { + /* Expire the cache */ + gf_log(this->name, GF_LOG_DEBUG, + "Cache age %lf exceeded timeout %d", cache_age, + conf->timeout); + ret = -1; + goto unlock; } + + *buf = &conf->statfs_cache.buf; + } unlock: - pthread_mutex_unlock (&conf->statfs_cache.lock); + pthread_mutex_unlock(&conf->statfs_cache.lock); err: - return ret; + return ret; } int -mdc_statfs_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, - struct statvfs *buf, dict_t *xdata) +mdc_statfs_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, struct statvfs *buf, + dict_t *xdata) { - struct mdc_conf *conf = this->private; - mdc_local_t *local = NULL; + struct mdc_conf *conf = this->private; + mdc_local_t *local = NULL; - local = frame->local; - if (!local) - goto out; + local = frame->local; + if (!local) + goto out; - if (op_ret != 0) { - if ((op_errno == ENOENT) || (op_errno == ESTALE)) { - mdc_inode_iatt_invalidate (this, local->loc.inode); - } - - goto out; + if (op_ret != 0) { + if ((op_errno == ENOENT) || (op_errno == ESTALE)) { + mdc_inode_iatt_invalidate(this, local->loc.inode); } - if (conf && conf->cache_statfs) { - mdc_cache_statfs (this, buf); - } + goto out; + } + + if (conf && conf->cache_statfs) { + mdc_cache_statfs(this, buf); + } out: - MDC_STACK_UNWIND (statfs, frame, op_ret, op_errno, buf, xdata); + MDC_STACK_UNWIND(statfs, frame, op_ret, op_errno, buf, xdata); - return 0; + return 0; } int -mdc_statfs (call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *xdata) +mdc_statfs(call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *xdata) { - int ret = 0, op_ret = 0, op_errno = 0; - struct statvfs *buf = NULL; - mdc_local_t *local = NULL; - struct mdc_conf *conf = this->private; + int ret = 0, op_ret = 0, op_errno = 0; + struct statvfs *buf = NULL; + mdc_local_t *local = NULL; + struct mdc_conf *conf = this->private; - local = mdc_local_get (frame, loc->inode); - if (!local) { - op_ret = -1; - op_errno = ENOMEM; - goto out; - } + local = mdc_local_get(frame, loc->inode); + if (!local) { + op_ret = -1; + op_errno = ENOMEM; + goto out; + } - loc_copy (&local->loc, loc); + loc_copy(&local->loc, loc); - if (!conf) { - goto uncached; - } + if (!conf) { + goto uncached; + } - if (!conf->cache_statfs) { - goto uncached; - } + if (!conf->cache_statfs) { + goto uncached; + } - ret = mdc_load_statfs_info_from_cache (this, &buf); - if (ret == 0 && buf) { - op_ret = 0; - op_errno = 0; - goto out; - } + ret = mdc_load_statfs_info_from_cache(this, &buf); + if (ret == 0 && buf) { + op_ret = 0; + op_errno = 0; + goto out; + } uncached: - STACK_WIND (frame, mdc_statfs_cbk, FIRST_CHILD (this), - FIRST_CHILD (this)->fops->statfs, loc, xdata); - return 0; + STACK_WIND(frame, mdc_statfs_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->statfs, loc, xdata); + return 0; out: - STACK_UNWIND_STRICT (statfs, frame, op_ret, op_errno, buf, xdata); - return 0; + STACK_UNWIND_STRICT(statfs, frame, op_ret, op_errno, buf, xdata); + return 0; } int -mdc_lookup_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, inode_t *inode, - struct iatt *stbuf, dict_t *dict, struct iatt *postparent) +mdc_lookup_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, inode_t *inode, + struct iatt *stbuf, dict_t *dict, struct iatt *postparent) { - mdc_local_t *local = NULL; - struct mdc_conf *conf = this->private; + mdc_local_t *local = NULL; + struct mdc_conf *conf = this->private; - local = frame->local; + local = frame->local; - if (op_ret != 0) { - if (op_errno == ENOENT) - GF_ATOMIC_INC (conf->mdc_counter.negative_lookup); + if (op_ret != 0) { + if (op_errno == ENOENT) + GF_ATOMIC_INC(conf->mdc_counter.negative_lookup); - if (op_errno == ESTALE) { - /* if op_errno is ENOENT, fuse-bridge will unlink the - * dentry - */ - if (local->loc.parent) - mdc_inode_iatt_invalidate (this, - local->loc.parent); - else - mdc_inode_iatt_invalidate (this, - local->loc.inode); - } - - goto out; + if (op_errno == ESTALE) { + /* if op_errno is ENOENT, fuse-bridge will unlink the + * dentry + */ + if (local->loc.parent) + mdc_inode_iatt_invalidate(this, local->loc.parent); + else + mdc_inode_iatt_invalidate(this, local->loc.inode); } - if (!local) - goto out; - - if (local->loc.parent) { - mdc_inode_iatt_set (this, local->loc.parent, postparent, - local->incident_time); - } + goto out; + } - if (local->loc.inode) { - mdc_inode_iatt_set (this, local->loc.inode, stbuf, - local->incident_time); - mdc_inode_xatt_set (this, local->loc.inode, dict); - } -out: - MDC_STACK_UNWIND (lookup, frame, op_ret, op_errno, inode, stbuf, - dict, postparent); - return 0; -} + if (!local) + goto out; + if (local->loc.parent) { + mdc_inode_iatt_set(this, local->loc.parent, postparent, + local->incident_time); + } -int -mdc_lookup (call_frame_t *frame, xlator_t *this, loc_t *loc, - dict_t *xdata) -{ - int ret = 0; - struct iatt stbuf = {0, }; - struct iatt postparent = {0, }; - dict_t *xattr_rsp = NULL; - dict_t *xattr_alloc = NULL; - mdc_local_t *local = NULL; - struct mdc_conf *conf = this->private; - - local = mdc_local_get (frame, loc->inode); - if (!local) { - GF_ATOMIC_INC (conf->mdc_counter.stat_miss); - goto uncached; - } - - loc_copy (&local->loc, loc); - - if (!inode_is_linked(loc->inode)) { - GF_ATOMIC_INC (conf->mdc_counter.stat_miss); - goto uncached; - } - - if (mdc_inode_reset_need_lookup (this, loc->inode)) { - GF_ATOMIC_INC (conf->mdc_counter.need_lookup); - goto uncached; - } - - ret = mdc_inode_iatt_get (this, loc->inode, &stbuf); + if (local->loc.inode) { + mdc_inode_iatt_set(this, local->loc.inode, stbuf, local->incident_time); + mdc_inode_xatt_set(this, local->loc.inode, dict); + } +out: + MDC_STACK_UNWIND(lookup, frame, op_ret, op_errno, inode, stbuf, dict, + postparent); + return 0; +} + +int +mdc_lookup(call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *xdata) +{ + int ret = 0; + struct iatt stbuf = { + 0, + }; + struct iatt postparent = { + 0, + }; + dict_t *xattr_rsp = NULL; + dict_t *xattr_alloc = NULL; + mdc_local_t *local = NULL; + struct mdc_conf *conf = this->private; + + local = mdc_local_get(frame, loc->inode); + if (!local) { + GF_ATOMIC_INC(conf->mdc_counter.stat_miss); + goto uncached; + } + + loc_copy(&local->loc, loc); + + if (!inode_is_linked(loc->inode)) { + GF_ATOMIC_INC(conf->mdc_counter.stat_miss); + goto uncached; + } + + if (mdc_inode_reset_need_lookup(this, loc->inode)) { + GF_ATOMIC_INC(conf->mdc_counter.need_lookup); + goto uncached; + } + + ret = mdc_inode_iatt_get(this, loc->inode, &stbuf); + if (ret != 0) { + GF_ATOMIC_INC(conf->mdc_counter.stat_miss); + goto uncached; + } + + if (xdata) { + ret = mdc_inode_xatt_get(this, loc->inode, &xattr_rsp); if (ret != 0) { - GF_ATOMIC_INC (conf->mdc_counter.stat_miss); - goto uncached; + GF_ATOMIC_INC(conf->mdc_counter.xattr_miss); + goto uncached; } - if (xdata) { - ret = mdc_inode_xatt_get (this, loc->inode, &xattr_rsp); - if (ret != 0) { - GF_ATOMIC_INC (conf->mdc_counter.xattr_miss); - goto uncached; - } - - if (!mdc_xattr_satisfied (this, xdata, xattr_rsp)) { - GF_ATOMIC_INC (conf->mdc_counter.xattr_miss); - goto uncached; - } + if (!mdc_xattr_satisfied(this, xdata, xattr_rsp)) { + GF_ATOMIC_INC(conf->mdc_counter.xattr_miss); + goto uncached; } + } - GF_ATOMIC_INC (conf->mdc_counter.stat_hit); - MDC_STACK_UNWIND (lookup, frame, 0, 0, loc->inode, &stbuf, - xattr_rsp, &postparent); + GF_ATOMIC_INC(conf->mdc_counter.stat_hit); + MDC_STACK_UNWIND(lookup, frame, 0, 0, loc->inode, &stbuf, xattr_rsp, + &postparent); - if (xattr_rsp) - dict_unref (xattr_rsp); + if (xattr_rsp) + dict_unref(xattr_rsp); - return 0; + return 0; uncached: - if (!xdata) - xdata = xattr_alloc = dict_new (); - if (xdata) - mdc_load_reqs (this, xdata); - - STACK_WIND (frame, mdc_lookup_cbk, FIRST_CHILD (this), - FIRST_CHILD (this)->fops->lookup, loc, xdata); - - if (xattr_rsp) - dict_unref (xattr_rsp); - if (xattr_alloc) - dict_unref (xattr_alloc); - return 0; -} + if (!xdata) + xdata = xattr_alloc = dict_new(); + if (xdata) + mdc_load_reqs(this, xdata); + STACK_WIND(frame, mdc_lookup_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->lookup, loc, xdata); + + if (xattr_rsp) + dict_unref(xattr_rsp); + if (xattr_alloc) + dict_unref(xattr_alloc); + return 0; +} int -mdc_stat_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, struct iatt *buf, dict_t *xdata) +mdc_stat_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int32_t op_ret, + int32_t op_errno, struct iatt *buf, dict_t *xdata) { - mdc_local_t *local = NULL; - - local = frame->local; - if (!local) - goto out; + mdc_local_t *local = NULL; - if (op_ret != 0) { - if ((op_errno == ESTALE) || (op_errno == ENOENT)) { - mdc_inode_iatt_invalidate (this, local->loc.inode); - } + local = frame->local; + if (!local) + goto out; - goto out; + if (op_ret != 0) { + if ((op_errno == ESTALE) || (op_errno == ENOENT)) { + mdc_inode_iatt_invalidate(this, local->loc.inode); } - mdc_inode_iatt_set (this, local->loc.inode, buf, - local->incident_time); + goto out; + } + + mdc_inode_iatt_set(this, local->loc.inode, buf, local->incident_time); out: - MDC_STACK_UNWIND (stat, frame, op_ret, op_errno, buf, xdata); + MDC_STACK_UNWIND(stat, frame, op_ret, op_errno, buf, xdata); - return 0; + return 0; } - int -mdc_stat (call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *xdata) +mdc_stat(call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *xdata) { - int ret; - struct iatt stbuf; - mdc_local_t *local = NULL; - struct mdc_conf *conf = this->private; + int ret; + struct iatt stbuf; + mdc_local_t *local = NULL; + struct mdc_conf *conf = this->private; - local = mdc_local_get (frame, loc->inode); - if (!local) - goto uncached; + local = mdc_local_get(frame, loc->inode); + if (!local) + goto uncached; - loc_copy (&local->loc, loc); + loc_copy(&local->loc, loc); - if (!inode_is_linked(loc->inode)) { - GF_ATOMIC_INC (conf->mdc_counter.stat_miss); - goto uncached; - } + if (!inode_is_linked(loc->inode)) { + GF_ATOMIC_INC(conf->mdc_counter.stat_miss); + goto uncached; + } - ret = mdc_inode_iatt_get (this, loc->inode, &stbuf); - if (ret != 0) - goto uncached; + ret = mdc_inode_iatt_get(this, loc->inode, &stbuf); + if (ret != 0) + goto uncached; - GF_ATOMIC_INC (conf->mdc_counter.stat_hit); - MDC_STACK_UNWIND (stat, frame, 0, 0, &stbuf, xdata); + GF_ATOMIC_INC(conf->mdc_counter.stat_hit); + MDC_STACK_UNWIND(stat, frame, 0, 0, &stbuf, xdata); - return 0; + return 0; uncached: - GF_ATOMIC_INC (conf->mdc_counter.stat_miss); - STACK_WIND (frame, mdc_stat_cbk, - FIRST_CHILD(this), FIRST_CHILD(this)->fops->stat, - loc, xdata); - return 0; + GF_ATOMIC_INC(conf->mdc_counter.stat_miss); + STACK_WIND(frame, mdc_stat_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->stat, loc, xdata); + return 0; } - int -mdc_fstat_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, struct iatt *buf, - dict_t *xdata) +mdc_fstat_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int32_t op_ret, + int32_t op_errno, struct iatt *buf, dict_t *xdata) { - mdc_local_t *local = NULL; + mdc_local_t *local = NULL; - local = frame->local; - if (!local) - goto out; + local = frame->local; + if (!local) + goto out; - if (op_ret != 0) { - if ((op_errno == ENOENT) || (op_errno == ESTALE)) { - mdc_inode_iatt_invalidate (this, local->fd->inode); - } - - goto out; + if (op_ret != 0) { + if ((op_errno == ENOENT) || (op_errno == ESTALE)) { + mdc_inode_iatt_invalidate(this, local->fd->inode); } - mdc_inode_iatt_set (this, local->fd->inode, buf, local->incident_time); + goto out; + } + + mdc_inode_iatt_set(this, local->fd->inode, buf, local->incident_time); out: - MDC_STACK_UNWIND (fstat, frame, op_ret, op_errno, buf, xdata); + MDC_STACK_UNWIND(fstat, frame, op_ret, op_errno, buf, xdata); - return 0; + return 0; } - int -mdc_fstat (call_frame_t *frame, xlator_t *this, fd_t *fd, dict_t *xdata) +mdc_fstat(call_frame_t *frame, xlator_t *this, fd_t *fd, dict_t *xdata) { - int ret; - struct iatt stbuf; - mdc_local_t *local = NULL; - struct mdc_conf *conf = this->private; + int ret; + struct iatt stbuf; + mdc_local_t *local = NULL; + struct mdc_conf *conf = this->private; - local = mdc_local_get (frame, fd->inode); - if (!local) - goto uncached; + local = mdc_local_get(frame, fd->inode); + if (!local) + goto uncached; - local->fd = fd_ref (fd); + local->fd = fd_ref(fd); - ret = mdc_inode_iatt_get (this, fd->inode, &stbuf); - if (ret != 0) - goto uncached; + ret = mdc_inode_iatt_get(this, fd->inode, &stbuf); + if (ret != 0) + goto uncached; - GF_ATOMIC_INC (conf->mdc_counter.stat_hit); - MDC_STACK_UNWIND (fstat, frame, 0, 0, &stbuf, xdata); + GF_ATOMIC_INC(conf->mdc_counter.stat_hit); + MDC_STACK_UNWIND(fstat, frame, 0, 0, &stbuf, xdata); - return 0; + return 0; uncached: - GF_ATOMIC_INC (conf->mdc_counter.stat_miss); - STACK_WIND (frame, mdc_fstat_cbk, - FIRST_CHILD(this), FIRST_CHILD(this)->fops->fstat, - fd, xdata); - return 0; + GF_ATOMIC_INC(conf->mdc_counter.stat_miss); + STACK_WIND(frame, mdc_fstat_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->fstat, fd, xdata); + return 0; } - int -mdc_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, dict_t *xdata) +mdc_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, dict_t *xdata) { - mdc_local_t *local = NULL; + mdc_local_t *local = NULL; - local = frame->local; + local = frame->local; - if (!local) - goto out; + if (!local) + goto out; - if (op_ret != 0) { - if ((op_errno == ESTALE) || (op_errno == ENOENT)) - mdc_inode_iatt_invalidate (this, local->loc.inode); + if (op_ret != 0) { + if ((op_errno == ESTALE) || (op_errno == ENOENT)) + mdc_inode_iatt_invalidate(this, local->loc.inode); - goto out; - } + goto out; + } - mdc_inode_iatt_set_validate(this, local->loc.inode, prebuf, postbuf, - _gf_true, local->incident_time); + mdc_inode_iatt_set_validate(this, local->loc.inode, prebuf, postbuf, + _gf_true, local->incident_time); out: - MDC_STACK_UNWIND (truncate, frame, op_ret, op_errno, prebuf, postbuf, - xdata); + MDC_STACK_UNWIND(truncate, frame, op_ret, op_errno, prebuf, postbuf, xdata); - return 0; + return 0; } - int -mdc_truncate (call_frame_t *frame, xlator_t *this, loc_t *loc, - off_t offset, dict_t *xdata) +mdc_truncate(call_frame_t *frame, xlator_t *this, loc_t *loc, off_t offset, + dict_t *xdata) { - mdc_local_t *local = NULL; + mdc_local_t *local = NULL; - local = mdc_local_get (frame, loc->inode); + local = mdc_local_get(frame, loc->inode); - local->loc.inode = inode_ref (loc->inode); + local->loc.inode = inode_ref(loc->inode); - STACK_WIND (frame, mdc_truncate_cbk, - FIRST_CHILD(this), FIRST_CHILD(this)->fops->truncate, - loc, offset, xdata); - return 0; + STACK_WIND(frame, mdc_truncate_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->truncate, loc, offset, xdata); + return 0; } - int -mdc_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, dict_t *xdata) +mdc_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, dict_t *xdata) { - mdc_local_t *local = NULL; + mdc_local_t *local = NULL; - local = frame->local; + local = frame->local; - if (!local) - goto out; + if (!local) + goto out; - if (op_ret != 0) { - if ((op_errno == ENOENT) || (op_errno == ESTALE)) - mdc_inode_iatt_invalidate (this, local->fd->inode); + if (op_ret != 0) { + if ((op_errno == ENOENT) || (op_errno == ESTALE)) + mdc_inode_iatt_invalidate(this, local->fd->inode); - goto out; - } + goto out; + } - mdc_inode_iatt_set_validate(this, local->fd->inode, prebuf, postbuf, - _gf_true, local->incident_time); + mdc_inode_iatt_set_validate(this, local->fd->inode, prebuf, postbuf, + _gf_true, local->incident_time); out: - MDC_STACK_UNWIND (ftruncate, frame, op_ret, op_errno, prebuf, postbuf, - xdata); + MDC_STACK_UNWIND(ftruncate, frame, op_ret, op_errno, prebuf, postbuf, + xdata); - return 0; + return 0; } - int -mdc_ftruncate (call_frame_t *frame, xlator_t *this, fd_t *fd, - off_t offset, dict_t *xdata) +mdc_ftruncate(call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset, + dict_t *xdata) { - mdc_local_t *local = NULL; + mdc_local_t *local = NULL; - local = mdc_local_get (frame, fd->inode); + local = mdc_local_get(frame, fd->inode); - local->fd = fd_ref (fd); + local->fd = fd_ref(fd); - STACK_WIND (frame, mdc_ftruncate_cbk, - FIRST_CHILD(this), FIRST_CHILD(this)->fops->ftruncate, - fd, offset, xdata); - return 0; + STACK_WIND(frame, mdc_ftruncate_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->ftruncate, fd, offset, xdata); + return 0; } - int -mdc_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, dict_t *xdata) +mdc_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, dict_t *xdata) { - mdc_local_t *local = NULL; - - local = frame->local; + mdc_local_t *local = NULL; - if (!local) - goto out; + local = frame->local; - if (op_ret != 0) { - if ((op_errno == ESTALE) || (op_errno == ENOENT)) { - mdc_inode_iatt_invalidate (this, local->loc.parent); - } + if (!local) + goto out; - goto out; + if (op_ret != 0) { + if ((op_errno == ESTALE) || (op_errno == ENOENT)) { + mdc_inode_iatt_invalidate(this, local->loc.parent); } - if (local->loc.parent) { - mdc_inode_iatt_set (this, local->loc.parent, postparent, - local->incident_time); - } + goto out; + } - if (local->loc.inode) { - mdc_inode_iatt_set (this, local->loc.inode, buf, - local->incident_time); - mdc_inode_xatt_set (this, local->loc.inode, local->xattr); - } + if (local->loc.parent) { + mdc_inode_iatt_set(this, local->loc.parent, postparent, + local->incident_time); + } + + if (local->loc.inode) { + mdc_inode_iatt_set(this, local->loc.inode, buf, local->incident_time); + mdc_inode_xatt_set(this, local->loc.inode, local->xattr); + } out: - MDC_STACK_UNWIND (mknod, frame, op_ret, op_errno, inode, buf, - preparent, postparent, xdata); - return 0; + MDC_STACK_UNWIND(mknod, frame, op_ret, op_errno, inode, buf, preparent, + postparent, xdata); + return 0; } - int -mdc_mknod (call_frame_t *frame, xlator_t *this, loc_t *loc, - mode_t mode, dev_t rdev, mode_t umask, dict_t *xdata) +mdc_mknod(call_frame_t *frame, xlator_t *this, loc_t *loc, mode_t mode, + dev_t rdev, mode_t umask, dict_t *xdata) { - mdc_local_t *local = NULL; + mdc_local_t *local = NULL; - local = mdc_local_get (frame, loc->inode); + local = mdc_local_get(frame, loc->inode); - loc_copy (&local->loc, loc); - local->xattr = dict_ref (xdata); + loc_copy(&local->loc, loc); + local->xattr = dict_ref(xdata); - STACK_WIND (frame, mdc_mknod_cbk, - FIRST_CHILD(this), FIRST_CHILD(this)->fops->mknod, - loc, mode, rdev, umask, xdata); - return 0; + STACK_WIND(frame, mdc_mknod_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->mknod, loc, mode, rdev, umask, xdata); + return 0; } - int -mdc_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, dict_t *xdata) +mdc_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, dict_t *xdata) { - mdc_local_t *local = NULL; - - local = frame->local; + mdc_local_t *local = NULL; - if (!local) - goto out; + local = frame->local; - if (op_ret != 0) { - if ((op_errno == ESTALE) || (op_errno == ENOENT)) { - mdc_inode_iatt_invalidate (this, local->loc.parent); - } + if (!local) + goto out; - goto out; + if (op_ret != 0) { + if ((op_errno == ESTALE) || (op_errno == ENOENT)) { + mdc_inode_iatt_invalidate(this, local->loc.parent); } - if (local->loc.parent) { - mdc_inode_iatt_set (this, local->loc.parent, postparent, - local->incident_time); - } + goto out; + } - if (local->loc.inode) { - mdc_inode_iatt_set (this, local->loc.inode, buf, - local->incident_time); - mdc_inode_xatt_set (this, local->loc.inode, local->xattr); - } + if (local->loc.parent) { + mdc_inode_iatt_set(this, local->loc.parent, postparent, + local->incident_time); + } + + if (local->loc.inode) { + mdc_inode_iatt_set(this, local->loc.inode, buf, local->incident_time); + mdc_inode_xatt_set(this, local->loc.inode, local->xattr); + } out: - MDC_STACK_UNWIND (mkdir, frame, op_ret, op_errno, inode, buf, - preparent, postparent, xdata); - return 0; + MDC_STACK_UNWIND(mkdir, frame, op_ret, op_errno, inode, buf, preparent, + postparent, xdata); + return 0; } - int -mdc_mkdir (call_frame_t *frame, xlator_t *this, loc_t *loc, - mode_t mode, mode_t umask, dict_t *xdata) +mdc_mkdir(call_frame_t *frame, xlator_t *this, loc_t *loc, mode_t mode, + mode_t umask, dict_t *xdata) { - mdc_local_t *local = NULL; + mdc_local_t *local = NULL; - local = mdc_local_get (frame, loc->inode); + local = mdc_local_get(frame, loc->inode); - loc_copy (&local->loc, loc); - local->xattr = dict_ref (xdata); + loc_copy(&local->loc, loc); + local->xattr = dict_ref(xdata); - STACK_WIND (frame, mdc_mkdir_cbk, - FIRST_CHILD(this), FIRST_CHILD(this)->fops->mkdir, - loc, mode, umask, xdata); - return 0; + STACK_WIND(frame, mdc_mkdir_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->mkdir, loc, mode, umask, xdata); + return 0; } - int -mdc_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, dict_t *xdata) +mdc_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, dict_t *xdata) { - mdc_local_t *local = NULL; + mdc_local_t *local = NULL; - local = frame->local; + local = frame->local; - if (!local) - goto out; + if (!local) + goto out; - if (op_ret != 0) { - /* if errno is ESTALE, parent is not present, which implies even - * child is not present. Also, man 2 unlink states unlink can - * return ENOENT if a component in pathname does not - * exist or is a dangling symbolic link. So, invalidate both - * parent and child for both errno - */ - - if ((op_errno == ENOENT) || (op_errno == ESTALE)) { - mdc_inode_iatt_invalidate (this, local->loc.inode); - mdc_inode_iatt_invalidate (this, local->loc.parent); - } + if (op_ret != 0) { + /* if errno is ESTALE, parent is not present, which implies even + * child is not present. Also, man 2 unlink states unlink can + * return ENOENT if a component in pathname does not + * exist or is a dangling symbolic link. So, invalidate both + * parent and child for both errno + */ - goto out; + if ((op_errno == ENOENT) || (op_errno == ESTALE)) { + mdc_inode_iatt_invalidate(this, local->loc.inode); + mdc_inode_iatt_invalidate(this, local->loc.parent); } - if (local->loc.parent) { - mdc_inode_iatt_set (this, local->loc.parent, postparent, - local->incident_time); - } + goto out; + } - if (local->loc.inode) { - mdc_inode_iatt_set (this, local->loc.inode, NULL, - local->incident_time); - } + if (local->loc.parent) { + mdc_inode_iatt_set(this, local->loc.parent, postparent, + local->incident_time); + } + + if (local->loc.inode) { + mdc_inode_iatt_set(this, local->loc.inode, NULL, local->incident_time); + } out: - MDC_STACK_UNWIND (unlink, frame, op_ret, op_errno, - preparent, postparent, xdata); - return 0; + MDC_STACK_UNWIND(unlink, frame, op_ret, op_errno, preparent, postparent, + xdata); + return 0; } - int -mdc_unlink (call_frame_t *frame, xlator_t *this, loc_t *loc, int32_t xflag, - dict_t *xdata) +mdc_unlink(call_frame_t *frame, xlator_t *this, loc_t *loc, int32_t xflag, + dict_t *xdata) { - mdc_local_t *local = NULL; + mdc_local_t *local = NULL; - local = mdc_local_get (frame, loc->inode); + local = mdc_local_get(frame, loc->inode); - loc_copy (&local->loc, loc); + loc_copy(&local->loc, loc); - STACK_WIND (frame, mdc_unlink_cbk, - FIRST_CHILD(this), FIRST_CHILD(this)->fops->unlink, - loc, xflag, xdata); - return 0; + STACK_WIND(frame, mdc_unlink_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->unlink, loc, xflag, xdata); + return 0; } - int -mdc_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, dict_t *xdata) +mdc_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, + dict_t *xdata) { - mdc_local_t *local = NULL; - - local = frame->local; + mdc_local_t *local = NULL; - if (!local) - goto out; + local = frame->local; - if (op_ret != 0) { - /* if errno is ESTALE, parent is not present, which implies even - * child is not present. Also, man 2 rmdir states rmdir can - * return ENOENT if a directory component in pathname does not - * exist or is a dangling symbolic link. So, invalidate both - * parent and child for both errno - */ + if (!local) + goto out; - if ((op_errno == ESTALE) || (op_errno == ENOENT)) { - mdc_inode_iatt_invalidate (this, local->loc.inode); - mdc_inode_iatt_invalidate (this, local->loc.parent); - } + if (op_ret != 0) { + /* if errno is ESTALE, parent is not present, which implies even + * child is not present. Also, man 2 rmdir states rmdir can + * return ENOENT if a directory component in pathname does not + * exist or is a dangling symbolic link. So, invalidate both + * parent and child for both errno + */ - goto out; + if ((op_errno == ESTALE) || (op_errno == ENOENT)) { + mdc_inode_iatt_invalidate(this, local->loc.inode); + mdc_inode_iatt_invalidate(this, local->loc.parent); } - if (local->loc.parent) { - mdc_inode_iatt_set (this, local->loc.parent, postparent, - local->incident_time); - } + goto out; + } + + if (local->loc.parent) { + mdc_inode_iatt_set(this, local->loc.parent, postparent, + local->incident_time); + } out: - MDC_STACK_UNWIND (rmdir, frame, op_ret, op_errno, - preparent, postparent, xdata); - return 0; + MDC_STACK_UNWIND(rmdir, frame, op_ret, op_errno, preparent, postparent, + xdata); + return 0; } - int -mdc_rmdir (call_frame_t *frame, xlator_t *this, loc_t *loc, int flag, - dict_t *xdata) +mdc_rmdir(call_frame_t *frame, xlator_t *this, loc_t *loc, int flag, + dict_t *xdata) { - mdc_local_t *local = NULL; + mdc_local_t *local = NULL; - local = mdc_local_get (frame, loc->inode); + local = mdc_local_get(frame, loc->inode); - loc_copy (&local->loc, loc); + loc_copy(&local->loc, loc); - STACK_WIND (frame, mdc_rmdir_cbk, - FIRST_CHILD(this), FIRST_CHILD(this)->fops->rmdir, - loc, flag, xdata); - return 0; + STACK_WIND(frame, mdc_rmdir_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->rmdir, loc, flag, xdata); + return 0; } - int -mdc_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, dict_t *xdata) +mdc_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, dict_t *xdata) { - mdc_local_t *local = NULL; - - local = frame->local; + mdc_local_t *local = NULL; - if (!local) - goto out; + local = frame->local; - if (op_ret != 0) { - if ((op_errno == ESTALE) || (op_errno == ENOENT)) { - mdc_inode_iatt_invalidate (this, local->loc.parent); - } + if (!local) + goto out; - goto out; + if (op_ret != 0) { + if ((op_errno == ESTALE) || (op_errno == ENOENT)) { + mdc_inode_iatt_invalidate(this, local->loc.parent); } - if (local->loc.parent) { - mdc_inode_iatt_set (this, local->loc.parent, postparent, - local->incident_time); - } + goto out; + } - if (local->loc.inode) { - mdc_inode_iatt_set (this, local->loc.inode, buf, - local->incident_time); - } + if (local->loc.parent) { + mdc_inode_iatt_set(this, local->loc.parent, postparent, + local->incident_time); + } + + if (local->loc.inode) { + mdc_inode_iatt_set(this, local->loc.inode, buf, local->incident_time); + } out: - MDC_STACK_UNWIND (symlink, frame, op_ret, op_errno, inode, buf, - preparent, postparent, xdata); - return 0; + MDC_STACK_UNWIND(symlink, frame, op_ret, op_errno, inode, buf, preparent, + postparent, xdata); + return 0; } - int -mdc_symlink (call_frame_t *frame, xlator_t *this, const char *linkname, - loc_t *loc, mode_t umask, dict_t *xdata) +mdc_symlink(call_frame_t *frame, xlator_t *this, const char *linkname, + loc_t *loc, mode_t umask, dict_t *xdata) { - mdc_local_t *local = NULL; + mdc_local_t *local = NULL; - local = mdc_local_get (frame, loc->inode); + local = mdc_local_get(frame, loc->inode); - loc_copy (&local->loc, loc); + loc_copy(&local->loc, loc); - local->linkname = gf_strdup (linkname); + local->linkname = gf_strdup(linkname); - STACK_WIND (frame, mdc_symlink_cbk, - FIRST_CHILD(this), FIRST_CHILD(this)->fops->symlink, - linkname, loc, umask, xdata); - return 0; + STACK_WIND(frame, mdc_symlink_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->symlink, linkname, loc, umask, xdata); + return 0; } - int -mdc_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, - dict_t *xdata) +mdc_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, + dict_t *xdata) { - mdc_local_t *local = NULL; - - local = frame->local; - if (!local) - goto out; + mdc_local_t *local = NULL; - if (op_ret != 0) { - if ((op_errno == ESTALE) || (op_errno == ENOENT)) { - mdc_inode_iatt_invalidate (this, local->loc.inode); - mdc_inode_iatt_invalidate (this, local->loc2.parent); - } + local = frame->local; + if (!local) + goto out; - goto out; + if (op_ret != 0) { + if ((op_errno == ESTALE) || (op_errno == ENOENT)) { + mdc_inode_iatt_invalidate(this, local->loc.inode); + mdc_inode_iatt_invalidate(this, local->loc2.parent); } - if (local->loc.parent) { - mdc_inode_iatt_set (this, local->loc.parent, postoldparent, - local->incident_time); - } + goto out; + } - if (local->loc.inode) { - /* TODO: fix dht_rename() not to return linkfile - attributes before setting attributes here - */ + if (local->loc.parent) { + mdc_inode_iatt_set(this, local->loc.parent, postoldparent, + local->incident_time); + } - mdc_inode_iatt_set (this, local->loc.inode, NULL, - local->incident_time); - } + if (local->loc.inode) { + /* TODO: fix dht_rename() not to return linkfile + attributes before setting attributes here + */ - if (local->loc2.parent) { - mdc_inode_iatt_set (this, local->loc2.parent, postnewparent, - local->incident_time); - } + mdc_inode_iatt_set(this, local->loc.inode, NULL, local->incident_time); + } + + if (local->loc2.parent) { + mdc_inode_iatt_set(this, local->loc2.parent, postnewparent, + local->incident_time); + } out: - MDC_STACK_UNWIND (rename, frame, op_ret, op_errno, buf, - preoldparent, postoldparent, prenewparent, - postnewparent, xdata); - return 0; + MDC_STACK_UNWIND(rename, frame, op_ret, op_errno, buf, preoldparent, + postoldparent, prenewparent, postnewparent, xdata); + return 0; } - int -mdc_rename (call_frame_t *frame, xlator_t *this, - loc_t *oldloc, loc_t *newloc, dict_t *xdata) +mdc_rename(call_frame_t *frame, xlator_t *this, loc_t *oldloc, loc_t *newloc, + dict_t *xdata) { - mdc_local_t *local = NULL; + mdc_local_t *local = NULL; - local = mdc_local_get (frame, oldloc->inode); + local = mdc_local_get(frame, oldloc->inode); - loc_copy (&local->loc, oldloc); - loc_copy (&local->loc2, newloc); + loc_copy(&local->loc, oldloc); + loc_copy(&local->loc2, newloc); - STACK_WIND (frame, mdc_rename_cbk, - FIRST_CHILD(this), FIRST_CHILD(this)->fops->rename, - oldloc, newloc, xdata); - return 0; + STACK_WIND(frame, mdc_rename_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->rename, oldloc, newloc, xdata); + return 0; } - int -mdc_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, dict_t *xdata) +mdc_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, dict_t *xdata) { - mdc_local_t *local = NULL; - - local = frame->local; + mdc_local_t *local = NULL; - if (!local) - goto out; + local = frame->local; - if (op_ret != 0) { - if ((op_errno == ENOENT) || (op_errno == ESTALE)) { - mdc_inode_iatt_invalidate (this, local->loc.inode); - mdc_inode_iatt_invalidate (this, local->loc2.parent); - } + if (!local) + goto out; - goto out; + if (op_ret != 0) { + if ((op_errno == ENOENT) || (op_errno == ESTALE)) { + mdc_inode_iatt_invalidate(this, local->loc.inode); + mdc_inode_iatt_invalidate(this, local->loc2.parent); } - if (local->loc.inode) { - mdc_inode_iatt_set (this, local->loc.inode, buf, - local->incident_time); - } + goto out; + } - if (local->loc2.parent) { - mdc_inode_iatt_set (this, local->loc2.parent, postparent, - local->incident_time); - } + if (local->loc.inode) { + mdc_inode_iatt_set(this, local->loc.inode, buf, local->incident_time); + } + + if (local->loc2.parent) { + mdc_inode_iatt_set(this, local->loc2.parent, postparent, + local->incident_time); + } out: - MDC_STACK_UNWIND (link, frame, op_ret, op_errno, inode, buf, - preparent, postparent, xdata); - return 0; + MDC_STACK_UNWIND(link, frame, op_ret, op_errno, inode, buf, preparent, + postparent, xdata); + return 0; } - int -mdc_link (call_frame_t *frame, xlator_t *this, - loc_t *oldloc, loc_t *newloc, dict_t *xdata) +mdc_link(call_frame_t *frame, xlator_t *this, loc_t *oldloc, loc_t *newloc, + dict_t *xdata) { - mdc_local_t *local = NULL; + mdc_local_t *local = NULL; - local = mdc_local_get (frame, oldloc->inode); + local = mdc_local_get(frame, oldloc->inode); - loc_copy (&local->loc, oldloc); - loc_copy (&local->loc2, newloc); + loc_copy(&local->loc, oldloc); + loc_copy(&local->loc2, newloc); - STACK_WIND (frame, mdc_link_cbk, - FIRST_CHILD(this), FIRST_CHILD(this)->fops->link, - oldloc, newloc, xdata); - return 0; + STACK_WIND(frame, mdc_link_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->link, oldloc, newloc, xdata); + return 0; } - int -mdc_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 *buf, struct iatt *preparent, - struct iatt *postparent, dict_t *xdata) +mdc_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 *buf, struct iatt *preparent, + struct iatt *postparent, dict_t *xdata) { - mdc_local_t *local = NULL; - - local = frame->local; + mdc_local_t *local = NULL; - if (!local) - goto out; + local = frame->local; - if (op_ret != 0) { - if ((op_errno == ESTALE) || (op_errno == ENOENT)) { - mdc_inode_iatt_invalidate (this, local->loc.parent); - } + if (!local) + goto out; - goto out; + if (op_ret != 0) { + if ((op_errno == ESTALE) || (op_errno == ENOENT)) { + mdc_inode_iatt_invalidate(this, local->loc.parent); } - if (local->loc.parent) { - mdc_inode_iatt_set (this, local->loc.parent, postparent, - local->incident_time); - } + goto out; + } - if (local->loc.inode) { - mdc_inode_iatt_set (this, inode, buf, local->incident_time); - mdc_inode_xatt_set (this, local->loc.inode, local->xattr); - } + if (local->loc.parent) { + mdc_inode_iatt_set(this, local->loc.parent, postparent, + local->incident_time); + } + + if (local->loc.inode) { + mdc_inode_iatt_set(this, inode, buf, local->incident_time); + mdc_inode_xatt_set(this, local->loc.inode, local->xattr); + } out: - MDC_STACK_UNWIND (create, frame, op_ret, op_errno, fd, inode, buf, - preparent, postparent, xdata); - return 0; + MDC_STACK_UNWIND(create, frame, op_ret, op_errno, fd, inode, buf, preparent, + postparent, xdata); + return 0; } - int -mdc_create (call_frame_t *frame, xlator_t *this, loc_t *loc, int flags, - mode_t mode, mode_t umask, fd_t *fd, dict_t *xdata) +mdc_create(call_frame_t *frame, xlator_t *this, loc_t *loc, int flags, + mode_t mode, mode_t umask, fd_t *fd, dict_t *xdata) { - mdc_local_t *local = NULL; + mdc_local_t *local = NULL; - local = mdc_local_get (frame, loc->inode); + local = mdc_local_get(frame, loc->inode); - loc_copy (&local->loc, loc); - local->xattr = dict_ref (xdata); + loc_copy(&local->loc, loc); + local->xattr = dict_ref(xdata); - STACK_WIND (frame, mdc_create_cbk, - FIRST_CHILD(this), FIRST_CHILD(this)->fops->create, - loc, flags, mode, umask, fd, xdata); - return 0; + STACK_WIND(frame, mdc_create_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->create, loc, flags, mode, umask, fd, + xdata); + return 0; } - static int -mdc_open_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, fd_t *fd, - dict_t *xdata) +mdc_open_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int32_t op_ret, + int32_t op_errno, fd_t *fd, dict_t *xdata) { - mdc_local_t *local = NULL; + mdc_local_t *local = NULL; - local = frame->local; + local = frame->local; - if (!local) - goto out; + if (!local) + goto out; - if (op_ret != 0) { - if ((op_errno == ESTALE) || (op_errno == ENOENT)) - mdc_inode_iatt_invalidate (this, local->loc.inode); - goto out; - } + if (op_ret != 0) { + if ((op_errno == ESTALE) || (op_errno == ENOENT)) + mdc_inode_iatt_invalidate(this, local->loc.inode); + goto out; + } - if (local->fd->flags & O_TRUNC) { - /* O_TRUNC modifies file size. Hence invalidate the - * cache entry to fetch latest attributes. */ - mdc_inode_iatt_invalidate (this, local->fd->inode); - } + if (local->fd->flags & O_TRUNC) { + /* O_TRUNC modifies file size. Hence invalidate the + * cache entry to fetch latest attributes. */ + mdc_inode_iatt_invalidate(this, local->fd->inode); + } out: - MDC_STACK_UNWIND (open, frame, op_ret, op_errno, fd, xdata); - return 0; + MDC_STACK_UNWIND(open, frame, op_ret, op_errno, fd, xdata); + return 0; } - static int -mdc_open (call_frame_t *frame, xlator_t *this, loc_t *loc, int flags, - fd_t *fd, dict_t *xdata) +mdc_open(call_frame_t *frame, xlator_t *this, loc_t *loc, int flags, fd_t *fd, + dict_t *xdata) { - mdc_local_t *local = NULL; + mdc_local_t *local = NULL; - if (!fd || !IA_ISREG(fd->inode->ia_type) || - !(fd->flags & O_TRUNC)) { - goto out; - } + if (!fd || !IA_ISREG(fd->inode->ia_type) || !(fd->flags & O_TRUNC)) { + goto out; + } - local = mdc_local_get (frame, loc->inode); + local = mdc_local_get(frame, loc->inode); - local->fd = fd_ref (fd); + local->fd = fd_ref(fd); out: - STACK_WIND (frame, mdc_open_cbk, - FIRST_CHILD(this), FIRST_CHILD(this)->fops->open, - loc, flags, fd, xdata); - return 0; + STACK_WIND(frame, mdc_open_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->open, loc, flags, fd, xdata); + return 0; } - int -mdc_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, dict_t *xdata) +mdc_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, dict_t *xdata) { - mdc_local_t *local = NULL; + mdc_local_t *local = NULL; - local = frame->local; - if (!local) - goto out; + local = frame->local; + if (!local) + goto out; - if (op_ret < 0) { - if ((op_errno == ENOENT) || (op_errno == ESTALE)) - mdc_inode_iatt_invalidate (this, local->fd->inode); - goto out; - } + if (op_ret < 0) { + if ((op_errno == ENOENT) || (op_errno == ESTALE)) + mdc_inode_iatt_invalidate(this, local->fd->inode); + goto out; + } - mdc_inode_iatt_set (this, local->fd->inode, stbuf, local->incident_time); + mdc_inode_iatt_set(this, local->fd->inode, stbuf, local->incident_time); out: - MDC_STACK_UNWIND (readv, frame, op_ret, op_errno, vector, count, - stbuf, iobref, xdata); + MDC_STACK_UNWIND(readv, frame, op_ret, op_errno, vector, count, stbuf, + iobref, xdata); - return 0; + return 0; } - int -mdc_readv (call_frame_t *frame, xlator_t *this, fd_t *fd, size_t size, - off_t offset, uint32_t flags, dict_t *xdata) +mdc_readv(call_frame_t *frame, xlator_t *this, fd_t *fd, size_t size, + off_t offset, uint32_t flags, dict_t *xdata) { - mdc_local_t *local = NULL; + mdc_local_t *local = NULL; - local = mdc_local_get (frame, fd->inode); + local = mdc_local_get(frame, fd->inode); - local->fd = fd_ref (fd); + local->fd = fd_ref(fd); - STACK_WIND (frame, mdc_readv_cbk, - FIRST_CHILD(this), FIRST_CHILD(this)->fops->readv, - fd, size, offset, flags, xdata); - return 0; + STACK_WIND(frame, mdc_readv_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->readv, fd, size, offset, flags, xdata); + return 0; } - int -mdc_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, dict_t *xdata) +mdc_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, dict_t *xdata) { - mdc_local_t *local = NULL; + mdc_local_t *local = NULL; - local = frame->local; - if (!local) - goto out; + local = frame->local; + if (!local) + goto out; - if (op_ret == -1) { - if ((op_errno == ENOENT) || (op_errno == ESTALE)) - mdc_inode_iatt_invalidate (this, local->fd->inode); - goto out; - } + if (op_ret == -1) { + if ((op_errno == ENOENT) || (op_errno == ESTALE)) + mdc_inode_iatt_invalidate(this, local->fd->inode); + goto out; + } - mdc_inode_iatt_set_validate(this, local->fd->inode, prebuf, postbuf, - _gf_true, local->incident_time); + mdc_inode_iatt_set_validate(this, local->fd->inode, prebuf, postbuf, + _gf_true, local->incident_time); out: - MDC_STACK_UNWIND (writev, frame, op_ret, op_errno, prebuf, postbuf, - xdata); + MDC_STACK_UNWIND(writev, frame, op_ret, op_errno, prebuf, postbuf, xdata); - return 0; + return 0; } - int -mdc_writev (call_frame_t *frame, xlator_t *this, fd_t *fd, struct iovec *vector, - int count, off_t offset, uint32_t flags, struct iobref *iobref, - dict_t *xdata) +mdc_writev(call_frame_t *frame, xlator_t *this, fd_t *fd, struct iovec *vector, + int count, off_t offset, uint32_t flags, struct iobref *iobref, + dict_t *xdata) { - mdc_local_t *local = NULL; + mdc_local_t *local = NULL; - local = mdc_local_get (frame, fd->inode); + local = mdc_local_get(frame, fd->inode); - local->fd = fd_ref (fd); + local->fd = fd_ref(fd); - STACK_WIND (frame, mdc_writev_cbk, - FIRST_CHILD(this), FIRST_CHILD(this)->fops->writev, - fd, vector, count, offset, flags, iobref, xdata); - return 0; + STACK_WIND(frame, mdc_writev_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->writev, fd, vector, count, offset, + flags, iobref, xdata); + return 0; } - int -mdc_setattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, - struct iatt *prebuf, struct iatt *postbuf, dict_t *xdata) +mdc_setattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, struct iatt *prebuf, + struct iatt *postbuf, dict_t *xdata) { - mdc_local_t *local = NULL; + mdc_local_t *local = NULL; - local = frame->local; + local = frame->local; - if (op_ret != 0) { - mdc_inode_iatt_set (this, local->loc.inode, NULL, - local->incident_time); - goto out; - } + if (op_ret != 0) { + mdc_inode_iatt_set(this, local->loc.inode, NULL, local->incident_time); + goto out; + } - if (!local) - goto out; + if (!local) + goto out; - mdc_inode_iatt_set_validate(this, local->loc.inode, prebuf, postbuf, - _gf_true, local->incident_time); + mdc_inode_iatt_set_validate(this, local->loc.inode, prebuf, postbuf, + _gf_true, local->incident_time); out: - MDC_STACK_UNWIND (setattr, frame, op_ret, op_errno, prebuf, postbuf, - xdata); + MDC_STACK_UNWIND(setattr, frame, op_ret, op_errno, prebuf, postbuf, xdata); - return 0; + return 0; } - int -mdc_setattr (call_frame_t *frame, xlator_t *this, loc_t *loc, - struct iatt *stbuf, int valid, dict_t *xdata) +mdc_setattr(call_frame_t *frame, xlator_t *this, loc_t *loc, struct iatt *stbuf, + int valid, dict_t *xdata) { - mdc_local_t *local = NULL; + mdc_local_t *local = NULL; - local = mdc_local_get (frame, loc->inode); + local = mdc_local_get(frame, loc->inode); - loc_copy (&local->loc, loc); + loc_copy(&local->loc, loc); - STACK_WIND (frame, mdc_setattr_cbk, - FIRST_CHILD(this), FIRST_CHILD(this)->fops->setattr, - loc, stbuf, valid, xdata); - return 0; + STACK_WIND(frame, mdc_setattr_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->setattr, loc, stbuf, valid, xdata); + return 0; } - int -mdc_fsetattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, - struct iatt *prebuf, struct iatt *postbuf, dict_t *xdata) +mdc_fsetattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, struct iatt *prebuf, + struct iatt *postbuf, dict_t *xdata) { - mdc_local_t *local = NULL; + mdc_local_t *local = NULL; - local = frame->local; - if (!local) - goto out; + local = frame->local; + if (!local) + goto out; - if (op_ret != 0) { - if ((op_errno == ESTALE) || (op_errno == ENOENT)) - mdc_inode_iatt_invalidate (this, local->fd->inode); - goto out; - } + if (op_ret != 0) { + if ((op_errno == ESTALE) || (op_errno == ENOENT)) + mdc_inode_iatt_invalidate(this, local->fd->inode); + goto out; + } - mdc_inode_iatt_set_validate(this, local->fd->inode, prebuf, postbuf, - _gf_true, local->incident_time); + mdc_inode_iatt_set_validate(this, local->fd->inode, prebuf, postbuf, + _gf_true, local->incident_time); out: - MDC_STACK_UNWIND (fsetattr, frame, op_ret, op_errno, prebuf, postbuf, - xdata); + MDC_STACK_UNWIND(fsetattr, frame, op_ret, op_errno, prebuf, postbuf, xdata); - return 0; + return 0; } - int -mdc_fsetattr (call_frame_t *frame, xlator_t *this, fd_t *fd, - struct iatt *stbuf, int valid, dict_t *xdata) +mdc_fsetattr(call_frame_t *frame, xlator_t *this, fd_t *fd, struct iatt *stbuf, + int valid, dict_t *xdata) { - mdc_local_t *local = NULL; + mdc_local_t *local = NULL; - local = mdc_local_get (frame, fd->inode); + local = mdc_local_get(frame, fd->inode); - local->fd = fd_ref (fd); + local->fd = fd_ref(fd); - STACK_WIND (frame, mdc_fsetattr_cbk, - FIRST_CHILD(this), FIRST_CHILD(this)->fops->fsetattr, - fd, stbuf, valid, xdata); - return 0; + STACK_WIND(frame, mdc_fsetattr_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->fsetattr, fd, stbuf, valid, xdata); + return 0; } - int -mdc_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, dict_t *xdata) +mdc_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, + dict_t *xdata) { - mdc_local_t *local = NULL; + mdc_local_t *local = NULL; - local = frame->local; - if (!local) - goto out; + local = frame->local; + if (!local) + goto out; - if (op_ret != 0) { - if ((op_errno == ENOENT) || (op_errno == ESTALE)) - mdc_inode_iatt_invalidate (this, local->fd->inode); - goto out; - } + if (op_ret != 0) { + if ((op_errno == ENOENT) || (op_errno == ESTALE)) + mdc_inode_iatt_invalidate(this, local->fd->inode); + goto out; + } - mdc_inode_iatt_set_validate(this, local->fd->inode, prebuf, postbuf, - _gf_true, local->incident_time); + mdc_inode_iatt_set_validate(this, local->fd->inode, prebuf, postbuf, + _gf_true, local->incident_time); out: - MDC_STACK_UNWIND (fsync, frame, op_ret, op_errno, prebuf, postbuf, - xdata); + MDC_STACK_UNWIND(fsync, frame, op_ret, op_errno, prebuf, postbuf, xdata); - return 0; + return 0; } - int -mdc_fsync (call_frame_t *frame, xlator_t *this, fd_t *fd, int datasync, - dict_t *xdata) +mdc_fsync(call_frame_t *frame, xlator_t *this, fd_t *fd, int datasync, + dict_t *xdata) { - mdc_local_t *local = NULL; + mdc_local_t *local = NULL; - local = mdc_local_get (frame, fd->inode); + local = mdc_local_get(frame, fd->inode); - local->fd = fd_ref (fd); + local->fd = fd_ref(fd); - STACK_WIND (frame, mdc_fsync_cbk, - FIRST_CHILD(this), FIRST_CHILD(this)->fops->fsync, - fd, datasync, xdata); - return 0; + STACK_WIND(frame, mdc_fsync_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->fsync, fd, datasync, xdata); + return 0; } - int -mdc_setxattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, dict_t *xdata) +mdc_setxattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, dict_t *xdata) { - mdc_local_t *local = NULL; - struct iatt prestat = {0,}; - struct iatt poststat = {0,}; - int ret = 0; + mdc_local_t *local = NULL; + struct iatt prestat = { + 0, + }; + struct iatt poststat = { + 0, + }; + int ret = 0; - local = frame->local; - if (!local) - goto out; + local = frame->local; + if (!local) + goto out; - if (op_ret != 0) { - if ((op_errno == ENOENT) || (op_errno == ESTALE)) - mdc_inode_iatt_invalidate (this, local->loc.inode); - goto out; - } + if (op_ret != 0) { + if ((op_errno == ENOENT) || (op_errno == ESTALE)) + mdc_inode_iatt_invalidate(this, local->loc.inode); + goto out; + } - mdc_inode_xatt_update (this, local->loc.inode, local->xattr); + mdc_inode_xatt_update(this, local->loc.inode, local->xattr); - ret = dict_get_iatt (xdata, GF_PRESTAT, &prestat); - if (ret >= 0) { - ret = dict_get_iatt (xdata, GF_POSTSTAT, &poststat); - mdc_inode_iatt_set_validate (this, local->loc.inode, &prestat, - &poststat, _gf_true, - local->incident_time); - } + ret = dict_get_iatt(xdata, GF_PRESTAT, &prestat); + if (ret >= 0) { + ret = dict_get_iatt(xdata, GF_POSTSTAT, &poststat); + mdc_inode_iatt_set_validate(this, local->loc.inode, &prestat, &poststat, + _gf_true, local->incident_time); + } - if (ret < 0) - mdc_inode_iatt_invalidate (this, local->loc.inode); + if (ret < 0) + mdc_inode_iatt_invalidate(this, local->loc.inode); out: - MDC_STACK_UNWIND (setxattr, frame, op_ret, op_errno, xdata); + MDC_STACK_UNWIND(setxattr, frame, op_ret, op_errno, xdata); - return 0; + return 0; } - int -mdc_setxattr (call_frame_t *frame, xlator_t *this, loc_t *loc, - dict_t *xattr, int flags, dict_t *xdata) +mdc_setxattr(call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *xattr, + int flags, dict_t *xdata) { - mdc_local_t *local = NULL; + mdc_local_t *local = NULL; - local = mdc_local_get (frame, loc->inode); + local = mdc_local_get(frame, loc->inode); - loc_copy (&local->loc, loc); - local->xattr = dict_ref (xattr); + loc_copy(&local->loc, loc); + local->xattr = dict_ref(xattr); - STACK_WIND (frame, mdc_setxattr_cbk, - FIRST_CHILD(this), FIRST_CHILD(this)->fops->setxattr, - loc, xattr, flags, xdata); + STACK_WIND(frame, mdc_setxattr_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->setxattr, loc, xattr, flags, xdata); - return 0; + return 0; } - int -mdc_fsetxattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, dict_t *xdata) +mdc_fsetxattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, dict_t *xdata) { - mdc_local_t *local = NULL; - struct iatt prestat = {0,}; - struct iatt poststat = {0,}; - int ret = 0; + mdc_local_t *local = NULL; + struct iatt prestat = { + 0, + }; + struct iatt poststat = { + 0, + }; + int ret = 0; - local = frame->local; - if (!local) - goto out; + local = frame->local; + if (!local) + goto out; - if (op_ret != 0) { - if ((op_errno == ESTALE) || (op_errno == ENOENT)) - mdc_inode_iatt_invalidate (this, local->fd->inode); - goto out; - } + if (op_ret != 0) { + if ((op_errno == ESTALE) || (op_errno == ENOENT)) + mdc_inode_iatt_invalidate(this, local->fd->inode); + goto out; + } - mdc_inode_xatt_update (this, local->fd->inode, local->xattr); + mdc_inode_xatt_update(this, local->fd->inode, local->xattr); - ret = dict_get_iatt (xdata, GF_PRESTAT, &prestat); - if (ret >= 0) { - ret = dict_get_iatt (xdata, GF_POSTSTAT, &poststat); - mdc_inode_iatt_set_validate (this, local->fd->inode, &prestat, - &poststat, _gf_true, - local->incident_time); - } + ret = dict_get_iatt(xdata, GF_PRESTAT, &prestat); + if (ret >= 0) { + ret = dict_get_iatt(xdata, GF_POSTSTAT, &poststat); + mdc_inode_iatt_set_validate(this, local->fd->inode, &prestat, &poststat, + _gf_true, local->incident_time); + } - if (ret < 0) - mdc_inode_iatt_invalidate (this, local->fd->inode); + if (ret < 0) + mdc_inode_iatt_invalidate(this, local->fd->inode); out: - MDC_STACK_UNWIND (fsetxattr, frame, op_ret, op_errno, xdata); + MDC_STACK_UNWIND(fsetxattr, frame, op_ret, op_errno, xdata); - return 0; + return 0; } - int -mdc_fsetxattr (call_frame_t *frame, xlator_t *this, fd_t *fd, - dict_t *xattr, int flags, dict_t *xdata) +mdc_fsetxattr(call_frame_t *frame, xlator_t *this, fd_t *fd, dict_t *xattr, + int flags, dict_t *xdata) { - mdc_local_t *local = NULL; + mdc_local_t *local = NULL; - local = mdc_local_get (frame, fd->inode); + local = mdc_local_get(frame, fd->inode); - local->fd = fd_ref (fd); - local->xattr = dict_ref (xattr); + local->fd = fd_ref(fd); + local->xattr = dict_ref(xattr); - STACK_WIND (frame, mdc_fsetxattr_cbk, - FIRST_CHILD(this), FIRST_CHILD(this)->fops->fsetxattr, - fd, xattr, flags, xdata); + STACK_WIND(frame, mdc_fsetxattr_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->fsetxattr, fd, xattr, flags, xdata); - return 0; + return 0; } int -mdc_getxattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, dict_t *xattr, - dict_t *xdata) +mdc_getxattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, dict_t *xattr, dict_t *xdata) { - mdc_local_t *local = NULL; + mdc_local_t *local = NULL; - local = frame->local; - if (!local) - goto out; + local = frame->local; + if (!local) + goto out; - if (op_ret < 0) { - if ((op_errno == ENOENT) || (op_errno == ESTALE)) - mdc_inode_iatt_invalidate (this, local->loc.inode); - goto out; - } + if (op_ret < 0) { + if ((op_errno == ENOENT) || (op_errno == ESTALE)) + mdc_inode_iatt_invalidate(this, local->loc.inode); + goto out; + } - mdc_inode_xatt_update (this, local->loc.inode, xattr); + mdc_inode_xatt_update(this, local->loc.inode, xattr); out: - MDC_STACK_UNWIND (getxattr, frame, op_ret, op_errno, xattr, xdata); + MDC_STACK_UNWIND(getxattr, frame, op_ret, op_errno, xattr, xdata); - return 0; + return 0; } - int -mdc_getxattr (call_frame_t *frame, xlator_t *this, loc_t *loc, const char *key, - dict_t *xdata) +mdc_getxattr(call_frame_t *frame, xlator_t *this, loc_t *loc, const char *key, + dict_t *xdata) { - int ret; - int op_errno = ENODATA; - mdc_local_t *local = NULL; - dict_t *xattr = NULL; - struct mdc_conf *conf = this->private; + int ret; + int op_errno = ENODATA; + mdc_local_t *local = NULL; + dict_t *xattr = NULL; + struct mdc_conf *conf = this->private; - local = mdc_local_get (frame, loc->inode); - if (!local) - goto uncached; + local = mdc_local_get(frame, loc->inode); + if (!local) + goto uncached; - loc_copy (&local->loc, loc); + loc_copy(&local->loc, loc); - if (!is_mdc_key_satisfied (this, key)) - goto uncached; + if (!is_mdc_key_satisfied(this, key)) + goto uncached; - ret = mdc_inode_xatt_get (this, loc->inode, &xattr); - if (ret != 0) - goto uncached; + ret = mdc_inode_xatt_get(this, loc->inode, &xattr); + if (ret != 0) + goto uncached; - if (!xattr || !dict_get (xattr, (char *)key)) { - ret = -1; - op_errno = ENODATA; - } + if (!xattr || !dict_get(xattr, (char *)key)) { + ret = -1; + op_errno = ENODATA; + } - GF_ATOMIC_INC (conf->mdc_counter.xattr_hit); - MDC_STACK_UNWIND (getxattr, frame, ret, op_errno, xattr, xdata); + GF_ATOMIC_INC(conf->mdc_counter.xattr_hit); + MDC_STACK_UNWIND(getxattr, frame, ret, op_errno, xattr, xdata); - return 0; + return 0; uncached: - GF_ATOMIC_INC (conf->mdc_counter.xattr_miss); - STACK_WIND (frame, mdc_getxattr_cbk, - FIRST_CHILD(this), FIRST_CHILD(this)->fops->getxattr, - loc, key, xdata); - return 0; + GF_ATOMIC_INC(conf->mdc_counter.xattr_miss); + STACK_WIND(frame, mdc_getxattr_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->getxattr, loc, key, xdata); + return 0; } - int -mdc_fgetxattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, dict_t *xattr, - dict_t *xdata) +mdc_fgetxattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, dict_t *xattr, + dict_t *xdata) { - mdc_local_t *local = NULL; + mdc_local_t *local = NULL; - local = frame->local; - if (!local) - goto out; + local = frame->local; + if (!local) + goto out; - if (op_ret < 0) { - if ((op_errno == ENOENT) || (op_errno == ESTALE)) - mdc_inode_iatt_invalidate (this, local->fd->inode); - goto out; - } + if (op_ret < 0) { + if ((op_errno == ENOENT) || (op_errno == ESTALE)) + mdc_inode_iatt_invalidate(this, local->fd->inode); + goto out; + } - mdc_inode_xatt_update (this, local->fd->inode, xattr); + mdc_inode_xatt_update(this, local->fd->inode, xattr); out: - MDC_STACK_UNWIND (fgetxattr, frame, op_ret, op_errno, xattr, xdata); + MDC_STACK_UNWIND(fgetxattr, frame, op_ret, op_errno, xattr, xdata); - return 0; + return 0; } - int -mdc_fgetxattr (call_frame_t *frame, xlator_t *this, fd_t *fd, const char *key, - dict_t *xdata) +mdc_fgetxattr(call_frame_t *frame, xlator_t *this, fd_t *fd, const char *key, + dict_t *xdata) { - int ret; - mdc_local_t *local = NULL; - dict_t *xattr = NULL; - int op_errno = ENODATA; - struct mdc_conf *conf = this->private; + int ret; + mdc_local_t *local = NULL; + dict_t *xattr = NULL; + int op_errno = ENODATA; + struct mdc_conf *conf = this->private; - local = mdc_local_get (frame, fd->inode); - if (!local) - goto uncached; + local = mdc_local_get(frame, fd->inode); + if (!local) + goto uncached; - local->fd = fd_ref (fd); + local->fd = fd_ref(fd); - if (!is_mdc_key_satisfied (this, key)) - goto uncached; + if (!is_mdc_key_satisfied(this, key)) + goto uncached; - ret = mdc_inode_xatt_get (this, fd->inode, &xattr); - if (ret != 0) - goto uncached; + ret = mdc_inode_xatt_get(this, fd->inode, &xattr); + if (ret != 0) + goto uncached; - if (!xattr || !dict_get (xattr, (char *)key)) { - ret = -1; - op_errno = ENODATA; - } + if (!xattr || !dict_get(xattr, (char *)key)) { + ret = -1; + op_errno = ENODATA; + } - GF_ATOMIC_INC (conf->mdc_counter.xattr_hit); - MDC_STACK_UNWIND (fgetxattr, frame, ret, op_errno, xattr, xdata); + GF_ATOMIC_INC(conf->mdc_counter.xattr_hit); + MDC_STACK_UNWIND(fgetxattr, frame, ret, op_errno, xattr, xdata); - return 0; + return 0; uncached: - GF_ATOMIC_INC (conf->mdc_counter.xattr_miss); - STACK_WIND (frame, mdc_fgetxattr_cbk, - FIRST_CHILD(this), FIRST_CHILD(this)->fops->fgetxattr, - fd, key, xdata); - return 0; + GF_ATOMIC_INC(conf->mdc_counter.xattr_miss); + STACK_WIND(frame, mdc_fgetxattr_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->fgetxattr, fd, key, xdata); + return 0; } int -mdc_removexattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, dict_t *xdata) +mdc_removexattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, dict_t *xdata) { - mdc_local_t *local = NULL; - struct iatt prestat = {0,}; - struct iatt poststat = {0,}; - int ret = 0; + mdc_local_t *local = NULL; + struct iatt prestat = { + 0, + }; + struct iatt poststat = { + 0, + }; + int ret = 0; - local = frame->local; - if (!local) - goto out; + local = frame->local; + if (!local) + goto out; - if (op_ret != 0) { - if ((op_errno == ENOENT) || (op_errno == ESTALE)) - mdc_inode_iatt_invalidate (this, local->loc.inode); - goto out; - } - - if (local->key) - mdc_inode_xatt_unset (this, local->loc.inode, local->key); - else - mdc_inode_xatt_invalidate (this, local->loc.inode); - - ret = dict_get_iatt (xdata, GF_PRESTAT, &prestat); - if (ret >= 0) { - ret = dict_get_iatt (xdata, GF_POSTSTAT, &poststat); - mdc_inode_iatt_set_validate (this, local->loc.inode, &prestat, - &poststat, _gf_true, - local->incident_time); - } + if (op_ret != 0) { + if ((op_errno == ENOENT) || (op_errno == ESTALE)) + mdc_inode_iatt_invalidate(this, local->loc.inode); + goto out; + } + + if (local->key) + mdc_inode_xatt_unset(this, local->loc.inode, local->key); + else + mdc_inode_xatt_invalidate(this, local->loc.inode); + + ret = dict_get_iatt(xdata, GF_PRESTAT, &prestat); + if (ret >= 0) { + ret = dict_get_iatt(xdata, GF_POSTSTAT, &poststat); + mdc_inode_iatt_set_validate(this, local->loc.inode, &prestat, &poststat, + _gf_true, local->incident_time); + } - if (ret < 0) - mdc_inode_iatt_invalidate (this, local->loc.inode); + if (ret < 0) + mdc_inode_iatt_invalidate(this, local->loc.inode); out: - MDC_STACK_UNWIND (removexattr, frame, op_ret, op_errno, xdata); + MDC_STACK_UNWIND(removexattr, frame, op_ret, op_errno, xdata); - return 0; + return 0; } - int -mdc_removexattr (call_frame_t *frame, xlator_t *this, loc_t *loc, - const char *name, dict_t *xdata) +mdc_removexattr(call_frame_t *frame, xlator_t *this, loc_t *loc, + const char *name, dict_t *xdata) { - mdc_local_t *local = NULL; - int op_errno = ENODATA; - int ret = 0; - dict_t *xattr = NULL; - struct mdc_conf *conf = this->private; + mdc_local_t *local = NULL; + int op_errno = ENODATA; + int ret = 0; + dict_t *xattr = NULL; + struct mdc_conf *conf = this->private; - local = mdc_local_get (frame, loc->inode); + local = mdc_local_get(frame, loc->inode); - loc_copy (&local->loc, loc); + loc_copy(&local->loc, loc); - local->key = gf_strdup (name); + local->key = gf_strdup(name); - if (!is_mdc_key_satisfied (this, name)) - goto uncached; + if (!is_mdc_key_satisfied(this, name)) + goto uncached; - ret = mdc_inode_xatt_get (this, loc->inode, &xattr); - if (ret != 0) - goto uncached; + ret = mdc_inode_xatt_get(this, loc->inode, &xattr); + if (ret != 0) + goto uncached; - if (!xattr || !dict_get (xattr, (char *)name)) { - ret = -1; - op_errno = ENODATA; - } + if (!xattr || !dict_get(xattr, (char *)name)) { + ret = -1; + op_errno = ENODATA; + } - GF_ATOMIC_INC (conf->mdc_counter.xattr_hit); - MDC_STACK_UNWIND (removexattr, frame, ret, op_errno, xdata); + GF_ATOMIC_INC(conf->mdc_counter.xattr_hit); + MDC_STACK_UNWIND(removexattr, frame, ret, op_errno, xdata); - return 0; + return 0; uncached: - GF_ATOMIC_INC (conf->mdc_counter.xattr_miss); - STACK_WIND (frame, mdc_removexattr_cbk, - FIRST_CHILD(this), FIRST_CHILD(this)->fops->removexattr, - loc, name, xdata); - return 0; + GF_ATOMIC_INC(conf->mdc_counter.xattr_miss); + STACK_WIND(frame, mdc_removexattr_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->removexattr, loc, name, xdata); + return 0; } - int -mdc_fremovexattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, dict_t *xdata) +mdc_fremovexattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, dict_t *xdata) { - mdc_local_t *local = NULL; - struct iatt prestat = {0,}; - struct iatt poststat = {0,}; - int ret = 0; + mdc_local_t *local = NULL; + struct iatt prestat = { + 0, + }; + struct iatt poststat = { + 0, + }; + int ret = 0; - local = frame->local; - if (!local) - goto out; + local = frame->local; + if (!local) + goto out; - if (op_ret != 0) { - if ((op_errno == ENOENT) || (op_errno == ESTALE)) - mdc_inode_iatt_invalidate (this, local->fd->inode); - goto out; - } - - if (local->key) - mdc_inode_xatt_unset (this, local->fd->inode, local->key); - else - mdc_inode_xatt_invalidate (this, local->fd->inode); - - ret = dict_get_iatt (xdata, GF_PRESTAT, &prestat); - if (ret >= 0) { - ret = dict_get_iatt (xdata, GF_POSTSTAT, &poststat); - mdc_inode_iatt_set_validate (this, local->fd->inode, &prestat, - &poststat, _gf_true, - local->incident_time); - } + if (op_ret != 0) { + if ((op_errno == ENOENT) || (op_errno == ESTALE)) + mdc_inode_iatt_invalidate(this, local->fd->inode); + goto out; + } + + if (local->key) + mdc_inode_xatt_unset(this, local->fd->inode, local->key); + else + mdc_inode_xatt_invalidate(this, local->fd->inode); + + ret = dict_get_iatt(xdata, GF_PRESTAT, &prestat); + if (ret >= 0) { + ret = dict_get_iatt(xdata, GF_POSTSTAT, &poststat); + mdc_inode_iatt_set_validate(this, local->fd->inode, &prestat, &poststat, + _gf_true, local->incident_time); + } - if (ret < 0) - mdc_inode_iatt_invalidate (this, local->fd->inode); + if (ret < 0) + mdc_inode_iatt_invalidate(this, local->fd->inode); out: - MDC_STACK_UNWIND (fremovexattr, frame, op_ret, op_errno, xdata); + MDC_STACK_UNWIND(fremovexattr, frame, op_ret, op_errno, xdata); - return 0; + return 0; } - int -mdc_fremovexattr (call_frame_t *frame, xlator_t *this, fd_t *fd, - const char *name, dict_t *xdata) +mdc_fremovexattr(call_frame_t *frame, xlator_t *this, fd_t *fd, + const char *name, dict_t *xdata) { - mdc_local_t *local = NULL; - int op_errno = ENODATA; - int ret = 0; - dict_t *xattr = NULL; - struct mdc_conf *conf = this->private; + mdc_local_t *local = NULL; + int op_errno = ENODATA; + int ret = 0; + dict_t *xattr = NULL; + struct mdc_conf *conf = this->private; - local = mdc_local_get (frame, fd->inode); + local = mdc_local_get(frame, fd->inode); - local->fd = fd_ref (fd); + local->fd = fd_ref(fd); - local->key = gf_strdup (name); + local->key = gf_strdup(name); - if (!is_mdc_key_satisfied (this, name)) - goto uncached; + if (!is_mdc_key_satisfied(this, name)) + goto uncached; - ret = mdc_inode_xatt_get (this, fd->inode, &xattr); - if (ret != 0) - goto uncached; + ret = mdc_inode_xatt_get(this, fd->inode, &xattr); + if (ret != 0) + goto uncached; - if (!xattr || !dict_get (xattr, (char *)name)) { - ret = -1; - op_errno = ENODATA; - } + if (!xattr || !dict_get(xattr, (char *)name)) { + ret = -1; + op_errno = ENODATA; + } - GF_ATOMIC_INC (conf->mdc_counter.xattr_hit); - MDC_STACK_UNWIND (fremovexattr, frame, ret, op_errno, xdata); - return 0; + GF_ATOMIC_INC(conf->mdc_counter.xattr_hit); + MDC_STACK_UNWIND(fremovexattr, frame, ret, op_errno, xdata); + return 0; uncached: - GF_ATOMIC_INC (conf->mdc_counter.xattr_miss); - STACK_WIND (frame, mdc_fremovexattr_cbk, - FIRST_CHILD(this), FIRST_CHILD(this)->fops->fremovexattr, - fd, name, xdata); - return 0; + GF_ATOMIC_INC(conf->mdc_counter.xattr_miss); + STACK_WIND(frame, mdc_fremovexattr_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->fremovexattr, fd, name, xdata); + return 0; } int32_t -mdc_opendir_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, fd_t *fd, - dict_t *xdata) +mdc_opendir_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, fd_t *fd, dict_t *xdata) { - mdc_local_t *local = NULL; + mdc_local_t *local = NULL; - local = frame->local; - if (!local) - goto out; + local = frame->local; + if (!local) + goto out; - if (op_ret == 0) - goto out; + if (op_ret == 0) + goto out; - if ((op_errno == ESTALE) || (op_errno == ENOENT)) - mdc_inode_iatt_invalidate (this, local->loc.inode); + if ((op_errno == ESTALE) || (op_errno == ENOENT)) + mdc_inode_iatt_invalidate(this, local->loc.inode); out: - MDC_STACK_UNWIND (opendir, frame, op_ret, op_errno, fd, xdata); - return 0; + MDC_STACK_UNWIND(opendir, frame, op_ret, op_errno, fd, xdata); + return 0; } - int -mdc_opendir(call_frame_t *frame, xlator_t *this, loc_t *loc, - fd_t *fd, dict_t *xdata) +mdc_opendir(call_frame_t *frame, xlator_t *this, loc_t *loc, fd_t *fd, + dict_t *xdata) { - dict_t *xattr_alloc = NULL; - mdc_local_t *local = NULL; + dict_t *xattr_alloc = NULL; + mdc_local_t *local = NULL; - local = mdc_local_get (frame, loc->inode); + local = mdc_local_get(frame, loc->inode); - loc_copy (&local->loc, loc); + loc_copy(&local->loc, loc); - if (!xdata) - xdata = xattr_alloc = dict_new (); + if (!xdata) + xdata = xattr_alloc = dict_new(); - if (xdata) { - /* Tell readdir-ahead to include these keys in xdata when it - * internally issues readdirp() in it's opendir_cbk */ - mdc_load_reqs (this, xdata); - } + if (xdata) { + /* Tell readdir-ahead to include these keys in xdata when it + * internally issues readdirp() in it's opendir_cbk */ + mdc_load_reqs(this, xdata); + } - STACK_WIND (frame, mdc_opendir_cbk, FIRST_CHILD(this), - FIRST_CHILD(this)->fops->opendir, loc, fd, xdata); + STACK_WIND(frame, mdc_opendir_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->opendir, loc, fd, xdata); - if (xattr_alloc) - dict_unref (xattr_alloc); + if (xattr_alloc) + dict_unref(xattr_alloc); - return 0; + return 0; } - int -mdc_readdirp_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int op_ret, int op_errno, gf_dirent_t *entries, dict_t *xdata) +mdc_readdirp_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int op_ret, + int op_errno, gf_dirent_t *entries, dict_t *xdata) { - gf_dirent_t *entry = NULL; - mdc_local_t *local = NULL; + gf_dirent_t *entry = NULL; + mdc_local_t *local = NULL; - local = frame->local; - if (!local) - goto unwind; + local = frame->local; + if (!local) + goto unwind; - if (op_ret <= 0) { - if ((op_ret == -1) && ((op_errno == ENOENT) - || (op_errno == ESTALE))) - mdc_inode_iatt_invalidate (this, local->fd->inode); - goto unwind; - } + if (op_ret <= 0) { + if ((op_ret == -1) && ((op_errno == ENOENT) || (op_errno == ESTALE))) + mdc_inode_iatt_invalidate(this, local->fd->inode); + goto unwind; + } - list_for_each_entry (entry, &entries->list, list) { - if (!entry->inode) - continue; - mdc_inode_iatt_set (this, entry->inode, &entry->d_stat, - local->incident_time); - mdc_inode_xatt_set (this, entry->inode, entry->dict); - } + list_for_each_entry(entry, &entries->list, list) + { + if (!entry->inode) + continue; + mdc_inode_iatt_set(this, entry->inode, &entry->d_stat, + local->incident_time); + mdc_inode_xatt_set(this, entry->inode, entry->dict); + } unwind: - MDC_STACK_UNWIND (readdirp, frame, op_ret, op_errno, entries, xdata); - return 0; + MDC_STACK_UNWIND(readdirp, frame, op_ret, op_errno, entries, xdata); + return 0; } - int -mdc_readdirp (call_frame_t *frame, xlator_t *this, fd_t *fd, - size_t size, off_t offset, dict_t *xdata) +mdc_readdirp(call_frame_t *frame, xlator_t *this, fd_t *fd, size_t size, + off_t offset, dict_t *xdata) { - dict_t *xattr_alloc = NULL; - mdc_local_t *local = NULL; + dict_t *xattr_alloc = NULL; + mdc_local_t *local = NULL; - local = mdc_local_get (frame, fd->inode); - if (!local) - goto out; + local = mdc_local_get(frame, fd->inode); + if (!local) + goto out; - local->fd = fd_ref (fd); + local->fd = fd_ref(fd); - if (!xdata) - xdata = xattr_alloc = dict_new (); - if (xdata) - mdc_load_reqs (this, xdata); + if (!xdata) + xdata = xattr_alloc = dict_new(); + if (xdata) + mdc_load_reqs(this, xdata); - STACK_WIND (frame, mdc_readdirp_cbk, - FIRST_CHILD (this), FIRST_CHILD (this)->fops->readdirp, - fd, size, offset, xdata); - if (xattr_alloc) - dict_unref (xattr_alloc); - return 0; + STACK_WIND(frame, mdc_readdirp_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->readdirp, fd, size, offset, xdata); + if (xattr_alloc) + dict_unref(xattr_alloc); + return 0; out: - STACK_UNWIND_STRICT (readdirp, frame, -1, ENOMEM, NULL, NULL); - return 0; + STACK_UNWIND_STRICT(readdirp, frame, -1, ENOMEM, NULL, NULL); + return 0; } int mdc_readdir_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int op_ret, - int op_errno, gf_dirent_t *entries, dict_t *xdata) + int op_errno, gf_dirent_t *entries, dict_t *xdata) { - mdc_local_t *local = NULL; + mdc_local_t *local = NULL; - local = frame->local; - if (!local) - goto out; + local = frame->local; + if (!local) + goto out; - if (op_ret == 0) - goto out; + if (op_ret == 0) + goto out; - if ((op_errno == ESTALE) || (op_errno == ENOENT)) - mdc_inode_iatt_invalidate (this, local->fd->inode); + if ((op_errno == ESTALE) || (op_errno == ENOENT)) + mdc_inode_iatt_invalidate(this, local->fd->inode); out: - MDC_STACK_UNWIND (readdir, frame, op_ret, op_errno, entries, xdata); - return 0; + MDC_STACK_UNWIND(readdir, frame, op_ret, op_errno, entries, xdata); + return 0; } int -mdc_readdir (call_frame_t *frame, xlator_t *this, fd_t *fd, - size_t size, off_t offset, dict_t *xdata) +mdc_readdir(call_frame_t *frame, xlator_t *this, fd_t *fd, size_t size, + off_t offset, dict_t *xdata) { - int need_unref = 0; - mdc_local_t *local = NULL; - struct mdc_conf *conf = this->private; + int need_unref = 0; + mdc_local_t *local = NULL; + struct mdc_conf *conf = this->private; - local = mdc_local_get (frame, fd->inode); - if (!local) - goto unwind; + local = mdc_local_get(frame, fd->inode); + if (!local) + goto unwind; - local->fd = fd_ref (fd); + local->fd = fd_ref(fd); - if (!conf->force_readdirp) { - STACK_WIND(frame, mdc_readdir_cbk, FIRST_CHILD(this), - FIRST_CHILD(this)->fops->readdir, fd, size, offset, - xdata); - return 0; - } + if (!conf->force_readdirp) { + STACK_WIND(frame, mdc_readdir_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->readdir, fd, size, offset, xdata); + return 0; + } - if (!xdata) { - xdata = dict_new (); - need_unref = 1; - } + if (!xdata) { + xdata = dict_new(); + need_unref = 1; + } - if (xdata) - mdc_load_reqs (this, xdata); + if (xdata) + mdc_load_reqs(this, xdata); - STACK_WIND(frame, mdc_readdirp_cbk, FIRST_CHILD(this), - FIRST_CHILD(this)->fops->readdirp, fd, size, offset, - xdata); + STACK_WIND(frame, mdc_readdirp_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->readdirp, fd, size, offset, xdata); - if (need_unref && xdata) - dict_unref (xdata); + if (need_unref && xdata) + dict_unref(xdata); - return 0; + return 0; unwind: - MDC_STACK_UNWIND (readdir, frame, -1, ENOMEM, NULL, NULL); - return 0; + MDC_STACK_UNWIND(readdir, frame, -1, ENOMEM, NULL, NULL); + return 0; } int mdc_fallocate_cbk(call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, - struct iatt *prebuf, struct iatt *postbuf, dict_t *xdata) + int32_t op_ret, int32_t op_errno, struct iatt *prebuf, + struct iatt *postbuf, dict_t *xdata) { - mdc_local_t *local = NULL; + mdc_local_t *local = NULL; - local = frame->local; - if (!local) - goto out; + local = frame->local; + if (!local) + goto out; - if (op_ret != 0) { - if ((op_errno == ENOENT) || (op_errno == ESTALE)) - mdc_inode_iatt_invalidate (this, local->fd->inode); - goto out; - } + if (op_ret != 0) { + if ((op_errno == ENOENT) || (op_errno == ESTALE)) + mdc_inode_iatt_invalidate(this, local->fd->inode); + goto out; + } - mdc_inode_iatt_set_validate(this, local->fd->inode, prebuf, postbuf, - _gf_true, local->incident_time); + mdc_inode_iatt_set_validate(this, local->fd->inode, prebuf, postbuf, + _gf_true, local->incident_time); out: - MDC_STACK_UNWIND (fallocate, frame, op_ret, op_errno, prebuf, postbuf, - xdata); + MDC_STACK_UNWIND(fallocate, frame, op_ret, op_errno, prebuf, postbuf, + xdata); - return 0; + return 0; } -int mdc_fallocate(call_frame_t *frame, xlator_t *this, fd_t *fd, int32_t mode, - off_t offset, size_t len, dict_t *xdata) +int +mdc_fallocate(call_frame_t *frame, xlator_t *this, fd_t *fd, int32_t mode, + off_t offset, size_t len, dict_t *xdata) { - mdc_local_t *local; + mdc_local_t *local; - local = mdc_local_get (frame, fd->inode); - local->fd = fd_ref(fd); + local = mdc_local_get(frame, fd->inode); + local->fd = fd_ref(fd); - STACK_WIND(frame, mdc_fallocate_cbk, FIRST_CHILD(this), - FIRST_CHILD(this)->fops->fallocate, fd, mode, offset, len, - xdata); + STACK_WIND(frame, mdc_fallocate_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->fallocate, fd, mode, offset, len, + xdata); - return 0; + return 0; } int mdc_discard_cbk(call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, - struct iatt *prebuf, struct iatt *postbuf, dict_t *xdata) + int32_t op_ret, int32_t op_errno, struct iatt *prebuf, + struct iatt *postbuf, dict_t *xdata) { - mdc_local_t *local = NULL; + mdc_local_t *local = NULL; - local = frame->local; - if (!local) - goto out; + local = frame->local; + if (!local) + goto out; - if (op_ret != 0) { - if ((op_errno == ENOENT) || (op_errno == ESTALE)) - mdc_inode_iatt_invalidate (this, local->fd->inode); - goto out; - } + if (op_ret != 0) { + if ((op_errno == ENOENT) || (op_errno == ESTALE)) + mdc_inode_iatt_invalidate(this, local->fd->inode); + goto out; + } - mdc_inode_iatt_set_validate(this, local->fd->inode, prebuf, postbuf, - _gf_true, local->incident_time); + mdc_inode_iatt_set_validate(this, local->fd->inode, prebuf, postbuf, + _gf_true, local->incident_time); out: - MDC_STACK_UNWIND(discard, frame, op_ret, op_errno, prebuf, postbuf, - xdata); + MDC_STACK_UNWIND(discard, frame, op_ret, op_errno, prebuf, postbuf, xdata); - return 0; + return 0; } -int mdc_discard(call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset, - size_t len, dict_t *xdata) +int +mdc_discard(call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset, + size_t len, dict_t *xdata) { - mdc_local_t *local; + mdc_local_t *local; - local = mdc_local_get (frame, fd->inode); - local->fd = fd_ref(fd); + local = mdc_local_get(frame, fd->inode); + local->fd = fd_ref(fd); - STACK_WIND(frame, mdc_discard_cbk, FIRST_CHILD(this), - FIRST_CHILD(this)->fops->discard, fd, offset, len, - xdata); + STACK_WIND(frame, mdc_discard_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->discard, fd, offset, len, xdata); - return 0; + return 0; } int mdc_zerofill_cbk(call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, - struct iatt *prebuf, struct iatt *postbuf, dict_t *xdata) + int32_t op_ret, int32_t op_errno, struct iatt *prebuf, + struct iatt *postbuf, dict_t *xdata) { - mdc_local_t *local = NULL; + mdc_local_t *local = NULL; - local = frame->local; - if (!local) - goto out; + local = frame->local; + if (!local) + goto out; - if (op_ret != 0) { - if ((op_errno == ENOENT) || (op_errno == ESTALE)) - mdc_inode_iatt_invalidate (this, local->fd->inode); - goto out; - } + if (op_ret != 0) { + if ((op_errno == ENOENT) || (op_errno == ESTALE)) + mdc_inode_iatt_invalidate(this, local->fd->inode); + goto out; + } - mdc_inode_iatt_set_validate(this, local->fd->inode, prebuf, postbuf, - _gf_true, local->incident_time); + mdc_inode_iatt_set_validate(this, local->fd->inode, prebuf, postbuf, + _gf_true, local->incident_time); out: - MDC_STACK_UNWIND(zerofill, frame, op_ret, op_errno, prebuf, postbuf, - xdata); + MDC_STACK_UNWIND(zerofill, frame, op_ret, op_errno, prebuf, postbuf, xdata); - return 0; + return 0; } -int mdc_zerofill(call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset, - off_t len, dict_t *xdata) +int +mdc_zerofill(call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset, + off_t len, dict_t *xdata) { - mdc_local_t *local; + mdc_local_t *local; - local = mdc_local_get (frame, fd->inode); - local->fd = fd_ref(fd); + local = mdc_local_get(frame, fd->inode); + local->fd = fd_ref(fd); - STACK_WIND(frame, mdc_zerofill_cbk, FIRST_CHILD(this), - FIRST_CHILD(this)->fops->zerofill, fd, offset, len, - xdata); + STACK_WIND(frame, mdc_zerofill_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->zerofill, fd, offset, len, xdata); - return 0; + return 0; } int32_t -mdc_readlink_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, const char *path, - struct iatt *buf, dict_t *xdata) +mdc_readlink_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, const char *path, + struct iatt *buf, dict_t *xdata) { - mdc_local_t *local = NULL; + mdc_local_t *local = NULL; - local = frame->local; - if (!local) - goto out; + local = frame->local; + if (!local) + goto out; - if (op_ret == 0) - goto out; + if (op_ret == 0) + goto out; - if ((op_errno == ENOENT) || (op_errno == ESTALE)) - mdc_inode_iatt_invalidate (this, local->loc.inode); + if ((op_errno == ENOENT) || (op_errno == ESTALE)) + mdc_inode_iatt_invalidate(this, local->loc.inode); out: - MDC_STACK_UNWIND (readlink, frame, op_ret, op_errno, - path, buf, xdata); - return 0; + MDC_STACK_UNWIND(readlink, frame, op_ret, op_errno, path, buf, xdata); + return 0; } int32_t -mdc_readlink (call_frame_t *frame, xlator_t *this, loc_t *loc, size_t size, - dict_t *xdata) +mdc_readlink(call_frame_t *frame, xlator_t *this, loc_t *loc, size_t size, + dict_t *xdata) { - mdc_local_t *local = NULL; + mdc_local_t *local = NULL; - local = mdc_local_get (frame, loc->inode); - if (!local) - goto unwind; + local = mdc_local_get(frame, loc->inode); + if (!local) + goto unwind; - loc_copy (&local->loc, loc); + loc_copy(&local->loc, loc); - STACK_WIND (frame, mdc_readlink_cbk, FIRST_CHILD(this), - FIRST_CHILD(this)->fops->readlink, - loc, size, xdata); - return 0; + STACK_WIND(frame, mdc_readlink_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->readlink, loc, size, xdata); + return 0; unwind: - MDC_STACK_UNWIND (readlink, frame, -1, ENOMEM, NULL, NULL, NULL); - return 0; + MDC_STACK_UNWIND(readlink, frame, -1, ENOMEM, NULL, NULL, NULL); + return 0; } int32_t -mdc_fsyncdir_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, dict_t *xdata) +mdc_fsyncdir_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, dict_t *xdata) { - mdc_local_t *local = NULL; + mdc_local_t *local = NULL; - local = frame->local; - if (!local) - goto out; + local = frame->local; + if (!local) + goto out; - if (op_ret == 0) - goto out; + if (op_ret == 0) + goto out; - if ((op_errno == ESTALE) || (op_errno == ENOENT)) - mdc_inode_iatt_invalidate (this, local->fd->inode); + if ((op_errno == ESTALE) || (op_errno == ENOENT)) + mdc_inode_iatt_invalidate(this, local->fd->inode); out: - MDC_STACK_UNWIND (fsyncdir, frame, op_ret, op_errno, xdata); - return 0; + MDC_STACK_UNWIND(fsyncdir, frame, op_ret, op_errno, xdata); + return 0; } int32_t -mdc_fsyncdir (call_frame_t *frame, xlator_t *this, fd_t *fd, int32_t flags, - dict_t *xdata) +mdc_fsyncdir(call_frame_t *frame, xlator_t *this, fd_t *fd, int32_t flags, + dict_t *xdata) { - mdc_local_t *local = NULL; + mdc_local_t *local = NULL; - local = mdc_local_get (frame, fd->inode); - if (!local) - goto unwind; + local = mdc_local_get(frame, fd->inode); + if (!local) + goto unwind; - local->fd = fd_ref (fd); + local->fd = fd_ref(fd); - STACK_WIND (frame, mdc_fsyncdir_cbk, FIRST_CHILD(this), - FIRST_CHILD(this)->fops->fsyncdir, fd, flags, xdata); - return 0; + STACK_WIND(frame, mdc_fsyncdir_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->fsyncdir, fd, flags, xdata); + return 0; unwind: - MDC_STACK_UNWIND (fsyncdir, frame, -1, ENOMEM, NULL); - return 0; + MDC_STACK_UNWIND(fsyncdir, frame, -1, ENOMEM, NULL); + return 0; } int32_t -mdc_access_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, dict_t *xdata) +mdc_access_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, dict_t *xdata) { - mdc_local_t *local = NULL; + mdc_local_t *local = NULL; - local = frame->local; - if (!local) - goto out; + local = frame->local; + if (!local) + goto out; - if (op_ret == 0) - goto out; + if (op_ret == 0) + goto out; - if ((op_errno == ESTALE) || (op_errno == ENOENT)) - mdc_inode_iatt_invalidate (this, local->loc.inode); + if ((op_errno == ESTALE) || (op_errno == ENOENT)) + mdc_inode_iatt_invalidate(this, local->loc.inode); out: - MDC_STACK_UNWIND (access, frame, op_ret, op_errno, xdata); - return 0; + MDC_STACK_UNWIND(access, frame, op_ret, op_errno, xdata); + return 0; } - - int32_t -mdc_access (call_frame_t *frame, xlator_t *this, loc_t *loc, int32_t mask, - dict_t *xdata) +mdc_access(call_frame_t *frame, xlator_t *this, loc_t *loc, int32_t mask, + dict_t *xdata) { - mdc_local_t *local = NULL; + mdc_local_t *local = NULL; - local = mdc_local_get (frame, loc->inode); - if (!local) - goto unwind; + local = mdc_local_get(frame, loc->inode); + if (!local) + goto unwind; - loc_copy (&local->loc, loc); + loc_copy(&local->loc, loc); - STACK_WIND (frame, mdc_access_cbk, FIRST_CHILD(this), - FIRST_CHILD(this)->fops->access, loc, mask, xdata); - return 0; + STACK_WIND(frame, mdc_access_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->access, loc, mask, xdata); + return 0; unwind: - MDC_STACK_UNWIND (access, frame, -1, ENOMEM, NULL); - return 0; + MDC_STACK_UNWIND(access, frame, -1, ENOMEM, NULL); + return 0; } - int -mdc_priv_dump (xlator_t *this) +mdc_priv_dump(xlator_t *this) { - struct mdc_conf *conf = NULL; - char key_prefix[GF_DUMP_MAX_BUF_LEN]; + struct mdc_conf *conf = NULL; + char key_prefix[GF_DUMP_MAX_BUF_LEN]; - conf = this->private; + conf = this->private; - snprintf(key_prefix, GF_DUMP_MAX_BUF_LEN, "%s.%s", this->type, this->name); - gf_proc_dump_add_section(key_prefix); + 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("stat_hit_count", "%"PRId64, - GF_ATOMIC_GET(conf->mdc_counter.stat_hit)); - gf_proc_dump_write("stat_miss_count", "%"PRId64, - GF_ATOMIC_GET(conf->mdc_counter.stat_miss)); - gf_proc_dump_write("xattr_hit_count", "%"PRId64, - GF_ATOMIC_GET(conf->mdc_counter.xattr_hit)); - gf_proc_dump_write("xattr_miss_count", "%"PRId64, - GF_ATOMIC_GET(conf->mdc_counter.xattr_miss)); - gf_proc_dump_write("nameless_lookup_count", "%"PRId64, - GF_ATOMIC_GET(conf->mdc_counter.nameless_lookup)); - gf_proc_dump_write("negative_lookup_count", "%"PRId64, - GF_ATOMIC_GET(conf->mdc_counter.negative_lookup)); - gf_proc_dump_write("stat_invalidations_received", "%"PRId64, - GF_ATOMIC_GET(conf->mdc_counter.stat_invals)); - gf_proc_dump_write("xattr_invalidations_received", "%"PRId64, - GF_ATOMIC_GET(conf->mdc_counter.xattr_invals)); + gf_proc_dump_write("stat_hit_count", "%" PRId64, + GF_ATOMIC_GET(conf->mdc_counter.stat_hit)); + gf_proc_dump_write("stat_miss_count", "%" PRId64, + GF_ATOMIC_GET(conf->mdc_counter.stat_miss)); + gf_proc_dump_write("xattr_hit_count", "%" PRId64, + GF_ATOMIC_GET(conf->mdc_counter.xattr_hit)); + gf_proc_dump_write("xattr_miss_count", "%" PRId64, + GF_ATOMIC_GET(conf->mdc_counter.xattr_miss)); + gf_proc_dump_write("nameless_lookup_count", "%" PRId64, + GF_ATOMIC_GET(conf->mdc_counter.nameless_lookup)); + gf_proc_dump_write("negative_lookup_count", "%" PRId64, + GF_ATOMIC_GET(conf->mdc_counter.negative_lookup)); + gf_proc_dump_write("stat_invalidations_received", "%" PRId64, + GF_ATOMIC_GET(conf->mdc_counter.stat_invals)); + gf_proc_dump_write("xattr_invalidations_received", "%" PRId64, + GF_ATOMIC_GET(conf->mdc_counter.xattr_invals)); - return 0; + return 0; } - static int32_t -mdc_dump_metrics (xlator_t *this, int fd) -{ - struct mdc_conf *conf = NULL; - - conf = this->private; - if (!conf) - goto out; - - dprintf (fd, "%s.stat_cache_hit_count %"PRId64"\n", this->name, - GF_ATOMIC_GET(conf->mdc_counter.stat_hit)); - dprintf (fd, "%s.stat_cache_miss_count %"PRId64"\n", this->name, - GF_ATOMIC_GET(conf->mdc_counter.stat_miss)); - dprintf (fd, "%s.xattr_cache_hit_count %"PRId64"\n", this->name, - GF_ATOMIC_GET(conf->mdc_counter.xattr_hit)); - dprintf (fd, "%s.xattr_cache_miss_count %"PRId64"\n", this->name, - GF_ATOMIC_GET(conf->mdc_counter.xattr_miss)); - dprintf (fd, "%s.nameless_lookup_count %"PRId64"\n", this->name, - GF_ATOMIC_GET(conf->mdc_counter.nameless_lookup)); - dprintf (fd, "%s.negative_lookup_count %"PRId64"\n", this->name, - GF_ATOMIC_GET(conf->mdc_counter.negative_lookup)); - dprintf (fd, "%s.stat_cache_invalidations_received %"PRId64"\n", - this->name, - GF_ATOMIC_GET(conf->mdc_counter.stat_invals)); - dprintf (fd, "%s.xattr_cache_invalidations_received %"PRId64"\n", - this->name, - GF_ATOMIC_GET(conf->mdc_counter.xattr_invals)); +mdc_dump_metrics(xlator_t *this, int fd) +{ + struct mdc_conf *conf = NULL; + + conf = this->private; + if (!conf) + goto out; + + dprintf(fd, "%s.stat_cache_hit_count %" PRId64 "\n", this->name, + GF_ATOMIC_GET(conf->mdc_counter.stat_hit)); + dprintf(fd, "%s.stat_cache_miss_count %" PRId64 "\n", this->name, + GF_ATOMIC_GET(conf->mdc_counter.stat_miss)); + dprintf(fd, "%s.xattr_cache_hit_count %" PRId64 "\n", this->name, + GF_ATOMIC_GET(conf->mdc_counter.xattr_hit)); + dprintf(fd, "%s.xattr_cache_miss_count %" PRId64 "\n", this->name, + GF_ATOMIC_GET(conf->mdc_counter.xattr_miss)); + dprintf(fd, "%s.nameless_lookup_count %" PRId64 "\n", this->name, + GF_ATOMIC_GET(conf->mdc_counter.nameless_lookup)); + dprintf(fd, "%s.negative_lookup_count %" PRId64 "\n", this->name, + GF_ATOMIC_GET(conf->mdc_counter.negative_lookup)); + dprintf(fd, "%s.stat_cache_invalidations_received %" PRId64 "\n", + this->name, GF_ATOMIC_GET(conf->mdc_counter.stat_invals)); + dprintf(fd, "%s.xattr_cache_invalidations_received %" PRId64 "\n", + this->name, GF_ATOMIC_GET(conf->mdc_counter.xattr_invals)); out: - return 0; + return 0; } - int -mdc_forget (xlator_t *this, inode_t *inode) +mdc_forget(xlator_t *this, inode_t *inode) { - mdc_inode_wipe (this, inode); + mdc_inode_wipe(this, inode); - return 0; + return 0; } - int -is_strpfx (const char *str1, const char *str2) +is_strpfx(const char *str1, const char *str2) { - /* is one of the string a prefix of the other? */ - int i; + /* is one of the string a prefix of the other? */ + int i; - for (i = 0; str1[i] == str2[i]; i++) { - if (!str1[i] || !str2[i]) - break; - } + for (i = 0; str1[i] == str2[i]; i++) { + if (!str1[i] || !str2[i]) + break; + } - return !(str1[i] && str2[i]); + return !(str1[i] && str2[i]); } - static int -mdc_key_unload_all (struct mdc_conf *conf) +mdc_key_unload_all(struct mdc_conf *conf) { - conf->mdc_xattr_str = NULL; + conf->mdc_xattr_str = NULL; - return 0; + return 0; } - int -mdc_xattr_list_populate (struct mdc_conf *conf, char *tmp_str) +mdc_xattr_list_populate(struct mdc_conf *conf, char *tmp_str) { - char *mdc_xattr_str = NULL; - size_t max_size = 0; - int ret = 0; + char *mdc_xattr_str = NULL; + size_t max_size = 0; + int ret = 0; - max_size = SLEN ("security.capability,security.selinux,security.ima," - POSIX_ACL_ACCESS_XATTR","POSIX_ACL_DEFAULT_XATTR"," - GF_POSIX_ACL_ACCESS","GF_POSIX_ACL_DEFAULT"," - "user.swift.metadata,user.DOSATTRIB,user.DosStream.*" - ",user.org.netatalk.Metadata,security.NTACL," - "user.org.netatalk.ResourceFork") - + strlen (tmp_str) + 5; /*Some buffer bytes*/ + max_size = SLEN( + "security.capability,security.selinux,security." + "ima," POSIX_ACL_ACCESS_XATTR "," POSIX_ACL_DEFAULT_XATTR + "," GF_POSIX_ACL_ACCESS "," GF_POSIX_ACL_DEFAULT + "," + "user.swift.metadata,user.DOSATTRIB,user.DosStream.*" + ",user.org.netatalk.Metadata,security.NTACL," + "user.org.netatalk.ResourceFork") + + strlen(tmp_str) + 5; /*Some buffer bytes*/ - mdc_xattr_str = GF_MALLOC (max_size, gf_common_mt_char); - GF_CHECK_ALLOC (mdc_xattr_str, ret, out); + mdc_xattr_str = GF_MALLOC(max_size, gf_common_mt_char); + GF_CHECK_ALLOC(mdc_xattr_str, ret, out); - if (conf->cache_capability) - strcat (mdc_xattr_str, "security.capability,"); + if (conf->cache_capability) + strcat(mdc_xattr_str, "security.capability,"); - if (conf->cache_selinux) - strcat (mdc_xattr_str, "security.selinux,"); + if (conf->cache_selinux) + strcat(mdc_xattr_str, "security.selinux,"); - if (conf->cache_ima) - strcat (mdc_xattr_str, "security.ima,"); + if (conf->cache_ima) + strcat(mdc_xattr_str, "security.ima,"); - if (conf->cache_posix_acl) - strcat (mdc_xattr_str, POSIX_ACL_ACCESS_XATTR"," - POSIX_ACL_DEFAULT_XATTR","GF_POSIX_ACL_ACCESS - ","GF_POSIX_ACL_DEFAULT","); + if (conf->cache_posix_acl) + strcat(mdc_xattr_str, POSIX_ACL_ACCESS_XATTR + "," POSIX_ACL_DEFAULT_XATTR "," GF_POSIX_ACL_ACCESS + "," GF_POSIX_ACL_DEFAULT ","); - if (conf->cache_swift_metadata) - strcat (mdc_xattr_str, "user.swift.metadata,"); + if (conf->cache_swift_metadata) + strcat(mdc_xattr_str, "user.swift.metadata,"); - if (conf->cache_samba_metadata) - strcat (mdc_xattr_str, "user.DOSATTRIB,user.DosStream.*," - "user.org.netatalk.Metadata,user.org.netatalk." - "ResourceFork,security.NTACL,"); + if (conf->cache_samba_metadata) + strcat(mdc_xattr_str, + "user.DOSATTRIB,user.DosStream.*," + "user.org.netatalk.Metadata,user.org.netatalk." + "ResourceFork,security.NTACL,"); - strcat (mdc_xattr_str, tmp_str); + strcat(mdc_xattr_str, tmp_str); - LOCK (&conf->lock); - { - /* This is not freed, else is_mdc_key_satisfied, which is - * called by every fop has to take lock, and will lead to - * lock contention - */ - conf->mdc_xattr_str = mdc_xattr_str; - } - UNLOCK (&conf->lock); + LOCK(&conf->lock); + { + /* This is not freed, else is_mdc_key_satisfied, which is + * called by every fop has to take lock, and will lead to + * lock contention + */ + conf->mdc_xattr_str = mdc_xattr_str; + } + UNLOCK(&conf->lock); out: - return ret; + return ret; } - struct set { - inode_t *inode; - xlator_t *this; + inode_t *inode; + xlator_t *this; }; static int -mdc_inval_xatt (dict_t *d, char *k, data_t *v, void *tmp) +mdc_inval_xatt(dict_t *d, char *k, data_t *v, void *tmp) { - struct set *tmp1 = NULL; - int ret = 0; + struct set *tmp1 = NULL; + int ret = 0; - tmp1 = (struct set *)tmp; - ret = mdc_inode_xatt_unset (tmp1->this, tmp1->inode, k); - return ret; + tmp1 = (struct set *)tmp; + ret = mdc_inode_xatt_unset(tmp1->this, tmp1->inode, k); + return ret; } static int -mdc_invalidate (xlator_t *this, void *data) -{ - struct gf_upcall *up_data = NULL; - struct gf_upcall_cache_invalidation *up_ci = NULL; - inode_t *inode = NULL; - int ret = 0; - struct set tmp = {0, }; - inode_table_t *itable = NULL; - struct mdc_conf *conf = this->private; - uint64_t gen = 0; - - up_data = (struct gf_upcall *)data; - - if (up_data->event_type != GF_UPCALL_CACHE_INVALIDATION) - goto out; - - up_ci = (struct gf_upcall_cache_invalidation *)up_data->data; - - itable = ((xlator_t *)this->graph->top)->itable; - inode = inode_find (itable, up_data->gfid); - if (!inode) { - ret = -1; - goto out; - } - - if (up_ci->flags & UP_PARENT_DENTRY_FLAGS) { - mdc_update_gfid_stat (this, &up_ci->p_stat); - if (up_ci->flags & UP_RENAME_FLAGS) - mdc_update_gfid_stat (this, &up_ci->oldp_stat); - } - - if (up_ci->flags & UP_EXPLICIT_LOOKUP) { - mdc_inode_set_need_lookup (this, inode, _gf_true); - goto out; - } - - if (up_ci->flags & - (UP_NLINK | UP_RENAME_FLAGS | UP_FORGET | UP_INVAL_ATTR)) { - mdc_inode_iatt_invalidate (this, inode); - mdc_inode_xatt_invalidate (this, inode); - GF_ATOMIC_INC (conf->mdc_counter.stat_invals); - goto out; - } - - if (up_ci->flags & IATT_UPDATE_FLAGS) { - gen = mdc_get_generation (this, inode); - ret = mdc_inode_iatt_set_validate (this, inode, NULL, - &up_ci->stat, _gf_false, - gen); - /* one of the scenarios where ret < 0 is when this invalidate - * is older than the current stat, in that case do not - * update the xattrs as well - */ - if (ret < 0) - goto out; - GF_ATOMIC_INC (conf->mdc_counter.stat_invals); - } +mdc_invalidate(xlator_t *this, void *data) +{ + struct gf_upcall *up_data = NULL; + struct gf_upcall_cache_invalidation *up_ci = NULL; + inode_t *inode = NULL; + int ret = 0; + struct set tmp = { + 0, + }; + inode_table_t *itable = NULL; + struct mdc_conf *conf = this->private; + uint64_t gen = 0; + + up_data = (struct gf_upcall *)data; + + if (up_data->event_type != GF_UPCALL_CACHE_INVALIDATION) + goto out; + + up_ci = (struct gf_upcall_cache_invalidation *)up_data->data; + + itable = ((xlator_t *)this->graph->top)->itable; + inode = inode_find(itable, up_data->gfid); + if (!inode) { + ret = -1; + goto out; + } + + if (up_ci->flags & UP_PARENT_DENTRY_FLAGS) { + mdc_update_gfid_stat(this, &up_ci->p_stat); + if (up_ci->flags & UP_RENAME_FLAGS) + mdc_update_gfid_stat(this, &up_ci->oldp_stat); + } + + if (up_ci->flags & UP_EXPLICIT_LOOKUP) { + mdc_inode_set_need_lookup(this, inode, _gf_true); + goto out; + } + + if (up_ci->flags & + (UP_NLINK | UP_RENAME_FLAGS | UP_FORGET | UP_INVAL_ATTR)) { + mdc_inode_iatt_invalidate(this, inode); + mdc_inode_xatt_invalidate(this, inode); + GF_ATOMIC_INC(conf->mdc_counter.stat_invals); + goto out; + } + + if (up_ci->flags & IATT_UPDATE_FLAGS) { + gen = mdc_get_generation(this, inode); + ret = mdc_inode_iatt_set_validate(this, inode, NULL, &up_ci->stat, + _gf_false, gen); + /* one of the scenarios where ret < 0 is when this invalidate + * is older than the current stat, in that case do not + * update the xattrs as well + */ + if (ret < 0) + goto out; + GF_ATOMIC_INC(conf->mdc_counter.stat_invals); + } - if (up_ci->flags & UP_XATTR) { - if (up_ci->dict) - ret = mdc_inode_xatt_update (this, inode, up_ci->dict); - else - ret = mdc_inode_xatt_invalidate (this, inode); + if (up_ci->flags & UP_XATTR) { + if (up_ci->dict) + ret = mdc_inode_xatt_update(this, inode, up_ci->dict); + else + ret = mdc_inode_xatt_invalidate(this, inode); - GF_ATOMIC_INC (conf->mdc_counter.xattr_invals); - } else if (up_ci->flags & UP_XATTR_RM) { - tmp.inode = inode; - tmp.this = this; - ret = dict_foreach (up_ci->dict, mdc_inval_xatt, &tmp); + GF_ATOMIC_INC(conf->mdc_counter.xattr_invals); + } else if (up_ci->flags & UP_XATTR_RM) { + tmp.inode = inode; + tmp.this = this; + ret = dict_foreach(up_ci->dict, mdc_inval_xatt, &tmp); - GF_ATOMIC_INC (conf->mdc_counter.xattr_invals); - } + GF_ATOMIC_INC(conf->mdc_counter.xattr_invals); + } out: - if (inode) - inode_unref (inode); + if (inode) + inode_unref(inode); - return ret; + return ret; } struct mdc_ipc { - xlator_t *this; - dict_t *xattr; + xlator_t *this; + dict_t *xattr; }; static int -mdc_send_xattrs_cbk (int ret, call_frame_t *frame, void *data) +mdc_send_xattrs_cbk(int ret, call_frame_t *frame, void *data) { - struct mdc_ipc *tmp = data; + struct mdc_ipc *tmp = data; - if (ret < 0) { - mdc_key_unload_all (THIS->private); - gf_msg ("md-cache", GF_LOG_INFO, 0, MD_CACHE_MSG_NO_XATTR_CACHE, - "Disabled cache for all xattrs, as registering for " - "xattr cache invalidation failed"); - } - STACK_DESTROY (frame->root); - dict_unref (tmp->xattr); - GF_FREE (tmp); + if (ret < 0) { + mdc_key_unload_all(THIS->private); + gf_msg("md-cache", GF_LOG_INFO, 0, MD_CACHE_MSG_NO_XATTR_CACHE, + "Disabled cache for all xattrs, as registering for " + "xattr cache invalidation failed"); + } + STACK_DESTROY(frame->root); + dict_unref(tmp->xattr); + GF_FREE(tmp); - return 0; + return 0; } static int -mdc_send_xattrs (void *data) +mdc_send_xattrs(void *data) { - int ret = 0; - struct mdc_ipc *tmp = data; + int ret = 0; + struct mdc_ipc *tmp = data; - ret = syncop_ipc (FIRST_CHILD (tmp->this), GF_IPC_TARGET_UPCALL, - tmp->xattr, NULL); - DECODE_SYNCOP_ERR (ret); - if (ret < 0) { - gf_msg (tmp->this->name, GF_LOG_WARNING, errno, - MD_CACHE_MSG_IPC_UPCALL_FAILED, "Registering the list " - "of xattrs that needs invalidaton, with upcall, failed"); - } + ret = syncop_ipc(FIRST_CHILD(tmp->this), GF_IPC_TARGET_UPCALL, tmp->xattr, + NULL); + DECODE_SYNCOP_ERR(ret); + if (ret < 0) { + gf_msg(tmp->this->name, GF_LOG_WARNING, errno, + MD_CACHE_MSG_IPC_UPCALL_FAILED, + "Registering the list " + "of xattrs that needs invalidaton, with upcall, failed"); + } - return ret; + return ret; } - static int -mdc_register_xattr_inval (xlator_t *this) -{ - dict_t *xattr = NULL; - int ret = 0; - struct mdc_conf *conf = NULL; - call_frame_t *frame = NULL; - struct mdc_ipc *data = NULL; - - conf = this->private; - - LOCK (&conf->lock); - { - if (!conf->mdc_invalidation) { - UNLOCK (&conf->lock); - goto out; - } - } - UNLOCK (&conf->lock); - - xattr = dict_new (); - if (!xattr) { - gf_msg (this->name, GF_LOG_WARNING, ENOMEM, - MD_CACHE_MSG_NO_MEMORY, "dict_new failed"); - ret = -1; - goto out; - } - - mdc_load_reqs (this, xattr); - - frame = create_frame (this, this->ctx->pool); - if (!frame) { - gf_msg (this->name, GF_LOG_ERROR, ENOMEM, - MD_CACHE_MSG_NO_MEMORY, - "failed to create the frame"); - ret = -1; - goto out; - } - - data = GF_CALLOC (1, sizeof (struct mdc_ipc), gf_mdc_mt_mdc_ipc); - if (!data) { - gf_msg (this->name, GF_LOG_ERROR, ENOMEM, - MD_CACHE_MSG_NO_MEMORY, - "failed to allocate memory"); - ret = -1; - goto out; - } - - data->this = this; - data->xattr = xattr; - ret = synctask_new (this->ctx->env, mdc_send_xattrs, mdc_send_xattrs_cbk, - frame, data); - if (ret < 0) { - gf_msg (this->name, GF_LOG_WARNING, errno, - MD_CACHE_MSG_IPC_UPCALL_FAILED, "Registering the list " - "of xattrs that needs invalidaton, with upcall, failed"); - } +mdc_register_xattr_inval(xlator_t *this) +{ + dict_t *xattr = NULL; + int ret = 0; + struct mdc_conf *conf = NULL; + call_frame_t *frame = NULL; + struct mdc_ipc *data = NULL; + + conf = this->private; + + LOCK(&conf->lock); + { + if (!conf->mdc_invalidation) { + UNLOCK(&conf->lock); + goto out; + } + } + UNLOCK(&conf->lock); + + xattr = dict_new(); + if (!xattr) { + gf_msg(this->name, GF_LOG_WARNING, ENOMEM, MD_CACHE_MSG_NO_MEMORY, + "dict_new failed"); + ret = -1; + goto out; + } + + mdc_load_reqs(this, xattr); + + frame = create_frame(this, this->ctx->pool); + if (!frame) { + gf_msg(this->name, GF_LOG_ERROR, ENOMEM, MD_CACHE_MSG_NO_MEMORY, + "failed to create the frame"); + ret = -1; + goto out; + } + + data = GF_CALLOC(1, sizeof(struct mdc_ipc), gf_mdc_mt_mdc_ipc); + if (!data) { + gf_msg(this->name, GF_LOG_ERROR, ENOMEM, MD_CACHE_MSG_NO_MEMORY, + "failed to allocate memory"); + ret = -1; + goto out; + } + + data->this = this; + data->xattr = xattr; + ret = synctask_new(this->ctx->env, mdc_send_xattrs, mdc_send_xattrs_cbk, + frame, data); + if (ret < 0) { + gf_msg(this->name, GF_LOG_WARNING, errno, + MD_CACHE_MSG_IPC_UPCALL_FAILED, + "Registering the list " + "of xattrs that needs invalidaton, with upcall, failed"); + } out: - if (ret < 0) { - mdc_key_unload_all (conf); - if (xattr) - dict_unref (xattr); - if (frame) - STACK_DESTROY (frame->root); - GF_FREE (data); - gf_msg (this->name, GF_LOG_INFO, 0, MD_CACHE_MSG_NO_XATTR_CACHE, - "Disabled cache for all xattrs, as registering for " - "xattr cache invalidation failed"); - } + if (ret < 0) { + mdc_key_unload_all(conf); + if (xattr) + dict_unref(xattr); + if (frame) + STACK_DESTROY(frame->root); + GF_FREE(data); + gf_msg(this->name, GF_LOG_INFO, 0, MD_CACHE_MSG_NO_XATTR_CACHE, + "Disabled cache for all xattrs, as registering for " + "xattr cache invalidation failed"); + } - return ret; + return ret; } - int -mdc_reconfigure (xlator_t *this, dict_t *options) +mdc_reconfigure(xlator_t *this, dict_t *options) { - struct mdc_conf *conf = NULL; - int timeout = 0; - char *tmp_str = NULL; - - conf = this->private; + struct mdc_conf *conf = NULL; + int timeout = 0; + char *tmp_str = NULL; - GF_OPTION_RECONF ("md-cache-timeout", timeout, options, int32, out); + conf = this->private; - GF_OPTION_RECONF ("cache-selinux", conf->cache_selinux, options, bool, out); + GF_OPTION_RECONF("md-cache-timeout", timeout, options, int32, out); - GF_OPTION_RECONF ("cache-capability-xattrs", conf->cache_capability, - options, bool, out); + GF_OPTION_RECONF("cache-selinux", conf->cache_selinux, options, bool, out); - GF_OPTION_RECONF ("cache-ima-xattrs", conf->cache_ima, options, bool, - out); + GF_OPTION_RECONF("cache-capability-xattrs", conf->cache_capability, options, + bool, out); - GF_OPTION_RECONF ("cache-posix-acl", conf->cache_posix_acl, options, - bool, out); + GF_OPTION_RECONF("cache-ima-xattrs", conf->cache_ima, options, bool, out); - GF_OPTION_RECONF ("cache-swift-metadata", conf->cache_swift_metadata, - options, bool, out); + GF_OPTION_RECONF("cache-posix-acl", conf->cache_posix_acl, options, bool, + out); - GF_OPTION_RECONF ("cache-samba-metadata", conf->cache_samba_metadata, - options, bool, out); + GF_OPTION_RECONF("cache-swift-metadata", conf->cache_swift_metadata, + options, bool, out); - GF_OPTION_RECONF ("force-readdirp", conf->force_readdirp, options, bool, - out); + GF_OPTION_RECONF("cache-samba-metadata", conf->cache_samba_metadata, + options, bool, out); - GF_OPTION_RECONF ("cache-invalidation", conf->mdc_invalidation, options, - bool, out); + GF_OPTION_RECONF("force-readdirp", conf->force_readdirp, options, bool, + out); - GF_OPTION_RECONF ("pass-through", this->pass_through, options, bool, - out); + GF_OPTION_RECONF("cache-invalidation", conf->mdc_invalidation, options, + bool, out); - GF_OPTION_RECONF ("md-cache-statfs", conf->cache_statfs, options, - bool, out); + GF_OPTION_RECONF("pass-through", this->pass_through, options, bool, out); - GF_OPTION_RECONF ("xattr-cache-list", tmp_str, options, str, out); - mdc_xattr_list_populate (conf, tmp_str); + GF_OPTION_RECONF("md-cache-statfs", conf->cache_statfs, options, bool, out); + GF_OPTION_RECONF("xattr-cache-list", tmp_str, options, str, out); + mdc_xattr_list_populate(conf, tmp_str); - /* If timeout is greater than 60s (default before the patch that added - * cache invalidation support was added) then, cache invalidation - * feature for md-cache needs to be enabled, if not set timeout to the - * previous max which is 60s - */ - if ((timeout > 60) && (!conf->mdc_invalidation)) { - conf->timeout = 60; - goto out; - } - conf->timeout = timeout; + /* If timeout is greater than 60s (default before the patch that added + * cache invalidation support was added) then, cache invalidation + * feature for md-cache needs to be enabled, if not set timeout to the + * previous max which is 60s + */ + if ((timeout > 60) && (!conf->mdc_invalidation)) { + conf->timeout = 60; + goto out; + } + conf->timeout = timeout; - (void) mdc_register_xattr_inval (this); + (void)mdc_register_xattr_inval(this); out: - return 0; + return 0; } int32_t -mdc_mem_acct_init (xlator_t *this) +mdc_mem_acct_init(xlator_t *this) { - int ret = -1; + int ret = -1; - ret = xlator_mem_acct_init (this, gf_mdc_mt_end + 1); - return ret; + ret = xlator_mem_acct_init(this, gf_mdc_mt_end + 1); + return ret; } int -mdc_init (xlator_t *this) +mdc_init(xlator_t *this) { - struct mdc_conf *conf = NULL; - int timeout = 0; - char *tmp_str = NULL; + struct mdc_conf *conf = NULL; + int timeout = 0; + char *tmp_str = NULL; - conf = GF_CALLOC (sizeof (*conf), 1, gf_mdc_mt_mdc_conf_t); - if (!conf) { - gf_msg (this->name, GF_LOG_ERROR, ENOMEM, - MD_CACHE_MSG_NO_MEMORY, "out of memory"); - return -1; - } + conf = GF_CALLOC(sizeof(*conf), 1, gf_mdc_mt_mdc_conf_t); + if (!conf) { + gf_msg(this->name, GF_LOG_ERROR, ENOMEM, MD_CACHE_MSG_NO_MEMORY, + "out of memory"); + return -1; + } - LOCK_INIT (&conf->lock); + LOCK_INIT(&conf->lock); - GF_OPTION_INIT ("md-cache-timeout", timeout, int32, out); + GF_OPTION_INIT("md-cache-timeout", timeout, int32, out); - GF_OPTION_INIT ("cache-selinux", conf->cache_selinux, bool, out); + GF_OPTION_INIT("cache-selinux", conf->cache_selinux, bool, out); - GF_OPTION_INIT ("cache-capability-xattrs", conf->cache_capability, - bool, out); + GF_OPTION_INIT("cache-capability-xattrs", conf->cache_capability, bool, + out); - GF_OPTION_INIT ("cache-ima-xattrs", conf->cache_ima, bool, out); + GF_OPTION_INIT("cache-ima-xattrs", conf->cache_ima, bool, out); - GF_OPTION_INIT ("cache-posix-acl", conf->cache_posix_acl, bool, out); + GF_OPTION_INIT("cache-posix-acl", conf->cache_posix_acl, bool, out); - GF_OPTION_INIT ("cache-swift-metadata", - conf->cache_swift_metadata, bool, out); + GF_OPTION_INIT("cache-swift-metadata", conf->cache_swift_metadata, bool, + out); - GF_OPTION_INIT ("cache-samba-metadata", conf->cache_samba_metadata, - bool, out); + GF_OPTION_INIT("cache-samba-metadata", conf->cache_samba_metadata, bool, + out); - GF_OPTION_INIT("force-readdirp", conf->force_readdirp, bool, out); + GF_OPTION_INIT("force-readdirp", conf->force_readdirp, bool, out); - GF_OPTION_INIT("cache-invalidation", conf->mdc_invalidation, bool, out); + GF_OPTION_INIT("cache-invalidation", conf->mdc_invalidation, bool, out); - GF_OPTION_INIT ("pass-through", this->pass_through, bool, out); + GF_OPTION_INIT("pass-through", this->pass_through, bool, out); - pthread_mutex_init (&conf->statfs_cache.lock, NULL); - GF_OPTION_INIT ("md-cache-statfs", conf->cache_statfs, bool, out); + pthread_mutex_init(&conf->statfs_cache.lock, NULL); + GF_OPTION_INIT("md-cache-statfs", conf->cache_statfs, bool, out); - GF_OPTION_INIT("xattr-cache-list", tmp_str, str, out); - mdc_xattr_list_populate (conf, tmp_str); + GF_OPTION_INIT("xattr-cache-list", tmp_str, str, out); + mdc_xattr_list_populate(conf, tmp_str); - time (&conf->last_child_down); - /* initialize gf_atomic_t counters */ - GF_ATOMIC_INIT (conf->mdc_counter.stat_hit, 0); - GF_ATOMIC_INIT (conf->mdc_counter.stat_miss, 0); - GF_ATOMIC_INIT (conf->mdc_counter.xattr_hit, 0); - GF_ATOMIC_INIT (conf->mdc_counter.xattr_miss, 0); - GF_ATOMIC_INIT (conf->mdc_counter.negative_lookup, 0); - GF_ATOMIC_INIT (conf->mdc_counter.nameless_lookup, 0); - GF_ATOMIC_INIT (conf->mdc_counter.stat_invals, 0); - GF_ATOMIC_INIT (conf->mdc_counter.xattr_invals, 0); - GF_ATOMIC_INIT (conf->mdc_counter.need_lookup, 0); - GF_ATOMIC_INIT (conf->generation, 0); + time(&conf->last_child_down); + /* initialize gf_atomic_t counters */ + GF_ATOMIC_INIT(conf->mdc_counter.stat_hit, 0); + GF_ATOMIC_INIT(conf->mdc_counter.stat_miss, 0); + GF_ATOMIC_INIT(conf->mdc_counter.xattr_hit, 0); + GF_ATOMIC_INIT(conf->mdc_counter.xattr_miss, 0); + GF_ATOMIC_INIT(conf->mdc_counter.negative_lookup, 0); + GF_ATOMIC_INIT(conf->mdc_counter.nameless_lookup, 0); + GF_ATOMIC_INIT(conf->mdc_counter.stat_invals, 0); + GF_ATOMIC_INIT(conf->mdc_counter.xattr_invals, 0); + GF_ATOMIC_INIT(conf->mdc_counter.need_lookup, 0); + GF_ATOMIC_INIT(conf->generation, 0); - /* If timeout is greater than 60s (default before the patch that added - * cache invalidation support was added) then, cache invalidation - * feature for md-cache needs to be enabled, if not set timeout to the - * previous max which is 60s - */ - if ((timeout > 60) && (!conf->mdc_invalidation)) { - conf->timeout = 60; - goto out; - } - conf->timeout = timeout; + /* If timeout is greater than 60s (default before the patch that added + * cache invalidation support was added) then, cache invalidation + * feature for md-cache needs to be enabled, if not set timeout to the + * previous max which is 60s + */ + if ((timeout > 60) && (!conf->mdc_invalidation)) { + conf->timeout = 60; + goto out; + } + conf->timeout = timeout; out: - this->private = conf; + this->private = conf; - return 0; + return 0; } - void -mdc_update_child_down_time (xlator_t *this, time_t *now) +mdc_update_child_down_time(xlator_t *this, time_t *now) { - struct mdc_conf *conf = NULL; + struct mdc_conf *conf = NULL; - conf = this->private; + conf = this->private; - LOCK (&conf->lock); - { - conf->last_child_down = *now; - } - UNLOCK (&conf->lock); + LOCK(&conf->lock); + { + conf->last_child_down = *now; + } + UNLOCK(&conf->lock); } - int -mdc_notify (xlator_t *this, int event, void *data, ...) +mdc_notify(xlator_t *this, int event, void *data, ...) { - int ret = 0; - struct mdc_conf *conf = NULL; - time_t now = 0; + int ret = 0; + struct mdc_conf *conf = NULL; + time_t now = 0; - conf = this->private; - switch (event) { + conf = this->private; + switch (event) { case GF_EVENT_CHILD_DOWN: case GF_EVENT_SOME_DESCENDENT_DOWN: - time (&now); - mdc_update_child_down_time (this, &now); - break; + time(&now); + mdc_update_child_down_time(this, &now); + break; case GF_EVENT_UPCALL: - if (conf->mdc_invalidation) - ret = mdc_invalidate (this, data); - break; + if (conf->mdc_invalidation) + ret = mdc_invalidate(this, data); + break; case GF_EVENT_CHILD_UP: case GF_EVENT_SOME_DESCENDENT_UP: - ret = mdc_register_xattr_inval (this); - break; + ret = mdc_register_xattr_inval(this); + break; default: - break; - } + break; + } - if (default_notify (this, event, data) != 0) - ret = -1; + if (default_notify(this, event, data) != 0) + ret = -1; - return ret; + return ret; } - void -mdc_fini (xlator_t *this) +mdc_fini(xlator_t *this) { - GF_FREE (this->private); + GF_FREE(this->private); } - struct xlator_fops mdc_fops = { - .lookup = mdc_lookup, - .stat = mdc_stat, - .fstat = mdc_fstat, - .truncate = mdc_truncate, - .ftruncate = mdc_ftruncate, - .mknod = mdc_mknod, - .mkdir = mdc_mkdir, - .unlink = mdc_unlink, - .rmdir = mdc_rmdir, - .symlink = mdc_symlink, - .rename = mdc_rename, - .link = mdc_link, - .create = mdc_create, - .open = mdc_open, - .readv = mdc_readv, - .writev = mdc_writev, - .setattr = mdc_setattr, - .fsetattr = mdc_fsetattr, - .fsync = mdc_fsync, - .setxattr = mdc_setxattr, - .fsetxattr = mdc_fsetxattr, - .getxattr = mdc_getxattr, - .fgetxattr = mdc_fgetxattr, - .removexattr = mdc_removexattr, - .fremovexattr= mdc_fremovexattr, - .opendir = mdc_opendir, - .readdirp = mdc_readdirp, - .readdir = mdc_readdir, - .fallocate = mdc_fallocate, - .discard = mdc_discard, - .zerofill = mdc_zerofill, - .statfs = mdc_statfs, - .readlink = mdc_readlink, - .fsyncdir = mdc_fsyncdir, - .access = mdc_access, + .lookup = mdc_lookup, + .stat = mdc_stat, + .fstat = mdc_fstat, + .truncate = mdc_truncate, + .ftruncate = mdc_ftruncate, + .mknod = mdc_mknod, + .mkdir = mdc_mkdir, + .unlink = mdc_unlink, + .rmdir = mdc_rmdir, + .symlink = mdc_symlink, + .rename = mdc_rename, + .link = mdc_link, + .create = mdc_create, + .open = mdc_open, + .readv = mdc_readv, + .writev = mdc_writev, + .setattr = mdc_setattr, + .fsetattr = mdc_fsetattr, + .fsync = mdc_fsync, + .setxattr = mdc_setxattr, + .fsetxattr = mdc_fsetxattr, + .getxattr = mdc_getxattr, + .fgetxattr = mdc_fgetxattr, + .removexattr = mdc_removexattr, + .fremovexattr = mdc_fremovexattr, + .opendir = mdc_opendir, + .readdirp = mdc_readdirp, + .readdir = mdc_readdir, + .fallocate = mdc_fallocate, + .discard = mdc_discard, + .zerofill = mdc_zerofill, + .statfs = mdc_statfs, + .readlink = mdc_readlink, + .fsyncdir = mdc_fsyncdir, + .access = mdc_access, }; - struct xlator_cbks mdc_cbks = { - .forget = mdc_forget, + .forget = mdc_forget, }; - struct xlator_dumpops mdc_dumpops = { - .priv = mdc_priv_dump, + .priv = mdc_priv_dump, }; - struct volume_options mdc_options[] = { - { .key = {"cache-selinux"}, - .type = GF_OPTION_TYPE_BOOL, - .default_value = "false", - .op_version = {2}, - .flags = OPT_FLAG_SETTABLE | OPT_FLAG_CLIENT_OPT | OPT_FLAG_DOC, - .description = "Cache selinux xattr(security.selinux) on client side", - }, - { .key = {"cache-capability-xattrs"}, - .type = GF_OPTION_TYPE_BOOL, - .default_value = "true", - .op_version = {GD_OP_VERSION_3_10_0}, - .flags = OPT_FLAG_SETTABLE | OPT_FLAG_CLIENT_OPT | OPT_FLAG_DOC, - .description = "Cache capability xattr(security.capability) on " - "client side", - }, - { .key = {"cache-ima-xattrs"}, - .type = GF_OPTION_TYPE_BOOL, - .default_value = "true", - .op_version = {GD_OP_VERSION_3_10_0}, - .flags = OPT_FLAG_SETTABLE | OPT_FLAG_CLIENT_OPT | OPT_FLAG_DOC, - .description = "Cache Linux integrity subsystem xattr(security.ima) " - "on client side", - }, - { .key = {"cache-swift-metadata"}, - .type = GF_OPTION_TYPE_BOOL, - .default_value = "true", - .op_version = {GD_OP_VERSION_3_7_10}, - .flags = OPT_FLAG_SETTABLE | OPT_FLAG_CLIENT_OPT | OPT_FLAG_DOC, - .description = "Cache swift metadata (user.swift.metadata xattr)", - }, - { .key = {"cache-samba-metadata"}, - .type = GF_OPTION_TYPE_BOOL, - .default_value = "false", - .op_version = {GD_OP_VERSION_3_9_0}, - .flags = OPT_FLAG_SETTABLE | OPT_FLAG_CLIENT_OPT | OPT_FLAG_DOC, - .description = "Cache samba metadata (user.DOSATTRIB, security.NTACL," - " org.netatalk.Metadata, org.netatalk.ResourceFork, " - "and user.DosStream. xattrs)", - }, - { .key = {"cache-posix-acl"}, - .type = GF_OPTION_TYPE_BOOL, - .default_value = "false", - .op_version = {2}, - .flags = OPT_FLAG_SETTABLE | OPT_FLAG_CLIENT_OPT | OPT_FLAG_DOC, - .description = "Cache posix ACL xattrs (system.posix_acl_access, " - "system.posix_acl_default) on client side", - }, - { .key = {"md-cache-timeout"}, - .type = GF_OPTION_TYPE_INT, - .min = 0, - .max = 600, - .default_value = SITE_H_MD_CACHE_TIMEOUT, - .op_version = {2}, - .flags = OPT_FLAG_SETTABLE | OPT_FLAG_CLIENT_OPT | OPT_FLAG_DOC, - .description = "Time period after which cache has to be refreshed", - }, - { .key = {"force-readdirp"}, - .type = GF_OPTION_TYPE_BOOL, - .default_value = "true", - .op_version = {2}, - .flags = OPT_FLAG_SETTABLE | OPT_FLAG_CLIENT_OPT | OPT_FLAG_DOC, - .description = "Convert all readdir requests to readdirplus to " - "collect stat info on each entry.", - }, - { .key = {"cache-invalidation"}, - .type = GF_OPTION_TYPE_BOOL, - .default_value = "false", - .op_version = {GD_OP_VERSION_3_9_0}, - .flags = OPT_FLAG_SETTABLE | OPT_FLAG_CLIENT_OPT | OPT_FLAG_DOC, - .description = "When \"on\", invalidates/updates the metadata cache," - " on receiving the cache-invalidation notifications", - }, - { .key = {"md-cache-statfs"}, - .type = GF_OPTION_TYPE_BOOL, - .default_value = "off", - .op_version = {GD_OP_VERSION_4_0_0}, - .flags = OPT_FLAG_SETTABLE | OPT_FLAG_CLIENT_OPT | OPT_FLAG_DOC, - .description = "Cache statfs information of filesystem on the client", - }, - { .key = {"xattr-cache-list"}, - .type = GF_OPTION_TYPE_STR, - .default_value = "", - .op_version = {GD_OP_VERSION_4_0_0}, - .flags = OPT_FLAG_SETTABLE | OPT_FLAG_CLIENT_OPT | OPT_FLAG_DOC, - .description = "A comma separated list of xattrs that shall be " - "cached by md-cache. The only wildcard allowed is '*'", - }, - { .key = {"pass-through"}, - .type = GF_OPTION_TYPE_BOOL, - .default_value = "false", - .op_version = {GD_OP_VERSION_4_1_0}, - .flags = OPT_FLAG_SETTABLE | OPT_FLAG_DOC | OPT_FLAG_CLIENT_OPT, - .tags = {"md-cache"}, - .description = "Enable/Disable md cache translator" - }, - { .key = {NULL} }, + { + .key = {"cache-selinux"}, + .type = GF_OPTION_TYPE_BOOL, + .default_value = "false", + .op_version = {2}, + .flags = OPT_FLAG_SETTABLE | OPT_FLAG_CLIENT_OPT | OPT_FLAG_DOC, + .description = "Cache selinux xattr(security.selinux) on client side", + }, + { + .key = {"cache-capability-xattrs"}, + .type = GF_OPTION_TYPE_BOOL, + .default_value = "true", + .op_version = {GD_OP_VERSION_3_10_0}, + .flags = OPT_FLAG_SETTABLE | OPT_FLAG_CLIENT_OPT | OPT_FLAG_DOC, + .description = "Cache capability xattr(security.capability) on " + "client side", + }, + { + .key = {"cache-ima-xattrs"}, + .type = GF_OPTION_TYPE_BOOL, + .default_value = "true", + .op_version = {GD_OP_VERSION_3_10_0}, + .flags = OPT_FLAG_SETTABLE | OPT_FLAG_CLIENT_OPT | OPT_FLAG_DOC, + .description = "Cache Linux integrity subsystem xattr(security.ima) " + "on client side", + }, + { + .key = {"cache-swift-metadata"}, + .type = GF_OPTION_TYPE_BOOL, + .default_value = "true", + .op_version = {GD_OP_VERSION_3_7_10}, + .flags = OPT_FLAG_SETTABLE | OPT_FLAG_CLIENT_OPT | OPT_FLAG_DOC, + .description = "Cache swift metadata (user.swift.metadata xattr)", + }, + { + .key = {"cache-samba-metadata"}, + .type = GF_OPTION_TYPE_BOOL, + .default_value = "false", + .op_version = {GD_OP_VERSION_3_9_0}, + .flags = OPT_FLAG_SETTABLE | OPT_FLAG_CLIENT_OPT | OPT_FLAG_DOC, + .description = "Cache samba metadata (user.DOSATTRIB, security.NTACL," + " org.netatalk.Metadata, org.netatalk.ResourceFork, " + "and user.DosStream. xattrs)", + }, + { + .key = {"cache-posix-acl"}, + .type = GF_OPTION_TYPE_BOOL, + .default_value = "false", + .op_version = {2}, + .flags = OPT_FLAG_SETTABLE | OPT_FLAG_CLIENT_OPT | OPT_FLAG_DOC, + .description = "Cache posix ACL xattrs (system.posix_acl_access, " + "system.posix_acl_default) on client side", + }, + { + .key = {"md-cache-timeout"}, + .type = GF_OPTION_TYPE_INT, + .min = 0, + .max = 600, + .default_value = SITE_H_MD_CACHE_TIMEOUT, + .op_version = {2}, + .flags = OPT_FLAG_SETTABLE | OPT_FLAG_CLIENT_OPT | OPT_FLAG_DOC, + .description = "Time period after which cache has to be refreshed", + }, + { + .key = {"force-readdirp"}, + .type = GF_OPTION_TYPE_BOOL, + .default_value = "true", + .op_version = {2}, + .flags = OPT_FLAG_SETTABLE | OPT_FLAG_CLIENT_OPT | OPT_FLAG_DOC, + .description = "Convert all readdir requests to readdirplus to " + "collect stat info on each entry.", + }, + { + .key = {"cache-invalidation"}, + .type = GF_OPTION_TYPE_BOOL, + .default_value = "false", + .op_version = {GD_OP_VERSION_3_9_0}, + .flags = OPT_FLAG_SETTABLE | OPT_FLAG_CLIENT_OPT | OPT_FLAG_DOC, + .description = "When \"on\", invalidates/updates the metadata cache," + " on receiving the cache-invalidation notifications", + }, + { + .key = {"md-cache-statfs"}, + .type = GF_OPTION_TYPE_BOOL, + .default_value = "off", + .op_version = {GD_OP_VERSION_4_0_0}, + .flags = OPT_FLAG_SETTABLE | OPT_FLAG_CLIENT_OPT | OPT_FLAG_DOC, + .description = "Cache statfs information of filesystem on the client", + }, + { + .key = {"xattr-cache-list"}, + .type = GF_OPTION_TYPE_STR, + .default_value = "", + .op_version = {GD_OP_VERSION_4_0_0}, + .flags = OPT_FLAG_SETTABLE | OPT_FLAG_CLIENT_OPT | OPT_FLAG_DOC, + .description = "A comma separated list of xattrs that shall be " + "cached by md-cache. The only wildcard allowed is '*'", + }, + {.key = {"pass-through"}, + .type = GF_OPTION_TYPE_BOOL, + .default_value = "false", + .op_version = {GD_OP_VERSION_4_1_0}, + .flags = OPT_FLAG_SETTABLE | OPT_FLAG_DOC | OPT_FLAG_CLIENT_OPT, + .tags = {"md-cache"}, + .description = "Enable/Disable md cache translator"}, + {.key = {NULL}}, }; - xlator_api_t xlator_api = { - .init = mdc_init, - .fini = mdc_fini, - .notify = mdc_notify, - .reconfigure = mdc_reconfigure, - .mem_acct_init = mdc_mem_acct_init, - .dump_metrics = mdc_dump_metrics, - .op_version = {1}, /* Present from the initial version */ - .dumpops = &mdc_dumpops, - .fops = &mdc_fops, - .cbks = &mdc_cbks, - .options = mdc_options, - .identifier = "md-cache", - .category = GF_MAINTAINED, + .init = mdc_init, + .fini = mdc_fini, + .notify = mdc_notify, + .reconfigure = mdc_reconfigure, + .mem_acct_init = mdc_mem_acct_init, + .dump_metrics = mdc_dump_metrics, + .op_version = {1}, /* Present from the initial version */ + .dumpops = &mdc_dumpops, + .fops = &mdc_fops, + .cbks = &mdc_cbks, + .options = mdc_options, + .identifier = "md-cache", + .category = GF_MAINTAINED, }; |