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>

1 files changed, 137 insertions, 121 deletions

diff --git a/xlators/system/posix-acl/src/posix-acl.c b/xlators/system/posix-acl/src/posix-acl.c
index 0fe47c71d79..f2fe7d9c4c5 100644
--- a/xlators/system/posix-acl/src/posix-acl.c
+++ b/xlators/system/posix-acl/src/posix-acl.c
@@ -808,7 +808,8 @@ red:
 
 
 int
-posix_acl_access (call_frame_t *frame, xlator_t *this, loc_t *loc, int mask)
+posix_acl_access (call_frame_t *frame, xlator_t *this, loc_t *loc, int mask,
+                  dict_t *xdata)
 {
         int  op_ret = 0;
         int  op_errno = 0;
@@ -861,9 +862,9 @@ posix_acl_access (call_frame_t *frame, xlator_t *this, loc_t *loc, int mask)
 
 unwind:
         if (is_fuse_call)
-                STACK_UNWIND_STRICT (access, frame, op_ret, op_errno);
+                STACK_UNWIND_STRICT (access, frame, op_ret, op_errno, NULL);
         else
-                STACK_UNWIND_STRICT (access, frame, 0, mode);
+                STACK_UNWIND_STRICT (access, frame, 0, mode, NULL);
         return 0;
 }
 
@@ -871,16 +872,18 @@ unwind:
 int
 posix_acl_truncate_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
                         int op_ret, int op_errno, struct iatt *prebuf,
-                        struct iatt *postbuf)
+                        struct iatt *postbuf, dict_t *xdata)
 {
-        STACK_UNWIND_STRICT (truncate, frame, op_ret, op_errno, prebuf, postbuf);
+        STACK_UNWIND_STRICT (truncate, frame, op_ret, op_errno, prebuf,
+                             postbuf, xdata);
 
         return 0;
 }
 
 
 int
-posix_acl_truncate (call_frame_t *frame, xlator_t *this, loc_t *loc, off_t off)
+posix_acl_truncate (call_frame_t *frame, xlator_t *this, loc_t *loc, off_t off,
+                    dict_t *xdata)
 {
         if (acl_permits (frame, loc->inode, POSIX_ACL_WRITE))
                 goto green;
@@ -889,19 +892,19 @@ posix_acl_truncate (call_frame_t *frame, xlator_t *this, loc_t *loc, off_t off)
 green:
         STACK_WIND (frame, posix_acl_truncate_cbk,
                     FIRST_CHILD(this), FIRST_CHILD(this)->fops->truncate,
-                    loc, off);
+                    loc, off, xdata);
         return 0;
 red:
-        STACK_UNWIND_STRICT (truncate, frame, -1, EACCES, NULL, NULL);
+        STACK_UNWIND_STRICT (truncate, frame, -1, EACCES, NULL, NULL, NULL);
         return 0;
 }
 
 
 int
 posix_acl_open_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                    int op_ret, int op_errno, fd_t *fd)
+                    int op_ret, int 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;
 }
@@ -909,7 +912,7 @@ posix_acl_open_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
 
 int
 posix_acl_open (call_frame_t *frame, xlator_t *this, loc_t *loc, int flags,
-                fd_t *fd, int wbflags)
+                fd_t *fd, dict_t *xdata)
 {
         int perm = 0;
 
@@ -934,10 +937,10 @@ posix_acl_open (call_frame_t *frame, xlator_t *this, loc_t *loc, int flags,
 green:
         STACK_WIND (frame, posix_acl_open_cbk,
                     FIRST_CHILD(this), FIRST_CHILD(this)->fops->open,
-                    loc, flags, fd, wbflags);
+                    loc, flags, fd, xdata);
         return 0;
 red:
-        STACK_UNWIND_STRICT (open, frame, -1, EACCES, NULL);
+        STACK_UNWIND_STRICT (open, frame, -1, EACCES, NULL, xdata);
         return 0;
 }
 
@@ -945,17 +948,18 @@ red:
 int
 posix_acl_readv_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
                      int op_ret, int op_errno, struct iovec *vector,
-                     int count, struct iatt *stbuf, struct iobref *iobref)
+                     int count, struct iatt *stbuf, struct iobref *iobref,
+                     dict_t *xdata)
 {
         STACK_UNWIND_STRICT (readv, frame, op_ret, op_errno, vector, count,
-                             stbuf, iobref);
+                             stbuf, iobref, xdata);
         return 0;
 }
 
 
 int
 posix_acl_readv (call_frame_t *frame, xlator_t *this, fd_t *fd,
-                 size_t size, off_t offset, uint32_t flags)
+                 size_t size, off_t offset, uint32_t flags, dict_t *xdata)
 {
         if (__is_fuse_call (frame))
                 goto green;
@@ -968,10 +972,10 @@ posix_acl_readv (call_frame_t *frame, xlator_t *this, fd_t *fd,
 green:
         STACK_WIND (frame, posix_acl_readv_cbk,
                     FIRST_CHILD(this), FIRST_CHILD(this)->fops->readv,
-                    fd, size, offset, flags);
+                    fd, size, offset, flags, xdata);
         return 0;
 red:
-        STACK_UNWIND_STRICT (readv, frame, -1, EACCES, NULL, 0, NULL, NULL);
+        STACK_UNWIND_STRICT (readv, frame, -1, EACCES, NULL, 0, NULL, NULL, xdata);
         return 0;
 }
 
@@ -979,10 +983,10 @@ red:
 int
 posix_acl_writev_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
                       int op_ret, int op_errno,
-                      struct iatt *prebuf, struct iatt *postbuf)
+                      struct iatt *prebuf, struct iatt *postbuf, dict_t *xdata)
 {
         STACK_UNWIND_STRICT (writev, frame, op_ret, op_errno,
-                             prebuf, postbuf);
+                             prebuf, postbuf, xdata);
         return 0;
 }
 
@@ -990,7 +994,7 @@ posix_acl_writev_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
 int
 posix_acl_writev (call_frame_t *frame, xlator_t *this, fd_t *fd,
                   struct iovec *vector, int count, off_t offset,
-                  uint32_t flags, struct iobref *iobref)
+                  uint32_t flags, struct iobref *iobref, dict_t *xdata)
 {
         if (__is_fuse_call (frame))
                 goto green;
@@ -1003,10 +1007,10 @@ posix_acl_writev (call_frame_t *frame, xlator_t *this, fd_t *fd,
 green:
         STACK_WIND (frame, posix_acl_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;
 red:
-        STACK_UNWIND_STRICT (writev, frame, -1, EACCES, NULL, NULL);
+        STACK_UNWIND_STRICT (writev, frame, -1, EACCES, NULL, NULL, xdata);
         return 0;
 }
 
@@ -1014,18 +1018,18 @@ red:
 
 int
 posix_acl_ftruncate_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                         int op_ret, int op_errno,
-                         struct iatt *prebuf, struct iatt *postbuf)
+                         int op_ret, int op_errno, struct iatt *prebuf,
+                         struct iatt *postbuf, dict_t *xdata)
 {
         STACK_UNWIND_STRICT (ftruncate, frame, op_ret, op_errno,
-                             prebuf, postbuf);
+                             prebuf, postbuf, xdata);
         return 0;
 }
 
 
 int
 posix_acl_ftruncate (call_frame_t *frame, xlator_t *this, fd_t *fd,
-                     off_t offset)
+                     off_t offset, dict_t *xdata)
 {
         if (__is_fuse_call (frame))
                 goto green;
@@ -1038,26 +1042,26 @@ posix_acl_ftruncate (call_frame_t *frame, xlator_t *this, fd_t *fd,
 green:
         STACK_WIND (frame, posix_acl_ftruncate_cbk,
                     FIRST_CHILD(this), FIRST_CHILD(this)->fops->ftruncate,
-                    fd, offset);
+                    fd, offset, xdata);
         return 0;
 red:
-        STACK_UNWIND_STRICT (ftruncate, frame, -1, EACCES, NULL, NULL);
+        STACK_UNWIND_STRICT (ftruncate, frame, -1, EACCES, NULL, NULL, xdata);
         return 0;
 }
 
 
 int
 posix_acl_opendir_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                       int op_ret, int op_errno, fd_t *fd)
+                       int op_ret, int op_errno, fd_t *fd, dict_t *xdata)
 {
-        STACK_UNWIND_STRICT (opendir, frame, op_ret, op_errno, fd);
+        STACK_UNWIND_STRICT (opendir, frame, op_ret, op_errno, fd, xdata);
 
         return 0;
 }
 
 
 int
-posix_acl_opendir (call_frame_t *frame, xlator_t *this, loc_t *loc, fd_t *fd)
+posix_acl_opendir (call_frame_t *frame, xlator_t *this, loc_t *loc, fd_t *fd, dict_t *xdata)
 {
         if (acl_permits (frame, loc->inode, POSIX_ACL_READ))
                 goto green;
@@ -1066,10 +1070,10 @@ posix_acl_opendir (call_frame_t *frame, xlator_t *this, loc_t *loc, fd_t *fd)
 green:
         STACK_WIND (frame, posix_acl_opendir_cbk,
                     FIRST_CHILD(this), FIRST_CHILD(this)->fops->opendir,
-                    loc, fd);
+                    loc, fd, xdata);
         return 0;
 red:
-        STACK_UNWIND_STRICT (opendir, frame, -1, EACCES, NULL);
+        STACK_UNWIND_STRICT (opendir, frame, -1, EACCES, NULL, xdata);
         return 0;
 }
 
@@ -1077,7 +1081,8 @@ red:
 int
 posix_acl_mkdir_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
                      int op_ret, int op_errno, inode_t *inode, struct iatt *buf,
-                     struct iatt *preparent, struct iatt *postparent)
+                     struct iatt *preparent, struct iatt *postparent,
+                     dict_t *xdata)
 {
         if (op_ret != 0)
                 goto unwind;
@@ -1086,14 +1091,14 @@ posix_acl_mkdir_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
 
 unwind:
         STACK_UNWIND_STRICT (mkdir, frame, op_ret, op_errno, inode, buf,
-                             preparent, postparent);
+                             preparent, postparent, xdata);
         return 0;
 }
 
 
 int
 posix_acl_mkdir (call_frame_t *frame, xlator_t *this, loc_t *loc, mode_t mode,
-                 dict_t *params)
+                 mode_t umask, dict_t *xdata)
 {
         mode_t   newmode = 0;
 
@@ -1103,14 +1108,15 @@ posix_acl_mkdir (call_frame_t *frame, xlator_t *this, loc_t *loc, mode_t mode,
         else
                 goto red;
 green:
-        newmode = posix_acl_inherit_dir (this, loc, params, mode);
+        newmode = posix_acl_inherit_dir (this, loc, xdata, mode);
 
         STACK_WIND (frame, posix_acl_mkdir_cbk,
                     FIRST_CHILD(this), FIRST_CHILD(this)->fops->mkdir,
-                    loc, newmode, params);
+                    loc, newmode, umask, xdata);
         return 0;
 red:
-        STACK_UNWIND_STRICT (mkdir, frame, -1, EACCES, NULL, NULL, NULL, NULL);
+        STACK_UNWIND_STRICT (mkdir, frame, -1, EACCES, NULL, NULL, NULL, NULL,
+                             NULL);
         return 0;
 }
 
@@ -1118,7 +1124,8 @@ red:
 int
 posix_acl_mknod_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
                      int op_ret, int op_errno, inode_t *inode, struct iatt *buf,
-                     struct iatt *preparent, struct iatt *postparent)
+                     struct iatt *preparent, struct iatt *postparent,
+                     dict_t *xdata)
 {
         if (op_ret != 0)
                 goto unwind;
@@ -1127,14 +1134,14 @@ posix_acl_mknod_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
 
 unwind:
         STACK_UNWIND_STRICT (mknod, frame, op_ret, op_errno, inode, buf,
-                             preparent, postparent);
+                             preparent, postparent, xdata);
         return 0;
 }
 
 
 int
 posix_acl_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)
 {
         mode_t  newmode = 0;
 
@@ -1144,14 +1151,15 @@ posix_acl_mknod (call_frame_t *frame, xlator_t *this, loc_t *loc, mode_t mode,
         else
                 goto red;
 green:
-        newmode = posix_acl_inherit_file (this, loc, params, mode);
+        newmode = posix_acl_inherit_file (this, loc, xdata, mode);
 
         STACK_WIND (frame, posix_acl_mknod_cbk,
                     FIRST_CHILD(this), FIRST_CHILD(this)->fops->mknod,
-                    loc, newmode, rdev, params);
+                    loc, newmode, rdev, umask, xdata);
         return 0;
 red:
-        STACK_UNWIND_STRICT (mknod, frame, -1, EACCES, NULL, NULL, NULL, NULL);
+        STACK_UNWIND_STRICT (mknod, frame, -1, EACCES, NULL, NULL, NULL, NULL,
+                             NULL);
         return 0;
 }
 
@@ -1160,7 +1168,7 @@ int
 posix_acl_create_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
                       int op_ret, int op_errno, fd_t *fd, inode_t *inode,
                       struct iatt *buf, struct iatt *preparent,
-                      struct iatt *postparent)
+                      struct iatt *postparent, dict_t *xdata)
 {
         if (op_ret != 0)
                 goto unwind;
@@ -1169,14 +1177,14 @@ posix_acl_create_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
 
 unwind:
         STACK_UNWIND_STRICT (create, frame, op_ret, op_errno, fd, inode, buf,
-                             preparent, postparent);
+                             preparent, postparent, xdata);
         return 0;
 }
 
 
 int
 posix_acl_create (call_frame_t *frame, xlator_t *this, loc_t *loc, int flags,
-                  mode_t mode, fd_t *fd, dict_t *params)
+                  mode_t mode, mode_t umask, fd_t *fd, dict_t *xdata)
 {
         mode_t  newmode = 0;
 
@@ -1186,14 +1194,15 @@ posix_acl_create (call_frame_t *frame, xlator_t *this, loc_t *loc, int flags,
         else
                 goto red;
 green:
-        newmode = posix_acl_inherit_file (this, loc, params, mode);
+        newmode = posix_acl_inherit_file (this, loc, xdata, mode);
 
         STACK_WIND (frame, posix_acl_create_cbk,
                     FIRST_CHILD(this), FIRST_CHILD(this)->fops->create,
-                    loc, flags, newmode, fd, params);
+                    loc, flags, newmode, umask, fd, xdata);
         return 0;
 red:
-        STACK_UNWIND_STRICT (create, frame, -1, EACCES, NULL, NULL, NULL, NULL, NULL);
+        STACK_UNWIND_STRICT (create, frame, -1, EACCES, NULL, NULL, NULL,
+                             NULL, NULL, NULL);
         return 0;
 }
 
@@ -1202,7 +1211,7 @@ int
 posix_acl_symlink_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
                       int op_ret, int op_errno, inode_t *inode,
                       struct iatt *buf, struct iatt *preparent,
-                      struct iatt *postparent)
+                      struct iatt *postparent, dict_t *xdata)
 {
         if (op_ret != 0)
                 goto unwind;
@@ -1211,14 +1220,14 @@ posix_acl_symlink_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
 
 unwind:
         STACK_UNWIND_STRICT (symlink, frame, op_ret, op_errno, inode, buf,
-                             preparent, postparent);
+                             preparent, postparent, xdata);
         return 0;
 }
 
 
 int
 posix_acl_symlink (call_frame_t *frame, xlator_t *this, const char *linkname,
-                   loc_t *loc, dict_t *params)
+                   loc_t *loc, mode_t umask, dict_t *xdata)
 {
         if (acl_permits (frame, loc->parent, POSIX_ACL_WRITE|POSIX_ACL_EXECUTE))
                 goto green;
@@ -1227,30 +1236,32 @@ posix_acl_symlink (call_frame_t *frame, xlator_t *this, const char *linkname,
 green:
         STACK_WIND (frame, posix_acl_symlink_cbk,
                     FIRST_CHILD(this), FIRST_CHILD(this)->fops->symlink,
-                    linkname, loc, params);
+                    linkname, loc, umask, xdata);
         return 0;
 red:
-        STACK_UNWIND_STRICT (symlink, frame, -1, EACCES, NULL, NULL, NULL, NULL);
+        STACK_UNWIND_STRICT (symlink, frame, -1, EACCES, NULL, NULL, NULL,
+                             NULL, xdata);
         return 0;
 }
 
 
 int
 posix_acl_unlink_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                      int op_ret, int op_errno,
-                      struct iatt *preparent, struct iatt *postparent)
+                      int op_ret, int op_errno, struct iatt *preparent,
+                      struct iatt *postparent, dict_t *xdata)
 {
         if (op_ret != 0)
                 goto unwind;
 unwind:
         STACK_UNWIND_STRICT (unlink, frame, op_ret, op_errno,
-                             preparent, postparent);
+                             preparent, postparent, xdata);
         return 0;
 }
 
 
 int
-posix_acl_unlink (call_frame_t *frame, xlator_t *this, loc_t *loc)
+posix_acl_unlink (call_frame_t *frame, xlator_t *this, loc_t *loc, int xflag,
+                  dict_t *xdata)
 {
         if (!sticky_permits (frame, loc->parent, loc->inode))
                 goto red;
@@ -1262,10 +1273,10 @@ posix_acl_unlink (call_frame_t *frame, xlator_t *this, loc_t *loc)
 green:
         STACK_WIND (frame, posix_acl_unlink_cbk,
                     FIRST_CHILD(this), FIRST_CHILD(this)->fops->unlink,
-                    loc);
+                    loc, xflag, xdata);
         return 0;
 red:
-        STACK_UNWIND_STRICT (unlink, frame, -1, EACCES, NULL, NULL);
+        STACK_UNWIND_STRICT (unlink, frame, -1, EACCES, NULL, NULL, xdata);
         return 0;
 }
 
@@ -1273,19 +1284,19 @@ red:
 int
 posix_acl_rmdir_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
                      int op_ret, int op_errno,
-                     struct iatt *preparent, struct iatt *postparent)
+                     struct iatt *preparent, struct iatt *postparent, dict_t *xdata)
 {
         if (op_ret != 0)
                 goto unwind;
 unwind:
         STACK_UNWIND_STRICT (rmdir, frame, op_ret, op_errno,
-                             preparent, postparent);
+                             preparent, postparent, xdata);
         return 0;
 }
 
 
 int
-posix_acl_rmdir (call_frame_t *frame, xlator_t *this, loc_t *loc, int flags)
+posix_acl_rmdir (call_frame_t *frame, xlator_t *this, loc_t *loc, int flags, dict_t *xdata)
 {
         if (!sticky_permits (frame, loc->parent, loc->inode))
                 goto red;
@@ -1297,10 +1308,10 @@ posix_acl_rmdir (call_frame_t *frame, xlator_t *this, loc_t *loc, int flags)
 green:
         STACK_WIND (frame, posix_acl_rmdir_cbk,
                     FIRST_CHILD(this), FIRST_CHILD(this)->fops->rmdir,
-                    loc, flags);
+                    loc, flags, xdata);
         return 0;
 red:
-        STACK_UNWIND_STRICT (rmdir, frame, -1, EACCES, NULL, NULL);
+        STACK_UNWIND_STRICT (rmdir, frame, -1, EACCES, NULL, NULL, xdata);
         return 0;
 }
 
@@ -1309,20 +1320,21 @@ int
 posix_acl_rename_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
                       int op_ret, int 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)
 {
         if (op_ret != 0)
                 goto unwind;
 unwind:
         STACK_UNWIND_STRICT (rename, frame, op_ret, op_errno, buf,
                              preoldparent, postoldparent,
-                             prenewparent, postnewparent);
+                             prenewparent, postnewparent, xdata);
         return 0;
 }
 
 
 int
-posix_acl_rename (call_frame_t *frame, xlator_t *this, loc_t *old, loc_t *new)
+posix_acl_rename (call_frame_t *frame, xlator_t *this, loc_t *old, loc_t *new, dict_t *xdata)
 {
         if (!acl_permits (frame, old->parent, POSIX_ACL_WRITE))
                 goto red;
@@ -1340,11 +1352,11 @@ posix_acl_rename (call_frame_t *frame, xlator_t *this, loc_t *old, loc_t *new)
 
         STACK_WIND (frame, posix_acl_rename_cbk,
                     FIRST_CHILD(this), FIRST_CHILD(this)->fops->rename,
-                    old, new);
+                    old, new, xdata);
         return 0;
 red:
         STACK_UNWIND_STRICT (rename, frame, -1, EACCES, NULL, NULL, NULL, NULL,
-                             NULL);
+                             NULL, NULL);
         return 0;
 }
 
@@ -1352,19 +1364,19 @@ red:
 int
 posix_acl_link_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
                     int op_ret, int op_errno, inode_t *inode, struct iatt *buf,
-                    struct iatt *preparent, struct iatt *postparent)
+                    struct iatt *preparent, struct iatt *postparent, dict_t *xdata)
 {
         if (op_ret != 0)
                 goto unwind;
 unwind:
         STACK_UNWIND_STRICT (link, frame, op_ret, op_errno, inode, buf,
-                             preparent, postparent);
+                             preparent, postparent, xdata);
         return 0;
 }
 
 
 int
-posix_acl_link (call_frame_t *frame, xlator_t *this, loc_t *old, loc_t *new)
+posix_acl_link (call_frame_t *frame, xlator_t *this, loc_t *old, loc_t *new, dict_t *xdata)
 {
         struct posix_acl_ctx *ctx = NULL;
         int                   op_errno = 0;
@@ -1382,10 +1394,10 @@ posix_acl_link (call_frame_t *frame, xlator_t *this, loc_t *old, loc_t *new)
 
         STACK_WIND (frame, posix_acl_link_cbk,
                     FIRST_CHILD(this), FIRST_CHILD(this)->fops->link,
-                    old, new);
+                    old, new, xdata);
         return 0;
 red:
-        STACK_UNWIND_STRICT (link, frame, -1, op_errno, NULL, NULL, NULL, NULL);
+        STACK_UNWIND_STRICT (link, frame, -1, op_errno, NULL, NULL, NULL, NULL, xdata);
 
         return 0;
 }
@@ -1393,19 +1405,20 @@ red:
 
 int
 posix_acl_readdir_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)
 {
         if (op_ret != 0)
                 goto unwind;
 unwind:
-        STACK_UNWIND_STRICT (readdir, frame, op_ret, op_errno, entries);
+        STACK_UNWIND_STRICT (readdir, frame, op_ret, op_errno, entries, xdata);
         return 0;
 }
 
 
 int
 posix_acl_readdir (call_frame_t *frame, xlator_t *this, fd_t *fd, size_t size,
-                   off_t offset)
+                   off_t offset, dict_t *xdata)
 {
         if (acl_permits (frame, fd->inode, POSIX_ACL_READ))
                 goto green;
@@ -1414,10 +1427,10 @@ posix_acl_readdir (call_frame_t *frame, xlator_t *this, fd_t *fd, size_t size,
 green:
         STACK_WIND (frame, posix_acl_readdir_cbk,
                     FIRST_CHILD(this), FIRST_CHILD(this)->fops->readdir,
-                    fd, size, offset);
+                    fd, size, offset, xdata);
         return 0;
 red:
-        STACK_UNWIND_STRICT (readdir, frame, -1, EACCES, NULL);
+        STACK_UNWIND_STRICT (readdir, frame, -1, EACCES, NULL, xdata);
 
         return 0;
 }
@@ -1425,7 +1438,8 @@ red:
 
 int
 posix_acl_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;
         struct posix_acl *acl_access  = NULL;
@@ -1491,7 +1505,7 @@ posix_acl_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;
 }
 
@@ -1527,7 +1541,7 @@ green:
 
         return 0;
 red:
-        STACK_UNWIND_STRICT (readdirp, frame, -1, EACCES, NULL);
+        STACK_UNWIND_STRICT (readdirp, frame, -1, EACCES, NULL, NULL);
 
         return 0;
 }
@@ -1597,7 +1611,7 @@ setattr_scrutiny (call_frame_t *frame, inode_t *inode, struct iatt *buf,
 int
 posix_acl_setattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
                        int op_ret, int op_errno,
-                       struct iatt *prebuf, struct iatt *postbuf)
+                       struct iatt *prebuf, struct iatt *postbuf, dict_t *xdata)
 {
         inode_t   *inode = NULL;
 
@@ -1610,14 +1624,15 @@ posix_acl_setattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
         posix_acl_ctx_update (inode, this, postbuf);
 
 unwind:
-        STACK_UNWIND_STRICT (setattr, frame, op_ret, op_errno, prebuf, postbuf);
+        STACK_UNWIND_STRICT (setattr, frame, op_ret, op_errno, prebuf,
+                             postbuf, xdata);
         return 0;
 }
 
 
 int
 posix_acl_setattr (call_frame_t *frame, xlator_t *this, loc_t *loc,
-                   struct iatt *buf, int valid)
+                   struct iatt *buf, int valid, dict_t *xdata)
 {
         int  op_errno = 0;
 
@@ -1630,10 +1645,10 @@ posix_acl_setattr (call_frame_t *frame, xlator_t *this, loc_t *loc,
 
         STACK_WIND (frame, posix_acl_setattr_cbk,
                     FIRST_CHILD(this), FIRST_CHILD(this)->fops->setattr,
-                    loc, buf, valid);
+                    loc, buf, valid, xdata);
         return 0;
 red:
-        STACK_UNWIND_STRICT (setattr, frame, -1, op_errno, NULL, NULL);
+        STACK_UNWIND_STRICT (setattr, frame, -1, op_errno, NULL, NULL, xdata);
 
         return 0;
 }
@@ -1642,7 +1657,7 @@ red:
 int
 posix_acl_fsetattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
                         int op_ret, int op_errno,
-                        struct iatt *prebuf, struct iatt *postbuf)
+                        struct iatt *prebuf, struct iatt *postbuf, dict_t *xdata)
 {
         inode_t   *inode = NULL;
 
@@ -1655,14 +1670,15 @@ posix_acl_fsetattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
         posix_acl_ctx_update (inode, this, postbuf);
 
 unwind:
-        STACK_UNWIND_STRICT (fsetattr, frame, op_ret, op_errno, prebuf, postbuf);
+        STACK_UNWIND_STRICT (fsetattr, frame, op_ret, op_errno, prebuf,
+                             postbuf, xdata);
         return 0;
 }
 
 
 int
 posix_acl_fsetattr (call_frame_t *frame, xlator_t *this, fd_t *fd,
-                    struct iatt *buf, int valid)
+                    struct iatt *buf, int valid, dict_t *xdata)
 {
         int  op_errno = 0;
 
@@ -1675,10 +1691,10 @@ posix_acl_fsetattr (call_frame_t *frame, xlator_t *this, fd_t *fd,
 
         STACK_WIND (frame, posix_acl_fsetattr_cbk,
                     FIRST_CHILD(this), FIRST_CHILD(this)->fops->fsetattr,
-                    fd, buf, valid);
+                    fd, buf, valid, xdata);
         return 0;
 red:
-        STACK_UNWIND_STRICT (fsetattr, frame, -1, EACCES, NULL, NULL);
+        STACK_UNWIND_STRICT (fsetattr, frame, -1, EACCES, NULL, NULL, xdata);
 
         return 0;
 }
@@ -1781,9 +1797,9 @@ posix_acl_setxattr_update (xlator_t *this, inode_t *inode, dict_t *xattr)
 
 int
 posix_acl_setxattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                        int op_ret, int op_errno)
+                        int op_ret, int op_errno, dict_t *xdata)
 {
-        STACK_UNWIND_STRICT (setxattr, frame, op_ret, op_errno);
+        STACK_UNWIND_STRICT (setxattr, frame, op_ret, op_errno, xdata);
 
         return 0;
 }
@@ -1791,7 +1807,7 @@ posix_acl_setxattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
 
 int
 posix_acl_setxattr (call_frame_t *frame, xlator_t *this, loc_t *loc,
-                    dict_t *xattr, int flags)
+                    dict_t *xattr, int flags, dict_t *xdata)
 {
         int  op_errno = 0;
 
@@ -1804,10 +1820,10 @@ posix_acl_setxattr (call_frame_t *frame, xlator_t *this, loc_t *loc,
 
         STACK_WIND (frame, posix_acl_setxattr_cbk,
                     FIRST_CHILD(this), FIRST_CHILD(this)->fops->setxattr,
-                    loc, xattr, flags);
+                    loc, xattr, flags, xdata);
         return 0;
 red:
-        STACK_UNWIND_STRICT (setxattr, frame, -1, op_errno);
+        STACK_UNWIND_STRICT (setxattr, frame, -1, op_errno, xdata);
 
         return 0;
 }
@@ -1815,9 +1831,9 @@ red:
 
 int
 posix_acl_fsetxattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                         int op_ret, int op_errno)
+                         int op_ret, int op_errno, dict_t *xdata)
 {
-        STACK_UNWIND_STRICT (fsetxattr, frame, op_ret, op_errno);
+        STACK_UNWIND_STRICT (fsetxattr, frame, op_ret, op_errno, xdata);
 
         return 0;
 }
@@ -1825,7 +1841,7 @@ posix_acl_fsetxattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
 
 int
 posix_acl_fsetxattr (call_frame_t *frame, xlator_t *this, fd_t *fd,
-                     dict_t *xattr, int flags)
+                     dict_t *xattr, int flags, dict_t *xdata)
 {
         int  op_errno = 0;
 
@@ -1838,10 +1854,10 @@ posix_acl_fsetxattr (call_frame_t *frame, xlator_t *this, fd_t *fd,
 
         STACK_WIND (frame, posix_acl_fsetxattr_cbk,
                     FIRST_CHILD(this), FIRST_CHILD(this)->fops->fsetxattr,
-                    fd, xattr, flags);
+                    fd, xattr, flags, xdata);
         return 0;
 red:
-        STACK_UNWIND_STRICT (fsetxattr, frame, -1, op_errno);
+        STACK_UNWIND_STRICT (fsetxattr, frame, -1, op_errno, xdata);
 
         return 0;
 }
@@ -1849,9 +1865,9 @@ red:
 
 int
 posix_acl_getxattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                        int op_ret, int op_errno, dict_t *xattr)
+                        int op_ret, int op_errno, dict_t *xattr, dict_t *xdata)
 {
-        STACK_UNWIND_STRICT (getxattr, frame, op_ret, op_errno, xattr);
+        STACK_UNWIND_STRICT (getxattr, frame, op_ret, op_errno, xattr, xdata);
 
         return 0;
 }
@@ -1859,7 +1875,7 @@ posix_acl_getxattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
 
 int
 posix_acl_getxattr (call_frame_t *frame, xlator_t *this, loc_t *loc,
-                    const char *name)
+                    const char *name, dict_t *xdata)
 {
         if (whitelisted_xattr (name))
                 goto green;
@@ -1871,10 +1887,10 @@ posix_acl_getxattr (call_frame_t *frame, xlator_t *this, loc_t *loc,
 green:
         STACK_WIND (frame, posix_acl_getxattr_cbk,
                     FIRST_CHILD(this), FIRST_CHILD(this)->fops->getxattr,
-                    loc, name);
+                    loc, name, xdata);
         return 0;
 red:
-        STACK_UNWIND_STRICT (getxattr, frame, -1, EACCES, NULL);
+        STACK_UNWIND_STRICT (getxattr, frame, -1, EACCES, NULL, xdata);
 
         return 0;
 }
@@ -1882,9 +1898,9 @@ red:
 
 int
 posix_acl_fgetxattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                         int op_ret, int op_errno, dict_t *xattr)
+                         int op_ret, int op_errno, dict_t *xattr, dict_t *xdata)
 {
-        STACK_UNWIND_STRICT (fgetxattr, frame, op_ret, op_errno, xattr);
+        STACK_UNWIND_STRICT (fgetxattr, frame, op_ret, op_errno, xattr, xdata);
 
         return 0;
 }
@@ -1892,7 +1908,7 @@ posix_acl_fgetxattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
 
 int
 posix_acl_fgetxattr (call_frame_t *frame, xlator_t *this, fd_t *fd,
-                     const char *name)
+                     const char *name, dict_t *xdata)
 {
         if (whitelisted_xattr (name))
                 goto green;
@@ -1904,10 +1920,10 @@ posix_acl_fgetxattr (call_frame_t *frame, xlator_t *this, fd_t *fd,
 green:
         STACK_WIND (frame, posix_acl_fgetxattr_cbk,
                     FIRST_CHILD(this), FIRST_CHILD(this)->fops->fgetxattr,
-                    fd, name);
+                    fd, name, xdata);
         return 0;
 red:
-        STACK_UNWIND_STRICT (fgetxattr, frame, -1, EACCES, NULL);
+        STACK_UNWIND_STRICT (fgetxattr, frame, -1, EACCES, NULL, xdata);
 
         return 0;
 }
@@ -1915,9 +1931,9 @@ red:
 
 int
 posix_acl_removexattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                           int op_ret, int op_errno)
+                           int op_ret, int op_errno, dict_t *xdata)
 {
-        STACK_UNWIND_STRICT (removexattr, frame, op_ret, op_errno);
+        STACK_UNWIND_STRICT (removexattr, frame, op_ret, op_errno, xdata);
 
         return 0;
 }
@@ -1925,7 +1941,7 @@ posix_acl_removexattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
 
 int
 posix_acl_removexattr (call_frame_t *frame, xlator_t *this, loc_t *loc,
-                       const char *name)
+                       const char *name, dict_t *xdata)
 {
         struct  posix_acl_ctx  *ctx = NULL;
         int                     op_errno = EACCES;
@@ -1953,10 +1969,10 @@ posix_acl_removexattr (call_frame_t *frame, xlator_t *this, loc_t *loc,
 green:
         STACK_WIND (frame, posix_acl_removexattr_cbk,
                     FIRST_CHILD(this), FIRST_CHILD(this)->fops->removexattr,
-                    loc, name);
+                    loc, name, xdata);
         return 0;
 red:
-        STACK_UNWIND_STRICT (removexattr, frame, -1, op_errno);
+        STACK_UNWIND_STRICT (removexattr, frame, -1, op_errno, xdata);
 
         return 0;
 }