diff options
Diffstat (limited to 'xlators/debug/trace/src/trace.c')
| -rw-r--r-- | xlators/debug/trace/src/trace.c | 3079 |
1 files changed, 1961 insertions, 1118 deletions
diff --git a/xlators/debug/trace/src/trace.c b/xlators/debug/trace/src/trace.c index 943009daf..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,353 +2108,552 @@ 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) + 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")", - 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" 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); + 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, 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")", - frame->root->unique, uuid_utoa (fd->inode->gfid), - fd, count, offset); + 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, 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; } int trace_readdirp (call_frame_t *frame, xlator_t *this, fd_t *fd, size_t size, - off_t offset) + 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, - 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" 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, - fd, size, offset); + fd, size, offset, dict); 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; @@ -2089,163 +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 ino=%"PRIu64, - uuid_utoa (inode->gfid), inode->ino); + 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) { @@ -2255,7 +2929,6 @@ enable_all_calls (int enabled) trace_fop_names[i].enabled = enabled; } - void enable_call (const char *name, int enabled) { @@ -2283,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) @@ -2290,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; @@ -2304,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")); @@ -2312,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; } } @@ -2321,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")); @@ -2336,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 @@ -2363,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; @@ -2411,7 +3239,6 @@ struct xlator_fops fops = { .fsetattr = trace_fsetattr, }; - struct xlator_cbks cbks = { .release = trace_release, .releasedir = trace_releasedir, @@ -2427,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 +}; |