diff options
Diffstat (limited to 'xlators/debug/error-gen/src/error-gen.c')
| -rw-r--r-- | xlators/debug/error-gen/src/error-gen.c | 1471 |
1 files changed, 752 insertions, 719 deletions
diff --git a/xlators/debug/error-gen/src/error-gen.c b/xlators/debug/error-gen/src/error-gen.c index e6a5967cc..ec0874b35 100644 --- a/xlators/debug/error-gen/src/error-gen.c +++ b/xlators/debug/error-gen/src/error-gen.c @@ -1,22 +1,12 @@ /* - Copyright (c) 2008-2009 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/>. -*/ + Copyright (c) 2008-2012 Red Hat, Inc. <http://www.redhat.com> + This file is part of GlusterFS. + 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 #define _CONFIG_H #include "config.h" @@ -24,166 +14,165 @@ #include "xlator.h" #include "error-gen.h" +#include "statedump.h" sys_error_t error_no_list[] = { - [ERR_LOOKUP] = { .error_no_count = 4, + [GF_FOP_LOOKUP] = { .error_no_count = 4, .error_no = {ENOENT,ENOTDIR, ENAMETOOLONG,EAGAIN}}, - [ERR_STAT] = { .error_no_count = 7, + [GF_FOP_STAT] = { .error_no_count = 7, .error_no = {EACCES,EBADF,EFAULT, ENAMETOOLONG,ENOENT, ENOMEM,ENOTDIR}}, - [ERR_READLINK] = { .error_no_count = 8, + [GF_FOP_READLINK] = { .error_no_count = 8, .error_no = {EACCES,EFAULT,EINVAL,EIO, ENAMETOOLONG,ENOENT,ENOMEM, ENOTDIR}}, - [ERR_MKNOD] = { .error_no_count = 11, + [GF_FOP_MKNOD] = { .error_no_count = 11, .error_no = {EACCES,EEXIST,EFAULT, EINVAL,ENAMETOOLONG, ENOENT,ENOMEM,ENOSPC, ENOTDIR,EPERM,EROFS}}, - [ERR_MKDIR] = { .error_no_count = 10, + [GF_FOP_MKDIR] = { .error_no_count = 10, .error_no = {EACCES,EEXIST,EFAULT, ENAMETOOLONG,ENOENT, ENOMEM,ENOSPC,ENOTDIR, EPERM,EROFS}}, - [ERR_UNLINK] = { .error_no_count = 10, + [GF_FOP_UNLINK] = { .error_no_count = 10, .error_no = {EACCES,EBUSY,EFAULT,EIO, EISDIR,ENAMETOOLONG, ENOENT,ENOMEM,ENOTDIR, EPERM,EROFS}}, - [ERR_RMDIR] = { .error_no_count = 8, + [GF_FOP_RMDIR] = { .error_no_count = 8, .error_no = {EACCES,EBUSY,EFAULT, ENOMEM,ENOTDIR,ENOTEMPTY, EPERM,EROFS}}, - [ERR_SYMLINK] = { .error_no_count = 11, + [GF_FOP_SYMLINK] = { .error_no_count = 11, .error_no = {EACCES,EEXIST,EFAULT,EIO, ENAMETOOLONG,ENOENT,ENOMEM, ENOSPC,ENOTDIR,EPERM, EROFS}}, - [ERR_RENAME] = { .error_no_count = 13, + [GF_FOP_RENAME] = { .error_no_count = 13, .error_no = {EACCES,EBUSY,EFAULT, EINVAL,EISDIR,EMLINK, ENAMETOOLONG,ENOENT,ENOMEM, ENOSPC,ENOTDIR,EEXIST, EXDEV}}, - [ERR_LINK] = { .error_no_count = 13, + [GF_FOP_LINK] = { .error_no_count = 13, .error_no = {EACCES,EFAULT,EEXIST,EIO, EMLINK,ENAMETOOLONG, ENOENT,ENOMEM,ENOSPC, ENOTDIR,EPERM,EROFS, EXDEV}}, - [ERR_TRUNCATE] = { .error_no_count = 10, + [GF_FOP_TRUNCATE] = { .error_no_count = 10, .error_no = {EACCES,EFAULT,EFBIG, EINTR,EINVAL,EIO,EISDIR, ENAMETOOLONG,ENOENT, EISDIR}}, - [ERR_CREATE] = {.error_no_count = 10, + [GF_FOP_CREATE] = {.error_no_count = 10, .error_no = {EACCES,EEXIST,EFAULT, EISDIR,EMFILE,ENAMETOOLONG, ENFILE,ENODEV,ENOENT, ENODEV}}, - [ERR_OPEN] = { .error_no_count = 10, + [GF_FOP_OPEN] = { .error_no_count = 10, .error_no = {EACCES,EEXIST,EFAULT, EISDIR,EMFILE, ENAMETOOLONG,ENFILE, ENODEV,ENOENT,ENOMEM}}, - [ERR_READV] = { .error_no_count = 5, + [GF_FOP_READ] = { .error_no_count = 5, .error_no = {EINVAL,EBADF,EFAULT,EISDIR, ENAMETOOLONG}}, - [ERR_WRITEV] = { .error_no_count = 5, + [GF_FOP_WRITE] = { .error_no_count = 7, .error_no = {EINVAL,EBADF,EFAULT,EISDIR, - ENAMETOOLONG}}, - [ERR_STATFS] = {.error_no_count = 10, + ENAMETOOLONG,ENOSPC, + GF_ERROR_SHORT_WRITE}}, + [GF_FOP_STATFS] = {.error_no_count = 10, .error_no = {EACCES,EBADF,EFAULT,EINTR, EIO,ENAMETOOLONG,ENOENT, ENOMEM,ENOSYS,ENOTDIR}}, - [ERR_FLUSH] = { .error_no_count = 5, + [GF_FOP_FLUSH] = { .error_no_count = 5, .error_no = {EACCES,EFAULT, ENAMETOOLONG,ENOSYS, ENOENT}}, - [ERR_FSYNC] = { .error_no_count = 4, + [GF_FOP_FSYNC] = { .error_no_count = 4, .error_no = {EBADF,EIO,EROFS,EINVAL}}, - [ERR_SETXATTR] = { .error_no_count = 4, + [GF_FOP_SETXATTR] = { .error_no_count = 4, .error_no = {EACCES,EBADF,EINTR, ENAMETOOLONG}}, - [ERR_GETXATTR] = { .error_no_count = 4, + [GF_FOP_GETXATTR] = { .error_no_count = 4, .error_no = {EACCES,EBADF,ENAMETOOLONG, EINTR}}, - [ERR_REMOVEXATTR] = { .error_no_count = 4, + [GF_FOP_REMOVEXATTR] = { .error_no_count = 4, .error_no = {EACCES,EBADF,ENAMETOOLONG, EINTR}}, - [ERR_OPENDIR] = { .error_no_count = 8, + [GF_FOP_FSETXATTR] = { .error_no_count = 4, + .error_no = {EACCES,EBADF,EINTR, + ENAMETOOLONG}}, + [GF_FOP_FGETXATTR] = { .error_no_count = 4, + .error_no = {EACCES,EBADF,ENAMETOOLONG, + EINTR}}, + [GF_FOP_FREMOVEXATTR] = { .error_no_count = 4, + .error_no = {EACCES,EBADF,ENAMETOOLONG, + EINTR}}, + [GF_FOP_OPENDIR] = { .error_no_count = 8, .error_no = {EACCES,EEXIST,EFAULT, EISDIR,EMFILE, ENAMETOOLONG,ENFILE, ENODEV}}, - [ERR_READDIR] = { .error_no_count = 5, + [GF_FOP_READDIR] = { .error_no_count = 5, .error_no = {EINVAL,EACCES,EBADF, EMFILE,ENOENT}}, - [ERR_READDIRP] = { .error_no_count = 5, + [GF_FOP_READDIRP] = { .error_no_count = 5, .error_no = {EINVAL,EACCES,EBADF, EMFILE,ENOENT}}, - [ERR_GETDENTS] = { .error_no_count = 5, - .error_no = {EBADF,EFAULT,EINVAL, - ENOENT,ENOTDIR}}, - [ERR_FSYNCDIR] = { .error_no_count = 4, + [GF_FOP_FSYNCDIR] = { .error_no_count = 4, .error_no = {EBADF,EIO,EROFS,EINVAL}}, - [ERR_ACCESS] = { .error_no_count = 8, + [GF_FOP_ACCESS] = { .error_no_count = 8, .error_no = {EACCES,ENAMETOOLONG, ENOENT,ENOTDIR,EROFS, EFAULT,EINVAL,EIO}}, - [ERR_FTRUNCATE] = { .error_no_count = 9, + [GF_FOP_FTRUNCATE] = { .error_no_count = 9, .error_no = {EACCES,EFAULT,EFBIG, EINTR,EINVAL,EIO,EISDIR, ENAMETOOLONG,ENOENT}}, - [ERR_FSTAT] = { .error_no_count = 7, + [GF_FOP_FSTAT] = { .error_no_count = 7, .error_no = {EACCES,EBADF,EFAULT, ENAMETOOLONG,ENOENT, ENOMEM,ENOTDIR}}, - [ERR_LK] = { .error_no_count = 4, + [GF_FOP_LK] = { .error_no_count = 4, .error_no = {EACCES,EFAULT,ENOENT, EINTR}}, - [ERR_SETDENTS] = { .error_no_count = 4, - .error_no = {EACCES,EBADF,EINTR, - ENAMETOOLONG}}, - [ERR_CHECKSUM] = { .error_no_count = 4, - .error_no = {EACCES,EBADF, - ENAMETOOLONG,EINTR}}, - [ERR_XATTROP] = { .error_no_count = 5, + [GF_FOP_XATTROP] = { .error_no_count = 5, .error_no = {EACCES,EFAULT, ENAMETOOLONG,ENOSYS, ENOENT}}, - [ERR_FXATTROP] = { .error_no_count = 4, + [GF_FOP_FXATTROP] = { .error_no_count = 4, .error_no = {EBADF,EIO,EROFS,EINVAL}}, - [ERR_INODELK] = { .error_no_count = 4, + [GF_FOP_INODELK] = { .error_no_count = 4, .error_no = {EACCES,EBADF,EINTR, ENAMETOOLONG}}, - [ERR_FINODELK] = { .error_no_count = 4, + [GF_FOP_FINODELK] = { .error_no_count = 4, .error_no = {EACCES,EBADF,EINTR, ENAMETOOLONG}}, - [ERR_ENTRYLK] = { .error_no_count = 4, + [GF_FOP_ENTRYLK] = { .error_no_count = 4, .error_no = {EACCES,EBADF, ENAMETOOLONG,EINTR}}, - [ERR_FENTRYLK] = { .error_no_count = 10, + [GF_FOP_FENTRYLK] = { .error_no_count = 10, .error_no = {EACCES,EEXIST,EFAULT, EISDIR,EMFILE, ENAMETOOLONG,ENFILE, ENODEV,ENOENT,ENOMEM}}, - [ERR_SETATTR] = {.error_no_count = 11, + [GF_FOP_SETATTR] = {.error_no_count = 11, .error_no = {EACCES,EFAULT,EIO, ENAMETOOLONG,ENOENT, ENOMEM,ENOTDIR,EPERM, EROFS,EBADF,EIO}}, - [ERR_FSETATTR] = { .error_no_count = 11, + [GF_FOP_FSETATTR] = { .error_no_count = 11, .error_no = {EACCES,EFAULT,EIO, ENAMETOOLONG,ENOENT, ENOMEM,ENOTDIR,EPERM, EROFS,EBADF,EIO}}, - [ERR_STATS] = { .error_no_count = 4, - .error_no = {EACCES,EBADF,ENAMETOOLONG, - EINTR}}, - [ERR_GETSPEC] = { .error_no_count = 4, + [GF_FOP_GETSPEC] = { .error_no_count = 4, .error_no = {EACCES,EBADF,ENAMETOOLONG, EINTR}} }; @@ -193,7 +182,7 @@ generate_rand_no (int op_no) { int rand_no = 0; - if (op_no < NO_OF_FOPS) + if (op_no < GF_FOP_MAXVALUE) rand_no = rand () % error_no_list[op_no].error_no_count; return rand_no; } @@ -249,6 +238,8 @@ conv_errno_to_int (char **error_no) return EINTR; else if (!strcmp ((*error_no), "EFBIG")) return EFBIG; + else if (!strcmp((*error_no), "GF_ERROR_SHORT_WRITE")) + return GF_ERROR_SHORT_WRITE; else return EAGAIN; } @@ -257,89 +248,87 @@ int get_fop_int (char **op_no_str) { if (!strcmp ((*op_no_str), "lookup")) - return ERR_LOOKUP; + return GF_FOP_LOOKUP; else if (!strcmp ((*op_no_str), "stat")) - return ERR_STAT; + return GF_FOP_STAT; else if (!strcmp ((*op_no_str), "readlink")) - return ERR_READLINK; + return GF_FOP_READLINK; else if (!strcmp ((*op_no_str), "mknod")) - return ERR_MKNOD; + return GF_FOP_MKNOD; else if (!strcmp ((*op_no_str), "mkdir")) - return ERR_MKDIR; + return GF_FOP_MKDIR; else if (!strcmp ((*op_no_str), "unlink")) - return ERR_UNLINK; + return GF_FOP_UNLINK; else if (!strcmp ((*op_no_str), "rmdir")) - return ERR_RMDIR; + return GF_FOP_RMDIR; else if (!strcmp ((*op_no_str), "symlink")) - return ERR_SYMLINK; + return GF_FOP_SYMLINK; else if (!strcmp ((*op_no_str), "rename")) - return ERR_RENAME; + return GF_FOP_RENAME; else if (!strcmp ((*op_no_str), "link")) - return ERR_LINK; + return GF_FOP_LINK; else if (!strcmp ((*op_no_str), "truncate")) - return ERR_TRUNCATE; + return GF_FOP_TRUNCATE; else if (!strcmp ((*op_no_str), "create")) - return ERR_CREATE; + return GF_FOP_CREATE; else if (!strcmp ((*op_no_str), "open")) - return ERR_OPEN; + return GF_FOP_OPEN; else if (!strcmp ((*op_no_str), "readv")) - return ERR_READV; + return GF_FOP_READ; else if (!strcmp ((*op_no_str), "writev")) - return ERR_WRITEV; + return GF_FOP_WRITE; else if (!strcmp ((*op_no_str), "statfs")) - return ERR_STATFS; + return GF_FOP_STATFS; else if (!strcmp ((*op_no_str), "flush")) - return ERR_FLUSH; + return GF_FOP_FLUSH; else if (!strcmp ((*op_no_str), "fsync")) - return ERR_FSYNC; + return GF_FOP_FSYNC; else if (!strcmp ((*op_no_str), "setxattr")) - return ERR_SETXATTR; + return GF_FOP_SETXATTR; else if (!strcmp ((*op_no_str), "getxattr")) - return ERR_GETXATTR; + return GF_FOP_GETXATTR; else if (!strcmp ((*op_no_str), "removexattr")) - return ERR_REMOVEXATTR; + return GF_FOP_REMOVEXATTR; + else if (!strcmp ((*op_no_str), "fsetxattr")) + return GF_FOP_FSETXATTR; + else if (!strcmp ((*op_no_str), "fgetxattr")) + return GF_FOP_FGETXATTR; + else if (!strcmp ((*op_no_str), "fremovexattr")) + return GF_FOP_FREMOVEXATTR; else if (!strcmp ((*op_no_str), "opendir")) - return ERR_OPENDIR; + return GF_FOP_OPENDIR; else if (!strcmp ((*op_no_str), "readdir")) - return ERR_READDIR; + return GF_FOP_READDIR; else if (!strcmp ((*op_no_str), "readdirp")) - return ERR_READDIRP; - else if (!strcmp ((*op_no_str), "getdents")) - return ERR_GETDENTS; + return GF_FOP_READDIRP; else if (!strcmp ((*op_no_str), "fsyncdir")) - return ERR_FSYNCDIR; + return GF_FOP_FSYNCDIR; else if (!strcmp ((*op_no_str), "access")) - return ERR_ACCESS; + return GF_FOP_ACCESS; else if (!strcmp ((*op_no_str), "ftruncate")) - return ERR_FTRUNCATE; + return GF_FOP_FTRUNCATE; else if (!strcmp ((*op_no_str), "fstat")) - return ERR_FSTAT; + return GF_FOP_FSTAT; else if (!strcmp ((*op_no_str), "lk")) - return ERR_LK; - else if (!strcmp ((*op_no_str), "setdents")) - return ERR_SETDENTS; - else if (!strcmp ((*op_no_str), "checksum")) - return ERR_CHECKSUM; + return GF_FOP_LK; else if (!strcmp ((*op_no_str), "xattrop")) - return ERR_XATTROP; + return GF_FOP_XATTROP; else if (!strcmp ((*op_no_str), "fxattrop")) - return ERR_FXATTROP; + return GF_FOP_FXATTROP; else if (!strcmp ((*op_no_str), "inodelk")) - return ERR_INODELK; + return GF_FOP_INODELK; else if (!strcmp ((*op_no_str), "finodelk")) - return ERR_FINODELK; + return GF_FOP_FINODELK; else if (!strcmp ((*op_no_str), "etrylk")) - return ERR_ENTRYLK; + return GF_FOP_ENTRYLK; else if (!strcmp ((*op_no_str), "fentrylk")) - return ERR_FENTRYLK; + return GF_FOP_FENTRYLK; else if (!strcmp ((*op_no_str), "setattr")) - return ERR_SETATTR; + return GF_FOP_SETATTR; else if (!strcmp ((*op_no_str), "fsetattr")) - return ERR_FSETATTR; - else if (!strcmp ((*op_no_str), "stats")) - return ERR_STATS; + return GF_FOP_FSETATTR; else if (!strcmp ((*op_no_str), "getspec")) - return ERR_GETSPEC; + return GF_FOP_GETSPEC; else return -1; } @@ -376,12 +365,14 @@ error_gen (xlator_t *this, int op_no) else { rand_no = generate_rand_no (op_no); - if (op_no >= NO_OF_FOPS) + if (op_no >= GF_FOP_MAXVALUE) op_no = 0; if (rand_no >= error_no_list[op_no].error_no_count) rand_no = 0; ret = error_no_list[op_no].error_no[rand_no]; } + if (egp->random_failure == _gf_true) + egp->failure_iter_no = 3 + (rand () % GF_UNIVERSAL_ANSWER); } return ret; } @@ -390,667 +381,663 @@ error_gen (xlator_t *this, int op_no) int error_gen_lookup_cbk (call_frame_t *frame, void *cookie, xlator_t *this, int32_t op_ret, int32_t op_errno, inode_t *inode, - struct stat *buf, dict_t *dict, struct stat *postparent) + struct iatt *buf, dict_t *xdata, struct iatt *postparent) { STACK_UNWIND_STRICT (lookup, frame, op_ret, op_errno, inode, - buf, dict, postparent); - return 0; + buf, xdata, postparent); + return 0; } int error_gen_lookup (call_frame_t *frame, xlator_t *this, loc_t *loc, - dict_t *xattr_req) + dict_t *xdata) { int op_errno = 0; eg_t *egp = NULL; int enable = 1; egp = this->private; - enable = egp->enable[ERR_LOOKUP]; + enable = egp->enable[GF_FOP_LOOKUP]; if (enable) - op_errno = error_gen (this, ERR_LOOKUP); + op_errno = error_gen (this, GF_FOP_LOOKUP); if (op_errno) { GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno)); - STACK_UNWIND (frame, -1, op_errno, NULL, NULL, NULL, - NULL); - return 0; + STACK_UNWIND_STRICT (lookup, frame, -1, op_errno, NULL, NULL, NULL, + NULL); + return 0; } STACK_WIND (frame, error_gen_lookup_cbk, FIRST_CHILD(this), FIRST_CHILD(this)->fops->lookup, - loc, xattr_req); - return 0; -} - - -int -error_gen_forget (xlator_t *this, inode_t *inode) -{ - return 0; + loc, xdata); + return 0; } int error_gen_stat_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, struct stat *buf) + int32_t op_ret, int32_t op_errno, struct iatt *buf, dict_t *xdata) { - STACK_UNWIND_STRICT (stat, frame, op_ret, op_errno, buf); - - return 0; + STACK_UNWIND_STRICT (stat, frame, op_ret, op_errno, buf, xdata); + return 0; } int -error_gen_stat (call_frame_t *frame, xlator_t *this, loc_t *loc) +error_gen_stat (call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *xdata) { int op_errno = 0; eg_t *egp = NULL; int enable = 1; egp = this->private; - enable = egp->enable[ERR_STAT]; + enable = egp->enable[GF_FOP_STAT]; if (enable) - op_errno = error_gen (this, ERR_STAT); + op_errno = error_gen (this, GF_FOP_STAT); if (op_errno) { GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno)); - STACK_UNWIND (frame, -1, op_errno, NULL); - return 0; + STACK_UNWIND_STRICT (stat, frame, -1, op_errno, NULL, xdata); + return 0; } STACK_WIND (frame, error_gen_stat_cbk, FIRST_CHILD(this), FIRST_CHILD(this)->fops->stat, - loc); - return 0; + loc, xdata); + return 0; } int error_gen_setattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this, int32_t op_ret, int32_t op_errno, - struct stat *preop, struct stat *postop) + struct iatt *preop, struct iatt *postop, dict_t *xdata) { - STACK_UNWIND_STRICT (setattr, frame, op_ret, op_errno, preop, postop); - - return 0; + STACK_UNWIND_STRICT (setattr, frame, op_ret, op_errno, preop, postop, xdata); + return 0; } int error_gen_setattr (call_frame_t *frame, xlator_t *this, loc_t *loc, - struct stat *stbuf, int32_t valid) + struct iatt *stbuf, int32_t valid, dict_t *xdata) { int op_errno = 0; eg_t *egp = NULL; int enable = 1; egp = this->private; - enable = egp->enable[ERR_SETATTR]; + enable = egp->enable[GF_FOP_SETATTR]; if (enable) - op_errno = error_gen (this, ERR_SETATTR); + op_errno = error_gen (this, GF_FOP_SETATTR); if (op_errno) { GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno)); - STACK_UNWIND_STRICT (setattr, frame, -1, op_errno, NULL, NULL); - return 0; + STACK_UNWIND_STRICT (setattr, frame, -1, op_errno, NULL, NULL, xdata); + return 0; } STACK_WIND (frame, error_gen_setattr_cbk, FIRST_CHILD(this), FIRST_CHILD(this)->fops->setattr, - loc, stbuf, valid); - return 0; + loc, stbuf, valid, xdata); + return 0; } int error_gen_fsetattr (call_frame_t *frame, xlator_t *this, fd_t *fd, - struct stat *stbuf, int32_t valid) + struct iatt *stbuf, int32_t valid, dict_t *xdata) { int op_errno = 0; eg_t *egp = NULL; int enable = 1; egp = this->private; - enable = egp->enable[ERR_FSETATTR]; + enable = egp->enable[GF_FOP_FSETATTR]; if (enable) - op_errno = error_gen (this, ERR_FSETATTR); + op_errno = error_gen (this, GF_FOP_FSETATTR); if (op_errno) { GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno)); - STACK_UNWIND_STRICT (fsetattr, frame, -1, op_errno, NULL, NULL); - return 0; + STACK_UNWIND_STRICT (fsetattr, frame, -1, op_errno, NULL, NULL, xdata); + return 0; } STACK_WIND (frame, error_gen_setattr_cbk, FIRST_CHILD(this), FIRST_CHILD(this)->fops->fsetattr, - fd, stbuf, valid); - return 0; + fd, stbuf, valid, xdata); + return 0; } int error_gen_truncate_cbk (call_frame_t *frame, void *cookie, xlator_t *this, int32_t op_ret, int32_t op_errno, - struct stat *prebuf, struct stat *postbuf) + struct iatt *prebuf, struct iatt *postbuf, dict_t *xdata) { STACK_UNWIND_STRICT (truncate, frame, op_ret, op_errno, - prebuf, postbuf); - return 0; + prebuf, postbuf, xdata); + return 0; } int error_gen_truncate (call_frame_t *frame, xlator_t *this, loc_t *loc, - off_t offset) + off_t offset, dict_t *xdata) { int op_errno = 0; eg_t *egp = NULL; int enable = 1; egp = this->private; - enable = egp->enable[ERR_TRUNCATE]; + enable = egp->enable[GF_FOP_TRUNCATE]; if (enable) - op_errno = error_gen (this, ERR_TRUNCATE); + op_errno = error_gen (this, GF_FOP_TRUNCATE); if (op_errno) { GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno)); STACK_UNWIND_STRICT (truncate, frame, -1, op_errno, - NULL, NULL); - return 0; + NULL, NULL, xdata); + return 0; } STACK_WIND (frame, error_gen_truncate_cbk, FIRST_CHILD(this), FIRST_CHILD(this)->fops->truncate, - loc, offset); - return 0; + loc, offset, xdata); + return 0; } int error_gen_ftruncate_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, struct stat *prebuf, - struct stat *postbuf) + int32_t op_ret, int32_t op_errno, struct iatt *prebuf, + struct iatt *postbuf, dict_t *xdata) { STACK_UNWIND_STRICT (ftruncate, frame, op_ret, op_errno, - prebuf, postbuf); - return 0; + prebuf, postbuf, xdata); + return 0; } int error_gen_ftruncate (call_frame_t *frame, xlator_t *this, fd_t *fd, - off_t offset) + off_t offset, dict_t *xdata) { int op_errno = 0; eg_t *egp =NULL; int enable = 1; egp = this->private; - enable = egp->enable[ERR_FTRUNCATE]; + enable = egp->enable[GF_FOP_FTRUNCATE]; if (enable) - op_errno = error_gen (this, ERR_FTRUNCATE); + op_errno = error_gen (this, GF_FOP_FTRUNCATE); if (op_errno) { GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno)); STACK_UNWIND_STRICT (ftruncate, frame, -1, op_errno, - NULL, NULL); - return 0; + NULL, NULL, xdata); + return 0; } STACK_WIND (frame, error_gen_ftruncate_cbk, FIRST_CHILD(this), FIRST_CHILD(this)->fops->ftruncate, - fd, offset); - return 0; + fd, offset, xdata); + return 0; } int error_gen_access_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno) + int32_t op_ret, int32_t op_errno, dict_t *xdata) { - STACK_UNWIND_STRICT (access, frame, op_ret, op_errno); - - return 0; + STACK_UNWIND_STRICT (access, frame, op_ret, op_errno, xdata); + return 0; } int error_gen_access (call_frame_t *frame, xlator_t *this, loc_t *loc, - int32_t mask) + int32_t mask, dict_t *xdata) { int op_errno = 0; eg_t *egp = NULL; int enable = 1; egp = this->private; - enable = egp->enable[ERR_ACCESS]; + enable = egp->enable[GF_FOP_ACCESS]; if (enable) - op_errno = error_gen (this, ERR_ACCESS); + op_errno = error_gen (this, GF_FOP_ACCESS); if (op_errno) { GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno)); - STACK_UNWIND_STRICT (access, frame, -1, op_errno); - return 0; + STACK_UNWIND_STRICT (access, frame, -1, op_errno, xdata); + return 0; } STACK_WIND (frame, error_gen_access_cbk, FIRST_CHILD(this), FIRST_CHILD(this)->fops->access, - loc, mask); - return 0; + loc, mask, xdata); + return 0; } int error_gen_readlink_cbk (call_frame_t *frame, void *cookie, xlator_t *this, int32_t op_ret, int32_t op_errno, - const char *path, struct stat *sbuf) + const char *path, struct iatt *sbuf, dict_t *xdata) { - STACK_UNWIND_STRICT (readlink, frame, op_ret, op_errno, path, sbuf); - return 0; + STACK_UNWIND_STRICT (readlink, frame, op_ret, op_errno, path, sbuf, xdata); + return 0; } int error_gen_readlink (call_frame_t *frame, xlator_t *this, loc_t *loc, - size_t size) + size_t size, dict_t *xdata) { int op_errno = 0; eg_t *egp = NULL; int enable = 1; egp = this->private; - enable = egp->enable[ERR_READLINK]; + enable = egp->enable[GF_FOP_READLINK]; if (enable) - op_errno = error_gen (this, ERR_READLINK); + op_errno = error_gen (this, GF_FOP_READLINK); if (op_errno) { GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno)); - STACK_UNWIND_STRICT (readlink, frame, -1, op_errno, NULL, NULL); - return 0; + STACK_UNWIND_STRICT (readlink, frame, -1, op_errno, NULL, NULL, xdata); + return 0; } STACK_WIND (frame, error_gen_readlink_cbk, FIRST_CHILD(this), FIRST_CHILD(this)->fops->readlink, - loc, size); - return 0; + loc, size, xdata); + return 0; } int error_gen_mknod_cbk (call_frame_t *frame, void *cookie, xlator_t *this, int32_t op_ret, int32_t op_errno, inode_t *inode, - struct stat *buf, struct stat *preparent, - struct stat *postparent) + struct iatt *buf, struct iatt *preparent, + struct iatt *postparent, dict_t *xdata) { STACK_UNWIND_STRICT (mknod, frame, op_ret, op_errno, inode, buf, - preparent, postparent); - return 0; + preparent, postparent, xdata); + return 0; } int error_gen_mknod (call_frame_t *frame, xlator_t *this, loc_t *loc, - mode_t mode, dev_t rdev) + mode_t mode, dev_t rdev, mode_t umask, dict_t *xdata) { int op_errno = 0; eg_t *egp = NULL; int enable = 1; egp = this->private; - enable = egp->enable[ERR_MKNOD]; + enable = egp->enable[GF_FOP_MKNOD]; if (enable) - op_errno = error_gen (this, ERR_MKNOD); + op_errno = error_gen (this, GF_FOP_MKNOD); if (op_errno) { GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno)); STACK_UNWIND_STRICT (mknod, frame, -1, op_errno, NULL, NULL, - NULL, NULL); - return 0; + NULL, NULL, xdata); + return 0; } STACK_WIND (frame, error_gen_mknod_cbk, FIRST_CHILD(this), FIRST_CHILD(this)->fops->mknod, - loc, mode, rdev); - return 0; + loc, mode, rdev, umask, xdata); + return 0; } int error_gen_mkdir_cbk (call_frame_t *frame, void *cookie, xlator_t *this, int32_t op_ret, int32_t op_errno, inode_t *inode, - struct stat *buf, struct stat *preparent, - struct stat *postparent) + struct iatt *buf, struct iatt *preparent, + struct iatt *postparent, dict_t *xdata) { STACK_UNWIND_STRICT (mkdir, frame, op_ret, op_errno, inode, buf, - preparent, postparent); - return 0; + preparent, postparent, xdata); + return 0; } int error_gen_mkdir (call_frame_t *frame, xlator_t *this, - loc_t *loc, mode_t mode) + loc_t *loc, mode_t mode, mode_t umask, dict_t *xdata) { int op_errno = 0; eg_t *egp = NULL; int enable = 1; egp = this->private; - enable = egp->enable[ERR_MKDIR]; + enable = egp->enable[GF_FOP_MKDIR]; if (enable) - op_errno = error_gen (this, ERR_MKDIR); + op_errno = error_gen (this, GF_FOP_MKDIR); if (op_errno) { GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno)); STACK_UNWIND_STRICT (mkdir, frame, -1, op_errno, NULL, NULL, - NULL, NULL); - return 0; + NULL, NULL, xdata); + return 0; } STACK_WIND (frame, error_gen_mkdir_cbk, FIRST_CHILD(this), FIRST_CHILD(this)->fops->mkdir, - loc, mode); - return 0; + loc, mode, umask, xdata); + return 0; } int error_gen_unlink_cbk (call_frame_t *frame, void *cookie, xlator_t *this, int32_t op_ret, int32_t op_errno, - struct stat *preparent, struct stat *postparent) + struct iatt *preparent, struct iatt *postparent, dict_t *xdata) { STACK_UNWIND_STRICT (unlink, frame, op_ret, op_errno, - preparent, postparent); - return 0; + preparent, postparent, xdata); + return 0; } int -error_gen_unlink (call_frame_t *frame, xlator_t *this, loc_t *loc) +error_gen_unlink (call_frame_t *frame, xlator_t *this, loc_t *loc, int xflag, + dict_t *xdata) { int op_errno = 0; eg_t *egp = NULL; int enable = 1; egp = this->private; - enable = egp->enable[ERR_UNLINK]; + enable = egp->enable[GF_FOP_UNLINK]; if (enable) - op_errno = error_gen (this, ERR_UNLINK); + op_errno = error_gen (this, GF_FOP_UNLINK); if (op_errno) { GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno)); - STACK_UNWIND_STRICT (unlink, frame, -1, op_errno, NULL, NULL); - return 0; + STACK_UNWIND_STRICT (unlink, frame, -1, op_errno, NULL, NULL, + xdata); + return 0; } STACK_WIND (frame, error_gen_unlink_cbk, FIRST_CHILD(this), FIRST_CHILD(this)->fops->unlink, - loc); - return 0; + loc, xflag, xdata); + return 0; } int error_gen_rmdir_cbk (call_frame_t *frame, void *cookie, xlator_t *this, int32_t op_ret, int32_t op_errno, - struct stat *preparent, struct stat *postparent) + struct iatt *preparent, struct iatt *postparent, + dict_t *xdata) { STACK_UNWIND_STRICT (rmdir, frame, op_ret, op_errno, - preparent, postparent); - return 0; + preparent, postparent, xdata); + return 0; } int -error_gen_rmdir (call_frame_t *frame, xlator_t *this, loc_t *loc) +error_gen_rmdir (call_frame_t *frame, xlator_t *this, loc_t *loc, int flags, + dict_t *xdata) { int op_errno = 0; eg_t *egp = NULL; int enable = 1; egp = this->private; - enable = egp->enable[ERR_RMDIR]; + enable = egp->enable[GF_FOP_RMDIR]; if (enable) - op_errno = error_gen (this, ERR_RMDIR); + op_errno = error_gen (this, GF_FOP_RMDIR); if (op_errno) { GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno)); - STACK_UNWIND_STRICT (rmdir, frame, -1, op_errno, NULL, NULL); - return 0; + STACK_UNWIND_STRICT (rmdir, frame, -1, op_errno, NULL, NULL, xdata); + return 0; } STACK_WIND (frame, error_gen_rmdir_cbk, FIRST_CHILD(this), FIRST_CHILD(this)->fops->rmdir, - loc); - return 0; + loc, flags, xdata); + return 0; } int error_gen_symlink_cbk (call_frame_t *frame, void *cookie, xlator_t *this, int32_t op_ret, int32_t op_errno, inode_t *inode, - struct stat *buf, struct stat *preparent, - struct stat *postparent) + struct iatt *buf, struct iatt *preparent, + struct iatt *postparent, dict_t *xdata) { STACK_UNWIND_STRICT (symlink, frame, op_ret, op_errno, inode, buf, - preparent, postparent); - return 0; + preparent, postparent, xdata); + return 0; } int error_gen_symlink (call_frame_t *frame, xlator_t *this, const char *linkpath, - loc_t *loc) + loc_t *loc, mode_t umask, dict_t *xdata) { int op_errno = 0; eg_t *egp = NULL; int enable = 1; egp = this->private; - enable = egp->enable[ERR_SYMLINK]; + enable = egp->enable[GF_FOP_SYMLINK]; if (enable) - op_errno = error_gen (this, ERR_SYMLINK); + op_errno = error_gen (this, GF_FOP_SYMLINK); if (op_errno) { GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno)); STACK_UNWIND_STRICT (symlink, frame, -1, op_errno, NULL, NULL, - NULL, NULL); /* pre & post parent attr */ + NULL, NULL, NULL); /* pre & post parent attr */ return 0; } STACK_WIND (frame, error_gen_symlink_cbk, FIRST_CHILD(this), FIRST_CHILD(this)->fops->symlink, - linkpath, loc); - return 0; + linkpath, loc, umask, xdata); + return 0; } int error_gen_rename_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, struct stat *buf, - struct stat *preoldparent, struct stat *postoldparent, - struct stat *prenewparent, struct stat *postnewparent) + int32_t op_ret, int32_t op_errno, struct iatt *buf, + struct iatt *preoldparent, struct iatt *postoldparent, + struct iatt *prenewparent, struct iatt *postnewparent, + dict_t *xdata) { STACK_UNWIND_STRICT (rename, frame, op_ret, op_errno, buf, preoldparent, postoldparent, - prenewparent, postnewparent); - return 0; + prenewparent, postnewparent, xdata); + return 0; } int error_gen_rename (call_frame_t *frame, xlator_t *this, - loc_t *oldloc, loc_t *newloc) + loc_t *oldloc, loc_t *newloc, dict_t *xdata) { int op_errno = 0; eg_t *egp = NULL; int enable = 1; egp = this->private; - enable = egp->enable[ERR_RENAME]; + enable = egp->enable[GF_FOP_RENAME]; if (enable) - op_errno = error_gen (this, ERR_RENAME); + op_errno = error_gen (this, GF_FOP_RENAME); if (op_errno) { GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno)); STACK_UNWIND_STRICT (rename, frame, -1, op_errno, NULL, - NULL, NULL, NULL, NULL); /* pre & post parent attr */ + NULL, NULL, NULL, NULL, NULL); return 0; } STACK_WIND (frame, error_gen_rename_cbk, FIRST_CHILD(this), FIRST_CHILD(this)->fops->rename, - oldloc, newloc); - return 0; + oldloc, newloc, xdata); + return 0; } int error_gen_link_cbk (call_frame_t *frame, void *cookie, xlator_t *this, int32_t op_ret, int32_t op_errno, inode_t *inode, - struct stat *buf, struct stat *preparent, - struct stat *postparent) + struct iatt *buf, struct iatt *preparent, + struct iatt *postparent, dict_t *xdata) { STACK_UNWIND_STRICT (link, frame, op_ret, op_errno, inode, buf, - preparent, postparent); - return 0; + preparent, postparent, xdata); + return 0; } int error_gen_link (call_frame_t *frame, xlator_t *this, - loc_t *oldloc, loc_t *newloc) + loc_t *oldloc, loc_t *newloc, dict_t *xdata) { int op_errno = 0; eg_t *egp = NULL; int enable = 1; egp = this->private; - enable = egp->enable[ERR_LINK]; + enable = egp->enable[GF_FOP_LINK]; if (enable) - op_errno = error_gen (this, ERR_LINK); + op_errno = error_gen (this, GF_FOP_LINK); if (op_errno) { GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno)); STACK_UNWIND_STRICT (link, frame, -1, op_errno, NULL, NULL, - NULL, NULL); /* pre & post parent attr */ + NULL, NULL, NULL); return 0; } STACK_WIND (frame, error_gen_link_cbk, FIRST_CHILD(this), FIRST_CHILD(this)->fops->link, - oldloc, newloc); - return 0; + oldloc, newloc, xdata); + return 0; } int error_gen_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 stat *buf, - struct stat *preparent, struct stat *postparent) + fd_t *fd, inode_t *inode, struct iatt *buf, + struct iatt *preparent, struct iatt *postparent, dict_t *xdata) { STACK_UNWIND_STRICT (create, frame, op_ret, op_errno, fd, inode, buf, - preparent, postparent); - return 0; + preparent, postparent, xdata); + return 0; } int error_gen_create (call_frame_t *frame, xlator_t *this, loc_t *loc, - int32_t flags, mode_t mode, fd_t *fd) + int32_t flags, mode_t mode, mode_t umask, fd_t *fd, + dict_t *xdata) { int op_errno = 0; eg_t *egp = NULL; int enable = 1; egp = this->private; - enable = egp->enable[ERR_CREATE]; + enable = egp->enable[GF_FOP_CREATE]; if (enable) - op_errno = error_gen (this, ERR_CREATE); + op_errno = error_gen (this, GF_FOP_CREATE); if (op_errno) { GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno)); STACK_UNWIND_STRICT (create, frame, -1, op_errno, NULL, NULL, - NULL, NULL, NULL); /* pre & post attr */ + NULL, NULL, NULL, NULL); return 0; } STACK_WIND (frame, error_gen_create_cbk, FIRST_CHILD(this), FIRST_CHILD(this)->fops->create, - loc, flags, mode, fd); - return 0; + loc, flags, mode, umask, fd, xdata); + return 0; } int error_gen_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) { - STACK_UNWIND_STRICT (open, frame, op_ret, op_errno, fd); - return 0; + STACK_UNWIND_STRICT (open, frame, op_ret, op_errno, fd, xdata); + return 0; } int error_gen_open (call_frame_t *frame, xlator_t *this, loc_t *loc, - int32_t flags, fd_t *fd, int32_t wbflags) + int32_t flags, fd_t *fd, dict_t *xdata) { int op_errno = 0; eg_t *egp = NULL; int enable = 1; egp = this->private; - enable = egp->enable[ERR_OPEN]; + enable = egp->enable[GF_FOP_OPEN]; if (enable) - op_errno = error_gen (this, ERR_OPEN); + op_errno = error_gen (this, GF_FOP_OPEN); if (op_errno) { GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno)); - STACK_UNWIND_STRICT (open, frame, -1, op_errno, NULL); - return 0; + STACK_UNWIND_STRICT (open, frame, -1, op_errno, NULL, xdata); + return 0; } STACK_WIND (frame, error_gen_open_cbk, FIRST_CHILD(this), FIRST_CHILD(this)->fops->open, - loc, flags, fd, wbflags); - return 0; + loc, flags, fd, xdata); + return 0; } @@ -1058,977 +1045,1051 @@ int error_gen_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 stat *stbuf, struct iobref *iobref) + struct iatt *stbuf, struct iobref *iobref, dict_t *xdata) { STACK_UNWIND_STRICT (readv, frame, op_ret, op_errno, - vector, count, stbuf, iobref); - return 0; + vector, count, stbuf, iobref, xdata); + return 0; } int error_gen_readv (call_frame_t *frame, xlator_t *this, - fd_t *fd, size_t size, off_t offset) + fd_t *fd, size_t size, off_t offset, uint32_t flags, dict_t *xdata) { int op_errno = 0; eg_t *egp = NULL; int enable = 1; egp = this->private; - enable = egp->enable[ERR_READV]; + enable = egp->enable[GF_FOP_READ]; if (enable) - op_errno = error_gen (this, ERR_READV); + op_errno = error_gen (this, GF_FOP_READ); if (op_errno) { GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno)); STACK_UNWIND_STRICT (readv, frame, -1, op_errno, NULL, 0, - NULL, NULL); - return 0; + NULL, NULL, xdata); + return 0; } STACK_WIND (frame, error_gen_readv_cbk, FIRST_CHILD(this), FIRST_CHILD(this)->fops->readv, - fd, size, offset); - return 0; + fd, size, offset, flags, xdata); + return 0; } int error_gen_writev_cbk (call_frame_t *frame, void *cookie, xlator_t *this, int32_t op_ret, int32_t op_errno, - struct stat *prebuf, struct stat *postbuf) + struct iatt *prebuf, struct iatt *postbuf, dict_t *xdata) { - STACK_UNWIND_STRICT (writev, frame, op_ret, op_errno, prebuf, postbuf); - return 0; + STACK_UNWIND_STRICT (writev, frame, op_ret, op_errno, prebuf, postbuf, xdata); + return 0; } int error_gen_writev (call_frame_t *frame, xlator_t *this, fd_t *fd, struct iovec *vector, int32_t count, - off_t off, struct iobref *iobref) + off_t off, uint32_t flags, struct iobref *iobref, dict_t *xdata) { int op_errno = 0; eg_t *egp = NULL; int enable = 1; egp = this->private; - enable = egp->enable[ERR_WRITEV]; + enable = egp->enable[GF_FOP_WRITE]; if (enable) - op_errno = error_gen (this, ERR_WRITEV); - - if (op_errno) { - GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno)); - STACK_UNWIND_STRICT (writev, frame, -1, op_errno, NULL, NULL); + op_errno = error_gen (this, GF_FOP_WRITE); + + if (op_errno == GF_ERROR_SHORT_WRITE) { + struct iovec *shortvec; + + /* + * A short write error returns some value less than what was + * requested from a write. To simulate this, replace the vector + * with one half the size; + */ + shortvec = iov_dup(vector, 1); + shortvec->iov_len /= 2; + + STACK_WIND(frame, error_gen_writev_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->writev, fd, shortvec, count, + off, flags, iobref, xdata); + GF_FREE(shortvec); return 0; + } else if (op_errno) { + GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno)); + STACK_UNWIND_STRICT (writev, frame, -1, op_errno, NULL, NULL, xdata); + return 0; } STACK_WIND (frame, error_gen_writev_cbk, FIRST_CHILD(this), FIRST_CHILD(this)->fops->writev, - fd, vector, count, off, iobref); - return 0; + fd, vector, count, off, flags, iobref, xdata); + return 0; } int error_gen_flush_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno) + int32_t op_ret, int32_t op_errno, dict_t *xdata) { - STACK_UNWIND_STRICT (flush, frame, op_ret, op_errno); - return 0; + STACK_UNWIND_STRICT (flush, frame, op_ret, op_errno, xdata); + return 0; } int -error_gen_flush (call_frame_t *frame, xlator_t *this, fd_t *fd) +error_gen_flush (call_frame_t *frame, xlator_t *this, fd_t *fd, dict_t *xdata) { int op_errno = 0; eg_t *egp = NULL; int enable = 1; egp = this->private; - enable = egp->enable[ERR_FLUSH]; + enable = egp->enable[GF_FOP_FLUSH]; if (enable) - op_errno = error_gen (this, ERR_FLUSH); + op_errno = error_gen (this, GF_FOP_FLUSH); if (op_errno) { GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno)); - STACK_UNWIND_STRICT (flush, frame, -1, op_errno); - return 0; + STACK_UNWIND_STRICT (flush, frame, -1, op_errno, xdata); + return 0; } STACK_WIND (frame, error_gen_flush_cbk, FIRST_CHILD(this), FIRST_CHILD(this)->fops->flush, - fd); - return 0; + fd, xdata); + return 0; } int error_gen_fsync_cbk (call_frame_t *frame, void *cookie, xlator_t *this, int32_t op_ret, - int32_t op_errno, struct stat *prebuf, - struct stat *postbuf) + int32_t op_errno, struct iatt *prebuf, + struct iatt *postbuf, dict_t *xdata) { - STACK_UNWIND_STRICT (fsync, frame, op_ret, op_errno, prebuf, postbuf); - return 0; + STACK_UNWIND_STRICT (fsync, frame, op_ret, op_errno, prebuf, postbuf, xdata); + return 0; } int -error_gen_fsync (call_frame_t *frame, xlator_t *this, fd_t *fd, int32_t flags) +error_gen_fsync (call_frame_t *frame, xlator_t *this, fd_t *fd, int32_t flags, dict_t *xdata) { int op_errno = 0; eg_t *egp = NULL; int enable = 1; egp = this->private; - enable = egp->enable[ERR_FSYNC]; + enable = egp->enable[GF_FOP_FSYNC]; if (enable) - op_errno = error_gen (this, ERR_FSYNC); + op_errno = error_gen (this, GF_FOP_FSYNC); if (op_errno) { GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno)); - STACK_UNWIND_STRICT (fsync, frame, -1, op_errno, NULL, NULL); - return 0; + STACK_UNWIND_STRICT (fsync, frame, -1, op_errno, NULL, NULL, xdata); + return 0; } STACK_WIND (frame, error_gen_fsync_cbk, FIRST_CHILD(this), FIRST_CHILD(this)->fops->fsync, - fd, flags); - return 0; + fd, flags, xdata); + return 0; } int error_gen_fstat_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, struct stat *buf) + int32_t op_ret, int32_t op_errno, struct iatt *buf, dict_t *xdata) { - STACK_UNWIND_STRICT (fstat, frame, op_ret, op_errno, buf); - return 0; + STACK_UNWIND_STRICT (fstat, frame, op_ret, op_errno, buf, xdata); + return 0; } int -error_gen_fstat (call_frame_t *frame, xlator_t *this, fd_t *fd) +error_gen_fstat (call_frame_t *frame, xlator_t *this, fd_t *fd, dict_t *xdata) { int op_errno = 0; eg_t *egp = NULL; int enable = 1; egp = this->private; - enable = egp->enable[ERR_FSTAT]; + enable = egp->enable[GF_FOP_FSTAT]; if (enable) - op_errno = error_gen (this, ERR_FSTAT); + op_errno = error_gen (this, GF_FOP_FSTAT); if (op_errno) { GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno)); - STACK_UNWIND_STRICT (fstat, frame, -1, op_errno, NULL); - return 0; + STACK_UNWIND_STRICT (fstat, frame, -1, op_errno, NULL, xdata); + return 0; } STACK_WIND (frame, error_gen_fstat_cbk, FIRST_CHILD(this), FIRST_CHILD(this)->fops->fstat, - fd); - return 0; + fd, xdata); + return 0; } int error_gen_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) { - STACK_UNWIND_STRICT (opendir, frame, op_ret, op_errno, fd); - return 0; + STACK_UNWIND_STRICT (opendir, frame, op_ret, op_errno, fd, xdata); + return 0; } int -error_gen_opendir (call_frame_t *frame, xlator_t *this, loc_t *loc, fd_t *fd) +error_gen_opendir (call_frame_t *frame, xlator_t *this, loc_t *loc, fd_t *fd, dict_t *xdata) { int op_errno = 0; eg_t *egp = NULL; int enable = 1; egp = this->private; - enable = egp->enable[ERR_OPENDIR]; + enable = egp->enable[GF_FOP_OPENDIR]; if (enable) - op_errno = error_gen (this, ERR_OPENDIR); + op_errno = error_gen (this, GF_FOP_OPENDIR); if (op_errno) { GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno)); - STACK_UNWIND_STRICT (opendir, frame, -1, op_errno, NULL); - return 0; + STACK_UNWIND_STRICT (opendir, frame, -1, op_errno, NULL, xdata); + return 0; } STACK_WIND (frame, error_gen_opendir_cbk, FIRST_CHILD(this), FIRST_CHILD(this)->fops->opendir, - loc, fd); - return 0; + loc, fd, xdata); + return 0; } - int -error_gen_getdents_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, dir_entry_t *entries, - int32_t count) +error_gen_fsyncdir_cbk (call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, dict_t *xdata) { - STACK_UNWIND_STRICT (getdents, frame, op_ret, op_errno, entries, - count); - return 0; + STACK_UNWIND_STRICT (fsyncdir, frame, op_ret, op_errno, xdata); + return 0; } int -error_gen_getdents (call_frame_t *frame, xlator_t *this, fd_t *fd, - size_t size, off_t offset, int32_t flag) +error_gen_fsyncdir (call_frame_t *frame, xlator_t *this, fd_t *fd, + int32_t flags, dict_t *xdata) { int op_errno = 0; eg_t *egp = NULL; int enable = 1; egp = this->private; - enable = egp->enable[ERR_GETDENTS]; + enable = egp->enable[GF_FOP_FSYNCDIR]; if (enable) - op_errno = error_gen (this, ERR_GETDENTS); + op_errno = error_gen (this, GF_FOP_FSYNCDIR); if (op_errno) { GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno)); - STACK_UNWIND_STRICT (getdents, frame, -1, op_errno, NULL, 0); - return 0; + STACK_UNWIND_STRICT (fsyncdir, frame, -1, op_errno, xdata); + return 0; } - STACK_WIND (frame, error_gen_getdents_cbk, + STACK_WIND (frame, error_gen_fsyncdir_cbk, FIRST_CHILD(this), - FIRST_CHILD(this)->fops->getdents, - fd, size, offset, flag); - return 0; + FIRST_CHILD(this)->fops->fsyncdir, + fd, flags, xdata); + return 0; } int -error_gen_setdents_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno) +error_gen_statfs_cbk (call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, struct statvfs *buf, dict_t *xdata) { - STACK_UNWIND_STRICT (setdents, frame, op_ret, op_errno); - return 0; + STACK_UNWIND_STRICT (statfs, frame, op_ret, op_errno, buf, xdata); + return 0; } int -error_gen_setdents (call_frame_t *frame, xlator_t *this, fd_t *fd, - int32_t flags, dir_entry_t *entries, int32_t count) +error_gen_statfs (call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *xdata) { int op_errno = 0; eg_t *egp = NULL; int enable = 1; egp = this->private; - enable = egp->enable[ERR_SETDENTS]; + enable = egp->enable[GF_FOP_STATFS]; if (enable) - op_errno = error_gen (this, ERR_SETDENTS); + op_errno = error_gen (this, GF_FOP_STATFS); if (op_errno) { GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno)); - STACK_UNWIND_STRICT (setdents, frame, -1, op_errno); - return 0; + STACK_UNWIND_STRICT (statfs, frame, -1, op_errno, NULL, xdata); + return 0; } - STACK_WIND (frame, error_gen_setdents_cbk, + STACK_WIND (frame, error_gen_statfs_cbk, FIRST_CHILD(this), - FIRST_CHILD(this)->fops->setdents, - fd, flags, entries, count); - return 0; + FIRST_CHILD(this)->fops->statfs, + loc, xdata); + return 0; } int -error_gen_fsyncdir_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno) +error_gen_setxattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, dict_t *xdata) { - STACK_UNWIND_STRICT (fsyncdir, frame, op_ret, op_errno); - return 0; + STACK_UNWIND_STRICT (setxattr, frame, op_ret, op_errno, xdata); + return 0; } int -error_gen_fsyncdir (call_frame_t *frame, xlator_t *this, fd_t *fd, - int32_t flags) +error_gen_setxattr (call_frame_t *frame, xlator_t *this, loc_t *loc, + dict_t *dict, int32_t flags, dict_t *xdata) { int op_errno = 0; eg_t *egp = NULL; int enable = 1; egp = this->private; - enable = egp->enable[ERR_FSYNCDIR]; + enable = egp->enable[GF_FOP_SETXATTR]; if (enable) - op_errno = error_gen (this, ERR_FSYNCDIR); + op_errno = error_gen (this, GF_FOP_SETXATTR); if (op_errno) { GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno)); - STACK_UNWIND_STRICT (fsyncdir, frame, -1, op_errno); - return 0; + STACK_UNWIND_STRICT (setxattr, frame, -1, op_errno, xdata); + return 0; } - STACK_WIND (frame, error_gen_fsyncdir_cbk, + STACK_WIND (frame, error_gen_setxattr_cbk, FIRST_CHILD(this), - FIRST_CHILD(this)->fops->fsyncdir, - fd, flags); - return 0; + FIRST_CHILD(this)->fops->setxattr, + loc, dict, flags, xdata); + return 0; } int -error_gen_statfs_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, struct statvfs *buf) +error_gen_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) { - STACK_UNWIND_STRICT (statfs, frame, op_ret, op_errno, buf); - - return 0; + STACK_UNWIND_STRICT (getxattr, frame, op_ret, op_errno, dict, xdata); + return 0; } int -error_gen_statfs (call_frame_t *frame, xlator_t *this, loc_t *loc) +error_gen_getxattr (call_frame_t *frame, xlator_t *this, loc_t *loc, + const char *name, dict_t *xdata) { int op_errno = 0; eg_t *egp = NULL; int enable = 1; egp = this->private; - enable = egp->enable[ERR_STATFS]; + enable = egp->enable[GF_FOP_GETXATTR]; if (enable) - op_errno = error_gen (this, ERR_STATFS); + op_errno = error_gen (this, GF_FOP_GETXATTR); if (op_errno) { GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno)); - STACK_UNWIND_STRICT (statfs, frame, -1, op_errno, NULL); - return 0; + STACK_UNWIND_STRICT (getxattr, frame, -1, op_errno, NULL, xdata); + return 0; } - STACK_WIND (frame, error_gen_statfs_cbk, + STACK_WIND (frame, error_gen_getxattr_cbk, FIRST_CHILD(this), - FIRST_CHILD(this)->fops->statfs, - loc); - return 0; + FIRST_CHILD(this)->fops->getxattr, + loc, name, xdata); + return 0; } - int -error_gen_setxattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno) +error_gen_fsetxattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, dict_t *xdata) { - STACK_UNWIND_STRICT (setxattr, frame, op_ret, op_errno); - - return 0; + STACK_UNWIND_STRICT (fsetxattr, frame, op_ret, op_errno, xdata); + return 0; } int -error_gen_setxattr (call_frame_t *frame, xlator_t *this, loc_t *loc, - dict_t *dict, int32_t flags) +error_gen_fsetxattr (call_frame_t *frame, xlator_t *this, fd_t *fd, + dict_t *dict, int32_t flags, dict_t *xdata) { int op_errno = 0; eg_t *egp = NULL; int enable = 1; egp = this->private; - enable = egp->enable[ERR_SETXATTR]; + enable = egp->enable[GF_FOP_FSETXATTR]; if (enable) - op_errno = error_gen (this, ERR_SETXATTR); + op_errno = error_gen (this, GF_FOP_FSETXATTR); if (op_errno) { GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno)); - STACK_UNWIND_STRICT (setxattr, frame, -1, op_errno); - return 0; + STACK_UNWIND_STRICT (fsetxattr, frame, -1, op_errno, xdata); + return 0; } - STACK_WIND (frame, error_gen_setxattr_cbk, + STACK_WIND (frame, error_gen_fsetxattr_cbk, FIRST_CHILD(this), - FIRST_CHILD(this)->fops->setxattr, - loc, dict, flags); - return 0; + FIRST_CHILD(this)->fops->fsetxattr, + fd, dict, flags, xdata); + return 0; } int -error_gen_getxattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, dict_t *dict) +error_gen_fgetxattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, dict_t *dict, dict_t *xdata) { - STACK_UNWIND_STRICT (getxattr, frame, op_ret, op_errno, dict); - return 0; + STACK_UNWIND_STRICT (fgetxattr, frame, op_ret, op_errno, dict, xdata); + return 0; } int -error_gen_getxattr (call_frame_t *frame, xlator_t *this, loc_t *loc, - const char *name) +error_gen_fgetxattr (call_frame_t *frame, xlator_t *this, fd_t *fd, + const char *name, dict_t *xdata) { int op_errno = 0; eg_t *egp = NULL; int enable = 1; egp = this->private; - enable = egp->enable[ERR_GETXATTR]; + enable = egp->enable[GF_FOP_FGETXATTR]; if (enable) - op_errno = error_gen (this, ERR_GETXATTR); + op_errno = error_gen (this, GF_FOP_FGETXATTR); if (op_errno) { GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno)); - STACK_UNWIND_STRICT (getxattr, frame, -1, op_errno, NULL); - return 0; + STACK_UNWIND_STRICT (fgetxattr, frame, -1, op_errno, NULL, xdata); + return 0; } - STACK_WIND (frame, error_gen_getxattr_cbk, + STACK_WIND (frame, error_gen_fgetxattr_cbk, FIRST_CHILD(this), - FIRST_CHILD(this)->fops->getxattr, - loc, name); - return 0; + FIRST_CHILD(this)->fops->fgetxattr, + fd, name, xdata); + return 0; } int error_gen_xattrop_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, dict_t *dict) + int32_t op_ret, int32_t op_errno, dict_t *dict, dict_t *xdata) { - STACK_UNWIND_STRICT (xattrop, frame, op_ret, op_errno, dict); - - return 0; + STACK_UNWIND_STRICT (xattrop, frame, op_ret, op_errno, dict, xdata); + return 0; } int error_gen_xattrop (call_frame_t *frame, xlator_t *this, loc_t *loc, - gf_xattrop_flags_t flags, dict_t *dict) + gf_xattrop_flags_t flags, dict_t *dict, dict_t *xdata) { int op_errno = 0; eg_t *egp = NULL; int enable = 1; egp = this->private; - enable = egp->enable[ERR_XATTROP]; + enable = egp->enable[GF_FOP_XATTROP]; if (enable) - op_errno = error_gen (this, ERR_XATTROP); + op_errno = error_gen (this, GF_FOP_XATTROP); if (op_errno) { GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno)); - STACK_UNWIND_STRICT (xattrop, frame, -1, op_errno, NULL); - return 0; + STACK_UNWIND_STRICT (xattrop, frame, -1, op_errno, NULL, xdata); + return 0; } STACK_WIND (frame, error_gen_xattrop_cbk, FIRST_CHILD(this), FIRST_CHILD(this)->fops->xattrop, - loc, flags, dict); - return 0; + loc, flags, dict, xdata); + return 0; } int error_gen_fxattrop_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, dict_t *dict) + int32_t op_ret, int32_t op_errno, dict_t *dict, dict_t *xdata) { - STACK_UNWIND_STRICT (fxattrop, frame, op_ret, op_errno, dict); - - return 0; + STACK_UNWIND_STRICT (fxattrop, frame, op_ret, op_errno, dict, xdata); + return 0; } int error_gen_fxattrop (call_frame_t *frame, xlator_t *this, fd_t *fd, - gf_xattrop_flags_t flags, dict_t *dict) + gf_xattrop_flags_t flags, dict_t *dict, dict_t *xdata) { int op_errno = 0; eg_t *egp = NULL; int enable = 1; egp = this->private; - enable = egp->enable[ERR_FXATTROP]; + enable = egp->enable[GF_FOP_FXATTROP]; if (enable) - op_errno = error_gen (this, ERR_FXATTROP); + op_errno = error_gen (this, GF_FOP_FXATTROP); if (op_errno) { GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno)); - STACK_UNWIND_STRICT (fxattrop, frame, -1, op_errno, NULL); - return 0; + STACK_UNWIND_STRICT (fxattrop, frame, -1, op_errno, NULL, xdata); + return 0; } STACK_WIND (frame, error_gen_fxattrop_cbk, FIRST_CHILD(this), FIRST_CHILD(this)->fops->fxattrop, - fd, flags, dict); - return 0; + fd, flags, dict, xdata); + return 0; } int error_gen_removexattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno) + int32_t op_ret, int32_t op_errno, dict_t *xdata) { - STACK_UNWIND_STRICT (removexattr, frame, op_ret, op_errno); - - return 0; + STACK_UNWIND_STRICT (removexattr, frame, op_ret, op_errno, xdata); + return 0; } int error_gen_removexattr (call_frame_t *frame, xlator_t *this, loc_t *loc, - const char *name) + const char *name, dict_t *xdata) { int op_errno = 0; eg_t *egp = NULL; int enable = 1; egp = this->private; - enable = egp->enable[ERR_REMOVEXATTR]; + enable = egp->enable[GF_FOP_REMOVEXATTR]; if (enable) - op_errno = error_gen (this, ERR_REMOVEXATTR); + op_errno = error_gen (this, GF_FOP_REMOVEXATTR); if (op_errno) { GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno)); - STACK_UNWIND_STRICT (removexattr, frame, -1, op_errno); - return 0; + STACK_UNWIND_STRICT (removexattr, frame, -1, op_errno, xdata); + return 0; } STACK_WIND (frame, error_gen_removexattr_cbk, FIRST_CHILD(this), FIRST_CHILD(this)->fops->removexattr, - loc, name); - return 0; + loc, name, xdata); + return 0; +} + +int +error_gen_fremovexattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, dict_t *xdata) +{ + STACK_UNWIND_STRICT (fremovexattr, frame, op_ret, op_errno, xdata); + return 0; +} + + +int +error_gen_fremovexattr (call_frame_t *frame, xlator_t *this, fd_t *fd, + const char *name, dict_t *xdata) +{ + int op_errno = 0; + eg_t *egp = NULL; + int enable = 1; + + egp = this->private; + enable = egp->enable[GF_FOP_FREMOVEXATTR]; + + if (enable) + op_errno = error_gen (this, GF_FOP_FREMOVEXATTR); + + if (op_errno) { + GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno)); + STACK_UNWIND_STRICT (fremovexattr, frame, -1, op_errno, xdata); + return 0; + } + + STACK_WIND (frame, error_gen_fremovexattr_cbk, + FIRST_CHILD(this), + FIRST_CHILD(this)->fops->fremovexattr, + fd, name, xdata); + return 0; } int error_gen_lk_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, struct flock *lock) + int32_t op_ret, int32_t op_errno, struct gf_flock *lock, dict_t *xdata) { - STACK_UNWIND_STRICT (lk, frame, op_ret, op_errno, lock); - return 0; + STACK_UNWIND_STRICT (lk, frame, op_ret, op_errno, lock, xdata); + return 0; } int error_gen_lk (call_frame_t *frame, xlator_t *this, fd_t *fd, int32_t cmd, - struct flock *lock) + struct gf_flock *lock, dict_t *xdata) { int op_errno = 0; eg_t *egp = NULL; int enable = 1; egp = this->private; - enable = egp->enable[ERR_LK]; + enable = egp->enable[GF_FOP_LK]; if (enable) - op_errno = error_gen (this, ERR_LK); + op_errno = error_gen (this, GF_FOP_LK); if (op_errno) { GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno)); - STACK_UNWIND_STRICT (lk, frame, -1, op_errno, NULL); - return 0; + STACK_UNWIND_STRICT (lk, frame, -1, op_errno, NULL, xdata); + return 0; } STACK_WIND (frame, error_gen_lk_cbk, FIRST_CHILD(this), FIRST_CHILD(this)->fops->lk, - fd, cmd, lock); - return 0; + fd, cmd, lock, xdata); + return 0; } int -error_gen_inodelk_cbk (call_frame_t *frame, void *cookie, - xlator_t *this, int32_t op_ret, int32_t op_errno) - +error_gen_inodelk_cbk (call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, dict_t *xdata) { - STACK_UNWIND_STRICT (inodelk, frame, op_ret, op_errno); - return 0; + STACK_UNWIND_STRICT (inodelk, frame, op_ret, op_errno, xdata); + return 0; } int error_gen_inodelk (call_frame_t *frame, xlator_t *this, const char *volume, loc_t *loc, int32_t cmd, - struct flock *lock) + struct gf_flock *lock, dict_t *xdata) { int op_errno = 0; eg_t *egp = NULL; int enable = 1; egp = this->private; - enable = egp->enable[ERR_INODELK]; + enable = egp->enable[GF_FOP_INODELK]; if (enable) - op_errno = error_gen (this, ERR_INODELK); + op_errno = error_gen (this, GF_FOP_INODELK); if (op_errno) { GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno)); - STACK_UNWIND_STRICT (inodelk, frame, -1, op_errno); - return 0; + STACK_UNWIND_STRICT (inodelk, frame, -1, op_errno, xdata); + return 0; } STACK_WIND (frame, error_gen_inodelk_cbk, FIRST_CHILD(this), FIRST_CHILD(this)->fops->inodelk, - volume, loc, cmd, lock); - return 0; + volume, loc, cmd, lock, xdata); + return 0; } int -error_gen_finodelk_cbk (call_frame_t *frame, void *cookie, - xlator_t *this, int32_t op_ret, int32_t op_errno) - +error_gen_finodelk_cbk (call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, dict_t *xdata) { - STACK_UNWIND_STRICT (finodelk, frame, op_ret, op_errno); - return 0; + STACK_UNWIND_STRICT (finodelk, frame, op_ret, op_errno, xdata); + return 0; } int error_gen_finodelk (call_frame_t *frame, xlator_t *this, const char *volume, fd_t *fd, int32_t cmd, - struct flock *lock) + struct gf_flock *lock, dict_t *xdata) { int op_errno = 0; eg_t *egp = NULL; int enable = 1; egp = this->private; - enable = egp->enable[ERR_FINODELK]; + enable = egp->enable[GF_FOP_FINODELK]; if (enable) - op_errno = error_gen (this, ERR_FINODELK); + op_errno = error_gen (this, GF_FOP_FINODELK); if (op_errno) { GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno)); - STACK_UNWIND_STRICT (finodelk, frame, -1, op_errno); - return 0; + STACK_UNWIND_STRICT (finodelk, frame, -1, op_errno, xdata); + return 0; } STACK_WIND (frame, error_gen_finodelk_cbk, FIRST_CHILD(this), FIRST_CHILD(this)->fops->finodelk, - volume, fd, cmd, lock); - return 0; + volume, fd, cmd, lock, xdata); + return 0; } int -error_gen_entrylk_cbk (call_frame_t *frame, void *cookie, - xlator_t *this, int32_t op_ret, int32_t op_errno) - +error_gen_entrylk_cbk (call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, dict_t *xdata) { - STACK_UNWIND_STRICT (entrylk, frame, op_ret, op_errno); - return 0; + STACK_UNWIND_STRICT (entrylk, frame, op_ret, op_errno, xdata); + return 0; } int error_gen_entrylk (call_frame_t *frame, xlator_t *this, const char *volume, loc_t *loc, const char *basename, - entrylk_cmd cmd, entrylk_type type) + entrylk_cmd cmd, entrylk_type type, dict_t *xdata) { int op_errno = 0; eg_t *egp = NULL; int enable = 1; egp = this->private; - enable = egp->enable[ERR_ENTRYLK]; + enable = egp->enable[GF_FOP_ENTRYLK]; if (enable) - op_errno = error_gen (this, ERR_ENTRYLK); + op_errno = error_gen (this, GF_FOP_ENTRYLK); if (op_errno) { GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno)); - STACK_UNWIND_STRICT (entrylk, frame, -1, op_errno); - return 0; + STACK_UNWIND_STRICT (entrylk, frame, -1, op_errno, xdata); + return 0; } STACK_WIND (frame, error_gen_entrylk_cbk, FIRST_CHILD(this), FIRST_CHILD(this)->fops->entrylk, - volume, loc, basename, cmd, type); - return 0; + volume, loc, basename, cmd, type, xdata); + return 0; } int -error_gen_fentrylk_cbk (call_frame_t *frame, void *cookie, - xlator_t *this, int32_t op_ret, int32_t op_errno) - +error_gen_fentrylk_cbk (call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, dict_t *xdata) { - STACK_UNWIND_STRICT (fentrylk, frame, op_ret, op_errno); - return 0; + STACK_UNWIND_STRICT (fentrylk, frame, op_ret, op_errno, xdata); + return 0; } int error_gen_fentrylk (call_frame_t *frame, xlator_t *this, const char *volume, fd_t *fd, const char *basename, - entrylk_cmd cmd, entrylk_type type) + entrylk_cmd cmd, entrylk_type type, dict_t *xdata) { int op_errno = 0; eg_t *egp = NULL; int enable = 1; egp = this->private; - enable = egp->enable[ERR_FENTRYLK]; + enable = egp->enable[GF_FOP_FENTRYLK]; if (enable) - op_errno = error_gen (this, ERR_FENTRYLK); + op_errno = error_gen (this, GF_FOP_FENTRYLK); if (op_errno) { GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno)); - STACK_UNWIND_STRICT (fentrylk, frame, -1, op_errno); - return 0; + STACK_UNWIND_STRICT (fentrylk, frame, -1, op_errno, xdata); + return 0; } STACK_WIND (frame, error_gen_fentrylk_cbk, FIRST_CHILD(this), FIRST_CHILD(this)->fops->fentrylk, - volume, fd, basename, cmd, type); - return 0; + volume, fd, basename, cmd, type, xdata); + return 0; } /* Management operations */ + int -error_gen_stats_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, - struct xlator_stats *stats) +error_gen_getspec_cbk (call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, char *spec_data) { - STACK_UNWIND (frame, op_ret, op_errno, stats); - return 0; + STACK_UNWIND_STRICT (getspec, frame, op_ret, op_errno, spec_data); + return 0; } int -error_gen_stats (call_frame_t *frame, xlator_t *this, int32_t flags) +error_gen_getspec (call_frame_t *frame, xlator_t *this, const char *key, + int32_t flags) { int op_errno = 0; eg_t *egp = NULL; int enable = 1; egp = this->private; - enable = egp->enable[ERR_STATS]; + enable = egp->enable[GF_FOP_GETSPEC]; if (enable) - op_errno = error_gen (this, ERR_STATS); + op_errno = error_gen (this, GF_FOP_GETSPEC); if (op_errno) { GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno)); - STACK_UNWIND (frame, -1, op_errno, NULL); + STACK_UNWIND_STRICT (getspec, frame, -1, op_errno, NULL); return 0; } - STACK_WIND (frame, error_gen_stats_cbk, + STACK_WIND (frame, error_gen_getspec_cbk, FIRST_CHILD(this), - FIRST_CHILD(this)->mops->stats, - flags); + FIRST_CHILD(this)->fops->getspec, + key, flags); return 0; } int -error_gen_getspec_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, char *spec_data) +error_gen_readdir_cbk (call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, gf_dirent_t *entries, + dict_t *xdata) { - STACK_UNWIND (frame, op_ret, op_errno, spec_data); - + STACK_UNWIND_STRICT (readdir, frame, op_ret, op_errno, entries, xdata); return 0; } int -error_gen_getspec (call_frame_t *frame, xlator_t *this, const char *key, - int32_t flags) +error_gen_readdir (call_frame_t *frame, xlator_t *this, fd_t *fd, + size_t size, off_t off, dict_t *xdata) { int op_errno = 0; eg_t *egp = NULL; int enable = 1; egp = this->private; - enable = egp->enable[ERR_GETSPEC]; + enable = egp->enable[GF_FOP_READDIR]; if (enable) - op_errno = error_gen (this, ERR_GETSPEC); + op_errno = error_gen (this, GF_FOP_READDIR); if (op_errno) { GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno)); - STACK_UNWIND (frame, -1, op_errno, NULL); + STACK_UNWIND_STRICT (readdir, frame, -1, op_errno, NULL, xdata); return 0; } - STACK_WIND (frame, error_gen_getspec_cbk, + STACK_WIND (frame, error_gen_readdir_cbk, FIRST_CHILD(this), - FIRST_CHILD(this)->mops->getspec, - key, flags); + FIRST_CHILD(this)->fops->readdir, + fd, size, off, xdata); return 0; } int -error_gen_checksum_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, - uint8_t *file_checksum, uint8_t *dir_checksum) +error_gen_readdirp_cbk (call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, gf_dirent_t *entries, + dict_t *xdata) { - STACK_UNWIND (frame, op_ret, op_errno, - file_checksum, dir_checksum); + STACK_UNWIND_STRICT (readdirp, frame, op_ret, op_errno, entries, xdata); return 0; } int -error_gen_checksum (call_frame_t *frame, xlator_t *this, loc_t *loc, - int32_t flag) +error_gen_readdirp (call_frame_t *frame, xlator_t *this, fd_t *fd, size_t size, + off_t off, dict_t *dict) { int op_errno = 0; eg_t *egp = NULL; int enable = 1; egp = this->private; - enable = egp->enable[ERR_CHECKSUM]; + enable = egp->enable[GF_FOP_READDIRP]; if (enable) - op_errno = error_gen (this, ERR_CHECKSUM); + op_errno = error_gen (this, GF_FOP_READDIRP); if (op_errno) { GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno)); - STACK_UNWIND (frame, -1, op_errno, NULL, NULL); + STACK_UNWIND_STRICT (readdirp, frame, -1, op_errno, NULL, NULL); return 0; } - STACK_WIND (frame, error_gen_checksum_cbk, - FIRST_CHILD(this), - FIRST_CHILD(this)->fops->checksum, - loc, flag); + STACK_WIND (frame, error_gen_readdirp_cbk, + FIRST_CHILD(this), + FIRST_CHILD(this)->fops->readdirp, + fd, size, off, dict); return 0; } - -int -error_gen_readdir_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, gf_dirent_t *entries) +static void +error_gen_set_failure (eg_t *pvt, int percent) { - STACK_UNWIND_STRICT (readdir, frame, op_ret, op_errno, entries); - return 0; + GF_ASSERT (pvt); + + if (percent) + pvt->failure_iter_no = 100/percent; + else + pvt->failure_iter_no = 100/GF_FAILURE_DEFAULT; } +static void +error_gen_parse_fill_fops (eg_t *pvt, char *enable_fops) +{ + char *op_no_str = NULL; + int op_no = -1; + int i = 0; + xlator_t *this = THIS; + char *saveptr = NULL; + + GF_ASSERT (pvt); + GF_ASSERT (this); -int -error_gen_readdir (call_frame_t *frame, xlator_t *this, fd_t *fd, - size_t size, off_t off) + for (i = 0; i < GF_FOP_MAXVALUE; i++) + pvt->enable[i] = 0; + + if (!enable_fops) { + gf_log (this->name, GF_LOG_WARNING, + "All fops are enabled."); + for (i = 0; i < GF_FOP_MAXVALUE; i++) + pvt->enable[i] = 1; + } else { + op_no_str = strtok_r (enable_fops, ",", &saveptr); + while (op_no_str) { + op_no = get_fop_int (&op_no_str); + if (op_no == -1) { + gf_log (this->name, GF_LOG_WARNING, + "Wrong option value %s", op_no_str); + } else + pvt->enable[op_no] = 1; + + op_no_str = strtok_r (NULL, ",", &saveptr); + } + } +} + +int32_t +error_gen_priv_dump (xlator_t *this) { - int op_errno = 0; - eg_t *egp = NULL; - int enable = 1; + char key_prefix[GF_DUMP_MAX_BUF_LEN]; + int ret = -1; + eg_t *conf = NULL; - egp = this->private; - enable = egp->enable[ERR_READDIR]; + if (!this) + goto out; - if (enable) - op_errno = error_gen (this, ERR_READDIR); + conf = this->private; + if (!conf) + goto out; - if (op_errno) { - GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno)); - STACK_UNWIND_STRICT (readdir, frame, -1, op_errno, NULL); - return 0; - } + ret = TRY_LOCK(&conf->lock); + if (ret != 0) { + return ret; + } - STACK_WIND (frame, error_gen_readdir_cbk, - FIRST_CHILD(this), - FIRST_CHILD(this)->fops->readdir, - fd, size, off); - return 0; -} + gf_proc_dump_add_section("xlator.debug.error-gen.%s.priv", this->name); + gf_proc_dump_build_key(key_prefix,"xlator.debug.error-gen","%s.priv", + this->name); + gf_proc_dump_write("op_count", "%d", conf->op_count); + gf_proc_dump_write("failure_iter_no", "%d", conf->failure_iter_no); + gf_proc_dump_write("error_no", "%s", conf->error_no); + gf_proc_dump_write("random_failure", "%d", conf->random_failure); -int -error_gen_readdirp_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, gf_dirent_t *entries) -{ - STACK_UNWIND_STRICT (readdirp, frame, op_ret, op_errno, entries); - return 0; + UNLOCK(&conf->lock); +out: + return ret; } - -int -error_gen_readdirp (call_frame_t *frame, xlator_t *this, fd_t *fd, size_t size, - off_t off) +int32_t +mem_acct_init (xlator_t *this) { - int op_errno = 0; - eg_t *egp = NULL; - int enable = 1; + int ret = -1; - egp = this->private; - enable = egp->enable[ERR_READDIRP]; + if (!this) + return ret; - if (enable) - op_errno = error_gen (this, ERR_READDIRP); + ret = xlator_mem_acct_init (this, gf_error_gen_mt_end + 1); - if (op_errno) { - GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno)); - STACK_UNWIND_STRICT (readdirp, frame, -1, op_errno, NULL); - return 0; - } + if (ret != 0) { + gf_log (this->name, GF_LOG_ERROR, "Memory accounting init" + " failed"); + return ret; + } - STACK_WIND (frame, error_gen_readdirp_cbk, - FIRST_CHILD(this), - FIRST_CHILD(this)->fops->readdirp, - fd, size, off); - return 0; + return ret; } - int -error_gen_closedir (xlator_t *this, fd_t *fd) +reconfigure (xlator_t *this, dict_t *options) { - return 0; -} + eg_t *pvt = NULL; + int32_t ret = 0; + char *error_enable_fops = NULL; + int32_t failure_percent_int = 0; + if (!this || !this->private) + goto out; -int -error_gen_close (xlator_t *this, fd_t *fd) -{ - return 0; -} + pvt = this->private; + + GF_OPTION_RECONF ("error-no", pvt->error_no, options, str, out); + + GF_OPTION_RECONF ("failure", failure_percent_int, options, int32, + out); + GF_OPTION_RECONF ("enable", error_enable_fops, options, str, out); + + GF_OPTION_RECONF ("random-failure", pvt->random_failure, options, + bool, out); + + error_gen_parse_fill_fops (pvt, error_enable_fops); + error_gen_set_failure (pvt, failure_percent_int); + + ret = 0; +out: + gf_log (this->name, GF_LOG_DEBUG, "reconfigure returning %d", ret); + return ret; +} int init (xlator_t *this) { eg_t *pvt = NULL; - data_t *error_no = NULL; - data_t *failure_percent = NULL; - data_t *enable = NULL; int32_t ret = 0; char *error_enable_fops = NULL; - char *op_no_str = NULL; - int op_no = -1; - int i = 0; int32_t failure_percent_int = 0; if (!this->children || this->children->next) { @@ -2043,71 +2104,34 @@ init (xlator_t *this) "dangling volume. check volfile "); } - error_no = dict_get (this->options, "error-no"); - failure_percent = dict_get (this->options, "failure"); - enable = dict_get (this->options, "enable"); - - pvt = CALLOC (1, sizeof (eg_t)); + pvt = GF_CALLOC (1, sizeof (eg_t), gf_error_gen_mt_eg_t); if (!pvt) { - gf_log (this->name, GF_LOG_ERROR, - "out of memory."); ret = -1; goto out; } LOCK_INIT (&pvt->lock); - for (i = 0; i < NO_OF_FOPS; i++) - pvt->enable[i] = 0; - if (!error_no) { - gf_log (this->name, GF_LOG_DEBUG, - "error-no not specified."); - } else { - pvt->error_no = data_to_str (error_no); - } + GF_OPTION_INIT ("error-no", pvt->error_no, str, out); - if (!failure_percent) { - gf_log (this->name, GF_LOG_DEBUG, - "failure percent not specified."); - pvt->failure_iter_no = 100/GF_FAILURE_DEFAULT; - } else { - failure_percent_int = data_to_int32 (failure_percent); - if (failure_percent_int) - pvt->failure_iter_no = 100/failure_percent_int; - else - pvt->failure_iter_no = 100/GF_FAILURE_DEFAULT; - } + GF_OPTION_INIT ("failure", failure_percent_int, int32, out); + + GF_OPTION_INIT ("enable", error_enable_fops, str, out); + + GF_OPTION_INIT ("random-failure", pvt->random_failure, bool, out); + + + error_gen_parse_fill_fops (pvt, error_enable_fops); + error_gen_set_failure (pvt, failure_percent_int); - if (!enable) { - gf_log (this->name, GF_LOG_WARNING, - "All fops are enabled."); - for (i = 0; i < NO_OF_FOPS; i++) - pvt->enable[i] = 1; - } else { - error_enable_fops = data_to_str (enable); - op_no_str = error_enable_fops; - while ((*error_enable_fops) != '\0') { - error_enable_fops++; - if (((*error_enable_fops) == ',') || - ((*error_enable_fops) == '\0')) { - if ((*error_enable_fops) != '\0') { - (*error_enable_fops) = '\0'; - error_enable_fops++; - } - op_no = get_fop_int (&op_no_str); - if (op_no == -1) { - gf_log (this->name, GF_LOG_WARNING, - "Wrong option value %s", - op_no_str); - } else - pvt->enable[op_no] = 1; - op_no_str = error_enable_fops; - } - } - } this->private = pvt; + + /* Give some seed value here */ + srand (time(NULL)); out: + if (ret) + GF_FREE (pvt); return ret; } @@ -2123,12 +2147,18 @@ fini (xlator_t *this) if (pvt) { LOCK_DESTROY (&pvt->lock); - FREE (pvt); + GF_FREE (pvt); gf_log (this->name, GF_LOG_DEBUG, "fini called"); } return; } +struct xlator_dumpops dumpops = { + .priv = error_gen_priv_dump, +}; + +struct xlator_fops cbks; + struct xlator_fops fops = { .lookup = error_gen_lookup, .stat = error_gen_stat, @@ -2151,18 +2181,18 @@ struct xlator_fops fops = { .setxattr = error_gen_setxattr, .getxattr = error_gen_getxattr, .removexattr = error_gen_removexattr, + .fsetxattr = error_gen_fsetxattr, + .fgetxattr = error_gen_fgetxattr, + .fremovexattr = error_gen_fremovexattr, .opendir = error_gen_opendir, .readdir = error_gen_readdir, .readdirp = error_gen_readdirp, - .getdents = error_gen_getdents, .fsyncdir = error_gen_fsyncdir, .access = error_gen_access, .ftruncate = error_gen_ftruncate, .fstat = error_gen_fstat, .lk = error_gen_lk, - .setdents = error_gen_setdents, .lookup_cbk = error_gen_lookup_cbk, - .checksum = error_gen_checksum, .xattrop = error_gen_xattrop, .fxattrop = error_gen_fxattrop, .inodelk = error_gen_inodelk, @@ -2171,29 +2201,32 @@ struct xlator_fops fops = { .fentrylk = error_gen_fentrylk, .setattr = error_gen_setattr, .fsetattr = error_gen_fsetattr, -}; - -struct xlator_mops mops = { - .stats = error_gen_stats, - .getspec = error_gen_getspec, -}; - -struct xlator_cbks cbks = { - .release = error_gen_close, - .releasedir = error_gen_closedir, + .getspec = error_gen_getspec, }; struct volume_options options[] = { { .key = {"failure"}, - .type = GF_OPTION_TYPE_INT }, + .type = GF_OPTION_TYPE_INT, + .description = "Percentage failure of operations when enabled.", + }, + { .key = {"error-no"}, .value = {"ENOENT","ENOTDIR","ENAMETOOLONG","EACCES","EBADF", "EFAULT","ENOMEM","EINVAL","EIO","EEXIST","ENOSPC", "EPERM","EROFS","EBUSY","EISDIR","ENOTEMPTY","EMLINK" "ENODEV","EXDEV","EMFILE","ENFILE","ENOSYS","EINTR", - "EFBIG","EAGAIN"}, - .type = GF_OPTION_TYPE_STR }, + "EFBIG","EAGAIN","GF_ERROR_SHORT_WRITE"}, + .type = GF_OPTION_TYPE_STR, + }, + + { .key = {"random-failure"}, + .type = GF_OPTION_TYPE_BOOL, + .default_value = "off", + }, + { .key = {"enable"}, - .type = GF_OPTION_TYPE_STR }, + .type = GF_OPTION_TYPE_STR, + }, + { .key = {NULL} } }; |