diff options
Diffstat (limited to 'xlators/debug')
| -rw-r--r-- | xlators/debug/Makefile.am | 3 | ||||
| -rw-r--r-- | xlators/debug/error-gen/Makefile.am | 3 | ||||
| -rw-r--r-- | xlators/debug/error-gen/src/Makefile.am | 14 | ||||
| -rw-r--r-- | xlators/debug/error-gen/src/error-gen.c | 1780 | ||||
| -rw-r--r-- | xlators/debug/trace/Makefile.am | 3 | ||||
| -rw-r--r-- | xlators/debug/trace/src/Makefile.am | 14 | ||||
| -rw-r--r-- | xlators/debug/trace/src/trace.c | 2321 |
7 files changed, 4138 insertions, 0 deletions
diff --git a/xlators/debug/Makefile.am b/xlators/debug/Makefile.am new file mode 100644 index 00000000000..16cf893a11c --- /dev/null +++ b/xlators/debug/Makefile.am @@ -0,0 +1,3 @@ +SUBDIRS = trace error-gen + +CLEANFILES = diff --git a/xlators/debug/error-gen/Makefile.am b/xlators/debug/error-gen/Makefile.am new file mode 100644 index 00000000000..d471a3f9243 --- /dev/null +++ b/xlators/debug/error-gen/Makefile.am @@ -0,0 +1,3 @@ +SUBDIRS = src + +CLEANFILES = diff --git a/xlators/debug/error-gen/src/Makefile.am b/xlators/debug/error-gen/src/Makefile.am new file mode 100644 index 00000000000..1bd7f332ca0 --- /dev/null +++ b/xlators/debug/error-gen/src/Makefile.am @@ -0,0 +1,14 @@ + +xlator_LTLIBRARIES = error-gen.la +xlatordir = $(libdir)/glusterfs/$(PACKAGE_VERSION)/xlator/debug + +error_gen_la_LDFLAGS = -module -avoidversion + +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) + +CLEANFILES = + diff --git a/xlators/debug/error-gen/src/error-gen.c b/xlators/debug/error-gen/src/error-gen.c new file mode 100644 index 00000000000..9c0b3253e65 --- /dev/null +++ b/xlators/debug/error-gen/src/error-gen.c @@ -0,0 +1,1780 @@ +/* + Copyright (c) 2008 Z RESEARCH, Inc. <http://www.zresearch.com> + This file is part of GlusterFS. + + GlusterFS is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published + by the Free Software Foundation; either version 3 of the License, + or (at your option) any later version. + + GlusterFS is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see + <http://www.gnu.org/licenses/>. +*/ + +#ifndef _CONFIG_H +#define _CONFIG_H +#include "config.h" +#endif + +#include "xlator.h" + +typedef struct { + int op_count; +} eg_t; + +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; +} + +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; +} + +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; +} + + +int32_t +error_gen_forget (xlator_t *this, + inode_t *inode) +{ + return 0; +} + +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; +} + +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; +} + +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; +} + +int32_t +error_gen_chmod (call_frame_t *frame, + xlator_t *this, + loc_t *loc, + 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_chmod_cbk, + FIRST_CHILD(this), + FIRST_CHILD(this)->fops->chmod, + loc, + mode); + return 0; +} + + +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; +} + +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; +} + +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; +} + +int32_t +error_gen_chown (call_frame_t *frame, + xlator_t *this, + loc_t *loc, + 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_chown_cbk, + FIRST_CHILD(this), + FIRST_CHILD(this)->fops->chown, + loc, + uid, + gid); + return 0; +} + +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; +} + +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; +} + +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; +} + +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; +} + +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) +{ + STACK_UNWIND (frame, + op_ret, + op_errno, + buf); + return 0; +} + +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; +} + +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; +} + + +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; +} + +int32_t +error_gen_access_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; +} + +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; +} + + +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; +} + +int32_t +error_gen_readlink (call_frame_t *frame, + xlator_t *this, + loc_t *loc, + size_t size) +{ + 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; +} + + +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; +} + +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; +} + +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; +} + +int32_t +error_gen_mkdir (call_frame_t *frame, + xlator_t *this, + loc_t *loc, + 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, NULL); + return 0; + } + STACK_WIND (frame, + error_gen_mkdir_cbk, + FIRST_CHILD(this), + FIRST_CHILD(this)->fops->mkdir, + loc, mode); + return 0; +} + +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; +} + +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; +} + +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; +} + +int32_t +error_gen_rmdir (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_rmdir_cbk, + FIRST_CHILD(this), + FIRST_CHILD(this)->fops->rmdir, + loc); + return 0; +} + + +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; +} + +int32_t +error_gen_symlink (call_frame_t *frame, + xlator_t *this, + const char *linkpath, + 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, NULL); + return 0; + } + STACK_WIND (frame, + error_gen_symlink_cbk, + FIRST_CHILD(this), + FIRST_CHILD(this)->fops->symlink, + linkpath, loc); + return 0; +} + + +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; +} + +int32_t +error_gen_rename (call_frame_t *frame, + xlator_t *this, + loc_t *oldloc, + loc_t *newloc) +{ + 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; +} + + +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; +} + +int32_t +error_gen_link (call_frame_t *frame, + xlator_t *this, + loc_t *oldloc, + loc_t *newloc) +{ + 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; +} + + +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; +} + +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; +} + +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) +{ + STACK_UNWIND (frame, + op_ret, + op_errno, + fd); + return 0; +} + +int32_t +error_gen_open (call_frame_t *frame, + xlator_t *this, + loc_t *loc, + int32_t flags, 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); + return 0; + } + + STACK_WIND (frame, + error_gen_open_cbk, + FIRST_CHILD(this), + FIRST_CHILD(this)->fops->open, + loc, flags, fd); + 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) +{ + STACK_UNWIND (frame, + op_ret, + op_errno, + vector, + count, + stbuf); + return 0; +} + +int32_t +error_gen_readv (call_frame_t *frame, + xlator_t *this, + fd_t *fd, + size_t size, + 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, 0, NULL); + return 0; + } + + + STACK_WIND (frame, + error_gen_readv_cbk, + FIRST_CHILD(this), + FIRST_CHILD(this)->fops->readv, + fd, + size, + offset); + return 0; +} + + +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; +} + +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 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; +} + +int32_t +error_gen_flush_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; +} + +int32_t +error_gen_flush (call_frame_t *frame, + xlator_t *this, + 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); + return 0; + } + + STACK_WIND (frame, + error_gen_flush_cbk, + FIRST_CHILD(this), + FIRST_CHILD(this)->fops->flush, + fd); + return 0; +} + + +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; +} + +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; +} + +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) +{ + STACK_UNWIND (frame, + op_ret, + op_errno, + buf); + return 0; +} + +int32_t +error_gen_fstat (call_frame_t *frame, + xlator_t *this, + 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); + return 0; + } + + STACK_WIND (frame, + error_gen_fstat_cbk, + FIRST_CHILD(this), + FIRST_CHILD(this)->fops->fstat, + fd); + 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) +{ + STACK_UNWIND (frame, + op_ret, + op_errno, + fd); + return 0; +} + +int32_t +error_gen_opendir (call_frame_t *frame, + xlator_t *this, + loc_t *loc, 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); + return 0; + } + + STACK_WIND (frame, + error_gen_opendir_cbk, + FIRST_CHILD(this), + FIRST_CHILD(this)->fops->opendir, + loc, fd); + return 0; +} + + +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; +} + +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 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; +} + + +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; +} + +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 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; +} + + +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; +} + +int32_t +error_gen_fsyncdir (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_fsyncdir_cbk, + FIRST_CHILD(this), + FIRST_CHILD(this)->fops->fsyncdir, + fd, + flags); + return 0; +} + + +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; +} + +int32_t +error_gen_statfs (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_statfs_cbk, + FIRST_CHILD(this), + FIRST_CHILD(this)->fops->statfs, + loc); + return 0; +} + + +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; +} + +int32_t +error_gen_setxattr (call_frame_t *frame, + xlator_t *this, + loc_t *loc, + dict_t *dict, + 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_setxattr_cbk, + FIRST_CHILD(this), + FIRST_CHILD(this)->fops->setxattr, + loc, + dict, + flags); + 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) +{ + STACK_UNWIND (frame, + op_ret, + op_errno, + dict); + return 0; +} + +int32_t +error_gen_getxattr (call_frame_t *frame, + xlator_t *this, + loc_t *loc, + const char *name) +{ + 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; +} + +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) +{ + STACK_UNWIND (frame, op_ret, op_errno, dict); + 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 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; +} + +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) +{ + STACK_UNWIND (frame, op_ret, op_errno, dict); + 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 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; +} + +int32_t +error_gen_removexattr_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; +} + +int32_t +error_gen_removexattr (call_frame_t *frame, + xlator_t *this, + loc_t *loc, + const char *name) +{ + 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; +} + +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) +{ + STACK_UNWIND (frame, + op_ret, + op_errno, + lock); + return 0; +} + +int32_t +error_gen_lk (call_frame_t *frame, + xlator_t *this, + fd_t *fd, + int32_t cmd, + struct flock *lock) +{ + 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; +} + + +int32_t +error_gen_inodelk_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; +} + + +int32_t +error_gen_inodelk (call_frame_t *frame, xlator_t *this, + loc_t *loc, int32_t cmd, struct flock *lock) +{ + 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, + loc, cmd, lock); + return 0; +} + + +int32_t +error_gen_finodelk_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; +} + + +int32_t +error_gen_finodelk (call_frame_t *frame, xlator_t *this, + fd_t *fd, int32_t cmd, struct flock *lock) +{ + 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, + fd, cmd, lock); + return 0; +} + + +int32_t +error_gen_entrylk_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; +} + +int32_t +error_gen_entrylk (call_frame_t *frame, xlator_t *this, + loc_t *loc, const char *basename, + entrylk_cmd cmd, entrylk_type type) +{ + 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, + loc, basename, cmd, type); + return 0; +} + +int32_t +error_gen_fentrylk_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; +} + +int32_t +error_gen_fentrylk (call_frame_t *frame, xlator_t *this, + fd_t *fd, const char *basename, + entrylk_cmd cmd, entrylk_type type) +{ + 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, + fd, basename, cmd, type); + return 0; +} + + +/* Management operations */ + +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) +{ + STACK_UNWIND (frame, + op_ret, + op_errno, + stats); + return 0; +} + + +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; +} + + + +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) +{ + STACK_UNWIND (frame, + op_ret, + op_errno, + spec_data); + return 0; +} + + +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; +} + + +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; +} + + +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; +} + +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) +{ + STACK_UNWIND (frame, op_ret, op_errno, entries); + return 0; +} + + +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; +} + +int32_t +error_gen_closedir (xlator_t *this, + fd_t *fd) +{ + return 0; +} + +int32_t +error_gen_close (xlator_t *this, + fd_t *fd) +{ + return 0; +} + +int +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; +} + +void +fini (xlator_t *this) +{ + gf_log (this->name, GF_LOG_DEBUG, "fini called"); + return; +} + + +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 +}; + +struct xlator_mops mops = { + .stats = error_gen_stats, + .getspec = error_gen_getspec, +}; + +struct xlator_cbks cbks = { + .release = error_gen_close, + .releasedir = error_gen_closedir, +}; diff --git a/xlators/debug/trace/Makefile.am b/xlators/debug/trace/Makefile.am new file mode 100644 index 00000000000..d471a3f9243 --- /dev/null +++ b/xlators/debug/trace/Makefile.am @@ -0,0 +1,3 @@ +SUBDIRS = src + +CLEANFILES = diff --git a/xlators/debug/trace/src/Makefile.am b/xlators/debug/trace/src/Makefile.am new file mode 100644 index 00000000000..0f1679a049d --- /dev/null +++ b/xlators/debug/trace/src/Makefile.am @@ -0,0 +1,14 @@ + +xlator_LTLIBRARIES = trace.la +xlatordir = $(libdir)/glusterfs/$(PACKAGE_VERSION)/xlator/debug + +trace_la_LDFLAGS = -module -avoidversion + +trace_la_SOURCES = trace.c +trace_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) + +CLEANFILES = + diff --git a/xlators/debug/trace/src/trace.c b/xlators/debug/trace/src/trace.c new file mode 100644 index 00000000000..3ccf11a837a --- /dev/null +++ b/xlators/debug/trace/src/trace.c @@ -0,0 +1,2321 @@ +/* + Copyright (c) 2006, 2007, 2008 Z RESEARCH, Inc. <http://www.zresearch.com> + This file is part of GlusterFS. + + GlusterFS is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published + by the Free Software Foundation; either version 3 of the License, + or (at your option) any later version. + + GlusterFS is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see + <http://www.gnu.org/licenses/>. +*/ + +#ifndef _CONFIG_H +#define _CONFIG_H +#include "config.h" +#endif + +/** + * xlators/debug/trace : + * This translator logs all the arguments to the fops/mops and also + * their _cbk functions, which later passes the call to next layer. + * Very helpful translator for debugging. + */ + +#include <time.h> +#include <errno.h> +#include "glusterfs.h" +#include "xlator.h" +#include "common-utils.h" + +#define ERR_EINVAL_NORETURN(cond) \ +do \ + { \ + if ((cond)) \ + { \ + gf_log ("ERROR", GF_LOG_ERROR, \ + "%s: %s: (%s) is true", \ + __FILE__, __FUNCTION__, #cond); \ + } \ + } while (0) + +typedef struct trace_private { + int32_t debug_flag; +} trace_private_t; + +struct { + char *name; + int enabled; +} trace_fop_names[GF_FOP_MAXVALUE]; + +int32_t +trace_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) +{ + char atime_buf[256], mtime_buf[256], ctime_buf[256]; + ERR_EINVAL_NORETURN (!this); + + if (trace_fop_names[GF_FOP_CREATE].enabled) { + if (op_ret >= 0) { + strftime (atime_buf, 256, "[%b %d %H:%M:%S]", localtime (&buf->st_atime)); + strftime (mtime_buf, 256, "[%b %d %H:%M:%S]", localtime (&buf->st_mtime)); + strftime (ctime_buf, 256, "[%b %d %H:%M:%S]", localtime (&buf->st_ctime)); + + gf_log (this->name, GF_LOG_NORMAL, + "%"PRId64": (op_ret=%d, fd=%p, ino=%"PRIu64"), " + "*buf {st_dev=%"GF_PRI_DEV", st_ino=%"PRIu64", " + "st_mode=%d, st_nlink=%"GF_PRI_NLINK", st_uid=%d, " + "st_gid=%d, st_rdev=%"GF_PRI_DEV", st_size=%"PRId64", " + "st_blksize=%"GF_PRI_BLKSIZE", st_blocks=%"PRId64", " + "st_atime=%s, st_mtime=%s, st_ctime=%s})", + frame->root->unique, op_ret, fd, inode->ino, buf->st_dev, + buf->st_ino, buf->st_mode, buf->st_nlink, + buf->st_uid, buf->st_gid, buf->st_rdev, buf->st_size, + buf->st_blksize, + buf->st_blocks, atime_buf, mtime_buf, ctime_buf); + } else { + gf_log (this->name, GF_LOG_NORMAL, + "%"PRId64": (op_ret=%d, op_errno=%d)", + frame->root->unique, op_ret, op_errno); + } + } + + STACK_UNWIND (frame, op_ret, op_errno, fd, inode, buf); + return 0; +} + +int32_t +trace_open_cbk (call_frame_t *frame, + void *cookie, + xlator_t *this, + int32_t op_ret, + int32_t op_errno, + fd_t *fd) +{ + ERR_EINVAL_NORETURN (!this); + + if (trace_fop_names[GF_FOP_OPEN].enabled) { + gf_log (this->name, GF_LOG_NORMAL, + "%"PRId64": (op_ret=%d, op_errno=%d, *fd=%p)", + frame->root->unique, op_ret, op_errno, fd); + } + + STACK_UNWIND (frame, op_ret, op_errno, fd); + return 0; +} + +int32_t +trace_stat_cbk (call_frame_t *frame, + void *cookie, + xlator_t *this, + int32_t op_ret, + int32_t op_errno, + struct stat *buf) +{ + char atime_buf[256], mtime_buf[256], ctime_buf[256]; + ERR_EINVAL_NORETURN (!this); + + if (trace_fop_names[GF_FOP_STAT].enabled) { + + if (op_ret >= 0) { + strftime (atime_buf, 256, "[%b %d %H:%M:%S]", localtime (&buf->st_atime)); + strftime (mtime_buf, 256, "[%b %d %H:%M:%S]", localtime (&buf->st_mtime)); + strftime (ctime_buf, 256, "[%b %d %H:%M:%S]", localtime (&buf->st_ctime)); + + gf_log (this->name, GF_LOG_NORMAL, + "%"PRId64": (op_ret=%d, buf {st_dev=%"GF_PRI_DEV", " + "st_ino=%"PRIu64", st_mode=%d, st_nlink=%"GF_PRI_NLINK", " + "st_uid=%d, st_gid=%d, st_rdev=%"GF_PRI_DEV", st_size=%"PRId64 + ", st_blksize=%"GF_PRI_BLKSIZE", st_blocks=%"PRId64", " + "st_atime=%s, st_mtime=%s, st_ctime=%s})", + frame->root->unique, op_ret, buf->st_dev, buf->st_ino, + buf->st_mode, buf->st_nlink, buf->st_uid, buf->st_gid, + buf->st_rdev, buf->st_size, buf->st_blksize, + buf->st_blocks, atime_buf, mtime_buf, ctime_buf); + } else { + gf_log (this->name, GF_LOG_NORMAL, + "%"PRId64": (op_ret=%d, op_errno=%d)", + frame->root->unique, op_ret, op_errno); + } + } + + STACK_UNWIND (frame, op_ret, op_errno, buf); + return 0; +} + +int32_t +trace_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 *buf) +{ + char atime_buf[256], mtime_buf[256], ctime_buf[256]; + ERR_EINVAL_NORETURN (!this); + + if (trace_fop_names[GF_FOP_READ].enabled) { + + if (op_ret >= 0) { + strftime (atime_buf, 256, "[%b %d %H:%M:%S]", localtime (&buf->st_atime)); + strftime (mtime_buf, 256, "[%b %d %H:%M:%S]", localtime (&buf->st_mtime)); + strftime (ctime_buf, 256, "[%b %d %H:%M:%S]", localtime (&buf->st_ctime)); + + gf_log (this->name, GF_LOG_NORMAL, + "%"PRId64": (op_ret=%d, *buf {st_dev=%"GF_PRI_DEV", " + "st_ino=%"PRIu64", st_mode=%d, st_nlink=%"GF_PRI_NLINK", " + "st_uid=%d, st_gid=%d, st_rdev=%"GF_PRI_DEV", " + "st_size=%"PRId64", st_blksize=%"GF_PRI_BLKSIZE", " + "st_blocks=%"PRId64", st_atime=%s, st_mtime=%s, st_ctime=%s})", + frame->root->unique, op_ret, buf->st_dev, buf->st_ino, + buf->st_mode, buf->st_nlink, buf->st_uid, buf->st_gid, + buf->st_rdev, buf->st_size, buf->st_blksize, buf->st_blocks, + atime_buf, mtime_buf, ctime_buf); + } else { + gf_log (this->name, GF_LOG_NORMAL, + "%"PRId64": (op_ret=%d, op_errno=%d)", + frame->root->unique, op_ret, op_errno); + } + } + + STACK_UNWIND (frame, op_ret, op_errno, vector, count, buf); + return 0; +} + +int32_t +trace_writev_cbk (call_frame_t *frame, + void *cookie, + xlator_t *this, + int32_t op_ret, + int32_t op_errno, + struct stat *buf) +{ + char atime_buf[256], mtime_buf[256], ctime_buf[256]; + ERR_EINVAL_NORETURN (!this); + + if (trace_fop_names[GF_FOP_WRITE].enabled) { + if (op_ret >= 0) { + strftime (atime_buf, 256, "[%b %d %H:%M:%S]", localtime (&buf->st_atime)); + strftime (mtime_buf, 256, "[%b %d %H:%M:%S]", localtime (&buf->st_mtime)); + strftime (ctime_buf, 256, "[%b %d %H:%M:%S]", localtime (&buf->st_ctime)); + + gf_log (this->name, GF_LOG_NORMAL, + "%"PRId64": (op_ret=%d, *buf {st_ino=%"PRIu64", " + "st_size=%"PRId64", st_blocks=%"PRId64", st_atime=%s, " + "st_mtime=%s, st_ctime=%s})", + frame->root->unique, op_ret, buf->st_ino, buf->st_size, + buf->st_blocks, atime_buf, mtime_buf, ctime_buf); + } else { + gf_log (this->name, GF_LOG_NORMAL, + "%"PRId64": (op_ret=%d, op_errno=%d)", + frame->root->unique, op_ret, op_errno); + } + } + + STACK_UNWIND (frame, op_ret, op_errno, buf); + return 0; +} + +int32_t +trace_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) +{ + ERR_EINVAL_NORETURN (!this ); + + if (trace_fop_names[GF_FOP_GETDENTS].enabled) { + gf_log (this->name, GF_LOG_NORMAL, + "%"PRId64": (op_ret=%d, op_errno=%d, count=%d)", + frame->root->unique, op_ret, op_errno, count); + } + + STACK_UNWIND (frame, op_ret, op_errno, entries, count); + return 0; +} + +int32_t +trace_readdir_cbk (call_frame_t *frame, + void *cookie, + xlator_t *this, + int32_t op_ret, + int32_t op_errno, + gf_dirent_t *buf) +{ + ERR_EINVAL_NORETURN (!this ); + + if (trace_fop_names[GF_FOP_READDIR].enabled) { + gf_log (this->name, GF_LOG_NORMAL, + "%"PRId64" :(op_ret=%d, op_errno=%d)", + frame->root->unique, op_ret, op_errno); + } + + STACK_UNWIND (frame, op_ret, op_errno, buf); + + return 0; +} + +int32_t +trace_fsync_cbk (call_frame_t *frame, + void *cookie, + xlator_t *this, + int32_t op_ret, + int32_t op_errno) +{ + ERR_EINVAL_NORETURN (!this ); + + if (trace_fop_names[GF_FOP_FSYNC].enabled) { + gf_log (this->name, GF_LOG_NORMAL, + "%"PRId64": (op_ret=%d, op_errno=%d)", + frame->root->unique, op_ret, op_errno); + } + + STACK_UNWIND (frame, op_ret, op_errno); + return 0; +} + +int32_t +trace_chown_cbk (call_frame_t *frame, + void *cookie, + xlator_t *this, + int32_t op_ret, + int32_t op_errno, + struct stat *buf) +{ + char atime_buf[256], mtime_buf[256], ctime_buf[256]; + ERR_EINVAL_NORETURN (!this ); + + if (trace_fop_names[GF_FOP_CHOWN].enabled) { + if (op_ret >= 0) { + strftime (atime_buf, 256, "[%b %d %H:%M:%S]", localtime (&buf->st_atime)); + strftime (mtime_buf, 256, "[%b %d %H:%M:%S]", localtime (&buf->st_mtime)); + strftime (ctime_buf, 256, "[%b %d %H:%M:%S]", localtime (&buf->st_ctime)); + + gf_log (this->name, GF_LOG_NORMAL, + "%"PRId64": (op_ret=%d, *buf {st_ino=%"PRIu64", st_mode=%d, " + "st_uid=%d, st_gid=%d, st_atime=%s, st_mtime=%s, st_ctime=%s})", + frame->root->unique, op_ret, buf->st_ino, buf->st_mode, + buf->st_uid, buf->st_gid, atime_buf, mtime_buf, ctime_buf); + } else { + gf_log (this->name, GF_LOG_NORMAL, + "%"PRId64": (op_ret=%d, op_errno=%d)", + frame->root->unique, op_ret, op_errno); + } + } + + STACK_UNWIND (frame, op_ret, op_errno, buf); + return 0; +} + +int32_t +trace_chmod_cbk (call_frame_t *frame, + void *cookie, + xlator_t *this, + int32_t op_ret, + int32_t op_errno, + struct stat *buf) +{ + char atime_buf[256], mtime_buf[256], ctime_buf[256]; + ERR_EINVAL_NORETURN (!this ); + + if (trace_fop_names[GF_FOP_CHMOD].enabled) { + if (op_ret >= 0) { + strftime (atime_buf, 256, "[%b %d %H:%M:%S]", localtime (&buf->st_atime)); + strftime (mtime_buf, 256, "[%b %d %H:%M:%S]", localtime (&buf->st_mtime)); + strftime (ctime_buf, 256, "[%b %d %H:%M:%S]", localtime (&buf->st_ctime)); + + gf_log (this->name, GF_LOG_NORMAL, + "%"PRId64": (op_ret=%d, *buf {st_ino=%"PRIu64", st_mode=%d, " + "st_atime=%s, st_mtime=%s, st_ctime=%s})", + frame->root->unique, op_ret, buf->st_ino, buf->st_mode, + atime_buf, mtime_buf, ctime_buf); + } else { + gf_log (this->name, GF_LOG_NORMAL, + "%"PRId64": (op_ret=%d, op_errno=%d)", + frame->root->unique, op_ret, op_errno); + } + } + + STACK_UNWIND (frame, op_ret, op_errno, buf); + return 0; +} + +int32_t +trace_fchmod_cbk (call_frame_t *frame, + void *cookie, + xlator_t *this, + int32_t op_ret, + int32_t op_errno, + struct stat *buf) +{ + char atime_buf[256], mtime_buf[256], ctime_buf[256]; + ERR_EINVAL_NORETURN (!this ); + + if (trace_fop_names[GF_FOP_FCHMOD].enabled) { + if (op_ret >= 0) { + strftime (atime_buf, 256, "[%b %d %H:%M:%S]", localtime (&buf->st_atime)); + strftime (mtime_buf, 256, "[%b %d %H:%M:%S]", localtime (&buf->st_mtime)); + strftime (ctime_buf, 256, "[%b %d %H:%M:%S]", localtime (&buf->st_ctime)); + + gf_log (this->name, GF_LOG_NORMAL, + "%"PRId64": (op_ret=%d, *buf {st_ino=%"PRIu64", st_mode=%d, " + "st_atime=%s, st_mtime=%s, st_ctime=%s})", + frame->root->unique, op_ret, buf->st_ino, buf->st_mode, + atime_buf, mtime_buf, ctime_buf); + } else { + gf_log (this->name, GF_LOG_NORMAL, + "%"PRId64": (op_ret=%d, op_errno=%d)", + frame->root->unique, op_ret, op_errno); + } + } + + STACK_UNWIND (frame, op_ret, op_errno, buf); + return 0; +} + +int32_t +trace_fchown_cbk (call_frame_t *frame, + void *cookie, + xlator_t *this, + int32_t op_ret, + int32_t op_errno, + struct stat *buf) +{ + char atime_buf[256], mtime_buf[256], ctime_buf[256]; + ERR_EINVAL_NORETURN (!this ); + + if (trace_fop_names[GF_FOP_FCHOWN].enabled) { + if (op_ret >= 0) { + strftime (atime_buf, 256, "[%b %d %H:%M:%S]", localtime (&buf->st_atime)); + strftime (mtime_buf, 256, "[%b %d %H:%M:%S]", localtime (&buf->st_mtime)); + strftime (ctime_buf, 256, "[%b %d %H:%M:%S]", localtime (&buf->st_ctime)); + + gf_log (this->name, GF_LOG_NORMAL, + "%"PRId64": (op_ret=%d, *buf {st_ino=%"PRIu64", st_mode=%d, " + "st_uid=%d, st_gid=%d, st_atime=%s, st_mtime=%s, st_ctime=%s})", + frame->root->unique, op_ret, buf->st_ino, buf->st_mode, + buf->st_uid, buf->st_gid, atime_buf, mtime_buf, ctime_buf); + } else { + gf_log (this->name, GF_LOG_NORMAL, + "%"PRId64": (op_ret=%d, op_errno=%d)", + frame->root->unique, op_ret, op_errno); + } + } + + STACK_UNWIND (frame, op_ret, op_errno, buf); + return 0; +} + +int32_t +trace_unlink_cbk (call_frame_t *frame, + void *cookie, + xlator_t *this, + int32_t op_ret, + int32_t op_errno) +{ + ERR_EINVAL_NORETURN (!this ); + + if (trace_fop_names[GF_FOP_UNLINK].enabled) { + gf_log (this->name, GF_LOG_NORMAL, + "%"PRId64": (op_ret=%d, op_errno=%d)", + frame->root->unique, op_ret, op_errno); + } + + STACK_UNWIND (frame, op_ret, op_errno); + return 0; +} + +int32_t +trace_rename_cbk (call_frame_t *frame, + void *cookie, + xlator_t *this, + int32_t op_ret, + int32_t op_errno, + struct stat *buf) +{ + ERR_EINVAL_NORETURN (!this ); + + if (trace_fop_names[GF_FOP_RENAME].enabled) { + gf_log (this->name, GF_LOG_NORMAL, + "%"PRId64": (op_ret=%d, op_errno=%d, buf {st_ino=%"PRIu64"})", + frame->root->unique, op_ret, op_errno, + (buf? buf->st_ino : 0)); + } + + STACK_UNWIND (frame, op_ret, op_errno, buf); + return 0; +} + +int32_t +trace_readlink_cbk (call_frame_t *frame, + void *cookie, + xlator_t *this, + int32_t op_ret, + int32_t op_errno, + const char *buf) +{ + ERR_EINVAL_NORETURN (!this ); + + if (trace_fop_names[GF_FOP_READLINK].enabled) { + gf_log (this->name, GF_LOG_NORMAL, + "%"PRId64": (op_ret=%d, op_errno=%d, buf=%s)", + frame->root->unique, op_ret, op_errno, buf); + } + + STACK_UNWIND (frame, op_ret, op_errno, buf); + return 0; +} + +int32_t +trace_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 *xattr) +{ + ERR_EINVAL_NORETURN (!this ); + + if (trace_fop_names[GF_FOP_LOOKUP].enabled) { + if (op_ret >= 0) { + gf_log (this->name, GF_LOG_NORMAL, + "%"PRId64": (op_ret=%d, ino=%"PRIu64", " + "*buf {st_dev=%"GF_PRI_DEV", st_ino=%"PRIu64", st_mode=%d, " + "st_nlink=%"GF_PRI_NLINK", st_uid=%d, st_gid=%d, " + "st_rdev=%"GF_PRI_DEV", st_size=%"PRId64", " + "st_blksize=%"GF_PRI_BLKSIZE", st_blocks=%"PRId64"})", + frame->root->unique, op_ret, inode->ino, buf->st_dev, buf->st_ino, + buf->st_mode, buf->st_nlink, buf->st_uid, buf->st_gid, + buf->st_rdev, buf->st_size, buf->st_blksize, buf->st_blocks); + } else { + gf_log (this->name, GF_LOG_NORMAL, + "%"PRId64": (op_ret=%d, op_errno=%d)", + frame->root->unique, op_ret, op_errno); + } + } + + STACK_UNWIND (frame, op_ret, op_errno, inode, buf, xattr); + return 0; +} + +int32_t +trace_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) +{ + char atime_buf[256], mtime_buf[256], ctime_buf[256]; + ERR_EINVAL_NORETURN (!this ); + + if (trace_fop_names[GF_FOP_SYMLINK].enabled) { + if (op_ret >= 0) { + strftime (atime_buf, 256, "[%b %d %H:%M:%S]", localtime (&buf->st_atime)); + strftime (mtime_buf, 256, "[%b %d %H:%M:%S]", localtime (&buf->st_mtime)); + strftime (ctime_buf, 256, "[%b %d %H:%M:%S]", localtime (&buf->st_ctime)); + + gf_log (this->name, GF_LOG_NORMAL, + "%"PRId64": (op_ret=%d, ino=%"PRIu64", *buf {st_ino=%"PRIu64", " + "st_mode=%d, st_nlink=%"GF_PRI_NLINK", st_uid=%d, st_gid=%d, " + "st_size=%"PRId64", st_blocks=%"PRId64", st_atime=%s, " + "st_mtime=%s, st_ctime=%s})", + frame->root->unique, op_ret, inode->ino, buf->st_ino, + buf->st_mode, buf->st_nlink, buf->st_uid, buf->st_gid, + buf->st_size, buf->st_blocks, atime_buf, mtime_buf, ctime_buf); + } else { + gf_log (this->name, GF_LOG_NORMAL, + "%"PRId64": (op_ret=%d, op_errno=%d)", + frame->root->unique, op_ret, op_errno); + } + } + + STACK_UNWIND (frame, op_ret, op_errno, inode, buf); + return 0; +} + +int32_t +trace_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) +{ + char atime_buf[256], mtime_buf[256], ctime_buf[256]; + ERR_EINVAL_NORETURN (!this ); + + if (trace_fop_names[GF_FOP_MKNOD].enabled) { + if (op_ret >= 0) { + strftime (atime_buf, 256, "[%b %d %H:%M:%S]", localtime (&buf->st_atime)); + strftime (mtime_buf, 256, "[%b %d %H:%M:%S]", localtime (&buf->st_mtime)); + strftime (ctime_buf, 256, "[%b %d %H:%M:%S]", localtime (&buf->st_ctime)); + + gf_log (this->name, GF_LOG_NORMAL, + "%"PRId64": (op_ret=%d, ino=%"PRIu64", *buf {st_dev=%"GF_PRI_DEV + ", st_ino=%"PRIu64", st_mode=%d, st_nlink=%"GF_PRI_NLINK", " + "st_uid=%d, st_gid=%d, st_rdev=%"GF_PRI_DEV", st_size=%"PRId64 + ", st_blksize=%"GF_PRI_BLKSIZE", st_blocks=%"PRId64", st_atime=%s, " + "st_mtime=%s, st_ctime=%s})", + frame->root->unique, op_ret, inode->ino, buf->st_dev, buf->st_ino, + buf->st_mode, buf->st_nlink, buf->st_uid, buf->st_gid, + buf->st_rdev, buf->st_size, buf->st_blksize, buf->st_blocks, + atime_buf, mtime_buf, ctime_buf); + } else { + gf_log (this->name, GF_LOG_NORMAL, + "%"PRId64": (op_ret=%d, op_errno=%d)", + frame->root->unique, op_ret, op_errno); + } + } + + STACK_UNWIND (frame, op_ret, op_errno, inode, buf); + return 0; +} + + +int32_t +trace_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) +{ + ERR_EINVAL_NORETURN (!this ); + + if (trace_fop_names[GF_FOP_MKDIR].enabled) { + gf_log (this->name, GF_LOG_NORMAL, + "%"PRId64": (op_ret=%d, op_errno=%d, ino=%"PRIu64"", + frame->root->unique, op_ret, op_errno, + (inode? inode->ino : 0)); + } + + STACK_UNWIND (frame, op_ret, op_errno, inode, buf); + return 0; +} + +int32_t +trace_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) +{ + ERR_EINVAL_NORETURN (!this ); + + if (trace_fop_names[GF_FOP_LINK].enabled) { + if (op_ret >= 0) { + gf_log (this->name, GF_LOG_NORMAL, + "%"PRId64": (op_ret=%d, ino=%"PRIu64", " + "*buf {st_nlink=%"GF_PRI_NLINK"})", + frame->root->unique, op_ret, inode->ino, buf->st_nlink); + } else { + gf_log (this->name, GF_LOG_NORMAL, + "%"PRId64": (op_ret=%d, op_errno=%d)", + frame->root->unique, op_ret, op_errno); + } + } + + STACK_UNWIND (frame, op_ret, op_errno, inode, buf); + return 0; +} + +int32_t +trace_flush_cbk (call_frame_t *frame, + void *cookie, + xlator_t *this, + int32_t op_ret, + int32_t op_errno) +{ + ERR_EINVAL_NORETURN (!this ); + + if (trace_fop_names[GF_FOP_FLUSH].enabled) { + gf_log (this->name, GF_LOG_NORMAL, + "%"PRId64": (op_ret=%d, op_errno=%d)", + frame->root->unique, op_ret, op_errno); + } + + STACK_UNWIND (frame, op_ret, op_errno); + return 0; +} + + +int32_t +trace_opendir_cbk (call_frame_t *frame, + void *cookie, + xlator_t *this, + int32_t op_ret, + int32_t op_errno, + fd_t *fd) +{ + ERR_EINVAL_NORETURN (!this ); + + if (trace_fop_names[GF_FOP_OPENDIR].enabled) { + gf_log (this->name, GF_LOG_NORMAL, + "%"PRId64": (op_ret=%d, op_errno=%d, fd=%p)", + frame->root->unique, op_ret, op_errno, fd); + } + + STACK_UNWIND (frame, op_ret, op_errno, fd); + return 0; +} + +int32_t +trace_rmdir_cbk (call_frame_t *frame, + void *cookie, + xlator_t *this, + int32_t op_ret, + int32_t op_errno) +{ + ERR_EINVAL_NORETURN (!this ); + + if (trace_fop_names[GF_FOP_RMDIR].enabled) { + gf_log (this->name, GF_LOG_NORMAL, + "%"PRId64": (op_ret=%d, op_errno=%d)", + frame->root->unique, op_ret, op_errno); + } + + STACK_UNWIND (frame, op_ret, op_errno); + return 0; +} + +int32_t +trace_truncate_cbk (call_frame_t *frame, + void *cookie, + xlator_t *this, + int32_t op_ret, + int32_t op_errno, + struct stat *buf) +{ + ERR_EINVAL_NORETURN (!this ); + + if (trace_fop_names[GF_FOP_TRUNCATE].enabled) { + if (op_ret >= 0) { + gf_log (this->name, GF_LOG_NORMAL, + "%"PRId64": (op_ret=%d, *buf {st_size=%"PRId64", st_blksize=%" + GF_PRI_BLKSIZE", st_blocks=%"PRId64"})", + frame->root->unique, op_ret, buf->st_size, buf->st_blksize, + buf->st_blocks); + } else { + gf_log (this->name, GF_LOG_NORMAL, + "%"PRId64": (op_ret=%d, op_errno=%d)", + frame->root->unique, op_ret, op_errno); + } + } + + STACK_UNWIND (frame, op_ret, op_errno, buf); + return 0; +} + +int32_t +trace_utimens_cbk (call_frame_t *frame, + void *cookie, + xlator_t *this, + int32_t op_ret, + int32_t op_errno, + struct stat *buf) +{ + char atime_buf[256], mtime_buf[256], ctime_buf[256]; + ERR_EINVAL_NORETURN (!this ); + + if (trace_fop_names[GF_FOP_UTIMENS].enabled) { + if (op_ret >= 0) { + strftime (atime_buf, 256, "[%b %d %H:%M:%S]", localtime (&buf->st_atime)); + strftime (mtime_buf, 256, "[%b %d %H:%M:%S]", localtime (&buf->st_mtime)); + strftime (ctime_buf, 256, "[%b %d %H:%M:%S]", localtime (&buf->st_ctime)); + + gf_log (this->name, GF_LOG_NORMAL, + "%"PRId64": (op_ret=%d, *buf {st_atime=%s, st_mtime=%s, " + "st_ctime=%s})", + frame->root->unique, op_ret, atime_buf, mtime_buf, ctime_buf); + } else { + gf_log (this->name, GF_LOG_NORMAL, + "%"PRId64": (op_ret=%d, op_errno=%d)", + frame->root->unique, op_ret, op_errno); + } + } + + STACK_UNWIND (frame, op_ret, op_errno, buf); + return 0; +} + +int32_t +trace_statfs_cbk (call_frame_t *frame, + void *cookie, + xlator_t *this, + int32_t op_ret, + int32_t op_errno, + struct statvfs *buf) +{ + ERR_EINVAL_NORETURN (!this); + + if (trace_fop_names[GF_FOP_STATFS].enabled) { + if (op_ret >= 0) { + gf_log (this->name, GF_LOG_NORMAL, + "%"PRId64": ({f_bsize=%lu, f_frsize=%lu, f_blocks=%"GF_PRI_FSBLK + ", f_bfree=%"GF_PRI_FSBLK", f_bavail=%"GF_PRI_FSBLK", " + "f_files=%"GF_PRI_FSBLK", f_ffree=%"GF_PRI_FSBLK", f_favail=%" + GF_PRI_FSBLK", f_fsid=%lu, f_flag=%lu, f_namemax=%lu}) => ret=%d", + frame->root->unique, buf->f_bsize, buf->f_frsize, buf->f_blocks, + buf->f_bfree, buf->f_bavail, buf->f_files, buf->f_ffree, + buf->f_favail, buf->f_fsid, buf->f_flag, buf->f_namemax, op_ret); + } else { + gf_log (this->name, GF_LOG_NORMAL, + "%"PRId64": (op_ret=%d, op_errno=%d)", + frame->root->unique, op_ret, op_errno); + } + } + + STACK_UNWIND (frame, op_ret, op_errno, buf); + return 0; +} + +int32_t +trace_setxattr_cbk (call_frame_t *frame, + void *cookie, + xlator_t *this, + int32_t op_ret, + int32_t op_errno) +{ + ERR_EINVAL_NORETURN (!this ); + + if (trace_fop_names[GF_FOP_SETXATTR].enabled) { + gf_log (this->name, GF_LOG_NORMAL, + "%"PRId64": (op_ret=%d, op_errno=%d)", + frame->root->unique, op_ret, op_errno); + } + + STACK_UNWIND (frame, op_ret, op_errno); + return 0; +} + +int32_t +trace_getxattr_cbk (call_frame_t *frame, + void *cookie, + xlator_t *this, + int32_t op_ret, + int32_t op_errno, + dict_t *dict) +{ + ERR_EINVAL_NORETURN (!this || !dict); + + if (trace_fop_names[GF_FOP_GETXATTR].enabled) { + gf_log (this->name, GF_LOG_NORMAL, + "%"PRId64": (op_ret=%d, op_errno=%d, dict=%p)", + frame->root->unique, op_ret, op_errno, dict); + } + + STACK_UNWIND (frame, op_ret, op_errno, dict); + return 0; +} + +int32_t +trace_removexattr_cbk (call_frame_t *frame, + void *cookie, + xlator_t *this, + int32_t op_ret, + int32_t op_errno) +{ + ERR_EINVAL_NORETURN (!this ); + + if (trace_fop_names[GF_FOP_REMOVEXATTR].enabled) { + gf_log (this->name, GF_LOG_NORMAL, + "%"PRId64": (op_ret=%d, op_errno=%d)", + frame->root->unique, op_ret, op_errno); + } + + STACK_UNWIND (frame, op_ret, op_errno); + return 0; +} + + +int32_t +trace_fsyncdir_cbk (call_frame_t *frame, + void *cookie, + xlator_t *this, + int32_t op_ret, + int32_t op_errno) +{ + ERR_EINVAL_NORETURN (!this ); + + if (trace_fop_names[GF_FOP_FSYNCDIR].enabled) { + gf_log (this->name, GF_LOG_NORMAL, + "%"PRId64": (op_ret=%d, op_errno=%d)", + frame->root->unique, op_ret, op_errno); + } + + STACK_UNWIND (frame, op_ret, op_errno); + return 0; +} + +int32_t +trace_access_cbk (call_frame_t *frame, + void *cookie, + xlator_t *this, + int32_t op_ret, + int32_t op_errno) +{ + ERR_EINVAL_NORETURN (!this ); + + if (trace_fop_names[GF_FOP_ACCESS].enabled) { + gf_log (this->name, GF_LOG_NORMAL, + "%"PRId64": (op_ret=%d, op_errno=%d)", + frame->root->unique, op_ret, op_errno); + } + + STACK_UNWIND (frame, op_ret, op_errno); + return 0; +} + +int32_t +trace_ftruncate_cbk (call_frame_t *frame, + void *cookie, + xlator_t *this, + int32_t op_ret, + int32_t op_errno, + struct stat *buf) +{ + ERR_EINVAL_NORETURN (!this ); + + if (trace_fop_names[GF_FOP_FTRUNCATE].enabled) { + if (op_ret >= 0) { + gf_log (this->name, GF_LOG_NORMAL, + "%"PRId64": (op_ret=%d, *buf {st_size=%"PRId64", " + "st_blksize=%"GF_PRI_BLKSIZE", st_blocks=%"PRId64"})", + frame->root->unique, op_ret, buf->st_size, buf->st_blksize, + buf->st_blocks); + } else { + gf_log (this->name, GF_LOG_NORMAL, + "%"PRId64": (op_ret=%d, op_errno=%d)", + frame->root->unique, op_ret, op_errno); + } + } + + STACK_UNWIND (frame, op_ret, op_errno, buf); + return 0; +} + +int32_t +trace_fstat_cbk (call_frame_t *frame, + void *cookie, + xlator_t *this, + int32_t op_ret, + int32_t op_errno, + struct stat *buf) +{ + char atime_buf[256], mtime_buf[256], ctime_buf[256]; + ERR_EINVAL_NORETURN (!this ); + + if (trace_fop_names[GF_FOP_FSTAT].enabled) { + if (op_ret >= 0) { + strftime (atime_buf, 256, "[%b %d %H:%M:%S]", localtime (&buf->st_atime)); + strftime (mtime_buf, 256, "[%b %d %H:%M:%S]", localtime (&buf->st_mtime)); + strftime (ctime_buf, 256, "[%b %d %H:%M:%S]", localtime (&buf->st_ctime)); + + gf_log (this->name, GF_LOG_NORMAL, + "%"PRId64": (op_ret=%d, *buf {st_dev=%"GF_PRI_DEV", " + "st_ino=%"PRIu64", st_mode=%d, st_nlink=%"GF_PRI_NLINK", " + "st_uid=%d, st_gid=%d, st_rdev=%"GF_PRI_DEV", st_size=%"PRId64", " + "st_blksize=%"GF_PRI_BLKSIZE", st_blocks=%"PRId64", st_atime=%s, " + "st_mtime=%s, st_ctime=%s})", + frame->root->unique, op_ret, buf->st_dev, buf->st_ino, + buf->st_mode, buf->st_nlink, buf->st_uid, buf->st_gid, + buf->st_rdev, buf->st_size, buf->st_blksize, + buf->st_blocks, atime_buf, mtime_buf, ctime_buf); + } else { + gf_log (this->name, GF_LOG_NORMAL, + "%"PRId64": (op_ret=%d, op_errno=%d)", + frame->root->unique, op_ret, op_errno); + } + } + + STACK_UNWIND (frame, op_ret, op_errno, buf); + return 0; +} + +int32_t +trace_lk_cbk (call_frame_t *frame, + void *cookie, + xlator_t *this, + int32_t op_ret, + int32_t op_errno, + struct flock *lock) +{ + ERR_EINVAL_NORETURN (!this ); + + if (trace_fop_names[GF_FOP_LK].enabled) { + if (op_ret >= 0) { + gf_log (this->name, GF_LOG_NORMAL, + "%"PRId64": (op_ret=%d, {l_type=%d, l_whence=%d, " + "l_start=%"PRId64", l_len=%"PRId64", l_pid=%u})", + frame->root->unique, op_ret, lock->l_type, lock->l_whence, + lock->l_start, lock->l_len, lock->l_pid); + } else { + gf_log (this->name, GF_LOG_NORMAL, + "%"PRId64": (op_ret=%d, op_errno=%d)", + frame->root->unique, op_ret, op_errno); + } + } + + STACK_UNWIND (frame, op_ret, op_errno, lock); + return 0; +} + + +int32_t +trace_setdents_cbk (call_frame_t *frame, + void *cookie, + xlator_t *this, + int32_t op_ret, + int32_t op_errno) +{ + ERR_EINVAL_NORETURN (!this ); + + if (trace_fop_names[GF_FOP_SETDENTS].enabled) { + gf_log (this->name, GF_LOG_NORMAL, + "%"PRId64": op_ret=%d, op_errno=%d", + frame->root->unique, op_ret, op_errno); + } + + STACK_UNWIND (frame, op_ret, op_errno); + return 0; +} + +int32_t +trace_entrylk_cbk (call_frame_t *frame, + void *cookie, + xlator_t *this, + int32_t op_ret, + int32_t op_errno) +{ + ERR_EINVAL_NORETURN (!this ); + + if (trace_fop_names[GF_FOP_ENTRYLK].enabled) { + gf_log (this->name, GF_LOG_NORMAL, + "%"PRId64": op_ret=%d, op_errno=%d", + frame->root->unique, op_ret, op_errno); + } + + STACK_UNWIND (frame, op_ret, op_errno); + return 0; +} + + +int32_t +trace_xattrop_cbk (call_frame_t *frame, + void *cookie, + xlator_t *this, + int32_t op_ret, + int32_t op_errno, + dict_t *dict) +{ + ERR_EINVAL_NORETURN (!this || !dict); + + if (trace_fop_names[GF_FOP_XATTROP].enabled) { + gf_log (this->name, GF_LOG_NORMAL, + "%"PRId64": (op_ret=%d, op_errno=%d)", + frame->root->unique, op_ret, op_errno); + } + + STACK_UNWIND (frame, op_ret, op_errno, dict); + return 0; +} + +int32_t +trace_fxattrop_cbk (call_frame_t *frame, + void *cookie, + xlator_t *this, + int32_t op_ret, + int32_t op_errno, + dict_t *dict) +{ + ERR_EINVAL_NORETURN (!this || !dict); + + if (trace_fop_names[GF_FOP_FXATTROP].enabled) { + gf_log (this->name, GF_LOG_NORMAL, + "%"PRId64": (op_ret=%d, op_errno=%d)", + frame->root->unique, op_ret, op_errno); + } + + STACK_UNWIND (frame, op_ret, op_errno, dict); + return 0; +} + +int32_t +trace_inodelk_cbk (call_frame_t *frame, + void *cookie, + xlator_t *this, + int32_t op_ret, + int32_t op_errno) +{ + ERR_EINVAL_NORETURN (!this ); + + if (trace_fop_names[GF_FOP_INODELK].enabled) { + gf_log (this->name, GF_LOG_NORMAL, + "%"PRId64": op_ret=%d, op_errno=%d", + frame->root->unique, op_ret, op_errno); + } + + STACK_UNWIND (frame, op_ret, op_errno); + return 0; +} + + +int32_t +trace_entrylk (call_frame_t *frame, xlator_t *this, + loc_t *loc, const char *basename, + entrylk_cmd cmd, entrylk_type type) +{ + ERR_EINVAL_NORETURN (!this || !loc || !basename); + + if (trace_fop_names[GF_FOP_ENTRYLK].enabled) { + gf_log (this->name, GF_LOG_NORMAL, + "%"PRId64": (loc= {path=%s, ino=%"PRIu64"} basename=%s, cmd=%s, type=%s)", + frame->root->unique, loc->path, loc->inode->ino, basename, + ((cmd == ENTRYLK_LOCK) ? "ENTRYLK_LOCK" : "ENTRYLK_UNLOCK"), + ((type == ENTRYLK_RDLCK) ? "ENTRYLK_RDLCK" : "ENTRYLK_WRLCK")); + } + + STACK_WIND (frame, + trace_entrylk_cbk, + FIRST_CHILD (this), + FIRST_CHILD (this)->fops->entrylk, + loc, basename, cmd, type); + return 0; +} + +int32_t +trace_inodelk (call_frame_t *frame, + xlator_t *this, + loc_t *loc, int32_t cmd, struct flock *flock) +{ + ERR_EINVAL_NORETURN (!this || !loc); + + if (trace_fop_names[GF_FOP_INODELK].enabled) { + gf_log (this->name, GF_LOG_NORMAL, + "%"PRId64": (loc {path=%s, ino=%"PRIu64"}, cmd=%s)", + frame->root->unique, loc->path, loc->inode->ino, + ((cmd == F_SETLK)? "F_SETLK" : "unknown")); + } + + STACK_WIND (frame, + trace_inodelk_cbk, + FIRST_CHILD (this), + FIRST_CHILD (this)->fops->inodelk, + loc, cmd, flock); + return 0; +} + + +int32_t +trace_finodelk_cbk (call_frame_t *frame, + void *cookie, + xlator_t *this, + int32_t op_ret, + int32_t op_errno) +{ + ERR_EINVAL_NORETURN (!this ); + + if (trace_fop_names[GF_FOP_FINODELK].enabled) { + gf_log (this->name, GF_LOG_NORMAL, + "%"PRId64": op_ret=%d, op_errno=%d", + frame->root->unique, op_ret, op_errno); + } + + STACK_UNWIND (frame, op_ret, op_errno); + return 0; +} + +int32_t +trace_finodelk (call_frame_t *frame, + xlator_t *this, + fd_t *fd, int32_t cmd, struct flock *flock) +{ + ERR_EINVAL_NORETURN (!this || !fd); + + if (trace_fop_names[GF_FOP_FINODELK].enabled) { + gf_log (this->name, GF_LOG_NORMAL, + "%"PRId64": (fd=%p, cmd=%s)", + frame->root->unique, fd, + ((cmd == F_SETLK) ? "F_SETLK" : "unknown")); + } + + STACK_WIND (frame, + trace_finodelk_cbk, + FIRST_CHILD (this), + FIRST_CHILD (this)->fops->finodelk, + fd, cmd, flock); + return 0; +} + + +int32_t +trace_xattrop (call_frame_t *frame, + xlator_t *this, + loc_t *loc, + gf_xattrop_flags_t flags, + dict_t *dict) +{ + ERR_EINVAL_NORETURN (!this || !loc); + + if (trace_fop_names[GF_FOP_XATTROP].enabled) { + gf_log (this->name, GF_LOG_NORMAL, + "%"PRId64": (path=%s, ino=%"PRIu64" flags=%d)", + frame->root->unique, loc->path, loc->inode->ino, flags); + + } + + STACK_WIND (frame, trace_xattrop_cbk, + FIRST_CHILD(this), + FIRST_CHILD(this)->fops->xattrop, + loc, flags, dict); + + return 0; +} + +int32_t +trace_fxattrop (call_frame_t *frame, + xlator_t *this, + fd_t *fd, + gf_xattrop_flags_t flags, + dict_t *dict) +{ + ERR_EINVAL_NORETURN (!this || !fd); + + if (trace_fop_names[GF_FOP_FXATTROP].enabled) { + gf_log (this->name, GF_LOG_NORMAL, + "%"PRId64": (fd=%p, flags=%d)", + frame->root->unique, fd, flags); + + } + + STACK_WIND (frame, trace_fxattrop_cbk, + FIRST_CHILD(this), + FIRST_CHILD(this)->fops->fxattrop, + fd, flags, dict); + + return 0; +} + +int32_t +trace_lookup (call_frame_t *frame, + xlator_t *this, + loc_t *loc, + dict_t *xattr_req) +{ + ERR_EINVAL_NORETURN (!this || !loc); + + if (trace_fop_names[GF_FOP_LOOKUP].enabled) { + /* TODO: print all the keys mentioned in xattr_req */ + gf_log (this->name, GF_LOG_NORMAL, + "%"PRId64": (loc {path=%s, ino=%"PRIu64"})", + frame->root->unique, loc->path, + loc->inode->ino); + } + + STACK_WIND (frame, trace_lookup_cbk, + FIRST_CHILD(this), + FIRST_CHILD(this)->fops->lookup, + loc, xattr_req); + + return 0; +} + +int32_t +trace_stat (call_frame_t *frame, + xlator_t *this, + loc_t *loc) +{ + ERR_EINVAL_NORETURN (!this || !loc ); + + + if (trace_fop_names[GF_FOP_STAT].enabled) { + gf_log (this->name, GF_LOG_NORMAL, + "%"PRId64": (loc {path=%s, ino=%"PRIu64"})", + frame->root->unique, loc->path, loc->inode->ino); + } + + STACK_WIND (frame, + trace_stat_cbk, + FIRST_CHILD(this), + FIRST_CHILD(this)->fops->stat, + loc); + + return 0; +} + +int32_t +trace_readlink (call_frame_t *frame, + xlator_t *this, + loc_t *loc, + size_t size) +{ + ERR_EINVAL_NORETURN (!this || !loc || (size < 1)); + + if (trace_fop_names[GF_FOP_READLINK].enabled) { + gf_log (this->name, GF_LOG_NORMAL, + "%"PRId64": (loc {path=%s, ino=%"PRIu64"}, size=%"GF_PRI_SIZET")", + frame->root->unique, loc->path, loc->inode->ino, size); + } + + STACK_WIND (frame, + trace_readlink_cbk, + FIRST_CHILD(this), + FIRST_CHILD(this)->fops->readlink, + loc, + size); + + return 0; +} + +int32_t +trace_mknod (call_frame_t *frame, + xlator_t *this, + loc_t *loc, + mode_t mode, + dev_t dev) +{ + ERR_EINVAL_NORETURN (!this || !loc->path); + + if (trace_fop_names[GF_FOP_MKNOD].enabled) { + gf_log (this->name, GF_LOG_NORMAL, + "%"PRId64": (loc {path=%s, ino=%"PRIu64"}, mode=%d, dev=%"GF_PRI_DEV")", + frame->root->unique, loc->path, loc->inode->ino, mode, dev); + } + + STACK_WIND (frame, + trace_mknod_cbk, + FIRST_CHILD(this), + FIRST_CHILD(this)->fops->mknod, + loc, + mode, + dev); + + return 0; +} + +int32_t +trace_mkdir (call_frame_t *frame, + xlator_t *this, + loc_t *loc, + mode_t mode) +{ + ERR_EINVAL_NORETURN (!this || !loc || !loc->path); + + if (trace_fop_names[GF_FOP_MKDIR].enabled) { + gf_log (this->name, GF_LOG_NORMAL, + "%"PRId64": (path=%s, ino=%"PRIu64", mode=%d)", + frame->root->unique, loc->path, + ((loc->inode)? loc->inode->ino : 0), mode); + } + + STACK_WIND (frame, + trace_mkdir_cbk, + FIRST_CHILD(this), + FIRST_CHILD(this)->fops->mkdir, + loc, + mode); + return 0; +} + +int32_t +trace_unlink (call_frame_t *frame, + xlator_t *this, + loc_t *loc) +{ + ERR_EINVAL_NORETURN (!this || !loc); + + if (trace_fop_names[GF_FOP_UNLINK].enabled) { + gf_log (this->name, GF_LOG_NORMAL, + "%"PRId64": (loc {path=%s, ino=%"PRIu64"})", + frame->root->unique, loc->path, loc->inode->ino); + } + + STACK_WIND (frame, + trace_unlink_cbk, + FIRST_CHILD(this), + FIRST_CHILD(this)->fops->unlink, + loc); + return 0; +} + +int32_t +trace_rmdir (call_frame_t *frame, + xlator_t *this, + loc_t *loc) +{ + ERR_EINVAL_NORETURN (!this || !loc); + + if (trace_fop_names[GF_FOP_RMDIR].enabled) { + gf_log (this->name, GF_LOG_NORMAL, + "%"PRId64": (loc {path=%s, ino=%"PRIu64"})", + frame->root->unique, loc->path, loc->inode->ino); + } + + STACK_WIND (frame, + trace_rmdir_cbk, + FIRST_CHILD(this), + FIRST_CHILD(this)->fops->rmdir, + loc); + + return 0; +} + +int32_t +trace_symlink (call_frame_t *frame, + xlator_t *this, + const char *linkpath, + loc_t *loc) +{ + ERR_EINVAL_NORETURN (!this || !linkpath || !loc || !loc->path); + + if (trace_fop_names[GF_FOP_SYMLINK].enabled) { + gf_log (this->name, GF_LOG_NORMAL, + "%"PRId64": (linkpath=%s, loc {path=%s, ino=%"PRIu64"})", + frame->root->unique, linkpath, loc->path, + ((loc->inode)? loc->inode->ino : 0)); + } + + STACK_WIND (frame, + trace_symlink_cbk, + FIRST_CHILD(this), + FIRST_CHILD(this)->fops->symlink, + linkpath, + loc); + + return 0; +} + +int32_t +trace_rename (call_frame_t *frame, + xlator_t *this, + loc_t *oldloc, + loc_t *newloc) +{ + ERR_EINVAL_NORETURN (!this || !oldloc || !newloc); + + if (trace_fop_names[GF_FOP_RENAME].enabled) { + gf_log (this->name, GF_LOG_NORMAL, + "%"PRId64": (oldloc {path=%s, ino=%"PRIu64"}, " + "newloc{path=%s, ino=%"PRIu64"})", + frame->root->unique, oldloc->path, oldloc->ino, + newloc->path, newloc->ino); + } + + STACK_WIND (frame, + trace_rename_cbk, + FIRST_CHILD(this), + FIRST_CHILD(this)->fops->rename, + oldloc, + newloc); + + return 0; +} + +int32_t +trace_link (call_frame_t *frame, + xlator_t *this, + loc_t *oldloc, + loc_t *newloc) +{ + ERR_EINVAL_NORETURN (!this || !oldloc || !newloc); + + if (trace_fop_names[GF_FOP_LINK].enabled) { + gf_log (this->name, GF_LOG_NORMAL, + "%"PRId64": (oldloc {path=%s, ino=%"PRIu64"}, " + "newloc {path=%s, ino=%"PRIu64"})", + frame->root->unique, oldloc->path, oldloc->inode->ino, + newloc->path, newloc->inode->ino); + } + + STACK_WIND (frame, + trace_link_cbk, + FIRST_CHILD(this), + FIRST_CHILD(this)->fops->link, + oldloc, + newloc); + return 0; +} + +int32_t +trace_chmod (call_frame_t *frame, + xlator_t *this, + loc_t *loc, + mode_t mode) +{ + ERR_EINVAL_NORETURN (!this || !loc); + + if (trace_fop_names[GF_FOP_CHMOD].enabled) { + gf_log (this->name, GF_LOG_NORMAL, + "%"PRId64": (loc {path=%s, ino=%"PRIu64"}, mode=%o)", + frame->root->unique, loc->path, loc->inode->ino, mode); + } + + STACK_WIND (frame, + trace_chmod_cbk, + FIRST_CHILD(this), + FIRST_CHILD(this)->fops->chmod, + loc, + mode); + + return 0; +} + +int32_t +trace_chown (call_frame_t *frame, + xlator_t *this, + loc_t *loc, + uid_t uid, + gid_t gid) +{ + ERR_EINVAL_NORETURN (!this || !loc); + + if (trace_fop_names[GF_FOP_CHOWN].enabled) { + gf_log (this->name, GF_LOG_NORMAL, + "%"PRId64": (loc {path=%s, ino=%"PRIu64"}, uid=%d, gid=%d)", + frame->root->unique, loc->path, loc->inode->ino, uid, gid); + } + + STACK_WIND (frame, + trace_chown_cbk, + FIRST_CHILD(this), + FIRST_CHILD(this)->fops->chown, + loc, + uid, + gid); + + return 0; +} + +int32_t +trace_truncate (call_frame_t *frame, + xlator_t *this, + loc_t *loc, + off_t offset) +{ + ERR_EINVAL_NORETURN (!this || !loc); + + if (trace_fop_names[GF_FOP_TRUNCATE].enabled) { + gf_log (this->name, GF_LOG_NORMAL, + "%"PRId64": (loc {path=%s, ino=%"PRIu64"}, offset=%"PRId64")", + frame->root->unique, loc->path, loc->inode->ino, offset); + } + + STACK_WIND (frame, + trace_truncate_cbk, + FIRST_CHILD(this), + FIRST_CHILD(this)->fops->truncate, + loc, + offset); + + return 0; +} + +int32_t +trace_utimens (call_frame_t *frame, + xlator_t *this, + loc_t *loc, + struct timespec tv[2]) +{ + char actime_str[256]; + char modtime_str[256]; + + ERR_EINVAL_NORETURN (!this || !loc || !tv); + + if (trace_fop_names[GF_FOP_UTIMENS].enabled) { + strftime (actime_str, 256, "[%b %d %H:%M:%S]", localtime (&tv[0].tv_sec)); + strftime (modtime_str, 256, "[%b %d %H:%M:%S]", localtime (&tv[1].tv_sec)); + + gf_log (this->name, GF_LOG_NORMAL, + "%"PRId64": (loc {path=%s, ino=%"PRIu64"}, " + "*tv=%p {actime=%s, modtime=%s})", + frame->root->unique, loc->path, loc->inode->ino, + tv, actime_str, modtime_str); + } + + STACK_WIND (frame, + trace_utimens_cbk, + FIRST_CHILD(this), + FIRST_CHILD(this)->fops->utimens, + loc, + tv); + + return 0; +} + +int32_t +trace_open (call_frame_t *frame, + xlator_t *this, + loc_t *loc, + int32_t flags, + fd_t *fd) +{ + ERR_EINVAL_NORETURN (!this || !loc); + + if (trace_fop_names[GF_FOP_OPEN].enabled) { + gf_log (this->name, GF_LOG_NORMAL, + "%"PRId64": (loc {path=%s, ino=%"PRIu64"}, flags=%d, fd=%p)", + frame->root->unique, loc->path, loc->inode->ino, flags, fd); + } + + STACK_WIND (frame, + trace_open_cbk, + FIRST_CHILD(this), + FIRST_CHILD(this)->fops->open, + loc, + flags, + fd); + return 0; +} + +int32_t +trace_create (call_frame_t *frame, + xlator_t *this, + loc_t *loc, + int32_t flags, + mode_t mode, + fd_t *fd) +{ + ERR_EINVAL_NORETURN (!this || !loc->path); + + if (trace_fop_names[GF_FOP_CREATE].enabled) { + gf_log (this->name, GF_LOG_NORMAL, + "%"PRId64": (loc {path=%s, ino=%"PRIu64"}, flags=0%o mode=0%o)", + frame->root->unique, loc->path, loc->inode->ino, flags, mode); + } + + STACK_WIND (frame, + trace_create_cbk, + FIRST_CHILD(this), + FIRST_CHILD(this)->fops->create, + loc, + flags, + mode, + fd); + return 0; +} + +int32_t +trace_readv (call_frame_t *frame, + xlator_t *this, + fd_t *fd, + size_t size, + off_t offset) +{ + ERR_EINVAL_NORETURN (!this || !fd || (size < 1)); + + if (trace_fop_names[GF_FOP_READ].enabled) { + gf_log (this->name, GF_LOG_NORMAL, + "%"PRId64": (*fd=%p, size=%"GF_PRI_SIZET", offset=%"PRId64")", + frame->root->unique, fd, size, offset); + } + + STACK_WIND (frame, + trace_readv_cbk, + FIRST_CHILD(this), + FIRST_CHILD(this)->fops->readv, + fd, + size, + offset); + return 0; +} + +int32_t +trace_writev (call_frame_t *frame, + xlator_t *this, + fd_t *fd, + struct iovec *vector, + int32_t count, + off_t offset) +{ + ERR_EINVAL_NORETURN (!this || !fd || !vector || (count < 1)); + + if (trace_fop_names[GF_FOP_WRITE].enabled) { + gf_log (this->name, GF_LOG_NORMAL, + "%"PRId64": (*fd=%p, *vector=%p, count=%d, offset=%"PRId64")", + frame->root->unique, fd, vector, count, offset); + } + + STACK_WIND (frame, + trace_writev_cbk, + FIRST_CHILD(this), + FIRST_CHILD(this)->fops->writev, + fd, + vector, + count, + offset); + return 0; +} + +int32_t +trace_statfs (call_frame_t *frame, + xlator_t *this, + loc_t *loc) +{ + ERR_EINVAL_NORETURN (!this || !loc); + + if (trace_fop_names[GF_FOP_STATFS].enabled) { + gf_log (this->name, GF_LOG_NORMAL, + "%"PRId64": (loc {path=%s, ino=%"PRIu64"})", + frame->root->unique, loc->path, + ((loc->inode)? loc->inode->ino : 0)); + } + + STACK_WIND (frame, + trace_statfs_cbk, + FIRST_CHILD(this), FIRST_CHILD(this)->fops->statfs, + loc); + return 0; +} + +int32_t +trace_flush (call_frame_t *frame, + xlator_t *this, + fd_t *fd) +{ + ERR_EINVAL_NORETURN (!this || !fd); + + if (trace_fop_names[GF_FOP_FLUSH].enabled) { + gf_log (this->name, GF_LOG_NORMAL, + "%"PRId64": (*fd=%p)", + frame->root->unique, fd); + } + + STACK_WIND (frame, + trace_flush_cbk, + FIRST_CHILD(this), + FIRST_CHILD(this)->fops->flush, + fd); + return 0; +} + + +int32_t +trace_fsync (call_frame_t *frame, + xlator_t *this, + fd_t *fd, + int32_t flags) +{ + ERR_EINVAL_NORETURN (!this || !fd); + + if (trace_fop_names[GF_FOP_FSYNC].enabled) { + gf_log (this->name, GF_LOG_NORMAL, + "%"PRId64": (flags=%d, *fd=%p)", + frame->root->unique, flags, fd); + } + + STACK_WIND (frame, + trace_fsync_cbk, + FIRST_CHILD(this), + FIRST_CHILD(this)->fops->fsync, + fd, + flags); + return 0; +} + +int32_t +trace_setxattr (call_frame_t *frame, + xlator_t *this, + loc_t *loc, + dict_t *dict, + int32_t flags) +{ + ERR_EINVAL_NORETURN (!this || !loc || !dict); + + if (trace_fop_names[GF_FOP_SETXATTR].enabled) { + gf_log (this->name, GF_LOG_NORMAL, + "%"PRId64": (loc {path=%s, ino=%"PRIu64"}, dict=%p, flags=%d)", + frame->root->unique, loc->path, + ((loc->inode)? loc->inode->ino : 0), dict, flags); + } + + STACK_WIND (frame, + trace_setxattr_cbk, + FIRST_CHILD(this), + FIRST_CHILD(this)->fops->setxattr, + loc, + dict, + flags); + return 0; +} + +int32_t +trace_getxattr (call_frame_t *frame, + xlator_t *this, + loc_t *loc, + const char *name) +{ + ERR_EINVAL_NORETURN (!this || !loc); + + if (trace_fop_names[GF_FOP_GETXATTR].enabled) { + gf_log (this->name, GF_LOG_NORMAL, + "%"PRId64": (loc {path=%s, ino=%"PRIu64"}), name=%s", + frame->root->unique, loc->path, + ((loc->inode)? loc->inode->ino : 0), name); + } + + STACK_WIND (frame, + trace_getxattr_cbk, + FIRST_CHILD(this), + FIRST_CHILD(this)->fops->getxattr, + loc, + name); + return 0; +} + +int32_t +trace_removexattr (call_frame_t *frame, + xlator_t *this, + loc_t *loc, + const char *name) +{ + ERR_EINVAL_NORETURN (!this || !loc || !name); + + if (trace_fop_names[GF_FOP_REMOVEXATTR].enabled) { + gf_log (this->name, GF_LOG_NORMAL, + "%"PRId64": (loc {path=%s, ino=%"PRIu64"}, name=%s)", + frame->root->unique, loc->path, + ((loc->inode)? loc->inode->ino : 0), name); + } + + STACK_WIND (frame, + trace_removexattr_cbk, + FIRST_CHILD(this), + FIRST_CHILD(this)->fops->removexattr, + loc, + name); + + return 0; +} + +int32_t +trace_opendir (call_frame_t *frame, + xlator_t *this, + loc_t *loc, + fd_t *fd) +{ + ERR_EINVAL_NORETURN (!this || !loc ); + + if (trace_fop_names[GF_FOP_OPENDIR].enabled) { + gf_log (this->name, GF_LOG_NORMAL, + "%"PRId64":( loc {path=%s, ino=%"PRIu64"}, fd=%p)", + frame->root->unique, loc->path, loc->inode->ino, fd); + } + + STACK_WIND (frame, + trace_opendir_cbk, + FIRST_CHILD(this), + FIRST_CHILD(this)->fops->opendir, + loc, + fd); + return 0; +} + +int32_t +trace_getdents (call_frame_t *frame, + xlator_t *this, + fd_t *fd, + size_t size, + off_t offset, + int32_t flag) +{ + ERR_EINVAL_NORETURN (!this || !fd); + + if (trace_fop_names[GF_FOP_GETDENTS].enabled) { + gf_log (this->name, GF_LOG_NORMAL, + "%"PRId64": (fd=%p, size=%"GF_PRI_SIZET", offset=%"PRId64", flag=0x%x)", + frame->root->unique, fd, size, offset, flag); + } + + STACK_WIND (frame, + trace_getdents_cbk, + FIRST_CHILD(this), + FIRST_CHILD(this)->fops->getdents, + fd, + size, + offset, + flag); + return 0; +} + + +int32_t +trace_readdir (call_frame_t *frame, + xlator_t *this, + fd_t *fd, + size_t size, + off_t offset) +{ + ERR_EINVAL_NORETURN (!this || !fd); + + if (trace_fop_names[GF_FOP_READDIR].enabled) { + gf_log (this->name, GF_LOG_NORMAL, + "%"PRId64": (fd=%p, size=%"GF_PRI_SIZET", offset=%"PRId64")", + frame->root->unique, fd, size, offset); + } + + STACK_WIND (frame, + trace_readdir_cbk, + FIRST_CHILD(this), + FIRST_CHILD(this)->fops->readdir, + fd, + size, + offset); + + return 0; +} + + +int32_t +trace_fsyncdir (call_frame_t *frame, + xlator_t *this, + fd_t *fd, + int32_t datasync) +{ + ERR_EINVAL_NORETURN (!this || !fd); + + if (trace_fop_names[GF_FOP_FSYNCDIR].enabled) { + gf_log (this->name, GF_LOG_NORMAL, + "%"PRId64": (datasync=%d, *fd=%p)", + frame->root->unique, datasync, fd); + } + + STACK_WIND (frame, + trace_fsyncdir_cbk, + FIRST_CHILD(this), + FIRST_CHILD(this)->fops->fsyncdir, + fd, + datasync); + return 0; +} + +int32_t +trace_access (call_frame_t *frame, + xlator_t *this, + loc_t *loc, + int32_t mask) +{ + ERR_EINVAL_NORETURN (!this || !loc); + + if (trace_fop_names[GF_FOP_ACCESS].enabled) { + gf_log (this->name, GF_LOG_NORMAL, + "%"PRId64": (*loc {path=%s, ino=%"PRIu64"}, mask=0%o)", + frame->root->unique, loc->path, + ((loc->inode)? loc->inode->ino : 0), mask); + } + + STACK_WIND (frame, + trace_access_cbk, + FIRST_CHILD(this), + FIRST_CHILD(this)->fops->access, + loc, + mask); + return 0; +} + +int32_t +trace_ftruncate (call_frame_t *frame, + xlator_t *this, + fd_t *fd, + off_t offset) +{ + ERR_EINVAL_NORETURN (!this || !fd); + + if (trace_fop_names[GF_FOP_FTRUNCATE].enabled) { + gf_log (this->name, GF_LOG_NORMAL, + "%"PRId64": (offset=%"PRId64", *fd=%p)", + frame->root->unique, offset, fd); + } + + STACK_WIND (frame, + trace_ftruncate_cbk, + FIRST_CHILD(this), + FIRST_CHILD(this)->fops->ftruncate, + fd, + offset); + + return 0; +} + +int32_t +trace_fchown (call_frame_t *frame, + xlator_t *this, + fd_t *fd, + uid_t uid, + gid_t gid) +{ + ERR_EINVAL_NORETURN (!this || !fd); + + if (trace_fop_names[GF_FOP_FCHOWN].enabled) { + gf_log (this->name, GF_LOG_NORMAL, + "%"PRId64": (*fd=%p, uid=%d, gid=%d)", + frame->root->unique, fd, uid, gid); + } + + STACK_WIND (frame, + trace_fchown_cbk, + FIRST_CHILD(this), + FIRST_CHILD(this)->fops->fchown, + fd, + uid, + gid); + return 0; +} + +int32_t +trace_fchmod (call_frame_t *frame, + xlator_t *this, + fd_t *fd, + mode_t mode) +{ + ERR_EINVAL_NORETURN (!this || !fd); + + if (trace_fop_names[GF_FOP_FCHMOD].enabled) { + gf_log (this->name, GF_LOG_NORMAL, + "%"PRId64": (mode=%o, *fd=%p)", + frame->root->unique, mode, fd); + } + + STACK_WIND (frame, + trace_fchmod_cbk, + FIRST_CHILD(this), + FIRST_CHILD(this)->fops->fchmod, + fd, + mode); + return 0; +} + +int32_t +trace_fstat (call_frame_t *frame, + xlator_t *this, + fd_t *fd) +{ + ERR_EINVAL_NORETURN (!this || !fd); + + if (trace_fop_names[GF_FOP_FSTAT].enabled) { + gf_log (this->name, GF_LOG_NORMAL, + "%"PRId64": (*fd=%p)", + frame->root->unique, fd); + } + + STACK_WIND (frame, + trace_fstat_cbk, + FIRST_CHILD(this), + FIRST_CHILD(this)->fops->fstat, + fd); + return 0; +} + +int32_t +trace_lk (call_frame_t *frame, + xlator_t *this, + fd_t *fd, + int32_t cmd, + struct flock *lock) +{ + ERR_EINVAL_NORETURN (!this || !fd); + + if (trace_fop_names[GF_FOP_LK].enabled) { + gf_log (this->name, GF_LOG_NORMAL, + "%"PRId64": (*fd=%p, cmd=%d, lock {l_type=%d, l_whence=%d, " + "l_start=%"PRId64", l_len=%"PRId64", l_pid=%u})", + frame->root->unique, fd, cmd, lock->l_type, lock->l_whence, + lock->l_start, lock->l_len, lock->l_pid); + } + + STACK_WIND (frame, + trace_lk_cbk, + FIRST_CHILD(this), + FIRST_CHILD(this)->fops->lk, + fd, + cmd, + lock); + return 0; +} + +int32_t +trace_setdents (call_frame_t *frame, + xlator_t *this, + fd_t *fd, + int32_t flags, + dir_entry_t *entries, + int32_t count) +{ + if (trace_fop_names[GF_FOP_SETDENTS].enabled) { + gf_log (this->name, GF_LOG_NORMAL, + "%"PRId64": (*fd=%p, flags=%d, count=%d", + frame->root->unique, fd, flags, count); + } + + STACK_WIND (frame, + trace_setdents_cbk, + FIRST_CHILD(this), + FIRST_CHILD(this)->fops->setdents, + fd, + flags, + entries, + count); + return 0; +} + + +int32_t +trace_checksum_cbk (call_frame_t *frame, + void *cookie, + xlator_t *this, + int32_t op_ret, + int32_t op_errno, + uint8_t *fchecksum, + uint8_t *dchecksum) +{ + gf_log (this->name, GF_LOG_NORMAL, + "%"PRId64": op_ret (%d), op_errno(%d)", + frame->root->unique, op_ret, op_errno); + + STACK_UNWIND (frame, op_ret, op_errno, fchecksum, dchecksum); + + return 0; +} + +int32_t +trace_checksum (call_frame_t *frame, + xlator_t *this, + loc_t *loc, + int32_t flag) +{ + gf_log (this->name, GF_LOG_NORMAL, + "%"PRId64": loc->path (%s) flag (%d)", + frame->root->unique, loc->path, flag); + + STACK_WIND (frame, + trace_checksum_cbk, + FIRST_CHILD(this), + FIRST_CHILD(this)->fops->checksum, + loc, + flag); + + return 0; +} + + +int32_t +trace_stats_cbk (call_frame_t *frame, + void *cookie, + xlator_t *this, + int32_t op_ret, + int32_t op_errno, + struct xlator_stats *stats) +{ + gf_log (this->name, GF_LOG_NORMAL, + "%"PRId64": op_ret (%d), op_errno(%d)", + frame->root->unique, op_ret, op_errno); + + STACK_UNWIND (frame, op_ret, op_errno, stats); + return 0; +} + +int32_t +trace_stats (call_frame_t *frame, + xlator_t *this, + int32_t flags) +{ + ERR_EINVAL_NORETURN (!this); + + gf_log (this->name, GF_LOG_NORMAL, + "%"PRId64": (flags=%d)", + frame->root->unique, flags); + + STACK_WIND (frame, + trace_stats_cbk, + FIRST_CHILD(this), + FIRST_CHILD(this)->mops->stats, + flags); + + return 0; +} + +void +enable_all_calls (int enabled) +{ + int i; + for (i = 0; i < GF_FOP_MAXVALUE; i++) + trace_fop_names[i].enabled = enabled; +} + +void +enable_call (const char *name, int enabled) +{ + int i; + for (i = 0; i < GF_FOP_MAXVALUE; i++) + if (!strcasecmp(trace_fop_names[i].name, name)) + trace_fop_names[i].enabled = enabled; +} + + +/* + include = 1 for "include-ops" + = 0 for "exclude-ops" +*/ +void +process_call_list (const char *list, int include) +{ + enable_all_calls (include ? 0 : 1); + + char *call = strsep ((char **)&list, ","); + while (call) { + enable_call (call, include); + call = strsep ((char **)&list, ","); + } +} + + +int32_t +init (xlator_t *this) +{ + dict_t *options = this->options; + char *includes = NULL, *excludes = NULL; + + if (!this) + return -1; + + if (!this->children || this->children->next) { + gf_log (this->name, GF_LOG_ERROR, + "trace translator requires one subvolume"); + return -1; + } + if (!this->parents) { + gf_log (this->name, GF_LOG_WARNING, + "dangling volume. check volfile "); + } + + + includes = data_to_str (dict_get (options, "include-ops")); + excludes = data_to_str (dict_get (options, "exclude-ops")); + + { + int i; + for (i = 0; i < GF_FOP_MAXVALUE; i++) { + trace_fop_names[i].name = (gf_fop_list[i] ? + gf_fop_list[i] : ":O"); + trace_fop_names[i].enabled = 1; + } + } + + if (includes && excludes) { + gf_log (this->name, + GF_LOG_ERROR, + "must specify only one of 'include-ops' and 'exclude-ops'"); + return -1; + } + if (includes) + process_call_list (includes, 1); + if (excludes) + process_call_list (excludes, 0); + + gf_log_set_loglevel (GF_LOG_NORMAL); + + /* Set this translator's inode table pointer to child node's pointer. */ + this->itable = FIRST_CHILD (this)->itable; + + return 0; +} + +void +fini (xlator_t *this) +{ + if (!this) + return; + + gf_log (this->name, GF_LOG_NORMAL, + "trace translator unloaded"); + return; +} + +struct xlator_fops fops = { + .stat = trace_stat, + .readlink = trace_readlink, + .mknod = trace_mknod, + .mkdir = trace_mkdir, + .unlink = trace_unlink, + .rmdir = trace_rmdir, + .symlink = trace_symlink, + .rename = trace_rename, + .link = trace_link, + .chmod = trace_chmod, + .chown = trace_chown, + .truncate = trace_truncate, + .utimens = trace_utimens, + .open = trace_open, + .readv = trace_readv, + .writev = trace_writev, + .statfs = trace_statfs, + .flush = trace_flush, + .fsync = trace_fsync, + .setxattr = trace_setxattr, + .getxattr = trace_getxattr, + .removexattr = trace_removexattr, + .opendir = trace_opendir, + .readdir = trace_readdir, + .fsyncdir = trace_fsyncdir, + .access = trace_access, + .ftruncate = trace_ftruncate, + .fstat = trace_fstat, + .create = trace_create, + .fchown = trace_fchown, + .fchmod = trace_fchmod, + .lk = trace_lk, + .inodelk = trace_inodelk, + .finodelk = trace_finodelk, + .entrylk = trace_entrylk, + .lookup = trace_lookup, + .setdents = trace_setdents, + .getdents = trace_getdents, + .checksum = trace_checksum, + .xattrop = trace_xattrop, + .fxattrop = trace_fxattrop, +}; + +struct xlator_mops mops = { + .stats = trace_stats, +}; + +struct xlator_cbks cbks = { +}; + +struct volume_options options[] = { + { .key = {"include-ops", "include"}, + .type = GF_OPTION_TYPE_STR, + /*.value = { ""} */ + }, + { .key = {"exclude-ops", "exclude"}, + .type = GF_OPTION_TYPE_STR + /*.value = { ""} */ + }, + { .key = {NULL} }, +}; + |