diff options
Diffstat (limited to 'libglusterfs/src/call-stub.c')
| -rw-r--r-- | libglusterfs/src/call-stub.c | 3822 |
1 files changed, 3822 insertions, 0 deletions
diff --git a/libglusterfs/src/call-stub.c b/libglusterfs/src/call-stub.c new file mode 100644 index 00000000000..cd735725960 --- /dev/null +++ b/libglusterfs/src/call-stub.c @@ -0,0 +1,3822 @@ +/* + Copyright (c) 2007, 2008 Z RESEARCH, Inc. <http://www.zresearch.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/>. +*/ + +#ifndef _CONFIG_H +#define _CONFIG_H +#include "config.h" +#endif + +#include "call-stub.h" + + +static call_stub_t * +stub_new (call_frame_t *frame, + char wind, + glusterfs_fop_t fop) +{ + call_stub_t *new = NULL; + + GF_VALIDATE_OR_GOTO ("call-stub", frame, out); + + new = CALLOC (1, sizeof (*new)); + GF_VALIDATE_OR_GOTO ("call-stub", new, out); + + new->frame = frame; + new->wind = wind; + new->fop = fop; + + INIT_LIST_HEAD (&new->list); +out: + return new; +} + + +call_stub_t * +fop_lookup_stub (call_frame_t *frame, + fop_lookup_t fn, + loc_t *loc, + dict_t *xattr_req) +{ + call_stub_t *stub = NULL; + + GF_VALIDATE_OR_GOTO ("call-stub", frame, out); + GF_VALIDATE_OR_GOTO ("call-stub", loc, out); + + stub = stub_new (frame, 1, GF_FOP_LOOKUP); + GF_VALIDATE_OR_GOTO ("call-stub", stub, out); + + stub->args.lookup.fn = fn; + + if (xattr_req) + stub->args.lookup.xattr_req = dict_ref (xattr_req); + + loc_copy (&stub->args.lookup.loc, loc); +out: + return stub; +} + + +call_stub_t * +fop_lookup_cbk_stub (call_frame_t *frame, + fop_lookup_cbk_t fn, + int32_t op_ret, + int32_t op_errno, + inode_t *inode, + struct stat *buf, + dict_t *dict) +{ + call_stub_t *stub = NULL; + + GF_VALIDATE_OR_GOTO ("call-stub", frame, out); + + stub = stub_new (frame, 0, GF_FOP_LOOKUP); + GF_VALIDATE_OR_GOTO ("call-stub", stub, out); + + stub->args.lookup_cbk.fn = fn; + stub->args.lookup_cbk.op_ret = op_ret; + stub->args.lookup_cbk.op_errno = op_errno; + if (inode) + stub->args.lookup_cbk.inode = inode_ref (inode); + if (buf) + stub->args.lookup_cbk.buf = *buf; + if (dict) + stub->args.lookup_cbk.dict = dict_ref (dict); +out: + return stub; +} + + + +call_stub_t * +fop_stat_stub (call_frame_t *frame, + fop_stat_t fn, + loc_t *loc) +{ + call_stub_t *stub = NULL; + + GF_VALIDATE_OR_GOTO ("call-stub", frame, out); + GF_VALIDATE_OR_GOTO ("call-stub", loc, out); + + stub = stub_new (frame, 1, GF_FOP_STAT); + GF_VALIDATE_OR_GOTO ("call-stub", stub, out); + + stub->args.stat.fn = fn; + loc_copy (&stub->args.stat.loc, loc); +out: + return stub; +} + + +call_stub_t * +fop_stat_cbk_stub (call_frame_t *frame, + fop_stat_cbk_t fn, + int32_t op_ret, + int32_t op_errno, + struct stat *buf) +{ + call_stub_t *stub = NULL; + + GF_VALIDATE_OR_GOTO ("call-stub", frame, out); + + stub = stub_new (frame, 0, GF_FOP_STAT); + GF_VALIDATE_OR_GOTO ("call-stub", stub, out); + + stub->args.stat_cbk.fn = fn; + stub->args.stat_cbk.op_ret = op_ret; + stub->args.stat_cbk.op_errno = op_errno; + if (op_ret == 0) + stub->args.stat_cbk.buf = *buf; +out: + return stub; +} + + +call_stub_t * +fop_fstat_stub (call_frame_t *frame, + fop_fstat_t fn, + fd_t *fd) +{ + call_stub_t *stub = NULL; + + GF_VALIDATE_OR_GOTO ("call-stub", frame, out); + + stub = stub_new (frame, 1, GF_FOP_FSTAT); + GF_VALIDATE_OR_GOTO ("call-stub", stub, out); + + stub->args.fstat.fn = fn; + + if (fd) + stub->args.fstat.fd = fd_ref (fd); +out: + return stub; +} + + +call_stub_t * +fop_fstat_cbk_stub (call_frame_t *frame, + fop_fstat_cbk_t fn, + int32_t op_ret, + int32_t op_errno, + struct stat *buf) +{ + call_stub_t *stub = NULL; + + GF_VALIDATE_OR_GOTO ("call-stub", frame, out); + + stub = stub_new (frame, 0, GF_FOP_FSTAT); + GF_VALIDATE_OR_GOTO ("call-stub", stub, out); + + stub->args.fstat_cbk.fn = fn; + stub->args.fstat_cbk.op_ret = op_ret; + stub->args.fstat_cbk.op_errno = op_errno; + if (buf) + stub->args.fstat_cbk.buf = *buf; +out: + return stub; +} + + +call_stub_t * +fop_chmod_stub (call_frame_t *frame, + fop_chmod_t fn, + loc_t *loc, + mode_t mode) +{ + call_stub_t *stub = NULL; + + GF_VALIDATE_OR_GOTO ("call-stub", frame, out); + GF_VALIDATE_OR_GOTO ("call-stub", loc, out); + + stub = stub_new (frame, 1, GF_FOP_CHMOD); + GF_VALIDATE_OR_GOTO ("call-stub", stub, out); + + stub->args.chmod.fn = fn; + loc_copy (&stub->args.chmod.loc, loc); + stub->args.chmod.mode = mode; +out: + return stub; +} + + +call_stub_t * +fop_chmod_cbk_stub (call_frame_t *frame, + fop_chmod_cbk_t fn, + int32_t op_ret, + int32_t op_errno, + struct stat *buf) +{ + call_stub_t *stub = NULL; + + GF_VALIDATE_OR_GOTO ("call-stub", frame, out); + + stub = stub_new (frame, 0, GF_FOP_CHMOD); + GF_VALIDATE_OR_GOTO ("call-stub", stub, out); + + stub->args.chmod_cbk.fn = fn; + stub->args.chmod_cbk.op_ret = op_ret; + stub->args.chmod_cbk.op_errno = op_errno; + if (buf) + stub->args.chmod_cbk.buf = *buf; +out: + return stub; +} + + +call_stub_t * +fop_fchmod_stub (call_frame_t *frame, + fop_fchmod_t fn, + fd_t *fd, + mode_t mode) +{ + call_stub_t *stub = NULL; + + GF_VALIDATE_OR_GOTO ("call-stub", frame, out); + + stub = stub_new (frame, 1, GF_FOP_FCHMOD); + GF_VALIDATE_OR_GOTO ("call-stub", stub, out); + + stub->args.fchmod.fn = fn; + if (fd) + stub->args.fchmod.fd = fd_ref (fd); + stub->args.fchmod.mode = mode; +out: + return stub; +} + + +call_stub_t * +fop_fchmod_cbk_stub (call_frame_t *frame, + fop_fchmod_cbk_t fn, + int32_t op_ret, + int32_t op_errno, + struct stat *buf) +{ + call_stub_t *stub = NULL; + + GF_VALIDATE_OR_GOTO ("call-stub", frame, out); + + stub = stub_new (frame, 0, GF_FOP_FCHMOD); + GF_VALIDATE_OR_GOTO ("call-stub", stub, out); + + stub->args.fchmod_cbk.fn = fn; + stub->args.fchmod_cbk.op_ret = op_ret; + stub->args.fchmod_cbk.op_errno = op_errno; + if (buf) + stub->args.fchmod_cbk.buf = *buf; +out: + return stub; +} + + +call_stub_t * +fop_chown_stub (call_frame_t *frame, + fop_chown_t fn, + loc_t *loc, + uid_t uid, + gid_t gid) +{ + call_stub_t *stub = NULL; + + GF_VALIDATE_OR_GOTO ("call-stub", frame, out); + GF_VALIDATE_OR_GOTO ("call-stub", loc, out); + + stub = stub_new (frame, 1, GF_FOP_CHOWN); + GF_VALIDATE_OR_GOTO ("call-stub", stub, out); + + stub->args.chown.fn = fn; + loc_copy (&stub->args.chown.loc, loc); + stub->args.chown.uid = uid; + stub->args.chown.gid = gid; +out: + return stub; +} + + +call_stub_t * +fop_chown_cbk_stub (call_frame_t *frame, + fop_chown_cbk_t fn, + int32_t op_ret, + int32_t op_errno, + struct stat *buf) +{ + call_stub_t *stub = NULL; + + GF_VALIDATE_OR_GOTO ("call-stub", frame, out); + + stub = stub_new (frame, 0, GF_FOP_CHOWN); + GF_VALIDATE_OR_GOTO ("call-stub", stub, out); + + stub->args.chown_cbk.fn = fn; + stub->args.chown_cbk.op_ret = op_ret; + stub->args.chown_cbk.op_errno = op_errno; + if (buf) + stub->args.chown_cbk.buf = *buf; +out: + return stub; +} + + +call_stub_t * +fop_fchown_stub (call_frame_t *frame, + fop_fchown_t fn, + fd_t *fd, + uid_t uid, + gid_t gid) +{ + call_stub_t *stub = NULL; + + GF_VALIDATE_OR_GOTO ("call-stub", frame, out); + + stub = stub_new (frame, 1, GF_FOP_FCHOWN); + GF_VALIDATE_OR_GOTO ("call-stub", stub, out); + + stub->args.fchown.fn = fn; + if (fd) + stub->args.fchown.fd = fd_ref (fd); + stub->args.fchown.uid = uid; + stub->args.fchown.gid = gid; +out: + return stub; +} + + +call_stub_t * +fop_fchown_cbk_stub (call_frame_t *frame, + fop_fchown_cbk_t fn, + int32_t op_ret, + int32_t op_errno, + struct stat *buf) +{ + call_stub_t *stub = NULL; + + GF_VALIDATE_OR_GOTO ("call-stub", frame, out); + + stub = stub_new (frame, 0, GF_FOP_FCHOWN); + GF_VALIDATE_OR_GOTO ("call-stub", stub, out); + + stub->args.fchown_cbk.fn = fn; + stub->args.fchown_cbk.op_ret = op_ret; + stub->args.fchown_cbk.op_errno = op_errno; + if (buf) + stub->args.fchown_cbk.buf = *buf; +out: + return stub; +} + + +/* truncate */ + +call_stub_t * +fop_truncate_stub (call_frame_t *frame, + fop_truncate_t fn, + loc_t *loc, + off_t off) +{ + call_stub_t *stub = NULL; + + GF_VALIDATE_OR_GOTO ("call-stub", frame, out); + GF_VALIDATE_OR_GOTO ("call-stub", loc, out); + + stub = stub_new (frame, 1, GF_FOP_TRUNCATE); + GF_VALIDATE_OR_GOTO ("call-stub", stub, out); + + stub->args.truncate.fn = fn; + loc_copy (&stub->args.truncate.loc, loc); + stub->args.truncate.off = off; +out: + return stub; +} + + +call_stub_t * +fop_truncate_cbk_stub (call_frame_t *frame, + fop_truncate_cbk_t fn, + int32_t op_ret, + int32_t op_errno, + struct stat *buf) +{ + call_stub_t *stub = NULL; + + GF_VALIDATE_OR_GOTO ("call-stub", frame, out); + + stub = stub_new (frame, 0, GF_FOP_TRUNCATE); + GF_VALIDATE_OR_GOTO ("call-stub", stub, out); + + stub->args.truncate_cbk.fn = fn; + stub->args.truncate_cbk.op_ret = op_ret; + stub->args.truncate_cbk.op_errno = op_errno; + if (buf) + stub->args.truncate_cbk.buf = *buf; +out: + return stub; +} + + +call_stub_t * +fop_ftruncate_stub (call_frame_t *frame, + fop_ftruncate_t fn, + fd_t *fd, + off_t off) +{ + call_stub_t *stub = NULL; + + GF_VALIDATE_OR_GOTO ("call-stub", frame, out); + + stub = stub_new (frame, 1, GF_FOP_FTRUNCATE); + GF_VALIDATE_OR_GOTO ("call-stub", stub, out); + + stub->args.ftruncate.fn = fn; + if (fd) + stub->args.ftruncate.fd = fd_ref (fd); + + stub->args.ftruncate.off = off; +out: + return stub; +} + + +call_stub_t * +fop_ftruncate_cbk_stub (call_frame_t *frame, + fop_ftruncate_cbk_t fn, + int32_t op_ret, + int32_t op_errno, + struct stat *buf) +{ + call_stub_t *stub = NULL; + + GF_VALIDATE_OR_GOTO ("call-stub", frame, out); + + stub = stub_new (frame, 0, GF_FOP_FTRUNCATE); + GF_VALIDATE_OR_GOTO ("call-stub", stub, out); + + stub->args.ftruncate_cbk.fn = fn; + stub->args.ftruncate_cbk.op_ret = op_ret; + stub->args.ftruncate_cbk.op_errno = op_errno; + if (buf) + stub->args.ftruncate_cbk.buf = *buf; +out: + return stub; +} + + +call_stub_t * +fop_utimens_stub (call_frame_t *frame, + fop_utimens_t fn, + loc_t *loc, + struct timespec tv[2]) +{ + call_stub_t *stub = NULL; + + GF_VALIDATE_OR_GOTO ("call-stub", frame, out); + GF_VALIDATE_OR_GOTO ("call-stub", loc, out); + + stub = stub_new (frame, 1, GF_FOP_UTIMENS); + GF_VALIDATE_OR_GOTO ("call-stub", stub, out); + + stub->args.utimens.fn = fn; + loc_copy (&stub->args.utimens.loc, loc); + stub->args.utimens.tv[0] = tv[0]; + stub->args.utimens.tv[1] = tv[1]; +out: + return stub; +} + + +call_stub_t * +fop_utimens_cbk_stub (call_frame_t *frame, + fop_utimens_cbk_t fn, + int32_t op_ret, + int32_t op_errno, + struct stat *buf) +{ + call_stub_t *stub = NULL; + + GF_VALIDATE_OR_GOTO ("call-stub", frame, out); + + stub = stub_new (frame, 0, GF_FOP_UTIMENS); + GF_VALIDATE_OR_GOTO ("call-stub", stub, out); + + stub->args.utimens_cbk.fn = fn; + stub->args.utimens_cbk.op_ret = op_ret; + stub->args.utimens_cbk.op_errno = op_errno; + if (buf) + stub->args.utimens_cbk.buf = *buf; +out: + return stub; +} + + +call_stub_t * +fop_access_stub (call_frame_t *frame, + fop_access_t fn, + loc_t *loc, + int32_t mask) +{ + call_stub_t *stub = NULL; + + GF_VALIDATE_OR_GOTO ("call-stub", frame, out); + GF_VALIDATE_OR_GOTO ("call-stub", loc, out); + + stub = stub_new (frame, 1, GF_FOP_ACCESS); + GF_VALIDATE_OR_GOTO ("call-stub", stub, out); + + stub->args.access.fn = fn; + loc_copy (&stub->args.access.loc, loc); + stub->args.access.mask = mask; +out: + return stub; +} + + +call_stub_t * +fop_access_cbk_stub (call_frame_t *frame, + fop_access_cbk_t fn, + int32_t op_ret, + int32_t op_errno) +{ + call_stub_t *stub = NULL; + + GF_VALIDATE_OR_GOTO ("call-stub", frame, out); + + stub = stub_new (frame, 0, GF_FOP_ACCESS); + GF_VALIDATE_OR_GOTO ("call-stub", stub, out); + + stub->args.access_cbk.fn = fn; + stub->args.access_cbk.op_ret = op_ret; + stub->args.access_cbk.op_errno = op_errno; +out: + return stub; +} + + +call_stub_t * +fop_readlink_stub (call_frame_t *frame, + fop_readlink_t fn, + loc_t *loc, + size_t size) +{ + call_stub_t *stub = NULL; + + GF_VALIDATE_OR_GOTO ("call-stub", frame, out); + GF_VALIDATE_OR_GOTO ("call-stub", loc, out); + + stub = stub_new (frame, 1, GF_FOP_READLINK); + GF_VALIDATE_OR_GOTO ("call-stub", stub, out); + + stub->args.readlink.fn = fn; + loc_copy (&stub->args.readlink.loc, loc); + stub->args.readlink.size = size; +out: + return stub; +} + + +call_stub_t * +fop_readlink_cbk_stub (call_frame_t *frame, + fop_readlink_cbk_t fn, + int32_t op_ret, + int32_t op_errno, + const char *path) +{ + call_stub_t *stub = NULL; + + GF_VALIDATE_OR_GOTO ("call-stub", frame, out); + + stub = stub_new (frame, 0, GF_FOP_READLINK); + GF_VALIDATE_OR_GOTO ("call-stub", stub, out); + + stub->args.readlink_cbk.fn = fn; + stub->args.readlink_cbk.op_ret = op_ret; + stub->args.readlink_cbk.op_errno = op_errno; + if (path) + stub->args.readlink_cbk.buf = strdup (path); +out: + return stub; +} + + +call_stub_t * +fop_mknod_stub (call_frame_t *frame, + fop_mknod_t fn, + loc_t *loc, + mode_t mode, + dev_t rdev) +{ + call_stub_t *stub = NULL; + + GF_VALIDATE_OR_GOTO ("call-stub", frame, out); + GF_VALIDATE_OR_GOTO ("call-stub", loc, out); + + stub = stub_new (frame, 1, GF_FOP_MKNOD); + GF_VALIDATE_OR_GOTO ("call-stub", stub, out); + + stub->args.mknod.fn = fn; + loc_copy (&stub->args.mknod.loc, loc); + stub->args.mknod.mode = mode; + stub->args.mknod.rdev = rdev; +out: + return stub; +} + + +call_stub_t * +fop_mknod_cbk_stub (call_frame_t *frame, + fop_mknod_cbk_t fn, + int32_t op_ret, + int32_t op_errno, + inode_t *inode, + struct stat *buf) +{ + call_stub_t *stub = NULL; + + GF_VALIDATE_OR_GOTO ("call-stub", frame, out); + + stub = stub_new (frame, 0, GF_FOP_MKNOD); + GF_VALIDATE_OR_GOTO ("call-stub", stub, out); + + stub->args.mknod_cbk.fn = fn; + stub->args.mknod_cbk.op_ret = op_ret; + stub->args.mknod_cbk.op_errno = op_errno; + if (inode) + stub->args.mknod_cbk.inode = inode_ref (inode); + if (buf) + stub->args.mknod_cbk.buf = *buf; +out: + return stub; +} + + +call_stub_t * +fop_mkdir_stub (call_frame_t *frame, + fop_mkdir_t fn, + loc_t *loc, + mode_t mode) +{ + call_stub_t *stub = NULL; + + GF_VALIDATE_OR_GOTO ("call-stub", frame, out); + GF_VALIDATE_OR_GOTO ("call-stub", loc, out); + + stub = stub_new (frame, 1, GF_FOP_MKDIR); + GF_VALIDATE_OR_GOTO ("call-stub", stub, out); + + stub->args.mkdir.fn = fn; + loc_copy (&stub->args.mkdir.loc, loc); + stub->args.mkdir.mode = mode; +out: + return stub; +} + + +call_stub_t * +fop_mkdir_cbk_stub (call_frame_t *frame, + fop_mkdir_cbk_t fn, + int32_t op_ret, + int32_t op_errno, + inode_t *inode, + struct stat *buf) +{ + call_stub_t *stub = NULL; + + GF_VALIDATE_OR_GOTO ("call-stub", frame, out); + + stub = stub_new (frame, 0, GF_FOP_MKDIR); + GF_VALIDATE_OR_GOTO ("call-stub", stub, out); + + stub->args.mkdir_cbk.fn = fn; + stub->args.mkdir_cbk.op_ret = op_ret; + stub->args.mkdir_cbk.op_errno = op_errno; + if (inode) + stub->args.mkdir_cbk.inode = inode_ref (inode); + if (buf) + stub->args.mkdir_cbk.buf = *buf; +out: + return stub; +} + + +call_stub_t * +fop_unlink_stub (call_frame_t *frame, + fop_unlink_t fn, + loc_t *loc) +{ + call_stub_t *stub = NULL; + + GF_VALIDATE_OR_GOTO ("call-stub", frame, out); + GF_VALIDATE_OR_GOTO ("call-stub", loc, out); + + stub = stub_new (frame, 1, GF_FOP_UNLINK); + GF_VALIDATE_OR_GOTO ("call-stub", stub, out); + + stub->args.unlink.fn = fn; + loc_copy (&stub->args.unlink.loc, loc); +out: + return stub; +} + + +call_stub_t * +fop_unlink_cbk_stub (call_frame_t *frame, + fop_unlink_cbk_t fn, + int32_t op_ret, + int32_t op_errno) +{ + call_stub_t *stub = NULL; + + GF_VALIDATE_OR_GOTO ("call-stub", frame, out); + + stub = stub_new (frame, 0, GF_FOP_UNLINK); + GF_VALIDATE_OR_GOTO ("call-stub", stub, out); + + stub->args.unlink_cbk.fn = fn; + stub->args.unlink_cbk.op_ret = op_ret; + stub->args.unlink_cbk.op_errno = op_errno; +out: + return stub; +} + + + +call_stub_t * +fop_rmdir_stub (call_frame_t *frame, + fop_rmdir_t fn, + loc_t *loc) +{ + call_stub_t *stub = NULL; + + GF_VALIDATE_OR_GOTO ("call-stub", frame, out); + GF_VALIDATE_OR_GOTO ("call-stub", loc, out); + + stub = stub_new (frame, 1, GF_FOP_RMDIR); + GF_VALIDATE_OR_GOTO ("call-stub", stub, out); + + stub->args.rmdir.fn = fn; + loc_copy (&stub->args.rmdir.loc, loc); +out: + return stub; +} + + +call_stub_t * +fop_rmdir_cbk_stub (call_frame_t *frame, + fop_rmdir_cbk_t fn, + int32_t op_ret, + int32_t op_errno) +{ + call_stub_t *stub = NULL; + + GF_VALIDATE_OR_GOTO ("call-stub", frame, out); + + stub = stub_new (frame, 0, GF_FOP_RMDIR); + GF_VALIDATE_OR_GOTO ("call-stub", stub, out); + + stub->args.rmdir_cbk.fn = fn; + stub->args.rmdir_cbk.op_ret = op_ret; + stub->args.rmdir_cbk.op_errno = op_errno; +out: + return stub; +} + + +call_stub_t * +fop_symlink_stub (call_frame_t *frame, + fop_symlink_t fn, + const char *linkname, + loc_t *loc) +{ + call_stub_t *stub = NULL; + + GF_VALIDATE_OR_GOTO ("call-stub", frame, out); + GF_VALIDATE_OR_GOTO ("call-stub", loc, out); + GF_VALIDATE_OR_GOTO ("call-stub", linkname, out); + + stub = stub_new (frame, 1, GF_FOP_SYMLINK); + GF_VALIDATE_OR_GOTO ("call-stub", stub, out); + + stub->args.symlink.fn = fn; + stub->args.symlink.linkname = strdup (linkname); + loc_copy (&stub->args.symlink.loc, loc); +out: + return stub; +} + + +call_stub_t * +fop_symlink_cbk_stub (call_frame_t *frame, + fop_symlink_cbk_t fn, + int32_t op_ret, + int32_t op_errno, + inode_t *inode, + struct stat *buf) +{ + call_stub_t *stub = NULL; + + GF_VALIDATE_OR_GOTO ("call-stub", frame, out); + + stub = stub_new (frame, 0, GF_FOP_SYMLINK); + GF_VALIDATE_OR_GOTO ("call-stub", stub, out); + + stub->args.symlink_cbk.fn = fn; + stub->args.symlink_cbk.op_ret = op_ret; + stub->args.symlink_cbk.op_errno = op_errno; + if (inode) + stub->args.symlink_cbk.inode = inode_ref (inode); + if (buf) + stub->args.symlink_cbk.buf = *buf; +out: + return stub; +} + + +call_stub_t * +fop_rename_stub (call_frame_t *frame, + fop_rename_t fn, + loc_t *oldloc, + loc_t *newloc) +{ + call_stub_t *stub = NULL; + + GF_VALIDATE_OR_GOTO ("call-stub", frame, out); + GF_VALIDATE_OR_GOTO ("call-stub", oldloc, out); + GF_VALIDATE_OR_GOTO ("call-stub", newloc, out); + + stub = stub_new (frame, 1, GF_FOP_RENAME); + GF_VALIDATE_OR_GOTO ("call-stub", stub, out); + + stub->args.rename.fn = fn; + loc_copy (&stub->args.rename.old, oldloc); + loc_copy (&stub->args.rename.new, newloc); +out: + return stub; +} + + +call_stub_t * +fop_rename_cbk_stub (call_frame_t *frame, + fop_rename_cbk_t fn, + int32_t op_ret, + int32_t op_errno, + struct stat *buf) +{ + call_stub_t *stub = NULL; + + GF_VALIDATE_OR_GOTO ("call-stub", frame, out); + + stub = stub_new (frame, 0, GF_FOP_RENAME); + GF_VALIDATE_OR_GOTO ("call-stub", stub, out); + + stub->args.rename_cbk.fn = fn; + stub->args.rename_cbk.op_ret = op_ret; + stub->args.rename_cbk.op_errno = op_errno; + if (buf) + stub->args.rename_cbk.buf = *buf; +out: + return stub; +} + + +call_stub_t * +fop_link_stub (call_frame_t *frame, + fop_link_t fn, + loc_t *oldloc, + loc_t *newloc) +{ + call_stub_t *stub = NULL; + + GF_VALIDATE_OR_GOTO ("call-stub", frame, out); + GF_VALIDATE_OR_GOTO ("call-stub", oldloc, out); + GF_VALIDATE_OR_GOTO ("call-stub", newloc, out); + + stub = stub_new (frame, 1, GF_FOP_LINK); + GF_VALIDATE_OR_GOTO ("call-stub", stub, out); + + stub->args.link.fn = fn; + loc_copy (&stub->args.link.oldloc, oldloc); + loc_copy (&stub->args.link.newloc, newloc); + +out: + return stub; +} + + +call_stub_t * +fop_link_cbk_stub (call_frame_t *frame, + fop_link_cbk_t fn, + int32_t op_ret, + int32_t op_errno, + inode_t *inode, + struct stat *buf) +{ + call_stub_t *stub = NULL; + + GF_VALIDATE_OR_GOTO ("call-stub", frame, out); + + stub = stub_new (frame, 0, GF_FOP_LINK); + GF_VALIDATE_OR_GOTO ("call-stub", stub, out); + + stub->args.link_cbk.fn = fn; + stub->args.link_cbk.op_ret = op_ret; + stub->args.link_cbk.op_errno = op_errno; + if (inode) + stub->args.link_cbk.inode = inode_ref (inode); + if (buf) + stub->args.link_cbk.buf = *buf; +out: + return stub; +} + + +call_stub_t * +fop_create_stub (call_frame_t *frame, + fop_create_t fn, + loc_t *loc, + int32_t flags, + mode_t mode, fd_t *fd) +{ + call_stub_t *stub = NULL; + + GF_VALIDATE_OR_GOTO ("call-stub", frame, out); + GF_VALIDATE_OR_GOTO ("call-stub", loc, out); + + stub = stub_new (frame, 1, GF_FOP_CREATE); + GF_VALIDATE_OR_GOTO ("call-stub", stub, out); + + stub->args.create.fn = fn; + loc_copy (&stub->args.create.loc, loc); + stub->args.create.flags = flags; + stub->args.create.mode = mode; + if (fd) + stub->args.create.fd = fd_ref (fd); +out: + return stub; +} + + +call_stub_t * +fop_create_cbk_stub (call_frame_t *frame, + fop_create_cbk_t fn, + int32_t op_ret, + int32_t op_errno, + fd_t *fd, + inode_t *inode, + struct stat *buf) +{ + call_stub_t *stub = NULL; + + GF_VALIDATE_OR_GOTO ("call-stub", frame, out); + + stub = stub_new (frame, 0, GF_FOP_CREATE); + GF_VALIDATE_OR_GOTO ("call-stub", stub, out); + + stub->args.create_cbk.fn = fn; + stub->args.create_cbk.op_ret = op_ret; + stub->args.create_cbk.op_errno = op_errno; + if (fd) + stub->args.create_cbk.fd = fd_ref (fd); + if (inode) + stub->args.create_cbk.inode = inode_ref (inode); + if (buf) + stub->args.create_cbk.buf = *buf; +out: + return stub; +} + + +call_stub_t * +fop_open_stub (call_frame_t *frame, + fop_open_t fn, + loc_t *loc, + int32_t flags, fd_t *fd) +{ + call_stub_t *stub = NULL; + + GF_VALIDATE_OR_GOTO ("call-stub", frame, out); + GF_VALIDATE_OR_GOTO ("call-stub", loc, out); + + stub = stub_new (frame, 1, GF_FOP_OPEN); + GF_VALIDATE_OR_GOTO ("call-stub", stub, out); + + stub->args.open.fn = fn; + loc_copy (&stub->args.open.loc, loc); + stub->args.open.flags = flags; + if (fd) + stub->args.open.fd = fd_ref (fd); +out: + return stub; +} + + +call_stub_t * +fop_open_cbk_stub (call_frame_t *frame, + fop_open_cbk_t fn, + int32_t op_ret, + int32_t op_errno, + fd_t *fd) + +{ + call_stub_t *stub = NULL; + + GF_VALIDATE_OR_GOTO ("call-stub", frame, out); + + stub = stub_new (frame, 0, GF_FOP_OPEN); + GF_VALIDATE_OR_GOTO ("call-stub", stub, out); + + stub->args.open_cbk.fn = fn; + stub->args.open_cbk.op_ret = op_ret; + stub->args.open_cbk.op_errno = op_errno; + if (fd) + stub->args.open_cbk.fd = fd_ref (fd); +out: + return stub; +} + + +call_stub_t * +fop_readv_stub (call_frame_t *frame, + fop_readv_t fn, + fd_t *fd, + size_t size, + off_t off) +{ + call_stub_t *stub = NULL; + + GF_VALIDATE_OR_GOTO ("call-stub", frame, out); + + stub = stub_new (frame, 1, GF_FOP_READ); + GF_VALIDATE_OR_GOTO ("call-stub", stub, out); + + stub->args.readv.fn = fn; + if (fd) + stub->args.readv.fd = fd_ref (fd); + stub->args.readv.size = size; + stub->args.readv.off = off; +out: + return stub; +} + + +call_stub_t * +fop_readv_cbk_stub (call_frame_t *frame, + fop_readv_cbk_t fn, + int32_t op_ret, + int32_t op_errno, + struct iovec *vector, + int32_t count, + struct stat *stbuf) + +{ + call_stub_t *stub = NULL; + + GF_VALIDATE_OR_GOTO ("call-stub", frame, out); + + stub = stub_new (frame, 0, GF_FOP_READ); + GF_VALIDATE_OR_GOTO ("call-stub", stub, out); + + stub->args.readv_cbk.fn = fn; + stub->args.readv_cbk.op_ret = op_ret; + stub->args.readv_cbk.op_errno = op_errno; + if (op_ret >= 0) { + stub->args.readv_cbk.vector = iov_dup (vector, count); + stub->args.readv_cbk.count = count; + stub->args.readv_cbk.stbuf = *stbuf; + stub->args.readv_cbk.rsp_refs = + dict_ref (frame->root->rsp_refs); + } +out: + return stub; +} + + +call_stub_t * +fop_writev_stub (call_frame_t *frame, + fop_writev_t fn, + fd_t *fd, + struct iovec *vector, + int32_t count, + off_t off) +{ + call_stub_t *stub = NULL; + + GF_VALIDATE_OR_GOTO ("call-stub", frame, out); + GF_VALIDATE_OR_GOTO ("call-stub", vector, out); + + stub = stub_new (frame, 1, GF_FOP_WRITE); + GF_VALIDATE_OR_GOTO ("call-stub", stub, out); + + stub->args.writev.fn = fn; + if (fd) + stub->args.writev.fd = fd_ref (fd); + stub->args.writev.vector = iov_dup (vector, count); + stub->args.writev.count = count; + stub->args.writev.off = off; + + if (frame->root->req_refs) + stub->args.writev.req_refs = dict_ref (frame->root->req_refs); +out: + return stub; +} + + +call_stub_t * +fop_writev_cbk_stub (call_frame_t *frame, + fop_writev_cbk_t fn, + int32_t op_ret, + int32_t op_errno, + struct stat *stbuf) + +{ + call_stub_t *stub = NULL; + + GF_VALIDATE_OR_GOTO ("call-stub", frame, out); + + stub = stub_new (frame, 0, GF_FOP_WRITE); + GF_VALIDATE_OR_GOTO ("call-stub", stub, out); + + stub->args.writev_cbk.fn = fn; + stub->args.writev_cbk.op_ret = op_ret; + stub->args.writev_cbk.op_errno = op_errno; + if (op_ret >= 0) + stub->args.writev_cbk.stbuf = *stbuf; +out: + return stub; +} + + + +call_stub_t * +fop_flush_stub (call_frame_t *frame, + fop_flush_t fn, + fd_t *fd) +{ + call_stub_t *stub = NULL; + + GF_VALIDATE_OR_GOTO ("call-stub", frame, out); + + stub = stub_new (frame, 1, GF_FOP_FLUSH); + GF_VALIDATE_OR_GOTO ("call-stub", stub, out); + + stub->args.flush.fn = fn; + if (fd) + stub->args.flush.fd = fd_ref (fd); +out: + return stub; +} + + +call_stub_t * +fop_flush_cbk_stub (call_frame_t *frame, + fop_flush_cbk_t fn, + int32_t op_ret, + int32_t op_errno) + +{ + call_stub_t *stub = NULL; + + GF_VALIDATE_OR_GOTO ("call-stub", frame, out); + + stub = stub_new (frame, 0, GF_FOP_FLUSH); + GF_VALIDATE_OR_GOTO ("call-stub", stub, out); + + stub->args.flush_cbk.fn = fn; + stub->args.flush_cbk.op_ret = op_ret; + stub->args.flush_cbk.op_errno = op_errno; +out: + return stub; +} + + + + +call_stub_t * +fop_fsync_stub (call_frame_t *frame, + fop_fsync_t fn, + fd_t *fd, + int32_t datasync) +{ + call_stub_t *stub = NULL; + + GF_VALIDATE_OR_GOTO ("call-stub", frame, out); + + stub = stub_new (frame, 1, GF_FOP_FSYNC); + GF_VALIDATE_OR_GOTO ("call-stub", stub, out); + + stub->args.fsync.fn = fn; + if (fd) + stub->args.fsync.fd = fd_ref (fd); + stub->args.fsync.datasync = datasync; +out: + return stub; +} + + +call_stub_t * +fop_fsync_cbk_stub (call_frame_t *frame, + fop_fsync_cbk_t fn, + int32_t op_ret, + int32_t op_errno) + +{ + call_stub_t *stub = NULL; + + GF_VALIDATE_OR_GOTO ("call-stub", frame, out); + + stub = stub_new (frame, 0, GF_FOP_FSYNC); + GF_VALIDATE_OR_GOTO ("call-stub", stub, out); + + stub->args.fsync_cbk.fn = fn; + stub->args.fsync_cbk.op_ret = op_ret; + stub->args.fsync_cbk.op_errno = op_errno; +out: + return stub; +} + + +call_stub_t * +fop_opendir_stub (call_frame_t *frame, + fop_opendir_t fn, + loc_t *loc, fd_t *fd) +{ + call_stub_t *stub = NULL; + + GF_VALIDATE_OR_GOTO ("call-stub", frame, out); + GF_VALIDATE_OR_GOTO ("call-stub", loc, out); + + stub = stub_new (frame, 1, GF_FOP_OPENDIR); + GF_VALIDATE_OR_GOTO ("call-stub", stub, out); + + stub->args.opendir.fn = fn; + loc_copy (&stub->args.opendir.loc, loc); + if (stub->args.opendir.fd) + stub->args.opendir.fd = fd_ref (fd); +out: + return stub; +} + + +call_stub_t * +fop_opendir_cbk_stub (call_frame_t *frame, + fop_opendir_cbk_t fn, + int32_t op_ret, + int32_t op_errno, + fd_t *fd) + +{ + call_stub_t *stub = NULL; + + GF_VALIDATE_OR_GOTO ("call-stub", frame, out); + + stub = stub_new (frame, 0, GF_FOP_OPENDIR); + GF_VALIDATE_OR_GOTO ("call-stub", stub, out); + + stub->args.opendir_cbk.fn = fn; + stub->args.opendir_cbk.op_ret = op_ret; + stub->args.opendir_cbk.op_errno = op_errno; + + if (fd) + stub->args.opendir_cbk.fd = fd_ref (fd); +out: + return stub; +} + + +call_stub_t * +fop_getdents_stub (call_frame_t *frame, + fop_getdents_t fn, + fd_t *fd, + size_t size, + off_t off, + int32_t flag) +{ + call_stub_t *stub = NULL; + + GF_VALIDATE_OR_GOTO ("call-stub", frame, out); + + stub = stub_new (frame, 1, GF_FOP_GETDENTS); + GF_VALIDATE_OR_GOTO ("call-stub", stub, out); + + stub->args.getdents.fn = fn; + stub->args.getdents.size = size; + stub->args.getdents.off = off; + if (fd) + stub->args.getdents.fd = fd_ref (fd); + stub->args.getdents.flag = flag; +out: + return stub; +} + + +call_stub_t * +fop_getdents_cbk_stub (call_frame_t *frame, + fop_getdents_cbk_t fn, + int32_t op_ret, + int32_t op_errno, + dir_entry_t *entries, + int32_t count) + +{ + call_stub_t *stub = NULL; + + GF_VALIDATE_OR_GOTO ("call-stub", frame, out); + + stub = stub_new (frame, 0, GF_FOP_GETDENTS); + GF_VALIDATE_OR_GOTO ("call-stub", stub, out); + + stub->args.getdents_cbk.fn = fn; + stub->args.getdents_cbk.op_ret = op_ret; + stub->args.getdents_cbk.op_errno = op_errno; + if (op_ret >= 0) { + stub->args.getdents_cbk.entries.next = entries->next; + /* FIXME: are entries not needed in the caller after + * creating stub? */ + entries->next = NULL; + } + + stub->args.getdents_cbk.count = count; +out: + return stub; +} + + + +call_stub_t * +fop_fsyncdir_stub (call_frame_t *frame, + fop_fsyncdir_t fn, + fd_t *fd, + int32_t datasync) +{ + call_stub_t *stub = NULL; + + GF_VALIDATE_OR_GOTO ("call-stub", frame, out); + + stub = stub_new (frame, 1, GF_FOP_FSYNCDIR); + GF_VALIDATE_OR_GOTO ("call-stub", stub, out); + + stub->args.fsyncdir.fn = fn; + if (fd) + stub->args.fsyncdir.fd = fd_ref (fd); + stub->args.fsyncdir.datasync = datasync; +out: + return stub; +} + + +call_stub_t * +fop_fsyncdir_cbk_stub (call_frame_t *frame, + fop_fsyncdir_cbk_t fn, + int32_t op_ret, + int32_t op_errno) + +{ + call_stub_t *stub = NULL; + + GF_VALIDATE_OR_GOTO ("call-stub", frame, out); + + stub = stub_new (frame, 0, GF_FOP_FSYNCDIR); + GF_VALIDATE_OR_GOTO ("call-stub", stub, out); + + stub->args.fsyncdir_cbk.fn = fn; + stub->args.fsyncdir_cbk.op_ret = op_ret; + stub->args.fsyncdir_cbk.op_errno = op_errno; +out: + return stub; +} + + +call_stub_t * +fop_statfs_stub (call_frame_t *frame, + fop_statfs_t fn, + loc_t *loc) +{ + call_stub_t *stub = NULL; + + GF_VALIDATE_OR_GOTO ("call-stub", frame, out); + GF_VALIDATE_OR_GOTO ("call-stub", loc, out); + + stub = stub_new (frame, 1, GF_FOP_STATFS); + GF_VALIDATE_OR_GOTO ("call-stub", stub, out); + + stub->args.statfs.fn = fn; + loc_copy (&stub->args.statfs.loc, loc); +out: + return stub; +} + + +call_stub_t * +fop_statfs_cbk_stub (call_frame_t *frame, + fop_statfs_cbk_t fn, + int32_t op_ret, + int32_t op_errno, + struct statvfs *buf) + +{ + call_stub_t *stub = NULL; + + GF_VALIDATE_OR_GOTO ("call-stub", frame, out); + + stub = stub_new (frame, 0, GF_FOP_STATFS); + GF_VALIDATE_OR_GOTO ("call-stub", stub, out); + + stub->args.statfs_cbk.fn = fn; + stub->args.statfs_cbk.op_ret = op_ret; + stub->args.statfs_cbk.op_errno = op_errno; + if (op_ret == 0) + stub->args.statfs_cbk.buf = *buf; +out: + return stub; +} + + +call_stub_t * +fop_setxattr_stub (call_frame_t *frame, + fop_setxattr_t fn, + loc_t *loc, + dict_t *dict, + int32_t flags) +{ + call_stub_t *stub = NULL; + + GF_VALIDATE_OR_GOTO ("call-stub", frame, out); + GF_VALIDATE_OR_GOTO ("call-stub", loc, out); + + stub = stub_new (frame, 1, GF_FOP_SETXATTR); + GF_VALIDATE_OR_GOTO ("call-stub", stub, out); + + stub->args.setxattr.fn = fn; + loc_copy (&stub->args.setxattr.loc, loc); + /* TODO */ + if (dict) + stub->args.setxattr.dict = dict_ref (dict); + stub->args.setxattr.flags = flags; +out: + return stub; +} + + +call_stub_t * +fop_setxattr_cbk_stub (call_frame_t *frame, + fop_setxattr_cbk_t fn, + int32_t op_ret, + int32_t op_errno) +{ + call_stub_t *stub = NULL; + + GF_VALIDATE_OR_GOTO ("call-stub", frame, out); + + stub = stub_new (frame, 0, GF_FOP_SETXATTR); + GF_VALIDATE_OR_GOTO ("call-stub", stub, out); + + stub->args.setxattr_cbk.fn = fn; + stub->args.setxattr_cbk.op_ret = op_ret; + stub->args.setxattr_cbk.op_errno = op_errno; +out: + return stub; +} + +call_stub_t * +fop_getxattr_stub (call_frame_t *frame, + fop_getxattr_t fn, + loc_t *loc, + const char *name) +{ + call_stub_t *stub = NULL; + + GF_VALIDATE_OR_GOTO ("call-stub", frame, out); + GF_VALIDATE_OR_GOTO ("call-stub", loc, out); + + stub = stub_new (frame, 1, GF_FOP_GETXATTR); + GF_VALIDATE_OR_GOTO ("call-stub", stub, out); + + stub->args.getxattr.fn = fn; + loc_copy (&stub->args.getxattr.loc, loc); + + if (name) + stub->args.getxattr.name = strdup (name); +out: + return stub; +} + + +call_stub_t * +fop_getxattr_cbk_stub (call_frame_t *frame, + fop_getxattr_cbk_t fn, + int32_t op_ret, + int32_t op_errno, + dict_t *dict) +{ + call_stub_t *stub = NULL; + + GF_VALIDATE_OR_GOTO ("call-stub", frame, out); + + stub = stub_new (frame, 0, GF_FOP_GETXATTR); + GF_VALIDATE_OR_GOTO ("call-stub", stub, out); + + stub->args.getxattr_cbk.fn = fn; + stub->args.getxattr_cbk.op_ret = op_ret; + stub->args.getxattr_cbk.op_errno = op_errno; + /* TODO */ + if (dict) + stub->args.getxattr_cbk.dict = dict_ref (dict); +out: + return stub; +} + +call_stub_t * +fop_removexattr_stub (call_frame_t *frame, + fop_removexattr_t fn, + loc_t *loc, + const char *name) +{ + call_stub_t *stub = NULL; + + GF_VALIDATE_OR_GOTO ("call-stub", frame, out); + GF_VALIDATE_OR_GOTO ("call-stub", loc, out); + GF_VALIDATE_OR_GOTO ("call-stub", name, out); + + stub = stub_new (frame, 1, GF_FOP_REMOVEXATTR); + GF_VALIDATE_OR_GOTO ("call-stub", stub, out); + + stub->args.removexattr.fn = fn; + loc_copy (&stub->args.removexattr.loc, loc); + stub->args.removexattr.name = strdup (name); +out: + return stub; +} + + +call_stub_t * +fop_removexattr_cbk_stub (call_frame_t *frame, + fop_removexattr_cbk_t fn, + int32_t op_ret, + int32_t op_errno) +{ + call_stub_t *stub = NULL; + + GF_VALIDATE_OR_GOTO ("call-stub", frame, out); + + stub = stub_new (frame, 0, GF_FOP_REMOVEXATTR); + GF_VALIDATE_OR_GOTO ("call-stub", stub, out); + + stub->args.removexattr_cbk.fn = fn; + stub->args.removexattr_cbk.op_ret = op_ret; + stub->args.removexattr_cbk.op_errno = op_errno; +out: + return stub; +} + + +call_stub_t * +fop_lk_stub (call_frame_t *frame, + fop_lk_t fn, + fd_t *fd, + int32_t cmd, + struct flock *lock) +{ + call_stub_t *stub = NULL; + + GF_VALIDATE_OR_GOTO ("call-stub", frame, out); + GF_VALIDATE_OR_GOTO ("call-stub", lock, out); + + stub = stub_new (frame, 1, GF_FOP_LK); + GF_VALIDATE_OR_GOTO ("call-stub", stub, out); + + stub->args.lk.fn = fn; + if (fd) + stub->args.lk.fd = fd_ref (fd); + stub->args.lk.cmd = cmd; + stub->args.lk.lock = *lock; +out: + return stub; +} + + +call_stub_t * +fop_lk_cbk_stub (call_frame_t *frame, + fop_lk_cbk_t fn, + int32_t op_ret, + int32_t op_errno, + struct flock *lock) + +{ + call_stub_t *stub = NULL; + + GF_VALIDATE_OR_GOTO ("call-stub", frame, out); + + stub = stub_new (frame, 0, GF_FOP_LK); + GF_VALIDATE_OR_GOTO ("call-stub", stub, out); + + stub->args.lk_cbk.fn = fn; + stub->args.lk_cbk.op_ret = op_ret; + stub->args.lk_cbk.op_errno = op_errno; + if (op_ret == 0) + stub->args.lk_cbk.lock = *lock; +out: + return stub; +} + +call_stub_t * +fop_inodelk_stub (call_frame_t *frame, fop_inodelk_t fn, + loc_t *loc, int32_t cmd, struct flock *lock) +{ + call_stub_t *stub = NULL; + + if (!frame || !lock) + return NULL; + + stub = stub_new (frame, 1, GF_FOP_INODELK); + if (!stub) + return NULL; + + stub->args.inodelk.fn = fn; + + loc_copy (&stub->args.inodelk.loc, loc); + stub->args.inodelk.cmd = cmd; + stub->args.inodelk.lock = *lock; + + return stub; +} + +call_stub_t * +fop_inodelk_cbk_stub (call_frame_t *frame, fop_inodelk_cbk_t fn, + int32_t op_ret, int32_t op_errno) +{ + call_stub_t *stub = NULL; + + if (!frame) + return NULL; + + stub = stub_new (frame, 0, GF_FOP_INODELK); + if (!stub) + return NULL; + + stub->args.inodelk_cbk.fn = fn; + stub->args.inodelk_cbk.op_ret = op_ret; + stub->args.inodelk_cbk.op_errno = op_errno; + + return stub; +} + + +call_stub_t * +fop_finodelk_stub (call_frame_t *frame, fop_finodelk_t fn, + fd_t *fd, int32_t cmd, struct flock *lock) +{ + call_stub_t *stub = NULL; + + if (!frame || !lock) + return NULL; + + stub = stub_new (frame, 1, GF_FOP_FINODELK); + if (!stub) + return NULL; + + stub->args.finodelk.fn = fn; + + if (fd) + stub->args.finodelk.fd = fd_ref (fd); + stub->args.finodelk.cmd = cmd; + stub->args.finodelk.lock = *lock; + + return stub; +} + + +call_stub_t * +fop_finodelk_cbk_stub (call_frame_t *frame, fop_inodelk_cbk_t fn, + int32_t op_ret, int32_t op_errno) +{ + call_stub_t *stub = NULL; + + if (!frame) + return NULL; + + stub = stub_new (frame, 0, GF_FOP_FINODELK); + if (!stub) + return NULL; + + stub->args.finodelk_cbk.fn = fn; + stub->args.finodelk_cbk.op_ret = op_ret; + stub->args.finodelk_cbk.op_errno = op_errno; + + return stub; +} + + +call_stub_t * +fop_entrylk_stub (call_frame_t *frame, fop_entrylk_t fn, + loc_t *loc, const char *name, + entrylk_cmd cmd, entrylk_type type) +{ + call_stub_t *stub = NULL; + + if (!frame) + return NULL; + + stub = stub_new (frame, 1, GF_FOP_ENTRYLK); + if (!stub) + return NULL; + + stub->args.entrylk.fn = fn; + loc_copy (&stub->args.entrylk.loc, loc); + + stub->args.entrylk.cmd = cmd; + stub->args.entrylk.type = type; + if (name) + stub->args.entrylk.name = strdup (name); + + return stub; +} + +call_stub_t * +fop_entrylk_cbk_stub (call_frame_t *frame, fop_entrylk_cbk_t fn, + int32_t op_ret, int32_t op_errno) +{ + call_stub_t *stub = NULL; + + if (!frame) + return NULL; + + stub = stub_new (frame, 0, GF_FOP_ENTRYLK); + if (!stub) + return NULL; + + stub->args.entrylk_cbk.fn = fn; + stub->args.entrylk_cbk.op_ret = op_ret; + stub->args.entrylk_cbk.op_errno = op_errno; + + return stub; +} + + +call_stub_t * +fop_fentrylk_stub (call_frame_t *frame, fop_fentrylk_t fn, + fd_t *fd, const char *name, + entrylk_cmd cmd, entrylk_type type) +{ + call_stub_t *stub = NULL; + + if (!frame) + return NULL; + + stub = stub_new (frame, 1, GF_FOP_FENTRYLK); + if (!stub) + return NULL; + + stub->args.fentrylk.fn = fn; + + if (fd) + stub->args.fentrylk.fd = fd_ref (fd); + stub->args.fentrylk.cmd = cmd; + stub->args.fentrylk.type = type; + if (name) + stub->args.fentrylk.name = strdup (name); + + return stub; +} + +call_stub_t * +fop_fentrylk_cbk_stub (call_frame_t *frame, fop_fentrylk_cbk_t fn, + int32_t op_ret, int32_t op_errno) +{ + call_stub_t *stub = NULL; + + if (!frame) + return NULL; + + stub = stub_new (frame, 0, GF_FOP_FENTRYLK); + if (!stub) + return NULL; + + stub->args.fentrylk_cbk.fn = fn; + stub->args.fentrylk_cbk.op_ret = op_ret; + stub->args.fentrylk_cbk.op_errno = op_errno; + + return stub; +} + + +call_stub_t * +fop_setdents_stub (call_frame_t *frame, + fop_setdents_t fn, + fd_t *fd, + int32_t flags, + dir_entry_t *entries, + int32_t count) +{ + call_stub_t *stub = NULL; + + GF_VALIDATE_OR_GOTO ("call-stub", frame, out); + + stub = stub_new (frame, 1, GF_FOP_SETDENTS); + GF_VALIDATE_OR_GOTO ("call-stub", stub, out); + + if (fd) + stub->args.setdents.fd = fd_ref (fd); + stub->args.setdents.fn = fn; + stub->args.setdents.flags = flags; + stub->args.setdents.count = count; + if (entries) { + stub->args.setdents.entries.next = entries->next; + entries->next = NULL; + } +out: + return stub; +} + +call_stub_t * +fop_setdents_cbk_stub (call_frame_t *frame, + fop_setdents_cbk_t fn, + int32_t op_ret, + int32_t op_errno) +{ + call_stub_t *stub = NULL; + + GF_VALIDATE_OR_GOTO ("call-stub", frame, out); + + stub = stub_new (frame, 0, GF_FOP_SETDENTS); + GF_VALIDATE_OR_GOTO ("call-stub", stub, out); + + stub->args.setdents_cbk.fn = fn; + stub->args.setdents_cbk.op_ret = op_ret; + stub->args.setdents_cbk.op_errno = op_errno; +out: + return stub; + +} + +call_stub_t * +fop_readdir_cbk_stub (call_frame_t *frame, + fop_readdir_cbk_t fn, + int32_t op_ret, + int32_t op_errno, + gf_dirent_t *entries) +{ + call_stub_t *stub = NULL; + gf_dirent_t *stub_entry = NULL, *entry = NULL; + + GF_VALIDATE_OR_GOTO ("call-stub", frame, out); + + stub = stub_new (frame, 0, GF_FOP_READDIR); + GF_VALIDATE_OR_GOTO ("call-stub", stub, out); + + stub->args.readdir_cbk.fn = fn; + stub->args.readdir_cbk.op_ret = op_ret; + stub->args.readdir_cbk.op_errno = op_errno; + INIT_LIST_HEAD (&stub->args.readdir_cbk.entries.list); + + if (op_ret > 0) { + list_for_each_entry (entry, &entries->list, list) { + stub_entry = gf_dirent_for_name (entry->d_name); + ERR_ABORT (stub_entry); + stub_entry->d_off = entry->d_off; + stub_entry->d_ino = entry->d_ino; + + list_add_tail (&stub_entry->list, + &stub->args.readdir_cbk.entries.list); + } + } +out: + return stub; +} + +call_stub_t * +fop_readdir_stub (call_frame_t *frame, + fop_readdir_t fn, + fd_t *fd, + size_t size, + off_t off) +{ + call_stub_t *stub = NULL; + + stub = stub_new (frame, 1, GF_FOP_READDIR); + stub->args.readdir.fn = fn; + stub->args.readdir.fd = fd_ref (fd); + stub->args.readdir.size = size; + stub->args.readdir.off = off; + + return stub; +} +call_stub_t * +fop_checksum_stub (call_frame_t *frame, + fop_checksum_t fn, + loc_t *loc, + int32_t flags) +{ + call_stub_t *stub = NULL; + + GF_VALIDATE_OR_GOTO ("call-stub", frame, out); + GF_VALIDATE_OR_GOTO ("call-stub", loc, out); + + stub = stub_new (frame, 1, GF_FOP_CHECKSUM); + GF_VALIDATE_OR_GOTO ("call-stub", stub, out); + + stub->args.checksum.fn = fn; + loc_copy (&stub->args.checksum.loc, loc); + stub->args.checksum.flags = flags; +out: + return stub; +} + + +call_stub_t * +fop_checksum_cbk_stub (call_frame_t *frame, + fop_checksum_cbk_t fn, + int32_t op_ret, + int32_t op_errno, + uint8_t *file_checksum, + uint8_t *dir_checksum) +{ + call_stub_t *stub = NULL; + + GF_VALIDATE_OR_GOTO ("call-stub", frame, out); + + stub = stub_new (frame, 0, GF_FOP_CHECKSUM); + GF_VALIDATE_OR_GOTO ("call-stub", stub, out); + + stub->args.checksum_cbk.fn = fn; + stub->args.checksum_cbk.op_ret = op_ret; + stub->args.checksum_cbk.op_errno = op_errno; + if (op_ret >= 0) + { + stub->args.checksum_cbk.file_checksum = + memdup (file_checksum, ZR_FILENAME_MAX); + + stub->args.checksum_cbk.dir_checksum = + memdup (dir_checksum, ZR_FILENAME_MAX); + } +out: + return stub; +} + + +call_stub_t * +fop_xattrop_cbk_stub (call_frame_t *frame, + fop_xattrop_cbk_t fn, + int32_t op_ret, + int32_t op_errno) +{ + call_stub_t *stub = NULL; + + GF_VALIDATE_OR_GOTO ("call-stub", frame, out); + + stub = stub_new (frame, 0, GF_FOP_XATTROP); + GF_VALIDATE_OR_GOTO ("call-stub", stub, out); + + stub->args.xattrop_cbk.fn = fn; + stub->args.xattrop_cbk.op_ret = op_ret; + stub->args.xattrop_cbk.op_errno = op_errno; + +out: + return stub; +} + + +call_stub_t * +fop_fxattrop_cbk_stub (call_frame_t *frame, + fop_fxattrop_cbk_t fn, + int32_t op_ret, + int32_t op_errno, + dict_t *xattr) +{ + call_stub_t *stub = NULL; + GF_VALIDATE_OR_GOTO ("call-stub", frame, out); + + stub = stub_new (frame, 1, GF_FOP_FXATTROP); + stub->args.fxattrop_cbk.fn = fn; + stub->args.fxattrop_cbk.op_ret = op_ret; + stub->args.fxattrop_cbk.op_errno = op_errno; + if (xattr) + stub->args.fxattrop_cbk.xattr = dict_ref (xattr); + +out: + return stub; +} + + +call_stub_t * +fop_xattrop_stub (call_frame_t *frame, + fop_xattrop_t fn, + loc_t *loc, + gf_xattrop_flags_t optype, + dict_t *xattr) +{ + call_stub_t *stub = NULL; + + if (!frame || !xattr) + return NULL; + + stub = stub_new (frame, 1, GF_FOP_XATTROP); + if (!stub) + return NULL; + + stub->args.xattrop.fn = fn; + + loc_copy (&stub->args.xattrop.loc, loc); + + stub->args.xattrop.optype = optype; + stub->args.xattrop.xattr = dict_ref (xattr); + + return stub; +} + +call_stub_t * +fop_fxattrop_stub (call_frame_t *frame, + fop_fxattrop_t fn, + fd_t *fd, + gf_xattrop_flags_t optype, + dict_t *xattr) +{ + call_stub_t *stub = NULL; + + if (!frame || !xattr) + return NULL; + + stub = stub_new (frame, 1, GF_FOP_FXATTROP); + if (!stub) + return NULL; + + stub->args.fxattrop.fn = fn; + + stub->args.fxattrop.fd = fd_ref (fd); + + stub->args.fxattrop.optype = optype; + stub->args.fxattrop.xattr = dict_ref (xattr); + + return stub; +} + + +static void +call_resume_wind (call_stub_t *stub) +{ + GF_VALIDATE_OR_GOTO ("call-stub", stub, out); + + switch (stub->fop) { + case GF_FOP_OPEN: + { + stub->args.open.fn (stub->frame, + stub->frame->this, + &stub->args.open.loc, + stub->args.open.flags, stub->args.open.fd); + break; + } + case GF_FOP_CREATE: + { + stub->args.create.fn (stub->frame, + stub->frame->this, + &stub->args.create.loc, + stub->args.create.flags, + stub->args.create.mode, + stub->args.create.fd); + break; + } + case GF_FOP_STAT: + { + stub->args.stat.fn (stub->frame, + stub->frame->this, + &stub->args.stat.loc); + break; + } + case GF_FOP_READLINK: + { + stub->args.readlink.fn (stub->frame, + stub->frame->this, + &stub->args.readlink.loc, + stub->args.readlink.size); + break; + } + + case GF_FOP_MKNOD: + { + stub->args.mknod.fn (stub->frame, + stub->frame->this, + &stub->args.mknod.loc, + stub->args.mknod.mode, + stub->args.mknod.rdev); + } + break; + + case GF_FOP_MKDIR: + { + stub->args.mkdir.fn (stub->frame, + stub->frame->this, + &stub->args.mkdir.loc, + stub->args.mkdir.mode); + } + break; + + case GF_FOP_UNLINK: + { + stub->args.unlink.fn (stub->frame, + stub->frame->this, + &stub->args.unlink.loc); + } + break; + + case GF_FOP_RMDIR: + { + stub->args.rmdir.fn (stub->frame, + stub->frame->this, + &stub->args.rmdir.loc); + } + break; + + case GF_FOP_SYMLINK: + { + stub->args.symlink.fn (stub->frame, + stub->frame->this, + stub->args.symlink.linkname, + &stub->args.symlink.loc); + } + break; + + case GF_FOP_RENAME: + { + stub->args.rename.fn (stub->frame, + stub->frame->this, + &stub->args.rename.old, + &stub->args.rename.new); + } + break; + + case GF_FOP_LINK: + { + stub->args.link.fn (stub->frame, + stub->frame->this, + &stub->args.link.oldloc, + &stub->args.link.newloc); + } + break; + + case GF_FOP_CHMOD: + { + stub->args.chmod.fn (stub->frame, + stub->frame->this, + &stub->args.chmod.loc, + stub->args.chmod.mode); + } + break; + + case GF_FOP_CHOWN: + { + stub->args.chown.fn (stub->frame, + stub->frame->this, + &stub->args.chown.loc, + stub->args.chown.uid, + stub->args.chown.gid); + break; + } + case GF_FOP_TRUNCATE: + { + stub->args.truncate.fn (stub->frame, + stub->frame->this, + &stub->args.truncate.loc, + stub->args.truncate.off); + break; + } + + case GF_FOP_READ: + { + stub->args.readv.fn (stub->frame, + stub->frame->this, + stub->args.readv.fd, + stub->args.readv.size, + stub->args.readv.off); + break; + } + + case GF_FOP_WRITE: + { + stub->args.writev.fn (stub->frame, + stub->frame->this, + stub->args.writev.fd, + stub->args.writev.vector, + stub->args.writev.count, + stub->args.writev.off); + break; + } + + case GF_FOP_STATFS: + { + stub->args.statfs.fn (stub->frame, + stub->frame->this, + &stub->args.statfs.loc); + break; + } + case GF_FOP_FLUSH: + { + stub->args.flush.fn (stub->frame, + stub->frame->this, + stub->args.flush.fd); + break; + } + + case GF_FOP_FSYNC: + { + stub->args.fsync.fn (stub->frame, + stub->frame->this, + stub->args.fsync.fd, + stub->args.fsync.datasync); + break; + } + + case GF_FOP_SETXATTR: + { + stub->args.setxattr.fn (stub->frame, + stub->frame->this, + &stub->args.setxattr.loc, + stub->args.setxattr.dict, + stub->args.setxattr.flags); + break; + } + + case GF_FOP_GETXATTR: + { + stub->args.getxattr.fn (stub->frame, + stub->frame->this, + &stub->args.getxattr.loc, + stub->args.getxattr.name); + break; + } + + case GF_FOP_REMOVEXATTR: + { + stub->args.removexattr.fn (stub->frame, + stub->frame->this, + &stub->args.removexattr.loc, + stub->args.removexattr.name); + break; + } + + case GF_FOP_OPENDIR: + { + stub->args.opendir.fn (stub->frame, + stub->frame->this, + &stub->args.opendir.loc, + stub->args.opendir.fd); + break; + } + + case GF_FOP_GETDENTS: + { + stub->args.getdents.fn (stub->frame, + stub->frame->this, + stub->args.getdents.fd, + stub->args.getdents.size, + stub->args.getdents.off, + stub->args.getdents.flag); + break; + } + + case GF_FOP_FSYNCDIR: + { + stub->args.fsyncdir.fn (stub->frame, + stub->frame->this, + stub->args.fsyncdir.fd, + stub->args.fsyncdir.datasync); + break; + } + + case GF_FOP_ACCESS: + { + stub->args.access.fn (stub->frame, + stub->frame->this, + &stub->args.access.loc, + stub->args.access.mask); + break; + } + + case GF_FOP_FTRUNCATE: + { + stub->args.ftruncate.fn (stub->frame, + stub->frame->this, + stub->args.ftruncate.fd, + stub->args.ftruncate.off); + break; + } + + case GF_FOP_FSTAT: + { + stub->args.fstat.fn (stub->frame, + stub->frame->this, + stub->args.fstat.fd); + break; + } + + case GF_FOP_LK: + { + stub->args.lk.fn (stub->frame, + stub->frame->this, + stub->args.lk.fd, + stub->args.lk.cmd, + &stub->args.lk.lock); + break; + } + + case GF_FOP_INODELK: + { + stub->args.inodelk.fn (stub->frame, + stub->frame->this, + &stub->args.inodelk.loc, + stub->args.inodelk.cmd, + &stub->args.inodelk.lock); + break; + } + + case GF_FOP_FINODELK: + { + stub->args.finodelk.fn (stub->frame, + stub->frame->this, + stub->args.finodelk.fd, + stub->args.finodelk.cmd, + &stub->args.finodelk.lock); + break; + } + + case GF_FOP_ENTRYLK: + { + stub->args.entrylk.fn (stub->frame, + stub->frame->this, + &stub->args.entrylk.loc, + stub->args.entrylk.name, + stub->args.entrylk.cmd, + stub->args.entrylk.type); + break; + } + + case GF_FOP_FENTRYLK: + { + stub->args.fentrylk.fn (stub->frame, + stub->frame->this, + stub->args.fentrylk.fd, + stub->args.fentrylk.name, + stub->args.fentrylk.cmd, + stub->args.fentrylk.type); + break; + } + + case GF_FOP_UTIMENS: + { + stub->args.utimens.fn (stub->frame, + stub->frame->this, + &stub->args.utimens.loc, + stub->args.utimens.tv); + break; + } + + + break; + case GF_FOP_FCHMOD: + { + stub->args.fchmod.fn (stub->frame, + stub->frame->this, + stub->args.fchmod.fd, + stub->args.fchmod.mode); + break; + } + + case GF_FOP_FCHOWN: + { + stub->args.fchown.fn (stub->frame, + stub->frame->this, + stub->args.fchown.fd, + stub->args.fchown.uid, + stub->args.fchown.gid); + break; + } + + case GF_FOP_LOOKUP: + { + stub->args.lookup.fn (stub->frame, + stub->frame->this, + &stub->args.lookup.loc, + stub->args.lookup.xattr_req); + break; + } + + case GF_FOP_SETDENTS: + { + stub->args.setdents.fn (stub->frame, + stub->frame->this, + stub->args.setdents.fd, + stub->args.setdents.flags, + &stub->args.setdents.entries, + stub->args.setdents.count); + break; + } + + case GF_FOP_CHECKSUM: + { + stub->args.checksum.fn (stub->frame, + stub->frame->this, + &stub->args.checksum.loc, + stub->args.checksum.flags); + break; + } + case GF_FOP_READDIR: + { + stub->args.readdir.fn (stub->frame, + stub->frame->this, + stub->args.readdir.fd, + stub->args.readdir.size, + stub->args.readdir.off); + break; + } + case GF_FOP_XATTROP: + { + stub->args.xattrop.fn (stub->frame, + stub->frame->this, + &stub->args.xattrop.loc, + stub->args.xattrop.optype, + stub->args.xattrop.xattr); + + break; + } + case GF_FOP_FXATTROP: + { + stub->args.fxattrop.fn (stub->frame, + stub->frame->this, + stub->args.fxattrop.fd, + stub->args.fxattrop.optype, + stub->args.fxattrop.xattr); + + break; + } + default: + { + gf_log ("call-stub", + GF_LOG_DEBUG, + "Invalid value of FOP"); + } + break; + } +out: + return; +} + + + +static void +call_resume_unwind (call_stub_t *stub) +{ + GF_VALIDATE_OR_GOTO ("call-stub", stub, out); + + switch (stub->fop) { + case GF_FOP_OPEN: + { + if (!stub->args.open_cbk.fn) + STACK_UNWIND (stub->frame, + stub->args.open_cbk.op_ret, + stub->args.open_cbk.op_errno, + stub->args.open_cbk.fd); + else + stub->args.open_cbk.fn (stub->frame, + stub->frame->cookie, + stub->frame->this, + stub->args.open_cbk.op_ret, + stub->args.open_cbk.op_errno, + stub->args.open_cbk.fd); + break; + } + + case GF_FOP_CREATE: + { + if (!stub->args.create_cbk.fn) + STACK_UNWIND (stub->frame, + stub->args.create_cbk.op_ret, + stub->args.create_cbk.op_errno, + stub->args.create_cbk.fd, + stub->args.create_cbk.inode, + &stub->args.create_cbk.buf); + else + stub->args.create_cbk.fn (stub->frame, + stub->frame->cookie, + stub->frame->this, + stub->args.create_cbk.op_ret, + stub->args.create_cbk.op_errno, + stub->args.create_cbk.fd, + stub->args.create_cbk.inode, + &stub->args.create_cbk.buf); + + break; + } + + case GF_FOP_STAT: + { + if (!stub->args.stat_cbk.fn) + STACK_UNWIND (stub->frame, + stub->args.stat_cbk.op_ret, + stub->args.stat_cbk.op_errno, + &stub->args.stat_cbk.buf); + else + stub->args.stat_cbk.fn (stub->frame, + stub->frame->cookie, + stub->frame->this, + stub->args.stat_cbk.op_ret, + stub->args.stat_cbk.op_errno, + &stub->args.stat_cbk.buf); + + break; + } + + case GF_FOP_READLINK: + { + if (!stub->args.readlink_cbk.fn) + STACK_UNWIND (stub->frame, + stub->args.readlink_cbk.op_ret, + stub->args.readlink_cbk.op_errno, + stub->args.readlink_cbk.buf); + else + stub->args.readlink_cbk.fn (stub->frame, + stub->frame->cookie, + stub->frame->this, + stub->args.readlink_cbk.op_ret, + stub->args.readlink_cbk.op_errno, + stub->args.readlink_cbk.buf); + + break; + } + + case GF_FOP_MKNOD: + { + if (!stub->args.mknod_cbk.fn) + STACK_UNWIND (stub->frame, + stub->args.mknod_cbk.op_ret, + stub->args.mknod_cbk.op_errno, + stub->args.mknod_cbk.inode, + &stub->args.mknod_cbk.buf); + else + stub->args.mknod_cbk.fn (stub->frame, + stub->frame->cookie, + stub->frame->this, + stub->args.mknod_cbk.op_ret, + stub->args.mknod_cbk.op_errno, + stub->args.mknod_cbk.inode, + &stub->args.mknod_cbk.buf); + break; + } + + case GF_FOP_MKDIR: + { + if (!stub->args.mkdir_cbk.fn) + STACK_UNWIND (stub->frame, + stub->args.mkdir_cbk.op_ret, + stub->args.mkdir_cbk.op_errno, + stub->args.mkdir_cbk.inode, + &stub->args.mkdir_cbk.buf); + else + stub->args.mkdir_cbk.fn (stub->frame, + stub->frame->cookie, + stub->frame->this, + stub->args.mkdir_cbk.op_ret, + stub->args.mkdir_cbk.op_errno, + stub->args.mkdir_cbk.inode, + &stub->args.mkdir_cbk.buf); + + if (stub->args.mkdir_cbk.inode) + inode_unref (stub->args.mkdir_cbk.inode); + + break; + } + + case GF_FOP_UNLINK: + { + if (!stub->args.unlink_cbk.fn) + STACK_UNWIND (stub->frame, + stub->args.unlink_cbk.op_ret, + stub->args.unlink_cbk.op_errno); + else + stub->args.unlink_cbk.fn (stub->frame, + stub->frame->cookie, + stub->frame->this, + stub->args.unlink_cbk.op_ret, + stub->args.unlink_cbk.op_errno); + break; + } + + case GF_FOP_RMDIR: + { + if (!stub->args.rmdir_cbk.fn) + STACK_UNWIND (stub->frame, + stub->args.rmdir_cbk.op_ret, + stub->args.rmdir_cbk.op_errno); + else + stub->args.unlink_cbk.fn (stub->frame, + stub->frame->cookie, + stub->frame->this, + stub->args.rmdir_cbk.op_ret, + stub->args.rmdir_cbk.op_errno); + break; + } + + case GF_FOP_SYMLINK: + { + if (!stub->args.symlink_cbk.fn) + STACK_UNWIND (stub->frame, + stub->args.symlink_cbk.op_ret, + stub->args.symlink_cbk.op_errno, + stub->args.symlink_cbk.inode, + &stub->args.symlink_cbk.buf); + else + stub->args.symlink_cbk.fn (stub->frame, + stub->frame->cookie, + stub->frame->this, + stub->args.symlink_cbk.op_ret, + stub->args.symlink_cbk.op_errno, + stub->args.symlink_cbk.inode, + &stub->args.symlink_cbk.buf); + } + break; + + case GF_FOP_RENAME: + { +#if 0 + if (!stub->args.rename_cbk.fn) + STACK_UNWIND (stub->frame, + stub->args.rename_cbk.op_ret, + stub->args.rename_cbk.op_errno, + &stub->args.rename_cbk.buf); + else + stub->args.rename_cbk.fn (stub->frame, + stub->frame->cookie, + stub->frame->this, + stub->args.rename_cbk.op_ret, + stub->args.rename_cbk.op_errno, + &stub->args.rename_cbk.buf); +#endif + break; + } + + case GF_FOP_LINK: + { + if (!stub->args.link_cbk.fn) + STACK_UNWIND (stub->frame, + stub->args.link_cbk.op_ret, + stub->args.link_cbk.op_errno, + stub->args.link_cbk.inode, + &stub->args.link_cbk.buf); + else + stub->args.link_cbk.fn (stub->frame, + stub->frame->cookie, + stub->frame->this, + stub->args.link_cbk.op_ret, + stub->args.link_cbk.op_errno, + stub->args.link_cbk.inode, + &stub->args.link_cbk.buf); + break; + } + + case GF_FOP_CHMOD: + { + if (!stub->args.chmod_cbk.fn) + STACK_UNWIND (stub->frame, + stub->args.chmod_cbk.op_ret, + stub->args.chmod_cbk.op_errno, + &stub->args.chmod_cbk.buf); + else + stub->args.chmod_cbk.fn (stub->frame, + stub->frame->cookie, + stub->frame->this, + stub->args.chmod_cbk.op_ret, + stub->args.chmod_cbk.op_errno, + &stub->args.chmod_cbk.buf); + break; + } + + case GF_FOP_CHOWN: + { + if (!stub->args.chown_cbk.fn) + STACK_UNWIND (stub->frame, + stub->args.chown_cbk.op_ret, + stub->args.chown_cbk.op_errno, + &stub->args.chown_cbk.buf); + else + stub->args.chown_cbk.fn (stub->frame, + stub->frame->cookie, + stub->frame->this, + stub->args.chown_cbk.op_ret, + stub->args.chown_cbk.op_errno, + &stub->args.chown_cbk.buf); + break; + } + + case GF_FOP_TRUNCATE: + { + if (!stub->args.truncate_cbk.fn) + STACK_UNWIND (stub->frame, + stub->args.truncate_cbk.op_ret, + stub->args.truncate_cbk.op_errno, + &stub->args.truncate_cbk.buf); + else + stub->args.truncate_cbk.fn (stub->frame, + stub->frame->cookie, + stub->frame->this, + stub->args.truncate_cbk.op_ret, + stub->args.truncate_cbk.op_errno, + &stub->args.truncate_cbk.buf); + break; + } + + case GF_FOP_READ: + { + if (!stub->args.readv_cbk.fn) + STACK_UNWIND (stub->frame, + stub->args.readv_cbk.op_ret, + stub->args.readv_cbk.op_errno, + stub->args.readv_cbk.vector, + stub->args.readv_cbk.count, + &stub->args.readv_cbk.stbuf); + else + stub->args.readv_cbk.fn (stub->frame, + stub->frame->cookie, + stub->frame->this, + stub->args.readv_cbk.op_ret, + stub->args.readv_cbk.op_errno, + stub->args.readv_cbk.vector, + stub->args.readv_cbk.count, + &stub->args.readv_cbk.stbuf); + } + break; + + case GF_FOP_WRITE: + { + if (!stub->args.writev_cbk.fn) + STACK_UNWIND (stub->frame, + stub->args.writev_cbk.op_ret, + stub->args.writev_cbk.op_errno, + &stub->args.writev_cbk.stbuf); + else + stub->args.writev_cbk.fn (stub->frame, + stub->frame->cookie, + stub->frame->this, + stub->args.writev_cbk.op_ret, + stub->args.writev_cbk.op_errno, + &stub->args.writev_cbk.stbuf); + break; + } + + case GF_FOP_STATFS: + { + if (!stub->args.statfs_cbk.fn) + STACK_UNWIND (stub->frame, + stub->args.statfs_cbk.op_ret, + stub->args.statfs_cbk.op_errno, + &(stub->args.statfs_cbk.buf)); + else + stub->args.statfs_cbk.fn (stub->frame, + stub->frame->cookie, + stub->frame->this, + stub->args.statfs_cbk.op_ret, + stub->args.statfs_cbk.op_errno, + &(stub->args.statfs_cbk.buf)); + } + break; + + case GF_FOP_FLUSH: + { + if (!stub->args.flush_cbk.fn) + STACK_UNWIND (stub->frame, + stub->args.flush_cbk.op_ret, + stub->args.flush_cbk.op_errno); + else + stub->args.flush_cbk.fn (stub->frame, + stub->frame->cookie, + stub->frame->this, + stub->args.flush_cbk.op_ret, + stub->args.flush_cbk.op_errno); + + break; + } + + case GF_FOP_FSYNC: + { + if (!stub->args.fsync_cbk.fn) + STACK_UNWIND (stub->frame, + stub->args.fsync_cbk.op_ret, + stub->args.fsync_cbk.op_errno); + else + stub->args.fsync_cbk.fn (stub->frame, + stub->frame->cookie, + stub->frame->this, + stub->args.fsync_cbk.op_ret, + stub->args.fsync_cbk.op_errno); + break; + } + + case GF_FOP_SETXATTR: + { + if (!stub->args.setxattr_cbk.fn) + STACK_UNWIND (stub->frame, + stub->args.setxattr_cbk.op_ret, + stub->args.setxattr_cbk.op_errno); + + else + stub->args.setxattr_cbk.fn (stub->frame, + stub->frame->cookie, + stub->frame->this, + stub->args.setxattr_cbk.op_ret, + stub->args.setxattr_cbk.op_errno); + + break; + } + + case GF_FOP_GETXATTR: + { + if (!stub->args.getxattr_cbk.fn) + STACK_UNWIND (stub->frame, + stub->args.getxattr_cbk.op_ret, + stub->args.getxattr_cbk.op_errno, + stub->args.getxattr_cbk.dict); + else + stub->args.getxattr_cbk.fn (stub->frame, + stub->frame->cookie, + stub->frame->this, + stub->args.getxattr_cbk.op_ret, + stub->args.getxattr_cbk.op_errno, + stub->args.getxattr_cbk.dict); + break; + } + + case GF_FOP_REMOVEXATTR: + { + if (!stub->args.removexattr_cbk.fn) + STACK_UNWIND (stub->frame, + stub->args.removexattr_cbk.op_ret, + stub->args.removexattr_cbk.op_errno); + else + stub->args.removexattr_cbk.fn (stub->frame, + stub->frame->cookie, + stub->frame->this, + stub->args.removexattr_cbk.op_ret, + stub->args.removexattr_cbk.op_errno); + + break; + } + + case GF_FOP_OPENDIR: + { + if (!stub->args.opendir_cbk.fn) + STACK_UNWIND (stub->frame, + stub->args.opendir_cbk.op_ret, + stub->args.opendir_cbk.op_errno, + stub->args.opendir_cbk.fd); + else + stub->args.opendir_cbk.fn (stub->frame, + stub->frame->cookie, + stub->frame->this, + stub->args.opendir_cbk.op_ret, + stub->args.opendir_cbk.op_errno, + stub->args.opendir_cbk.fd); + break; + } + + case GF_FOP_GETDENTS: + { + if (!stub->args.getdents_cbk.fn) + STACK_UNWIND (stub->frame, + stub->args.getdents_cbk.op_ret, + stub->args.getdents_cbk.op_errno, + &stub->args.getdents_cbk.entries, + stub->args.getdents_cbk.count); + else + stub->args.getdents_cbk.fn (stub->frame, + stub->frame->cookie, + stub->frame->this, + stub->args.getdents_cbk.op_ret, + stub->args.getdents_cbk.op_errno, + &stub->args.getdents_cbk.entries, + stub->args.getdents_cbk.count); + break; + } + + case GF_FOP_FSYNCDIR: + { + if (!stub->args.fsyncdir_cbk.fn) + STACK_UNWIND (stub->frame, + stub->args.fsyncdir_cbk.op_ret, + stub->args.fsyncdir_cbk.op_errno); + else + stub->args.fsyncdir_cbk.fn (stub->frame, + stub->frame->cookie, + stub->frame->this, + stub->args.fsyncdir_cbk.op_ret, + stub->args.fsyncdir_cbk.op_errno); + break; + } + + case GF_FOP_ACCESS: + { + if (!stub->args.access_cbk.fn) + STACK_UNWIND (stub->frame, + stub->args.access_cbk.op_ret, + stub->args.access_cbk.op_errno); + else + stub->args.access_cbk.fn (stub->frame, + stub->frame->cookie, + stub->frame->this, + stub->args.access_cbk.op_ret, + stub->args.access_cbk.op_errno); + + break; + } + + case GF_FOP_FTRUNCATE: + { + if (!stub->args.ftruncate_cbk.fn) + STACK_UNWIND (stub->frame, + stub->args.ftruncate_cbk.op_ret, + stub->args.ftruncate_cbk.op_errno, + &stub->args.ftruncate_cbk.buf); + else + stub->args.ftruncate_cbk.fn (stub->frame, + stub->frame->cookie, + stub->frame->this, + stub->args.ftruncate_cbk.op_ret, + stub->args.ftruncate_cbk.op_errno, + &stub->args.ftruncate_cbk.buf); + break; + } + + case GF_FOP_FSTAT: + { + if (!stub->args.fstat_cbk.fn) + STACK_UNWIND (stub->frame, + stub->args.fstat_cbk.op_ret, + stub->args.fstat_cbk.op_errno, + &stub->args.fstat_cbk.buf); + else + stub->args.fstat_cbk.fn (stub->frame, + stub->frame->cookie, + stub->frame->this, + stub->args.fstat_cbk.op_ret, + stub->args.fstat_cbk.op_errno, + &stub->args.fstat_cbk.buf); + + break; + } + + case GF_FOP_LK: + { + if (!stub->args.lk_cbk.fn) + STACK_UNWIND (stub->frame, + stub->args.lk_cbk.op_ret, + stub->args.lk_cbk.op_errno, + &stub->args.lk_cbk.lock); + else + stub->args.lk_cbk.fn (stub->frame, + stub->frame->cookie, + stub->frame->this, + stub->args.lk_cbk.op_ret, + stub->args.lk_cbk.op_errno, + &stub->args.lk_cbk.lock); + break; + } + + case GF_FOP_INODELK: + { + if (!stub->args.inodelk_cbk.fn) + STACK_UNWIND (stub->frame, + stub->args.inodelk_cbk.op_ret, + stub->args.inodelk_cbk.op_errno); + + else + stub->args.inodelk_cbk.fn (stub->frame, + stub->frame->cookie, + stub->frame->this, + stub->args.inodelk_cbk.op_ret, + stub->args.inodelk_cbk.op_errno); + break; + } + + case GF_FOP_FINODELK: + { + if (!stub->args.finodelk_cbk.fn) + STACK_UNWIND (stub->frame, + stub->args.finodelk_cbk.op_ret, + stub->args.finodelk_cbk.op_errno); + + else + stub->args.finodelk_cbk.fn (stub->frame, + stub->frame->cookie, + stub->frame->this, + stub->args.finodelk_cbk.op_ret, + stub->args.finodelk_cbk.op_errno); + break; + } + + case GF_FOP_ENTRYLK: + { + if (!stub->args.entrylk_cbk.fn) + STACK_UNWIND (stub->frame, + stub->args.entrylk_cbk.op_ret, + stub->args.entrylk_cbk.op_errno); + + else + stub->args.entrylk_cbk.fn (stub->frame, + stub->frame->cookie, + stub->frame->this, + stub->args.entrylk_cbk.op_ret, + stub->args.entrylk_cbk.op_errno); + break; + } + + case GF_FOP_FENTRYLK: + { + if (!stub->args.fentrylk_cbk.fn) + STACK_UNWIND (stub->frame, + stub->args.fentrylk_cbk.op_ret, + stub->args.fentrylk_cbk.op_errno); + + else + stub->args.fentrylk_cbk.fn (stub->frame, + stub->frame->cookie, + stub->frame->this, + stub->args.fentrylk_cbk.op_ret, + stub->args.fentrylk_cbk.op_errno); + break; + } + + case GF_FOP_UTIMENS: + { + if (!stub->args.utimens_cbk.fn) + STACK_UNWIND (stub->frame, + stub->args.utimens_cbk.op_ret, + stub->args.utimens_cbk.op_errno, + &stub->args.utimens_cbk.buf); + else + stub->args.utimens_cbk.fn (stub->frame, + stub->frame->cookie, + stub->frame->this, + stub->args.utimens_cbk.op_ret, + stub->args.utimens_cbk.op_errno, + &stub->args.utimens_cbk.buf); + + break; + } + + + break; + case GF_FOP_FCHMOD: + { + if (!stub->args.fchmod_cbk.fn) + STACK_UNWIND (stub->frame, + stub->args.fchmod_cbk.op_ret, + stub->args.fchmod_cbk.op_errno, + &stub->args.fchmod_cbk.buf); + else + stub->args.fchmod_cbk.fn (stub->frame, + stub->frame->cookie, + stub->frame->this, + stub->args.fchmod_cbk.op_ret, + stub->args.fchmod_cbk.op_errno, + &stub->args.fchmod_cbk.buf); + break; + } + + case GF_FOP_FCHOWN: + { + if (!stub->args.fchown_cbk.fn) + STACK_UNWIND (stub->frame, + stub->args.fchown_cbk.op_ret, + stub->args.fchown_cbk.op_errno, + &stub->args.fchown_cbk.buf); + else + stub->args.fchown_cbk.fn (stub->frame, + stub->frame->cookie, + stub->frame->this, + stub->args.fchown_cbk.op_ret, + stub->args.fchown_cbk.op_errno, + &stub->args.fchown_cbk.buf); + break; + } + + case GF_FOP_LOOKUP: + { + if (!stub->args.lookup_cbk.fn) + STACK_UNWIND (stub->frame, + stub->args.lookup_cbk.op_ret, + stub->args.lookup_cbk.op_errno, + stub->args.lookup_cbk.inode, + &stub->args.lookup_cbk.buf, + stub->args.lookup_cbk.dict); + else + stub->args.lookup_cbk.fn (stub->frame, + stub->frame->cookie, + stub->frame->this, + stub->args.lookup_cbk.op_ret, + stub->args.lookup_cbk.op_errno, + stub->args.lookup_cbk.inode, + &stub->args.lookup_cbk.buf, + stub->args.lookup_cbk.dict); + /* FIXME NULL should not be passed */ + + if (stub->args.lookup_cbk.dict) + dict_unref (stub->args.lookup_cbk.dict); + if (stub->args.lookup_cbk.inode) + inode_unref (stub->args.lookup_cbk.inode); + + break; + } + case GF_FOP_SETDENTS: + { + if (!stub->args.setdents_cbk.fn) + STACK_UNWIND (stub->frame, + stub->args.setdents_cbk.op_ret, + stub->args.setdents_cbk.op_errno); + else + stub->args.setdents_cbk.fn (stub->frame, + stub->frame->cookie, + stub->frame->this, + stub->args.setdents_cbk.op_ret, + stub->args.setdents_cbk.op_errno); + break; + } + + case GF_FOP_CHECKSUM: + { + if (!stub->args.checksum_cbk.fn) + STACK_UNWIND (stub->frame, + stub->args.checksum_cbk.op_ret, + stub->args.checksum_cbk.op_errno, + stub->args.checksum_cbk.file_checksum, + stub->args.checksum_cbk.dir_checksum); + else + stub->args.checksum_cbk.fn (stub->frame, + stub->frame->cookie, + stub->frame->this, + stub->args.checksum_cbk.op_ret, + stub->args.checksum_cbk.op_errno, + stub->args.checksum_cbk.file_checksum, + stub->args.checksum_cbk.dir_checksum); + if (stub->args.checksum_cbk.op_ret >= 0) + { + FREE (stub->args.checksum_cbk.file_checksum); + FREE (stub->args.checksum_cbk.dir_checksum); + } + + break; + } + + case GF_FOP_READDIR: + { + if (!stub->args.readdir_cbk.fn) + STACK_UNWIND (stub->frame, + stub->args.readdir_cbk.op_ret, + stub->args.readdir_cbk.op_errno, + &stub->args.readdir_cbk.entries); + else + stub->args.readdir_cbk.fn (stub->frame, + stub->frame->cookie, + stub->frame->this, + stub->args.readdir_cbk.op_ret, + stub->args.readdir_cbk.op_errno, + &stub->args.readdir_cbk.entries); + + if (stub->args.readdir_cbk.op_ret > 0) + gf_dirent_free (&stub->args.readdir_cbk.entries); + + break; + } + + case GF_FOP_XATTROP: + { + if (!stub->args.xattrop_cbk.fn) + STACK_UNWIND (stub->frame, + stub->args.xattrop_cbk.op_ret, + stub->args.xattrop_cbk.op_errno); + else + stub->args.xattrop_cbk.fn (stub->frame, + stub->frame->cookie, + stub->frame->this, + stub->args.xattrop_cbk.op_ret, + stub->args.xattrop_cbk.op_errno, + stub->args.xattrop_cbk.xattr); + + if (stub->args.xattrop_cbk.xattr) + dict_unref (stub->args.xattrop_cbk.xattr); + + break; + } + case GF_FOP_FXATTROP: + { + if (!stub->args.fxattrop_cbk.fn) + STACK_UNWIND (stub->frame, + stub->args.fxattrop_cbk.op_ret, + stub->args.fxattrop_cbk.op_errno); + else + stub->args.fxattrop_cbk.fn (stub->frame, + stub->frame->cookie, + stub->frame->this, + stub->args.fxattrop_cbk.op_ret, + stub->args.fxattrop_cbk.op_errno, + stub->args.fxattrop_cbk.xattr); + + if (stub->args.fxattrop_cbk.xattr) + dict_unref (stub->args.fxattrop_cbk.xattr); + + break; + } + case GF_FOP_MAXVALUE: + { + gf_log ("call-stub", + GF_LOG_DEBUG, + "Invalid value of FOP"); + } + break; + } +out: + return; +} + + +static void +call_stub_destroy_wind (call_stub_t *stub) +{ + switch (stub->fop) { + case GF_FOP_OPEN: + { + loc_wipe (&stub->args.open.loc); + if (stub->args.open.fd) + fd_unref (stub->args.open.fd); + break; + } + case GF_FOP_CREATE: + { + loc_wipe (&stub->args.create.loc); + if (stub->args.create.fd) + fd_unref (stub->args.create.fd); + break; + } + case GF_FOP_STAT: + { + loc_wipe (&stub->args.stat.loc); + break; + } + case GF_FOP_READLINK: + { + loc_wipe (&stub->args.readlink.loc); + break; + } + + case GF_FOP_MKNOD: + { + loc_wipe (&stub->args.mknod.loc); + } + break; + + case GF_FOP_MKDIR: + { + loc_wipe (&stub->args.mkdir.loc); + } + break; + + case GF_FOP_UNLINK: + { + loc_wipe (&stub->args.unlink.loc); + } + break; + + case GF_FOP_RMDIR: + { + loc_wipe (&stub->args.rmdir.loc); + } + break; + + case GF_FOP_SYMLINK: + { + FREE (stub->args.symlink.linkname); + loc_wipe (&stub->args.symlink.loc); + } + break; + + case GF_FOP_RENAME: + { + loc_wipe (&stub->args.rename.old); + loc_wipe (&stub->args.rename.new); + } + break; + + case GF_FOP_LINK: + { + loc_wipe (&stub->args.link.oldloc); + loc_wipe (&stub->args.link.newloc); + } + break; + + case GF_FOP_CHMOD: + { + loc_wipe (&stub->args.chmod.loc); + } + break; + + case GF_FOP_CHOWN: + { + loc_wipe (&stub->args.chown.loc); + break; + } + case GF_FOP_TRUNCATE: + { + loc_wipe (&stub->args.truncate.loc); + break; + } + + case GF_FOP_READ: + { + if (stub->args.readv.fd) + fd_unref (stub->args.readv.fd); + break; + } + + case GF_FOP_WRITE: + { + dict_t *refs = stub->args.writev.req_refs; + if (stub->args.writev.fd) + fd_unref (stub->args.writev.fd); + FREE (stub->args.writev.vector); + if (refs) + dict_unref (refs); + break; + } + + case GF_FOP_STATFS: + { + loc_wipe (&stub->args.statfs.loc); + break; + } + case GF_FOP_FLUSH: + { + if (stub->args.flush.fd) + fd_unref (stub->args.flush.fd); + break; + } + + case GF_FOP_FSYNC: + { + if (stub->args.fsync.fd) + fd_unref (stub->args.fsync.fd); + break; + } + + case GF_FOP_SETXATTR: + { + loc_wipe (&stub->args.setxattr.loc); + if (stub->args.setxattr.dict) + dict_unref (stub->args.setxattr.dict); + break; + } + + case GF_FOP_GETXATTR: + { + if (stub->args.getxattr.name) + FREE (stub->args.getxattr.name); + loc_wipe (&stub->args.getxattr.loc); + break; + } + + case GF_FOP_REMOVEXATTR: + { + loc_wipe (&stub->args.removexattr.loc); + FREE (stub->args.removexattr.name); + break; + } + + case GF_FOP_OPENDIR: + { + loc_wipe (&stub->args.opendir.loc); + if (stub->args.opendir.fd) + fd_unref (stub->args.opendir.fd); + break; + } + + case GF_FOP_GETDENTS: + { + if (stub->args.getdents.fd) + fd_unref (stub->args.getdents.fd); + break; + } + + case GF_FOP_FSYNCDIR: + { + if (stub->args.fsyncdir.fd) + fd_unref (stub->args.fsyncdir.fd); + break; + } + + case GF_FOP_ACCESS: + { + loc_wipe (&stub->args.access.loc); + break; + } + + case GF_FOP_FTRUNCATE: + { + if (stub->args.ftruncate.fd) + fd_unref (stub->args.ftruncate.fd); + break; + } + + case GF_FOP_FSTAT: + { + if (stub->args.fstat.fd) + fd_unref (stub->args.fstat.fd); + break; + } + + case GF_FOP_LK: + { + if (stub->args.lk.fd) + fd_unref (stub->args.lk.fd); + break; + } + + case GF_FOP_INODELK: + { + loc_wipe (&stub->args.inodelk.loc); + break; + } + case GF_FOP_FINODELK: + { + if (stub->args.finodelk.fd) + fd_unref (stub->args.finodelk.fd); + break; + } + case GF_FOP_ENTRYLK: + { + if (stub->args.entrylk.name) + FREE (stub->args.entrylk.name); + loc_wipe (&stub->args.entrylk.loc); + break; + } + case GF_FOP_FENTRYLK: + { + if (stub->args.fentrylk.name) + FREE (stub->args.fentrylk.name); + + if (stub->args.fentrylk.fd) + fd_unref (stub->args.fentrylk.fd); + break; + } + case GF_FOP_UTIMENS: + { + loc_wipe (&stub->args.utimens.loc); + break; + } + break; + case GF_FOP_FCHMOD: + { + if (stub->args.fchmod.fd) + fd_unref (stub->args.fchmod.fd); + break; + } + + case GF_FOP_FCHOWN: + { + if (stub->args.fchown.fd) + fd_unref (stub->args.fchown.fd); + break; + } + + case GF_FOP_LOOKUP: + { + loc_wipe (&stub->args.lookup.loc); + if (stub->args.lookup.xattr_req) + dict_unref (stub->args.lookup.xattr_req); + break; + } + + case GF_FOP_SETDENTS: + { + dir_entry_t *entry, *next; + if (stub->args.setdents.fd) + fd_unref (stub->args.setdents.fd); + entry = stub->args.setdents.entries.next; + while (entry) { + next = entry->next; + FREE (entry->name); + FREE (entry); + entry = next; + } + break; + } + + case GF_FOP_CHECKSUM: + { + loc_wipe (&stub->args.checksum.loc); + break; + } + break; + case GF_FOP_READDIR: + { + if (stub->args.readdir.fd) + fd_unref (stub->args.readdir.fd); + break; + } + case GF_FOP_XATTROP: + { + loc_wipe (&stub->args.xattrop.loc); + dict_unref (stub->args.xattrop.xattr); + break; + } + case GF_FOP_FXATTROP: + { + if (stub->args.fxattrop.fd) + fd_unref (stub->args.fxattrop.fd); + dict_unref (stub->args.xattrop.xattr); + break; + } + case GF_FOP_MAXVALUE: + { + gf_log ("call-stub", + GF_LOG_DEBUG, + "Invalid value of FOP"); + } + break; + default: + break; + } +} + + +static void +call_stub_destroy_unwind (call_stub_t *stub) +{ + switch (stub->fop) { + case GF_FOP_OPEN: + { + if (stub->args.open_cbk.fd) + fd_unref (stub->args.open_cbk.fd); + } + break; + + case GF_FOP_CREATE: + { + if (stub->args.create_cbk.fd) + fd_unref (stub->args.create_cbk.fd); + + if (stub->args.create_cbk.inode) + inode_unref (stub->args.create_cbk.inode); + } + break; + + case GF_FOP_STAT: + break; + + case GF_FOP_READLINK: + { + if (stub->args.readlink_cbk.buf) + FREE (stub->args.readlink_cbk.buf); + } + break; + + case GF_FOP_MKNOD: + { + if (stub->args.mknod_cbk.inode) + inode_unref (stub->args.mknod_cbk.inode); + } + break; + + case GF_FOP_MKDIR: + { + if (stub->args.mkdir_cbk.inode) + inode_unref (stub->args.mkdir_cbk.inode); + } + break; + + case GF_FOP_UNLINK: + break; + + case GF_FOP_RMDIR: + break; + + case GF_FOP_SYMLINK: + { + if (stub->args.symlink_cbk.inode) + inode_unref (stub->args.symlink_cbk.inode); + } + break; + + case GF_FOP_RENAME: + break; + + case GF_FOP_LINK: + { + if (stub->args.link_cbk.inode) + inode_unref (stub->args.link_cbk.inode); + } + break; + + case GF_FOP_CHMOD: + break; + + case GF_FOP_CHOWN: + break; + + case GF_FOP_TRUNCATE: + break; + + case GF_FOP_READ: + { + if (stub->args.readv_cbk.op_ret >= 0) { + dict_t *refs = stub->args.readv_cbk.rsp_refs; + FREE (stub->args.readv_cbk.vector); + + if (refs) { + dict_unref (refs); + } + } + } + break; + + case GF_FOP_WRITE: + break; + + case GF_FOP_STATFS: + break; + + case GF_FOP_FLUSH: + break; + + case GF_FOP_FSYNC: + break; + + case GF_FOP_SETXATTR: + break; + + case GF_FOP_GETXATTR: + { + if (stub->args.getxattr_cbk.dict) + dict_unref (stub->args.getxattr_cbk.dict); + } + break; + + case GF_FOP_REMOVEXATTR: + break; + + case GF_FOP_OPENDIR: + { + if (stub->args.opendir_cbk.fd) + fd_unref (stub->args.opendir_cbk.fd); + } + break; + + case GF_FOP_GETDENTS: + { + dir_entry_t *tmp = NULL, *entries = NULL; + + entries = &stub->args.getdents_cbk.entries; + if (stub->args.getdents_cbk.op_ret >= 0) { + while (entries->next) { + tmp = entries->next; + entries->next = entries->next->next; + FREE (tmp->name); + FREE (tmp); + } + } + } + break; + + case GF_FOP_FSYNCDIR: + break; + + case GF_FOP_ACCESS: + break; + + case GF_FOP_FTRUNCATE: + break; + + case GF_FOP_FSTAT: + break; + + case GF_FOP_LK: + break; + + case GF_FOP_INODELK: + break; + + case GF_FOP_FINODELK: + break; + + case GF_FOP_ENTRYLK: + break; + + case GF_FOP_FENTRYLK: + break; + + case GF_FOP_UTIMENS: + break; + + case GF_FOP_FCHMOD: + break; + + case GF_FOP_FCHOWN: + break; + + case GF_FOP_LOOKUP: + { + if (stub->args.lookup_cbk.inode) + inode_unref (stub->args.lookup_cbk.inode); + + if (stub->args.lookup_cbk.dict) + dict_unref (stub->args.lookup_cbk.dict); + } + break; + + case GF_FOP_SETDENTS: + break; + + case GF_FOP_CHECKSUM: + { + if (stub->args.checksum_cbk.op_ret >= 0) { + FREE (stub->args.checksum_cbk.file_checksum); + FREE (stub->args.checksum_cbk.dir_checksum); + } + } + break; + + case GF_FOP_READDIR: + { + if (stub->args.readdir_cbk.op_ret > 0) { + gf_dirent_free (&stub->args.readdir_cbk.entries); + } + } + break; + + case GF_FOP_XATTROP: + { + if (stub->args.xattrop_cbk.xattr) + dict_unref (stub->args.xattrop_cbk.xattr); + } + break; + + case GF_FOP_FXATTROP: + { + if (stub->args.fxattrop_cbk.xattr) + dict_unref (stub->args.fxattrop_cbk.xattr); + } + break; + + case GF_FOP_MAXVALUE: + { + gf_log ("call-stub", + GF_LOG_DEBUG, + "Invalid value of FOP"); + } + break; + + default: + break; + } +} + + +void +call_stub_destroy (call_stub_t *stub) +{ + GF_VALIDATE_OR_GOTO ("call-stub", stub, out); + + if (stub->wind) { + call_stub_destroy_wind (stub); + } else { + call_stub_destroy_unwind (stub); + } + + FREE (stub); +out: + return; +} + +void +call_resume (call_stub_t *stub) +{ + errno = EINVAL; + GF_VALIDATE_OR_GOTO ("call-stub", stub, out); + + list_del_init (&stub->list); + + if (stub->wind) + call_resume_wind (stub); + else + call_resume_unwind (stub); + + call_stub_destroy (stub); +out: + return; +} + + |