diff options
Diffstat (limited to 'xlators/nfs/server/src/nfs-fops.c')
| -rw-r--r-- | xlators/nfs/server/src/nfs-fops.c | 659 |
1 files changed, 511 insertions, 148 deletions
diff --git a/xlators/nfs/server/src/nfs-fops.c b/xlators/nfs/server/src/nfs-fops.c index b5ff93782..236b80c76 100644 --- a/xlators/nfs/server/src/nfs-fops.c +++ b/xlators/nfs/server/src/nfs-fops.c @@ -1,20 +1,11 @@ /* - Copyright (c) 2010 Gluster, Inc. <http://www.gluster.com> + Copyright (c) 2010-2011 Gluster, Inc. <http://www.gluster.com> This file is part of GlusterFS. - GlusterFS is free software; you can redistribute it and/or modify - it under the terms of the GNU General Public License as published - by the Free Software Foundation; either version 3 of the License, - or (at your option) any later version. - - GlusterFS is distributed in the hope that it will be useful, but - WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - General Public License for more details. - - You should have received a copy of the GNU General Public License - along with this program. If not, see - <http://www.gnu.org/licenses/>. + This file is licensed to you under your choice of the GNU Lesser + General Public License, version 3 or any later version (LGPLv3 or + later), or the GNU General Public License, version 2 (GPLv2), in all + cases as published by the Free Software Foundation. */ #ifndef _CONFIG_H @@ -22,6 +13,9 @@ #include "config.h" #endif +#include <grp.h> +#include <pwd.h> + #include "dict.h" #include "xlator.h" #include "iobuf.h" @@ -31,10 +25,80 @@ #include "nfs-fops.h" #include "inode.h" #include "nfs-common.h" - +#include "nfs3-helpers.h" +#include "nfs-mem-types.h" #include <libgen.h> #include <semaphore.h> +void +nfs_fix_groups (xlator_t *this, call_stack_t *root) +{ + struct passwd mypw; + char mystrs[1024]; + struct passwd *result; + gid_t mygroups[GF_MAX_AUX_GROUPS]; + int ngroups; + int i; + struct nfs_state *priv = this->private; + const gid_list_t *agl; + gid_list_t gl; + + if (!priv->server_aux_gids) { + return; + } + + agl = gid_cache_lookup(&priv->gid_cache, root->uid); + if (agl) { + for (ngroups = 0; ngroups < agl->gl_count; ngroups++) + root->groups[ngroups] = agl->gl_list[ngroups]; + root->ngrps = ngroups; + gid_cache_release(&priv->gid_cache, agl); + return; + } + + /* No cached list found. */ + if (getpwuid_r(root->uid,&mypw,mystrs,sizeof(mystrs),&result) != 0) { + gf_log (this->name, GF_LOG_ERROR, + "getpwuid_r(%u) failed", root->uid); + return; + } + + if (!result) { + gf_log (this->name, GF_LOG_ERROR, + "getpwuid_r(%u) found nothing", root->uid); + return; + } + + gf_log (this->name, GF_LOG_TRACE, "mapped %u => %s", + root->uid, result->pw_name); + + ngroups = GF_MAX_AUX_GROUPS; + if (getgrouplist(result->pw_name,root->gid,mygroups,&ngroups) == -1) { + gf_log (this->name, GF_LOG_ERROR, + "could not map %s to group list", result->pw_name); + return; + } + + /* Add the group data to the cache. */ + gl.gl_list = GF_CALLOC(ngroups, sizeof(gid_t), gf_nfs_mt_aux_gids); + if (gl.gl_list) { + /* It's not fatal if the alloc failed. */ + gl.gl_id = root->uid; + gl.gl_count = ngroups; + memcpy(gl.gl_list, mygroups, sizeof(gid_t) * ngroups); + if (gid_cache_add(&priv->gid_cache, &gl) != 1) + GF_FREE(gl.gl_list); + } + + /* Copy data to the frame. */ + for (i = 0; i < ngroups; ++i) { + gf_log (this->name, GF_LOG_TRACE, + "%s is in group %u", result->pw_name, mygroups[i]); + root->groups[i] = mygroups[i]; + } + root->ngrps = ngroups; +} + struct nfs_fop_local * nfs_fop_local_init (xlator_t *nfsx) { @@ -52,13 +116,9 @@ nfs_fop_local_init (xlator_t *nfsx) void nfs_fop_local_wipe (xlator_t *nfsx, struct nfs_fop_local *l) { - struct nfs_state *nfs = NULL; - if ((!nfsx) || (!l)) return; - nfs = nfsx->private; - if (l->iobref) iobref_unref (l->iobref); @@ -71,7 +131,10 @@ nfs_fop_local_wipe (xlator_t *nfsx, struct nfs_fop_local *l) if (l->newparent) inode_unref (l->newparent); - mem_put (nfs->foppool, l); + if (l->dictgfid) + dict_unref (l->dictgfid); + + mem_put (l); return; } @@ -91,7 +154,7 @@ unsigned int cval = 1; int nfs_frame_getctr () { - int val = 0; + uint64_t val = 0; pthread_mutex_lock (&ctr); { @@ -119,20 +182,33 @@ nfs_create_frame (xlator_t *xl, nfs_user_t *nfu) frame = create_frame (xl, (call_pool_t *)xl->ctx->pool); if (!frame) goto err; + if (call_stack_alloc_groups (frame->root, nfu->ngrps) != 0) { + STACK_DESTROY (frame->root); + frame = NULL; + goto err; + } + + frame->root->pid = NFS_PID; frame->root->uid = nfu->uid; frame->root->gid = nfu->gids[NFS_PRIMGID_IDX]; - if (nfu->ngrps == 1) - goto err; /* Done, we only got primary gid */ + frame->root->lk_owner = nfu->lk_owner; - frame->root->ngrps = nfu->ngrps - 1; + if (nfu->ngrps != 1) { + frame->root->ngrps = nfu->ngrps - 1; - gf_log (GF_NFS, GF_LOG_TRACE,"uid: %d, gid %d, gids: %d", - frame->root->uid, frame->root->gid, frame->root->ngrps); - for(y = 0, x = 1; y < frame->root->ngrps; x++,y++) { - gf_log (GF_NFS, GF_LOG_TRACE, "gid: %d", nfu->gids[x]); - frame->root->groups[y] = nfu->gids[x]; + gf_log (GF_NFS, GF_LOG_TRACE,"uid: %d, gid %d, gids: %d", + frame->root->uid, frame->root->gid, frame->root->ngrps); + for(y = 0, x = 1; y < frame->root->ngrps; x++,y++) { + gf_log (GF_NFS, GF_LOG_TRACE, "gid: %d", nfu->gids[x]); + frame->root->groups[y] = nfu->gids[x]; + } } - frame->root->lk_owner = nfs_frame_getctr (); + + /* + * It's tempting to do this *instead* of using nfu above, but we need + * to have those values in case nfs_fix_groups doesn't do anything. + */ + nfs_fix_groups(xl,frame->root); err: return frame; @@ -140,7 +216,7 @@ err: #define nfs_fop_handle_frame_create(fram, xla, nfuser, retval, errlabel) \ do { \ - fram = nfs_create_frame (xla, (nfuser)); \ + fram = nfs_create_frame (xla, (nfuser)); \ if (!fram) { \ retval = (-ENOMEM); \ gf_log (GF_NFS, GF_LOG_ERROR,"Frame creation failed");\ @@ -152,28 +228,31 @@ err: * for us to determine in the callback whether to funge the ino in the stat buf * with 1 for the parent. */ -#define nfs_fop_save_root_ino(locl, loc) \ - do { \ - if ((loc)->ino == 1) \ - (locl)->rootinode = 1; \ - else if (((loc)->parent) && ((loc)->parent->ino == 1)) \ - (locl)->rootparentinode = 1; \ - } while (0) \ +#define nfs_fop_save_root_ino(locl, loc) \ + do { \ + if (((loc)->inode) && \ + __is_root_gfid ((loc)->inode->gfid)) \ + (locl)->rootinode = 1; \ + else if (((loc)->parent) && \ + __is_root_gfid ((loc)->parent->gfid)) \ + (locl)->rootparentinode = 1; \ + } while (0) /* Do the same for an fd */ -#define nfs_fop_save_root_fd_ino(locl, fdesc) \ - do { \ - if ((fdesc)->inode->ino == 1) \ - (locl)->rootinode = 1; \ - } while (0) \ - +#define nfs_fop_save_root_fd_ino(locl, fdesc) \ + do { \ + if (__is_root_gfid ((fdesc)->inode->gfid)) \ + (locl)->rootinode = 1; \ + } while (0) /* Use the state saved by the previous macro to funge the ino in the appropriate * structure. */ -#define nfs_fop_restore_root_ino(locl, preattr, postattr, prepar, postpar) \ +#define nfs_fop_restore_root_ino(locl, fopret, preattr, postattr, prepar, postpar) \ do { \ + if (fopret == -1) \ + break; \ if ((locl)->rootinode) { \ if ((preattr)) { \ ((struct iatt *)(preattr))->ia_ino = 1; \ @@ -198,17 +277,21 @@ err: /* If the newly created, inode's parent is root, we'll need to funge the ino * in the parent attr when we receive them in the callback. */ -#define nfs_fop_newloc_save_root_ino(locl, newloc) \ - do { \ - if ((newloc)->ino == 1) \ - (locl)->newrootinode = 1; \ - else if (((newloc)->parent) && ((newloc)->parent->ino == 1)) \ - (locl)->newrootparentinode = 1; \ - } while (0) \ - - -#define nfs_fop_newloc_restore_root_ino(locl, preattr, postattr, prepar, postpar) \ +#define nfs_fop_newloc_save_root_ino(locl, newloc) \ + do { \ + if (((newloc)->inode) && \ + __is_root_gfid ((newloc)->inode->gfid)) \ + (locl)->newrootinode = 1; \ + else if (((newloc)->parent) && \ + __is_root_gfid ((newloc)->parent->gfid)) \ + (locl)->newrootparentinode = 1; \ + } while (0) + +#define nfs_fop_newloc_restore_root_ino(locl, fopret, preattr, postattr, prepar, postpar) \ do { \ + if (fopret == -1) \ + break; \ + \ if ((locl)->newrootinode) { \ if ((preattr)) \ ((struct iatt *)(preattr))->ia_ino = 1; \ @@ -222,6 +305,51 @@ err: } \ } while (0) \ +dict_t * +nfs_gfid_dict (inode_t *inode) +{ + uuid_t newgfid = {0, }; + char *dyngfid = NULL; + dict_t *dictgfid = NULL; + int ret = -1; + uuid_t rootgfid = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1}; + + dyngfid = GF_CALLOC (1, sizeof (uuid_t), gf_common_mt_char); + uuid_generate (newgfid); + + if (uuid_compare (inode->gfid, rootgfid) == 0) + memcpy (dyngfid, rootgfid, sizeof (uuid_t)); + else + memcpy (dyngfid, newgfid, sizeof (uuid_t)); + + dictgfid = dict_new (); + if (!dictgfid) { + gf_log (GF_NFS, GF_LOG_ERROR, "Failed to create gfid dict"); + goto out; + } + + ret = dict_set_bin (dictgfid, "gfid-req", dyngfid, sizeof (uuid_t)); + if (ret < 0) { + dict_unref (dictgfid); + dictgfid = NULL; + } + +out: + return dictgfid; +} + +#define nfs_fop_gfid_setup(nflcl, inode, retval, erlbl) \ + do { \ + if (nflcl) { \ + (nflcl)->dictgfid = nfs_gfid_dict (inode); \ + \ + if (!((nflcl)->dictgfid)) { \ + retval = -EFAULT; \ + goto erlbl; \ + } \ + } \ + } while (0) \ + /* Fops Layer Explained * The fops layer has three types of functions. They can all be identified by * their names. Here are the three patterns: @@ -236,7 +364,7 @@ err: * * nfs_<fopname> * Unlike the nfs_fop_<fopname> variety, this is the stateful type of fop, in - * that it silently performs all the relevant GlusterFS state maintainence + * that it silently performs all the relevant GlusterFS state maintenance * operations on the data returned to the callbacks, leaving the caller's * callback to just use the data returned for whatever it needs to do with that * data, for eg. the nfs_lookup, will take care of looking up the inodes, @@ -255,8 +383,12 @@ nfs_fop_lookup_cbk (call_frame_t *frame, void *cookie, xlator_t *this, struct nfs_fop_local *local = NULL; fop_lookup_cbk_t progcbk; + if (op_ret == 0) { + nfs_fix_generation(this,inode); + } + nfl_to_prog_data (local, progcbk, frame); - nfs_fop_restore_root_ino (local, buf, NULL, NULL, postparent); + nfs_fop_restore_root_ino (local, op_ret, buf, NULL, NULL, postparent); if (progcbk) progcbk (frame, cookie, this, op_ret, op_errno, inode, buf, xattr, postparent); @@ -281,9 +413,10 @@ nfs_fop_lookup (xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, loc_t *loc, nfs_fop_handle_frame_create (frame, nfsx, nfu, ret, err); nfs_fop_handle_local_init (frame, nfsx, nfl, cbk, local, ret, err); nfs_fop_save_root_ino (nfl, loc); + nfs_fop_gfid_setup (nfl, loc->inode, ret, err); STACK_WIND_COOKIE (frame, nfs_fop_lookup_cbk, xl, xl, - xl->fops->lookup, loc, NULL); + xl->fops->lookup, loc, nfl->dictgfid); ret = 0; err: @@ -295,18 +428,63 @@ err: return ret; } +int32_t +nfs_fop_access_cbk (call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, dict_t *xdata) +{ + struct nfs_fop_local *nfl = NULL; + fop_access_cbk_t progcbk = NULL; + + nfl_to_prog_data (nfl, progcbk, frame); + if (progcbk) + progcbk (frame, cookie, this, op_ret, op_errno, xdata); + + nfs_stack_destroy (nfl, frame); + return 0; +} + +int +nfs_fop_access (xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, loc_t *loc, + int32_t accesstest, fop_access_cbk_t cbk, void *local) +{ + call_frame_t *frame = NULL; + int ret = -EFAULT; + struct nfs_fop_local *nfl = NULL; + uint32_t accessbits = 0; + + if ((!xl) || (!loc) || (!nfu)) + return ret; + + gf_log (GF_NFS, GF_LOG_TRACE, "Access: %s", loc->path); + nfs_fop_handle_frame_create (frame, nfsx, nfu, ret, err); + nfs_fop_handle_local_init (frame, nfsx, nfl, cbk, local, ret, err); + nfs_fop_save_root_ino (nfl, loc); + + accessbits = nfs3_request_to_accessbits (accesstest); + STACK_WIND_COOKIE (frame, nfs_fop_access_cbk, xl, xl, xl->fops->access, + loc, accessbits, NULL); + ret = 0; +err: + if (ret < 0) { + if (frame) + nfs_stack_destroy (nfl, frame); + } + + return ret; +} int32_t nfs_fop_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) { struct nfs_fop_local *nfl = NULL; fop_stat_cbk_t progcbk = NULL; nfl_to_prog_data (nfl, progcbk, frame); - nfs_fop_restore_root_ino (nfl, buf, NULL, NULL, NULL); + nfs_fop_restore_root_ino (nfl, op_ret, buf, NULL, NULL, NULL); if (progcbk) - progcbk (frame, cookie, this, op_ret, op_errno, buf); + progcbk (frame, cookie, this, op_ret, op_errno, buf, xdata); nfs_stack_destroy (nfl, frame); return 0; @@ -330,7 +508,7 @@ nfs_fop_stat (xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, loc_t *loc, nfs_fop_save_root_ino (nfl, loc); STACK_WIND_COOKIE (frame, nfs_fop_stat_cbk, xl, xl, xl->fops->stat, - loc); + loc, NULL); ret = 0; err: if (ret < 0) { @@ -344,15 +522,16 @@ err: int32_t nfs_fop_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) { struct nfs_fop_local *nfl = NULL; fop_fstat_cbk_t progcbk = NULL; nfl_to_prog_data (nfl, progcbk, frame); - nfs_fop_restore_root_ino (nfl, buf, NULL, NULL, NULL); + nfs_fop_restore_root_ino (nfl, op_ret, buf, NULL, NULL, NULL); if (progcbk) - progcbk (frame, cookie, this, op_ret, op_errno, buf); + progcbk (frame, cookie, this, op_ret, op_errno, buf, xdata); nfs_stack_destroy (nfl, frame); return 0; @@ -376,7 +555,7 @@ nfs_fop_fstat (xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, fd_t *fd, nfs_fop_save_root_fd_ino (nfl, fd); STACK_WIND_COOKIE (frame, nfs_fop_fstat_cbk, xl, xl, xl->fops->fstat, - fd); + fd, NULL); ret = 0; err: @@ -391,14 +570,14 @@ err: int32_t nfs_fop_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) { struct nfs_fop_local *nfl = NULL; fop_opendir_cbk_t progcbk = NULL; nfl_to_prog_data (nfl, progcbk, frame); if (progcbk) - progcbk (frame, cookie, this, op_ret, op_errno, fd); + progcbk (frame, cookie, this, op_ret, op_errno, fd, xdata); nfs_stack_destroy (nfl, frame); return 0; } @@ -420,7 +599,7 @@ nfs_fop_opendir (xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, loc_t *pathloc, nfs_fop_handle_local_init (frame, nfsx, nfl, cbk, local, ret, err); STACK_WIND_COOKIE (frame, nfs_fop_opendir_cbk, xl, xl, - xl->fops->opendir, pathloc, dirfd); + xl->fops->opendir, pathloc, dirfd, NULL); ret = 0; err: @@ -434,14 +613,14 @@ err: int nfs_fop_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) { struct nfs_fop_local *nfl = NULL; fop_flush_cbk_t progcbk = NULL; nfl_to_prog_data (nfl, progcbk, frame); if (progcbk) - progcbk (frame, cookie, this, op_ret, op_errno); + progcbk (frame, cookie, this, op_ret, op_errno, xdata); nfs_stack_destroy (nfl, frame); return 0; @@ -463,7 +642,7 @@ nfs_fop_flush (xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, fd_t *fd, nfs_fop_handle_local_init (frame, nfsx, nfl, cbk, local, ret, err); STACK_WIND_COOKIE (frame, nfs_fop_flush_cbk, xl, xl, xl->fops->flush, - fd); + fd, NULL); ret = 0; err: if (ret < 0) { @@ -477,14 +656,15 @@ err: int32_t nfs_fop_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) { struct nfs_fop_local *nfl = NULL; fop_readdirp_cbk_t progcbk = NULL; nfl_to_prog_data (nfl, progcbk, frame); if (progcbk) - progcbk (frame, cookie, this, op_ret, op_errno, entries); + progcbk (frame, cookie, this, op_ret, op_errno, entries, xdata); nfs_stack_destroy (nfl, frame); @@ -509,7 +689,7 @@ nfs_fop_readdirp (xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, fd_t *dirfd, nfs_fop_handle_local_init (frame, nfsx, nfl, cbk, local, ret, err); STACK_WIND_COOKIE (frame, nfs_fop_readdirp_cbk, xl, xl, - xl->fops->readdirp, dirfd, bufsize, offset); + xl->fops->readdirp, dirfd, bufsize, offset, 0); ret = 0; err: @@ -524,7 +704,8 @@ err: int32_t nfs_fop_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) { struct nfs_fop_local *nfl = NULL; @@ -532,7 +713,7 @@ nfs_fop_statfs_cbk (call_frame_t *frame, void *cookie, xlator_t *this, nfl_to_prog_data (nfl, progcbk, frame); if (progcbk) - progcbk (frame, cookie, this, op_ret, op_errno, buf); + progcbk (frame, cookie, this, op_ret, op_errno, buf, xdata); nfs_stack_destroy (nfl, frame); return 0; @@ -555,7 +736,7 @@ nfs_fop_statfs (xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, loc_t *pathloc, nfs_fop_handle_local_init (frame, nfsx, nfl, cbk, local, ret, err); STACK_WIND_COOKIE (frame, nfs_fop_statfs_cbk, xl, xl, - xl->fops->statfs, pathloc); + xl->fops->statfs, pathloc, NULL); ret = 0; err: if (ret < 0) { @@ -571,16 +752,21 @@ int32_t nfs_fop_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) { struct nfs_fop_local *nfl = NULL; fop_create_cbk_t progcbk = NULL; + if (op_ret == 0) { + nfs_fix_generation(this,inode); + } + nfl_to_prog_data (nfl, progcbk, frame); - nfs_fop_restore_root_ino (nfl, buf, NULL, preparent, postparent); + nfs_fop_restore_root_ino (nfl, op_ret, buf, NULL, preparent, + postparent); if (progcbk) progcbk (frame, cookie, this, op_ret, op_errno, fd, inode, buf, - preparent, postparent); + preparent, postparent, NULL); nfs_stack_destroy (nfl, frame); return 0; @@ -603,9 +789,11 @@ nfs_fop_create (xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, loc_t *pathloc, nfs_fop_handle_frame_create (frame, nfsx, nfu, ret, err); nfs_fop_handle_local_init (frame, nfsx, nfl, cbk, local, ret, err); nfs_fop_save_root_ino (nfl, pathloc); + nfs_fop_gfid_setup (nfl, pathloc->inode, ret, err); + + STACK_WIND_COOKIE (frame, nfs_fop_create_cbk, xl, xl, xl->fops->create, + pathloc, flags, mode, 0, fd, nfl->dictgfid); - STACK_WIND_COOKIE (frame, nfs_fop_create_cbk, xl, xl,xl->fops->create - , pathloc, flags, mode, fd); ret = 0; err: if (ret < 0) { @@ -620,15 +808,16 @@ err: int32_t nfs_fop_setattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this, int32_t op_ret, int32_t op_errno, struct iatt *pre, - struct iatt *post) + struct iatt *post, dict_t *xdata) { struct nfs_fop_local *nfl = NULL; fop_setattr_cbk_t progcbk = NULL; nfl_to_prog_data (nfl, progcbk, frame); - nfs_fop_restore_root_ino (nfl, pre, post, NULL, NULL); + nfs_fop_restore_root_ino (nfl, op_ret, pre, post, NULL, NULL); if (progcbk) - progcbk (frame, cookie, this, op_ret, op_errno, pre, post); + progcbk (frame, cookie, this, op_ret, op_errno, pre, post, + xdata); nfs_stack_destroy (nfl, frame); return 0; } @@ -653,7 +842,7 @@ nfs_fop_setattr (xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, loc_t *pathloc, nfs_fop_save_root_ino (nfl, pathloc); STACK_WIND_COOKIE (frame, nfs_fop_setattr_cbk, xl, xl, - xl->fops->setattr, pathloc, buf, valid); + xl->fops->setattr, pathloc, buf, valid, NULL); ret = 0; err: if (ret < 0) { @@ -669,16 +858,20 @@ int32_t nfs_fop_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) { struct nfs_fop_local *nfl = NULL; fop_mkdir_cbk_t progcbk = NULL; + if (op_ret == 0) { + nfs_fix_generation(this,inode); + } + nfl_to_prog_data (nfl, progcbk, frame); - nfs_fop_restore_root_ino (nfl, buf, NULL, preparent, postparent); + nfs_fop_restore_root_ino (nfl, op_ret, buf, NULL,preparent, postparent); if (progcbk) progcbk (frame, cookie, this, op_ret, op_errno, inode, buf, - preparent, postparent); + preparent, postparent, xdata); nfs_stack_destroy (nfl, frame); return 0; } @@ -699,9 +892,10 @@ nfs_fop_mkdir (xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, loc_t *pathloc, nfs_fop_handle_frame_create (frame, nfsx, nfu, ret, err); nfs_fop_handle_local_init (frame, nfsx, nfl, cbk, local, ret, err); nfs_fop_save_root_ino (nfl, pathloc); + nfs_fop_gfid_setup (nfl, pathloc->inode, ret, err); - STACK_WIND_COOKIE (frame, nfs_fop_mkdir_cbk, xl, xl, xl->fops->mkdir, - pathloc, mode); + STACK_WIND_COOKIE (frame, nfs_fop_mkdir_cbk, xl, xl, xl->fops->mkdir, + pathloc, mode, 0, nfl->dictgfid); ret = 0; err: if (ret < 0) { @@ -717,16 +911,20 @@ int32_t nfs_fop_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) { struct nfs_fop_local *nfl = NULL; fop_symlink_cbk_t progcbk = NULL; + if (op_ret == 0) { + nfs_fix_generation(this,inode); + } + nfl_to_prog_data (nfl, progcbk, frame); - nfs_fop_restore_root_ino (nfl, buf, NULL, preparent, postparent); + nfs_fop_restore_root_ino (nfl, op_ret,buf, NULL, preparent, postparent); if (progcbk) progcbk (frame, cookie, this, op_ret, op_errno, inode, buf, - preparent, postparent); + preparent, postparent, xdata); nfs_stack_destroy (nfl, frame); return 0; } @@ -746,9 +944,11 @@ nfs_fop_symlink (xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, char *target, nfs_fop_handle_frame_create (frame, nfsx, nfu, ret, err); nfs_fop_handle_local_init (frame, nfsx, nfl, cbk, local, ret, err); nfs_fop_save_root_ino (nfl, pathloc); + nfs_fop_gfid_setup (nfl, pathloc->inode, ret, err); - STACK_WIND_COOKIE (frame, nfs_fop_symlink_cbk, xl, xl, - xl->fops->symlink, target, pathloc); + STACK_WIND_COOKIE (frame, nfs_fop_symlink_cbk, xl, xl, + xl->fops->symlink, target, pathloc, + 0, nfl->dictgfid); ret = 0; err: if (ret < 0) { @@ -763,15 +963,16 @@ err: int32_t nfs_fop_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) { struct nfs_fop_local *nfl = NULL; fop_readlink_cbk_t progcbk = NULL; nfl_to_prog_data (nfl, progcbk, frame); - nfs_fop_restore_root_ino (nfl, buf, NULL, NULL, NULL); + nfs_fop_restore_root_ino (nfl, op_ret, buf, NULL, NULL, NULL); if (progcbk) - progcbk (frame, cookie, this, op_ret, op_errno, path, buf); + progcbk (frame, cookie, this, op_ret, op_errno, path, buf, + xdata); nfs_stack_destroy (nfl, frame); return 0; } @@ -794,7 +995,7 @@ nfs_fop_readlink (xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, loc_t *pathloc, nfs_fop_save_root_ino (nfl, pathloc); STACK_WIND_COOKIE (frame, nfs_fop_readlink_cbk, xl, xl, - xl->fops->readlink, pathloc, size); + xl->fops->readlink, pathloc, size, NULL); ret = 0; err: if (ret < 0) { @@ -810,16 +1011,20 @@ int32_t nfs_fop_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) { struct nfs_fop_local *nfl = NULL; fop_mknod_cbk_t progcbk = NULL; + if (op_ret == 0) { + nfs_fix_generation(this,inode); + } + nfl_to_prog_data (nfl, progcbk, frame); - nfs_fop_restore_root_ino (nfl, buf, NULL, preparent, postparent); + nfs_fop_restore_root_ino (nfl, op_ret,buf, NULL, preparent, postparent); if (progcbk) progcbk (frame, cookie, this, op_ret, op_errno, inode, buf, - preparent, postparent); + preparent, postparent, xdata); nfs_stack_destroy (nfl, frame); return 0; } @@ -840,9 +1045,10 @@ nfs_fop_mknod (xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, loc_t *pathloc, nfs_fop_handle_frame_create (frame, nfsx, nfu, ret, err); nfs_fop_handle_local_init (frame, nfsx, nfl, cbk, local, ret, err); nfs_fop_save_root_ino (nfl, pathloc); + nfs_fop_gfid_setup (nfl, pathloc->inode, ret, err); - STACK_WIND_COOKIE (frame, nfs_fop_mknod_cbk, xl, xl, xl->fops->mknod, - pathloc, mode, dev); + STACK_WIND_COOKIE (frame, nfs_fop_mknod_cbk, xl, xl, xl->fops->mknod, + pathloc, mode, dev, 0, nfl->dictgfid); ret = 0; err: if (ret < 0) { @@ -856,16 +1062,17 @@ err: int32_t nfs_fop_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) { struct nfs_fop_local *nfl = frame->local; fop_rmdir_cbk_t progcbk = NULL; nfl_to_prog_data (nfl, progcbk, frame); - nfs_fop_restore_root_ino (nfl, NULL, NULL, preparent, postparent); + nfs_fop_restore_root_ino (nfl, op_ret, NULL, NULL, preparent, + postparent); if (progcbk) progcbk (frame, cookie, this, op_ret, op_errno, preparent, - postparent); + postparent, NULL); nfs_stack_destroy (nfl, frame); return 0; } @@ -889,7 +1096,7 @@ nfs_fop_rmdir (xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, loc_t *pathloc, nfs_fop_save_root_ino (nfl, pathloc); STACK_WIND_COOKIE (frame, nfs_fop_rmdir_cbk, xl, xl, xl->fops->rmdir, - pathloc); + pathloc, 0, NULL); ret = 0; err: if (ret < 0) { @@ -905,16 +1112,17 @@ err: int32_t nfs_fop_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) { struct nfs_fop_local *nfl = frame->local; fop_unlink_cbk_t progcbk = NULL; nfl_to_prog_data (nfl, progcbk, frame); - nfs_fop_restore_root_ino (nfl, NULL, NULL, preparent, postparent); + nfs_fop_restore_root_ino (nfl, op_ret, NULL, NULL, preparent, + postparent); if (progcbk) progcbk (frame, cookie, this, op_ret, op_errno, preparent, - postparent); + postparent, xdata); nfs_stack_destroy (nfl, frame); return 0; } @@ -937,7 +1145,7 @@ nfs_fop_unlink (xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, loc_t *pathloc, nfs_fop_save_root_ino (nfl, pathloc); STACK_WIND_COOKIE (frame, nfs_fop_unlink_cbk, xl, xl, - xl->fops->unlink, pathloc); + xl->fops->unlink, pathloc, 0, NULL); ret = 0; err: if (ret < 0) { @@ -954,16 +1162,21 @@ int32_t nfs_fop_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) { struct nfs_fop_local *nfl = NULL; fop_link_cbk_t progcbk = NULL; + if (op_ret == 0) { + nfs_fix_generation(this,inode); + } + nfl_to_prog_data (nfl, progcbk, frame); - nfs_fop_restore_root_ino (nfl, buf, NULL, preparent, postparent); + nfs_fop_restore_root_ino (nfl, op_ret, buf, NULL, preparent, + postparent); if (progcbk) progcbk (frame, cookie, this, op_ret, op_errno, inode, buf, - preparent, postparent); + preparent, postparent, xdata); nfs_stack_destroy (nfl, frame); return 0; @@ -988,7 +1201,7 @@ nfs_fop_link (xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, loc_t *oldloc, nfs_fop_save_root_ino (nfl, newloc); STACK_WIND_COOKIE (frame, nfs_fop_link_cbk, xl, xl, xl->fops->link, - oldloc, newloc); + oldloc, newloc, NULL); ret = 0; err: if (ret < 0) { @@ -1004,7 +1217,8 @@ int32_t nfs_fop_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) { struct nfs_fop_local *nfl = NULL; @@ -1013,15 +1227,16 @@ nfs_fop_rename_cbk (call_frame_t *frame, void *cookie, xlator_t *this, nfl_to_prog_data (nfl, progcbk, frame); /* The preattr arg needs to be NULL instead of @buf because it is * possible that the new parent is not root whereas the source dir - * could've been. That is handled in the next macro. + * could have been. That is handled in the next macro. */ - nfs_fop_restore_root_ino (nfl, NULL, NULL, preoldparent, postoldparent); - nfs_fop_newloc_restore_root_ino (nfl, buf, NULL, prenewparent, + nfs_fop_restore_root_ino (nfl, op_ret, NULL, NULL, preoldparent, + postoldparent); + nfs_fop_newloc_restore_root_ino (nfl, op_ret, buf, NULL, prenewparent, postnewparent); if (progcbk) progcbk (frame, cookie, this, op_ret, op_errno, buf, preoldparent, postoldparent, prenewparent, - postnewparent); + postnewparent, xdata); nfs_stack_destroy (nfl, frame); return 0; } @@ -1046,7 +1261,7 @@ nfs_fop_rename (xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, loc_t *oldloc, nfs_fop_newloc_save_root_ino (nfl, newloc); STACK_WIND_COOKIE (frame, nfs_fop_rename_cbk, xl, xl, - xl->fops->rename, oldloc, newloc); + xl->fops->rename, oldloc, newloc, NULL); ret = 0; err: if (ret < 0) { @@ -1060,14 +1275,14 @@ err: int32_t nfs_fop_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) { struct nfs_fop_local *nfl = NULL; fop_open_cbk_t progcbk = NULL; nfl_to_prog_data (nfl, progcbk, frame); if (progcbk) - progcbk (frame, cookie, this, op_ret, op_errno, fd); + progcbk (frame, cookie, this, op_ret, op_errno, fd, xdata); nfs_stack_destroy (nfl, frame); return 0; @@ -1075,7 +1290,7 @@ nfs_fop_open_cbk (call_frame_t *frame, void *cookie, xlator_t *this, int nfs_fop_open (xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, loc_t *loc, - int32_t flags, fd_t *fd, int32_t wbflags, fop_open_cbk_t cbk, + int32_t flags, fd_t *fd, fop_open_cbk_t cbk, void *local) { call_frame_t *frame = NULL; @@ -1090,7 +1305,7 @@ nfs_fop_open (xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, loc_t *loc, nfs_fop_handle_local_init (frame, nfsx, nfl, cbk, local, ret, err); STACK_WIND_COOKIE (frame, nfs_fop_open_cbk, xl, xl, xl->fops->open, - loc, flags, fd, wbflags); + loc, flags, fd, NULL); ret = 0; err: if (ret < 0) { @@ -1105,15 +1320,16 @@ err: int32_t nfs_fop_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) { struct nfs_fop_local *nfl = NULL; fop_writev_cbk_t progcbk = NULL; nfl_to_prog_data (nfl, progcbk, frame); - nfs_fop_restore_root_ino (nfl, prebuf, postbuf, NULL, NULL); + nfs_fop_restore_root_ino (nfl, op_ret, prebuf, postbuf, NULL, NULL); if (progcbk) - progcbk (frame, cookie, this, op_ret, op_errno, prebuf,postbuf); + progcbk (frame, cookie, this, op_ret, op_errno, prebuf, + postbuf, xdata); nfs_stack_destroy (nfl, frame); @@ -1123,20 +1339,20 @@ nfs_fop_writev_cbk (call_frame_t *frame, void *cookie, xlator_t *this, int nfs_fop_write (xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, fd_t *fd, - struct iobuf *srciob, struct iovec *vector, int32_t count, + struct iobref *srciobref, struct iovec *vector, int32_t count, off_t offset, fop_writev_cbk_t cbk, void *local) { call_frame_t *frame = NULL; int ret = -EFAULT; struct nfs_fop_local *nfl = NULL; - if ((!nfsx) || (!xl) || (!fd) || (!vector) || (!nfu) || (!srciob)) + if ((!nfsx) || (!xl) || (!fd) || (!vector) || (!nfu) || (!srciobref)) return ret; nfs_fop_handle_frame_create (frame, nfsx, nfu, ret, err); nfs_fop_handle_local_init (frame, nfsx, nfl, cbk, local, ret, err); nfs_fop_save_root_fd_ino (nfl, fd); - +/* nfl->iobref = iobref_new (); if (!nfl->iobref) { gf_log (GF_NFS, GF_LOG_ERROR, "iobref creation failed"); @@ -1145,8 +1361,9 @@ nfs_fop_write (xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, fd_t *fd, } iobref_add (nfl->iobref, srciob); - STACK_WIND_COOKIE (frame, nfs_fop_writev_cbk, xl, xl,xl->fops->writev - , fd, vector, count, offset, nfl->iobref); +*/ + STACK_WIND_COOKIE (frame, nfs_fop_writev_cbk, xl, xl,xl->fops->writev, + fd, vector, count, offset, fd->flags, srciobref, NULL); ret = 0; err: if (ret < 0) { @@ -1161,15 +1378,17 @@ err: int32_t nfs_fop_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) { struct nfs_fop_local *nfl = NULL; fop_fsync_cbk_t progcbk = NULL; nfl_to_prog_data (nfl, progcbk, frame); - nfs_fop_restore_root_ino (nfl, prebuf, postbuf, NULL, NULL); + nfs_fop_restore_root_ino (nfl, op_ret, prebuf, postbuf, NULL, NULL); if (progcbk) - progcbk (frame, cookie, this, op_ret, op_errno, prebuf,postbuf); + progcbk (frame, cookie, this, op_ret, op_errno, prebuf, + postbuf, xdata); + nfs_stack_destroy (nfl, frame); return 0; } @@ -1192,7 +1411,7 @@ nfs_fop_fsync (xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, fd_t *fd, nfs_fop_save_root_fd_ino (nfl, fd); STACK_WIND_COOKIE (frame, nfs_fop_fsync_cbk, xl, xl, - xl->fops->fsync, fd, datasync); + xl->fops->fsync, fd, datasync, NULL); ret = 0; err: if (ret < 0) { @@ -1207,16 +1426,17 @@ err: int32_t nfs_fop_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) { struct nfs_fop_local *nfl = NULL; fop_readv_cbk_t progcbk = NULL; nfl_to_prog_data (nfl, progcbk, frame); - nfs_fop_restore_root_ino (nfl, stbuf, NULL, NULL, NULL); + nfs_fop_restore_root_ino (nfl, op_ret, stbuf, NULL, NULL, NULL); if (progcbk) progcbk (frame, cookie, this, op_ret, op_errno, vector, count, - stbuf, iobref); + stbuf, iobref, xdata); nfs_stack_destroy (nfl, frame); return 0; @@ -1239,7 +1459,149 @@ nfs_fop_read (xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, fd_t *fd, nfs_fop_save_root_fd_ino (nfl, fd); STACK_WIND_COOKIE (frame, nfs_fop_readv_cbk, xl, xl, xl->fops->readv, - fd, size, offset); + fd, size, offset, 0, NULL); + ret = 0; +err: + if (ret < 0) { + if (frame) + nfs_stack_destroy (nfl, frame); + } + + return ret; +} + +int32_t +nfs_fop_lk_cbk (call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, struct gf_flock *flock, + dict_t *xdata) +{ + struct nfs_fop_local *nfl = NULL; + fop_lk_cbk_t progcbk = NULL; + + nfl_to_prog_data (nfl, progcbk, frame); + + if (!op_ret) + fd_lk_insert_and_merge (nfl->fd, nfl->cmd, &nfl->flock); + + fd_unref (nfl->fd); + + if (progcbk) + progcbk (frame, cookie, this, op_ret, op_errno, flock, xdata); + + nfs_stack_destroy (nfl, frame); + return 0; +} + + +int +nfs_fop_lk (xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, fd_t *fd, + int cmd, struct gf_flock *flock, fop_lk_cbk_t cbk, void *local) +{ + call_frame_t *frame = NULL; + int ret = -EFAULT; + struct nfs_fop_local *nfl = NULL; + + if ((!xl) || (!fd) || (!nfu)) + return ret; + + nfs_fop_handle_frame_create (frame, nfsx, nfu, ret, err); + nfs_fop_handle_local_init (frame, nfsx, nfl, cbk, local, ret, err); + + nfl->cmd = cmd; + nfl->fd = fd_ref (fd); + nfl->flock = *flock; + + STACK_WIND_COOKIE (frame, nfs_fop_lk_cbk, xl, xl, xl->fops->lk, + fd, cmd, flock, NULL); + ret = 0; +err: + if (ret < 0) { + if (frame) + nfs_stack_destroy (nfl, frame); + } + + return ret; +} + +int32_t +nfs_fop_getxattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, dict_t *dict, + dict_t *xdata) +{ + struct nfs_fop_local *nfl = NULL; + fop_getxattr_cbk_t progcbk = NULL; + + nfl_to_prog_data (nfl, progcbk, frame); + + if (progcbk) + progcbk (frame, cookie, this, op_ret, op_errno, dict, xdata); + + nfs_stack_destroy (nfl, frame); + return 0; +} + + +int +nfs_fop_getxattr (xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, loc_t *loc, + char *name, dict_t *xdata, fop_getxattr_cbk_t cbk, void *local) +{ + call_frame_t *frame = NULL; + int ret = -EFAULT; + struct nfs_fop_local *nfl = NULL; + + if ((!xl) || (!loc) || (!nfu)) + return ret; + + nfs_fop_handle_frame_create (frame, nfsx, nfu, ret, err); + nfs_fop_handle_local_init (frame, nfsx, nfl, cbk, local, ret, err); + + STACK_WIND_COOKIE (frame, nfs_fop_getxattr_cbk, xl, xl, xl->fops->getxattr, + loc, name, NULL); + ret = 0; +err: + if (ret < 0) { + if (frame) + nfs_stack_destroy (nfl, frame); + } + + return ret; +} + + +int32_t +nfs_fop_setxattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, dict_t *xdata) +{ + struct nfs_fop_local *nfl = NULL; + fop_setxattr_cbk_t progcbk = NULL; + + nfl_to_prog_data (nfl, progcbk, frame); + + if (progcbk) + progcbk (frame, cookie, this, op_ret, op_errno, xdata); + + nfs_stack_destroy (nfl, frame); + return 0; +} + + +int +nfs_fop_setxattr (xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, + loc_t *loc, dict_t *dict, int32_t flags, dict_t *xdata, + fop_setxattr_cbk_t cbk, void *local) +{ + call_frame_t *frame = NULL; + int ret = -EFAULT; + struct nfs_fop_local *nfl = NULL; + + if ((!xl) || (!loc) || (!nfu)) + return ret; + + nfs_fop_handle_frame_create (frame, nfsx, nfu, ret, err); + nfs_fop_handle_local_init (frame, nfsx, nfl, cbk, local, ret, err); + + STACK_WIND_COOKIE (frame, nfs_fop_setxattr_cbk, xl, xl, xl->fops->setxattr, + loc, dict, flags, xdata); ret = 0; err: if (ret < 0) { @@ -1254,15 +1616,16 @@ err: int32_t nfs_fop_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) { struct nfs_fop_local *nfl = NULL; fop_truncate_cbk_t progcbk = NULL; nfl_to_prog_data (nfl, progcbk, frame); - nfs_fop_restore_root_ino (nfl, prebuf, postbuf, NULL, NULL); + nfs_fop_restore_root_ino (nfl, op_ret, prebuf, postbuf, NULL, NULL); if (progcbk) - progcbk (frame, cookie, this, op_ret, op_errno, prebuf,postbuf); + progcbk (frame, cookie, this, op_ret, op_errno, prebuf, + postbuf, xdata); nfs_stack_destroy (nfl, frame); return 0; @@ -1285,7 +1648,7 @@ nfs_fop_truncate (xlator_t *nfsx, xlator_t *xl, nfs_user_t *nfu, loc_t *loc, nfs_fop_save_root_ino (nfl, loc); STACK_WIND_COOKIE (frame, nfs_fop_truncate_cbk, xl, xl, - xl->fops->truncate, loc, offset); + xl->fops->truncate, loc, offset, NULL); ret = 0; err: |