core: adding extra data for fops

with this change, the xlator APIs will have a dictionary as extra
argument, which is passed between all the layers. This can be
utilized for overloading in some of the operations.

Change-Id: I58a8186b3ef647650280e63f3e5e9b9de7827b40
Signed-off-by: Amar Tumballi <amarts@redhat.com>
BUG: 782265
Reviewed-on: http://review.gluster.com/2960
Tested-by: Gluster Build System <jenkins@build.gluster.com>
Reviewed-by: Anand Avati <avati@redhat.com>

19 files changed, 966 insertions, 887 deletions

diff --git a/xlators/features/Makefile.am b/xlators/features/Makefile.am
index 884f82d68ff..be48f93fa52 100644
--- a/xlators/features/Makefile.am
+++ b/xlators/features/Makefile.am
@@ -1,3 +1,3 @@
-SUBDIRS = locks trash quota read-only mac-compat quiesce marker index#path-converter # filter
+SUBDIRS = locks quota read-only mac-compat quiesce marker index # trash path-converter # filter
 
 CLEANFILES =
diff --git a/xlators/features/index/src/index.c b/xlators/features/index/src/index.c
index 12309b83f85..ead20e06f88 100644
--- a/xlators/features/index/src/index.c
+++ b/xlators/features/index/src/index.c
@@ -605,10 +605,10 @@ unlock:
                 frame = new->frame;
                 if (new->fop == GF_FOP_XATTROP) {
                         INDEX_STACK_UNWIND (xattrop, frame, -1, ENOMEM,
-                                            NULL);
+                                            NULL, NULL);
                 } else if (new->fop == GF_FOP_FXATTROP) {
                         INDEX_STACK_UNWIND (fxattrop, frame, -1, ENOMEM,
-                                            NULL);
+                                            NULL, NULL);
                 }
                 call_stub_destroy (new);
         } else if (stub) {
@@ -619,7 +619,7 @@ unlock:
 
 int32_t
 index_xattrop_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                   int32_t op_ret, int32_t op_errno, dict_t *xattr)
+                   int32_t op_ret, int32_t op_errno, dict_t *xattr, dict_t *xdata)
 {
         inode_t *inode = NULL;
 
@@ -628,7 +628,7 @@ index_xattrop_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
                 goto out;
         fop_xattrop_index_action (this, frame->local, xattr);
 out:
-        INDEX_STACK_UNWIND (xattrop, frame, op_ret, op_errno, xattr);
+        INDEX_STACK_UNWIND (xattrop, frame, op_ret, op_errno, xattr, xdata);
         index_queue_process (this, inode, NULL);
         inode_unref (inode);
 
@@ -637,7 +637,8 @@ out:
 
 int32_t
 index_fxattrop_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                    int32_t op_ret, int32_t op_errno, dict_t *xattr)
+                    int32_t op_ret, int32_t op_errno, dict_t *xattr,
+                    dict_t *xdata)
 {
         inode_t *inode = NULL;
 
@@ -647,7 +648,7 @@ index_fxattrop_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
 
         fop_fxattrop_index_action (this, frame->local, xattr);
 out:
-        INDEX_STACK_UNWIND (fxattrop, frame, op_ret, op_errno, xattr);
+        INDEX_STACK_UNWIND (fxattrop, frame, op_ret, op_errno, xattr, xdata);
         index_queue_process (this, inode, NULL);
         inode_unref (inode);
 
@@ -656,25 +657,27 @@ out:
 
 int
 index_xattrop_wrapper (call_frame_t *frame, xlator_t *this, loc_t *loc,
-                       gf_xattrop_flags_t optype, dict_t *xattr)
+                       gf_xattrop_flags_t optype, dict_t *xattr, dict_t *xdata)
 {
         STACK_WIND (frame, index_xattrop_cbk, FIRST_CHILD (this),
-                    FIRST_CHILD (this)->fops->xattrop, loc, optype, xattr);
+                    FIRST_CHILD (this)->fops->xattrop, loc, optype, xattr,
+                    xdata);
         return 0;
 }
 
 int
 index_fxattrop_wrapper (call_frame_t *frame, xlator_t *this, fd_t *fd,
-                        gf_xattrop_flags_t optype, dict_t *xattr)
+                        gf_xattrop_flags_t optype, dict_t *xattr, dict_t *xdata)
 {
         STACK_WIND (frame, index_fxattrop_cbk, FIRST_CHILD (this),
-                    FIRST_CHILD (this)->fops->fxattrop, fd, optype, xattr);
+                    FIRST_CHILD (this)->fops->fxattrop, fd, optype, xattr,
+                    xdata);
         return 0;
 }
 
 int32_t
 index_xattrop (call_frame_t *frame, xlator_t *this, loc_t *loc,
-	       gf_xattrop_flags_t flags, dict_t *dict)
+	       gf_xattrop_flags_t flags, dict_t *dict, dict_t *xdata)
 {
         call_stub_t     *stub = NULL;
 
@@ -683,9 +686,9 @@ index_xattrop (call_frame_t *frame, xlator_t *this, loc_t *loc,
 
         frame->local = inode_ref (loc->inode);
         stub = fop_xattrop_stub (frame, index_xattrop_wrapper,
-                                 loc, flags, dict);
+                                 loc, flags, dict, xdata);
         if (!stub) {
-                INDEX_STACK_UNWIND (xattrop, frame, -1, ENOMEM, NULL);
+                INDEX_STACK_UNWIND (xattrop, frame, -1, ENOMEM, NULL, NULL);
                 return 0;
         }
 
@@ -693,13 +696,13 @@ index_xattrop (call_frame_t *frame, xlator_t *this, loc_t *loc,
         return 0;
 out:
         STACK_WIND (frame, default_xattrop_cbk, FIRST_CHILD(this),
-                    FIRST_CHILD(this)->fops->xattrop, loc, flags, dict);
+                    FIRST_CHILD(this)->fops->xattrop, loc, flags, dict, xdata);
         return 0;
 }
 
 int32_t
 index_fxattrop (call_frame_t *frame, xlator_t *this, fd_t *fd,
-		gf_xattrop_flags_t flags, dict_t *dict)
+		gf_xattrop_flags_t flags, dict_t *dict, dict_t *xdata)
 {
         call_stub_t    *stub = NULL;
 
@@ -708,9 +711,9 @@ index_fxattrop (call_frame_t *frame, xlator_t *this, fd_t *fd,
 
         frame->local = inode_ref (fd->inode);
         stub = fop_fxattrop_stub (frame, index_fxattrop_wrapper,
-                                  fd, flags, dict);
+                                  fd, flags, dict, xdata);
         if (!stub) {
-                INDEX_STACK_UNWIND (fxattrop, frame, -1, ENOMEM, NULL);
+                INDEX_STACK_UNWIND (fxattrop, frame, -1, ENOMEM, NULL, xdata);
                 return 0;
         }
 
@@ -718,13 +721,13 @@ index_fxattrop (call_frame_t *frame, xlator_t *this, fd_t *fd,
         return 0;
 out:
         STACK_WIND (frame, default_fxattrop_cbk, FIRST_CHILD(this),
-                    FIRST_CHILD(this)->fops->fxattrop, fd, flags, dict);
+                    FIRST_CHILD(this)->fops->fxattrop, fd, flags, dict, xdata);
         return 0;
 }
 
 int32_t
 index_getxattr_wrapper (call_frame_t *frame, xlator_t *this,
-                        loc_t *loc, const char *name)
+                        loc_t *loc, const char *name, dict_t *xdata)
 {
         index_priv_t    *priv = NULL;
         dict_t          *xattr = NULL;
@@ -748,9 +751,9 @@ index_getxattr_wrapper (call_frame_t *frame, xlator_t *this,
         }
 done:
         if (ret)
-                STACK_UNWIND_STRICT (getxattr, frame, -1, -ret, xattr);
+                STACK_UNWIND_STRICT (getxattr, frame, -1, -ret, xattr, xdata);
         else
-                STACK_UNWIND_STRICT (getxattr, frame, 0, 0, xattr);
+                STACK_UNWIND_STRICT (getxattr, frame, 0, 0, xattr, xdata);
 
         if (xattr)
                 dict_unref (xattr);
@@ -820,7 +823,7 @@ done:
 
 int32_t
 index_readdir_wrapper (call_frame_t *frame, xlator_t *this,
-                       fd_t *fd, size_t size, off_t off)
+                       fd_t *fd, size_t size, off_t off, dict_t *xdata)
 {
         index_fd_ctx_t       *fctx           = NULL;
         DIR                  *dir            = NULL;
@@ -855,13 +858,14 @@ index_readdir_wrapper (call_frame_t *frame, xlator_t *this,
         op_errno = errno;
         op_ret = count;
 done:
-        STACK_UNWIND_STRICT (readdir, frame, op_ret, op_errno, &entries);
+        STACK_UNWIND_STRICT (readdir, frame, op_ret, op_errno, &entries, xdata);
         gf_dirent_free (&entries);
         return 0;
 }
 
 int
-index_unlink_wrapper (call_frame_t *frame, xlator_t *this, loc_t *loc)
+index_unlink_wrapper (call_frame_t *frame, xlator_t *this, loc_t *loc, int flag,
+                      dict_t *xdata)
 {
         index_priv_t    *priv = NULL;
         int32_t         op_ret = 0;
@@ -905,29 +909,30 @@ index_unlink_wrapper (call_frame_t *frame, xlator_t *this, loc_t *loc)
         postparent.ia_ino = -1;
 done:
         INDEX_STACK_UNWIND (unlink, frame, op_ret, op_errno, &preparent,
-                            &postparent);
+                            &postparent, xdata);
         return 0;
 }
 
 int32_t
 index_getxattr (call_frame_t *frame, xlator_t *this,
-                loc_t *loc, const char *name)
+                loc_t *loc, const char *name, dict_t *xdata)
 {
         call_stub_t     *stub = NULL;
 
         if (!name || strcmp (GF_XATTROP_INDEX_GFID, name))
                 goto out;
 
-        stub = fop_getxattr_stub (frame, index_getxattr_wrapper, loc, name);
+        stub = fop_getxattr_stub (frame, index_getxattr_wrapper, loc, name,
+                                  xdata);
         if (!stub) {
-                STACK_UNWIND_STRICT (getxattr, frame, -1, ENOMEM, NULL);
+                STACK_UNWIND_STRICT (getxattr, frame, -1, ENOMEM, NULL, NULL);
                 return 0;
         }
         worker_enqueue (this, stub);
         return 0;
 out:
         STACK_WIND (frame, default_getxattr_cbk, FIRST_CHILD(this),
-                    FIRST_CHILD(this)->fops->getxattr, loc, name);
+                    FIRST_CHILD(this)->fops->getxattr, loc, name, xdata);
         return 0;
 }
 
@@ -961,7 +966,7 @@ normal:
 
 int32_t
 index_readdir (call_frame_t *frame, xlator_t *this,
-               fd_t *fd, size_t size, off_t off)
+               fd_t *fd, size_t size, off_t off, dict_t *xdata)
 {
         call_stub_t     *stub = NULL;
         index_priv_t    *priv = NULL;
@@ -969,21 +974,23 @@ index_readdir (call_frame_t *frame, xlator_t *this,
         priv = this->private;
         if (uuid_compare (fd->inode->gfid, priv->xattrop_vgfid))
                 goto out;
-        stub = fop_readdir_stub (frame, index_readdir_wrapper, fd, size, off);
+        stub = fop_readdir_stub (frame, index_readdir_wrapper, fd, size, off,
+                                 xdata);
         if (!stub) {
-                STACK_UNWIND_STRICT (readdir, frame, -1, ENOMEM, NULL);
+                STACK_UNWIND_STRICT (readdir, frame, -1, ENOMEM, NULL, NULL);
                 return 0;
         }
         worker_enqueue (this, stub);
         return 0;
 out:
         STACK_WIND (frame, default_readdir_cbk, FIRST_CHILD(this),
-                    FIRST_CHILD(this)->fops->readdir, fd, size, off);
+                    FIRST_CHILD(this)->fops->readdir, fd, size, off, xdata);
         return 0;
 }
 
 int
-index_unlink (call_frame_t *frame, xlator_t *this, loc_t *loc)
+index_unlink (call_frame_t *frame, xlator_t *this, loc_t *loc, int xflag,
+              dict_t *xdata)
 {
         call_stub_t     *stub = NULL;
         index_priv_t    *priv = NULL;
@@ -992,16 +999,17 @@ index_unlink (call_frame_t *frame, xlator_t *this, loc_t *loc)
         if (uuid_compare (loc->pargfid, priv->xattrop_vgfid))
                 goto out;
 
-        stub = fop_unlink_stub (frame, index_unlink_wrapper, loc);
+        stub = fop_unlink_stub (frame, index_unlink_wrapper, loc, xflag, xdata);
         if (!stub) {
-                STACK_UNWIND_STRICT (unlink, frame, -1, ENOMEM, NULL, NULL);
+                STACK_UNWIND_STRICT (unlink, frame, -1, ENOMEM, NULL, NULL,
+                                     NULL);
                 return 0;
         }
         worker_enqueue (this, stub);
         return 0;
 out:
         STACK_WIND (frame, default_unlink_cbk, FIRST_CHILD(this),
-                    FIRST_CHILD(this)->fops->unlink, loc);
+                    FIRST_CHILD(this)->fops->unlink, loc, xflag, xdata);
         return 0;
 }
 
diff --git a/xlators/features/locks/src/clear.c b/xlators/features/locks/src/clear.c
index 6c6afe008be..a4e235886e2 100644
--- a/xlators/features/locks/src/clear.c
+++ b/xlators/features/locks/src/clear.c
@@ -193,8 +193,8 @@ clrlk_clear_posixlk (xlator_t *this, pl_inode_t *pl_inode, clrlk_args *args,
                                               F_SETLKW, &plock->user_flock,
                                               -1, EAGAIN, NULL);
 
-                                STACK_UNWIND (plock->frame, -1, EAGAIN,
-                                              &plock->user_flock);
+                                STACK_UNWIND_STRICT (lk, plock->frame, -1, EAGAIN,
+                                                     &plock->user_flock, NULL);
 
                         } else {
                                 gcount++;
@@ -261,7 +261,7 @@ blkd:
                               &ilock->user_flock, -1, EAGAIN,
                               ilock->volume);
                 STACK_UNWIND_STRICT (inodelk, ilock->frame, -1,
-                                     EAGAIN);
+                                     EAGAIN, NULL);
                 //No need to take lock as the locks are only in one list
                 __pl_inodelk_unref (ilock);
         }
@@ -335,6 +335,7 @@ blkd:
                         }
 
                         bcount++;
+
                         list_del_init (&elock->blocked_locks);
                         list_add_tail (&elock->blocked_locks, &released);
                 }
@@ -346,7 +347,7 @@ blkd:
                 entrylk_trace_out (this, elock->frame, elock->volume, NULL, NULL,
                                    elock->basename, ENTRYLK_LOCK, elock->type,
                                    -1, EAGAIN);
-                STACK_UNWIND_STRICT (entrylk, elock->frame, -1, EAGAIN);
+                STACK_UNWIND_STRICT (entrylk, elock->frame, -1, EAGAIN, NULL);
                 GF_FREE ((char *) elock->basename);
                 GF_FREE (elock);
         }
diff --git a/xlators/features/locks/src/common.c b/xlators/features/locks/src/common.c
index b775fcca70b..a92145d23e1 100644
--- a/xlators/features/locks/src/common.c
+++ b/xlators/features/locks/src/common.c
@@ -933,7 +933,8 @@ grant_blocked_locks (xlator_t *this, pl_inode_t *pl_inode)
                 pl_trace_out (this, lock->frame, NULL, NULL, F_SETLKW,
                               &lock->user_flock, 0, 0, NULL);
 
-                STACK_UNWIND (lock->frame, 0, 0, &lock->user_flock);
+                STACK_UNWIND_STRICT (lk, lock->frame, 0, 0,
+                                     &lock->user_flock, NULL);
 
                 GF_FREE (lock);
         }
@@ -978,7 +979,8 @@ pl_send_prelock_unlock (xlator_t *this, pl_inode_t *pl_inode,
                 pl_trace_out (this, lock->frame, NULL, NULL, F_SETLKW,
                               &lock->user_flock, 0, 0, NULL);
 
-                STACK_UNWIND (lock->frame, 0, 0, &lock->user_flock);
+                STACK_UNWIND_STRICT (lk, lock->frame, 0, 0,
+                                     &lock->user_flock, NULL);
 
                 GF_FREE (lock);
         }
diff --git a/xlators/features/locks/src/entrylk.c b/xlators/features/locks/src/entrylk.c
index 3e91b9d9467..e034c37b325 100644
--- a/xlators/features/locks/src/entrylk.c
+++ b/xlators/features/locks/src/entrylk.c
@@ -505,7 +505,7 @@ grant_blocked_entry_locks (xlator_t *this, pl_inode_t *pl_inode,
                                    lock->basename, ENTRYLK_LOCK, lock->type,
                                    0, 0);
 
-                STACK_UNWIND_STRICT (entrylk, lock->frame, 0, 0);
+                STACK_UNWIND_STRICT (entrylk, lock->frame, 0, 0, NULL);
 
         }
 
@@ -573,7 +573,7 @@ release_entry_locks_for_transport (xlator_t *this, pl_inode_t *pinode,
         list_for_each_entry_safe (lock, tmp, &released, blocked_locks) {
                 list_del_init (&lock->blocked_locks);
 
-                STACK_UNWIND_STRICT (entrylk, lock->frame, -1, EAGAIN);
+                STACK_UNWIND_STRICT (entrylk, lock->frame, -1, EAGAIN, NULL);
 
                 if (lock->basename)
                         GF_FREE ((char *)lock->basename);
@@ -584,7 +584,7 @@ release_entry_locks_for_transport (xlator_t *this, pl_inode_t *pinode,
         list_for_each_entry_safe (lock, tmp, &granted, blocked_locks) {
                 list_del_init (&lock->blocked_locks);
 
-                STACK_UNWIND_STRICT (entrylk, lock->frame, 0, 0);
+                STACK_UNWIND_STRICT (entrylk, lock->frame, 0, 0, NULL);
 
                 if (lock->basename)
                         GF_FREE ((char *)lock->basename);
@@ -710,7 +710,7 @@ out:
                 entrylk_trace_out (this, frame, volume, fd, loc, basename,
                                    cmd, type, op_ret, op_errno);
 
-                STACK_UNWIND_STRICT (entrylk, frame, op_ret, op_errno);
+                STACK_UNWIND_STRICT (entrylk, frame, op_ret, op_errno, NULL);
         } else {
                 entrylk_trace_block (this, frame, volume, fd, loc, basename,
                                      cmd, type);
diff --git a/xlators/features/locks/src/inodelk.c b/xlators/features/locks/src/inodelk.c
index b59f2a280cc..a2e65d55fc3 100644
--- a/xlators/features/locks/src/inodelk.c
+++ b/xlators/features/locks/src/inodelk.c
@@ -369,7 +369,7 @@ grant_blocked_inode_locks (xlator_t *this, pl_inode_t *pl_inode, pl_dom_list_t *
                 pl_trace_out (this, lock->frame, NULL, NULL, F_SETLKW,
                               &lock->user_flock, 0, 0, lock->volume);
 
-                STACK_UNWIND_STRICT (inodelk, lock->frame, 0, 0);
+                STACK_UNWIND_STRICT (inodelk, lock->frame, 0, 0, NULL);
         }
 
         pthread_mutex_lock (&pl_inode->mutex);
@@ -462,7 +462,7 @@ release_inode_locks_of_transport (xlator_t *this, pl_dom_list_t *dom,
         list_for_each_entry_safe (l, tmp, &released, blocked_locks) {
                 list_del_init (&l->blocked_locks);
 
-                STACK_UNWIND_STRICT (inodelk, l->frame, -1, EAGAIN);
+                STACK_UNWIND_STRICT (inodelk, l->frame, -1, EAGAIN, NULL);
                 //No need to take lock as the locks are only in one list
                 __pl_inodelk_unref (l);
         }
@@ -668,7 +668,7 @@ unwind:
                 pl_trace_out (this, frame, fd, loc, cmd, flock, op_ret, op_errno, volume);
         }
 
-        STACK_UNWIND_STRICT (inodelk, frame, op_ret, op_errno);
+        STACK_UNWIND_STRICT (inodelk, frame, op_ret, op_errno, NULL);
 out:
         return 0;
 }
diff --git a/xlators/features/locks/src/locks.h b/xlators/features/locks/src/locks.h
index 6df1235a2be..f855c07899c 100644
--- a/xlators/features/locks/src/locks.h
+++ b/xlators/features/locks/src/locks.h
@@ -170,6 +170,7 @@ typedef struct {
         loc_t  loc;
         fd_t  *fd;
         off_t  offset;
+        dict_t *xdata;
         enum {TRUNCATE, FTRUNCATE} op;
 } pl_local_t;
 
diff --git a/xlators/features/locks/src/posix.c b/xlators/features/locks/src/posix.c
index 39991299c7f..81cfc7f9178 100644
--- a/xlators/features/locks/src/posix.c
+++ b/xlators/features/locks/src/posix.c
@@ -102,7 +102,7 @@ out:
 int
 pl_truncate_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
                  int32_t op_ret, int32_t op_errno, struct iatt *prebuf,
-                 struct iatt *postbuf)
+                 struct iatt *postbuf, dict_t *xdata)
 {
         pl_local_t *local = NULL;
 
@@ -111,8 +111,13 @@ pl_truncate_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
         if (local->op == TRUNCATE)
                 loc_wipe (&local->loc);
 
+        if (local->xdata)
+                dict_unref (local->xdata);
+        if (local->fd)
+                fd_unref (local->fd);
+
         STACK_UNWIND_STRICT (truncate, frame, op_ret, op_errno,
-                             prebuf, postbuf);
+                             prebuf, postbuf, xdata);
         return 0;
 }
 
@@ -153,7 +158,8 @@ truncate_allowed (pl_inode_t *pl_inode,
 
 static int
 truncate_stat_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                   int32_t op_ret, int32_t op_errno, struct iatt *buf)
+                   int32_t op_ret, int32_t op_errno, struct iatt *buf,
+                   dict_t *xdata)
 {
         posix_locks_private_t *priv = NULL;
         pl_local_t            *local = NULL;
@@ -197,12 +203,12 @@ truncate_stat_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
         case TRUNCATE:
                 STACK_WIND (frame, pl_truncate_cbk, FIRST_CHILD (this),
                             FIRST_CHILD (this)->fops->truncate,
-                            &local->loc, local->offset);
+                            &local->loc, local->offset, local->xdata);
                 break;
         case FTRUNCATE:
                 STACK_WIND (frame, pl_truncate_cbk, FIRST_CHILD (this),
                             FIRST_CHILD (this)->fops->ftruncate,
-                            local->fd, local->offset);
+                            local->fd, local->offset, local->xdata);
                 break;
         }
 
@@ -214,14 +220,14 @@ unwind:
         if (local->op == TRUNCATE)
                 loc_wipe (&local->loc);
 
-        STACK_UNWIND_STRICT (truncate, frame, op_ret, op_errno, buf, NULL);
+        STACK_UNWIND_STRICT (truncate, frame, op_ret, op_errno, buf, NULL, xdata);
         return 0;
 }
 
 
 int
 pl_truncate (call_frame_t *frame, xlator_t *this,
-             loc_t *loc, off_t offset)
+             loc_t *loc, off_t offset, dict_t *xdata)
 {
         pl_local_t *local = NULL;
 
@@ -231,18 +237,19 @@ pl_truncate (call_frame_t *frame, xlator_t *this,
         local->op         = TRUNCATE;
         local->offset     = offset;
         loc_copy (&local->loc, loc);
+        local->xdata = dict_ref (xdata);
 
         frame->local = local;
 
         STACK_WIND (frame, truncate_stat_cbk, FIRST_CHILD (this),
-                    FIRST_CHILD (this)->fops->stat, loc);
+                    FIRST_CHILD (this)->fops->stat, loc, NULL);
 
         return 0;
 
 unwind:
         gf_log (this->name, GF_LOG_ERROR, "truncate for %s failed with ret: %d, "
                 "error: %s", loc->path, -1, strerror (ENOMEM));
-        STACK_UNWIND_STRICT (truncate, frame, -1, ENOMEM, NULL, NULL);
+        STACK_UNWIND_STRICT (truncate, frame, -1, ENOMEM, NULL, NULL, NULL);
 
         return 0;
 }
@@ -250,7 +257,7 @@ unwind:
 
 int
 pl_ftruncate (call_frame_t *frame, xlator_t *this,
-              fd_t *fd, off_t offset)
+              fd_t *fd, off_t offset, dict_t *xdata)
 {
         pl_local_t *local = NULL;
 
@@ -259,18 +266,19 @@ pl_ftruncate (call_frame_t *frame, xlator_t *this,
 
         local->op         = FTRUNCATE;
         local->offset     = offset;
-        local->fd         = fd;
+        local->fd         = fd_ref (fd);
+        local->xdata      = dict_ref (xdata);
 
         frame->local = local;
 
         STACK_WIND (frame, truncate_stat_cbk, FIRST_CHILD(this),
-                    FIRST_CHILD(this)->fops->fstat, fd);
+                    FIRST_CHILD(this)->fops->fstat, fd, xdata);
         return 0;
 
 unwind:
         gf_log (this->name, GF_LOG_ERROR, "ftruncate failed with ret: %d, "
                 "error: %s", -1, strerror (ENOMEM));
-        STACK_UNWIND_STRICT (ftruncate, frame, -1, ENOMEM, NULL, NULL);
+        STACK_UNWIND_STRICT (ftruncate, frame, -1, ENOMEM, NULL, NULL, NULL);
 
         return 0;
 }
@@ -325,7 +333,8 @@ delete_locks_of_fd (xlator_t *this, pl_inode_t *pl_inode, fd_t *fd)
 
        list_for_each_entry_safe (l, tmp, &blocked_list, list) {
                list_del_init(&l->list);
-               STACK_UNWIND_STRICT (lk, l->frame, -1, EAGAIN, &l->user_flock);
+               STACK_UNWIND_STRICT (lk, l->frame, -1, EAGAIN, &l->user_flock,
+                                    NULL);
                __destroy_lock (l);
        }
 
@@ -368,16 +377,16 @@ __delete_locks_of_owner (pl_inode_t *pl_inode,
 
 int32_t
 pl_getxattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                 int32_t op_ret, int32_t op_errno, dict_t *dict)
+                 int32_t op_ret, int32_t op_errno, dict_t *dict, dict_t *xdata)
 {
-        STACK_UNWIND_STRICT (getxattr, frame, op_ret, op_errno, dict);
+        STACK_UNWIND_STRICT (getxattr, frame, op_ret, op_errno, dict, xdata);
         return 0;
 
 }
 
 int32_t
 pl_getxattr (call_frame_t *frame, xlator_t *this, loc_t *loc,
-             const char *name)
+             const char *name, dict_t *xdata)
 {
         int                     op_errno        = EINVAL;
         int                     op_ret          = -1;
@@ -457,7 +466,7 @@ pl_getxattr (call_frame_t *frame, xlator_t *this, loc_t *loc,
 
         op_ret = 0;
 out:
-        STACK_UNWIND_STRICT (getxattr, frame, op_ret, op_errno, dict);
+        STACK_UNWIND_STRICT (getxattr, frame, op_ret, op_errno, dict, xdata);
 
         if (args.opts)
                 GF_FREE (args.opts);
@@ -469,17 +478,17 @@ out:
 
 usual:
         STACK_WIND (frame, pl_getxattr_cbk, FIRST_CHILD(this),
-                    FIRST_CHILD(this)->fops->getxattr, loc, name);
+                    FIRST_CHILD(this)->fops->getxattr, loc, name, xdata);
         return 0;
 }
 
 int32_t
 pl_opendir_cbk (call_frame_t *frame,
-                     void *cookie,
-                     xlator_t *this,
-                     int32_t op_ret,
-                     int32_t op_errno,
-                     fd_t *fd)
+                void *cookie,
+                xlator_t *this,
+                int32_t op_ret,
+                int32_t op_errno,
+                fd_t *fd, dict_t *xdata)
 {
         pl_fdctx_t *fdctx = NULL;
 
@@ -498,28 +507,28 @@ unwind:
                              frame,
                              op_ret,
                              op_errno,
-                             fd);
+                             fd, xdata);
         return 0;
 }
 
 int32_t
 pl_opendir (call_frame_t *frame, xlator_t *this,
-             loc_t *loc, fd_t *fd)
+             loc_t *loc, fd_t *fd, dict_t *xdata)
 {
         STACK_WIND (frame,
                     pl_opendir_cbk,
                     FIRST_CHILD(this),
                     FIRST_CHILD(this)->fops->opendir,
-                    loc, fd);
+                    loc, fd, xdata);
         return 0;
 
 }
 
 int
 pl_flush_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-              int32_t op_ret, int32_t op_errno)
+              int32_t op_ret, int32_t op_errno, dict_t *xdata)
 {
-        STACK_UNWIND_STRICT (flush, frame, op_ret, op_errno);
+        STACK_UNWIND_STRICT (flush, frame, op_ret, op_errno, xdata);
 
         return 0;
 }
@@ -527,7 +536,7 @@ pl_flush_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
 
 int
 pl_flush (call_frame_t *frame, xlator_t *this,
-          fd_t *fd)
+          fd_t *fd, dict_t *xdata)
 {
         pl_inode_t *pl_inode = NULL;
 
@@ -535,7 +544,7 @@ pl_flush (call_frame_t *frame, xlator_t *this,
 
         if (!pl_inode) {
                 gf_log (this->name, GF_LOG_DEBUG, "Could not get inode.");
-                STACK_UNWIND_STRICT (flush, frame, -1, EBADFD);
+                STACK_UNWIND_STRICT (flush, frame, -1, EBADFD, NULL);
                 return 0;
         }
 
@@ -565,14 +574,14 @@ pl_flush (call_frame_t *frame, xlator_t *this,
 
 wind:
         STACK_WIND (frame, pl_flush_cbk, FIRST_CHILD(this),
-                    FIRST_CHILD(this)->fops->flush, fd);
+                    FIRST_CHILD(this)->fops->flush, fd, xdata);
         return 0;
 }
 
 
 int
 pl_open_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-             int32_t op_ret, int32_t op_errno, fd_t *fd)
+             int32_t op_ret, int32_t op_errno, fd_t *fd, dict_t *xdata)
 {
         pl_fdctx_t *fdctx = NULL;
 
@@ -587,7 +596,7 @@ pl_open_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
         }
 
 unwind:
-        STACK_UNWIND_STRICT (open, frame, op_ret, op_errno, fd);
+        STACK_UNWIND_STRICT (open, frame, op_ret, op_errno, fd, xdata);
 
         return 0;
 }
@@ -595,12 +604,12 @@ unwind:
 
 int
 pl_open (call_frame_t *frame, xlator_t *this, loc_t *loc, int32_t flags,
-         fd_t *fd, int32_t wbflags)
+         fd_t *fd, dict_t *xdata)
 {
         /* why isn't O_TRUNC being handled ? */
         STACK_WIND (frame, pl_open_cbk,
                     FIRST_CHILD(this), FIRST_CHILD(this)->fops->open,
-                    loc, flags & ~O_TRUNC, fd, wbflags);
+                    loc, flags & ~O_TRUNC, fd, xdata);
 
         return 0;
 }
@@ -610,7 +619,7 @@ int
 pl_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)
+               struct iatt *preparent, struct iatt *postparent, dict_t *xdata)
 {
         pl_fdctx_t *fdctx = NULL;
 
@@ -626,7 +635,7 @@ pl_create_cbk (call_frame_t *frame, void *cookie,
 
 unwind:
         STACK_UNWIND_STRICT (create, frame, op_ret, op_errno, fd, inode, buf,
-                             preparent, postparent);
+                             preparent, postparent, xdata);
 
         return 0;
 }
@@ -634,11 +643,12 @@ unwind:
 
 int
 pl_create (call_frame_t *frame, xlator_t *this,
-           loc_t *loc, int32_t flags, mode_t mode, fd_t *fd, dict_t *params)
+           loc_t *loc, int32_t flags, mode_t mode, mode_t umask, fd_t *fd,
+           dict_t *xdata)
 {
         STACK_WIND (frame, pl_create_cbk,
                     FIRST_CHILD (this), FIRST_CHILD (this)->fops->create,
-                    loc, flags, mode, fd, params);
+                    loc, flags, mode, umask, fd, xdata);
         return 0;
 }
 
@@ -647,10 +657,10 @@ int
 pl_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)
+              struct iobref *iobref, dict_t *xdata)
 {
         STACK_UNWIND_STRICT (readv, frame, op_ret, op_errno,
-                             vector, count, stbuf, iobref);
+                             vector, count, stbuf, iobref, xdata);
 
         return 0;
 }
@@ -658,9 +668,10 @@ pl_readv_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
 int
 pl_writev_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
                int32_t op_ret, int32_t op_errno, struct iatt *prebuf,
-               struct iatt *postbuf)
+               struct iatt *postbuf, dict_t *xdata)
 {
-        STACK_UNWIND_STRICT (writev, frame, op_ret, op_errno, prebuf, postbuf);
+        STACK_UNWIND_STRICT (writev, frame, op_ret, op_errno, prebuf, postbuf,
+                             xdata);
 
         return 0;
 }
@@ -718,12 +729,12 @@ __rw_allowable (pl_inode_t *pl_inode, posix_lock_t *region,
 
 
 int
-pl_readv_cont (call_frame_t *frame, xlator_t *this,
-               fd_t *fd, size_t size, off_t offset, uint32_t flags)
+pl_readv_cont (call_frame_t *frame, xlator_t *this, fd_t *fd, size_t size,
+               off_t offset, uint32_t flags, dict_t *xdata)
 {
         STACK_WIND (frame, pl_readv_cbk,
                     FIRST_CHILD (this), FIRST_CHILD (this)->fops->readv,
-                    fd, size, offset, flags);
+                    fd, size, offset, flags, xdata);
 
         return 0;
 }
@@ -731,7 +742,7 @@ pl_readv_cont (call_frame_t *frame, xlator_t *this,
 
 int
 pl_readv (call_frame_t *frame, xlator_t *this,
-          fd_t *fd, size_t size, off_t offset, uint32_t flags)
+          fd_t *fd, size_t size, off_t offset, uint32_t flags, dict_t *xdata)
 {
         posix_locks_private_t *priv = NULL;
         pl_inode_t            *pl_inode = NULL;
@@ -778,7 +789,8 @@ pl_readv (call_frame_t *frame, xlator_t *this,
                         }
 
                         rw->stub = fop_readv_stub (frame, pl_readv_cont,
-                                                   fd, size, offset, flags);
+                                                   fd, size, offset, flags,
+                                                   xdata);
                         if (!rw->stub) {
                                 op_errno = ENOMEM;
                                 op_ret = -1;
@@ -798,12 +810,12 @@ pl_readv (call_frame_t *frame, xlator_t *this,
         if (wind_needed) {
                 STACK_WIND (frame, pl_readv_cbk,
                             FIRST_CHILD (this), FIRST_CHILD (this)->fops->readv,
-                            fd, size, offset, flags);
+                            fd, size, offset, flags, xdata);
         }
 
         if (op_ret == -1)
                 STACK_UNWIND_STRICT (readv, frame, -1, op_errno,
-                                     NULL, 0, NULL, NULL);
+                                     NULL, 0, NULL, NULL, NULL);
 
         return 0;
 }
@@ -812,11 +824,11 @@ pl_readv (call_frame_t *frame, xlator_t *this,
 int
 pl_writev_cont (call_frame_t *frame, xlator_t *this, fd_t *fd,
                 struct iovec *vector, int count, off_t offset,
-                uint32_t flags, struct iobref *iobref)
+                uint32_t flags, struct iobref *iobref, dict_t *xdata)
 {
         STACK_WIND (frame, pl_writev_cbk,
                     FIRST_CHILD (this), FIRST_CHILD (this)->fops->writev,
-                    fd, vector, count, offset, flags, iobref);
+                    fd, vector, count, offset, flags, iobref, xdata);
 
         return 0;
 }
@@ -825,7 +837,7 @@ pl_writev_cont (call_frame_t *frame, xlator_t *this, fd_t *fd,
 int
 pl_writev (call_frame_t *frame, xlator_t *this, fd_t *fd,
            struct iovec *vector, int32_t count, off_t offset,
-           uint32_t flags, struct iobref *iobref)
+           uint32_t flags, struct iobref *iobref, dict_t *xdata)
 {
         posix_locks_private_t *priv = NULL;
         pl_inode_t            *pl_inode = NULL;
@@ -872,7 +884,7 @@ pl_writev (call_frame_t *frame, xlator_t *this, fd_t *fd,
 
                         rw->stub = fop_writev_stub (frame, pl_writev_cont,
                                                     fd, vector, count, offset,
-                                                    flags, iobref);
+                                                    flags, iobref, xdata);
                         if (!rw->stub) {
                                 op_errno = ENOMEM;
                                 op_ret = -1;
@@ -892,10 +904,11 @@ pl_writev (call_frame_t *frame, xlator_t *this, fd_t *fd,
         if (wind_needed)
                 STACK_WIND (frame, pl_writev_cbk,
                             FIRST_CHILD (this), FIRST_CHILD (this)->fops->writev,
-                            fd, vector, count, offset, flags, iobref);
+                            fd, vector, count, offset, flags, iobref, xdata);
 
         if (op_ret == -1)
-                STACK_UNWIND_STRICT (writev, frame, -1, op_errno, NULL, NULL);
+                STACK_UNWIND_STRICT (writev, frame, -1, op_errno, NULL, NULL,
+                                     NULL);
 
         return 0;
 }
@@ -1079,7 +1092,7 @@ unlock:
 
 int
 pl_lk (call_frame_t *frame, xlator_t *this,
-       fd_t *fd, int32_t cmd, struct gf_flock *flock)
+       fd_t *fd, int32_t cmd, struct gf_flock *flock, dict_t *xdata)
 {
         void         *transport  = NULL;
         pid_t         client_pid = 0;
@@ -1237,7 +1250,7 @@ unwind:
         else
                 flock->l_type = F_UNLCK;
 
-        STACK_UNWIND_STRICT (lk, frame, op_ret, op_errno, flock);
+        STACK_UNWIND_STRICT (lk, frame, op_ret, op_errno, flock, xdata);
 out:
         return 0;
 }
@@ -1348,19 +1361,20 @@ pl_forget (xlator_t *this,
 
         list_for_each_entry_safe (ext_l, ext_tmp, &posixlks_released, list) {
 
-                STACK_UNWIND_STRICT (lk, ext_l->frame, -1, 0, &ext_l->user_flock);
+                STACK_UNWIND_STRICT (lk, ext_l->frame, -1, 0,
+                                     &ext_l->user_flock, NULL);
                 __destroy_lock (ext_l);
         }
 
         list_for_each_entry_safe (ino_l, ino_tmp, &inodelks_released, blocked_locks) {
 
-                STACK_UNWIND_STRICT (inodelk, ino_l->frame, -1, 0);
+                STACK_UNWIND_STRICT (inodelk, ino_l->frame, -1, 0, NULL);
                 __pl_inodelk_unref (ino_l);
         }
 
         list_for_each_entry_safe (entry_l, entry_tmp, &entrylks_released, blocked_locks) {
 
-                STACK_UNWIND_STRICT (entrylk, entry_l->frame, -1, 0);
+                STACK_UNWIND_STRICT (entrylk, entry_l->frame, -1, 0, NULL);
                 if (entry_l->basename)
                         GF_FREE ((char *)entry_l->basename);
                 GF_FREE (entry_l);
@@ -1543,7 +1557,7 @@ pl_lookup_cbk (call_frame_t *frame,
                     int32_t op_errno,
                     inode_t *inode,
                     struct iatt *buf,
-                    dict_t *dict,
+                    dict_t *xdata,
                     struct iatt *postparent)
 {
         pl_local_t *local = NULL;
@@ -1557,11 +1571,11 @@ pl_lookup_cbk (call_frame_t *frame,
         local = frame->local;
 
         if (local->entrylk_count_req)
-                pl_entrylk_xattr_fill (this, inode, dict);
+                pl_entrylk_xattr_fill (this, inode, xdata);
         if (local->inodelk_count_req)
-                pl_inodelk_xattr_fill (this, inode, dict);
+                pl_inodelk_xattr_fill (this, inode, xdata);
         if (local->posixlk_count_req)
-                pl_posixlk_xattr_fill (this, inode, dict);
+                pl_posixlk_xattr_fill (this, inode, xdata);
 
 
         frame->local = NULL;
@@ -1573,20 +1587,20 @@ out:
         STACK_UNWIND_STRICT (
                      lookup,
                      frame,
-                      op_ret,
-                      op_errno,
-                      inode,
-                      buf,
-                      dict,
-                      postparent);
+                     op_ret,
+                     op_errno,
+                     inode,
+                     buf,
+                     xdata,
+                     postparent);
         return 0;
 }
 
 int32_t
 pl_lookup (call_frame_t *frame,
-                xlator_t *this,
-                loc_t *loc,
-                dict_t *xattr_req)
+           xlator_t *this,
+           loc_t *loc,
+           dict_t *xdata)
 {
         pl_local_t *local  = NULL;
         int         ret    = -1;
@@ -1598,12 +1612,12 @@ pl_lookup (call_frame_t *frame,
         local = mem_get0 (this->local_pool);
         GF_VALIDATE_OR_GOTO (this->name, local, out);
 
-        if (xattr_req) {
-                if (dict_get (xattr_req, GLUSTERFS_ENTRYLK_COUNT))
+        if (xdata) {
+                if (dict_get (xdata, GLUSTERFS_ENTRYLK_COUNT))
                         local->entrylk_count_req = 1;
-                if (dict_get (xattr_req, GLUSTERFS_INODELK_COUNT))
+                if (dict_get (xdata, GLUSTERFS_INODELK_COUNT))
                         local->inodelk_count_req = 1;
-                if (dict_get (xattr_req, GLUSTERFS_POSIXLK_COUNT))
+                if (dict_get (xdata, GLUSTERFS_POSIXLK_COUNT))
                         local->posixlk_count_req = 1;
         }
 
@@ -1613,18 +1627,18 @@ pl_lookup (call_frame_t *frame,
                     pl_lookup_cbk,
                     FIRST_CHILD(this),
                     FIRST_CHILD(this)->fops->lookup,
-                    loc,
-                    xattr_req);
+                    loc, xdata);
         ret = 0;
 out:
         if (ret == -1)
-                STACK_UNWIND_STRICT (lookup, frame, -1, 0, NULL, NULL, NULL, NULL);
+                STACK_UNWIND_STRICT (lookup, frame, -1, 0, NULL,
+                                     NULL, NULL, NULL);
 
         return 0;
 }
 int
 pl_readdirp_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                 int op_ret, int op_errno, gf_dirent_t *entries)
+                 int op_ret, int op_errno, gf_dirent_t *entries, dict_t *xdata)
 {
         pl_local_t *local  = NULL;
         gf_dirent_t *entry = NULL;
@@ -1645,7 +1659,7 @@ pl_readdirp_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
 
 unwind:
         frame->local = NULL;
-        STACK_UNWIND_STRICT (readdirp, frame, op_ret, op_errno, entries);
+        STACK_UNWIND_STRICT (readdirp, frame, op_ret, op_errno, entries, xdata);
 
         if (local)
                 mem_put (local);
@@ -1679,7 +1693,7 @@ pl_readdirp (call_frame_t *frame, xlator_t *this, fd_t *fd, size_t size,
 
         return 0;
 out:
-        STACK_UNWIND_STRICT (readdirp, frame, -1, ENOMEM, NULL);
+        STACK_UNWIND_STRICT (readdirp, frame, -1, ENOMEM, NULL, NULL);
         return 0;
 }
 
@@ -2089,21 +2103,23 @@ fini (xlator_t *this)
 
 int
 pl_inodelk (call_frame_t *frame, xlator_t *this,
-            const char *volume, loc_t *loc, int32_t cmd, struct gf_flock *flock);
+            const char *volume, loc_t *loc, int32_t cmd, struct gf_flock *flock,
+            dict_t *xdata);
 
 int
 pl_finodelk (call_frame_t *frame, xlator_t *this,
-             const char *volume, fd_t *fd, int32_t cmd, struct gf_flock *flock);
+             const char *volume, fd_t *fd, int32_t cmd, struct gf_flock *flock,
+             dict_t *xdata);
 
 int
 pl_entrylk (call_frame_t *frame, xlator_t *this,
             const char *volume, loc_t *loc, const char *basename,
-            entrylk_cmd cmd, entrylk_type type);
+            entrylk_cmd cmd, entrylk_type type, dict_t *xdata);
 
 int
 pl_fentrylk (call_frame_t *frame, xlator_t *this,
              const char *volume, fd_t *fd, const char *basename,
-             entrylk_cmd cmd, entrylk_type type);
+             entrylk_cmd cmd, entrylk_type type, dict_t *xdata);
 
 struct xlator_fops fops = {
         .lookup      = pl_lookup,
diff --git a/xlators/features/locks/src/reservelk.c b/xlators/features/locks/src/reservelk.c
index 7a75cdea10d..11b724bc562 100644
--- a/xlators/features/locks/src/reservelk.c
+++ b/xlators/features/locks/src/reservelk.c
@@ -299,7 +299,8 @@ grant_blocked_reserve_locks (xlator_t *this, pl_inode_t *pl_inode)
                         lock->user_flock.l_start,
                         lock->user_flock.l_len);
 
-                STACK_UNWIND_STRICT (lk, lock->frame, 0, 0, &lock->user_flock);
+                STACK_UNWIND_STRICT (lk, lock->frame, 0, 0, &lock->user_flock,
+                                     NULL);
         }
 
 }
@@ -376,7 +377,9 @@ grant_blocked_lock_calls (xlator_t *this, pl_inode_t *pl_inode)
                                 pl_trace_out (this, lock->frame, fd, NULL, cmd,
                                               &lock->user_flock, -1, EAGAIN, NULL);
                                 pl_update_refkeeper (this, fd->inode);
-                                STACK_UNWIND_STRICT (lk, lock->frame, -1, EAGAIN, &lock->user_flock);
+                                STACK_UNWIND_STRICT (lk, lock->frame, -1,
+                                                     EAGAIN, &lock->user_flock,
+                                                     NULL);
                                 __destroy_lock (lock);
                         }
                 }
diff --git a/xlators/features/mac-compat/src/mac-compat.c b/xlators/features/mac-compat/src/mac-compat.c
index 188b593e4e6..cce621e6723 100644
--- a/xlators/features/mac-compat/src/mac-compat.c
+++ b/xlators/features/mac-compat/src/mac-compat.c
@@ -57,7 +57,8 @@ static int32_t apple_xattr_len[] = {
 
 int32_t
 maccomp_getxattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                      int32_t op_ret, int32_t op_errno, dict_t *dict)
+                      int32_t op_ret, int32_t op_errno, dict_t *dict,
+                      dict_t *xdata)
 {
         intptr_t ax = (intptr_t)this->private;
         int i = 0;
@@ -80,7 +81,7 @@ maccomp_getxattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
                 }
          }
 
-        STACK_UNWIND_STRICT (getxattr, frame, op_ret, op_errno, dict);
+        STACK_UNWIND_STRICT (getxattr, frame, op_ret, op_errno, dict, xdata);
 
         return 0;
 }
@@ -88,7 +89,7 @@ maccomp_getxattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
 
 int32_t
 maccomp_getxattr (call_frame_t *frame, xlator_t *this, loc_t *loc,
-                  const char *name)
+                  const char *name, dict_t *xdata)
 {
         intptr_t ax = GF_XATTR_NONE;
         int i = 0;
@@ -109,14 +110,14 @@ maccomp_getxattr (call_frame_t *frame, xlator_t *this, loc_t *loc,
         STACK_WIND (frame, maccomp_getxattr_cbk,
                     FIRST_CHILD(this),
                     FIRST_CHILD(this)->fops->getxattr,
-                    loc, name);
+                    loc, name, xdata);
         return 0;
 }
 
 
 int32_t
 maccomp_fgetxattr (call_frame_t *frame, xlator_t *this, fd_t *fd,
-                   const char *name)
+                   const char *name, dict_t *xdata)
 {
         intptr_t ax = GF_XATTR_NONE;
         int i = 0;
@@ -137,21 +138,21 @@ maccomp_fgetxattr (call_frame_t *frame, xlator_t *this, fd_t *fd,
         STACK_WIND (frame, maccomp_getxattr_cbk,
                     FIRST_CHILD(this),
                     FIRST_CHILD(this)->fops->fgetxattr,
-                    fd, name);
+                    fd, name, xdata);
         return 0;
 }
 
 
 int32_t
 maccomp_setxattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                      int32_t op_ret, int32_t op_errno)
+                      int32_t op_ret, int32_t op_errno, dict_t *xdata)
 {
         intptr_t ax = (intptr_t)this->private;
 
         if (op_ret == -1 && ax != GF_XATTR_NONE)
                 op_ret = op_errno = 0;
 
-        STACK_UNWIND_STRICT (setxattr, frame, op_ret, op_errno);
+        STACK_UNWIND_STRICT (setxattr, frame, op_ret, op_errno, xdata);
 
         return 0;
 }
@@ -159,7 +160,7 @@ maccomp_setxattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
 
 int32_t
 maccomp_setxattr (call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *dict,
-                  int32_t flags)
+                  int32_t flags, dict_t *xdata)
 {
         intptr_t ax = GF_XATTR_NONE;
         int i = 0;
@@ -177,14 +178,14 @@ maccomp_setxattr (call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *dict,
         STACK_WIND (frame, maccomp_setxattr_cbk,
                     FIRST_CHILD(this),
                     FIRST_CHILD(this)->fops->setxattr,
-                    loc, dict, flags);
+                    loc, dict, flags, xdata);
         return 0;
 }
 
 
 int32_t
 maccomp_fsetxattr (call_frame_t *frame, xlator_t *this, fd_t *fd, dict_t *dict,
-                   int32_t flags)
+                   int32_t flags, dict_t *xdata)
 {
         intptr_t ax = GF_XATTR_NONE;
         int i = 0;
@@ -202,7 +203,7 @@ maccomp_fsetxattr (call_frame_t *frame, xlator_t *this, fd_t *fd, dict_t *dict,
         STACK_WIND (frame, maccomp_setxattr_cbk,
                     FIRST_CHILD(this),
                     FIRST_CHILD(this)->fops->fsetxattr,
-                    fd, dict, flags);
+                    fd, dict, flags, xdata);
         return 0;
 }
 
diff --git a/xlators/features/marker/src/marker-quota.c b/xlators/features/marker/src/marker-quota.c
index 43e4ec724a9..c8bb9e4909f 100644
--- a/xlators/features/marker/src/marker-quota.c
+++ b/xlators/features/marker/src/marker-quota.c
@@ -208,7 +208,7 @@ out:
 
 int32_t
 mq_dirty_inode_updation_done (call_frame_t *frame, void *cookie, xlator_t *this,
-                              int32_t op_ret, int32_t op_errno)
+                              int32_t op_ret, int32_t op_errno, dict_t *xdata)
 {
         QUOTA_STACK_DESTROY (frame, this);
 
@@ -217,7 +217,7 @@ mq_dirty_inode_updation_done (call_frame_t *frame, void *cookie, xlator_t *this,
 
 int32_t
 mq_release_lock_on_dirty_inode (call_frame_t *frame, void *cookie, xlator_t *this,
-                                int32_t op_ret, int32_t op_errno)
+                                int32_t op_ret, int32_t op_errno, dict_t *xdata)
 {
         struct gf_flock   lock  = {0, };
         quota_local_t    *local = NULL;
@@ -229,7 +229,7 @@ mq_release_lock_on_dirty_inode (call_frame_t *frame, void *cookie, xlator_t *thi
         if (op_ret == -1) {
                 local->err = -1;
 
-                mq_dirty_inode_updation_done (frame, NULL, this, 0, 0);
+                mq_dirty_inode_updation_done (frame, NULL, this, 0, 0, NULL);
 
                 return 0;
         }
@@ -247,7 +247,7 @@ mq_release_lock_on_dirty_inode (call_frame_t *frame, void *cookie, xlator_t *thi
 	if (ret == -1) {
                 local->err = -1;
                 frame->local = NULL;
-                mq_dirty_inode_updation_done (frame, NULL, this, 0, 0);
+                mq_dirty_inode_updation_done (frame, NULL, this, 0, 0, NULL);
                 return 0;
         }
 
@@ -261,20 +261,21 @@ mq_release_lock_on_dirty_inode (call_frame_t *frame, void *cookie, xlator_t *thi
                     mq_dirty_inode_updation_done,
                     FIRST_CHILD(this),
                     FIRST_CHILD(this)->fops->inodelk,
-                    this->name, &loc, F_SETLKW, &lock);
+                    this->name, &loc, F_SETLKW, &lock, NULL);
 
         loc_wipe (&loc);
 
         return 0;
 out:
-        mq_dirty_inode_updation_done (frame, NULL, this, -1, 0);
+        mq_dirty_inode_updation_done (frame, NULL, this, -1, 0, NULL);
 
         return 0;
 }
 
 int32_t
 mq_mark_inode_undirty (call_frame_t *frame, void *cookie, xlator_t *this,
-                       int32_t op_ret, int32_t op_errno, dict_t *dict)
+                       int32_t op_ret, int32_t op_errno, dict_t *dict,
+                       dict_t *xdata)
 {
         int32_t        ret     = -1;
         int64_t       *size    = NULL;
@@ -315,14 +316,14 @@ wind:
         STACK_WIND (frame, mq_release_lock_on_dirty_inode,
                     FIRST_CHILD(this),
                     FIRST_CHILD(this)->fops->setxattr,
-                    &local->loc, newdict, 0);
+                    &local->loc, newdict, 0, NULL);
         ret = 0;
 
 err:
         if (op_ret == -1 || ret == -1) {
                 local->err = -1;
 
-                mq_release_lock_on_dirty_inode (frame, NULL, this, 0, 0);
+                mq_release_lock_on_dirty_inode (frame, NULL, this, 0, 0, NULL);
         }
 
         if (newdict)
@@ -385,7 +386,7 @@ mq_update_size_xattr (call_frame_t *frame, void *cookie, xlator_t *this,
 
         STACK_WIND (frame, mq_mark_inode_undirty, FIRST_CHILD(this),
                     FIRST_CHILD(this)->fops->xattrop, &local->loc,
-                    GF_XATTROP_ADD_ARRAY64, new_dict);
+                    GF_XATTROP_ADD_ARRAY64, new_dict, NULL);
 
         ret = 0;
 
@@ -393,7 +394,7 @@ err:
         if (op_ret == -1 || ret == -1) {
                 local->err = -1;
 
-                mq_release_lock_on_dirty_inode (frame, NULL, this, 0, 0);
+                mq_release_lock_on_dirty_inode (frame, NULL, this, 0, 0, NULL);
         }
 
         if (new_dict)
@@ -457,7 +458,7 @@ err:
         if (ret) {
                 local->err = -1;
 
-                mq_release_lock_on_dirty_inode (frame, NULL, this, 0, 0);
+                mq_release_lock_on_dirty_inode (frame, NULL, this, 0, 0, NULL);
         }
 
         if (dict)
@@ -495,7 +496,8 @@ mq_get_child_contribution (call_frame_t *frame,
                 val = -2;
                 if (!mq_test_and_set_local_err (local, &val) &&
                     val != -2)
-                        mq_release_lock_on_dirty_inode (local->frame, NULL, this, 0, 0);
+                        mq_release_lock_on_dirty_inode (local->frame, NULL,
+                                                        this, 0, 0, NULL);
 
                 goto exit;
         }
@@ -523,7 +525,7 @@ out:
 
         if (val == 0) {
                 mq_dirty_inode_readdir (local->frame, NULL, this,
-                                                   0, 0, NULL);
+                                        0, 0, NULL, NULL);
         }
         mq_local_unref (this, local);
 
@@ -539,7 +541,7 @@ mq_readdir_cbk (call_frame_t *frame,
                 xlator_t *this,
                 int32_t op_ret,
                 int32_t op_errno,
-                gf_dirent_t *entries)
+                gf_dirent_t *entries, dict_t *xdata)
 {
         char           contri_key [512]   = {0, };
         int32_t        ret                = 0;
@@ -559,7 +561,7 @@ mq_readdir_cbk (call_frame_t *frame,
                         "readdir failed %s", strerror (op_errno));
                 local->err = -1;
 
-                mq_release_lock_on_dirty_inode (frame, NULL, this, 0, 0);
+                mq_release_lock_on_dirty_inode (frame, NULL, this, 0, 0, NULL);
 
                 goto end;
         } else if (op_ret == 0) {
@@ -681,7 +683,7 @@ mq_readdir_cbk (call_frame_t *frame,
         }
 
         if (ret && val != -2) {
-                mq_release_lock_on_dirty_inode (frame, NULL, this, 0, 0);
+                mq_release_lock_on_dirty_inode (frame, NULL, this, 0, 0, NULL);
         }
 end:
         mq_local_unref (this, local);
@@ -695,7 +697,7 @@ mq_dirty_inode_readdir (call_frame_t *frame,
                         xlator_t *this,
                         int32_t op_ret,
                         int32_t op_errno,
-                        fd_t *fd)
+                        fd_t *fd, dict_t *xdata)
 {
         quota_local_t *local = NULL;
 
@@ -703,7 +705,7 @@ mq_dirty_inode_readdir (call_frame_t *frame,
 
         if (op_ret == -1) {
                 local->err = -1;
-                mq_release_lock_on_dirty_inode (frame, NULL, this, 0, 0);
+                mq_release_lock_on_dirty_inode (frame, NULL, this, 0, 0, NULL);
                 return 0;
         }
 
@@ -714,7 +716,7 @@ mq_dirty_inode_readdir (call_frame_t *frame,
                     mq_readdir_cbk,
                     FIRST_CHILD(this),
                     FIRST_CHILD(this)->fops->readdir,
-                    local->fd, READDIR_BUF, local->d_off);
+                    local->fd, READDIR_BUF, local->d_off, xdata);
 
         return 0;
 }
@@ -754,7 +756,7 @@ mq_check_if_still_dirty (call_frame_t *frame,
 
         //the inode is not dirty anymore
         if (dirty == 0) {
-                mq_release_lock_on_dirty_inode (frame, NULL, this, 0, 0);
+                mq_release_lock_on_dirty_inode (frame, NULL, this, 0, 0, NULL);
 
                 return 0;
         }
@@ -771,14 +773,14 @@ mq_check_if_still_dirty (call_frame_t *frame,
                    mq_dirty_inode_readdir,
                    FIRST_CHILD(this),
                    FIRST_CHILD(this)->fops->opendir,
-                   &local->loc, fd);
+                   &local->loc, fd, NULL);
 
         ret = 0;
 
 err:
         if (op_ret == -1 || ret == -1) {
                 local->err = -1;
-                mq_release_lock_on_dirty_inode (frame, NULL, this, 0, 0);
+                mq_release_lock_on_dirty_inode (frame, NULL, this, 0, 0, NULL);
         }
 
         if (fd != NULL) {
@@ -789,15 +791,15 @@ err:
 }
 
 int32_t
-mq_get_dirty_xattr (call_frame_t *frame, void *cookie,
-                    xlator_t *this, int32_t op_ret, int32_t op_errno)
+mq_get_dirty_xattr (call_frame_t *frame, void *cookie, xlator_t *this,
+                    int32_t op_ret, int32_t op_errno, dict_t *xdata)
 {
         int32_t        ret       = -1;
         dict_t        *xattr_req = NULL;
         quota_local_t *local     = NULL;
 
         if (op_ret == -1) {
-                mq_dirty_inode_updation_done (frame, NULL, this, 0, 0);
+                mq_dirty_inode_updation_done (frame, NULL, this, 0, 0, NULL);
                 return 0;
         }
 
@@ -829,7 +831,7 @@ mq_get_dirty_xattr (call_frame_t *frame, void *cookie,
 err:
         if (ret) {
                 local->err = -1;
-                mq_release_lock_on_dirty_inode(frame, NULL, this, 0, 0);
+                mq_release_lock_on_dirty_inode(frame, NULL, this, 0, 0, NULL);
         }
 
         if (xattr_req)
@@ -896,7 +898,7 @@ mq_update_dirty_inode (xlator_t *this,
                     mq_get_dirty_xattr,
                     FIRST_CHILD(this),
                     FIRST_CHILD(this)->fops->inodelk,
-                    this->name, &local->loc, F_SETLKW, &lock);
+                    this->name, &local->loc, F_SETLKW, &lock, NULL);
         return 1;
 
 fr_destroy:
@@ -909,7 +911,7 @@ out:
 
 int32_t
 mq_inode_creation_done (call_frame_t *frame, void *cookie, xlator_t *this,
-                        int32_t op_ret, int32_t op_errno)
+                        int32_t op_ret, int32_t op_errno, dict_t *xdata)
 {
         quota_local_t *local = NULL;
 
@@ -931,7 +933,7 @@ mq_inode_creation_done (call_frame_t *frame, void *cookie, xlator_t *this,
 int32_t
 mq_xattr_creation_release_lock (call_frame_t *frame, void *cookie,
                                 xlator_t *this, int32_t op_ret,
-                                int32_t op_errno)
+                                int32_t op_errno, dict_t *xdata)
 {
         struct gf_flock  lock  = {0, };
         quota_local_t   *local = NULL;
@@ -949,7 +951,7 @@ mq_xattr_creation_release_lock (call_frame_t *frame, void *cookie,
                     FIRST_CHILD(this),
                     FIRST_CHILD(this)->fops->inodelk,
                     this->name, &local->loc,
-                    F_SETLKW, &lock);
+                    F_SETLKW, &lock, NULL);
 
         return 0;
 }
@@ -957,7 +959,8 @@ mq_xattr_creation_release_lock (call_frame_t *frame, void *cookie,
 
 int32_t
 mq_create_dirty_xattr (call_frame_t *frame, void *cookie, xlator_t *this,
-                       int32_t op_ret, int32_t op_errno, dict_t *dict)
+                       int32_t op_ret, int32_t op_errno, dict_t *dict,
+                       dict_t *xdata)
 {
         int32_t          ret       = -1;
         dict_t          *newdict   = NULL;
@@ -986,16 +989,16 @@ mq_create_dirty_xattr (call_frame_t *frame, void *cookie, xlator_t *this,
                 STACK_WIND (frame, mq_xattr_creation_release_lock,
                             FIRST_CHILD(this),
                             FIRST_CHILD(this)->fops->setxattr,
-                            &local->loc, newdict, 0);
+                            &local->loc, newdict, 0, NULL);
         } else {
-                mq_xattr_creation_release_lock (frame, NULL, this, 0, 0);
+                mq_xattr_creation_release_lock (frame, NULL, this, 0, 0, NULL);
         }
 
         ret = 0;
 
 err:
         if (ret < 0) {
-                mq_xattr_creation_release_lock (frame, NULL, this, 0, 0);
+                mq_xattr_creation_release_lock (frame, NULL, this, 0, 0, NULL);
         }
 
         if (newdict != NULL)
@@ -1061,7 +1064,7 @@ mq_create_xattr (xlator_t *this, call_frame_t *frame)
 
         STACK_WIND (frame, mq_create_dirty_xattr, FIRST_CHILD(this),
                     FIRST_CHILD(this)->fops->xattrop, &local->loc,
-                    GF_XATTROP_ADD_ARRAY64, dict);
+                    GF_XATTROP_ADD_ARRAY64, dict, NULL);
         ret = 0;
 
 free_size:
@@ -1079,7 +1082,7 @@ err:
 
 out:
         if (ret < 0) {
-                mq_xattr_creation_release_lock (frame, NULL, this, 0, 0);
+                mq_xattr_creation_release_lock (frame, NULL, this, 0, 0, NULL);
         }
 
         return 0;
@@ -1124,7 +1127,7 @@ mq_check_n_set_inode_xattr (call_frame_t *frame, void *cookie,
         }
 
 out:
-        mq_xattr_creation_release_lock (frame, NULL, this, 0, 0);
+        mq_xattr_creation_release_lock (frame, NULL, this, 0, 0, NULL);
         return 0;
 
 create_xattr:
@@ -1139,7 +1142,7 @@ create_xattr:
 
 int32_t
 mq_get_xattr (call_frame_t *frame, void *cookie, xlator_t *this,
-              int32_t op_ret, int32_t op_errno)
+              int32_t op_ret, int32_t op_errno, dict_t *xdata)
 {
         dict_t        *xattr_req = NULL;
         quota_local_t *local     = NULL;
@@ -1175,14 +1178,14 @@ mq_get_xattr (call_frame_t *frame, void *cookie, xlator_t *this,
         return 0;
 
 err:
-        mq_xattr_creation_release_lock (frame, NULL, this, 0, 0);
+        mq_xattr_creation_release_lock (frame, NULL, this, 0, 0, NULL);
 
         if (xattr_req)
                 dict_unref (xattr_req);
         return 0;
 
 lock_err:
-        mq_inode_creation_done (frame, NULL, this, 0, 0);
+        mq_inode_creation_done (frame, NULL, this, 0, 0, NULL);
         return 0;
 }
 
@@ -1224,7 +1227,7 @@ mq_set_inode_xattr (xlator_t *this, loc_t *loc)
                     mq_get_xattr,
                     FIRST_CHILD(this),
                     FIRST_CHILD(this)->fops->inodelk,
-                    this->name, &local->loc, F_SETLKW, &lock);
+                    this->name, &local->loc, F_SETLKW, &lock, NULL);
 
         return 0;
 
@@ -1297,7 +1300,7 @@ mq_xattr_updation_done (call_frame_t *frame,
                         xlator_t *this,
                         int32_t op_ret,
                         int32_t op_errno,
-                        dict_t *dict)
+                        dict_t *dict, dict_t *xdata)
 {
         QUOTA_STACK_DESTROY (frame, this);
         return 0;
@@ -1306,7 +1309,7 @@ mq_xattr_updation_done (call_frame_t *frame,
 
 int32_t
 mq_inodelk_cbk (call_frame_t *frame, void *cookie,
-                xlator_t *this, int32_t op_ret, int32_t op_errno)
+                xlator_t *this, int32_t op_ret, int32_t op_errno, dict_t *xdata)
 {
         int32_t         ret    = 0;
         gf_boolean_t    status = _gf_false;
@@ -1320,7 +1323,7 @@ mq_inodelk_cbk (call_frame_t *frame, void *cookie,
                                 "unlocking failed on path (%s)(%s)",
                                 local->parent_loc.path, strerror (op_errno));
                 }
-                mq_xattr_updation_done (frame, NULL, this, 0, 0, NULL);
+                mq_xattr_updation_done (frame, NULL, this, 0, 0, NULL, NULL);
 
                 return 0;
         }
@@ -1330,11 +1333,12 @@ mq_inodelk_cbk (call_frame_t *frame, void *cookie,
 
         if ((strcmp (local->parent_loc.path, "/") == 0)
             || (local->delta == 0)) {
-                mq_xattr_updation_done (frame, NULL, this, 0, 0, NULL);
+                mq_xattr_updation_done (frame, NULL, this, 0, 0, NULL, NULL);
         } else {
                 ret = mq_get_parent_inode_local (this, local);
                 if (ret < 0) {
-                        mq_xattr_updation_done (frame, NULL, this, 0, 0, NULL);
+                        mq_xattr_updation_done (frame, NULL, this, 0, 0, NULL,
+                                                NULL);
                         goto out;
                 }
                 status = _gf_true;
@@ -1343,7 +1347,8 @@ mq_inodelk_cbk (call_frame_t *frame, void *cookie,
                 if (ret == 0 && status == _gf_false) {
                         mq_get_lock_on_parent (frame, this);
                 } else {
-                        mq_xattr_updation_done (frame, NULL, this, 0, 0, NULL);
+                        mq_xattr_updation_done (frame, NULL, this, 0, 0, NULL,
+                                                NULL);
                 }
         }
 out:
@@ -1355,7 +1360,7 @@ out:
 int32_t
 mq_release_parent_lock (call_frame_t *frame, void *cookie,
                         xlator_t *this, int32_t op_ret,
-                        int32_t op_errno)
+                        int32_t op_errno, dict_t *xdata)
 {
         int32_t            ret      = 0;
         quota_local_t     *local    = NULL;
@@ -1401,12 +1406,12 @@ wind:
                     FIRST_CHILD(this),
                     FIRST_CHILD(this)->fops->inodelk,
                     this->name, &local->parent_loc,
-                    F_SETLKW, &lock);
+                    F_SETLKW, &lock, NULL);
 
         return 0;
 err:
         mq_xattr_updation_done (frame, NULL, this,
-                             0, 0 , NULL);
+                                0, 0 , NULL, NULL);
         return 0;
 }
 
@@ -1417,7 +1422,7 @@ mq_mark_undirty (call_frame_t *frame,
                  xlator_t *this,
                  int32_t op_ret,
                  int32_t op_errno,
-                 dict_t *dict)
+                 dict_t *dict, dict_t *xdata)
 {
         int32_t            ret          = -1;
         int64_t           *size         = NULL;
@@ -1478,14 +1483,14 @@ mq_mark_undirty (call_frame_t *frame,
         STACK_WIND (frame, mq_release_parent_lock,
                     FIRST_CHILD(this),
                     FIRST_CHILD(this)->fops->setxattr,
-                    &local->parent_loc, newdict, 0);
+                    &local->parent_loc, newdict, 0, NULL);
 
         ret = 0;
 err:
         if (op_ret == -1 || ret == -1) {
                 local->err = op_errno;
 
-                mq_release_parent_lock (frame, NULL, this, 0, 0);
+                mq_release_parent_lock (frame, NULL, this, 0, 0, NULL);
         }
 
         if (newdict)
@@ -1501,7 +1506,7 @@ mq_update_parent_size (call_frame_t *frame,
                        xlator_t *this,
                        int32_t op_ret,
                        int32_t op_errno,
-                       dict_t *dict)
+                       dict_t *dict, dict_t *xdata)
 {
         int64_t             *size       = NULL;
         int32_t              ret        = -1;
@@ -1568,12 +1573,12 @@ mq_update_parent_size (call_frame_t *frame,
                     FIRST_CHILD(this)->fops->xattrop,
                     &local->parent_loc,
                     GF_XATTROP_ADD_ARRAY64,
-                    newdict);
+                    newdict, NULL);
         ret = 0;
 err:
         if (op_ret == -1 || ret < 0) {
                 local->err = op_errno;
-                mq_release_parent_lock (frame, NULL, this, 0, 0);
+                mq_release_parent_lock (frame, NULL, this, 0, 0, NULL);
         }
 
         if (newdict)
@@ -1661,7 +1666,7 @@ unlock:
         local->delta = size_int - contri_int;
 
         if (local->delta == 0) {
-                mq_mark_undirty (frame, NULL, this, 0, 0, NULL);
+                mq_mark_undirty (frame, NULL, this, 0, 0, NULL, NULL);
                 return 0;
         }
 
@@ -1694,14 +1699,14 @@ unlock:
                     FIRST_CHILD(this)->fops->xattrop,
                     &local->loc,
                     GF_XATTROP_ADD_ARRAY64,
-                    newdict);
+                    newdict, NULL);
         ret = 0;
 
 err:
         if (op_ret == -1 || ret < 0) {
                 local->err = op_errno;
 
-                mq_release_parent_lock (frame, NULL, this, 0, 0);
+                mq_release_parent_lock (frame, NULL, this, 0, 0, NULL);
         }
 
         if (newdict)
@@ -1713,7 +1718,7 @@ err:
 int32_t
 mq_fetch_child_size_and_contri (call_frame_t *frame, void *cookie,
                                 xlator_t *this, int32_t op_ret,
-                                int32_t op_errno)
+                                int32_t op_errno, dict_t *xdata)
 {
         int32_t            ret              = -1;
         char               contri_key [512] = {0, };
@@ -1795,7 +1800,7 @@ err:
 
                 mq_set_ctx_updation_status (local->ctx, _gf_false);
 
-                mq_release_parent_lock (frame, NULL, this, 0, 0);
+                mq_release_parent_lock (frame, NULL, this, 0, 0, NULL);
         }
 
         if (newdict)
@@ -1806,7 +1811,7 @@ err:
 
 int32_t
 mq_markdirty (call_frame_t *frame, void *cookie,
-              xlator_t *this, int32_t op_ret, int32_t op_errno)
+              xlator_t *this, int32_t op_ret, int32_t op_errno, dict_t *xdata)
 {
         int32_t        ret      = -1;
         dict_t        *dict     = NULL;
@@ -1823,7 +1828,7 @@ mq_markdirty (call_frame_t *frame, void *cookie,
 
                 mq_set_ctx_updation_status (local->ctx, _gf_false);
 
-                mq_inodelk_cbk (frame, NULL, this, 0, 0);
+                mq_inodelk_cbk (frame, NULL, this, 0, 0, NULL);
 
                 return 0;
         }
@@ -1848,7 +1853,7 @@ mq_markdirty (call_frame_t *frame, void *cookie,
         STACK_WIND (frame, mq_fetch_child_size_and_contri,
                     FIRST_CHILD(this),
                     FIRST_CHILD(this)->fops->setxattr,
-                    &local->parent_loc, dict, 0);
+                    &local->parent_loc, dict, 0, NULL);
 
         ret = 0;
 err:
@@ -1857,7 +1862,7 @@ err:
 
                 mq_set_ctx_updation_status (local->ctx, _gf_false);
 
-                mq_release_parent_lock (frame, NULL, this, 0, 0);
+                mq_release_parent_lock (frame, NULL, this, 0, 0, NULL);
         }
 
         if (dict)
@@ -1895,7 +1900,7 @@ mq_get_lock_on_parent (call_frame_t *frame, xlator_t *this)
                     mq_markdirty,
                     FIRST_CHILD(this),
                     FIRST_CHILD(this)->fops->inodelk,
-                    this->name, &local->parent_loc, F_SETLKW, &lock);
+                    this->name, &local->parent_loc, F_SETLKW, &lock, NULL);
 
         return 0;
 
@@ -2224,7 +2229,7 @@ out:
 
 int32_t
 mq_removexattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                    int32_t op_ret, int32_t op_errno)
+                    int32_t op_ret, int32_t op_errno, dict_t *xdata)
 {
         QUOTA_STACK_DESTROY (frame, this);
 
@@ -2233,7 +2238,7 @@ mq_removexattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
 
 int32_t
 _mq_inode_remove_done (call_frame_t *frame, void *cookie, xlator_t *this,
-                       int32_t op_ret, int32_t op_errno)
+                       int32_t op_ret, int32_t op_errno, dict_t *xdata)
 {
         int32_t        ret                = 0;
         char           contri_key [512]   = {0, };
@@ -2242,7 +2247,7 @@ _mq_inode_remove_done (call_frame_t *frame, void *cookie, xlator_t *this,
         local = (quota_local_t *) frame->local;
 
         if (op_ret == -1 || local->err == -1) {
-                mq_removexattr_cbk (frame, NULL, this, -1, 0);
+                mq_removexattr_cbk (frame, NULL, this, -1, 0, NULL);
                 return 0;
         }
 
@@ -2253,10 +2258,10 @@ _mq_inode_remove_done (call_frame_t *frame, void *cookie, xlator_t *this,
 
                 STACK_WIND (frame, mq_removexattr_cbk, FIRST_CHILD(this),
                             FIRST_CHILD(this)->fops->removexattr,
-                            &local->loc, contri_key);
+                            &local->loc, contri_key, NULL);
                 ret = 0;
         } else {
-                mq_removexattr_cbk (frame, NULL, this, 0, 0);
+                mq_removexattr_cbk (frame, NULL, this, 0, 0, NULL);
         }
 
         if (strcmp (local->parent_loc.path, "/") != 0) {
@@ -2274,7 +2279,8 @@ out:
 
 int32_t
 mq_inode_remove_done (call_frame_t *frame, void *cookie, xlator_t *this,
-                      int32_t op_ret, int32_t op_errno, dict_t *dict)
+                      int32_t op_ret, int32_t op_errno, dict_t *dict,
+                      dict_t *xdata)
 {
         int32_t            ret   = -1;
         struct gf_flock    lock  = {0, };
@@ -2321,13 +2327,13 @@ mq_inode_remove_done (call_frame_t *frame, void *cookie, xlator_t *this,
                     FIRST_CHILD(this),
                     FIRST_CHILD(this)->fops->inodelk,
                     this->name, &local->parent_loc,
-                    F_SETLKW, &lock);
+                    F_SETLKW, &lock, NULL);
         return 0;
 }
 
 int32_t
-mq_reduce_parent_size_xattr (call_frame_t *frame, void *cookie,
-                             xlator_t *this, int32_t op_ret, int32_t op_errno)
+mq_reduce_parent_size_xattr (call_frame_t *frame, void *cookie, xlator_t *this,
+                             int32_t op_ret, int32_t op_errno, dict_t *xdata)
 {
         int32_t                  ret               = -1;
         int64_t                 *size              = NULL;
@@ -2364,13 +2370,13 @@ mq_reduce_parent_size_xattr (call_frame_t *frame, void *cookie,
 
         STACK_WIND (frame, mq_inode_remove_done, FIRST_CHILD(this),
                     FIRST_CHILD(this)->fops->xattrop, &local->parent_loc,
-                    GF_XATTROP_ADD_ARRAY64, dict);
+                    GF_XATTROP_ADD_ARRAY64, dict, NULL);
         dict_unref (dict);
         return 0;
 
 err:
         local->err = 1;
-        mq_inode_remove_done (frame, NULL, this, -1, 0, NULL);
+        mq_inode_remove_done (frame, NULL, this, -1, 0, NULL, NULL);
         if (dict)
                 dict_unref (dict);
         return 0;
@@ -2455,7 +2461,7 @@ mq_reduce_parent_size (xlator_t *this, loc_t *loc, int64_t contri)
                     mq_reduce_parent_size_xattr,
                     FIRST_CHILD(this),
                     FIRST_CHILD(this)->fops->inodelk,
-                    this->name, &local->parent_loc, F_SETLKW, &lock);
+                    this->name, &local->parent_loc, F_SETLKW, &lock, NULL);
         local = NULL;
         ret = 0;
 
diff --git a/xlators/features/marker/src/marker-quota.h b/xlators/features/marker/src/marker-quota.h
index 30ee4426449..4dd855fd730 100644
--- a/xlators/features/marker/src/marker-quota.h
+++ b/xlators/features/marker/src/marker-quota.h
@@ -123,7 +123,7 @@ mq_initiate_quota_txn (xlator_t *, loc_t *);
 
 int32_t
 mq_dirty_inode_readdir (call_frame_t *, void *, xlator_t *,
-                        int32_t, int32_t, fd_t *);
+                        int32_t, int32_t, fd_t *, dict_t *);
 
 int32_t
 mq_reduce_parent_size (xlator_t *, loc_t *, int64_t);
diff --git a/xlators/features/marker/src/marker.c b/xlators/features/marker/src/marker.c
index fcaafe746c4..4f143f5efdb 100644
--- a/xlators/features/marker/src/marker.c
+++ b/xlators/features/marker/src/marker.c
@@ -226,13 +226,14 @@ stat_stampfile (xlator_t *this, marker_conf_t *priv,
 
 int32_t
 marker_getxattr_stampfile_cbk (call_frame_t *frame, xlator_t *this,
-                               const char *name, struct volume_mark *vol_mark)
+                               const char *name, struct volume_mark *vol_mark,
+                               dict_t *xdata)
 {
         int32_t   ret  = -1;
         dict_t   *dict = NULL;
 
         if (vol_mark == NULL){
-                STACK_UNWIND_STRICT (getxattr, frame, -1, ENOMEM, NULL);
+                STACK_UNWIND_STRICT (getxattr, frame, -1, ENOMEM, NULL, NULL);
 
                 goto out;
         }
@@ -245,7 +246,7 @@ marker_getxattr_stampfile_cbk (call_frame_t *frame, xlator_t *this,
                 gf_log (this->name, GF_LOG_WARNING, "failed to set key %s",
                         name);
 
-        STACK_UNWIND_STRICT (getxattr, frame, 0, 0, dict);
+        STACK_UNWIND_STRICT (getxattr, frame, 0, 0, dict, xdata);
 
         dict_unref (dict);
 out:
@@ -269,14 +270,15 @@ call_from_special_client (call_frame_t *frame, xlator_t *this, const char *name)
 
         stat_stampfile (this, priv, &vol_mark);
 
-        marker_getxattr_stampfile_cbk (frame, this, name, vol_mark);
+        marker_getxattr_stampfile_cbk (frame, this, name, vol_mark, NULL);
 out:
         return ret;
 }
 
 int32_t
 marker_getxattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                     int32_t op_ret, int32_t op_errno, dict_t *dict)
+                     int32_t op_ret, int32_t op_errno, dict_t *dict,
+                     dict_t *xdata)
 {
         if (cookie) {
                 gf_log (this->name, GF_LOG_DEBUG,
@@ -284,13 +286,13 @@ marker_getxattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
 
                 dict_foreach (dict, marker_filter_quota_xattr, NULL);
         }
-        STACK_UNWIND_STRICT (getxattr, frame, op_ret, op_errno, dict);
+        STACK_UNWIND_STRICT (getxattr, frame, op_ret, op_errno, dict, xdata);
         return 0;
 }
 
 int32_t
 marker_getxattr (call_frame_t *frame, xlator_t *this, loc_t *loc,
-                 const char *name)
+                 const char *name, dict_t *xdata)
 {
         gf_boolean_t   ret    = _gf_false;
         marker_conf_t *priv   = NULL;
@@ -317,7 +319,7 @@ wind:
                 STACK_WIND_COOKIE (frame, marker_getxattr_cbk, (void *)cookie,
                                    FIRST_CHILD(this),
                                    FIRST_CHILD(this)->fops->getxattr, loc,
-                                   name);
+                                   name, xdata);
         }
 
         return 0;
@@ -342,7 +344,7 @@ marker_setxattr_done (call_frame_t *frame)
 
 int
 marker_specific_setxattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                              int32_t op_ret, int32_t op_errno)
+                              int32_t op_ret, int32_t op_errno, dict_t *xdata)
 {
         int32_t         ret   = 0;
         int32_t         done  = 0;
@@ -416,7 +418,8 @@ marker_start_setxattr (call_frame_t *frame, xlator_t *this)
         }
 
         STACK_WIND (frame, marker_specific_setxattr_cbk, FIRST_CHILD(this),
-                    FIRST_CHILD(this)->fops->setxattr, &local->loc, dict, 0);
+                    FIRST_CHILD(this)->fops->setxattr, &local->loc, dict, 0,
+                    NULL);
 
         ret = 0;
 out:
@@ -476,7 +479,7 @@ int32_t
 marker_mkdir_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
                   int32_t op_ret, int32_t op_errno, inode_t *inode,
                   struct iatt *buf, struct iatt *preparent,
-                  struct iatt *postparent)
+                  struct iatt *postparent, dict_t *xdata)
 {
         marker_conf_t      *priv    = NULL;
         marker_local_t     *local   = NULL;
@@ -491,7 +494,7 @@ marker_mkdir_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
         frame->local = NULL;
 
         STACK_UNWIND_STRICT (mkdir, frame, op_ret, op_errno, inode,
-                             buf, preparent, postparent);
+                             buf, preparent, postparent, xdata);
 
         if (op_ret == -1 || local == NULL)
                 goto out;
@@ -512,7 +515,7 @@ out:
 
 int
 marker_mkdir (call_frame_t *frame, xlator_t *this, loc_t *loc, mode_t mode,
-              dict_t *params)
+              mode_t umask, dict_t *xdata)
 {
         int32_t          ret   = 0;
         marker_local_t  *local = NULL;
@@ -533,12 +536,12 @@ marker_mkdir (call_frame_t *frame, xlator_t *this, loc_t *loc, mode_t mode,
                 goto err;
 wind:
         STACK_WIND (frame, marker_mkdir_cbk, FIRST_CHILD(this),
-                    FIRST_CHILD(this)->fops->mkdir, loc, mode, params);
+                    FIRST_CHILD(this)->fops->mkdir, loc, mode, umask, xdata);
 
         return 0;
 err:
         STACK_UNWIND_STRICT (mkdir, frame, -1, ENOMEM, NULL,
-                             NULL, NULL, NULL);
+                             NULL, NULL, NULL, NULL);
         return 0;
 }
 
@@ -547,7 +550,7 @@ int32_t
 marker_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)
+                   struct iatt *postparent, dict_t *xdata)
 {
         marker_local_t     *local   = NULL;
         marker_conf_t      *priv    = NULL;
@@ -562,7 +565,7 @@ marker_create_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
         frame->local = NULL;
 
         STACK_UNWIND_STRICT (create, frame, op_ret, op_errno, fd, inode, buf,
-                             preparent, postparent);
+                             preparent, postparent, xdata);
 
         if (op_ret == -1 || local == NULL)
                 goto out;
@@ -583,7 +586,7 @@ out:
 
 int32_t
 marker_create (call_frame_t *frame, xlator_t *this, loc_t *loc, int32_t flags,
-               mode_t mode, fd_t *fd, dict_t *params)
+               mode_t mode, mode_t umask, fd_t *fd, dict_t *xdata)
 {
         int32_t          ret   = 0;
         marker_local_t  *local = NULL;
@@ -604,12 +607,12 @@ marker_create (call_frame_t *frame, xlator_t *this, loc_t *loc, int32_t flags,
                 goto err;
 wind:
         STACK_WIND (frame, marker_create_cbk, FIRST_CHILD(this),
-                    FIRST_CHILD(this)->fops->create, loc, flags, mode, fd,
-                    params);
+                    FIRST_CHILD(this)->fops->create, loc, flags, mode, umask,
+                    fd, xdata);
         return 0;
 err:
         STACK_UNWIND_STRICT (create, frame, -1, ENOMEM, NULL, NULL, NULL, NULL,
-                             NULL);
+                             NULL, NULL);
 
         return 0;
 }
@@ -618,7 +621,7 @@ err:
 int32_t
 marker_writev_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
                    int32_t op_ret, int32_t op_errno, struct iatt *prebuf,
-                   struct iatt *postbuf)
+                   struct iatt *postbuf, dict_t *xdata)
 {
         marker_conf_t      *priv    = NULL;
         marker_local_t     *local   = NULL;
@@ -632,7 +635,8 @@ marker_writev_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
 
         frame->local = NULL;
 
-        STACK_UNWIND_STRICT (writev, frame, op_ret, op_errno, prebuf, postbuf);
+        STACK_UNWIND_STRICT (writev, frame, op_ret, op_errno, prebuf, postbuf,
+                             xdata);
 
         if (op_ret == -1 || local == NULL)
                 goto out;
@@ -658,7 +662,7 @@ marker_writev (call_frame_t *frame,
                struct iovec *vector,
                int32_t count,
                off_t offset, uint32_t flags,
-               struct iobref *iobref)
+               struct iobref *iobref, dict_t *xdata)
 {
         int32_t          ret   = 0;
         marker_local_t  *local = NULL;
@@ -680,10 +684,10 @@ marker_writev (call_frame_t *frame,
 wind:
         STACK_WIND (frame, marker_writev_cbk, FIRST_CHILD(this),
                     FIRST_CHILD(this)->fops->writev, fd, vector, count, offset,
-                    flags, iobref);
+                    flags, iobref, xdata);
         return 0;
 err:
-        STACK_UNWIND_STRICT (writev, frame, -1, ENOMEM, NULL, NULL);
+        STACK_UNWIND_STRICT (writev, frame, -1, ENOMEM, NULL, NULL, NULL);
 
         return 0;
 }
@@ -692,7 +696,7 @@ err:
 int32_t
 marker_rmdir_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
                   int32_t op_ret, int32_t op_errno, struct iatt *preparent,
-                  struct iatt *postparent)
+                  struct iatt *postparent, dict_t *xdata)
 {
         marker_conf_t      *priv    = NULL;
         marker_local_t     *local   = NULL;
@@ -707,7 +711,7 @@ marker_rmdir_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
         frame->local = NULL;
 
         STACK_UNWIND_STRICT (rmdir, frame, op_ret, op_errno, preparent,
-                             postparent);
+                             postparent, xdata);
 
         if (op_ret == -1 || local == NULL)
                 goto out;
@@ -726,7 +730,8 @@ out:
 }
 
 int32_t
-marker_rmdir (call_frame_t *frame, xlator_t *this, loc_t *loc, int flags)
+marker_rmdir (call_frame_t *frame, xlator_t *this, loc_t *loc, int flags,
+              dict_t *xdata)
 {
         int32_t          ret   = 0;
         marker_local_t  *local = NULL;
@@ -747,10 +752,10 @@ marker_rmdir (call_frame_t *frame, xlator_t *this, loc_t *loc, int flags)
                 goto err;
 wind:
         STACK_WIND (frame, marker_rmdir_cbk, FIRST_CHILD(this),
-                    FIRST_CHILD(this)->fops->rmdir, loc, flags);
+                    FIRST_CHILD(this)->fops->rmdir, loc, flags, xdata);
         return 0;
 err:
-        STACK_UNWIND_STRICT (rmdir, frame, -1, ENOMEM, NULL, NULL);
+        STACK_UNWIND_STRICT (rmdir, frame, -1, ENOMEM, NULL, NULL, NULL);
 
         return 0;
 }
@@ -759,7 +764,7 @@ err:
 int32_t
 marker_unlink_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
                    int32_t op_ret, int32_t op_errno, struct iatt *preparent,
-                   struct iatt *postparent)
+                   struct iatt *postparent, dict_t *xdata)
 {
         marker_conf_t      *priv    = NULL;
         marker_local_t     *local   = NULL;
@@ -774,7 +779,7 @@ marker_unlink_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
         frame->local = NULL;
 
         STACK_UNWIND_STRICT (unlink, frame, op_ret, op_errno, preparent,
-                             postparent);
+                             postparent, xdata);
 
         if (op_ret == -1 || local == NULL)
                 goto out;
@@ -795,7 +800,8 @@ out:
 
 int32_t
 marker_unlink_stat_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                        int32_t op_ret, int32_t op_errno, struct iatt *buf)
+                        int32_t op_ret, int32_t op_errno, struct iatt *buf,
+                        dict_t *xdata)
 {
         marker_local_t *local = NULL;
 
@@ -812,18 +818,20 @@ marker_unlink_stat_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
         local->ia_nlink = buf->ia_nlink;
 
         STACK_WIND (frame, marker_unlink_cbk, FIRST_CHILD(this),
-                    FIRST_CHILD(this)->fops->unlink, &local->loc);
+                    FIRST_CHILD(this)->fops->unlink, &local->loc, local->xflag,
+                    NULL);
         return 0;
 err:
         frame->local = NULL;
-        STACK_UNWIND_STRICT (unlink, frame, -1, op_errno, NULL, NULL);
+        STACK_UNWIND_STRICT (unlink, frame, -1, op_errno, NULL, NULL, NULL);
         marker_local_unref (local);
         return 0;
 }
 
 
 int32_t
-marker_unlink (call_frame_t *frame, xlator_t *this, loc_t *loc)
+marker_unlink (call_frame_t *frame, xlator_t *this, loc_t *loc, int xflag,
+               dict_t *xdata)
 {
         int32_t          ret   = 0;
         marker_local_t  *local = NULL;
@@ -835,7 +843,7 @@ marker_unlink (call_frame_t *frame, xlator_t *this, loc_t *loc)
                 goto unlink_wind;
 
         local = mem_get0 (this->local_pool);
-
+        local->xflag = xflag;
         MARKER_INIT_LOCAL (frame, local);
 
         ret = loc_copy (&local->loc, loc);
@@ -847,16 +855,16 @@ marker_unlink (call_frame_t *frame, xlator_t *this, loc_t *loc)
                 uuid_copy (loc->gfid, loc->inode->gfid);
 
         STACK_WIND (frame, marker_unlink_stat_cbk, FIRST_CHILD(this),
-                    FIRST_CHILD(this)->fops->stat, loc);
+                    FIRST_CHILD(this)->fops->stat, loc, xdata);
         return 0;
 
 unlink_wind:
         STACK_WIND (frame, marker_unlink_cbk, FIRST_CHILD(this),
-                    FIRST_CHILD(this)->fops->unlink, loc);
+                    FIRST_CHILD(this)->fops->unlink, loc, xflag, xdata);
         return 0;
 err:
         frame->local = NULL;
-        STACK_UNWIND_STRICT (unlink, frame, -1, ENOMEM, NULL, NULL);
+        STACK_UNWIND_STRICT (unlink, frame, -1, ENOMEM, NULL, NULL, NULL);
         marker_local_unref (local);
         return 0;
 }
@@ -866,7 +874,7 @@ int32_t
 marker_link_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
                  int32_t op_ret, int32_t op_errno, inode_t *inode,
                  struct iatt *buf, struct iatt *preparent,
-                 struct iatt *postparent)
+                 struct iatt *postparent, dict_t *xdata)
 {
         marker_local_t     *local   = NULL;
         marker_conf_t      *priv    = NULL;
@@ -881,7 +889,7 @@ marker_link_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
         frame->local = NULL;
 
         STACK_UNWIND_STRICT (link, frame, op_ret, op_errno, inode, buf,
-                             preparent, postparent);
+                             preparent, postparent, xdata);
 
         if (op_ret == -1 || local == NULL)
                 goto out;
@@ -900,7 +908,8 @@ out:
 }
 
 int32_t
-marker_link (call_frame_t *frame, xlator_t *this, loc_t *oldloc, loc_t *newloc)
+marker_link (call_frame_t *frame, xlator_t *this, loc_t *oldloc, loc_t *newloc,
+             dict_t *xdata)
 {
         int32_t          ret   = 0;
         marker_local_t  *local = NULL;
@@ -921,10 +930,11 @@ marker_link (call_frame_t *frame, xlator_t *this, loc_t *oldloc, loc_t *newloc)
                 goto err;
 wind:
         STACK_WIND (frame, marker_link_cbk, FIRST_CHILD(this),
-                    FIRST_CHILD(this)->fops->link, oldloc, newloc);
+                    FIRST_CHILD(this)->fops->link, oldloc, newloc, xdata);
         return 0;
 err:
-        STACK_UNWIND_STRICT (link, frame, -1, ENOMEM, NULL, NULL, NULL, NULL);
+        STACK_UNWIND_STRICT (link, frame, -1, ENOMEM, NULL, NULL, NULL, NULL,
+                             NULL);
 
         return 0;
 }
@@ -932,7 +942,7 @@ err:
 
 int32_t
 marker_rename_done (call_frame_t *frame, void *cookie, xlator_t *this,
-                    int32_t op_ret, int32_t op_errno)
+                    int32_t op_ret, int32_t op_errno, dict_t *xdata)
 {
         marker_local_t *local  = NULL, *oplocal = NULL;
         loc_t           newloc = {0, };
@@ -962,7 +972,7 @@ marker_rename_done (call_frame_t *frame, void *cookie, xlator_t *this,
                 local->stub = NULL;
         } else if (local->err != 0) {
                 STACK_UNWIND_STRICT (rename, frame, -1, local->err, NULL, NULL,
-                                     NULL, NULL, NULL);
+                                     NULL, NULL, NULL, NULL);
         }
 
         mq_reduce_parent_size (this, &oplocal->loc, oplocal->contribution);
@@ -998,7 +1008,7 @@ marker_rename_done (call_frame_t *frame, void *cookie, xlator_t *this,
 int32_t
 marker_rename_release_newp_lock (call_frame_t *frame, void *cookie,
                                  xlator_t *this, int32_t op_ret,
-                                 int32_t op_errno)
+                                 int32_t op_errno, dict_t *xdata)
 {
         marker_local_t  *local = NULL, *oplocal = NULL;
         struct gf_flock  lock  = {0, };
@@ -1019,7 +1029,7 @@ marker_rename_release_newp_lock (call_frame_t *frame, void *cookie,
         }
 
         if (local->next_lock_on == NULL) {
-                marker_rename_done (frame, NULL, this, 0, 0);
+                marker_rename_done (frame, NULL, this, 0, 0, NULL);
                 goto out;
         }
 
@@ -1033,7 +1043,7 @@ marker_rename_release_newp_lock (call_frame_t *frame, void *cookie,
                     marker_rename_done,
                     FIRST_CHILD(this),
                     FIRST_CHILD(this)->fops->inodelk,
-                    this->name, &local->parent_loc, F_SETLKW, &lock);
+                    this->name, &local->parent_loc, F_SETLKW, &lock, NULL);
 
 out:
         return 0;
@@ -1043,7 +1053,7 @@ out:
 int32_t
 marker_rename_release_oldp_lock (call_frame_t *frame, void *cookie,
                                  xlator_t *this, int32_t op_ret,
-                                 int32_t op_errno)
+                                 int32_t op_errno, dict_t *xdata)
 {
         marker_local_t  *local = NULL, *oplocal = NULL;
         struct gf_flock  lock  = {0, };
@@ -1069,7 +1079,7 @@ marker_rename_release_oldp_lock (call_frame_t *frame, void *cookie,
                     marker_rename_release_newp_lock,
                     FIRST_CHILD(this),
                     FIRST_CHILD(this)->fops->inodelk,
-                    this->name, &oplocal->parent_loc, F_SETLKW, &lock);
+                    this->name, &oplocal->parent_loc, F_SETLKW, &lock, NULL);
         return 0;
 }
 
@@ -1078,7 +1088,8 @@ int32_t
 marker_rename_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
                    int32_t op_ret, int32_t op_errno, struct iatt *buf,
                    struct iatt *preoldparent, struct iatt *postoldparent,
-                   struct iatt *prenewparent, struct iatt *postnewparent)
+                   struct iatt *prenewparent, struct iatt *postnewparent,
+                   dict_t *xdata)
 {
         marker_conf_t  *priv                 = NULL;
         marker_local_t *local                = NULL;
@@ -1113,7 +1124,7 @@ marker_rename_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
                 stub = fop_rename_cbk_stub (frame, default_rename_cbk, op_ret,
                                             op_errno, buf, preoldparent,
                                             postoldparent, prenewparent,
-                                            postnewparent);
+                                            postnewparent, xdata);
                 if (stub == NULL) {
                         local->err = ENOMEM;
                         goto quota_err;
@@ -1143,7 +1154,7 @@ marker_rename_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
                 STACK_WIND_COOKIE (frame, marker_rename_release_oldp_lock,
                                    frame->cookie, FIRST_CHILD(this),
                                    FIRST_CHILD(this)->fops->removexattr,
-                                   &newloc, contri_key);
+                                   &newloc, contri_key, NULL);
 
                 loc_wipe (&newloc);
         } else {
@@ -1151,7 +1162,7 @@ marker_rename_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
 
                 STACK_UNWIND_STRICT (rename, frame, op_ret, op_errno, buf,
                                      preoldparent, postoldparent, prenewparent,
-                                     postnewparent);
+                                     postnewparent, xdata);
 
                 if ((op_ret < 0) || (local == NULL)) {
                         goto out;
@@ -1174,15 +1185,14 @@ out:
         return 0;
 
 quota_err:
-        marker_rename_release_oldp_lock (frame, NULL, this, 0, 0);
+        marker_rename_release_oldp_lock (frame, NULL, this, 0, 0, NULL);
         return 0;
 }
 
 
 int32_t
 marker_do_rename (call_frame_t *frame, void *cookie, xlator_t *this,
-                  int32_t op_ret, int32_t op_errno, dict_t *dict)
-
+                  int32_t op_ret, int32_t op_errno, dict_t *dict, dict_t *xdata)
 {
         marker_local_t       *local           = NULL, *oplocal = NULL;
         char                  contri_key[512] = {0, };
@@ -1221,12 +1231,12 @@ marker_do_rename (call_frame_t *frame, void *cookie, xlator_t *this,
 
         STACK_WIND (frame, marker_rename_cbk, FIRST_CHILD(this),
                     FIRST_CHILD(this)->fops->rename, &oplocal->loc,
-                    &local->loc);
+                    &local->loc, NULL);
 
         return 0;
 
 err:
-        marker_rename_release_oldp_lock (frame, NULL, this, 0, 0);
+        marker_rename_release_oldp_lock (frame, NULL, this, 0, 0, NULL);
         return 0;
 }
 
@@ -1234,7 +1244,7 @@ err:
 int32_t
 marker_get_newpath_contribution (call_frame_t *frame, void *cookie,
                                  xlator_t *this, int32_t op_ret,
-                                 int32_t op_errno, dict_t *dict)
+                                 int32_t op_errno, dict_t *dict, dict_t *xdata)
 {
         marker_local_t *local           = NULL, *oplocal = NULL;
         char            contri_key[512] = {0, };
@@ -1286,14 +1296,14 @@ marker_get_newpath_contribution (call_frame_t *frame, void *cookie,
                 STACK_WIND_COOKIE (frame, marker_do_rename,
                                    frame->cookie, FIRST_CHILD(this),
                                    FIRST_CHILD(this)->fops->getxattr,
-                                   &local->loc, contri_key);
+                                   &local->loc, contri_key, NULL);
         } else {
-                marker_do_rename (frame, NULL, this, 0, 0, NULL);
+                marker_do_rename (frame, NULL, this, 0, 0, NULL, NULL);
         }
 
         return 0;
 err:
-        marker_rename_release_oldp_lock (frame, NULL, this, 0, 0);
+        marker_rename_release_oldp_lock (frame, NULL, this, 0, 0, NULL);
         return 0;
 }
 
@@ -1301,7 +1311,7 @@ err:
 int32_t
 marker_get_oldpath_contribution (call_frame_t *frame, void *cookie,
                                  xlator_t *this, int32_t op_ret,
-                                 int32_t op_errno)
+                                 int32_t op_errno, dict_t *xdata)
 {
         marker_local_t *local           = NULL, *oplocal = NULL;
         char            contri_key[512] = {0, };
@@ -1340,20 +1350,20 @@ marker_get_oldpath_contribution (call_frame_t *frame, void *cookie,
         STACK_WIND_COOKIE (frame, marker_get_newpath_contribution,
                            frame->cookie, FIRST_CHILD(this),
                            FIRST_CHILD(this)->fops->getxattr,
-                           &oplocal->loc, contri_key);
+                           &oplocal->loc, contri_key, NULL);
         return 0;
 
 quota_err:
-        marker_rename_release_oldp_lock (frame, NULL, this, 0, 0);
+        marker_rename_release_oldp_lock (frame, NULL, this, 0, 0, NULL);
         return 0;
 
 lock_err:
         if ((local->next_lock_on == NULL)
             || (local->next_lock_on == &local->parent_loc)) {
                 local->next_lock_on = NULL;
-                marker_rename_release_oldp_lock (frame, NULL, this, 0, 0);
+                marker_rename_release_oldp_lock (frame, NULL, this, 0, 0, NULL);
         } else {
-                marker_rename_release_newp_lock (frame, NULL, this, 0, 0);
+                marker_rename_release_newp_lock (frame, NULL, this, 0, 0, NULL);
         }
 
         return 0;
@@ -1362,7 +1372,7 @@ lock_err:
 
 int32_t
 marker_rename_inodelk_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                           int32_t op_ret, int32_t op_errno)
+                           int32_t op_ret, int32_t op_errno, dict_t *xdata)
 {
         marker_local_t  *local = NULL, *oplocal = NULL;
         loc_t           *loc   = NULL;
@@ -1397,22 +1407,22 @@ marker_rename_inodelk_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
                             FIRST_CHILD(this),
                             FIRST_CHILD(this)->fops->inodelk,
                             this->name, local->next_lock_on,
-                            F_SETLKW, &lock);
+                            F_SETLKW, &lock, NULL);
         } else {
-                marker_get_oldpath_contribution (frame, 0, this, 0, 0);
+                marker_get_oldpath_contribution (frame, 0, this, 0, 0, NULL);
         }
 
         return 0;
 
 err:
-        marker_rename_done (frame, NULL, this, 0, 0);
+        marker_rename_done (frame, NULL, this, 0, 0, NULL);
         return 0;
 }
 
 
 int32_t
 marker_rename (call_frame_t *frame, xlator_t *this, loc_t *oldloc,
-               loc_t *newloc)
+               loc_t *newloc, dict_t *xdata)
 {
         int32_t         ret              = 0;
         marker_local_t *local            = NULL;
@@ -1481,18 +1491,18 @@ marker_rename (call_frame_t *frame, xlator_t *this, loc_t *oldloc,
                     FIRST_CHILD(this),
                     FIRST_CHILD(this)->fops->inodelk,
                     this->name, lock_on,
-                    F_SETLKW, &lock);
+                    F_SETLKW, &lock, NULL);
 
         return 0;
 
 rename_wind:
         STACK_WIND (frame, marker_rename_cbk, FIRST_CHILD(this),
-                    FIRST_CHILD(this)->fops->rename, oldloc, newloc);
+                    FIRST_CHILD(this)->fops->rename, oldloc, newloc, xdata);
 
         return 0;
 err:
         STACK_UNWIND_STRICT (rename, frame, -1, ENOMEM, NULL,
-                             NULL, NULL, NULL, NULL);
+                             NULL, NULL, NULL, NULL, NULL);
 
         return 0;
 }
@@ -1501,7 +1511,7 @@ err:
 int32_t
 marker_truncate_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
                      int32_t op_ret, int32_t op_errno, struct iatt *prebuf,
-                     struct iatt *postbuf)
+                     struct iatt *postbuf, dict_t *xdata)
 {
         marker_local_t     *local   = NULL;
         marker_conf_t      *priv    = NULL;
@@ -1516,7 +1526,7 @@ marker_truncate_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
         frame->local = NULL;
 
         STACK_UNWIND_STRICT (truncate, frame, op_ret, op_errno, prebuf,
-                             postbuf);
+                             postbuf, xdata);
 
         if (op_ret == -1 || local == NULL)
                 goto out;
@@ -1536,7 +1546,8 @@ out:
 }
 
 int32_t
-marker_truncate (call_frame_t *frame, xlator_t *this, loc_t *loc, off_t offset)
+marker_truncate (call_frame_t *frame, xlator_t *this, loc_t *loc, off_t offset,
+                 dict_t *xdata)
 {
         int32_t          ret   = 0;
         marker_local_t  *local = NULL;
@@ -1557,10 +1568,10 @@ marker_truncate (call_frame_t *frame, xlator_t *this, loc_t *loc, off_t offset)
                 goto err;
 wind:
         STACK_WIND (frame, marker_truncate_cbk, FIRST_CHILD(this),
-                    FIRST_CHILD(this)->fops->truncate, loc, offset);
+                    FIRST_CHILD(this)->fops->truncate, loc, offset, xdata);
         return 0;
 err:
-        STACK_UNWIND_STRICT (truncate, frame, -1, ENOMEM, NULL, NULL);
+        STACK_UNWIND_STRICT (truncate, frame, -1, ENOMEM, NULL, NULL, NULL);
 
         return 0;
 }
@@ -1569,7 +1580,7 @@ err:
 int32_t
 marker_ftruncate_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
                       int32_t op_ret, int32_t op_errno, struct iatt *prebuf,
-                      struct iatt *postbuf)
+                      struct iatt *postbuf, dict_t *xdata)
 {
         marker_local_t     *local   = NULL;
         marker_conf_t      *priv    = NULL;
@@ -1584,7 +1595,7 @@ marker_ftruncate_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
         frame->local = NULL;
 
         STACK_UNWIND_STRICT (ftruncate, frame, op_ret, op_errno, prebuf,
-                             postbuf);
+                             postbuf, xdata);
 
         if (op_ret == -1 || local == NULL)
                 goto out;
@@ -1603,7 +1614,8 @@ out:
 }
 
 int32_t
-marker_ftruncate (call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset)
+marker_ftruncate (call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset,
+                  dict_t *xdata)
 {
         int32_t          ret   = 0;
         marker_local_t  *local = NULL;
@@ -1624,10 +1636,10 @@ marker_ftruncate (call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset)
                 goto err;
 wind:
         STACK_WIND (frame, marker_ftruncate_cbk, FIRST_CHILD(this),
-                    FIRST_CHILD(this)->fops->ftruncate, fd, offset);
+                    FIRST_CHILD(this)->fops->ftruncate, fd, offset, xdata);
         return 0;
 err:
-        STACK_UNWIND_STRICT (ftruncate, frame, -1, ENOMEM, NULL, NULL);
+        STACK_UNWIND_STRICT (ftruncate, frame, -1, ENOMEM, NULL, NULL, NULL);
 
         return 0;
 }
@@ -1637,7 +1649,7 @@ int32_t
 marker_symlink_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
                     int32_t op_ret, int32_t op_errno, inode_t *inode,
                     struct iatt *buf, struct iatt *preparent,
-                    struct iatt *postparent)
+                    struct iatt *postparent, dict_t *xdata)
 {
         marker_conf_t      *priv    = NULL;
         marker_local_t     *local   = NULL;
@@ -1652,7 +1664,7 @@ marker_symlink_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
         frame->local = NULL;
 
         STACK_UNWIND_STRICT (symlink, frame, op_ret, op_errno, inode, buf,
-                             preparent, postparent);
+                             preparent, postparent, xdata);
 
         if (op_ret == -1 || local == NULL)
                 goto out;
@@ -1672,7 +1684,7 @@ out:
 
 int
 marker_symlink (call_frame_t *frame, xlator_t *this, const char *linkpath,
-                loc_t *loc, dict_t *params)
+                loc_t *loc, mode_t umask, dict_t *xdata)
 {
         int32_t          ret   = 0;
         marker_local_t  *local = NULL;
@@ -1693,11 +1705,12 @@ marker_symlink (call_frame_t *frame, xlator_t *this, const char *linkpath,
                 goto err;
 wind:
         STACK_WIND (frame, marker_symlink_cbk, FIRST_CHILD(this),
-                    FIRST_CHILD(this)->fops->symlink, linkpath, loc, params);
+                    FIRST_CHILD(this)->fops->symlink, linkpath, loc, umask,
+                    xdata);
         return 0;
 err:
         STACK_UNWIND_STRICT (symlink, frame, -1, ENOMEM, NULL,
-                             NULL, NULL, NULL);
+                             NULL, NULL, NULL, NULL);
         return 0;
 }
 
@@ -1706,7 +1719,7 @@ int32_t
 marker_mknod_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
                   int32_t op_ret, int32_t op_errno, inode_t *inode,
                   struct iatt *buf, struct iatt *preparent,
-                  struct iatt *postparent)
+                  struct iatt *postparent, dict_t *xdata)
 {
         marker_local_t     *local   = NULL;
         marker_conf_t      *priv    = NULL;
@@ -1721,7 +1734,7 @@ marker_mknod_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
         frame->local = NULL;
 
         STACK_UNWIND_STRICT (mknod, frame, op_ret, op_errno, inode,
-                             buf, preparent, postparent);
+                             buf, preparent, postparent, xdata);
 
         if (op_ret == -1 ||  local == NULL)
                 goto out;
@@ -1742,7 +1755,7 @@ out:
 
 int
 marker_mknod (call_frame_t *frame, xlator_t *this, loc_t *loc, mode_t mode,
-              dev_t rdev, dict_t *parms)
+              dev_t rdev, mode_t umask, dict_t *xdata)
 {
         int32_t          ret   = 0;
         marker_local_t  *local = NULL;
@@ -1765,11 +1778,12 @@ marker_mknod (call_frame_t *frame, xlator_t *this, loc_t *loc, mode_t mode,
                 goto err;
 wind:
         STACK_WIND (frame, marker_mknod_cbk, FIRST_CHILD(this),
-                    FIRST_CHILD(this)->fops->mknod, loc, mode, rdev, parms);
+                    FIRST_CHILD(this)->fops->mknod, loc, mode, rdev, umask,
+                    xdata);
         return 0;
 err:
         STACK_UNWIND_STRICT (mknod, frame, -1, ENOMEM, NULL,
-                             NULL, NULL, NULL);
+                             NULL, NULL, NULL, NULL);
         return 0;
 }
 
@@ -1829,7 +1843,7 @@ call_from_sp_client_to_reset_tmfile (call_frame_t *frame,
                 op_errno = EINVAL;
         }
 out:
-        STACK_UNWIND_STRICT (setxattr, frame, op_ret, op_errno);
+        STACK_UNWIND_STRICT (setxattr, frame, op_ret, op_errno, NULL);
 
         return 0;
 }
@@ -1837,7 +1851,7 @@ out:
 
 int32_t
 marker_setxattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                     int32_t op_ret, int32_t op_errno)
+                     int32_t op_ret, int32_t op_errno, dict_t *xdata)
 {
         marker_local_t     *local   = NULL;
         marker_conf_t      *priv    = NULL;
@@ -1851,7 +1865,7 @@ marker_setxattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
 
         frame->local = NULL;
 
-        STACK_UNWIND_STRICT (setxattr, frame, op_ret, op_errno);
+        STACK_UNWIND_STRICT (setxattr, frame, op_ret, op_errno, xdata);
 
         if (op_ret == -1 || local == NULL)
                 goto out;
@@ -1868,7 +1882,7 @@ out:
 
 int32_t
 marker_setxattr (call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *dict,
-                 int32_t flags)
+                 int32_t flags, dict_t *xdata)
 {
         int32_t          ret   = 0;
         marker_local_t  *local = NULL;
@@ -1893,10 +1907,10 @@ marker_setxattr (call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *dict,
                 goto err;
 wind:
         STACK_WIND (frame, marker_setxattr_cbk, FIRST_CHILD(this),
-                    FIRST_CHILD(this)->fops->setxattr, loc, dict, flags);
+                    FIRST_CHILD(this)->fops->setxattr, loc, dict, flags, xdata);
         return 0;
 err:
-        STACK_UNWIND_STRICT (setxattr, frame, -1, ENOMEM);
+        STACK_UNWIND_STRICT (setxattr, frame, -1, ENOMEM, NULL);
 
         return 0;
 }
@@ -1904,7 +1918,7 @@ err:
 
 int32_t
 marker_fsetxattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                      int32_t op_ret, int32_t op_errno)
+                      int32_t op_ret, int32_t op_errno, dict_t *xdata)
 {
         marker_local_t     *local   = NULL;
         marker_conf_t      *priv    = NULL;
@@ -1918,7 +1932,7 @@ marker_fsetxattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
 
         frame->local = NULL;
 
-        STACK_UNWIND_STRICT (fsetxattr, frame, op_ret, op_errno);
+        STACK_UNWIND_STRICT (fsetxattr, frame, op_ret, op_errno, xdata);
 
         if (op_ret == -1 || local == NULL)
                 goto out;
@@ -1935,7 +1949,7 @@ out:
 
 int32_t
 marker_fsetxattr (call_frame_t *frame, xlator_t *this, fd_t *fd, dict_t *dict,
-                  int32_t flags)
+                  int32_t flags, dict_t *xdata)
 {
         int32_t          ret   = 0;
         marker_local_t  *local = NULL;
@@ -1960,10 +1974,10 @@ marker_fsetxattr (call_frame_t *frame, xlator_t *this, fd_t *fd, dict_t *dict,
                 goto err;
 wind:
         STACK_WIND (frame, marker_fsetxattr_cbk, FIRST_CHILD(this),
-                    FIRST_CHILD(this)->fops->fsetxattr, fd, dict, flags);
+                    FIRST_CHILD(this)->fops->fsetxattr, fd, dict, flags, xdata);
         return 0;
 err:
-        STACK_UNWIND_STRICT (fsetxattr, frame, -1, ENOMEM);
+        STACK_UNWIND_STRICT (fsetxattr, frame, -1, ENOMEM, NULL);
 
         return 0;
 }
@@ -1972,7 +1986,7 @@ err:
 int32_t
 marker_fsetattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
                      int32_t op_ret, int32_t op_errno, struct iatt *statpre,
-                     struct iatt *statpost)
+                     struct iatt *statpost, dict_t *xdata)
 {
         marker_local_t     *local   = NULL;
         marker_conf_t      *priv    = NULL;
@@ -1987,7 +2001,7 @@ marker_fsetattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
         frame->local = NULL;
 
         STACK_UNWIND_STRICT (fsetattr, frame, op_ret, op_errno, statpre,
-                             statpost);
+                             statpost, xdata);
 
         if (op_ret == -1 || local == NULL)
                 goto out;
@@ -2005,7 +2019,7 @@ out:
 
 int32_t
 marker_fsetattr (call_frame_t *frame, xlator_t *this, fd_t *fd,
-                 struct iatt *stbuf, int32_t valid)
+                 struct iatt *stbuf, int32_t valid, dict_t *xdata)
 {
         int32_t          ret   = 0;
         marker_local_t  *local = NULL;
@@ -2026,10 +2040,10 @@ marker_fsetattr (call_frame_t *frame, xlator_t *this, fd_t *fd,
                 goto err;
 wind:
         STACK_WIND (frame, marker_fsetattr_cbk, FIRST_CHILD (this),
-                    FIRST_CHILD (this)->fops->fsetattr, fd, stbuf, valid);
+                    FIRST_CHILD (this)->fops->fsetattr, fd, stbuf, valid, xdata);
         return 0;
 err:
-        STACK_UNWIND_STRICT (fsetattr, frame, -1, ENOMEM, NULL, NULL);
+        STACK_UNWIND_STRICT (fsetattr, frame, -1, ENOMEM, NULL, NULL, NULL);
 
         return 0;
 }
@@ -2038,7 +2052,7 @@ err:
 int32_t
 marker_setattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
                     int32_t op_ret, int32_t op_errno, struct iatt *statpre,
-                    struct iatt *statpost)
+                    struct iatt *statpost, dict_t *xdata)
 {
         marker_local_t     *local   = NULL;
         marker_conf_t      *priv    = NULL;
@@ -2056,7 +2070,7 @@ marker_setattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
         }
 
         STACK_UNWIND_STRICT (setattr, frame, op_ret, op_errno, statpre,
-                             statpost);
+                             statpost, xdata);
 
         if (op_ret == -1 || local == NULL)
                 goto out;
@@ -2073,7 +2087,7 @@ out:
 
 int32_t
 marker_setattr (call_frame_t *frame, xlator_t *this, loc_t *loc,
-                struct iatt *stbuf, int32_t valid)
+                struct iatt *stbuf, int32_t valid, dict_t *xdata)
 {
         int32_t          ret   = 0;
         marker_local_t  *local = NULL;
@@ -2094,10 +2108,10 @@ marker_setattr (call_frame_t *frame, xlator_t *this, loc_t *loc,
                 goto err;
 wind:
         STACK_WIND (frame, marker_setattr_cbk, FIRST_CHILD (this),
-                    FIRST_CHILD (this)->fops->setattr, loc, stbuf, valid);
+                    FIRST_CHILD (this)->fops->setattr, loc, stbuf, valid, xdata);
         return 0;
 err:
-        STACK_UNWIND_STRICT (setattr, frame, -1, ENOMEM, NULL, NULL);
+        STACK_UNWIND_STRICT (setattr, frame, -1, ENOMEM, NULL, NULL, NULL);
 
         return 0;
 }
@@ -2105,7 +2119,7 @@ err:
 
 int32_t
 marker_removexattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                        int32_t op_ret, int32_t op_errno)
+                        int32_t op_ret, int32_t op_errno, dict_t *xdata)
 {
         marker_local_t     *local   = NULL;
         marker_conf_t      *priv    = NULL;
@@ -2119,7 +2133,7 @@ marker_removexattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
 
         frame->local = NULL;
 
-        STACK_UNWIND_STRICT (removexattr, frame, op_ret, op_errno);
+        STACK_UNWIND_STRICT (removexattr, frame, op_ret, op_errno, xdata);
 
         if (op_ret == -1 || local == NULL)
                 goto out;
@@ -2136,7 +2150,7 @@ out:
 
 int32_t
 marker_removexattr (call_frame_t *frame, xlator_t *this, loc_t *loc,
-                    const char *name)
+                    const char *name, dict_t *xdata)
 {
         int32_t          ret   = 0;
         marker_local_t  *local = NULL;
@@ -2157,10 +2171,10 @@ marker_removexattr (call_frame_t *frame, xlator_t *this, loc_t *loc,
                 goto err;
 wind:
         STACK_WIND (frame, marker_removexattr_cbk, FIRST_CHILD(this),
-                    FIRST_CHILD(this)->fops->removexattr, loc, name);
+                    FIRST_CHILD(this)->fops->removexattr, loc, name, xdata);
         return 0;
 err:
-        STACK_UNWIND_STRICT (removexattr, frame, -1, ENOMEM);
+        STACK_UNWIND_STRICT (removexattr, frame, -1, ENOMEM, NULL);
 
         return 0;
 }
@@ -2239,7 +2253,8 @@ err:
 
 int
 marker_readdirp_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                     int op_ret, int op_errno, gf_dirent_t *entries)
+                     int op_ret, int op_errno, gf_dirent_t *entries,
+                     dict_t *xdata)
 {
         gf_dirent_t *entry = NULL;
 
@@ -2251,7 +2266,7 @@ marker_readdirp_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
         }
 
 unwind:
-        STACK_UNWIND_STRICT (readdirp, frame, op_ret, op_errno, entries);
+        STACK_UNWIND_STRICT (readdirp, frame, op_ret, op_errno, entries, xdata);
 
         return 0;
 }
diff --git a/xlators/features/marker/src/marker.h b/xlators/features/marker/src/marker.h
index 3dcb41f8ad3..cf0f92b7908 100644
--- a/xlators/features/marker/src/marker.h
+++ b/xlators/features/marker/src/marker.h
@@ -117,6 +117,8 @@ struct marker_local{
 
         quota_inode_ctx_t    *ctx;
         inode_contribution_t *contri;
+
+        int xflag;
 };
 typedef struct marker_local marker_local_t;
 
diff --git a/xlators/features/quiesce/src/quiesce.c b/xlators/features/quiesce/src/quiesce.c
index 1b150b21558..d355a19fa7f 100644
--- a/xlators/features/quiesce/src/quiesce.c
+++ b/xlators/features/quiesce/src/quiesce.c
@@ -191,7 +191,8 @@ out:
 
 int32_t
 quiesce_stat_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                  int32_t op_ret, int32_t op_errno, struct iatt *buf)
+                  int32_t op_ret, int32_t op_errno, struct iatt *buf,
+                  dict_t *xdata)
 {
         call_stub_t    *stub = NULL;
         quiesce_local_t *local = NULL;
@@ -201,10 +202,10 @@ quiesce_stat_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
         if ((op_ret == -1) && (op_errno == ENOTCONN)) {
                 /* Re-transmit (by putting in the queue) */
                 stub = fop_stat_stub (frame, default_stat_resume,
-                                      &local->loc);
+                                      &local->loc, xdata);
                 if (!stub) {
                         STACK_UNWIND_STRICT (stat, frame, -1, ENOMEM,
-                                             NULL);
+                                             NULL, NULL);
                         goto out;
                 }
 
@@ -212,7 +213,7 @@ quiesce_stat_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
                 goto out;
         }
 
-        STACK_UNWIND_STRICT (stat, frame, op_ret, op_errno, buf);
+        STACK_UNWIND_STRICT (stat, frame, op_ret, op_errno, buf, xdata);
 out:
         gf_quiesce_local_wipe (this, local);
 
@@ -221,7 +222,7 @@ out:
 
 int32_t
 quiesce_access_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                    int32_t op_ret, int32_t op_errno)
+                    int32_t op_ret, int32_t op_errno, dict_t *xdata)
 {
         call_stub_t    *stub = NULL;
         quiesce_local_t *local = NULL;
@@ -231,9 +232,9 @@ quiesce_access_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
         if ((op_ret == -1) && (op_errno == ENOTCONN)) {
                 /* Re-transmit (by putting in the queue) */
                 stub = fop_access_stub (frame, default_access_resume,
-                                        &local->loc, local->flag);
+                                        &local->loc, local->flag, xdata);
                 if (!stub) {
-                        STACK_UNWIND_STRICT (access, frame, -1, ENOMEM);
+                        STACK_UNWIND_STRICT (access, frame, -1, ENOMEM, NULL);
                         goto out;
                 }
 
@@ -241,7 +242,7 @@ quiesce_access_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
                 goto out;
         }
 
-        STACK_UNWIND_STRICT (access, frame, op_ret, op_errno);
+        STACK_UNWIND_STRICT (access, frame, op_ret, op_errno, xdata);
 out:
         gf_quiesce_local_wipe (this, local);
 
@@ -251,7 +252,7 @@ out:
 int32_t
 quiesce_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)
+                      struct iatt *buf, dict_t *xdata)
 {
         call_stub_t    *stub = NULL;
         quiesce_local_t *local = NULL;
@@ -261,10 +262,10 @@ quiesce_readlink_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
         if ((op_ret == -1) && (op_errno == ENOTCONN)) {
                 /* Re-transmit (by putting in the queue) */
                 stub = fop_readlink_stub (frame, default_readlink_resume,
-                                          &local->loc, local->size);
+                                          &local->loc, local->size, xdata);
                 if (!stub) {
                         STACK_UNWIND_STRICT (readlink, frame, -1, ENOMEM,
-                                             NULL, NULL);
+                                             NULL, NULL, NULL);
                         goto out;
                 }
 
@@ -272,7 +273,7 @@ quiesce_readlink_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
                 goto out;
         }
 
-        STACK_UNWIND_STRICT (readlink, frame, op_ret, op_errno, path, buf);
+        STACK_UNWIND_STRICT (readlink, frame, op_ret, op_errno, path, buf, xdata);
 out:
         gf_quiesce_local_wipe (this, local);
 
@@ -281,7 +282,7 @@ out:
 
 int32_t
 quiesce_open_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                  int32_t op_ret, int32_t op_errno, fd_t *fd)
+                  int32_t op_ret, int32_t op_errno, fd_t *fd, dict_t *xdata)
 {
         call_stub_t    *stub = NULL;
         quiesce_local_t *local = NULL;
@@ -292,10 +293,10 @@ quiesce_open_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
                 /* Re-transmit (by putting in the queue) */
                 stub = fop_open_stub (frame, default_open_resume,
                                       &local->loc, local->flag, local->fd,
-                                      local->wbflags);
+                                      xdata);
                 if (!stub) {
                         STACK_UNWIND_STRICT (open, frame, -1, ENOMEM,
-                                             NULL);
+                                             NULL, NULL);
                         goto out;
                 }
 
@@ -303,7 +304,7 @@ quiesce_open_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
                 goto out;
         }
 
-        STACK_UNWIND_STRICT (open, frame, op_ret, op_errno, fd);
+        STACK_UNWIND_STRICT (open, frame, op_ret, op_errno, fd, xdata);
 out:
         gf_quiesce_local_wipe (this, local);
 
@@ -313,7 +314,7 @@ out:
 int32_t
 quiesce_readv_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
                    int32_t op_ret, int32_t op_errno, struct iovec *vector,
-                   int32_t count, struct iatt *stbuf, struct iobref *iobref)
+                   int32_t count, struct iatt *stbuf, struct iobref *iobref, dict_t *xdata)
 {
         call_stub_t    *stub = NULL;
         quiesce_local_t *local = NULL;
@@ -324,10 +325,10 @@ quiesce_readv_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
                 /* Re-transmit (by putting in the queue) */
                 stub = fop_readv_stub (frame, default_readv_resume,
                                        local->fd, local->size, local->offset,
-                                       local->io_flag);
+                                       local->io_flag, xdata);
                 if (!stub) {
                         STACK_UNWIND_STRICT (readv, frame, -1, ENOMEM,
-                                             NULL, 0, NULL, NULL);
+                                             NULL, 0, NULL, NULL, NULL);
                         goto out;
                 }
 
@@ -336,7 +337,7 @@ quiesce_readv_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
         }
 
         STACK_UNWIND_STRICT (readv, frame, op_ret, op_errno, vector, count,
-                             stbuf, iobref);
+                             stbuf, iobref, xdata);
 out:
         gf_quiesce_local_wipe (this, local);
 
@@ -345,7 +346,7 @@ out:
 
 int32_t
 quiesce_flush_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                   int32_t op_ret, int32_t op_errno)
+                   int32_t op_ret, int32_t op_errno, dict_t *xdata)
 {
         call_stub_t    *stub = NULL;
         quiesce_local_t *local = NULL;
@@ -355,9 +356,9 @@ quiesce_flush_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
         if ((op_ret == -1) && (op_errno == ENOTCONN)) {
                 /* Re-transmit (by putting in the queue) */
                 stub = fop_flush_stub (frame, default_flush_resume,
-                                       local->fd);
+                                       local->fd, xdata);
                 if (!stub) {
-                        STACK_UNWIND_STRICT (flush, frame, -1, ENOMEM);
+                        STACK_UNWIND_STRICT (flush, frame, -1, ENOMEM, NULL);
                         goto out;
                 }
 
@@ -365,7 +366,7 @@ quiesce_flush_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
                 goto out;
         }
 
-        STACK_UNWIND_STRICT (flush, frame, op_ret, op_errno);
+        STACK_UNWIND_STRICT (flush, frame, op_ret, op_errno, xdata);
 out:
         gf_quiesce_local_wipe (this, local);
 
@@ -377,7 +378,7 @@ out:
 int32_t
 quiesce_fsync_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
                    int32_t op_ret, int32_t op_errno, struct iatt *prebuf,
-                   struct iatt *postbuf)
+                   struct iatt *postbuf, dict_t *xdata)
 {
         call_stub_t    *stub = NULL;
         quiesce_local_t *local = NULL;
@@ -387,10 +388,10 @@ quiesce_fsync_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
         if ((op_ret == -1) && (op_errno == ENOTCONN)) {
                 /* Re-transmit (by putting in the queue) */
                 stub = fop_fsync_stub (frame, default_fsync_resume,
-                                       local->fd, local->flag);
+                                       local->fd, local->flag, xdata);
                 if (!stub) {
                         STACK_UNWIND_STRICT (fsync, frame, -1, ENOMEM,
-                                             NULL, NULL);
+                                             NULL, NULL, NULL);
                         goto out;
                 }
 
@@ -398,7 +399,7 @@ quiesce_fsync_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
                 goto out;
         }
 
-        STACK_UNWIND_STRICT (fsync, frame, op_ret, op_errno, prebuf, postbuf);
+        STACK_UNWIND_STRICT (fsync, frame, op_ret, op_errno, prebuf, postbuf, xdata);
 out:
         gf_quiesce_local_wipe (this, local);
 
@@ -407,7 +408,7 @@ out:
 
 int32_t
 quiesce_fstat_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                   int32_t op_ret, int32_t op_errno, struct iatt *buf)
+                   int32_t op_ret, int32_t op_errno, struct iatt *buf, dict_t *xdata)
 {
         call_stub_t    *stub = NULL;
         quiesce_local_t *local = NULL;
@@ -417,10 +418,10 @@ quiesce_fstat_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
         if ((op_ret == -1) && (op_errno == ENOTCONN)) {
                 /* Re-transmit (by putting in the queue) */
                 stub = fop_fstat_stub (frame, default_fstat_resume,
-                                       local->fd);
+                                       local->fd, xdata);
                 if (!stub) {
                         STACK_UNWIND_STRICT (fstat, frame, -1, ENOMEM,
-                                             NULL);
+                                             NULL, NULL);
                         goto out;
                 }
 
@@ -428,7 +429,7 @@ quiesce_fstat_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
                 goto out;
         }
 
-        STACK_UNWIND_STRICT (fstat, frame, op_ret, op_errno, buf);
+        STACK_UNWIND_STRICT (fstat, frame, op_ret, op_errno, buf, xdata);
 out:
         gf_quiesce_local_wipe (this, local);
 
@@ -437,7 +438,7 @@ out:
 
 int32_t
 quiesce_opendir_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                     int32_t op_ret, int32_t op_errno, fd_t *fd)
+                     int32_t op_ret, int32_t op_errno, fd_t *fd, dict_t *xdata)
 {
         call_stub_t    *stub = NULL;
         quiesce_local_t *local = NULL;
@@ -447,10 +448,10 @@ quiesce_opendir_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
         if ((op_ret == -1) && (op_errno == ENOTCONN)) {
                 /* Re-transmit (by putting in the queue) */
                 stub = fop_opendir_stub (frame, default_opendir_resume,
-                                         &local->loc, local->fd);
+                                         &local->loc, local->fd, xdata);
                 if (!stub) {
                         STACK_UNWIND_STRICT (opendir, frame, -1, ENOMEM,
-                                             NULL);
+                                             NULL, NULL);
                         goto out;
                 }
 
@@ -458,7 +459,7 @@ quiesce_opendir_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
                 goto out;
         }
 
-        STACK_UNWIND_STRICT (opendir, frame, op_ret, op_errno, fd);
+        STACK_UNWIND_STRICT (opendir, frame, op_ret, op_errno, fd, xdata);
 out:
         gf_quiesce_local_wipe (this, local);
 
@@ -467,7 +468,7 @@ out:
 
 int32_t
 quiesce_fsyncdir_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                      int32_t op_ret, int32_t op_errno)
+                      int32_t op_ret, int32_t op_errno, dict_t *xdata)
 {
         call_stub_t    *stub = NULL;
         quiesce_local_t *local = NULL;
@@ -477,9 +478,9 @@ quiesce_fsyncdir_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
         if ((op_ret == -1) && (op_errno == ENOTCONN)) {
                 /* Re-transmit (by putting in the queue) */
                 stub = fop_fsyncdir_stub (frame, default_fsyncdir_resume,
-                                          local->fd, local->flag);
+                                          local->fd, local->flag, xdata);
                 if (!stub) {
-                        STACK_UNWIND_STRICT (fsyncdir, frame, -1, ENOMEM);
+                        STACK_UNWIND_STRICT (fsyncdir, frame, -1, ENOMEM, NULL);
                         goto out;
                 }
 
@@ -487,7 +488,7 @@ quiesce_fsyncdir_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
                 goto out;
         }
 
-        STACK_UNWIND_STRICT (fsyncdir, frame, op_ret, op_errno);
+        STACK_UNWIND_STRICT (fsyncdir, frame, op_ret, op_errno, xdata);
 out:
         gf_quiesce_local_wipe (this, local);
 
@@ -496,7 +497,7 @@ out:
 
 int32_t
 quiesce_statfs_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                    int32_t op_ret, int32_t op_errno, struct statvfs *buf)
+                    int32_t op_ret, int32_t op_errno, struct statvfs *buf, dict_t *xdata)
 {
         call_stub_t    *stub = NULL;
         quiesce_local_t *local = NULL;
@@ -506,10 +507,10 @@ quiesce_statfs_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
         if ((op_ret == -1) && (op_errno == ENOTCONN)) {
                 /* Re-transmit (by putting in the queue) */
                 stub = fop_statfs_stub (frame, default_statfs_resume,
-                                        &local->loc);
+                                        &local->loc, xdata);
                 if (!stub) {
                         STACK_UNWIND_STRICT (statfs, frame, -1, ENOMEM,
-                                             NULL);
+                                             NULL, NULL);
                         goto out;
                 }
 
@@ -517,7 +518,7 @@ quiesce_statfs_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
                 goto out;
         }
 
-        STACK_UNWIND_STRICT (statfs, frame, op_ret, op_errno, buf);
+        STACK_UNWIND_STRICT (statfs, frame, op_ret, op_errno, buf, xdata);
 out:
         gf_quiesce_local_wipe (this, local);
 
@@ -526,7 +527,7 @@ out:
 
 int32_t
 quiesce_fgetxattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                       int32_t op_ret, int32_t op_errno, dict_t *dict)
+                       int32_t op_ret, int32_t op_errno, dict_t *dict, dict_t *xdata)
 {
         call_stub_t    *stub = NULL;
         quiesce_local_t *local = NULL;
@@ -536,10 +537,10 @@ quiesce_fgetxattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
         if ((op_ret == -1) && (op_errno == ENOTCONN)) {
                 /* Re-transmit (by putting in the queue) */
                 stub = fop_fgetxattr_stub (frame, default_fgetxattr_resume,
-                                           local->fd, local->name);
+                                           local->fd, local->name, xdata);
                 if (!stub) {
                         STACK_UNWIND_STRICT (fgetxattr, frame, -1, ENOMEM,
-                                             NULL);
+                                             NULL, NULL);
                         goto out;
                 }
 
@@ -547,7 +548,7 @@ quiesce_fgetxattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
                 goto out;
         }
 
-        STACK_UNWIND_STRICT (fgetxattr, frame, op_ret, op_errno, dict);
+        STACK_UNWIND_STRICT (fgetxattr, frame, op_ret, op_errno, dict, xdata);
 out:
         gf_quiesce_local_wipe (this, local);
 
@@ -557,7 +558,7 @@ out:
 
 int32_t
 quiesce_getxattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                      int32_t op_ret, int32_t op_errno, dict_t *dict)
+                      int32_t op_ret, int32_t op_errno, dict_t *dict, dict_t *xdata)
 {
         call_stub_t    *stub = NULL;
         quiesce_local_t *local = NULL;
@@ -567,10 +568,10 @@ quiesce_getxattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
         if ((op_ret == -1) && (op_errno == ENOTCONN)) {
                 /* Re-transmit (by putting in the queue) */
                 stub = fop_getxattr_stub (frame, default_getxattr_resume,
-                                          &local->loc, local->name);
+                                          &local->loc, local->name, xdata);
                 if (!stub) {
                         STACK_UNWIND_STRICT (getxattr, frame, -1, ENOMEM,
-                                             NULL);
+                                             NULL, NULL);
                         goto out;
                 }
 
@@ -578,7 +579,7 @@ quiesce_getxattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
                 goto out;
         }
 
-        STACK_UNWIND_STRICT (getxattr, frame, op_ret, op_errno, dict);
+        STACK_UNWIND_STRICT (getxattr, frame, op_ret, op_errno, dict, xdata);
 out:
         gf_quiesce_local_wipe (this, local);
 
@@ -589,7 +590,7 @@ out:
 int32_t
 quiesce_rchecksum_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
                        int32_t op_ret, int32_t op_errno, uint32_t weak_checksum,
-                       uint8_t *strong_checksum)
+                       uint8_t *strong_checksum, dict_t *xdata)
 {
         call_stub_t    *stub = NULL;
         quiesce_local_t *local = NULL;
@@ -599,10 +600,10 @@ quiesce_rchecksum_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
         if ((op_ret == -1) && (op_errno == ENOTCONN)) {
                 /* Re-transmit (by putting in the queue) */
                 stub = fop_rchecksum_stub (frame, default_rchecksum_resume,
-                                           local->fd, local->offset, local->flag);
+                                           local->fd, local->offset, local->flag, xdata);
                 if (!stub) {
                         STACK_UNWIND_STRICT (rchecksum, frame, -1, ENOMEM,
-                                             0, NULL);
+                                             0, NULL, NULL);
                         goto out;
                 }
 
@@ -611,7 +612,7 @@ quiesce_rchecksum_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
         }
 
         STACK_UNWIND_STRICT (rchecksum, frame, op_ret, op_errno, weak_checksum,
-                             strong_checksum);
+                             strong_checksum, xdata);
 out:
         gf_quiesce_local_wipe (this, local);
 
@@ -621,7 +622,7 @@ out:
 
 int32_t
 quiesce_readdir_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                     int32_t op_ret, int32_t op_errno, gf_dirent_t *entries)
+                     int32_t op_ret, int32_t op_errno, gf_dirent_t *entries, dict_t *xdata)
 {
         call_stub_t    *stub = NULL;
         quiesce_local_t *local = NULL;
@@ -631,10 +632,10 @@ quiesce_readdir_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
         if ((op_ret == -1) && (op_errno == ENOTCONN)) {
                 /* Re-transmit (by putting in the queue) */
                 stub = fop_readdir_stub (frame, default_readdir_resume,
-                                         local->fd, local->size, local->offset);
+                                         local->fd, local->size, local->offset, xdata);
                 if (!stub) {
                         STACK_UNWIND_STRICT (readdir, frame, -1, ENOMEM,
-                                             NULL);
+                                             NULL, NULL);
                         goto out;
                 }
 
@@ -642,7 +643,7 @@ quiesce_readdir_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
                 goto out;
         }
 
-        STACK_UNWIND_STRICT (readdir, frame, op_ret, op_errno, entries);
+        STACK_UNWIND_STRICT (readdir, frame, op_ret, op_errno, entries, xdata);
 out:
         gf_quiesce_local_wipe (this, local);
 
@@ -652,7 +653,7 @@ out:
 
 int32_t
 quiesce_readdirp_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                      int32_t op_ret, int32_t op_errno, gf_dirent_t *entries)
+                      int32_t op_ret, int32_t op_errno, gf_dirent_t *entries, dict_t *xdata)
 {
         call_stub_t    *stub = NULL;
         quiesce_local_t *local = NULL;
@@ -666,7 +667,7 @@ quiesce_readdirp_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
                                           local->dict);
                 if (!stub) {
                         STACK_UNWIND_STRICT (readdirp, frame, -1, ENOMEM,
-                                             NULL);
+                                             NULL, NULL);
                         goto out;
                 }
 
@@ -674,7 +675,7 @@ quiesce_readdirp_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
                 goto out;
         }
 
-        STACK_UNWIND_STRICT (readdirp, frame, op_ret, op_errno, entries);
+        STACK_UNWIND_STRICT (readdirp, frame, op_ret, op_errno, entries, xdata);
 out:
         gf_quiesce_local_wipe (this, local);
 
@@ -687,7 +688,7 @@ out:
 int32_t
 quiesce_writev_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
                     int32_t op_ret, int32_t op_errno, struct iatt *prebuf,
-                    struct iatt *postbuf)
+                    struct iatt *postbuf, dict_t *xdata)
 {
         quiesce_priv_t *priv = NULL;
         call_stub_t    *stub = NULL;
@@ -702,10 +703,10 @@ quiesce_writev_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
                 stub = fop_writev_stub (frame, default_writev_resume,
                                         local->fd, local->vector, local->flag,
                                         local->offset, local->io_flags,
-                                        local->iobref);
+                                        local->iobref, xdata);
                 if (!stub) {
                         STACK_UNWIND_STRICT (writev, frame, -1, ENOMEM,
-                                             NULL, NULL);
+                                             NULL, NULL, NULL);
                         goto out;
                 }
 
@@ -713,7 +714,7 @@ quiesce_writev_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
                 goto out;
         }
 
-        STACK_UNWIND_STRICT (writev, frame, op_ret, op_errno, prebuf, postbuf);
+        STACK_UNWIND_STRICT (writev, frame, op_ret, op_errno, prebuf, postbuf, xdata);
 out:
         gf_quiesce_local_wipe (this, local);
 
@@ -722,7 +723,7 @@ out:
 
 int32_t
 quiesce_xattrop_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                     int32_t op_ret, int32_t op_errno, dict_t *dict)
+                     int32_t op_ret, int32_t op_errno, dict_t *dict, dict_t *xdata)
 {
         quiesce_priv_t *priv = NULL;
         call_stub_t    *stub = NULL;
@@ -736,10 +737,10 @@ quiesce_xattrop_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
                 /* Re-transmit (by putting in the queue) */
                 stub = fop_xattrop_stub (frame, default_xattrop_resume,
                                          &local->loc, local->xattrop_flags,
-                                         local->dict);
+                                         local->dict, xdata);
                 if (!stub) {
                         STACK_UNWIND_STRICT (xattrop, frame, -1, ENOMEM,
-                                             NULL);
+                                             NULL, NULL);
                         goto out;
                 }
 
@@ -747,7 +748,7 @@ quiesce_xattrop_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
                 goto out;
         }
 
-        STACK_UNWIND_STRICT (xattrop, frame, op_ret, op_errno, dict);
+        STACK_UNWIND_STRICT (xattrop, frame, op_ret, op_errno, dict, xdata);
 out:
         gf_quiesce_local_wipe (this, local);
 
@@ -756,7 +757,7 @@ out:
 
 int32_t
 quiesce_fxattrop_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                      int32_t op_ret, int32_t op_errno, dict_t *dict)
+                      int32_t op_ret, int32_t op_errno, dict_t *dict, dict_t *xdata)
 {
         quiesce_priv_t *priv = NULL;
         call_stub_t    *stub = NULL;
@@ -770,10 +771,10 @@ quiesce_fxattrop_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
                 /* Re-transmit (by putting in the queue) */
                 stub = fop_fxattrop_stub (frame, default_fxattrop_resume,
                                           local->fd, local->xattrop_flags,
-                                          local->dict);
+                                          local->dict, xdata);
                 if (!stub) {
                         STACK_UNWIND_STRICT (fxattrop, frame, -1, ENOMEM,
-                                             NULL);
+                                             NULL, NULL);
                         goto out;
                 }
 
@@ -781,7 +782,7 @@ quiesce_fxattrop_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
                 goto out;
         }
 
-        STACK_UNWIND_STRICT (fxattrop, frame, op_ret, op_errno, dict);
+        STACK_UNWIND_STRICT (fxattrop, frame, op_ret, op_errno, dict, xdata);
 out:
         gf_quiesce_local_wipe (this, local);
 
@@ -790,7 +791,7 @@ out:
 
 int32_t
 quiesce_lk_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                int32_t op_ret, int32_t op_errno, struct gf_flock *lock)
+                int32_t op_ret, int32_t op_errno, struct gf_flock *lock, dict_t *xdata)
 {
         quiesce_priv_t *priv = NULL;
         call_stub_t    *stub = NULL;
@@ -803,10 +804,10 @@ quiesce_lk_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
         if ((op_ret == -1) && (op_errno == ENOTCONN)) {
                 /* Re-transmit (by putting in the queue) */
                 stub = fop_lk_stub (frame, default_lk_resume,
-                                    local->fd, local->flag, &local->flock);
+                                    local->fd, local->flag, &local->flock, xdata);
                 if (!stub) {
                         STACK_UNWIND_STRICT (lk, frame, -1, ENOMEM,
-                                             NULL);
+                                             NULL, NULL);
                         goto out;
                 }
 
@@ -814,7 +815,7 @@ quiesce_lk_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
                 goto out;
         }
 
-        STACK_UNWIND_STRICT (lk, frame, op_ret, op_errno, lock);
+        STACK_UNWIND_STRICT (lk, frame, op_ret, op_errno, lock, xdata);
 out:
         gf_quiesce_local_wipe (this, local);
 
@@ -823,7 +824,7 @@ out:
 
 int32_t
 quiesce_inodelk_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                     int32_t op_ret, int32_t op_errno)
+                     int32_t op_ret, int32_t op_errno, dict_t *xdata)
 {
         quiesce_priv_t *priv = NULL;
         call_stub_t    *stub = NULL;
@@ -837,9 +838,9 @@ quiesce_inodelk_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
                 /* Re-transmit (by putting in the queue) */
                 stub = fop_inodelk_stub (frame, default_inodelk_resume,
                                          local->volname, &local->loc,
-                                         local->flag, &local->flock);
+                                         local->flag, &local->flock, xdata);
                 if (!stub) {
-                        STACK_UNWIND_STRICT (inodelk, frame, -1, ENOMEM);
+                        STACK_UNWIND_STRICT (inodelk, frame, -1, ENOMEM, NULL);
                         goto out;
                 }
 
@@ -847,7 +848,7 @@ quiesce_inodelk_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
                 goto out;
         }
 
-        STACK_UNWIND_STRICT (inodelk, frame, op_ret, op_errno);
+        STACK_UNWIND_STRICT (inodelk, frame, op_ret, op_errno, xdata);
 out:
         gf_quiesce_local_wipe (this, local);
 
@@ -857,7 +858,7 @@ out:
 
 int32_t
 quiesce_finodelk_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                      int32_t op_ret, int32_t op_errno)
+                      int32_t op_ret, int32_t op_errno, dict_t *xdata)
 {
         quiesce_priv_t *priv = NULL;
         call_stub_t    *stub = NULL;
@@ -871,9 +872,9 @@ quiesce_finodelk_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
                 /* Re-transmit (by putting in the queue) */
                 stub = fop_finodelk_stub (frame, default_finodelk_resume,
                                          local->volname, local->fd,
-                                         local->flag, &local->flock);
+                                         local->flag, &local->flock, xdata);
                 if (!stub) {
-                        STACK_UNWIND_STRICT (finodelk, frame, -1, ENOMEM);
+                        STACK_UNWIND_STRICT (finodelk, frame, -1, ENOMEM, NULL);
                         goto out;
                 }
 
@@ -881,7 +882,7 @@ quiesce_finodelk_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
                 goto out;
         }
 
-        STACK_UNWIND_STRICT (finodelk, frame, op_ret, op_errno);
+        STACK_UNWIND_STRICT (finodelk, frame, op_ret, op_errno, xdata);
 out:
         gf_quiesce_local_wipe (this, local);
 
@@ -890,7 +891,7 @@ out:
 
 int32_t
 quiesce_entrylk_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                     int32_t op_ret, int32_t op_errno)
+                     int32_t op_ret, int32_t op_errno, dict_t *xdata)
 {
         quiesce_priv_t *priv = NULL;
         call_stub_t    *stub = NULL;
@@ -904,9 +905,9 @@ quiesce_entrylk_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
                 /* Re-transmit (by putting in the queue) */
                 stub = fop_entrylk_stub (frame, default_entrylk_resume,
                                          local->volname, &local->loc,
-                                         local->name, local->cmd, local->type);
+                                         local->name, local->cmd, local->type, xdata);
                 if (!stub) {
-                        STACK_UNWIND_STRICT (entrylk, frame, -1, ENOMEM);
+                        STACK_UNWIND_STRICT (entrylk, frame, -1, ENOMEM, NULL);
                         goto out;
                 }
 
@@ -914,7 +915,7 @@ quiesce_entrylk_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
                 goto out;
         }
 
-        STACK_UNWIND_STRICT (entrylk, frame, op_ret, op_errno);
+        STACK_UNWIND_STRICT (entrylk, frame, op_ret, op_errno, xdata);
 out:
         gf_quiesce_local_wipe (this, local);
 
@@ -923,7 +924,7 @@ out:
 
 int32_t
 quiesce_fentrylk_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                      int32_t op_ret, int32_t op_errno)
+                      int32_t op_ret, int32_t op_errno, dict_t *xdata)
 {
         quiesce_priv_t *priv = NULL;
         call_stub_t    *stub = NULL;
@@ -937,9 +938,9 @@ quiesce_fentrylk_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
                 /* Re-transmit (by putting in the queue) */
                 stub = fop_fentrylk_stub (frame, default_fentrylk_resume,
                                           local->volname, local->fd,
-                                          local->name, local->cmd, local->type);
+                                          local->name, local->cmd, local->type, xdata);
                 if (!stub) {
-                        STACK_UNWIND_STRICT (fentrylk, frame, -1, ENOMEM);
+                        STACK_UNWIND_STRICT (fentrylk, frame, -1, ENOMEM, NULL);
                         goto out;
                 }
 
@@ -947,7 +948,7 @@ quiesce_fentrylk_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
                 goto out;
         }
 
-        STACK_UNWIND_STRICT (fentrylk, frame, op_ret, op_errno);
+        STACK_UNWIND_STRICT (fentrylk, frame, op_ret, op_errno, xdata);
 out:
         gf_quiesce_local_wipe (this, local);
 
@@ -957,7 +958,7 @@ out:
 int32_t
 quiesce_setattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
                      int32_t op_ret, int32_t op_errno, struct iatt *statpre,
-                     struct iatt *statpost)
+                     struct iatt *statpost, dict_t *xdata)
 {
         quiesce_priv_t *priv = NULL;
         call_stub_t    *stub = NULL;
@@ -970,10 +971,10 @@ quiesce_setattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
         if ((op_ret == -1) && (op_errno == ENOTCONN)) {
                 /* Re-transmit (by putting in the queue) */
                 stub = fop_setattr_stub (frame, default_setattr_resume,
-                                         &local->loc, &local->stbuf, local->flag);
+                                         &local->loc, &local->stbuf, local->flag, xdata);
                 if (!stub) {
                         STACK_UNWIND_STRICT (setattr, frame, -1, ENOMEM,
-                                             NULL, NULL);
+                                             NULL, NULL, NULL);
                         goto out;
                 }
 
@@ -982,7 +983,7 @@ quiesce_setattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
         }
 
         STACK_UNWIND_STRICT (setattr, frame, op_ret, op_errno, statpre,
-                             statpost);
+                             statpost, xdata);
 out:
         gf_quiesce_local_wipe (this, local);
 
@@ -992,7 +993,7 @@ out:
 int32_t
 quiesce_fsetattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
                       int32_t op_ret, int32_t op_errno, struct iatt *statpre,
-                      struct iatt *statpost)
+                      struct iatt *statpost, dict_t *xdata)
 {
         quiesce_priv_t *priv = NULL;
         call_stub_t    *stub = NULL;
@@ -1006,10 +1007,10 @@ quiesce_fsetattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
         if ((op_ret == -1) && (op_errno == ENOTCONN)) {
                 /* Re-transmit (by putting in the queue) */
                 stub = fop_fsetattr_stub (frame, default_fsetattr_resume,
-                                          local->fd, &local->stbuf, local->flag);
+                                          local->fd, &local->stbuf, local->flag, xdata);
                 if (!stub) {
                         STACK_UNWIND_STRICT (fsetattr, frame, -1, ENOMEM,
-                                             NULL, NULL);
+                                             NULL, NULL, NULL);
                         goto out;
                 }
 
@@ -1018,7 +1019,7 @@ quiesce_fsetattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
         }
 
         STACK_UNWIND_STRICT (fsetattr, frame, op_ret, op_errno, statpre,
-                             statpost);
+                             statpost, xdata);
 out:
         gf_quiesce_local_wipe (this, local);
 
@@ -1036,7 +1037,7 @@ int32_t
 quiesce_removexattr (call_frame_t *frame,
 		     xlator_t *this,
 		     loc_t *loc,
-		     const char *name)
+		     const char *name, dict_t *xdata)
 {
 	quiesce_priv_t *priv = NULL;
         call_stub_t    *stub = NULL;
@@ -1049,14 +1050,14 @@ quiesce_removexattr (call_frame_t *frame,
                             FIRST_CHILD(this),
                             FIRST_CHILD(this)->fops->removexattr,
                             loc,
-                            name);
-	        return 0;
+                            name, xdata);
+                return 0;
         }
 
         stub = fop_removexattr_stub (frame, default_removexattr_resume,
-                                     loc, name);
+                                     loc, name, xdata);
         if (!stub) {
-                STACK_UNWIND_STRICT (removexattr, frame, -1, ENOMEM);
+                STACK_UNWIND_STRICT (removexattr, frame, -1, ENOMEM, NULL);
                 return 0;
         }
 
@@ -1069,7 +1070,7 @@ int32_t
 quiesce_truncate (call_frame_t *frame,
 		  xlator_t *this,
 		  loc_t *loc,
-		  off_t offset)
+		  off_t offset, dict_t *xdata)
 {
 	quiesce_priv_t *priv = NULL;
         call_stub_t    *stub = NULL;
@@ -1082,13 +1083,13 @@ quiesce_truncate (call_frame_t *frame,
                             FIRST_CHILD(this),
                             FIRST_CHILD(this)->fops->truncate,
                             loc,
-                            offset);
-	        return 0;
+                            offset, xdata);
+                return 0;
         }
 
-        stub = fop_truncate_stub (frame, default_truncate_resume, loc, offset);
+        stub = fop_truncate_stub (frame, default_truncate_resume, loc, offset, xdata);
         if (!stub) {
-                STACK_UNWIND_STRICT (truncate, frame, -1, ENOMEM, NULL, NULL);
+                STACK_UNWIND_STRICT (truncate, frame, -1, ENOMEM, NULL, NULL, NULL);
                 return 0;
         }
 
@@ -1102,7 +1103,7 @@ quiesce_fsetxattr (call_frame_t *frame,
                    xlator_t *this,
                    fd_t *fd,
                    dict_t *dict,
-                   int32_t flags)
+                   int32_t flags, dict_t *xdata)
 {
 	quiesce_priv_t *priv = NULL;
         call_stub_t    *stub = NULL;
@@ -1116,14 +1117,14 @@ quiesce_fsetxattr (call_frame_t *frame,
                             FIRST_CHILD(this)->fops->fsetxattr,
                             fd,
                             dict,
-                            flags);
-	        return 0;
+                            flags, xdata);
+                return 0;
         }
 
         stub = fop_fsetxattr_stub (frame, default_fsetxattr_resume,
-                                   fd, dict, flags);
+                                   fd, dict, flags, xdata);
         if (!stub) {
-                STACK_UNWIND_STRICT (fsetxattr, frame, -1, ENOMEM);
+                STACK_UNWIND_STRICT (fsetxattr, frame, -1, ENOMEM, NULL);
                 return 0;
         }
 
@@ -1137,7 +1138,7 @@ quiesce_setxattr (call_frame_t *frame,
 		  xlator_t *this,
 		  loc_t *loc,
 		  dict_t *dict,
-		  int32_t flags)
+		  int32_t flags, dict_t *xdata)
 {
 	quiesce_priv_t *priv = NULL;
         call_stub_t    *stub = NULL;
@@ -1151,14 +1152,14 @@ quiesce_setxattr (call_frame_t *frame,
                             FIRST_CHILD(this)->fops->setxattr,
                             loc,
                             dict,
-                            flags);
-	        return 0;
+                            flags, xdata);
+                return 0;
         }
 
         stub = fop_setxattr_stub (frame, default_setxattr_resume,
-                                  loc, dict, flags);
+                                  loc, dict, flags, xdata);
         if (!stub) {
-                STACK_UNWIND_STRICT (setxattr, frame, -1, ENOMEM);
+                STACK_UNWIND_STRICT (setxattr, frame, -1, ENOMEM, NULL);
                 return 0;
         }
 
@@ -1170,7 +1171,7 @@ quiesce_setxattr (call_frame_t *frame,
 int32_t
 quiesce_create (call_frame_t *frame, xlator_t *this,
 		loc_t *loc, int32_t flags, mode_t mode,
-                fd_t *fd, dict_t *params)
+                mode_t umask, fd_t *fd, dict_t *xdata)
 {
 	quiesce_priv_t *priv = NULL;
         call_stub_t    *stub = NULL;
@@ -1183,15 +1184,15 @@ quiesce_create (call_frame_t *frame, xlator_t *this,
                 STACK_WIND (frame, default_create_cbk,
                             FIRST_CHILD(this),
                             FIRST_CHILD(this)->fops->create,
-                            loc, (flags & ~O_APPEND), mode, fd, params);
-	        return 0;
+                            loc, (flags & ~O_APPEND), mode, umask, fd, xdata);
+                return 0;
         }
 
         stub = fop_create_stub (frame, default_create_resume,
-                                loc, (flags & ~O_APPEND), mode, fd, params);
+                                loc, (flags & ~O_APPEND), mode, umask, fd, xdata);
         if (!stub) {
                 STACK_UNWIND_STRICT (create, frame, -1, ENOMEM,
-                                     NULL, NULL, NULL, NULL, NULL);
+                                     NULL, NULL, NULL, NULL, NULL, NULL);
                 return 0;
         }
 
@@ -1204,7 +1205,7 @@ int32_t
 quiesce_link (call_frame_t *frame,
 	      xlator_t *this,
 	      loc_t *oldloc,
-	      loc_t *newloc)
+	      loc_t *newloc, dict_t *xdata)
 {
 	quiesce_priv_t *priv = NULL;
         call_stub_t    *stub = NULL;
@@ -1216,14 +1217,14 @@ quiesce_link (call_frame_t *frame,
                             default_link_cbk,
                             FIRST_CHILD(this),
                             FIRST_CHILD(this)->fops->link,
-                            oldloc, newloc);
-	        return 0;
+                            oldloc, newloc, xdata);
+                return 0;
         }
 
-        stub = fop_link_stub (frame, default_link_resume, oldloc, newloc);
+        stub = fop_link_stub (frame, default_link_resume, oldloc, newloc, xdata);
         if (!stub) {
                 STACK_UNWIND_STRICT (link, frame, -1, ENOMEM,
-                                     NULL, NULL, NULL, NULL);
+                                     NULL, NULL, NULL, NULL, NULL);
                 return 0;
         }
 
@@ -1236,7 +1237,7 @@ int32_t
 quiesce_rename (call_frame_t *frame,
 		xlator_t *this,
 		loc_t *oldloc,
-		loc_t *newloc)
+		loc_t *newloc, dict_t *xdata)
 {
 	quiesce_priv_t *priv = NULL;
         call_stub_t    *stub = NULL;
@@ -1248,14 +1249,14 @@ quiesce_rename (call_frame_t *frame,
                             default_rename_cbk,
                             FIRST_CHILD(this),
                             FIRST_CHILD(this)->fops->rename,
-                            oldloc, newloc);
-	        return 0;
+                            oldloc, newloc, xdata);
+                return 0;
         }
 
-        stub = fop_rename_stub (frame, default_rename_resume, oldloc, newloc);
+        stub = fop_rename_stub (frame, default_rename_resume, oldloc, newloc, xdata);
         if (!stub) {
                 STACK_UNWIND_STRICT (rename, frame, -1, ENOMEM,
-                                     NULL, NULL, NULL, NULL, NULL);
+                                     NULL, NULL, NULL, NULL, NULL, NULL);
                 return 0;
         }
 
@@ -1267,7 +1268,7 @@ quiesce_rename (call_frame_t *frame,
 
 int
 quiesce_symlink (call_frame_t *frame, xlator_t *this,
-		 const char *linkpath, loc_t *loc, dict_t *params)
+		 const char *linkpath, loc_t *loc, mode_t umask, dict_t *xdata)
 {
 	quiesce_priv_t *priv = NULL;
         call_stub_t    *stub = NULL;
@@ -1278,15 +1279,15 @@ quiesce_symlink (call_frame_t *frame, xlator_t *this,
                 STACK_WIND (frame, default_symlink_cbk,
                             FIRST_CHILD(this),
                             FIRST_CHILD(this)->fops->symlink,
-                            linkpath, loc, params);
-	        return 0;
+                            linkpath, loc, umask, xdata);
+                return 0;
         }
 
         stub = fop_symlink_stub (frame, default_symlink_resume,
-                                 linkpath, loc, params);
+                                 linkpath, loc, umask, xdata);
         if (!stub) {
                 STACK_UNWIND_STRICT (symlink, frame, -1, ENOMEM,
-                                     NULL, NULL, NULL, NULL);
+                                     NULL, NULL, NULL, NULL, NULL);
                 return 0;
         }
 
@@ -1297,7 +1298,7 @@ quiesce_symlink (call_frame_t *frame, xlator_t *this,
 
 
 int
-quiesce_rmdir (call_frame_t *frame, xlator_t *this, loc_t *loc, int flags)
+quiesce_rmdir (call_frame_t *frame, xlator_t *this, loc_t *loc, int flags, dict_t *xdata)
 {
 	quiesce_priv_t *priv = NULL;
         call_stub_t    *stub = NULL;
@@ -1308,13 +1309,13 @@ quiesce_rmdir (call_frame_t *frame, xlator_t *this, loc_t *loc, int flags)
                 STACK_WIND (frame, default_rmdir_cbk,
                             FIRST_CHILD(this),
                             FIRST_CHILD(this)->fops->rmdir,
-                            loc, flags);
-	        return 0;
+                            loc, flags, xdata);
+                return 0;
         }
 
-        stub = fop_rmdir_stub (frame, default_rmdir_resume, loc, flags);
+        stub = fop_rmdir_stub (frame, default_rmdir_resume, loc, flags, xdata);
         if (!stub) {
-                STACK_UNWIND_STRICT (rmdir, frame, -1, ENOMEM, NULL, NULL);
+                STACK_UNWIND_STRICT (rmdir, frame, -1, ENOMEM, NULL, NULL, NULL);
                 return 0;
         }
 
@@ -1326,7 +1327,7 @@ quiesce_rmdir (call_frame_t *frame, xlator_t *this, loc_t *loc, int flags)
 int32_t
 quiesce_unlink (call_frame_t *frame,
 		xlator_t *this,
-		loc_t *loc)
+		loc_t *loc, int xflag, dict_t *xdata)
 {
 	quiesce_priv_t *priv = NULL;
         call_stub_t    *stub = NULL;
@@ -1338,13 +1339,13 @@ quiesce_unlink (call_frame_t *frame,
                             default_unlink_cbk,
                             FIRST_CHILD(this),
                             FIRST_CHILD(this)->fops->unlink,
-                            loc);
-	        return 0;
+                            loc, xflag, xdata);
+                return 0;
         }
 
-        stub = fop_unlink_stub (frame, default_unlink_resume, loc);
+        stub = fop_unlink_stub (frame, default_unlink_resume, loc, xflag, xdata);
         if (!stub) {
-                STACK_UNWIND_STRICT (unlink, frame, -1, ENOMEM, NULL, NULL);
+                STACK_UNWIND_STRICT (unlink, frame, -1, ENOMEM, NULL, NULL, NULL);
                 return 0;
         }
 
@@ -1355,7 +1356,7 @@ quiesce_unlink (call_frame_t *frame,
 
 int
 quiesce_mkdir (call_frame_t *frame, xlator_t *this,
-	       loc_t *loc, mode_t mode, dict_t *params)
+	       loc_t *loc, mode_t mode, mode_t umask, dict_t *xdata)
 {
 	quiesce_priv_t *priv = NULL;
         call_stub_t    *stub = NULL;
@@ -1366,15 +1367,15 @@ quiesce_mkdir (call_frame_t *frame, xlator_t *this,
                 STACK_WIND (frame, default_mkdir_cbk,
                             FIRST_CHILD(this),
                             FIRST_CHILD(this)->fops->mkdir,
-                            loc, mode, params);
-	        return 0;
+                            loc, mode, umask, xdata);
+                return 0;
         }
 
         stub = fop_mkdir_stub (frame, default_mkdir_resume,
-                               loc, mode, params);
+                               loc, mode, umask, xdata);
         if (!stub) {
                 STACK_UNWIND_STRICT (mkdir, frame, -1, ENOMEM,
-                                     NULL, NULL, NULL, NULL);
+                                     NULL, NULL, NULL, NULL, NULL);
                 return 0;
         }
 
@@ -1386,7 +1387,7 @@ quiesce_mkdir (call_frame_t *frame, xlator_t *this,
 
 int
 quiesce_mknod (call_frame_t *frame, xlator_t *this,
-	       loc_t *loc, mode_t mode, dev_t rdev, dict_t *parms)
+	       loc_t *loc, mode_t mode, dev_t rdev, mode_t umask, dict_t *xdata)
 {
 	quiesce_priv_t *priv = NULL;
         call_stub_t    *stub = NULL;
@@ -1397,15 +1398,15 @@ quiesce_mknod (call_frame_t *frame, xlator_t *this,
                 STACK_WIND (frame, default_mknod_cbk,
                             FIRST_CHILD(this),
                             FIRST_CHILD(this)->fops->mknod,
-                            loc, mode, rdev, parms);
-	        return 0;
+                            loc, mode, rdev, umask, xdata);
+                return 0;
         }
 
         stub = fop_mknod_stub (frame, default_mknod_resume,
-                               loc, mode, rdev, parms);
+                               loc, mode, rdev, umask, xdata);
         if (!stub) {
                 STACK_UNWIND_STRICT (mknod, frame, -1, ENOMEM,
-                                     NULL, NULL, NULL, NULL);
+                                     NULL, NULL, NULL, NULL, NULL);
                 return 0;
         }
 
@@ -1418,7 +1419,7 @@ int32_t
 quiesce_ftruncate (call_frame_t *frame,
 		   xlator_t *this,
 		   fd_t *fd,
-		   off_t offset)
+		   off_t offset, dict_t *xdata)
 {
 	quiesce_priv_t *priv = NULL;
         call_stub_t    *stub = NULL;
@@ -1431,13 +1432,13 @@ quiesce_ftruncate (call_frame_t *frame,
                             FIRST_CHILD(this),
                             FIRST_CHILD(this)->fops->ftruncate,
                             fd,
-                            offset);
-	        return 0;
+                            offset, xdata);
+                return 0;
         }
 
-        stub = fop_ftruncate_stub (frame, default_ftruncate_resume, fd, offset);
+        stub = fop_ftruncate_stub (frame, default_ftruncate_resume, fd, offset, xdata);
         if (!stub) {
-                STACK_UNWIND_STRICT (ftruncate, frame, -1, ENOMEM, NULL, NULL);
+                STACK_UNWIND_STRICT (ftruncate, frame, -1, ENOMEM, NULL, NULL, NULL);
                 return 0;
         }
 
@@ -1452,7 +1453,7 @@ int32_t
 quiesce_readlink (call_frame_t *frame,
 		  xlator_t *this,
 		  loc_t *loc,
-		  size_t size)
+		  size_t size, dict_t *xdata)
 {
 	quiesce_priv_t *priv = NULL;
         call_stub_t    *stub = NULL;
@@ -1471,13 +1472,13 @@ quiesce_readlink (call_frame_t *frame,
                             FIRST_CHILD(this),
                             FIRST_CHILD(this)->fops->readlink,
                             loc,
-                            size);
-	        return 0;
+                            size, xdata);
+                return 0;
         }
 
-        stub = fop_readlink_stub (frame, default_readlink_resume, loc, size);
+        stub = fop_readlink_stub (frame, default_readlink_resume, loc, size, xdata);
         if (!stub) {
-                STACK_UNWIND_STRICT (readlink, frame, -1, ENOMEM, NULL, NULL);
+                STACK_UNWIND_STRICT (readlink, frame, -1, ENOMEM, NULL, NULL, NULL);
                 return 0;
         }
 
@@ -1491,7 +1492,7 @@ int32_t
 quiesce_access (call_frame_t *frame,
 		xlator_t *this,
 		loc_t *loc,
-		int32_t mask)
+		int32_t mask, dict_t *xdata)
 {
 	quiesce_priv_t *priv = NULL;
         call_stub_t    *stub = NULL;
@@ -1510,13 +1511,13 @@ quiesce_access (call_frame_t *frame,
                             FIRST_CHILD(this),
                             FIRST_CHILD(this)->fops->access,
                             loc,
-                            mask);
-	        return 0;
+                            mask, xdata);
+                return 0;
         }
 
-        stub = fop_access_stub (frame, default_access_resume, loc, mask);
+        stub = fop_access_stub (frame, default_access_resume, loc, mask, xdata);
         if (!stub) {
-                STACK_UNWIND_STRICT (access, frame, -1, ENOMEM);
+                STACK_UNWIND_STRICT (access, frame, -1, ENOMEM, NULL);
                 return 0;
         }
 
@@ -1529,7 +1530,7 @@ int32_t
 quiesce_fgetxattr (call_frame_t *frame,
                    xlator_t *this,
                    fd_t *fd,
-                   const char *name)
+                   const char *name, dict_t *xdata)
 {
         quiesce_priv_t *priv = NULL;
         call_stub_t    *stub = NULL;
@@ -1550,13 +1551,13 @@ quiesce_fgetxattr (call_frame_t *frame,
                             FIRST_CHILD(this),
                             FIRST_CHILD(this)->fops->fgetxattr,
                             fd,
-                            name);
+                            name, xdata);
                 return 0;
         }
 
-        stub = fop_fgetxattr_stub (frame, default_fgetxattr_resume, fd, name);
+        stub = fop_fgetxattr_stub (frame, default_fgetxattr_resume, fd, name, xdata);
         if (!stub) {
-                STACK_UNWIND_STRICT (fgetxattr, frame, -1, ENOMEM, NULL);
+                STACK_UNWIND_STRICT (fgetxattr, frame, -1, ENOMEM, NULL, NULL);
                 return 0;
         }
 
@@ -1568,7 +1569,7 @@ quiesce_fgetxattr (call_frame_t *frame,
 int32_t
 quiesce_statfs (call_frame_t *frame,
 		xlator_t *this,
-		loc_t *loc)
+		loc_t *loc, dict_t *xdata)
 {
 	quiesce_priv_t *priv = NULL;
         call_stub_t    *stub = NULL;
@@ -1585,13 +1586,13 @@ quiesce_statfs (call_frame_t *frame,
                             quiesce_statfs_cbk,
                             FIRST_CHILD(this),
                             FIRST_CHILD(this)->fops->statfs,
-                            loc);
-	        return 0;
+                            loc, xdata);
+                return 0;
         }
 
-        stub = fop_statfs_stub (frame, default_statfs_resume, loc);
+        stub = fop_statfs_stub (frame, default_statfs_resume, loc, xdata);
         if (!stub) {
-                STACK_UNWIND_STRICT (statfs, frame, -1, ENOMEM, NULL);
+                STACK_UNWIND_STRICT (statfs, frame, -1, ENOMEM, NULL, NULL);
                 return 0;
         }
 
@@ -1604,7 +1605,7 @@ int32_t
 quiesce_fsyncdir (call_frame_t *frame,
 		  xlator_t *this,
 		  fd_t *fd,
-		  int32_t flags)
+		  int32_t flags, dict_t *xdata)
 {
 	quiesce_priv_t *priv = NULL;
         call_stub_t    *stub = NULL;
@@ -1623,13 +1624,13 @@ quiesce_fsyncdir (call_frame_t *frame,
                             FIRST_CHILD(this),
                             FIRST_CHILD(this)->fops->fsyncdir,
                             fd,
-                            flags);
-	        return 0;
+                            flags, xdata);
+                return 0;
         }
 
-        stub = fop_fsyncdir_stub (frame, default_fsyncdir_resume, fd, flags);
+        stub = fop_fsyncdir_stub (frame, default_fsyncdir_resume, fd, flags, xdata);
         if (!stub) {
-                STACK_UNWIND_STRICT (fsyncdir, frame, -1, ENOMEM);
+                STACK_UNWIND_STRICT (fsyncdir, frame, -1, ENOMEM, NULL);
                 return 0;
         }
 
@@ -1641,7 +1642,7 @@ quiesce_fsyncdir (call_frame_t *frame,
 int32_t
 quiesce_opendir (call_frame_t *frame,
 		 xlator_t *this,
-		 loc_t *loc, fd_t *fd)
+		 loc_t *loc, fd_t *fd, dict_t *xdata)
 {
 	quiesce_priv_t *priv = NULL;
         call_stub_t    *stub = NULL;
@@ -1659,13 +1660,13 @@ quiesce_opendir (call_frame_t *frame,
                             quiesce_opendir_cbk,
                             FIRST_CHILD(this),
                             FIRST_CHILD(this)->fops->opendir,
-                            loc, fd);
-	        return 0;
+                            loc, fd, xdata);
+                return 0;
         }
 
-        stub = fop_opendir_stub (frame, default_opendir_resume, loc, fd);
+        stub = fop_opendir_stub (frame, default_opendir_resume, loc, fd, xdata);
         if (!stub) {
-                STACK_UNWIND_STRICT (opendir, frame, -1, ENOMEM, NULL);
+                STACK_UNWIND_STRICT (opendir, frame, -1, ENOMEM, NULL, NULL);
                 return 0;
         }
 
@@ -1677,7 +1678,7 @@ quiesce_opendir (call_frame_t *frame,
 int32_t
 quiesce_fstat (call_frame_t *frame,
 	       xlator_t *this,
-	       fd_t *fd)
+	       fd_t *fd, dict_t *xdata)
 {
 	quiesce_priv_t *priv = NULL;
         call_stub_t    *stub = NULL;
@@ -1694,13 +1695,13 @@ quiesce_fstat (call_frame_t *frame,
                             quiesce_fstat_cbk,
                             FIRST_CHILD(this),
                             FIRST_CHILD(this)->fops->fstat,
-                            fd);
-	        return 0;
+                            fd, xdata);
+                return 0;
         }
 
-        stub = fop_fstat_stub (frame, default_fstat_resume, fd);
+        stub = fop_fstat_stub (frame, default_fstat_resume, fd, xdata);
         if (!stub) {
-                STACK_UNWIND_STRICT (fstat, frame, -1, ENOMEM, NULL);
+                STACK_UNWIND_STRICT (fstat, frame, -1, ENOMEM, NULL, NULL);
                 return 0;
         }
 
@@ -1713,7 +1714,7 @@ int32_t
 quiesce_fsync (call_frame_t *frame,
 	       xlator_t *this,
 	       fd_t *fd,
-	       int32_t flags)
+	       int32_t flags, dict_t *xdata)
 {
 	quiesce_priv_t *priv = NULL;
         call_stub_t    *stub = NULL;
@@ -1732,13 +1733,13 @@ quiesce_fsync (call_frame_t *frame,
                             FIRST_CHILD(this),
                             FIRST_CHILD(this)->fops->fsync,
                             fd,
-                            flags);
-	        return 0;
+                            flags, xdata);
+                return 0;
         }
 
-        stub = fop_fsync_stub (frame, default_fsync_resume, fd, flags);
+        stub = fop_fsync_stub (frame, default_fsync_resume, fd, flags, xdata);
         if (!stub) {
-                STACK_UNWIND_STRICT (fsync, frame, -1, ENOMEM, NULL, NULL);
+                STACK_UNWIND_STRICT (fsync, frame, -1, ENOMEM, NULL, NULL, NULL);
                 return 0;
         }
 
@@ -1750,7 +1751,7 @@ quiesce_fsync (call_frame_t *frame,
 int32_t
 quiesce_flush (call_frame_t *frame,
 	       xlator_t *this,
-	       fd_t *fd)
+	       fd_t *fd, dict_t *xdata)
 {
 	quiesce_priv_t *priv = NULL;
         call_stub_t    *stub = NULL;
@@ -1767,13 +1768,13 @@ quiesce_flush (call_frame_t *frame,
                             quiesce_flush_cbk,
                             FIRST_CHILD(this),
                             FIRST_CHILD(this)->fops->flush,
-                            fd);
-	        return 0;
+                            fd, xdata);
+                return 0;
         }
 
-        stub = fop_flush_stub (frame, default_flush_resume, fd);
+        stub = fop_flush_stub (frame, default_flush_resume, fd, xdata);
         if (!stub) {
-                STACK_UNWIND_STRICT (flush, frame, -1, ENOMEM);
+                STACK_UNWIND_STRICT (flush, frame, -1, ENOMEM, NULL);
                 return 0;
         }
 
@@ -1789,7 +1790,7 @@ quiesce_writev (call_frame_t *frame,
 		struct iovec *vector,
 		int32_t count,
 		off_t off, uint32_t flags,
-                struct iobref *iobref)
+                struct iobref *iobref, dict_t *xdata)
 {
 	quiesce_priv_t *priv = NULL;
         call_stub_t    *stub = NULL;
@@ -1805,14 +1806,14 @@ quiesce_writev (call_frame_t *frame,
                             vector,
                             count,
                             off, flags,
-                            iobref);
-	        return 0;
+                            iobref, xdata);
+                return 0;
         }
 
         stub = fop_writev_stub (frame, default_writev_resume,
-                                fd, vector, count, off, flags, iobref);
+                                fd, vector, count, off, flags, iobref, xdata);
         if (!stub) {
-                STACK_UNWIND_STRICT (writev, frame, -1, ENOMEM, NULL, NULL);
+                STACK_UNWIND_STRICT (writev, frame, -1, ENOMEM, NULL, NULL, NULL);
                 return 0;
         }
 
@@ -1826,7 +1827,7 @@ quiesce_readv (call_frame_t *frame,
 	       xlator_t *this,
 	       fd_t *fd,
 	       size_t size,
-	       off_t offset, uint32_t flags)
+	       off_t offset, uint32_t flags, dict_t *xdata)
 {
 	quiesce_priv_t *priv = NULL;
         call_stub_t    *stub = NULL;
@@ -1848,15 +1849,15 @@ quiesce_readv (call_frame_t *frame,
                             FIRST_CHILD(this)->fops->readv,
                             fd,
                             size,
-                            offset, flags);
-	        return 0;
+                            offset, flags, xdata);
+                return 0;
         }
 
         stub = fop_readv_stub (frame, default_readv_resume, fd, size, offset,
-                               flags);
+                               flags, xdata);
         if (!stub) {
                 STACK_UNWIND_STRICT (readv, frame, -1, ENOMEM,
-                                     NULL, 0, NULL, NULL);
+                                     NULL, 0, NULL, NULL, NULL);
                 return 0;
         }
 
@@ -1871,7 +1872,7 @@ quiesce_open (call_frame_t *frame,
 	      xlator_t *this,
 	      loc_t *loc,
 	      int32_t flags, fd_t *fd,
-              int32_t wbflags)
+              dict_t *xdata)
 {
 	quiesce_priv_t *priv = NULL;
         call_stub_t    *stub = NULL;
@@ -1887,21 +1888,20 @@ quiesce_open (call_frame_t *frame,
                 /* Don't send O_APPEND below, as write() re-transmittions can
                    fail with O_APPEND */
                 local->flag = (flags & ~O_APPEND);
-                local->wbflags = wbflags;
                 frame->local = local;
 
                 STACK_WIND (frame,
                             quiesce_open_cbk,
                             FIRST_CHILD(this),
                             FIRST_CHILD(this)->fops->open,
-                            loc, (flags & ~O_APPEND), fd, wbflags);
-	        return 0;
+                            loc, (flags & ~O_APPEND), fd, xdata);
+                return 0;
         }
 
         stub = fop_open_stub (frame, default_open_resume, loc,
-                              (flags & ~O_APPEND), fd, wbflags);
+                              (flags & ~O_APPEND), fd, xdata);
         if (!stub) {
-                STACK_UNWIND_STRICT (open, frame, -1, ENOMEM, NULL);
+                STACK_UNWIND_STRICT (open, frame, -1, ENOMEM, NULL, NULL);
                 return 0;
         }
 
@@ -1914,7 +1914,7 @@ int32_t
 quiesce_getxattr (call_frame_t *frame,
 		  xlator_t *this,
 		  loc_t *loc,
-		  const char *name)
+		  const char *name, dict_t *xdata)
 {
 	quiesce_priv_t *priv = NULL;
         call_stub_t    *stub = NULL;
@@ -1935,13 +1935,13 @@ quiesce_getxattr (call_frame_t *frame,
                             FIRST_CHILD(this),
                             FIRST_CHILD(this)->fops->getxattr,
                             loc,
-                            name);
-	        return 0;
+                            name, xdata);
+                return 0;
         }
 
-        stub = fop_getxattr_stub (frame, default_getxattr_resume, loc, name);
+        stub = fop_getxattr_stub (frame, default_getxattr_resume, loc, name, xdata);
         if (!stub) {
-                STACK_UNWIND_STRICT (getxattr, frame, -1, ENOMEM, NULL);
+                STACK_UNWIND_STRICT (getxattr, frame, -1, ENOMEM, NULL, NULL);
                 return 0;
         }
 
@@ -1956,7 +1956,7 @@ quiesce_xattrop (call_frame_t *frame,
 		 xlator_t *this,
 		 loc_t *loc,
 		 gf_xattrop_flags_t flags,
-		 dict_t *dict)
+		 dict_t *dict, dict_t *xdata)
 {
 	quiesce_priv_t *priv = NULL;
         call_stub_t    *stub = NULL;
@@ -1970,14 +1970,14 @@ quiesce_xattrop (call_frame_t *frame,
                             FIRST_CHILD(this)->fops->xattrop,
                             loc,
                             flags,
-                            dict);
-	        return 0;
+                            dict, xdata);
+                return 0;
         }
 
         stub = fop_xattrop_stub (frame, default_xattrop_resume,
-                                 loc, flags, dict);
+                                 loc, flags, dict, xdata);
         if (!stub) {
-                STACK_UNWIND_STRICT (xattrop, frame, -1, ENOMEM, NULL);
+                STACK_UNWIND_STRICT (xattrop, frame, -1, ENOMEM, NULL, NULL);
                 return 0;
         }
 
@@ -1991,7 +1991,7 @@ quiesce_fxattrop (call_frame_t *frame,
 		  xlator_t *this,
 		  fd_t *fd,
 		  gf_xattrop_flags_t flags,
-		  dict_t *dict)
+		  dict_t *dict, dict_t *xdata)
 {
 	quiesce_priv_t *priv = NULL;
         call_stub_t    *stub = NULL;
@@ -2005,14 +2005,14 @@ quiesce_fxattrop (call_frame_t *frame,
                             FIRST_CHILD(this)->fops->fxattrop,
                             fd,
                             flags,
-                            dict);
-	        return 0;
+                            dict, xdata);
+                return 0;
         }
 
         stub = fop_fxattrop_stub (frame, default_fxattrop_resume,
-                                  fd, flags, dict);
+                                  fd, flags, dict, xdata);
         if (!stub) {
-                STACK_UNWIND_STRICT (fxattrop, frame, -1, ENOMEM, NULL);
+                STACK_UNWIND_STRICT (fxattrop, frame, -1, ENOMEM, NULL, NULL);
                 return 0;
         }
 
@@ -2026,7 +2026,7 @@ quiesce_lk (call_frame_t *frame,
 	    xlator_t *this,
 	    fd_t *fd,
 	    int32_t cmd,
-	    struct gf_flock *lock)
+	    struct gf_flock *lock, dict_t *xdata)
 {
 	quiesce_priv_t *priv = NULL;
         call_stub_t    *stub = NULL;
@@ -2040,13 +2040,13 @@ quiesce_lk (call_frame_t *frame,
                             FIRST_CHILD(this)->fops->lk,
                             fd,
                             cmd,
-                            lock);
-	        return 0;
+                            lock, xdata);
+                return 0;
         }
 
-        stub = fop_lk_stub (frame, default_lk_resume, fd, cmd, lock);
+        stub = fop_lk_stub (frame, default_lk_resume, fd, cmd, lock, xdata);
         if (!stub) {
-                STACK_UNWIND_STRICT (lk, frame, -1, ENOMEM, NULL);
+                STACK_UNWIND_STRICT (lk, frame, -1, ENOMEM, NULL, NULL);
                 return 0;
         }
 
@@ -2059,7 +2059,7 @@ quiesce_lk (call_frame_t *frame,
 int32_t
 quiesce_inodelk (call_frame_t *frame, xlator_t *this,
 		 const char *volume, loc_t *loc, int32_t cmd,
-                 struct gf_flock *lock)
+                 struct gf_flock *lock, dict_t *xdata)
 {
 	quiesce_priv_t *priv = NULL;
         call_stub_t    *stub = NULL;
@@ -2071,14 +2071,14 @@ quiesce_inodelk (call_frame_t *frame, xlator_t *this,
                             default_inodelk_cbk,
                             FIRST_CHILD(this),
                             FIRST_CHILD(this)->fops->inodelk,
-                            volume, loc, cmd, lock);
-	        return 0;
+                            volume, loc, cmd, lock, xdata);
+                return 0;
         }
 
         stub = fop_inodelk_stub (frame, default_inodelk_resume,
-                                 volume, loc, cmd, lock);
+                                 volume, loc, cmd, lock, xdata);
         if (!stub) {
-                STACK_UNWIND_STRICT (inodelk, frame, -1, ENOMEM);
+                STACK_UNWIND_STRICT (inodelk, frame, -1, ENOMEM, NULL);
                 return 0;
         }
 
@@ -2089,7 +2089,7 @@ quiesce_inodelk (call_frame_t *frame, xlator_t *this,
 
 int32_t
 quiesce_finodelk (call_frame_t *frame, xlator_t *this,
-		  const char *volume, fd_t *fd, int32_t cmd, struct gf_flock *lock)
+		  const char *volume, fd_t *fd, int32_t cmd, struct gf_flock *lock, dict_t *xdata)
 {
 	quiesce_priv_t *priv = NULL;
         call_stub_t    *stub = NULL;
@@ -2101,14 +2101,14 @@ quiesce_finodelk (call_frame_t *frame, xlator_t *this,
                             default_finodelk_cbk,
                             FIRST_CHILD(this),
                             FIRST_CHILD(this)->fops->finodelk,
-                            volume, fd, cmd, lock);
-	        return 0;
+                            volume, fd, cmd, lock, xdata);
+                return 0;
         }
 
         stub = fop_finodelk_stub (frame, default_finodelk_resume,
-                                  volume, fd, cmd, lock);
+                                  volume, fd, cmd, lock, xdata);
         if (!stub) {
-                STACK_UNWIND_STRICT (finodelk, frame, -1, ENOMEM);
+                STACK_UNWIND_STRICT (finodelk, frame, -1, ENOMEM, NULL);
                 return 0;
         }
 
@@ -2120,7 +2120,7 @@ quiesce_finodelk (call_frame_t *frame, xlator_t *this,
 int32_t
 quiesce_entrylk (call_frame_t *frame, xlator_t *this,
 		 const char *volume, loc_t *loc, const char *basename,
-		 entrylk_cmd cmd, entrylk_type type)
+		 entrylk_cmd cmd, entrylk_type type, dict_t *xdata)
 {
 	quiesce_priv_t *priv = NULL;
         call_stub_t    *stub = NULL;
@@ -2131,14 +2131,14 @@ quiesce_entrylk (call_frame_t *frame, xlator_t *this,
                 STACK_WIND (frame, default_entrylk_cbk,
                             FIRST_CHILD(this),
                             FIRST_CHILD(this)->fops->entrylk,
-                            volume, loc, basename, cmd, type);
-	        return 0;
+                            volume, loc, basename, cmd, type, xdata);
+                return 0;
         }
 
         stub = fop_entrylk_stub (frame, default_entrylk_resume,
-                                 volume, loc, basename, cmd, type);
+                                 volume, loc, basename, cmd, type, xdata);
         if (!stub) {
-                STACK_UNWIND_STRICT (entrylk, frame, -1, ENOMEM);
+                STACK_UNWIND_STRICT (entrylk, frame, -1, ENOMEM, NULL);
                 return 0;
         }
 
@@ -2150,7 +2150,7 @@ quiesce_entrylk (call_frame_t *frame, xlator_t *this,
 int32_t
 quiesce_fentrylk (call_frame_t *frame, xlator_t *this,
 		  const char *volume, fd_t *fd, const char *basename,
-		  entrylk_cmd cmd, entrylk_type type)
+		  entrylk_cmd cmd, entrylk_type type, dict_t *xdata)
 {
 	quiesce_priv_t *priv = NULL;
         call_stub_t    *stub = NULL;
@@ -2161,14 +2161,14 @@ quiesce_fentrylk (call_frame_t *frame, xlator_t *this,
                 STACK_WIND (frame, default_fentrylk_cbk,
                             FIRST_CHILD(this),
                             FIRST_CHILD(this)->fops->fentrylk,
-                            volume, fd, basename, cmd, type);
-	        return 0;
+                            volume, fd, basename, cmd, type, xdata);
+                return 0;
         }
 
         stub = fop_fentrylk_stub (frame, default_fentrylk_resume,
-                                  volume, fd, basename, cmd, type);
+                                  volume, fd, basename, cmd, type, xdata);
         if (!stub) {
-                STACK_UNWIND_STRICT (fentrylk, frame, -1, ENOMEM);
+                STACK_UNWIND_STRICT (fentrylk, frame, -1, ENOMEM, NULL);
                 return 0;
         }
 
@@ -2181,7 +2181,7 @@ int32_t
 quiesce_rchecksum (call_frame_t *frame,
                    xlator_t *this,
                    fd_t *fd, off_t offset,
-                   int32_t len)
+                   int32_t len, dict_t *xdata)
 {
 	quiesce_priv_t *priv = NULL;
         call_stub_t    *stub = NULL;
@@ -2200,14 +2200,14 @@ quiesce_rchecksum (call_frame_t *frame,
                             quiesce_rchecksum_cbk,
                             FIRST_CHILD(this),
                             FIRST_CHILD(this)->fops->rchecksum,
-                            fd, offset, len);
-	        return 0;
+                            fd, offset, len, xdata);
+                return 0;
         }
 
         stub = fop_rchecksum_stub (frame, default_rchecksum_resume,
-                                   fd, offset, len);
+                                   fd, offset, len, xdata);
         if (!stub) {
-                STACK_UNWIND_STRICT (rchecksum, frame, -1, ENOMEM, 0, NULL);
+                STACK_UNWIND_STRICT (rchecksum, frame, -1, ENOMEM, 0, NULL, NULL);
                 return 0;
         }
 
@@ -2222,7 +2222,7 @@ quiesce_readdir (call_frame_t *frame,
 		 xlator_t *this,
 		 fd_t *fd,
 		 size_t size,
-		 off_t off)
+		 off_t off, dict_t *xdata)
 {
 	quiesce_priv_t *priv = NULL;
         call_stub_t    *stub = NULL;
@@ -2241,13 +2241,13 @@ quiesce_readdir (call_frame_t *frame,
                             quiesce_readdir_cbk,
                             FIRST_CHILD(this),
                             FIRST_CHILD(this)->fops->readdir,
-                            fd, size, off);
-	        return 0;
+                            fd, size, off, xdata);
+                return 0;
         }
 
-        stub = fop_readdir_stub (frame, default_readdir_resume, fd, size, off);
+        stub = fop_readdir_stub (frame, default_readdir_resume, fd, size, off, xdata);
         if (!stub) {
-                STACK_UNWIND_STRICT (readdir, frame, -1, ENOMEM, NULL);
+                STACK_UNWIND_STRICT (readdir, frame, -1, ENOMEM, NULL, NULL);
                 return 0;
         }
 
@@ -2283,13 +2283,13 @@ quiesce_readdirp (call_frame_t *frame,
                             FIRST_CHILD(this),
                             FIRST_CHILD(this)->fops->readdirp,
                             fd, size, off, dict);
-	        return 0;
+                return 0;
         }
 
         stub = fop_readdirp_stub (frame, default_readdirp_resume, fd, size,
                                   off, dict);
         if (!stub) {
-                STACK_UNWIND_STRICT (readdirp, frame, -1, ENOMEM, NULL);
+                STACK_UNWIND_STRICT (readdirp, frame, -1, ENOMEM, NULL, NULL);
                 return 0;
         }
 
@@ -2303,7 +2303,7 @@ quiesce_setattr (call_frame_t *frame,
                  xlator_t *this,
                  loc_t *loc,
                  struct iatt *stbuf,
-                 int32_t valid)
+                 int32_t valid, dict_t *xdata)
 {
 	quiesce_priv_t *priv = NULL;
         call_stub_t    *stub = NULL;
@@ -2315,14 +2315,14 @@ quiesce_setattr (call_frame_t *frame,
                             default_setattr_cbk,
                             FIRST_CHILD (this),
                             FIRST_CHILD (this)->fops->setattr,
-                            loc, stbuf, valid);
-	        return 0;
+                            loc, stbuf, valid, xdata);
+                return 0;
         }
 
         stub = fop_setattr_stub (frame, default_setattr_resume,
-                                   loc, stbuf, valid);
+                                   loc, stbuf, valid, xdata);
         if (!stub) {
-                STACK_UNWIND_STRICT (setattr, frame, -1, ENOMEM, NULL, NULL);
+                STACK_UNWIND_STRICT (setattr, frame, -1, ENOMEM, NULL, NULL, NULL);
                 return 0;
         }
 
@@ -2335,7 +2335,7 @@ quiesce_setattr (call_frame_t *frame,
 int32_t
 quiesce_stat (call_frame_t *frame,
 	      xlator_t *this,
-	      loc_t *loc)
+	      loc_t *loc, dict_t *xdata)
 {
 	quiesce_priv_t *priv = NULL;
         call_stub_t    *stub = NULL;
@@ -2352,13 +2352,13 @@ quiesce_stat (call_frame_t *frame,
                             quiesce_stat_cbk,
                             FIRST_CHILD(this),
                             FIRST_CHILD(this)->fops->stat,
-                            loc);
-	        return 0;
+                            loc, xdata);
+                return 0;
         }
 
-        stub = fop_stat_stub (frame, default_stat_resume, loc);
+        stub = fop_stat_stub (frame, default_stat_resume, loc, xdata);
         if (!stub) {
-                STACK_UNWIND_STRICT (stat, frame, -1, ENOMEM, NULL);
+                STACK_UNWIND_STRICT (stat, frame, -1, ENOMEM, NULL, NULL);
                 return 0;
         }
 
@@ -2389,9 +2389,8 @@ quiesce_lookup (call_frame_t *frame,
                             quiesce_lookup_cbk,
                             FIRST_CHILD(this),
                             FIRST_CHILD(this)->fops->lookup,
-                            loc,
-                            xattr_req);
-	        return 0;
+                            loc, xattr_req);
+                return 0;
         }
 
         stub = fop_lookup_stub (frame, default_lookup_resume, loc, xattr_req);
@@ -2411,7 +2410,7 @@ quiesce_fsetattr (call_frame_t *frame,
                   xlator_t *this,
                   fd_t *fd,
                   struct iatt *stbuf,
-                  int32_t valid)
+                  int32_t valid, dict_t *xdata)
 {
 	quiesce_priv_t *priv = NULL;
         call_stub_t    *stub = NULL;
@@ -2423,14 +2422,14 @@ quiesce_fsetattr (call_frame_t *frame,
                             default_fsetattr_cbk,
                             FIRST_CHILD (this),
                             FIRST_CHILD (this)->fops->fsetattr,
-                            fd, stbuf, valid);
-	        return 0;
+                            fd, stbuf, valid, xdata);
+                return 0;
         }
 
         stub = fop_fsetattr_stub (frame, default_fsetattr_resume,
-                                  fd, stbuf, valid);
+                                  fd, stbuf, valid, xdata);
         if (!stub) {
-                STACK_UNWIND_STRICT (fsetattr, frame, -1, ENOMEM, NULL, NULL);
+                STACK_UNWIND_STRICT (fsetattr, frame, -1, ENOMEM, NULL, NULL, NULL);
                 return 0;
         }
 
diff --git a/xlators/features/quota/src/quota.c b/xlators/features/quota/src/quota.c
index 42bcc21836d..10b61721fb3 100644
--- a/xlators/features/quota/src/quota.c
+++ b/xlators/features/quota/src/quota.c
@@ -194,7 +194,8 @@ out:
 
 int32_t
 quota_validate_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                    int32_t op_ret, int32_t op_errno, dict_t *dict)
+                    int32_t op_ret, int32_t op_errno, dict_t *dict,
+                    dict_t *xdata)
 {
         quota_local_t     *local          = NULL;
         uint32_t           validate_count = 0, link_count = 0;
@@ -457,7 +458,7 @@ validate:
 
         STACK_WIND (frame, quota_validate_cbk, FIRST_CHILD(this),
                     FIRST_CHILD(this)->fops->getxattr, &local->validate_loc,
-                    QUOTA_SIZE_KEY);
+                    QUOTA_SIZE_KEY, NULL);
 
 loc_fill_failed:
         inode_unref (_inode);
@@ -803,7 +804,7 @@ out:
 int32_t
 quota_writev_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
                   int32_t op_ret, int32_t op_errno, struct iatt *prebuf,
-                  struct iatt *postbuf)
+                  struct iatt *postbuf, dict_t *xdata)
 {
         int32_t                  ret            = 0;
         uint64_t                 ctx_int        = 0;
@@ -847,7 +848,8 @@ quota_writev_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
         }
 
 out:
-        QUOTA_STACK_UNWIND (writev, frame, op_ret, op_errno, prebuf, postbuf);
+        QUOTA_STACK_UNWIND (writev, frame, op_ret, op_errno, prebuf, postbuf,
+                            xdata);
 
         return 0;
 }
@@ -856,7 +858,7 @@ out:
 int32_t
 quota_writev_helper (call_frame_t *frame, xlator_t *this, fd_t *fd,
                      struct iovec *vector, int32_t count, off_t off,
-                     uint32_t flags, struct iobref *iobref)
+                     uint32_t flags, struct iobref *iobref, dict_t *xdata)
 {
         quota_local_t *local    = NULL;
         int32_t        op_errno = EINVAL;
@@ -874,11 +876,11 @@ quota_writev_helper (call_frame_t *frame, xlator_t *this, fd_t *fd,
 
         STACK_WIND (frame, quota_writev_cbk, FIRST_CHILD(this),
                     FIRST_CHILD(this)->fops->writev, fd, vector, count, off,
-                    flags, iobref);
+                    flags, iobref, xdata);
         return 0;
 
 unwind:
-        QUOTA_STACK_UNWIND (writev, frame, -1, op_errno, NULL, NULL);
+        QUOTA_STACK_UNWIND (writev, frame, -1, op_errno, NULL, NULL, NULL);
         return 0;
 }
 
@@ -886,7 +888,7 @@ unwind:
 int32_t
 quota_writev (call_frame_t *frame, xlator_t *this, fd_t *fd,
               struct iovec *vector, int32_t count, off_t off,
-              uint32_t flags, struct iobref *iobref)
+              uint32_t flags, struct iobref *iobref, dict_t *xdata)
 {
         int32_t            ret     = -1, op_errno = EINVAL;
         int32_t            parents = 0;
@@ -918,7 +920,7 @@ quota_writev (call_frame_t *frame, xlator_t *this, fd_t *fd,
         }
 
         stub = fop_writev_stub (frame, quota_writev_helper, fd, vector, count,
-                                off, flags, iobref);
+                                off, flags, iobref, xdata);
         if (stub == NULL) {
                 op_errno = ENOMEM;
                 goto unwind;
@@ -967,7 +969,7 @@ quota_writev (call_frame_t *frame, xlator_t *this, fd_t *fd,
         return 0;
 
 unwind:
-        QUOTA_STACK_UNWIND (writev, frame, -1, op_errno, NULL, NULL);
+        QUOTA_STACK_UNWIND (writev, frame, -1, op_errno, NULL, NULL, NULL);
         return 0;
 }
 
@@ -976,17 +978,17 @@ int32_t
 quota_mkdir_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
                  int32_t op_ret, int32_t op_errno, inode_t *inode,
                  struct iatt *buf, struct iatt *preparent,
-                 struct iatt *postparent)
+                 struct iatt *postparent, dict_t *xdata)
 {
         QUOTA_STACK_UNWIND (mkdir, frame, op_ret, op_errno, inode,
-                            buf, preparent, postparent);
+                            buf, preparent, postparent, xdata);
         return 0;
 }
 
 
 int32_t
 quota_mkdir_helper (call_frame_t *frame, xlator_t *this, loc_t *loc,
-                    mode_t mode, dict_t *params)
+                    mode_t mode, mode_t umask, dict_t *xdata)
 {
         quota_local_t *local    = NULL;
         int32_t        op_errno = EINVAL;
@@ -1004,19 +1006,19 @@ quota_mkdir_helper (call_frame_t *frame, xlator_t *this, loc_t *loc,
         }
 
         STACK_WIND (frame, quota_mkdir_cbk, FIRST_CHILD(this),
-                    FIRST_CHILD(this)->fops->mkdir, loc, mode, params);
+                    FIRST_CHILD(this)->fops->mkdir, loc, mode, umask, xdata);
         return 0;
 
 unwind:
         QUOTA_STACK_UNWIND (mkdir, frame, -1, op_errno, NULL, NULL,
-                            NULL, NULL);
+                            NULL, NULL, NULL);
         return 0;
 }
 
 
 int32_t
 quota_mkdir (call_frame_t *frame, xlator_t *this, loc_t *loc, mode_t mode,
-             dict_t *params)
+             mode_t umask, dict_t *xdata)
 {
         int32_t        ret            = 0, op_errno = 0;
         quota_local_t *local          = NULL;
@@ -1039,7 +1041,8 @@ quota_mkdir (call_frame_t *frame, xlator_t *this, loc_t *loc, mode_t mode,
                 goto err;
         }
 
-        stub = fop_mkdir_stub (frame, quota_mkdir_helper, loc, mode, params);
+        stub = fop_mkdir_stub (frame, quota_mkdir_helper, loc, mode, umask,
+                               xdata);
         if (stub == NULL) {
                 op_errno = ENOMEM;
                 goto err;
@@ -1070,7 +1073,7 @@ quota_mkdir (call_frame_t *frame, xlator_t *this, loc_t *loc, mode_t mode,
         return 0;
 err:
         QUOTA_STACK_UNWIND (mkdir, frame, -1, op_errno, NULL, NULL, NULL,
-                            NULL);
+                            NULL, NULL);
 
         return 0;
 }
@@ -1080,7 +1083,7 @@ int32_t
 quota_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)
+                  struct iatt *postparent, dict_t *xdata)
 {
         int32_t            ret    = -1;
         quota_local_t     *local  = NULL;
@@ -1123,14 +1126,15 @@ unlock:
 
 unwind:
         QUOTA_STACK_UNWIND (create, frame, op_ret, op_errno, fd, inode, buf,
-                            preparent, postparent);
+                            preparent, postparent, xdata);
         return 0;
 }
 
 
 int32_t
 quota_create_helper (call_frame_t *frame, xlator_t *this, loc_t *loc,
-                     int32_t flags, mode_t mode, fd_t *fd, dict_t *params)
+                     int32_t flags, mode_t mode, mode_t umask, fd_t *fd,
+                     dict_t *xdata)
 {
         quota_local_t *local    = NULL;
         int32_t        op_errno = EINVAL;
@@ -1147,20 +1151,20 @@ quota_create_helper (call_frame_t *frame, xlator_t *this, loc_t *loc,
         }
 
         STACK_WIND (frame, quota_create_cbk, FIRST_CHILD(this),
-                    FIRST_CHILD(this)->fops->create, loc, flags, mode, fd,
-                    params);
+                    FIRST_CHILD(this)->fops->create, loc, flags, mode, umask,
+                    fd, xdata);
         return 0;
 
 unwind:
         QUOTA_STACK_UNWIND (create, frame, -1, op_errno, NULL, NULL,
-                            NULL, NULL, NULL);
+                            NULL, NULL, NULL, NULL);
         return 0;
 }
 
 
 int32_t
 quota_create (call_frame_t *frame, xlator_t *this, loc_t *loc, int32_t flags,
-              mode_t mode, fd_t *fd, dict_t *params)
+              mode_t mode, mode_t umask, fd_t *fd, dict_t *xdata)
 {
         int32_t            ret            = -1;
         quota_local_t     *local          = NULL;
@@ -1180,7 +1184,7 @@ quota_create (call_frame_t *frame, xlator_t *this, loc_t *loc, int32_t flags,
         }
 
         stub = fop_create_stub (frame, quota_create_helper, loc, flags, mode,
-                                fd, params);
+                                umask, fd, xdata);
         if (stub == NULL) {
                 goto err;
         }
@@ -1210,7 +1214,7 @@ quota_create (call_frame_t *frame, xlator_t *this, loc_t *loc, int32_t flags,
         return 0;
 err:
         QUOTA_STACK_UNWIND (create, frame, -1, ENOMEM, NULL, NULL, NULL, NULL,
-                            NULL);
+                            NULL, NULL);
 
         return 0;
 }
@@ -1219,7 +1223,7 @@ err:
 int32_t
 quota_unlink_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
                   int32_t op_ret, int32_t op_errno, struct iatt *preparent,
-                  struct iatt *postparent)
+                  struct iatt *postparent, dict_t *xdata)
 {
         quota_local_t     *local = NULL;
         quota_inode_ctx_t *ctx   = NULL;
@@ -1247,13 +1251,14 @@ quota_unlink_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
 
 out:
         QUOTA_STACK_UNWIND (unlink, frame, op_ret, op_errno, preparent,
-                            postparent);
+                            postparent, xdata);
         return 0;
 }
 
 
 int32_t
-quota_unlink (call_frame_t *frame, xlator_t *this, loc_t *loc)
+quota_unlink (call_frame_t *frame, xlator_t *this, loc_t *loc, int xflag,
+              dict_t *xdata)
 {
         int32_t        ret = 0;
         quota_local_t *local = NULL;
@@ -1272,13 +1277,13 @@ quota_unlink (call_frame_t *frame, xlator_t *this, loc_t *loc)
         }
 
         STACK_WIND (frame, quota_unlink_cbk, FIRST_CHILD(this),
-                    FIRST_CHILD(this)->fops->unlink, loc);
+                    FIRST_CHILD(this)->fops->unlink, loc, xflag, xdata);
 
         ret = 0;
 
 err:
         if (ret == -1) {
-                QUOTA_STACK_UNWIND (unlink, frame, -1, 0, NULL, NULL);
+                QUOTA_STACK_UNWIND (unlink, frame, -1, 0, NULL, NULL, NULL);
         }
 
         return 0;
@@ -1289,7 +1294,7 @@ int32_t
 quota_link_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
                 int32_t op_ret, int32_t op_errno, inode_t *inode,
                 struct iatt *buf, struct iatt *preparent,
-                struct iatt *postparent)
+                struct iatt *postparent, dict_t *xdata)
 {
         int32_t               ret          = -1;
         quota_local_t        *local        = NULL;
@@ -1354,7 +1359,7 @@ unlock:
 
 out:
         QUOTA_STACK_UNWIND (link, frame, op_ret, op_errno, inode, buf,
-                            preparent, postparent);
+                            preparent, postparent, xdata);
 
         return 0;
 }
@@ -1362,7 +1367,7 @@ out:
 
 int32_t
 quota_link_helper (call_frame_t *frame, xlator_t *this, loc_t *oldloc,
-                   loc_t *newloc)
+                   loc_t *newloc, dict_t *xdata)
 {
         quota_local_t *local    = NULL;
         int32_t        op_errno = EINVAL;
@@ -1380,18 +1385,19 @@ quota_link_helper (call_frame_t *frame, xlator_t *this, loc_t *oldloc,
         }
 
         STACK_WIND (frame, quota_link_cbk, FIRST_CHILD(this),
-                    FIRST_CHILD(this)->fops->link, oldloc, newloc);
+                    FIRST_CHILD(this)->fops->link, oldloc, newloc, xdata);
         return 0;
 
 unwind:
         QUOTA_STACK_UNWIND (link, frame, -1, op_errno, NULL, NULL,
-                            NULL, NULL);
+                            NULL, NULL, NULL);
         return 0;
 }
 
 
 int32_t
-quota_link (call_frame_t *frame, xlator_t *this, loc_t *oldloc, loc_t *newloc)
+quota_link (call_frame_t *frame, xlator_t *this, loc_t *oldloc, loc_t *newloc,
+            dict_t *xdata)
 {
         int32_t            ret   = -1, op_errno = ENOMEM;
         quota_local_t     *local = NULL;
@@ -1411,7 +1417,7 @@ quota_link (call_frame_t *frame, xlator_t *this, loc_t *oldloc, loc_t *newloc)
                 goto err;
         }
 
-        stub = fop_link_stub (frame, quota_link_helper, oldloc, newloc);
+        stub = fop_link_stub (frame, quota_link_helper, oldloc, newloc, xdata);
         if (stub == NULL) {
                 goto err;
         }
@@ -1454,7 +1460,7 @@ quota_link (call_frame_t *frame, xlator_t *this, loc_t *oldloc, loc_t *newloc)
 err:
         if (ret < 0) {
                 QUOTA_STACK_UNWIND (link, frame, -1, op_errno, NULL, NULL,
-                                    NULL, NULL);
+                                    NULL, NULL, NULL);
         }
 
         return 0;
@@ -1465,7 +1471,8 @@ int32_t
 quota_rename_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
                   int32_t op_ret, int32_t op_errno, struct iatt *buf,
                   struct iatt *preoldparent, struct iatt *postoldparent,
-                  struct iatt *prenewparent, struct iatt *postnewparent)
+                  struct iatt *prenewparent, struct iatt *postnewparent,
+                  dict_t *xdata)
 {
         int32_t               ret              = -1;
         quota_local_t        *local            = NULL;
@@ -1569,7 +1576,7 @@ unlock:
 
 out:
         QUOTA_STACK_UNWIND (rename, frame, op_ret, op_errno, buf, preoldparent,
-                            postoldparent, prenewparent, postnewparent);
+                            postoldparent, prenewparent, postnewparent, xdata);
 
         return 0;
 }
@@ -1577,7 +1584,7 @@ out:
 
 int32_t
 quota_rename_helper (call_frame_t *frame, xlator_t *this, loc_t *oldloc,
-                     loc_t *newloc)
+                     loc_t *newloc, dict_t *xdata)
 {
         quota_local_t *local    = NULL;
         int32_t        op_errno = EINVAL;
@@ -1595,19 +1602,19 @@ quota_rename_helper (call_frame_t *frame, xlator_t *this, loc_t *oldloc,
         }
 
         STACK_WIND (frame, quota_rename_cbk, FIRST_CHILD(this),
-                    FIRST_CHILD(this)->fops->rename, oldloc, newloc);
+                    FIRST_CHILD(this)->fops->rename, oldloc, newloc, xdata);
         return 0;
 
 unwind:
         QUOTA_STACK_UNWIND (rename, frame, -1, op_errno, NULL, NULL,
-                            NULL, NULL, NULL);
+                            NULL, NULL, NULL, NULL);
         return 0;
 }
 
 
 int32_t
 quota_rename (call_frame_t *frame, xlator_t *this, loc_t *oldloc,
-              loc_t *newloc)
+              loc_t *newloc, dict_t *xdata)
 {
         int32_t            ret            = -1, op_errno = ENOMEM;
         quota_local_t     *local          = NULL;
@@ -1633,7 +1640,8 @@ quota_rename (call_frame_t *frame, xlator_t *this, loc_t *oldloc,
                 goto err;
         }
 
-        stub = fop_rename_stub (frame, quota_rename_helper, oldloc, newloc);
+        stub = fop_rename_stub (frame, quota_rename_helper, oldloc, newloc,
+                                xdata);
         if (stub == NULL) {
                 goto err;
         }
@@ -1681,7 +1689,7 @@ quota_rename (call_frame_t *frame, xlator_t *this, loc_t *oldloc,
 err:
         if (ret == -1) {
                 QUOTA_STACK_UNWIND (rename, frame, -1, op_errno, NULL,
-                                    NULL, NULL, NULL, NULL);
+                                    NULL, NULL, NULL, NULL, NULL);
         }
 
         return 0;
@@ -1692,7 +1700,7 @@ int32_t
 quota_symlink_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
                    int32_t op_ret, int32_t op_errno, inode_t *inode,
                    struct iatt *buf, struct iatt *preparent,
-                   struct iatt *postparent)
+                   struct iatt *postparent, dict_t *xdata)
 {
         int64_t            size   = 0;
         quota_local_t     *local  = NULL;
@@ -1736,7 +1744,7 @@ quota_symlink_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
 
 out:
         QUOTA_STACK_UNWIND (symlink, frame, op_ret, op_errno, inode, buf,
-                            preparent, postparent);
+                            preparent, postparent, xdata);
 
         return 0;
 }
@@ -1744,7 +1752,7 @@ out:
 
 int
 quota_symlink_helper (call_frame_t *frame, xlator_t *this, const char *linkpath,
-                      loc_t *loc, dict_t *params)
+                      loc_t *loc, mode_t umask, dict_t *xdata)
 {
         quota_local_t *local    = NULL;
         int32_t        op_errno = EINVAL;
@@ -1761,19 +1769,20 @@ quota_symlink_helper (call_frame_t *frame, xlator_t *this, const char *linkpath,
         }
 
         STACK_WIND (frame, quota_symlink_cbk, FIRST_CHILD(this),
-                    FIRST_CHILD(this)->fops->symlink, linkpath, loc, params);
+                    FIRST_CHILD(this)->fops->symlink, linkpath, loc, umask,
+                    xdata);
         return 0;
 
 unwind:
         QUOTA_STACK_UNWIND (symlink, frame, -1, op_errno, NULL, NULL,
-                            NULL, NULL);
+                            NULL, NULL, NULL);
         return 0;
 }
 
 
 int
 quota_symlink (call_frame_t *frame, xlator_t *this, const char *linkpath,
-               loc_t *loc, dict_t *params)
+               loc_t *loc, mode_t umask, dict_t *xdata)
 {
         int32_t          ret      = -1;
         int32_t          op_errno = ENOMEM;
@@ -1796,7 +1805,7 @@ quota_symlink (call_frame_t *frame, xlator_t *this, const char *linkpath,
         local->link_count = 1;
 
         stub = fop_symlink_stub (frame, quota_symlink_helper, linkpath, loc,
-                                 params);
+                                 umask, xdata);
         if (stub == NULL) {
                 goto err;
         }
@@ -1827,7 +1836,7 @@ quota_symlink (call_frame_t *frame, xlator_t *this, const char *linkpath,
 
 err:
         QUOTA_STACK_UNWIND (symlink, frame, -1, op_errno, NULL, NULL, NULL,
-                            NULL);
+                            NULL, NULL);
 
         return 0;
 }
@@ -1836,7 +1845,7 @@ err:
 int32_t
 quota_truncate_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
                     int32_t op_ret, int32_t op_errno, struct iatt *prebuf,
-                    struct iatt *postbuf)
+                    struct iatt *postbuf, dict_t *xdata)
 {
         quota_local_t     *local = NULL;
         int64_t            delta = 0;
@@ -1873,13 +1882,14 @@ quota_truncate_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
 
 out:
         QUOTA_STACK_UNWIND (truncate, frame, op_ret, op_errno, prebuf,
-                            postbuf);
+                            postbuf, xdata);
         return 0;
 }
 
 
 int32_t
-quota_truncate (call_frame_t *frame, xlator_t *this, loc_t *loc, off_t offset)
+quota_truncate (call_frame_t *frame, xlator_t *this, loc_t *loc, off_t offset,
+                dict_t *xdata)
 {
         int32_t          ret   = -1;
         quota_local_t   *local = NULL;
@@ -1898,11 +1908,11 @@ quota_truncate (call_frame_t *frame, xlator_t *this, loc_t *loc, off_t offset)
         }
 
         STACK_WIND (frame, quota_truncate_cbk, FIRST_CHILD(this),
-                    FIRST_CHILD(this)->fops->truncate, loc, offset);
+                    FIRST_CHILD(this)->fops->truncate, loc, offset, xdata);
 
         return 0;
 err:
-        QUOTA_STACK_UNWIND (truncate, frame, -1, ENOMEM, NULL, NULL);
+        QUOTA_STACK_UNWIND (truncate, frame, -1, ENOMEM, NULL, NULL, NULL);
 
         return 0;
 }
@@ -1911,7 +1921,7 @@ err:
 int32_t
 quota_ftruncate_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
                      int32_t op_ret, int32_t op_errno, struct iatt *prebuf,
-                     struct iatt *postbuf)
+                     struct iatt *postbuf, dict_t *xdata)
 {
         quota_local_t     *local = NULL;
         int64_t            delta = 0;
@@ -1948,13 +1958,14 @@ quota_ftruncate_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
 
 out:
         QUOTA_STACK_UNWIND (ftruncate, frame, op_ret, op_errno, prebuf,
-                            postbuf);
+                            postbuf, xdata);
         return 0;
 }
 
 
 int32_t
-quota_ftruncate (call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset)
+quota_ftruncate (call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset,
+                 dict_t *xdata)
 {
         quota_local_t   *local = NULL;
 
@@ -1967,11 +1978,11 @@ quota_ftruncate (call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset)
         local->loc.inode = inode_ref (fd->inode);
 
         STACK_WIND (frame, quota_ftruncate_cbk, FIRST_CHILD(this),
-                    FIRST_CHILD(this)->fops->ftruncate, fd, offset);
+                    FIRST_CHILD(this)->fops->ftruncate, fd, offset, xdata);
 
         return 0;
 err:
-        QUOTA_STACK_UNWIND (ftruncate, frame, -1, ENOMEM, NULL, NULL);
+        QUOTA_STACK_UNWIND (ftruncate, frame, -1, ENOMEM, NULL, NULL, NULL);
 
         return 0;
 }
@@ -2006,7 +2017,7 @@ quota_send_dir_limit_to_cli (call_frame_t *frame, xlator_t *this,
 
         gf_log (this->name, GF_LOG_INFO, "str = %s", dir_limit);
 
-        QUOTA_STACK_UNWIND (getxattr, frame, 0, 0, dict);
+        QUOTA_STACK_UNWIND (getxattr, frame, 0, 0, dict, NULL);
 
         ret = 0;
 
@@ -2017,7 +2028,7 @@ out:
 
 int32_t
 quota_fgetxattr (call_frame_t *frame, xlator_t *this, fd_t *fd,
-                 const char *name)
+                 const char *name, dict_t *xdata)
 {
         int32_t ret     = 0;
 
@@ -2030,14 +2041,14 @@ quota_fgetxattr (call_frame_t *frame, xlator_t *this, fd_t *fd,
         }
 
         STACK_WIND (frame, default_fgetxattr_cbk, FIRST_CHILD(this),
-                    FIRST_CHILD(this)->fops->fgetxattr, fd, name);
+                    FIRST_CHILD(this)->fops->fgetxattr, fd, name, xdata);
         return 0;
 }
 
 
 int32_t
 quota_getxattr (call_frame_t *frame, xlator_t *this, loc_t *loc,
-                const char *name)
+                const char *name, dict_t *xdata)
 {
         int32_t ret     = 0;
 
@@ -2049,14 +2060,14 @@ quota_getxattr (call_frame_t *frame, xlator_t *this, loc_t *loc,
         }
 
         STACK_WIND (frame, default_getxattr_cbk, FIRST_CHILD(this),
-                    FIRST_CHILD(this)->fops->getxattr, loc, name);
+                    FIRST_CHILD(this)->fops->getxattr, loc, name, xdata);
         return 0;
 }
 
 
 int32_t
 quota_stat_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                int32_t op_ret, int32_t op_errno, struct iatt *buf)
+                int32_t op_ret, int32_t op_errno, struct iatt *buf, dict_t *xdata)
 {
         quota_local_t     *local = NULL;
         quota_inode_ctx_t *ctx   = NULL;
@@ -2088,13 +2099,13 @@ quota_stat_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
         UNLOCK (&ctx->lock);
 
 out:
-        QUOTA_STACK_UNWIND (stat, frame, op_ret, op_errno, buf);
+        QUOTA_STACK_UNWIND (stat, frame, op_ret, op_errno, buf, xdata);
         return 0;
 }
 
 
 int32_t
-quota_stat (call_frame_t *frame, xlator_t *this, loc_t *loc)
+quota_stat (call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *xdata)
 {
         quota_local_t *local = NULL;
         int32_t        ret   = -1;
@@ -2112,18 +2123,19 @@ quota_stat (call_frame_t *frame, xlator_t *this, loc_t *loc)
         }
 
         STACK_WIND (frame, quota_stat_cbk, FIRST_CHILD(this),
-                    FIRST_CHILD(this)->fops->stat, loc);
+                    FIRST_CHILD(this)->fops->stat, loc, xdata);
         return 0;
 
 unwind:
-        QUOTA_STACK_UNWIND (stat, frame, -1, ENOMEM, NULL);
+        QUOTA_STACK_UNWIND (stat, frame, -1, ENOMEM, NULL, NULL);
         return 0;
 }
 
 
 int32_t
 quota_fstat_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                 int32_t op_ret, int32_t op_errno, struct iatt *buf)
+                 int32_t op_ret, int32_t op_errno, struct iatt *buf,
+                 dict_t *xdata)
 {
         quota_local_t     *local = NULL;
         quota_inode_ctx_t *ctx   = NULL;
@@ -2155,13 +2167,13 @@ quota_fstat_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
         UNLOCK (&ctx->lock);
 
 out:
-        QUOTA_STACK_UNWIND (fstat, frame, op_ret, op_errno, buf);
+        QUOTA_STACK_UNWIND (fstat, frame, op_ret, op_errno, buf, xdata);
         return 0;
 }
 
 
 int32_t
-quota_fstat (call_frame_t *frame, xlator_t *this, fd_t *fd)
+quota_fstat (call_frame_t *frame, xlator_t *this, fd_t *fd, dict_t *xdata)
 {
         quota_local_t *local = NULL;
 
@@ -2175,11 +2187,11 @@ quota_fstat (call_frame_t *frame, xlator_t *this, fd_t *fd)
         local->loc.inode = inode_ref (fd->inode);
 
         STACK_WIND (frame, quota_fstat_cbk, FIRST_CHILD(this),
-                    FIRST_CHILD(this)->fops->fstat, fd);
+                    FIRST_CHILD(this)->fops->fstat, fd, xdata);
         return 0;
 
 unwind:
-        QUOTA_STACK_UNWIND (fstat, frame, -1, ENOMEM, NULL);
+        QUOTA_STACK_UNWIND (fstat, frame, -1, ENOMEM, NULL, NULL);
         return 0;
 }
 
@@ -2187,7 +2199,7 @@ unwind:
 int32_t
 quota_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)
+                    struct iatt *buf, dict_t *xdata)
 {
         quota_local_t     *local = NULL;
         quota_inode_ctx_t *ctx   = NULL;
@@ -2218,13 +2230,14 @@ quota_readlink_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
         UNLOCK (&ctx->lock);
 
 out:
-        QUOTA_STACK_UNWIND (readlink, frame, op_ret, op_errno, path, buf);
+        QUOTA_STACK_UNWIND (readlink, frame, op_ret, op_errno, path, buf, xdata);
         return 0;
 }
 
 
 int32_t
-quota_readlink (call_frame_t *frame, xlator_t *this, loc_t *loc, size_t size)
+quota_readlink (call_frame_t *frame, xlator_t *this, loc_t *loc, size_t size,
+                dict_t *xdata)
 {
         quota_local_t *local = NULL;
         int32_t        ret   = -1;
@@ -2243,11 +2256,11 @@ quota_readlink (call_frame_t *frame, xlator_t *this, loc_t *loc, size_t size)
         }
 
         STACK_WIND (frame, quota_readlink_cbk, FIRST_CHILD(this),
-                    FIRST_CHILD(this)->fops->readlink, loc, size);
+                    FIRST_CHILD(this)->fops->readlink, loc, size, xdata);
         return 0;
 
 unwind:
-        QUOTA_STACK_UNWIND (readlink, frame, -1, ENOMEM, NULL, NULL);
+        QUOTA_STACK_UNWIND (readlink, frame, -1, ENOMEM, NULL, NULL, NULL);
         return 0;
 }
 
@@ -2255,7 +2268,8 @@ unwind:
 int32_t
 quota_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 *buf, struct iobref *iobref)
+                 int32_t count, struct iatt *buf, struct iobref *iobref,
+                 dict_t *xdata)
 {
         quota_local_t     *local = NULL;
         quota_inode_ctx_t *ctx   = NULL;
@@ -2287,14 +2301,14 @@ quota_readv_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
 
 out:
         QUOTA_STACK_UNWIND (readv, frame, op_ret, op_errno, vector, count,
-                            buf, iobref);
+                            buf, iobref, xdata);
         return 0;
 }
 
 
 int32_t
 quota_readv (call_frame_t *frame, xlator_t *this, fd_t *fd, size_t size,
-             off_t offset, uint32_t flags)
+             off_t offset, uint32_t flags, dict_t *xdata)
 {
         quota_local_t *local = NULL;
 
@@ -2308,11 +2322,12 @@ quota_readv (call_frame_t *frame, xlator_t *this, fd_t *fd, size_t size,
         local->loc.inode = inode_ref (fd->inode);
 
         STACK_WIND (frame, quota_readv_cbk, FIRST_CHILD(this),
-                    FIRST_CHILD(this)->fops->readv, fd, size, offset, flags);
+                    FIRST_CHILD(this)->fops->readv, fd, size, offset, flags,
+                    xdata);
         return 0;
 
 unwind:
-        QUOTA_STACK_UNWIND (readv, frame, -1, ENOMEM, NULL, -1, NULL, NULL);
+        QUOTA_STACK_UNWIND (readv, frame, -1, ENOMEM, NULL, -1, NULL, NULL, NULL);
         return 0;
 }
 
@@ -2320,7 +2335,7 @@ unwind:
 int32_t
 quota_fsync_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
                  int32_t op_ret, int32_t op_errno, struct iatt *prebuf,
-                 struct iatt *postbuf)
+                 struct iatt *postbuf, dict_t *xdata)
 {
         quota_local_t     *local = NULL;
         quota_inode_ctx_t *ctx   = NULL;
@@ -2351,13 +2366,15 @@ quota_fsync_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
         UNLOCK (&ctx->lock);
 
 out:
-        QUOTA_STACK_UNWIND (fsync, frame, op_ret, op_errno, prebuf, postbuf);
+        QUOTA_STACK_UNWIND (fsync, frame, op_ret, op_errno, prebuf, postbuf,
+                            xdata);
         return 0;
 }
 
 
 int32_t
-quota_fsync (call_frame_t *frame, xlator_t *this, fd_t *fd, int32_t flags)
+quota_fsync (call_frame_t *frame, xlator_t *this, fd_t *fd, int32_t flags,
+             dict_t *xdata)
 {
         quota_local_t *local = NULL;
 
@@ -2371,11 +2388,11 @@ quota_fsync (call_frame_t *frame, xlator_t *this, fd_t *fd, int32_t flags)
         frame->local = local;
 
         STACK_WIND (frame, quota_fsync_cbk, FIRST_CHILD(this),
-                    FIRST_CHILD(this)->fops->fsync, fd, flags);
+                    FIRST_CHILD(this)->fops->fsync, fd, flags, xdata);
         return 0;
 
 unwind:
-        QUOTA_STACK_UNWIND (fsync, frame, -1, ENOMEM, NULL, NULL);
+        QUOTA_STACK_UNWIND (fsync, frame, -1, ENOMEM, NULL, NULL, NULL);
         return 0;
 
 }
@@ -2384,7 +2401,7 @@ unwind:
 int32_t
 quota_setattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
                    int32_t op_ret, int32_t op_errno, struct iatt *statpre,
-                   struct iatt *statpost)
+                   struct iatt *statpost, dict_t *xdata)
 {
         quota_local_t     *local = NULL;
         quota_inode_ctx_t *ctx   = NULL;
@@ -2417,14 +2434,14 @@ quota_setattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
 
 out:
         QUOTA_STACK_UNWIND (setattr, frame, op_ret, op_errno, statpre,
-                            statpost);
+                            statpost, xdata);
         return 0;
 }
 
 
 int32_t
 quota_setattr (call_frame_t *frame, xlator_t *this, loc_t *loc,
-               struct iatt *stbuf, int32_t valid)
+               struct iatt *stbuf, int32_t valid, dict_t *xdata)
 {
         quota_local_t *local = NULL;
         int32_t        ret   = -1;
@@ -2443,11 +2460,11 @@ quota_setattr (call_frame_t *frame, xlator_t *this, loc_t *loc,
         }
 
         STACK_WIND (frame, quota_setattr_cbk, FIRST_CHILD (this),
-                    FIRST_CHILD (this)->fops->setattr, loc, stbuf, valid);
+                    FIRST_CHILD (this)->fops->setattr, loc, stbuf, valid, xdata);
         return 0;
 
 unwind:
-        QUOTA_STACK_UNWIND (setattr, frame, -1, ENOMEM, NULL, NULL);
+        QUOTA_STACK_UNWIND (setattr, frame, -1, ENOMEM, NULL, NULL, NULL);
         return 0;
 }
 
@@ -2455,7 +2472,7 @@ unwind:
 int32_t
 quota_fsetattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
                     int32_t op_ret, int32_t op_errno, struct iatt *statpre,
-                    struct iatt *statpost)
+                    struct iatt *statpost, dict_t *xdata)
 {
         quota_local_t     *local = NULL;
         quota_inode_ctx_t *ctx   = NULL;
@@ -2487,14 +2504,14 @@ quota_fsetattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
 
 out:
         QUOTA_STACK_UNWIND (fsetattr, frame, op_ret, op_errno, statpre,
-                            statpost);
+                            statpost, xdata);
         return 0;
 }
 
 
 int32_t
 quota_fsetattr (call_frame_t *frame, xlator_t *this, fd_t *fd,
-                struct iatt *stbuf, int32_t valid)
+                struct iatt *stbuf, int32_t valid, dict_t *xdata)
 {
         quota_local_t *local = NULL;
 
@@ -2508,11 +2525,11 @@ quota_fsetattr (call_frame_t *frame, xlator_t *this, fd_t *fd,
         local->loc.inode = inode_ref (fd->inode);
 
         STACK_WIND (frame, quota_fsetattr_cbk, FIRST_CHILD (this),
-                    FIRST_CHILD (this)->fops->fsetattr, fd, stbuf, valid);
+                    FIRST_CHILD (this)->fops->fsetattr, fd, stbuf, valid, xdata);
         return 0;
 
 unwind:
-        QUOTA_STACK_UNWIND (fsetattr, frame, -1, ENOMEM, NULL, NULL);
+        QUOTA_STACK_UNWIND (fsetattr, frame, -1, ENOMEM, NULL, NULL, NULL);
         return 0;
 }
 
@@ -2521,7 +2538,7 @@ int32_t
 quota_mknod_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
                  int32_t op_ret, int32_t op_errno, inode_t *inode,
                  struct iatt *buf, struct iatt *preparent,
-                 struct iatt *postparent)
+                 struct iatt *postparent, dict_t *xdata)
 {
         int32_t            ret    = -1;
         quota_local_t     *local  = NULL;
@@ -2563,14 +2580,14 @@ unlock:
 
 unwind:
         QUOTA_STACK_UNWIND (mknod, frame, op_ret, op_errno, inode,
-                            buf, preparent, postparent);
+                            buf, preparent, postparent, xdata);
         return 0;
 }
 
 
 int
 quota_mknod_helper (call_frame_t *frame, xlator_t *this, loc_t *loc,
-                    mode_t mode, dev_t rdev, dict_t *parms)
+                    mode_t mode, dev_t rdev, mode_t umask, dict_t *xdata)
 {
         quota_local_t *local    = NULL;
         int32_t        op_errno = EINVAL;
@@ -2587,20 +2604,21 @@ quota_mknod_helper (call_frame_t *frame, xlator_t *this, loc_t *loc,
         }
 
         STACK_WIND (frame, quota_mknod_cbk, FIRST_CHILD(this),
-                    FIRST_CHILD(this)->fops->mknod, loc, mode, rdev, parms);
+                    FIRST_CHILD(this)->fops->mknod, loc, mode, rdev, umask,
+                    xdata);
 
         return 0;
 
 unwind:
         QUOTA_STACK_UNWIND (mknod, frame, -1, op_errno, NULL, NULL,
-                            NULL, NULL);
+                            NULL, NULL, NULL);
         return 0;
 }
 
 
 int
 quota_mknod (call_frame_t *frame, xlator_t *this, loc_t *loc, mode_t mode,
-             dev_t rdev, dict_t *parms)
+             dev_t rdev, mode_t umask, dict_t *xdata)
 {
         int32_t            ret            = -1;
         quota_local_t     *local          = NULL;
@@ -2620,7 +2638,7 @@ quota_mknod (call_frame_t *frame, xlator_t *this, loc_t *loc, mode_t mode,
         }
 
         stub = fop_mknod_stub (frame, quota_mknod_helper, loc, mode, rdev,
-                               parms);
+                               umask, xdata);
         if (stub == NULL) {
                 goto err;
         }
@@ -2649,22 +2667,23 @@ quota_mknod (call_frame_t *frame, xlator_t *this, loc_t *loc, mode_t mode,
 
         return 0;
 err:
-        QUOTA_STACK_UNWIND (mknod, frame, -1, ENOMEM, NULL, NULL, NULL, NULL);
+        QUOTA_STACK_UNWIND (mknod, frame, -1, ENOMEM, NULL, NULL, NULL, NULL,
+                            NULL);
 
         return 0;
 }
 
 int
 quota_setxattr_cbk (call_frame_t *frame, void *cookie,
-                    xlator_t *this, int op_ret, int op_errno)
+                    xlator_t *this, int op_ret, int op_errno, dict_t *xdata)
 {
-        QUOTA_STACK_UNWIND (setxattr, frame, op_ret, op_errno);
+        QUOTA_STACK_UNWIND (setxattr, frame, op_ret, op_errno, xdata);
         return 0;
 }
 
 int
 quota_setxattr (call_frame_t *frame, xlator_t *this,
-                loc_t *loc, dict_t *dict, int flags)
+                loc_t *loc, dict_t *dict, int flags, dict_t *xdata)
 {
         data_pair_t    *trav     = NULL;
         int             op_errno = EINVAL;
@@ -2680,24 +2699,24 @@ quota_setxattr (call_frame_t *frame, xlator_t *this,
         STACK_WIND (frame, quota_setxattr_cbk,
                     FIRST_CHILD(this),
                     FIRST_CHILD(this)->fops->setxattr,
-                    loc, dict, flags);
+                    loc, dict, flags, xdata);
         return 0;
 err:
-        QUOTA_STACK_UNWIND (setxattr, frame, op_ret, op_errno);
+        QUOTA_STACK_UNWIND (setxattr, frame, op_ret, op_errno, NULL);
         return 0;
 }
 
 int
 quota_fsetxattr_cbk (call_frame_t *frame, void *cookie,
-                     xlator_t *this, int op_ret, int op_errno)
+                     xlator_t *this, int op_ret, int op_errno, dict_t *xdata)
 {
-        QUOTA_STACK_UNWIND (fsetxattr, frame, op_ret, op_errno);
+        QUOTA_STACK_UNWIND (fsetxattr, frame, op_ret, op_errno, xdata);
         return 0;
 }
 
 int
 quota_fsetxattr (call_frame_t *frame, xlator_t *this, fd_t *fd,
-                 dict_t *dict, int flags)
+                 dict_t *dict, int flags, dict_t *xdata)
 {
         data_pair_t    *trav     = NULL;
         int32_t         op_ret   = -1;
@@ -2713,25 +2732,25 @@ quota_fsetxattr (call_frame_t *frame, xlator_t *this, fd_t *fd,
         STACK_WIND (frame, quota_fsetxattr_cbk,
                     FIRST_CHILD(this),
                     FIRST_CHILD(this)->fops->fsetxattr,
-                    fd, dict, flags);
+                    fd, dict, flags, xdata);
         return 0;
  err:
-        QUOTA_STACK_UNWIND (fsetxattr, frame, op_ret, op_errno);
+        QUOTA_STACK_UNWIND (fsetxattr, frame, op_ret, op_errno, NULL);
         return 0;
 }
 
 
 int
-quota_removexattr_cbk (call_frame_t *frame, void *cookie,
-                       xlator_t *this, int32_t op_ret, int32_t op_errno)
+quota_removexattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
+                       int32_t op_ret, int32_t op_errno, dict_t *xdata)
 {
-        QUOTA_STACK_UNWIND (removexattr, frame, op_ret, op_errno);
+        QUOTA_STACK_UNWIND (removexattr, frame, op_ret, op_errno, xdata);
         return 0;
 }
 
 int
 quota_removexattr (call_frame_t *frame, xlator_t *this,
-                   loc_t *loc, const char *name)
+                   loc_t *loc, const char *name, dict_t *xdata)
 {
         int32_t         op_errno = EINVAL;
 
@@ -2746,25 +2765,25 @@ quota_removexattr (call_frame_t *frame, xlator_t *this,
         STACK_WIND (frame, quota_removexattr_cbk,
                     FIRST_CHILD(this),
                     FIRST_CHILD(this)->fops->removexattr,
-                    loc, name);
+                    loc, name, xdata);
         return 0;
 err:
-        QUOTA_STACK_UNWIND (removexattr, frame, -1,  op_errno);
+        QUOTA_STACK_UNWIND (removexattr, frame, -1,  op_errno, NULL);
         return 0;
 }
 
 
 int
-quota_fremovexattr_cbk (call_frame_t *frame, void *cookie,
-                        xlator_t *this, int32_t op_ret, int32_t op_errno)
+quota_fremovexattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
+                        int32_t op_ret, int32_t op_errno, dict_t *xdata)
 {
-        QUOTA_STACK_UNWIND (fremovexattr, frame, op_ret, op_errno);
+        QUOTA_STACK_UNWIND (fremovexattr, frame, op_ret, op_errno, xdata);
         return 0;
 }
 
 int
 quota_fremovexattr (call_frame_t *frame, xlator_t *this,
-                    fd_t *fd, const char *name)
+                    fd_t *fd, const char *name, dict_t *xdata)
 {
         int32_t         op_ret   = -1;
         int32_t         op_errno = EINVAL;
@@ -2779,16 +2798,17 @@ quota_fremovexattr (call_frame_t *frame, xlator_t *this,
         STACK_WIND (frame, quota_fremovexattr_cbk,
                     FIRST_CHILD(this),
                     FIRST_CHILD(this)->fops->fremovexattr,
-                    fd, name);
+                    fd, name, xdata);
         return 0;
  err:
-        QUOTA_STACK_UNWIND (fremovexattr, frame, op_ret, op_errno);
+        QUOTA_STACK_UNWIND (fremovexattr, frame, op_ret, op_errno, NULL);
         return 0;
 }
 
 int32_t
 quota_statfs_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                  int32_t op_ret, int32_t op_errno, struct statvfs *buf)
+                  int32_t op_ret, int32_t op_errno, struct statvfs *buf,
+                  dict_t *xdata)
 {
 	inode_t            *root_inode = NULL;
         quota_priv_t       *priv       = NULL;
@@ -2853,13 +2873,13 @@ unwind:
 	if (root_inode) {
 		inode_unref(root_inode);
 	}
-        STACK_UNWIND_STRICT (statfs, frame, op_ret, op_errno, buf);
+        STACK_UNWIND_STRICT (statfs, frame, op_ret, op_errno, buf, xdata);
         return 0;
 }
 
 
 int32_t
-quota_statfs (call_frame_t *frame, xlator_t *this, loc_t *loc)
+quota_statfs (call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *xdata)
 {
 	inode_t *root_inode = NULL;
 
@@ -2868,7 +2888,7 @@ quota_statfs (call_frame_t *frame, xlator_t *this, loc_t *loc)
 		inode_ref(root_inode);
 		STACK_WIND_COOKIE (frame, quota_statfs_cbk, root_inode,
 				   FIRST_CHILD(this),
-				   FIRST_CHILD(this)->fops->statfs, loc);
+				   FIRST_CHILD(this)->fops->statfs, loc, xdata);
 	}
 	else {
 		/*
@@ -2881,7 +2901,7 @@ quota_statfs (call_frame_t *frame, xlator_t *this, loc_t *loc)
 		gf_log(this->name,GF_LOG_WARNING,
 		       "missing inode, cannot adjust for quota");
 		STACK_WIND (frame, default_statfs_cbk, FIRST_CHILD(this),
-			    FIRST_CHILD(this)->fops->statfs, loc);
+			    FIRST_CHILD(this)->fops->statfs, loc, xdata);
 	}
         return 0;
 }
@@ -2889,7 +2909,8 @@ quota_statfs (call_frame_t *frame, xlator_t *this, loc_t *loc)
 
 int
 quota_readdirp_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                    int op_ret, int op_errno, gf_dirent_t *entries)
+                    int op_ret, int op_errno, gf_dirent_t *entries,
+                    dict_t *xdata)
 {
         gf_dirent_t *entry = NULL;
 
@@ -2901,7 +2922,7 @@ quota_readdirp_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
         }
 
 unwind:
-        STACK_UNWIND_STRICT (readdirp, frame, op_ret, op_errno, entries);
+        STACK_UNWIND_STRICT (readdirp, frame, op_ret, op_errno, entries, xdata);
 
         return 0;
 }
@@ -2923,7 +2944,7 @@ quota_readdirp (call_frame_t *frame, xlator_t *this, fd_t *fd, size_t size,
                     fd, size, offset, dict);
         return 0;
 err:
-        STACK_UNWIND_STRICT (readdirp, frame, -1, EINVAL, NULL);
+        STACK_UNWIND_STRICT (readdirp, frame, -1, EINVAL, NULL, NULL);
         return 0;
 }
 
diff --git a/xlators/features/read-only/src/read-only-common.c b/xlators/features/read-only/src/read-only-common.c
index efd1750811f..dbb529ce5cb 100644
--- a/xlators/features/read-only/src/read-only-common.c
+++ b/xlators/features/read-only/src/read-only-common.c
@@ -27,220 +27,223 @@
 
 int32_t
 ro_xattrop (call_frame_t *frame, xlator_t *this, loc_t *loc,
-            gf_xattrop_flags_t flags, dict_t *dict)
+            gf_xattrop_flags_t flags, dict_t *dict, dict_t *xdata)
 {
-        STACK_UNWIND_STRICT (xattrop, frame, -1, EROFS, NULL);
+        STACK_UNWIND_STRICT (xattrop, frame, -1, EROFS, NULL, xdata);
         return 0;
 }
 
 int32_t
 ro_fxattrop (call_frame_t *frame, xlator_t *this,
-             fd_t *fd, gf_xattrop_flags_t flags, dict_t *dict)
+             fd_t *fd, gf_xattrop_flags_t flags, dict_t *dict, dict_t *xdata)
 {
-        STACK_UNWIND_STRICT (fxattrop, frame, -1, EROFS, NULL);
+        STACK_UNWIND_STRICT (fxattrop, frame, -1, EROFS, NULL, xdata);
         return 0;
 }
 
 int32_t
 ro_entrylk (call_frame_t *frame, xlator_t *this, const char *volume,
             loc_t *loc, const char *basename, entrylk_cmd cmd,
-            entrylk_type type)
+            entrylk_type type, dict_t *xdata)
 {
-        STACK_UNWIND_STRICT (entrylk, frame, -1, EROFS);
+        STACK_UNWIND_STRICT (entrylk, frame, -1, EROFS, xdata);
         return 0;
 }
 
 int32_t
 ro_fentrylk (call_frame_t *frame, xlator_t *this, const char *volume,
-             fd_t *fd, const char *basename, entrylk_cmd cmd, entrylk_type type)
+             fd_t *fd, const char *basename, entrylk_cmd cmd, entrylk_type type, dict_t *xdata)
 {
-        STACK_UNWIND_STRICT (fentrylk, frame, -1, EROFS);
+        STACK_UNWIND_STRICT (fentrylk, frame, -1, EROFS, xdata);
         return 0;
 }
 
 int32_t
 ro_inodelk (call_frame_t *frame, xlator_t *this, const char *volume,
-            loc_t *loc, int32_t cmd, struct gf_flock *lock)
+            loc_t *loc, int32_t cmd, struct gf_flock *lock, dict_t *xdata)
 {
-        STACK_UNWIND_STRICT (inodelk, frame, -1, EROFS);
+        STACK_UNWIND_STRICT (inodelk, frame, -1, EROFS, xdata);
         return 0;
 }
 
 int32_t
 ro_finodelk (call_frame_t *frame, xlator_t *this, const char *volume,
-             fd_t *fd, int32_t cmd, struct gf_flock *lock)
+             fd_t *fd, int32_t cmd, struct gf_flock *lock, dict_t *xdata)
 {
-        STACK_UNWIND_STRICT (finodelk, frame, -1, EROFS);
+        STACK_UNWIND_STRICT (finodelk, frame, -1, EROFS, xdata);
         return 0;
 }
 
 int32_t
 ro_lk (call_frame_t *frame, xlator_t *this, fd_t *fd, int cmd,
-       struct gf_flock *flock)
+       struct gf_flock *flock, dict_t *xdata)
 {
-        STACK_UNWIND_STRICT (lk, frame, -1, EROFS, NULL);
+        STACK_UNWIND_STRICT (lk, frame, -1, EROFS, NULL, xdata);
         return 0;
 }
 
 int32_t
 ro_setattr (call_frame_t *frame, xlator_t *this, loc_t *loc,
-            struct iatt *stbuf, int32_t valid)
+            struct iatt *stbuf, int32_t valid, dict_t *xdata)
 {
-        STACK_UNWIND_STRICT (setattr, frame, -1, EROFS, NULL, NULL);
+        STACK_UNWIND_STRICT (setattr, frame, -1, EROFS, NULL, NULL, xdata);
 	return 0;
 }
 
 int32_t
 ro_fsetattr (call_frame_t *frame, xlator_t *this, fd_t *fd,
-             struct iatt *stbuf, int32_t valid)
+             struct iatt *stbuf, int32_t valid, dict_t *xdata)
 {
-        STACK_UNWIND_STRICT (fsetattr, frame, -1, EROFS, NULL, NULL);
+        STACK_UNWIND_STRICT (fsetattr, frame, -1, EROFS, NULL, NULL, xdata);
         return 0;
 }
 
 
 int32_t
-ro_truncate (call_frame_t *frame, xlator_t *this, loc_t *loc, off_t offset)
+ro_truncate (call_frame_t *frame, xlator_t *this, loc_t *loc, off_t offset, dict_t *xdata)
 {
-        STACK_UNWIND_STRICT (truncate, frame, -1, EROFS, NULL, NULL);
+        STACK_UNWIND_STRICT (truncate, frame, -1, EROFS, NULL, NULL, xdata);
 	return 0;
 }
 
 int32_t
-ro_ftruncate (call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset)
+ro_ftruncate (call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset, dict_t *xdata)
 {
-        STACK_UNWIND_STRICT (ftruncate, frame, -1, EROFS, NULL, NULL);
+        STACK_UNWIND_STRICT (ftruncate, frame, -1, EROFS, NULL, NULL, xdata);
 	return 0;
 }
 
 int
 ro_mknod (call_frame_t *frame, xlator_t *this, loc_t *loc, mode_t mode,
-          dev_t rdev, dict_t *params)
+          dev_t rdev, mode_t umask, dict_t *xdata)
 {
-        STACK_UNWIND_STRICT (mknod, frame, -1, EROFS, NULL, NULL, NULL, NULL);
+        STACK_UNWIND_STRICT (mknod, frame, -1, EROFS, NULL, NULL, NULL, NULL, xdata);
         return 0;
 }
 
 
 int
 ro_mkdir (call_frame_t *frame, xlator_t *this, loc_t *loc, mode_t mode,
-          dict_t *params)
+          mode_t umask, dict_t *xdata)
 {
-        STACK_UNWIND_STRICT (mkdir, frame, -1, EROFS, NULL, NULL, NULL, NULL);
+        STACK_UNWIND_STRICT (mkdir, frame, -1, EROFS, NULL, NULL, NULL, NULL, xdata);
         return 0;
 }
 
 int32_t
-ro_unlink (call_frame_t *frame, xlator_t *this, loc_t *loc)
+ro_unlink (call_frame_t *frame, xlator_t *this, loc_t *loc, int xflag,
+           dict_t *xdata)
 {
-        STACK_UNWIND_STRICT (unlink, frame, -1, EROFS, NULL, NULL);
+        STACK_UNWIND_STRICT (unlink, frame, -1, EROFS, NULL, NULL, xdata);
         return 0;
 }
 
 
 int
-ro_rmdir (call_frame_t *frame, xlator_t *this, loc_t *loc, int flags)
+ro_rmdir (call_frame_t *frame, xlator_t *this, loc_t *loc, int flags,
+          dict_t *xdata)
 {
-        STACK_UNWIND_STRICT (rmdir, frame, -1, EROFS, NULL, NULL);
+        STACK_UNWIND_STRICT (rmdir, frame, -1, EROFS, NULL, NULL, xdata);
         return 0;
 }
 
 
 int
 ro_symlink (call_frame_t *frame, xlator_t *this, const char *linkpath,
-            loc_t *loc, dict_t *params)
+            loc_t *loc, mode_t umask, dict_t *xdata)
 {
-        STACK_UNWIND_STRICT (symlink, frame, -1, EROFS, NULL, NULL, NULL, NULL);
+        STACK_UNWIND_STRICT (symlink, frame, -1, EROFS, NULL, NULL, NULL,
+                             NULL, xdata);
         return 0;
 }
 
 
 
 int32_t
-ro_rename (call_frame_t *frame, xlator_t *this, loc_t *oldloc, loc_t *newloc)
+ro_rename (call_frame_t *frame, xlator_t *this, loc_t *oldloc, loc_t *newloc, dict_t *xdata)
 {
         STACK_UNWIND_STRICT (rename, frame, -1, EROFS, NULL, NULL, NULL, NULL,
-                             NULL);
+                             NULL, xdata);
         return 0;
 }
 
 
 int32_t
-ro_link (call_frame_t *frame, xlator_t *this, loc_t *oldloc, loc_t *newloc)
+ro_link (call_frame_t *frame, xlator_t *this, loc_t *oldloc, loc_t *newloc, dict_t *xdata)
 {
-        STACK_UNWIND_STRICT (link, frame, -1, EROFS, NULL, NULL, NULL, NULL);
+        STACK_UNWIND_STRICT (link, frame, -1, EROFS, NULL, NULL, NULL, NULL, xdata);
         return 0;
 }
 
 int32_t
 ro_create (call_frame_t *frame, xlator_t *this, loc_t *loc, int32_t flags,
-           mode_t mode, fd_t *fd, dict_t *params)
+           mode_t mode, mode_t umask, fd_t *fd, dict_t *xdata)
 {
         STACK_UNWIND_STRICT (create, frame, -1, EROFS, NULL, NULL, NULL,
-                             NULL, NULL);
+                             NULL, NULL, xdata);
         return 0;
 }
 
 
 static int32_t
 ro_open_cbk (call_frame_t *frame, void *cookie, xlator_t *this, int32_t op_ret,
-             int32_t op_errno, fd_t *fd)
+             int32_t op_errno, fd_t *fd, dict_t *xdata)
 {
-	STACK_UNWIND_STRICT (open, frame, op_ret, op_errno, fd);
+	STACK_UNWIND_STRICT (open, frame, op_ret, op_errno, fd, xdata);
 	return 0;
 }
 
 int32_t
 ro_open (call_frame_t *frame, xlator_t *this, loc_t *loc, int32_t flags,
-         fd_t *fd, int32_t wbflags)
+         fd_t *fd, dict_t *xdata)
 {
         if (((flags & O_ACCMODE) == O_WRONLY) ||
               ((flags & O_ACCMODE) == O_RDWR)) {
-                STACK_UNWIND_STRICT (open, frame, -1, EROFS, NULL);
+                STACK_UNWIND_STRICT (open, frame, -1, EROFS, NULL, xdata);
                 return 0;
 	}
 
 	STACK_WIND (frame, ro_open_cbk, FIRST_CHILD(this),
-                    FIRST_CHILD(this)->fops->open, loc, flags, fd, wbflags);
+                    FIRST_CHILD(this)->fops->open, loc, flags, fd, xdata);
 	return 0;
 }
 
 int32_t
 ro_fsetxattr (call_frame_t *frame, xlator_t *this, fd_t *fd, dict_t *dict,
-              int32_t flags)
+              int32_t flags, dict_t *xdata)
 {
-        STACK_UNWIND_STRICT (fsetxattr, frame, -1, EROFS);
+        STACK_UNWIND_STRICT (fsetxattr, frame, -1, EROFS, xdata);
 	return 0;
 }
 
 int32_t
-ro_fsyncdir (call_frame_t *frame, xlator_t *this, fd_t *fd, int32_t flags)
+ro_fsyncdir (call_frame_t *frame, xlator_t *this, fd_t *fd, int32_t flags, dict_t *xdata)
 {
-        STACK_UNWIND_STRICT (fsyncdir, frame, -1, EROFS);
+        STACK_UNWIND_STRICT (fsyncdir, frame, -1, EROFS, xdata);
 	return 0;
 }
 
 int32_t
 ro_writev (call_frame_t *frame, xlator_t *this, fd_t *fd, struct iovec *vector,
-           int32_t count, off_t off, uint32_t flags, struct iobref *iobref)
+           int32_t count, off_t off, uint32_t flags, struct iobref *iobref, dict_t *xdata)
 {
-        STACK_UNWIND_STRICT (writev, frame, -1, EROFS, NULL, NULL);
+        STACK_UNWIND_STRICT (writev, frame, -1, EROFS, NULL, NULL, xdata);
         return 0;
 }
 
 
 int32_t
 ro_setxattr (call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *dict,
-             int32_t flags)
+             int32_t flags, dict_t *xdata)
 {
-        STACK_UNWIND_STRICT (setxattr, frame, -1, EROFS);
+        STACK_UNWIND_STRICT (setxattr, frame, -1, EROFS, xdata);
         return 0;
 }
 
 int32_t
 ro_removexattr (call_frame_t *frame, xlator_t *this, loc_t *loc,
-                const char *name)
+                const char *name, dict_t *xdata)
 {
-        STACK_UNWIND_STRICT (removexattr, frame, -1, EROFS);
+        STACK_UNWIND_STRICT (removexattr, frame, -1, EROFS, xdata);
         return 0;
 }
diff --git a/xlators/features/read-only/src/read-only-common.h b/xlators/features/read-only/src/read-only-common.h
index 8c89e88ce68..0a3f7dceb41 100644
--- a/xlators/features/read-only/src/read-only-common.h
+++ b/xlators/features/read-only/src/read-only-common.h
@@ -27,97 +27,99 @@
 
 int32_t
 ro_xattrop (call_frame_t *frame, xlator_t *this, loc_t *loc,
-            gf_xattrop_flags_t flags, dict_t *dict);
+            gf_xattrop_flags_t flags, dict_t *dict, dict_t *xdata);
 
 int32_t
 ro_fxattrop (call_frame_t *frame, xlator_t *this,
-             fd_t *fd, gf_xattrop_flags_t flags, dict_t *dict);
+             fd_t *fd, gf_xattrop_flags_t flags, dict_t *dict, dict_t *xdata);
 
 int32_t
 ro_entrylk (call_frame_t *frame, xlator_t *this, const char *volume,
             loc_t *loc, const char *basename, entrylk_cmd cmd,
-            entrylk_type type);
+            entrylk_type type, dict_t *xdata);
 
 int32_t
 ro_fentrylk (call_frame_t *frame, xlator_t *this, const char *volume,
              fd_t *fd, const char *basename, entrylk_cmd cmd, entrylk_type
-             type);
+             type, dict_t *xdata);
 
 int32_t
 ro_inodelk (call_frame_t *frame, xlator_t *this, const char *volume,
-            loc_t *loc, int32_t cmd, struct gf_flock *lock);
+            loc_t *loc, int32_t cmd, struct gf_flock *lock, dict_t *xdata);
 
 int32_t
 ro_finodelk (call_frame_t *frame, xlator_t *this, const char *volume,
-             fd_t *fd, int32_t cmd, struct gf_flock *lock);
+             fd_t *fd, int32_t cmd, struct gf_flock *lock, dict_t *xdata);
 
 int32_t
 ro_lk (call_frame_t *frame, xlator_t *this, fd_t *fd, int cmd,
-       struct gf_flock *flock);
+       struct gf_flock *flock, dict_t *xdata);
 
 int32_t
 ro_setattr (call_frame_t *frame, xlator_t *this, loc_t *loc,
-            struct iatt *stbuf, int32_t valid);
+            struct iatt *stbuf, int32_t valid, dict_t *xdata);
 
 int32_t
 ro_fsetattr (call_frame_t *frame, xlator_t *this, fd_t *fd,
-             struct iatt *stbuf, int32_t valid);
+             struct iatt *stbuf, int32_t valid, dict_t *xdata);
 
 
 int32_t
-ro_truncate (call_frame_t *frame, xlator_t *this, loc_t *loc, off_t offset);
+ro_truncate (call_frame_t *frame, xlator_t *this, loc_t *loc, off_t offset, dict_t *xdata);
 
 int32_t
-ro_ftruncate (call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset);
+ro_ftruncate (call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset, dict_t *xdata);
 
 int
 ro_mknod (call_frame_t *frame, xlator_t *this, loc_t *loc, mode_t mode,
-          dev_t rdev, dict_t *params);
+          dev_t rdev, mode_t umask, dict_t *xdata);
 
 int
 ro_mkdir (call_frame_t *frame, xlator_t *this, loc_t *loc, mode_t mode,
-          dict_t *params);
+          mode_t umask, dict_t *xdata);
 
 int32_t
-ro_unlink (call_frame_t *frame, xlator_t *this, loc_t *loc);
+ro_unlink (call_frame_t *frame, xlator_t *this, loc_t *loc, int xflag,
+           dict_t *xdata);
 
 int
-ro_rmdir (call_frame_t *frame, xlator_t *this, loc_t *loc, int flags);
+ro_rmdir (call_frame_t *frame, xlator_t *this, loc_t *loc, int flags,
+          dict_t *xdata);
 
 
 int
 ro_symlink (call_frame_t *frame, xlator_t *this, const char *linkpath,
-            loc_t *loc, dict_t *params);
+            loc_t *loc, mode_t umask, dict_t *xdata);
 
 int32_t
-ro_rename (call_frame_t *frame, xlator_t *this, loc_t *oldloc, loc_t *newloc);
+ro_rename (call_frame_t *frame, xlator_t *this, loc_t *oldloc, loc_t *newloc, dict_t *xdata);
 
 int32_t
-ro_link (call_frame_t *frame, xlator_t *this, loc_t *oldloc, loc_t *newloc);
+ro_link (call_frame_t *frame, xlator_t *this, loc_t *oldloc, loc_t *newloc, dict_t *xdata);
 
 int32_t
 ro_create (call_frame_t *frame, xlator_t *this, loc_t *loc, int32_t flags,
-           mode_t mode, fd_t *fd, dict_t *params);
+           mode_t mode, mode_t umask, fd_t *fd, dict_t *xdata);
 
 int32_t
 ro_open (call_frame_t *frame, xlator_t *this, loc_t *loc, int32_t flags,
-         fd_t *fd, int32_t wbflags);
+         fd_t *fd, dict_t *xdata);
 
 int32_t
 ro_fsetxattr (call_frame_t *frame, xlator_t *this, fd_t *fd, dict_t *dict,
-              int32_t flags);
+              int32_t flags, dict_t *xdata);
 
 int32_t
-ro_fsyncdir (call_frame_t *frame, xlator_t *this, fd_t *fd, int32_t flags);
+ro_fsyncdir (call_frame_t *frame, xlator_t *this, fd_t *fd, int32_t flags, dict_t *xdata);
 
 int32_t
 ro_writev (call_frame_t *frame, xlator_t *this, fd_t *fd, struct iovec *vector,
-           int32_t count, off_t off, uint32_t flags, struct iobref *iobref);
+           int32_t count, off_t off, uint32_t flags, struct iobref *iobref, dict_t *xdata);
 
 int32_t
 ro_setxattr (call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *dict,
-             int32_t flags);
+             int32_t flags, dict_t *xdata);
 
 int32_t
 ro_removexattr (call_frame_t *frame, xlator_t *this, loc_t *loc,
-                const char *name);
+                const char *name, dict_t *xdata);
diff --git a/xlators/features/read-only/src/worm.c b/xlators/features/read-only/src/worm.c
index 790bc3234dd..d6c1e1b7dd0 100644
--- a/xlators/features/read-only/src/worm.c
+++ b/xlators/features/read-only/src/worm.c
@@ -28,25 +28,25 @@
 
 static int32_t
 worm_open_cbk (call_frame_t *frame, void *cookie, xlator_t *this, int32_t op_ret,
-             int32_t op_errno, fd_t *fd)
+               int32_t op_errno, fd_t *fd, dict_t *xdata)
 {
-        STACK_UNWIND_STRICT (open, frame, op_ret, op_errno, fd);
+        STACK_UNWIND_STRICT (open, frame, op_ret, op_errno, fd, xdata);
         return 0;
 }
 
 int32_t
 worm_open (call_frame_t *frame, xlator_t *this, loc_t *loc, int32_t flags,
-         fd_t *fd, int32_t wbflags)
+           fd_t *fd, dict_t *xdata)
 {
         if ((((flags & O_ACCMODE) == O_WRONLY) ||
               ((flags & O_ACCMODE) == O_RDWR)) &&
               !(flags & O_APPEND)) {
-                STACK_UNWIND_STRICT (open, frame, -1, EROFS, NULL);
+                STACK_UNWIND_STRICT (open, frame, -1, EROFS, NULL, NULL);
                 return 0;
         }
 
         STACK_WIND (frame, worm_open_cbk, FIRST_CHILD(this),
-                    FIRST_CHILD(this)->fops->open, loc, flags, fd, wbflags);
+                    FIRST_CHILD(this)->fops->open, loc, flags, fd, xdata);
         return 0;
 }
 
@@ -75,7 +75,6 @@ fini (xlator_t *this)
 }
 
 struct xlator_fops fops = {
-        
         .open        = worm_open,
 
         .unlink      = ro_unlink,