From dfa3942f67e11ce0bef0975173f63932b0db3143 Mon Sep 17 00:00:00 2001 From: Soumya Koduri Date: Thu, 30 Apr 2015 11:34:14 +0530 Subject: Upcall: Handle missing fops in the upcall xlator Change-Id: I968980dc4df458ec427e33503363bbd017e1163e BUG: 1200271 Signed-off-by: Soumya Koduri Reviewed-on: http://review.gluster.org/10194 Tested-by: NetBSD Build System Reviewed-by: Kaleb KEITHLEY Reviewed-by: Niels de Vos --- .../upcall/src/upcall-cache-invalidation.h | 26 +- xlators/features/upcall/src/upcall-internal.c | 21 + xlators/features/upcall/src/upcall.c | 1254 ++++++++++++++++---- xlators/features/upcall/src/upcall.h | 4 + 4 files changed, 1072 insertions(+), 233 deletions(-) (limited to 'xlators') diff --git a/xlators/features/upcall/src/upcall-cache-invalidation.h b/xlators/features/upcall/src/upcall-cache-invalidation.h index 138595cecb6..c39962b68c4 100644 --- a/xlators/features/upcall/src/upcall-cache-invalidation.h +++ b/xlators/features/upcall/src/upcall-cache-invalidation.h @@ -35,7 +35,7 @@ invalidate the cache entry */ /* for fops - open, read, lk, */ -#define UP_IDEMPOTENT_FLAGS (UP_ATIME) +#define UP_UPDATE_CLIENT (UP_ATIME) /* for fop - write, truncate */ #define UP_WRITE_FLAGS (UP_SIZE | UP_TIMES) @@ -53,30 +53,6 @@ /* for fop - unlink, link, rmdir, mkdir */ #define UP_NLINK_FLAGS (UP_NLINK | UP_TIMES) -#define CACHE_INVALIDATE(frame, this, client, inode, p_flags) do { \ - \ - if (!is_cache_invalidation_enabled(this)) \ - break; \ - \ - (void)upcall_cache_invalidate (frame, this, client, \ - inode, p_flags); \ -} while (0) - -#define CACHE_INVALIDATE_DIR(frame, this, client, inode_p, p_flags) do {\ - \ - if (!is_cache_invalidation_enabled(this)) \ - break; \ - \ - dentry_t *dentry; \ - dentry_t *dentry_tmp; \ - list_for_each_entry_safe (dentry, dentry_tmp, \ - &inode_p->dentry_list, \ - inode_list) { \ - (void)upcall_cache_invalidate (frame, this, client, \ - dentry->inode, p_flags); \ - } \ -} while (0) - /* xlator options */ gf_boolean_t is_cache_invalidation_enabled(xlator_t *this); int32_t get_cache_invalidation_timeout(xlator_t *this); diff --git a/xlators/features/upcall/src/upcall-internal.c b/xlators/features/upcall/src/upcall-internal.c index a7f0fd991cf..a2c33cb2ca7 100644 --- a/xlators/features/upcall/src/upcall-internal.c +++ b/xlators/features/upcall/src/upcall-internal.c @@ -327,6 +327,24 @@ out: return ret; } +void +upcall_cache_invalidate_dir (call_frame_t *frame, xlator_t *this, + client_t *client, inode_t *inode, uint32_t flags) +{ + dentry_t *dentry; + dentry_t *dentry_tmp; + + if (!is_cache_invalidation_enabled(this)) + return; + + list_for_each_entry_safe (dentry, dentry_tmp, + &inode->dentry_list, + inode_list) { + upcall_cache_invalidate (frame, this, client, + dentry->inode, flags); + } +} + /* * Given a gfid, client, first fetch upcall_entry_t based on gfid. * Later traverse through the client list of that upcall entry. If this client @@ -347,6 +365,9 @@ upcall_cache_invalidate (call_frame_t *frame, xlator_t *this, client_t *client, upcall_inode_ctx_t *up_inode_ctx = NULL; gf_boolean_t found = _gf_false; + if (!is_cache_invalidation_enabled(this)) + return; + up_inode_ctx = ((upcall_local_t *)frame->local)->upcall_inode_ctx; if (!up_inode_ctx) diff --git a/xlators/features/upcall/src/upcall.c b/xlators/features/upcall/src/upcall.c index 21f8e0ba339..ad86567aa7c 100644 --- a/xlators/features/upcall/src/upcall.c +++ b/xlators/features/upcall/src/upcall.c @@ -34,7 +34,7 @@ #include "protocol-common.h" #include "defaults.h" -int +int32_t up_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) { @@ -50,8 +50,8 @@ up_open_cbk (call_frame_t *frame, void *cookie, xlator_t *this, if ((op_ret < 0) || !local) { goto out; } - flags = UP_IDEMPOTENT_FLAGS; - CACHE_INVALIDATE (frame, this, client, local->inode, flags); + flags = UP_UPDATE_CLIENT; + upcall_cache_invalidate (frame, this, client, local->inode, flags); out: UPCALL_STACK_UNWIND (open, frame, op_ret, op_errno, fd, xdata); @@ -60,7 +60,7 @@ out: } -int +int32_t up_open (call_frame_t *frame, xlator_t *this, loc_t *loc, int32_t flags, fd_t *fd, dict_t *xdata) { @@ -89,10 +89,10 @@ err: return 0; } -int +int32_t up_writev_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int op_ret, int op_errno, struct iatt *prebuf, - struct iatt *postbuf, dict_t *xdata) + int op_ret, int op_errno, struct iatt *prebuf, + struct iatt *postbuf, dict_t *xdata) { client_t *client = NULL; uint32_t flags = 0; @@ -105,7 +105,7 @@ up_writev_cbk (call_frame_t *frame, void *cookie, xlator_t *this, goto out; } flags = UP_WRITE_FLAGS; - CACHE_INVALIDATE (frame, this, client, local->inode, flags); + upcall_cache_invalidate (frame, this, client, local->inode, flags); out: UPCALL_STACK_UNWIND (writev, frame, op_ret, op_errno, @@ -115,10 +115,10 @@ out: } -int +int32_t up_writev (call_frame_t *frame, xlator_t *this, fd_t *fd, - struct iovec *vector, int count, off_t off, uint32_t flags, - struct iobref *iobref, dict_t *xdata) + struct iovec *vector, int count, off_t off, uint32_t flags, + struct iobref *iobref, dict_t *xdata) { int32_t op_errno = -1; upcall_local_t *local = NULL; @@ -147,11 +147,11 @@ err: } -int +int32_t up_readv_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int op_ret, int op_errno, - struct iovec *vector, int count, struct iatt *stbuf, - struct iobref *iobref, dict_t *xdata) + int op_ret, int op_errno, + struct iovec *vector, int count, struct iatt *stbuf, + struct iobref *iobref, dict_t *xdata) { client_t *client = NULL; uint32_t flags = 0; @@ -165,8 +165,8 @@ up_readv_cbk (call_frame_t *frame, void *cookie, xlator_t *this, if ((op_ret < 0) || !local) { goto out; } - flags = UP_IDEMPOTENT_FLAGS; - CACHE_INVALIDATE (frame, this, client, local->inode, flags); + flags = UP_UPDATE_CLIENT; + upcall_cache_invalidate (frame, this, client, local->inode, flags); out: UPCALL_STACK_UNWIND (readv, frame, op_ret, op_errno, vector, @@ -175,7 +175,7 @@ out: return 0; } -int +int32_t up_readv (call_frame_t *frame, xlator_t *this, fd_t *fd, size_t size, off_t offset, uint32_t flags, dict_t *xdata) @@ -208,8 +208,8 @@ err: int32_t up_lk_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, struct gf_flock *lock, - dict_t *xdata) + int32_t op_ret, int32_t op_errno, struct gf_flock *lock, + dict_t *xdata) { client_t *client = NULL; uint32_t flags = 0; @@ -223,8 +223,8 @@ up_lk_cbk (call_frame_t *frame, void *cookie, xlator_t *this, if ((op_ret < 0) || !local) { goto out; } - flags = UP_IDEMPOTENT_FLAGS; - CACHE_INVALIDATE (frame, this, client, local->inode, flags); + flags = UP_UPDATE_CLIENT; + upcall_cache_invalidate (frame, this, client, local->inode, flags); out: UPCALL_STACK_UNWIND (lk, frame, op_ret, op_errno, lock, xdata); @@ -232,7 +232,7 @@ out: return 0; } -int +int32_t up_lk (call_frame_t *frame, xlator_t *this, fd_t *fd, int32_t cmd, struct gf_flock *flock, dict_t *xdata) { @@ -260,10 +260,10 @@ err: return 0; } -int +int32_t up_truncate_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int op_ret, int op_errno, struct iatt *prebuf, - struct iatt *postbuf, dict_t *xdata) + int op_ret, int op_errno, struct iatt *prebuf, + struct iatt *postbuf, dict_t *xdata) { client_t *client = NULL; uint32_t flags = 0; @@ -278,7 +278,7 @@ up_truncate_cbk (call_frame_t *frame, void *cookie, xlator_t *this, goto out; } flags = UP_WRITE_FLAGS; - CACHE_INVALIDATE (frame, this, client, local->inode, flags); + upcall_cache_invalidate (frame, this, client, local->inode, flags); out: UPCALL_STACK_UNWIND (truncate, frame, op_ret, op_errno, @@ -287,9 +287,9 @@ out: return 0; } -int +int32_t up_truncate (call_frame_t *frame, xlator_t *this, loc_t *loc, off_t offset, - dict_t *xdata) + dict_t *xdata) { int32_t op_errno = -1; upcall_local_t *local = NULL; @@ -316,10 +316,10 @@ err: return 0; } -int +int32_t up_setattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int op_ret, int op_errno, struct iatt *statpre, - struct iatt *statpost, dict_t *xdata) + int op_ret, int op_errno, struct iatt *statpre, + struct iatt *statpost, dict_t *xdata) { client_t *client = NULL; uint32_t flags = 0; @@ -339,7 +339,7 @@ up_setattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this, * Bug1200271. */ flags = UP_ATTR_FLAGS; - CACHE_INVALIDATE (frame, this, client, local->inode, flags); + upcall_cache_invalidate (frame, this, client, local->inode, flags); out: UPCALL_STACK_UNWIND (setattr, frame, op_ret, op_errno, @@ -348,9 +348,9 @@ out: return 0; } -int +int32_t up_setattr (call_frame_t *frame, xlator_t *this, loc_t *loc, - struct iatt *stbuf, int32_t valid, dict_t *xdata) + struct iatt *stbuf, int32_t valid, dict_t *xdata) { int32_t op_errno = -1; upcall_local_t *local = NULL; @@ -378,12 +378,12 @@ err: return 0; } -int +int32_t up_rename_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, struct iatt *stbuf, - struct iatt *preoldparent, struct iatt *postoldparent, - struct iatt *prenewparent, struct iatt *postnewparent, - dict_t *xdata) + int32_t op_ret, int32_t op_errno, struct iatt *stbuf, + struct iatt *preoldparent, struct iatt *postoldparent, + struct iatt *prenewparent, struct iatt *postnewparent, + dict_t *xdata) { client_t *client = NULL; uint32_t flags = 0; @@ -398,15 +398,16 @@ up_rename_cbk (call_frame_t *frame, void *cookie, xlator_t *this, goto out; } flags = UP_RENAME_FLAGS; - CACHE_INVALIDATE (frame, this, client, local->inode, flags); + upcall_cache_invalidate (frame, this, client, local->inode, flags); /* Need to invalidate old and new parent entries as well */ flags = UP_PARENT_DENTRY_FLAGS; - CACHE_INVALIDATE_DIR (frame, this, client, local->inode, flags); + upcall_cache_invalidate_dir (frame, this, client, local->inode, flags); - /* XXX: notify oldparent as well */ -/* if (gf_uuid_compare (preoldparent->ia_gfid, prenewparent->ia_gfid)) - CACHE_INVALIDATE (frame, this, client, prenewparent->ia_gfid, flags);*/ + /* notify oldparent as well */ + flags = UP_PARENT_DENTRY_FLAGS; + upcall_cache_invalidate_dir (frame, this, client, + local->rename_oldloc.inode, flags); out: UPCALL_STACK_UNWIND (rename, frame, op_ret, op_errno, @@ -416,7 +417,7 @@ out: return 0; } -int +int32_t up_rename (call_frame_t *frame, xlator_t *this, loc_t *oldloc, loc_t *newloc, dict_t *xdata) { @@ -431,6 +432,8 @@ up_rename (call_frame_t *frame, xlator_t *this, goto err; } + /* copy oldloc */ + loc_copy (&local->rename_oldloc, oldloc); out: STACK_WIND (frame, up_rename_cbk, FIRST_CHILD(this), FIRST_CHILD(this)->fops->rename, @@ -446,10 +449,10 @@ err: return 0; } -int +int32_t up_unlink_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int op_ret, int op_errno, struct iatt *preparent, - struct iatt *postparent, dict_t *xdata) + int op_ret, int op_errno, struct iatt *preparent, + struct iatt *postparent, dict_t *xdata) { client_t *client = NULL; uint32_t flags = 0; @@ -464,11 +467,11 @@ up_unlink_cbk (call_frame_t *frame, void *cookie, xlator_t *this, goto out; } flags = UP_NLINK_FLAGS; - CACHE_INVALIDATE (frame, this, client, local->inode, flags); + upcall_cache_invalidate (frame, this, client, local->inode, flags); flags = UP_PARENT_DENTRY_FLAGS; /* invalidate parent's entry too */ - CACHE_INVALIDATE_DIR (frame, this, client, local->inode, flags); + upcall_cache_invalidate_dir (frame, this, client, local->inode, flags); out: UPCALL_STACK_UNWIND (unlink, frame, op_ret, op_errno, @@ -477,9 +480,9 @@ out: return 0; } -int +int32_t up_unlink (call_frame_t *frame, xlator_t *this, loc_t *loc, int xflag, - dict_t *xdata) + dict_t *xdata) { int32_t op_errno = -1; upcall_local_t *local = NULL; @@ -506,10 +509,10 @@ err: return 0; } -int +int32_t up_link_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int op_ret, int op_errno, inode_t *inode, struct iatt *stbuf, - struct iatt *preparent, struct iatt *postparent, dict_t *xdata) + int op_ret, int op_errno, inode_t *inode, struct iatt *stbuf, + struct iatt *preparent, struct iatt *postparent, dict_t *xdata) { client_t *client = NULL; uint32_t flags = 0; @@ -524,7 +527,7 @@ up_link_cbk (call_frame_t *frame, void *cookie, xlator_t *this, goto out; } flags = UP_NLINK_FLAGS; - CACHE_INVALIDATE (frame, this, client, local->inode, flags); + upcall_cache_invalidate (frame, this, client, local->inode, flags); /* do we need to update parent as well?? */ out: @@ -534,7 +537,7 @@ out: return 0; } -int +int32_t up_link (call_frame_t *frame, xlator_t *this, loc_t *oldloc, loc_t *newloc, dict_t *xdata) { @@ -564,10 +567,10 @@ err: return 0; } -int +int32_t up_rmdir_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int op_ret, int op_errno, struct iatt *preparent, - struct iatt *postparent, dict_t *xdata) + int op_ret, int op_errno, struct iatt *preparent, + struct iatt *postparent, dict_t *xdata) { client_t *client = NULL; uint32_t flags = 0; @@ -582,11 +585,11 @@ up_rmdir_cbk (call_frame_t *frame, void *cookie, xlator_t *this, goto out; } flags = UP_NLINK_FLAGS; - CACHE_INVALIDATE (frame, this, client, local->inode, flags); + upcall_cache_invalidate (frame, this, client, local->inode, flags); /* invalidate parent's entry too */ flags = UP_PARENT_DENTRY_FLAGS; - CACHE_INVALIDATE_DIR (frame, this, client, local->inode, flags); + upcall_cache_invalidate_dir (frame, this, client, local->inode, flags); out: UPCALL_STACK_UNWIND (rmdir, frame, op_ret, op_errno, @@ -595,9 +598,9 @@ out: return 0; } -int +int32_t up_rmdir (call_frame_t *frame, xlator_t *this, loc_t *loc, int flags, - dict_t *xdata) + dict_t *xdata) { int32_t op_errno = -1; upcall_local_t *local = NULL; @@ -624,11 +627,11 @@ err: return 0; } -int +int32_t up_mkdir_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int op_ret, int op_errno, inode_t *inode, - struct iatt *stbuf, struct iatt *preparent, - struct iatt *postparent, dict_t *xdata) + int op_ret, int op_errno, inode_t *inode, + struct iatt *stbuf, struct iatt *preparent, + struct iatt *postparent, dict_t *xdata) { client_t *client = NULL; uint32_t flags = 0; @@ -642,12 +645,10 @@ up_mkdir_cbk (call_frame_t *frame, void *cookie, xlator_t *this, if ((op_ret < 0) || !local) { goto out; } - flags = UP_NLINK_FLAGS; - CACHE_INVALIDATE (frame, this, client, local->inode, flags); /* invalidate parent's entry too */ flags = UP_PARENT_DENTRY_FLAGS; - CACHE_INVALIDATE_DIR (frame, this, client, local->inode, flags); + upcall_cache_invalidate_dir (frame, this, client, local->inode, flags); out: UPCALL_STACK_UNWIND (mkdir, frame, op_ret, op_errno, @@ -656,7 +657,7 @@ out: return 0; } -int +int32_t up_mkdir (call_frame_t *frame, xlator_t *this, loc_t *loc, mode_t mode, mode_t umask, dict_t *params) { @@ -686,11 +687,11 @@ err: return 0; } -int +int32_t up_create_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int op_ret, int op_errno, fd_t *fd, inode_t *inode, - struct iatt *stbuf, struct iatt *preparent, - struct iatt *postparent, dict_t *xdata) + int op_ret, int op_errno, fd_t *fd, inode_t *inode, + struct iatt *stbuf, struct iatt *preparent, + struct iatt *postparent, dict_t *xdata) { client_t *client = NULL; uint32_t flags = 0; @@ -708,7 +709,7 @@ up_create_cbk (call_frame_t *frame, void *cookie, xlator_t *this, /* As its a new file create, no need of sending notification */ /* However invalidate parent's entry */ flags = UP_PARENT_DENTRY_FLAGS; - CACHE_INVALIDATE_DIR (frame, this, client, local->inode, flags); + upcall_cache_invalidate_dir (frame, this, client, local->inode, flags); out: UPCALL_STACK_UNWIND (create, frame, op_ret, op_errno, fd, @@ -717,10 +718,10 @@ out: return 0; } -int +int32_t up_create (call_frame_t *frame, xlator_t *this, - loc_t *loc, int32_t flags, mode_t mode, - mode_t umask, fd_t *fd, dict_t *params) + loc_t *loc, int32_t flags, mode_t mode, + mode_t umask, fd_t *fd, dict_t *params) { int32_t op_errno = -1; upcall_local_t *local = NULL; @@ -750,164 +751,964 @@ err: } int32_t -mem_acct_init (xlator_t *this) +up_lookup_cbk (call_frame_t *frame, void *cookie, xlator_t *this, + int op_ret, int op_errno, + inode_t *inode, struct iatt *stbuf, dict_t *xattr, + struct iatt *postparent) { - int ret = -1; + client_t *client = NULL; + uint32_t flags = 0; + upcall_local_t *local = NULL; - if (!this) - return ret; + EXIT_IF_UPCALL_OFF (this, out); - ret = xlator_mem_acct_init (this, gf_upcall_mt_end + 1); + client = frame->root->client; + local = frame->local; - if (ret != 0) { - gf_msg ("upcall", GF_LOG_WARNING, 0, - UPCALL_MSG_NO_MEMORY, - "Memory allocation failed"); - return ret; + if ((op_ret < 0) || !local) { + goto out; } + flags = UP_UPDATE_CLIENT; + upcall_cache_invalidate (frame, this, client, local->inode, flags); - return ret; -} +out: + UPCALL_STACK_UNWIND (lookup, frame, op_ret, op_errno, inode, stbuf, + xattr, postparent); -void -upcall_local_wipe (xlator_t *this, upcall_local_t *local) -{ - if (local) { - inode_unref (local->inode); - mem_put (local); - } + return 0; } -upcall_local_t * -upcall_local_init (call_frame_t *frame, xlator_t *this, inode_t *inode) +int32_t +up_lookup (call_frame_t *frame, xlator_t *this, + loc_t *loc, dict_t *xattr_req) { - upcall_local_t *local = NULL; + int32_t op_errno = -1; + upcall_local_t *local = NULL; - local = mem_get0 (THIS->local_pool); + EXIT_IF_UPCALL_OFF (this, out); - if (!local) - goto out; + local = upcall_local_init (frame, this, loc->inode); + if (!local) { + op_errno = ENOMEM; + goto err; + } - local->inode = inode_ref (inode); +out: + STACK_WIND (frame, up_lookup_cbk, + FIRST_CHILD(this), FIRST_CHILD(this)->fops->lookup, + loc, xattr_req); - /* Shall we get inode_ctx and store it here itself? */ - local->upcall_inode_ctx = upcall_inode_ctx_get (inode, this); + return 0; - frame->local = local; +err: + op_errno = (op_errno == -1) ? errno : op_errno; + UPCALL_STACK_UNWIND (lookup, frame, -1, op_errno, NULL, + NULL, NULL, NULL); -out: - return local; + return 0; } -int -reconfigure (xlator_t *this, dict_t *options) +int32_t +up_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) { - upcall_private_t *priv = NULL; - int ret = -1; + client_t *client = NULL; + uint32_t flags = 0; + upcall_local_t *local = NULL; - priv = this->private; - GF_ASSERT (priv); + EXIT_IF_UPCALL_OFF (this, out); - GF_OPTION_RECONF ("cache-invalidation", priv->cache_invalidation_enabled, - options, bool, out); - GF_OPTION_RECONF ("cache-invalidation-timeout", priv->cache_invalidation_timeout, - options, int32, out); + client = frame->root->client; + local = frame->local; + + if ((op_ret < 0) || !local) { + goto out; + } + flags = UP_UPDATE_CLIENT; + upcall_cache_invalidate (frame, this, client, local->inode, flags); - ret = 0; out: - return ret; + UPCALL_STACK_UNWIND (stat, frame, op_ret, op_errno, buf, + xdata); + + return 0; } -int -init (xlator_t *this) +int32_t +up_stat (call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *xdata) { - int ret = -1; - upcall_private_t *priv = NULL; + int32_t op_errno = -1; + upcall_local_t *local = NULL; - priv = GF_CALLOC (1, sizeof (*priv), - gf_upcall_mt_private_t); - if (!priv) { - gf_msg ("upcall", GF_LOG_WARNING, 0, - UPCALL_MSG_NO_MEMORY, - "Memory allocation failed"); - goto out; + EXIT_IF_UPCALL_OFF (this, out); + + local = upcall_local_init (frame, this, loc->inode); + if (!local) { + op_errno = ENOMEM; + goto err; } - GF_OPTION_INIT ("cache-invalidation", priv->cache_invalidation_enabled, - bool, out); - GF_OPTION_INIT ("cache-invalidation-timeout", - priv->cache_invalidation_timeout, int32, out); +out: + STACK_WIND (frame, up_stat_cbk, + FIRST_CHILD(this), FIRST_CHILD(this)->fops->stat, + loc, xdata); - this->private = priv; - this->local_pool = mem_pool_new (upcall_local_t, 512); - ret = 0; + return 0; -out: - if (ret) { - GF_FREE (priv); - } +err: + op_errno = (op_errno == -1) ? errno : op_errno; + UPCALL_STACK_UNWIND (stat, frame, -1, op_errno, NULL, NULL); - return ret; + return 0; } -int -fini (xlator_t *this) +int32_t +up_fstat (call_frame_t *frame, xlator_t *this, + fd_t *fd, dict_t *xdata) { - upcall_private_t *priv = NULL; + int32_t op_errno = -1; + upcall_local_t *local = NULL; - priv = this->private; - if (!priv) { - return 0; + EXIT_IF_UPCALL_OFF (this, out); + + local = upcall_local_init (frame, this, fd->inode); + if (!local) { + op_errno = ENOMEM; + goto err; } - this->private = NULL; - GF_FREE (priv); +out: + STACK_WIND (frame, up_stat_cbk, + FIRST_CHILD(this), FIRST_CHILD(this)->fops->fstat, + fd, xdata); return 0; -} -int -upcall_forget (xlator_t *this, inode_t *inode) -{ - upcall_cleanup_inode_ctx (this, inode); +err: + op_errno = (op_errno == -1) ? errno : op_errno; + UPCALL_STACK_UNWIND (fstat, frame, -1, op_errno, NULL, NULL); + return 0; } -int -upcall_release (xlator_t *this, fd_t *fd) +int32_t +up_ftruncate (call_frame_t *frame, xlator_t *this, + fd_t *fd, off_t offset, dict_t *xdata) { + int32_t op_errno = -1; + upcall_local_t *local = NULL; + + EXIT_IF_UPCALL_OFF (this, out); + + local = upcall_local_init (frame, this, fd->inode); + if (!local) { + op_errno = ENOMEM; + goto err; + } + +out: + STACK_WIND (frame, up_truncate_cbk, + FIRST_CHILD(this), FIRST_CHILD(this)->fops->ftruncate, + fd, offset, xdata); + + return 0; + +err: + op_errno = (op_errno == -1) ? errno : op_errno; + UPCALL_STACK_UNWIND (ftruncate, frame, -1, op_errno, NULL, + NULL, NULL); + return 0; } -int -notify (xlator_t *this, int32_t event, void *data, ...) +int32_t +up_access_cbk (call_frame_t *frame, void *cookie, xlator_t *this, + int op_ret, int op_errno, dict_t *xdata) { - int ret = -1; - int32_t val = 0; - notify_event_data_t *notify_event = NULL; - struct gf_upcall up_req = {0,}; - upcall_client_t *up_client_entry = NULL; - struct gf_upcall_cache_invalidation ca_req = {0,}; + client_t *client = NULL; + uint32_t flags = 0; + upcall_local_t *local = NULL; - switch (event) { - case GF_EVENT_UPCALL: - { - gf_log (this->name, GF_LOG_DEBUG, "Upcall Notify event = %d", - event); + EXIT_IF_UPCALL_OFF (this, out); - notify_event = (notify_event_data_t *) data; - up_client_entry = notify_event->client_entry; + client = frame->root->client; + local = frame->local; - if (!up_client_entry) { - goto out; - } + if ((op_ret < 0) || !local) { + goto out; + } + flags = UP_UPDATE_CLIENT; + upcall_cache_invalidate (frame, this, client, local->inode, flags); - up_req.client_uid = up_client_entry->client_uid; +out: + UPCALL_STACK_UNWIND (access, frame, op_ret, op_errno, xdata); - gf_uuid_copy (up_req.gfid, notify_event->gfid); - gf_log (this->name, GF_LOG_DEBUG, - "Sending notify to the client- %s, gfid - %s", - up_client_entry->client_uid, up_req.gfid); + return 0; +} + +int32_t +up_access (call_frame_t *frame, xlator_t *this, + loc_t *loc, int32_t mask, dict_t *xdata) +{ + int32_t op_errno = -1; + upcall_local_t *local = NULL; + + EXIT_IF_UPCALL_OFF (this, out); + + local = upcall_local_init (frame, this, loc->inode); + if (!local) { + op_errno = ENOMEM; + goto err; + } + +out: + STACK_WIND (frame, up_access_cbk, + FIRST_CHILD(this), FIRST_CHILD(this)->fops->access, + loc, mask, xdata); + + return 0; + +err: + op_errno = (op_errno == -1) ? errno : op_errno; + UPCALL_STACK_UNWIND (access, frame, -1, op_errno, NULL); + + return 0; +} + +int32_t +up_readlink_cbk (call_frame_t *frame, void *cookie, xlator_t *this, + int op_ret, int op_errno, const char *path, + struct iatt *stbuf, dict_t *xdata) +{ + client_t *client = NULL; + uint32_t flags = 0; + upcall_local_t *local = NULL; + + EXIT_IF_UPCALL_OFF (this, out); + + client = frame->root->client; + local = frame->local; + + if ((op_ret < 0) || !local) { + goto out; + } + flags = UP_UPDATE_CLIENT; + upcall_cache_invalidate (frame, this, client, local->inode, flags); + +out: + UPCALL_STACK_UNWIND (readlink, frame, op_ret, op_errno, path, stbuf, + xdata); + + return 0; +} + +int32_t +up_readlink (call_frame_t *frame, xlator_t *this, + loc_t *loc, size_t size, dict_t *xdata) +{ + int32_t op_errno = -1; + upcall_local_t *local = NULL; + + EXIT_IF_UPCALL_OFF (this, out); + + local = upcall_local_init (frame, this, loc->inode); + if (!local) { + op_errno = ENOMEM; + goto err; + } + +out: + STACK_WIND (frame, up_readlink_cbk, + FIRST_CHILD(this), FIRST_CHILD(this)->fops->readlink, + loc, size, xdata); + + return 0; + +err: + op_errno = (op_errno == -1) ? errno : op_errno; + UPCALL_STACK_UNWIND (readlink, frame, -1, op_errno, NULL, + NULL, NULL); + + return 0; +} + +int32_t +up_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) +{ + client_t *client = NULL; + uint32_t flags = 0; + upcall_local_t *local = NULL; + + EXIT_IF_UPCALL_OFF (this, out); + + client = frame->root->client; + local = frame->local; + + if ((op_ret < 0) || !local) { + goto out; + } + + /* invalidate parent's entry too */ + flags = UP_PARENT_DENTRY_FLAGS; + upcall_cache_invalidate_dir (frame, this, client, local->inode, flags); + +out: + UPCALL_STACK_UNWIND (mknod, frame, op_ret, op_errno, inode, buf, + preparent, postparent, xdata); + + return 0; +} + +int32_t +up_mknod (call_frame_t *frame, xlator_t *this, loc_t *loc, + mode_t mode, dev_t rdev, mode_t umask, dict_t *xdata) +{ + int32_t op_errno = -1; + upcall_local_t *local = NULL; + + EXIT_IF_UPCALL_OFF (this, out); + + local = upcall_local_init (frame, this, loc->inode); + if (!local) { + op_errno = ENOMEM; + goto err; + } + +out: + STACK_WIND (frame, up_mknod_cbk, + FIRST_CHILD(this), FIRST_CHILD(this)->fops->mknod, + loc, mode, rdev, umask, xdata); + + return 0; + +err: + op_errno = (op_errno == -1) ? errno : op_errno; + UPCALL_STACK_UNWIND (mknod, frame, -1, op_errno, NULL, + NULL, NULL, NULL, NULL); + + return 0; +} + +int32_t +up_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) +{ + client_t *client = NULL; + uint32_t flags = 0; + upcall_local_t *local = NULL; + + EXIT_IF_UPCALL_OFF (this, out); + + client = frame->root->client; + local = frame->local; + + if ((op_ret < 0) || !local) { + goto out; + } + + /* invalidate parent's entry too */ + flags = UP_PARENT_DENTRY_FLAGS; + upcall_cache_invalidate_dir (frame, this, client, local->inode, flags); + +out: + UPCALL_STACK_UNWIND (symlink, frame, op_ret, op_errno, inode, buf, + preparent, postparent, xdata); + + return 0; +} + +int32_t +up_symlink (call_frame_t *frame, xlator_t *this, + const char *linkpath, loc_t *loc, mode_t umask, + dict_t *xdata) +{ + int32_t op_errno = -1; + upcall_local_t *local = NULL; + + EXIT_IF_UPCALL_OFF (this, out); + + local = upcall_local_init (frame, this, loc->inode); + if (!local) { + op_errno = ENOMEM; + goto err; + } + +out: + STACK_WIND (frame, up_symlink_cbk, + FIRST_CHILD(this), FIRST_CHILD(this)->fops->symlink, + linkpath, loc, umask, xdata); + + return 0; + +err: + op_errno = (op_errno == -1) ? errno : op_errno; + UPCALL_STACK_UNWIND (symlink, frame, -1, op_errno, NULL, + NULL, NULL, NULL, NULL); + + return 0; +} + +int32_t +up_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) +{ + client_t *client = NULL; + uint32_t flags = 0; + upcall_local_t *local = NULL; + + EXIT_IF_UPCALL_OFF (this, out); + + client = frame->root->client; + local = frame->local; + + if ((op_ret < 0) || !local) { + goto out; + } + flags = UP_UPDATE_CLIENT; + upcall_cache_invalidate (frame, this, client, local->inode, flags); + +out: + UPCALL_STACK_UNWIND (opendir, frame, op_ret, op_errno, fd, xdata); + + return 0; +} + +int32_t +up_opendir (call_frame_t *frame, xlator_t *this, + loc_t *loc, fd_t *fd, dict_t *xdata) +{ + int32_t op_errno = -1; + upcall_local_t *local = NULL; + + EXIT_IF_UPCALL_OFF (this, out); + + local = upcall_local_init (frame, this, loc->inode); + if (!local) { + op_errno = ENOMEM; + goto err; + } + +out: + STACK_WIND (frame, up_opendir_cbk, + FIRST_CHILD(this), FIRST_CHILD(this)->fops->opendir, + loc, fd, xdata); + + return 0; + +err: + op_errno = (op_errno == -1) ? errno : op_errno; + UPCALL_STACK_UNWIND (opendir, frame, -1, op_errno, NULL, NULL); + + return 0; +} + +int32_t +up_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) +{ + client_t *client = NULL; + uint32_t flags = 0; + upcall_local_t *local = NULL; + + EXIT_IF_UPCALL_OFF (this, out); + + client = frame->root->client; + local = frame->local; + + if ((op_ret < 0) || !local) { + goto out; + } + flags = UP_UPDATE_CLIENT; + upcall_cache_invalidate (frame, this, client, local->inode, flags); + +out: + UPCALL_STACK_UNWIND (statfs, frame, op_ret, op_errno, buf, xdata); + + return 0; +} + +int32_t +up_statfs (call_frame_t *frame, xlator_t *this, + loc_t *loc, dict_t *xdata) +{ + int32_t op_errno = -1; + upcall_local_t *local = NULL; + + EXIT_IF_UPCALL_OFF (this, out); + + local = upcall_local_init (frame, this, loc->inode); + if (!local) { + op_errno = ENOMEM; + goto err; + } + +out: + STACK_WIND (frame, up_statfs_cbk, + FIRST_CHILD(this), FIRST_CHILD(this)->fops->statfs, + loc, xdata); + + return 0; + +err: + op_errno = (op_errno == -1) ? errno : op_errno; + UPCALL_STACK_UNWIND (statfs, frame, -1, op_errno, NULL, NULL); + + return 0; +} + +int32_t +up_readdir_cbk (call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, gf_dirent_t *entries, + dict_t *xdata) +{ + client_t *client = NULL; + uint32_t flags = 0; + upcall_local_t *local = NULL; + + EXIT_IF_UPCALL_OFF (this, out); + + client = frame->root->client; + local = frame->local; + + if ((op_ret < 0) || !local) { + goto out; + } + flags = UP_UPDATE_CLIENT; + upcall_cache_invalidate (frame, this, client, local->inode, flags); + +out: + UPCALL_STACK_UNWIND (readdir, frame, op_ret, op_errno, entries, xdata); + + return 0; +} + +int32_t +up_readdir (call_frame_t *frame, xlator_t *this, + fd_t *fd, size_t size, off_t off, dict_t *xdata) +{ + int32_t op_errno = -1; + upcall_local_t *local = NULL; + + EXIT_IF_UPCALL_OFF (this, out); + + local = upcall_local_init (frame, this, fd->inode); + if (!local) { + op_errno = ENOMEM; + goto err; + } + +out: + STACK_WIND (frame, up_readdir_cbk, + FIRST_CHILD(this), FIRST_CHILD(this)->fops->readdir, + fd, size, off, xdata); + + return 0; + +err: + op_errno = (op_errno == -1) ? errno : op_errno; + UPCALL_STACK_UNWIND (readdir, frame, -1, op_errno, NULL, NULL); + + return 0; +} + +int32_t +up_readdirp (call_frame_t *frame, xlator_t *this, + fd_t *fd, size_t size, off_t off, dict_t *dict) +{ + int32_t op_errno = -1; + upcall_local_t *local = NULL; + + EXIT_IF_UPCALL_OFF (this, out); + + local = upcall_local_init (frame, this, fd->inode); + if (!local) { + op_errno = ENOMEM; + goto err; + } + +out: + STACK_WIND (frame, up_readdir_cbk, + FIRST_CHILD(this), FIRST_CHILD(this)->fops->readdirp, + fd, size, off, dict); + + return 0; + +err: + op_errno = (op_errno == -1) ? errno : op_errno; + UPCALL_STACK_UNWIND (readdirp, frame, -1, op_errno, NULL, NULL); + + return 0; +} + +int32_t +up_fsetattr (call_frame_t *frame, xlator_t *this, fd_t *fd, + struct iatt *stbuf, int32_t valid, dict_t *xdata) +{ + int32_t op_errno = -1; + upcall_local_t *local = NULL; + + EXIT_IF_UPCALL_OFF (this, out); + + local = upcall_local_init (frame, this, fd->inode); + if (!local) { + op_errno = ENOMEM; + goto err; + } + +out: + STACK_WIND (frame, up_setattr_cbk, + FIRST_CHILD(this), FIRST_CHILD(this)->fops->fsetattr, + fd, stbuf, valid, xdata); + + return 0; + +err: + op_errno = (op_errno == -1) ? errno : op_errno; + UPCALL_STACK_UNWIND (fsetattr, frame, -1, op_errno, NULL, + NULL, NULL); + + return 0; +} + +int32_t +up_fallocate_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, struct iatt *pre, + struct iatt *post, dict_t *xdata) +{ + client_t *client = NULL; + uint32_t flags = 0; + upcall_local_t *local = NULL; + + EXIT_IF_UPCALL_OFF (this, out); + + client = frame->root->client; + local = frame->local; + + if ((op_ret < 0) || !local) { + goto out; + } + flags = UP_WRITE_FLAGS; + upcall_cache_invalidate (frame, this, client, local->inode, flags); + +out: + UPCALL_STACK_UNWIND (fallocate, frame, op_ret, op_errno, pre, + post, xdata); + + return 0; +} + +int32_t +up_fallocate(call_frame_t *frame, xlator_t *this, fd_t *fd, + int32_t mode, off_t offset, size_t len, dict_t *xdata) +{ + int32_t op_errno = -1; + upcall_local_t *local = NULL; + + EXIT_IF_UPCALL_OFF (this, out); + + local = upcall_local_init (frame, this, fd->inode); + if (!local) { + op_errno = ENOMEM; + goto err; + } + +out: + STACK_WIND (frame, up_fallocate_cbk, + FIRST_CHILD(this), FIRST_CHILD(this)->fops->fallocate, + fd, mode, offset, len, xdata); + + return 0; + +err: + op_errno = (op_errno == -1) ? errno : op_errno; + UPCALL_STACK_UNWIND (fallocate, frame, -1, op_errno, NULL, + NULL, NULL); + + return 0; +} + +int32_t +up_discard_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, struct iatt *pre, + struct iatt *post, dict_t *xdata) +{ + client_t *client = NULL; + uint32_t flags = 0; + upcall_local_t *local = NULL; + + EXIT_IF_UPCALL_OFF (this, out); + + client = frame->root->client; + local = frame->local; + + if ((op_ret < 0) || !local) { + goto out; + } + flags = UP_WRITE_FLAGS; + upcall_cache_invalidate (frame, this, client, local->inode, flags); + +out: + UPCALL_STACK_UNWIND (discard, frame, op_ret, op_errno, pre, + post, xdata); + + return 0; +} + +int32_t +up_discard(call_frame_t *frame, xlator_t *this, fd_t *fd, + off_t offset, size_t len, dict_t *xdata) +{ + int32_t op_errno = -1; + upcall_local_t *local = NULL; + + EXIT_IF_UPCALL_OFF (this, out); + + local = upcall_local_init (frame, this, fd->inode); + if (!local) { + op_errno = ENOMEM; + goto err; + } + +out: + STACK_WIND (frame, up_discard_cbk, + FIRST_CHILD(this), FIRST_CHILD(this)->fops->discard, + fd, offset, len, xdata); + + return 0; + +err: + op_errno = (op_errno == -1) ? errno : op_errno; + UPCALL_STACK_UNWIND (discard, frame, -1, op_errno, NULL, + NULL, NULL); + + return 0; +} + +int32_t +up_zerofill_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, struct iatt *pre, + struct iatt *post, dict_t *xdata) +{ + client_t *client = NULL; + uint32_t flags = 0; + upcall_local_t *local = NULL; + + EXIT_IF_UPCALL_OFF (this, out); + + client = frame->root->client; + local = frame->local; + + if ((op_ret < 0) || !local) { + goto out; + } + flags = UP_WRITE_FLAGS; + upcall_cache_invalidate (frame, this, client, local->inode, flags); + +out: + UPCALL_STACK_UNWIND (zerofill, frame, op_ret, op_errno, pre, + post, xdata); + + return 0; +} + +int +up_zerofill(call_frame_t *frame, xlator_t *this, fd_t *fd, + off_t offset, off_t len, dict_t *xdata) +{ + int32_t op_errno = -1; + upcall_local_t *local = NULL; + + EXIT_IF_UPCALL_OFF (this, out); + + local = upcall_local_init (frame, this, fd->inode); + if (!local) { + op_errno = ENOMEM; + goto err; + } + +out: + STACK_WIND (frame, up_zerofill_cbk, + FIRST_CHILD(this), FIRST_CHILD(this)->fops->zerofill, + fd, offset, len, xdata); + + return 0; + +err: + op_errno = (op_errno == -1) ? errno : op_errno; + UPCALL_STACK_UNWIND (zerofill, frame, -1, op_errno, NULL, + NULL, NULL); + + return 0; +} + +int32_t +mem_acct_init (xlator_t *this) +{ + int ret = -1; + + if (!this) + return ret; + + ret = xlator_mem_acct_init (this, gf_upcall_mt_end + 1); + + if (ret != 0) { + gf_msg ("upcall", GF_LOG_WARNING, 0, + UPCALL_MSG_NO_MEMORY, + "Memory allocation failed"); + return ret; + } + + return ret; +} + +void +upcall_local_wipe (xlator_t *this, upcall_local_t *local) +{ + if (local) { + inode_unref (local->inode); + mem_put (local); + loc_wipe (&local->rename_oldloc); + } +} + +upcall_local_t * +upcall_local_init (call_frame_t *frame, xlator_t *this, inode_t *inode) +{ + upcall_local_t *local = NULL; + + local = mem_get0 (THIS->local_pool); + + if (!local) + goto out; + + local->inode = inode_ref (inode); + + /* Shall we get inode_ctx and store it here itself? */ + local->upcall_inode_ctx = upcall_inode_ctx_get (inode, this); + + frame->local = local; + +out: + return local; +} + +int +reconfigure (xlator_t *this, dict_t *options) +{ + upcall_private_t *priv = NULL; + int ret = -1; + + priv = this->private; + GF_ASSERT (priv); + + GF_OPTION_RECONF ("cache-invalidation", priv->cache_invalidation_enabled, + options, bool, out); + GF_OPTION_RECONF ("cache-invalidation-timeout", priv->cache_invalidation_timeout, + options, int32, out); + + ret = 0; +out: + return ret; +} + +int +init (xlator_t *this) +{ + int ret = -1; + upcall_private_t *priv = NULL; + + priv = GF_CALLOC (1, sizeof (*priv), + gf_upcall_mt_private_t); + if (!priv) { + gf_msg ("upcall", GF_LOG_WARNING, 0, + UPCALL_MSG_NO_MEMORY, + "Memory allocation failed"); + goto out; + } + + GF_OPTION_INIT ("cache-invalidation", priv->cache_invalidation_enabled, + bool, out); + GF_OPTION_INIT ("cache-invalidation-timeout", + priv->cache_invalidation_timeout, int32, out); + + this->private = priv; + this->local_pool = mem_pool_new (upcall_local_t, 512); + ret = 0; + +out: + if (ret) { + GF_FREE (priv); + } + + return ret; +} + +int +fini (xlator_t *this) +{ + upcall_private_t *priv = NULL; + + priv = this->private; + if (!priv) { + return 0; + } + this->private = NULL; + + GF_FREE (priv); + + return 0; +} + +int +upcall_forget (xlator_t *this, inode_t *inode) +{ + upcall_cleanup_inode_ctx (this, inode); + return 0; +} + +int +upcall_release (xlator_t *this, fd_t *fd) +{ + return 0; +} + +int +notify (xlator_t *this, int32_t event, void *data, ...) +{ + int ret = -1; + int32_t val = 0; + notify_event_data_t *notify_event = NULL; + struct gf_upcall up_req = {0,}; + upcall_client_t *up_client_entry = NULL; + struct gf_upcall_cache_invalidation ca_req = {0,}; + + switch (event) { + case GF_EVENT_UPCALL: + { + gf_log (this->name, GF_LOG_DEBUG, "Upcall Notify event = %d", + event); + + notify_event = (notify_event_data_t *) data; + up_client_entry = notify_event->client_entry; + + if (!up_client_entry) { + goto out; + } + + up_req.client_uid = up_client_entry->client_uid; + + gf_uuid_copy (up_req.gfid, notify_event->gfid); + gf_log (this->name, GF_LOG_DEBUG, + "Sending notify to the client- %s, gfid - %s", + up_client_entry->client_uid, up_req.gfid); switch (notify_event->event_type) { case GF_UPCALL_CACHE_INVALIDATION: @@ -943,38 +1744,75 @@ out: } struct xlator_fops fops = { + /* fops which do not trigger upcall + * notifications but will add/update + * clients info in the upcall inode ctx.*/ + .lookup = up_lookup, .open = up_open, + .statfs = up_statfs, + .opendir = up_opendir, + .readdir = up_readdir, + .readdirp = up_readdirp, + .stat = up_stat, + .fstat = up_fstat, + .access = up_access, + .readlink = up_readlink, .readv = up_readv, - .writev = up_writev, - .truncate = up_truncate, .lk = up_lk, + + /* fops doing write */ + .truncate = up_truncate, + .ftruncate = up_ftruncate, + .writev = up_writev, + .zerofill = up_zerofill, + .fallocate = up_fallocate, + .discard = up_discard, + + /* fops changing attributes */ + .fsetattr = up_fsetattr, .setattr = up_setattr, + + /* fops affecting parent dirent */ + .mknod = up_mknod, + .create = up_create, + .symlink = up_symlink, + .mkdir = up_mkdir, + + /* fops affecting both file and parent + * cache entries */ + .unlink = up_unlink, + .link = up_link, + .rmdir = up_rmdir, .rename = up_rename, - .unlink = up_unlink, /* invalidate both file and parent dir */ - .rmdir = up_rmdir, /* same as above */ - .link = up_link, /* invalidate both file and parent dir */ - .create = up_create, /* update only direntry */ - .mkdir = up_mkdir, /* update only dirent */ -#ifdef WIP - .ftruncate = up_ftruncate, /* reqd? */ - .getattr = up_getattr, /* ?? */ - .getxattr = up_getxattr, /* ?? */ - .access = up_access, - .lookup = up_lookup, - .symlink = up_symlink, /* invalidate both file and parent dir maybe */ - .readlink = up_readlink, /* Needed? readlink same as read? */ - .readdirp = up_readdirp, - .readdir = up_readdir, -/* other fops to be considered - Bug1200271 - * lookup, stat, opendir, readdir, readdirp, readlink, mknod, statfs, flush, - * fsync, mknod, fsyncdir, setxattr, removexattr, rchecksum, fallocate, discard, - * zerofill, (also variants of above similar to fsetattr) - */ + +#ifdef NOT_SUPPORTED + /* internal lk fops */ + .inodelk = up_inodelk, + .finodelk = up_finodelk, + .entrylk = up_entrylk, + .fentrylk = up_fentrylk, + + /* Below fops follow 'WRITE' which + * would have already sent upcall + * notifications */ + .flush = up_flush, + .fsync = up_fsync, + .fsyncdir = up_fsyncdir, + + /* XXX: Handle xattr fops (BZ-1211863) */ + .getxattr = up_getxattr, + .fgetxattr = up_fgetxattr, + .fremovexattr = up_fremovexattr, + .removexattr = up_removexattr, + .setxattr = up_setxattr, + .fsetxattr = up_fsetxattr, + .xattrop = up_xattrop, + .fxattrop = up_fxattrop, #endif }; struct xlator_cbks cbks = { - .forget = upcall_forget, + .forget = upcall_forget, .release = upcall_release, }; diff --git a/xlators/features/upcall/src/upcall.h b/xlators/features/upcall/src/upcall.h index 3994c2648f4..7e15f6c97cd 100644 --- a/xlators/features/upcall/src/upcall.h +++ b/xlators/features/upcall/src/upcall.h @@ -96,6 +96,7 @@ struct upcall_local { */ upcall_inode_ctx_t *upcall_inode_ctx; inode_t *inode; + loc_t rename_oldloc; }; typedef struct upcall_local upcall_local_t; @@ -129,5 +130,8 @@ void upcall_cache_invalidate (call_frame_t *frame, xlator_t *this, client_t *cli void upcall_client_cache_invalidate (xlator_t *xl, uuid_t gfid, upcall_client_t *up_client_entry, uint32_t flags); +void upcall_cache_invalidate_dir (call_frame_t *frame, xlator_t *this, + client_t *client, inode_t *inode, + uint32_t flags); #endif /* __UPCALL_H__ */ -- cgit