diff options
Diffstat (limited to 'xlators/debug/error-gen/src/error-gen.c')
| -rw-r--r-- | xlators/debug/error-gen/src/error-gen.c | 2534 |
1 files changed, 1231 insertions, 1303 deletions
diff --git a/xlators/debug/error-gen/src/error-gen.c b/xlators/debug/error-gen/src/error-gen.c index eeb7b3d0953..c6595b4c0e4 100644 --- a/xlators/debug/error-gen/src/error-gen.c +++ b/xlators/debug/error-gen/src/error-gen.c @@ -26,1694 +26,1622 @@ * something completely different and this number is irrelevant. See error_gen * for the legacy code.) */ -#define FAILURE_GRANULARITY (1 << 20) +#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 = 7, - .error_no = {EACCES,EBADF,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 = 10, - .error_no = {EACCES,EBADF,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 = 4, - .error_no = {EACCES,EBADF,EINTR, - ENAMETOOLONG}}, - [GF_FOP_GETXATTR] = { .error_no_count = 4, - .error_no = {EACCES,EBADF,ENAMETOOLONG, - EINTR}}, - [GF_FOP_REMOVEXATTR] = { .error_no_count = 4, - .error_no = {EACCES,EBADF,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 = 4, - .error_no = {EACCES,EBADF,EINTR, - ENAMETOOLONG}}, - [GF_FOP_FINODELK] = { .error_no_count = 4, - .error_no = {EACCES,EBADF,EINTR, - ENAMETOOLONG}}, - [GF_FOP_ENTRYLK] = { .error_no_count = 4, - .error_no = {EACCES,EBADF, - 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 = 11, - .error_no = {EACCES,EFAULT,EIO, - ENAMETOOLONG,ENOENT, - ENOMEM,ENOTDIR,EPERM, - EROFS,EBADF,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 = 4, - .error_no = {EACCES,EBADF,ENAMETOOLONG, - EINTR}} -}; + [GF_FOP_LOOKUP] = {.error_no_count = 4, + .error_no = {ENOENT, ENOTDIR, ENAMETOOLONG, EAGAIN}}, + [GF_FOP_STAT] = {.error_no_count = 7, + .error_no = {EACCES, EBADF, 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 = 10, + .error_no = {EACCES, EBADF, 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 = 4, + .error_no = {EACCES, EBADF, EINTR, ENAMETOOLONG}}, + [GF_FOP_GETXATTR] = {.error_no_count = 4, + .error_no = {EACCES, EBADF, ENAMETOOLONG, EINTR}}, + [GF_FOP_REMOVEXATTR] = {.error_no_count = 4, + .error_no = {EACCES, EBADF, 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 = 4, + .error_no = {EACCES, EBADF, EINTR, ENAMETOOLONG}}, + [GF_FOP_FINODELK] = {.error_no_count = 4, + .error_no = {EACCES, EBADF, EINTR, ENAMETOOLONG}}, + [GF_FOP_ENTRYLK] = {.error_no_count = 4, + .error_no = {EACCES, EBADF, 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 = 11, + .error_no = {EACCES, EFAULT, EIO, ENAMETOOLONG, ENOENT, + ENOMEM, ENOTDIR, EPERM, EROFS, EBADF, + 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 = 4, + .error_no = {EACCES, EBADF, ENAMETOOLONG, EINTR}}}; int -generate_rand_no (int op_no) +generate_rand_no(int op_no) { - int rand_no = 0; - int error_no_list_size = 0; + int rand_no = 0; + int error_no_list_size = 0; - error_no_list_size = sizeof(error_no_list)/sizeof(error_no_list[0]); + error_no_list_size = sizeof(error_no_list) / sizeof(error_no_list[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; + 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; } int -conv_errno_to_int (char **error_no) +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; + 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; } int -error_gen (xlator_t *this, int op_no) +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; - } + 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; + } } - - 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]; - } + 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; + return ret; } int -error_gen_lookup (call_frame_t *frame, xlator_t *this, loc_t *loc, - dict_t *xdata) +error_gen_lookup(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[GF_FOP_LOOKUP]; - - if (enable) - op_errno = error_gen (this, GF_FOP_LOOKUP); - - 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); + int op_errno = 0; + eg_t *egp = NULL; + int enable = 1; + + egp = this->private; + enable = egp->enable[GF_FOP_LOOKUP]; + + if (enable) + op_errno = error_gen(this, GF_FOP_LOOKUP); + + 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; } int -error_gen_stat (call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *xdata) +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[GF_FOP_STAT]; + int op_errno = 0; + eg_t *egp = NULL; + int enable = 1; - if (enable) - op_errno = error_gen (this, GF_FOP_STAT); + egp = this->private; + enable = egp->enable[GF_FOP_STAT]; - if (op_errno) { - GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno)); - STACK_UNWIND_STRICT (stat, frame, -1, op_errno, NULL, xdata); - return 0; - } + if (enable) + op_errno = error_gen(this, GF_FOP_STAT); - STACK_WIND_TAIL (frame, FIRST_CHILD(this), - FIRST_CHILD(this)->fops->stat, loc, xdata); + if (op_errno) { + GF_ERROR(this, "unwind(-1, %s)", strerror(op_errno)); + STACK_UNWIND_STRICT(stat, frame, -1, op_errno, NULL, xdata); return 0; + } + + STACK_WIND_TAIL(frame, FIRST_CHILD(this), FIRST_CHILD(this)->fops->stat, + loc, xdata); + return 0; } int -error_gen_setattr (call_frame_t *frame, xlator_t *this, loc_t *loc, - struct iatt *stbuf, int32_t valid, dict_t *xdata) +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; - eg_t *egp = NULL; - int enable = 1; - - egp = this->private; - enable = egp->enable[GF_FOP_SETATTR]; + int op_errno = 0; + eg_t *egp = NULL; + int enable = 1; - if (enable) - op_errno = error_gen (this, GF_FOP_SETATTR); + egp = this->private; + enable = egp->enable[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, xdata); - return 0; - } + if (enable) + op_errno = error_gen(this, GF_FOP_SETATTR); - STACK_WIND_TAIL (frame, FIRST_CHILD(this), - FIRST_CHILD(this)->fops->setattr, - loc, stbuf, valid, xdata); + 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; -} + } + STACK_WIND_TAIL(frame, FIRST_CHILD(this), FIRST_CHILD(this)->fops->setattr, + loc, stbuf, valid, xdata); + return 0; +} int -error_gen_fsetattr (call_frame_t *frame, xlator_t *this, fd_t *fd, - struct iatt *stbuf, int32_t valid, dict_t *xdata) +error_gen_fsetattr(call_frame_t *frame, xlator_t *this, fd_t *fd, + 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[GF_FOP_FSETATTR]; + int op_errno = 0; + eg_t *egp = NULL; + int enable = 1; - if (enable) - op_errno = error_gen (this, GF_FOP_FSETATTR); + egp = this->private; + enable = egp->enable[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; - } + if (enable) + op_errno = error_gen(this, GF_FOP_FSETATTR); - STACK_WIND_TAIL (frame, FIRST_CHILD(this), - FIRST_CHILD(this)->fops->fsetattr, - fd, stbuf, valid, xdata); + 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; + } + + STACK_WIND_TAIL(frame, FIRST_CHILD(this), FIRST_CHILD(this)->fops->fsetattr, + fd, stbuf, valid, xdata); + return 0; } int -error_gen_truncate (call_frame_t *frame, xlator_t *this, loc_t *loc, - off_t offset, dict_t *xdata) +error_gen_truncate(call_frame_t *frame, xlator_t *this, loc_t *loc, + off_t offset, dict_t *xdata) { - int op_errno = 0; - eg_t *egp = NULL; - int enable = 1; - - egp = this->private; - enable = egp->enable[GF_FOP_TRUNCATE]; - - if (enable) - 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, xdata); - return 0; - } - - STACK_WIND_TAIL (frame, FIRST_CHILD(this), - FIRST_CHILD(this)->fops->truncate, - loc, offset, xdata); + int op_errno = 0; + eg_t *egp = NULL; + int enable = 1; + + egp = this->private; + enable = egp->enable[GF_FOP_TRUNCATE]; + + if (enable) + 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, xdata); return 0; + } + + STACK_WIND_TAIL(frame, FIRST_CHILD(this), FIRST_CHILD(this)->fops->truncate, + loc, offset, xdata); + return 0; } int -error_gen_ftruncate (call_frame_t *frame, xlator_t *this, fd_t *fd, - off_t offset, dict_t *xdata) +error_gen_ftruncate(call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset, + dict_t *xdata) { - int op_errno = 0; - eg_t *egp =NULL; - int enable = 1; - - egp = this->private; - enable = egp->enable[GF_FOP_FTRUNCATE]; - - if (enable) - 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, xdata); - return 0; - } - - STACK_WIND_TAIL (frame, FIRST_CHILD(this), - FIRST_CHILD(this)->fops->ftruncate, - fd, offset, xdata); + int op_errno = 0; + eg_t *egp = NULL; + int enable = 1; + + egp = this->private; + enable = egp->enable[GF_FOP_FTRUNCATE]; + + if (enable) + 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, xdata); return 0; + } + + STACK_WIND_TAIL(frame, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->ftruncate, fd, offset, xdata); + return 0; } int -error_gen_access (call_frame_t *frame, xlator_t *this, loc_t *loc, - int32_t mask, dict_t *xdata) +error_gen_access(call_frame_t *frame, xlator_t *this, loc_t *loc, int32_t mask, + dict_t *xdata) { - int op_errno = 0; - eg_t *egp = NULL; - int enable = 1; + int op_errno = 0; + eg_t *egp = NULL; + int enable = 1; - egp = this->private; - enable = egp->enable[GF_FOP_ACCESS]; + egp = this->private; + enable = egp->enable[GF_FOP_ACCESS]; - if (enable) - op_errno = error_gen (this, GF_FOP_ACCESS); + if (enable) + 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, xdata); - return 0; - } - - STACK_WIND_TAIL (frame, FIRST_CHILD(this), - FIRST_CHILD(this)->fops->access, - loc, mask, xdata); + 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; } int -error_gen_readlink (call_frame_t *frame, xlator_t *this, loc_t *loc, - size_t size, dict_t *xdata) +error_gen_readlink(call_frame_t *frame, xlator_t *this, loc_t *loc, size_t size, + dict_t *xdata) { - int op_errno = 0; - eg_t *egp = NULL; - int enable = 1; - - egp = this->private; - enable = egp->enable[GF_FOP_READLINK]; + int op_errno = 0; + eg_t *egp = NULL; + int enable = 1; - if (enable) - op_errno = error_gen (this, GF_FOP_READLINK); + egp = this->private; + enable = egp->enable[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; - } + if (enable) + op_errno = error_gen(this, GF_FOP_READLINK); - STACK_WIND_TAIL (frame, FIRST_CHILD(this), - FIRST_CHILD(this)->fops->readlink, - loc, size, xdata); + 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; } 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) +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; - eg_t *egp = NULL; - int enable = 1; - - egp = this->private; - enable = egp->enable[GF_FOP_MKNOD]; - - 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); + int op_errno = 0; + eg_t *egp = NULL; + int enable = 1; + + egp = this->private; + enable = egp->enable[GF_FOP_MKNOD]; + + 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; } int -error_gen_mkdir (call_frame_t *frame, xlator_t *this, - loc_t *loc, mode_t mode, mode_t umask, dict_t *xdata) +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; - eg_t *egp = NULL; - int enable = 1; - - egp = this->private; - enable = egp->enable[GF_FOP_MKDIR]; - - 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); + int op_errno = 0; + eg_t *egp = NULL; + int enable = 1; + + egp = this->private; + enable = egp->enable[GF_FOP_MKDIR]; + + 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; } int -error_gen_unlink (call_frame_t *frame, xlator_t *this, loc_t *loc, int xflag, - dict_t *xdata) +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[GF_FOP_UNLINK]; - - if (enable) - 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, - xdata); - return 0; - } - - STACK_WIND_TAIL (frame, FIRST_CHILD(this), - FIRST_CHILD(this)->fops->unlink, - loc, xflag, xdata); + int op_errno = 0; + eg_t *egp = NULL; + int enable = 1; + + egp = this->private; + enable = egp->enable[GF_FOP_UNLINK]; + + if (enable) + 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, xdata); return 0; + } + + STACK_WIND_TAIL(frame, FIRST_CHILD(this), FIRST_CHILD(this)->fops->unlink, + loc, xflag, xdata); + return 0; } int -error_gen_rmdir (call_frame_t *frame, xlator_t *this, loc_t *loc, int flags, - dict_t *xdata) +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; + int op_errno = 0; + eg_t *egp = NULL; + int enable = 1; - egp = this->private; - enable = egp->enable[GF_FOP_RMDIR]; + egp = this->private; + enable = egp->enable[GF_FOP_RMDIR]; - if (enable) - op_errno = error_gen (this, 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); + 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; } int -error_gen_symlink (call_frame_t *frame, xlator_t *this, const char *linkpath, - loc_t *loc, mode_t umask, dict_t *xdata) +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; - 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); + 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; } int -error_gen_rename (call_frame_t *frame, xlator_t *this, - loc_t *oldloc, loc_t *newloc, dict_t *xdata) +error_gen_rename(call_frame_t *frame, xlator_t *this, 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[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); + 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; } int -error_gen_link (call_frame_t *frame, xlator_t *this, - loc_t *oldloc, loc_t *newloc, dict_t *xdata) +error_gen_link(call_frame_t *frame, xlator_t *this, 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[GF_FOP_LINK]; - - 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); + int op_errno = 0; + eg_t *egp = NULL; + int enable = 1; + + egp = this->private; + enable = egp->enable[GF_FOP_LINK]; + + 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; } 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) +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; - 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); + 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; } int -error_gen_open (call_frame_t *frame, xlator_t *this, loc_t *loc, - int32_t flags, fd_t *fd, dict_t *xdata) +error_gen_open(call_frame_t *frame, xlator_t *this, loc_t *loc, 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[GF_FOP_OPEN]; + int op_errno = 0; + eg_t *egp = NULL; + int enable = 1; - if (enable) - op_errno = error_gen (this, GF_FOP_OPEN); + egp = this->private; + enable = egp->enable[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; - } + if (enable) + op_errno = error_gen(this, GF_FOP_OPEN); - STACK_WIND_TAIL (frame, FIRST_CHILD(this), - FIRST_CHILD(this)->fops->open, - loc, flags, fd, xdata); + 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; } 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) +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; - eg_t *egp = NULL; - int enable = 1; - - egp = this->private; - enable = egp->enable[GF_FOP_READ]; - - 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); + int op_errno = 0; + eg_t *egp = NULL; + int enable = 1; + + egp = this->private; + enable = egp->enable[GF_FOP_READ]; + + 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; } 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) +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; - 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; - } + 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; + 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); + 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; + if (shortvec) + GF_FREE(shortvec); + return 0; } int -error_gen_flush (call_frame_t *frame, xlator_t *this, fd_t *fd, dict_t *xdata) +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; + int op_errno = 0; + eg_t *egp = NULL; + int enable = 1; - egp = this->private; - enable = egp->enable[GF_FOP_FLUSH]; + egp = this->private; + enable = egp->enable[GF_FOP_FLUSH]; - if (enable) - op_errno = error_gen (this, 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); + 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; } int -error_gen_fsync (call_frame_t *frame, xlator_t *this, fd_t *fd, int32_t flags, dict_t *xdata) +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[GF_FOP_FSYNC]; + int op_errno = 0; + eg_t *egp = NULL; + int enable = 1; - if (enable) - op_errno = error_gen (this, GF_FOP_FSYNC); + egp = this->private; + enable = egp->enable[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; - } + if (enable) + op_errno = error_gen(this, GF_FOP_FSYNC); - STACK_WIND_TAIL (frame, FIRST_CHILD(this), - FIRST_CHILD(this)->fops->fsync, - fd, flags, xdata); + 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; } int -error_gen_fstat (call_frame_t *frame, xlator_t *this, fd_t *fd, dict_t *xdata) +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[GF_FOP_FSTAT]; + int op_errno = 0; + eg_t *egp = NULL; + int enable = 1; - if (enable) - op_errno = error_gen (this, GF_FOP_FSTAT); + egp = this->private; + enable = egp->enable[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; - } + if (enable) + op_errno = error_gen(this, GF_FOP_FSTAT); - STACK_WIND_TAIL (frame, FIRST_CHILD(this), - FIRST_CHILD(this)->fops->fstat, - fd, xdata); + 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; } int -error_gen_opendir (call_frame_t *frame, xlator_t *this, loc_t *loc, fd_t *fd, dict_t *xdata) +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[GF_FOP_OPENDIR]; + int op_errno = 0; + eg_t *egp = NULL; + int enable = 1; - if (enable) - op_errno = error_gen (this, GF_FOP_OPENDIR); + egp = this->private; + enable = egp->enable[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; - } + if (enable) + op_errno = error_gen(this, GF_FOP_OPENDIR); - STACK_WIND_TAIL (frame, FIRST_CHILD(this), - FIRST_CHILD(this)->fops->opendir, - loc, fd, xdata); + 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; } int -error_gen_fsyncdir (call_frame_t *frame, xlator_t *this, fd_t *fd, - int32_t flags, dict_t *xdata) +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; + int op_errno = 0; + eg_t *egp = NULL; + int enable = 1; - egp = this->private; - enable = egp->enable[GF_FOP_FSYNCDIR]; + egp = this->private; + enable = egp->enable[GF_FOP_FSYNCDIR]; - if (enable) - op_errno = error_gen (this, GF_FOP_FSYNCDIR); + 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); + 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; } int -error_gen_statfs (call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *xdata) +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[GF_FOP_STATFS]; + int op_errno = 0; + eg_t *egp = NULL; + int enable = 1; - if (enable) - op_errno = error_gen (this, GF_FOP_STATFS); + egp = this->private; + enable = egp->enable[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; - } + if (enable) + op_errno = error_gen(this, GF_FOP_STATFS); - STACK_WIND_TAIL (frame, FIRST_CHILD(this), - FIRST_CHILD(this)->fops->statfs, - loc, xdata); + 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; } int -error_gen_setxattr (call_frame_t *frame, xlator_t *this, loc_t *loc, - dict_t *dict, int32_t flags, dict_t *xdata) +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[GF_FOP_SETXATTR]; + int op_errno = 0; + eg_t *egp = NULL; + int enable = 1; - if (enable) - op_errno = error_gen (this, GF_FOP_SETXATTR); + egp = this->private; + enable = egp->enable[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; - } + if (enable) + op_errno = error_gen(this, GF_FOP_SETXATTR); - STACK_WIND_TAIL (frame, FIRST_CHILD(this), - FIRST_CHILD(this)->fops->setxattr, - loc, dict, flags, xdata); + 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; } int -error_gen_getxattr (call_frame_t *frame, xlator_t *this, loc_t *loc, - const char *name, dict_t *xdata) +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[GF_FOP_GETXATTR]; + int op_errno = 0; + eg_t *egp = NULL; + int enable = 1; - if (enable) - op_errno = error_gen (this, GF_FOP_GETXATTR); + egp = this->private; + enable = egp->enable[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; - } + if (enable) + op_errno = error_gen(this, GF_FOP_GETXATTR); - STACK_WIND_TAIL (frame, FIRST_CHILD(this), - FIRST_CHILD(this)->fops->getxattr, - loc, name, xdata); + 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; } int -error_gen_fsetxattr (call_frame_t *frame, xlator_t *this, fd_t *fd, - dict_t *dict, int32_t flags, dict_t *xdata) +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; + int op_errno = 0; + eg_t *egp = NULL; + int enable = 1; - egp = this->private; - enable = egp->enable[GF_FOP_FSETXATTR]; + egp = this->private; + enable = egp->enable[GF_FOP_FSETXATTR]; - if (enable) - op_errno = error_gen (this, 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); + 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; } int -error_gen_fgetxattr (call_frame_t *frame, xlator_t *this, fd_t *fd, - const char *name, dict_t *xdata) +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[GF_FOP_FGETXATTR]; + int op_errno = 0; + eg_t *egp = NULL; + int enable = 1; - if (enable) - op_errno = error_gen (this, GF_FOP_FGETXATTR); + egp = this->private; + enable = egp->enable[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; - } + if (enable) + op_errno = error_gen(this, GF_FOP_FGETXATTR); - STACK_WIND_TAIL (frame, FIRST_CHILD(this), - FIRST_CHILD(this)->fops->fgetxattr, - fd, name, xdata); + 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; } 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) +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; - eg_t *egp = NULL; - int enable = 1; - - egp = this->private; - enable = egp->enable[GF_FOP_XATTROP]; + int op_errno = 0; + eg_t *egp = NULL; + int enable = 1; - if (enable) - op_errno = error_gen (this, GF_FOP_XATTROP); + egp = this->private; + enable = egp->enable[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; - } + if (enable) + op_errno = error_gen(this, GF_FOP_XATTROP); - STACK_WIND_TAIL (frame, FIRST_CHILD(this), - FIRST_CHILD(this)->fops->xattrop, - loc, flags, dict, xdata); + 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; } 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) +error_gen_fxattrop(call_frame_t *frame, xlator_t *this, fd_t *fd, + 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[GF_FOP_FXATTROP]; + int op_errno = 0; + eg_t *egp = NULL; + int enable = 1; - if (enable) - op_errno = error_gen (this, GF_FOP_FXATTROP); + egp = this->private; + enable = egp->enable[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; - } + if (enable) + op_errno = error_gen(this, GF_FOP_FXATTROP); - STACK_WIND_TAIL (frame, FIRST_CHILD(this), - FIRST_CHILD(this)->fops->fxattrop, - fd, flags, dict, xdata); + 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; } int -error_gen_removexattr (call_frame_t *frame, xlator_t *this, loc_t *loc, - const char *name, dict_t *xdata) +error_gen_removexattr(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[GF_FOP_REMOVEXATTR]; + int op_errno = 0; + eg_t *egp = NULL; + int enable = 1; - if (enable) - op_errno = error_gen (this, GF_FOP_REMOVEXATTR); + egp = this->private; + enable = egp->enable[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; - } + if (enable) + op_errno = error_gen(this, GF_FOP_REMOVEXATTR); - STACK_WIND_TAIL (frame, FIRST_CHILD(this), - FIRST_CHILD(this)->fops->removexattr, - loc, name, xdata); + 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; } int -error_gen_fremovexattr (call_frame_t *frame, xlator_t *this, fd_t *fd, - const char *name, dict_t *xdata) +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]; + int op_errno = 0; + eg_t *egp = NULL; + int enable = 1; - if (enable) - op_errno = error_gen (this, GF_FOP_FREMOVEXATTR); + egp = this->private; + enable = egp->enable[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; - } + if (enable) + op_errno = error_gen(this, GF_FOP_FREMOVEXATTR); - STACK_WIND_TAIL (frame, FIRST_CHILD(this), - FIRST_CHILD(this)->fops->fremovexattr, - fd, name, xdata); + 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; } int -error_gen_lk (call_frame_t *frame, xlator_t *this, fd_t *fd, int32_t cmd, - struct gf_flock *lock, dict_t *xdata) +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; - eg_t *egp = NULL; - int enable = 1; + int op_errno = 0; + eg_t *egp = NULL; + int enable = 1; - egp = this->private; - enable = egp->enable[GF_FOP_LK]; + egp = this->private; + enable = egp->enable[GF_FOP_LK]; - if (enable) - op_errno = error_gen (this, 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); + 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; } 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) +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) { - int op_errno = 0; - eg_t *egp = NULL; - int enable = 1; + int op_errno = 0; + eg_t *egp = NULL; + int enable = 1; - egp = this->private; - enable = egp->enable[GF_FOP_INODELK]; + egp = this->private; + enable = egp->enable[GF_FOP_INODELK]; - if (enable) - op_errno = error_gen (this, 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); + 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; } 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) +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; - eg_t *egp = NULL; - int enable = 1; + int op_errno = 0; + eg_t *egp = NULL; + int enable = 1; - egp = this->private; - enable = egp->enable[GF_FOP_FINODELK]; + egp = this->private; + enable = egp->enable[GF_FOP_FINODELK]; - if (enable) - op_errno = error_gen (this, 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); + 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; } 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) +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) { - int op_errno = 0; - eg_t *egp = NULL; - int enable = 1; + int op_errno = 0; + eg_t *egp = NULL; + int enable = 1; - egp = this->private; - enable = egp->enable[GF_FOP_ENTRYLK]; + egp = this->private; + enable = egp->enable[GF_FOP_ENTRYLK]; - if (enable) - op_errno = error_gen (this, 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); + 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; } 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) +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; - eg_t *egp = NULL; - int enable = 1; - - egp = this->private; - enable = egp->enable[GF_FOP_FENTRYLK]; + int op_errno = 0; + eg_t *egp = NULL; + int enable = 1; - if (enable) - op_errno = error_gen (this, GF_FOP_FENTRYLK); + egp = this->private; + enable = egp->enable[GF_FOP_FENTRYLK]; - if (op_errno) { - GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno)); - STACK_UNWIND_STRICT (fentrylk, frame, -1, op_errno, xdata); - return 0; - } + if (enable) + op_errno = error_gen(this, GF_FOP_FENTRYLK); - STACK_WIND_TAIL (frame, FIRST_CHILD(this), - FIRST_CHILD(this)->fops->fentrylk, - volume, fd, basename, cmd, type, xdata); + 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; } int -error_gen_getspec (call_frame_t *frame, xlator_t *this, const char *key, - 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[GF_FOP_GETSPEC]; - - if (enable) - op_errno = error_gen (this, GF_FOP_GETSPEC); - - 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; + int op_errno = 0; + eg_t *egp = NULL; + int enable = 1; + + egp = this->private; + enable = egp->enable[GF_FOP_GETSPEC]; + + if (enable) + op_errno = error_gen(this, GF_FOP_GETSPEC); + + 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; } int -error_gen_readdir (call_frame_t *frame, xlator_t *this, fd_t *fd, - size_t size, off_t off, dict_t *xdata) +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[GF_FOP_READDIR]; - - if (enable) - op_errno = error_gen (this, GF_FOP_READDIR); - - 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; + int op_errno = 0; + eg_t *egp = NULL; + int enable = 1; + + egp = this->private; + enable = egp->enable[GF_FOP_READDIR]; + + if (enable) + op_errno = error_gen(this, GF_FOP_READDIR); + + 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; } int -error_gen_readdirp (call_frame_t *frame, xlator_t *this, fd_t *fd, size_t size, - off_t off, dict_t *dict) +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; + int op_errno = 0; + eg_t *egp = NULL; + int enable = 1; - egp = this->private; - enable = egp->enable[GF_FOP_READDIRP]; + egp = this->private; + enable = egp->enable[GF_FOP_READDIRP]; - if (enable) - op_errno = error_gen (this, GF_FOP_READDIRP); + 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; - } + 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, + STACK_WIND_TAIL(frame, FIRST_CHILD(this), FIRST_CHILD(this)->fops->readdirp, fd, size, off, dict); - return 0; + return 0; } static void -error_gen_set_failure (eg_t *pvt, double percent) +error_gen_set_failure(eg_t *pvt, double percent) { - double ppm; + double ppm; - GF_ASSERT (pvt); + GF_ASSERT(pvt); - ppm = (percent / 100.0) * (double)FAILURE_GRANULARITY; - pvt->failure_iter_no = (int)ppm; + ppm = (percent / 100.0) * (double)FAILURE_GRANULARITY; + pvt->failure_iter_no = (int)ppm; } static void -error_gen_parse_fill_fops (eg_t *pvt, char *enable_fops) +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; + 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); + GF_ASSERT(pvt); + GF_ASSERT(this); + 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] = 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); - } + 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_priv_dump (xlator_t *this) +error_gen_priv_dump(xlator_t *this) { - char key_prefix[GF_DUMP_MAX_BUF_LEN]; - int ret = -1; - eg_t *conf = NULL; + char key_prefix[GF_DUMP_MAX_BUF_LEN]; + int ret = -1; + eg_t *conf = NULL; - if (!this) - goto out; + if (!this) + goto out; - conf = this->private; - if (!conf) - goto out; + conf = this->private; + if (!conf) + goto out; - ret = TRY_LOCK(&conf->lock); - if (ret != 0) { - return ret; - } + ret = TRY_LOCK(&conf->lock); + if (ret != 0) { + return ret; + } - 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_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); + 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); - UNLOCK(&conf->lock); + UNLOCK(&conf->lock); out: - return ret; + return ret; } int32_t -mem_acct_init (xlator_t *this) +mem_acct_init(xlator_t *this) { - int ret = -1; + int ret = -1; - if (!this) - return ret; - - ret = xlator_mem_acct_init (this, gf_error_gen_mt_end + 1); + if (!this) + return ret; - if (ret != 0) { - gf_log (this->name, GF_LOG_ERROR, "Memory accounting init" - " failed"); - return ret; - } + ret = xlator_mem_acct_init(this, gf_error_gen_mt_end + 1); + if (ret != 0) { + gf_log(this->name, GF_LOG_ERROR, + "Memory accounting init" + " failed"); return ret; + } + + return ret; } int -reconfigure (xlator_t *this, dict_t *options) +reconfigure(xlator_t *this, dict_t *options) { - eg_t *pvt = NULL; - int32_t ret = 0; - char *error_enable_fops = NULL; - double failure_percent_dbl = 0.0; + eg_t *pvt = NULL; + int32_t ret = 0; + char *error_enable_fops = NULL; + double failure_percent_dbl = 0.0; - if (!this || !this->private) - goto out; + if (!this || !this->private) + goto out; - pvt = this->private; + pvt = this->private; - ret = -1; + ret = -1; - GF_OPTION_RECONF ("error-no", pvt->error_no, options, str, out); + GF_OPTION_RECONF("error-no", pvt->error_no, options, str, out); - if (pvt->error_no) - pvt->error_no_int = conv_errno_to_int (&pvt->error_no); + if (pvt->error_no) + pvt->error_no_int = conv_errno_to_int(&pvt->error_no); - GF_OPTION_RECONF ("failure", failure_percent_dbl, options, percent, - out); + GF_OPTION_RECONF("failure", failure_percent_dbl, options, percent, out); - GF_OPTION_RECONF ("enable", error_enable_fops, options, str, out); + GF_OPTION_RECONF("enable", error_enable_fops, options, str, out); - GF_OPTION_RECONF ("random-failure", pvt->random_failure, options, - bool, 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); + error_gen_parse_fill_fops(pvt, error_enable_fops); + error_gen_set_failure(pvt, failure_percent_dbl); - ret = 0; + ret = 0; out: - gf_log (this ? this->name : "error-gen", GF_LOG_DEBUG, - "reconfigure returning %d", ret); - return ret; + 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; - int32_t ret = 0; - char *error_enable_fops = 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); + eg_t *pvt = NULL; + int32_t ret = 0; + char *error_enable_fops = 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 (!pvt) { - ret = -1; - goto out; - } + if (!this->parents) { + gf_log(this->name, GF_LOG_WARNING, "dangling volume. check volfile "); + } - LOCK_INIT (&pvt->lock); + pvt = GF_CALLOC(1, sizeof(eg_t), gf_error_gen_mt_eg_t); + if (!pvt) { ret = -1; + goto out; + } - GF_OPTION_INIT ("error-no", pvt->error_no, str, out); + LOCK_INIT(&pvt->lock); - if (pvt->error_no) - pvt->error_no_int = conv_errno_to_int (&pvt->error_no); + ret = -1; - GF_OPTION_INIT ("failure", failure_percent_dbl, percent, out); + GF_OPTION_INIT("error-no", pvt->error_no, str, out); - GF_OPTION_INIT ("enable", error_enable_fops, str, out); + if (pvt->error_no) + pvt->error_no_int = conv_errno_to_int(&pvt->error_no); - GF_OPTION_INIT ("random-failure", pvt->random_failure, bool, out); + GF_OPTION_INIT("failure", failure_percent_dbl, percent, out); + GF_OPTION_INIT("enable", error_enable_fops, str, out); - error_gen_parse_fill_fops (pvt, error_enable_fops); - error_gen_set_failure (pvt, failure_percent_dbl); + GF_OPTION_INIT("random-failure", pvt->random_failure, bool, out); - this->private = pvt; + error_gen_parse_fill_fops(pvt, error_enable_fops); + error_gen_set_failure(pvt, failure_percent_dbl); - /* Give some seed value here */ - srand (time(NULL)); + this->private = pvt; - ret = 0; + /* Give some seed value here */ + srand(time(NULL)); + + ret = 0; out: - if (ret) - GF_FREE (pvt); - return ret; + if (ret) + GF_FREE(pvt); + return ret; } - void -fini (xlator_t *this) +fini(xlator_t *this) { - eg_t *pvt = NULL; - - if (!this) - return; - pvt = this->private; + eg_t *pvt = NULL; - if (pvt) { - LOCK_DESTROY (&pvt->lock); - GF_FREE (pvt); - gf_log (this->name, GF_LOG_DEBUG, "fini called"); - } + 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, + .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, - .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, + .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 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} } -}; + { + .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}}}; |