summaryrefslogtreecommitdiffstats
path: root/xlators/debug
diff options
context:
space:
mode:
authorVikas Gorur <vikas@zresearch.com>2009-02-18 17:36:07 +0530
committerVikas Gorur <vikas@zresearch.com>2009-02-18 17:36:07 +0530
commit77adf4cd648dce41f89469dd185deec6b6b53a0b (patch)
tree02e155a5753b398ee572b45793f889b538efab6b /xlators/debug
parentf3b2e6580e5663292ee113c741343c8a43ee133f (diff)
Added all files
Diffstat (limited to 'xlators/debug')
-rw-r--r--xlators/debug/Makefile.am3
-rw-r--r--xlators/debug/error-gen/Makefile.am3
-rw-r--r--xlators/debug/error-gen/src/Makefile.am14
-rw-r--r--xlators/debug/error-gen/src/error-gen.c1780
-rw-r--r--xlators/debug/trace/Makefile.am3
-rw-r--r--xlators/debug/trace/src/Makefile.am14
-rw-r--r--xlators/debug/trace/src/trace.c2321
7 files changed, 4138 insertions, 0 deletions
diff --git a/xlators/debug/Makefile.am b/xlators/debug/Makefile.am
new file mode 100644
index 0000000..16cf893
--- /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 0000000..d471a3f
--- /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 0000000..1bd7f33
--- /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 0000000..9c0b325
--- /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 0000000..d471a3f
--- /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 0000000..0f1679a
--- /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 0000000..3ccf11a
--- /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} },
+};
+