diff options
Diffstat (limited to 'xlators/debug/error-gen/src')
| -rw-r--r-- | xlators/debug/error-gen/src/Makefile.am | 10 | ||||
| -rw-r--r-- | xlators/debug/error-gen/src/error-gen-mem-types.h | 20 | ||||
| -rw-r--r-- | xlators/debug/error-gen/src/error-gen.c | 2969 | ||||
| -rw-r--r-- | xlators/debug/error-gen/src/error-gen.h | 49 |
4 files changed, 1501 insertions, 1547 deletions
diff --git a/xlators/debug/error-gen/src/Makefile.am b/xlators/debug/error-gen/src/Makefile.am index 1bd7f332ca0..038d2e8e66d 100644 --- a/xlators/debug/error-gen/src/Makefile.am +++ b/xlators/debug/error-gen/src/Makefile.am @@ -2,13 +2,17 @@ xlator_LTLIBRARIES = error-gen.la xlatordir = $(libdir)/glusterfs/$(PACKAGE_VERSION)/xlator/debug -error_gen_la_LDFLAGS = -module -avoidversion +error_gen_la_LDFLAGS = -module $(GF_XLATOR_DEFAULT_LDFLAGS) error_gen_la_SOURCES = error-gen.c error_gen_la_LIBADD = $(top_builddir)/libglusterfs/src/libglusterfs.la -AM_CFLAGS = -fPIC -D_FILE_OFFSET_BITS=64 -D_GNU_SOURCE -Wall -D$(GF_HOST_OS)\ - -I$(top_srcdir)/libglusterfs/src -shared -nostartfiles $(GF_CFLAGS) +noinst_HEADERS = error-gen.h error-gen-mem-types.h + +AM_CPPFLAGS = $(GF_CPPFLAGS) -I$(top_srcdir)/libglusterfs/src \ + -I$(top_srcdir)/rpc/xdr/src -I$(top_builddir)/rpc/xdr/src + +AM_CFLAGS = -Wall $(GF_CFLAGS) CLEANFILES = diff --git a/xlators/debug/error-gen/src/error-gen-mem-types.h b/xlators/debug/error-gen/src/error-gen-mem-types.h new file mode 100644 index 00000000000..b9b713af8fc --- /dev/null +++ b/xlators/debug/error-gen/src/error-gen-mem-types.h @@ -0,0 +1,20 @@ +/* + 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 __ERROR_GEN_MEM_TYPES_H__ +#define __ERROR_GEN_MEM_TYPES_H__ + +#include <glusterfs/mem-types.h> + +enum gf_error_gen_mem_types_ { + gf_error_gen_mt_eg_t = gf_common_mt_end + 1, + gf_error_gen_mt_end +}; +#endif diff --git a/xlators/debug/error-gen/src/error-gen.c b/xlators/debug/error-gen/src/error-gen.c index f013023a51b..d45655ef4c3 100644 --- a/xlators/debug/error-gen/src/error-gen.c +++ b/xlators/debug/error-gen/src/error-gen.c @@ -1,1782 +1,1663 @@ /* - Copyright (c) 2008-2009 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/>. + 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. */ +#include <glusterfs/xlator.h> +#include "error-gen.h" +#include <glusterfs/statedump.h> +#include <glusterfs/defaults.h> -#ifndef _CONFIG_H -#define _CONFIG_H -#include "config.h" -#endif +/* + * The user can specify an error probability as a float percentage, but we + * store it internally as a numerator with this as the denominator. When it's + * used, it's like this: + * + * (rand() % FAILURE_GRANULARITY) < error_rate + * + * To minimize rounding errors from the modulo operation, it's good for this to + * be a power of two. + * + * (BTW this is just the normal case. If "random-failure" is set, that does + * something completely different and this number is irrelevant. See error_gen + * for the legacy code.) + */ +#define FAILURE_GRANULARITY (1 << 20) + +sys_error_t error_no_list[] = { + [GF_FOP_LOOKUP] = {.error_no_count = 4, + .error_no = {ENOENT, ENOTDIR, ENAMETOOLONG, EAGAIN}}, + [GF_FOP_STAT] = {.error_no_count = 6, + .error_no = {EACCES, EFAULT, ENAMETOOLONG, ENOENT, ENOMEM, + ENOTDIR}}, + [GF_FOP_READLINK] = {.error_no_count = 8, + .error_no = {EACCES, EFAULT, EINVAL, EIO, ENAMETOOLONG, + ENOENT, ENOMEM, ENOTDIR}}, + [GF_FOP_MKNOD] = {.error_no_count = 11, + .error_no = {EACCES, EEXIST, EFAULT, EINVAL, ENAMETOOLONG, + ENOENT, ENOMEM, ENOSPC, ENOTDIR, EPERM, + EROFS}}, + [GF_FOP_MKDIR] = {.error_no_count = 10, + .error_no = {EACCES, EEXIST, EFAULT, ENAMETOOLONG, ENOENT, + ENOMEM, ENOSPC, ENOTDIR, EPERM, EROFS}}, + [GF_FOP_UNLINK] = {.error_no_count = 10, + .error_no = {EACCES, EBUSY, EFAULT, EIO, EISDIR, + ENAMETOOLONG, ENOENT, ENOMEM, ENOTDIR, + EPERM, EROFS}}, + [GF_FOP_RMDIR] = {.error_no_count = 8, + .error_no = {EACCES, EBUSY, EFAULT, ENOMEM, ENOTDIR, + ENOTEMPTY, EPERM, EROFS}}, + [GF_FOP_SYMLINK] = {.error_no_count = 11, + .error_no = {EACCES, EEXIST, EFAULT, EIO, ENAMETOOLONG, + ENOENT, ENOMEM, ENOSPC, ENOTDIR, EPERM, + EROFS}}, + [GF_FOP_RENAME] = {.error_no_count = 13, + .error_no = {EACCES, EBUSY, EFAULT, EINVAL, EISDIR, + EMLINK, ENAMETOOLONG, ENOENT, ENOMEM, + ENOSPC, ENOTDIR, EEXIST, EXDEV}}, + [GF_FOP_LINK] = {.error_no_count = 13, + .error_no = {EACCES, EFAULT, EEXIST, EIO, EMLINK, + ENAMETOOLONG, ENOENT, ENOMEM, ENOSPC, ENOTDIR, + EPERM, EROFS, EXDEV}}, + [GF_FOP_TRUNCATE] = {.error_no_count = 10, + .error_no = {EACCES, EFAULT, EFBIG, EINTR, EINVAL, EIO, + EISDIR, ENAMETOOLONG, ENOENT, EISDIR}}, + [GF_FOP_CREATE] = {.error_no_count = 10, + .error_no = {EACCES, EEXIST, EFAULT, EISDIR, EMFILE, + ENAMETOOLONG, ENFILE, ENODEV, ENOENT, + ENODEV}}, + [GF_FOP_OPEN] = {.error_no_count = 10, + .error_no = {EACCES, EEXIST, EFAULT, EISDIR, EMFILE, + ENAMETOOLONG, ENFILE, ENODEV, ENOENT, + ENOMEM}}, + [GF_FOP_READ] = {.error_no_count = 5, + .error_no = {EINVAL, EBADF, EFAULT, EISDIR, ENAMETOOLONG}}, + [GF_FOP_WRITE] = {.error_no_count = 7, + .error_no = {EINVAL, EBADF, EFAULT, EISDIR, ENAMETOOLONG, + ENOSPC, GF_ERROR_SHORT_WRITE}}, + [GF_FOP_STATFS] = {.error_no_count = 9, + .error_no = {EACCES, EFAULT, EINTR, EIO, ENAMETOOLONG, + ENOENT, ENOMEM, ENOSYS, ENOTDIR}}, + [GF_FOP_FLUSH] = {.error_no_count = 5, + .error_no = {EACCES, EFAULT, ENAMETOOLONG, ENOSYS, + ENOENT}}, + [GF_FOP_FSYNC] = {.error_no_count = 4, + .error_no = {EBADF, EIO, EROFS, EINVAL}}, + [GF_FOP_SETXATTR] = {.error_no_count = 3, + .error_no = {EACCES, EINTR, ENAMETOOLONG}}, + [GF_FOP_GETXATTR] = {.error_no_count = 3, + .error_no = {EACCES, ENAMETOOLONG, EINTR}}, + [GF_FOP_REMOVEXATTR] = {.error_no_count = 3, + .error_no = {EACCES, ENAMETOOLONG, EINTR}}, + [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}}, + [GF_FOP_READDIR] = {.error_no_count = 5, + .error_no = {EINVAL, EACCES, EBADF, EMFILE, ENOENT}}, + [GF_FOP_READDIRP] = {.error_no_count = 5, + .error_no = {EINVAL, EACCES, EBADF, EMFILE, ENOENT}}, + [GF_FOP_FSYNCDIR] = {.error_no_count = 4, + .error_no = {EBADF, EIO, EROFS, EINVAL}}, + [GF_FOP_ACCESS] = {.error_no_count = 8, + .error_no = {EACCES, ENAMETOOLONG, ENOENT, ENOTDIR, + EROFS, EFAULT, EINVAL, EIO}}, + [GF_FOP_FTRUNCATE] = {.error_no_count = 9, + .error_no = {EACCES, EFAULT, EFBIG, EINTR, EINVAL, + EIO, EISDIR, ENAMETOOLONG, ENOENT}}, + [GF_FOP_FSTAT] = {.error_no_count = 7, + .error_no = {EACCES, EBADF, EFAULT, ENAMETOOLONG, ENOENT, + ENOMEM, ENOTDIR}}, + [GF_FOP_LK] = {.error_no_count = 4, + .error_no = {EACCES, EFAULT, ENOENT, EINTR}}, + [GF_FOP_XATTROP] = {.error_no_count = 5, + .error_no = {EACCES, EFAULT, ENAMETOOLONG, ENOSYS, + ENOENT}}, + [GF_FOP_FXATTROP] = {.error_no_count = 4, + .error_no = {EBADF, EIO, EROFS, EINVAL}}, + [GF_FOP_INODELK] = {.error_no_count = 3, + .error_no = {EACCES, EINTR, ENAMETOOLONG}}, + [GF_FOP_FINODELK] = {.error_no_count = 4, + .error_no = {EACCES, EBADF, EINTR, ENAMETOOLONG}}, + [GF_FOP_ENTRYLK] = {.error_no_count = 3, + .error_no = {EACCES, ENAMETOOLONG, EINTR}}, + [GF_FOP_FENTRYLK] = {.error_no_count = 10, + .error_no = {EACCES, EEXIST, EFAULT, EISDIR, EMFILE, + ENAMETOOLONG, ENFILE, ENODEV, ENOENT, + ENOMEM}}, + [GF_FOP_SETATTR] = {.error_no_count = 10, + .error_no = {EACCES, EFAULT, EIO, ENAMETOOLONG, ENOENT, + ENOMEM, ENOTDIR, EPERM, EROFS, EIO}}, + [GF_FOP_FSETATTR] = {.error_no_count = 11, + .error_no = {EACCES, EFAULT, EIO, ENAMETOOLONG, ENOENT, + ENOMEM, ENOTDIR, EPERM, EROFS, EBADF, + EIO}}, + [GF_FOP_GETSPEC] = {.error_no_count = 3, + .error_no = {EACCES, ENAMETOOLONG, EINTR}}}; -#include "xlator.h" +int +generate_rand_no(int op_no) +{ + int rand_no = 0; + int error_no_list_size = 0; -typedef struct { - int op_count; -} eg_t; + error_no_list_size = sizeof(error_no_list) / sizeof(error_no_list[0]); -int error_gen (xlator_t *this) -{ - eg_t *egp = NULL; - int count = 0; - egp = this->private; - count = ++egp->op_count; - if((count % 10) == 0) { - count = count / 10; - if ((count % 2) == 0) - return ENOTCONN; - else - return EIO; - } - return 0; + if (op_no < error_no_list_size) + /* coverity[DC.WEAK_CRYPTO] */ + rand_no = rand() % error_no_list[op_no].error_no_count; + return rand_no; } -static int32_t -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) -{ - STACK_UNWIND (frame, - op_ret, - op_errno, - inode, - buf, - dict); - return 0; +int +conv_errno_to_int(char **error_no) +{ + if (!strcmp((*error_no), "ENOENT")) + return ENOENT; + else if (!strcmp((*error_no), "ENOTDIR")) + return ENOTDIR; + else if (!strcmp((*error_no), "ENAMETOOLONG")) + return ENAMETOOLONG; + else if (!strcmp((*error_no), "EACCES")) + return EACCES; + else if (!strcmp((*error_no), "EBADF")) + return EBADF; + else if (!strcmp((*error_no), "EFAULT")) + return EFAULT; + else if (!strcmp((*error_no), "ENOMEM")) + return ENOMEM; + else if (!strcmp((*error_no), "EINVAL")) + return EINVAL; + else if (!strcmp((*error_no), "EIO")) + return EIO; + else if (!strcmp((*error_no), "EEXIST")) + return EEXIST; + else if (!strcmp((*error_no), "ENOSPC")) + return ENOSPC; + else if (!strcmp((*error_no), "EPERM")) + return EPERM; + else if (!strcmp((*error_no), "EROFS")) + return EROFS; + else if (!strcmp((*error_no), "EBUSY")) + return EBUSY; + else if (!strcmp((*error_no), "EISDIR")) + return EISDIR; + else if (!strcmp((*error_no), "ENOTEMPTY")) + return ENOTEMPTY; + else if (!strcmp((*error_no), "EMLINK")) + return EMLINK; + else if (!strcmp((*error_no), "ENODEV")) + return ENODEV; + else if (!strcmp((*error_no), "EXDEV")) + return EXDEV; + else if (!strcmp((*error_no), "EMFILE")) + return EMFILE; + else if (!strcmp((*error_no), "ENFILE")) + return ENFILE; + else if (!strcmp((*error_no), "ENOSYS")) + return ENOSYS; + else if (!strcmp((*error_no), "EINTR")) + 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; } -int32_t -error_gen_lookup (call_frame_t *frame, - xlator_t *this, - loc_t *loc, - dict_t *xattr_req) -{ - int op_errno = 0; - op_errno = error_gen(this); - if (op_errno) { - GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno)); - STACK_UNWIND (frame, -1, op_errno, 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(xlator_t *this, int op_no) +{ + eg_t *egp = NULL; + int count = 0; + int error_no_int = 0; + int rand_no = 0; + int ret = 0; + gf_boolean_t should_err = _gf_false; + int error_no_list_size = 0; + + egp = this->private; + + if (egp->random_failure) { + /* + * I honestly don't know why anyone would use this "feature" + * but I'll try to preserve its functionality anyway. Without + * locking twice to update failure_iter_no and egp->op_count + * separately, then not locking at all to update + * egp->failure_iter_no. That's not needed for compatibility, + * and it's abhorrently wrong. I have *some* standards. + */ + LOCK(&egp->lock); + { + count = ++(egp->op_count); + error_no_int = egp->error_no_int; + if ((count % egp->failure_iter_no) == 0) { + egp->op_count = 0; + /* coverity[DC.WEAK_CRYPTO] */ + egp->failure_iter_no = 3 + (rand() % GF_UNIVERSAL_ANSWER); + should_err = _gf_true; + } + } + UNLOCK(&egp->lock); + } else { + /* + * It turns out that rand() is almost universally implemented + * as a linear congruential PRNG, which is about as cheap as + * it gets. This gets us real random behavior, including + * phenomena like streaks and dry spells, with controllable + * long-term probability, cheaply. + */ + if ((rand() % FAILURE_GRANULARITY) < egp->failure_iter_no) { + should_err = _gf_true; + } + } + + error_no_list_size = sizeof(error_no_list) / sizeof(error_no_list[0]); + if (should_err) { + if (error_no_int) + ret = error_no_int; + else { + rand_no = generate_rand_no(op_no); + if (op_no >= error_no_list_size) + 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]; + } + } + + return ret; } - -int32_t -error_gen_forget (xlator_t *this, - inode_t *inode) +int +error_gen_lookup(call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *xdata) { - return 0; -} + int op_errno = 0; + eg_t *egp = NULL; + int enable = 1; -int32_t -error_gen_stat_cbk (call_frame_t *frame, - void *cookie, - xlator_t *this, - int32_t op_ret, - int32_t op_errno, - struct stat *buf) -{ - STACK_UNWIND (frame, - op_ret, - op_errno, - buf); - return 0; -} + egp = this->private; + enable = egp->enable[GF_FOP_LOOKUP]; -int32_t -error_gen_stat (call_frame_t *frame, - xlator_t *this, - loc_t *loc) -{ - int op_errno = 0; - op_errno = error_gen(this); - if (op_errno) { - GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno)); - STACK_UNWIND (frame, -1, op_errno, NULL); - return 0; - } - STACK_WIND (frame, - error_gen_stat_cbk, - FIRST_CHILD(this), - FIRST_CHILD(this)->fops->stat, - loc); - return 0; -} + if (enable) + op_errno = error_gen(this, GF_FOP_LOOKUP); -int32_t -error_gen_chmod_cbk (call_frame_t *frame, - void *cookie, - xlator_t *this, - int32_t op_ret, - int32_t op_errno, - struct stat *buf) -{ - STACK_UNWIND (frame, - op_ret, - op_errno, - buf); - return 0; + if (op_errno) { + GF_ERROR(this, "unwind(-1, %s)", strerror(op_errno)); + STACK_UNWIND_STRICT(lookup, frame, -1, op_errno, NULL, NULL, NULL, + NULL); + return 0; + } + + STACK_WIND_TAIL(frame, FIRST_CHILD(this), FIRST_CHILD(this)->fops->lookup, + loc, xdata); + return 0; } -int32_t -error_gen_chmod (call_frame_t *frame, - xlator_t *this, - loc_t *loc, - mode_t mode) +int +error_gen_stat(call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *xdata) { - int op_errno = 0; - op_errno = error_gen(this); - if (op_errno) { - GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno)); - STACK_UNWIND (frame, -1, op_errno, NULL); - return 0; - } - STACK_WIND (frame, - error_gen_chmod_cbk, - FIRST_CHILD(this), - FIRST_CHILD(this)->fops->chmod, - loc, - mode); - return 0; -} + int op_errno = 0; + eg_t *egp = NULL; + int enable = 1; + egp = this->private; + enable = egp->enable[GF_FOP_STAT]; -int32_t -error_gen_fchmod_cbk (call_frame_t *frame, - void *cookie, - xlator_t *this, - int32_t op_ret, - int32_t op_errno, - struct stat *buf) -{ - STACK_UNWIND (frame, - op_ret, - op_errno, - buf); - return 0; -} + if (enable) + op_errno = error_gen(this, GF_FOP_STAT); -int32_t -error_gen_fchmod (call_frame_t *frame, - xlator_t *this, - fd_t *fd, - mode_t mode) -{ - int op_errno = 0; - op_errno = error_gen(this); - if (op_errno) { - GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno)); - STACK_UNWIND (frame, -1, op_errno, NULL); - return 0; - } - STACK_WIND (frame, - error_gen_fchmod_cbk, - FIRST_CHILD(this), - FIRST_CHILD(this)->fops->fchmod, - fd, - mode); - return 0; -} + if (op_errno) { + GF_ERROR(this, "unwind(-1, %s)", strerror(op_errno)); + STACK_UNWIND_STRICT(stat, frame, -1, op_errno, NULL, xdata); + return 0; + } -int32_t -error_gen_chown_cbk (call_frame_t *frame, - void *cookie, - xlator_t *this, - int32_t op_ret, - int32_t op_errno, - struct stat *buf) -{ - STACK_UNWIND (frame, - op_ret, - op_errno, - buf); - return 0; + STACK_WIND_TAIL(frame, FIRST_CHILD(this), FIRST_CHILD(this)->fops->stat, + loc, xdata); + return 0; } -int32_t -error_gen_chown (call_frame_t *frame, - xlator_t *this, - loc_t *loc, - uid_t uid, - gid_t gid) +int +error_gen_setattr(call_frame_t *frame, xlator_t *this, loc_t *loc, + struct iatt *stbuf, int32_t valid, dict_t *xdata) { - int op_errno = 0; - op_errno = error_gen(this); - if (op_errno) { - GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno)); - STACK_UNWIND (frame, -1, op_errno, NULL); - return 0; - } - STACK_WIND (frame, - error_gen_chown_cbk, - FIRST_CHILD(this), - FIRST_CHILD(this)->fops->chown, - loc, - uid, - gid); - return 0; -} + int op_errno = 0; + eg_t *egp = NULL; + int enable = 1; -int32_t -error_gen_fchown_cbk (call_frame_t *frame, - void *cookie, - xlator_t *this, - int32_t op_ret, - int32_t op_errno, - struct stat *buf) -{ - STACK_UNWIND (frame, - op_ret, - op_errno, - buf); - return 0; -} + egp = this->private; + enable = egp->enable[GF_FOP_SETATTR]; -int32_t -error_gen_fchown (call_frame_t *frame, - xlator_t *this, - fd_t *fd, - uid_t uid, - gid_t gid) -{ - int op_errno = 0; - op_errno = error_gen(this); - if (op_errno) { - GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno)); - STACK_UNWIND (frame, -1, op_errno, NULL); - return 0; - } - STACK_WIND (frame, - error_gen_fchown_cbk, - FIRST_CHILD(this), - FIRST_CHILD(this)->fops->fchown, - fd, - uid, - gid); - return 0; -} + if (enable) + op_errno = error_gen(this, GF_FOP_SETATTR); -int32_t -error_gen_truncate_cbk (call_frame_t *frame, - void *cookie, - xlator_t *this, - int32_t op_ret, - int32_t op_errno, - struct stat *buf) -{ - STACK_UNWIND (frame, - op_ret, - op_errno, - buf); - return 0; -} + if (op_errno) { + GF_ERROR(this, "unwind(-1, %s)", strerror(op_errno)); + STACK_UNWIND_STRICT(setattr, frame, -1, op_errno, NULL, NULL, xdata); + return 0; + } -int32_t -error_gen_truncate (call_frame_t *frame, - xlator_t *this, - loc_t *loc, - off_t offset) -{ - int op_errno = 0; - op_errno = error_gen(this); - if (op_errno) { - GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno)); - STACK_UNWIND (frame, -1, op_errno, NULL); - return 0; - } - STACK_WIND (frame, - error_gen_truncate_cbk, - FIRST_CHILD(this), - FIRST_CHILD(this)->fops->truncate, - loc, - offset); - return 0; + STACK_WIND_TAIL(frame, FIRST_CHILD(this), FIRST_CHILD(this)->fops->setattr, + loc, stbuf, valid, xdata); + return 0; } -int32_t -error_gen_ftruncate_cbk (call_frame_t *frame, - void *cookie, - xlator_t *this, - int32_t op_ret, - int32_t op_errno, - struct stat *buf) +int +error_gen_fsetattr(call_frame_t *frame, xlator_t *this, fd_t *fd, + struct iatt *stbuf, int32_t valid, dict_t *xdata) { - STACK_UNWIND (frame, - op_ret, - op_errno, - buf); - return 0; -} + int op_errno = 0; + eg_t *egp = NULL; + int enable = 1; -int32_t -error_gen_ftruncate (call_frame_t *frame, - xlator_t *this, - fd_t *fd, - off_t offset) -{ - int op_errno = 0; - op_errno = error_gen(this); - if (op_errno) { - GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno)); - STACK_UNWIND (frame, -1, op_errno, NULL); - return 0; - } - STACK_WIND (frame, - error_gen_ftruncate_cbk, - FIRST_CHILD(this), - FIRST_CHILD(this)->fops->ftruncate, - fd, - offset); - return 0; -} + egp = this->private; + enable = egp->enable[GF_FOP_FSETATTR]; -int32_t -error_gen_utimens_cbk (call_frame_t *frame, - void *cookie, - xlator_t *this, - int32_t op_ret, - int32_t op_errno, - struct stat *buf) -{ - STACK_UNWIND (frame, - op_ret, - op_errno, - buf); - return 0; -} + if (enable) + 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, xdata); + return 0; + } -int32_t -error_gen_utimens (call_frame_t *frame, - xlator_t *this, - loc_t *loc, - struct timespec tv[2]) -{ - int op_errno = 0; - op_errno = error_gen(this); - if (op_errno) { - GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno)); - STACK_UNWIND (frame, -1, op_errno, NULL); - return 0; - } - STACK_WIND (frame, - error_gen_utimens_cbk, - FIRST_CHILD(this), - FIRST_CHILD(this)->fops->utimens, - loc, - tv); - return 0; + STACK_WIND_TAIL(frame, FIRST_CHILD(this), FIRST_CHILD(this)->fops->fsetattr, + fd, stbuf, valid, xdata); + return 0; } -int32_t -error_gen_access_cbk (call_frame_t *frame, - void *cookie, - xlator_t *this, - int32_t op_ret, - int32_t op_errno) +int +error_gen_truncate(call_frame_t *frame, xlator_t *this, loc_t *loc, + off_t offset, dict_t *xdata) { - STACK_UNWIND (frame, - op_ret, - op_errno); - return 0; -} + int op_errno = 0; + eg_t *egp = NULL; + int enable = 1; -int32_t -error_gen_access (call_frame_t *frame, - xlator_t *this, - loc_t *loc, - int32_t mask) -{ - int op_errno = 0; - op_errno = error_gen(this); - if (op_errno) { - GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno)); - STACK_UNWIND (frame, -1, op_errno); - return 0; - } - STACK_WIND (frame, - error_gen_access_cbk, - FIRST_CHILD(this), - FIRST_CHILD(this)->fops->access, - loc, - mask); - return 0; -} + egp = this->private; + enable = egp->enable[GF_FOP_TRUNCATE]; + if (enable) + op_errno = error_gen(this, GF_FOP_TRUNCATE); -int32_t -error_gen_readlink_cbk (call_frame_t *frame, - void *cookie, - xlator_t *this, - int32_t op_ret, - int32_t op_errno, - const char *path) -{ - STACK_UNWIND (frame, - op_ret, - op_errno, - path); - return 0; + if (op_errno) { + GF_ERROR(this, "unwind(-1, %s)", strerror(op_errno)); + STACK_UNWIND_STRICT(truncate, frame, -1, op_errno, NULL, NULL, xdata); + return 0; + } + + STACK_WIND_TAIL(frame, FIRST_CHILD(this), FIRST_CHILD(this)->fops->truncate, + loc, offset, xdata); + return 0; } -int32_t -error_gen_readlink (call_frame_t *frame, - xlator_t *this, - loc_t *loc, - size_t size) +int +error_gen_ftruncate(call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset, + dict_t *xdata) { - int op_errno = 0; - op_errno = error_gen(this); - if (op_errno) { - GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno)); - STACK_UNWIND (frame, -1, op_errno, NULL); - return 0; - } - STACK_WIND (frame, - error_gen_readlink_cbk, - FIRST_CHILD(this), - FIRST_CHILD(this)->fops->readlink, - loc, - size); - return 0; -} + int op_errno = 0; + eg_t *egp = NULL; + int enable = 1; + egp = this->private; + enable = egp->enable[GF_FOP_FTRUNCATE]; -int32_t -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) -{ - STACK_UNWIND (frame, - op_ret, - op_errno, - inode, - buf); - return 0; -} + if (enable) + op_errno = error_gen(this, GF_FOP_FTRUNCATE); -int32_t -error_gen_mknod (call_frame_t *frame, - xlator_t *this, - loc_t *loc, - mode_t mode, - dev_t rdev) -{ - int op_errno = 0; - op_errno = error_gen(this); - if (op_errno) { - GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno)); - STACK_UNWIND (frame, -1, op_errno, NULL, NULL); - return 0; - } - STACK_WIND (frame, - error_gen_mknod_cbk, - FIRST_CHILD(this), - FIRST_CHILD(this)->fops->mknod, - loc, mode, rdev); - return 0; -} + if (op_errno) { + GF_ERROR(this, "unwind(-1, %s)", strerror(op_errno)); + STACK_UNWIND_STRICT(ftruncate, frame, -1, op_errno, NULL, NULL, xdata); + return 0; + } -int32_t -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) -{ - STACK_UNWIND (frame, - op_ret, - op_errno, - inode, - buf); - return 0; + STACK_WIND_TAIL(frame, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->ftruncate, fd, offset, xdata); + return 0; } -int32_t -error_gen_mkdir (call_frame_t *frame, - xlator_t *this, - loc_t *loc, - mode_t mode) +int +error_gen_access(call_frame_t *frame, xlator_t *this, loc_t *loc, int32_t mask, + dict_t *xdata) { - int op_errno = 0; - op_errno = error_gen(this); - if (op_errno) { - GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno)); - STACK_UNWIND (frame, -1, op_errno, NULL, NULL); - return 0; - } - STACK_WIND (frame, - error_gen_mkdir_cbk, - FIRST_CHILD(this), - FIRST_CHILD(this)->fops->mkdir, - loc, mode); - return 0; -} + int op_errno = 0; + eg_t *egp = NULL; + int enable = 1; -int32_t -error_gen_unlink_cbk (call_frame_t *frame, - void *cookie, - xlator_t *this, - int32_t op_ret, - int32_t op_errno) -{ - STACK_UNWIND (frame, op_ret, op_errno); - return 0; -} + egp = this->private; + enable = egp->enable[GF_FOP_ACCESS]; -int32_t -error_gen_unlink (call_frame_t *frame, - xlator_t *this, - loc_t *loc) -{ - int op_errno = 0; - op_errno = error_gen(this); - if (op_errno) { - GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno)); - STACK_UNWIND (frame, -1, op_errno); - return 0; - } - STACK_WIND (frame, - error_gen_unlink_cbk, - FIRST_CHILD(this), - FIRST_CHILD(this)->fops->unlink, - loc); - return 0; -} + if (enable) + op_errno = error_gen(this, GF_FOP_ACCESS); -int32_t -error_gen_rmdir_cbk (call_frame_t *frame, - void *cookie, - xlator_t *this, - int32_t op_ret, - int32_t op_errno) -{ - STACK_UNWIND (frame, - op_ret, - op_errno); - return 0; + if (op_errno) { + GF_ERROR(this, "unwind(-1, %s)", strerror(op_errno)); + STACK_UNWIND_STRICT(access, frame, -1, op_errno, xdata); + return 0; + } + + STACK_WIND_TAIL(frame, FIRST_CHILD(this), FIRST_CHILD(this)->fops->access, + loc, mask, xdata); + return 0; } -int32_t -error_gen_rmdir (call_frame_t *frame, - xlator_t *this, - loc_t *loc) +int +error_gen_readlink(call_frame_t *frame, xlator_t *this, loc_t *loc, size_t size, + dict_t *xdata) { - int op_errno = 0; - op_errno = error_gen(this); - if (op_errno) { - GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno)); - STACK_UNWIND (frame, -1, op_errno); - return 0; - } - STACK_WIND (frame, - error_gen_rmdir_cbk, - FIRST_CHILD(this), - FIRST_CHILD(this)->fops->rmdir, - loc); - return 0; -} + int op_errno = 0; + eg_t *egp = NULL; + int enable = 1; + egp = this->private; + enable = egp->enable[GF_FOP_READLINK]; -int32_t -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) -{ - STACK_UNWIND (frame, op_ret, op_errno, inode, buf); - return 0; + if (enable) + 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, xdata); + return 0; + } + + STACK_WIND_TAIL(frame, FIRST_CHILD(this), FIRST_CHILD(this)->fops->readlink, + loc, size, xdata); + return 0; } -int32_t -error_gen_symlink (call_frame_t *frame, - xlator_t *this, - const char *linkpath, - loc_t *loc) +int +error_gen_mknod(call_frame_t *frame, xlator_t *this, loc_t *loc, mode_t mode, + dev_t rdev, mode_t umask, dict_t *xdata) { - int op_errno = 0; - op_errno = error_gen(this); - if (op_errno) { - GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno)); - STACK_UNWIND (frame, -1, op_errno, NULL, NULL); - return 0; - } - STACK_WIND (frame, - error_gen_symlink_cbk, - FIRST_CHILD(this), - FIRST_CHILD(this)->fops->symlink, - linkpath, loc); - return 0; -} + int op_errno = 0; + eg_t *egp = NULL; + int enable = 1; + egp = this->private; + enable = egp->enable[GF_FOP_MKNOD]; -int32_t -error_gen_rename_cbk (call_frame_t *frame, - void *cookie, - xlator_t *this, - int32_t op_ret, - int32_t op_errno, - struct stat *buf) -{ - STACK_UNWIND (frame, op_ret, op_errno, buf); - return 0; + if (enable) + 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, + xdata); + return 0; + } + + STACK_WIND_TAIL(frame, FIRST_CHILD(this), FIRST_CHILD(this)->fops->mknod, + loc, mode, rdev, umask, xdata); + return 0; } -int32_t -error_gen_rename (call_frame_t *frame, - xlator_t *this, - loc_t *oldloc, - loc_t *newloc) +int +error_gen_mkdir(call_frame_t *frame, xlator_t *this, loc_t *loc, mode_t mode, + mode_t umask, dict_t *xdata) { - int op_errno = 0; - op_errno = error_gen(this); - if (op_errno) { - GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno)); - STACK_UNWIND (frame, -1, op_errno, NULL); - return 0; - } - STACK_WIND (frame, - error_gen_rename_cbk, - FIRST_CHILD(this), - FIRST_CHILD(this)->fops->rename, - oldloc, newloc); - return 0; -} + int op_errno = 0; + eg_t *egp = NULL; + int enable = 1; + egp = this->private; + enable = egp->enable[GF_FOP_MKDIR]; -int32_t -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) -{ - STACK_UNWIND (frame, op_ret, op_errno, inode, buf); - return 0; + if (enable) + 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, + xdata); + return 0; + } + + STACK_WIND_TAIL(frame, FIRST_CHILD(this), FIRST_CHILD(this)->fops->mkdir, + loc, mode, umask, xdata); + return 0; } -int32_t -error_gen_link (call_frame_t *frame, - xlator_t *this, - loc_t *oldloc, - loc_t *newloc) +int +error_gen_unlink(call_frame_t *frame, xlator_t *this, loc_t *loc, int xflag, + dict_t *xdata) { - int op_errno = 0; - op_errno = error_gen(this); - if (op_errno) { - GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno)); - STACK_UNWIND (frame, -1, op_errno, NULL, NULL); - return 0; - } - STACK_WIND (frame, - error_gen_link_cbk, - FIRST_CHILD(this), - FIRST_CHILD(this)->fops->link, - oldloc, newloc); - return 0; -} + int op_errno = 0; + eg_t *egp = NULL; + int enable = 1; + egp = this->private; + enable = egp->enable[GF_FOP_UNLINK]; -int32_t -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) -{ - STACK_UNWIND (frame, op_ret, op_errno, fd, inode, buf); - return 0; -} + if (enable) + op_errno = error_gen(this, GF_FOP_UNLINK); -int32_t -error_gen_create (call_frame_t *frame, - xlator_t *this, - loc_t *loc, - int32_t flags, - mode_t mode, fd_t *fd) -{ - int op_errno = 0; - op_errno = error_gen(this); - if (op_errno) { - GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno)); - STACK_UNWIND (frame, -1, op_errno, 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; + if (op_errno) { + GF_ERROR(this, "unwind(-1, %s)", strerror(op_errno)); + STACK_UNWIND_STRICT(unlink, frame, -1, op_errno, NULL, NULL, xdata); + return 0; + } + + STACK_WIND_TAIL(frame, FIRST_CHILD(this), FIRST_CHILD(this)->fops->unlink, + loc, xflag, xdata); + return 0; } -int32_t -error_gen_open_cbk (call_frame_t *frame, - void *cookie, - xlator_t *this, - int32_t op_ret, - int32_t op_errno, - fd_t *fd) +int +error_gen_rmdir(call_frame_t *frame, xlator_t *this, loc_t *loc, int flags, + dict_t *xdata) { - STACK_UNWIND (frame, - op_ret, - op_errno, - fd); - return 0; + int op_errno = 0; + eg_t *egp = NULL; + int enable = 1; + + egp = this->private; + enable = egp->enable[GF_FOP_RMDIR]; + + if (enable) + 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, xdata); + return 0; + } + + STACK_WIND_TAIL(frame, FIRST_CHILD(this), FIRST_CHILD(this)->fops->rmdir, + loc, flags, xdata); + return 0; } -int32_t -error_gen_open (call_frame_t *frame, - xlator_t *this, - loc_t *loc, - int32_t flags, fd_t *fd) +int +error_gen_symlink(call_frame_t *frame, xlator_t *this, const char *linkpath, + loc_t *loc, mode_t umask, dict_t *xdata) { - int op_errno = 0; - op_errno = error_gen(this); - if (op_errno) { - GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno)); - STACK_UNWIND (frame, -1, op_errno, NULL); - return 0; - } - - STACK_WIND (frame, - error_gen_open_cbk, - FIRST_CHILD(this), - FIRST_CHILD(this)->fops->open, - loc, flags, fd); - return 0; + int op_errno = 0; + eg_t *egp = NULL; + int enable = 1; + + egp = this->private; + enable = egp->enable[GF_FOP_SYMLINK]; + + if (enable) + 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, NULL); /* pre & post parent attr */ + return 0; + } + + STACK_WIND_TAIL(frame, FIRST_CHILD(this), FIRST_CHILD(this)->fops->symlink, + linkpath, loc, umask, xdata); + return 0; } -int32_t -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) +int +error_gen_rename(call_frame_t *frame, xlator_t *this, loc_t *oldloc, + loc_t *newloc, dict_t *xdata) { - STACK_UNWIND (frame, - op_ret, - op_errno, - vector, - count, - stbuf); - return 0; + int op_errno = 0; + eg_t *egp = NULL; + int enable = 1; + + egp = this->private; + enable = egp->enable[GF_FOP_RENAME]; + + if (enable) + 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, NULL); + return 0; + } + + STACK_WIND_TAIL(frame, FIRST_CHILD(this), FIRST_CHILD(this)->fops->rename, + oldloc, newloc, xdata); + return 0; } -int32_t -error_gen_readv (call_frame_t *frame, - xlator_t *this, - fd_t *fd, - size_t size, - off_t offset) +int +error_gen_link(call_frame_t *frame, xlator_t *this, loc_t *oldloc, + loc_t *newloc, dict_t *xdata) { - int op_errno = 0; - op_errno = error_gen(this); - if (op_errno) { - GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno)); - STACK_UNWIND (frame, -1, op_errno, NULL, 0, NULL); - return 0; - } - - - STACK_WIND (frame, - error_gen_readv_cbk, - FIRST_CHILD(this), - FIRST_CHILD(this)->fops->readv, - fd, - size, - offset); - return 0; -} + int op_errno = 0; + eg_t *egp = NULL; + int enable = 1; + egp = this->private; + enable = egp->enable[GF_FOP_LINK]; -int32_t -error_gen_writev_cbk (call_frame_t *frame, - void *cookie, - xlator_t *this, - int32_t op_ret, - int32_t op_errno, - struct stat *stbuf) -{ - STACK_UNWIND (frame, - op_ret, - op_errno, - stbuf); - return 0; + if (enable) + 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, + NULL); + return 0; + } + + STACK_WIND_TAIL(frame, FIRST_CHILD(this), FIRST_CHILD(this)->fops->link, + oldloc, newloc, xdata); + return 0; } -int32_t -error_gen_writev (call_frame_t *frame, - xlator_t *this, - fd_t *fd, - struct iovec *vector, - int32_t count, - off_t off) +int +error_gen_create(call_frame_t *frame, xlator_t *this, loc_t *loc, int32_t flags, + mode_t mode, mode_t umask, fd_t *fd, dict_t *xdata) { - int op_errno = 0; - op_errno = error_gen(this); - if (op_errno) { - GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno)); - STACK_UNWIND (frame, -1, op_errno, NULL); - return 0; - } - - - STACK_WIND (frame, - error_gen_writev_cbk, - FIRST_CHILD(this), - FIRST_CHILD(this)->fops->writev, - fd, - vector, - count, - off); - return 0; + int op_errno = 0; + eg_t *egp = NULL; + int enable = 1; + + egp = this->private; + enable = egp->enable[GF_FOP_CREATE]; + + if (enable) + 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, NULL); + return 0; + } + + STACK_WIND_TAIL(frame, FIRST_CHILD(this), FIRST_CHILD(this)->fops->create, + loc, flags, mode, umask, fd, xdata); + return 0; } -int32_t -error_gen_flush_cbk (call_frame_t *frame, - void *cookie, - xlator_t *this, - int32_t op_ret, - int32_t op_errno) +int +error_gen_open(call_frame_t *frame, xlator_t *this, loc_t *loc, int32_t flags, + fd_t *fd, dict_t *xdata) { - STACK_UNWIND (frame, - op_ret, - op_errno); - return 0; + int op_errno = 0; + eg_t *egp = NULL; + int enable = 1; + + egp = this->private; + enable = egp->enable[GF_FOP_OPEN]; + + if (enable) + 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, xdata); + return 0; + } + + STACK_WIND_TAIL(frame, FIRST_CHILD(this), FIRST_CHILD(this)->fops->open, + loc, flags, fd, xdata); + return 0; } -int32_t -error_gen_flush (call_frame_t *frame, - xlator_t *this, - fd_t *fd) +int +error_gen_readv(call_frame_t *frame, xlator_t *this, fd_t *fd, size_t size, + off_t offset, uint32_t flags, dict_t *xdata) { - int op_errno = 0; - op_errno = error_gen(this); - if (op_errno) { - GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno)); - STACK_UNWIND (frame, -1, op_errno); - return 0; - } - - STACK_WIND (frame, - error_gen_flush_cbk, - FIRST_CHILD(this), - FIRST_CHILD(this)->fops->flush, - fd); - return 0; -} + int op_errno = 0; + eg_t *egp = NULL; + int enable = 1; + egp = this->private; + enable = egp->enable[GF_FOP_READ]; -int32_t -error_gen_fsync_cbk (call_frame_t *frame, - void *cookie, - xlator_t *this, - int32_t op_ret, - int32_t op_errno) -{ - STACK_UNWIND (frame, - op_ret, - op_errno); - return 0; + if (enable) + 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, + xdata); + return 0; + } + + STACK_WIND_TAIL(frame, FIRST_CHILD(this), FIRST_CHILD(this)->fops->readv, + fd, size, offset, flags, xdata); + return 0; } -int32_t -error_gen_fsync (call_frame_t *frame, - xlator_t *this, - fd_t *fd, - int32_t flags) -{ - int op_errno = 0; - op_errno = error_gen(this); - if (op_errno) { - GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno)); - STACK_UNWIND (frame, -1, op_errno); - return 0; - } - - STACK_WIND (frame, - error_gen_fsync_cbk, - FIRST_CHILD(this), - FIRST_CHILD(this)->fops->fsync, - fd, - flags); - 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, uint32_t flags, + struct iobref *iobref, dict_t *xdata) +{ + int op_errno = 0; + eg_t *egp = NULL; + int enable = 1; + struct iovec *shortvec = NULL; + + egp = this->private; + enable = egp->enable[GF_FOP_WRITE]; + + if (enable) + op_errno = error_gen(this, GF_FOP_WRITE); + + if (op_errno == GF_ERROR_SHORT_WRITE) { + /* + * 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; + count = 1; + goto wind; + } 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; + } +wind: + STACK_WIND_TAIL(frame, FIRST_CHILD(this), FIRST_CHILD(this)->fops->writev, + fd, shortvec ? shortvec : vector, count, off, flags, iobref, + xdata); + + if (shortvec) + GF_FREE(shortvec); + return 0; } -int32_t -error_gen_fstat_cbk (call_frame_t *frame, - void *cookie, - xlator_t *this, - int32_t op_ret, - int32_t op_errno, - struct stat *buf) +int +error_gen_flush(call_frame_t *frame, xlator_t *this, fd_t *fd, dict_t *xdata) { - STACK_UNWIND (frame, - op_ret, - op_errno, - buf); - return 0; + int op_errno = 0; + eg_t *egp = NULL; + int enable = 1; + + egp = this->private; + enable = egp->enable[GF_FOP_FLUSH]; + + if (enable) + 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, xdata); + return 0; + } + + STACK_WIND_TAIL(frame, FIRST_CHILD(this), FIRST_CHILD(this)->fops->flush, + fd, xdata); + return 0; } -int32_t -error_gen_fstat (call_frame_t *frame, - xlator_t *this, - fd_t *fd) +int +error_gen_fsync(call_frame_t *frame, xlator_t *this, fd_t *fd, int32_t flags, + dict_t *xdata) { - int op_errno = 0; - op_errno = error_gen(this); - if (op_errno) { - GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno)); - STACK_UNWIND (frame, -1, op_errno, NULL); - return 0; - } - - STACK_WIND (frame, - error_gen_fstat_cbk, - FIRST_CHILD(this), - FIRST_CHILD(this)->fops->fstat, - fd); - return 0; + int op_errno = 0; + eg_t *egp = NULL; + int enable = 1; + + egp = this->private; + enable = egp->enable[GF_FOP_FSYNC]; + + if (enable) + 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, xdata); + return 0; + } + + STACK_WIND_TAIL(frame, FIRST_CHILD(this), FIRST_CHILD(this)->fops->fsync, + fd, flags, xdata); + return 0; } -int32_t -error_gen_opendir_cbk (call_frame_t *frame, - void *cookie, - xlator_t *this, - int32_t op_ret, - int32_t op_errno, - fd_t *fd) +int +error_gen_fstat(call_frame_t *frame, xlator_t *this, fd_t *fd, dict_t *xdata) { - STACK_UNWIND (frame, - op_ret, - op_errno, - fd); - return 0; + int op_errno = 0; + eg_t *egp = NULL; + int enable = 1; + + egp = this->private; + enable = egp->enable[GF_FOP_FSTAT]; + + if (enable) + 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, xdata); + return 0; + } + + STACK_WIND_TAIL(frame, FIRST_CHILD(this), FIRST_CHILD(this)->fops->fstat, + fd, xdata); + return 0; } -int32_t -error_gen_opendir (call_frame_t *frame, - xlator_t *this, - loc_t *loc, fd_t *fd) +int +error_gen_opendir(call_frame_t *frame, xlator_t *this, loc_t *loc, fd_t *fd, + dict_t *xdata) { - int op_errno = 0; - op_errno = error_gen(this); - if (op_errno) { - GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno)); - STACK_UNWIND (frame, -1, op_errno, NULL); - return 0; - } - - STACK_WIND (frame, - error_gen_opendir_cbk, - FIRST_CHILD(this), - FIRST_CHILD(this)->fops->opendir, - loc, fd); - return 0; -} + int op_errno = 0; + eg_t *egp = NULL; + int enable = 1; + egp = this->private; + enable = egp->enable[GF_FOP_OPENDIR]; -int32_t -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) -{ - STACK_UNWIND (frame, - op_ret, - op_errno, - entries, - count); - return 0; + if (enable) + 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, xdata); + return 0; + } + + STACK_WIND_TAIL(frame, FIRST_CHILD(this), FIRST_CHILD(this)->fops->opendir, + loc, fd, xdata); + return 0; } -int32_t -error_gen_getdents (call_frame_t *frame, - xlator_t *this, - fd_t *fd, - size_t size, - off_t offset, - int32_t flag) +int +error_gen_fsyncdir(call_frame_t *frame, xlator_t *this, fd_t *fd, int32_t flags, + dict_t *xdata) { - int op_errno = 0; - op_errno = error_gen(this); - if (op_errno) { - GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno)); - STACK_UNWIND (frame, -1, op_errno, NULL, 0); - return 0; - } - - STACK_WIND (frame, - error_gen_getdents_cbk, - FIRST_CHILD(this), - FIRST_CHILD(this)->fops->getdents, - fd, - size, - offset, - flag); - return 0; -} + int op_errno = 0; + eg_t *egp = NULL; + int enable = 1; + egp = this->private; + enable = egp->enable[GF_FOP_FSYNCDIR]; -int32_t -error_gen_setdents_cbk (call_frame_t *frame, - void *cookie, - xlator_t *this, - int32_t op_ret, - int32_t op_errno) -{ - STACK_UNWIND (frame, - op_ret, - op_errno); - return 0; + if (enable) + op_errno = error_gen(this, GF_FOP_FSYNCDIR); + + if (op_errno) { + GF_ERROR(this, "unwind(-1, %s)", strerror(op_errno)); + STACK_UNWIND_STRICT(fsyncdir, frame, -1, op_errno, xdata); + return 0; + } + + STACK_WIND_TAIL(frame, FIRST_CHILD(this), FIRST_CHILD(this)->fops->fsyncdir, + fd, flags, xdata); + return 0; } -int32_t -error_gen_setdents (call_frame_t *frame, - xlator_t *this, - fd_t *fd, - int32_t flags, - dir_entry_t *entries, - int32_t count) +int +error_gen_statfs(call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *xdata) { - int op_errno = 0; - op_errno = error_gen(this); - if (op_errno) { - GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno)); - STACK_UNWIND (frame, -1, op_errno, NULL, 0); - return 0; - } - - STACK_WIND (frame, - error_gen_setdents_cbk, - FIRST_CHILD(this), - FIRST_CHILD(this)->fops->setdents, - fd, - flags, - entries, - count); - return 0; -} + int op_errno = 0; + eg_t *egp = NULL; + int enable = 1; + egp = this->private; + enable = egp->enable[GF_FOP_STATFS]; -int32_t -error_gen_fsyncdir_cbk (call_frame_t *frame, - void *cookie, - xlator_t *this, - int32_t op_ret, - int32_t op_errno) -{ - STACK_UNWIND (frame, - op_ret, - op_errno); - return 0; + if (enable) + op_errno = error_gen(this, GF_FOP_STATFS); + + if (op_errno) { + GF_ERROR(this, "unwind(-1, %s)", strerror(op_errno)); + STACK_UNWIND_STRICT(statfs, frame, -1, op_errno, NULL, xdata); + return 0; + } + + STACK_WIND_TAIL(frame, FIRST_CHILD(this), FIRST_CHILD(this)->fops->statfs, + loc, xdata); + return 0; } -int32_t -error_gen_fsyncdir (call_frame_t *frame, - xlator_t *this, - fd_t *fd, - int32_t flags) +int +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; - op_errno = error_gen(this); - if (op_errno) { - GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno)); - STACK_UNWIND (frame, -1, op_errno); - return 0; - } - - STACK_WIND (frame, - error_gen_fsyncdir_cbk, - FIRST_CHILD(this), - FIRST_CHILD(this)->fops->fsyncdir, - fd, - flags); - return 0; -} + int op_errno = 0; + eg_t *egp = NULL; + int enable = 1; + egp = this->private; + enable = egp->enable[GF_FOP_SETXATTR]; -int32_t -error_gen_statfs_cbk (call_frame_t *frame, - void *cookie, - xlator_t *this, - int32_t op_ret, - int32_t op_errno, - struct statvfs *buf) -{ - STACK_UNWIND (frame, - op_ret, - op_errno, - buf); - return 0; + if (enable) + op_errno = error_gen(this, GF_FOP_SETXATTR); + + if (op_errno) { + GF_ERROR(this, "unwind(-1, %s)", strerror(op_errno)); + STACK_UNWIND_STRICT(setxattr, frame, -1, op_errno, xdata); + return 0; + } + + STACK_WIND_TAIL(frame, FIRST_CHILD(this), FIRST_CHILD(this)->fops->setxattr, + loc, dict, flags, xdata); + return 0; } -int32_t -error_gen_statfs (call_frame_t *frame, - xlator_t *this, - loc_t *loc) +int +error_gen_getxattr(call_frame_t *frame, xlator_t *this, loc_t *loc, + const char *name, dict_t *xdata) { - int op_errno = 0; - op_errno = error_gen(this); - if (op_errno) { - GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno)); - STACK_UNWIND (frame, -1, op_errno, NULL); - return 0; - } - - STACK_WIND (frame, - error_gen_statfs_cbk, - FIRST_CHILD(this), - FIRST_CHILD(this)->fops->statfs, - loc); - return 0; -} + int op_errno = 0; + eg_t *egp = NULL; + int enable = 1; + egp = this->private; + enable = egp->enable[GF_FOP_GETXATTR]; -int32_t -error_gen_setxattr_cbk (call_frame_t *frame, - void *cookie, - xlator_t *this, - int32_t op_ret, - int32_t op_errno) -{ - STACK_UNWIND (frame, - op_ret, - op_errno); - return 0; + if (enable) + op_errno = error_gen(this, GF_FOP_GETXATTR); + + if (op_errno) { + GF_ERROR(this, "unwind(-1, %s)", strerror(op_errno)); + STACK_UNWIND_STRICT(getxattr, frame, -1, op_errno, NULL, xdata); + return 0; + } + + STACK_WIND_TAIL(frame, FIRST_CHILD(this), FIRST_CHILD(this)->fops->getxattr, + loc, name, xdata); + return 0; } -int32_t -error_gen_setxattr (call_frame_t *frame, - xlator_t *this, - loc_t *loc, - dict_t *dict, - int32_t flags) +int +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; - op_errno = error_gen(this); - if (op_errno) { - GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno)); - STACK_UNWIND (frame, -1, op_errno); - return 0; - } - - STACK_WIND (frame, - error_gen_setxattr_cbk, - FIRST_CHILD(this), - FIRST_CHILD(this)->fops->setxattr, - loc, - dict, - flags); - return 0; + int op_errno = 0; + eg_t *egp = NULL; + int enable = 1; + + egp = this->private; + enable = egp->enable[GF_FOP_FSETXATTR]; + + if (enable) + op_errno = error_gen(this, GF_FOP_FSETXATTR); + + if (op_errno) { + GF_ERROR(this, "unwind(-1, %s)", strerror(op_errno)); + STACK_UNWIND_STRICT(fsetxattr, frame, -1, op_errno, xdata); + return 0; + } + + STACK_WIND_TAIL(frame, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->fsetxattr, fd, dict, flags, xdata); + return 0; } -int32_t -error_gen_getxattr_cbk (call_frame_t *frame, - void *cookie, - xlator_t *this, - int32_t op_ret, - int32_t op_errno, - dict_t *dict) +int +error_gen_fgetxattr(call_frame_t *frame, xlator_t *this, fd_t *fd, + const char *name, dict_t *xdata) { - STACK_UNWIND (frame, - op_ret, - op_errno, - dict); - return 0; + int op_errno = 0; + eg_t *egp = NULL; + int enable = 1; + + egp = this->private; + enable = egp->enable[GF_FOP_FGETXATTR]; + + if (enable) + op_errno = error_gen(this, GF_FOP_FGETXATTR); + + if (op_errno) { + GF_ERROR(this, "unwind(-1, %s)", strerror(op_errno)); + STACK_UNWIND_STRICT(fgetxattr, frame, -1, op_errno, NULL, xdata); + return 0; + } + + STACK_WIND_TAIL(frame, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->fgetxattr, fd, name, xdata); + return 0; } -int32_t -error_gen_getxattr (call_frame_t *frame, - xlator_t *this, - loc_t *loc, - const char *name) +int +error_gen_xattrop(call_frame_t *frame, xlator_t *this, loc_t *loc, + gf_xattrop_flags_t flags, dict_t *dict, dict_t *xdata) { - int op_errno = 0; - op_errno = error_gen(this); - if (op_errno) { - GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno)); - STACK_UNWIND (frame, -1, op_errno, NULL); - return 0; - } - - STACK_WIND (frame, - error_gen_getxattr_cbk, - FIRST_CHILD(this), - FIRST_CHILD(this)->fops->getxattr, - loc, - name); - return 0; + int op_errno = 0; + eg_t *egp = NULL; + int enable = 1; + + egp = this->private; + enable = egp->enable[GF_FOP_XATTROP]; + + if (enable) + 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, xdata); + return 0; + } + + STACK_WIND_TAIL(frame, FIRST_CHILD(this), FIRST_CHILD(this)->fops->xattrop, + loc, flags, dict, xdata); + return 0; } -int32_t -error_gen_xattrop_cbk (call_frame_t *frame, - void *cookie, - xlator_t *this, - int32_t op_ret, - int32_t op_errno, - dict_t *dict) +int +error_gen_fxattrop(call_frame_t *frame, xlator_t *this, fd_t *fd, + gf_xattrop_flags_t flags, dict_t *dict, dict_t *xdata) { - STACK_UNWIND (frame, op_ret, op_errno, dict); - return 0; + int op_errno = 0; + eg_t *egp = NULL; + int enable = 1; + + egp = this->private; + enable = egp->enable[GF_FOP_FXATTROP]; + + if (enable) + 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, xdata); + return 0; + } + + STACK_WIND_TAIL(frame, FIRST_CHILD(this), FIRST_CHILD(this)->fops->fxattrop, + fd, flags, dict, xdata); + return 0; } -int32_t -error_gen_xattrop (call_frame_t *frame, - xlator_t *this, - loc_t *loc, - gf_xattrop_flags_t flags, - dict_t *dict) +int +error_gen_removexattr(call_frame_t *frame, xlator_t *this, loc_t *loc, + const char *name, dict_t *xdata) { - int op_errno = 0; - op_errno = error_gen(this); - if (op_errno) { - GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno)); - STACK_UNWIND (frame, -1, op_errno, NULL); - return 0; - } - - STACK_WIND (frame, - error_gen_xattrop_cbk, - FIRST_CHILD(this), - FIRST_CHILD(this)->fops->xattrop, - loc, flags, dict); - return 0; + int op_errno = 0; + eg_t *egp = NULL; + int enable = 1; + + egp = this->private; + enable = egp->enable[GF_FOP_REMOVEXATTR]; + + if (enable) + 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, xdata); + return 0; + } + + STACK_WIND_TAIL(frame, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->removexattr, loc, name, xdata); + return 0; } -int32_t -error_gen_fxattrop_cbk (call_frame_t *frame, - void *cookie, - xlator_t *this, - int32_t op_ret, - int32_t op_errno, - dict_t *dict) +int +error_gen_fremovexattr(call_frame_t *frame, xlator_t *this, fd_t *fd, + const char *name, dict_t *xdata) { - STACK_UNWIND (frame, op_ret, op_errno, dict); - return 0; + 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_TAIL(frame, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->fremovexattr, fd, name, xdata); + return 0; } -int32_t -error_gen_fxattrop (call_frame_t *frame, - xlator_t *this, - fd_t *fd, - gf_xattrop_flags_t flags, - dict_t *dict) +int +error_gen_lk(call_frame_t *frame, xlator_t *this, fd_t *fd, int32_t cmd, + struct gf_flock *lock, dict_t *xdata) { - int op_errno = 0; - op_errno = error_gen(this); - if (op_errno) { - GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno)); - STACK_UNWIND (frame, -1, op_errno, NULL); - return 0; - } - - STACK_WIND (frame, - error_gen_fxattrop_cbk, - FIRST_CHILD(this), - FIRST_CHILD(this)->fops->fxattrop, - fd, flags, dict); - return 0; + int op_errno = 0; + eg_t *egp = NULL; + int enable = 1; + + egp = this->private; + enable = egp->enable[GF_FOP_LK]; + + if (enable) + 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, xdata); + return 0; + } + + STACK_WIND_TAIL(frame, FIRST_CHILD(this), FIRST_CHILD(this)->fops->lk, fd, + cmd, lock, xdata); + return 0; } -int32_t -error_gen_removexattr_cbk (call_frame_t *frame, - void *cookie, - xlator_t *this, - int32_t op_ret, - int32_t op_errno) +int +error_gen_inodelk(call_frame_t *frame, xlator_t *this, const char *volume, + loc_t *loc, int32_t cmd, struct gf_flock *lock, dict_t *xdata) { - STACK_UNWIND (frame, - op_ret, - op_errno); - return 0; + int op_errno = 0; + eg_t *egp = NULL; + int enable = 1; + + egp = this->private; + enable = egp->enable[GF_FOP_INODELK]; + + if (enable) + 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, xdata); + return 0; + } + + STACK_WIND_TAIL(frame, FIRST_CHILD(this), FIRST_CHILD(this)->fops->inodelk, + volume, loc, cmd, lock, xdata); + return 0; } -int32_t -error_gen_removexattr (call_frame_t *frame, - xlator_t *this, - loc_t *loc, - const char *name) +int +error_gen_finodelk(call_frame_t *frame, xlator_t *this, const char *volume, + fd_t *fd, int32_t cmd, struct gf_flock *lock, dict_t *xdata) { - int op_errno = 0; - op_errno = error_gen(this); - if (op_errno) { - GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno)); - STACK_UNWIND (frame, -1, op_errno, NULL); - return 0; - } - - STACK_WIND (frame, - error_gen_removexattr_cbk, - FIRST_CHILD(this), - FIRST_CHILD(this)->fops->removexattr, - loc, - name); - return 0; + int op_errno = 0; + eg_t *egp = NULL; + int enable = 1; + + egp = this->private; + enable = egp->enable[GF_FOP_FINODELK]; + + if (enable) + 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, xdata); + return 0; + } + + STACK_WIND_TAIL(frame, FIRST_CHILD(this), FIRST_CHILD(this)->fops->finodelk, + volume, fd, cmd, lock, xdata); + return 0; } -int32_t -error_gen_lk_cbk (call_frame_t *frame, - void *cookie, - xlator_t *this, - int32_t op_ret, - int32_t op_errno, - struct flock *lock) +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, dict_t *xdata) { - STACK_UNWIND (frame, - op_ret, - op_errno, - lock); - return 0; + int op_errno = 0; + eg_t *egp = NULL; + int enable = 1; + + egp = this->private; + enable = egp->enable[GF_FOP_ENTRYLK]; + + if (enable) + 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, xdata); + return 0; + } + + STACK_WIND_TAIL(frame, FIRST_CHILD(this), FIRST_CHILD(this)->fops->entrylk, + volume, loc, basename, cmd, type, xdata); + return 0; } -int32_t -error_gen_lk (call_frame_t *frame, - xlator_t *this, - fd_t *fd, - int32_t cmd, - struct flock *lock) +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, dict_t *xdata) { - int op_errno = 0; - op_errno = error_gen(this); - if (op_errno) { - GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno)); - STACK_UNWIND (frame, -1, op_errno, NULL); - return 0; - } - - STACK_WIND (frame, - error_gen_lk_cbk, - FIRST_CHILD(this), - FIRST_CHILD(this)->fops->lk, - fd, - cmd, - lock); - return 0; -} + int op_errno = 0; + eg_t *egp = NULL; + int enable = 1; + egp = this->private; + enable = egp->enable[GF_FOP_FENTRYLK]; -int32_t -error_gen_inodelk_cbk (call_frame_t *frame, void *cookie, - xlator_t *this, int32_t op_ret, int32_t op_errno) + if (enable) + op_errno = error_gen(this, GF_FOP_FENTRYLK); -{ - STACK_UNWIND (frame, op_ret, op_errno); - return 0; -} + if (op_errno) { + GF_ERROR(this, "unwind(-1, %s)", strerror(op_errno)); + STACK_UNWIND_STRICT(fentrylk, frame, -1, op_errno, xdata); + return 0; + } + STACK_WIND_TAIL(frame, FIRST_CHILD(this), FIRST_CHILD(this)->fops->fentrylk, + volume, fd, basename, cmd, type, xdata); + return 0; +} -int32_t -error_gen_inodelk (call_frame_t *frame, xlator_t *this, - const char *volume, loc_t *loc, int32_t cmd, - struct flock *lock) +int +error_gen_getspec(call_frame_t *frame, xlator_t *this, const char *key, + int32_t flags) { - int op_errno = 0; - op_errno = error_gen(this); - if (op_errno) { - GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno)); - STACK_UNWIND (frame, -1, op_errno); - return 0; - } - - STACK_WIND (frame, - error_gen_inodelk_cbk, - FIRST_CHILD(this), - FIRST_CHILD(this)->fops->inodelk, - volume, loc, cmd, lock); - return 0; -} + int op_errno = 0; + eg_t *egp = NULL; + int enable = 1; + egp = this->private; + enable = egp->enable[GF_FOP_GETSPEC]; -int32_t -error_gen_finodelk_cbk (call_frame_t *frame, void *cookie, - xlator_t *this, int32_t op_ret, int32_t op_errno) + if (enable) + op_errno = error_gen(this, GF_FOP_GETSPEC); -{ - STACK_UNWIND (frame, op_ret, op_errno); - return 0; -} + if (op_errno) { + GF_ERROR(this, "unwind(-1, %s)", strerror(op_errno)); + STACK_UNWIND_STRICT(getspec, frame, -1, op_errno, NULL); + return 0; + } + STACK_WIND_TAIL(frame, FIRST_CHILD(this), FIRST_CHILD(this)->fops->getspec, + key, flags); + return 0; +} -int32_t -error_gen_finodelk (call_frame_t *frame, xlator_t *this, - const char *volume, fd_t *fd, int32_t cmd, - struct flock *lock) +int +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; - op_errno = error_gen(this); - if (op_errno) { - GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno)); - STACK_UNWIND (frame, -1, op_errno); - return 0; - } - - STACK_WIND (frame, - error_gen_finodelk_cbk, - FIRST_CHILD(this), - FIRST_CHILD(this)->fops->finodelk, - volume, fd, cmd, lock); - return 0; -} + int op_errno = 0; + eg_t *egp = NULL; + int enable = 1; + egp = this->private; + enable = egp->enable[GF_FOP_READDIR]; -int32_t -error_gen_entrylk_cbk (call_frame_t *frame, void *cookie, - xlator_t *this, int32_t op_ret, int32_t op_errno) + if (enable) + op_errno = error_gen(this, GF_FOP_READDIR); -{ - STACK_UNWIND (frame, op_ret, op_errno); - return 0; + if (op_errno) { + GF_ERROR(this, "unwind(-1, %s)", strerror(op_errno)); + STACK_UNWIND_STRICT(readdir, frame, -1, op_errno, NULL, xdata); + return 0; + } + + STACK_WIND_TAIL(frame, FIRST_CHILD(this), FIRST_CHILD(this)->fops->readdir, + fd, size, off, xdata); + return 0; } -int32_t -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) +int +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; - op_errno = error_gen(this); - if (op_errno) { - GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno)); - STACK_UNWIND (frame, -1, op_errno); - return 0; - } - - STACK_WIND (frame, error_gen_entrylk_cbk, - FIRST_CHILD(this), - FIRST_CHILD(this)->fops->entrylk, - volume, loc, basename, cmd, type); - return 0; -} + int op_errno = 0; + eg_t *egp = NULL; + int enable = 1; -int32_t -error_gen_fentrylk_cbk (call_frame_t *frame, void *cookie, - xlator_t *this, int32_t op_ret, int32_t op_errno) + egp = this->private; + enable = egp->enable[GF_FOP_READDIRP]; -{ - STACK_UNWIND (frame, op_ret, op_errno); - return 0; + if (enable) + op_errno = error_gen(this, GF_FOP_READDIRP); + + if (op_errno) { + GF_ERROR(this, "unwind(-1, %s)", strerror(op_errno)); + STACK_UNWIND_STRICT(readdirp, frame, -1, op_errno, NULL, NULL); + return 0; + } + + STACK_WIND_TAIL(frame, FIRST_CHILD(this), FIRST_CHILD(this)->fops->readdirp, + fd, size, off, dict); + return 0; } -int32_t -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) +static void +error_gen_set_failure(eg_t *pvt, double percent) { - int op_errno = 0; - op_errno = error_gen(this); - if (op_errno) { - GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno)); - STACK_UNWIND (frame, -1, op_errno); - return 0; - } - - STACK_WIND (frame, error_gen_fentrylk_cbk, - FIRST_CHILD(this), - FIRST_CHILD(this)->fops->fentrylk, - volume, fd, basename, cmd, type); - return 0; -} + double ppm; + GF_ASSERT(pvt); -/* Management operations */ + ppm = (percent / 100.0) * (double)FAILURE_GRANULARITY; + pvt->failure_iter_no = (int)ppm; +} -int32_t -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) +static void +error_gen_parse_fill_fops(eg_t *pvt, char *enable_fops) { - STACK_UNWIND (frame, - op_ret, - op_errno, - stats); - return 0; -} + 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); -int32_t -error_gen_stats (call_frame_t *frame, - xlator_t *this, - int32_t flags) -{ - int op_errno = 0; - op_errno = error_gen(this); - if (op_errno) { - GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno)); - STACK_UNWIND (frame, -1, op_errno, NULL); - return 0; - } - - STACK_WIND (frame, - error_gen_stats_cbk, - FIRST_CHILD(this), - FIRST_CHILD(this)->mops->stats, - flags); - return 0; -} + 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 = gf_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_getspec_cbk (call_frame_t *frame, - void *cookie, - xlator_t *this, - int32_t op_ret, - int32_t op_errno, - char *spec_data) +error_gen_priv_dump(xlator_t *this) { - STACK_UNWIND (frame, - op_ret, - op_errno, - spec_data); - return 0; -} + char key_prefix[GF_DUMP_MAX_BUF_LEN]; + int ret = -1; + eg_t *conf = NULL; + if (!this) + goto out; -int32_t -error_gen_getspec (call_frame_t *frame, - xlator_t *this, - const char *key, - int32_t flags) -{ - int op_errno = 0; - op_errno = error_gen(this); - if (op_errno) { - GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno)); - STACK_UNWIND (frame, -1, op_errno, NULL); - return 0; - } - - STACK_WIND (frame, - error_gen_getspec_cbk, - FIRST_CHILD(this), - FIRST_CHILD(this)->mops->getspec, - key, flags); - return 0; -} + conf = this->private; + if (!conf) + goto out; + ret = TRY_LOCK(&conf->lock); + if (ret != 0) { + return ret; + } -int32_t -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) -{ - STACK_UNWIND (frame, - op_ret, - op_errno, - file_checksum, - dir_checksum); - 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", "%d", conf->error_no_int); + gf_proc_dump_write("random_failure", "%d", conf->random_failure); -int32_t -error_gen_checksum (call_frame_t *frame, - xlator_t *this, - loc_t *loc, - int32_t flag) -{ - int op_errno = 0; - op_errno = error_gen(this); - if (op_errno) { - GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno)); - STACK_UNWIND (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); - return 0; + UNLOCK(&conf->lock); +out: + return ret; } int32_t -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) +mem_acct_init(xlator_t *this) { - STACK_UNWIND (frame, op_ret, op_errno, entries); - return 0; -} + int ret = -1; + if (!this) + return ret; -int32_t -error_gen_readdir (call_frame_t *frame, - xlator_t *this, - fd_t *fd, - size_t size, - off_t off) -{ - int op_errno = 0; - op_errno = error_gen(this); - if (op_errno) { - GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno)); - STACK_UNWIND (frame, -1, op_errno, NULL); - return 0; - } - - STACK_WIND (frame, - error_gen_readdir_cbk, - FIRST_CHILD(this), - FIRST_CHILD(this)->fops->readdir, - fd, size, off); - return 0; -} + ret = xlator_mem_acct_init(this, gf_error_gen_mt_end + 1); -int32_t -error_gen_closedir (xlator_t *this, - fd_t *fd) -{ - return 0; + if (ret != 0) { + gf_log(this->name, GF_LOG_ERROR, + "Memory accounting init" + " failed"); + return ret; + } + + return ret; } -int32_t -error_gen_close (xlator_t *this, - fd_t *fd) +int +reconfigure(xlator_t *this, dict_t *options) { - return 0; + eg_t *pvt = NULL; + int32_t ret = 0; + char *error_enable_fops = NULL; + char *error_no = NULL; + double failure_percent_dbl = 0.0; + + if (!this || !this->private) + goto out; + + pvt = this->private; + + ret = -1; + + GF_OPTION_RECONF("error-no", error_no, options, str, out); + + if (error_no) + pvt->error_no_int = conv_errno_to_int(&error_no); + + GF_OPTION_RECONF("failure", failure_percent_dbl, options, percent, 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_dbl); + + ret = 0; +out: + gf_log(this ? this->name : "error-gen", GF_LOG_DEBUG, + "reconfigure returning %d", ret); + return ret; } int -init (xlator_t *this) +init(xlator_t *this) { - eg_t *pvt = NULL; - - if (!this->children || this->children->next) { - gf_log (this->name, GF_LOG_ERROR, - "error-gen not configured with one subvolume"); - return -1; - } - - if (!this->parents) { - gf_log (this->name, GF_LOG_WARNING, - "dangling volume. check volfile "); - } - - pvt = CALLOC (1, sizeof (eg_t)); - this->private = pvt; - return 0; + eg_t *pvt = NULL; + int32_t ret = 0; + char *error_enable_fops = NULL; + char *error_no = NULL; + double failure_percent_dbl = 0.0; + + if (!this->children || this->children->next) { + gf_log(this->name, GF_LOG_ERROR, + "error-gen not configured with one subvolume"); + ret = -1; + goto out; + } + + if (!this->parents) { + gf_log(this->name, GF_LOG_WARNING, "dangling volume. check volfile "); + } + + pvt = GF_CALLOC(1, sizeof(eg_t), gf_error_gen_mt_eg_t); + + if (!pvt) { + ret = -1; + goto out; + } + + LOCK_INIT(&pvt->lock); + + ret = -1; + + GF_OPTION_INIT("error-no", error_no, str, out); + + if (error_no) + pvt->error_no_int = conv_errno_to_int(&error_no); + + GF_OPTION_INIT("failure", failure_percent_dbl, percent, 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_dbl); + + this->private = pvt; + + /* Give some seed value here. */ + srand(gf_time()); + + ret = 0; +out: + if (ret) + GF_FREE(pvt); + return ret; } void -fini (xlator_t *this) +fini(xlator_t *this) { - gf_log (this->name, GF_LOG_DEBUG, "fini called"); - return; + eg_t *pvt = NULL; + + if (!this) + return; + pvt = this->private; + + if (pvt) { + LOCK_DESTROY(&pvt->lock); + GF_FREE(pvt); + gf_log(this->name, GF_LOG_DEBUG, "fini called"); + } + return; } +struct xlator_dumpops dumpops = { + .priv = error_gen_priv_dump, +}; + +struct xlator_cbks cbks; struct xlator_fops fops = { - .lookup = error_gen_lookup, - .stat = error_gen_stat, - .readlink = error_gen_readlink, - .mknod = error_gen_mknod, - .mkdir = error_gen_mkdir, - .unlink = error_gen_unlink, - .rmdir = error_gen_rmdir, - .symlink = error_gen_symlink, - .rename = error_gen_rename, - .link = error_gen_link, - .chmod = error_gen_chmod, - .chown = error_gen_chown, - .truncate = error_gen_truncate, - .utimens = error_gen_utimens, - .create = error_gen_create, - .open = error_gen_open, - .readv = error_gen_readv, - .writev = error_gen_writev, - .statfs = error_gen_statfs, - .flush = error_gen_flush, - .fsync = error_gen_fsync, - .setxattr = error_gen_setxattr, - .getxattr = error_gen_getxattr, - .removexattr = error_gen_removexattr, - .opendir = error_gen_opendir, - .readdir = error_gen_readdir, - .getdents = error_gen_getdents, - .fsyncdir = error_gen_fsyncdir, - .access = error_gen_access, - .ftruncate = error_gen_ftruncate, - .fstat = error_gen_fstat, - .lk = error_gen_lk, - .fchmod = error_gen_fchmod, - .fchown = error_gen_fchown, - .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, - .finodelk = error_gen_finodelk, - .entrylk = error_gen_entrylk, - .fentrylk = error_gen_fentrylk + .lookup = error_gen_lookup, + .stat = error_gen_stat, + .readlink = error_gen_readlink, + .mknod = error_gen_mknod, + .mkdir = error_gen_mkdir, + .unlink = error_gen_unlink, + .rmdir = error_gen_rmdir, + .symlink = error_gen_symlink, + .rename = error_gen_rename, + .link = error_gen_link, + .truncate = error_gen_truncate, + .create = error_gen_create, + .open = error_gen_open, + .readv = error_gen_readv, + .writev = error_gen_writev, + .statfs = error_gen_statfs, + .flush = error_gen_flush, + .fsync = error_gen_fsync, + .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, + .fsyncdir = error_gen_fsyncdir, + .access = error_gen_access, + .ftruncate = error_gen_ftruncate, + .fstat = error_gen_fstat, + .lk = error_gen_lk, + .xattrop = error_gen_xattrop, + .fxattrop = error_gen_fxattrop, + .inodelk = error_gen_inodelk, + .finodelk = error_gen_finodelk, + .entrylk = error_gen_entrylk, + .fentrylk = error_gen_fentrylk, + .setattr = error_gen_setattr, + .fsetattr = error_gen_fsetattr, + .getspec = error_gen_getspec, }; -struct xlator_mops mops = { - .stats = error_gen_stats, - .getspec = error_gen_getspec, +struct volume_options options[] = { + { + .key = {"failure"}, + .type = GF_OPTION_TYPE_PERCENT, + .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", + "GF_ERROR_SHORT_WRITE"}, + .type = GF_OPTION_TYPE_STR, + .op_version = {3}, + .tags = {"error-gen"}, + .flags = OPT_FLAG_SETTABLE, + + }, + + { + .key = {"random-failure"}, + .type = GF_OPTION_TYPE_BOOL, + .default_value = "off", + .op_version = {3}, + .tags = {"error-gen"}, + .flags = OPT_FLAG_SETTABLE, + }, + + { + .key = {"enable", "error-fops"}, + .type = GF_OPTION_TYPE_STR, + .description = "Accepts a string which takes ',' separated fop " + "strings to denote which fops are enabled for error", + .op_version = {3}, + .tags = {"error-gen"}, + .flags = OPT_FLAG_SETTABLE, + }, + + {.key = {NULL}}, }; -struct xlator_cbks cbks = { - .release = error_gen_close, - .releasedir = error_gen_closedir, +xlator_api_t xlator_api = { + .init = init, + .fini = fini, + .reconfigure = reconfigure, + .mem_acct_init = mem_acct_init, + .op_version = {1}, + .dumpops = &dumpops, + .fops = &fops, + .cbks = &cbks, + .options = options, + .identifier = "error-gen", + .category = GF_TECH_PREVIEW, }; diff --git a/xlators/debug/error-gen/src/error-gen.h b/xlators/debug/error-gen/src/error-gen.h new file mode 100644 index 00000000000..2478cd5b21c --- /dev/null +++ b/xlators/debug/error-gen/src/error-gen.h @@ -0,0 +1,49 @@ +/* + 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 _ERROR_GEN_H +#define _ERROR_GEN_H + +#include "error-gen-mem-types.h" + +#define GF_FAILURE_DEFAULT 10 + +/* + * Pseudo-errors refer to errors beyond the scope of traditional <-1, op_errno> + * returns. This facilitates the ability to return unexpected, but not -1 values + * and/or to inject operations that lead to implicit error conditions. The range + * for pseudo errors resides at a high value to avoid conflicts with the errno + * range. + */ +enum GF_PSEUDO_ERRORS { + GF_ERROR_SHORT_WRITE = 1000, /* short writev return value */ + GF_ERROR_MAX +}; + +typedef struct { + int enable[GF_FOP_MAXVALUE]; + int op_count; + /* + * This is only an iteration number in the random-failure case. For + * the normal controlled-probability case, it's actually a numerator + * for the failure probability (see FAILURE_GRANULARITY declaration). + * It's just not worth blowing up the diff by changing it. + */ + int failure_iter_no; + int error_no_int; + gf_boolean_t random_failure; + gf_lock_t lock; +} eg_t; + +typedef struct { + int error_no_count; + int error_no[20]; +} sys_error_t; + +#endif |