diff options
Diffstat (limited to 'xlators/debug')
| -rw-r--r-- | xlators/debug/error-gen/src/Makefile.am | 7 | ||||
| -rw-r--r-- | xlators/debug/error-gen/src/error-gen-mem-types.h | 20 | ||||
| -rw-r--r-- | xlators/debug/error-gen/src/error-gen.c | 914 | ||||
| -rw-r--r-- | xlators/debug/error-gen/src/error-gen.h | 36 | ||||
| -rw-r--r-- | xlators/debug/io-stats/src/Makefile.am | 7 | ||||
| -rw-r--r-- | xlators/debug/io-stats/src/io-stats-mem-types.h | 21 | ||||
| -rw-r--r-- | xlators/debug/io-stats/src/io-stats.c | 780 | ||||
| -rw-r--r-- | xlators/debug/trace/src/Makefile.am | 8 | ||||
| -rw-r--r-- | xlators/debug/trace/src/trace-mem-types.h | 21 | ||||
| -rw-r--r-- | xlators/debug/trace/src/trace.c | 3078 | ||||
| -rw-r--r-- | xlators/debug/trace/src/trace.h | 98 |
11 files changed, 3053 insertions, 1937 deletions
diff --git a/xlators/debug/error-gen/src/Makefile.am b/xlators/debug/error-gen/src/Makefile.am index df9080358..5075c59a8 100644 --- a/xlators/debug/error-gen/src/Makefile.am +++ b/xlators/debug/error-gen/src/Makefile.am @@ -2,15 +2,16 @@ xlator_LTLIBRARIES = error-gen.la xlatordir = $(libdir)/glusterfs/$(PACKAGE_VERSION)/xlator/debug -error_gen_la_LDFLAGS = -module -avoidversion +error_gen_la_LDFLAGS = -module -avoid-version error_gen_la_SOURCES = error-gen.c error_gen_la_LIBADD = $(top_builddir)/libglusterfs/src/libglusterfs.la noinst_HEADERS = error-gen.h error-gen-mem-types.h -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) +AM_CPPFLAGS = $(GF_CPPFLAGS) -I$(top_srcdir)/libglusterfs/src + +AM_CFLAGS = -Wall $(GF_CFLAGS) CLEANFILES = diff --git a/xlators/debug/error-gen/src/error-gen-mem-types.h b/xlators/debug/error-gen/src/error-gen-mem-types.h index b643dc5f7..f02280535 100644 --- a/xlators/debug/error-gen/src/error-gen-mem-types.h +++ b/xlators/debug/error-gen/src/error-gen-mem-types.h @@ -1,23 +1,13 @@ /* - Copyright (c) 2008-2011 Gluster, Inc. <http://www.gluster.com> + Copyright (c) 2008-2012 Red Hat, Inc. <http://www.redhat.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/>. + This file is licensed to you under your choice of the GNU Lesser + General Public License, version 3 or any later version (LGPLv3 or + later), or the GNU General Public License, version 2 (GPLv2), in all + cases as published by the Free Software Foundation. */ - #ifndef __ERROR_GEN_MEM_TYPES_H__ #define __ERROR_GEN_MEM_TYPES_H__ diff --git a/xlators/debug/error-gen/src/error-gen.c b/xlators/debug/error-gen/src/error-gen.c index e44baf5b7..ec0874b35 100644 --- a/xlators/debug/error-gen/src/error-gen.c +++ b/xlators/debug/error-gen/src/error-gen.c @@ -1,22 +1,12 @@ /* - Copyright (c) 2008-2011 Gluster, Inc. <http://www.gluster.com> - This file is part of GlusterFS. - - GlusterFS is free software; you can redistribute it and/or modify - it under the terms of the GNU General Public License as published - by the Free Software Foundation; either version 3 of the License, - or (at your option) any later version. - - GlusterFS is distributed in the hope that it will be useful, but - WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - General Public License for more details. - - You should have received a copy of the GNU General Public License - along with this program. If not, see - <http://www.gnu.org/licenses/>. -*/ + Copyright (c) 2008-2012 Red Hat, Inc. <http://www.redhat.com> + This file is part of GlusterFS. + This file is licensed to you under your choice of the GNU Lesser + General Public License, version 3 or any later version (LGPLv3 or + later), or the GNU General Public License, version 2 (GPLv2), in all + cases as published by the Free Software Foundation. +*/ #ifndef _CONFIG_H #define _CONFIG_H #include "config.h" @@ -24,6 +14,7 @@ #include "xlator.h" #include "error-gen.h" +#include "statedump.h" sys_error_t error_no_list[] = { [GF_FOP_LOOKUP] = { .error_no_count = 4, @@ -91,9 +82,10 @@ sys_error_t error_no_list[] = { [GF_FOP_READ] = { .error_no_count = 5, .error_no = {EINVAL,EBADF,EFAULT,EISDIR, ENAMETOOLONG}}, - [GF_FOP_WRITE] = { .error_no_count = 5, + [GF_FOP_WRITE] = { .error_no_count = 7, .error_no = {EINVAL,EBADF,EFAULT,EISDIR, - ENAMETOOLONG}}, + ENAMETOOLONG,ENOSPC, + GF_ERROR_SHORT_WRITE}}, [GF_FOP_STATFS] = {.error_no_count = 10, .error_no = {EACCES,EBADF,EFAULT,EINTR, EIO,ENAMETOOLONG,ENOENT, @@ -246,6 +238,8 @@ conv_errno_to_int (char **error_no) return EINTR; else if (!strcmp ((*error_no), "EFBIG")) return EFBIG; + else if (!strcmp((*error_no), "GF_ERROR_SHORT_WRITE")) + return GF_ERROR_SHORT_WRITE; else return EAGAIN; } @@ -387,17 +381,17 @@ error_gen (xlator_t *this, int op_no) int error_gen_lookup_cbk (call_frame_t *frame, void *cookie, xlator_t *this, int32_t op_ret, int32_t op_errno, inode_t *inode, - struct iatt *buf, dict_t *dict, struct iatt *postparent) + struct iatt *buf, dict_t *xdata, struct iatt *postparent) { STACK_UNWIND_STRICT (lookup, frame, op_ret, op_errno, inode, - buf, dict, postparent); - return 0; + buf, xdata, postparent); + return 0; } int error_gen_lookup (call_frame_t *frame, xlator_t *this, loc_t *loc, - dict_t *xattr_req) + dict_t *xdata) { int op_errno = 0; eg_t *egp = NULL; @@ -412,36 +406,28 @@ error_gen_lookup (call_frame_t *frame, xlator_t *this, loc_t *loc, if (op_errno) { GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno)); STACK_UNWIND_STRICT (lookup, frame, -1, op_errno, NULL, NULL, NULL, - NULL); - return 0; + NULL); + return 0; } STACK_WIND (frame, error_gen_lookup_cbk, FIRST_CHILD(this), FIRST_CHILD(this)->fops->lookup, - loc, xattr_req); - return 0; -} - - -int -error_gen_forget (xlator_t *this, inode_t *inode) -{ - return 0; + loc, xdata); + return 0; } int error_gen_stat_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, struct iatt *buf) + int32_t op_ret, int32_t op_errno, struct iatt *buf, dict_t *xdata) { - STACK_UNWIND_STRICT (stat, frame, op_ret, op_errno, buf); - - return 0; + STACK_UNWIND_STRICT (stat, frame, op_ret, op_errno, buf, xdata); + return 0; } int -error_gen_stat (call_frame_t *frame, xlator_t *this, loc_t *loc) +error_gen_stat (call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *xdata) { int op_errno = 0; eg_t *egp = NULL; @@ -455,32 +441,31 @@ error_gen_stat (call_frame_t *frame, xlator_t *this, loc_t *loc) if (op_errno) { GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno)); - STACK_UNWIND_STRICT (stat, frame, -1, op_errno, NULL); - return 0; + STACK_UNWIND_STRICT (stat, frame, -1, op_errno, NULL, xdata); + return 0; } STACK_WIND (frame, error_gen_stat_cbk, FIRST_CHILD(this), FIRST_CHILD(this)->fops->stat, - loc); - return 0; + loc, xdata); + return 0; } int error_gen_setattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this, int32_t op_ret, int32_t op_errno, - struct iatt *preop, struct iatt *postop) + struct iatt *preop, struct iatt *postop, dict_t *xdata) { - STACK_UNWIND_STRICT (setattr, frame, op_ret, op_errno, preop, postop); - - return 0; + STACK_UNWIND_STRICT (setattr, frame, op_ret, op_errno, preop, postop, xdata); + return 0; } int error_gen_setattr (call_frame_t *frame, xlator_t *this, loc_t *loc, - struct iatt *stbuf, int32_t valid) + struct iatt *stbuf, int32_t valid, dict_t *xdata) { int op_errno = 0; eg_t *egp = NULL; @@ -494,21 +479,21 @@ error_gen_setattr (call_frame_t *frame, xlator_t *this, loc_t *loc, if (op_errno) { GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno)); - STACK_UNWIND_STRICT (setattr, frame, -1, op_errno, NULL, NULL); - return 0; + STACK_UNWIND_STRICT (setattr, frame, -1, op_errno, NULL, NULL, xdata); + return 0; } STACK_WIND (frame, error_gen_setattr_cbk, FIRST_CHILD(this), FIRST_CHILD(this)->fops->setattr, - loc, stbuf, valid); - return 0; + loc, stbuf, valid, xdata); + return 0; } int error_gen_fsetattr (call_frame_t *frame, xlator_t *this, fd_t *fd, - struct iatt *stbuf, int32_t valid) + struct iatt *stbuf, int32_t valid, dict_t *xdata) { int op_errno = 0; eg_t *egp = NULL; @@ -522,32 +507,32 @@ error_gen_fsetattr (call_frame_t *frame, xlator_t *this, fd_t *fd, if (op_errno) { GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno)); - STACK_UNWIND_STRICT (fsetattr, frame, -1, op_errno, NULL, NULL); - return 0; + STACK_UNWIND_STRICT (fsetattr, frame, -1, op_errno, NULL, NULL, xdata); + return 0; } STACK_WIND (frame, error_gen_setattr_cbk, FIRST_CHILD(this), FIRST_CHILD(this)->fops->fsetattr, - fd, stbuf, valid); - return 0; + fd, stbuf, valid, xdata); + return 0; } int error_gen_truncate_cbk (call_frame_t *frame, void *cookie, xlator_t *this, int32_t op_ret, int32_t op_errno, - struct iatt *prebuf, struct iatt *postbuf) + struct iatt *prebuf, struct iatt *postbuf, dict_t *xdata) { STACK_UNWIND_STRICT (truncate, frame, op_ret, op_errno, - prebuf, postbuf); - return 0; + prebuf, postbuf, xdata); + return 0; } int error_gen_truncate (call_frame_t *frame, xlator_t *this, loc_t *loc, - off_t offset) + off_t offset, dict_t *xdata) { int op_errno = 0; eg_t *egp = NULL; @@ -562,32 +547,32 @@ error_gen_truncate (call_frame_t *frame, xlator_t *this, loc_t *loc, if (op_errno) { GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno)); STACK_UNWIND_STRICT (truncate, frame, -1, op_errno, - NULL, NULL); - return 0; + NULL, NULL, xdata); + return 0; } STACK_WIND (frame, error_gen_truncate_cbk, FIRST_CHILD(this), FIRST_CHILD(this)->fops->truncate, - loc, offset); - return 0; + loc, offset, xdata); + return 0; } int error_gen_ftruncate_cbk (call_frame_t *frame, void *cookie, xlator_t *this, int32_t op_ret, int32_t op_errno, struct iatt *prebuf, - struct iatt *postbuf) + struct iatt *postbuf, dict_t *xdata) { STACK_UNWIND_STRICT (ftruncate, frame, op_ret, op_errno, - prebuf, postbuf); - return 0; + prebuf, postbuf, xdata); + return 0; } int error_gen_ftruncate (call_frame_t *frame, xlator_t *this, fd_t *fd, - off_t offset) + off_t offset, dict_t *xdata) { int op_errno = 0; eg_t *egp =NULL; @@ -602,31 +587,30 @@ error_gen_ftruncate (call_frame_t *frame, xlator_t *this, fd_t *fd, if (op_errno) { GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno)); STACK_UNWIND_STRICT (ftruncate, frame, -1, op_errno, - NULL, NULL); - return 0; + NULL, NULL, xdata); + return 0; } STACK_WIND (frame, error_gen_ftruncate_cbk, FIRST_CHILD(this), FIRST_CHILD(this)->fops->ftruncate, - fd, offset); - return 0; + fd, offset, xdata); + return 0; } int error_gen_access_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno) + int32_t op_ret, int32_t op_errno, dict_t *xdata) { - STACK_UNWIND_STRICT (access, frame, op_ret, op_errno); - - return 0; + STACK_UNWIND_STRICT (access, frame, op_ret, op_errno, xdata); + return 0; } int error_gen_access (call_frame_t *frame, xlator_t *this, loc_t *loc, - int32_t mask) + int32_t mask, dict_t *xdata) { int op_errno = 0; eg_t *egp = NULL; @@ -640,31 +624,31 @@ error_gen_access (call_frame_t *frame, xlator_t *this, loc_t *loc, if (op_errno) { GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno)); - STACK_UNWIND_STRICT (access, frame, -1, op_errno); - return 0; + STACK_UNWIND_STRICT (access, frame, -1, op_errno, xdata); + return 0; } STACK_WIND (frame, error_gen_access_cbk, FIRST_CHILD(this), FIRST_CHILD(this)->fops->access, - loc, mask); - return 0; + loc, mask, xdata); + return 0; } int error_gen_readlink_cbk (call_frame_t *frame, void *cookie, xlator_t *this, int32_t op_ret, int32_t op_errno, - const char *path, struct iatt *sbuf) + const char *path, struct iatt *sbuf, dict_t *xdata) { - STACK_UNWIND_STRICT (readlink, frame, op_ret, op_errno, path, sbuf); - return 0; + STACK_UNWIND_STRICT (readlink, frame, op_ret, op_errno, path, sbuf, xdata); + return 0; } int error_gen_readlink (call_frame_t *frame, xlator_t *this, loc_t *loc, - size_t size) + size_t size, dict_t *xdata) { int op_errno = 0; eg_t *egp = NULL; @@ -678,15 +662,15 @@ error_gen_readlink (call_frame_t *frame, xlator_t *this, loc_t *loc, if (op_errno) { GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno)); - STACK_UNWIND_STRICT (readlink, frame, -1, op_errno, NULL, NULL); - return 0; + STACK_UNWIND_STRICT (readlink, frame, -1, op_errno, NULL, NULL, xdata); + return 0; } STACK_WIND (frame, error_gen_readlink_cbk, FIRST_CHILD(this), FIRST_CHILD(this)->fops->readlink, - loc, size); - return 0; + loc, size, xdata); + return 0; } @@ -694,18 +678,18 @@ int error_gen_mknod_cbk (call_frame_t *frame, void *cookie, xlator_t *this, int32_t op_ret, int32_t op_errno, inode_t *inode, struct iatt *buf, struct iatt *preparent, - struct iatt *postparent) + struct iatt *postparent, dict_t *xdata) { STACK_UNWIND_STRICT (mknod, frame, op_ret, op_errno, inode, buf, - preparent, postparent); - return 0; + preparent, postparent, xdata); + return 0; } int error_gen_mknod (call_frame_t *frame, xlator_t *this, loc_t *loc, - mode_t mode, dev_t rdev, dict_t *params) + mode_t mode, dev_t rdev, mode_t umask, dict_t *xdata) { int op_errno = 0; eg_t *egp = NULL; @@ -720,15 +704,15 @@ error_gen_mknod (call_frame_t *frame, xlator_t *this, loc_t *loc, if (op_errno) { GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno)); STACK_UNWIND_STRICT (mknod, frame, -1, op_errno, NULL, NULL, - NULL, NULL); - return 0; + NULL, NULL, xdata); + return 0; } STACK_WIND (frame, error_gen_mknod_cbk, FIRST_CHILD(this), FIRST_CHILD(this)->fops->mknod, - loc, mode, rdev, params); - return 0; + loc, mode, rdev, umask, xdata); + return 0; } @@ -736,17 +720,17 @@ int error_gen_mkdir_cbk (call_frame_t *frame, void *cookie, xlator_t *this, int32_t op_ret, int32_t op_errno, inode_t *inode, struct iatt *buf, struct iatt *preparent, - struct iatt *postparent) + struct iatt *postparent, dict_t *xdata) { STACK_UNWIND_STRICT (mkdir, frame, op_ret, op_errno, inode, buf, - preparent, postparent); - return 0; + preparent, postparent, xdata); + return 0; } int error_gen_mkdir (call_frame_t *frame, xlator_t *this, - loc_t *loc, mode_t mode, dict_t *params) + loc_t *loc, mode_t mode, mode_t umask, dict_t *xdata) { int op_errno = 0; eg_t *egp = NULL; @@ -761,31 +745,32 @@ error_gen_mkdir (call_frame_t *frame, xlator_t *this, if (op_errno) { GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno)); STACK_UNWIND_STRICT (mkdir, frame, -1, op_errno, NULL, NULL, - NULL, NULL); - return 0; + NULL, NULL, xdata); + return 0; } STACK_WIND (frame, error_gen_mkdir_cbk, FIRST_CHILD(this), FIRST_CHILD(this)->fops->mkdir, - loc, mode, params); - return 0; + loc, mode, umask, xdata); + return 0; } int error_gen_unlink_cbk (call_frame_t *frame, void *cookie, xlator_t *this, int32_t op_ret, int32_t op_errno, - struct iatt *preparent, struct iatt *postparent) + struct iatt *preparent, struct iatt *postparent, dict_t *xdata) { STACK_UNWIND_STRICT (unlink, frame, op_ret, op_errno, - preparent, postparent); - return 0; + preparent, postparent, xdata); + return 0; } int -error_gen_unlink (call_frame_t *frame, xlator_t *this, loc_t *loc) +error_gen_unlink (call_frame_t *frame, xlator_t *this, loc_t *loc, int xflag, + dict_t *xdata) { int op_errno = 0; eg_t *egp = NULL; @@ -799,31 +784,34 @@ error_gen_unlink (call_frame_t *frame, xlator_t *this, loc_t *loc) if (op_errno) { GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno)); - STACK_UNWIND_STRICT (unlink, frame, -1, op_errno, NULL, NULL); - return 0; + STACK_UNWIND_STRICT (unlink, frame, -1, op_errno, NULL, NULL, + xdata); + return 0; } STACK_WIND (frame, error_gen_unlink_cbk, FIRST_CHILD(this), FIRST_CHILD(this)->fops->unlink, - loc); - return 0; + loc, xflag, xdata); + return 0; } int error_gen_rmdir_cbk (call_frame_t *frame, void *cookie, xlator_t *this, int32_t op_ret, int32_t op_errno, - struct iatt *preparent, struct iatt *postparent) + struct iatt *preparent, struct iatt *postparent, + dict_t *xdata) { STACK_UNWIND_STRICT (rmdir, frame, op_ret, op_errno, - preparent, postparent); - return 0; + preparent, postparent, xdata); + return 0; } int -error_gen_rmdir (call_frame_t *frame, xlator_t *this, loc_t *loc, int flags) +error_gen_rmdir (call_frame_t *frame, xlator_t *this, loc_t *loc, int flags, + dict_t *xdata) { int op_errno = 0; eg_t *egp = NULL; @@ -837,15 +825,15 @@ error_gen_rmdir (call_frame_t *frame, xlator_t *this, loc_t *loc, int flags) if (op_errno) { GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno)); - STACK_UNWIND_STRICT (rmdir, frame, -1, op_errno, NULL, NULL); - return 0; + STACK_UNWIND_STRICT (rmdir, frame, -1, op_errno, NULL, NULL, xdata); + return 0; } STACK_WIND (frame, error_gen_rmdir_cbk, FIRST_CHILD(this), FIRST_CHILD(this)->fops->rmdir, - loc, flags); - return 0; + loc, flags, xdata); + return 0; } @@ -853,17 +841,17 @@ int error_gen_symlink_cbk (call_frame_t *frame, void *cookie, xlator_t *this, int32_t op_ret, int32_t op_errno, inode_t *inode, struct iatt *buf, struct iatt *preparent, - struct iatt *postparent) + struct iatt *postparent, dict_t *xdata) { STACK_UNWIND_STRICT (symlink, frame, op_ret, op_errno, inode, buf, - preparent, postparent); - return 0; + preparent, postparent, xdata); + return 0; } int error_gen_symlink (call_frame_t *frame, xlator_t *this, const char *linkpath, - loc_t *loc, dict_t *params) + loc_t *loc, mode_t umask, dict_t *xdata) { int op_errno = 0; eg_t *egp = NULL; @@ -878,15 +866,15 @@ error_gen_symlink (call_frame_t *frame, xlator_t *this, const char *linkpath, if (op_errno) { GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno)); STACK_UNWIND_STRICT (symlink, frame, -1, op_errno, NULL, NULL, - NULL, NULL); /* pre & post parent attr */ + NULL, NULL, NULL); /* pre & post parent attr */ return 0; } STACK_WIND (frame, error_gen_symlink_cbk, FIRST_CHILD(this), FIRST_CHILD(this)->fops->symlink, - linkpath, loc, params); - return 0; + linkpath, loc, umask, xdata); + return 0; } @@ -894,18 +882,19 @@ int error_gen_rename_cbk (call_frame_t *frame, void *cookie, xlator_t *this, int32_t op_ret, int32_t op_errno, struct iatt *buf, struct iatt *preoldparent, struct iatt *postoldparent, - struct iatt *prenewparent, struct iatt *postnewparent) + struct iatt *prenewparent, struct iatt *postnewparent, + dict_t *xdata) { STACK_UNWIND_STRICT (rename, frame, op_ret, op_errno, buf, preoldparent, postoldparent, - prenewparent, postnewparent); - return 0; + prenewparent, postnewparent, xdata); + return 0; } int error_gen_rename (call_frame_t *frame, xlator_t *this, - loc_t *oldloc, loc_t *newloc) + loc_t *oldloc, loc_t *newloc, dict_t *xdata) { int op_errno = 0; eg_t *egp = NULL; @@ -920,15 +909,15 @@ error_gen_rename (call_frame_t *frame, xlator_t *this, if (op_errno) { GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno)); STACK_UNWIND_STRICT (rename, frame, -1, op_errno, NULL, - NULL, NULL, NULL, NULL); /* pre & post parent attr */ + NULL, NULL, NULL, NULL, NULL); return 0; } STACK_WIND (frame, error_gen_rename_cbk, FIRST_CHILD(this), FIRST_CHILD(this)->fops->rename, - oldloc, newloc); - return 0; + oldloc, newloc, xdata); + return 0; } @@ -936,17 +925,17 @@ int error_gen_link_cbk (call_frame_t *frame, void *cookie, xlator_t *this, int32_t op_ret, int32_t op_errno, inode_t *inode, struct iatt *buf, struct iatt *preparent, - struct iatt *postparent) + struct iatt *postparent, dict_t *xdata) { STACK_UNWIND_STRICT (link, frame, op_ret, op_errno, inode, buf, - preparent, postparent); - return 0; + preparent, postparent, xdata); + return 0; } int error_gen_link (call_frame_t *frame, xlator_t *this, - loc_t *oldloc, loc_t *newloc) + loc_t *oldloc, loc_t *newloc, dict_t *xdata) { int op_errno = 0; eg_t *egp = NULL; @@ -961,15 +950,15 @@ error_gen_link (call_frame_t *frame, xlator_t *this, if (op_errno) { GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno)); STACK_UNWIND_STRICT (link, frame, -1, op_errno, NULL, NULL, - NULL, NULL); /* pre & post parent attr */ + NULL, NULL, NULL); return 0; } STACK_WIND (frame, error_gen_link_cbk, FIRST_CHILD(this), FIRST_CHILD(this)->fops->link, - oldloc, newloc); - return 0; + oldloc, newloc, xdata); + return 0; } @@ -977,17 +966,18 @@ int error_gen_create_cbk (call_frame_t *frame, void *cookie, xlator_t *this, int32_t op_ret, int32_t op_errno, fd_t *fd, inode_t *inode, struct iatt *buf, - struct iatt *preparent, struct iatt *postparent) + struct iatt *preparent, struct iatt *postparent, dict_t *xdata) { STACK_UNWIND_STRICT (create, frame, op_ret, op_errno, fd, inode, buf, - preparent, postparent); - return 0; + preparent, postparent, xdata); + return 0; } int error_gen_create (call_frame_t *frame, xlator_t *this, loc_t *loc, - int32_t flags, mode_t mode, fd_t *fd, dict_t *params) + int32_t flags, mode_t mode, mode_t umask, fd_t *fd, + dict_t *xdata) { int op_errno = 0; eg_t *egp = NULL; @@ -1002,30 +992,30 @@ error_gen_create (call_frame_t *frame, xlator_t *this, loc_t *loc, if (op_errno) { GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno)); STACK_UNWIND_STRICT (create, frame, -1, op_errno, NULL, NULL, - NULL, NULL, NULL); /* pre & post attr */ + NULL, NULL, NULL, NULL); return 0; } STACK_WIND (frame, error_gen_create_cbk, FIRST_CHILD(this), FIRST_CHILD(this)->fops->create, - loc, flags, mode, fd, params); - return 0; + loc, flags, mode, umask, fd, xdata); + return 0; } int error_gen_open_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, fd_t *fd) + int32_t op_ret, int32_t op_errno, fd_t *fd, dict_t *xdata) { - STACK_UNWIND_STRICT (open, frame, op_ret, op_errno, fd); - return 0; + STACK_UNWIND_STRICT (open, frame, op_ret, op_errno, fd, xdata); + return 0; } int error_gen_open (call_frame_t *frame, xlator_t *this, loc_t *loc, - int32_t flags, fd_t *fd, int32_t wbflags) + int32_t flags, fd_t *fd, dict_t *xdata) { int op_errno = 0; eg_t *egp = NULL; @@ -1039,15 +1029,15 @@ error_gen_open (call_frame_t *frame, xlator_t *this, loc_t *loc, if (op_errno) { GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno)); - STACK_UNWIND_STRICT (open, frame, -1, op_errno, NULL); - return 0; + STACK_UNWIND_STRICT (open, frame, -1, op_errno, NULL, xdata); + return 0; } STACK_WIND (frame, error_gen_open_cbk, FIRST_CHILD(this), FIRST_CHILD(this)->fops->open, - loc, flags, fd, wbflags); - return 0; + loc, flags, fd, xdata); + return 0; } @@ -1055,17 +1045,17 @@ int error_gen_readv_cbk (call_frame_t *frame, void *cookie, xlator_t *this, int32_t op_ret, int32_t op_errno, struct iovec *vector, int32_t count, - struct iatt *stbuf, struct iobref *iobref) + struct iatt *stbuf, struct iobref *iobref, dict_t *xdata) { STACK_UNWIND_STRICT (readv, frame, op_ret, op_errno, - vector, count, stbuf, iobref); - return 0; + vector, count, stbuf, iobref, xdata); + return 0; } int error_gen_readv (call_frame_t *frame, xlator_t *this, - fd_t *fd, size_t size, off_t offset, uint32_t flags) + fd_t *fd, size_t size, off_t offset, uint32_t flags, dict_t *xdata) { int op_errno = 0; eg_t *egp = NULL; @@ -1080,33 +1070,33 @@ error_gen_readv (call_frame_t *frame, xlator_t *this, if (op_errno) { GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno)); STACK_UNWIND_STRICT (readv, frame, -1, op_errno, NULL, 0, - NULL, NULL); - return 0; + NULL, NULL, xdata); + return 0; } STACK_WIND (frame, error_gen_readv_cbk, FIRST_CHILD(this), FIRST_CHILD(this)->fops->readv, - fd, size, offset, flags); - return 0; + fd, size, offset, flags, xdata); + return 0; } int error_gen_writev_cbk (call_frame_t *frame, void *cookie, xlator_t *this, int32_t op_ret, int32_t op_errno, - struct iatt *prebuf, struct iatt *postbuf) + struct iatt *prebuf, struct iatt *postbuf, dict_t *xdata) { - STACK_UNWIND_STRICT (writev, frame, op_ret, op_errno, prebuf, postbuf); - return 0; + STACK_UNWIND_STRICT (writev, frame, op_ret, op_errno, prebuf, postbuf, xdata); + return 0; } int error_gen_writev (call_frame_t *frame, xlator_t *this, fd_t *fd, struct iovec *vector, int32_t count, - off_t off, uint32_t flags, struct iobref *iobref) + off_t off, uint32_t flags, struct iobref *iobref, dict_t *xdata) { int op_errno = 0; eg_t *egp = NULL; @@ -1118,31 +1108,47 @@ error_gen_writev (call_frame_t *frame, xlator_t *this, fd_t *fd, if (enable) op_errno = error_gen (this, GF_FOP_WRITE); - if (op_errno) { - GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno)); - STACK_UNWIND_STRICT (writev, frame, -1, op_errno, NULL, NULL); + if (op_errno == GF_ERROR_SHORT_WRITE) { + struct iovec *shortvec; + + /* + * A short write error returns some value less than what was + * requested from a write. To simulate this, replace the vector + * with one half the size; + */ + shortvec = iov_dup(vector, 1); + shortvec->iov_len /= 2; + + STACK_WIND(frame, error_gen_writev_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->writev, fd, shortvec, count, + off, flags, iobref, xdata); + GF_FREE(shortvec); return 0; + } else if (op_errno) { + GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno)); + STACK_UNWIND_STRICT (writev, frame, -1, op_errno, NULL, NULL, xdata); + return 0; } STACK_WIND (frame, error_gen_writev_cbk, FIRST_CHILD(this), FIRST_CHILD(this)->fops->writev, - fd, vector, count, off, flags, iobref); - return 0; + fd, vector, count, off, flags, iobref, xdata); + return 0; } int error_gen_flush_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno) + int32_t op_ret, int32_t op_errno, dict_t *xdata) { - STACK_UNWIND_STRICT (flush, frame, op_ret, op_errno); - return 0; + STACK_UNWIND_STRICT (flush, frame, op_ret, op_errno, xdata); + return 0; } int -error_gen_flush (call_frame_t *frame, xlator_t *this, fd_t *fd) +error_gen_flush (call_frame_t *frame, xlator_t *this, fd_t *fd, dict_t *xdata) { int op_errno = 0; eg_t *egp = NULL; @@ -1156,15 +1162,15 @@ error_gen_flush (call_frame_t *frame, xlator_t *this, fd_t *fd) if (op_errno) { GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno)); - STACK_UNWIND_STRICT (flush, frame, -1, op_errno); - return 0; + STACK_UNWIND_STRICT (flush, frame, -1, op_errno, xdata); + return 0; } STACK_WIND (frame, error_gen_flush_cbk, FIRST_CHILD(this), FIRST_CHILD(this)->fops->flush, - fd); - return 0; + fd, xdata); + return 0; } @@ -1172,15 +1178,15 @@ int error_gen_fsync_cbk (call_frame_t *frame, void *cookie, xlator_t *this, int32_t op_ret, int32_t op_errno, struct iatt *prebuf, - struct iatt *postbuf) + struct iatt *postbuf, dict_t *xdata) { - STACK_UNWIND_STRICT (fsync, frame, op_ret, op_errno, prebuf, postbuf); - return 0; + STACK_UNWIND_STRICT (fsync, frame, op_ret, op_errno, prebuf, postbuf, xdata); + return 0; } int -error_gen_fsync (call_frame_t *frame, xlator_t *this, fd_t *fd, int32_t flags) +error_gen_fsync (call_frame_t *frame, xlator_t *this, fd_t *fd, int32_t flags, dict_t *xdata) { int op_errno = 0; eg_t *egp = NULL; @@ -1194,29 +1200,29 @@ error_gen_fsync (call_frame_t *frame, xlator_t *this, fd_t *fd, int32_t flags) if (op_errno) { GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno)); - STACK_UNWIND_STRICT (fsync, frame, -1, op_errno, NULL, NULL); - return 0; + STACK_UNWIND_STRICT (fsync, frame, -1, op_errno, NULL, NULL, xdata); + return 0; } STACK_WIND (frame, error_gen_fsync_cbk, FIRST_CHILD(this), FIRST_CHILD(this)->fops->fsync, - fd, flags); - return 0; + fd, flags, xdata); + return 0; } int error_gen_fstat_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, struct iatt *buf) + int32_t op_ret, int32_t op_errno, struct iatt *buf, dict_t *xdata) { - STACK_UNWIND_STRICT (fstat, frame, op_ret, op_errno, buf); - return 0; + STACK_UNWIND_STRICT (fstat, frame, op_ret, op_errno, buf, xdata); + return 0; } int -error_gen_fstat (call_frame_t *frame, xlator_t *this, fd_t *fd) +error_gen_fstat (call_frame_t *frame, xlator_t *this, fd_t *fd, dict_t *xdata) { int op_errno = 0; eg_t *egp = NULL; @@ -1230,29 +1236,29 @@ error_gen_fstat (call_frame_t *frame, xlator_t *this, fd_t *fd) if (op_errno) { GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno)); - STACK_UNWIND_STRICT (fstat, frame, -1, op_errno, NULL); - return 0; + STACK_UNWIND_STRICT (fstat, frame, -1, op_errno, NULL, xdata); + return 0; } STACK_WIND (frame, error_gen_fstat_cbk, FIRST_CHILD(this), FIRST_CHILD(this)->fops->fstat, - fd); - return 0; + fd, xdata); + return 0; } int error_gen_opendir_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, fd_t *fd) + int32_t op_ret, int32_t op_errno, fd_t *fd, dict_t *xdata) { - STACK_UNWIND_STRICT (opendir, frame, op_ret, op_errno, fd); - return 0; + STACK_UNWIND_STRICT (opendir, frame, op_ret, op_errno, fd, xdata); + return 0; } int -error_gen_opendir (call_frame_t *frame, xlator_t *this, loc_t *loc, fd_t *fd) +error_gen_opendir (call_frame_t *frame, xlator_t *this, loc_t *loc, fd_t *fd, dict_t *xdata) { int op_errno = 0; eg_t *egp = NULL; @@ -1266,29 +1272,29 @@ error_gen_opendir (call_frame_t *frame, xlator_t *this, loc_t *loc, fd_t *fd) if (op_errno) { GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno)); - STACK_UNWIND_STRICT (opendir, frame, -1, op_errno, NULL); - return 0; + STACK_UNWIND_STRICT (opendir, frame, -1, op_errno, NULL, xdata); + return 0; } STACK_WIND (frame, error_gen_opendir_cbk, FIRST_CHILD(this), FIRST_CHILD(this)->fops->opendir, - loc, fd); - return 0; + loc, fd, xdata); + return 0; } int error_gen_fsyncdir_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno) + int32_t op_ret, int32_t op_errno, dict_t *xdata) { - STACK_UNWIND_STRICT (fsyncdir, frame, op_ret, op_errno); - return 0; + STACK_UNWIND_STRICT (fsyncdir, frame, op_ret, op_errno, xdata); + return 0; } int error_gen_fsyncdir (call_frame_t *frame, xlator_t *this, fd_t *fd, - int32_t flags) + int32_t flags, dict_t *xdata) { int op_errno = 0; eg_t *egp = NULL; @@ -1302,30 +1308,29 @@ error_gen_fsyncdir (call_frame_t *frame, xlator_t *this, fd_t *fd, if (op_errno) { GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno)); - STACK_UNWIND_STRICT (fsyncdir, frame, -1, op_errno); - return 0; + STACK_UNWIND_STRICT (fsyncdir, frame, -1, op_errno, xdata); + return 0; } STACK_WIND (frame, error_gen_fsyncdir_cbk, FIRST_CHILD(this), FIRST_CHILD(this)->fops->fsyncdir, - fd, flags); - return 0; + fd, flags, xdata); + return 0; } int error_gen_statfs_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, struct statvfs *buf) + int32_t op_ret, int32_t op_errno, struct statvfs *buf, dict_t *xdata) { - STACK_UNWIND_STRICT (statfs, frame, op_ret, op_errno, buf); - - return 0; + STACK_UNWIND_STRICT (statfs, frame, op_ret, op_errno, buf, xdata); + return 0; } int -error_gen_statfs (call_frame_t *frame, xlator_t *this, loc_t *loc) +error_gen_statfs (call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *xdata) { int op_errno = 0; eg_t *egp = NULL; @@ -1339,31 +1344,30 @@ error_gen_statfs (call_frame_t *frame, xlator_t *this, loc_t *loc) if (op_errno) { GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno)); - STACK_UNWIND_STRICT (statfs, frame, -1, op_errno, NULL); - return 0; + STACK_UNWIND_STRICT (statfs, frame, -1, op_errno, NULL, xdata); + return 0; } STACK_WIND (frame, error_gen_statfs_cbk, FIRST_CHILD(this), FIRST_CHILD(this)->fops->statfs, - loc); - return 0; + loc, xdata); + return 0; } int error_gen_setxattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno) + int32_t op_ret, int32_t op_errno, dict_t *xdata) { - STACK_UNWIND_STRICT (setxattr, frame, op_ret, op_errno); - - return 0; + STACK_UNWIND_STRICT (setxattr, frame, op_ret, op_errno, xdata); + return 0; } int error_gen_setxattr (call_frame_t *frame, xlator_t *this, loc_t *loc, - dict_t *dict, int32_t flags) + dict_t *dict, int32_t flags, dict_t *xdata) { int op_errno = 0; eg_t *egp = NULL; @@ -1377,30 +1381,30 @@ error_gen_setxattr (call_frame_t *frame, xlator_t *this, loc_t *loc, if (op_errno) { GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno)); - STACK_UNWIND_STRICT (setxattr, frame, -1, op_errno); - return 0; + STACK_UNWIND_STRICT (setxattr, frame, -1, op_errno, xdata); + return 0; } STACK_WIND (frame, error_gen_setxattr_cbk, FIRST_CHILD(this), FIRST_CHILD(this)->fops->setxattr, - loc, dict, flags); - return 0; + loc, dict, flags, xdata); + return 0; } int error_gen_getxattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, dict_t *dict) + int32_t op_ret, int32_t op_errno, dict_t *dict, dict_t *xdata) { - STACK_UNWIND_STRICT (getxattr, frame, op_ret, op_errno, dict); - return 0; + STACK_UNWIND_STRICT (getxattr, frame, op_ret, op_errno, dict, xdata); + return 0; } int error_gen_getxattr (call_frame_t *frame, xlator_t *this, loc_t *loc, - const char *name) + const char *name, dict_t *xdata) { int op_errno = 0; eg_t *egp = NULL; @@ -1414,30 +1418,29 @@ error_gen_getxattr (call_frame_t *frame, xlator_t *this, loc_t *loc, if (op_errno) { GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno)); - STACK_UNWIND_STRICT (getxattr, frame, -1, op_errno, NULL); - return 0; + STACK_UNWIND_STRICT (getxattr, frame, -1, op_errno, NULL, xdata); + return 0; } STACK_WIND (frame, error_gen_getxattr_cbk, FIRST_CHILD(this), FIRST_CHILD(this)->fops->getxattr, - loc, name); - return 0; + loc, name, xdata); + return 0; } int error_gen_fsetxattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno) + int32_t op_ret, int32_t op_errno, dict_t *xdata) { - STACK_UNWIND_STRICT (fsetxattr, frame, op_ret, op_errno); - - return 0; + STACK_UNWIND_STRICT (fsetxattr, frame, op_ret, op_errno, xdata); + return 0; } int error_gen_fsetxattr (call_frame_t *frame, xlator_t *this, fd_t *fd, - dict_t *dict, int32_t flags) + dict_t *dict, int32_t flags, dict_t *xdata) { int op_errno = 0; eg_t *egp = NULL; @@ -1451,30 +1454,30 @@ error_gen_fsetxattr (call_frame_t *frame, xlator_t *this, fd_t *fd, if (op_errno) { GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno)); - STACK_UNWIND_STRICT (fsetxattr, frame, -1, op_errno); - return 0; + STACK_UNWIND_STRICT (fsetxattr, frame, -1, op_errno, xdata); + return 0; } STACK_WIND (frame, error_gen_fsetxattr_cbk, FIRST_CHILD(this), FIRST_CHILD(this)->fops->fsetxattr, - fd, dict, flags); - return 0; + fd, dict, flags, xdata); + return 0; } int error_gen_fgetxattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, dict_t *dict) + int32_t op_ret, int32_t op_errno, dict_t *dict, dict_t *xdata) { - STACK_UNWIND_STRICT (fgetxattr, frame, op_ret, op_errno, dict); - return 0; + STACK_UNWIND_STRICT (fgetxattr, frame, op_ret, op_errno, dict, xdata); + return 0; } int error_gen_fgetxattr (call_frame_t *frame, xlator_t *this, fd_t *fd, - const char *name) + const char *name, dict_t *xdata) { int op_errno = 0; eg_t *egp = NULL; @@ -1488,31 +1491,30 @@ error_gen_fgetxattr (call_frame_t *frame, xlator_t *this, fd_t *fd, if (op_errno) { GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno)); - STACK_UNWIND_STRICT (fgetxattr, frame, -1, op_errno, NULL); - return 0; + STACK_UNWIND_STRICT (fgetxattr, frame, -1, op_errno, NULL, xdata); + return 0; } STACK_WIND (frame, error_gen_fgetxattr_cbk, FIRST_CHILD(this), FIRST_CHILD(this)->fops->fgetxattr, - fd, name); - return 0; + fd, name, xdata); + return 0; } int error_gen_xattrop_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, dict_t *dict) + int32_t op_ret, int32_t op_errno, dict_t *dict, dict_t *xdata) { - STACK_UNWIND_STRICT (xattrop, frame, op_ret, op_errno, dict); - - return 0; + STACK_UNWIND_STRICT (xattrop, frame, op_ret, op_errno, dict, xdata); + return 0; } int error_gen_xattrop (call_frame_t *frame, xlator_t *this, loc_t *loc, - gf_xattrop_flags_t flags, dict_t *dict) + gf_xattrop_flags_t flags, dict_t *dict, dict_t *xdata) { int op_errno = 0; eg_t *egp = NULL; @@ -1526,31 +1528,30 @@ error_gen_xattrop (call_frame_t *frame, xlator_t *this, loc_t *loc, if (op_errno) { GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno)); - STACK_UNWIND_STRICT (xattrop, frame, -1, op_errno, NULL); - return 0; + STACK_UNWIND_STRICT (xattrop, frame, -1, op_errno, NULL, xdata); + return 0; } STACK_WIND (frame, error_gen_xattrop_cbk, FIRST_CHILD(this), FIRST_CHILD(this)->fops->xattrop, - loc, flags, dict); - return 0; + loc, flags, dict, xdata); + return 0; } int error_gen_fxattrop_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, dict_t *dict) + int32_t op_ret, int32_t op_errno, dict_t *dict, dict_t *xdata) { - STACK_UNWIND_STRICT (fxattrop, frame, op_ret, op_errno, dict); - - return 0; + STACK_UNWIND_STRICT (fxattrop, frame, op_ret, op_errno, dict, xdata); + return 0; } int error_gen_fxattrop (call_frame_t *frame, xlator_t *this, fd_t *fd, - gf_xattrop_flags_t flags, dict_t *dict) + gf_xattrop_flags_t flags, dict_t *dict, dict_t *xdata) { int op_errno = 0; eg_t *egp = NULL; @@ -1564,31 +1565,30 @@ error_gen_fxattrop (call_frame_t *frame, xlator_t *this, fd_t *fd, if (op_errno) { GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno)); - STACK_UNWIND_STRICT (fxattrop, frame, -1, op_errno, NULL); - return 0; + STACK_UNWIND_STRICT (fxattrop, frame, -1, op_errno, NULL, xdata); + return 0; } STACK_WIND (frame, error_gen_fxattrop_cbk, FIRST_CHILD(this), FIRST_CHILD(this)->fops->fxattrop, - fd, flags, dict); - return 0; + fd, flags, dict, xdata); + return 0; } int error_gen_removexattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno) + int32_t op_ret, int32_t op_errno, dict_t *xdata) { - STACK_UNWIND_STRICT (removexattr, frame, op_ret, op_errno); - - return 0; + STACK_UNWIND_STRICT (removexattr, frame, op_ret, op_errno, xdata); + return 0; } int error_gen_removexattr (call_frame_t *frame, xlator_t *this, loc_t *loc, - const char *name) + const char *name, dict_t *xdata) { int op_errno = 0; eg_t *egp = NULL; @@ -1602,30 +1602,29 @@ error_gen_removexattr (call_frame_t *frame, xlator_t *this, loc_t *loc, if (op_errno) { GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno)); - STACK_UNWIND_STRICT (removexattr, frame, -1, op_errno); - return 0; + STACK_UNWIND_STRICT (removexattr, frame, -1, op_errno, xdata); + return 0; } STACK_WIND (frame, error_gen_removexattr_cbk, FIRST_CHILD(this), FIRST_CHILD(this)->fops->removexattr, - loc, name); - return 0; + loc, name, xdata); + return 0; } int error_gen_fremovexattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno) + int32_t op_ret, int32_t op_errno, dict_t *xdata) { - STACK_UNWIND_STRICT (fremovexattr, frame, op_ret, op_errno); - - return 0; + STACK_UNWIND_STRICT (fremovexattr, frame, op_ret, op_errno, xdata); + return 0; } int error_gen_fremovexattr (call_frame_t *frame, xlator_t *this, fd_t *fd, - const char *name) + const char *name, dict_t *xdata) { int op_errno = 0; eg_t *egp = NULL; @@ -1639,30 +1638,30 @@ error_gen_fremovexattr (call_frame_t *frame, xlator_t *this, fd_t *fd, if (op_errno) { GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno)); - STACK_UNWIND_STRICT (fremovexattr, frame, -1, op_errno); - return 0; + STACK_UNWIND_STRICT (fremovexattr, frame, -1, op_errno, xdata); + return 0; } STACK_WIND (frame, error_gen_fremovexattr_cbk, FIRST_CHILD(this), FIRST_CHILD(this)->fops->fremovexattr, - fd, name); - return 0; + fd, name, xdata); + return 0; } int error_gen_lk_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, struct gf_flock *lock) + int32_t op_ret, int32_t op_errno, struct gf_flock *lock, dict_t *xdata) { - STACK_UNWIND_STRICT (lk, frame, op_ret, op_errno, lock); - return 0; + STACK_UNWIND_STRICT (lk, frame, op_ret, op_errno, lock, xdata); + return 0; } int error_gen_lk (call_frame_t *frame, xlator_t *this, fd_t *fd, int32_t cmd, - struct gf_flock *lock) + struct gf_flock *lock, dict_t *xdata) { int op_errno = 0; eg_t *egp = NULL; @@ -1676,32 +1675,31 @@ error_gen_lk (call_frame_t *frame, xlator_t *this, fd_t *fd, int32_t cmd, if (op_errno) { GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno)); - STACK_UNWIND_STRICT (lk, frame, -1, op_errno, NULL); - return 0; + STACK_UNWIND_STRICT (lk, frame, -1, op_errno, NULL, xdata); + return 0; } STACK_WIND (frame, error_gen_lk_cbk, FIRST_CHILD(this), FIRST_CHILD(this)->fops->lk, - fd, cmd, lock); - return 0; + fd, cmd, lock, xdata); + return 0; } int -error_gen_inodelk_cbk (call_frame_t *frame, void *cookie, - xlator_t *this, int32_t op_ret, int32_t op_errno) - +error_gen_inodelk_cbk (call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, dict_t *xdata) { - STACK_UNWIND_STRICT (inodelk, frame, op_ret, op_errno); - return 0; + STACK_UNWIND_STRICT (inodelk, frame, op_ret, op_errno, xdata); + return 0; } int error_gen_inodelk (call_frame_t *frame, xlator_t *this, const char *volume, loc_t *loc, int32_t cmd, - struct gf_flock *lock) + struct gf_flock *lock, dict_t *xdata) { int op_errno = 0; eg_t *egp = NULL; @@ -1715,32 +1713,31 @@ error_gen_inodelk (call_frame_t *frame, xlator_t *this, if (op_errno) { GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno)); - STACK_UNWIND_STRICT (inodelk, frame, -1, op_errno); - return 0; + STACK_UNWIND_STRICT (inodelk, frame, -1, op_errno, xdata); + return 0; } STACK_WIND (frame, error_gen_inodelk_cbk, FIRST_CHILD(this), FIRST_CHILD(this)->fops->inodelk, - volume, loc, cmd, lock); - return 0; + volume, loc, cmd, lock, xdata); + return 0; } int -error_gen_finodelk_cbk (call_frame_t *frame, void *cookie, - xlator_t *this, int32_t op_ret, int32_t op_errno) - +error_gen_finodelk_cbk (call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, dict_t *xdata) { - STACK_UNWIND_STRICT (finodelk, frame, op_ret, op_errno); - return 0; + STACK_UNWIND_STRICT (finodelk, frame, op_ret, op_errno, xdata); + return 0; } int error_gen_finodelk (call_frame_t *frame, xlator_t *this, const char *volume, fd_t *fd, int32_t cmd, - struct gf_flock *lock) + struct gf_flock *lock, dict_t *xdata) { int op_errno = 0; eg_t *egp = NULL; @@ -1754,32 +1751,31 @@ error_gen_finodelk (call_frame_t *frame, xlator_t *this, if (op_errno) { GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno)); - STACK_UNWIND_STRICT (finodelk, frame, -1, op_errno); - return 0; + STACK_UNWIND_STRICT (finodelk, frame, -1, op_errno, xdata); + return 0; } STACK_WIND (frame, error_gen_finodelk_cbk, FIRST_CHILD(this), FIRST_CHILD(this)->fops->finodelk, - volume, fd, cmd, lock); - return 0; + volume, fd, cmd, lock, xdata); + return 0; } int -error_gen_entrylk_cbk (call_frame_t *frame, void *cookie, - xlator_t *this, int32_t op_ret, int32_t op_errno) - +error_gen_entrylk_cbk (call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, dict_t *xdata) { - STACK_UNWIND_STRICT (entrylk, frame, op_ret, op_errno); - return 0; + STACK_UNWIND_STRICT (entrylk, frame, op_ret, op_errno, xdata); + return 0; } int error_gen_entrylk (call_frame_t *frame, xlator_t *this, const char *volume, loc_t *loc, const char *basename, - entrylk_cmd cmd, entrylk_type type) + entrylk_cmd cmd, entrylk_type type, dict_t *xdata) { int op_errno = 0; eg_t *egp = NULL; @@ -1793,32 +1789,31 @@ error_gen_entrylk (call_frame_t *frame, xlator_t *this, if (op_errno) { GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno)); - STACK_UNWIND_STRICT (entrylk, frame, -1, op_errno); - return 0; + STACK_UNWIND_STRICT (entrylk, frame, -1, op_errno, xdata); + return 0; } STACK_WIND (frame, error_gen_entrylk_cbk, FIRST_CHILD(this), FIRST_CHILD(this)->fops->entrylk, - volume, loc, basename, cmd, type); - return 0; + volume, loc, basename, cmd, type, xdata); + return 0; } int -error_gen_fentrylk_cbk (call_frame_t *frame, void *cookie, - xlator_t *this, int32_t op_ret, int32_t op_errno) - +error_gen_fentrylk_cbk (call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, dict_t *xdata) { - STACK_UNWIND_STRICT (fentrylk, frame, op_ret, op_errno); - return 0; + STACK_UNWIND_STRICT (fentrylk, frame, op_ret, op_errno, xdata); + return 0; } int error_gen_fentrylk (call_frame_t *frame, xlator_t *this, const char *volume, fd_t *fd, const char *basename, - entrylk_cmd cmd, entrylk_type type) + entrylk_cmd cmd, entrylk_type type, dict_t *xdata) { int op_errno = 0; eg_t *egp = NULL; @@ -1832,15 +1827,15 @@ error_gen_fentrylk (call_frame_t *frame, xlator_t *this, if (op_errno) { GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno)); - STACK_UNWIND_STRICT (fentrylk, frame, -1, op_errno); - return 0; + STACK_UNWIND_STRICT (fentrylk, frame, -1, op_errno, xdata); + return 0; } STACK_WIND (frame, error_gen_fentrylk_cbk, FIRST_CHILD(this), FIRST_CHILD(this)->fops->fentrylk, - volume, fd, basename, cmd, type); - return 0; + volume, fd, basename, cmd, type, xdata); + return 0; } @@ -1852,8 +1847,7 @@ 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_STRICT (getspec, frame, op_ret, op_errno, spec_data); - - return 0; + return 0; } @@ -1887,16 +1881,17 @@ error_gen_getspec (call_frame_t *frame, xlator_t *this, const char *key, int error_gen_readdir_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, gf_dirent_t *entries) + int32_t op_ret, int32_t op_errno, gf_dirent_t *entries, + dict_t *xdata) { - STACK_UNWIND_STRICT (readdir, frame, op_ret, op_errno, entries); + STACK_UNWIND_STRICT (readdir, frame, op_ret, op_errno, entries, xdata); return 0; } int error_gen_readdir (call_frame_t *frame, xlator_t *this, fd_t *fd, - size_t size, off_t off) + size_t size, off_t off, dict_t *xdata) { int op_errno = 0; eg_t *egp = NULL; @@ -1910,23 +1905,24 @@ error_gen_readdir (call_frame_t *frame, xlator_t *this, fd_t *fd, if (op_errno) { GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno)); - STACK_UNWIND_STRICT (readdir, frame, -1, op_errno, NULL); + STACK_UNWIND_STRICT (readdir, frame, -1, op_errno, NULL, xdata); return 0; } STACK_WIND (frame, error_gen_readdir_cbk, FIRST_CHILD(this), FIRST_CHILD(this)->fops->readdir, - fd, size, off); + fd, size, off, xdata); return 0; } int error_gen_readdirp_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, gf_dirent_t *entries) + int32_t op_ret, int32_t op_errno, gf_dirent_t *entries, + dict_t *xdata) { - STACK_UNWIND_STRICT (readdirp, frame, op_ret, op_errno, entries); + STACK_UNWIND_STRICT (readdirp, frame, op_ret, op_errno, entries, xdata); return 0; } @@ -1947,7 +1943,7 @@ error_gen_readdirp (call_frame_t *frame, xlator_t *this, fd_t *fd, size_t size, if (op_errno) { GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno)); - STACK_UNWIND_STRICT (readdirp, frame, -1, op_errno, NULL); + STACK_UNWIND_STRICT (readdirp, frame, -1, op_errno, NULL, NULL); return 0; } @@ -1958,18 +1954,83 @@ error_gen_readdirp (call_frame_t *frame, xlator_t *this, fd_t *fd, size_t size, return 0; } - -int -error_gen_closedir (xlator_t *this, fd_t *fd) +static void +error_gen_set_failure (eg_t *pvt, int percent) { - return 0; + GF_ASSERT (pvt); + + if (percent) + pvt->failure_iter_no = 100/percent; + else + pvt->failure_iter_no = 100/GF_FAILURE_DEFAULT; } +static void +error_gen_parse_fill_fops (eg_t *pvt, char *enable_fops) +{ + char *op_no_str = NULL; + int op_no = -1; + int i = 0; + xlator_t *this = THIS; + char *saveptr = NULL; -int -error_gen_close (xlator_t *this, fd_t *fd) + GF_ASSERT (pvt); + GF_ASSERT (this); + + for (i = 0; i < GF_FOP_MAXVALUE; i++) + pvt->enable[i] = 0; + + if (!enable_fops) { + gf_log (this->name, GF_LOG_WARNING, + "All fops are enabled."); + for (i = 0; i < GF_FOP_MAXVALUE; i++) + pvt->enable[i] = 1; + } else { + op_no_str = strtok_r (enable_fops, ",", &saveptr); + while (op_no_str) { + op_no = get_fop_int (&op_no_str); + if (op_no == -1) { + gf_log (this->name, GF_LOG_WARNING, + "Wrong option value %s", op_no_str); + } else + pvt->enable[op_no] = 1; + + op_no_str = strtok_r (NULL, ",", &saveptr); + } + } +} + +int32_t +error_gen_priv_dump (xlator_t *this) { - return 0; + char key_prefix[GF_DUMP_MAX_BUF_LEN]; + int ret = -1; + eg_t *conf = NULL; + + if (!this) + goto out; + + conf = this->private; + if (!conf) + goto out; + + ret = TRY_LOCK(&conf->lock); + if (ret != 0) { + return ret; + } + + gf_proc_dump_add_section("xlator.debug.error-gen.%s.priv", this->name); + gf_proc_dump_build_key(key_prefix,"xlator.debug.error-gen","%s.priv", + this->name); + + gf_proc_dump_write("op_count", "%d", conf->op_count); + gf_proc_dump_write("failure_iter_no", "%d", conf->failure_iter_no); + gf_proc_dump_write("error_no", "%s", conf->error_no); + gf_proc_dump_write("random_failure", "%d", conf->random_failure); + + UNLOCK(&conf->lock); +out: + return ret; } int32_t @@ -1992,18 +2053,43 @@ mem_acct_init (xlator_t *this) } int +reconfigure (xlator_t *this, dict_t *options) +{ + eg_t *pvt = NULL; + int32_t ret = 0; + char *error_enable_fops = NULL; + int32_t failure_percent_int = 0; + + if (!this || !this->private) + goto out; + + pvt = this->private; + + GF_OPTION_RECONF ("error-no", pvt->error_no, options, str, out); + + GF_OPTION_RECONF ("failure", failure_percent_int, options, int32, + out); + + GF_OPTION_RECONF ("enable", error_enable_fops, options, str, out); + + GF_OPTION_RECONF ("random-failure", pvt->random_failure, options, + bool, out); + + error_gen_parse_fill_fops (pvt, error_enable_fops); + error_gen_set_failure (pvt, failure_percent_int); + + ret = 0; +out: + gf_log (this->name, GF_LOG_DEBUG, "reconfigure returning %d", ret); + return ret; +} + +int init (xlator_t *this) { eg_t *pvt = NULL; - data_t *error_no = NULL; - data_t *failure_percent = NULL; - data_t *enable = NULL; - gf_boolean_t random_failure = _gf_false; int32_t ret = 0; char *error_enable_fops = NULL; - char *op_no_str = NULL; - int op_no = -1; - int i = 0; int32_t failure_percent_int = 0; if (!this->children || this->children->next) { @@ -2018,79 +2104,34 @@ init (xlator_t *this) "dangling volume. check volfile "); } - error_no = dict_get (this->options, "error-no"); - failure_percent = dict_get (this->options, "failure"); - enable = dict_get (this->options, "enable"); - pvt = GF_CALLOC (1, sizeof (eg_t), gf_error_gen_mt_eg_t); if (!pvt) { - gf_log (this->name, GF_LOG_ERROR, - "out of memory."); ret = -1; goto out; } LOCK_INIT (&pvt->lock); - for (i = 0; i < GF_FOP_MAXVALUE; i++) - pvt->enable[i] = 0; - if (!error_no) { - gf_log (this->name, GF_LOG_DEBUG, - "error-no not specified."); - } else { - pvt->error_no = data_to_str (error_no); - } + GF_OPTION_INIT ("error-no", pvt->error_no, str, out); - if (!failure_percent) { - gf_log (this->name, GF_LOG_DEBUG, - "failure percent not specified."); - pvt->failure_iter_no = 100/GF_FAILURE_DEFAULT; - } else { - failure_percent_int = data_to_int32 (failure_percent); - if (failure_percent_int) - pvt->failure_iter_no = 100/failure_percent_int; - else - pvt->failure_iter_no = 100/GF_FAILURE_DEFAULT; - } + GF_OPTION_INIT ("failure", failure_percent_int, int32, out); + + GF_OPTION_INIT ("enable", error_enable_fops, str, out); + + GF_OPTION_INIT ("random-failure", pvt->random_failure, bool, out); - if (!enable) { - gf_log (this->name, GF_LOG_WARNING, - "All fops are enabled."); - for (i = 0; i < GF_FOP_MAXVALUE; i++) - pvt->enable[i] = 1; - } else { - error_enable_fops = data_to_str (enable); - op_no_str = error_enable_fops; - while ((*error_enable_fops) != '\0') { - error_enable_fops++; - if (((*error_enable_fops) == ',') || - ((*error_enable_fops) == '\0')) { - if ((*error_enable_fops) != '\0') { - (*error_enable_fops) = '\0'; - error_enable_fops++; - } - op_no = get_fop_int (&op_no_str); - if (op_no == -1) { - gf_log (this->name, GF_LOG_WARNING, - "Wrong option value %s", - op_no_str); - } else - pvt->enable[op_no] = 1; - op_no_str = error_enable_fops; - } - } - } - random_failure = dict_get_str_boolean (this->options, "random-failure", - _gf_false); - pvt->random_failure = random_failure; + error_gen_parse_fill_fops (pvt, error_enable_fops); + error_gen_set_failure (pvt, failure_percent_int); this->private = pvt; /* Give some seed value here */ srand (time(NULL)); out: + if (ret) + GF_FREE (pvt); return ret; } @@ -2112,6 +2153,12 @@ fini (xlator_t *this) return; } +struct xlator_dumpops dumpops = { + .priv = error_gen_priv_dump, +}; + +struct xlator_fops cbks; + struct xlator_fops fops = { .lookup = error_gen_lookup, .stat = error_gen_stat, @@ -2157,24 +2204,29 @@ struct xlator_fops fops = { .getspec = error_gen_getspec, }; -struct xlator_cbks cbks = { - .release = error_gen_close, - .releasedir = error_gen_closedir, -}; - struct volume_options options[] = { { .key = {"failure"}, - .type = GF_OPTION_TYPE_INT }, + .type = GF_OPTION_TYPE_INT, + .description = "Percentage failure of operations when enabled.", + }, + { .key = {"error-no"}, .value = {"ENOENT","ENOTDIR","ENAMETOOLONG","EACCES","EBADF", "EFAULT","ENOMEM","EINVAL","EIO","EEXIST","ENOSPC", "EPERM","EROFS","EBUSY","EISDIR","ENOTEMPTY","EMLINK" "ENODEV","EXDEV","EMFILE","ENFILE","ENOSYS","EINTR", - "EFBIG","EAGAIN"}, - .type = GF_OPTION_TYPE_STR }, + "EFBIG","EAGAIN","GF_ERROR_SHORT_WRITE"}, + .type = GF_OPTION_TYPE_STR, + }, + { .key = {"random-failure"}, - .type = GF_OPTION_TYPE_BOOL}, + .type = GF_OPTION_TYPE_BOOL, + .default_value = "off", + }, + { .key = {"enable"}, - .type = GF_OPTION_TYPE_STR }, + .type = GF_OPTION_TYPE_STR, + }, + { .key = {NULL} } }; diff --git a/xlators/debug/error-gen/src/error-gen.h b/xlators/debug/error-gen/src/error-gen.h index bb3adb2ab..d92c23062 100644 --- a/xlators/debug/error-gen/src/error-gen.h +++ b/xlators/debug/error-gen/src/error-gen.h @@ -1,22 +1,12 @@ /* - Copyright (c) 2008-2011 Gluster, Inc. <http://www.gluster.com> - This file is part of GlusterFS. - - GlusterFS is free software; you can redistribute it and/or modify - it under the terms of the GNU General Public License as published - by the Free Software Foundation; either version 3 of the License, - or (at your option) any later version. - - GlusterFS is distributed in the hope that it will be useful, but - WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - General Public License for more details. - - You should have received a copy of the GNU General Public License - along with this program. If not, see - <http://www.gnu.org/licenses/>. -*/ + Copyright (c) 2008-2012 Red Hat, Inc. <http://www.redhat.com> + This file is part of GlusterFS. + This file is licensed to you under your choice of the GNU Lesser + General Public License, version 3 or any later version (LGPLv3 or + later), or the GNU General Public License, version 2 (GPLv2), in all + cases as published by the Free Software Foundation. +*/ #ifndef _ERROR_GEN_H #define _ERROR_GEN_H @@ -29,6 +19,18 @@ #define GF_FAILURE_DEFAULT 10 +/* + * Pseudo-errors refer to errors beyond the scope of traditional <-1, op_errno> + * returns. This facilitates the ability to return unexpected, but not -1 values + * and/or to inject operations that lead to implicit error conditions. The range + * for pseudo errors resides at a high value to avoid conflicts with the errno + * range. + */ +enum GF_PSEUDO_ERRORS { + GF_ERROR_SHORT_WRITE = 1000, /* short writev return value */ + GF_ERROR_MAX +}; + typedef struct { int enable[GF_FOP_MAXVALUE]; int op_count; diff --git a/xlators/debug/io-stats/src/Makefile.am b/xlators/debug/io-stats/src/Makefile.am index b894e79c3..332d79015 100644 --- a/xlators/debug/io-stats/src/Makefile.am +++ b/xlators/debug/io-stats/src/Makefile.am @@ -2,14 +2,15 @@ xlator_LTLIBRARIES = io-stats.la xlatordir = $(libdir)/glusterfs/$(PACKAGE_VERSION)/xlator/debug -io_stats_la_LDFLAGS = -module -avoidversion +io_stats_la_LDFLAGS = -module -avoid-version io_stats_la_SOURCES = io-stats.c io_stats_la_LIBADD = $(top_builddir)/libglusterfs/src/libglusterfs.la noinst_HEADERS = io-stats-mem-types.h -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) +AM_CPPFLAGS = $(GF_CPPFLAGS) -I$(top_srcdir)/libglusterfs/src + +AM_CFLAGS = -Wall $(GF_CFLAGS) CLEANFILES = diff --git a/xlators/debug/io-stats/src/io-stats-mem-types.h b/xlators/debug/io-stats/src/io-stats-mem-types.h index 2063f6d6a..c30dfb17e 100644 --- a/xlators/debug/io-stats/src/io-stats-mem-types.h +++ b/xlators/debug/io-stats/src/io-stats-mem-types.h @@ -1,24 +1,13 @@ - /* - Copyright (c) 2008-2011 Gluster, Inc. <http://www.gluster.com> + Copyright (c) 2008-2012 Red Hat, Inc. <http://www.redhat.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/>. + This file is licensed to you under your choice of the GNU Lesser + General Public License, version 3 or any later version (LGPLv3 or + later), or the GNU General Public License, version 2 (GPLv2), in all + cases as published by the Free Software Foundation. */ - #ifndef __IO_STATS_MEM_TYPES_H__ #define __IO_STATS_MEM_TYPES_H__ diff --git a/xlators/debug/io-stats/src/io-stats.c b/xlators/debug/io-stats/src/io-stats.c index 888c36dfb..7fb697ae4 100644 --- a/xlators/debug/io-stats/src/io-stats.c +++ b/xlators/debug/io-stats/src/io-stats.c @@ -1,22 +1,12 @@ /* - Copyright (c) 2006-2011 Gluster, Inc. <http://www.gluster.com> - This file is part of GlusterFS. - - GlusterFS is free software; you can redistribute it and/or modify - it under the terms of the GNU General Public License as published - by the Free Software Foundation; either version 3 of the License, - or (at your option) any later version. - - GlusterFS is distributed in the hope that it will be useful, but - WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - General Public License for more details. - - You should have received a copy of the GNU General Public License - along with this program. If not, see - <http://www.gnu.org/licenses/>. -*/ + Copyright (c) 2006-2012 Red Hat, Inc. <http://www.redhat.com> + This file is part of GlusterFS. + This file is licensed to you under your choice of the GNU Lesser + General Public License, version 3 or any later version (LGPLv3 or + later), or the GNU General Public License, version 2 (GPLv2), in all + cases as published by the Free Software Foundation. +*/ #ifndef _CONFIG_H #define _CONFIG_H #include "config.h" @@ -58,7 +48,7 @@ typedef enum { IOS_STATS_TYPE_READDIRP, IOS_STATS_TYPE_READ_THROUGHPUT, IOS_STATS_TYPE_WRITE_THROUGHPUT, - IOS_STATS_TYPE_MAX, + IOS_STATS_TYPE_MAX }ios_stats_type_t; typedef enum { @@ -293,43 +283,43 @@ is_fop_latency_started (call_frame_t *frame) } \ UNLOCK (&iosstat->lock); \ ios_stat_add_to_list (&conf->list[type], \ - value, iosstat); \ + value, iosstat); \ \ } while (0) #define BUMP_THROUGHPUT(iosstat, type) \ do { \ - struct ios_conf *conf = NULL; \ - double elapsed; \ - struct timeval *begin, *end; \ - double throughput; \ + struct ios_conf *conf = NULL; \ + double elapsed; \ + struct timeval *begin, *end; \ + double throughput; \ int flag = 0; \ - \ - begin = &frame->begin; \ - end = &frame->end; \ - \ - elapsed = (end->tv_sec - begin->tv_sec) * 1e6 \ - + (end->tv_usec - begin->tv_usec); \ - throughput = op_ret / elapsed; \ - \ - conf = this->private; \ - LOCK(&iosstat->lock); \ - { \ - if (iosstat->thru_counters[type].throughput \ + \ + begin = &frame->begin; \ + end = &frame->end; \ + \ + elapsed = (end->tv_sec - begin->tv_sec) * 1e6 \ + + (end->tv_usec - begin->tv_usec); \ + throughput = op_ret / elapsed; \ + \ + conf = this->private; \ + LOCK(&iosstat->lock); \ + { \ + if (iosstat->thru_counters[type].throughput \ <= throughput) { \ - iosstat->thru_counters[type].throughput = \ + iosstat->thru_counters[type].throughput = \ throughput; \ - gettimeofday (&iosstat-> \ + gettimeofday (&iosstat-> \ thru_counters[type].time, NULL); \ flag = 1; \ } \ } \ - UNLOCK (&iosstat->lock); \ + UNLOCK (&iosstat->lock); \ if (flag) \ ios_stat_add_to_list (&conf->thru_list[type], \ throughput, iosstat); \ - } while (0) + } while (0) int ios_fd_ctx_get (fd_t *fd, xlator_t *this, struct ios_fd **iosfd) @@ -484,12 +474,12 @@ ios_stat_add_to_list (struct ios_stat_head *list_head, uint64_t value, new = GF_CALLOC (1, sizeof (*new), gf_io_stats_mt_ios_stat_list); new->iosstat = iosstat; - new->value = value; + new->value = value; ios_stat_ref (iosstat); - list_add_tail (&new->list, &tmp->list); + list_add_tail (&new->list, &tmp->list); stat = last->iosstat; last->iosstat = NULL; - ios_stat_unref (stat); + ios_stat_unref (stat); list_del (&last->list); GF_FREE (last); if (reposition == MAX_LIST_MEMBERS) @@ -511,7 +501,7 @@ ios_stat_add_to_list (struct ios_stat_head *list_head, uint64_t value, list_head->members++; if (list_head->min_cnt > value) list_head->min_cnt = value; - } + } } out: UNLOCK (&list_head->lock); @@ -568,19 +558,16 @@ ios_dump_throughput_stats (struct ios_stat_head *list_head, xlator_t *this, FILE* logfp, ios_stats_type_t type) { struct ios_stat_list *entry = NULL; - struct timeval time = {0, }; - struct tm *tm = NULL; + struct timeval time = {0, }; char timestr[256] = {0, }; LOCK (&list_head->lock); { list_for_each_entry (entry, &list_head->iosstats->list, list) { - time = entry->iosstat->thru_counters[type].time; - tm = localtime (&time.tv_sec); - if (!tm) - continue; - strftime (timestr, 256, "%Y-%m-%d %H:%M:%S", tm); - snprintf (timestr + strlen (timestr), 256 - strlen (timestr), + gf_time_fmt (timestr, sizeof timestr, + entry->iosstat->thru_counters[type].time.tv_sec, + gf_timefmt_FT); + snprintf (timestr + strlen (timestr), sizeof timestr - strlen (timestr), ".%"GF_PRI_SUSECONDS, time.tv_usec); ios_log (this, logfp, "%s \t %-10.2f \t %s", @@ -600,7 +587,6 @@ io_stats_dump_global_to_logfp (xlator_t *this, struct ios_global_stats *stats, int index = 0; struct ios_stat_head *list_head = NULL; struct ios_conf *conf = NULL; - struct tm *tm = NULL; char timestr[256] = {0, }; char str_header[128] = {0}; char str_read[128] = {0}; @@ -694,9 +680,10 @@ io_stats_dump_global_to_logfp (xlator_t *this, struct ios_global_stats *stats, if (interval == -1) { LOCK (&conf->lock); { - tm = localtime (&conf->cumulative.max_openfd_time.tv_sec); - strftime (timestr, 256, "%Y-%m-%d %H:%M:%S", tm); - snprintf (timestr + strlen (timestr), 256 - strlen (timestr), + gf_time_fmt (timestr, sizeof timestr, + conf->cumulative.max_openfd_time.tv_sec, + gf_timefmt_FT); + snprintf (timestr + strlen (timestr), sizeof timestr - strlen (timestr), ".%"GF_PRI_SUSECONDS, conf->cumulative.max_openfd_time.tv_usec); ios_log (this, logfp, "Current open fd's: %"PRId64 @@ -735,13 +722,13 @@ io_stats_dump_global_to_logfp (xlator_t *this, struct ios_global_stats *stats, ios_log (this, logfp, "\nTIMESTAMP \t\t\t THROUGHPUT(KBPS)" "\tFILE NAME"); list_head = &conf->thru_list[IOS_STATS_THRU_READ]; - ios_dump_throughput_stats(list_head, this, logfp, IOS_STATS_THRU_READ); + ios_dump_throughput_stats(list_head, this, logfp, IOS_STATS_THRU_READ); ios_log (this, logfp, "\n======Write Throughput File Stats======"); ios_log (this, logfp, "\nTIMESTAMP \t\t\t THROUGHPUT(KBPS)" "\tFILE NAME"); list_head = &conf->thru_list[IOS_STATS_THRU_WRITE]; - ios_dump_throughput_stats (list_head, this, logfp, IOS_STATS_THRU_WRITE); + ios_dump_throughput_stats (list_head, this, logfp, IOS_STATS_THRU_WRITE); } return 0; } @@ -1080,36 +1067,45 @@ io_stats_dump_stats_to_dict (xlator_t *this, dict_t *resp, struct ios_stat_list *entry = NULL; int ret = -1; ios_stats_thru_t index = IOS_STATS_THRU_MAX; - struct tm *tm = NULL; char timestr[256] = {0, }; + char *dict_timestr = NULL; conf = this->private; switch (flags) { - case IOS_STATS_TYPE_OPEN: + case IOS_STATS_TYPE_OPEN: list_head = &conf->list[IOS_STATS_TYPE_OPEN]; LOCK (&conf->lock); { ret = dict_set_uint64 (resp, "current-open", conf->cumulative.nr_opens); if (ret) - goto out; + goto unlock; ret = dict_set_uint64 (resp, "max-open", conf->cumulative.max_nr_opens); - tm = localtime (&conf->cumulative.max_openfd_time.tv_sec); - strftime (timestr, 256, "%Y-%m-%d %H:%M:%S", tm); - snprintf (timestr + strlen (timestr), 256 - strlen (timestr), - ".%"GF_PRI_SUSECONDS, - conf->cumulative.max_openfd_time.tv_usec); - - ret = dict_set_str (resp, "max-openfd-time", - timestr); + gf_time_fmt (timestr, sizeof timestr, + conf->cumulative.max_openfd_time.tv_sec, + gf_timefmt_FT); + if (conf->cumulative.max_openfd_time.tv_sec) + snprintf (timestr + strlen (timestr), sizeof timestr - strlen (timestr), + ".%"GF_PRI_SUSECONDS, + conf->cumulative.max_openfd_time.tv_usec); + + dict_timestr = gf_strdup (timestr); + if (!dict_timestr) + goto unlock; + ret = dict_set_dynstr (resp, "max-openfd-time", + dict_timestr); if (ret) - goto out; + goto unlock; } + unlock: UNLOCK (&conf->lock); - + /* Do not proceed if we came here because of some error + * during the dict operation */ + if (ret) + goto out; break; case IOS_STATS_TYPE_READ: list_head = &conf->list[IOS_STATS_TYPE_READ]; @@ -1125,7 +1121,7 @@ io_stats_dump_stats_to_dict (xlator_t *this, dict_t *resp, break; case IOS_STATS_TYPE_READ_THROUGHPUT: list_head = &conf->thru_list[IOS_STATS_THRU_READ]; - index = IOS_STATS_THRU_READ; + index = IOS_STATS_THRU_READ; break; case IOS_STATS_TYPE_WRITE_THROUGHPUT: list_head = &conf->thru_list[IOS_STATS_THRU_WRITE]; @@ -1146,39 +1142,44 @@ io_stats_dump_stats_to_dict (xlator_t *this, dict_t *resp, snprintf (key, 256, "%s-%d", "filename", cnt); ret = dict_set_str (resp, key, entry->iosstat->filename); if (ret) - goto out; + goto unlock_list_head; snprintf (key, 256, "%s-%d", "value",cnt); ret = dict_set_uint64 (resp, key, entry->value); if (ret) - goto out; + goto unlock_list_head; if (index != IOS_STATS_THRU_MAX) { snprintf (key, 256, "%s-%d", "time-sec", cnt); - ret = dict_set_int32 (resp, key, + ret = dict_set_int32 (resp, key, entry->iosstat->thru_counters[index].time.tv_sec); if (ret) - goto out; + goto unlock_list_head; snprintf (key, 256, "%s-%d", "time-usec", cnt); - ret = dict_set_int32 (resp, key, + ret = dict_set_int32 (resp, key, entry->iosstat->thru_counters[index].time.tv_usec); if (ret) - goto out; + goto unlock_list_head; } if (cnt == list_cnt) break; } } +unlock_list_head: UNLOCK (&list_head->lock); - + /* ret is !=0 if some dict operation in the above critical region + * failed. */ + if (ret) + goto out; ret = dict_set_int32 (resp, "members", cnt); out: return ret; } + int io_stats_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 iatt *buf, - struct iatt *preparent, struct iatt *postparent) + struct iatt *preparent, struct iatt *postparent, dict_t *xdata) { struct ios_fd *iosfd = NULL; char *path = NULL; @@ -1231,21 +1232,21 @@ io_stats_create_cbk (call_frame_t *frame, void *cookie, xlator_t *this, unwind: UPDATE_PROFILE_STATS (frame, CREATE); STACK_UNWIND_STRICT (create, frame, op_ret, op_errno, fd, inode, buf, - preparent, postparent); + preparent, postparent, xdata); return 0; } int io_stats_open_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, fd_t *fd) + int32_t op_ret, int32_t op_errno, fd_t *fd, dict_t *xdata) { struct ios_fd *iosfd = NULL; char *path = NULL; struct ios_stat *iosstat = NULL; struct ios_conf *conf = NULL; - conf = this->private; + conf = this->private; path = frame->local; frame->local = NULL; @@ -1269,6 +1270,16 @@ io_stats_open_cbk (call_frame_t *frame, void *cookie, xlator_t *this, ios_fd_ctx_set (fd, this, iosfd); ios_inode_ctx_get (fd->inode, this, &iosstat); + if (!iosstat) { + iosstat = GF_CALLOC (1, sizeof (*iosstat), + gf_io_stats_mt_ios_stat); + if (iosstat) { + iosstat->filename = gf_strdup (path); + uuid_copy (iosstat->gfid, fd->inode->gfid); + LOCK_INIT (&iosstat->lock); + ios_inode_ctx_set (fd->inode, this, iosstat); + } + } LOCK (&conf->lock); { @@ -1286,7 +1297,7 @@ io_stats_open_cbk (call_frame_t *frame, void *cookie, xlator_t *this, unwind: UPDATE_PROFILE_STATS (frame, OPEN); - STACK_UNWIND_STRICT (open, frame, op_ret, op_errno, fd); + STACK_UNWIND_STRICT (open, frame, op_ret, op_errno, fd, xdata); return 0; } @@ -1294,10 +1305,10 @@ unwind: int io_stats_stat_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, struct iatt *buf) + int32_t op_ret, int32_t op_errno, struct iatt *buf, dict_t *xdata) { UPDATE_PROFILE_STATS (frame, STAT); - STACK_UNWIND_STRICT (stat, frame, op_ret, op_errno, buf); + STACK_UNWIND_STRICT (stat, frame, op_ret, op_errno, buf, xdata); return 0; } @@ -1306,7 +1317,7 @@ int io_stats_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 iatt *buf, struct iobref *iobref) + struct iatt *buf, struct iobref *iobref, dict_t *xdata) { int len = 0; fd_t *fd = NULL; @@ -1330,7 +1341,7 @@ io_stats_readv_cbk (call_frame_t *frame, void *cookie, xlator_t *this, } STACK_UNWIND_STRICT (readv, frame, op_ret, op_errno, - vector, count, buf, iobref); + vector, count, buf, iobref, xdata); return 0; } @@ -1339,7 +1350,7 @@ io_stats_readv_cbk (call_frame_t *frame, void *cookie, xlator_t *this, int io_stats_writev_cbk (call_frame_t *frame, void *cookie, xlator_t *this, int32_t op_ret, int32_t op_errno, - struct iatt *prebuf, struct iatt *postbuf) + struct iatt *prebuf, struct iatt *postbuf, dict_t *xdata) { struct ios_stat *iosstat = NULL; inode_t *inode = NULL; @@ -1351,13 +1362,13 @@ io_stats_writev_cbk (call_frame_t *frame, void *cookie, xlator_t *this, ios_inode_ctx_get (inode, this, &iosstat); if (iosstat) { BUMP_STATS (iosstat, IOS_STATS_TYPE_WRITE); - BUMP_THROUGHPUT (iosstat, IOS_STATS_THRU_WRITE); + BUMP_THROUGHPUT (iosstat, IOS_STATS_THRU_WRITE); inode = NULL; iosstat = NULL; } } - STACK_UNWIND_STRICT (writev, frame, op_ret, op_errno, prebuf, postbuf); + STACK_UNWIND_STRICT (writev, frame, op_ret, op_errno, prebuf, postbuf, xdata); return 0; } @@ -1367,7 +1378,7 @@ io_stats_writev_cbk (call_frame_t *frame, void *cookie, xlator_t *this, int io_stats_readdirp_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, gf_dirent_t *buf) + int32_t op_ret, int32_t op_errno, gf_dirent_t *buf, dict_t *xdata) { struct ios_stat *iosstat = NULL; inode_t *inode = frame->local; @@ -1383,17 +1394,17 @@ io_stats_readdirp_cbk (call_frame_t *frame, void *cookie, xlator_t *this, iosstat = NULL; } - STACK_UNWIND_STRICT (readdirp, frame, op_ret, op_errno, buf); + STACK_UNWIND_STRICT (readdirp, frame, op_ret, op_errno, buf, xdata); return 0; } int io_stats_readdir_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, gf_dirent_t *buf) + int32_t op_ret, int32_t op_errno, gf_dirent_t *buf, dict_t *xdata) { UPDATE_PROFILE_STATS (frame, READDIR); - STACK_UNWIND_STRICT (readdir, frame, op_ret, op_errno, buf); + STACK_UNWIND_STRICT (readdir, frame, op_ret, op_errno, buf, xdata); return 0; } @@ -1401,10 +1412,10 @@ io_stats_readdir_cbk (call_frame_t *frame, void *cookie, xlator_t *this, int io_stats_fsync_cbk (call_frame_t *frame, void *cookie, xlator_t *this, int32_t op_ret, int32_t op_errno, - struct iatt *prebuf, struct iatt *postbuf) + struct iatt *prebuf, struct iatt *postbuf, dict_t *xdata) { UPDATE_PROFILE_STATS (frame, FSYNC); - STACK_UNWIND_STRICT (fsync, frame, op_ret, op_errno, prebuf, postbuf); + STACK_UNWIND_STRICT (fsync, frame, op_ret, op_errno, prebuf, postbuf, xdata); return 0; } @@ -1412,10 +1423,10 @@ io_stats_fsync_cbk (call_frame_t *frame, void *cookie, xlator_t *this, int io_stats_setattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this, int32_t op_ret, int32_t op_errno, - struct iatt *preop, struct iatt *postop) + struct iatt *preop, struct iatt *postop, dict_t *xdata) { UPDATE_PROFILE_STATS (frame, SETATTR); - STACK_UNWIND_STRICT (setattr, frame, op_ret, op_errno, preop, postop); + STACK_UNWIND_STRICT (setattr, frame, op_ret, op_errno, preop, postop, xdata); return 0; } @@ -1423,11 +1434,11 @@ io_stats_setattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this, int io_stats_unlink_cbk (call_frame_t *frame, void *cookie, xlator_t *this, int32_t op_ret, int32_t op_errno, - struct iatt *preparent, struct iatt *postparent) + struct iatt *preparent, struct iatt *postparent, dict_t *xdata) { UPDATE_PROFILE_STATS (frame, UNLINK); STACK_UNWIND_STRICT (unlink, frame, op_ret, op_errno, - preparent, postparent); + preparent, postparent, xdata); return 0; } @@ -1437,12 +1448,12 @@ int io_stats_rename_cbk (call_frame_t *frame, void *cookie, xlator_t *this, int32_t op_ret, int32_t op_errno, struct iatt *buf, struct iatt *preoldparent, struct iatt *postoldparent, - struct iatt *prenewparent, struct iatt *postnewparent) + struct iatt *prenewparent, struct iatt *postnewparent, dict_t *xdata) { UPDATE_PROFILE_STATS (frame, RENAME); STACK_UNWIND_STRICT (rename, frame, op_ret, op_errno, buf, preoldparent, postoldparent, - prenewparent, postnewparent); + prenewparent, postnewparent, xdata); return 0; } @@ -1450,10 +1461,10 @@ io_stats_rename_cbk (call_frame_t *frame, void *cookie, xlator_t *this, int io_stats_readlink_cbk (call_frame_t *frame, void *cookie, xlator_t *this, int32_t op_ret, int32_t op_errno, const char *buf, - struct iatt *sbuf) + struct iatt *sbuf, dict_t *xdata) { UPDATE_PROFILE_STATS (frame, READLINK); - STACK_UNWIND_STRICT (readlink, frame, op_ret, op_errno, buf, sbuf); + STACK_UNWIND_STRICT (readlink, frame, op_ret, op_errno, buf, sbuf, xdata); return 0; } @@ -1462,10 +1473,10 @@ int io_stats_lookup_cbk (call_frame_t *frame, void *cookie, xlator_t *this, int32_t op_ret, int32_t op_errno, inode_t *inode, struct iatt *buf, - dict_t *xattr, struct iatt *postparent) + dict_t *xdata, struct iatt *postparent) { UPDATE_PROFILE_STATS (frame, LOOKUP); - STACK_UNWIND_STRICT (lookup, frame, op_ret, op_errno, inode, buf, xattr, + STACK_UNWIND_STRICT (lookup, frame, op_ret, op_errno, inode, buf, xdata, postparent); return 0; } @@ -1475,11 +1486,11 @@ int io_stats_symlink_cbk (call_frame_t *frame, void *cookie, xlator_t *this, int32_t op_ret, int32_t op_errno, inode_t *inode, struct iatt *buf, - struct iatt *preparent, struct iatt *postparent) + struct iatt *preparent, struct iatt *postparent, dict_t *xdata) { UPDATE_PROFILE_STATS (frame, SYMLINK); STACK_UNWIND_STRICT (symlink, frame, op_ret, op_errno, inode, buf, - preparent, postparent); + preparent, postparent, xdata); return 0; } @@ -1488,11 +1499,11 @@ int io_stats_mknod_cbk (call_frame_t *frame, void *cookie, xlator_t *this, int32_t op_ret, int32_t op_errno, inode_t *inode, struct iatt *buf, - struct iatt *preparent, struct iatt *postparent) + struct iatt *preparent, struct iatt *postparent, dict_t *xdata) { UPDATE_PROFILE_STATS (frame, MKNOD); STACK_UNWIND_STRICT (mknod, frame, op_ret, op_errno, inode, buf, - preparent, postparent); + preparent, postparent, xdata); return 0; } @@ -1501,7 +1512,8 @@ int io_stats_mkdir_cbk (call_frame_t *frame, void *cookie, xlator_t *this, int32_t op_ret, int32_t op_errno, inode_t *inode, struct iatt *buf, - struct iatt *preparent, struct iatt *postparent) + struct iatt *preparent, struct iatt *postparent, + dict_t *xdata) { struct ios_stat *iosstat = NULL; char *path = frame->local; @@ -1519,8 +1531,11 @@ io_stats_mkdir_cbk (call_frame_t *frame, void *cookie, xlator_t *this, } unwind: + /* local is assigned with path */ + GF_FREE (frame->local); + frame->local = NULL; STACK_UNWIND_STRICT (mkdir, frame, op_ret, op_errno, inode, buf, - preparent, postparent); + preparent, postparent, xdata); return 0; } @@ -1529,28 +1544,28 @@ int io_stats_link_cbk (call_frame_t *frame, void *cookie, xlator_t *this, int32_t op_ret, int32_t op_errno, inode_t *inode, struct iatt *buf, - struct iatt *preparent, struct iatt *postparent) + struct iatt *preparent, struct iatt *postparent, dict_t *xdata) { UPDATE_PROFILE_STATS (frame, LINK); STACK_UNWIND_STRICT (link, frame, op_ret, op_errno, inode, buf, - preparent, postparent); + preparent, postparent, xdata); return 0; } int io_stats_flush_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno) + int32_t op_ret, int32_t op_errno, dict_t *xdata) { UPDATE_PROFILE_STATS (frame, FLUSH); - STACK_UNWIND_STRICT (flush, frame, op_ret, op_errno); + STACK_UNWIND_STRICT (flush, frame, op_ret, op_errno, xdata); return 0; } int io_stats_opendir_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, fd_t *fd) + int32_t op_ret, int32_t op_errno, fd_t *fd, dict_t *xdata) { struct ios_stat *iosstat = NULL; int ret = -1; @@ -1566,7 +1581,7 @@ io_stats_opendir_cbk (call_frame_t *frame, void *cookie, xlator_t *this, BUMP_STATS (iosstat, IOS_STATS_TYPE_OPENDIR); unwind: - STACK_UNWIND_STRICT (opendir, frame, op_ret, op_errno, fd); + STACK_UNWIND_STRICT (opendir, frame, op_ret, op_errno, fd, xdata); return 0; } @@ -1574,13 +1589,13 @@ unwind: int io_stats_rmdir_cbk (call_frame_t *frame, void *cookie, xlator_t *this, int32_t op_ret, int32_t op_errno, - struct iatt *preparent, struct iatt *postparent) + struct iatt *preparent, struct iatt *postparent, dict_t *xdata) { UPDATE_PROFILE_STATS (frame, RMDIR); STACK_UNWIND_STRICT (rmdir, frame, op_ret, op_errno, - preparent, postparent); + preparent, postparent, xdata); return 0; } @@ -1588,100 +1603,100 @@ io_stats_rmdir_cbk (call_frame_t *frame, void *cookie, xlator_t *this, int io_stats_truncate_cbk (call_frame_t *frame, void *cookie, xlator_t *this, int32_t op_ret, int32_t op_errno, - struct iatt *prebuf, struct iatt *postbuf) + struct iatt *prebuf, struct iatt *postbuf, dict_t *xdata) { UPDATE_PROFILE_STATS (frame, TRUNCATE); STACK_UNWIND_STRICT (truncate, frame, op_ret, op_errno, - prebuf, postbuf); + prebuf, postbuf, xdata); return 0; } int io_stats_statfs_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, struct statvfs *buf) + int32_t op_ret, int32_t op_errno, struct statvfs *buf, dict_t *xdata) { UPDATE_PROFILE_STATS (frame, STATFS); - STACK_UNWIND_STRICT (statfs, frame, op_ret, op_errno, buf); + STACK_UNWIND_STRICT (statfs, frame, op_ret, op_errno, buf, xdata); return 0; } int io_stats_setxattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno) + int32_t op_ret, int32_t op_errno, dict_t *xdata) { UPDATE_PROFILE_STATS (frame, SETXATTR); - STACK_UNWIND_STRICT (setxattr, frame, op_ret, op_errno); + STACK_UNWIND_STRICT (setxattr, frame, op_ret, op_errno, xdata); return 0; } int io_stats_getxattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, dict_t *dict) + int32_t op_ret, int32_t op_errno, dict_t *dict, dict_t *xdata) { UPDATE_PROFILE_STATS (frame, GETXATTR); - STACK_UNWIND_STRICT (getxattr, frame, op_ret, op_errno, dict); + STACK_UNWIND_STRICT (getxattr, frame, op_ret, op_errno, dict, xdata); return 0; } int io_stats_removexattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno) + int32_t op_ret, int32_t op_errno, dict_t *xdata) { UPDATE_PROFILE_STATS (frame, REMOVEXATTR); - STACK_UNWIND_STRICT (removexattr, frame, op_ret, op_errno); + STACK_UNWIND_STRICT (removexattr, frame, op_ret, op_errno, xdata); return 0; } int io_stats_fsetxattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno) + int32_t op_ret, int32_t op_errno, dict_t *xdata) { UPDATE_PROFILE_STATS (frame, FSETXATTR); - STACK_UNWIND_STRICT (fsetxattr, frame, op_ret, op_errno); + STACK_UNWIND_STRICT (fsetxattr, frame, op_ret, op_errno, xdata); return 0; } int io_stats_fgetxattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, dict_t *dict) + int32_t op_ret, int32_t op_errno, dict_t *dict, dict_t *xdata) { UPDATE_PROFILE_STATS (frame, FGETXATTR); - STACK_UNWIND_STRICT (fgetxattr, frame, op_ret, op_errno, dict); + STACK_UNWIND_STRICT (fgetxattr, frame, op_ret, op_errno, dict, xdata); return 0; } int io_stats_fremovexattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno) + int32_t op_ret, int32_t op_errno, dict_t *xdata) { UPDATE_PROFILE_STATS (frame, FREMOVEXATTR); - STACK_UNWIND_STRICT (fremovexattr, frame, op_ret, op_errno); + STACK_UNWIND_STRICT (fremovexattr, frame, op_ret, op_errno, xdata); return 0; } int io_stats_fsyncdir_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno) + int32_t op_ret, int32_t op_errno, dict_t *xdata) { UPDATE_PROFILE_STATS (frame, FSYNCDIR); - STACK_UNWIND_STRICT (fsyncdir, frame, op_ret, op_errno); + STACK_UNWIND_STRICT (fsyncdir, frame, op_ret, op_errno, xdata); return 0; } int io_stats_access_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno) + int32_t op_ret, int32_t op_errno, dict_t *xdata) { UPDATE_PROFILE_STATS (frame, ACCESS); - STACK_UNWIND_STRICT (access, frame, op_ret, op_errno); + STACK_UNWIND_STRICT (access, frame, op_ret, op_errno, xdata); return 0; } @@ -1689,92 +1704,126 @@ io_stats_access_cbk (call_frame_t *frame, void *cookie, xlator_t *this, int io_stats_ftruncate_cbk (call_frame_t *frame, void *cookie, xlator_t *this, int32_t op_ret, int32_t op_errno, - struct iatt *prebuf, struct iatt *postbuf) + struct iatt *prebuf, struct iatt *postbuf, dict_t *xdata) { UPDATE_PROFILE_STATS (frame, FTRUNCATE); STACK_UNWIND_STRICT (ftruncate, frame, op_ret, op_errno, - prebuf, postbuf); + prebuf, postbuf, xdata); return 0; } int io_stats_fstat_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, struct iatt *buf) + int32_t op_ret, int32_t op_errno, struct iatt *buf, dict_t *xdata) { UPDATE_PROFILE_STATS (frame, FSTAT); - STACK_UNWIND_STRICT (fstat, frame, op_ret, op_errno, buf); + STACK_UNWIND_STRICT (fstat, frame, op_ret, op_errno, buf, xdata); return 0; } int +io_stats_fallocate_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, struct iatt *prebuf, + struct iatt *postbuf, dict_t *xdata) +{ + UPDATE_PROFILE_STATS(frame, FALLOCATE); + STACK_UNWIND_STRICT(fallocate, frame, op_ret, op_errno, prebuf, postbuf, + xdata); + return 0; +} + + +int +io_stats_discard_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, struct iatt *prebuf, + struct iatt *postbuf, dict_t *xdata) +{ + UPDATE_PROFILE_STATS(frame, DISCARD); + STACK_UNWIND_STRICT(discard, frame, op_ret, op_errno, prebuf, postbuf, + xdata); + return 0; +} + +int +io_stats_zerofill_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, struct iatt *prebuf, + struct iatt *postbuf, dict_t *xdata) +{ + UPDATE_PROFILE_STATS(frame, ZEROFILL); + STACK_UNWIND_STRICT(zerofill, frame, op_ret, op_errno, prebuf, postbuf, + xdata); + return 0; +} + +int io_stats_lk_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, struct gf_flock *lock) + int32_t op_ret, int32_t op_errno, struct gf_flock *lock, dict_t *xdata) { UPDATE_PROFILE_STATS (frame, LK); - STACK_UNWIND_STRICT (lk, frame, op_ret, op_errno, lock); + STACK_UNWIND_STRICT (lk, frame, op_ret, op_errno, lock, xdata); return 0; } int io_stats_entrylk_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno) + int32_t op_ret, int32_t op_errno, dict_t *xdata) { UPDATE_PROFILE_STATS (frame, ENTRYLK); - STACK_UNWIND_STRICT (entrylk, frame, op_ret, op_errno); + STACK_UNWIND_STRICT (entrylk, frame, op_ret, op_errno, xdata); return 0; } int io_stats_xattrop_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, dict_t *dict) + int32_t op_ret, int32_t op_errno, dict_t *dict, dict_t *xdata) { UPDATE_PROFILE_STATS (frame, XATTROP); - STACK_UNWIND_STRICT (xattrop, frame, op_ret, op_errno, dict); + STACK_UNWIND_STRICT (xattrop, frame, op_ret, op_errno, dict, xdata); return 0; } int io_stats_fxattrop_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, dict_t *dict) + int32_t op_ret, int32_t op_errno, dict_t *dict, dict_t *xdata) { UPDATE_PROFILE_STATS (frame, FXATTROP); - STACK_UNWIND_STRICT (fxattrop, frame, op_ret, op_errno, dict); + STACK_UNWIND_STRICT (fxattrop, frame, op_ret, op_errno, dict, xdata); return 0; } int io_stats_inodelk_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno) + int32_t op_ret, int32_t op_errno, dict_t *xdata) { UPDATE_PROFILE_STATS (frame, INODELK); - STACK_UNWIND_STRICT (inodelk, frame, op_ret, op_errno); + STACK_UNWIND_STRICT (inodelk, frame, op_ret, op_errno, xdata); return 0; } int io_stats_entrylk (call_frame_t *frame, xlator_t *this, const char *volume, loc_t *loc, const char *basename, - entrylk_cmd cmd, entrylk_type type) + entrylk_cmd cmd, entrylk_type type, dict_t *xdata) { START_FOP_LATENCY (frame); STACK_WIND (frame, io_stats_entrylk_cbk, FIRST_CHILD (this), FIRST_CHILD (this)->fops->entrylk, - volume, loc, basename, cmd, type); + volume, loc, basename, cmd, type, xdata); return 0; } int io_stats_inodelk (call_frame_t *frame, xlator_t *this, - const char *volume, loc_t *loc, int32_t cmd, struct gf_flock *flock) + const char *volume, loc_t *loc, int32_t cmd, struct gf_flock *flock, dict_t *xdata) { START_FOP_LATENCY (frame); @@ -1782,128 +1831,122 @@ io_stats_inodelk (call_frame_t *frame, xlator_t *this, STACK_WIND (frame, io_stats_inodelk_cbk, FIRST_CHILD (this), FIRST_CHILD (this)->fops->inodelk, - volume, loc, cmd, flock); + volume, loc, cmd, flock, xdata); return 0; } int io_stats_finodelk_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno) + int32_t op_ret, int32_t op_errno, dict_t *xdata) { UPDATE_PROFILE_STATS (frame, FINODELK); - STACK_UNWIND_STRICT (finodelk, frame, op_ret, op_errno); + STACK_UNWIND_STRICT (finodelk, frame, op_ret, op_errno, xdata); return 0; } int -io_stats_finodelk (call_frame_t *frame, xlator_t *this, - const char *volume, fd_t *fd, int32_t cmd, struct gf_flock *flock) +io_stats_finodelk (call_frame_t *frame, xlator_t *this, const char *volume, + fd_t *fd, int32_t cmd, struct gf_flock *flock, dict_t *xdata) { START_FOP_LATENCY (frame); STACK_WIND (frame, io_stats_finodelk_cbk, FIRST_CHILD (this), FIRST_CHILD (this)->fops->finodelk, - volume, fd, cmd, flock); + volume, fd, cmd, flock, xdata); return 0; } int -io_stats_xattrop (call_frame_t *frame, xlator_t *this, - loc_t *loc, gf_xattrop_flags_t flags, dict_t *dict) +io_stats_xattrop (call_frame_t *frame, xlator_t *this, loc_t *loc, + gf_xattrop_flags_t flags, dict_t *dict, dict_t *xdata) { START_FOP_LATENCY (frame); STACK_WIND (frame, io_stats_xattrop_cbk, FIRST_CHILD(this), FIRST_CHILD(this)->fops->xattrop, - loc, flags, dict); - + loc, flags, dict, xdata); return 0; } int -io_stats_fxattrop (call_frame_t *frame, xlator_t *this, - fd_t *fd, gf_xattrop_flags_t flags, dict_t *dict) +io_stats_fxattrop (call_frame_t *frame, xlator_t *this, fd_t *fd, + gf_xattrop_flags_t flags, dict_t *dict, dict_t *xdata) { START_FOP_LATENCY (frame); STACK_WIND (frame, io_stats_fxattrop_cbk, FIRST_CHILD(this), FIRST_CHILD(this)->fops->fxattrop, - fd, flags, dict); - + fd, flags, dict, xdata); return 0; } int io_stats_lookup (call_frame_t *frame, xlator_t *this, - loc_t *loc, dict_t *xattr_req) + loc_t *loc, dict_t *xdata) { START_FOP_LATENCY (frame); STACK_WIND (frame, io_stats_lookup_cbk, FIRST_CHILD(this), FIRST_CHILD(this)->fops->lookup, - loc, xattr_req); - + loc, xdata); return 0; } int -io_stats_stat (call_frame_t *frame, xlator_t *this, loc_t *loc) +io_stats_stat (call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *xdata) { START_FOP_LATENCY (frame); STACK_WIND (frame, io_stats_stat_cbk, FIRST_CHILD(this), FIRST_CHILD(this)->fops->stat, - loc); - + loc, xdata); return 0; } int io_stats_readlink (call_frame_t *frame, xlator_t *this, - loc_t *loc, size_t size) + loc_t *loc, size_t size, dict_t *xdata) { START_FOP_LATENCY (frame); STACK_WIND (frame, io_stats_readlink_cbk, FIRST_CHILD(this), FIRST_CHILD(this)->fops->readlink, - loc, size); - + loc, size, xdata); return 0; } int -io_stats_mknod (call_frame_t *frame, xlator_t *this, - loc_t *loc, mode_t mode, dev_t dev, dict_t *params) +io_stats_mknod (call_frame_t *frame, xlator_t *this, loc_t *loc, + mode_t mode, dev_t dev, mode_t umask, dict_t *xdata) { START_FOP_LATENCY (frame); STACK_WIND (frame, io_stats_mknod_cbk, FIRST_CHILD(this), FIRST_CHILD(this)->fops->mknod, - loc, mode, dev, params); - + loc, mode, dev, umask, xdata); return 0; } int io_stats_mkdir (call_frame_t *frame, xlator_t *this, - loc_t *loc, mode_t mode, dict_t *params) + loc_t *loc, mode_t mode, mode_t umask, dict_t *xdata) { frame->local = gf_strdup (loc->path); @@ -1912,117 +1955,112 @@ io_stats_mkdir (call_frame_t *frame, xlator_t *this, STACK_WIND (frame, io_stats_mkdir_cbk, FIRST_CHILD(this), FIRST_CHILD(this)->fops->mkdir, - loc, mode, params); + loc, mode, umask, xdata); return 0; } int io_stats_unlink (call_frame_t *frame, xlator_t *this, - loc_t *loc) + loc_t *loc, int xflag, dict_t *xdata) { START_FOP_LATENCY (frame); STACK_WIND (frame, io_stats_unlink_cbk, FIRST_CHILD(this), FIRST_CHILD(this)->fops->unlink, - loc); + loc, xflag, xdata); return 0; } int io_stats_rmdir (call_frame_t *frame, xlator_t *this, - loc_t *loc, int flags) + loc_t *loc, int flags, dict_t *xdata) { START_FOP_LATENCY (frame); STACK_WIND (frame, io_stats_rmdir_cbk, FIRST_CHILD(this), FIRST_CHILD(this)->fops->rmdir, - loc, flags); - + loc, flags, xdata); return 0; } int -io_stats_symlink (call_frame_t *frame, xlator_t *this, - const char *linkpath, loc_t *loc, dict_t *params) +io_stats_symlink (call_frame_t *frame, xlator_t *this, const char *linkpath, + loc_t *loc, mode_t umask, dict_t *xdata) { START_FOP_LATENCY (frame); STACK_WIND (frame, io_stats_symlink_cbk, FIRST_CHILD(this), FIRST_CHILD(this)->fops->symlink, - linkpath, loc, params); - + linkpath, loc, umask, xdata); return 0; } int io_stats_rename (call_frame_t *frame, xlator_t *this, - loc_t *oldloc, loc_t *newloc) + loc_t *oldloc, loc_t *newloc, dict_t *xdata) { START_FOP_LATENCY (frame); STACK_WIND (frame, io_stats_rename_cbk, FIRST_CHILD(this), FIRST_CHILD(this)->fops->rename, - oldloc, newloc); - + oldloc, newloc, xdata); return 0; } int io_stats_link (call_frame_t *frame, xlator_t *this, - loc_t *oldloc, loc_t *newloc) + loc_t *oldloc, loc_t *newloc, dict_t *xdata) { START_FOP_LATENCY (frame); STACK_WIND (frame, io_stats_link_cbk, FIRST_CHILD(this), FIRST_CHILD(this)->fops->link, - oldloc, newloc); + oldloc, newloc, xdata); return 0; } int io_stats_setattr (call_frame_t *frame, xlator_t *this, - loc_t *loc, struct iatt *stbuf, int32_t valid) + loc_t *loc, struct iatt *stbuf, int32_t valid, dict_t *xdata) { START_FOP_LATENCY (frame); STACK_WIND (frame, io_stats_setattr_cbk, FIRST_CHILD(this), FIRST_CHILD(this)->fops->setattr, - loc, stbuf, valid); - + loc, stbuf, valid, xdata); return 0; } int io_stats_truncate (call_frame_t *frame, xlator_t *this, - loc_t *loc, off_t offset) + loc_t *loc, off_t offset, dict_t *xdata) { START_FOP_LATENCY (frame); STACK_WIND (frame, io_stats_truncate_cbk, FIRST_CHILD(this), FIRST_CHILD(this)->fops->truncate, - loc, offset); - + loc, offset, xdata); return 0; } int -io_stats_open (call_frame_t *frame, xlator_t *this, - loc_t *loc, int32_t flags, fd_t *fd, int32_t wbflags) +io_stats_open (call_frame_t *frame, xlator_t *this, loc_t *loc, + int32_t flags, fd_t *fd, dict_t *xdata) { frame->local = gf_strdup (loc->path); @@ -2031,7 +2069,7 @@ io_stats_open (call_frame_t *frame, xlator_t *this, STACK_WIND (frame, io_stats_open_cbk, FIRST_CHILD(this), FIRST_CHILD(this)->fops->open, - loc, flags, fd, wbflags); + loc, flags, fd, xdata); return 0; } @@ -2039,7 +2077,7 @@ io_stats_open (call_frame_t *frame, xlator_t *this, int io_stats_create (call_frame_t *frame, xlator_t *this, loc_t *loc, int32_t flags, mode_t mode, - fd_t *fd, dict_t *params) + mode_t umask, fd_t *fd, dict_t *xdata) { frame->local = gf_strdup (loc->path); @@ -2048,14 +2086,14 @@ io_stats_create (call_frame_t *frame, xlator_t *this, STACK_WIND (frame, io_stats_create_cbk, FIRST_CHILD(this), FIRST_CHILD(this)->fops->create, - loc, flags, mode, fd, params); + loc, flags, mode, umask, fd, xdata); return 0; } int io_stats_readv (call_frame_t *frame, xlator_t *this, - fd_t *fd, size_t size, off_t offset, uint32_t flags) + fd_t *fd, size_t size, off_t offset, uint32_t flags, dict_t *xdata) { frame->local = fd; @@ -2064,7 +2102,7 @@ io_stats_readv (call_frame_t *frame, xlator_t *this, STACK_WIND (frame, io_stats_readv_cbk, FIRST_CHILD(this), FIRST_CHILD(this)->fops->readv, - fd, size, offset, flags); + fd, size, offset, flags, xdata); return 0; } @@ -2073,7 +2111,7 @@ int io_stats_writev (call_frame_t *frame, xlator_t *this, fd_t *fd, struct iovec *vector, int32_t count, off_t offset, - uint32_t flags, struct iobref *iobref) + uint32_t flags, struct iobref *iobref, dict_t *xdata) { int len = 0; @@ -2087,7 +2125,7 @@ io_stats_writev (call_frame_t *frame, xlator_t *this, STACK_WIND (frame, io_stats_writev_cbk, FIRST_CHILD(this), FIRST_CHILD(this)->fops->writev, - fd, vector, count, offset, flags, iobref); + fd, vector, count, offset, flags, iobref, xdata); return 0; } @@ -2095,47 +2133,47 @@ io_stats_writev (call_frame_t *frame, xlator_t *this, int io_stats_statfs (call_frame_t *frame, xlator_t *this, - loc_t *loc) + loc_t *loc, dict_t *xdata) { START_FOP_LATENCY (frame); STACK_WIND (frame, io_stats_statfs_cbk, FIRST_CHILD(this), FIRST_CHILD(this)->fops->statfs, - loc); + loc, xdata); return 0; } int io_stats_flush (call_frame_t *frame, xlator_t *this, - fd_t *fd) + fd_t *fd, dict_t *xdata) { START_FOP_LATENCY (frame); STACK_WIND (frame, io_stats_flush_cbk, FIRST_CHILD(this), FIRST_CHILD(this)->fops->flush, - fd); + fd, xdata); return 0; } int io_stats_fsync (call_frame_t *frame, xlator_t *this, - fd_t *fd, int32_t flags) + fd_t *fd, int32_t flags, dict_t *xdata) { START_FOP_LATENCY (frame); STACK_WIND (frame, io_stats_fsync_cbk, FIRST_CHILD(this), FIRST_CHILD(this)->fops->fsync, - fd, flags); + fd, flags, xdata); return 0; } -void +int conditional_dump (dict_t *dict, char *key, data_t *value, void *data) { struct { @@ -2159,27 +2197,27 @@ conditional_dump (dict_t *dict, char *key, data_t *value, void *data) if (!strncmp (filename, "", 1)) { gf_log (this->name, GF_LOG_ERROR, "No filename given"); - return; + return -1; } logfp = fopen (filename, "w+"); - GF_ASSERT (logfp); if (!logfp) { gf_log (this->name, GF_LOG_ERROR, "failed to open %s " "for writing", filename); - return; + return -1; } (void) ios_dump_args_init (&args, IOS_DUMP_TYPE_FILE, logfp); io_stats_dump (this, &args); fclose (logfp); } + return 0; } int io_stats_setxattr (call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *dict, - int32_t flags) + int32_t flags, dict_t *xdata) { struct { xlator_t *this; @@ -2198,36 +2236,35 @@ io_stats_setxattr (call_frame_t *frame, xlator_t *this, STACK_WIND (frame, io_stats_setxattr_cbk, FIRST_CHILD(this), FIRST_CHILD(this)->fops->setxattr, - loc, dict, flags); + loc, dict, flags, xdata); return 0; } int io_stats_getxattr (call_frame_t *frame, xlator_t *this, - loc_t *loc, const char *name) + loc_t *loc, const char *name, dict_t *xdata) { START_FOP_LATENCY (frame); STACK_WIND (frame, io_stats_getxattr_cbk, FIRST_CHILD(this), FIRST_CHILD(this)->fops->getxattr, - loc, name); + loc, name, xdata); return 0; } int io_stats_removexattr (call_frame_t *frame, xlator_t *this, - loc_t *loc, const char *name) + loc_t *loc, const char *name, dict_t *xdata) { START_FOP_LATENCY (frame); STACK_WIND (frame, io_stats_removexattr_cbk, FIRST_CHILD(this), FIRST_CHILD(this)->fops->removexattr, - loc, name); - + loc, name, xdata); return 0; } @@ -2235,50 +2272,49 @@ io_stats_removexattr (call_frame_t *frame, xlator_t *this, int io_stats_fsetxattr (call_frame_t *frame, xlator_t *this, fd_t *fd, dict_t *dict, - int32_t flags) + int32_t flags, dict_t *xdata) { START_FOP_LATENCY (frame); STACK_WIND (frame, io_stats_fsetxattr_cbk, FIRST_CHILD(this), FIRST_CHILD(this)->fops->fsetxattr, - fd, dict, flags); + fd, dict, flags, xdata); return 0; } int io_stats_fgetxattr (call_frame_t *frame, xlator_t *this, - fd_t *fd, const char *name) + fd_t *fd, const char *name, dict_t *xdata) { START_FOP_LATENCY (frame); STACK_WIND (frame, io_stats_fgetxattr_cbk, FIRST_CHILD(this), FIRST_CHILD(this)->fops->fgetxattr, - fd, name); + fd, name, xdata); return 0; } int io_stats_fremovexattr (call_frame_t *frame, xlator_t *this, - fd_t *fd, const char *name) + fd_t *fd, const char *name, dict_t *xdata) { START_FOP_LATENCY (frame); STACK_WIND (frame, io_stats_fremovexattr_cbk, FIRST_CHILD(this), FIRST_CHILD(this)->fops->fremovexattr, - fd, name); - + fd, name, xdata); return 0; } int io_stats_opendir (call_frame_t *frame, xlator_t *this, - loc_t *loc, fd_t *fd) + loc_t *loc, fd_t *fd, dict_t *xdata) { START_FOP_LATENCY (frame); @@ -2286,7 +2322,7 @@ io_stats_opendir (call_frame_t *frame, xlator_t *this, STACK_WIND (frame, io_stats_opendir_cbk, FIRST_CHILD(this), FIRST_CHILD(this)->fops->opendir, - loc, fd); + loc, fd, xdata); return 0; } @@ -2301,107 +2337,143 @@ io_stats_readdirp (call_frame_t *frame, xlator_t *this, fd_t *fd, size_t size, FIRST_CHILD(this), FIRST_CHILD(this)->fops->readdirp, fd, size, offset, dict); - return 0; } int io_stats_readdir (call_frame_t *frame, xlator_t *this, - fd_t *fd, size_t size, off_t offset) + fd_t *fd, size_t size, off_t offset, dict_t *xdata) { START_FOP_LATENCY (frame); STACK_WIND (frame, io_stats_readdir_cbk, FIRST_CHILD(this), FIRST_CHILD(this)->fops->readdir, - fd, size, offset); - + fd, size, offset, xdata); return 0; } int io_stats_fsyncdir (call_frame_t *frame, xlator_t *this, - fd_t *fd, int32_t datasync) + fd_t *fd, int32_t datasync, dict_t *xdata) { START_FOP_LATENCY (frame); STACK_WIND (frame, io_stats_fsyncdir_cbk, FIRST_CHILD(this), FIRST_CHILD(this)->fops->fsyncdir, - fd, datasync); + fd, datasync, xdata); return 0; } int io_stats_access (call_frame_t *frame, xlator_t *this, - loc_t *loc, int32_t mask) + loc_t *loc, int32_t mask, dict_t *xdata) { START_FOP_LATENCY (frame); STACK_WIND (frame, io_stats_access_cbk, FIRST_CHILD(this), FIRST_CHILD(this)->fops->access, - loc, mask); + loc, mask, xdata); return 0; } int io_stats_ftruncate (call_frame_t *frame, xlator_t *this, - fd_t *fd, off_t offset) + fd_t *fd, off_t offset, dict_t *xdata) { START_FOP_LATENCY (frame); STACK_WIND (frame, io_stats_ftruncate_cbk, FIRST_CHILD(this), FIRST_CHILD(this)->fops->ftruncate, - fd, offset); - + fd, offset, xdata); return 0; } int io_stats_fsetattr (call_frame_t *frame, xlator_t *this, - fd_t *fd, struct iatt *stbuf, int32_t valid) + fd_t *fd, struct iatt *stbuf, int32_t valid, dict_t *xdata) { START_FOP_LATENCY (frame); STACK_WIND (frame, io_stats_setattr_cbk, FIRST_CHILD(this), FIRST_CHILD(this)->fops->fsetattr, - fd, stbuf, valid); + fd, stbuf, valid, xdata); return 0; } int io_stats_fstat (call_frame_t *frame, xlator_t *this, - fd_t *fd) + fd_t *fd, dict_t *xdata) { START_FOP_LATENCY (frame); STACK_WIND (frame, io_stats_fstat_cbk, FIRST_CHILD(this), FIRST_CHILD(this)->fops->fstat, - fd); + fd, xdata); + return 0; +} + + +int +io_stats_fallocate(call_frame_t *frame, xlator_t *this, fd_t *fd, int32_t mode, + off_t offset, size_t len, dict_t *xdata) +{ + START_FOP_LATENCY(frame); + + STACK_WIND(frame, io_stats_fallocate_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->fallocate, fd, mode, offset, len, + xdata); + + return 0; +} + + +int +io_stats_discard(call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset, + size_t len, dict_t *xdata) +{ + START_FOP_LATENCY(frame); + + STACK_WIND(frame, io_stats_discard_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->discard, fd, offset, len, xdata); + + return 0; +} + +int +io_stats_zerofill(call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset, + size_t len, dict_t *xdata) +{ + START_FOP_LATENCY(frame); + + STACK_WIND(frame, io_stats_zerofill_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->zerofill, fd, offset, len, xdata); + return 0; } int io_stats_lk (call_frame_t *frame, xlator_t *this, - fd_t *fd, int32_t cmd, struct gf_flock *lock) + fd_t *fd, int32_t cmd, struct gf_flock *lock, dict_t *xdata) { START_FOP_LATENCY (frame); STACK_WIND (frame, io_stats_lk_cbk, FIRST_CHILD(this), FIRST_CHILD(this)->fops->lk, - fd, cmd, lock); + fd, cmd, lock, xdata); return 0; } @@ -2418,7 +2490,7 @@ io_stats_release (xlator_t *this, fd_t *fd) LOCK (&conf->lock); { - conf->cumulative.nr_opens--; + conf->cumulative.nr_opens--; } UNLOCK (&conf->lock); @@ -2426,8 +2498,7 @@ io_stats_release (xlator_t *this, fd_t *fd) if (iosfd) { io_stats_dump_fd (this, iosfd); - if (iosfd->filename) - GF_FREE (iosfd->filename); + GF_FREE (iosfd->filename); GF_FREE (iosfd); } @@ -2452,6 +2523,93 @@ io_stats_forget (xlator_t *this, inode_t *inode) return 0; } +static int +ios_init_top_stats (struct ios_conf *conf) +{ + int i = 0; + + GF_ASSERT (conf); + + for (i = 0; i <IOS_STATS_TYPE_MAX; i++) { + conf->list[i].iosstats = GF_CALLOC (1, + sizeof(*conf->list[i].iosstats), + gf_io_stats_mt_ios_stat); + + if (!conf->list[i].iosstats) + return -1; + + INIT_LIST_HEAD(&conf->list[i].iosstats->list); + LOCK_INIT (&conf->list[i].lock); + } + + for (i = 0; i < IOS_STATS_THRU_MAX; i ++) { + conf->thru_list[i].iosstats = GF_CALLOC (1, + sizeof (*conf->thru_list[i].iosstats), + gf_io_stats_mt_ios_stat); + + if (!conf->thru_list[i].iosstats) + return -1; + + INIT_LIST_HEAD(&conf->thru_list[i].iosstats->list); + LOCK_INIT (&conf->thru_list[i].lock); + } + + return 0; +} + +static void +ios_destroy_top_stats (struct ios_conf *conf) +{ + int i = 0; + struct ios_stat_head *list_head = NULL; + struct ios_stat_list *entry = NULL; + struct ios_stat_list *tmp = NULL; + struct ios_stat_list *list = NULL; + struct ios_stat *stat = NULL; + + GF_ASSERT (conf); + + LOCK (&conf->lock); + + conf->cumulative.nr_opens = 0; + conf->cumulative.max_nr_opens = 0; + conf->cumulative.max_openfd_time.tv_sec = 0; + conf->cumulative.max_openfd_time.tv_usec = 0; + + for (i = 0; i < IOS_STATS_TYPE_MAX; i++) { + list_head = &conf->list[i]; + if (!list_head) + continue; + list_for_each_entry_safe (entry, tmp, + &list_head->iosstats->list, list) { + list = entry; + stat = list->iosstat; + ios_stat_unref (stat); + list_del (&list->list); + GF_FREE (list); + list_head->members--; + } + } + + for (i = 0; i < IOS_STATS_THRU_MAX; i++) { + list_head = &conf->thru_list[i]; + if (!list_head) + continue; + list_for_each_entry_safe (entry, tmp, + &list_head->iosstats->list, list) { + list = entry; + stat = list->iosstat; + ios_stat_unref (stat); + list_del (&list->list); + GF_FREE (list); + list_head->members--; + } + } + + UNLOCK (&conf->lock); + + return; +} int reconfigure (xlator_t *this, dict_t *options) @@ -2519,7 +2677,6 @@ int init (xlator_t *this) { struct ios_conf *conf = NULL; - int i = 0; char *sys_log_str = NULL; int sys_log_level = -1; char *log_str = NULL; @@ -2556,35 +2713,9 @@ init (xlator_t *this) gettimeofday (&conf->cumulative.started_at, NULL); gettimeofday (&conf->incremental.started_at, NULL); - for (i = 0; i <IOS_STATS_TYPE_MAX; i++) { - conf->list[i].iosstats = GF_CALLOC (1, - sizeof(*conf->list[i].iosstats), - gf_io_stats_mt_ios_stat); - - if (!conf->list[i].iosstats) { - gf_log (this->name, GF_LOG_ERROR, - "Out of memory"); - return -1; - } - - INIT_LIST_HEAD(&conf->list[i].iosstats->list); - LOCK_INIT (&conf->list[i].lock); - } - - for (i = 0; i < IOS_STATS_THRU_MAX; i ++) { - conf->thru_list[i].iosstats = GF_CALLOC (1, - sizeof (*conf->thru_list[i].iosstats), - gf_io_stats_mt_ios_stat); - - if (!conf->thru_list[i].iosstats) { - gf_log (this->name, GF_LOG_ERROR, - "Out of memory"); - return -1; - } - - INIT_LIST_HEAD(&conf->thru_list[i].iosstats->list); - LOCK_INIT (&conf->thru_list[i].lock); - } + ret = ios_init_top_stats (conf); + if (ret) + return -1; GF_OPTION_INIT ("dump-fd-stats", conf->dump_fd_stats, bool, out); @@ -2616,12 +2747,6 @@ void fini (xlator_t *this) { struct ios_conf *conf = NULL; - struct ios_stat_head *list_head = NULL; - struct ios_stat_list *entry = NULL; - struct ios_stat_list *tmp = NULL; - struct ios_stat_list *list = NULL; - struct ios_stat *stat = NULL; - int i = 0; if (!this) return; @@ -2632,45 +2757,15 @@ fini (xlator_t *this) return; this->private = NULL; - for (i = 0; i < IOS_STATS_TYPE_MAX; i++) { - list_head = &conf->list[i]; - if (!list_head) - continue; - list_for_each_entry_safe (entry, tmp, - &list_head->iosstats->list, list) { - list = entry; - stat = list->iosstat; - ios_stat_unref (stat); - list_del (&list->list); - if (list) - GF_FREE (list); - } - } - - for (i = 0; i < IOS_STATS_THRU_MAX; i++) { - list_head = &conf->thru_list[i]; - if (!list_head) - continue; - list_for_each_entry_safe (entry, tmp, - &list_head->iosstats->list, list) { - list = entry; - stat = list->iosstat; - ios_stat_unref (stat); - list_del (&list->list); - if (list) - GF_FREE (list); - } - } + ios_destroy_top_stats (conf); - if (conf) - GF_FREE(conf); + GF_FREE(conf); gf_log (this->name, GF_LOG_INFO, "io-stats translator unloaded"); return; } - int notify (xlator_t *this, int32_t event, void *data, ...) { @@ -2690,6 +2785,28 @@ notify (xlator_t *this, int32_t event, void *data, ...) va_end (ap); switch (event) { case GF_EVENT_TRANSLATOR_INFO: + ret = dict_get_str_boolean (dict, "clear-stats", _gf_false); + if (ret) { + ret = dict_set_int32 (output, "top-op", top_op); + if (ret) { + gf_log (this->name, GF_LOG_ERROR, + "Failed to set top-op in dict"); + goto out; + } + ios_destroy_top_stats (this->private); + ret = ios_init_top_stats (this->private); + if (ret) + gf_log (this->name, GF_LOG_ERROR, + "Failed to reset top stats"); + ret = dict_set_int32 (output, "stats-cleared", + ret ? 0 : 1); + if (ret) + gf_log (this->name, GF_LOG_ERROR, + "Failed to set stats-cleared" + " in dict"); + goto out; + } + ret = dict_get_int32 (dict, "top-op", &top_op); if (!ret) { ret = dict_get_int32 (dict, "list-cnt", &list_cnt); @@ -2773,6 +2890,9 @@ struct xlator_fops fops = { .fxattrop = io_stats_fxattrop, .setattr = io_stats_setattr, .fsetattr = io_stats_fsetattr, + .fallocate = io_stats_fallocate, + .discard = io_stats_discard, + .zerofill = io_stats_zerofill, }; struct xlator_cbks cbks = { @@ -2816,7 +2936,7 @@ struct volume_options options[] = { .type = GF_OPTION_TYPE_STR, .default_value = "CRITICAL", .description = "Gluster's syslog log-level", - .value = { "WARNING", "ERROR", "CRITICAL"} + .value = { "WARNING", "ERROR", "INFO", "CRITICAL"} }, { .key = {"brick-log-level"}, .type = GF_OPTION_TYPE_STR, diff --git a/xlators/debug/trace/src/Makefile.am b/xlators/debug/trace/src/Makefile.am index 0f1679a04..7b2597b4d 100644 --- a/xlators/debug/trace/src/Makefile.am +++ b/xlators/debug/trace/src/Makefile.am @@ -2,13 +2,15 @@ xlator_LTLIBRARIES = trace.la xlatordir = $(libdir)/glusterfs/$(PACKAGE_VERSION)/xlator/debug -trace_la_LDFLAGS = -module -avoidversion +trace_la_LDFLAGS = -module -avoid-version 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) +noinst_HEADERS = trace.h trace-mem-types.h +AM_CPPFLAGS = $(GF_CPPFLAGS) -I$(top_srcdir)/libglusterfs/src + +AM_CFLAGS = -Wall $(GF_CFLAGS) CLEANFILES = diff --git a/xlators/debug/trace/src/trace-mem-types.h b/xlators/debug/trace/src/trace-mem-types.h new file mode 100644 index 000000000..9fa7d97c2 --- /dev/null +++ b/xlators/debug/trace/src/trace-mem-types.h @@ -0,0 +1,21 @@ +/* + Copyright (c) 2006-2012 Red Hat, Inc. <http://www.redhat.com> + This file is part of GlusterFS. + + This file is licensed to you under your choice of the GNU Lesser + General Public License, version 3 or any later version (LGPLv3 or + later), or the GNU General Public License, version 2 (GPLv2), in all + cases as published by the Free Software Foundation. +*/ + + +#ifndef __TRACE_MEM_TYPES_H__ +#define __TRACE_MEM_TYPES_H__ + +#include "mem-types.h" + +enum gf_trace_mem_types_ { + gf_trace_mt_trace_conf_t = gf_common_mt_end + 1, + gf_trace_mt_end +}; +#endif diff --git a/xlators/debug/trace/src/trace.c b/xlators/debug/trace/src/trace.c index 09c58bdfd..c9d839356 100644 --- a/xlators/debug/trace/src/trace.c +++ b/xlators/debug/trace/src/trace.c @@ -1,26 +1,15 @@ /* - Copyright (c) 2006-2011 Gluster, Inc. <http://www.gluster.com> + Copyright (c) 2006-2012 Red Hat, Inc. <http://www.redhat.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/>. + This file is licensed to you under your choice of the GNU Lesser + General Public License, version 3 or any later version (LGPLv3 or + later), or the GNU General Public License, version 2 (GPLv2), in all + cases as published by the Free Software Foundation. */ -#ifndef _CONFIG_H -#define _CONFIG_H -#include "config.h" -#endif +#include "trace.h" +#include "trace-mem-types.h" /** * xlators/debug/trace : @@ -29,1203 +18,1388 @@ * Very helpful translator for debugging. */ -#include <time.h> -#include <errno.h> -#include "glusterfs.h" -#include "xlator.h" -#include "common-utils.h" - - -struct { - char *name; - int enabled; -} trace_fop_names[GF_FOP_MAXVALUE]; - -int trace_log_level = GF_LOG_INFO; - -static char * -trace_stat_to_str (struct iatt *buf) +int +dump_history_trace (circular_buffer_t *cb, void *data) { - char *statstr = NULL; - char atime_buf[256] = {0,}; - char mtime_buf[256] = {0,}; - char ctime_buf[256] = {0,}; - int asprint_ret_value = 0; - uint64_t ia_time = 0; - - if (!buf) { - statstr = NULL; - goto out; - } - - ia_time = buf->ia_atime; - strftime (atime_buf, 256, "[%b %d %H:%M:%S]", - localtime ((time_t *)&ia_time)); - - ia_time = buf->ia_mtime; - strftime (mtime_buf, 256, "[%b %d %H:%M:%S]", - localtime ((time_t *)&ia_time)); + char *string = NULL; + struct tm *tm = NULL; + char timestr[256] = {0,}; - ia_time = buf->ia_ctime; - strftime (ctime_buf, 256, "[%b %d %H:%M:%S]", - localtime ((time_t *)&ia_time)); + string = (char *)cb->data; + tm = localtime (&cb->tv.tv_sec); - asprint_ret_value = gf_asprintf (&statstr, - "gfid=%s ino=%"PRIu64", mode=%o, " - "nlink=%"GF_PRI_NLINK", uid=%u, " - "gid=%u, size=%"PRIu64", " - "blocks=%"PRIu64", atime=%s, " - "mtime=%s, ctime=%s", - uuid_utoa (buf->ia_gfid), buf->ia_ino, - st_mode_from_ia (buf->ia_prot, - buf->ia_type), - buf->ia_nlink, buf->ia_uid, - buf->ia_gid, buf->ia_size, - buf->ia_blocks, atime_buf, - mtime_buf, ctime_buf); + /* Since we are continuing with adding entries to the buffer even when + gettimeofday () fails, it's safe to check tm and then dump the time + at which the entry was added to the buffer */ + if (tm) { + strftime (timestr, 256, "%Y-%m-%d %H:%M:%S", tm); + snprintf (timestr + strlen (timestr), 256 - strlen (timestr), + ".%"GF_PRI_SUSECONDS, cb->tv.tv_usec); + gf_proc_dump_write ("TIME", "%s", timestr); + } - if (asprint_ret_value < 0) - statstr = NULL; + gf_proc_dump_write ("FOP", "%s\n", string); -out: - return statstr; + return 0; } - int 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 iatt *buf, - struct iatt *preparent, struct iatt *postparent) + struct iatt *preparent, struct iatt *postparent, + dict_t *xdata) { - char *statstr = NULL; - char *preparentstr = NULL; - char *postparentstr = NULL; + char statstr[4096] = {0, }; + char preparentstr[4096] = {0, }; + char postparentstr[4096] = {0, }; + trace_conf_t *conf = NULL; + + conf = this->private; + if (!conf->log_file && !conf->log_history) + goto out; if (trace_fop_names[GF_FOP_CREATE].enabled) { + char string[4096] = {0,}; if (op_ret >= 0) { - statstr = trace_stat_to_str (buf); - preparentstr = trace_stat_to_str (preparent); - postparentstr = trace_stat_to_str (postparent); - - gf_log (this->name, GF_LOG_INFO, - "%"PRId64": gfid=%s (op_ret=%d, fd=%p" - "*stbuf {%s}, *preparent {%s}, *postparent = " - "{%s})", frame->root->unique, - uuid_utoa (inode->gfid), op_ret, fd, - statstr, preparentstr, postparentstr); - - if (statstr) - GF_FREE (statstr); - if (preparentstr) - GF_FREE (preparentstr); - if (postparentstr) - GF_FREE (postparentstr); + trace_stat_to_str (buf, statstr); + trace_stat_to_str (preparent, preparentstr); + trace_stat_to_str (postparent, postparentstr); + + snprintf (string, sizeof (string), + "%"PRId64": gfid=%s (op_ret=%d, fd=%p" + "*stbuf {%s}, *preparent {%s}, " + "*postparent = {%s})", + frame->root->unique, + uuid_utoa (inode->gfid), op_ret, fd, + statstr, preparentstr, postparentstr); /* for 'release' log */ fd_ctx_set (fd, this, 0); } else { - gf_log (this->name, GF_LOG_INFO, - "%"PRId64": (op_ret=%d, op_errno=%d)", - frame->root->unique, op_ret, op_errno); + snprintf (string, sizeof (string), + "%"PRId64": (op_ret=%d, op_errno=%d)", + frame->root->unique, op_ret, + op_errno); } + LOG_ELEMENT (conf, string); } - - frame->local = NULL; - STACK_UNWIND_STRICT (create, frame, op_ret, op_errno, fd, inode, buf, - preparent, postparent); +out: + TRACE_STACK_UNWIND (create, frame, op_ret, op_errno, fd, inode, buf, + preparent, postparent, xdata); return 0; } - int trace_open_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, fd_t *fd) + int32_t op_ret, int32_t op_errno, fd_t *fd, dict_t *xdata) { + trace_conf_t *conf = NULL; + + conf = this->private; + if (!conf->log_file && !conf->log_history) + goto out; if (trace_fop_names[GF_FOP_OPEN].enabled) { - gf_log (this->name, GF_LOG_INFO, - "%"PRId64": gfid=%s op_ret=%d, op_errno=%d, *fd=%p", - frame->root->unique, uuid_utoa (frame->local), op_ret, op_errno, fd); + char string[4096] = {0,}; + snprintf (string, sizeof (string), + "%"PRId64": gfid=%s op_ret=%d, op_errno=%d, " + "*fd=%p", frame->root->unique, + uuid_utoa (frame->local), op_ret, op_errno, + fd); + + LOG_ELEMENT (conf, string); } +out: /* for 'release' log */ if (op_ret >= 0) fd_ctx_set (fd, this, 0); - frame->local = NULL; - STACK_UNWIND_STRICT (open, frame, op_ret, op_errno, fd); + TRACE_STACK_UNWIND (open, frame, op_ret, op_errno, fd, xdata); return 0; } - int trace_stat_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, struct iatt *buf) + int32_t op_ret, int32_t op_errno, struct iatt *buf, + dict_t *xdata) { - char *statstr = NULL; + char statstr[4096] = {0, }; + trace_conf_t *conf = NULL; + + conf = this->private; + + if (!conf->log_file && !conf->log_history) + goto out; if (trace_fop_names[GF_FOP_STAT].enabled) { - if (op_ret >= 0) { - statstr = trace_stat_to_str (buf); - gf_log (this->name, GF_LOG_INFO, - "%"PRId64": gfid=%s op_ret=%d buf=%s", - frame->root->unique, uuid_utoa (frame->local), - op_ret, statstr); - - if (statstr) - GF_FREE (statstr); + char string[4096] = {0,}; + if (op_ret == 0) { + trace_stat_to_str (buf, statstr); + snprintf (string, sizeof (string), + "%"PRId64": gfid=%s op_ret=%d buf=%s", + frame->root->unique, + uuid_utoa (frame->local), op_ret, + statstr); } else { - gf_log (this->name, GF_LOG_INFO, - "%"PRId64": gfid=%s op_ret=%d, op_errno=%d)", - frame->root->unique, uuid_utoa (frame->local), op_ret, op_errno); + snprintf (string, sizeof (string), + "%"PRId64": gfid=%s op_ret=%d, " + "op_errno=%d)", + frame->root->unique, + uuid_utoa (frame->local), op_ret, + op_errno); } + LOG_ELEMENT (conf, string); } - - frame->local = NULL; - STACK_UNWIND_STRICT (stat, frame, op_ret, op_errno, buf); +out: + TRACE_STACK_UNWIND (stat, frame, op_ret, op_errno, buf, xdata); return 0; } - int 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 iatt *buf, struct iobref *iobref) + int32_t count, struct iatt *buf, struct iobref *iobref, + dict_t *xdata) { - char *statstr = NULL; + char statstr[4096] = {0, }; + trace_conf_t *conf = NULL; + + conf = this->private; + if (!conf->log_file && !conf->log_history) + goto out; if (trace_fop_names[GF_FOP_READ].enabled) { + char string[4096] = {0,}; if (op_ret >= 0) { - statstr = trace_stat_to_str (buf); - gf_log (this->name, GF_LOG_INFO, - "%"PRId64": gfid=%s op_ret=%d buf=%s", - frame->root->unique, uuid_utoa (frame->local), - op_ret, statstr); - - if (statstr) - GF_FREE (statstr); + trace_stat_to_str (buf, statstr); + snprintf (string, sizeof (string), + "%"PRId64": gfid=%s op_ret=%d buf=%s", + frame->root->unique, + uuid_utoa (frame->local), op_ret, + statstr); } else { - gf_log (this->name, GF_LOG_INFO, - "%"PRId64": gfid=%s op_ret=%d, op_errno=%d)", - frame->root->unique, uuid_utoa (frame->local), - op_ret, op_errno); + snprintf (string, sizeof (string), + "%"PRId64": gfid=%s op_ret=%d, " + "op_errno=%d)", + frame->root->unique, + uuid_utoa (frame->local), op_ret, + op_errno); } + LOG_ELEMENT (conf, string); } - - frame->local = NULL; - STACK_UNWIND_STRICT (readv, frame, op_ret, op_errno, vector, count, - buf, iobref); +out: + TRACE_STACK_UNWIND (readv, frame, op_ret, op_errno, vector, count, + buf, iobref, xdata); return 0; } - int trace_writev_cbk (call_frame_t *frame, void *cookie, xlator_t *this, int32_t op_ret, int32_t op_errno, - struct iatt *prebuf, struct iatt *postbuf) + struct iatt *prebuf, struct iatt *postbuf, dict_t *xdata) { - char *preopstr = NULL; - char *postopstr = NULL; + char preopstr[4096] = {0, }; + char postopstr[4096] = {0, }; + trace_conf_t *conf = NULL; + + conf = this->private; + if (!conf->log_file && !conf->log_history) + goto out; if (trace_fop_names[GF_FOP_WRITE].enabled) { + char string[4096] = {0,}; if (op_ret >= 0) { - preopstr = trace_stat_to_str (prebuf); - postopstr = trace_stat_to_str (postbuf); - - gf_log (this->name, GF_LOG_INFO, - "%"PRId64": (op_ret=%d, *prebuf = {%s}, " - "*postbuf = {%s})", - frame->root->unique, op_ret, - preopstr, postopstr); - - if (preopstr) - GF_FREE (preopstr); - - if (postopstr) - GF_FREE (postopstr); + trace_stat_to_str (prebuf, preopstr); + trace_stat_to_str (postbuf, postopstr); + + snprintf (string, sizeof (string), + "%"PRId64": (op_ret=%d, " + "*prebuf = {%s}, *postbuf = {%s})", + frame->root->unique, op_ret, + preopstr, postopstr); } else { - gf_log (this->name, GF_LOG_INFO, - "%"PRId64": gfid=%s op_ret=%d, op_errno=%d", - frame->root->unique, uuid_utoa (frame->local), - op_ret, op_errno); + snprintf (string, sizeof (string), + "%"PRId64": gfid=%s op_ret=%d, " + "op_errno=%d", frame->root->unique, + uuid_utoa (frame->local), op_ret, + op_errno); } + LOG_ELEMENT (conf, string); } - - frame->local = NULL; - STACK_UNWIND_STRICT (writev, frame, op_ret, op_errno, prebuf, postbuf); +out: + TRACE_STACK_UNWIND (writev, frame, op_ret, op_errno, prebuf, postbuf, + xdata); return 0; } - - int trace_readdir_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, gf_dirent_t *buf) + int32_t op_ret, int32_t op_errno, gf_dirent_t *buf, + dict_t *xdata) { + trace_conf_t *conf = NULL; + + conf = this->private; + + if (!conf->log_file && !conf->log_history) + goto out; if (trace_fop_names[GF_FOP_READDIR].enabled) { - gf_log (this->name, GF_LOG_INFO, - "%"PRId64" : gfid=%s op_ret=%d, op_errno=%d", - frame->root->unique, uuid_utoa (frame->local), op_ret, op_errno); - } + char string[4096] = {0,}; + snprintf (string, sizeof (string), + "%"PRId64" : gfid=%s op_ret=%d, op_errno=%d", + frame->root->unique, uuid_utoa (frame->local), + op_ret, op_errno); - frame->local = NULL; - STACK_UNWIND_STRICT (readdir, frame, op_ret, op_errno, buf); + LOG_ELEMENT (conf, string); + } +out: + TRACE_STACK_UNWIND (readdir, frame, op_ret, op_errno, buf, xdata); return 0; } - int trace_readdirp_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, gf_dirent_t *buf) + int32_t op_ret, int32_t op_errno, gf_dirent_t *buf, + dict_t *xdata) { + trace_conf_t *conf = NULL; + + conf = this->private; + + if (!conf->log_file && !conf->log_history) + goto out; if (trace_fop_names[GF_FOP_READDIRP].enabled) { - gf_log (this->name, GF_LOG_INFO, - "%"PRId64" : gfid=%s op_ret=%d, op_errno=%d", - frame->root->unique, uuid_utoa (frame->local), op_ret, op_errno); - } + char string[4096] = {0,}; + snprintf (string, sizeof (string), + "%"PRId64" : gfid=%s op_ret=%d, op_errno=%d", + frame->root->unique, uuid_utoa (frame->local), + op_ret, op_errno); - frame->local = NULL; - STACK_UNWIND_STRICT (readdirp, frame, op_ret, op_errno, buf); + LOG_ELEMENT (conf, string); + } +out: + TRACE_STACK_UNWIND (readdirp, frame, op_ret, op_errno, buf, xdata); return 0; } - int trace_fsync_cbk (call_frame_t *frame, void *cookie, xlator_t *this, int32_t op_ret, int32_t op_errno, - struct iatt *prebuf, struct iatt *postbuf) + struct iatt *prebuf, struct iatt *postbuf, dict_t *xdata) { - char *preopstr = NULL; - char *postopstr = NULL; - - if (trace_fop_names[GF_FOP_FSYNC].enabled) { - if (op_ret >= 0) { - preopstr = trace_stat_to_str (prebuf); - postopstr = trace_stat_to_str (postbuf); + char preopstr[4096] = {0, }; + char postopstr[4096] = {0, }; + trace_conf_t *conf = NULL; - gf_log (this->name, GF_LOG_INFO, - "%"PRId64": (op_ret=%d, *prebuf = {%s}, " - "*postbuf = {%s}", - frame->root->unique, op_ret, - preopstr, postopstr); + conf = this->private; - if (preopstr) - GF_FREE (preopstr); - - if (postopstr) - GF_FREE (postopstr); + if (!conf->log_file && !conf->log_history) + goto out; + if (trace_fop_names[GF_FOP_FSYNC].enabled) { + char string[4096] = {0,}; + if (op_ret == 0) { + trace_stat_to_str (prebuf, preopstr); + trace_stat_to_str (postbuf, postopstr); + + snprintf (string, sizeof (string), + "%"PRId64": (op_ret=%d, " + "*prebuf = {%s}, *postbuf = {%s}", + frame->root->unique, op_ret, + preopstr, postopstr); } else { - gf_log (this->name, GF_LOG_INFO, - "%"PRId64": gfid=%s op_ret=%d, op_errno=%d", - frame->root->unique, uuid_utoa (frame->local), - op_ret, op_errno); + snprintf (string, sizeof (string), + "%"PRId64": gfid=%s op_ret=%d, " + "op_errno=%d", frame->root->unique, + uuid_utoa (frame->local), op_ret, + op_errno); + } + LOG_ELEMENT (conf, string); } - - frame->local = NULL; - STACK_UNWIND_STRICT (fsync, frame, op_ret, op_errno, prebuf, postbuf); +out: + TRACE_STACK_UNWIND (fsync, frame, op_ret, op_errno, prebuf, postbuf, + xdata); return 0; } - int trace_setattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this, int32_t op_ret, int32_t op_errno, - struct iatt *statpre, struct iatt *statpost) + struct iatt *statpre, struct iatt *statpost, dict_t *xdata) { - char *preopstr = NULL; - char *postopstr = NULL; - - if (trace_fop_names[GF_FOP_SETATTR].enabled) { - if (op_ret >= 0) { - preopstr = trace_stat_to_str (statpre); - postopstr = trace_stat_to_str (statpost); + char preopstr[4096] = {0, }; + char postopstr[4096] = {0, }; + trace_conf_t *conf = NULL; - gf_log (this->name, GF_LOG_INFO, - "%"PRId64": (op_ret=%d, *prebuf = {%s}, " - "*postbuf = {%s})", - frame->root->unique, op_ret, - preopstr, postopstr); + conf = this->private; - if (preopstr) - GF_FREE (preopstr); - - if (postopstr) - GF_FREE (postopstr); + if (!conf->log_file && !conf->log_history) + goto out; + if (trace_fop_names[GF_FOP_SETATTR].enabled) { + char string[4096] = {0,}; + if (op_ret == 0) { + trace_stat_to_str (statpre, preopstr); + trace_stat_to_str (statpost, postopstr); + + snprintf (string, sizeof (string), + "%"PRId64": (op_ret=%d, " + "*prebuf = {%s}, *postbuf = {%s})", + frame->root->unique, op_ret, + preopstr, postopstr); } else { - gf_log (this->name, GF_LOG_INFO, - "%"PRId64": gfid=%s op_ret=%d, op_errno=%d)", - frame->root->unique, uuid_utoa (frame->local), op_ret, op_errno); + snprintf (string, sizeof (string), + "%"PRId64": gfid=%s op_ret=%d, " + "op_errno=%d)", frame->root->unique, + uuid_utoa (frame->local), op_ret, + op_errno); } + LOG_ELEMENT (conf, string); } - - frame->local = NULL; - STACK_UNWIND_STRICT (setattr, frame, op_ret, op_errno, statpre, statpost); +out: + TRACE_STACK_UNWIND (setattr, frame, op_ret, op_errno, statpre, + statpost, xdata); return 0; } - int trace_fsetattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this, int32_t op_ret, int32_t op_errno, - struct iatt *statpre, struct iatt *statpost) + struct iatt *statpre, struct iatt *statpost, dict_t *xdata) { - char *preopstr = NULL; - char *postopstr = NULL; - - if (trace_fop_names[GF_FOP_FSETATTR].enabled) { - if (op_ret >= 0) { - preopstr = trace_stat_to_str (statpre); - postopstr = trace_stat_to_str (statpost); + char preopstr[4096] = {0, }; + char postopstr[4096] = {0, }; + trace_conf_t *conf = NULL; - gf_log (this->name, GF_LOG_INFO, - "%"PRId64": (op_ret=%d, *prebuf = {%s}, " - "*postbuf = {%s})", - frame->root->unique, op_ret, - preopstr, postopstr); + conf = this->private; - if (preopstr) - GF_FREE (preopstr); - - if (postopstr) - GF_FREE (postopstr); + if (!conf->log_file && !conf->log_history) + goto out; + if (trace_fop_names[GF_FOP_FSETATTR].enabled) { + char string[4096] = {0,}; + if (op_ret == 0) { + trace_stat_to_str (statpre, preopstr); + trace_stat_to_str (statpost, postopstr); + + snprintf (string, sizeof (string), + "%"PRId64": (op_ret=%d, " + "*prebuf = {%s}, *postbuf = {%s})", + frame->root->unique, op_ret, + preopstr, postopstr); } else { - gf_log (this->name, GF_LOG_INFO, - "%"PRId64": gfid=%s op_ret=%d, op_errno=%d)", - frame->root->unique, uuid_utoa (frame->local), op_ret, op_errno); + snprintf (string, sizeof (string), + "%"PRId64": gfid=%s op_ret=%d, op_errno=%d)", + frame->root->unique, uuid_utoa (frame->local), + op_ret, op_errno); } + LOG_ELEMENT (conf, string); } - - frame->local = NULL; - STACK_UNWIND_STRICT (fsetattr, frame, op_ret, op_errno, - statpre, statpost); +out: + TRACE_STACK_UNWIND (fsetattr, frame, op_ret, op_errno, + statpre, statpost, xdata); return 0; } - int trace_unlink_cbk (call_frame_t *frame, void *cookie, xlator_t *this, int32_t op_ret, int32_t op_errno, - struct iatt *preparent, struct iatt *postparent) + struct iatt *preparent, struct iatt *postparent, + dict_t *xdata) { - char *preparentstr = NULL; - char *postparentstr = NULL; - - if (trace_fop_names[GF_FOP_UNLINK].enabled) { - if (op_ret >= 0) { - preparentstr = trace_stat_to_str (preparent); - postparentstr = trace_stat_to_str (postparent); - - gf_log (this->name, GF_LOG_INFO, - "%"PRId64": gfid=%s op_ret=%d, *preparent = {%s}, " - "*postparent = {%s})", - frame->root->unique, uuid_utoa (frame->local), op_ret, preparentstr, - postparentstr); + char preparentstr[4096] = {0, }; + char postparentstr[4096] = {0, }; + trace_conf_t *conf = NULL; - if (preparentstr) - GF_FREE (preparentstr); + conf = this->private; - if (postparentstr) - GF_FREE (postparentstr); + if (!conf->log_file && !conf->log_history) + goto out; + if (trace_fop_names[GF_FOP_UNLINK].enabled) { + char string[4096] = {0,}; + if (op_ret == 0) { + trace_stat_to_str (preparent, preparentstr); + trace_stat_to_str (postparent, postparentstr); + + snprintf (string, sizeof (string), + "%"PRId64": gfid=%s op_ret=%d, " + " *preparent = {%s}, " + "*postparent = {%s})", + frame->root->unique, + uuid_utoa (frame->local), + op_ret, preparentstr, + postparentstr); } else { - gf_log (this->name, GF_LOG_INFO, - "%"PRId64": gfid=%s op_ret=%d, op_errno=%d)", - frame->root->unique, uuid_utoa (frame->local), op_ret, op_errno); + snprintf (string, sizeof (string), + "%"PRId64": gfid=%s op_ret=%d, " + "op_errno=%d)", + frame->root->unique, + uuid_utoa (frame->local), op_ret, + op_errno); } + LOG_ELEMENT (conf, string); } - - frame->local = NULL; - STACK_UNWIND_STRICT (unlink, frame, op_ret, op_errno, - preparent, postparent); +out: + TRACE_STACK_UNWIND (unlink, frame, op_ret, op_errno, + preparent, postparent, xdata); return 0; } - int trace_rename_cbk (call_frame_t *frame, void *cookie, xlator_t *this, int32_t op_ret, int32_t op_errno, struct iatt *buf, struct iatt *preoldparent, struct iatt *postoldparent, - struct iatt *prenewparent, struct iatt *postnewparent) + struct iatt *prenewparent, struct iatt *postnewparent, + dict_t *xdata) { - char *statstr = NULL; - char *preoldparentstr = NULL; - char *postoldparentstr = NULL; - char *prenewparentstr = NULL; - char *postnewparentstr = NULL; - - if (trace_fop_names[GF_FOP_RENAME].enabled) { - if (op_ret >= 0) { - statstr = trace_stat_to_str (buf); - preoldparentstr = trace_stat_to_str (preoldparent); - postoldparentstr = trace_stat_to_str (postoldparent); - - prenewparentstr = trace_stat_to_str (prenewparent); - postnewparentstr = trace_stat_to_str (postnewparent); - - gf_log (this->name, GF_LOG_INFO, - "%"PRId64": (op_ret=%d, *stbuf = {%s}, " - "*preoldparent = {%s}, *postoldparent = {%s}" - " *prenewparent = {%s}, *postnewparent = {%s})", - frame->root->unique, op_ret, statstr, - preoldparentstr, postoldparentstr, - prenewparentstr, postnewparentstr); + char statstr[4096] = {0, }; + char preoldparentstr[4096] = {0, }; + char postoldparentstr[4096] = {0, }; + char prenewparentstr[4096] = {0, }; + char postnewparentstr[4096] = {0, }; + trace_conf_t *conf = NULL; - if (preoldparentstr) - GF_FREE (preoldparentstr); + conf = this->private; - if (postoldparentstr) - GF_FREE (postoldparentstr); - - if (prenewparentstr) - GF_FREE (prenewparentstr); - - if (postnewparentstr) - GF_FREE (postnewparentstr); + if (!conf->log_file && !conf->log_history) + goto out; + if (trace_fop_names[GF_FOP_RENAME].enabled) { + char string[4096] = {0,}; + if (op_ret == 0) { + trace_stat_to_str (buf, statstr); + trace_stat_to_str (preoldparent, preoldparentstr); + trace_stat_to_str (postoldparent, postoldparentstr); + trace_stat_to_str (prenewparent, prenewparentstr); + trace_stat_to_str (postnewparent, postnewparentstr); + + snprintf (string, sizeof (string), + "%"PRId64": (op_ret=%d, " + "*stbuf = {%s}, *preoldparent = {%s}," + " *postoldparent = {%s}" + " *prenewparent = {%s}, " + "*postnewparent = {%s})", + frame->root->unique, op_ret, statstr, + preoldparentstr, postoldparentstr, + prenewparentstr, postnewparentstr); } else { - gf_log (this->name, GF_LOG_INFO, - "%"PRId64": gfid=%s op_ret=%d, op_errno=%d", - frame->root->unique, uuid_utoa (frame->local), - op_ret, op_errno); + snprintf (string, sizeof (string), + "%"PRId64": gfid=%s op_ret=%d, " + "op_errno=%d", frame->root->unique, + uuid_utoa (frame->local), + op_ret, op_errno); + } + LOG_ELEMENT (conf, string); } - - frame->local = NULL; - STACK_UNWIND_STRICT (rename, frame, op_ret, op_errno, buf, - preoldparent, postoldparent, - prenewparent, postnewparent); +out: + TRACE_STACK_UNWIND (rename, frame, op_ret, op_errno, buf, + preoldparent, postoldparent, + prenewparent, postnewparent, xdata); return 0; } - int trace_readlink_cbk (call_frame_t *frame, void *cookie, xlator_t *this, int32_t op_ret, int32_t op_errno, - const char *buf, struct iatt *stbuf) + const char *buf, struct iatt *stbuf, dict_t *xdata) { - char *statstr = NULL; + char statstr[4096] = {0, }; + trace_conf_t *conf = NULL; - if (trace_fop_names[GF_FOP_READLINK].enabled) { + conf = this->private; + if (!conf->log_file && !conf->log_history) + goto out; + if (trace_fop_names[GF_FOP_READLINK].enabled) { + char string[4096] = {0,}; if (op_ret == 0) { - statstr = trace_stat_to_str (stbuf); - gf_log (this->name, GF_LOG_INFO, - "%"PRId64": (op_ret=%d, op_errno=%d, buf=%s, " - "stbuf = { %s })", - frame->root->unique, op_ret, op_errno, buf, - statstr); - } else - gf_log (this->name, GF_LOG_INFO, - "%"PRId64": gfid=%s op_ret=%d, op_errno=%d", - frame->root->unique, uuid_utoa (frame->local), - op_ret, op_errno); + trace_stat_to_str (stbuf, statstr); + snprintf (string, sizeof (string), + "%"PRId64": (op_ret=%d, op_errno=%d," + "buf=%s, stbuf = { %s })", + frame->root->unique, op_ret, op_errno, + buf, statstr); + } else { + snprintf (string, sizeof (string), + "%"PRId64": gfid=%s op_ret=%d, " + "op_errno=%d", + frame->root->unique, + uuid_utoa (frame->local), op_ret, + op_errno); + } - if (statstr) - GF_FREE (statstr); + LOG_ELEMENT (conf, string); } - - frame->local = NULL; - STACK_UNWIND_STRICT (readlink, frame, op_ret, op_errno, buf, stbuf); +out: + TRACE_STACK_UNWIND (readlink, frame, op_ret, op_errno, buf, stbuf, + xdata); return 0; } - int trace_lookup_cbk (call_frame_t *frame, void *cookie, xlator_t *this, int32_t op_ret, int32_t op_errno, inode_t *inode, struct iatt *buf, - dict_t *xattr, struct iatt *postparent) + dict_t *xdata, struct iatt *postparent) { - char *statstr = NULL; - char *postparentstr = NULL; + char statstr[4096] = {0, }; + char postparentstr[4096] = {0, }; + trace_conf_t *conf = NULL; - if (trace_fop_names[GF_FOP_LOOKUP].enabled) { - if (op_ret >= 0) { - statstr = trace_stat_to_str (buf); - postparentstr = trace_stat_to_str (postparent); + conf = this->private; - gf_log (this->name, GF_LOG_INFO, - "%"PRId64": gfid=%s (op_ret=%d " - "*buf {%s}, *postparent {%s}", - frame->root->unique, uuid_utoa (inode->gfid), - op_ret, statstr, postparentstr); - - if (statstr) - GF_FREE (statstr); - if (postparentstr) - GF_FREE (postparentstr); + if (!conf->log_file && !conf->log_history) + goto out; + if (trace_fop_names[GF_FOP_LOOKUP].enabled) { + char string[4096] = {0,}; + if (op_ret == 0) { + trace_stat_to_str (buf, statstr); + trace_stat_to_str (postparent, postparentstr); + /* print buf->ia_gfid instead of inode->gfid, + * since if the inode is not yet linked to the + * inode table (fresh lookup) then null gfid + * will be printed. + */ + snprintf (string, sizeof (string), + "%"PRId64": gfid=%s (op_ret=%d " + "*buf {%s}, *postparent {%s}", + frame->root->unique, + uuid_utoa (buf->ia_gfid), + op_ret, statstr, postparentstr); /* For 'forget' */ inode_ctx_put (inode, this, 0); } else { - gf_log (this->name, GF_LOG_INFO, - "%"PRId64": gfid=%s op_ret=%d, op_errno=%d)", - frame->root->unique, uuid_utoa (frame->local), - op_ret, op_errno); + snprintf (string, sizeof (string), + "%"PRId64": gfid=%s op_ret=%d, " + "op_errno=%d)", + frame->root->unique, + uuid_utoa (frame->local), op_ret, + op_errno); } + LOG_ELEMENT (conf, string); } - - frame->local = NULL; - STACK_UNWIND_STRICT (lookup, frame, op_ret, op_errno, inode, buf, - xattr, postparent); +out: + TRACE_STACK_UNWIND (lookup, frame, op_ret, op_errno, inode, buf, + xdata, postparent); return 0; } - int trace_symlink_cbk (call_frame_t *frame, void *cookie, xlator_t *this, int32_t op_ret, int32_t op_errno, inode_t *inode, struct iatt *buf, - struct iatt *preparent, struct iatt *postparent) + struct iatt *preparent, struct iatt *postparent, + dict_t *xdata) { - char *statstr = NULL; - char *preparentstr = NULL; - char *postparentstr = NULL; - - if (trace_fop_names[GF_FOP_SYMLINK].enabled) { - if (op_ret >= 0) { - statstr = trace_stat_to_str (buf); - preparentstr = trace_stat_to_str (preparent); - postparentstr = trace_stat_to_str (postparent); - - gf_log (this->name, GF_LOG_INFO, - "%"PRId64": gfid=%s (op_ret=%d " - "*stbuf = {%s}, *preparent = {%s}, " - "*postparent = {%s})", - frame->root->unique, uuid_utoa (inode->gfid), - op_ret, statstr, preparentstr, postparentstr); - - if (statstr) - GF_FREE (statstr); - - if (preparentstr) - GF_FREE (preparentstr); + char statstr[4096] = {0, }; + char preparentstr[4096] = {0, }; + char postparentstr[4096] = {0, }; + trace_conf_t *conf = NULL; - if (postparentstr) - GF_FREE (postparentstr); + conf = this->private; + if (!conf->log_file && !conf->log_history) + goto out; + if (trace_fop_names[GF_FOP_SYMLINK].enabled) { + char string[4096] = {0,}; + if (op_ret == 0) { + trace_stat_to_str (buf, statstr); + trace_stat_to_str (preparent, preparentstr); + trace_stat_to_str (postparent, postparentstr); + + snprintf (string, sizeof (string), + "%"PRId64": gfid=%s (op_ret=%d " + "*stbuf = {%s}, *preparent = {%s}, " + "*postparent = {%s})", + frame->root->unique, + uuid_utoa (inode->gfid), + op_ret, statstr, preparentstr, + postparentstr); } else { - gf_log (this->name, GF_LOG_INFO, - "%"PRId64": op_ret=%d, op_errno=%d", - frame->root->unique, op_ret, op_errno); + snprintf (string, sizeof (string), + "%"PRId64": op_ret=%d, op_errno=%d", + frame->root->unique, op_ret, + op_errno); } + LOG_ELEMENT (conf, string); } - - frame->local = NULL; - STACK_UNWIND_STRICT (symlink, frame, op_ret, op_errno, inode, buf, - preparent, postparent); +out: + TRACE_STACK_UNWIND (symlink, frame, op_ret, op_errno, inode, buf, + preparent, postparent, xdata); return 0; } - int trace_mknod_cbk (call_frame_t *frame, void *cookie, xlator_t *this, int32_t op_ret, int32_t op_errno, inode_t *inode, struct iatt *buf, - struct iatt *preparent, struct iatt *postparent) + struct iatt *preparent, struct iatt *postparent, dict_t *xdata) { - char *statstr = NULL; - char *preparentstr = NULL; - char *postparentstr = NULL; - - if (trace_fop_names[GF_FOP_MKNOD].enabled) { - if (op_ret >= 0) { - statstr = trace_stat_to_str (buf); - preparentstr = trace_stat_to_str (preparent); - postparentstr = trace_stat_to_str (postparent); - - gf_log (this->name, GF_LOG_INFO, - "%"PRId64": gfid=%s (op_ret=%d " - "*stbuf = {%s}, *preparent = {%s}, " - "*postparent = {%s})", - frame->root->unique, uuid_utoa (inode->gfid), - op_ret, statstr, preparentstr, postparentstr); - - if (statstr) - GF_FREE (statstr); + char statstr[4096] = {0, }; + char preparentstr[4096] = {0, }; + char postparentstr[4096] = {0, }; + trace_conf_t *conf = NULL; - if (preparentstr) - GF_FREE (preparentstr); + conf = this->private; - if (postparentstr) - GF_FREE (postparentstr); + if (!conf->log_file && !conf->log_history) + goto out; + char string[4096] = {0,}; + if (trace_fop_names[GF_FOP_MKNOD].enabled) { + if (op_ret == 0) { + trace_stat_to_str (buf, statstr); + trace_stat_to_str (preparent, preparentstr); + trace_stat_to_str (postparent, postparentstr); + + snprintf (string, sizeof (string), + "%"PRId64": gfid=%s (op_ret=%d " + "*stbuf = {%s}, *preparent = {%s}, " + "*postparent = {%s})", + frame->root->unique, + uuid_utoa (inode->gfid), + op_ret, statstr, preparentstr, + postparentstr); } else { - gf_log (this->name, GF_LOG_INFO, - "%"PRId64": (op_ret=%d, op_errno=%d)", - frame->root->unique, op_ret, op_errno); + snprintf (string, sizeof (string), + "%"PRId64": (op_ret=%d, op_errno=%d)", + frame->root->unique, op_ret, + op_errno); } + LOG_ELEMENT (conf, string); } - - frame->local = NULL; - STACK_UNWIND_STRICT (mknod, frame, op_ret, op_errno, inode, buf, - preparent, postparent); +out: + TRACE_STACK_UNWIND (mknod, frame, op_ret, op_errno, inode, buf, + preparent, postparent, xdata); return 0; } - int trace_mkdir_cbk (call_frame_t *frame, void *cookie, xlator_t *this, int32_t op_ret, int32_t op_errno, inode_t *inode, struct iatt *buf, - struct iatt *preparent, struct iatt *postparent) + struct iatt *preparent, struct iatt *postparent, dict_t *xdata) { - char *statstr = NULL; - char *preparentstr = NULL; - char *postparentstr = NULL; - - if (trace_fop_names[GF_FOP_MKDIR].enabled) { - if (op_ret >= 0) { - statstr = trace_stat_to_str (buf); - preparentstr = trace_stat_to_str (preparent); - postparentstr = trace_stat_to_str (postparent); - - gf_log (this->name, GF_LOG_INFO, - "%"PRId64": gfid=%s (op_ret=%d " - ", *stbuf = {%s}, *prebuf = {%s}, " - "*postbuf = {%s} )", - frame->root->unique, uuid_utoa (inode->gfid), - op_ret, statstr, preparentstr, postparentstr); - - if (statstr) - GF_FREE (statstr); + char statstr[4096] = {0, }; + char preparentstr[4096] = {0, }; + char postparentstr[4096] = {0, }; + trace_conf_t *conf = NULL; - if (preparentstr) - GF_FREE (preparentstr); + conf = this->private; - if (postparentstr) - GF_FREE (postparentstr); + if (!conf->log_file && !conf->log_history) + goto out; + if (trace_fop_names[GF_FOP_MKDIR].enabled) { + char string[4096] = {0,}; + if (op_ret == 0) { + trace_stat_to_str (buf, statstr); + trace_stat_to_str (preparent, preparentstr); + trace_stat_to_str (postparent, postparentstr); + + snprintf (string, sizeof (string), + "%"PRId64": gfid=%s (op_ret=%d " + ", *stbuf = {%s}, *prebuf = {%s}, " + "*postbuf = {%s} )", + frame->root->unique, + uuid_utoa (inode->gfid), + op_ret, statstr, preparentstr, + postparentstr); } else { - gf_log (this->name, GF_LOG_INFO, - "%"PRId64": (op_ret=%d, op_errno=%d)", - frame->root->unique, op_ret, op_errno); + snprintf (string, sizeof (string), + "%"PRId64": (op_ret=%d, op_errno=%d)", + frame->root->unique, op_ret, + op_errno); } + LOG_ELEMENT (conf, string); } - - frame->local = NULL; - STACK_UNWIND_STRICT (mkdir, frame, op_ret, op_errno, inode, buf, - preparent, postparent); +out: + TRACE_STACK_UNWIND (mkdir, frame, op_ret, op_errno, inode, buf, + preparent, postparent, xdata); return 0; } - int trace_link_cbk (call_frame_t *frame, void *cookie, xlator_t *this, int32_t op_ret, int32_t op_errno, inode_t *inode, struct iatt *buf, - struct iatt *preparent, struct iatt *postparent) + struct iatt *preparent, struct iatt *postparent, dict_t *xdata) { - char *statstr = NULL; - char *preparentstr = NULL; - char *postparentstr = NULL; - - if (trace_fop_names[GF_FOP_LINK].enabled) { - if (op_ret >= 0) { - statstr = trace_stat_to_str (buf); - preparentstr = trace_stat_to_str (preparent); - postparentstr = trace_stat_to_str (postparent); - - gf_log (this->name, GF_LOG_INFO, - "%"PRId64": (op_ret=%d, *stbuf = {%s}, " - " *prebuf = {%s}, *postbuf = {%s})", - frame->root->unique, op_ret, - statstr, preparentstr, postparentstr); + char statstr[4096] = {0, }; + char preparentstr[4096] = {0, }; + char postparentstr[4096] = {0, }; + trace_conf_t *conf = NULL; - if (statstr) - GF_FREE (statstr); + conf = this->private; - if (preparentstr) - GF_FREE (preparentstr); - - if (postparentstr) - GF_FREE (postparentstr); + if (!conf->log_file && !conf->log_history) + goto out; + char string[4096] = {0,}; + if (trace_fop_names[GF_FOP_LINK].enabled) { + if (op_ret == 0) { + trace_stat_to_str (buf, statstr); + trace_stat_to_str (preparent, preparentstr); + trace_stat_to_str (postparent, postparentstr); + + snprintf (string, sizeof (string), + "%"PRId64": (op_ret=%d, " + "*stbuf = {%s}, *prebuf = {%s}," + " *postbuf = {%s})", + frame->root->unique, op_ret, + statstr, preparentstr, postparentstr); } else { - gf_log (this->name, GF_LOG_INFO, - "%"PRId64": gfid=%s op_ret=%d, op_errno=%d", - frame->root->unique, uuid_utoa (frame->local), - op_ret, op_errno); + snprintf (string, sizeof (string), + "%"PRId64": gfid=%s op_ret=%d, " + "op_errno=%d", + frame->root->unique, + uuid_utoa (frame->local), + op_ret, op_errno); } + LOG_ELEMENT (conf, string); } - - frame->local = NULL; - STACK_UNWIND_STRICT (link, frame, op_ret, op_errno, inode, buf, - preparent, postparent); +out: + TRACE_STACK_UNWIND (link, frame, op_ret, op_errno, inode, buf, + preparent, postparent, xdata); return 0; } - int trace_flush_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno) + int32_t op_ret, int32_t op_errno, dict_t *xdata) { + trace_conf_t *conf = NULL; + + conf = this->private; + + if (!conf->log_file && !conf->log_history) + goto out; + char string[4096] = {0,}; if (trace_fop_names[GF_FOP_FLUSH].enabled) { - gf_log (this->name, GF_LOG_INFO, - "%"PRId64": gfid=%s op_ret=%d, op_errno=%d", - frame->root->unique, uuid_utoa (frame->local), - op_ret, op_errno); - } + snprintf (string, sizeof (string), + "%"PRId64": gfid=%s op_ret=%d, op_errno=%d", + frame->root->unique, uuid_utoa (frame->local), + op_ret, op_errno); - frame->local = NULL; - STACK_UNWIND_STRICT (flush, frame, op_ret, op_errno); + LOG_ELEMENT (conf, string); + } +out: + TRACE_STACK_UNWIND (flush, frame, op_ret, op_errno, xdata); return 0; } - int trace_opendir_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, fd_t *fd) + int32_t op_ret, int32_t op_errno, fd_t *fd, dict_t *xdata) { + trace_conf_t *conf = NULL; + + conf = this->private; + + if (!conf->log_file && !conf->log_history) + goto out; + char string[4096] = {0,}; if (trace_fop_names[GF_FOP_OPENDIR].enabled) { - gf_log (this->name, GF_LOG_INFO, - "%"PRId64": gfid=%s op_ret=%d, op_errno=%d, fd=%p", - frame->root->unique, uuid_utoa (frame->local), - op_ret, op_errno, fd); - } + snprintf (string, sizeof (string), + "%"PRId64": gfid=%s op_ret=%d, op_errno=%d," + " fd=%p", + frame->root->unique, uuid_utoa (frame->local), + op_ret, op_errno, fd); + LOG_ELEMENT (conf, string); + } +out: /* for 'releasedir' log */ if (op_ret >= 0) fd_ctx_set (fd, this, 0); - frame->local = NULL; - STACK_UNWIND_STRICT (opendir, frame, op_ret, op_errno, fd); + TRACE_STACK_UNWIND (opendir, frame, op_ret, op_errno, fd, xdata); return 0; } - int trace_rmdir_cbk (call_frame_t *frame, void *cookie, xlator_t *this, int32_t op_ret, int32_t op_errno, - struct iatt *preparent, struct iatt *postparent) + struct iatt *preparent, struct iatt *postparent, dict_t *xdata) { - char *preparentstr = NULL; - char *postparentstr = NULL; + char preparentstr[4096] = {0, }; + char postparentstr[4096] = {0, }; + trace_conf_t *conf = NULL; - if (trace_fop_names[GF_FOP_RMDIR].enabled) { - if (op_ret >= 0) { - preparentstr = trace_stat_to_str (preparent); - postparentstr = trace_stat_to_str (postparent); + conf = this->private; - gf_log (this->name, GF_LOG_INFO, - "%"PRId64": gfid=%s op_ret=%d, *prebuf = {%s}, " - "*postbuf = {%s}", - frame->root->unique, uuid_utoa (frame->local), - op_ret, preparentstr, postparentstr); - - if (preparentstr) - GF_FREE (preparentstr); - - if (postparentstr) - GF_FREE (postparentstr); + if (!conf->log_file && !conf->log_history) + goto out; + if (trace_fop_names[GF_FOP_RMDIR].enabled) { + char string[4096] = {0,}; + if (op_ret == 0) { + trace_stat_to_str (preparent, preparentstr); + trace_stat_to_str (postparent, postparentstr); + + snprintf (string, sizeof (string), + "%"PRId64": gfid=%s op_ret=%d, " + "*prebuf={%s}, *postbuf={%s}", + frame->root->unique, + uuid_utoa (frame->local), + op_ret, preparentstr, postparentstr); } else { - gf_log (this->name, GF_LOG_INFO, - "%"PRId64": gfid=%s op_ret=%d, op_errno=%d", - frame->root->unique, uuid_utoa (frame->local), - op_ret, op_errno); + snprintf (string, sizeof (string), + "%"PRId64": gfid=%s op_ret=%d, " + "op_errno=%d", frame->root->unique, + uuid_utoa (frame->local), + op_ret, op_errno); } + LOG_ELEMENT (conf, string); } - - frame->local = NULL; - STACK_UNWIND_STRICT (rmdir, frame, op_ret, op_errno, - preparent, postparent); +out: + TRACE_STACK_UNWIND (rmdir, frame, op_ret, op_errno, + preparent, postparent, xdata); return 0; } - int trace_truncate_cbk (call_frame_t *frame, void *cookie, xlator_t *this, int32_t op_ret, int32_t op_errno, - struct iatt *prebuf, struct iatt *postbuf) + struct iatt *prebuf, struct iatt *postbuf, dict_t *xdata) { - char *preopstr = NULL; - char *postopstr = NULL; - - if (trace_fop_names[GF_FOP_TRUNCATE].enabled) { - if (op_ret >= 0) { - preopstr = trace_stat_to_str (prebuf); - postopstr = trace_stat_to_str (postbuf); + char preopstr[4096] = {0, }; + char postopstr[4096] = {0, }; + trace_conf_t *conf = NULL; - gf_log (this->name, GF_LOG_INFO, - "%"PRId64": (op_ret=%d, *prebuf = {%s}, " - "*postbuf = {%s} )", - frame->root->unique, op_ret, preopstr, - postopstr); + conf = this->private; - if (preopstr) - GF_FREE (preopstr); - - if (postopstr) - GF_FREE (postopstr); + if (!conf->log_file && !conf->log_history) + goto out; + if (trace_fop_names[GF_FOP_TRUNCATE].enabled) { + char string[4096] = {0,}; + if (op_ret == 0) { + trace_stat_to_str (prebuf, preopstr); + trace_stat_to_str (postbuf, postopstr); + + snprintf (string, sizeof (string), + "%"PRId64": (op_ret=%d, " + "*prebuf = {%s}, *postbuf = {%s} )", + frame->root->unique, op_ret, + preopstr, postopstr); } else { - gf_log (this->name, GF_LOG_INFO, - "%"PRId64": gfid=%s op_ret=%d, op_errno=%d", - frame->root->unique, uuid_utoa (frame->local), - op_ret, op_errno); + snprintf (string, sizeof (string), + "%"PRId64": gfid=%s op_ret=%d, " + "op_errno=%d", frame->root->unique, + uuid_utoa (frame->local), op_ret, + op_errno); } + LOG_ELEMENT (conf, string); } - - frame->local = NULL; - STACK_UNWIND_STRICT (truncate, frame, op_ret, op_errno, prebuf, postbuf); +out: + TRACE_STACK_UNWIND (truncate, frame, op_ret, op_errno, prebuf, + postbuf, xdata); return 0; } - int trace_statfs_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, struct statvfs *buf) + int32_t op_ret, int32_t op_errno, struct statvfs *buf, + dict_t *xdata) { + trace_conf_t *conf = NULL; + + conf = this->private; + + if (!conf->log_file && !conf->log_history) + goto out; if (trace_fop_names[GF_FOP_STATFS].enabled) { - if (op_ret >= 0) { - gf_log (this->name, GF_LOG_INFO, - "%"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); + char string[4096] = {0,}; + if (op_ret == 0) { + snprintf (string, sizeof (string), + "%"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_INFO, - "%"PRId64": (op_ret=%d, op_errno=%d)", - frame->root->unique, op_ret, op_errno); + snprintf (string, sizeof (string), + "%"PRId64": (op_ret=%d, " + "op_errno=%d)", + frame->root->unique, op_ret, + op_errno); } + LOG_ELEMENT (conf, string); } - - frame->local = NULL; - STACK_UNWIND_STRICT (statfs, frame, op_ret, op_errno, buf); +out: + TRACE_STACK_UNWIND (statfs, frame, op_ret, op_errno, buf, xdata); return 0; } - int trace_setxattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno) + int32_t op_ret, int32_t op_errno, dict_t *xdata) { + trace_conf_t *conf = NULL; + + conf = this->private; + + if (!conf->log_file && !conf->log_history) + goto out; if (trace_fop_names[GF_FOP_SETXATTR].enabled) { - gf_log (this->name, GF_LOG_INFO, - "%"PRId64": gfid=%s op_ret=%d, op_errno=%d", - frame->root->unique, uuid_utoa (frame->local), - op_ret, op_errno); - } + char string[4096] = {0,}; + snprintf (string, sizeof (string), + "%"PRId64": gfid=%s op_ret=%d, op_errno=%d", + frame->root->unique, + uuid_utoa (frame->local), op_ret, + op_errno); - frame->local = NULL; - STACK_UNWIND_STRICT (setxattr, frame, op_ret, op_errno); + LOG_ELEMENT (conf, string); + } +out: + TRACE_STACK_UNWIND (setxattr, frame, op_ret, op_errno, xdata); return 0; } - int trace_getxattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, dict_t *dict) + int32_t op_ret, int32_t op_errno, dict_t *dict, + dict_t *xdata) { + trace_conf_t *conf = NULL; + + conf = this->private; + + if (!conf->log_file && !conf->log_history) + goto out; if (trace_fop_names[GF_FOP_GETXATTR].enabled) { - gf_log (this->name, GF_LOG_INFO, - "%"PRId64": gfid=%s op_ret=%d, op_errno=%d, dict=%p", - frame->root->unique, uuid_utoa (frame->local), op_ret, - op_errno, dict); - } + char string[4096] = {0,}; + snprintf (string, sizeof (string), + "%"PRId64": gfid=%s op_ret=%d, op_errno=%d," + " dict=%p", frame->root->unique, + uuid_utoa (frame->local), op_ret, op_errno, + dict); - frame->local = NULL; - STACK_UNWIND_STRICT (getxattr, frame, op_ret, op_errno, dict); + LOG_ELEMENT (conf, string); + } +out: + TRACE_STACK_UNWIND (getxattr, frame, op_ret, op_errno, dict, xdata); return 0; } int trace_fsetxattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno) + int32_t op_ret, int32_t op_errno, dict_t *xdata) { + trace_conf_t *conf = NULL; + + conf = this->private; + + if (!conf->log_file && !conf->log_history) + goto out; if (trace_fop_names[GF_FOP_FSETXATTR].enabled) { - gf_log (this->name, GF_LOG_INFO, - "%"PRId64": gfid=%s op_ret=%d, op_errno=%d", - frame->root->unique, uuid_utoa (frame->local), op_ret, - op_errno); - } + char string[4096] = {0,}; + snprintf (string, sizeof (string), + "%"PRId64": gfid=%s op_ret=%d, op_errno=%d", + frame->root->unique, + uuid_utoa (frame->local), op_ret, op_errno); - frame->local = NULL; - STACK_UNWIND_STRICT (fsetxattr, frame, op_ret, op_errno); + LOG_ELEMENT (conf, string); + } +out: + TRACE_STACK_UNWIND (fsetxattr, frame, op_ret, op_errno, xdata); return 0; } - int trace_fgetxattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, dict_t *dict) + int32_t op_ret, int32_t op_errno, dict_t *dict, + dict_t *xdata) { + trace_conf_t *conf = NULL; + + conf = this->private; + + if (!conf->log_file && !conf->log_history) + goto out; if (trace_fop_names[GF_FOP_FGETXATTR].enabled) { - gf_log (this->name, GF_LOG_INFO, - "%"PRId64": gfid=%s op_ret=%d, op_errno=%d, dict=%p", - frame->root->unique, uuid_utoa (frame->local), op_ret, - op_errno, dict); - } + char string[4096] = {0,}; + snprintf (string, sizeof (string), + "%"PRId64": gfid=%s op_ret=%d, op_errno=%d," + " dict=%p", frame->root->unique, + uuid_utoa (frame->local), op_ret, op_errno, + dict); - frame->local = NULL; - STACK_UNWIND_STRICT (fgetxattr, frame, op_ret, op_errno, dict); + LOG_ELEMENT (conf, string); + } +out: + TRACE_STACK_UNWIND (fgetxattr, frame, op_ret, op_errno, dict, xdata); return 0; } int trace_removexattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno) + int32_t op_ret, int32_t op_errno, dict_t *xdata) { + trace_conf_t *conf = NULL; + + conf = this->private; + + if (!conf->log_file && !conf->log_history) + goto out; if (trace_fop_names[GF_FOP_REMOVEXATTR].enabled) { - gf_log (this->name, GF_LOG_INFO, - "%"PRId64": gfid=%s op_ret=%d, op_errno=%d", - frame->root->unique, uuid_utoa (frame->local), - op_ret, op_errno); - } + char string[4096] = {0,}; + snprintf (string, sizeof (string), + "%"PRId64": gfid=%s op_ret=%d, op_errno=%d", + frame->root->unique, + uuid_utoa (frame->local), op_ret, op_errno); - frame->local = NULL; - STACK_UNWIND_STRICT (removexattr, frame, op_ret, op_errno); + LOG_ELEMENT (conf, string); + } +out: + TRACE_STACK_UNWIND (removexattr, frame, op_ret, op_errno, xdata); return 0; } - int trace_fsyncdir_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno) + int32_t op_ret, int32_t op_errno, dict_t *xdata) { + trace_conf_t *conf = NULL; + + conf = this->private; + + if (!conf->log_file && !conf->log_history) + goto out; if (trace_fop_names[GF_FOP_FSYNCDIR].enabled) { - gf_log (this->name, GF_LOG_INFO, - "%"PRId64": gfid=%s op_ret=%d, op_errno=%d", - frame->root->unique, uuid_utoa (frame->local), - op_ret, op_errno); - } + char string[4096] = {0,}; + snprintf (string, sizeof (string), + "%"PRId64": gfid=%s op_ret=%d, op_errno=%d", + frame->root->unique, + uuid_utoa (frame->local), op_ret, op_errno); - frame->local = NULL; - STACK_UNWIND_STRICT (fsyncdir, frame, op_ret, op_errno); + LOG_ELEMENT (conf, string); + } +out: + TRACE_STACK_UNWIND (fsyncdir, frame, op_ret, op_errno, xdata); return 0; } - int trace_access_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno) + int32_t op_ret, int32_t op_errno, dict_t *xdata) { + trace_conf_t *conf = NULL; + + conf = this->private; + + if (!conf->log_file && !conf->log_history) + goto out; if (trace_fop_names[GF_FOP_ACCESS].enabled) { - gf_log (this->name, GF_LOG_INFO, - "%"PRId64": gfid=%s op_ret=%d, op_errno=%d)", - frame->root->unique, uuid_utoa (frame->local), - op_ret, op_errno); - } + char string[4096] = {0,}; + snprintf (string, sizeof (string), + "%"PRId64": gfid=%s op_ret=%d, " + "op_errno=%d)", frame->root->unique, + uuid_utoa (frame->local), op_ret, op_errno); - frame->local = NULL; - STACK_UNWIND_STRICT (access, frame, op_ret, op_errno); + LOG_ELEMENT (conf, string); + } +out: + TRACE_STACK_UNWIND (access, frame, op_ret, op_errno, xdata); return 0; } - int trace_ftruncate_cbk (call_frame_t *frame, void *cookie, xlator_t *this, int32_t op_ret, int32_t op_errno, - struct iatt *prebuf, struct iatt *postbuf) + struct iatt *prebuf, struct iatt *postbuf, dict_t *xdata) { - char *prebufstr = NULL; - char *postbufstr = NULL; - - if (trace_fop_names[GF_FOP_FTRUNCATE].enabled) { - if (op_ret >= 0) { - prebufstr = trace_stat_to_str (prebuf); - postbufstr = trace_stat_to_str (postbuf); - - gf_log (this->name, GF_LOG_INFO, - "%"PRId64": op_ret=%d, *prebuf = {%s}, " - "*postbuf = {%s} )", - frame->root->unique, op_ret, - prebufstr, postbufstr); + char prebufstr[4096] = {0, }; + char postbufstr[4096] = {0, }; + trace_conf_t *conf = NULL; - if (prebufstr) - GF_FREE (prebufstr); - - if (postbufstr) - GF_FREE (postbufstr); + conf = this->private; + if (!conf->log_file && !conf->log_history) + goto out; + if (trace_fop_names[GF_FOP_FTRUNCATE].enabled) { + char string[4096] = {0,}; + if (op_ret == 0) { + trace_stat_to_str (prebuf, prebufstr); + trace_stat_to_str (postbuf, postbufstr); + + snprintf (string, sizeof (string), + "%"PRId64": op_ret=%d, " + "*prebuf = {%s}, *postbuf = {%s} )", + frame->root->unique, op_ret, + prebufstr, postbufstr); } else { - gf_log (this->name, GF_LOG_INFO, - "%"PRId64": gfid=%s op_ret=%d, op_errno=%d", - frame->root->unique, uuid_utoa (frame->local), - op_ret, op_errno); + snprintf (string, sizeof (string), + "%"PRId64": gfid=%s op_ret=%d, " + "op_errno=%d", frame->root->unique, + uuid_utoa (frame->local), op_ret, + op_errno); } + LOG_ELEMENT (conf, string); } - - frame->local = NULL; - STACK_UNWIND_STRICT (ftruncate, frame, op_ret, op_errno, prebuf, postbuf); +out: + TRACE_STACK_UNWIND (ftruncate, frame, op_ret, op_errno, prebuf, postbuf, + xdata); return 0; } - int trace_fstat_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, struct iatt *buf) + int32_t op_ret, int32_t op_errno, struct iatt *buf, dict_t *xdata) { - char *statstr = NULL; + char statstr[4096] = {0, }; + trace_conf_t *conf = NULL; + + conf = this->private; + if (!conf->log_file && !conf->log_history) + goto out; if (trace_fop_names[GF_FOP_FSTAT].enabled) { - if (op_ret >= 0) { - statstr = trace_stat_to_str (buf); - gf_log (this->name, GF_LOG_INFO, - "%"PRId64": gfid=%s op_ret=%d buf=%s", - frame->root->unique, uuid_utoa (frame->local), - op_ret, statstr); - - if (statstr) - GF_FREE (statstr); + char string[4096] = {0.}; + if (op_ret == 0) { + trace_stat_to_str (buf, statstr); + snprintf (string, sizeof (string), + "%"PRId64": gfid=%s op_ret=%d " + "buf=%s", frame->root->unique, + uuid_utoa (frame->local), op_ret, + statstr); } else { - gf_log (this->name, GF_LOG_INFO, - "%"PRId64": gfid=%s op_ret=%d, op_errno=%d", - frame->root->unique, uuid_utoa (frame->local), - op_ret, op_errno); + snprintf (string, sizeof (string), + "%"PRId64": gfid=%s op_ret=%d, " + "op_errno=%d", frame->root->unique, + uuid_utoa (frame->local), op_ret, + op_errno); } + LOG_ELEMENT (conf, string); } - - frame->local = NULL; - STACK_UNWIND_STRICT (fstat, frame, op_ret, op_errno, buf); +out: + TRACE_STACK_UNWIND (fstat, frame, op_ret, op_errno, buf, xdata); return 0; } - int trace_lk_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, struct gf_flock *lock) + int32_t op_ret, int32_t op_errno, struct gf_flock *lock, + dict_t *xdata) { + trace_conf_t *conf = NULL; + + conf = this->private; + + if (!conf->log_file && !conf->log_history) + goto out; if (trace_fop_names[GF_FOP_LK].enabled) { - if (op_ret >= 0) { - gf_log (this->name, GF_LOG_INFO, - "%"PRId64": gfid=%s op_ret=%d, {l_type=%d, l_whence=%d, " - "l_start=%"PRId64", l_len=%"PRId64", l_pid=%u})", - frame->root->unique, uuid_utoa (frame->local), - op_ret, lock->l_type, lock->l_whence, - lock->l_start, lock->l_len, lock->l_pid); + char string[4096] = {0,}; + if (op_ret == 0) { + snprintf (string, sizeof (string), + "%"PRId64": gfid=%s op_ret=%d, " + "{l_type=%d, l_whence=%d, " + "l_start=%"PRId64", " + "l_len=%"PRId64", l_pid=%u})", + frame->root->unique, + uuid_utoa (frame->local), + op_ret, lock->l_type, lock->l_whence, + lock->l_start, lock->l_len, + lock->l_pid); } else { - gf_log (this->name, GF_LOG_INFO, - "%"PRId64": gfid=%s op_ret=%d, op_errno=%d)", - frame->root->unique, uuid_utoa (frame->local), - op_ret, op_errno); + snprintf (string, sizeof (string), + "%"PRId64": gfid=%s op_ret=%d, " + "op_errno=%d)", frame->root->unique, + uuid_utoa (frame->local), op_ret, + op_errno); } - } - frame->local = NULL; - STACK_UNWIND_STRICT (lk, frame, op_ret, op_errno, lock); + LOG_ELEMENT (conf, string); + } +out: + TRACE_STACK_UNWIND (lk, frame, op_ret, op_errno, lock, xdata); return 0; } - - int trace_entrylk_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno) + int32_t op_ret, int32_t op_errno, dict_t *xdata) { + trace_conf_t *conf = NULL; + + conf = this->private; + + if (!conf->log_file && !conf->log_history) + goto out; if (trace_fop_names[GF_FOP_ENTRYLK].enabled) { - gf_log (this->name, GF_LOG_INFO, - "%"PRId64": gfid=%s op_ret=%d, op_errno=%d", - frame->root->unique, uuid_utoa (frame->local), - op_ret, op_errno); - } + char string[4096] = {0,}; + snprintf (string, sizeof (string), + "%"PRId64": gfid=%s op_ret=%d, op_errno=%d", + frame->root->unique, + uuid_utoa (frame->local), op_ret, op_errno); - frame->local = NULL; - STACK_UNWIND_STRICT (entrylk, frame, op_ret, op_errno); + LOG_ELEMENT (conf, string); + } +out: + TRACE_STACK_UNWIND (entrylk, frame, op_ret, op_errno, xdata); return 0; } int trace_fentrylk_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno) + int32_t op_ret, int32_t op_errno, dict_t *xdata) { + trace_conf_t *conf = NULL; + + conf = this->private; + + if (!conf->log_file && !conf->log_history) + goto out; if (trace_fop_names[GF_FOP_FENTRYLK].enabled) { - gf_log (this->name, GF_LOG_INFO, - "%"PRId64": gfid=%s op_ret=%d, op_errno=%d", - frame->root->unique, uuid_utoa (frame->local), - op_ret, op_errno); - } + char string[4096] = {0,}; + snprintf (string, sizeof (string), + "%"PRId64": gfid=%s op_ret=%d, op_errno=%d", + frame->root->unique, + uuid_utoa (frame->local), op_ret, op_errno); - frame->local = NULL; - STACK_UNWIND_STRICT (fentrylk, frame, op_ret, op_errno); + LOG_ELEMENT (conf, string); + } +out: + TRACE_STACK_UNWIND (fentrylk, frame, op_ret, op_errno, xdata); return 0; } - int trace_xattrop_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, dict_t *dict) + int32_t op_ret, int32_t op_errno, dict_t *dict, + dict_t *xdata) { + trace_conf_t *conf = NULL; + + conf = this->private; + + if (!conf->log_file && !conf->log_history) + goto out; if (trace_fop_names[GF_FOP_XATTROP].enabled) { - gf_log (this->name, GF_LOG_INFO, - "%"PRId64": gfid=%s op_ret=%d, op_errno=%d", - frame->root->unique, uuid_utoa (frame->local), - op_ret, op_errno); - } + char string[4096] = {0,}; + snprintf (string, sizeof (string), + "%"PRId64": gfid=%s op_ret=%d, op_errno=%d", + frame->root->unique, + uuid_utoa (frame->local), op_ret, op_errno); - frame->local = NULL; - STACK_UNWIND_STRICT (xattrop, frame, op_ret, op_errno, dict); + LOG_ELEMENT (conf, string); + } +out: + TRACE_STACK_UNWIND (xattrop, frame, op_ret, op_errno, dict, xdata); return 0; } - int trace_fxattrop_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, dict_t *dict) + int32_t op_ret, int32_t op_errno, dict_t *dict, + dict_t *xdata) { + trace_conf_t *conf = NULL; + + conf = this->private; + + if (!conf->log_file && !conf->log_history) + goto out; if (trace_fop_names[GF_FOP_FXATTROP].enabled) { - gf_log (this->name, GF_LOG_INFO, - "%"PRId64": gfid=%s op_ret=%d, op_errno=%d", - frame->root->unique, uuid_utoa (frame->local), - op_ret, op_errno); - } + char string[4096] = {0,}; + snprintf (string, sizeof (string), + "%"PRId64": gfid=%s op_ret=%d, op_errno=%d", + frame->root->unique, + uuid_utoa (frame->local), op_ret, op_errno); - frame->local = NULL; - STACK_UNWIND_STRICT (fxattrop, frame, op_ret, op_errno, dict); + LOG_ELEMENT (conf, string); + } +out: + TRACE_STACK_UNWIND (fxattrop, frame, op_ret, op_errno, dict, xdata); return 0; } - int trace_inodelk_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno) + int32_t op_ret, int32_t op_errno, dict_t *xdata) { + trace_conf_t *conf = NULL; + + conf = this->private; + + if (!conf->log_file && !conf->log_history) + goto out; if (trace_fop_names[GF_FOP_INODELK].enabled) { - gf_log (this->name, GF_LOG_INFO, - "%"PRId64": gfid=%s op_ret=%d, op_errno=%d", - frame->root->unique, uuid_utoa (frame->local), - op_ret, op_errno); - } + char string[4096] = {0,}; + snprintf (string, sizeof (string), + "%"PRId64": gfid=%s op_ret=%d, op_errno=%d", + frame->root->unique, + uuid_utoa (frame->local),op_ret, op_errno); - frame->local = NULL; - STACK_UNWIND_STRICT (inodelk, frame, op_ret, op_errno); + LOG_ELEMENT (conf, string); + } +out: + TRACE_STACK_UNWIND (inodelk, frame, op_ret, op_errno, xdata); return 0; } int trace_finodelk_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno) + int32_t op_ret, int32_t op_errno, dict_t *xdata) { + trace_conf_t *conf = NULL; + + conf = this->private; + + if (!conf->log_file && !conf->log_history) + goto out; if (trace_fop_names[GF_FOP_FINODELK].enabled) { - gf_log (this->name, GF_LOG_INFO, - "%"PRId64": gfid=%s op_ret=%d, op_errno=%d", - frame->root->unique, uuid_utoa (frame->local), op_ret, op_errno); - } + char string[4096] = {0,}; + snprintf (string, sizeof (string), + "%"PRId64": gfid=%s op_ret=%d, op_errno=%d", + frame->root->unique, + uuid_utoa (frame->local), op_ret, op_errno); - frame->local = NULL; - STACK_UNWIND_STRICT (finodelk, frame, op_ret, op_errno); + LOG_ELEMENT (conf, string); + } +out: + TRACE_STACK_UNWIND (finodelk, frame, op_ret, op_errno, xdata); return 0; } - int trace_rchecksum_cbk (call_frame_t *frame, void *cookie, xlator_t *this, int32_t op_ret, int32_t op_errno, - uint32_t weak_checksum, uint8_t *strong_checksum) + uint32_t weak_checksum, uint8_t *strong_checksum, + dict_t *xdata) { + trace_conf_t *conf = NULL; + + conf = this->private; + + if (!conf->log_file && !conf->log_history) + goto out; if (trace_fop_names[GF_FOP_RCHECKSUM].enabled) { - gf_log (this->name, GF_LOG_INFO, - "%"PRId64": gfid=%s op_ret=%d op_errno=%d", - frame->root->unique, uuid_utoa (frame->local), op_ret, op_errno); + char string[4096] = {0,}; + snprintf (string, sizeof (string), + "%"PRId64": gfid=%s op_ret=%d op_errno=%d", + frame->root->unique, + uuid_utoa (frame->local), op_ret, op_errno); + + LOG_ELEMENT (conf, string); } - frame->local = NULL; - STACK_UNWIND_STRICT (rchecksum, frame, op_ret, op_errno, weak_checksum, - strong_checksum); +out: + TRACE_STACK_UNWIND (rchecksum, frame, op_ret, op_errno, weak_checksum, + strong_checksum, xdata); return 0; } @@ -1235,35 +1409,54 @@ trace_rchecksum_cbk (call_frame_t *frame, void *cookie, xlator_t *this, int trace_entrylk (call_frame_t *frame, xlator_t *this, const char *volume, loc_t *loc, const char *basename, - entrylk_cmd cmd, entrylk_type type) + entrylk_cmd cmd, entrylk_type type, dict_t *xdata) { + trace_conf_t *conf = NULL; + + conf = this->private; + + if (!conf->log_file && !conf->log_history) + goto out; if (trace_fop_names[GF_FOP_ENTRYLK].enabled) { - gf_log (this->name, GF_LOG_INFO, - "%"PRId64": gfid=%s volume=%s, (path=%s basename=%s, " - "cmd=%s, type=%s)", - frame->root->unique, uuid_utoa (loc->inode->gfid), - volume, loc->path, basename, - ((cmd == ENTRYLK_LOCK) ? "ENTRYLK_LOCK" : "ENTRYLK_UNLOCK"), - ((type == ENTRYLK_RDLCK) ? "ENTRYLK_RDLCK" : "ENTRYLK_WRLCK")); + char string[4096] = {0,}; + snprintf (string, sizeof (string), + "%"PRId64": gfid=%s volume=%s, (path=%s " + "basename=%s, cmd=%s, type=%s)", + frame->root->unique, + uuid_utoa (loc->inode->gfid), + volume, loc->path, basename, + ((cmd == ENTRYLK_LOCK) ? "ENTRYLK_LOCK" : + "ENTRYLK_UNLOCK"), + ((type == ENTRYLK_RDLCK) ? "ENTRYLK_RDLCK" : + "ENTRYLK_WRLCK")); + frame->local = loc->inode->gfid; + + LOG_ELEMENT (conf, string); } +out: STACK_WIND (frame, trace_entrylk_cbk, FIRST_CHILD (this), FIRST_CHILD (this)->fops->entrylk, - volume, loc, basename, cmd, type); + volume, loc, basename, cmd, type, xdata); return 0; } - int trace_inodelk (call_frame_t *frame, xlator_t *this, const char *volume, - loc_t *loc, int32_t cmd, struct gf_flock *flock) + loc_t *loc, int32_t cmd, struct gf_flock *flock, dict_t *xdata) { - char *cmd_str = NULL; - char *type_str = NULL; + char *cmd_str = NULL; + char *type_str = NULL; + trace_conf_t *conf = NULL; + + conf = this->private; + if (!conf->log_file && !conf->log_history) + goto out; if (trace_fop_names[GF_FOP_INODELK].enabled) { + char string[4096] = {0,}; switch (cmd) { #if F_GETLK != F_GETLK64 case F_GETLK64: @@ -1306,32 +1499,43 @@ trace_inodelk (call_frame_t *frame, xlator_t *this, const char *volume, break; } - gf_log (this->name, GF_LOG_INFO, - "%"PRId64": gfid=%s volume=%s, (path=%s " - "cmd=%s, type=%s, start=%llu, len=%llu, pid=%llu)", - frame->root->unique, uuid_utoa (loc->inode->gfid), - volume, loc->path, - cmd_str, type_str, (unsigned long long) flock->l_start, - (unsigned long long) flock->l_len, - (unsigned long long) flock->l_pid); + snprintf (string, sizeof (string), + "%"PRId64": gfid=%s volume=%s, (path=%s " + "cmd=%s, type=%s, start=%llu, len=%llu, " + "pid=%llu)", frame->root->unique, + uuid_utoa (loc->inode->gfid), volume, + loc->path, cmd_str, type_str, + (unsigned long long)flock->l_start, + (unsigned long long) flock->l_len, + (unsigned long long) flock->l_pid); + frame->local = loc->inode->gfid; + + LOG_ELEMENT (conf, string); } +out: STACK_WIND (frame, trace_inodelk_cbk, FIRST_CHILD (this), FIRST_CHILD (this)->fops->inodelk, - volume, loc, cmd, flock); + volume, loc, cmd, flock, xdata); return 0; } - int trace_finodelk (call_frame_t *frame, xlator_t *this, const char *volume, - fd_t *fd, int32_t cmd, struct gf_flock *flock) + fd_t *fd, int32_t cmd, struct gf_flock *flock, dict_t *xdata) { - char *cmd_str = NULL, *type_str = NULL; + char *cmd_str = NULL; + char *type_str = NULL; + trace_conf_t *conf = NULL; + + conf = this->private; + if (!conf->log_file && !conf->log_history) + goto out; if (trace_fop_names[GF_FOP_FINODELK].enabled) { + char string[4096] = {0,}; switch (cmd) { #if F_GETLK != F_GETLK64 case F_GETLK64: @@ -1374,233 +1578,351 @@ trace_finodelk (call_frame_t *frame, xlator_t *this, const char *volume, break; } - gf_log (this->name, GF_LOG_INFO, - "%"PRId64": gfid=%s volume=%s, (fd =%p " - "cmd=%s, type=%s, start=%llu, len=%llu, pid=%llu)", - frame->root->unique, uuid_utoa (fd->inode->gfid), volume, fd, - cmd_str, type_str, (unsigned long long) flock->l_start, - (unsigned long long) flock->l_len, - (unsigned long long) flock->l_pid); + snprintf (string, sizeof (string), + "%"PRId64": gfid=%s volume=%s, (fd =%p " + "cmd=%s, type=%s, start=%llu, len=%llu, " + "pid=%llu)", frame->root->unique, + uuid_utoa (fd->inode->gfid), volume, fd, + cmd_str, type_str, + (unsigned long long) flock->l_start, + (unsigned long long) flock->l_len, + (unsigned long long) flock->l_pid); + frame->local = fd->inode->gfid; - } + LOG_ELEMENT (conf, string); + } +out: STACK_WIND (frame, trace_finodelk_cbk, FIRST_CHILD (this), FIRST_CHILD (this)->fops->finodelk, - volume, fd, cmd, flock); + volume, fd, cmd, flock, xdata); return 0; } - int trace_xattrop (call_frame_t *frame, xlator_t *this, loc_t *loc, - gf_xattrop_flags_t flags, dict_t *dict) + gf_xattrop_flags_t flags, dict_t *dict, dict_t *xdata) { + trace_conf_t *conf = NULL; + + conf = this->private; + + if (!conf->log_file && !conf->log_history) + goto out; if (trace_fop_names[GF_FOP_XATTROP].enabled) { - gf_log (this->name, GF_LOG_INFO, - "%"PRId64": gfid=%s (path=%s flags=%d)", - frame->root->unique, uuid_utoa (loc->inode->gfid), - loc->path, flags); + char string[4096] = {0,}; + snprintf (string, sizeof (string), + "%"PRId64": gfid=%s (path=%s flags=%d)", + frame->root->unique, + uuid_utoa (loc->inode->gfid), loc->path, + flags); + frame->local = loc->inode->gfid; + + LOG_ELEMENT (conf, string); } +out: STACK_WIND (frame, trace_xattrop_cbk, FIRST_CHILD(this), FIRST_CHILD(this)->fops->xattrop, - loc, flags, dict); + loc, flags, dict, xdata); return 0; } - int trace_fxattrop (call_frame_t *frame, xlator_t *this, fd_t *fd, - gf_xattrop_flags_t flags, dict_t *dict) + gf_xattrop_flags_t flags, dict_t *dict, dict_t *xdata) { + trace_conf_t *conf = NULL; + + conf = this->private; + + if (!conf->log_file && !conf->log_history) + goto out; if (trace_fop_names[GF_FOP_FXATTROP].enabled) { - gf_log (this->name, GF_LOG_INFO, - "%"PRId64": gfid=%s fd=%p, flags=%d", - frame->root->unique, uuid_utoa (fd->inode->gfid), - fd, flags); + char string[4096] = {0,}; + snprintf (string, sizeof (string), + "%"PRId64": gfid=%s fd=%p, flags=%d", + frame->root->unique, + uuid_utoa (fd->inode->gfid), fd, flags); + frame->local = fd->inode->gfid; + + LOG_ELEMENT (conf, string); } +out: STACK_WIND (frame, trace_fxattrop_cbk, FIRST_CHILD(this), FIRST_CHILD(this)->fops->fxattrop, - fd, flags, dict); + fd, flags, dict, xdata); return 0; } - int trace_lookup (call_frame_t *frame, xlator_t *this, - loc_t *loc, dict_t *xattr_req) + loc_t *loc, dict_t *xdata) { + trace_conf_t *conf = NULL; + + conf = this->private; + + if (!conf->log_file && !conf->log_history) + goto out; if (trace_fop_names[GF_FOP_LOOKUP].enabled) { + char string[4096] = {0,}; /* TODO: print all the keys mentioned in xattr_req */ - gf_log (this->name, GF_LOG_INFO, - "%"PRId64": gfid=%s path=%s", - frame->root->unique, uuid_utoa (loc->inode->gfid), - loc->path); + snprintf (string, sizeof (string), + "%"PRId64": gfid=%s path=%s", + frame->root->unique, + uuid_utoa (loc->inode->gfid), loc->path); + frame->local = loc->inode->gfid; + + LOG_ELEMENT (conf, string); } +out: STACK_WIND (frame, trace_lookup_cbk, FIRST_CHILD(this), FIRST_CHILD(this)->fops->lookup, - loc, xattr_req); + loc, xdata); return 0; } - int -trace_stat (call_frame_t *frame, xlator_t *this, loc_t *loc) +trace_stat (call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *xdata) { + trace_conf_t *conf = NULL; + + conf = this->private; + + if (!conf->log_file && !conf->log_history) + goto out; if (trace_fop_names[GF_FOP_STAT].enabled) { - gf_log (this->name, GF_LOG_INFO, - "%"PRId64": gfid=%s path=%s", - frame->root->unique, uuid_utoa (loc->inode->gfid), - loc->path); + char string[4096] = {0,}; + snprintf (string, sizeof (string), + "%"PRId64": gfid=%s path=%s", + frame->root->unique, + uuid_utoa (loc->inode->gfid), loc->path); + frame->local = loc->inode->gfid; + + LOG_ELEMENT (conf, string); } +out: STACK_WIND (frame, trace_stat_cbk, FIRST_CHILD(this), FIRST_CHILD(this)->fops->stat, - loc); + loc, xdata); return 0; } - int -trace_readlink (call_frame_t *frame, xlator_t *this, loc_t *loc, size_t size) +trace_readlink (call_frame_t *frame, xlator_t *this, loc_t *loc, size_t size, + dict_t *xdata) { + trace_conf_t *conf = NULL; + + conf = this->private; + + if (!conf->log_file && !conf->log_history) + goto out; if (trace_fop_names[GF_FOP_READLINK].enabled) { - gf_log (this->name, GF_LOG_INFO, - "%"PRId64": gfid=%s path=%s, size=%"GF_PRI_SIZET")", - frame->root->unique, uuid_utoa (loc->inode->gfid), - loc->path, size); + char string[4096] = {0,}; + snprintf (string, sizeof (string), + "%"PRId64": gfid=%s path=%s, " + "size=%"GF_PRI_SIZET")", frame->root->unique, + uuid_utoa (loc->inode->gfid), loc->path, + size); + frame->local = loc->inode->gfid; + + LOG_ELEMENT (conf, string); } +out: STACK_WIND (frame, trace_readlink_cbk, FIRST_CHILD(this), FIRST_CHILD(this)->fops->readlink, - loc, size); + loc, size, xdata); return 0; } - int trace_mknod (call_frame_t *frame, xlator_t *this, loc_t *loc, - mode_t mode, dev_t dev, dict_t *params) + mode_t mode, dev_t dev, mode_t umask, dict_t *xdata) { + trace_conf_t *conf = NULL; + + conf = this->private; + + if (!conf->log_file && !conf->log_history) + goto out; if (trace_fop_names[GF_FOP_MKNOD].enabled) { - gf_log (this->name, GF_LOG_INFO, - "%"PRId64": gfid=%s path=%s mode=%d dev=%"GF_PRI_DEV")", - frame->root->unique, uuid_utoa (loc->inode->gfid), - loc->path, mode, dev); + char string[4096] = {0,}; + snprintf (string, sizeof (string), + "%"PRId64": gfid=%s path=%s mode=%d " + "umask=0%o, dev=%"GF_PRI_DEV")", + frame->root->unique, + uuid_utoa (loc->inode->gfid), loc->path, + mode, umask, dev); + + LOG_ELEMENT (conf, string); } +out: STACK_WIND (frame, trace_mknod_cbk, FIRST_CHILD(this), FIRST_CHILD(this)->fops->mknod, - loc, mode, dev, params); + loc, mode, dev, umask, xdata); return 0; } - int trace_mkdir (call_frame_t *frame, xlator_t *this, loc_t *loc, mode_t mode, - dict_t *params) + mode_t umask, dict_t *xdata) { + trace_conf_t *conf = NULL; + + conf = this->private; + + if (!conf->log_file && !conf->log_history) + goto out; if (trace_fop_names[GF_FOP_MKDIR].enabled) { - gf_log (this->name, GF_LOG_INFO, - "%"PRId64": gfid=%s path=%s mode=%d", - frame->root->unique, uuid_utoa (loc->inode->gfid), - loc->path, mode); + char string[4096] = {0,}; + snprintf (string, sizeof (string), + "%"PRId64": gfid=%s path=%s mode=%d" + " umask=0%o", frame->root->unique, + uuid_utoa (loc->inode->gfid), loc->path, + mode, umask); + + LOG_ELEMENT (conf, string); } +out: STACK_WIND (frame, trace_mkdir_cbk, FIRST_CHILD(this), FIRST_CHILD(this)->fops->mkdir, - loc, mode, params); + loc, mode, umask, xdata); return 0; } - int -trace_unlink (call_frame_t *frame, xlator_t *this, loc_t *loc) +trace_unlink (call_frame_t *frame, xlator_t *this, loc_t *loc, int xflag, + dict_t *xdata) { + trace_conf_t *conf = NULL; + + conf = this->private; + + if (!conf->log_file && !conf->log_history) + goto out; if (trace_fop_names[GF_FOP_UNLINK].enabled) { - gf_log (this->name, GF_LOG_INFO, - "%"PRId64": gfid=%s path=%s", - frame->root->unique, uuid_utoa (loc->inode->gfid), - loc->path); + char string[4096] = {0,}; + snprintf (string, sizeof (string), + "%"PRId64": gfid=%s path=%s flag=%d", + frame->root->unique, + uuid_utoa (loc->inode->gfid), loc->path, + xflag); + frame->local = loc->inode->gfid; - } + LOG_ELEMENT (conf, string); + } +out: STACK_WIND (frame, trace_unlink_cbk, FIRST_CHILD(this), FIRST_CHILD(this)->fops->unlink, - loc); + loc, xflag, xdata); return 0; } - int -trace_rmdir (call_frame_t *frame, xlator_t *this, loc_t *loc, int flags) +trace_rmdir (call_frame_t *frame, xlator_t *this, loc_t *loc, int flags, + dict_t *xdata) { + trace_conf_t *conf = NULL; + + conf = this->private; + + if (!conf->log_file && !conf->log_history) + goto out; if (trace_fop_names[GF_FOP_RMDIR].enabled) { - gf_log (this->name, GF_LOG_INFO, - "%"PRId64": gfid=%s path=%s flags=%d", - frame->root->unique, uuid_utoa (loc->inode->gfid), - loc->path, flags); + char string[4096] = {0,}; + snprintf (string, sizeof (string), + "%"PRId64": gfid=%s path=%s flags=%d", + frame->root->unique, + uuid_utoa (loc->inode->gfid), loc->path, + flags); + frame->local = loc->inode->gfid; + + LOG_ELEMENT (conf, string); } +out: STACK_WIND (frame, trace_rmdir_cbk, FIRST_CHILD(this), FIRST_CHILD(this)->fops->rmdir, - loc, flags); + loc, flags, xdata); return 0; } - int trace_symlink (call_frame_t *frame, xlator_t *this, const char *linkpath, - loc_t *loc, dict_t *params) + loc_t *loc, mode_t umask, dict_t *xdata) { + trace_conf_t *conf = NULL; + + conf = this->private; + + if (!conf->log_file && !conf->log_history) + goto out; if (trace_fop_names[GF_FOP_SYMLINK].enabled) { - gf_log (this->name, GF_LOG_INFO, - "%"PRId64": gfid=%s linkpath=%s, path=%s", - frame->root->unique, uuid_utoa (loc->inode->gfid), - linkpath, loc->path); + char string[4096] = {0,}; + snprintf (string, sizeof (string), + "%"PRId64": gfid=%s linkpath=%s, path=%s" + " umask=0%o", frame->root->unique, + uuid_utoa (loc->inode->gfid), linkpath, + loc->path, umask); + + LOG_ELEMENT (conf, string); } +out: STACK_WIND (frame, trace_symlink_cbk, FIRST_CHILD(this), FIRST_CHILD(this)->fops->symlink, - linkpath, loc, params); + linkpath, loc, umask, xdata); return 0; } - int -trace_rename (call_frame_t *frame, xlator_t *this, loc_t *oldloc, loc_t *newloc) +trace_rename (call_frame_t *frame, xlator_t *this, loc_t *oldloc, loc_t *newloc, + dict_t *xdata) { - char oldgfid[50] = {0,}; - char newgfid[50] = {0,}; + char oldgfid[50] = {0,}; + char newgfid[50] = {0,}; + trace_conf_t *conf = NULL; + + conf = this->private; + if (!conf->log_file && !conf->log_history) + goto out; if (trace_fop_names[GF_FOP_RENAME].enabled) { + char string[4096] = {0,}; if (newloc->inode) uuid_utoa_r (newloc->inode->gfid, newgfid); else @@ -1608,29 +1930,40 @@ trace_rename (call_frame_t *frame, xlator_t *this, loc_t *oldloc, loc_t *newloc) uuid_utoa_r (oldloc->inode->gfid, oldgfid); - gf_log (this->name, GF_LOG_INFO, - "%"PRId64": oldgfid=%s oldpath=%s --> newgfid=%s newpath=%s", - frame->root->unique, oldgfid, oldloc->path, newgfid, newloc->path); + snprintf (string, sizeof (string), + "%"PRId64": oldgfid=%s oldpath=%s --> " + "newgfid=%s newpath=%s", + frame->root->unique, oldgfid, + oldloc->path, newgfid, newloc->path); frame->local = oldloc->inode->gfid; + + LOG_ELEMENT (conf, string); } +out: STACK_WIND (frame, trace_rename_cbk, FIRST_CHILD(this), FIRST_CHILD(this)->fops->rename, - oldloc, newloc); + oldloc, newloc, xdata); return 0; } - int -trace_link (call_frame_t *frame, xlator_t *this, loc_t *oldloc, loc_t *newloc) +trace_link (call_frame_t *frame, xlator_t *this, loc_t *oldloc, loc_t *newloc, + dict_t *xdata) { - char oldgfid[50] = {0,}; - char newgfid[50] = {0,}; + char oldgfid[50] = {0,}; + char newgfid[50] = {0,}; + trace_conf_t *conf = NULL; + conf = this->private; + + if (!conf->log_file && !conf->log_history) + goto out; if (trace_fop_names[GF_FOP_LINK].enabled) { + char string[4096] = {0,}; if (newloc->inode) uuid_utoa_r (newloc->inode->gfid, newgfid); else @@ -1638,42 +1971,63 @@ trace_link (call_frame_t *frame, xlator_t *this, loc_t *oldloc, loc_t *newloc) uuid_utoa_r (oldloc->inode->gfid, oldgfid); - gf_log (this->name, GF_LOG_INFO, - "%"PRId64": oldgfid=%s oldpath=%s --> newgfid=%s newpath=%s", - frame->root->unique, oldgfid, oldloc->path, - newgfid, newloc->path); + snprintf (string, sizeof (string), + "%"PRId64": oldgfid=%s oldpath=%s --> " + "newgfid=%s newpath=%s", frame->root->unique, + oldgfid, oldloc->path, newgfid, + newloc->path); + frame->local = oldloc->inode->gfid; + + LOG_ELEMENT (conf, string); } +out: STACK_WIND (frame, trace_link_cbk, FIRST_CHILD(this), FIRST_CHILD(this)->fops->link, - oldloc, newloc); + oldloc, newloc, xdata); return 0; } - int trace_setattr (call_frame_t *frame, xlator_t *this, loc_t *loc, - struct iatt *stbuf, int32_t valid) + struct iatt *stbuf, int32_t valid, dict_t *xdata) { - uint64_t ia_time = 0; - char actime_str[256] = {0,}; - char modtime_str[256] = {0,}; + uint64_t ia_time = 0; + char actime_str[256] = {0,}; + char modtime_str[256] = {0,}; + trace_conf_t *conf = NULL; + + conf = this->private; + if (!conf->log_file && !conf->log_history) + goto out; if (trace_fop_names[GF_FOP_SETATTR].enabled) { + char string[4096] = {0,}; if (valid & GF_SET_ATTR_MODE) { - gf_log (this->name, GF_LOG_INFO, - "%"PRId64": gfid=%s path=%s mode=%o)", - frame->root->unique, uuid_utoa (loc->inode->gfid), - loc->path, st_mode_from_ia (stbuf->ia_prot, stbuf->ia_type)); + snprintf (string, sizeof (string), + "%"PRId64": gfid=%s path=%s mode=%o)", + frame->root->unique, + uuid_utoa (loc->inode->gfid), + loc->path, + st_mode_from_ia (stbuf->ia_prot, + stbuf->ia_type)); + + LOG_ELEMENT (conf, string); + memset (string, 0 , sizeof (string)); } if (valid & (GF_SET_ATTR_UID | GF_SET_ATTR_GID)) { - gf_log (this->name, GF_LOG_INFO, - "%"PRId64": gfid=%s path=%s uid=%o, gid=%o", - frame->root->unique, uuid_utoa (loc->inode->gfid), - loc->path, stbuf->ia_uid, stbuf->ia_gid); + snprintf (string, sizeof (string), + "%"PRId64": gfid=%s path=%s uid=%o," + " gid=%o", frame->root->unique, + uuid_utoa (loc->inode->gfid), + loc->path, stbuf->ia_uid, + stbuf->ia_gid); + + LOG_ELEMENT (conf, string); + memset (string, 0 , sizeof (string)); } if (valid & (GF_SET_ATTR_ATIME | GF_SET_ATTR_MTIME)) { @@ -1685,44 +2039,64 @@ trace_setattr (call_frame_t *frame, xlator_t *this, loc_t *loc, strftime (modtime_str, 256, "[%b %d %H:%M:%S]", localtime ((time_t *)&ia_time)); - gf_log (this->name, GF_LOG_INFO, - "%"PRId64": gfid=%s path=%s ia_atime=%s, ia_mtime=%s", - frame->root->unique, uuid_utoa (loc->inode->gfid), - loc->path, actime_str, modtime_str); + snprintf (string, sizeof (string), + "%"PRId64": gfid=%s path=%s " + "ia_atime=%s, ia_mtime=%s", + frame->root->unique, + uuid_utoa (loc->inode->gfid), + loc->path, actime_str, modtime_str); + + LOG_ELEMENT (conf, string); + memset (string, 0 , sizeof (string)); } frame->local = loc->inode->gfid; } +out: STACK_WIND (frame, trace_setattr_cbk, FIRST_CHILD(this), FIRST_CHILD(this)->fops->setattr, - loc, stbuf, valid); + loc, stbuf, valid, xdata); return 0; } - int trace_fsetattr (call_frame_t *frame, xlator_t *this, fd_t *fd, - struct iatt *stbuf, int32_t valid) + struct iatt *stbuf, int32_t valid, dict_t *xdata) { - uint64_t ia_time = 0; - char actime_str[256] = {0,}; - char modtime_str[256] = {0,}; + uint64_t ia_time = 0; + char actime_str[256] = {0,}; + char modtime_str[256] = {0,}; + trace_conf_t *conf = NULL; + conf = this->private; + + if (!conf->log_file && !conf->log_history) + goto out; if (trace_fop_names[GF_FOP_FSETATTR].enabled) { + char string[4096] = {0,}; if (valid & GF_SET_ATTR_MODE) { - gf_log (this->name, GF_LOG_INFO, - "%"PRId64": gfid=%s fd=%p, mode=%o", - frame->root->unique, uuid_utoa (fd->inode->gfid), fd, - st_mode_from_ia (stbuf->ia_prot, stbuf->ia_type)); + snprintf (string, sizeof (string), + "%"PRId64": gfid=%s fd=%p, mode=%o", + frame->root->unique, + uuid_utoa (fd->inode->gfid), fd, + st_mode_from_ia (stbuf->ia_prot, + stbuf->ia_type)); + + LOG_ELEMENT (conf, string); + memset (string, 0, sizeof (string)); } if (valid & (GF_SET_ATTR_UID | GF_SET_ATTR_GID)) { - gf_log (this->name, GF_LOG_INFO, - "%"PRId64": gfid=%s fd=%p, uid=%o, gid=%o", - frame->root->unique, uuid_utoa (fd->inode->gfid), - fd, stbuf->ia_uid, stbuf->ia_gid); + snprintf (string, sizeof (string), + "%"PRId64": gfid=%s fd=%p, uid=%o, " + "gid=%o", frame->root->unique, + uuid_utoa (fd->inode->gfid), + fd, stbuf->ia_uid, stbuf->ia_gid); + + LOG_ELEMENT (conf, string); + memset (string, 0, sizeof (string)); } if (valid & (GF_SET_ATTR_ATIME | GF_SET_ATTR_MTIME)) { @@ -1734,256 +2108,394 @@ trace_fsetattr (call_frame_t *frame, xlator_t *this, fd_t *fd, strftime (modtime_str, 256, "[%b %d %H:%M:%S]", localtime ((time_t *)&ia_time)); - gf_log (this->name, GF_LOG_INFO, - "%"PRId64": gfid=%s fd=%p ia_atime=%s, ia_mtime=%s", - frame->root->unique, uuid_utoa (fd->inode->gfid), - fd, actime_str, modtime_str); + snprintf (string, sizeof (string), + "%"PRId64": gfid=%s fd=%p " + "ia_atime=%s, ia_mtime=%s", + frame->root->unique, + uuid_utoa (fd->inode->gfid), + fd, actime_str, modtime_str); + + LOG_ELEMENT (conf, string); + memset (string, 0, sizeof (string)); } frame->local = fd->inode->gfid; } +out: STACK_WIND (frame, trace_fsetattr_cbk, FIRST_CHILD(this), FIRST_CHILD(this)->fops->fsetattr, - fd, stbuf, valid); + fd, stbuf, valid, xdata); return 0; } - int trace_truncate (call_frame_t *frame, xlator_t *this, loc_t *loc, - off_t offset) + off_t offset, dict_t *xdata) { + trace_conf_t *conf = NULL; + + conf = this->private; + + if (!conf->log_file && !conf->log_history) + goto out; if (trace_fop_names[GF_FOP_TRUNCATE].enabled) { - gf_log (this->name, GF_LOG_INFO, - "%"PRId64": gfid=%s path=%s, offset=%"PRId64"", - frame->root->unique, uuid_utoa (loc->inode->gfid), - loc->path, offset); + char string[4096] = {0,}; + snprintf (string, sizeof (string), + "%"PRId64": gfid=%s path=%s, " + "offset=%"PRId64"", frame->root->unique, + uuid_utoa (loc->inode->gfid), loc->path, + offset); + frame->local = loc->inode->gfid; + + LOG_ELEMENT (conf, string); } +out: STACK_WIND (frame, trace_truncate_cbk, FIRST_CHILD(this), FIRST_CHILD(this)->fops->truncate, - loc, offset); + loc, offset, xdata); return 0; } - int trace_open (call_frame_t *frame, xlator_t *this, loc_t *loc, - int32_t flags, fd_t *fd, int32_t wbflags) + int32_t flags, fd_t *fd, dict_t *xdata) { + trace_conf_t *conf = NULL; + + conf = this->private; + + if (!conf->log_file && !conf->log_history) + goto out; if (trace_fop_names[GF_FOP_OPEN].enabled) { - gf_log (this->name, GF_LOG_INFO, - "%"PRId64": gfid=%s path=%s flags=%d fd=%p wbflags=%d", - frame->root->unique, uuid_utoa (loc->inode->gfid), - loc->path, flags, fd, wbflags); + char string[4096] = {0,}; + snprintf (string, sizeof (string), + "%"PRId64": gfid=%s path=%s flags=%d fd=%p", + frame->root->unique, + uuid_utoa (loc->inode->gfid), loc->path, + flags, fd); + frame->local = loc->inode->gfid; + + LOG_ELEMENT (conf, string); } +out: STACK_WIND (frame, trace_open_cbk, FIRST_CHILD(this), FIRST_CHILD(this)->fops->open, - loc, flags, fd, wbflags); + loc, flags, fd, xdata); return 0; } - int trace_create (call_frame_t *frame, xlator_t *this, loc_t *loc, - int32_t flags, mode_t mode, fd_t *fd, dict_t *params) + int32_t flags, mode_t mode, mode_t umask, fd_t *fd, + dict_t *xdata) { + trace_conf_t *conf = NULL; + + conf = this->private; + + if (!conf->log_file && !conf->log_history) + goto out; if (trace_fop_names[GF_FOP_CREATE].enabled) { - gf_log (this->name, GF_LOG_INFO, - "%"PRId64": gfid=%s path=%s, fd=%p, flags=0%o mode=0%o", - frame->root->unique, uuid_utoa (loc->inode->gfid), - loc->path, fd, flags, mode); + char string[4096] = {0,}; + snprintf (string, sizeof (string), + "%"PRId64": gfid=%s path=%s, fd=%p, " + "flags=0%o mode=0%o umask=0%o", + frame->root->unique, + uuid_utoa (loc->inode->gfid), loc->path, + fd, flags, mode, umask); + + LOG_ELEMENT (conf, string); } +out: STACK_WIND (frame, trace_create_cbk, FIRST_CHILD(this), FIRST_CHILD(this)->fops->create, - loc, flags, mode, fd, params); + loc, flags, mode, umask, fd, xdata); return 0; } - int trace_readv (call_frame_t *frame, xlator_t *this, fd_t *fd, - size_t size, off_t offset, uint32_t flags) + size_t size, off_t offset, uint32_t flags, dict_t *xdata) { + trace_conf_t *conf = NULL; + + conf = this->private; + + if (!conf->log_file && !conf->log_history) + goto out; if (trace_fop_names[GF_FOP_READ].enabled) { - gf_log (this->name, GF_LOG_INFO, - "%"PRId64": gfid=%s fd=%p, size=%"GF_PRI_SIZET", " - "offset=%"PRId64" flags=0%x)", - frame->root->unique, uuid_utoa (fd->inode->gfid), - fd, size, offset, flags); + char string[4096] = {0,}; + snprintf (string, sizeof (string), + "%"PRId64": gfid=%s fd=%p, size=%" + GF_PRI_SIZET"offset=%"PRId64" flags=0%x)", + frame->root->unique, + uuid_utoa (fd->inode->gfid), fd, size, + offset, flags); + frame->local = fd->inode->gfid; + + LOG_ELEMENT (conf, string); } +out: STACK_WIND (frame, trace_readv_cbk, FIRST_CHILD(this), FIRST_CHILD(this)->fops->readv, - fd, size, offset, flags); + fd, size, offset, flags, xdata); return 0; } - int trace_writev (call_frame_t *frame, xlator_t *this, fd_t *fd, struct iovec *vector, int32_t count, - off_t offset, uint32_t flags, struct iobref *iobref) + off_t offset, uint32_t flags, struct iobref *iobref, dict_t *xdata) { + trace_conf_t *conf = NULL; + + conf = this->private; + + if (!conf->log_file && !conf->log_history) + goto out; if (trace_fop_names[GF_FOP_WRITE].enabled) { - gf_log (this->name, GF_LOG_INFO, - "%"PRId64": gfid=%s fd=%p, count=%d, offset=%"PRId64 - " flag=0%x)", - frame->root->unique, uuid_utoa (fd->inode->gfid), - fd, count, offset, flags); + char string[4096] = {0,}; + snprintf (string, sizeof (string), + "%"PRId64": gfid=%s fd=%p, count=%d, " + " offset=%"PRId64" flags=0%x)", + frame->root->unique, + uuid_utoa (fd->inode->gfid), fd, count, + offset, flags); + frame->local = fd->inode->gfid; + + LOG_ELEMENT (conf, string); } +out: STACK_WIND (frame, trace_writev_cbk, FIRST_CHILD(this), FIRST_CHILD(this)->fops->writev, - fd, vector, count, offset, flags, iobref); + fd, vector, count, offset, flags, iobref, xdata); return 0; } - int -trace_statfs (call_frame_t *frame, xlator_t *this, loc_t *loc) +trace_statfs (call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *xdata) { + trace_conf_t *conf = NULL; + + conf = this->private; + + if (!conf->log_file && !conf->log_history) + goto out; if (trace_fop_names[GF_FOP_STATFS].enabled) { - gf_log (this->name, GF_LOG_INFO, - "%"PRId64": gfid=%s path=%s", - frame->root->unique, (loc->inode)? - uuid_utoa (loc->inode->gfid):"0", loc->path); + char string[4096] = {0,}; + snprintf (string, sizeof (string), + "%"PRId64": gfid=%s path=%s", + frame->root->unique, (loc->inode)? + uuid_utoa (loc->inode->gfid):"0", loc->path); + + LOG_ELEMENT (conf, string); } +out: STACK_WIND (frame, trace_statfs_cbk, FIRST_CHILD(this), FIRST_CHILD(this)->fops->statfs, - loc); + loc, xdata); return 0; } - int -trace_flush (call_frame_t *frame, xlator_t *this, fd_t *fd) +trace_flush (call_frame_t *frame, xlator_t *this, fd_t *fd, dict_t *xdata) { + trace_conf_t *conf = NULL; + + conf = this->private; + + if (!conf->log_file && !conf->log_history) + goto out; if (trace_fop_names[GF_FOP_FLUSH].enabled) { - gf_log (this->name, GF_LOG_INFO, - "%"PRId64": gfid=%s fd=%p", - frame->root->unique, uuid_utoa (fd->inode->gfid), fd); + char string[4096] = {0,}; + snprintf (string, sizeof (string), + "%"PRId64": gfid=%s fd=%p", + frame->root->unique, + uuid_utoa (fd->inode->gfid), fd); + frame->local = fd->inode->gfid; + + LOG_ELEMENT (conf, string); } +out: STACK_WIND (frame, trace_flush_cbk, FIRST_CHILD(this), FIRST_CHILD(this)->fops->flush, - fd); + fd, xdata); return 0; } - int -trace_fsync (call_frame_t *frame, xlator_t *this, fd_t *fd, int32_t flags) +trace_fsync (call_frame_t *frame, xlator_t *this, fd_t *fd, int32_t flags, + dict_t *xdata) { + trace_conf_t *conf = NULL; + + conf = this->private; + + if (!conf->log_file && !conf->log_history) + goto out; if (trace_fop_names[GF_FOP_FSYNC].enabled) { - gf_log (this->name, GF_LOG_INFO, - "%"PRId64": gfid=%s flags=%d fd=%p", - frame->root->unique, uuid_utoa (fd->inode->gfid), flags, fd); + char string[4096] = {0,}; + snprintf (string, sizeof (string), + "%"PRId64": gfid=%s flags=%d fd=%p", + frame->root->unique, + uuid_utoa (fd->inode->gfid), flags, fd); + frame->local = fd->inode->gfid; + + LOG_ELEMENT (conf, string); } +out: STACK_WIND (frame, trace_fsync_cbk, FIRST_CHILD(this), FIRST_CHILD(this)->fops->fsync, - fd, flags); + fd, flags, xdata); return 0; } - int trace_setxattr (call_frame_t *frame, xlator_t *this, - loc_t *loc, dict_t *dict, int32_t flags) + loc_t *loc, dict_t *dict, int32_t flags, dict_t *xdata) { + trace_conf_t *conf = NULL; + + conf = this->private; + + if (!conf->log_file && !conf->log_history) + goto out; if (trace_fop_names[GF_FOP_SETXATTR].enabled) { - gf_log (this->name, GF_LOG_INFO, - "%"PRId64": gfid=%s path=%s flags=%d", - frame->root->unique, uuid_utoa (loc->inode->gfid), - loc->path, flags); + char string[4096] = {0,}; + snprintf (string, sizeof (string), + "%"PRId64": gfid=%s path=%s flags=%d", + frame->root->unique, + uuid_utoa (loc->inode->gfid), loc->path, + flags); + frame->local = loc->inode->gfid; + + LOG_ELEMENT (conf, string); } +out: STACK_WIND (frame, trace_setxattr_cbk, FIRST_CHILD(this), FIRST_CHILD(this)->fops->setxattr, - loc, dict, flags); + loc, dict, flags, xdata); return 0; } - int trace_getxattr (call_frame_t *frame, xlator_t *this, - loc_t *loc, const char *name) + loc_t *loc, const char *name, dict_t *xdata) { + trace_conf_t *conf = NULL; + + conf = this->private; + + if (!conf->log_file && !conf->log_history) + goto out; if (trace_fop_names[GF_FOP_GETXATTR].enabled) { - gf_log (this->name, GF_LOG_INFO, - "%"PRId64": gfid=%s path=%s name=%s", - frame->root->unique, uuid_utoa (loc->inode->gfid), - loc->path, name); + char string[4096] = {0,}; + snprintf (string, sizeof (string), + "%"PRId64": gfid=%s path=%s name=%s", + frame->root->unique, + uuid_utoa (loc->inode->gfid), loc->path, + name); + frame->local = loc->inode->gfid; + + LOG_ELEMENT (conf, string); } +out: STACK_WIND (frame, trace_getxattr_cbk, FIRST_CHILD(this), FIRST_CHILD(this)->fops->getxattr, - loc, name); + loc, name, xdata); return 0; } - int trace_removexattr (call_frame_t *frame, xlator_t *this, - loc_t *loc, const char *name) + loc_t *loc, const char *name, dict_t *xdata) { + trace_conf_t *conf = NULL; + + conf = this->private; + + if (!conf->log_file && !conf->log_history) + goto out; if (trace_fop_names[GF_FOP_REMOVEXATTR].enabled) { - gf_log (this->name, GF_LOG_INFO, - "%"PRId64": gfid=%s path=%s name=%s", - frame->root->unique, uuid_utoa (loc->inode->gfid), - loc->path, name); + char string[4096] = {0,}; + snprintf (string, sizeof (string), + "%"PRId64": gfid=%s path=%s name=%s", + frame->root->unique, + uuid_utoa (loc->inode->gfid), loc->path, + name); + frame->local = loc->inode->gfid; + + LOG_ELEMENT (conf, string); } +out: STACK_WIND (frame, trace_removexattr_cbk, FIRST_CHILD(this), FIRST_CHILD(this)->fops->removexattr, - loc, name); + loc, name, xdata); return 0; } - int -trace_opendir (call_frame_t *frame, xlator_t *this, loc_t *loc, fd_t *fd) +trace_opendir (call_frame_t *frame, xlator_t *this, loc_t *loc, fd_t *fd, + dict_t *xdata) { + trace_conf_t *conf = NULL; + + conf = this->private; + + if (!conf->log_file && !conf->log_history) + goto out; if (trace_fop_names[GF_FOP_OPENDIR].enabled) { - gf_log (this->name, GF_LOG_INFO, - "%"PRId64": gfid=%s path=%s fd=%p", - frame->root->unique, uuid_utoa (loc->inode->gfid), - loc->path, fd); + char string[4096] = {0,}; + snprintf (string, sizeof (string), + "%"PRId64": gfid=%s path=%s fd=%p", + frame->root->unique, + uuid_utoa (loc->inode->gfid), loc->path, fd); + frame->local = loc->inode->gfid; + + LOG_ELEMENT (conf, string); } +out: STACK_WIND (frame, trace_opendir_cbk, FIRST_CHILD(this), FIRST_CHILD(this)->fops->opendir, - loc, fd); + loc, fd, xdata); return 0; } @@ -1991,15 +2503,27 @@ int trace_readdirp (call_frame_t *frame, xlator_t *this, fd_t *fd, size_t size, off_t offset, dict_t *dict) { + trace_conf_t *conf = NULL; + + conf = this->private; + + if (!conf->log_file && !conf->log_history) + goto out; if (trace_fop_names[GF_FOP_READDIRP].enabled) { - gf_log (this->name, GF_LOG_INFO, - "%"PRId64": gfid=%s fd=%p, size=%"GF_PRI_SIZET", " - "offset=%"PRId64" dict=%p", - frame->root->unique, uuid_utoa (fd->inode->gfid), - fd, size, offset, dict); + char string[4096] = {0,}; + snprintf (string, sizeof (string), + "%"PRId64": gfid=%s fd=%p, size=%"GF_PRI_SIZET + ", offset=%"PRId64" dict=%p", + frame->root->unique, + uuid_utoa (fd->inode->gfid), fd, size, + offset, dict); + frame->local = fd->inode->gfid; + + LOG_ELEMENT (conf, string); } +out: STACK_WIND (frame, trace_readdirp_cbk, FIRST_CHILD(this), FIRST_CHILD(this)->fops->readdirp, @@ -2008,83 +2532,128 @@ trace_readdirp (call_frame_t *frame, xlator_t *this, fd_t *fd, size_t size, return 0; } - int trace_readdir (call_frame_t *frame, xlator_t *this, fd_t *fd, - size_t size, off_t offset) + size_t size, off_t offset, dict_t *xdata) { + trace_conf_t *conf = NULL; + + conf = this->private; + + if (!conf->log_file && !conf->log_history) + goto out; if (trace_fop_names[GF_FOP_READDIR].enabled) { - gf_log (this->name, GF_LOG_INFO, - "%"PRId64": gfid=%s fd=%p, size=%"GF_PRI_SIZET", offset=%"PRId64, - frame->root->unique, uuid_utoa (fd->inode->gfid), - fd, size, offset); + char string[4096] = {0,}; + snprintf (string, sizeof (string), + "%"PRId64": gfid=%s fd=%p, size=%"GF_PRI_SIZET + ", offset=%"PRId64, + frame->root->unique, + uuid_utoa (fd->inode->gfid), fd, size, + offset); + frame->local = fd->inode->gfid; + + LOG_ELEMENT (conf, string); } +out: STACK_WIND (frame, trace_readdir_cbk, FIRST_CHILD(this), FIRST_CHILD(this)->fops->readdir, - fd, size, offset); + fd, size, offset, xdata); return 0; } - int trace_fsyncdir (call_frame_t *frame, xlator_t *this, - fd_t *fd, int32_t datasync) + fd_t *fd, int32_t datasync, dict_t *xdata) { + trace_conf_t *conf = NULL; + + conf = this->private; + + if (!conf->log_file && !conf->log_history) + goto out; if (trace_fop_names[GF_FOP_FSYNCDIR].enabled) { - gf_log (this->name, GF_LOG_INFO, - "%"PRId64": gfid=%s datasync=%d fd=%p", - frame->root->unique, uuid_utoa (fd->inode->gfid), - datasync, fd); + char string[4096] = {0,}; + snprintf (string, sizeof (string), + "%"PRId64": gfid=%s datasync=%d fd=%p", + frame->root->unique, + uuid_utoa (fd->inode->gfid), datasync, fd); + frame->local = fd->inode->gfid; + + LOG_ELEMENT (conf, string); } +out: STACK_WIND (frame, trace_fsyncdir_cbk, FIRST_CHILD(this), FIRST_CHILD(this)->fops->fsyncdir, - fd, datasync); + fd, datasync, xdata); return 0; } - int -trace_access (call_frame_t *frame, xlator_t *this, loc_t *loc, int32_t mask) +trace_access (call_frame_t *frame, xlator_t *this, loc_t *loc, int32_t mask, + dict_t *xdata) { + trace_conf_t *conf = NULL; + + conf = this->private; + + if (!conf->log_file && !conf->log_history) + goto out; if (trace_fop_names[GF_FOP_ACCESS].enabled) { - gf_log (this->name, GF_LOG_INFO, - "%"PRId64": gfid=%s path=%s mask=0%o", - frame->root->unique, uuid_utoa (loc->inode->gfid), - loc->path, mask); + char string[4096] = {0,}; + snprintf (string, sizeof (string), + "%"PRId64": gfid=%s path=%s mask=0%o", + frame->root->unique, + uuid_utoa (loc->inode->gfid), + loc->path, mask); + frame->local = loc->inode->gfid; + + LOG_ELEMENT (conf, string); } +out: STACK_WIND (frame, trace_access_cbk, FIRST_CHILD(this), FIRST_CHILD(this)->fops->access, - loc, mask); + loc, mask, xdata); return 0; } - int32_t trace_rchecksum (call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset, - int32_t len) + int32_t len, dict_t *xdata) { + + trace_conf_t *conf = NULL; + + conf = this->private; + + if (!conf->log_file && !conf->log_history) + goto out; if (trace_fop_names[GF_FOP_RCHECKSUM].enabled) { - gf_log (this->name, GF_LOG_INFO, - "%"PRId64": gfid=%s offset=%"PRId64" len=%u fd=%p", - frame->root->unique, uuid_utoa (fd->inode->gfid), - offset, len, fd); + char string[4096] = {0,}; + snprintf (string, sizeof (string), + "%"PRId64": gfid=%s offset=%"PRId64 + "len=%u fd=%p", frame->root->unique, + uuid_utoa (fd->inode->gfid), offset, len, fd); + frame->local = fd->inode->gfid; + + LOG_ELEMENT (conf, string); } +out: STACK_WIND (frame, trace_rchecksum_cbk, FIRST_CHILD(this), FIRST_CHILD(this)->fops->rchecksum, - fd, offset, len); + fd, offset, len, xdata); return 0; @@ -2093,162 +2662,264 @@ trace_rchecksum (call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset, int32_t trace_fentrylk (call_frame_t *frame, xlator_t *this, const char *volume, fd_t *fd, const char *basename, entrylk_cmd cmd, - entrylk_type type) + entrylk_type type, dict_t *xdata) { + trace_conf_t *conf = NULL; + + conf = this->private; + + if (!conf->log_file && !conf->log_history) + goto out; if (trace_fop_names[GF_FOP_FENTRYLK].enabled) { - gf_log (this->name, GF_LOG_INFO, - "%"PRId64": gfid=%s volume=%s, (fd=%p basename=%s, " - "cmd=%s, type=%s)", - frame->root->unique, uuid_utoa (fd->inode->gfid), - volume, fd, basename, - ((cmd == ENTRYLK_LOCK) ? "ENTRYLK_LOCK" : "ENTRYLK_UNLOCK"), - ((type == ENTRYLK_RDLCK) ? "ENTRYLK_RDLCK" : "ENTRYLK_WRLCK")); + char string[4096] = {0,}; + snprintf (string, sizeof (string), + "%"PRId64": gfid=%s volume=%s, (fd=%p " + "basename=%s, cmd=%s, type=%s)", + frame->root->unique, + uuid_utoa (fd->inode->gfid), volume, fd, + basename, + ((cmd == ENTRYLK_LOCK) ? "ENTRYLK_LOCK" : + "ENTRYLK_UNLOCK"), + ((type == ENTRYLK_RDLCK) ? "ENTRYLK_RDLCK" : + "ENTRYLK_WRLCK")); + frame->local = fd->inode->gfid; + + LOG_ELEMENT (conf, string); } +out: STACK_WIND (frame, trace_fentrylk_cbk, FIRST_CHILD (this), FIRST_CHILD (this)->fops->fentrylk, - volume, fd, basename, cmd, type); + volume, fd, basename, cmd, type, xdata); return 0; } int32_t trace_fgetxattr (call_frame_t *frame, xlator_t *this, fd_t *fd, - const char *name) + const char *name, dict_t *xdata) { + trace_conf_t *conf = NULL; + + conf = this->private; + + if (!conf->log_file && !conf->log_history) + goto out; if (trace_fop_names[GF_FOP_FGETXATTR].enabled) { - gf_log (this->name, GF_LOG_INFO, - "%"PRId64": gfid=%s fd=%p name=%s", - frame->root->unique, uuid_utoa (fd->inode->gfid), - fd, name); + char string[4096] = {0,}; + snprintf (string, sizeof (string), + "%"PRId64": gfid=%s fd=%p name=%s", + frame->root->unique, + uuid_utoa (fd->inode->gfid), fd, name); + frame->local = fd->inode->gfid; + + LOG_ELEMENT (conf, string); } +out: STACK_WIND (frame, trace_fgetxattr_cbk, FIRST_CHILD(this), FIRST_CHILD(this)->fops->fgetxattr, - fd, name); + fd, name, xdata); return 0; } int32_t trace_fsetxattr (call_frame_t *frame, xlator_t *this, fd_t *fd, - dict_t *dict, int32_t flags) + dict_t *dict, int32_t flags, dict_t *xdata) { + trace_conf_t *conf = NULL; + + conf = this->private; + + if (!conf->log_file && !conf->log_history) + goto out; if (trace_fop_names[GF_FOP_FSETXATTR].enabled) { - gf_log (this->name, GF_LOG_INFO, - "%"PRId64": gfid=%s fd=%p flags=%d", - frame->root->unique, uuid_utoa (fd->inode->gfid), - fd, flags); + char string[4096] = {0,}; + snprintf (string, sizeof (string), + "%"PRId64": gfid=%s fd=%p flags=%d", + frame->root->unique, + uuid_utoa (fd->inode->gfid), fd, flags); + frame->local = fd->inode->gfid; + + LOG_ELEMENT (conf, string); } +out: STACK_WIND (frame, trace_fsetxattr_cbk, FIRST_CHILD(this), FIRST_CHILD(this)->fops->fsetxattr, - fd, dict, flags); + fd, dict, flags, xdata); return 0; } int trace_ftruncate (call_frame_t *frame, xlator_t *this, - fd_t *fd, off_t offset) + fd_t *fd, off_t offset, dict_t *xdata) { + trace_conf_t *conf = NULL; + + conf = this->private; + + if (!conf->log_file && !conf->log_history) + goto out; if (trace_fop_names[GF_FOP_FTRUNCATE].enabled) { - gf_log (this->name, GF_LOG_INFO, - "%"PRId64": gfid=%s offset=%"PRId64" fd=%p", - frame->root->unique, uuid_utoa (fd->inode->gfid), - offset, fd); + char string[4096] = {0,}; + snprintf (string, sizeof (string), + "%"PRId64": gfid=%s offset=%"PRId64" fd=%p", + frame->root->unique, + uuid_utoa (fd->inode->gfid), offset, fd); + frame->local = fd->inode->gfid; + + LOG_ELEMENT (conf, string); } +out: STACK_WIND (frame, trace_ftruncate_cbk, FIRST_CHILD(this), FIRST_CHILD(this)->fops->ftruncate, - fd, offset); + fd, offset, xdata); return 0; } - int -trace_fstat (call_frame_t *frame, xlator_t *this, fd_t *fd) +trace_fstat (call_frame_t *frame, xlator_t *this, fd_t *fd, dict_t *xdata) { + trace_conf_t *conf = NULL; + + conf = this->private; + + if (!conf->log_file && !conf->log_history) + goto out; if (trace_fop_names[GF_FOP_FSTAT].enabled) { - gf_log (this->name, GF_LOG_INFO, - "%"PRId64": gfid=%s fd=%p", - frame->root->unique, uuid_utoa (fd->inode->gfid), fd); + char string[4096] = {0,}; + snprintf (string, sizeof (string), + "%"PRId64": gfid=%s fd=%p", + frame->root->unique, + uuid_utoa (fd->inode->gfid), fd); + frame->local = fd->inode->gfid; + + LOG_ELEMENT (conf, string); } +out: STACK_WIND (frame, trace_fstat_cbk, FIRST_CHILD(this), FIRST_CHILD(this)->fops->fstat, - fd); + fd, xdata); return 0; } - int trace_lk (call_frame_t *frame, xlator_t *this, fd_t *fd, - int32_t cmd, struct gf_flock *lock) + int32_t cmd, struct gf_flock *lock, dict_t *xdata) { + trace_conf_t *conf = NULL; + + conf = this->private; + + if (!conf->log_file && !conf->log_history) + goto out; if (trace_fop_names[GF_FOP_LK].enabled) { - gf_log (this->name, GF_LOG_INFO, - "%"PRId64": gfid=%s fd=%p, cmd=%d, lock {l_type=%d, l_whence=%d, " - "l_start=%"PRId64", l_len=%"PRId64", l_pid=%u})", - frame->root->unique, uuid_utoa (fd->inode->gfid), fd, - cmd, lock->l_type, lock->l_whence, - lock->l_start, lock->l_len, lock->l_pid); + char string[4096] = {0,}; + snprintf (string, sizeof (string), + "%"PRId64": gfid=%s fd=%p, cmd=%d, " + "lock {l_type=%d, " + "l_whence=%d, l_start=%"PRId64", " + "l_len=%"PRId64", l_pid=%u})", + frame->root->unique, + uuid_utoa (fd->inode->gfid), fd, cmd, + lock->l_type, lock->l_whence, + lock->l_start, lock->l_len, lock->l_pid); + frame->local = fd->inode->gfid; + + LOG_ELEMENT (conf, string); } +out: STACK_WIND (frame, trace_lk_cbk, FIRST_CHILD(this), FIRST_CHILD(this)->fops->lk, - fd, cmd, lock); + fd, cmd, lock, xdata); return 0; } int32_t trace_forget (xlator_t *this, inode_t *inode) { + trace_conf_t *conf = NULL; + + conf = this->private; /* If user want to understand when a lookup happens, he should know about 'forget' too */ + if (!conf->log_file && !conf->log_history) + goto out; if (trace_fop_names[GF_FOP_LOOKUP].enabled) { - gf_log (this->name, GF_LOG_INFO, - "gfid=%s", uuid_utoa (inode->gfid)); + char string[4096] = {0,}; + snprintf (string, sizeof (string), + "gfid=%s", uuid_utoa (inode->gfid)); + + LOG_ELEMENT (conf, string); } + +out: return 0; } - int32_t trace_releasedir (xlator_t *this, fd_t *fd) { + trace_conf_t *conf = NULL; + + conf = this->private; + + if (!conf->log_file && !conf->log_history) + goto out; if (trace_fop_names[GF_FOP_OPENDIR].enabled) { - gf_log (this->name, GF_LOG_INFO, - "gfid=%s fd=%p", uuid_utoa (fd->inode->gfid), fd); + char string[4096] = {0,}; + snprintf (string, sizeof (string), + "gfid=%s fd=%p", + uuid_utoa (fd->inode->gfid), fd); + + LOG_ELEMENT (conf, string); } +out: return 0; } int32_t trace_release (xlator_t *this, fd_t *fd) { + trace_conf_t *conf = NULL; + + conf = this->private; + + if (!conf->log_file && !conf->log_history) + goto out; if (trace_fop_names[GF_FOP_OPEN].enabled || trace_fop_names[GF_FOP_CREATE].enabled) { - gf_log (this->name, GF_LOG_INFO, - "gfid=%s fd=%p", uuid_utoa (fd->inode->gfid), fd); + char string[4096] = {0,}; + snprintf (string, sizeof (string), + "gfid=%s fd=%p", + uuid_utoa (fd->inode->gfid), fd); + + LOG_ELEMENT (conf, string); } + +out: return 0; } - void enable_all_calls (int enabled) { @@ -2258,7 +2929,6 @@ enable_all_calls (int enabled) trace_fop_names[i].enabled = enabled; } - void enable_call (const char *name, int enabled) { @@ -2286,6 +2956,105 @@ process_call_list (const char *list, int include) } } +int32_t +trace_dump_history (xlator_t *this) +{ + int ret = -1; + char key_prefix[GF_DUMP_MAX_BUF_LEN] = {0,}; + trace_conf_t *conf = NULL; + + GF_VALIDATE_OR_GOTO ("trace", this, out); + GF_VALIDATE_OR_GOTO (this->name, this->history, out); + + conf = this->private; + // Is it ok to return silently if log-history option his off? + if (conf && conf->log_history == _gf_true) { + gf_proc_dump_build_key (key_prefix, "xlator.debug.trace", + "history"); + gf_proc_dump_add_section (key_prefix); + eh_dump (this->history, NULL, dump_history_trace); + } + ret = 0; + +out: + return ret; +} + +int32_t +mem_acct_init (xlator_t *this) +{ + int ret = -1; + + if (!this) + return ret; + + ret = xlator_mem_acct_init (this, gf_trace_mt_end + 1); + + if (ret != 0) { + gf_log (this->name, GF_LOG_ERROR, "Memory accounting init" + " failed"); + return ret; + } + + return ret; +} + +int +reconfigure (xlator_t *this, dict_t *options) +{ + int32_t ret = -1; + trace_conf_t *conf = NULL; + char *includes = NULL, *excludes = NULL; + + GF_VALIDATE_OR_GOTO ("quick-read", this, out); + GF_VALIDATE_OR_GOTO (this->name, this->private, out); + GF_VALIDATE_OR_GOTO (this->name, options, out); + + conf = this->private; + + 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++) { + if (gf_fop_list[i]) + strncpy (trace_fop_names[i].name, + gf_fop_list[i], + strlen (gf_fop_list[i])); + else + strncpy (trace_fop_names[i].name, ":O", + strlen (":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'"); + goto out; + } + + if (includes) + process_call_list (includes, 1); + if (excludes) + process_call_list (excludes, 0); + + /* Should resizing of the event-history be allowed in reconfigure? + * for which a new event_history might have to be allocated and the + * older history has to be freed. + */ + GF_OPTION_RECONF ("log-file", conf->log_file, options, bool, out); + + GF_OPTION_RECONF ("log-history", conf->log_history, options, bool, out); + + ret = 0; + +out: + return ret; +} int32_t init (xlator_t *this) @@ -2293,6 +3062,10 @@ init (xlator_t *this) dict_t *options = NULL; char *includes = NULL, *excludes = NULL; char *forced_loglevel = NULL; + eh_t *history = NULL; + int ret = -1; + size_t history_size = TRACE_DEFAULT_HISTORY_SIZE; + trace_conf_t *conf = NULL; if (!this) return -1; @@ -2307,6 +3080,12 @@ init (xlator_t *this) "dangling volume. check volfile "); } + conf = GF_CALLOC (1, sizeof (trace_conf_t), gf_trace_mt_trace_conf_t); + if (!conf) { + gf_log (this->name, GF_LOG_ERROR, "cannot allocate " + "xl->private"); + return -1; + } options = this->options; includes = data_to_str (dict_get (options, "include-ops")); @@ -2315,8 +3094,13 @@ init (xlator_t *this) { int i; for (i = 0; i < GF_FOP_MAXVALUE; i++) { - trace_fop_names[i].name = (gf_fop_list[i] ? - gf_fop_list[i] : ":O"); + if (gf_fop_list[i]) + strncpy (trace_fop_names[i].name, + gf_fop_list[i], + strlen (gf_fop_list[i])); + else + strncpy (trace_fop_names[i].name, ":O", + strlen (":O")); trace_fop_names[i].enabled = 1; } } @@ -2324,14 +3108,43 @@ init (xlator_t *this) if (includes && excludes) { gf_log (this->name, GF_LOG_ERROR, - "must specify only one of 'include-ops' and 'exclude-ops'"); + "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_OPTION_INIT ("history-size", conf->history_size, size, out); + + gf_log (this->name, GF_LOG_INFO, "history size %"GF_PRI_SIZET, + history_size); + + GF_OPTION_INIT ("log-file", conf->log_file, bool, out); + + gf_log (this->name, GF_LOG_INFO, "logging to file %s", + (conf->log_file == _gf_true)?"enabled":"disabled"); + + GF_OPTION_INIT ("log-history", conf->log_history, bool, out); + + gf_log (this->name, GF_LOG_DEBUG, "logging to history %s", + (conf->log_history == _gf_true)?"enabled":"disabled"); + + history = eh_new (history_size, _gf_false, NULL); + if (!history) { + gf_log (this->name, GF_LOG_ERROR, "event history cannot be " + "initialized"); + return -1; + } + + this->history = history; + + conf->trace_log_level = GF_LOG_INFO; + if (dict_get (options, "force-log-level")) { forced_loglevel = data_to_str (dict_get (options, "force-log-level")); @@ -2339,25 +3152,34 @@ init (xlator_t *this) goto setloglevel; if (strcmp (forced_loglevel, "INFO") == 0) - trace_log_level = GF_LOG_INFO; + conf->trace_log_level = GF_LOG_INFO; else if (strcmp (forced_loglevel, "TRACE") == 0) - trace_log_level = GF_LOG_TRACE; + conf->trace_log_level = GF_LOG_TRACE; else if (strcmp (forced_loglevel, "ERROR") == 0) - trace_log_level = GF_LOG_ERROR; + conf->trace_log_level = GF_LOG_ERROR; else if (strcmp (forced_loglevel, "DEBUG") == 0) - trace_log_level = GF_LOG_DEBUG; + conf->trace_log_level = GF_LOG_DEBUG; else if (strcmp (forced_loglevel, "WARNING") == 0) - trace_log_level = GF_LOG_WARNING; + conf->trace_log_level = GF_LOG_WARNING; else if (strcmp (forced_loglevel, "CRITICAL") == 0) - trace_log_level = GF_LOG_CRITICAL; + conf->trace_log_level = GF_LOG_CRITICAL; else if (strcmp (forced_loglevel, "NONE") == 0) - trace_log_level = GF_LOG_NONE; + conf->trace_log_level = GF_LOG_NONE; } setloglevel: - gf_log_set_loglevel (trace_log_level); + gf_log_set_loglevel (conf->trace_log_level); + this->private = conf; + ret = 0; +out: + if (ret == -1) { + if (history) + GF_FREE (history); + if (conf) + GF_FREE (conf); + } - return 0; + return ret; } void @@ -2366,6 +3188,9 @@ fini (xlator_t *this) if (!this) return; + if (this->history) + eh_destroy (this->history); + gf_log (this->name, GF_LOG_INFO, "trace translator unloaded"); return; @@ -2414,7 +3239,6 @@ struct xlator_fops fops = { .fsetattr = trace_fsetattr, }; - struct xlator_cbks cbks = { .release = trace_release, .releasedir = trace_releasedir, @@ -2430,5 +3254,21 @@ struct volume_options options[] = { .type = GF_OPTION_TYPE_STR /*.value = { ""} */ }, + { .key = {"history-size"}, + .type = GF_OPTION_TYPE_SIZET, + .default_value = "1024", + }, + { .key = {"log-file"}, + .type = GF_OPTION_TYPE_BOOL, + .default_value = "no", + }, + { .key = {"log-history"}, + .type = GF_OPTION_TYPE_BOOL, + .default_value = "no", + }, { .key = {NULL} }, }; + +struct xlator_dumpops dumpops = { + .history = trace_dump_history +}; diff --git a/xlators/debug/trace/src/trace.h b/xlators/debug/trace/src/trace.h new file mode 100644 index 000000000..045eefb36 --- /dev/null +++ b/xlators/debug/trace/src/trace.h @@ -0,0 +1,98 @@ +/* + Copyright (c) 2006-2012 Red Hat, Inc. <http://www.redhat.com> + This file is part of GlusterFS. + + This file is licensed to you under your choice of the GNU Lesser + General Public License, version 3 or any later version (LGPLv3 or + later), or the GNU General Public License, version 2 (GPLv2), in all + cases as published by the Free Software Foundation. +*/ + +#ifndef _CONFIG_H +#define _CONFIG_H +#include "config.h" +#endif + +#include <time.h> +#include <errno.h> +#include "glusterfs.h" +#include "xlator.h" +#include "common-utils.h" +#include "event-history.h" +#include "logging.h" +#include "circ-buff.h" +#include "statedump.h" +#include "options.h" + +#define TRACE_DEFAULT_HISTORY_SIZE 1024 + +typedef struct { + /* Since the longest fop name is fremovexattr i.e 12 characters, array size + * is kept 24, i.e double of the maximum. + */ + char name[24]; + int enabled; +} trace_fop_name_t; + +trace_fop_name_t trace_fop_names[GF_FOP_MAXVALUE]; + +typedef struct { + gf_boolean_t log_file; + gf_boolean_t log_history; + size_t history_size; + int trace_log_level; +} trace_conf_t; + +#define TRACE_STACK_UNWIND(op, frame, params ...) \ + do { \ + frame->local = NULL; \ + STACK_UNWIND_STRICT (op, frame, params); \ + } while (0); + +#define LOG_ELEMENT(_conf, _string) \ + do { \ + if (_conf) { \ + if ((_conf->log_history) == _gf_true) \ + gf_log_eh ("%s", _string); \ + if ((_conf->log_file) == _gf_true) \ + gf_log (THIS->name, _conf->trace_log_level, \ + "%s", _string); \ + } \ + } while (0); + +#define trace_stat_to_str(buf, statstr) \ + do { \ + char atime_buf[256] = {0,}; \ + char mtime_buf[256] = {0,}; \ + char ctime_buf[256] = {0,}; \ + uint64_t ia_time = 0; \ + \ + if (!buf) \ + break; \ + \ + ia_time = buf->ia_atime; \ + strftime (atime_buf, 256, "[%b %d %H:%M:%S]", \ + localtime ((time_t *)&ia_time)); \ + \ + ia_time = buf->ia_mtime; \ + strftime (mtime_buf, 256, "[%b %d %H:%M:%S]", \ + localtime ((time_t *)&ia_time)); \ + \ + ia_time = buf->ia_ctime; \ + strftime (ctime_buf, 256, "[%b %d %H:%M:%S]", \ + localtime ((time_t *)&ia_time)); \ + \ + snprintf (statstr, sizeof (statstr), \ + "gfid=%s ino=%"PRIu64", mode=%o, " \ + "nlink=%"GF_PRI_NLINK", uid=%u, " \ + "gid=%u, size=%"PRIu64", " \ + "blocks=%"PRIu64", atime=%s, " \ + "mtime=%s, ctime=%s", \ + uuid_utoa (buf->ia_gfid), buf->ia_ino, \ + st_mode_from_ia (buf->ia_prot, \ + buf->ia_type), \ + buf->ia_nlink, buf->ia_uid, \ + buf->ia_gid, buf->ia_size, \ + buf->ia_blocks, atime_buf, \ + mtime_buf, ctime_buf); \ + } while (0); |