diff options
Diffstat (limited to 'xlators/debug')
| -rw-r--r-- | xlators/debug/delay-gen/src/delay-gen.c | 858 | ||||
| -rw-r--r-- | xlators/debug/error-gen/src/error-gen.c | 2534 | ||||
| -rw-r--r-- | xlators/debug/io-stats/src/io-stats.c | 6842 | ||||
| -rw-r--r-- | xlators/debug/sink/src/sink.c | 57 | ||||
| -rw-r--r-- | xlators/debug/trace/src/trace.c | 5447 |
5 files changed, 7750 insertions, 7988 deletions
diff --git a/xlators/debug/delay-gen/src/delay-gen.c b/xlators/debug/delay-gen/src/delay-gen.c index 849ebeaabcd..a2d02527f23 100644 --- a/xlators/debug/delay-gen/src/delay-gen.c +++ b/xlators/debug/delay-gen/src/delay-gen.c @@ -8,741 +8,675 @@ * cases as published by the Free Software Foundation. */ - #include "delay-gen.h" -#define DELAY_GRANULARITY (1 << 20) +#define DELAY_GRANULARITY (1 << 20) #define DG_FOP(fop, name, frame, this, args...) \ - do { \ - delay_gen (this, fop); \ - default_##name (frame, this, args); \ - } while (0) + do { \ + delay_gen(this, fop); \ + default_##name(frame, this, args); \ + } while (0) int -delay_gen (xlator_t *this, int fop) +delay_gen(xlator_t *this, int fop) { - dg_t *dg = this->private; + dg_t *dg = this->private; - if (!dg->enable[fop] || !dg->delay_ppm) - return 0; + if (!dg->enable[fop] || !dg->delay_ppm) + return 0; - if ((rand () % DELAY_GRANULARITY) < dg->delay_ppm) - usleep (dg->delay_duration); + if ((rand() % DELAY_GRANULARITY) < dg->delay_ppm) + usleep(dg->delay_duration); - return 0; + return 0; } int32_t -dg_rename (call_frame_t *frame, xlator_t *this, loc_t *oldloc, loc_t *newloc, - dict_t *xdata) +dg_rename(call_frame_t *frame, xlator_t *this, loc_t *oldloc, loc_t *newloc, + dict_t *xdata) { - DG_FOP (GF_FOP_RENAME, rename, frame, this, oldloc, newloc, xdata); - return 0; + DG_FOP(GF_FOP_RENAME, rename, frame, this, oldloc, newloc, xdata); + return 0; } - int32_t -dg_ipc (call_frame_t *frame, xlator_t *this, int32_t op, dict_t *xdata) +dg_ipc(call_frame_t *frame, xlator_t *this, int32_t op, dict_t *xdata) { - DG_FOP (GF_FOP_IPC, ipc, frame, this, op, xdata); - return 0; + DG_FOP(GF_FOP_IPC, ipc, frame, this, op, xdata); + return 0; } int32_t -dg_setactivelk (call_frame_t *frame, xlator_t *this, loc_t *loc, - lock_migration_info_t *locklist, dict_t *xdata) +dg_setactivelk(call_frame_t *frame, xlator_t *this, loc_t *loc, + lock_migration_info_t *locklist, dict_t *xdata) { - DG_FOP (GF_FOP_SETACTIVELK, setactivelk, frame, this, loc, - locklist, xdata); - return 0; + DG_FOP(GF_FOP_SETACTIVELK, setactivelk, frame, this, loc, locklist, xdata); + return 0; } int32_t -dg_flush (call_frame_t *frame, xlator_t *this, fd_t *fd, dict_t *xdata) +dg_flush(call_frame_t *frame, xlator_t *this, fd_t *fd, dict_t *xdata) { - DG_FOP (GF_FOP_FLUSH, flush, frame, this, fd, xdata); - return 0; + DG_FOP(GF_FOP_FLUSH, flush, frame, this, fd, xdata); + return 0; } int32_t -dg_readdir (call_frame_t *frame, xlator_t *this, fd_t *fd, size_t size, - off_t off, dict_t *xdata) +dg_readdir(call_frame_t *frame, xlator_t *this, fd_t *fd, size_t size, + off_t off, dict_t *xdata) { - DG_FOP (GF_FOP_READDIR, readdir, frame, this, fd, size, off, xdata); - return 0; + DG_FOP(GF_FOP_READDIR, readdir, frame, this, fd, size, off, xdata); + return 0; } int32_t -dg_setxattr (call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *dict, - int32_t flags, dict_t *xdata) +dg_setxattr(call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *dict, + int32_t flags, dict_t *xdata) { - DG_FOP (GF_FOP_SETXATTR, setxattr, frame, this, loc, dict, flags, - xdata); - return 0; + DG_FOP(GF_FOP_SETXATTR, setxattr, frame, this, loc, dict, flags, xdata); + return 0; } int32_t -dg_mknod (call_frame_t *frame, xlator_t *this, loc_t *loc, mode_t mode, - dev_t rdev, mode_t umask, dict_t *xdata) +dg_mknod(call_frame_t *frame, xlator_t *this, loc_t *loc, mode_t mode, + dev_t rdev, mode_t umask, dict_t *xdata) { - DG_FOP (GF_FOP_MKNOD, mknod, frame, this, loc, mode, rdev, umask, - xdata); - return 0; + DG_FOP(GF_FOP_MKNOD, mknod, frame, this, loc, mode, rdev, umask, xdata); + return 0; } int32_t -dg_fsetxattr (call_frame_t *frame, xlator_t *this, fd_t *fd, dict_t *dict, - int32_t flags, dict_t *xdata) +dg_fsetxattr(call_frame_t *frame, xlator_t *this, fd_t *fd, dict_t *dict, + int32_t flags, dict_t *xdata) { - DG_FOP (GF_FOP_FSETXATTR, fsetxattr, frame, this, fd, dict, flags, - xdata); - return 0; + DG_FOP(GF_FOP_FSETXATTR, fsetxattr, frame, this, fd, dict, flags, xdata); + return 0; } int32_t -dg_readv (call_frame_t *frame, xlator_t *this, fd_t *fd, size_t size, - off_t offset, uint32_t flags, dict_t *xdata) +dg_readv(call_frame_t *frame, xlator_t *this, fd_t *fd, size_t size, + off_t offset, uint32_t flags, dict_t *xdata) { - DG_FOP (GF_FOP_READ, readv, frame, this, fd, size, offset, flags, - xdata); - return 0; + DG_FOP(GF_FOP_READ, readv, frame, this, fd, size, offset, flags, xdata); + return 0; } int32_t -dg_inodelk (call_frame_t *frame, xlator_t *this, const char *volume, - loc_t *loc, int32_t cmd, struct gf_flock *lock, dict_t *xdata) +dg_inodelk(call_frame_t *frame, xlator_t *this, const char *volume, loc_t *loc, + int32_t cmd, struct gf_flock *lock, dict_t *xdata) { - DG_FOP (GF_FOP_INODELK, inodelk, frame, this, volume, loc, cmd, lock, - xdata); - return 0; + DG_FOP(GF_FOP_INODELK, inodelk, frame, this, volume, loc, cmd, lock, xdata); + return 0; } int32_t -dg_fremovexattr (call_frame_t *frame, xlator_t *this, fd_t *fd, - const char *name, dict_t *xdata) +dg_fremovexattr(call_frame_t *frame, xlator_t *this, fd_t *fd, const char *name, + dict_t *xdata) { - DG_FOP (GF_FOP_FREMOVEXATTR, fremovexattr, frame, this, fd, name, - xdata); - return 0; + DG_FOP(GF_FOP_FREMOVEXATTR, fremovexattr, frame, this, fd, name, xdata); + return 0; } int32_t -dg_open (call_frame_t *frame, xlator_t *this, loc_t *loc, int32_t flags, - fd_t *fd, dict_t *xdata) +dg_open(call_frame_t *frame, xlator_t *this, loc_t *loc, int32_t flags, + fd_t *fd, dict_t *xdata) { - DG_FOP (GF_FOP_OPEN, open, frame, this, loc, flags, fd, xdata); - return 0; + DG_FOP(GF_FOP_OPEN, open, frame, this, loc, flags, fd, xdata); + return 0; } int32_t -dg_xattrop (call_frame_t *frame, xlator_t *this, loc_t *loc, - gf_xattrop_flags_t flags, dict_t *dict, dict_t *xdata) +dg_xattrop(call_frame_t *frame, xlator_t *this, loc_t *loc, + gf_xattrop_flags_t flags, dict_t *dict, dict_t *xdata) { - DG_FOP (GF_FOP_XATTROP, xattrop, frame, this, loc, flags, dict, xdata); - return 0; + DG_FOP(GF_FOP_XATTROP, xattrop, frame, this, loc, flags, dict, xdata); + return 0; } int32_t -dg_entrylk (call_frame_t *frame, xlator_t *this, const char *volume, - loc_t *loc, const char *basename, entrylk_cmd cmd, - entrylk_type type, dict_t *xdata) +dg_entrylk(call_frame_t *frame, xlator_t *this, const char *volume, loc_t *loc, + const char *basename, entrylk_cmd cmd, entrylk_type type, + dict_t *xdata) { - DG_FOP (GF_FOP_ENTRYLK, entrylk, frame, this, volume, - loc, basename, cmd, type, xdata); - return 0; + DG_FOP(GF_FOP_ENTRYLK, entrylk, frame, this, volume, loc, basename, cmd, + type, xdata); + return 0; } int32_t -dg_getactivelk (call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *xdata) +dg_getactivelk(call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *xdata) { - DG_FOP (GF_FOP_GETACTIVELK, getactivelk, frame, this, loc, xdata); - return 0; + DG_FOP(GF_FOP_GETACTIVELK, getactivelk, frame, this, loc, xdata); + return 0; } int32_t -dg_finodelk (call_frame_t *frame, xlator_t *this, const char *volume, - fd_t *fd, int32_t cmd, struct gf_flock *lock, dict_t *xdata) +dg_finodelk(call_frame_t *frame, xlator_t *this, const char *volume, fd_t *fd, + int32_t cmd, struct gf_flock *lock, dict_t *xdata) { - DG_FOP (GF_FOP_FINODELK, finodelk, frame, this, volume, fd, cmd, lock, - xdata); - return 0; + DG_FOP(GF_FOP_FINODELK, finodelk, frame, this, volume, fd, cmd, lock, + xdata); + return 0; } int32_t -dg_create (call_frame_t *frame, xlator_t *this, loc_t *loc, int32_t flags, - mode_t mode, mode_t umask, fd_t *fd, dict_t *xdata) +dg_create(call_frame_t *frame, xlator_t *this, loc_t *loc, int32_t flags, + mode_t mode, mode_t umask, fd_t *fd, dict_t *xdata) { - DG_FOP (GF_FOP_CREATE, create, frame, this, loc, flags, mode, umask, fd, - xdata); - return 0; + DG_FOP(GF_FOP_CREATE, create, frame, this, loc, flags, mode, umask, fd, + xdata); + return 0; } int32_t -dg_discard (call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset, - size_t len, dict_t *xdata) +dg_discard(call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset, + size_t len, dict_t *xdata) { - DG_FOP (GF_FOP_DISCARD, discard, frame, this, fd, offset, len, xdata); - return 0; + DG_FOP(GF_FOP_DISCARD, discard, frame, this, fd, offset, len, xdata); + return 0; } int32_t -dg_mkdir (call_frame_t *frame, xlator_t *this, loc_t *loc, mode_t mode, - mode_t umask, dict_t *xdata) +dg_mkdir(call_frame_t *frame, xlator_t *this, loc_t *loc, mode_t mode, + mode_t umask, dict_t *xdata) { - DG_FOP (GF_FOP_MKDIR, mkdir, frame, this, loc, mode, umask, xdata); - return 0; + DG_FOP(GF_FOP_MKDIR, mkdir, frame, this, loc, mode, umask, xdata); + return 0; } int32_t -dg_lk (call_frame_t *frame, xlator_t *this, fd_t *fd, int32_t cmd, - struct gf_flock *lock, dict_t *xdata) +dg_lk(call_frame_t *frame, xlator_t *this, fd_t *fd, int32_t cmd, + struct gf_flock *lock, dict_t *xdata) { - DG_FOP (GF_FOP_LK, lk, frame, this, fd, cmd, lock, xdata); - return 0; + DG_FOP(GF_FOP_LK, lk, frame, this, fd, cmd, lock, xdata); + return 0; } int32_t -dg_writev (call_frame_t *frame, xlator_t *this, fd_t *fd, - struct iovec *vector, int32_t count, off_t off, uint32_t flags, - struct iobref *iobref, dict_t *xdata) +dg_writev(call_frame_t *frame, xlator_t *this, fd_t *fd, struct iovec *vector, + int32_t count, off_t off, uint32_t flags, struct iobref *iobref, + dict_t *xdata) { - DG_FOP (GF_FOP_WRITE, writev, frame, this, fd, - vector, count, off, flags, iobref, xdata); - return 0; + DG_FOP(GF_FOP_WRITE, writev, frame, this, fd, vector, count, off, flags, + iobref, xdata); + return 0; } int32_t -dg_access (call_frame_t *frame, xlator_t *this, loc_t *loc, int32_t mask, - dict_t *xdata) +dg_access(call_frame_t *frame, xlator_t *this, loc_t *loc, int32_t mask, + dict_t *xdata) { - DG_FOP (GF_FOP_ACCESS, access, frame, this, loc, mask, xdata); - return 0; + DG_FOP(GF_FOP_ACCESS, access, frame, this, loc, mask, xdata); + return 0; } int32_t -dg_lookup (call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *xdata) +dg_lookup(call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *xdata) { - DG_FOP (GF_FOP_LOOKUP, lookup, frame, this, loc, xdata); - return 0; + DG_FOP(GF_FOP_LOOKUP, lookup, frame, this, loc, xdata); + return 0; } - - int32_t -dg_rmdir (call_frame_t *frame, xlator_t *this, loc_t *loc, - int32_t flags, dict_t *xdata) +dg_rmdir(call_frame_t *frame, xlator_t *this, loc_t *loc, int32_t flags, + dict_t *xdata) { - DG_FOP (GF_FOP_RMDIR, rmdir, frame, this, loc, flags, xdata); - return 0; + DG_FOP(GF_FOP_RMDIR, rmdir, frame, this, loc, flags, xdata); + return 0; } - - int32_t -dg_fallocate (call_frame_t *frame, xlator_t *this, fd_t *fd, int32_t keep_size, - off_t offset, size_t len, dict_t *xdata) +dg_fallocate(call_frame_t *frame, xlator_t *this, fd_t *fd, int32_t keep_size, + off_t offset, size_t len, dict_t *xdata) { - DG_FOP (GF_FOP_FALLOCATE, fallocate, frame, this, fd, keep_size, offset, - len, xdata); - return 0; + DG_FOP(GF_FOP_FALLOCATE, fallocate, frame, this, fd, keep_size, offset, len, + xdata); + return 0; } - - int32_t -dg_fstat (call_frame_t *frame, xlator_t *this, fd_t *fd, dict_t *xdata) +dg_fstat(call_frame_t *frame, xlator_t *this, fd_t *fd, dict_t *xdata) { - DG_FOP (GF_FOP_FSTAT, fstat, frame, this, fd, xdata); - return 0; + DG_FOP(GF_FOP_FSTAT, fstat, frame, this, fd, xdata); + return 0; } - - int32_t -dg_lease (call_frame_t *frame, xlator_t *this, loc_t *loc, - struct gf_lease *lease, dict_t *xdata) +dg_lease(call_frame_t *frame, xlator_t *this, loc_t *loc, + struct gf_lease *lease, dict_t *xdata) { - DG_FOP (GF_FOP_LEASE, lease, frame, this, loc, lease, xdata); - return 0; + DG_FOP(GF_FOP_LEASE, lease, frame, this, loc, lease, xdata); + return 0; } - - int32_t -dg_stat (call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *xdata) +dg_stat(call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *xdata) { - DG_FOP (GF_FOP_STAT, stat, frame, this, loc, xdata); - return 0; + DG_FOP(GF_FOP_STAT, stat, frame, this, loc, xdata); + return 0; } - - int32_t -dg_truncate (call_frame_t *frame, xlator_t *this, loc_t *loc, off_t offset, - dict_t *xdata) +dg_truncate(call_frame_t *frame, xlator_t *this, loc_t *loc, off_t offset, + dict_t *xdata) { - DG_FOP (GF_FOP_TRUNCATE, truncate, frame, this, loc, offset, xdata); - return 0; + DG_FOP(GF_FOP_TRUNCATE, truncate, frame, this, loc, offset, xdata); + return 0; } - - int32_t -dg_getxattr (call_frame_t *frame, xlator_t *this, loc_t *loc, - const char *name, dict_t *xdata) +dg_getxattr(call_frame_t *frame, xlator_t *this, loc_t *loc, const char *name, + dict_t *xdata) { - DG_FOP (GF_FOP_GETXATTR, getxattr, frame, this, loc, name, xdata); - return 0; + DG_FOP(GF_FOP_GETXATTR, getxattr, frame, this, loc, name, xdata); + return 0; } - - int32_t -dg_symlink (call_frame_t *frame, xlator_t *this, const char *linkpath, - loc_t *loc, mode_t umask, dict_t *xdata) +dg_symlink(call_frame_t *frame, xlator_t *this, const char *linkpath, + loc_t *loc, mode_t umask, dict_t *xdata) { - DG_FOP (GF_FOP_SYMLINK, symlink, frame, this, linkpath, loc, umask, - xdata); - return 0; + DG_FOP(GF_FOP_SYMLINK, symlink, frame, this, linkpath, loc, umask, xdata); + return 0; } - - int32_t -dg_zerofill (call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset, - off_t len, dict_t *xdata) +dg_zerofill(call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset, + off_t len, dict_t *xdata) { - DG_FOP (GF_FOP_ZEROFILL, zerofill, frame, this, fd, offset, len, xdata); - return 0; + DG_FOP(GF_FOP_ZEROFILL, zerofill, frame, this, fd, offset, len, xdata); + return 0; } - - int32_t -dg_fsyncdir (call_frame_t *frame, xlator_t *this, fd_t *fd, int32_t flags, - dict_t *xdata) +dg_fsyncdir(call_frame_t *frame, xlator_t *this, fd_t *fd, int32_t flags, + dict_t *xdata) { - DG_FOP (GF_FOP_FSYNCDIR, fsyncdir, frame, this, fd, flags, xdata); - return 0; + DG_FOP(GF_FOP_FSYNCDIR, fsyncdir, frame, this, fd, flags, xdata); + return 0; } - - int32_t -dg_fgetxattr (call_frame_t *frame, xlator_t *this, fd_t *fd, const char *name, - dict_t *xdata) +dg_fgetxattr(call_frame_t *frame, xlator_t *this, fd_t *fd, const char *name, + dict_t *xdata) { - DG_FOP (GF_FOP_FGETXATTR, fgetxattr, frame, this, fd, name, xdata); - return 0; + DG_FOP(GF_FOP_FGETXATTR, fgetxattr, frame, this, fd, name, xdata); + return 0; } - - int32_t -dg_readdirp (call_frame_t *frame, xlator_t *this, fd_t *fd, size_t size, - off_t off, dict_t *xdata) +dg_readdirp(call_frame_t *frame, xlator_t *this, fd_t *fd, size_t size, + off_t off, dict_t *xdata) { - DG_FOP (GF_FOP_READDIRP, readdirp, frame, this, fd, size, off, xdata); - return 0; + DG_FOP(GF_FOP_READDIRP, readdirp, frame, this, fd, size, off, xdata); + return 0; } - - int32_t -dg_link (call_frame_t *frame, xlator_t *this, loc_t *oldloc, loc_t *newloc, - dict_t *xdata) +dg_link(call_frame_t *frame, xlator_t *this, loc_t *oldloc, loc_t *newloc, + dict_t *xdata) { - DG_FOP (GF_FOP_LINK, link, frame, this, oldloc, newloc, xdata); - return 0; + DG_FOP(GF_FOP_LINK, link, frame, this, oldloc, newloc, xdata); + return 0; } - - int32_t -dg_fxattrop (call_frame_t *frame, xlator_t *this, fd_t *fd, - gf_xattrop_flags_t flags, dict_t *dict, dict_t *xdata) +dg_fxattrop(call_frame_t *frame, xlator_t *this, fd_t *fd, + gf_xattrop_flags_t flags, dict_t *dict, dict_t *xdata) { - DG_FOP (GF_FOP_FXATTROP, fxattrop, frame, this, fd, flags, dict, xdata); - return 0; + DG_FOP(GF_FOP_FXATTROP, fxattrop, frame, this, fd, flags, dict, xdata); + return 0; } - - int32_t -dg_ftruncate (call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset, - dict_t *xdata) +dg_ftruncate(call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset, + dict_t *xdata) { - DG_FOP (GF_FOP_FTRUNCATE, ftruncate, frame, this, fd, offset, xdata); - return 0; + DG_FOP(GF_FOP_FTRUNCATE, ftruncate, frame, this, fd, offset, xdata); + return 0; } - - int32_t -dg_rchecksum (call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset, - int32_t len, dict_t *xdata) +dg_rchecksum(call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset, + int32_t len, dict_t *xdata) { - DG_FOP (GF_FOP_RCHECKSUM, rchecksum, frame, this, fd, offset, len, - xdata); - return 0; + DG_FOP(GF_FOP_RCHECKSUM, rchecksum, frame, this, fd, offset, len, xdata); + return 0; } - - int32_t -dg_unlink (call_frame_t *frame, xlator_t *this, loc_t *loc, int32_t flags, - dict_t *xdata) +dg_unlink(call_frame_t *frame, xlator_t *this, loc_t *loc, int32_t flags, + dict_t *xdata) { - DG_FOP (GF_FOP_UNLINK, unlink, frame, this, loc, flags, xdata); - return 0; + DG_FOP(GF_FOP_UNLINK, unlink, frame, this, loc, flags, xdata); + return 0; } - - int32_t -dg_fentrylk (call_frame_t *frame, xlator_t *this, const char *volume, - fd_t *fd, const char *basename, entrylk_cmd cmd, - entrylk_type type, dict_t *xdata) +dg_fentrylk(call_frame_t *frame, xlator_t *this, const char *volume, fd_t *fd, + const char *basename, entrylk_cmd cmd, entrylk_type type, + dict_t *xdata) { - DG_FOP (GF_FOP_FENTRYLK, fentrylk, frame, this, volume, fd, basename, - cmd, type, xdata); - return 0; + DG_FOP(GF_FOP_FENTRYLK, fentrylk, frame, this, volume, fd, basename, cmd, + type, xdata); + return 0; } - - int32_t -dg_getspec (call_frame_t *frame, xlator_t *this, const char *key, - int32_t flags) +dg_getspec(call_frame_t *frame, xlator_t *this, const char *key, int32_t flags) { - DG_FOP (GF_FOP_GETSPEC, getspec, frame, this, key, flags); - return 0; + DG_FOP(GF_FOP_GETSPEC, getspec, frame, this, key, flags); + return 0; } - - int32_t -dg_setattr (call_frame_t *frame, xlator_t *this, loc_t *loc, - struct iatt *stbuf, int32_t valid, dict_t *xdata) +dg_setattr(call_frame_t *frame, xlator_t *this, loc_t *loc, struct iatt *stbuf, + int32_t valid, dict_t *xdata) { - DG_FOP (GF_FOP_SETATTR, setattr, frame, this, loc, stbuf, valid, xdata); - return 0; + DG_FOP(GF_FOP_SETATTR, setattr, frame, this, loc, stbuf, valid, xdata); + return 0; } - - int32_t -dg_fsync (call_frame_t *frame, xlator_t *this, fd_t *fd, int32_t flags, - dict_t *xdata) +dg_fsync(call_frame_t *frame, xlator_t *this, fd_t *fd, int32_t flags, + dict_t *xdata) { - DG_FOP (GF_FOP_FSYNC, fsync, frame, this, fd, flags, xdata); - return 0; + DG_FOP(GF_FOP_FSYNC, fsync, frame, this, fd, flags, xdata); + return 0; } - - int32_t -dg_statfs (call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *xdata) +dg_statfs(call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *xdata) { - DG_FOP (GF_FOP_STATFS, statfs, frame, this, loc, xdata); - return 0; + DG_FOP(GF_FOP_STATFS, statfs, frame, this, loc, xdata); + return 0; } - - int32_t -dg_seek (call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset, - gf_seek_what_t what, dict_t *xdata) +dg_seek(call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset, + gf_seek_what_t what, dict_t *xdata) { - DG_FOP (GF_FOP_SEEK, seek, frame, this, fd, offset, what, xdata); - return 0; + DG_FOP(GF_FOP_SEEK, seek, frame, this, fd, offset, what, xdata); + return 0; } - - int32_t -dg_fsetattr (call_frame_t *frame, xlator_t *this, fd_t *fd, - struct iatt *stbuf, int32_t valid, dict_t *xdata) +dg_fsetattr(call_frame_t *frame, xlator_t *this, fd_t *fd, struct iatt *stbuf, + int32_t valid, dict_t *xdata) { - DG_FOP (GF_FOP_FSETATTR, fsetattr, frame, this, fd, - stbuf, valid, xdata); - return 0; + DG_FOP(GF_FOP_FSETATTR, fsetattr, frame, this, fd, stbuf, valid, xdata); + return 0; } - - int32_t -dg_opendir (call_frame_t *frame, xlator_t *this, loc_t *loc, fd_t *fd, - dict_t *xdata) +dg_opendir(call_frame_t *frame, xlator_t *this, loc_t *loc, fd_t *fd, + dict_t *xdata) { - DG_FOP (GF_FOP_OPENDIR, opendir, frame, this, loc, fd, xdata); - return 0; + DG_FOP(GF_FOP_OPENDIR, opendir, frame, this, loc, fd, xdata); + return 0; } - - int32_t -dg_readlink (call_frame_t *frame, xlator_t *this, loc_t *loc, size_t size, - dict_t *xdata) +dg_readlink(call_frame_t *frame, xlator_t *this, loc_t *loc, size_t size, + dict_t *xdata) { - DG_FOP (GF_FOP_READLINK, readlink, frame, this, loc, size, xdata); - return 0; + DG_FOP(GF_FOP_READLINK, readlink, frame, this, loc, size, xdata); + return 0; } - - int32_t -dg_removexattr (call_frame_t *frame, xlator_t *this, loc_t *loc, - const char *name, dict_t *xdata) +dg_removexattr(call_frame_t *frame, xlator_t *this, loc_t *loc, + const char *name, dict_t *xdata) { - DG_FOP (GF_FOP_REMOVEXATTR, removexattr, frame, this, loc, name, xdata); - return 0; + DG_FOP(GF_FOP_REMOVEXATTR, removexattr, frame, this, loc, name, xdata); + return 0; } int32_t -dg_forget (xlator_t *this, inode_t *inode) +dg_forget(xlator_t *this, inode_t *inode) { - return 0; + return 0; } int32_t -dg_release (xlator_t *this, fd_t *fd) +dg_release(xlator_t *this, fd_t *fd) { - return 0; + return 0; } int32_t -dg_releasedir (xlator_t *this, fd_t *fd) +dg_releasedir(xlator_t *this, fd_t *fd) { - return 0; + return 0; } static int -delay_gen_parse_fill_fops (dg_t *dg, char *enable_fops) -{ - char *op_no_str = NULL; - int op_no = -1; - int i = 0; - int ret = 0; - xlator_t *this = THIS; - char *saveptr = NULL; - char *dup_enable_fops = NULL; - - if (strlen (enable_fops) == 0) { - for (i = GF_FOP_NULL + 1; i < GF_FOP_MAXVALUE; i++) - dg->enable[i] = 1; - } else { - dup_enable_fops = gf_strdup (enable_fops); - if (!dup_enable_fops) { - ret = -1; - goto out; - } - op_no_str = strtok_r (dup_enable_fops, ",", &saveptr); - while (op_no_str) { - op_no = gf_fop_int (op_no_str); - if (op_no == -1) { - gf_log (this->name, GF_LOG_WARNING, - "Wrong option value %s", op_no_str); - ret = -1; - goto out; - } else { - dg->enable[op_no] = 1; - } - - op_no_str = strtok_r (NULL, ",", &saveptr); - } +delay_gen_parse_fill_fops(dg_t *dg, char *enable_fops) +{ + char *op_no_str = NULL; + int op_no = -1; + int i = 0; + int ret = 0; + xlator_t *this = THIS; + char *saveptr = NULL; + char *dup_enable_fops = NULL; + + if (strlen(enable_fops) == 0) { + for (i = GF_FOP_NULL + 1; i < GF_FOP_MAXVALUE; i++) + dg->enable[i] = 1; + } else { + dup_enable_fops = gf_strdup(enable_fops); + if (!dup_enable_fops) { + ret = -1; + goto out; + } + op_no_str = strtok_r(dup_enable_fops, ",", &saveptr); + while (op_no_str) { + op_no = gf_fop_int(op_no_str); + if (op_no == -1) { + gf_log(this->name, GF_LOG_WARNING, "Wrong option value %s", + op_no_str); + ret = -1; + goto out; + } else { + dg->enable[op_no] = 1; + } + + op_no_str = strtok_r(NULL, ",", &saveptr); } + } out: - GF_FREE (dup_enable_fops); - return ret; + GF_FREE(dup_enable_fops); + return ret; } void -delay_gen_set_delay_ppm (dg_t *dg, double percent) +delay_gen_set_delay_ppm(dg_t *dg, double percent) { - double ppm; + double ppm; - ppm = (percent / 100.0) * (double) DELAY_GRANULARITY; - dg->delay_ppm = ppm; + ppm = (percent / 100.0) * (double)DELAY_GRANULARITY; + dg->delay_ppm = ppm; } int32_t -init (xlator_t *this) +init(xlator_t *this) { - dg_t *dg = NULL; - int32_t ret = 0; - double delay_percent = 0; - char *delay_enable_fops = NULL; - - if (!this->children || this->children->next) { - gf_log (this->name, GF_LOG_ERROR, - "delay-gen not configured with one subvolume"); - ret = -1; - goto out; - } + dg_t *dg = NULL; + int32_t ret = 0; + double delay_percent = 0; + char *delay_enable_fops = NULL; - if (!this->parents) { - gf_log (this->name, GF_LOG_WARNING, - "dangling volume. check volfile "); - } + if (!this->children || this->children->next) { + gf_log(this->name, GF_LOG_ERROR, + "delay-gen not configured with one subvolume"); + ret = -1; + goto out; + } - dg = GF_CALLOC (1, sizeof (*dg), gf_delay_gen_mt_dg_t); + if (!this->parents) { + gf_log(this->name, GF_LOG_WARNING, "dangling volume. check volfile "); + } - if (!dg) { - ret = -1; - goto out; - } + dg = GF_CALLOC(1, sizeof(*dg), gf_delay_gen_mt_dg_t); + if (!dg) { ret = -1; + goto out; + } - GF_OPTION_INIT ("delay-percentage", delay_percent, percent, out); - GF_OPTION_INIT ("enable", delay_enable_fops, str, out); - GF_OPTION_INIT ("delay-duration", dg->delay_duration, int32, out); + ret = -1; - delay_gen_set_delay_ppm (dg, delay_percent); + GF_OPTION_INIT("delay-percentage", delay_percent, percent, out); + GF_OPTION_INIT("enable", delay_enable_fops, str, out); + GF_OPTION_INIT("delay-duration", dg->delay_duration, int32, out); - ret = delay_gen_parse_fill_fops (dg, delay_enable_fops); - if (ret) - goto out; + delay_gen_set_delay_ppm(dg, delay_percent); + + ret = delay_gen_parse_fill_fops(dg, delay_enable_fops); + if (ret) + goto out; - this->private = dg; + this->private = dg; - ret = 0; + ret = 0; out: - if (ret) - GF_FREE (dg); - return ret; + if (ret) + GF_FREE(dg); + return ret; } void -fini (xlator_t *this) +fini(xlator_t *this) { - GF_FREE (this->private); + GF_FREE(this->private); } int32_t -mem_acct_init (xlator_t *this) +mem_acct_init(xlator_t *this) { - int ret = -1; + int ret = -1; - if (!this) - return ret; - - ret = xlator_mem_acct_init (this, gf_delay_gen_mt_end + 1); + if (!this) + return ret; - if (ret != 0) { - gf_log (this->name, GF_LOG_ERROR, "Memory accounting init" - " failed"); - return ret; - } + ret = xlator_mem_acct_init(this, gf_delay_gen_mt_end + 1); + if (ret != 0) { + gf_log(this->name, GF_LOG_ERROR, + "Memory accounting init" + " failed"); return ret; + } + + return ret; } int32_t -reconfigure (xlator_t *this, dict_t *dict) +reconfigure(xlator_t *this, dict_t *dict) { - /*At the moment I don't see any need to implement this. In future - *if this is needed we can add code here. - */ - return 0; + /*At the moment I don't see any need to implement this. In future + *if this is needed we can add code here. + */ + return 0; } int -notify (xlator_t *this, int event, void *data, ...) +notify(xlator_t *this, int event, void *data, ...) { - return default_notify (this, event, data); + return default_notify(this, event, data); } - struct xlator_fops fops = { - .rename = dg_rename, - .ipc = dg_ipc, - .setactivelk = dg_setactivelk, - .flush = dg_flush, - .readdir = dg_readdir, - .setxattr = dg_setxattr, - .mknod = dg_mknod, - .fsetxattr = dg_fsetxattr, - .readv = dg_readv, - .inodelk = dg_inodelk, - .fremovexattr = dg_fremovexattr, - .open = dg_open, - .xattrop = dg_xattrop, - .entrylk = dg_entrylk, - .getactivelk = dg_getactivelk, - .finodelk = dg_finodelk, - .create = dg_create, - .discard = dg_discard, - .mkdir = dg_mkdir, - .lk = dg_lk, - .writev = dg_writev, - .access = dg_access, - .lookup = dg_lookup, - .rmdir = dg_rmdir, - .fallocate = dg_fallocate, - .fstat = dg_fstat, - .lease = dg_lease, - .stat = dg_stat, - .truncate = dg_truncate, - .getxattr = dg_getxattr, - .symlink = dg_symlink, - .zerofill = dg_zerofill, - .fsyncdir = dg_fsyncdir, - .fgetxattr = dg_fgetxattr, - .readdirp = dg_readdirp, - .link = dg_link, - .fxattrop = dg_fxattrop, - .ftruncate = dg_ftruncate, - .rchecksum = dg_rchecksum, - .unlink = dg_unlink, - .fentrylk = dg_fentrylk, - .getspec = dg_getspec, - .setattr = dg_setattr, - .fsync = dg_fsync, - .statfs = dg_statfs, - .seek = dg_seek, - .fsetattr = dg_fsetattr, - .opendir = dg_opendir, - .readlink = dg_readlink, - .removexattr = dg_removexattr, + .rename = dg_rename, + .ipc = dg_ipc, + .setactivelk = dg_setactivelk, + .flush = dg_flush, + .readdir = dg_readdir, + .setxattr = dg_setxattr, + .mknod = dg_mknod, + .fsetxattr = dg_fsetxattr, + .readv = dg_readv, + .inodelk = dg_inodelk, + .fremovexattr = dg_fremovexattr, + .open = dg_open, + .xattrop = dg_xattrop, + .entrylk = dg_entrylk, + .getactivelk = dg_getactivelk, + .finodelk = dg_finodelk, + .create = dg_create, + .discard = dg_discard, + .mkdir = dg_mkdir, + .lk = dg_lk, + .writev = dg_writev, + .access = dg_access, + .lookup = dg_lookup, + .rmdir = dg_rmdir, + .fallocate = dg_fallocate, + .fstat = dg_fstat, + .lease = dg_lease, + .stat = dg_stat, + .truncate = dg_truncate, + .getxattr = dg_getxattr, + .symlink = dg_symlink, + .zerofill = dg_zerofill, + .fsyncdir = dg_fsyncdir, + .fgetxattr = dg_fgetxattr, + .readdirp = dg_readdirp, + .link = dg_link, + .fxattrop = dg_fxattrop, + .ftruncate = dg_ftruncate, + .rchecksum = dg_rchecksum, + .unlink = dg_unlink, + .fentrylk = dg_fentrylk, + .getspec = dg_getspec, + .setattr = dg_setattr, + .fsync = dg_fsync, + .statfs = dg_statfs, + .seek = dg_seek, + .fsetattr = dg_fsetattr, + .opendir = dg_opendir, + .readlink = dg_readlink, + .removexattr = dg_removexattr, }; struct xlator_cbks cbks = { - .forget = dg_forget, - .release = dg_release, - .releasedir = dg_releasedir, + .forget = dg_forget, + .release = dg_release, + .releasedir = dg_releasedir, }; struct volume_options options[] = { - { .key = {"delay-percentage"}, - .type = GF_OPTION_TYPE_PERCENT, - .default_value = "10%", - .description = "Percentage delay of operations when enabled.", - .op_version = {GD_OP_VERSION_3_13_0}, - .flags = OPT_FLAG_SETTABLE, - .tags = {"delay-gen"}, - }, - - { .key = {"delay-duration"}, - .type = GF_OPTION_TYPE_INT, - .description = "Delay duration in micro seconds", - .default_value = "100000", - .op_version = {GD_OP_VERSION_3_13_0}, - .flags = OPT_FLAG_SETTABLE, - .tags = {"delay-gen"}, - }, - - { .key = {"enable"}, - .type = GF_OPTION_TYPE_STR, - .description = "Accepts a string which takes ',' separated fop " - "strings to denote which fops are enabled for delay", - .op_version = {GD_OP_VERSION_3_13_0}, - .flags = OPT_FLAG_SETTABLE, - .tags = {"delay-gen"}, - .default_value = "", - }, - - { .key = {NULL} } -}; + { + .key = {"delay-percentage"}, + .type = GF_OPTION_TYPE_PERCENT, + .default_value = "10%", + .description = "Percentage delay of operations when enabled.", + .op_version = {GD_OP_VERSION_3_13_0}, + .flags = OPT_FLAG_SETTABLE, + .tags = {"delay-gen"}, + }, + + { + .key = {"delay-duration"}, + .type = GF_OPTION_TYPE_INT, + .description = "Delay duration in micro seconds", + .default_value = "100000", + .op_version = {GD_OP_VERSION_3_13_0}, + .flags = OPT_FLAG_SETTABLE, + .tags = {"delay-gen"}, + }, + + { + .key = {"enable"}, + .type = GF_OPTION_TYPE_STR, + .description = "Accepts a string which takes ',' separated fop " + "strings to denote which fops are enabled for delay", + .op_version = {GD_OP_VERSION_3_13_0}, + .flags = OPT_FLAG_SETTABLE, + .tags = {"delay-gen"}, + .default_value = "", + }, + + {.key = {NULL}}}; diff --git a/xlators/debug/error-gen/src/error-gen.c b/xlators/debug/error-gen/src/error-gen.c index eeb7b3d0953..c6595b4c0e4 100644 --- a/xlators/debug/error-gen/src/error-gen.c +++ b/xlators/debug/error-gen/src/error-gen.c @@ -26,1694 +26,1622 @@ * something completely different and this number is irrelevant. See error_gen * for the legacy code.) */ -#define FAILURE_GRANULARITY (1 << 20) +#define FAILURE_GRANULARITY (1 << 20) sys_error_t error_no_list[] = { - [GF_FOP_LOOKUP] = { .error_no_count = 4, - .error_no = {ENOENT,ENOTDIR, - ENAMETOOLONG,EAGAIN}}, - [GF_FOP_STAT] = { .error_no_count = 7, - .error_no = {EACCES,EBADF,EFAULT, - ENAMETOOLONG,ENOENT, - ENOMEM,ENOTDIR}}, - [GF_FOP_READLINK] = { .error_no_count = 8, - .error_no = {EACCES,EFAULT,EINVAL,EIO, - ENAMETOOLONG,ENOENT,ENOMEM, - ENOTDIR}}, - [GF_FOP_MKNOD] = { .error_no_count = 11, - .error_no = {EACCES,EEXIST,EFAULT, - EINVAL,ENAMETOOLONG, - ENOENT,ENOMEM,ENOSPC, - ENOTDIR,EPERM,EROFS}}, - [GF_FOP_MKDIR] = { .error_no_count = 10, - .error_no = {EACCES,EEXIST,EFAULT, - ENAMETOOLONG,ENOENT, - ENOMEM,ENOSPC,ENOTDIR, - EPERM,EROFS}}, - [GF_FOP_UNLINK] = { .error_no_count = 10, - .error_no = {EACCES,EBUSY,EFAULT,EIO, - EISDIR,ENAMETOOLONG, - ENOENT,ENOMEM,ENOTDIR, - EPERM,EROFS}}, - [GF_FOP_RMDIR] = { .error_no_count = 8, - .error_no = {EACCES,EBUSY,EFAULT, - ENOMEM,ENOTDIR,ENOTEMPTY, - EPERM,EROFS}}, - [GF_FOP_SYMLINK] = { .error_no_count = 11, - .error_no = {EACCES,EEXIST,EFAULT,EIO, - ENAMETOOLONG,ENOENT,ENOMEM, - ENOSPC,ENOTDIR,EPERM, - EROFS}}, - [GF_FOP_RENAME] = { .error_no_count = 13, - .error_no = {EACCES,EBUSY,EFAULT, - EINVAL,EISDIR,EMLINK, - ENAMETOOLONG,ENOENT,ENOMEM, - ENOSPC,ENOTDIR,EEXIST, - EXDEV}}, - [GF_FOP_LINK] = { .error_no_count = 13, - .error_no = {EACCES,EFAULT,EEXIST,EIO, - EMLINK,ENAMETOOLONG, - ENOENT,ENOMEM,ENOSPC, - ENOTDIR,EPERM,EROFS, - EXDEV}}, - [GF_FOP_TRUNCATE] = { .error_no_count = 10, - .error_no = {EACCES,EFAULT,EFBIG, - EINTR,EINVAL,EIO,EISDIR, - ENAMETOOLONG,ENOENT, - EISDIR}}, - [GF_FOP_CREATE] = {.error_no_count = 10, - .error_no = {EACCES,EEXIST,EFAULT, - EISDIR,EMFILE,ENAMETOOLONG, - ENFILE,ENODEV,ENOENT, - ENODEV}}, - [GF_FOP_OPEN] = { .error_no_count = 10, - .error_no = {EACCES,EEXIST,EFAULT, - EISDIR,EMFILE, - ENAMETOOLONG,ENFILE, - ENODEV,ENOENT,ENOMEM}}, - [GF_FOP_READ] = { .error_no_count = 5, - .error_no = {EINVAL,EBADF,EFAULT,EISDIR, - ENAMETOOLONG}}, - [GF_FOP_WRITE] = { .error_no_count = 7, - .error_no = {EINVAL,EBADF,EFAULT,EISDIR, - ENAMETOOLONG,ENOSPC, - GF_ERROR_SHORT_WRITE}}, - [GF_FOP_STATFS] = {.error_no_count = 10, - .error_no = {EACCES,EBADF,EFAULT,EINTR, - EIO,ENAMETOOLONG,ENOENT, - ENOMEM,ENOSYS,ENOTDIR}}, - [GF_FOP_FLUSH] = { .error_no_count = 5, - .error_no = {EACCES,EFAULT, - ENAMETOOLONG,ENOSYS, - ENOENT}}, - [GF_FOP_FSYNC] = { .error_no_count = 4, - .error_no = {EBADF,EIO,EROFS,EINVAL}}, - [GF_FOP_SETXATTR] = { .error_no_count = 4, - .error_no = {EACCES,EBADF,EINTR, - ENAMETOOLONG}}, - [GF_FOP_GETXATTR] = { .error_no_count = 4, - .error_no = {EACCES,EBADF,ENAMETOOLONG, - EINTR}}, - [GF_FOP_REMOVEXATTR] = { .error_no_count = 4, - .error_no = {EACCES,EBADF,ENAMETOOLONG, - EINTR}}, - [GF_FOP_FSETXATTR] = { .error_no_count = 4, - .error_no = {EACCES,EBADF,EINTR, - ENAMETOOLONG}}, - [GF_FOP_FGETXATTR] = { .error_no_count = 4, - .error_no = {EACCES,EBADF,ENAMETOOLONG, - EINTR}}, - [GF_FOP_FREMOVEXATTR] = { .error_no_count = 4, - .error_no = {EACCES,EBADF,ENAMETOOLONG, - EINTR}}, - [GF_FOP_OPENDIR] = { .error_no_count = 8, - .error_no = {EACCES,EEXIST,EFAULT, - EISDIR,EMFILE, - ENAMETOOLONG,ENFILE, - ENODEV}}, - [GF_FOP_READDIR] = { .error_no_count = 5, - .error_no = {EINVAL,EACCES,EBADF, - EMFILE,ENOENT}}, - [GF_FOP_READDIRP] = { .error_no_count = 5, - .error_no = {EINVAL,EACCES,EBADF, - EMFILE,ENOENT}}, - [GF_FOP_FSYNCDIR] = { .error_no_count = 4, - .error_no = {EBADF,EIO,EROFS,EINVAL}}, - [GF_FOP_ACCESS] = { .error_no_count = 8, - .error_no = {EACCES,ENAMETOOLONG, - ENOENT,ENOTDIR,EROFS, - EFAULT,EINVAL,EIO}}, - [GF_FOP_FTRUNCATE] = { .error_no_count = 9, - .error_no = {EACCES,EFAULT,EFBIG, - EINTR,EINVAL,EIO,EISDIR, - ENAMETOOLONG,ENOENT}}, - [GF_FOP_FSTAT] = { .error_no_count = 7, - .error_no = {EACCES,EBADF,EFAULT, - ENAMETOOLONG,ENOENT, - ENOMEM,ENOTDIR}}, - [GF_FOP_LK] = { .error_no_count = 4, - .error_no = {EACCES,EFAULT,ENOENT, - EINTR}}, - [GF_FOP_XATTROP] = { .error_no_count = 5, - .error_no = {EACCES,EFAULT, - ENAMETOOLONG,ENOSYS, - ENOENT}}, - [GF_FOP_FXATTROP] = { .error_no_count = 4, - .error_no = {EBADF,EIO,EROFS,EINVAL}}, - [GF_FOP_INODELK] = { .error_no_count = 4, - .error_no = {EACCES,EBADF,EINTR, - ENAMETOOLONG}}, - [GF_FOP_FINODELK] = { .error_no_count = 4, - .error_no = {EACCES,EBADF,EINTR, - ENAMETOOLONG}}, - [GF_FOP_ENTRYLK] = { .error_no_count = 4, - .error_no = {EACCES,EBADF, - ENAMETOOLONG,EINTR}}, - [GF_FOP_FENTRYLK] = { .error_no_count = 10, - .error_no = {EACCES,EEXIST,EFAULT, - EISDIR,EMFILE, - ENAMETOOLONG,ENFILE, - ENODEV,ENOENT,ENOMEM}}, - [GF_FOP_SETATTR] = {.error_no_count = 11, - .error_no = {EACCES,EFAULT,EIO, - ENAMETOOLONG,ENOENT, - ENOMEM,ENOTDIR,EPERM, - EROFS,EBADF,EIO}}, - [GF_FOP_FSETATTR] = { .error_no_count = 11, - .error_no = {EACCES,EFAULT,EIO, - ENAMETOOLONG,ENOENT, - ENOMEM,ENOTDIR,EPERM, - EROFS,EBADF,EIO}}, - [GF_FOP_GETSPEC] = { .error_no_count = 4, - .error_no = {EACCES,EBADF,ENAMETOOLONG, - EINTR}} -}; + [GF_FOP_LOOKUP] = {.error_no_count = 4, + .error_no = {ENOENT, ENOTDIR, ENAMETOOLONG, EAGAIN}}, + [GF_FOP_STAT] = {.error_no_count = 7, + .error_no = {EACCES, EBADF, EFAULT, ENAMETOOLONG, ENOENT, + ENOMEM, ENOTDIR}}, + [GF_FOP_READLINK] = {.error_no_count = 8, + .error_no = {EACCES, EFAULT, EINVAL, EIO, ENAMETOOLONG, + ENOENT, ENOMEM, ENOTDIR}}, + [GF_FOP_MKNOD] = {.error_no_count = 11, + .error_no = {EACCES, EEXIST, EFAULT, EINVAL, ENAMETOOLONG, + ENOENT, ENOMEM, ENOSPC, ENOTDIR, EPERM, + EROFS}}, + [GF_FOP_MKDIR] = {.error_no_count = 10, + .error_no = {EACCES, EEXIST, EFAULT, ENAMETOOLONG, ENOENT, + ENOMEM, ENOSPC, ENOTDIR, EPERM, EROFS}}, + [GF_FOP_UNLINK] = {.error_no_count = 10, + .error_no = {EACCES, EBUSY, EFAULT, EIO, EISDIR, + ENAMETOOLONG, ENOENT, ENOMEM, ENOTDIR, + EPERM, EROFS}}, + [GF_FOP_RMDIR] = {.error_no_count = 8, + .error_no = {EACCES, EBUSY, EFAULT, ENOMEM, ENOTDIR, + ENOTEMPTY, EPERM, EROFS}}, + [GF_FOP_SYMLINK] = {.error_no_count = 11, + .error_no = {EACCES, EEXIST, EFAULT, EIO, ENAMETOOLONG, + ENOENT, ENOMEM, ENOSPC, ENOTDIR, EPERM, + EROFS}}, + [GF_FOP_RENAME] = {.error_no_count = 13, + .error_no = {EACCES, EBUSY, EFAULT, EINVAL, EISDIR, + EMLINK, ENAMETOOLONG, ENOENT, ENOMEM, + ENOSPC, ENOTDIR, EEXIST, EXDEV}}, + [GF_FOP_LINK] = {.error_no_count = 13, + .error_no = {EACCES, EFAULT, EEXIST, EIO, EMLINK, + ENAMETOOLONG, ENOENT, ENOMEM, ENOSPC, ENOTDIR, + EPERM, EROFS, EXDEV}}, + [GF_FOP_TRUNCATE] = {.error_no_count = 10, + .error_no = {EACCES, EFAULT, EFBIG, EINTR, EINVAL, EIO, + EISDIR, ENAMETOOLONG, ENOENT, EISDIR}}, + [GF_FOP_CREATE] = {.error_no_count = 10, + .error_no = {EACCES, EEXIST, EFAULT, EISDIR, EMFILE, + ENAMETOOLONG, ENFILE, ENODEV, ENOENT, + ENODEV}}, + [GF_FOP_OPEN] = {.error_no_count = 10, + .error_no = {EACCES, EEXIST, EFAULT, EISDIR, EMFILE, + ENAMETOOLONG, ENFILE, ENODEV, ENOENT, + ENOMEM}}, + [GF_FOP_READ] = {.error_no_count = 5, + .error_no = {EINVAL, EBADF, EFAULT, EISDIR, ENAMETOOLONG}}, + [GF_FOP_WRITE] = {.error_no_count = 7, + .error_no = {EINVAL, EBADF, EFAULT, EISDIR, ENAMETOOLONG, + ENOSPC, GF_ERROR_SHORT_WRITE}}, + [GF_FOP_STATFS] = {.error_no_count = 10, + .error_no = {EACCES, EBADF, EFAULT, EINTR, EIO, + ENAMETOOLONG, ENOENT, ENOMEM, ENOSYS, + ENOTDIR}}, + [GF_FOP_FLUSH] = {.error_no_count = 5, + .error_no = {EACCES, EFAULT, ENAMETOOLONG, ENOSYS, + ENOENT}}, + [GF_FOP_FSYNC] = {.error_no_count = 4, + .error_no = {EBADF, EIO, EROFS, EINVAL}}, + [GF_FOP_SETXATTR] = {.error_no_count = 4, + .error_no = {EACCES, EBADF, EINTR, ENAMETOOLONG}}, + [GF_FOP_GETXATTR] = {.error_no_count = 4, + .error_no = {EACCES, EBADF, ENAMETOOLONG, EINTR}}, + [GF_FOP_REMOVEXATTR] = {.error_no_count = 4, + .error_no = {EACCES, EBADF, ENAMETOOLONG, EINTR}}, + [GF_FOP_FSETXATTR] = {.error_no_count = 4, + .error_no = {EACCES, EBADF, EINTR, ENAMETOOLONG}}, + [GF_FOP_FGETXATTR] = {.error_no_count = 4, + .error_no = {EACCES, EBADF, ENAMETOOLONG, EINTR}}, + [GF_FOP_FREMOVEXATTR] = {.error_no_count = 4, + .error_no = {EACCES, EBADF, ENAMETOOLONG, EINTR}}, + [GF_FOP_OPENDIR] = {.error_no_count = 8, + .error_no = {EACCES, EEXIST, EFAULT, EISDIR, EMFILE, + ENAMETOOLONG, ENFILE, ENODEV}}, + [GF_FOP_READDIR] = {.error_no_count = 5, + .error_no = {EINVAL, EACCES, EBADF, EMFILE, ENOENT}}, + [GF_FOP_READDIRP] = {.error_no_count = 5, + .error_no = {EINVAL, EACCES, EBADF, EMFILE, ENOENT}}, + [GF_FOP_FSYNCDIR] = {.error_no_count = 4, + .error_no = {EBADF, EIO, EROFS, EINVAL}}, + [GF_FOP_ACCESS] = {.error_no_count = 8, + .error_no = {EACCES, ENAMETOOLONG, ENOENT, ENOTDIR, + EROFS, EFAULT, EINVAL, EIO}}, + [GF_FOP_FTRUNCATE] = {.error_no_count = 9, + .error_no = {EACCES, EFAULT, EFBIG, EINTR, EINVAL, + EIO, EISDIR, ENAMETOOLONG, ENOENT}}, + [GF_FOP_FSTAT] = {.error_no_count = 7, + .error_no = {EACCES, EBADF, EFAULT, ENAMETOOLONG, ENOENT, + ENOMEM, ENOTDIR}}, + [GF_FOP_LK] = {.error_no_count = 4, + .error_no = {EACCES, EFAULT, ENOENT, EINTR}}, + [GF_FOP_XATTROP] = {.error_no_count = 5, + .error_no = {EACCES, EFAULT, ENAMETOOLONG, ENOSYS, + ENOENT}}, + [GF_FOP_FXATTROP] = {.error_no_count = 4, + .error_no = {EBADF, EIO, EROFS, EINVAL}}, + [GF_FOP_INODELK] = {.error_no_count = 4, + .error_no = {EACCES, EBADF, EINTR, ENAMETOOLONG}}, + [GF_FOP_FINODELK] = {.error_no_count = 4, + .error_no = {EACCES, EBADF, EINTR, ENAMETOOLONG}}, + [GF_FOP_ENTRYLK] = {.error_no_count = 4, + .error_no = {EACCES, EBADF, ENAMETOOLONG, EINTR}}, + [GF_FOP_FENTRYLK] = {.error_no_count = 10, + .error_no = {EACCES, EEXIST, EFAULT, EISDIR, EMFILE, + ENAMETOOLONG, ENFILE, ENODEV, ENOENT, + ENOMEM}}, + [GF_FOP_SETATTR] = {.error_no_count = 11, + .error_no = {EACCES, EFAULT, EIO, ENAMETOOLONG, ENOENT, + ENOMEM, ENOTDIR, EPERM, EROFS, EBADF, + EIO}}, + [GF_FOP_FSETATTR] = {.error_no_count = 11, + .error_no = {EACCES, EFAULT, EIO, ENAMETOOLONG, ENOENT, + ENOMEM, ENOTDIR, EPERM, EROFS, EBADF, + EIO}}, + [GF_FOP_GETSPEC] = {.error_no_count = 4, + .error_no = {EACCES, EBADF, ENAMETOOLONG, EINTR}}}; int -generate_rand_no (int op_no) +generate_rand_no(int op_no) { - int rand_no = 0; - int error_no_list_size = 0; + int rand_no = 0; + int error_no_list_size = 0; - error_no_list_size = sizeof(error_no_list)/sizeof(error_no_list[0]); + error_no_list_size = sizeof(error_no_list) / sizeof(error_no_list[0]); - if (op_no < error_no_list_size) - /* coverity[DC.WEAK_CRYPTO] */ - rand_no = rand () % error_no_list[op_no].error_no_count; - return rand_no; + if (op_no < error_no_list_size) + /* coverity[DC.WEAK_CRYPTO] */ + rand_no = rand() % error_no_list[op_no].error_no_count; + return rand_no; } int -conv_errno_to_int (char **error_no) +conv_errno_to_int(char **error_no) { - if (!strcmp ((*error_no), "ENOENT")) - return ENOENT; - else if (!strcmp ((*error_no), "ENOTDIR")) - return ENOTDIR; - else if (!strcmp ((*error_no), "ENAMETOOLONG")) - return ENAMETOOLONG; - else if (!strcmp ((*error_no), "EACCES")) - return EACCES; - else if (!strcmp ((*error_no), "EBADF")) - return EBADF; - else if (!strcmp ((*error_no), "EFAULT")) - return EFAULT; - else if (!strcmp ((*error_no), "ENOMEM")) - return ENOMEM; - else if (!strcmp ((*error_no), "EINVAL")) - return EINVAL; - else if (!strcmp ((*error_no), "EIO")) - return EIO; - else if (!strcmp ((*error_no), "EEXIST")) - return EEXIST; - else if (!strcmp ((*error_no), "ENOSPC")) - return ENOSPC; - else if (!strcmp ((*error_no), "EPERM")) - return EPERM; - else if (!strcmp ((*error_no), "EROFS")) - return EROFS; - else if (!strcmp ((*error_no), "EBUSY")) - return EBUSY; - else if (!strcmp ((*error_no), "EISDIR")) - return EISDIR; - else if (!strcmp ((*error_no), "ENOTEMPTY")) - return ENOTEMPTY; - else if (!strcmp ((*error_no), "EMLINK")) - return EMLINK; - else if (!strcmp ((*error_no), "ENODEV")) - return ENODEV; - else if (!strcmp ((*error_no), "EXDEV")) - return EXDEV; - else if (!strcmp ((*error_no), "EMFILE")) - return EMFILE; - else if (!strcmp ((*error_no), "ENFILE")) - return ENFILE; - else if (!strcmp ((*error_no), "ENOSYS")) - return ENOSYS; - else if (!strcmp ((*error_no), "EINTR")) - return EINTR; - else if (!strcmp ((*error_no), "EFBIG")) - return EFBIG; - else if (!strcmp((*error_no), "GF_ERROR_SHORT_WRITE")) - return GF_ERROR_SHORT_WRITE; - else - return EAGAIN; + if (!strcmp((*error_no), "ENOENT")) + return ENOENT; + else if (!strcmp((*error_no), "ENOTDIR")) + return ENOTDIR; + else if (!strcmp((*error_no), "ENAMETOOLONG")) + return ENAMETOOLONG; + else if (!strcmp((*error_no), "EACCES")) + return EACCES; + else if (!strcmp((*error_no), "EBADF")) + return EBADF; + else if (!strcmp((*error_no), "EFAULT")) + return EFAULT; + else if (!strcmp((*error_no), "ENOMEM")) + return ENOMEM; + else if (!strcmp((*error_no), "EINVAL")) + return EINVAL; + else if (!strcmp((*error_no), "EIO")) + return EIO; + else if (!strcmp((*error_no), "EEXIST")) + return EEXIST; + else if (!strcmp((*error_no), "ENOSPC")) + return ENOSPC; + else if (!strcmp((*error_no), "EPERM")) + return EPERM; + else if (!strcmp((*error_no), "EROFS")) + return EROFS; + else if (!strcmp((*error_no), "EBUSY")) + return EBUSY; + else if (!strcmp((*error_no), "EISDIR")) + return EISDIR; + else if (!strcmp((*error_no), "ENOTEMPTY")) + return ENOTEMPTY; + else if (!strcmp((*error_no), "EMLINK")) + return EMLINK; + else if (!strcmp((*error_no), "ENODEV")) + return ENODEV; + else if (!strcmp((*error_no), "EXDEV")) + return EXDEV; + else if (!strcmp((*error_no), "EMFILE")) + return EMFILE; + else if (!strcmp((*error_no), "ENFILE")) + return ENFILE; + else if (!strcmp((*error_no), "ENOSYS")) + return ENOSYS; + else if (!strcmp((*error_no), "EINTR")) + return EINTR; + else if (!strcmp((*error_no), "EFBIG")) + return EFBIG; + else if (!strcmp((*error_no), "GF_ERROR_SHORT_WRITE")) + return GF_ERROR_SHORT_WRITE; + else + return EAGAIN; } int -error_gen (xlator_t *this, int op_no) +error_gen(xlator_t *this, int op_no) { - eg_t *egp = NULL; - int count = 0; - int error_no_int = 0; - int rand_no = 0; - int ret = 0; - gf_boolean_t should_err = _gf_false; - int error_no_list_size = 0; - - egp = this->private; - - if (egp->random_failure) { - /* - * I honestly don't know why anyone would use this "feature" - * but I'll try to preserve its functionality anyway. Without - * locking twice to update failure_iter_no and egp->op_count - * separately, then not locking at all to update - * egp->failure_iter_no. That's not needed for compatibility, - * and it's abhorrently wrong. I have *some* standards. - */ - LOCK (&egp->lock); - { - count = ++(egp->op_count); - error_no_int = egp->error_no_int; - if ((count % egp->failure_iter_no) == 0) { - egp->op_count = 0; - /* coverity[DC.WEAK_CRYPTO] */ - egp->failure_iter_no = 3 - + (rand () % GF_UNIVERSAL_ANSWER); - should_err = _gf_true; - } - } - UNLOCK (&egp->lock); - } else { - /* - * It turns out that rand() is almost universally implemented - * as a linear congruential PRNG, which is about as cheap as - * it gets. This gets us real random behavior, including - * phenomena like streaks and dry spells, with controllable - * long-term probability, cheaply. - */ - if ((rand () % FAILURE_GRANULARITY) < egp->failure_iter_no) { - should_err = _gf_true; - } + eg_t *egp = NULL; + int count = 0; + int error_no_int = 0; + int rand_no = 0; + int ret = 0; + gf_boolean_t should_err = _gf_false; + int error_no_list_size = 0; + + egp = this->private; + + if (egp->random_failure) { + /* + * I honestly don't know why anyone would use this "feature" + * but I'll try to preserve its functionality anyway. Without + * locking twice to update failure_iter_no and egp->op_count + * separately, then not locking at all to update + * egp->failure_iter_no. That's not needed for compatibility, + * and it's abhorrently wrong. I have *some* standards. + */ + LOCK(&egp->lock); + { + count = ++(egp->op_count); + error_no_int = egp->error_no_int; + if ((count % egp->failure_iter_no) == 0) { + egp->op_count = 0; + /* coverity[DC.WEAK_CRYPTO] */ + egp->failure_iter_no = 3 + (rand() % GF_UNIVERSAL_ANSWER); + should_err = _gf_true; + } } - - error_no_list_size = sizeof(error_no_list)/sizeof(error_no_list[0]); - if (should_err) { - if (error_no_int) - ret = error_no_int; - else { - rand_no = generate_rand_no (op_no); - if (op_no >= error_no_list_size) - op_no = 0; - if (rand_no >= error_no_list[op_no].error_no_count) - rand_no = 0; - ret = error_no_list[op_no].error_no[rand_no]; - } + UNLOCK(&egp->lock); + } else { + /* + * It turns out that rand() is almost universally implemented + * as a linear congruential PRNG, which is about as cheap as + * it gets. This gets us real random behavior, including + * phenomena like streaks and dry spells, with controllable + * long-term probability, cheaply. + */ + if ((rand() % FAILURE_GRANULARITY) < egp->failure_iter_no) { + should_err = _gf_true; + } + } + + error_no_list_size = sizeof(error_no_list) / sizeof(error_no_list[0]); + if (should_err) { + if (error_no_int) + ret = error_no_int; + else { + rand_no = generate_rand_no(op_no); + if (op_no >= error_no_list_size) + op_no = 0; + if (rand_no >= error_no_list[op_no].error_no_count) + rand_no = 0; + ret = error_no_list[op_no].error_no[rand_no]; } + } - return ret; + return ret; } int -error_gen_lookup (call_frame_t *frame, xlator_t *this, loc_t *loc, - dict_t *xdata) +error_gen_lookup(call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *xdata) { - int op_errno = 0; - eg_t *egp = NULL; - int enable = 1; - - egp = this->private; - enable = egp->enable[GF_FOP_LOOKUP]; - - if (enable) - op_errno = error_gen (this, GF_FOP_LOOKUP); - - if (op_errno) { - GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno)); - STACK_UNWIND_STRICT (lookup, frame, -1, op_errno, NULL, NULL, NULL, - NULL); - return 0; - } - - STACK_WIND_TAIL (frame, FIRST_CHILD(this), - FIRST_CHILD(this)->fops->lookup, - loc, xdata); + int op_errno = 0; + eg_t *egp = NULL; + int enable = 1; + + egp = this->private; + enable = egp->enable[GF_FOP_LOOKUP]; + + if (enable) + op_errno = error_gen(this, GF_FOP_LOOKUP); + + if (op_errno) { + GF_ERROR(this, "unwind(-1, %s)", strerror(op_errno)); + STACK_UNWIND_STRICT(lookup, frame, -1, op_errno, NULL, NULL, NULL, + NULL); return 0; + } + + STACK_WIND_TAIL(frame, FIRST_CHILD(this), FIRST_CHILD(this)->fops->lookup, + loc, xdata); + return 0; } int -error_gen_stat (call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *xdata) +error_gen_stat(call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *xdata) { - int op_errno = 0; - eg_t *egp = NULL; - int enable = 1; - - egp = this->private; - enable = egp->enable[GF_FOP_STAT]; + int op_errno = 0; + eg_t *egp = NULL; + int enable = 1; - if (enable) - op_errno = error_gen (this, GF_FOP_STAT); + egp = this->private; + enable = egp->enable[GF_FOP_STAT]; - if (op_errno) { - GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno)); - STACK_UNWIND_STRICT (stat, frame, -1, op_errno, NULL, xdata); - return 0; - } + if (enable) + op_errno = error_gen(this, GF_FOP_STAT); - STACK_WIND_TAIL (frame, FIRST_CHILD(this), - FIRST_CHILD(this)->fops->stat, loc, xdata); + if (op_errno) { + GF_ERROR(this, "unwind(-1, %s)", strerror(op_errno)); + STACK_UNWIND_STRICT(stat, frame, -1, op_errno, NULL, xdata); return 0; + } + + STACK_WIND_TAIL(frame, FIRST_CHILD(this), FIRST_CHILD(this)->fops->stat, + loc, xdata); + return 0; } int -error_gen_setattr (call_frame_t *frame, xlator_t *this, loc_t *loc, - struct iatt *stbuf, int32_t valid, dict_t *xdata) +error_gen_setattr(call_frame_t *frame, xlator_t *this, loc_t *loc, + struct iatt *stbuf, int32_t valid, dict_t *xdata) { - int op_errno = 0; - eg_t *egp = NULL; - int enable = 1; - - egp = this->private; - enable = egp->enable[GF_FOP_SETATTR]; + int op_errno = 0; + eg_t *egp = NULL; + int enable = 1; - if (enable) - op_errno = error_gen (this, GF_FOP_SETATTR); + egp = this->private; + enable = egp->enable[GF_FOP_SETATTR]; - if (op_errno) { - GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno)); - STACK_UNWIND_STRICT (setattr, frame, -1, op_errno, NULL, NULL, xdata); - return 0; - } + if (enable) + op_errno = error_gen(this, GF_FOP_SETATTR); - STACK_WIND_TAIL (frame, FIRST_CHILD(this), - FIRST_CHILD(this)->fops->setattr, - loc, stbuf, valid, xdata); + if (op_errno) { + GF_ERROR(this, "unwind(-1, %s)", strerror(op_errno)); + STACK_UNWIND_STRICT(setattr, frame, -1, op_errno, NULL, NULL, xdata); return 0; -} + } + STACK_WIND_TAIL(frame, FIRST_CHILD(this), FIRST_CHILD(this)->fops->setattr, + loc, stbuf, valid, xdata); + return 0; +} int -error_gen_fsetattr (call_frame_t *frame, xlator_t *this, fd_t *fd, - struct iatt *stbuf, int32_t valid, dict_t *xdata) +error_gen_fsetattr(call_frame_t *frame, xlator_t *this, fd_t *fd, + struct iatt *stbuf, int32_t valid, dict_t *xdata) { - int op_errno = 0; - eg_t *egp = NULL; - int enable = 1; - - egp = this->private; - enable = egp->enable[GF_FOP_FSETATTR]; + int op_errno = 0; + eg_t *egp = NULL; + int enable = 1; - if (enable) - op_errno = error_gen (this, GF_FOP_FSETATTR); + egp = this->private; + enable = egp->enable[GF_FOP_FSETATTR]; - if (op_errno) { - GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno)); - STACK_UNWIND_STRICT (fsetattr, frame, -1, op_errno, NULL, NULL, xdata); - return 0; - } + if (enable) + op_errno = error_gen(this, GF_FOP_FSETATTR); - STACK_WIND_TAIL (frame, FIRST_CHILD(this), - FIRST_CHILD(this)->fops->fsetattr, - fd, stbuf, valid, xdata); + if (op_errno) { + GF_ERROR(this, "unwind(-1, %s)", strerror(op_errno)); + STACK_UNWIND_STRICT(fsetattr, frame, -1, op_errno, NULL, NULL, xdata); return 0; + } + + STACK_WIND_TAIL(frame, FIRST_CHILD(this), FIRST_CHILD(this)->fops->fsetattr, + fd, stbuf, valid, xdata); + return 0; } int -error_gen_truncate (call_frame_t *frame, xlator_t *this, loc_t *loc, - off_t offset, dict_t *xdata) +error_gen_truncate(call_frame_t *frame, xlator_t *this, loc_t *loc, + off_t offset, dict_t *xdata) { - int op_errno = 0; - eg_t *egp = NULL; - int enable = 1; - - egp = this->private; - enable = egp->enable[GF_FOP_TRUNCATE]; - - if (enable) - op_errno = error_gen (this, GF_FOP_TRUNCATE); - - if (op_errno) { - GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno)); - STACK_UNWIND_STRICT (truncate, frame, -1, op_errno, - NULL, NULL, xdata); - return 0; - } - - STACK_WIND_TAIL (frame, FIRST_CHILD(this), - FIRST_CHILD(this)->fops->truncate, - loc, offset, xdata); + int op_errno = 0; + eg_t *egp = NULL; + int enable = 1; + + egp = this->private; + enable = egp->enable[GF_FOP_TRUNCATE]; + + if (enable) + op_errno = error_gen(this, GF_FOP_TRUNCATE); + + if (op_errno) { + GF_ERROR(this, "unwind(-1, %s)", strerror(op_errno)); + STACK_UNWIND_STRICT(truncate, frame, -1, op_errno, NULL, NULL, xdata); return 0; + } + + STACK_WIND_TAIL(frame, FIRST_CHILD(this), FIRST_CHILD(this)->fops->truncate, + loc, offset, xdata); + return 0; } int -error_gen_ftruncate (call_frame_t *frame, xlator_t *this, fd_t *fd, - off_t offset, dict_t *xdata) +error_gen_ftruncate(call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset, + dict_t *xdata) { - int op_errno = 0; - eg_t *egp =NULL; - int enable = 1; - - egp = this->private; - enable = egp->enable[GF_FOP_FTRUNCATE]; - - if (enable) - op_errno = error_gen (this, GF_FOP_FTRUNCATE); - - if (op_errno) { - GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno)); - STACK_UNWIND_STRICT (ftruncate, frame, -1, op_errno, - NULL, NULL, xdata); - return 0; - } - - STACK_WIND_TAIL (frame, FIRST_CHILD(this), - FIRST_CHILD(this)->fops->ftruncate, - fd, offset, xdata); + int op_errno = 0; + eg_t *egp = NULL; + int enable = 1; + + egp = this->private; + enable = egp->enable[GF_FOP_FTRUNCATE]; + + if (enable) + op_errno = error_gen(this, GF_FOP_FTRUNCATE); + + if (op_errno) { + GF_ERROR(this, "unwind(-1, %s)", strerror(op_errno)); + STACK_UNWIND_STRICT(ftruncate, frame, -1, op_errno, NULL, NULL, xdata); return 0; + } + + STACK_WIND_TAIL(frame, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->ftruncate, fd, offset, xdata); + return 0; } int -error_gen_access (call_frame_t *frame, xlator_t *this, loc_t *loc, - int32_t mask, dict_t *xdata) +error_gen_access(call_frame_t *frame, xlator_t *this, loc_t *loc, int32_t mask, + dict_t *xdata) { - int op_errno = 0; - eg_t *egp = NULL; - int enable = 1; + int op_errno = 0; + eg_t *egp = NULL; + int enable = 1; - egp = this->private; - enable = egp->enable[GF_FOP_ACCESS]; + egp = this->private; + enable = egp->enable[GF_FOP_ACCESS]; - if (enable) - op_errno = error_gen (this, GF_FOP_ACCESS); + if (enable) + op_errno = error_gen(this, GF_FOP_ACCESS); - if (op_errno) { - GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno)); - STACK_UNWIND_STRICT (access, frame, -1, op_errno, xdata); - return 0; - } - - STACK_WIND_TAIL (frame, FIRST_CHILD(this), - FIRST_CHILD(this)->fops->access, - loc, mask, xdata); + if (op_errno) { + GF_ERROR(this, "unwind(-1, %s)", strerror(op_errno)); + STACK_UNWIND_STRICT(access, frame, -1, op_errno, xdata); return 0; + } + + STACK_WIND_TAIL(frame, FIRST_CHILD(this), FIRST_CHILD(this)->fops->access, + loc, mask, xdata); + return 0; } int -error_gen_readlink (call_frame_t *frame, xlator_t *this, loc_t *loc, - size_t size, dict_t *xdata) +error_gen_readlink(call_frame_t *frame, xlator_t *this, loc_t *loc, size_t size, + dict_t *xdata) { - int op_errno = 0; - eg_t *egp = NULL; - int enable = 1; - - egp = this->private; - enable = egp->enable[GF_FOP_READLINK]; + int op_errno = 0; + eg_t *egp = NULL; + int enable = 1; - if (enable) - op_errno = error_gen (this, GF_FOP_READLINK); + egp = this->private; + enable = egp->enable[GF_FOP_READLINK]; - if (op_errno) { - GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno)); - STACK_UNWIND_STRICT (readlink, frame, -1, op_errno, NULL, NULL, xdata); - return 0; - } + if (enable) + op_errno = error_gen(this, GF_FOP_READLINK); - STACK_WIND_TAIL (frame, FIRST_CHILD(this), - FIRST_CHILD(this)->fops->readlink, - loc, size, xdata); + if (op_errno) { + GF_ERROR(this, "unwind(-1, %s)", strerror(op_errno)); + STACK_UNWIND_STRICT(readlink, frame, -1, op_errno, NULL, NULL, xdata); return 0; + } + + STACK_WIND_TAIL(frame, FIRST_CHILD(this), FIRST_CHILD(this)->fops->readlink, + loc, size, xdata); + return 0; } int -error_gen_mknod (call_frame_t *frame, xlator_t *this, loc_t *loc, - mode_t mode, dev_t rdev, mode_t umask, dict_t *xdata) +error_gen_mknod(call_frame_t *frame, xlator_t *this, loc_t *loc, mode_t mode, + dev_t rdev, mode_t umask, dict_t *xdata) { - int op_errno = 0; - eg_t *egp = NULL; - int enable = 1; - - egp = this->private; - enable = egp->enable[GF_FOP_MKNOD]; - - if (enable) - op_errno = error_gen (this, GF_FOP_MKNOD); - - if (op_errno) { - GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno)); - STACK_UNWIND_STRICT (mknod, frame, -1, op_errno, NULL, NULL, - NULL, NULL, xdata); - return 0; - } - - STACK_WIND_TAIL (frame, FIRST_CHILD(this), - FIRST_CHILD(this)->fops->mknod, - loc, mode, rdev, umask, xdata); + int op_errno = 0; + eg_t *egp = NULL; + int enable = 1; + + egp = this->private; + enable = egp->enable[GF_FOP_MKNOD]; + + if (enable) + op_errno = error_gen(this, GF_FOP_MKNOD); + + if (op_errno) { + GF_ERROR(this, "unwind(-1, %s)", strerror(op_errno)); + STACK_UNWIND_STRICT(mknod, frame, -1, op_errno, NULL, NULL, NULL, NULL, + xdata); return 0; + } + + STACK_WIND_TAIL(frame, FIRST_CHILD(this), FIRST_CHILD(this)->fops->mknod, + loc, mode, rdev, umask, xdata); + return 0; } int -error_gen_mkdir (call_frame_t *frame, xlator_t *this, - loc_t *loc, mode_t mode, mode_t umask, dict_t *xdata) +error_gen_mkdir(call_frame_t *frame, xlator_t *this, loc_t *loc, mode_t mode, + mode_t umask, dict_t *xdata) { - int op_errno = 0; - eg_t *egp = NULL; - int enable = 1; - - egp = this->private; - enable = egp->enable[GF_FOP_MKDIR]; - - if (enable) - op_errno = error_gen (this, GF_FOP_MKDIR); - - if (op_errno) { - GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno)); - STACK_UNWIND_STRICT (mkdir, frame, -1, op_errno, NULL, NULL, - NULL, NULL, xdata); - return 0; - } - - STACK_WIND_TAIL (frame, FIRST_CHILD(this), - FIRST_CHILD(this)->fops->mkdir, - loc, mode, umask, xdata); + int op_errno = 0; + eg_t *egp = NULL; + int enable = 1; + + egp = this->private; + enable = egp->enable[GF_FOP_MKDIR]; + + if (enable) + op_errno = error_gen(this, GF_FOP_MKDIR); + + if (op_errno) { + GF_ERROR(this, "unwind(-1, %s)", strerror(op_errno)); + STACK_UNWIND_STRICT(mkdir, frame, -1, op_errno, NULL, NULL, NULL, NULL, + xdata); return 0; + } + + STACK_WIND_TAIL(frame, FIRST_CHILD(this), FIRST_CHILD(this)->fops->mkdir, + loc, mode, umask, xdata); + return 0; } int -error_gen_unlink (call_frame_t *frame, xlator_t *this, loc_t *loc, int xflag, - dict_t *xdata) +error_gen_unlink(call_frame_t *frame, xlator_t *this, loc_t *loc, int xflag, + dict_t *xdata) { - int op_errno = 0; - eg_t *egp = NULL; - int enable = 1; - - egp = this->private; - enable = egp->enable[GF_FOP_UNLINK]; - - if (enable) - op_errno = error_gen (this, GF_FOP_UNLINK); - - if (op_errno) { - GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno)); - STACK_UNWIND_STRICT (unlink, frame, -1, op_errno, NULL, NULL, - xdata); - return 0; - } - - STACK_WIND_TAIL (frame, FIRST_CHILD(this), - FIRST_CHILD(this)->fops->unlink, - loc, xflag, xdata); + int op_errno = 0; + eg_t *egp = NULL; + int enable = 1; + + egp = this->private; + enable = egp->enable[GF_FOP_UNLINK]; + + if (enable) + op_errno = error_gen(this, GF_FOP_UNLINK); + + if (op_errno) { + GF_ERROR(this, "unwind(-1, %s)", strerror(op_errno)); + STACK_UNWIND_STRICT(unlink, frame, -1, op_errno, NULL, NULL, xdata); return 0; + } + + STACK_WIND_TAIL(frame, FIRST_CHILD(this), FIRST_CHILD(this)->fops->unlink, + loc, xflag, xdata); + return 0; } int -error_gen_rmdir (call_frame_t *frame, xlator_t *this, loc_t *loc, int flags, - dict_t *xdata) +error_gen_rmdir(call_frame_t *frame, xlator_t *this, loc_t *loc, int flags, + dict_t *xdata) { - int op_errno = 0; - eg_t *egp = NULL; - int enable = 1; + int op_errno = 0; + eg_t *egp = NULL; + int enable = 1; - egp = this->private; - enable = egp->enable[GF_FOP_RMDIR]; + egp = this->private; + enable = egp->enable[GF_FOP_RMDIR]; - if (enable) - op_errno = error_gen (this, GF_FOP_RMDIR); + if (enable) + op_errno = error_gen(this, GF_FOP_RMDIR); - if (op_errno) { - GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno)); - STACK_UNWIND_STRICT (rmdir, frame, -1, op_errno, NULL, NULL, xdata); - return 0; - } - - STACK_WIND_TAIL (frame, FIRST_CHILD(this), - FIRST_CHILD(this)->fops->rmdir, - loc, flags, xdata); + if (op_errno) { + GF_ERROR(this, "unwind(-1, %s)", strerror(op_errno)); + STACK_UNWIND_STRICT(rmdir, frame, -1, op_errno, NULL, NULL, xdata); return 0; + } + + STACK_WIND_TAIL(frame, FIRST_CHILD(this), FIRST_CHILD(this)->fops->rmdir, + loc, flags, xdata); + return 0; } int -error_gen_symlink (call_frame_t *frame, xlator_t *this, const char *linkpath, - loc_t *loc, mode_t umask, dict_t *xdata) +error_gen_symlink(call_frame_t *frame, xlator_t *this, const char *linkpath, + loc_t *loc, mode_t umask, dict_t *xdata) { - int op_errno = 0; - eg_t *egp = NULL; - int enable = 1; - - egp = this->private; - enable = egp->enable[GF_FOP_SYMLINK]; - - if (enable) - op_errno = error_gen (this, GF_FOP_SYMLINK); - - if (op_errno) { - GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno)); - STACK_UNWIND_STRICT (symlink, frame, -1, op_errno, NULL, NULL, - NULL, NULL, NULL); /* pre & post parent attr */ - return 0; - } - - STACK_WIND_TAIL (frame, FIRST_CHILD(this), - FIRST_CHILD(this)->fops->symlink, - linkpath, loc, umask, xdata); + int op_errno = 0; + eg_t *egp = NULL; + int enable = 1; + + egp = this->private; + enable = egp->enable[GF_FOP_SYMLINK]; + + if (enable) + op_errno = error_gen(this, GF_FOP_SYMLINK); + + if (op_errno) { + GF_ERROR(this, "unwind(-1, %s)", strerror(op_errno)); + STACK_UNWIND_STRICT(symlink, frame, -1, op_errno, NULL, NULL, NULL, + NULL, NULL); /* pre & post parent attr */ return 0; + } + + STACK_WIND_TAIL(frame, FIRST_CHILD(this), FIRST_CHILD(this)->fops->symlink, + linkpath, loc, umask, xdata); + return 0; } int -error_gen_rename (call_frame_t *frame, xlator_t *this, - loc_t *oldloc, loc_t *newloc, dict_t *xdata) +error_gen_rename(call_frame_t *frame, xlator_t *this, loc_t *oldloc, + loc_t *newloc, dict_t *xdata) { - int op_errno = 0; - eg_t *egp = NULL; - int enable = 1; - - egp = this->private; - enable = egp->enable[GF_FOP_RENAME]; - - if (enable) - op_errno = error_gen (this, GF_FOP_RENAME); - - if (op_errno) { - GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno)); - STACK_UNWIND_STRICT (rename, frame, -1, op_errno, NULL, - NULL, NULL, NULL, NULL, NULL); - return 0; - } - - STACK_WIND_TAIL (frame, FIRST_CHILD(this), - FIRST_CHILD(this)->fops->rename, - oldloc, newloc, xdata); + int op_errno = 0; + eg_t *egp = NULL; + int enable = 1; + + egp = this->private; + enable = egp->enable[GF_FOP_RENAME]; + + if (enable) + op_errno = error_gen(this, GF_FOP_RENAME); + + if (op_errno) { + GF_ERROR(this, "unwind(-1, %s)", strerror(op_errno)); + STACK_UNWIND_STRICT(rename, frame, -1, op_errno, NULL, NULL, NULL, NULL, + NULL, NULL); return 0; + } + + STACK_WIND_TAIL(frame, FIRST_CHILD(this), FIRST_CHILD(this)->fops->rename, + oldloc, newloc, xdata); + return 0; } int -error_gen_link (call_frame_t *frame, xlator_t *this, - loc_t *oldloc, loc_t *newloc, dict_t *xdata) +error_gen_link(call_frame_t *frame, xlator_t *this, loc_t *oldloc, + loc_t *newloc, dict_t *xdata) { - int op_errno = 0; - eg_t *egp = NULL; - int enable = 1; - - egp = this->private; - enable = egp->enable[GF_FOP_LINK]; - - if (enable) - op_errno = error_gen (this, GF_FOP_LINK); - - if (op_errno) { - GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno)); - STACK_UNWIND_STRICT (link, frame, -1, op_errno, NULL, NULL, - NULL, NULL, NULL); - return 0; - } - - STACK_WIND_TAIL (frame, FIRST_CHILD(this), - FIRST_CHILD(this)->fops->link, - oldloc, newloc, xdata); + int op_errno = 0; + eg_t *egp = NULL; + int enable = 1; + + egp = this->private; + enable = egp->enable[GF_FOP_LINK]; + + if (enable) + op_errno = error_gen(this, GF_FOP_LINK); + + if (op_errno) { + GF_ERROR(this, "unwind(-1, %s)", strerror(op_errno)); + STACK_UNWIND_STRICT(link, frame, -1, op_errno, NULL, NULL, NULL, NULL, + NULL); return 0; + } + + STACK_WIND_TAIL(frame, FIRST_CHILD(this), FIRST_CHILD(this)->fops->link, + oldloc, newloc, xdata); + return 0; } int -error_gen_create (call_frame_t *frame, xlator_t *this, loc_t *loc, - int32_t flags, mode_t mode, mode_t umask, fd_t *fd, - dict_t *xdata) +error_gen_create(call_frame_t *frame, xlator_t *this, loc_t *loc, int32_t flags, + mode_t mode, mode_t umask, fd_t *fd, dict_t *xdata) { - int op_errno = 0; - eg_t *egp = NULL; - int enable = 1; - - egp = this->private; - enable = egp->enable[GF_FOP_CREATE]; - - if (enable) - op_errno = error_gen (this, GF_FOP_CREATE); - - if (op_errno) { - GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno)); - STACK_UNWIND_STRICT (create, frame, -1, op_errno, NULL, NULL, - NULL, NULL, NULL, NULL); - return 0; - } - - STACK_WIND_TAIL (frame, FIRST_CHILD(this), - FIRST_CHILD(this)->fops->create, - loc, flags, mode, umask, fd, xdata); + int op_errno = 0; + eg_t *egp = NULL; + int enable = 1; + + egp = this->private; + enable = egp->enable[GF_FOP_CREATE]; + + if (enable) + op_errno = error_gen(this, GF_FOP_CREATE); + + if (op_errno) { + GF_ERROR(this, "unwind(-1, %s)", strerror(op_errno)); + STACK_UNWIND_STRICT(create, frame, -1, op_errno, NULL, NULL, NULL, NULL, + NULL, NULL); return 0; + } + + STACK_WIND_TAIL(frame, FIRST_CHILD(this), FIRST_CHILD(this)->fops->create, + loc, flags, mode, umask, fd, xdata); + return 0; } int -error_gen_open (call_frame_t *frame, xlator_t *this, loc_t *loc, - int32_t flags, fd_t *fd, dict_t *xdata) +error_gen_open(call_frame_t *frame, xlator_t *this, loc_t *loc, int32_t flags, + fd_t *fd, dict_t *xdata) { - int op_errno = 0; - eg_t *egp = NULL; - int enable = 1; - - egp = this->private; - enable = egp->enable[GF_FOP_OPEN]; + int op_errno = 0; + eg_t *egp = NULL; + int enable = 1; - if (enable) - op_errno = error_gen (this, GF_FOP_OPEN); + egp = this->private; + enable = egp->enable[GF_FOP_OPEN]; - if (op_errno) { - GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno)); - STACK_UNWIND_STRICT (open, frame, -1, op_errno, NULL, xdata); - return 0; - } + if (enable) + op_errno = error_gen(this, GF_FOP_OPEN); - STACK_WIND_TAIL (frame, FIRST_CHILD(this), - FIRST_CHILD(this)->fops->open, - loc, flags, fd, xdata); + if (op_errno) { + GF_ERROR(this, "unwind(-1, %s)", strerror(op_errno)); + STACK_UNWIND_STRICT(open, frame, -1, op_errno, NULL, xdata); return 0; + } + + STACK_WIND_TAIL(frame, FIRST_CHILD(this), FIRST_CHILD(this)->fops->open, + loc, flags, fd, xdata); + return 0; } int -error_gen_readv (call_frame_t *frame, xlator_t *this, - fd_t *fd, size_t size, off_t offset, uint32_t flags, dict_t *xdata) +error_gen_readv(call_frame_t *frame, xlator_t *this, fd_t *fd, size_t size, + off_t offset, uint32_t flags, dict_t *xdata) { - int op_errno = 0; - eg_t *egp = NULL; - int enable = 1; - - egp = this->private; - enable = egp->enable[GF_FOP_READ]; - - if (enable) - op_errno = error_gen (this, GF_FOP_READ); - - if (op_errno) { - GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno)); - STACK_UNWIND_STRICT (readv, frame, -1, op_errno, NULL, 0, - NULL, NULL, xdata); - return 0; - } - - STACK_WIND_TAIL (frame, FIRST_CHILD(this), - FIRST_CHILD(this)->fops->readv, - fd, size, offset, flags, xdata); + int op_errno = 0; + eg_t *egp = NULL; + int enable = 1; + + egp = this->private; + enable = egp->enable[GF_FOP_READ]; + + if (enable) + op_errno = error_gen(this, GF_FOP_READ); + + if (op_errno) { + GF_ERROR(this, "unwind(-1, %s)", strerror(op_errno)); + STACK_UNWIND_STRICT(readv, frame, -1, op_errno, NULL, 0, NULL, NULL, + xdata); return 0; + } + + STACK_WIND_TAIL(frame, FIRST_CHILD(this), FIRST_CHILD(this)->fops->readv, + fd, size, offset, flags, xdata); + return 0; } int -error_gen_writev (call_frame_t *frame, xlator_t *this, fd_t *fd, - struct iovec *vector, int32_t count, - off_t off, uint32_t flags, struct iobref *iobref, dict_t *xdata) +error_gen_writev(call_frame_t *frame, xlator_t *this, fd_t *fd, + struct iovec *vector, int32_t count, off_t off, uint32_t flags, + struct iobref *iobref, dict_t *xdata) { - int op_errno = 0; - eg_t *egp = NULL; - int enable = 1; - struct iovec *shortvec = NULL; - - egp = this->private; - enable = egp->enable[GF_FOP_WRITE]; - - if (enable) - op_errno = error_gen (this, GF_FOP_WRITE); - - if (op_errno == GF_ERROR_SHORT_WRITE) { - - /* - * A short write error returns some value less than what was - * requested from a write. To simulate this, replace the vector - * with one half the size; - */ - shortvec = iov_dup(vector, 1); - shortvec->iov_len /= 2; - goto wind; - } else if (op_errno) { - GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno)); - STACK_UNWIND_STRICT (writev, frame, -1, op_errno, NULL, NULL, xdata); - return 0; - } + int op_errno = 0; + eg_t *egp = NULL; + int enable = 1; + struct iovec *shortvec = NULL; + + egp = this->private; + enable = egp->enable[GF_FOP_WRITE]; + + if (enable) + op_errno = error_gen(this, GF_FOP_WRITE); + + if (op_errno == GF_ERROR_SHORT_WRITE) { + /* + * A short write error returns some value less than what was + * requested from a write. To simulate this, replace the vector + * with one half the size; + */ + shortvec = iov_dup(vector, 1); + shortvec->iov_len /= 2; + goto wind; + } else if (op_errno) { + GF_ERROR(this, "unwind(-1, %s)", strerror(op_errno)); + STACK_UNWIND_STRICT(writev, frame, -1, op_errno, NULL, NULL, xdata); + return 0; + } wind: - STACK_WIND_TAIL (frame, FIRST_CHILD(this), - FIRST_CHILD(this)->fops->writev, - fd, shortvec?shortvec:vector, - count, off, flags, iobref, xdata); + STACK_WIND_TAIL(frame, FIRST_CHILD(this), FIRST_CHILD(this)->fops->writev, + fd, shortvec ? shortvec : vector, count, off, flags, iobref, + xdata); - if (shortvec) - GF_FREE (shortvec); - return 0; + if (shortvec) + GF_FREE(shortvec); + return 0; } int -error_gen_flush (call_frame_t *frame, xlator_t *this, fd_t *fd, dict_t *xdata) +error_gen_flush(call_frame_t *frame, xlator_t *this, fd_t *fd, dict_t *xdata) { - int op_errno = 0; - eg_t *egp = NULL; - int enable = 1; + int op_errno = 0; + eg_t *egp = NULL; + int enable = 1; - egp = this->private; - enable = egp->enable[GF_FOP_FLUSH]; + egp = this->private; + enable = egp->enable[GF_FOP_FLUSH]; - if (enable) - op_errno = error_gen (this, GF_FOP_FLUSH); + if (enable) + op_errno = error_gen(this, GF_FOP_FLUSH); - if (op_errno) { - GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno)); - STACK_UNWIND_STRICT (flush, frame, -1, op_errno, xdata); - return 0; - } - - STACK_WIND_TAIL (frame, FIRST_CHILD(this), - FIRST_CHILD(this)->fops->flush, - fd, xdata); + if (op_errno) { + GF_ERROR(this, "unwind(-1, %s)", strerror(op_errno)); + STACK_UNWIND_STRICT(flush, frame, -1, op_errno, xdata); return 0; + } + + STACK_WIND_TAIL(frame, FIRST_CHILD(this), FIRST_CHILD(this)->fops->flush, + fd, xdata); + return 0; } int -error_gen_fsync (call_frame_t *frame, xlator_t *this, fd_t *fd, int32_t flags, dict_t *xdata) +error_gen_fsync(call_frame_t *frame, xlator_t *this, fd_t *fd, int32_t flags, + dict_t *xdata) { - int op_errno = 0; - eg_t *egp = NULL; - int enable = 1; - - egp = this->private; - enable = egp->enable[GF_FOP_FSYNC]; + int op_errno = 0; + eg_t *egp = NULL; + int enable = 1; - if (enable) - op_errno = error_gen (this, GF_FOP_FSYNC); + egp = this->private; + enable = egp->enable[GF_FOP_FSYNC]; - if (op_errno) { - GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno)); - STACK_UNWIND_STRICT (fsync, frame, -1, op_errno, NULL, NULL, xdata); - return 0; - } + if (enable) + op_errno = error_gen(this, GF_FOP_FSYNC); - STACK_WIND_TAIL (frame, FIRST_CHILD(this), - FIRST_CHILD(this)->fops->fsync, - fd, flags, xdata); + if (op_errno) { + GF_ERROR(this, "unwind(-1, %s)", strerror(op_errno)); + STACK_UNWIND_STRICT(fsync, frame, -1, op_errno, NULL, NULL, xdata); return 0; + } + + STACK_WIND_TAIL(frame, FIRST_CHILD(this), FIRST_CHILD(this)->fops->fsync, + fd, flags, xdata); + return 0; } int -error_gen_fstat (call_frame_t *frame, xlator_t *this, fd_t *fd, dict_t *xdata) +error_gen_fstat(call_frame_t *frame, xlator_t *this, fd_t *fd, dict_t *xdata) { - int op_errno = 0; - eg_t *egp = NULL; - int enable = 1; - - egp = this->private; - enable = egp->enable[GF_FOP_FSTAT]; + int op_errno = 0; + eg_t *egp = NULL; + int enable = 1; - if (enable) - op_errno = error_gen (this, GF_FOP_FSTAT); + egp = this->private; + enable = egp->enable[GF_FOP_FSTAT]; - if (op_errno) { - GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno)); - STACK_UNWIND_STRICT (fstat, frame, -1, op_errno, NULL, xdata); - return 0; - } + if (enable) + op_errno = error_gen(this, GF_FOP_FSTAT); - STACK_WIND_TAIL (frame, FIRST_CHILD(this), - FIRST_CHILD(this)->fops->fstat, - fd, xdata); + if (op_errno) { + GF_ERROR(this, "unwind(-1, %s)", strerror(op_errno)); + STACK_UNWIND_STRICT(fstat, frame, -1, op_errno, NULL, xdata); return 0; + } + + STACK_WIND_TAIL(frame, FIRST_CHILD(this), FIRST_CHILD(this)->fops->fstat, + fd, xdata); + return 0; } int -error_gen_opendir (call_frame_t *frame, xlator_t *this, loc_t *loc, fd_t *fd, dict_t *xdata) +error_gen_opendir(call_frame_t *frame, xlator_t *this, loc_t *loc, fd_t *fd, + dict_t *xdata) { - int op_errno = 0; - eg_t *egp = NULL; - int enable = 1; - - egp = this->private; - enable = egp->enable[GF_FOP_OPENDIR]; + int op_errno = 0; + eg_t *egp = NULL; + int enable = 1; - if (enable) - op_errno = error_gen (this, GF_FOP_OPENDIR); + egp = this->private; + enable = egp->enable[GF_FOP_OPENDIR]; - if (op_errno) { - GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno)); - STACK_UNWIND_STRICT (opendir, frame, -1, op_errno, NULL, xdata); - return 0; - } + if (enable) + op_errno = error_gen(this, GF_FOP_OPENDIR); - STACK_WIND_TAIL (frame, FIRST_CHILD(this), - FIRST_CHILD(this)->fops->opendir, - loc, fd, xdata); + if (op_errno) { + GF_ERROR(this, "unwind(-1, %s)", strerror(op_errno)); + STACK_UNWIND_STRICT(opendir, frame, -1, op_errno, NULL, xdata); return 0; + } + + STACK_WIND_TAIL(frame, FIRST_CHILD(this), FIRST_CHILD(this)->fops->opendir, + loc, fd, xdata); + return 0; } int -error_gen_fsyncdir (call_frame_t *frame, xlator_t *this, fd_t *fd, - int32_t flags, dict_t *xdata) +error_gen_fsyncdir(call_frame_t *frame, xlator_t *this, fd_t *fd, int32_t flags, + dict_t *xdata) { - int op_errno = 0; - eg_t *egp = NULL; - int enable = 1; + int op_errno = 0; + eg_t *egp = NULL; + int enable = 1; - egp = this->private; - enable = egp->enable[GF_FOP_FSYNCDIR]; + egp = this->private; + enable = egp->enable[GF_FOP_FSYNCDIR]; - if (enable) - op_errno = error_gen (this, GF_FOP_FSYNCDIR); + if (enable) + op_errno = error_gen(this, GF_FOP_FSYNCDIR); - if (op_errno) { - GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno)); - STACK_UNWIND_STRICT (fsyncdir, frame, -1, op_errno, xdata); - return 0; - } - - STACK_WIND_TAIL (frame, FIRST_CHILD(this), - FIRST_CHILD(this)->fops->fsyncdir, - fd, flags, xdata); + if (op_errno) { + GF_ERROR(this, "unwind(-1, %s)", strerror(op_errno)); + STACK_UNWIND_STRICT(fsyncdir, frame, -1, op_errno, xdata); return 0; + } + + STACK_WIND_TAIL(frame, FIRST_CHILD(this), FIRST_CHILD(this)->fops->fsyncdir, + fd, flags, xdata); + return 0; } int -error_gen_statfs (call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *xdata) +error_gen_statfs(call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *xdata) { - int op_errno = 0; - eg_t *egp = NULL; - int enable = 1; - - egp = this->private; - enable = egp->enable[GF_FOP_STATFS]; + int op_errno = 0; + eg_t *egp = NULL; + int enable = 1; - if (enable) - op_errno = error_gen (this, GF_FOP_STATFS); + egp = this->private; + enable = egp->enable[GF_FOP_STATFS]; - if (op_errno) { - GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno)); - STACK_UNWIND_STRICT (statfs, frame, -1, op_errno, NULL, xdata); - return 0; - } + if (enable) + op_errno = error_gen(this, GF_FOP_STATFS); - STACK_WIND_TAIL (frame, FIRST_CHILD(this), - FIRST_CHILD(this)->fops->statfs, - loc, xdata); + if (op_errno) { + GF_ERROR(this, "unwind(-1, %s)", strerror(op_errno)); + STACK_UNWIND_STRICT(statfs, frame, -1, op_errno, NULL, xdata); return 0; + } + + STACK_WIND_TAIL(frame, FIRST_CHILD(this), FIRST_CHILD(this)->fops->statfs, + loc, xdata); + return 0; } int -error_gen_setxattr (call_frame_t *frame, xlator_t *this, loc_t *loc, - dict_t *dict, int32_t flags, dict_t *xdata) +error_gen_setxattr(call_frame_t *frame, xlator_t *this, loc_t *loc, + dict_t *dict, int32_t flags, dict_t *xdata) { - int op_errno = 0; - eg_t *egp = NULL; - int enable = 1; - - egp = this->private; - enable = egp->enable[GF_FOP_SETXATTR]; + int op_errno = 0; + eg_t *egp = NULL; + int enable = 1; - if (enable) - op_errno = error_gen (this, GF_FOP_SETXATTR); + egp = this->private; + enable = egp->enable[GF_FOP_SETXATTR]; - if (op_errno) { - GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno)); - STACK_UNWIND_STRICT (setxattr, frame, -1, op_errno, xdata); - return 0; - } + if (enable) + op_errno = error_gen(this, GF_FOP_SETXATTR); - STACK_WIND_TAIL (frame, FIRST_CHILD(this), - FIRST_CHILD(this)->fops->setxattr, - loc, dict, flags, xdata); + if (op_errno) { + GF_ERROR(this, "unwind(-1, %s)", strerror(op_errno)); + STACK_UNWIND_STRICT(setxattr, frame, -1, op_errno, xdata); return 0; + } + + STACK_WIND_TAIL(frame, FIRST_CHILD(this), FIRST_CHILD(this)->fops->setxattr, + loc, dict, flags, xdata); + return 0; } int -error_gen_getxattr (call_frame_t *frame, xlator_t *this, loc_t *loc, - const char *name, dict_t *xdata) +error_gen_getxattr(call_frame_t *frame, xlator_t *this, loc_t *loc, + const char *name, dict_t *xdata) { - int op_errno = 0; - eg_t *egp = NULL; - int enable = 1; - - egp = this->private; - enable = egp->enable[GF_FOP_GETXATTR]; + int op_errno = 0; + eg_t *egp = NULL; + int enable = 1; - if (enable) - op_errno = error_gen (this, GF_FOP_GETXATTR); + egp = this->private; + enable = egp->enable[GF_FOP_GETXATTR]; - if (op_errno) { - GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno)); - STACK_UNWIND_STRICT (getxattr, frame, -1, op_errno, NULL, xdata); - return 0; - } + if (enable) + op_errno = error_gen(this, GF_FOP_GETXATTR); - STACK_WIND_TAIL (frame, FIRST_CHILD(this), - FIRST_CHILD(this)->fops->getxattr, - loc, name, xdata); + if (op_errno) { + GF_ERROR(this, "unwind(-1, %s)", strerror(op_errno)); + STACK_UNWIND_STRICT(getxattr, frame, -1, op_errno, NULL, xdata); return 0; + } + + STACK_WIND_TAIL(frame, FIRST_CHILD(this), FIRST_CHILD(this)->fops->getxattr, + loc, name, xdata); + return 0; } int -error_gen_fsetxattr (call_frame_t *frame, xlator_t *this, fd_t *fd, - dict_t *dict, int32_t flags, dict_t *xdata) +error_gen_fsetxattr(call_frame_t *frame, xlator_t *this, fd_t *fd, dict_t *dict, + int32_t flags, dict_t *xdata) { - int op_errno = 0; - eg_t *egp = NULL; - int enable = 1; + int op_errno = 0; + eg_t *egp = NULL; + int enable = 1; - egp = this->private; - enable = egp->enable[GF_FOP_FSETXATTR]; + egp = this->private; + enable = egp->enable[GF_FOP_FSETXATTR]; - if (enable) - op_errno = error_gen (this, GF_FOP_FSETXATTR); + if (enable) + op_errno = error_gen(this, GF_FOP_FSETXATTR); - if (op_errno) { - GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno)); - STACK_UNWIND_STRICT (fsetxattr, frame, -1, op_errno, xdata); - return 0; - } - - STACK_WIND_TAIL (frame, FIRST_CHILD(this), - FIRST_CHILD(this)->fops->fsetxattr, - fd, dict, flags, xdata); + if (op_errno) { + GF_ERROR(this, "unwind(-1, %s)", strerror(op_errno)); + STACK_UNWIND_STRICT(fsetxattr, frame, -1, op_errno, xdata); return 0; + } + + STACK_WIND_TAIL(frame, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->fsetxattr, fd, dict, flags, xdata); + return 0; } int -error_gen_fgetxattr (call_frame_t *frame, xlator_t *this, fd_t *fd, - const char *name, dict_t *xdata) +error_gen_fgetxattr(call_frame_t *frame, xlator_t *this, fd_t *fd, + const char *name, dict_t *xdata) { - int op_errno = 0; - eg_t *egp = NULL; - int enable = 1; - - egp = this->private; - enable = egp->enable[GF_FOP_FGETXATTR]; + int op_errno = 0; + eg_t *egp = NULL; + int enable = 1; - if (enable) - op_errno = error_gen (this, GF_FOP_FGETXATTR); + egp = this->private; + enable = egp->enable[GF_FOP_FGETXATTR]; - if (op_errno) { - GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno)); - STACK_UNWIND_STRICT (fgetxattr, frame, -1, op_errno, NULL, xdata); - return 0; - } + if (enable) + op_errno = error_gen(this, GF_FOP_FGETXATTR); - STACK_WIND_TAIL (frame, FIRST_CHILD(this), - FIRST_CHILD(this)->fops->fgetxattr, - fd, name, xdata); + if (op_errno) { + GF_ERROR(this, "unwind(-1, %s)", strerror(op_errno)); + STACK_UNWIND_STRICT(fgetxattr, frame, -1, op_errno, NULL, xdata); return 0; + } + + STACK_WIND_TAIL(frame, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->fgetxattr, fd, name, xdata); + return 0; } int -error_gen_xattrop (call_frame_t *frame, xlator_t *this, loc_t *loc, - gf_xattrop_flags_t flags, dict_t *dict, dict_t *xdata) +error_gen_xattrop(call_frame_t *frame, xlator_t *this, loc_t *loc, + gf_xattrop_flags_t flags, dict_t *dict, dict_t *xdata) { - int op_errno = 0; - eg_t *egp = NULL; - int enable = 1; - - egp = this->private; - enable = egp->enable[GF_FOP_XATTROP]; + int op_errno = 0; + eg_t *egp = NULL; + int enable = 1; - if (enable) - op_errno = error_gen (this, GF_FOP_XATTROP); + egp = this->private; + enable = egp->enable[GF_FOP_XATTROP]; - if (op_errno) { - GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno)); - STACK_UNWIND_STRICT (xattrop, frame, -1, op_errno, NULL, xdata); - return 0; - } + if (enable) + op_errno = error_gen(this, GF_FOP_XATTROP); - STACK_WIND_TAIL (frame, FIRST_CHILD(this), - FIRST_CHILD(this)->fops->xattrop, - loc, flags, dict, xdata); + if (op_errno) { + GF_ERROR(this, "unwind(-1, %s)", strerror(op_errno)); + STACK_UNWIND_STRICT(xattrop, frame, -1, op_errno, NULL, xdata); return 0; + } + + STACK_WIND_TAIL(frame, FIRST_CHILD(this), FIRST_CHILD(this)->fops->xattrop, + loc, flags, dict, xdata); + return 0; } int -error_gen_fxattrop (call_frame_t *frame, xlator_t *this, fd_t *fd, - gf_xattrop_flags_t flags, dict_t *dict, dict_t *xdata) +error_gen_fxattrop(call_frame_t *frame, xlator_t *this, fd_t *fd, + gf_xattrop_flags_t flags, dict_t *dict, dict_t *xdata) { - int op_errno = 0; - eg_t *egp = NULL; - int enable = 1; - - egp = this->private; - enable = egp->enable[GF_FOP_FXATTROP]; + int op_errno = 0; + eg_t *egp = NULL; + int enable = 1; - if (enable) - op_errno = error_gen (this, GF_FOP_FXATTROP); + egp = this->private; + enable = egp->enable[GF_FOP_FXATTROP]; - if (op_errno) { - GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno)); - STACK_UNWIND_STRICT (fxattrop, frame, -1, op_errno, NULL, xdata); - return 0; - } + if (enable) + op_errno = error_gen(this, GF_FOP_FXATTROP); - STACK_WIND_TAIL (frame, FIRST_CHILD(this), - FIRST_CHILD(this)->fops->fxattrop, - fd, flags, dict, xdata); + if (op_errno) { + GF_ERROR(this, "unwind(-1, %s)", strerror(op_errno)); + STACK_UNWIND_STRICT(fxattrop, frame, -1, op_errno, NULL, xdata); return 0; + } + + STACK_WIND_TAIL(frame, FIRST_CHILD(this), FIRST_CHILD(this)->fops->fxattrop, + fd, flags, dict, xdata); + return 0; } int -error_gen_removexattr (call_frame_t *frame, xlator_t *this, loc_t *loc, - const char *name, dict_t *xdata) +error_gen_removexattr(call_frame_t *frame, xlator_t *this, loc_t *loc, + const char *name, dict_t *xdata) { - int op_errno = 0; - eg_t *egp = NULL; - int enable = 1; - - egp = this->private; - enable = egp->enable[GF_FOP_REMOVEXATTR]; + int op_errno = 0; + eg_t *egp = NULL; + int enable = 1; - if (enable) - op_errno = error_gen (this, GF_FOP_REMOVEXATTR); + egp = this->private; + enable = egp->enable[GF_FOP_REMOVEXATTR]; - if (op_errno) { - GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno)); - STACK_UNWIND_STRICT (removexattr, frame, -1, op_errno, xdata); - return 0; - } + if (enable) + op_errno = error_gen(this, GF_FOP_REMOVEXATTR); - STACK_WIND_TAIL (frame, FIRST_CHILD(this), - FIRST_CHILD(this)->fops->removexattr, - loc, name, xdata); + if (op_errno) { + GF_ERROR(this, "unwind(-1, %s)", strerror(op_errno)); + STACK_UNWIND_STRICT(removexattr, frame, -1, op_errno, xdata); return 0; + } + + STACK_WIND_TAIL(frame, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->removexattr, loc, name, xdata); + return 0; } int -error_gen_fremovexattr (call_frame_t *frame, xlator_t *this, fd_t *fd, - const char *name, dict_t *xdata) +error_gen_fremovexattr(call_frame_t *frame, xlator_t *this, fd_t *fd, + const char *name, dict_t *xdata) { - int op_errno = 0; - eg_t *egp = NULL; - int enable = 1; - - egp = this->private; - enable = egp->enable[GF_FOP_FREMOVEXATTR]; + int op_errno = 0; + eg_t *egp = NULL; + int enable = 1; - if (enable) - op_errno = error_gen (this, GF_FOP_FREMOVEXATTR); + egp = this->private; + enable = egp->enable[GF_FOP_FREMOVEXATTR]; - if (op_errno) { - GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno)); - STACK_UNWIND_STRICT (fremovexattr, frame, -1, op_errno, xdata); - return 0; - } + if (enable) + op_errno = error_gen(this, GF_FOP_FREMOVEXATTR); - STACK_WIND_TAIL (frame, FIRST_CHILD(this), - FIRST_CHILD(this)->fops->fremovexattr, - fd, name, xdata); + if (op_errno) { + GF_ERROR(this, "unwind(-1, %s)", strerror(op_errno)); + STACK_UNWIND_STRICT(fremovexattr, frame, -1, op_errno, xdata); return 0; + } + + STACK_WIND_TAIL(frame, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->fremovexattr, fd, name, xdata); + return 0; } int -error_gen_lk (call_frame_t *frame, xlator_t *this, fd_t *fd, int32_t cmd, - struct gf_flock *lock, dict_t *xdata) +error_gen_lk(call_frame_t *frame, xlator_t *this, fd_t *fd, int32_t cmd, + struct gf_flock *lock, dict_t *xdata) { - int op_errno = 0; - eg_t *egp = NULL; - int enable = 1; + int op_errno = 0; + eg_t *egp = NULL; + int enable = 1; - egp = this->private; - enable = egp->enable[GF_FOP_LK]; + egp = this->private; + enable = egp->enable[GF_FOP_LK]; - if (enable) - op_errno = error_gen (this, GF_FOP_LK); + if (enable) + op_errno = error_gen(this, GF_FOP_LK); - if (op_errno) { - GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno)); - STACK_UNWIND_STRICT (lk, frame, -1, op_errno, NULL, xdata); - return 0; - } - - STACK_WIND_TAIL (frame, FIRST_CHILD(this), - FIRST_CHILD(this)->fops->lk, - fd, cmd, lock, xdata); + if (op_errno) { + GF_ERROR(this, "unwind(-1, %s)", strerror(op_errno)); + STACK_UNWIND_STRICT(lk, frame, -1, op_errno, NULL, xdata); return 0; + } + + STACK_WIND_TAIL(frame, FIRST_CHILD(this), FIRST_CHILD(this)->fops->lk, fd, + cmd, lock, xdata); + return 0; } int -error_gen_inodelk (call_frame_t *frame, xlator_t *this, - const char *volume, loc_t *loc, int32_t cmd, - struct gf_flock *lock, dict_t *xdata) +error_gen_inodelk(call_frame_t *frame, xlator_t *this, const char *volume, + loc_t *loc, int32_t cmd, struct gf_flock *lock, dict_t *xdata) { - int op_errno = 0; - eg_t *egp = NULL; - int enable = 1; + int op_errno = 0; + eg_t *egp = NULL; + int enable = 1; - egp = this->private; - enable = egp->enable[GF_FOP_INODELK]; + egp = this->private; + enable = egp->enable[GF_FOP_INODELK]; - if (enable) - op_errno = error_gen (this, GF_FOP_INODELK); + if (enable) + op_errno = error_gen(this, GF_FOP_INODELK); - if (op_errno) { - GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno)); - STACK_UNWIND_STRICT (inodelk, frame, -1, op_errno, xdata); - return 0; - } - - STACK_WIND_TAIL (frame, FIRST_CHILD(this), - FIRST_CHILD(this)->fops->inodelk, - volume, loc, cmd, lock, xdata); + if (op_errno) { + GF_ERROR(this, "unwind(-1, %s)", strerror(op_errno)); + STACK_UNWIND_STRICT(inodelk, frame, -1, op_errno, xdata); return 0; + } + + STACK_WIND_TAIL(frame, FIRST_CHILD(this), FIRST_CHILD(this)->fops->inodelk, + volume, loc, cmd, lock, xdata); + return 0; } int -error_gen_finodelk (call_frame_t *frame, xlator_t *this, - const char *volume, fd_t *fd, int32_t cmd, - struct gf_flock *lock, dict_t *xdata) +error_gen_finodelk(call_frame_t *frame, xlator_t *this, const char *volume, + fd_t *fd, int32_t cmd, struct gf_flock *lock, dict_t *xdata) { - int op_errno = 0; - eg_t *egp = NULL; - int enable = 1; + int op_errno = 0; + eg_t *egp = NULL; + int enable = 1; - egp = this->private; - enable = egp->enable[GF_FOP_FINODELK]; + egp = this->private; + enable = egp->enable[GF_FOP_FINODELK]; - if (enable) - op_errno = error_gen (this, GF_FOP_FINODELK); + if (enable) + op_errno = error_gen(this, GF_FOP_FINODELK); - if (op_errno) { - GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno)); - STACK_UNWIND_STRICT (finodelk, frame, -1, op_errno, xdata); - return 0; - } - - STACK_WIND_TAIL (frame, FIRST_CHILD(this), - FIRST_CHILD(this)->fops->finodelk, - volume, fd, cmd, lock, xdata); + if (op_errno) { + GF_ERROR(this, "unwind(-1, %s)", strerror(op_errno)); + STACK_UNWIND_STRICT(finodelk, frame, -1, op_errno, xdata); return 0; + } + + STACK_WIND_TAIL(frame, FIRST_CHILD(this), FIRST_CHILD(this)->fops->finodelk, + volume, fd, cmd, lock, xdata); + return 0; } int -error_gen_entrylk (call_frame_t *frame, xlator_t *this, - const char *volume, loc_t *loc, const char *basename, - entrylk_cmd cmd, entrylk_type type, dict_t *xdata) +error_gen_entrylk(call_frame_t *frame, xlator_t *this, const char *volume, + loc_t *loc, const char *basename, entrylk_cmd cmd, + entrylk_type type, dict_t *xdata) { - int op_errno = 0; - eg_t *egp = NULL; - int enable = 1; + int op_errno = 0; + eg_t *egp = NULL; + int enable = 1; - egp = this->private; - enable = egp->enable[GF_FOP_ENTRYLK]; + egp = this->private; + enable = egp->enable[GF_FOP_ENTRYLK]; - if (enable) - op_errno = error_gen (this, GF_FOP_ENTRYLK); + if (enable) + op_errno = error_gen(this, GF_FOP_ENTRYLK); - if (op_errno) { - GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno)); - STACK_UNWIND_STRICT (entrylk, frame, -1, op_errno, xdata); - return 0; - } - - STACK_WIND_TAIL (frame, FIRST_CHILD(this), - FIRST_CHILD(this)->fops->entrylk, - volume, loc, basename, cmd, type, xdata); + if (op_errno) { + GF_ERROR(this, "unwind(-1, %s)", strerror(op_errno)); + STACK_UNWIND_STRICT(entrylk, frame, -1, op_errno, xdata); return 0; + } + + STACK_WIND_TAIL(frame, FIRST_CHILD(this), FIRST_CHILD(this)->fops->entrylk, + volume, loc, basename, cmd, type, xdata); + return 0; } int -error_gen_fentrylk (call_frame_t *frame, xlator_t *this, - const char *volume, fd_t *fd, const char *basename, - entrylk_cmd cmd, entrylk_type type, dict_t *xdata) +error_gen_fentrylk(call_frame_t *frame, xlator_t *this, const char *volume, + fd_t *fd, const char *basename, entrylk_cmd cmd, + entrylk_type type, dict_t *xdata) { - int op_errno = 0; - eg_t *egp = NULL; - int enable = 1; - - egp = this->private; - enable = egp->enable[GF_FOP_FENTRYLK]; + int op_errno = 0; + eg_t *egp = NULL; + int enable = 1; - if (enable) - op_errno = error_gen (this, GF_FOP_FENTRYLK); + egp = this->private; + enable = egp->enable[GF_FOP_FENTRYLK]; - if (op_errno) { - GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno)); - STACK_UNWIND_STRICT (fentrylk, frame, -1, op_errno, xdata); - return 0; - } + if (enable) + op_errno = error_gen(this, GF_FOP_FENTRYLK); - STACK_WIND_TAIL (frame, FIRST_CHILD(this), - FIRST_CHILD(this)->fops->fentrylk, - volume, fd, basename, cmd, type, xdata); + if (op_errno) { + GF_ERROR(this, "unwind(-1, %s)", strerror(op_errno)); + STACK_UNWIND_STRICT(fentrylk, frame, -1, op_errno, xdata); return 0; + } + + STACK_WIND_TAIL(frame, FIRST_CHILD(this), FIRST_CHILD(this)->fops->fentrylk, + volume, fd, basename, cmd, type, xdata); + return 0; } int -error_gen_getspec (call_frame_t *frame, xlator_t *this, const char *key, - int32_t flags) +error_gen_getspec(call_frame_t *frame, xlator_t *this, const char *key, + int32_t flags) { - int op_errno = 0; - eg_t *egp = NULL; - int enable = 1; - - egp = this->private; - enable = egp->enable[GF_FOP_GETSPEC]; - - if (enable) - op_errno = error_gen (this, GF_FOP_GETSPEC); - - if (op_errno) { - GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno)); - STACK_UNWIND_STRICT (getspec, frame, -1, op_errno, NULL); - return 0; - } - - STACK_WIND_TAIL (frame, FIRST_CHILD(this), - FIRST_CHILD(this)->fops->getspec, - key, flags); - return 0; + int op_errno = 0; + eg_t *egp = NULL; + int enable = 1; + + egp = this->private; + enable = egp->enable[GF_FOP_GETSPEC]; + + if (enable) + op_errno = error_gen(this, GF_FOP_GETSPEC); + + if (op_errno) { + GF_ERROR(this, "unwind(-1, %s)", strerror(op_errno)); + STACK_UNWIND_STRICT(getspec, frame, -1, op_errno, NULL); + return 0; + } + + STACK_WIND_TAIL(frame, FIRST_CHILD(this), FIRST_CHILD(this)->fops->getspec, + key, flags); + return 0; } int -error_gen_readdir (call_frame_t *frame, xlator_t *this, fd_t *fd, - size_t size, off_t off, dict_t *xdata) +error_gen_readdir(call_frame_t *frame, xlator_t *this, fd_t *fd, size_t size, + off_t off, dict_t *xdata) { - int op_errno = 0; - eg_t *egp = NULL; - int enable = 1; - - egp = this->private; - enable = egp->enable[GF_FOP_READDIR]; - - if (enable) - op_errno = error_gen (this, GF_FOP_READDIR); - - if (op_errno) { - GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno)); - STACK_UNWIND_STRICT (readdir, frame, -1, op_errno, NULL, xdata); - return 0; - } - - STACK_WIND_TAIL (frame, FIRST_CHILD(this), - FIRST_CHILD(this)->fops->readdir, - fd, size, off, xdata); - return 0; + int op_errno = 0; + eg_t *egp = NULL; + int enable = 1; + + egp = this->private; + enable = egp->enable[GF_FOP_READDIR]; + + if (enable) + op_errno = error_gen(this, GF_FOP_READDIR); + + if (op_errno) { + GF_ERROR(this, "unwind(-1, %s)", strerror(op_errno)); + STACK_UNWIND_STRICT(readdir, frame, -1, op_errno, NULL, xdata); + return 0; + } + + STACK_WIND_TAIL(frame, FIRST_CHILD(this), FIRST_CHILD(this)->fops->readdir, + fd, size, off, xdata); + return 0; } int -error_gen_readdirp (call_frame_t *frame, xlator_t *this, fd_t *fd, size_t size, - off_t off, dict_t *dict) +error_gen_readdirp(call_frame_t *frame, xlator_t *this, fd_t *fd, size_t size, + off_t off, dict_t *dict) { - int op_errno = 0; - eg_t *egp = NULL; - int enable = 1; + int op_errno = 0; + eg_t *egp = NULL; + int enable = 1; - egp = this->private; - enable = egp->enable[GF_FOP_READDIRP]; + egp = this->private; + enable = egp->enable[GF_FOP_READDIRP]; - if (enable) - op_errno = error_gen (this, GF_FOP_READDIRP); + if (enable) + op_errno = error_gen(this, GF_FOP_READDIRP); - if (op_errno) { - GF_ERROR(this, "unwind(-1, %s)", strerror (op_errno)); - STACK_UNWIND_STRICT (readdirp, frame, -1, op_errno, NULL, NULL); - return 0; - } + if (op_errno) { + GF_ERROR(this, "unwind(-1, %s)", strerror(op_errno)); + STACK_UNWIND_STRICT(readdirp, frame, -1, op_errno, NULL, NULL); + return 0; + } - STACK_WIND_TAIL (frame, FIRST_CHILD(this), - FIRST_CHILD(this)->fops->readdirp, + STACK_WIND_TAIL(frame, FIRST_CHILD(this), FIRST_CHILD(this)->fops->readdirp, fd, size, off, dict); - return 0; + return 0; } static void -error_gen_set_failure (eg_t *pvt, double percent) +error_gen_set_failure(eg_t *pvt, double percent) { - double ppm; + double ppm; - GF_ASSERT (pvt); + GF_ASSERT(pvt); - ppm = (percent / 100.0) * (double)FAILURE_GRANULARITY; - pvt->failure_iter_no = (int)ppm; + ppm = (percent / 100.0) * (double)FAILURE_GRANULARITY; + pvt->failure_iter_no = (int)ppm; } static void -error_gen_parse_fill_fops (eg_t *pvt, char *enable_fops) +error_gen_parse_fill_fops(eg_t *pvt, char *enable_fops) { - char *op_no_str = NULL; - int op_no = -1; - int i = 0; - xlator_t *this = THIS; - char *saveptr = NULL; + char *op_no_str = NULL; + int op_no = -1; + int i = 0; + xlator_t *this = THIS; + char *saveptr = NULL; - GF_ASSERT (pvt); - GF_ASSERT (this); + GF_ASSERT(pvt); + GF_ASSERT(this); + for (i = 0; i < GF_FOP_MAXVALUE; i++) + pvt->enable[i] = 0; + + if (!enable_fops) { + gf_log(this->name, GF_LOG_WARNING, "All fops are enabled."); for (i = 0; i < GF_FOP_MAXVALUE; i++) - pvt->enable[i] = 0; - - if (!enable_fops) { - gf_log (this->name, GF_LOG_WARNING, - "All fops are enabled."); - for (i = 0; i < GF_FOP_MAXVALUE; i++) - pvt->enable[i] = 1; - } else { - op_no_str = strtok_r (enable_fops, ",", &saveptr); - while (op_no_str) { - op_no = gf_fop_int (op_no_str); - if (op_no == -1) { - gf_log (this->name, GF_LOG_WARNING, - "Wrong option value %s", op_no_str); - } else - pvt->enable[op_no] = 1; - - op_no_str = strtok_r (NULL, ",", &saveptr); - } + pvt->enable[i] = 1; + } else { + op_no_str = strtok_r(enable_fops, ",", &saveptr); + while (op_no_str) { + op_no = gf_fop_int(op_no_str); + if (op_no == -1) { + gf_log(this->name, GF_LOG_WARNING, "Wrong option value %s", + op_no_str); + } else + pvt->enable[op_no] = 1; + + op_no_str = strtok_r(NULL, ",", &saveptr); } + } } int32_t -error_gen_priv_dump (xlator_t *this) +error_gen_priv_dump(xlator_t *this) { - char key_prefix[GF_DUMP_MAX_BUF_LEN]; - int ret = -1; - eg_t *conf = NULL; + char key_prefix[GF_DUMP_MAX_BUF_LEN]; + int ret = -1; + eg_t *conf = NULL; - if (!this) - goto out; + if (!this) + goto out; - conf = this->private; - if (!conf) - goto out; + conf = this->private; + if (!conf) + goto out; - ret = TRY_LOCK(&conf->lock); - if (ret != 0) { - return ret; - } + ret = TRY_LOCK(&conf->lock); + if (ret != 0) { + return ret; + } - gf_proc_dump_add_section("xlator.debug.error-gen.%s.priv", this->name); - gf_proc_dump_build_key(key_prefix,"xlator.debug.error-gen","%s.priv", - this->name); + gf_proc_dump_add_section("xlator.debug.error-gen.%s.priv", this->name); + gf_proc_dump_build_key(key_prefix, "xlator.debug.error-gen", "%s.priv", + this->name); - gf_proc_dump_write("op_count", "%d", conf->op_count); - gf_proc_dump_write("failure_iter_no", "%d", conf->failure_iter_no); - gf_proc_dump_write("error_no", "%s", conf->error_no); - gf_proc_dump_write("random_failure", "%d", conf->random_failure); + gf_proc_dump_write("op_count", "%d", conf->op_count); + gf_proc_dump_write("failure_iter_no", "%d", conf->failure_iter_no); + gf_proc_dump_write("error_no", "%s", conf->error_no); + gf_proc_dump_write("random_failure", "%d", conf->random_failure); - UNLOCK(&conf->lock); + UNLOCK(&conf->lock); out: - return ret; + return ret; } int32_t -mem_acct_init (xlator_t *this) +mem_acct_init(xlator_t *this) { - int ret = -1; + int ret = -1; - if (!this) - return ret; - - ret = xlator_mem_acct_init (this, gf_error_gen_mt_end + 1); + if (!this) + return ret; - if (ret != 0) { - gf_log (this->name, GF_LOG_ERROR, "Memory accounting init" - " failed"); - return ret; - } + ret = xlator_mem_acct_init(this, gf_error_gen_mt_end + 1); + if (ret != 0) { + gf_log(this->name, GF_LOG_ERROR, + "Memory accounting init" + " failed"); return ret; + } + + return ret; } int -reconfigure (xlator_t *this, dict_t *options) +reconfigure(xlator_t *this, dict_t *options) { - eg_t *pvt = NULL; - int32_t ret = 0; - char *error_enable_fops = NULL; - double failure_percent_dbl = 0.0; + eg_t *pvt = NULL; + int32_t ret = 0; + char *error_enable_fops = NULL; + double failure_percent_dbl = 0.0; - if (!this || !this->private) - goto out; + if (!this || !this->private) + goto out; - pvt = this->private; + pvt = this->private; - ret = -1; + ret = -1; - GF_OPTION_RECONF ("error-no", pvt->error_no, options, str, out); + GF_OPTION_RECONF("error-no", pvt->error_no, options, str, out); - if (pvt->error_no) - pvt->error_no_int = conv_errno_to_int (&pvt->error_no); + if (pvt->error_no) + pvt->error_no_int = conv_errno_to_int(&pvt->error_no); - GF_OPTION_RECONF ("failure", failure_percent_dbl, options, percent, - out); + GF_OPTION_RECONF("failure", failure_percent_dbl, options, percent, out); - GF_OPTION_RECONF ("enable", error_enable_fops, options, str, out); + GF_OPTION_RECONF("enable", error_enable_fops, options, str, out); - GF_OPTION_RECONF ("random-failure", pvt->random_failure, options, - bool, out); + GF_OPTION_RECONF("random-failure", pvt->random_failure, options, bool, out); - error_gen_parse_fill_fops (pvt, error_enable_fops); - error_gen_set_failure (pvt, failure_percent_dbl); + error_gen_parse_fill_fops(pvt, error_enable_fops); + error_gen_set_failure(pvt, failure_percent_dbl); - ret = 0; + ret = 0; out: - gf_log (this ? this->name : "error-gen", GF_LOG_DEBUG, - "reconfigure returning %d", ret); - return ret; + gf_log(this ? this->name : "error-gen", GF_LOG_DEBUG, + "reconfigure returning %d", ret); + return ret; } int -init (xlator_t *this) +init(xlator_t *this) { - eg_t *pvt = NULL; - int32_t ret = 0; - char *error_enable_fops = NULL; - double failure_percent_dbl = 0.0; - - if (!this->children || this->children->next) { - gf_log (this->name, GF_LOG_ERROR, - "error-gen not configured with one subvolume"); - ret = -1; - goto out; - } - - if (!this->parents) { - gf_log (this->name, GF_LOG_WARNING, - "dangling volume. check volfile "); - } - - pvt = GF_CALLOC (1, sizeof (eg_t), gf_error_gen_mt_eg_t); + eg_t *pvt = NULL; + int32_t ret = 0; + char *error_enable_fops = NULL; + double failure_percent_dbl = 0.0; + + if (!this->children || this->children->next) { + gf_log(this->name, GF_LOG_ERROR, + "error-gen not configured with one subvolume"); + ret = -1; + goto out; + } - if (!pvt) { - ret = -1; - goto out; - } + if (!this->parents) { + gf_log(this->name, GF_LOG_WARNING, "dangling volume. check volfile "); + } - LOCK_INIT (&pvt->lock); + pvt = GF_CALLOC(1, sizeof(eg_t), gf_error_gen_mt_eg_t); + if (!pvt) { ret = -1; + goto out; + } - GF_OPTION_INIT ("error-no", pvt->error_no, str, out); + LOCK_INIT(&pvt->lock); - if (pvt->error_no) - pvt->error_no_int = conv_errno_to_int (&pvt->error_no); + ret = -1; - GF_OPTION_INIT ("failure", failure_percent_dbl, percent, out); + GF_OPTION_INIT("error-no", pvt->error_no, str, out); - GF_OPTION_INIT ("enable", error_enable_fops, str, out); + if (pvt->error_no) + pvt->error_no_int = conv_errno_to_int(&pvt->error_no); - GF_OPTION_INIT ("random-failure", pvt->random_failure, bool, out); + GF_OPTION_INIT("failure", failure_percent_dbl, percent, out); + GF_OPTION_INIT("enable", error_enable_fops, str, out); - error_gen_parse_fill_fops (pvt, error_enable_fops); - error_gen_set_failure (pvt, failure_percent_dbl); + GF_OPTION_INIT("random-failure", pvt->random_failure, bool, out); - this->private = pvt; + error_gen_parse_fill_fops(pvt, error_enable_fops); + error_gen_set_failure(pvt, failure_percent_dbl); - /* Give some seed value here */ - srand (time(NULL)); + this->private = pvt; - ret = 0; + /* Give some seed value here */ + srand(time(NULL)); + + ret = 0; out: - if (ret) - GF_FREE (pvt); - return ret; + if (ret) + GF_FREE(pvt); + return ret; } - void -fini (xlator_t *this) +fini(xlator_t *this) { - eg_t *pvt = NULL; - - if (!this) - return; - pvt = this->private; + eg_t *pvt = NULL; - if (pvt) { - LOCK_DESTROY (&pvt->lock); - GF_FREE (pvt); - gf_log (this->name, GF_LOG_DEBUG, "fini called"); - } + if (!this) return; + pvt = this->private; + + if (pvt) { + LOCK_DESTROY(&pvt->lock); + GF_FREE(pvt); + gf_log(this->name, GF_LOG_DEBUG, "fini called"); + } + return; } struct xlator_dumpops dumpops = { - .priv = error_gen_priv_dump, + .priv = error_gen_priv_dump, }; struct xlator_cbks cbks; struct xlator_fops fops = { - .lookup = error_gen_lookup, - .stat = error_gen_stat, - .readlink = error_gen_readlink, - .mknod = error_gen_mknod, - .mkdir = error_gen_mkdir, - .unlink = error_gen_unlink, - .rmdir = error_gen_rmdir, - .symlink = error_gen_symlink, - .rename = error_gen_rename, - .link = error_gen_link, - .truncate = error_gen_truncate, - .create = error_gen_create, - .open = error_gen_open, - .readv = error_gen_readv, - .writev = error_gen_writev, - .statfs = error_gen_statfs, - .flush = error_gen_flush, - .fsync = error_gen_fsync, - .setxattr = error_gen_setxattr, - .getxattr = error_gen_getxattr, - .removexattr = error_gen_removexattr, - .fsetxattr = error_gen_fsetxattr, - .fgetxattr = error_gen_fgetxattr, - .fremovexattr = error_gen_fremovexattr, - .opendir = error_gen_opendir, - .readdir = error_gen_readdir, - .readdirp = error_gen_readdirp, - .fsyncdir = error_gen_fsyncdir, - .access = error_gen_access, - .ftruncate = error_gen_ftruncate, - .fstat = error_gen_fstat, - .lk = error_gen_lk, - .xattrop = error_gen_xattrop, - .fxattrop = error_gen_fxattrop, - .inodelk = error_gen_inodelk, - .finodelk = error_gen_finodelk, - .entrylk = error_gen_entrylk, - .fentrylk = error_gen_fentrylk, - .setattr = error_gen_setattr, - .fsetattr = error_gen_fsetattr, - .getspec = error_gen_getspec, + .lookup = error_gen_lookup, + .stat = error_gen_stat, + .readlink = error_gen_readlink, + .mknod = error_gen_mknod, + .mkdir = error_gen_mkdir, + .unlink = error_gen_unlink, + .rmdir = error_gen_rmdir, + .symlink = error_gen_symlink, + .rename = error_gen_rename, + .link = error_gen_link, + .truncate = error_gen_truncate, + .create = error_gen_create, + .open = error_gen_open, + .readv = error_gen_readv, + .writev = error_gen_writev, + .statfs = error_gen_statfs, + .flush = error_gen_flush, + .fsync = error_gen_fsync, + .setxattr = error_gen_setxattr, + .getxattr = error_gen_getxattr, + .removexattr = error_gen_removexattr, + .fsetxattr = error_gen_fsetxattr, + .fgetxattr = error_gen_fgetxattr, + .fremovexattr = error_gen_fremovexattr, + .opendir = error_gen_opendir, + .readdir = error_gen_readdir, + .readdirp = error_gen_readdirp, + .fsyncdir = error_gen_fsyncdir, + .access = error_gen_access, + .ftruncate = error_gen_ftruncate, + .fstat = error_gen_fstat, + .lk = error_gen_lk, + .xattrop = error_gen_xattrop, + .fxattrop = error_gen_fxattrop, + .inodelk = error_gen_inodelk, + .finodelk = error_gen_finodelk, + .entrylk = error_gen_entrylk, + .fentrylk = error_gen_fentrylk, + .setattr = error_gen_setattr, + .fsetattr = error_gen_fsetattr, + .getspec = error_gen_getspec, }; struct volume_options options[] = { - { .key = {"failure"}, - .type = GF_OPTION_TYPE_PERCENT, - .description = "Percentage failure of operations when enabled.", - }, - - { .key = {"error-no"}, - .value = {"ENOENT","ENOTDIR","ENAMETOOLONG","EACCES","EBADF", - "EFAULT","ENOMEM","EINVAL","EIO","EEXIST","ENOSPC", - "EPERM","EROFS","EBUSY","EISDIR","ENOTEMPTY","EMLINK" - "ENODEV","EXDEV","EMFILE","ENFILE","ENOSYS","EINTR", - "EFBIG","EAGAIN","GF_ERROR_SHORT_WRITE"}, - .type = GF_OPTION_TYPE_STR, - .op_version = {3}, - .tags = {"error-gen"}, - .flags = OPT_FLAG_SETTABLE, - - }, - - { .key = {"random-failure"}, - .type = GF_OPTION_TYPE_BOOL, - .default_value = "off", - .op_version = {3}, - .tags = {"error-gen"}, - .flags = OPT_FLAG_SETTABLE, - }, - - { .key = {"enable", "error-fops"}, - .type = GF_OPTION_TYPE_STR, - .description = "Accepts a string which takes ',' separated fop " - "strings to denote which fops are enabled for error", - .op_version = {3}, - .tags = {"error-gen"}, - .flags = OPT_FLAG_SETTABLE, - }, - - { .key = {NULL} } -}; + { + .key = {"failure"}, + .type = GF_OPTION_TYPE_PERCENT, + .description = "Percentage failure of operations when enabled.", + }, + + { + .key = {"error-no"}, + .value = {"ENOENT", + "ENOTDIR", + "ENAMETOOLONG", + "EACCES", + "EBADF", + "EFAULT", + "ENOMEM", + "EINVAL", + "EIO", + "EEXIST", + "ENOSPC", + "EPERM", + "EROFS", + "EBUSY", + "EISDIR", + "ENOTEMPTY", + "EMLINK" + "ENODEV", + "EXDEV", + "EMFILE", + "ENFILE", + "ENOSYS", + "EINTR", + "EFBIG", + "EAGAIN", + "GF_ERROR_SHORT_WRITE"}, + .type = GF_OPTION_TYPE_STR, + .op_version = {3}, + .tags = {"error-gen"}, + .flags = OPT_FLAG_SETTABLE, + + }, + + { + .key = {"random-failure"}, + .type = GF_OPTION_TYPE_BOOL, + .default_value = "off", + .op_version = {3}, + .tags = {"error-gen"}, + .flags = OPT_FLAG_SETTABLE, + }, + + { + .key = {"enable", "error-fops"}, + .type = GF_OPTION_TYPE_STR, + .description = "Accepts a string which takes ',' separated fop " + "strings to denote which fops are enabled for error", + .op_version = {3}, + .tags = {"error-gen"}, + .flags = OPT_FLAG_SETTABLE, + }, + + {.key = {NULL}}}; diff --git a/xlators/debug/io-stats/src/io-stats.c b/xlators/debug/io-stats/src/io-stats.c index 4bc8b7999a7..6f6104033d8 100644 --- a/xlators/debug/io-stats/src/io-stats.c +++ b/xlators/debug/io-stats/src/io-stats.c @@ -17,9 +17,9 @@ * * a) total read data - since process start, last interval and per fd * b) total write data - since process start, last interval and per fd - * c) counts of read IO block size - since process start, last interval and per fd - * d) counts of write IO block size - since process start, last interval and per fd - * e) counts of all FOP types passing through it + * c) counts of read IO block size - since process start, last interval and per + * fd d) counts of write IO block size - since process start, last interval and + * per fd e) counts of all FOP types passing through it * * Usage: setfattr -n trusted.io-stats-dump /tmp/filename /mnt/gluster * output is written to /tmp/filename.<iostats xlator instance name> @@ -49,169 +49,168 @@ #define IOS_STATS_DUMP_DIR DEFAULT_VAR_RUN_DIRECTORY typedef enum { - IOS_STATS_TYPE_NONE, - IOS_STATS_TYPE_OPEN, - IOS_STATS_TYPE_READ, - IOS_STATS_TYPE_WRITE, - IOS_STATS_TYPE_OPENDIR, - IOS_STATS_TYPE_READDIRP, - IOS_STATS_TYPE_READ_THROUGHPUT, - IOS_STATS_TYPE_WRITE_THROUGHPUT, - IOS_STATS_TYPE_MAX -}ios_stats_type_t; + IOS_STATS_TYPE_NONE, + IOS_STATS_TYPE_OPEN, + IOS_STATS_TYPE_READ, + IOS_STATS_TYPE_WRITE, + IOS_STATS_TYPE_OPENDIR, + IOS_STATS_TYPE_READDIRP, + IOS_STATS_TYPE_READ_THROUGHPUT, + IOS_STATS_TYPE_WRITE_THROUGHPUT, + IOS_STATS_TYPE_MAX +} ios_stats_type_t; typedef enum { - IOS_STATS_THRU_READ, - IOS_STATS_THRU_WRITE, - IOS_STATS_THRU_MAX, -}ios_stats_thru_t; + IOS_STATS_THRU_READ, + IOS_STATS_THRU_WRITE, + IOS_STATS_THRU_MAX, +} ios_stats_thru_t; struct ios_stat_lat { - struct timeval time; - double throughput; + struct timeval time; + double throughput; }; struct ios_stat { - gf_lock_t lock; - uuid_t gfid; - char *filename; - gf_atomic_t counters[IOS_STATS_TYPE_MAX]; - struct ios_stat_lat thru_counters [IOS_STATS_THRU_MAX]; - gf_atomic_t refcnt; + gf_lock_t lock; + uuid_t gfid; + char *filename; + gf_atomic_t counters[IOS_STATS_TYPE_MAX]; + struct ios_stat_lat thru_counters[IOS_STATS_THRU_MAX]; + gf_atomic_t refcnt; }; struct ios_stat_list { - struct list_head list; - struct ios_stat *iosstat; - double value; + struct list_head list; + struct ios_stat *iosstat; + double value; }; struct ios_stat_head { - gf_lock_t lock; - double min_cnt; - uint64_t members; - struct ios_stat_list *iosstats; + gf_lock_t lock; + double min_cnt; + uint64_t members; + struct ios_stat_list *iosstats; }; typedef struct _ios_sample_t { - uid_t uid; - gid_t gid; - char identifier[UNIX_PATH_MAX]; - glusterfs_fop_t fop_type; - struct timeval timestamp; - double elapsed; + uid_t uid; + gid_t gid; + char identifier[UNIX_PATH_MAX]; + glusterfs_fop_t fop_type; + struct timeval timestamp; + double elapsed; } ios_sample_t; - typedef struct _ios_sample_buf_t { - uint64_t pos; /* Position in write buffer */ - uint64_t size; /* Size of ring buffer */ - uint64_t collected; /* Number of samples we've collected */ - uint64_t observed; /* Number of FOPs we've observed */ - ios_sample_t *ios_samples; /* Our list of samples */ + uint64_t pos; /* Position in write buffer */ + uint64_t size; /* Size of ring buffer */ + uint64_t collected; /* Number of samples we've collected */ + uint64_t observed; /* Number of FOPs we've observed */ + ios_sample_t *ios_samples; /* Our list of samples */ } ios_sample_buf_t; - struct ios_lat { - double min; - double max; - double avg; - uint64_t total; + double min; + double max; + double avg; + uint64_t total; }; struct ios_global_stats { - gf_atomic_t data_written; - gf_atomic_t data_read; - gf_atomic_t block_count_write[IOS_BLOCK_COUNT_SIZE]; - gf_atomic_t block_count_read[IOS_BLOCK_COUNT_SIZE]; - gf_atomic_t fop_hits[GF_FOP_MAXVALUE]; - gf_atomic_t upcall_hits[GF_UPCALL_FLAGS_MAXVALUE]; - struct timeval started_at; - struct ios_lat latency[GF_FOP_MAXVALUE]; - uint64_t nr_opens; - uint64_t max_nr_opens; - struct timeval max_openfd_time; + gf_atomic_t data_written; + gf_atomic_t data_read; + gf_atomic_t block_count_write[IOS_BLOCK_COUNT_SIZE]; + gf_atomic_t block_count_read[IOS_BLOCK_COUNT_SIZE]; + gf_atomic_t fop_hits[GF_FOP_MAXVALUE]; + gf_atomic_t upcall_hits[GF_UPCALL_FLAGS_MAXVALUE]; + struct timeval started_at; + struct ios_lat latency[GF_FOP_MAXVALUE]; + uint64_t nr_opens; + uint64_t max_nr_opens; + struct timeval max_openfd_time; }; typedef enum { - IOS_DUMP_TYPE_NONE = 0, - IOS_DUMP_TYPE_FILE = 1, - IOS_DUMP_TYPE_DICT = 2, - IOS_DUMP_TYPE_JSON_FILE = 3, - IOS_DUMP_TYPE_SAMPLES = 4, - IOS_DUMP_TYPE_MAX = 5 + IOS_DUMP_TYPE_NONE = 0, + IOS_DUMP_TYPE_FILE = 1, + IOS_DUMP_TYPE_DICT = 2, + IOS_DUMP_TYPE_JSON_FILE = 3, + IOS_DUMP_TYPE_SAMPLES = 4, + IOS_DUMP_TYPE_MAX = 5 } ios_dump_type_t; struct ios_conf { - gf_lock_t lock; - struct ios_global_stats cumulative; - uint64_t increment; - struct ios_global_stats incremental; - gf_boolean_t dump_fd_stats; - gf_boolean_t count_fop_hits; - gf_boolean_t measure_latency; - struct ios_stat_head list[IOS_STATS_TYPE_MAX]; - struct ios_stat_head thru_list[IOS_STATS_THRU_MAX]; - int32_t ios_dump_interval; - pthread_t dump_thread; - gf_boolean_t dump_thread_should_die; - gf_boolean_t dump_thread_running; - gf_lock_t ios_sampling_lock; - int32_t ios_sample_interval; - int32_t ios_sample_buf_size; - ios_sample_buf_t *ios_sample_buf; - struct dnscache *dnscache; - int32_t ios_dnscache_ttl_sec; - /* - * What we really need here is just a unique value to keep files - * created by this instance distinct from those created by any other. - * On the client side this isn't a problem, so we just use the - * translator name. On the server side conflicts can occur, so the - * volfile-generation code automatically sets this (via an option) - * to be the brick path. - * - * NB While the *field* name has changed, it didn't seem worth changing - * all of the cases where "xlator_name" is used as a *variable* name. - */ - char *unique_id; - ios_dump_type_t dump_format; - char *dump_format_str; + gf_lock_t lock; + struct ios_global_stats cumulative; + uint64_t increment; + struct ios_global_stats incremental; + gf_boolean_t dump_fd_stats; + gf_boolean_t count_fop_hits; + gf_boolean_t measure_latency; + struct ios_stat_head list[IOS_STATS_TYPE_MAX]; + struct ios_stat_head thru_list[IOS_STATS_THRU_MAX]; + int32_t ios_dump_interval; + pthread_t dump_thread; + gf_boolean_t dump_thread_should_die; + gf_boolean_t dump_thread_running; + gf_lock_t ios_sampling_lock; + int32_t ios_sample_interval; + int32_t ios_sample_buf_size; + ios_sample_buf_t *ios_sample_buf; + struct dnscache *dnscache; + int32_t ios_dnscache_ttl_sec; + /* + * What we really need here is just a unique value to keep files + * created by this instance distinct from those created by any other. + * On the client side this isn't a problem, so we just use the + * translator name. On the server side conflicts can occur, so the + * volfile-generation code automatically sets this (via an option) + * to be the brick path. + * + * NB While the *field* name has changed, it didn't seem worth changing + * all of the cases where "xlator_name" is used as a *variable* name. + */ + char *unique_id; + ios_dump_type_t dump_format; + char *dump_format_str; }; - struct ios_fd { - char *filename; - gf_atomic_t data_written; - gf_atomic_t data_read; - gf_atomic_t block_count_write[IOS_BLOCK_COUNT_SIZE]; - gf_atomic_t block_count_read[IOS_BLOCK_COUNT_SIZE]; - struct timeval opened_at; + char *filename; + gf_atomic_t data_written; + gf_atomic_t data_read; + gf_atomic_t block_count_write[IOS_BLOCK_COUNT_SIZE]; + gf_atomic_t block_count_read[IOS_BLOCK_COUNT_SIZE]; + struct timeval opened_at; }; struct ios_dump_args { - ios_dump_type_t type; - union { - FILE *logfp; - dict_t *dict; - } u; + ios_dump_type_t type; + union { + FILE *logfp; + dict_t *dict; + } u; }; -typedef int (*block_dump_func) (xlator_t *, struct ios_dump_args*, - int , int , uint64_t ) ; +typedef int (*block_dump_func)(xlator_t *, struct ios_dump_args *, int, int, + uint64_t); struct ios_local { - struct timeval wind_at; - struct timeval unwind_at; + struct timeval wind_at; + struct timeval unwind_at; }; struct volume_options options[]; static int -is_fop_latency_started (call_frame_t *frame) +is_fop_latency_started(call_frame_t *frame) { - GF_ASSERT (frame); - struct timeval epoch = {0,}; - return memcmp (&frame->begin, &epoch, sizeof (epoch)); + GF_ASSERT(frame); + struct timeval epoch = { + 0, + }; + return memcmp(&frame->begin, &epoch, sizeof(epoch)); } #define _IOS_SAMP_DIR DEFAULT_LOG_FILE_DIRECTORY "/samples" @@ -221,354 +220,334 @@ is_fop_latency_started (call_frame_t *frame) #define _IOS_DUMP_DIR DATADIR "/db/glusterd/stats" #endif -#define END_FOP_LATENCY(frame, op) \ - do { \ - struct ios_conf *conf = NULL; \ - \ - conf = this->private; \ - if (conf && conf->measure_latency) { \ - timespec_now (&frame->end); \ - update_ios_latency (conf, frame, GF_FOP_##op); \ - } \ - } while (0) - -#define START_FOP_LATENCY(frame) \ - do { \ - struct ios_conf *conf = NULL; \ - \ - conf = this->private; \ - if (conf && conf->measure_latency) { \ - timespec_now (&frame->begin); \ - } else { \ - memset (&frame->begin, 0, sizeof (frame->begin));\ - } \ - } while (0) - - -#define BUMP_FOP(op) \ - do { \ - struct ios_conf *conf = NULL; \ - \ - conf = this->private; \ - if (!conf) \ - break; \ - GF_ATOMIC_INC (conf->cumulative.fop_hits[GF_FOP_##op]); \ - GF_ATOMIC_INC (conf->incremental.fop_hits[GF_FOP_##op]);\ - } while (0) - -#define UPDATE_PROFILE_STATS(frame, op) \ - do { \ - struct ios_conf *conf = NULL; \ - \ - if (!is_fop_latency_started (frame)) \ - break; \ - conf = this->private; \ - if (conf && conf->measure_latency && \ - conf->count_fop_hits) { \ - BUMP_FOP (op); \ - timespec_now (&frame->end); \ - update_ios_latency (conf, frame, GF_FOP_##op); \ - } \ - } while (0) +#define END_FOP_LATENCY(frame, op) \ + do { \ + struct ios_conf *conf = NULL; \ + \ + conf = this->private; \ + if (conf && conf->measure_latency) { \ + timespec_now(&frame->end); \ + update_ios_latency(conf, frame, GF_FOP_##op); \ + } \ + } while (0) + +#define START_FOP_LATENCY(frame) \ + do { \ + struct ios_conf *conf = NULL; \ + \ + conf = this->private; \ + if (conf && conf->measure_latency) { \ + timespec_now(&frame->begin); \ + } else { \ + memset(&frame->begin, 0, sizeof(frame->begin)); \ + } \ + } while (0) + +#define BUMP_FOP(op) \ + do { \ + struct ios_conf *conf = NULL; \ + \ + conf = this->private; \ + if (!conf) \ + break; \ + GF_ATOMIC_INC(conf->cumulative.fop_hits[GF_FOP_##op]); \ + GF_ATOMIC_INC(conf->incremental.fop_hits[GF_FOP_##op]); \ + } while (0) + +#define UPDATE_PROFILE_STATS(frame, op) \ + do { \ + struct ios_conf *conf = NULL; \ + \ + if (!is_fop_latency_started(frame)) \ + break; \ + conf = this->private; \ + if (conf && conf->measure_latency && conf->count_fop_hits) { \ + BUMP_FOP(op); \ + timespec_now(&frame->end); \ + update_ios_latency(conf, frame, GF_FOP_##op); \ + } \ + } while (0) #define BUMP_THROUGHPUT(iosstat, type) \ - do { \ - struct ios_conf *conf = NULL; \ - double elapsed; \ - struct timespec *begin, *end; \ - double throughput; \ - int flag = 0; \ + do { \ + struct ios_conf *conf = NULL; \ + double elapsed; \ + struct timespec *begin, *end; \ + double throughput; \ + int flag = 0; \ \ - begin = &frame->begin; \ - end = &frame->end; \ + begin = &frame->begin; \ + end = &frame->end; \ \ - elapsed = ((end->tv_sec - begin->tv_sec) * 1e9 \ - + (end->tv_nsec - begin->tv_nsec)) / 1000; \ - throughput = op_ret / elapsed; \ + elapsed = ((end->tv_sec - begin->tv_sec) * 1e9 + \ + (end->tv_nsec - begin->tv_nsec)) / \ + 1000; \ + throughput = op_ret / elapsed; \ \ - conf = this->private; \ - LOCK (&iosstat->lock); \ - { \ - if (iosstat->thru_counters[type].throughput \ - <= throughput) { \ - iosstat->thru_counters[type].throughput = \ - throughput; \ - gettimeofday (&iosstat-> \ - thru_counters[type].time, NULL); \ - flag = 1; \ - } \ - } \ - UNLOCK (&iosstat->lock); \ - if (flag) \ - ios_stat_add_to_list (&conf->thru_list[type], \ - throughput, iosstat); \ - } while (0) + conf = this->private; \ + LOCK(&iosstat->lock); \ + { \ + if (iosstat->thru_counters[type].throughput <= throughput) { \ + iosstat->thru_counters[type].throughput = throughput; \ + gettimeofday(&iosstat->thru_counters[type].time, NULL); \ + flag = 1; \ + } \ + } \ + UNLOCK(&iosstat->lock); \ + if (flag) \ + ios_stat_add_to_list(&conf->thru_list[type], throughput, iosstat); \ + } while (0) static int -ios_fd_ctx_get (fd_t *fd, xlator_t *this, struct ios_fd **iosfd) +ios_fd_ctx_get(fd_t *fd, xlator_t *this, struct ios_fd **iosfd) { - uint64_t iosfd64 = 0; - unsigned long iosfdlong = 0; - int ret = 0; + uint64_t iosfd64 = 0; + unsigned long iosfdlong = 0; + int ret = 0; - ret = fd_ctx_get (fd, this, &iosfd64); - iosfdlong = iosfd64; - if (ret != -1) - *iosfd = (void *) iosfdlong; + ret = fd_ctx_get(fd, this, &iosfd64); + iosfdlong = iosfd64; + if (ret != -1) + *iosfd = (void *)iosfdlong; - return ret; + return ret; } - static int -ios_fd_ctx_set (fd_t *fd, xlator_t *this, struct ios_fd *iosfd) +ios_fd_ctx_set(fd_t *fd, xlator_t *this, struct ios_fd *iosfd) { - uint64_t iosfd64 = 0; - int ret = 0; + uint64_t iosfd64 = 0; + int ret = 0; - iosfd64 = (unsigned long) iosfd; - ret = fd_ctx_set (fd, this, iosfd64); + iosfd64 = (unsigned long)iosfd; + ret = fd_ctx_set(fd, this, iosfd64); - return ret; + return ret; } - static int -ios_stat_ref (struct ios_stat *iosstat) +ios_stat_ref(struct ios_stat *iosstat) { - uint64_t refcnt = 0; - refcnt = GF_ATOMIC_INC (iosstat->refcnt); + uint64_t refcnt = 0; + refcnt = GF_ATOMIC_INC(iosstat->refcnt); - return refcnt; + return refcnt; } - static int -ios_stat_unref (struct ios_stat *iosstat) +ios_stat_unref(struct ios_stat *iosstat) { - int cleanup = 0; - uint64_t refcnt = 0; + int cleanup = 0; + uint64_t refcnt = 0; - refcnt = GF_ATOMIC_DEC (iosstat->refcnt); - if (refcnt == 0) { - if (iosstat->filename) { - GF_FREE (iosstat->filename); - iosstat->filename = NULL; - } - cleanup = 1; + refcnt = GF_ATOMIC_DEC(iosstat->refcnt); + if (refcnt == 0) { + if (iosstat->filename) { + GF_FREE(iosstat->filename); + iosstat->filename = NULL; } + cleanup = 1; + } - if (cleanup) { - LOCK_DESTROY (&iosstat->lock); - GF_FREE (iosstat); - iosstat = NULL; - } + if (cleanup) { + LOCK_DESTROY(&iosstat->lock); + GF_FREE(iosstat); + iosstat = NULL; + } - return 0; + return 0; } - static int -ios_stat_add_to_list (struct ios_stat_head *list_head, uint64_t value, - struct ios_stat *iosstat) -{ - struct ios_stat_list *new = NULL; - struct ios_stat_list *entry = NULL; - struct ios_stat_list *t = NULL; - struct ios_stat_list *list_entry = NULL; - struct ios_stat_list *tmp = NULL; - struct ios_stat_list *last = NULL; - struct ios_stat *stat = NULL; - int cnt = 0; - int found = 0; - int reposition = 0; - double min_count = 0; - - LOCK (&list_head->lock); +ios_stat_add_to_list(struct ios_stat_head *list_head, uint64_t value, + struct ios_stat *iosstat) +{ + struct ios_stat_list *new = NULL; + struct ios_stat_list *entry = NULL; + struct ios_stat_list *t = NULL; + struct ios_stat_list *list_entry = NULL; + struct ios_stat_list *tmp = NULL; + struct ios_stat_list *last = NULL; + struct ios_stat *stat = NULL; + int cnt = 0; + int found = 0; + int reposition = 0; + double min_count = 0; + + LOCK(&list_head->lock); + { + if (list_head->min_cnt == 0) + list_head->min_cnt = value; + if ((list_head->members == MAX_LIST_MEMBERS) && + (list_head->min_cnt > value)) + goto out; + + list_for_each_entry_safe(entry, t, &list_head->iosstats->list, list) { - - if (list_head->min_cnt == 0) + cnt++; + if (cnt == list_head->members) + last = entry; + + if (!gf_uuid_compare(iosstat->gfid, entry->iosstat->gfid)) { + list_entry = entry; + found = cnt; + entry->value = value; + if (!reposition) { + if (cnt == list_head->members) list_head->min_cnt = value; - if ((list_head->members == MAX_LIST_MEMBERS) && - (list_head->min_cnt > value)) - goto out; - - list_for_each_entry_safe (entry, t, - &list_head->iosstats->list, list) { - cnt++; - if (cnt == list_head->members) - last = entry; - - if (!gf_uuid_compare (iosstat->gfid, - entry->iosstat->gfid)) { - list_entry = entry; - found = cnt; - entry->value = value; - if (!reposition) { - if (cnt == list_head->members) - list_head->min_cnt = value; - goto out; - } - break; - } else if (entry->value <= value && !reposition) { - reposition = cnt; - tmp = entry; - if (cnt == list_head->members - 1) - min_count = entry->value; - } - } - if (found) { - list_del (&list_entry->list); - list_add_tail (&list_entry->list, &tmp->list); - if (min_count) - list_head->min_cnt = min_count; - goto out; - } else if (list_head->members == MAX_LIST_MEMBERS && reposition) { - new = GF_CALLOC (1, sizeof (*new), - gf_io_stats_mt_ios_stat_list); - new->iosstat = iosstat; - new->value = value; - ios_stat_ref (iosstat); - list_add_tail (&new->list, &tmp->list); - if (last) { - stat = last->iosstat; - last->iosstat = NULL; - ios_stat_unref (stat); - list_del (&last->list); - GF_FREE (last); - } - if (reposition == MAX_LIST_MEMBERS) - list_head->min_cnt = value; - else if (min_count) { - list_head->min_cnt = min_count; - } - } else if (list_head->members < MAX_LIST_MEMBERS) { - new = GF_CALLOC (1, sizeof (*new), - gf_io_stats_mt_ios_stat_list); - new->iosstat = iosstat; - new->value = value; - ios_stat_ref (iosstat); - if (reposition) { - list_add_tail (&new->list, &tmp->list); - } else { - list_add_tail (&new->list, &entry->list); - } - list_head->members++; - if (list_head->min_cnt > value) - list_head->min_cnt = value; + goto out; } + break; + } else if (entry->value <= value && !reposition) { + reposition = cnt; + tmp = entry; + if (cnt == list_head->members - 1) + min_count = entry->value; + } + } + if (found) { + list_del(&list_entry->list); + list_add_tail(&list_entry->list, &tmp->list); + if (min_count) + list_head->min_cnt = min_count; + goto out; + } else if (list_head->members == MAX_LIST_MEMBERS && reposition) { + new = GF_CALLOC(1, sizeof(*new), gf_io_stats_mt_ios_stat_list); + new->iosstat = iosstat; + new->value = value; + ios_stat_ref(iosstat); + list_add_tail(&new->list, &tmp->list); + if (last) { + stat = last->iosstat; + last->iosstat = NULL; + ios_stat_unref(stat); + list_del(&last->list); + GF_FREE(last); + } + if (reposition == MAX_LIST_MEMBERS) + list_head->min_cnt = value; + else if (min_count) { + list_head->min_cnt = min_count; + } + } else if (list_head->members < MAX_LIST_MEMBERS) { + new = GF_CALLOC(1, sizeof(*new), gf_io_stats_mt_ios_stat_list); + new->iosstat = iosstat; + new->value = value; + ios_stat_ref(iosstat); + if (reposition) { + list_add_tail(&new->list, &tmp->list); + } else { + list_add_tail(&new->list, &entry->list); + } + list_head->members++; + if (list_head->min_cnt > value) + list_head->min_cnt = value; } + } out: - UNLOCK (&list_head->lock); - return 0; + UNLOCK(&list_head->lock); + return 0; } - static void -ios_bump_read (xlator_t *this, fd_t *fd, size_t len) -{ - struct ios_conf *conf = NULL; - struct ios_fd *iosfd = NULL; - int lb2 = 0; - - conf = this->private; - lb2 = log_base2 (len); - ios_fd_ctx_get (fd, this, &iosfd); - if (!conf) - return; - - GF_ATOMIC_ADD (conf->cumulative.data_read, len); - GF_ATOMIC_ADD (conf->incremental.data_read, len); - GF_ATOMIC_INC (conf->cumulative.block_count_read[lb2]); - GF_ATOMIC_INC (conf->incremental.block_count_read[lb2]); - - if (iosfd) { - GF_ATOMIC_ADD (iosfd->data_read, len); - GF_ATOMIC_INC (iosfd->block_count_read[lb2]); - } -} +ios_bump_read(xlator_t *this, fd_t *fd, size_t len) +{ + struct ios_conf *conf = NULL; + struct ios_fd *iosfd = NULL; + int lb2 = 0; + conf = this->private; + lb2 = log_base2(len); + ios_fd_ctx_get(fd, this, &iosfd); + if (!conf) + return; -static void -ios_bump_write (xlator_t *this, fd_t *fd, size_t len) -{ - struct ios_conf *conf = NULL; - struct ios_fd *iosfd = NULL; - int lb2 = 0; - - conf = this->private; - lb2 = log_base2 (len); - ios_fd_ctx_get (fd, this, &iosfd); - if (!conf) - return; - - GF_ATOMIC_ADD (conf->cumulative.data_written, len); - GF_ATOMIC_ADD (conf->incremental.data_written, len); - GF_ATOMIC_INC (conf->cumulative.block_count_write[lb2]); - GF_ATOMIC_INC (conf->incremental.block_count_write[lb2]); - - if (iosfd) { - GF_ATOMIC_ADD (iosfd->data_written, len); - GF_ATOMIC_INC (iosfd->block_count_write[lb2]); - } -} + GF_ATOMIC_ADD(conf->cumulative.data_read, len); + GF_ATOMIC_ADD(conf->incremental.data_read, len); + GF_ATOMIC_INC(conf->cumulative.block_count_read[lb2]); + GF_ATOMIC_INC(conf->incremental.block_count_read[lb2]); + if (iosfd) { + GF_ATOMIC_ADD(iosfd->data_read, len); + GF_ATOMIC_INC(iosfd->block_count_read[lb2]); + } +} static void -ios_bump_upcall (xlator_t *this, gf_upcall_flags_t event) +ios_bump_write(xlator_t *this, fd_t *fd, size_t len) { - struct ios_conf *conf = NULL; + struct ios_conf *conf = NULL; + struct ios_fd *iosfd = NULL; + int lb2 = 0; - conf = this->private; - if (!conf) - return; - if (conf->count_fop_hits) { - GF_ATOMIC_INC (conf->cumulative.upcall_hits[event]); - GF_ATOMIC_INC (conf->incremental.upcall_hits[event]); - } + conf = this->private; + lb2 = log_base2(len); + ios_fd_ctx_get(fd, this, &iosfd); + if (!conf) + return; + + GF_ATOMIC_ADD(conf->cumulative.data_written, len); + GF_ATOMIC_ADD(conf->incremental.data_written, len); + GF_ATOMIC_INC(conf->cumulative.block_count_write[lb2]); + GF_ATOMIC_INC(conf->incremental.block_count_write[lb2]); + + if (iosfd) { + GF_ATOMIC_ADD(iosfd->data_written, len); + GF_ATOMIC_INC(iosfd->block_count_write[lb2]); + } } +static void +ios_bump_upcall(xlator_t *this, gf_upcall_flags_t event) +{ + struct ios_conf *conf = NULL; + + conf = this->private; + if (!conf) + return; + if (conf->count_fop_hits) { + GF_ATOMIC_INC(conf->cumulative.upcall_hits[event]); + GF_ATOMIC_INC(conf->incremental.upcall_hits[event]); + } +} static void -ios_bump_stats (xlator_t *this, struct ios_stat *iosstat, - ios_stats_type_t type) +ios_bump_stats(xlator_t *this, struct ios_stat *iosstat, ios_stats_type_t type) { - struct ios_conf *conf = NULL; - uint64_t value = 0; + struct ios_conf *conf = NULL; + uint64_t value = 0; - conf = this->private; + conf = this->private; - value = GF_ATOMIC_INC (iosstat->counters[type]); - ios_stat_add_to_list (&conf->list[type], value, iosstat); + value = GF_ATOMIC_INC(iosstat->counters[type]); + ios_stat_add_to_list(&conf->list[type], value, iosstat); } - int -ios_inode_ctx_set (inode_t *inode, xlator_t *this, struct ios_stat *iosstat) +ios_inode_ctx_set(inode_t *inode, xlator_t *this, struct ios_stat *iosstat) { - uint64_t iosstat64 = 0; - int ret = 0; + uint64_t iosstat64 = 0; + int ret = 0; - ios_stat_ref (iosstat); - iosstat64 = (unsigned long) iosstat; - ret = inode_ctx_put (inode, this, iosstat64); - return ret; + ios_stat_ref(iosstat); + iosstat64 = (unsigned long)iosstat; + ret = inode_ctx_put(inode, this, iosstat64); + return ret; } int -ios_inode_ctx_get (inode_t *inode, xlator_t *this, struct ios_stat **iosstat) +ios_inode_ctx_get(inode_t *inode, xlator_t *this, struct ios_stat **iosstat) { - uint64_t iosstat64 = 0; - unsigned long iosstatlong = 0; - int ret = 0; + uint64_t iosstat64 = 0; + unsigned long iosstatlong = 0; + int ret = 0; - ret = inode_ctx_get (inode, this, &iosstat64); - iosstatlong = iosstat64; - if (ret != -1) - *iosstat = (void *) iosstatlong; - - return ret; + ret = inode_ctx_get(inode, this, &iosstat64); + iosstatlong = iosstat64; + if (ret != -1) + *iosstat = (void *)iosstatlong; + return ret; } /* @@ -583,598 +562,575 @@ ios_inode_ctx_get (inode_t *inode, xlator_t *this, struct ios_stat **iosstat) * */ ios_sample_buf_t * -ios_create_sample_buf (size_t buf_size) +ios_create_sample_buf(size_t buf_size) { - ios_sample_buf_t *ios_sample_buf = NULL; - ios_sample_t *ios_samples = NULL; + ios_sample_buf_t *ios_sample_buf = NULL; + ios_sample_t *ios_samples = NULL; - ios_sample_buf = GF_CALLOC (1, - sizeof (*ios_sample_buf), - gf_io_stats_mt_ios_sample_buf); - if (!ios_sample_buf) - goto err; + ios_sample_buf = GF_CALLOC(1, sizeof(*ios_sample_buf), + gf_io_stats_mt_ios_sample_buf); + if (!ios_sample_buf) + goto err; - ios_samples = GF_CALLOC (buf_size, - sizeof (*ios_samples), - gf_io_stats_mt_ios_sample); + ios_samples = GF_CALLOC(buf_size, sizeof(*ios_samples), + gf_io_stats_mt_ios_sample); - if (!ios_samples) - goto err; + if (!ios_samples) + goto err; - ios_sample_buf->ios_samples = ios_samples; - ios_sample_buf->size = buf_size; - ios_sample_buf->pos = 0; - ios_sample_buf->observed = 0; - ios_sample_buf->collected = 0; + ios_sample_buf->ios_samples = ios_samples; + ios_sample_buf->size = buf_size; + ios_sample_buf->pos = 0; + ios_sample_buf->observed = 0; + ios_sample_buf->collected = 0; - return ios_sample_buf; + return ios_sample_buf; err: - GF_FREE (ios_sample_buf); - return NULL; + GF_FREE(ios_sample_buf); + return NULL; } void -ios_destroy_sample_buf (ios_sample_buf_t *ios_sample_buf) +ios_destroy_sample_buf(ios_sample_buf_t *ios_sample_buf) { - GF_FREE (ios_sample_buf->ios_samples); - GF_FREE (ios_sample_buf); + GF_FREE(ios_sample_buf->ios_samples); + GF_FREE(ios_sample_buf); } static int -ios_init_sample_buf (struct ios_conf *conf) +ios_init_sample_buf(struct ios_conf *conf) { - int32_t ret = -1; + int32_t ret = -1; - GF_ASSERT (conf); - LOCK (&conf->lock); - conf->ios_sample_buf = ios_create_sample_buf ( - conf->ios_sample_buf_size); - if (!conf->ios_sample_buf) - goto out; - ret = 0; + GF_ASSERT(conf); + LOCK(&conf->lock); + conf->ios_sample_buf = ios_create_sample_buf(conf->ios_sample_buf_size); + if (!conf->ios_sample_buf) + goto out; + ret = 0; out: - UNLOCK (&conf->lock); - return ret; + UNLOCK(&conf->lock); + return ret; } static int -ios_stats_cleanup (xlator_t *this, inode_t *inode) +ios_stats_cleanup(xlator_t *this, inode_t *inode) { + struct ios_stat *iosstat = NULL; + uint64_t iosstat64 = 0; - struct ios_stat *iosstat = NULL; - uint64_t iosstat64 = 0; - - inode_ctx_del (inode, this, &iosstat64); - if (!iosstat64) { - gf_log (this->name, GF_LOG_WARNING, - "could not get inode ctx"); - return 0; - } - iosstat = (void *) (long)iosstat64; - if (iosstat) { - ios_stat_unref (iosstat); - } + inode_ctx_del(inode, this, &iosstat64); + if (!iosstat64) { + gf_log(this->name, GF_LOG_WARNING, "could not get inode ctx"); return 0; -} - -#define ios_log(this, logfp, fmt ...) \ - do { \ - if (logfp) { \ - fprintf (logfp, fmt); \ - fprintf (logfp, "\n"); \ - } \ - gf_log (this->name, GF_LOG_DEBUG, fmt); \ - } while (0) + } + iosstat = (void *)(long)iosstat64; + if (iosstat) { + ios_stat_unref(iosstat); + } + return 0; +} + +#define ios_log(this, logfp, fmt...) \ + do { \ + if (logfp) { \ + fprintf(logfp, fmt); \ + fprintf(logfp, "\n"); \ + } \ + gf_log(this->name, GF_LOG_DEBUG, fmt); \ + } while (0) int -ios_dump_file_stats (struct ios_stat_head *list_head, xlator_t *this, - FILE *logfp) +ios_dump_file_stats(struct ios_stat_head *list_head, xlator_t *this, + FILE *logfp) { - struct ios_stat_list *entry = NULL; + struct ios_stat_list *entry = NULL; - LOCK (&list_head->lock); + LOCK(&list_head->lock); + { + list_for_each_entry(entry, &list_head->iosstats->list, list) { - list_for_each_entry (entry, &list_head->iosstats->list, list) { - ios_log (this, logfp, "%-12.0f %s", - entry->value, entry->iosstat->filename); - } + ios_log(this, logfp, "%-12.0f %s", entry->value, + entry->iosstat->filename); } - UNLOCK (&list_head->lock); - return 0; + } + UNLOCK(&list_head->lock); + return 0; } int -ios_dump_throughput_stats (struct ios_stat_head *list_head, xlator_t *this, - FILE *logfp, ios_stats_thru_t type) -{ - struct ios_stat_list *entry = NULL; - struct timeval time = {0, }; - char timestr[256] = {0, }; - - LOCK (&list_head->lock); +ios_dump_throughput_stats(struct ios_stat_head *list_head, xlator_t *this, + FILE *logfp, ios_stats_thru_t type) +{ + struct ios_stat_list *entry = NULL; + struct timeval time = { + 0, + }; + char timestr[256] = { + 0, + }; + + LOCK(&list_head->lock); + { + list_for_each_entry(entry, &list_head->iosstats->list, list) { - list_for_each_entry (entry, &list_head->iosstats->list, list) { - gf_time_fmt (timestr, sizeof timestr, - entry->iosstat->thru_counters[type].time.tv_sec, - gf_timefmt_FT); - snprintf (timestr + strlen (timestr), sizeof timestr - strlen (timestr), - ".%"GF_PRI_SUSECONDS, time.tv_usec); - - ios_log (this, logfp, "%s \t %-10.2f \t %s", - timestr, entry->value, entry->iosstat->filename); - } + gf_time_fmt(timestr, sizeof timestr, + entry->iosstat->thru_counters[type].time.tv_sec, + gf_timefmt_FT); + snprintf(timestr + strlen(timestr), + sizeof timestr - strlen(timestr), ".%" GF_PRI_SUSECONDS, + time.tv_usec); + + ios_log(this, logfp, "%s \t %-10.2f \t %s", timestr, entry->value, + entry->iosstat->filename); } - UNLOCK (&list_head->lock); - return 0; + } + UNLOCK(&list_head->lock); + return 0; } int -_io_stats_get_key_prefix (xlator_t *this, char **key_prefix) { - char *key_root = "gluster"; - char *xlator_name = NULL; - char *instance_name = NULL; - size_t key_len = 0; - int bytes_written = 0; - int i = 0; - int ret = 0; - struct ios_conf *conf = this->private; - - xlator_name = strdupa (conf->unique_id); - for (i = 0; i < strlen (xlator_name); i++) { - if (xlator_name[i] == '/') - xlator_name[i] = '_'; +_io_stats_get_key_prefix(xlator_t *this, char **key_prefix) +{ + char *key_root = "gluster"; + char *xlator_name = NULL; + char *instance_name = NULL; + size_t key_len = 0; + int bytes_written = 0; + int i = 0; + int ret = 0; + struct ios_conf *conf = this->private; + + xlator_name = strdupa(conf->unique_id); + for (i = 0; i < strlen(xlator_name); i++) { + if (xlator_name[i] == '/') + xlator_name[i] = '_'; + } + + instance_name = this->instance_name; + if (this->name && strcmp(this->name, "glustershd") == 0) { + xlator_name = "shd"; + } else if (this->prev && strcmp(this->prev->name, "nfs-server") == 0) { + xlator_name = "nfsd"; + if (this->prev->instance_name) + instance_name = strdupa(this->prev->instance_name); + } + + if (strcmp(__progname, "glusterfsd") == 0) + key_root = "gluster.brick"; + + if (instance_name) { + /* +3 for 2 x "." + NULL */ + key_len = strlen(key_root) + strlen(xlator_name) + + strlen(instance_name) + 3; + *key_prefix = GF_CALLOC(key_len, sizeof(char), gf_common_mt_char); + if (!*key_prefix) { + ret = -ENOMEM; + goto err; } - - instance_name = this->instance_name; - if (this->name && strcmp (this->name, "glustershd") == 0) { - xlator_name = "shd"; - } else if (this->prev && - strcmp (this->prev->name, "nfs-server") == 0) { - xlator_name = "nfsd"; - if (this->prev->instance_name) - instance_name = strdupa (this->prev->instance_name); + bytes_written = snprintf(*key_prefix, key_len, "%s.%s.%s", key_root, + xlator_name, instance_name); + if (bytes_written != key_len - 1) { + ret = -EINVAL; + goto err; } - - if (strcmp (__progname, "glusterfsd") == 0) - key_root = "gluster.brick"; - - if (instance_name) { - /* +3 for 2 x "." + NULL */ - key_len = strlen (key_root) + strlen (xlator_name) + - strlen (instance_name) + 3; - *key_prefix = GF_CALLOC (key_len, sizeof (char), - gf_common_mt_char); - if (!*key_prefix) { - ret = -ENOMEM; - goto err; - } - bytes_written = snprintf (*key_prefix, key_len, "%s.%s.%s", - key_root, xlator_name, instance_name); - if (bytes_written != key_len - 1) { - ret = -EINVAL; - goto err; - } - } else { - /* +2 for 1 x "." + NULL */ - key_len = strlen (key_root) + strlen (xlator_name) + 2; - *key_prefix = GF_CALLOC (key_len, sizeof (char), - gf_common_mt_char); - if (!*key_prefix) { - ret = -ENOMEM; - goto err; - } - bytes_written = snprintf (*key_prefix, key_len, "%s.%s", - key_root, xlator_name); - if (bytes_written != key_len - 1) { - ret = -EINVAL; - goto err; - } + } else { + /* +2 for 1 x "." + NULL */ + key_len = strlen(key_root) + strlen(xlator_name) + 2; + *key_prefix = GF_CALLOC(key_len, sizeof(char), gf_common_mt_char); + if (!*key_prefix) { + ret = -ENOMEM; + goto err; } - return 0; + bytes_written = snprintf(*key_prefix, key_len, "%s.%s", key_root, + xlator_name); + if (bytes_written != key_len - 1) { + ret = -EINVAL; + goto err; + } + } + return 0; err: - GF_FREE (*key_prefix); - *key_prefix = NULL; - return ret; + GF_FREE(*key_prefix); + *key_prefix = NULL; + return ret; } int -io_stats_dump_global_to_json_logfp (xlator_t *this, - struct ios_global_stats *stats, struct timeval *now, int interval, - FILE *logfp) -{ - int i = 0; - int j = 0; - struct ios_conf *conf = NULL; - char *key_prefix = NULL; - char *str_prefix = NULL; - char *lc_fop_name = NULL; - int ret = 1; /* Default to error */ - int rw_size; - char *rw_unit = NULL; - uint64_t fop_hits; - float fop_lat_ave; - float fop_lat_min; - float fop_lat_max; - double interval_sec; - double fop_ave_usec = 0.0; - double fop_ave_usec_sum = 0.0; - double weighted_fop_ave_usec = 0.0; - double weighted_fop_ave_usec_sum = 0.0; - long total_fop_hits = 0; - loc_t unused_loc = {0, }; - dict_t *xattr = NULL; - - interval_sec = ((now->tv_sec * 1000000.0 + now->tv_usec) - - (stats->started_at.tv_sec * 1000000.0 + - stats->started_at.tv_usec)) / 1000000.0; - - conf = this->private; - - ret = _io_stats_get_key_prefix (this, &key_prefix); - if (ret) { - goto out; +io_stats_dump_global_to_json_logfp(xlator_t *this, + struct ios_global_stats *stats, + struct timeval *now, int interval, + FILE *logfp) +{ + int i = 0; + int j = 0; + struct ios_conf *conf = NULL; + char *key_prefix = NULL; + char *str_prefix = NULL; + char *lc_fop_name = NULL; + int ret = 1; /* Default to error */ + int rw_size; + char *rw_unit = NULL; + uint64_t fop_hits; + float fop_lat_ave; + float fop_lat_min; + float fop_lat_max; + double interval_sec; + double fop_ave_usec = 0.0; + double fop_ave_usec_sum = 0.0; + double weighted_fop_ave_usec = 0.0; + double weighted_fop_ave_usec_sum = 0.0; + long total_fop_hits = 0; + loc_t unused_loc = { + 0, + }; + dict_t *xattr = NULL; + + interval_sec = ((now->tv_sec * 1000000.0 + now->tv_usec) - + (stats->started_at.tv_sec * 1000000.0 + + stats->started_at.tv_usec)) / + 1000000.0; + + conf = this->private; + + ret = _io_stats_get_key_prefix(this, &key_prefix); + if (ret) { + goto out; + } + + if (interval == -1) { + str_prefix = "aggr"; + + } else { + str_prefix = "inter"; + } + ios_log(this, logfp, "{"); + + for (i = 0; i < 31; i++) { + rw_size = (1 << i); + if (rw_size >= 1024 * 1024) { + rw_size = rw_size / (1024 * 1024); + rw_unit = "mb"; + } else if (rw_size >= 1024) { + rw_size = rw_size / 1024; + rw_unit = "kb"; + } else { + rw_unit = "b"; } if (interval == -1) { - str_prefix = "aggr"; - + ios_log(this, logfp, "\"%s.%s.read_%d%s\": \"%" GF_PRI_ATOMIC "\",", + key_prefix, str_prefix, rw_size, rw_unit, + GF_ATOMIC_GET(stats->block_count_read[i])); + ios_log(this, logfp, + "\"%s.%s.write_%d%s\": \"%" GF_PRI_ATOMIC "\",", key_prefix, + str_prefix, rw_size, rw_unit, + GF_ATOMIC_GET(stats->block_count_write[i])); } else { - str_prefix = "inter"; + ios_log(this, logfp, "\"%s.%s.read_%d%s_per_sec\": \"%0.2lf\",", + key_prefix, str_prefix, rw_size, rw_unit, + (double)(GF_ATOMIC_GET(stats->block_count_read[i]) / + interval_sec)); + ios_log(this, logfp, "\"%s.%s.write_%d%s_per_sec\": \"%0.2lf\",", + key_prefix, str_prefix, rw_size, rw_unit, + (double)(GF_ATOMIC_GET(stats->block_count_write[i]) / + interval_sec)); } - ios_log (this, logfp, "{"); - - for (i = 0; i < 31; i++) { - rw_size = (1 << i); - if (rw_size >= 1024 * 1024) { - rw_size = rw_size / (1024 * 1024); - rw_unit = "mb"; - } else if (rw_size >= 1024) { - rw_size = rw_size / 1024; - rw_unit = "kb"; - } else { - rw_unit = "b"; - } - - if (interval == -1) { - ios_log (this, logfp, - "\"%s.%s.read_%d%s\": \"%"GF_PRI_ATOMIC"\",", - key_prefix, str_prefix, rw_size, rw_unit, - GF_ATOMIC_GET (stats->block_count_read[i])); - ios_log (this, logfp, - "\"%s.%s.write_%d%s\": \"%"GF_PRI_ATOMIC"\",", - key_prefix, str_prefix, rw_size, rw_unit, - GF_ATOMIC_GET (stats->block_count_write[i])); - } else { - ios_log (this, logfp, - "\"%s.%s.read_%d%s_per_sec\": \"%0.2lf\",", - key_prefix, str_prefix, rw_size, rw_unit, - (double) - (GF_ATOMIC_GET (stats->block_count_read[i]) / - interval_sec)); - ios_log (this, logfp, - "\"%s.%s.write_%d%s_per_sec\": \"%0.2lf\",", - key_prefix, str_prefix, rw_size, rw_unit, - (double) - (GF_ATOMIC_GET (stats->block_count_write[i]) / - interval_sec)); - } + } + + if (interval == -1) { + ios_log(this, logfp, "\"%s.%s.fds.open_count\": \"%" PRId64 "\",", + key_prefix, str_prefix, conf->cumulative.nr_opens); + ios_log(this, logfp, "\"%s.%s.fds.max_open_count\": \"%" PRId64 "\",", + key_prefix, str_prefix, conf->cumulative.max_nr_opens); + } + + for (i = 0; i < GF_FOP_MAXVALUE; i++) { + lc_fop_name = strdupa(gf_fop_list[i]); + for (j = 0; lc_fop_name[j]; j++) { + lc_fop_name[j] = tolower(lc_fop_name[j]); } - if (interval == -1) { - ios_log (this, logfp, "\"%s.%s.fds.open_count\": \"%"PRId64 - "\",", key_prefix, str_prefix, - conf->cumulative.nr_opens); - ios_log (this, logfp, - "\"%s.%s.fds.max_open_count\": \"%"PRId64"\",", - key_prefix, str_prefix, conf->cumulative.max_nr_opens); + fop_hits = GF_ATOMIC_GET(stats->fop_hits[i]); + fop_lat_ave = 0.0; + fop_lat_min = 0.0; + fop_lat_max = 0.0; + if (fop_hits) { + if (stats->latency[i].avg) { + fop_lat_ave = stats->latency[i].avg; + fop_lat_min = stats->latency[i].min; + fop_lat_max = stats->latency[i].max; + } } - - for (i = 0; i < GF_FOP_MAXVALUE; i++) { - lc_fop_name = strdupa (gf_fop_list[i]); - for (j = 0; lc_fop_name[j]; j++) { - lc_fop_name[j] = tolower (lc_fop_name[j]); - } - - fop_hits = GF_ATOMIC_GET (stats->fop_hits[i]); - fop_lat_ave = 0.0; - fop_lat_min = 0.0; - fop_lat_max = 0.0; - if (fop_hits) { - if (stats->latency[i].avg) { - fop_lat_ave = stats->latency[i].avg; - fop_lat_min = stats->latency[i].min; - fop_lat_max = stats->latency[i].max; - } - } - if (interval == -1) { - ios_log (this, logfp, - "\"%s.%s.fop.%s.count\": \"%"GF_PRI_ATOMIC"\",", - key_prefix, str_prefix, lc_fop_name, - fop_hits); - } else { - ios_log (this, logfp, - "\"%s.%s.fop.%s.per_sec\": \"%0.2lf\",", - key_prefix, str_prefix, lc_fop_name, - (double)(fop_hits / interval_sec)); - } - - ios_log (this, logfp, - "\"%s.%s.fop.%s.latency_ave_usec\": \"%0.2lf\",", - key_prefix, str_prefix, lc_fop_name, fop_lat_ave); - ios_log (this, logfp, - "\"%s.%s.fop.%s.latency_min_usec\": \"%0.2lf\",", - key_prefix, str_prefix, lc_fop_name, fop_lat_min); - ios_log (this, logfp, - "\"%s.%s.fop.%s.latency_max_usec\": \"%0.2lf\",", - key_prefix, str_prefix, lc_fop_name, fop_lat_max); - - fop_ave_usec_sum += fop_lat_ave; - weighted_fop_ave_usec_sum += fop_hits * fop_lat_ave; - total_fop_hits += fop_hits; + if (interval == -1) { + ios_log(this, logfp, + "\"%s.%s.fop.%s.count\": \"%" GF_PRI_ATOMIC "\",", + key_prefix, str_prefix, lc_fop_name, fop_hits); + } else { + ios_log(this, logfp, "\"%s.%s.fop.%s.per_sec\": \"%0.2lf\",", + key_prefix, str_prefix, lc_fop_name, + (double)(fop_hits / interval_sec)); } - if (total_fop_hits) { - weighted_fop_ave_usec = - weighted_fop_ave_usec_sum/total_fop_hits; - /* Extra key that does not print out an entry w/ 0.00 for - * intervals with no data - */ - ios_log (this, logfp, - "\"%s.%s.fop.weighted_latency_ave_usec_nozerofill\": " - "\"%0.4lf\",", - key_prefix, str_prefix, weighted_fop_ave_usec); - } - ios_log (this, logfp, - "\"%s.%s.fop.weighted_latency_ave_usec\": \"%0.4lf\",", - key_prefix, str_prefix, weighted_fop_ave_usec); - ios_log (this, logfp, - "\"%s.%s.fop.weighted_fop_count\": \"%ld\",", - key_prefix, str_prefix, total_fop_hits); - - fop_ave_usec = fop_ave_usec_sum/GF_FOP_MAXVALUE; - ios_log (this, logfp, - "\"%s.%s.fop.unweighted_latency_ave_usec\":\"%0.4lf\",", - key_prefix, str_prefix, fop_ave_usec); - - for (i = 0; i < GF_UPCALL_FLAGS_MAXVALUE; i++) { - lc_fop_name = strdupa (gf_upcall_list[i]); - for (j = 0; lc_fop_name[j]; j++) { - lc_fop_name[j] = tolower (lc_fop_name[j]); - } - fop_hits = GF_ATOMIC_GET (stats->upcall_hits[i]); - if (interval == -1) { - ios_log (this, logfp, - "\"%s.%s.fop.%s.count\": \"%"GF_PRI_ATOMIC"\",", - key_prefix, str_prefix, lc_fop_name, - fop_hits); - } else { - ios_log (this, logfp, - "\"%s.%s.fop.%s.per_sec\": \"%0.2lf\",", - key_prefix, str_prefix, lc_fop_name, - (double)(fop_hits / interval_sec)); - } + ios_log(this, logfp, "\"%s.%s.fop.%s.latency_ave_usec\": \"%0.2lf\",", + key_prefix, str_prefix, lc_fop_name, fop_lat_ave); + ios_log(this, logfp, "\"%s.%s.fop.%s.latency_min_usec\": \"%0.2lf\",", + key_prefix, str_prefix, lc_fop_name, fop_lat_min); + ios_log(this, logfp, "\"%s.%s.fop.%s.latency_max_usec\": \"%0.2lf\",", + key_prefix, str_prefix, lc_fop_name, fop_lat_max); + + fop_ave_usec_sum += fop_lat_ave; + weighted_fop_ave_usec_sum += fop_hits * fop_lat_ave; + total_fop_hits += fop_hits; + } + + if (total_fop_hits) { + weighted_fop_ave_usec = weighted_fop_ave_usec_sum / total_fop_hits; + /* Extra key that does not print out an entry w/ 0.00 for + * intervals with no data + */ + ios_log(this, logfp, + "\"%s.%s.fop.weighted_latency_ave_usec_nozerofill\": " + "\"%0.4lf\",", + key_prefix, str_prefix, weighted_fop_ave_usec); + } + ios_log(this, logfp, "\"%s.%s.fop.weighted_latency_ave_usec\": \"%0.4lf\",", + key_prefix, str_prefix, weighted_fop_ave_usec); + ios_log(this, logfp, "\"%s.%s.fop.weighted_fop_count\": \"%ld\",", + key_prefix, str_prefix, total_fop_hits); + + fop_ave_usec = fop_ave_usec_sum / GF_FOP_MAXVALUE; + ios_log(this, logfp, + "\"%s.%s.fop.unweighted_latency_ave_usec\":\"%0.4lf\",", key_prefix, + str_prefix, fop_ave_usec); + + for (i = 0; i < GF_UPCALL_FLAGS_MAXVALUE; i++) { + lc_fop_name = strdupa(gf_upcall_list[i]); + for (j = 0; lc_fop_name[j]; j++) { + lc_fop_name[j] = tolower(lc_fop_name[j]); } - - ret = syncop_getxattr (this, &unused_loc, &xattr, - IO_THREADS_QUEUE_SIZE_KEY, NULL, NULL); - if (xattr) { - /* - * Iterate over the dictionary returned to us by io-threads and - * dump the results to the stats file. - */ - data_pair_t *curr = NULL; - - dict_foreach_inline (xattr, curr) { - ios_log (this, logfp, - "\"%s.%s.%s.queue_size\": \"%d\",", - key_prefix, str_prefix, curr->key, - data_to_int32 (curr->value)); - } - - /* Free the dictionary */ - dict_unref (xattr); + fop_hits = GF_ATOMIC_GET(stats->upcall_hits[i]); + if (interval == -1) { + ios_log(this, logfp, + "\"%s.%s.fop.%s.count\": \"%" GF_PRI_ATOMIC "\",", + key_prefix, str_prefix, lc_fop_name, fop_hits); } else { - gf_log (this->name, GF_LOG_WARNING, - "Unable to get queue size counts from " - "the io-threads translator!"); + ios_log(this, logfp, "\"%s.%s.fop.%s.per_sec\": \"%0.2lf\",", + key_prefix, str_prefix, lc_fop_name, + (double)(fop_hits / interval_sec)); } + } - if (interval == -1) { - ios_log (this, logfp, "\"%s.%s.uptime\": \"%"PRId64"\",", - key_prefix, str_prefix, - (uint64_t) (now->tv_sec - stats->started_at.tv_sec)); - ios_log (this, logfp, "\"%s.%s.bytes_read\": \"" - "%"GF_PRI_ATOMIC"\",", key_prefix, str_prefix, - GF_ATOMIC_GET (stats->data_read)); - ios_log (this, logfp, "\"%s.%s.bytes_written\": \"" - "%"GF_PRI_ATOMIC"\"", key_prefix, str_prefix, - GF_ATOMIC_GET (stats->data_written)); - } else { - ios_log (this, logfp, - "\"%s.%s.sample_interval_sec\": \"%0.2lf\",", - key_prefix, str_prefix, - interval_sec); - ios_log (this, logfp, - "\"%s.%s.bytes_read_per_sec\": \"%0.2lf\",", - key_prefix, str_prefix, (double) - (GF_ATOMIC_GET (stats->data_read) / interval_sec)); - ios_log (this, logfp, - "\"%s.%s.bytes_written_per_sec\": \"%0.2lf\"", - key_prefix, str_prefix, (double) - (GF_ATOMIC_GET (stats->data_written) / interval_sec)); + ret = syncop_getxattr(this, &unused_loc, &xattr, IO_THREADS_QUEUE_SIZE_KEY, + NULL, NULL); + if (xattr) { + /* + * Iterate over the dictionary returned to us by io-threads and + * dump the results to the stats file. + */ + data_pair_t *curr = NULL; + + dict_foreach_inline(xattr, curr) + { + ios_log(this, logfp, "\"%s.%s.%s.queue_size\": \"%d\",", key_prefix, + str_prefix, curr->key, data_to_int32(curr->value)); } - ios_log (this, logfp, "}"); - ret = 0; + /* Free the dictionary */ + dict_unref(xattr); + } else { + gf_log(this->name, GF_LOG_WARNING, + "Unable to get queue size counts from " + "the io-threads translator!"); + } + + if (interval == -1) { + ios_log(this, logfp, "\"%s.%s.uptime\": \"%" PRId64 "\",", key_prefix, + str_prefix, (uint64_t)(now->tv_sec - stats->started_at.tv_sec)); + ios_log(this, logfp, + "\"%s.%s.bytes_read\": \"" + "%" GF_PRI_ATOMIC "\",", + key_prefix, str_prefix, GF_ATOMIC_GET(stats->data_read)); + ios_log(this, logfp, + "\"%s.%s.bytes_written\": \"" + "%" GF_PRI_ATOMIC "\"", + key_prefix, str_prefix, GF_ATOMIC_GET(stats->data_written)); + } else { + ios_log(this, logfp, "\"%s.%s.sample_interval_sec\": \"%0.2lf\",", + key_prefix, str_prefix, interval_sec); + ios_log(this, logfp, "\"%s.%s.bytes_read_per_sec\": \"%0.2lf\",", + key_prefix, str_prefix, + (double)(GF_ATOMIC_GET(stats->data_read) / interval_sec)); + ios_log(this, logfp, "\"%s.%s.bytes_written_per_sec\": \"%0.2lf\"", + key_prefix, str_prefix, + (double)(GF_ATOMIC_GET(stats->data_written) / interval_sec)); + } + + ios_log(this, logfp, "}"); + ret = 0; out: - GF_FREE (key_prefix); - return ret; + GF_FREE(key_prefix); + return ret; } char * -_resolve_username (xlator_t *this, uid_t uid) +_resolve_username(xlator_t *this, uid_t uid) { - struct passwd pwd; - struct passwd *pwd_result = NULL; - size_t pwd_buf_len; - char *pwd_buf = NULL; - char *ret = NULL; + struct passwd pwd; + struct passwd *pwd_result = NULL; + size_t pwd_buf_len; + char *pwd_buf = NULL; + char *ret = NULL; - /* Prepare our buffer for the uid->username translation */ + /* Prepare our buffer for the uid->username translation */ #ifdef _SC_GETGR_R_SIZE_MAX - pwd_buf_len = sysconf (_SC_GETGR_R_SIZE_MAX); + pwd_buf_len = sysconf(_SC_GETGR_R_SIZE_MAX); #else - pwd_buf_len = -1; + pwd_buf_len = -1; #endif - if (pwd_buf_len == -1) { - pwd_buf_len = DEFAULT_PWD_BUF_SZ; /* per the man page */ - } + if (pwd_buf_len == -1) { + pwd_buf_len = DEFAULT_PWD_BUF_SZ; /* per the man page */ + } - pwd_buf = alloca (pwd_buf_len); - if (!pwd_buf) - goto err; + pwd_buf = alloca(pwd_buf_len); + if (!pwd_buf) + goto err; - getpwuid_r (uid, &pwd, pwd_buf, pwd_buf_len, - &pwd_result); - if (!pwd_result) - goto err; + getpwuid_r(uid, &pwd, pwd_buf, pwd_buf_len, &pwd_result); + if (!pwd_result) + goto err; - ret = gf_strdup (pwd.pw_name); - if (ret) - return ret; - else - gf_log (this->name, GF_LOG_ERROR, - "gf_strdup failed, failing username " - "resolution."); -err: + ret = gf_strdup(pwd.pw_name); + if (ret) return ret; + else + gf_log(this->name, GF_LOG_ERROR, + "gf_strdup failed, failing username " + "resolution."); +err: + return ret; } char * -_resolve_group_name (xlator_t *this, gid_t gid) +_resolve_group_name(xlator_t *this, gid_t gid) { - struct group grp; - struct group *grp_result = NULL; - size_t grp_buf_len; - char *grp_buf = NULL; - char *ret = NULL; + struct group grp; + struct group *grp_result = NULL; + size_t grp_buf_len; + char *grp_buf = NULL; + char *ret = NULL; - /* Prepare our buffer for the gid->group name translation */ + /* Prepare our buffer for the gid->group name translation */ #ifdef _SC_GETGR_R_SIZE_MAX - grp_buf_len = sysconf (_SC_GETGR_R_SIZE_MAX); + grp_buf_len = sysconf(_SC_GETGR_R_SIZE_MAX); #else - grp_buf_len = -1; + grp_buf_len = -1; #endif - if (grp_buf_len == -1) { - grp_buf_len = DEFAULT_GRP_BUF_SZ; /* per the man page */ - } + if (grp_buf_len == -1) { + grp_buf_len = DEFAULT_GRP_BUF_SZ; /* per the man page */ + } - grp_buf = alloca (grp_buf_len); - if (!grp_buf) { - goto err; - } + grp_buf = alloca(grp_buf_len); + if (!grp_buf) { + goto err; + } - if (getgrgid_r (gid, &grp, grp_buf, grp_buf_len, &grp_result) != 0) - goto err; + if (getgrgid_r(gid, &grp, grp_buf, grp_buf_len, &grp_result) != 0) + goto err; - if (!grp_result) - goto err; + if (!grp_result) + goto err; - ret = gf_strdup (grp.gr_name); - if (ret) - return ret; - else - gf_log (this->name, GF_LOG_ERROR, - "gf_strdup failed, failing username " - "resolution."); -err: + ret = gf_strdup(grp.gr_name); + if (ret) return ret; + else + gf_log(this->name, GF_LOG_ERROR, + "gf_strdup failed, failing username " + "resolution."); +err: + return ret; } - /* * This function writes out a latency sample to a given file descriptor * and beautifies the output in the process. */ void -_io_stats_write_latency_sample (xlator_t *this, ios_sample_t *sample, - FILE *logfp) -{ - double epoch_time = 0.00; - char *xlator_name = NULL; - char *instance_name = NULL; - char *hostname = NULL; - char *identifier = NULL; - char *port = NULL; - char *port_pos = NULL; - char *group_name = NULL; - char *username = NULL; - struct ios_conf *conf = NULL; - - conf = this->private; - - epoch_time = (sample->timestamp).tv_sec + - ((sample->timestamp).tv_usec / 1000000.0); - - if (strlen (sample->identifier) == 0) { - hostname = "Unknown"; - port = "Unknown"; - } else { - identifier = strdupa (sample->identifier); - port_pos = strrchr (identifier, ':'); - if (!port_pos || strlen(port_pos) < 2) - goto err; - port = strdupa (port_pos + 1); - if (!port) - goto err; - *port_pos = '\0'; - hostname = gf_rev_dns_lookup_cached (identifier, - conf->dnscache); - if (!hostname) - hostname = "Unknown"; - } - - xlator_name = conf->unique_id; - if (!xlator_name || strlen (xlator_name) == 0) - xlator_name = "Unknown"; - - instance_name = this->instance_name; - if (!instance_name || strlen (instance_name) == 0) - instance_name = "N/A"; - - /* Resolve the UID to a string username */ - username = _resolve_username (this, sample->uid); +_io_stats_write_latency_sample(xlator_t *this, ios_sample_t *sample, + FILE *logfp) +{ + double epoch_time = 0.00; + char *xlator_name = NULL; + char *instance_name = NULL; + char *hostname = NULL; + char *identifier = NULL; + char *port = NULL; + char *port_pos = NULL; + char *group_name = NULL; + char *username = NULL; + struct ios_conf *conf = NULL; + + conf = this->private; + + epoch_time = (sample->timestamp).tv_sec + + ((sample->timestamp).tv_usec / 1000000.0); + + if (strlen(sample->identifier) == 0) { + hostname = "Unknown"; + port = "Unknown"; + } else { + identifier = strdupa(sample->identifier); + port_pos = strrchr(identifier, ':'); + if (!port_pos || strlen(port_pos) < 2) + goto err; + port = strdupa(port_pos + 1); + if (!port) + goto err; + *port_pos = '\0'; + hostname = gf_rev_dns_lookup_cached(identifier, conf->dnscache); + if (!hostname) + hostname = "Unknown"; + } + + xlator_name = conf->unique_id; + if (!xlator_name || strlen(xlator_name) == 0) + xlator_name = "Unknown"; + + instance_name = this->instance_name; + if (!instance_name || strlen(instance_name) == 0) + instance_name = "N/A"; + + /* Resolve the UID to a string username */ + username = _resolve_username(this, sample->uid); + if (!username) { + username = GF_MALLOC(30, gf_common_mt_char); if (!username) { - username = GF_MALLOC (30, gf_common_mt_char); - if (!username) { - goto out; - } - sprintf (username, "%d", (int32_t)sample->uid); + goto out; } + sprintf(username, "%d", (int32_t)sample->uid); + } - /* Resolve the GID to a string group name */ - group_name = _resolve_group_name (this, sample->gid); + /* Resolve the GID to a string group name */ + group_name = _resolve_group_name(this, sample->gid); + if (!group_name) { + group_name = GF_MALLOC(30, gf_common_mt_char); if (!group_name) { - group_name = GF_MALLOC (30, gf_common_mt_char); - if (!group_name) { - goto out; - } - sprintf (group_name, "%d", (int32_t)sample->gid); + goto out; } - - ios_log (this, logfp, - "%0.6lf,%s,%s,%0.4lf,%s,%s,%s,%s,%s,%s", - epoch_time, fop_enum_to_pri_string (sample->fop_type), - gf_fop_string (sample->fop_type), - sample->elapsed, xlator_name, instance_name, username, - group_name, hostname, port); - goto out; + sprintf(group_name, "%d", (int32_t)sample->gid); + } + + ios_log(this, logfp, "%0.6lf,%s,%s,%0.4lf,%s,%s,%s,%s,%s,%s", epoch_time, + fop_enum_to_pri_string(sample->fop_type), + gf_fop_string(sample->fop_type), sample->elapsed, xlator_name, + instance_name, username, group_name, hostname, port); + goto out; err: - gf_log (this->name, GF_LOG_ERROR, - "Error parsing socket identifier"); + gf_log(this->name, GF_LOG_ERROR, "Error parsing socket identifier"); out: - GF_FREE (group_name); - GF_FREE (username); + GF_FREE(group_name); + GF_FREE(username); } /* @@ -1183,3424 +1139,3210 @@ out: * contents of the saved reference. */ int -io_stats_dump_latency_samples_logfp (xlator_t *this, FILE *logfp) -{ - uint64_t i = 0; - struct ios_conf *conf = NULL; - ios_sample_buf_t *sample_buf = NULL; - int ret = 1; /* Default to error */ - - conf = this->private; - - /* Save pointer to old buffer; the CS equivalent of - * Indiana Jones: https://www.youtube.com/watch?v=Pr-8AP0To4k, - * though ours will end better I hope! - */ - sample_buf = conf->ios_sample_buf; - if (!sample_buf) { - gf_log (this->name, GF_LOG_WARNING, - "Sampling buffer is null, bailing!"); - goto out; - } - - /* Empty case, nothing to do, exit. */ - if (sample_buf->collected == 0) { - gf_log (this->name, GF_LOG_DEBUG, - "No samples, dump not required."); - ret = 0; - goto out; - } - - /* Init a new buffer, so we are free to work on the one we saved a - * reference to above. - */ - if (ios_init_sample_buf (conf) != 0) { - gf_log (this->name, GF_LOG_WARNING, - "Failed to init new sampling buffer, out of memory?"); - goto out; - } +io_stats_dump_latency_samples_logfp(xlator_t *this, FILE *logfp) +{ + uint64_t i = 0; + struct ios_conf *conf = NULL; + ios_sample_buf_t *sample_buf = NULL; + int ret = 1; /* Default to error */ + + conf = this->private; + + /* Save pointer to old buffer; the CS equivalent of + * Indiana Jones: https://www.youtube.com/watch?v=Pr-8AP0To4k, + * though ours will end better I hope! + */ + sample_buf = conf->ios_sample_buf; + if (!sample_buf) { + gf_log(this->name, GF_LOG_WARNING, "Sampling buffer is null, bailing!"); + goto out; + } - /* Wrap-around case, dump from pos to sample_buf->size -1 - * and then from 0 to sample_buf->pos (covered off by - * "simple case") - */ - if (sample_buf->collected > sample_buf->pos + 1) { - for (i = sample_buf->pos; i < sample_buf->size; i++) { - _io_stats_write_latency_sample (this, - &(sample_buf->ios_samples[i]), logfp); - } + /* Empty case, nothing to do, exit. */ + if (sample_buf->collected == 0) { + gf_log(this->name, GF_LOG_DEBUG, "No samples, dump not required."); + ret = 0; + goto out; + } + + /* Init a new buffer, so we are free to work on the one we saved a + * reference to above. + */ + if (ios_init_sample_buf(conf) != 0) { + gf_log(this->name, GF_LOG_WARNING, + "Failed to init new sampling buffer, out of memory?"); + goto out; + } + + /* Wrap-around case, dump from pos to sample_buf->size -1 + * and then from 0 to sample_buf->pos (covered off by + * "simple case") + */ + if (sample_buf->collected > sample_buf->pos + 1) { + for (i = sample_buf->pos; i < sample_buf->size; i++) { + _io_stats_write_latency_sample(this, &(sample_buf->ios_samples[i]), + logfp); } + } - /* Simple case: Dump from 0 to sample_buf->pos */ - for (i = 0; i < sample_buf->pos; i++) { - _io_stats_write_latency_sample (this, - &(sample_buf->ios_samples[i]), logfp); - } - ios_destroy_sample_buf (sample_buf); + /* Simple case: Dump from 0 to sample_buf->pos */ + for (i = 0; i < sample_buf->pos; i++) { + _io_stats_write_latency_sample(this, &(sample_buf->ios_samples[i]), + logfp); + } + ios_destroy_sample_buf(sample_buf); out: - return ret; + return ret; } int -io_stats_dump_global_to_logfp (xlator_t *this, struct ios_global_stats *stats, - struct timeval *now, int interval, FILE *logfp) -{ - int i = 0; - int per_line = 0; - int index = 0; - struct ios_stat_head *list_head = NULL; - struct ios_conf *conf = NULL; - char timestr[256] = {0, }; - char str_header[128] = {0}; - char str_read[128] = {0}; - char str_write[128] = {0}; - uint64_t fop_hits = 0; - uint64_t block_count_read = 0; - uint64_t block_count_write = 0; - - conf = this->private; - - if (interval == -1) - ios_log (this, logfp, "\n=== Cumulative stats ==="); +io_stats_dump_global_to_logfp(xlator_t *this, struct ios_global_stats *stats, + struct timeval *now, int interval, FILE *logfp) +{ + int i = 0; + int per_line = 0; + int index = 0; + struct ios_stat_head *list_head = NULL; + struct ios_conf *conf = NULL; + char timestr[256] = { + 0, + }; + char str_header[128] = {0}; + char str_read[128] = {0}; + char str_write[128] = {0}; + uint64_t fop_hits = 0; + uint64_t block_count_read = 0; + uint64_t block_count_write = 0; + + conf = this->private; + + if (interval == -1) + ios_log(this, logfp, "\n=== Cumulative stats ==="); + else + ios_log(this, logfp, "\n=== Interval %d stats ===", interval); + ios_log(this, logfp, " Duration : %" PRId64 " secs", + (uint64_t)(now->tv_sec - stats->started_at.tv_sec)); + ios_log(this, logfp, " BytesRead : %" GF_PRI_ATOMIC, + GF_ATOMIC_GET(stats->data_read)); + ios_log(this, logfp, " BytesWritten : %" GF_PRI_ATOMIC "\n", + GF_ATOMIC_GET(stats->data_written)); + + snprintf(str_header, sizeof(str_header), "%-12s %c", "Block Size", ':'); + snprintf(str_read, sizeof(str_read), "%-12s %c", "Read Count", ':'); + snprintf(str_write, sizeof(str_write), "%-12s %c", "Write Count", ':'); + index = 14; + for (i = 0; i < IOS_BLOCK_COUNT_SIZE; i++) { + block_count_read = GF_ATOMIC_GET(stats->block_count_read[i]); + block_count_write = GF_ATOMIC_GET(stats->block_count_write[i]); + if ((block_count_read == 0) && (block_count_write == 0)) + continue; + per_line++; + + snprintf(str_header + index, sizeof(str_header) - index, "%16dB+", + (1 << i)); + if (block_count_read) + snprintf(str_read + index, sizeof(str_read) - index, "%18" PRId64, + block_count_read); else - ios_log (this, logfp, "\n=== Interval %d stats ===", - interval); - ios_log (this, logfp, " Duration : %"PRId64" secs", - (uint64_t) (now->tv_sec - stats->started_at.tv_sec)); - ios_log (this, logfp, " BytesRead : %"GF_PRI_ATOMIC, - GF_ATOMIC_GET (stats->data_read)); - ios_log (this, logfp, " BytesWritten : %"GF_PRI_ATOMIC"\n", - GF_ATOMIC_GET (stats->data_written)); - - snprintf (str_header, sizeof (str_header), "%-12s %c", "Block Size", ':'); - snprintf (str_read, sizeof (str_read), "%-12s %c", "Read Count", ':'); - snprintf (str_write, sizeof (str_write), "%-12s %c", "Write Count", ':'); - index = 14; - for (i = 0; i < IOS_BLOCK_COUNT_SIZE; i++) { - block_count_read = GF_ATOMIC_GET (stats->block_count_read[i]); - block_count_write = GF_ATOMIC_GET (stats->block_count_write[i]); - if ((block_count_read == 0) && (block_count_write == 0)) - continue; - per_line++; - - snprintf (str_header+index, sizeof (str_header)-index, - "%16dB+", (1<<i)); - if (block_count_read) - snprintf (str_read+index, sizeof (str_read)-index, - "%18"PRId64, block_count_read); - else snprintf (str_read+index, sizeof (str_read)-index, - "%18s", "0"); - if (block_count_write) - snprintf (str_write+index, sizeof (str_write)-index, - "%18"GF_PRI_ATOMIC, block_count_write); - else snprintf (str_write+index, sizeof (str_write)-index, - "%18s", "0"); - - index += 18; - if (per_line == 3) { - ios_log (this, logfp, "%s", str_header); - ios_log (this, logfp, "%s", str_read); - ios_log (this, logfp, "%s\n", str_write); - - snprintf (str_header, sizeof (str_header), "%-12s %c", - "Block Size", ':'); - snprintf (str_read, sizeof (str_read), "%-12s %c", - "Read Count", ':'); - snprintf (str_write, sizeof (str_write), "%-12s %c", - "Write Count", ':'); - - index = 14; - per_line = 0; - } - } - - if (per_line != 0) { - ios_log (this, logfp, "%s", str_header); - ios_log (this, logfp, "%s", str_read); - ios_log (this, logfp, "%s\n", str_write); - } - - ios_log (this, logfp, "%-13s %10s %14s %14s %14s", "Fop", - "Call Count", "Avg-Latency", "Min-Latency", - "Max-Latency"); - ios_log (this, logfp, "%-13s %10s %14s %14s %14s", "---", "----------", - "-----------", "-----------", "-----------"); - - for (i = 0; i < GF_FOP_MAXVALUE; i++) { - fop_hits = GF_ATOMIC_GET (stats->fop_hits[i]); - if (fop_hits && !stats->latency[i].avg) - ios_log (this, logfp, "%-13s %10"GF_PRI_ATOMIC" %11s " - "us %11s us %11s us", gf_fop_list[i], - fop_hits, "0", "0", "0"); - else if (fop_hits && stats->latency[i].avg) - ios_log (this, logfp, "%-13s %10"GF_PRI_ATOMIC" " - "%11.2lf us %11.2lf us %11.2lf us", - gf_fop_list[i], fop_hits, - stats->latency[i].avg, stats->latency[i].min, - stats->latency[i].max); - } - - for (i = 0; i < GF_UPCALL_FLAGS_MAXVALUE; i++) { - fop_hits = GF_ATOMIC_GET (stats->upcall_hits[i]); - if (fop_hits) - ios_log (this, logfp, "%-13s %10"PRId64" %11s " - "us %11s us %11s us", gf_upcall_list[i], - fop_hits, "0", "0", "0"); + snprintf(str_read + index, sizeof(str_read) - index, "%18s", "0"); + if (block_count_write) + snprintf(str_write + index, sizeof(str_write) - index, + "%18" GF_PRI_ATOMIC, block_count_write); + else + snprintf(str_write + index, sizeof(str_write) - index, "%18s", "0"); + + index += 18; + if (per_line == 3) { + ios_log(this, logfp, "%s", str_header); + ios_log(this, logfp, "%s", str_read); + ios_log(this, logfp, "%s\n", str_write); + + snprintf(str_header, sizeof(str_header), "%-12s %c", "Block Size", + ':'); + snprintf(str_read, sizeof(str_read), "%-12s %c", "Read Count", ':'); + snprintf(str_write, sizeof(str_write), "%-12s %c", "Write Count", + ':'); + + index = 14; + per_line = 0; } - - ios_log (this, logfp, "------ ----- ----- ----- ----- ----- ----- ----- " - " ----- ----- ----- -----\n"); - - if (interval == -1) { - LOCK (&conf->lock); - { - gf_time_fmt (timestr, sizeof timestr, - conf->cumulative.max_openfd_time.tv_sec, - gf_timefmt_FT); - snprintf (timestr + strlen (timestr), sizeof timestr - strlen (timestr), - ".%"GF_PRI_SUSECONDS, - conf->cumulative.max_openfd_time.tv_usec); - ios_log (this, logfp, "Current open fd's: %"PRId64 - " Max open fd's: %"PRId64" time %s", - conf->cumulative.nr_opens, - conf->cumulative.max_nr_opens, timestr); - } - UNLOCK (&conf->lock); - ios_log (this, logfp, "\n==========Open File Stats========"); - ios_log (this, logfp, "\nCOUNT: \t FILE NAME"); - list_head = &conf->list[IOS_STATS_TYPE_OPEN]; - ios_dump_file_stats (list_head, this, logfp); - - - ios_log (this, logfp, "\n==========Read File Stats========"); - ios_log (this, logfp, "\nCOUNT: \t FILE NAME"); - list_head = &conf->list[IOS_STATS_TYPE_READ]; - ios_dump_file_stats (list_head, this, logfp); - - ios_log (this, logfp, "\n==========Write File Stats========"); - ios_log (this, logfp, "\nCOUNT: \t FILE NAME"); - list_head = &conf->list[IOS_STATS_TYPE_WRITE]; - ios_dump_file_stats (list_head, this, logfp); - - ios_log (this, logfp, "\n==========Directory open stats========"); - ios_log (this, logfp, "\nCOUNT: \t DIRECTORY NAME"); - list_head = &conf->list[IOS_STATS_TYPE_OPENDIR]; - ios_dump_file_stats (list_head, this, logfp); - - ios_log (this, logfp, "\n========Directory readdirp Stats======="); - ios_log (this, logfp, "\nCOUNT: \t DIRECTORY NAME"); - list_head = &conf->list[IOS_STATS_TYPE_READDIRP]; - ios_dump_file_stats (list_head, this, logfp); - - ios_log (this, logfp, "\n========Read Throughput File Stats====="); - ios_log (this, logfp, "\nTIMESTAMP \t\t\t THROUGHPUT(KBPS)" - "\tFILE NAME"); - list_head = &conf->thru_list[IOS_STATS_THRU_READ]; - ios_dump_throughput_stats(list_head, this, logfp, - IOS_STATS_THRU_READ); - - ios_log (this, logfp, "\n======Write Throughput File Stats======"); - ios_log (this, logfp, "\nTIMESTAMP \t\t\t THROUGHPUT(KBPS)" - "\tFILE NAME"); - list_head = &conf->thru_list[IOS_STATS_THRU_WRITE]; - ios_dump_throughput_stats (list_head, this, logfp, - IOS_STATS_THRU_WRITE); + } + + if (per_line != 0) { + ios_log(this, logfp, "%s", str_header); + ios_log(this, logfp, "%s", str_read); + ios_log(this, logfp, "%s\n", str_write); + } + + ios_log(this, logfp, "%-13s %10s %14s %14s %14s", "Fop", "Call Count", + "Avg-Latency", "Min-Latency", "Max-Latency"); + ios_log(this, logfp, "%-13s %10s %14s %14s %14s", "---", "----------", + "-----------", "-----------", "-----------"); + + for (i = 0; i < GF_FOP_MAXVALUE; i++) { + fop_hits = GF_ATOMIC_GET(stats->fop_hits[i]); + if (fop_hits && !stats->latency[i].avg) + ios_log(this, logfp, + "%-13s %10" GF_PRI_ATOMIC + " %11s " + "us %11s us %11s us", + gf_fop_list[i], fop_hits, "0", "0", "0"); + else if (fop_hits && stats->latency[i].avg) + ios_log(this, logfp, + "%-13s %10" GF_PRI_ATOMIC + " " + "%11.2lf us %11.2lf us %11.2lf us", + gf_fop_list[i], fop_hits, stats->latency[i].avg, + stats->latency[i].min, stats->latency[i].max); + } + + for (i = 0; i < GF_UPCALL_FLAGS_MAXVALUE; i++) { + fop_hits = GF_ATOMIC_GET(stats->upcall_hits[i]); + if (fop_hits) + ios_log(this, logfp, + "%-13s %10" PRId64 + " %11s " + "us %11s us %11s us", + gf_upcall_list[i], fop_hits, "0", "0", "0"); + } + + ios_log(this, logfp, + "------ ----- ----- ----- ----- ----- ----- ----- " + " ----- ----- ----- -----\n"); + + if (interval == -1) { + LOCK(&conf->lock); + { + gf_time_fmt(timestr, sizeof timestr, + conf->cumulative.max_openfd_time.tv_sec, gf_timefmt_FT); + snprintf(timestr + strlen(timestr), + sizeof timestr - strlen(timestr), ".%" GF_PRI_SUSECONDS, + conf->cumulative.max_openfd_time.tv_usec); + ios_log(this, logfp, + "Current open fd's: %" PRId64 " Max open fd's: %" PRId64 + " time %s", + conf->cumulative.nr_opens, conf->cumulative.max_nr_opens, + timestr); } - return 0; + UNLOCK(&conf->lock); + ios_log(this, logfp, "\n==========Open File Stats========"); + ios_log(this, logfp, "\nCOUNT: \t FILE NAME"); + list_head = &conf->list[IOS_STATS_TYPE_OPEN]; + ios_dump_file_stats(list_head, this, logfp); + + ios_log(this, logfp, "\n==========Read File Stats========"); + ios_log(this, logfp, "\nCOUNT: \t FILE NAME"); + list_head = &conf->list[IOS_STATS_TYPE_READ]; + ios_dump_file_stats(list_head, this, logfp); + + ios_log(this, logfp, "\n==========Write File Stats========"); + ios_log(this, logfp, "\nCOUNT: \t FILE NAME"); + list_head = &conf->list[IOS_STATS_TYPE_WRITE]; + ios_dump_file_stats(list_head, this, logfp); + + ios_log(this, logfp, "\n==========Directory open stats========"); + ios_log(this, logfp, "\nCOUNT: \t DIRECTORY NAME"); + list_head = &conf->list[IOS_STATS_TYPE_OPENDIR]; + ios_dump_file_stats(list_head, this, logfp); + + ios_log(this, logfp, "\n========Directory readdirp Stats======="); + ios_log(this, logfp, "\nCOUNT: \t DIRECTORY NAME"); + list_head = &conf->list[IOS_STATS_TYPE_READDIRP]; + ios_dump_file_stats(list_head, this, logfp); + + ios_log(this, logfp, "\n========Read Throughput File Stats====="); + ios_log(this, logfp, + "\nTIMESTAMP \t\t\t THROUGHPUT(KBPS)" + "\tFILE NAME"); + list_head = &conf->thru_list[IOS_STATS_THRU_READ]; + ios_dump_throughput_stats(list_head, this, logfp, IOS_STATS_THRU_READ); + + ios_log(this, logfp, "\n======Write Throughput File Stats======"); + ios_log(this, logfp, + "\nTIMESTAMP \t\t\t THROUGHPUT(KBPS)" + "\tFILE NAME"); + list_head = &conf->thru_list[IOS_STATS_THRU_WRITE]; + ios_dump_throughput_stats(list_head, this, logfp, IOS_STATS_THRU_WRITE); + } + return 0; } int -io_stats_dump_global_to_dict (xlator_t *this, struct ios_global_stats *stats, - struct timeval *now, int interval, dict_t *dict) -{ - int ret = 0; - char key[256] = {0}; - uint64_t sec = 0; - int i = 0; - uint64_t count = 0; - uint64_t fop_hits = 0; - - GF_ASSERT (stats); - GF_ASSERT (now); - GF_ASSERT (dict); - GF_ASSERT (this); - - if (interval == -1) - snprintf (key, sizeof (key), "cumulative"); - else - snprintf (key, sizeof (key), "interval"); - ret = dict_set_int32 (dict, key, interval); - if (ret) - gf_log (this->name, GF_LOG_ERROR, "failed to set " - "interval %d", interval); - - snprintf (key, sizeof (key), "%d-duration", interval); - sec = (uint64_t) (now->tv_sec - stats->started_at.tv_sec); - ret = dict_set_uint64 (dict, key, sec); - if (ret) { - gf_log (this->name, GF_LOG_ERROR, "failed to set " - "duration(%d) - %"PRId64, interval, sec); +io_stats_dump_global_to_dict(xlator_t *this, struct ios_global_stats *stats, + struct timeval *now, int interval, dict_t *dict) +{ + int ret = 0; + char key[256] = {0}; + uint64_t sec = 0; + int i = 0; + uint64_t count = 0; + uint64_t fop_hits = 0; + + GF_ASSERT(stats); + GF_ASSERT(now); + GF_ASSERT(dict); + GF_ASSERT(this); + + if (interval == -1) + snprintf(key, sizeof(key), "cumulative"); + else + snprintf(key, sizeof(key), "interval"); + ret = dict_set_int32(dict, key, interval); + if (ret) + gf_log(this->name, GF_LOG_ERROR, + "failed to set " + "interval %d", + interval); + + snprintf(key, sizeof(key), "%d-duration", interval); + sec = (uint64_t)(now->tv_sec - stats->started_at.tv_sec); + ret = dict_set_uint64(dict, key, sec); + if (ret) { + gf_log(this->name, GF_LOG_ERROR, + "failed to set " + "duration(%d) - %" PRId64, + interval, sec); + goto out; + } + + snprintf(key, sizeof(key), "%d-total-read", interval); + ret = dict_set_uint64(dict, key, GF_ATOMIC_GET(stats->data_read)); + if (ret) { + gf_log(this->name, GF_LOG_ERROR, + "failed to set total " + "read(%d) - %" GF_PRI_ATOMIC, + interval, GF_ATOMIC_GET(stats->data_read)); + goto out; + } + + snprintf(key, sizeof(key), "%d-total-write", interval); + ret = dict_set_uint64(dict, key, GF_ATOMIC_GET(stats->data_written)); + if (ret) { + gf_log(this->name, GF_LOG_ERROR, + "failed to set total " + "write(%d) - %" GF_PRI_ATOMIC, + interval, GF_ATOMIC_GET(stats->data_written)); + goto out; + } + for (i = 0; i < 32; i++) { + count = GF_ATOMIC_GET(stats->block_count_read[i]); + if (count) { + snprintf(key, sizeof(key), "%d-read-%d", interval, (1 << i)); + ret = dict_set_uint64(dict, key, count); + if (ret) { + gf_log(this->name, GF_LOG_ERROR, + "failed to " + "set read-%db+, with: %" PRId64, + (1 << i), count); goto out; + } } - - snprintf (key, sizeof (key), "%d-total-read", interval); - ret = dict_set_uint64 (dict, key, GF_ATOMIC_GET (stats->data_read)); - if (ret) { - gf_log (this->name, GF_LOG_ERROR, "failed to set total " - "read(%d) - %"GF_PRI_ATOMIC, interval, - GF_ATOMIC_GET (stats->data_read)); + } + + for (i = 0; i < IOS_BLOCK_COUNT_SIZE; i++) { + count = GF_ATOMIC_GET(stats->block_count_write[i]); + if (count) { + snprintf(key, sizeof(key), "%d-write-%d", interval, (1 << i)); + ret = dict_set_uint64(dict, key, count); + if (ret) { + gf_log(this->name, GF_LOG_ERROR, + "failed to " + "set write-%db+, with: %" PRId64, + (1 << i), count); goto out; + } } - - snprintf (key, sizeof (key), "%d-total-write", interval); - ret = dict_set_uint64 (dict, key, GF_ATOMIC_GET (stats->data_written)); + } + + for (i = 0; i < GF_FOP_MAXVALUE; i++) { + fop_hits = GF_ATOMIC_GET(stats->fop_hits[i]); + if (fop_hits == 0) + continue; + snprintf(key, sizeof(key), "%d-%d-hits", interval, i); + ret = dict_set_uint64(dict, key, fop_hits); if (ret) { - gf_log (this->name, GF_LOG_ERROR, "failed to set total " - "write(%d) - %"GF_PRI_ATOMIC, interval, - GF_ATOMIC_GET (stats->data_written)); - goto out; - } - for (i = 0; i < 32; i++) { - count = GF_ATOMIC_GET (stats->block_count_read[i]); - if (count) { - snprintf (key, sizeof (key), "%d-read-%d", interval, - (1 << i)); - ret = dict_set_uint64 (dict, key, count); - if (ret) { - gf_log (this->name, GF_LOG_ERROR, "failed to " - "set read-%db+, with: %"PRId64, - (1<<i), count); - goto out; - } - } + gf_log(this->name, GF_LOG_ERROR, + "failed to set " + "%s-fop-hits: %" GF_PRI_ATOMIC, + gf_fop_list[i], fop_hits); + goto out; } - for (i = 0; i < IOS_BLOCK_COUNT_SIZE; i++) { - count = GF_ATOMIC_GET (stats->block_count_write[i]); - if (count) { - snprintf (key, sizeof (key), "%d-write-%d", interval, - (1<<i)); - ret = dict_set_uint64 (dict, key, count); - if (ret) { - gf_log (this->name, GF_LOG_ERROR, "failed to " - "set write-%db+, with: %"PRId64, - (1<<i), count); - goto out; - } - } + if (stats->latency[i].avg == 0) + continue; + snprintf(key, sizeof(key), "%d-%d-avglatency", interval, i); + ret = dict_set_double(dict, key, stats->latency[i].avg); + if (ret) { + gf_log(this->name, GF_LOG_ERROR, + "failed to set %s " + "avglatency(%d) with %f", + gf_fop_list[i], interval, stats->latency[i].avg); + goto out; } - - for (i = 0; i < GF_FOP_MAXVALUE; i++) { - fop_hits = GF_ATOMIC_GET (stats->fop_hits[i]); - if (fop_hits == 0) - continue; - snprintf (key, sizeof (key), "%d-%d-hits", interval, i); - ret = dict_set_uint64 (dict, key, fop_hits); - if (ret) { - gf_log (this->name, GF_LOG_ERROR, "failed to set " - "%s-fop-hits: %"GF_PRI_ATOMIC, gf_fop_list[i], - fop_hits); - goto out; - } - - if (stats->latency[i].avg == 0) - continue; - snprintf (key, sizeof (key), "%d-%d-avglatency", interval, i); - ret = dict_set_double (dict, key, stats->latency[i].avg); - if (ret) { - gf_log (this->name, GF_LOG_ERROR, "failed to set %s " - "avglatency(%d) with %f", gf_fop_list[i], - interval, stats->latency[i].avg); - goto out; - } - snprintf (key, sizeof (key), "%d-%d-minlatency", interval, i); - ret = dict_set_double (dict, key, stats->latency[i].min); - if (ret) { - gf_log (this->name, GF_LOG_ERROR, "failed to set %s " - "minlatency(%d) with %f", gf_fop_list[i], - interval, stats->latency[i].min); - goto out; - } - snprintf (key, sizeof (key), "%d-%d-maxlatency", interval, i); - ret = dict_set_double (dict, key, stats->latency[i].max); - if (ret) { - gf_log (this->name, GF_LOG_ERROR, "failed to set %s " - "maxlatency(%d) with %f", gf_fop_list[i], - interval, stats->latency[i].max); - goto out; - } + snprintf(key, sizeof(key), "%d-%d-minlatency", interval, i); + ret = dict_set_double(dict, key, stats->latency[i].min); + if (ret) { + gf_log(this->name, GF_LOG_ERROR, + "failed to set %s " + "minlatency(%d) with %f", + gf_fop_list[i], interval, stats->latency[i].min); + goto out; } - for (i = 0; i < GF_UPCALL_FLAGS_MAXVALUE; i++) { - fop_hits = GF_ATOMIC_GET (stats->upcall_hits[i]); - if (fop_hits == 0) - continue; - snprintf (key, sizeof (key), "%d-%d-upcall-hits", interval, i); - ret = dict_set_uint64 (dict, key, fop_hits); - if (ret) { - gf_log (this->name, GF_LOG_ERROR, "failed to " - "set %s-upcall-hits: %"PRIu64, - gf_upcall_list[i], fop_hits); - goto out; - } + snprintf(key, sizeof(key), "%d-%d-maxlatency", interval, i); + ret = dict_set_double(dict, key, stats->latency[i].max); + if (ret) { + gf_log(this->name, GF_LOG_ERROR, + "failed to set %s " + "maxlatency(%d) with %f", + gf_fop_list[i], interval, stats->latency[i].max); + goto out; } + } + for (i = 0; i < GF_UPCALL_FLAGS_MAXVALUE; i++) { + fop_hits = GF_ATOMIC_GET(stats->upcall_hits[i]); + if (fop_hits == 0) + continue; + snprintf(key, sizeof(key), "%d-%d-upcall-hits", interval, i); + ret = dict_set_uint64(dict, key, fop_hits); + if (ret) { + gf_log(this->name, GF_LOG_ERROR, + "failed to " + "set %s-upcall-hits: %" PRIu64, + gf_upcall_list[i], fop_hits); + goto out; + } + } out: - gf_log (this->name, GF_LOG_DEBUG, "returning %d", ret); - return ret; + gf_log(this->name, GF_LOG_DEBUG, "returning %d", ret); + return ret; } int -io_stats_dump_global (xlator_t *this, struct ios_global_stats *stats, - struct timeval *now, int interval, - struct ios_dump_args *args) +io_stats_dump_global(xlator_t *this, struct ios_global_stats *stats, + struct timeval *now, int interval, + struct ios_dump_args *args) { - int ret = -1; + int ret = -1; - GF_ASSERT (args); - GF_ASSERT (now); - GF_ASSERT (stats); - GF_ASSERT (this); + GF_ASSERT(args); + GF_ASSERT(now); + GF_ASSERT(stats); + GF_ASSERT(this); - - - switch (args->type) { + switch (args->type) { case IOS_DUMP_TYPE_JSON_FILE: - ret = io_stats_dump_global_to_json_logfp ( - this, stats, now, interval, args->u.logfp); - break; + ret = io_stats_dump_global_to_json_logfp(this, stats, now, interval, + args->u.logfp); + break; case IOS_DUMP_TYPE_FILE: - ret = io_stats_dump_global_to_logfp (this, stats, now, - interval, args->u.logfp); - break; + ret = io_stats_dump_global_to_logfp(this, stats, now, interval, + args->u.logfp); + break; case IOS_DUMP_TYPE_DICT: - ret = io_stats_dump_global_to_dict (this, stats, now, - interval, args->u.dict); - break; + ret = io_stats_dump_global_to_dict(this, stats, now, interval, + args->u.dict); + break; default: - GF_ASSERT (0); - ret = -1; - break; - } - return ret; + GF_ASSERT(0); + ret = -1; + break; + } + return ret; } int -ios_dump_args_init (struct ios_dump_args *args, ios_dump_type_t type, - void *output) +ios_dump_args_init(struct ios_dump_args *args, ios_dump_type_t type, + void *output) { - int ret = 0; + int ret = 0; - GF_ASSERT (args); - GF_ASSERT (type > IOS_DUMP_TYPE_NONE && type < IOS_DUMP_TYPE_MAX); - GF_ASSERT (output); + GF_ASSERT(args); + GF_ASSERT(type > IOS_DUMP_TYPE_NONE && type < IOS_DUMP_TYPE_MAX); + GF_ASSERT(output); - args->type = type; - switch (args->type) { + args->type = type; + switch (args->type) { case IOS_DUMP_TYPE_JSON_FILE: case IOS_DUMP_TYPE_FILE: - args->u.logfp = output; - break; + args->u.logfp = output; + break; case IOS_DUMP_TYPE_DICT: - args->u.dict = output; - break; + args->u.dict = output; + break; default: - GF_ASSERT (0); - ret = -1; - } + GF_ASSERT(0); + ret = -1; + } - return ret; + return ret; } static void -ios_global_stats_clear (struct ios_global_stats *stats, struct timeval *now) +ios_global_stats_clear(struct ios_global_stats *stats, struct timeval *now) { - GF_ASSERT (stats); - GF_ASSERT (now); + GF_ASSERT(stats); + GF_ASSERT(now); - memset (stats, 0, sizeof (*stats)); - stats->started_at = *now; + memset(stats, 0, sizeof(*stats)); + stats->started_at = *now; } int -io_stats_dump (xlator_t *this, struct ios_dump_args *args, - gf1_cli_info_op op, gf_boolean_t is_peek) +io_stats_dump(xlator_t *this, struct ios_dump_args *args, gf1_cli_info_op op, + gf_boolean_t is_peek) { - struct ios_conf *conf = NULL; - struct ios_global_stats cumulative = { }; - struct ios_global_stats incremental = { }; - int increment = 0; - struct timeval now; + struct ios_conf *conf = NULL; + struct ios_global_stats cumulative = {}; + struct ios_global_stats incremental = {}; + int increment = 0; + struct timeval now; - GF_ASSERT (this); - GF_ASSERT (args); - GF_ASSERT (args->type > IOS_DUMP_TYPE_NONE); - GF_ASSERT (args->type < IOS_DUMP_TYPE_MAX); + GF_ASSERT(this); + GF_ASSERT(args); + GF_ASSERT(args->type > IOS_DUMP_TYPE_NONE); + GF_ASSERT(args->type < IOS_DUMP_TYPE_MAX); - conf = this->private; + conf = this->private; - gettimeofday (&now, NULL); - LOCK (&conf->lock); - { - if (op == GF_CLI_INFO_ALL || - op == GF_CLI_INFO_CUMULATIVE) - cumulative = conf->cumulative; + gettimeofday(&now, NULL); + LOCK(&conf->lock); + { + if (op == GF_CLI_INFO_ALL || op == GF_CLI_INFO_CUMULATIVE) + cumulative = conf->cumulative; - if (op == GF_CLI_INFO_ALL || - op == GF_CLI_INFO_INCREMENTAL) { - incremental = conf->incremental; - increment = conf->increment; + if (op == GF_CLI_INFO_ALL || op == GF_CLI_INFO_INCREMENTAL) { + incremental = conf->incremental; + increment = conf->increment; - if (!is_peek) { - increment = conf->increment++; + if (!is_peek) { + increment = conf->increment++; - ios_global_stats_clear (&conf->incremental, - &now); - } - } + ios_global_stats_clear(&conf->incremental, &now); + } } - UNLOCK (&conf->lock); + } + UNLOCK(&conf->lock); - if (op == GF_CLI_INFO_ALL || - op == GF_CLI_INFO_CUMULATIVE) - io_stats_dump_global (this, &cumulative, &now, -1, args); + if (op == GF_CLI_INFO_ALL || op == GF_CLI_INFO_CUMULATIVE) + io_stats_dump_global(this, &cumulative, &now, -1, args); - if (op == GF_CLI_INFO_ALL || - op == GF_CLI_INFO_INCREMENTAL) - io_stats_dump_global (this, &incremental, &now, increment, args); + if (op == GF_CLI_INFO_ALL || op == GF_CLI_INFO_INCREMENTAL) + io_stats_dump_global(this, &incremental, &now, increment, args); - return 0; + return 0; } - int -io_stats_dump_fd (xlator_t *this, struct ios_fd *iosfd) +io_stats_dump_fd(xlator_t *this, struct ios_fd *iosfd) { - struct ios_conf *conf = NULL; - struct timeval now; - uint64_t sec = 0; - uint64_t usec = 0; - int i = 0; - uint64_t data_read = 0; - uint64_t data_written = 0; - uint64_t block_count_read = 0; - uint64_t block_count_write = 0; + struct ios_conf *conf = NULL; + struct timeval now; + uint64_t sec = 0; + uint64_t usec = 0; + int i = 0; + uint64_t data_read = 0; + uint64_t data_written = 0; + uint64_t block_count_read = 0; + uint64_t block_count_write = 0; - conf = this->private; + conf = this->private; - if (!conf->dump_fd_stats) - return 0; + if (!conf->dump_fd_stats) + return 0; - if (!iosfd) - return 0; + if (!iosfd) + return 0; - gettimeofday (&now, NULL); + gettimeofday(&now, NULL); - if (iosfd->opened_at.tv_usec > now.tv_usec) { - now.tv_usec += 1000000; - now.tv_usec--; - } + if (iosfd->opened_at.tv_usec > now.tv_usec) { + now.tv_usec += 1000000; + now.tv_usec--; + } - sec = now.tv_sec - iosfd->opened_at.tv_sec; - usec = now.tv_usec - iosfd->opened_at.tv_usec; - - gf_log (this->name, GF_LOG_INFO, - "--- fd stats ---"); - - if (iosfd->filename) - gf_log (this->name, GF_LOG_INFO, - " Filename : %s", - iosfd->filename); - - if (sec) - gf_log (this->name, GF_LOG_INFO, - " Lifetime : %"PRId64"secs, %"PRId64"usecs", - sec, usec); - - data_read = GF_ATOMIC_GET (iosfd->data_read); - if (data_read) - gf_log (this->name, GF_LOG_INFO, - " BytesRead : %"PRId64" bytes", data_read); - - data_written = GF_ATOMIC_GET (iosfd->data_written); - if (data_written) - gf_log (this->name, GF_LOG_INFO, - " BytesWritten : %"PRId64" bytes", - data_written); - - for (i = 0; i < 32; i++) { - block_count_read = GF_ATOMIC_GET (iosfd->block_count_read[i]); - if (block_count_read) - gf_log (this->name, GF_LOG_INFO, " Read %06db+ :" - "%"PRId64, (1 << i), block_count_read); - } - for (i = 0; i < IOS_BLOCK_COUNT_SIZE; i++) { - block_count_write = GF_ATOMIC_GET (iosfd->block_count_write[i]); - if (block_count_write) - gf_log (this->name, GF_LOG_INFO, - "Write %06db+ : %"PRId64, - (1 << i), block_count_write); - } - return 0; -} + sec = now.tv_sec - iosfd->opened_at.tv_sec; + usec = now.tv_usec - iosfd->opened_at.tv_usec; -void collect_ios_latency_sample (struct ios_conf *conf, - glusterfs_fop_t fop_type, double elapsed, - call_frame_t *frame) -{ - ios_sample_buf_t *ios_sample_buf = NULL; - ios_sample_t *ios_sample = NULL; - struct timespec *timestamp = NULL; - call_stack_t *root = NULL; + gf_log(this->name, GF_LOG_INFO, "--- fd stats ---"); + if (iosfd->filename) + gf_log(this->name, GF_LOG_INFO, " Filename : %s", iosfd->filename); - ios_sample_buf = conf->ios_sample_buf; - LOCK (&conf->ios_sampling_lock); - if (conf->ios_sample_interval == 0 || - ios_sample_buf->observed % conf->ios_sample_interval != 0) - goto out; + if (sec) + gf_log(this->name, GF_LOG_INFO, + " Lifetime : %" PRId64 "secs, %" PRId64 "usecs", sec, usec); - timestamp = &frame->begin; - root = frame->root; - - ios_sample = &(ios_sample_buf->ios_samples[ios_sample_buf->pos]); - ios_sample->elapsed = elapsed; - ios_sample->fop_type = fop_type; - ios_sample->uid = root->uid; - ios_sample->gid = root->gid; - (ios_sample->timestamp).tv_sec = timestamp->tv_sec; - (ios_sample->timestamp).tv_usec = timestamp->tv_nsec / 1000; - memcpy (&ios_sample->identifier, &root->identifier, - sizeof (root->identifier)); - - /* We've reached the end of the circular buffer, start from the - * beginning. */ - if (ios_sample_buf->pos == (ios_sample_buf->size - 1)) - ios_sample_buf->pos = 0; - else - ios_sample_buf->pos++; - ios_sample_buf->collected++; + data_read = GF_ATOMIC_GET(iosfd->data_read); + if (data_read) + gf_log(this->name, GF_LOG_INFO, " BytesRead : %" PRId64 " bytes", + data_read); + + data_written = GF_ATOMIC_GET(iosfd->data_written); + if (data_written) + gf_log(this->name, GF_LOG_INFO, " BytesWritten : %" PRId64 " bytes", + data_written); + + for (i = 0; i < 32; i++) { + block_count_read = GF_ATOMIC_GET(iosfd->block_count_read[i]); + if (block_count_read) + gf_log(this->name, GF_LOG_INFO, + " Read %06db+ :" + "%" PRId64, + (1 << i), block_count_read); + } + for (i = 0; i < IOS_BLOCK_COUNT_SIZE; i++) { + block_count_write = GF_ATOMIC_GET(iosfd->block_count_write[i]); + if (block_count_write) + gf_log(this->name, GF_LOG_INFO, "Write %06db+ : %" PRId64, (1 << i), + block_count_write); + } + return 0; +} + +void +collect_ios_latency_sample(struct ios_conf *conf, glusterfs_fop_t fop_type, + double elapsed, call_frame_t *frame) +{ + ios_sample_buf_t *ios_sample_buf = NULL; + ios_sample_t *ios_sample = NULL; + struct timespec *timestamp = NULL; + call_stack_t *root = NULL; + + ios_sample_buf = conf->ios_sample_buf; + LOCK(&conf->ios_sampling_lock); + if (conf->ios_sample_interval == 0 || + ios_sample_buf->observed % conf->ios_sample_interval != 0) + goto out; + + timestamp = &frame->begin; + root = frame->root; + + ios_sample = &(ios_sample_buf->ios_samples[ios_sample_buf->pos]); + ios_sample->elapsed = elapsed; + ios_sample->fop_type = fop_type; + ios_sample->uid = root->uid; + ios_sample->gid = root->gid; + (ios_sample->timestamp).tv_sec = timestamp->tv_sec; + (ios_sample->timestamp).tv_usec = timestamp->tv_nsec / 1000; + memcpy(&ios_sample->identifier, &root->identifier, + sizeof(root->identifier)); + + /* We've reached the end of the circular buffer, start from the + * beginning. */ + if (ios_sample_buf->pos == (ios_sample_buf->size - 1)) + ios_sample_buf->pos = 0; + else + ios_sample_buf->pos++; + ios_sample_buf->collected++; out: - ios_sample_buf->observed++; - UNLOCK (&conf->ios_sampling_lock); - return; + ios_sample_buf->observed++; + UNLOCK(&conf->ios_sampling_lock); + return; } static void -update_ios_latency_stats (struct ios_global_stats *stats, double elapsed, - glusterfs_fop_t op) +update_ios_latency_stats(struct ios_global_stats *stats, double elapsed, + glusterfs_fop_t op) { - double avg; + double avg; - GF_ASSERT (stats); + GF_ASSERT(stats); - stats->latency[op].total += elapsed; + stats->latency[op].total += elapsed; - if (!stats->latency[op].min) - stats->latency[op].min = elapsed; - if (stats->latency[op].min > elapsed) - stats->latency[op].min = elapsed; - if (stats->latency[op].max < elapsed) - stats->latency[op].max = elapsed; + if (!stats->latency[op].min) + stats->latency[op].min = elapsed; + if (stats->latency[op].min > elapsed) + stats->latency[op].min = elapsed; + if (stats->latency[op].max < elapsed) + stats->latency[op].max = elapsed; - avg = stats->latency[op].avg; + avg = stats->latency[op].avg; - stats->latency[op].avg = avg + (elapsed - avg) / - GF_ATOMIC_GET (stats->fop_hits[op]); + stats->latency[op].avg = avg + (elapsed - avg) / + GF_ATOMIC_GET(stats->fop_hits[op]); } int -update_ios_latency (struct ios_conf *conf, call_frame_t *frame, - glusterfs_fop_t op) +update_ios_latency(struct ios_conf *conf, call_frame_t *frame, + glusterfs_fop_t op) { - double elapsed; - struct timespec *begin, *end; + double elapsed; + struct timespec *begin, *end; - begin = &frame->begin; - end = &frame->end; + begin = &frame->begin; + end = &frame->end; - elapsed = ((end->tv_sec - begin->tv_sec) * 1e9 - + (end->tv_nsec - begin->tv_nsec)) / 1000; + elapsed = ((end->tv_sec - begin->tv_sec) * 1e9 + + (end->tv_nsec - begin->tv_nsec)) / + 1000; - update_ios_latency_stats (&conf->cumulative, elapsed, op); - update_ios_latency_stats (&conf->incremental, elapsed, op); - collect_ios_latency_sample (conf, op, elapsed, frame); + update_ios_latency_stats(&conf->cumulative, elapsed, op); + update_ios_latency_stats(&conf->incremental, elapsed, op); + collect_ios_latency_sample(conf, op, elapsed, frame); - return 0; + return 0; } int32_t -io_stats_dump_stats_to_dict (xlator_t *this, dict_t *resp, - ios_stats_type_t flags, int32_t list_cnt) -{ - struct ios_conf *conf = NULL; - int cnt = 0; - char key[256]; - struct ios_stat_head *list_head = NULL; - struct ios_stat_list *entry = NULL; - int ret = -1; - ios_stats_thru_t index = IOS_STATS_THRU_MAX; - char timestr[256] = {0, }; - char *dict_timestr = NULL; - - conf = this->private; - - switch (flags) { - case IOS_STATS_TYPE_OPEN: - list_head = &conf->list[IOS_STATS_TYPE_OPEN]; - LOCK (&conf->lock); - { - ret = dict_set_uint64 (resp, "current-open", - conf->cumulative.nr_opens); - if (ret) - goto unlock; - ret = dict_set_uint64 (resp, "max-open", - conf->cumulative.max_nr_opens); - - gf_time_fmt (timestr, sizeof timestr, - conf->cumulative.max_openfd_time.tv_sec, - gf_timefmt_FT); - if (conf->cumulative.max_openfd_time.tv_sec) - snprintf (timestr + strlen (timestr), sizeof timestr - strlen (timestr), - ".%"GF_PRI_SUSECONDS, - conf->cumulative.max_openfd_time.tv_usec); - - dict_timestr = gf_strdup (timestr); - if (!dict_timestr) - goto unlock; - ret = dict_set_dynstr (resp, "max-openfd-time", - dict_timestr); - if (ret) - goto unlock; - } +io_stats_dump_stats_to_dict(xlator_t *this, dict_t *resp, + ios_stats_type_t flags, int32_t list_cnt) +{ + struct ios_conf *conf = NULL; + int cnt = 0; + char key[256]; + struct ios_stat_head *list_head = NULL; + struct ios_stat_list *entry = NULL; + int ret = -1; + ios_stats_thru_t index = IOS_STATS_THRU_MAX; + char timestr[256] = { + 0, + }; + char *dict_timestr = NULL; + + conf = this->private; + + switch (flags) { + case IOS_STATS_TYPE_OPEN: + list_head = &conf->list[IOS_STATS_TYPE_OPEN]; + LOCK(&conf->lock); + { + ret = dict_set_uint64(resp, "current-open", + conf->cumulative.nr_opens); + if (ret) + goto unlock; + ret = dict_set_uint64(resp, "max-open", + conf->cumulative.max_nr_opens); + + gf_time_fmt(timestr, sizeof timestr, + conf->cumulative.max_openfd_time.tv_sec, + gf_timefmt_FT); + if (conf->cumulative.max_openfd_time.tv_sec) + snprintf(timestr + strlen(timestr), + sizeof timestr - strlen(timestr), + ".%" GF_PRI_SUSECONDS, + conf->cumulative.max_openfd_time.tv_usec); + + dict_timestr = gf_strdup(timestr); + if (!dict_timestr) + goto unlock; + ret = dict_set_dynstr(resp, "max-openfd-time", dict_timestr); + if (ret) + goto unlock; + } unlock: - UNLOCK (&conf->lock); - /* Do not proceed if we came here because of some error - * during the dict operation */ - if (ret) - goto out; - break; - case IOS_STATS_TYPE_READ: - list_head = &conf->list[IOS_STATS_TYPE_READ]; - break; - case IOS_STATS_TYPE_WRITE: - list_head = &conf->list[IOS_STATS_TYPE_WRITE]; - break; - case IOS_STATS_TYPE_OPENDIR: - list_head = &conf->list[IOS_STATS_TYPE_OPENDIR]; - break; - case IOS_STATS_TYPE_READDIRP: - list_head = &conf->list[IOS_STATS_TYPE_READDIRP]; - break; - case IOS_STATS_TYPE_READ_THROUGHPUT: - list_head = &conf->thru_list[IOS_STATS_THRU_READ]; - index = IOS_STATS_THRU_READ; - break; - case IOS_STATS_TYPE_WRITE_THROUGHPUT: - list_head = &conf->thru_list[IOS_STATS_THRU_WRITE]; - index = IOS_STATS_THRU_WRITE; - break; - - default: - goto out; - } - ret = dict_set_int32 (resp, "top-op", flags); - if (!list_cnt) + UNLOCK(&conf->lock); + /* Do not proceed if we came here because of some error + * during the dict operation */ + if (ret) goto out; - LOCK (&list_head->lock); - { - list_for_each_entry (entry, &list_head->iosstats->list, list) { - - cnt++; - snprintf (key, 256, "%s-%d", "filename", cnt); - ret = dict_set_str (resp, key, entry->iosstat->filename); - if (ret) - goto unlock_list_head; - snprintf (key, 256, "%s-%d", "value",cnt); - ret = dict_set_uint64 (resp, key, entry->value); - if (ret) - goto unlock_list_head; - if (index != IOS_STATS_THRU_MAX) { - snprintf (key, 256, "%s-%d", "time-sec", cnt); - ret = dict_set_int32 (resp, key, - entry->iosstat->thru_counters[index].time.tv_sec); - if (ret) - goto unlock_list_head; - snprintf (key, 256, "%s-%d", "time-usec", cnt); - ret = dict_set_int32 (resp, key, - entry->iosstat->thru_counters[index].time.tv_usec); - if (ret) - goto unlock_list_head; - } - if (cnt == list_cnt) - break; + break; + case IOS_STATS_TYPE_READ: + list_head = &conf->list[IOS_STATS_TYPE_READ]; + break; + case IOS_STATS_TYPE_WRITE: + list_head = &conf->list[IOS_STATS_TYPE_WRITE]; + break; + case IOS_STATS_TYPE_OPENDIR: + list_head = &conf->list[IOS_STATS_TYPE_OPENDIR]; + break; + case IOS_STATS_TYPE_READDIRP: + list_head = &conf->list[IOS_STATS_TYPE_READDIRP]; + break; + case IOS_STATS_TYPE_READ_THROUGHPUT: + list_head = &conf->thru_list[IOS_STATS_THRU_READ]; + index = IOS_STATS_THRU_READ; + break; + case IOS_STATS_TYPE_WRITE_THROUGHPUT: + list_head = &conf->thru_list[IOS_STATS_THRU_WRITE]; + index = IOS_STATS_THRU_WRITE; + break; - } + default: + goto out; + } + ret = dict_set_int32(resp, "top-op", flags); + if (!list_cnt) + goto out; + LOCK(&list_head->lock); + { + list_for_each_entry(entry, &list_head->iosstats->list, list) + { + cnt++; + snprintf(key, 256, "%s-%d", "filename", cnt); + ret = dict_set_str(resp, key, entry->iosstat->filename); + if (ret) + goto unlock_list_head; + snprintf(key, 256, "%s-%d", "value", cnt); + ret = dict_set_uint64(resp, key, entry->value); + if (ret) + goto unlock_list_head; + if (index != IOS_STATS_THRU_MAX) { + snprintf(key, 256, "%s-%d", "time-sec", cnt); + ret = dict_set_int32( + resp, key, + entry->iosstat->thru_counters[index].time.tv_sec); + if (ret) + goto unlock_list_head; + snprintf(key, 256, "%s-%d", "time-usec", cnt); + ret = dict_set_int32( + resp, key, + entry->iosstat->thru_counters[index].time.tv_usec); + if (ret) + goto unlock_list_head; + } + if (cnt == list_cnt) + break; } + } unlock_list_head: - UNLOCK (&list_head->lock); - /* ret is !=0 if some dict operation in the above critical region - * failed. */ - if (ret) - goto out; - ret = dict_set_int32 (resp, "members", cnt); - out: - return ret; + UNLOCK(&list_head->lock); + /* ret is !=0 if some dict operation in the above critical region + * failed. */ + if (ret) + goto out; + ret = dict_set_int32(resp, "members", cnt); +out: + return ret; } -static struct ios_stat* -ios_init_iosstat (xlator_t *this, char *path, uuid_t gfid, inode_t *inode) +static struct ios_stat * +ios_init_iosstat(xlator_t *this, char *path, uuid_t gfid, inode_t *inode) { - struct ios_stat *iosstat = NULL; - int i = 0; + struct ios_stat *iosstat = NULL; + int i = 0; - iosstat = GF_CALLOC (1, sizeof (*iosstat), gf_io_stats_mt_ios_stat); - if (!iosstat) - goto out; + iosstat = GF_CALLOC(1, sizeof(*iosstat), gf_io_stats_mt_ios_stat); + if (!iosstat) + goto out; - iosstat->filename = gf_strdup (path); - gf_uuid_copy (iosstat->gfid, gfid); - LOCK_INIT (&iosstat->lock); + iosstat->filename = gf_strdup(path); + gf_uuid_copy(iosstat->gfid, gfid); + LOCK_INIT(&iosstat->lock); - for (i = 0; i < IOS_STATS_TYPE_MAX; i++) - GF_ATOMIC_INIT (iosstat->counters[i], 0); + for (i = 0; i < IOS_STATS_TYPE_MAX; i++) + GF_ATOMIC_INIT(iosstat->counters[i], 0); - ios_inode_ctx_set (inode, this, iosstat); + ios_inode_ctx_set(inode, this, iosstat); out: - return iosstat; + return iosstat; } int -io_stats_create_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, fd_t *fd, - inode_t *inode, struct iatt *buf, - struct iatt *preparent, struct iatt *postparent, dict_t *xdata) -{ - struct ios_fd *iosfd = NULL; - char *path = NULL; - struct ios_stat *iosstat = NULL; - struct ios_conf *conf = NULL; - - conf = this->private; - - path = frame->local; - frame->local = NULL; - - if (!path) - goto unwind; - - if (op_ret < 0) { - GF_FREE (path); - goto unwind; +io_stats_create_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, fd_t *fd, inode_t *inode, + struct iatt *buf, struct iatt *preparent, + struct iatt *postparent, dict_t *xdata) +{ + struct ios_fd *iosfd = NULL; + char *path = NULL; + struct ios_stat *iosstat = NULL; + struct ios_conf *conf = NULL; + + conf = this->private; + + path = frame->local; + frame->local = NULL; + + if (!path) + goto unwind; + + if (op_ret < 0) { + GF_FREE(path); + goto unwind; + } + + iosfd = GF_CALLOC(1, sizeof(*iosfd), gf_io_stats_mt_ios_fd); + if (!iosfd) { + GF_FREE(path); + goto unwind; + } + + iosfd->filename = path; + gettimeofday(&iosfd->opened_at, NULL); + + ios_fd_ctx_set(fd, this, iosfd); + LOCK(&conf->lock); + { + conf->cumulative.nr_opens++; + if (conf->cumulative.nr_opens > conf->cumulative.max_nr_opens) { + conf->cumulative.max_nr_opens = conf->cumulative.nr_opens; + conf->cumulative.max_openfd_time = iosfd->opened_at; } + } + UNLOCK(&conf->lock); - iosfd = GF_CALLOC (1, sizeof (*iosfd), gf_io_stats_mt_ios_fd); - if (!iosfd) { - GF_FREE (path); - goto unwind; - } - - iosfd->filename = path; - gettimeofday (&iosfd->opened_at, NULL); - - ios_fd_ctx_set (fd, this, iosfd); - LOCK (&conf->lock); - { - conf->cumulative.nr_opens++; - if (conf->cumulative.nr_opens > conf->cumulative.max_nr_opens) { - conf->cumulative.max_nr_opens = conf->cumulative.nr_opens; - conf->cumulative.max_openfd_time = iosfd->opened_at; - } - } - UNLOCK (&conf->lock); - - iosstat = ios_init_iosstat (this, path, buf->ia_gfid, inode); - if (!iosstat) - GF_FREE (path); + iosstat = ios_init_iosstat(this, path, buf->ia_gfid, inode); + if (!iosstat) + GF_FREE(path); unwind: - UPDATE_PROFILE_STATS (frame, CREATE); - STACK_UNWIND_STRICT (create, frame, op_ret, op_errno, fd, inode, buf, - preparent, postparent, xdata); - return 0; + UPDATE_PROFILE_STATS(frame, CREATE); + STACK_UNWIND_STRICT(create, frame, op_ret, op_errno, fd, inode, buf, + preparent, postparent, xdata); + return 0; } - int -io_stats_open_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, fd_t *fd, dict_t *xdata) -{ - struct ios_fd *iosfd = NULL; - char *path = NULL; - struct ios_stat *iosstat = NULL; - struct ios_conf *conf = NULL; - int i = 0; - - conf = this->private; - path = frame->local; - frame->local = NULL; - - if (!path) - goto unwind; - - if (op_ret < 0) { - GF_FREE (path); - goto unwind; - } - - iosfd = GF_CALLOC (1, sizeof (*iosfd), gf_io_stats_mt_ios_fd); - if (!iosfd) { - GF_FREE (path); - goto unwind; - } - - iosfd->filename = path; - GF_ATOMIC_INIT (iosfd->data_read, 0); - GF_ATOMIC_INIT (iosfd->data_written, 0); - for (i = 0; i < IOS_BLOCK_COUNT_SIZE; i++) { - GF_ATOMIC_INIT (iosfd->block_count_write[i], 0); - GF_ATOMIC_INIT (iosfd->block_count_read[i], 0); - } - gettimeofday (&iosfd->opened_at, NULL); - - ios_fd_ctx_set (fd, this, iosfd); - - ios_inode_ctx_get (fd->inode, this, &iosstat); - if (!iosstat) { - iosstat = ios_init_iosstat (this, path, fd->inode->gfid, - fd->inode); - } - - LOCK (&conf->lock); - { - conf->cumulative.nr_opens++; - if (conf->cumulative.nr_opens > conf->cumulative.max_nr_opens) { - conf->cumulative.max_nr_opens = conf->cumulative.nr_opens; - conf->cumulative.max_openfd_time = iosfd->opened_at; - } - } - UNLOCK (&conf->lock); - if (iosstat) { - ios_bump_stats (this, iosstat, IOS_STATS_TYPE_OPEN); - iosstat = NULL; +io_stats_open_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, fd_t *fd, dict_t *xdata) +{ + struct ios_fd *iosfd = NULL; + char *path = NULL; + struct ios_stat *iosstat = NULL; + struct ios_conf *conf = NULL; + int i = 0; + + conf = this->private; + path = frame->local; + frame->local = NULL; + + if (!path) + goto unwind; + + if (op_ret < 0) { + GF_FREE(path); + goto unwind; + } + + iosfd = GF_CALLOC(1, sizeof(*iosfd), gf_io_stats_mt_ios_fd); + if (!iosfd) { + GF_FREE(path); + goto unwind; + } + + iosfd->filename = path; + GF_ATOMIC_INIT(iosfd->data_read, 0); + GF_ATOMIC_INIT(iosfd->data_written, 0); + for (i = 0; i < IOS_BLOCK_COUNT_SIZE; i++) { + GF_ATOMIC_INIT(iosfd->block_count_write[i], 0); + GF_ATOMIC_INIT(iosfd->block_count_read[i], 0); + } + gettimeofday(&iosfd->opened_at, NULL); + + ios_fd_ctx_set(fd, this, iosfd); + + ios_inode_ctx_get(fd->inode, this, &iosstat); + if (!iosstat) { + iosstat = ios_init_iosstat(this, path, fd->inode->gfid, fd->inode); + } + + LOCK(&conf->lock); + { + conf->cumulative.nr_opens++; + if (conf->cumulative.nr_opens > conf->cumulative.max_nr_opens) { + conf->cumulative.max_nr_opens = conf->cumulative.nr_opens; + conf->cumulative.max_openfd_time = iosfd->opened_at; } + } + UNLOCK(&conf->lock); + if (iosstat) { + ios_bump_stats(this, iosstat, IOS_STATS_TYPE_OPEN); + iosstat = NULL; + } unwind: - UPDATE_PROFILE_STATS (frame, OPEN); - - STACK_UNWIND_STRICT (open, frame, op_ret, op_errno, fd, xdata); - return 0; + UPDATE_PROFILE_STATS(frame, OPEN); + STACK_UNWIND_STRICT(open, frame, op_ret, op_errno, fd, xdata); + return 0; } - int -io_stats_stat_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, struct iatt *buf, dict_t *xdata) +io_stats_stat_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, struct iatt *buf, + dict_t *xdata) { - UPDATE_PROFILE_STATS (frame, STAT); - STACK_UNWIND_STRICT (stat, frame, op_ret, op_errno, buf, xdata); - return 0; + UPDATE_PROFILE_STATS(frame, STAT); + STACK_UNWIND_STRICT(stat, frame, op_ret, op_errno, buf, xdata); + return 0; } - int -io_stats_readv_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, - struct iovec *vector, int32_t count, - struct iatt *buf, struct iobref *iobref, dict_t *xdata) +io_stats_readv_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, struct iovec *vector, + int32_t count, struct iatt *buf, struct iobref *iobref, + dict_t *xdata) { - int len = 0; - fd_t *fd = NULL; - struct ios_stat *iosstat = NULL; - - fd = frame->local; - frame->local = NULL; + int len = 0; + fd_t *fd = NULL; + struct ios_stat *iosstat = NULL; - if (op_ret > 0) { - len = iov_length (vector, count); - ios_bump_read (this, fd, len); - } + fd = frame->local; + frame->local = NULL; - UPDATE_PROFILE_STATS (frame, READ); - ios_inode_ctx_get (fd->inode, this, &iosstat); + if (op_ret > 0) { + len = iov_length(vector, count); + ios_bump_read(this, fd, len); + } - if (iosstat) { - ios_bump_stats (this, iosstat, IOS_STATS_TYPE_READ); - BUMP_THROUGHPUT (iosstat, IOS_STATS_THRU_READ); - iosstat = NULL; - } + UPDATE_PROFILE_STATS(frame, READ); + ios_inode_ctx_get(fd->inode, this, &iosstat); - STACK_UNWIND_STRICT (readv, frame, op_ret, op_errno, - vector, count, buf, iobref, xdata); - return 0; + if (iosstat) { + ios_bump_stats(this, iosstat, IOS_STATS_TYPE_READ); + BUMP_THROUGHPUT(iosstat, IOS_STATS_THRU_READ); + iosstat = NULL; + } + STACK_UNWIND_STRICT(readv, frame, op_ret, op_errno, vector, count, buf, + iobref, xdata); + return 0; } - int -io_stats_writev_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, - struct iatt *prebuf, struct iatt *postbuf, dict_t *xdata) -{ - struct ios_stat *iosstat = NULL; - inode_t *inode = NULL; - - UPDATE_PROFILE_STATS (frame, WRITE); - if (frame->local){ - inode = frame->local; - frame->local = NULL; - ios_inode_ctx_get (inode, this, &iosstat); - if (iosstat) { - ios_bump_stats (this, iosstat, IOS_STATS_TYPE_WRITE); - BUMP_THROUGHPUT (iosstat, IOS_STATS_THRU_WRITE); - inode = NULL; - iosstat = NULL; - } - } +io_stats_writev_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, struct iatt *prebuf, + struct iatt *postbuf, dict_t *xdata) +{ + struct ios_stat *iosstat = NULL; + inode_t *inode = NULL; - STACK_UNWIND_STRICT (writev, frame, op_ret, op_errno, prebuf, postbuf, xdata); - return 0; + UPDATE_PROFILE_STATS(frame, WRITE); + if (frame->local) { + inode = frame->local; + frame->local = NULL; + ios_inode_ctx_get(inode, this, &iosstat); + if (iosstat) { + ios_bump_stats(this, iosstat, IOS_STATS_TYPE_WRITE); + BUMP_THROUGHPUT(iosstat, IOS_STATS_THRU_WRITE); + inode = NULL; + iosstat = NULL; + } + } + STACK_UNWIND_STRICT(writev, frame, op_ret, op_errno, prebuf, postbuf, + xdata); + return 0; } - - - int -io_stats_readdirp_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, gf_dirent_t *buf, dict_t *xdata) +io_stats_readdirp_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, gf_dirent_t *buf, + dict_t *xdata) { - struct ios_stat *iosstat = NULL; - inode_t *inode = frame->local; + struct ios_stat *iosstat = NULL; + inode_t *inode = frame->local; - frame->local = NULL; + frame->local = NULL; - UPDATE_PROFILE_STATS (frame, READDIRP); + UPDATE_PROFILE_STATS(frame, READDIRP); - ios_inode_ctx_get (inode, this, &iosstat); + ios_inode_ctx_get(inode, this, &iosstat); - if (iosstat) { - ios_bump_stats (this, iosstat, IOS_STATS_TYPE_READDIRP); - iosstat = NULL; - } + if (iosstat) { + ios_bump_stats(this, iosstat, IOS_STATS_TYPE_READDIRP); + iosstat = NULL; + } - STACK_UNWIND_STRICT (readdirp, frame, op_ret, op_errno, buf, xdata); - return 0; + STACK_UNWIND_STRICT(readdirp, frame, op_ret, op_errno, buf, xdata); + return 0; } - int -io_stats_readdir_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, gf_dirent_t *buf, dict_t *xdata) +io_stats_readdir_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, gf_dirent_t *buf, + dict_t *xdata) { - UPDATE_PROFILE_STATS (frame, READDIR); - STACK_UNWIND_STRICT (readdir, frame, op_ret, op_errno, buf, xdata); - return 0; + UPDATE_PROFILE_STATS(frame, READDIR); + STACK_UNWIND_STRICT(readdir, frame, op_ret, op_errno, buf, xdata); + return 0; } - int -io_stats_fsync_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, - struct iatt *prebuf, struct iatt *postbuf, dict_t *xdata) +io_stats_fsync_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, struct iatt *prebuf, + struct iatt *postbuf, dict_t *xdata) { - UPDATE_PROFILE_STATS (frame, FSYNC); - STACK_UNWIND_STRICT (fsync, frame, op_ret, op_errno, prebuf, postbuf, xdata); - return 0; + UPDATE_PROFILE_STATS(frame, FSYNC); + STACK_UNWIND_STRICT(fsync, frame, op_ret, op_errno, prebuf, postbuf, xdata); + return 0; } - int -io_stats_setattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, - struct iatt *preop, struct iatt *postop, dict_t *xdata) +io_stats_setattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, struct iatt *preop, + struct iatt *postop, dict_t *xdata) { - UPDATE_PROFILE_STATS (frame, SETATTR); - STACK_UNWIND_STRICT (setattr, frame, op_ret, op_errno, preop, postop, xdata); - return 0; + UPDATE_PROFILE_STATS(frame, SETATTR); + STACK_UNWIND_STRICT(setattr, frame, op_ret, op_errno, preop, postop, xdata); + return 0; } - int -io_stats_unlink_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, - struct iatt *preparent, struct iatt *postparent, dict_t *xdata) +io_stats_unlink_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, struct iatt *preparent, + struct iatt *postparent, dict_t *xdata) { - UPDATE_PROFILE_STATS (frame, UNLINK); - STACK_UNWIND_STRICT (unlink, frame, op_ret, op_errno, - preparent, postparent, xdata); - return 0; - + UPDATE_PROFILE_STATS(frame, UNLINK); + STACK_UNWIND_STRICT(unlink, frame, op_ret, op_errno, preparent, postparent, + xdata); + return 0; } - int -io_stats_rename_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, struct iatt *buf, - struct iatt *preoldparent, struct iatt *postoldparent, - struct iatt *prenewparent, struct iatt *postnewparent, dict_t *xdata) -{ - UPDATE_PROFILE_STATS (frame, RENAME); - STACK_UNWIND_STRICT (rename, frame, op_ret, op_errno, buf, - preoldparent, postoldparent, - prenewparent, postnewparent, xdata); - return 0; +io_stats_rename_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, struct iatt *buf, + struct iatt *preoldparent, struct iatt *postoldparent, + struct iatt *prenewparent, struct iatt *postnewparent, + dict_t *xdata) +{ + UPDATE_PROFILE_STATS(frame, RENAME); + STACK_UNWIND_STRICT(rename, frame, op_ret, op_errno, buf, preoldparent, + postoldparent, prenewparent, postnewparent, xdata); + return 0; } - int -io_stats_readlink_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, const char *buf, - struct iatt *sbuf, dict_t *xdata) +io_stats_readlink_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, const char *buf, + struct iatt *sbuf, dict_t *xdata) { - UPDATE_PROFILE_STATS (frame, READLINK); - STACK_UNWIND_STRICT (readlink, frame, op_ret, op_errno, buf, sbuf, xdata); - return 0; + UPDATE_PROFILE_STATS(frame, READLINK); + STACK_UNWIND_STRICT(readlink, frame, op_ret, op_errno, buf, sbuf, xdata); + return 0; } - int -io_stats_lookup_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, - inode_t *inode, struct iatt *buf, - dict_t *xdata, struct iatt *postparent) -{ - UPDATE_PROFILE_STATS (frame, LOOKUP); - STACK_UNWIND_STRICT (lookup, frame, op_ret, op_errno, inode, buf, xdata, - postparent); - return 0; +io_stats_lookup_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, inode_t *inode, + struct iatt *buf, dict_t *xdata, struct iatt *postparent) +{ + UPDATE_PROFILE_STATS(frame, LOOKUP); + STACK_UNWIND_STRICT(lookup, frame, op_ret, op_errno, inode, buf, xdata, + postparent); + return 0; } - int -io_stats_symlink_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, - inode_t *inode, struct iatt *buf, - struct iatt *preparent, struct iatt *postparent, dict_t *xdata) -{ - UPDATE_PROFILE_STATS (frame, SYMLINK); - STACK_UNWIND_STRICT (symlink, frame, op_ret, op_errno, inode, buf, - preparent, postparent, xdata); - return 0; +io_stats_symlink_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, inode_t *inode, + struct iatt *buf, struct iatt *preparent, + struct iatt *postparent, dict_t *xdata) +{ + UPDATE_PROFILE_STATS(frame, SYMLINK); + STACK_UNWIND_STRICT(symlink, frame, op_ret, op_errno, inode, buf, preparent, + postparent, xdata); + return 0; } - int -io_stats_mknod_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, - inode_t *inode, struct iatt *buf, - struct iatt *preparent, struct iatt *postparent, dict_t *xdata) -{ - UPDATE_PROFILE_STATS (frame, MKNOD); - STACK_UNWIND_STRICT (mknod, frame, op_ret, op_errno, inode, buf, - preparent, postparent, xdata); - return 0; +io_stats_mknod_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, inode_t *inode, + struct iatt *buf, struct iatt *preparent, + struct iatt *postparent, dict_t *xdata) +{ + UPDATE_PROFILE_STATS(frame, MKNOD); + STACK_UNWIND_STRICT(mknod, frame, op_ret, op_errno, inode, buf, preparent, + postparent, xdata); + return 0; } - int -io_stats_mkdir_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, - inode_t *inode, struct iatt *buf, - struct iatt *preparent, struct iatt *postparent, - dict_t *xdata) +io_stats_mkdir_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, inode_t *inode, + struct iatt *buf, struct iatt *preparent, + struct iatt *postparent, dict_t *xdata) { - char *path = frame->local; + char *path = frame->local; - if (!path) - goto unwind; + if (!path) + goto unwind; - UPDATE_PROFILE_STATS (frame, MKDIR); - if (op_ret < 0) - goto unwind; + UPDATE_PROFILE_STATS(frame, MKDIR); + if (op_ret < 0) + goto unwind; - /* allocate a struct ios_stat and set the inode ctx */ - ios_init_iosstat (this, path, buf->ia_gfid, inode); + /* allocate a struct ios_stat and set the inode ctx */ + ios_init_iosstat(this, path, buf->ia_gfid, inode); unwind: - /* local is assigned with path */ - GF_FREE (frame->local); - frame->local = NULL; - STACK_UNWIND_STRICT (mkdir, frame, op_ret, op_errno, inode, buf, - preparent, postparent, xdata); - return 0; + /* local is assigned with path */ + GF_FREE(frame->local); + frame->local = NULL; + STACK_UNWIND_STRICT(mkdir, frame, op_ret, op_errno, inode, buf, preparent, + postparent, xdata); + return 0; } - int -io_stats_link_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, - inode_t *inode, struct iatt *buf, - struct iatt *preparent, struct iatt *postparent, dict_t *xdata) -{ - UPDATE_PROFILE_STATS (frame, LINK); - STACK_UNWIND_STRICT (link, frame, op_ret, op_errno, inode, buf, - preparent, postparent, xdata); - return 0; +io_stats_link_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, inode_t *inode, + struct iatt *buf, struct iatt *preparent, + struct iatt *postparent, dict_t *xdata) +{ + UPDATE_PROFILE_STATS(frame, LINK); + STACK_UNWIND_STRICT(link, frame, op_ret, op_errno, inode, buf, preparent, + postparent, xdata); + return 0; } - int -io_stats_flush_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, dict_t *xdata) +io_stats_flush_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, dict_t *xdata) { - UPDATE_PROFILE_STATS (frame, FLUSH); - STACK_UNWIND_STRICT (flush, frame, op_ret, op_errno, xdata); - return 0; + UPDATE_PROFILE_STATS(frame, FLUSH); + STACK_UNWIND_STRICT(flush, frame, op_ret, op_errno, xdata); + return 0; } - int -io_stats_opendir_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, fd_t *fd, dict_t *xdata) +io_stats_opendir_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, fd_t *fd, dict_t *xdata) { - struct ios_stat *iosstat = NULL; - int ret = -1; + struct ios_stat *iosstat = NULL; + int ret = -1; - UPDATE_PROFILE_STATS (frame, OPENDIR); - if (op_ret < 0) - goto unwind; + UPDATE_PROFILE_STATS(frame, OPENDIR); + if (op_ret < 0) + goto unwind; - ios_fd_ctx_set (fd, this, 0); + ios_fd_ctx_set(fd, this, 0); - ret = ios_inode_ctx_get (fd->inode, this, &iosstat); - if (!ret) - ios_bump_stats (this, iosstat, IOS_STATS_TYPE_OPENDIR); + ret = ios_inode_ctx_get(fd->inode, this, &iosstat); + if (!ret) + ios_bump_stats(this, iosstat, IOS_STATS_TYPE_OPENDIR); unwind: - STACK_UNWIND_STRICT (opendir, frame, op_ret, op_errno, fd, xdata); - return 0; + STACK_UNWIND_STRICT(opendir, frame, op_ret, op_errno, fd, xdata); + return 0; } - int -io_stats_rmdir_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, - struct iatt *preparent, struct iatt *postparent, dict_t *xdata) +io_stats_rmdir_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, struct iatt *preparent, + struct iatt *postparent, dict_t *xdata) { + UPDATE_PROFILE_STATS(frame, RMDIR); - UPDATE_PROFILE_STATS (frame, RMDIR); - - STACK_UNWIND_STRICT (rmdir, frame, op_ret, op_errno, - preparent, postparent, xdata); - return 0; + STACK_UNWIND_STRICT(rmdir, frame, op_ret, op_errno, preparent, postparent, + xdata); + return 0; } - int -io_stats_truncate_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, - struct iatt *prebuf, struct iatt *postbuf, dict_t *xdata) +io_stats_truncate_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, struct iatt *prebuf, + struct iatt *postbuf, dict_t *xdata) { - UPDATE_PROFILE_STATS (frame, TRUNCATE); - STACK_UNWIND_STRICT (truncate, frame, op_ret, op_errno, - prebuf, postbuf, xdata); - return 0; + UPDATE_PROFILE_STATS(frame, TRUNCATE); + STACK_UNWIND_STRICT(truncate, frame, op_ret, op_errno, prebuf, postbuf, + xdata); + return 0; } - int -io_stats_statfs_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, struct statvfs *buf, dict_t *xdata) +io_stats_statfs_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, struct statvfs *buf, + dict_t *xdata) { - UPDATE_PROFILE_STATS (frame, STATFS); - STACK_UNWIND_STRICT (statfs, frame, op_ret, op_errno, buf, xdata); - return 0; + UPDATE_PROFILE_STATS(frame, STATFS); + STACK_UNWIND_STRICT(statfs, frame, op_ret, op_errno, buf, xdata); + return 0; } - int -io_stats_setxattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, dict_t *xdata) +io_stats_setxattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, dict_t *xdata) { - UPDATE_PROFILE_STATS (frame, SETXATTR); - STACK_UNWIND_STRICT (setxattr, frame, op_ret, op_errno, xdata); - return 0; + UPDATE_PROFILE_STATS(frame, SETXATTR); + STACK_UNWIND_STRICT(setxattr, frame, op_ret, op_errno, xdata); + return 0; } - int -io_stats_getxattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, dict_t *dict, dict_t *xdata) +io_stats_getxattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, dict_t *dict, + dict_t *xdata) { - UPDATE_PROFILE_STATS (frame, GETXATTR); - STACK_UNWIND_STRICT (getxattr, frame, op_ret, op_errno, dict, xdata); - return 0; + UPDATE_PROFILE_STATS(frame, GETXATTR); + STACK_UNWIND_STRICT(getxattr, frame, op_ret, op_errno, dict, xdata); + return 0; } - int -io_stats_removexattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, dict_t *xdata) +io_stats_removexattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, dict_t *xdata) { - UPDATE_PROFILE_STATS (frame, REMOVEXATTR); - STACK_UNWIND_STRICT (removexattr, frame, op_ret, op_errno, xdata); - return 0; + UPDATE_PROFILE_STATS(frame, REMOVEXATTR); + STACK_UNWIND_STRICT(removexattr, frame, op_ret, op_errno, xdata); + return 0; } int -io_stats_fsetxattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, dict_t *xdata) +io_stats_fsetxattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, dict_t *xdata) { - UPDATE_PROFILE_STATS (frame, FSETXATTR); - STACK_UNWIND_STRICT (fsetxattr, frame, op_ret, op_errno, xdata); - return 0; + UPDATE_PROFILE_STATS(frame, FSETXATTR); + STACK_UNWIND_STRICT(fsetxattr, frame, op_ret, op_errno, xdata); + return 0; } - int -io_stats_fgetxattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, dict_t *dict, dict_t *xdata) +io_stats_fgetxattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, dict_t *dict, + dict_t *xdata) { - UPDATE_PROFILE_STATS (frame, FGETXATTR); - STACK_UNWIND_STRICT (fgetxattr, frame, op_ret, op_errno, dict, xdata); - return 0; + UPDATE_PROFILE_STATS(frame, FGETXATTR); + STACK_UNWIND_STRICT(fgetxattr, frame, op_ret, op_errno, dict, xdata); + return 0; } - int -io_stats_fremovexattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, dict_t *xdata) +io_stats_fremovexattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, dict_t *xdata) { - UPDATE_PROFILE_STATS (frame, FREMOVEXATTR); - STACK_UNWIND_STRICT (fremovexattr, frame, op_ret, op_errno, xdata); - return 0; + UPDATE_PROFILE_STATS(frame, FREMOVEXATTR); + STACK_UNWIND_STRICT(fremovexattr, frame, op_ret, op_errno, xdata); + return 0; } - int -io_stats_fsyncdir_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, dict_t *xdata) +io_stats_fsyncdir_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, dict_t *xdata) { - UPDATE_PROFILE_STATS (frame, FSYNCDIR); - STACK_UNWIND_STRICT (fsyncdir, frame, op_ret, op_errno, xdata); - return 0; + UPDATE_PROFILE_STATS(frame, FSYNCDIR); + STACK_UNWIND_STRICT(fsyncdir, frame, op_ret, op_errno, xdata); + return 0; } - int -io_stats_access_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, dict_t *xdata) +io_stats_access_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, dict_t *xdata) { - UPDATE_PROFILE_STATS (frame, ACCESS); - STACK_UNWIND_STRICT (access, frame, op_ret, op_errno, xdata); - return 0; + UPDATE_PROFILE_STATS(frame, ACCESS); + STACK_UNWIND_STRICT(access, frame, op_ret, op_errno, xdata); + return 0; } - int -io_stats_ftruncate_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, - struct iatt *prebuf, struct iatt *postbuf, dict_t *xdata) +io_stats_ftruncate_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, struct iatt *prebuf, + struct iatt *postbuf, dict_t *xdata) { - UPDATE_PROFILE_STATS (frame, FTRUNCATE); - STACK_UNWIND_STRICT (ftruncate, frame, op_ret, op_errno, - prebuf, postbuf, xdata); - return 0; + UPDATE_PROFILE_STATS(frame, FTRUNCATE); + STACK_UNWIND_STRICT(ftruncate, frame, op_ret, op_errno, prebuf, postbuf, + xdata); + return 0; } - int -io_stats_fstat_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, struct iatt *buf, dict_t *xdata) +io_stats_fstat_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, struct iatt *buf, + dict_t *xdata) { - UPDATE_PROFILE_STATS (frame, FSTAT); - STACK_UNWIND_STRICT (fstat, frame, op_ret, op_errno, buf, xdata); - return 0; + UPDATE_PROFILE_STATS(frame, FSTAT); + STACK_UNWIND_STRICT(fstat, frame, op_ret, op_errno, buf, xdata); + return 0; } - int io_stats_fallocate_cbk(call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, struct iatt *prebuf, - struct iatt *postbuf, dict_t *xdata) + int32_t op_ret, int32_t op_errno, struct iatt *prebuf, + struct iatt *postbuf, dict_t *xdata) { - UPDATE_PROFILE_STATS(frame, FALLOCATE); - STACK_UNWIND_STRICT(fallocate, frame, op_ret, op_errno, prebuf, postbuf, - xdata); - return 0; + UPDATE_PROFILE_STATS(frame, FALLOCATE); + STACK_UNWIND_STRICT(fallocate, frame, op_ret, op_errno, prebuf, postbuf, + xdata); + return 0; } - int io_stats_discard_cbk(call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, struct iatt *prebuf, - struct iatt *postbuf, dict_t *xdata) + int32_t op_ret, int32_t op_errno, struct iatt *prebuf, + struct iatt *postbuf, dict_t *xdata) { - UPDATE_PROFILE_STATS(frame, DISCARD); - STACK_UNWIND_STRICT(discard, frame, op_ret, op_errno, prebuf, postbuf, - xdata); - return 0; + UPDATE_PROFILE_STATS(frame, DISCARD); + STACK_UNWIND_STRICT(discard, frame, op_ret, op_errno, prebuf, postbuf, + xdata); + return 0; } int io_stats_zerofill_cbk(call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, struct iatt *prebuf, - struct iatt *postbuf, dict_t *xdata) + int32_t op_ret, int32_t op_errno, struct iatt *prebuf, + struct iatt *postbuf, dict_t *xdata) { - UPDATE_PROFILE_STATS(frame, ZEROFILL); - STACK_UNWIND_STRICT(zerofill, frame, op_ret, op_errno, prebuf, postbuf, - xdata); - return 0; + UPDATE_PROFILE_STATS(frame, ZEROFILL); + STACK_UNWIND_STRICT(zerofill, frame, op_ret, op_errno, prebuf, postbuf, + xdata); + return 0; } int32_t -io_stats_ipc_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, dict_t *xdata) +io_stats_ipc_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, dict_t *xdata) { - UPDATE_PROFILE_STATS(frame, IPC); - STACK_UNWIND_STRICT (ipc, frame, op_ret, op_errno, - xdata); - return 0; + UPDATE_PROFILE_STATS(frame, IPC); + STACK_UNWIND_STRICT(ipc, frame, op_ret, op_errno, xdata); + return 0; } int -io_stats_lk_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, struct gf_flock *lock, dict_t *xdata) +io_stats_lk_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, struct gf_flock *lock, + dict_t *xdata) { - UPDATE_PROFILE_STATS (frame, LK); - STACK_UNWIND_STRICT (lk, frame, op_ret, op_errno, lock, xdata); - return 0; + UPDATE_PROFILE_STATS(frame, LK); + STACK_UNWIND_STRICT(lk, frame, op_ret, op_errno, lock, xdata); + return 0; } - int -io_stats_entrylk_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, dict_t *xdata) +io_stats_entrylk_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, dict_t *xdata) { - UPDATE_PROFILE_STATS (frame, ENTRYLK); - STACK_UNWIND_STRICT (entrylk, frame, op_ret, op_errno, xdata); - return 0; + UPDATE_PROFILE_STATS(frame, ENTRYLK); + STACK_UNWIND_STRICT(entrylk, frame, op_ret, op_errno, xdata); + return 0; } int -io_stats_fentrylk_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, dict_t *xdata) +io_stats_fentrylk_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, dict_t *xdata) { - UPDATE_PROFILE_STATS (frame, FENTRYLK); - STACK_UNWIND_STRICT (fentrylk, frame, op_ret, op_errno, xdata); - return 0; + UPDATE_PROFILE_STATS(frame, FENTRYLK); + STACK_UNWIND_STRICT(fentrylk, frame, op_ret, op_errno, xdata); + return 0; } int -io_stats_rchecksum_cbk (call_frame_t *frame, void *cookie, xlator_t *this, +io_stats_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, dict_t *xdata) { - UPDATE_PROFILE_STATS (frame, RCHECKSUM); - STACK_UNWIND_STRICT (rchecksum, frame, op_ret, op_errno, weak_checksum, - strong_checksum, xdata); - return 0; + UPDATE_PROFILE_STATS(frame, RCHECKSUM); + STACK_UNWIND_STRICT(rchecksum, frame, op_ret, op_errno, weak_checksum, + strong_checksum, xdata); + return 0; } int -io_stats_seek_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, off_t offset, - dict_t *xdata) +io_stats_seek_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, off_t offset, dict_t *xdata) { - UPDATE_PROFILE_STATS (frame, SEEK); - STACK_UNWIND_STRICT (seek, frame, op_ret, op_errno, offset, xdata); - return 0; + UPDATE_PROFILE_STATS(frame, SEEK); + STACK_UNWIND_STRICT(seek, frame, op_ret, op_errno, offset, xdata); + return 0; } int -io_stats_lease_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, - struct gf_lease *lease, dict_t *xdata) +io_stats_lease_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, struct gf_lease *lease, + dict_t *xdata) { - UPDATE_PROFILE_STATS (frame, LEASE); - STACK_UNWIND_STRICT (lease, frame, op_ret, op_errno, lease, xdata); - return 0; + UPDATE_PROFILE_STATS(frame, LEASE); + STACK_UNWIND_STRICT(lease, frame, op_ret, op_errno, lease, xdata); + return 0; } int -io_stats_getactivelk_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, - lock_migration_info_t *locklist, - dict_t *xdata) -{ - UPDATE_PROFILE_STATS (frame, GETACTIVELK); - STACK_UNWIND_STRICT (getactivelk, frame, op_ret, op_errno, - locklist, xdata); - return 0; +io_stats_getactivelk_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, + lock_migration_info_t *locklist, dict_t *xdata) +{ + UPDATE_PROFILE_STATS(frame, GETACTIVELK); + STACK_UNWIND_STRICT(getactivelk, frame, op_ret, op_errno, locklist, xdata); + return 0; } int -io_stats_setactivelk_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, dict_t *xdata) +io_stats_setactivelk_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, dict_t *xdata) { - UPDATE_PROFILE_STATS (frame, SETACTIVELK); - STACK_UNWIND_STRICT (setactivelk, frame, op_ret, op_errno, xdata); - return 0; + UPDATE_PROFILE_STATS(frame, SETACTIVELK); + STACK_UNWIND_STRICT(setactivelk, frame, op_ret, op_errno, xdata); + return 0; } int -io_stats_compound_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, void *data, - dict_t *xdata) +io_stats_compound_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, void *data, + dict_t *xdata) { - UPDATE_PROFILE_STATS (frame, COMPOUND); - STACK_UNWIND_STRICT (compound, frame, op_ret, op_errno, data, xdata); - return 0; + UPDATE_PROFILE_STATS(frame, COMPOUND); + STACK_UNWIND_STRICT(compound, frame, op_ret, op_errno, data, xdata); + return 0; } int -io_stats_xattrop_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, dict_t *dict, dict_t *xdata) +io_stats_xattrop_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, dict_t *dict, + dict_t *xdata) { - UPDATE_PROFILE_STATS (frame, XATTROP); - STACK_UNWIND_STRICT (xattrop, frame, op_ret, op_errno, dict, xdata); - return 0; + UPDATE_PROFILE_STATS(frame, XATTROP); + STACK_UNWIND_STRICT(xattrop, frame, op_ret, op_errno, dict, xdata); + return 0; } - int -io_stats_fxattrop_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, dict_t *dict, dict_t *xdata) +io_stats_fxattrop_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, dict_t *dict, + dict_t *xdata) { - UPDATE_PROFILE_STATS (frame, FXATTROP); - STACK_UNWIND_STRICT (fxattrop, frame, op_ret, op_errno, dict, xdata); - return 0; + UPDATE_PROFILE_STATS(frame, FXATTROP); + STACK_UNWIND_STRICT(fxattrop, frame, op_ret, op_errno, dict, xdata); + return 0; } - int -io_stats_inodelk_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, dict_t *xdata) +io_stats_inodelk_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, dict_t *xdata) { - UPDATE_PROFILE_STATS (frame, INODELK); - STACK_UNWIND_STRICT (inodelk, frame, op_ret, op_errno, xdata); - return 0; + UPDATE_PROFILE_STATS(frame, INODELK); + STACK_UNWIND_STRICT(inodelk, frame, op_ret, op_errno, xdata); + return 0; } int -io_stats_entrylk (call_frame_t *frame, xlator_t *this, - const char *volume, loc_t *loc, const char *basename, - entrylk_cmd cmd, entrylk_type type, dict_t *xdata) +io_stats_entrylk(call_frame_t *frame, xlator_t *this, const char *volume, + loc_t *loc, const char *basename, entrylk_cmd cmd, + entrylk_type type, dict_t *xdata) { - START_FOP_LATENCY (frame); + START_FOP_LATENCY(frame); - STACK_WIND (frame, io_stats_entrylk_cbk, - FIRST_CHILD (this), - FIRST_CHILD (this)->fops->entrylk, - volume, loc, basename, cmd, type, xdata); - return 0; + STACK_WIND(frame, io_stats_entrylk_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->entrylk, volume, loc, basename, cmd, + type, xdata); + return 0; } int -io_stats_fentrylk (call_frame_t *frame, xlator_t *this, - const char *volume, fd_t *fd, const char *basename, - entrylk_cmd cmd, entrylk_type type, dict_t *xdata) +io_stats_fentrylk(call_frame_t *frame, xlator_t *this, const char *volume, + fd_t *fd, const char *basename, entrylk_cmd cmd, + entrylk_type type, dict_t *xdata) { - START_FOP_LATENCY (frame); + START_FOP_LATENCY(frame); - STACK_WIND (frame, io_stats_fentrylk_cbk, - FIRST_CHILD(this), - FIRST_CHILD(this)->fops->fentrylk, - volume, fd, basename, cmd, type, xdata); - return 0; + STACK_WIND(frame, io_stats_fentrylk_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->fentrylk, volume, fd, basename, cmd, + type, xdata); + return 0; } - int -io_stats_inodelk (call_frame_t *frame, xlator_t *this, - const char *volume, loc_t *loc, int32_t cmd, struct gf_flock *flock, dict_t *xdata) +io_stats_inodelk(call_frame_t *frame, xlator_t *this, const char *volume, + loc_t *loc, int32_t cmd, struct gf_flock *flock, dict_t *xdata) { + START_FOP_LATENCY(frame); - START_FOP_LATENCY (frame); - - STACK_WIND (frame, io_stats_inodelk_cbk, - FIRST_CHILD (this), - FIRST_CHILD (this)->fops->inodelk, - volume, loc, cmd, flock, xdata); - return 0; + STACK_WIND(frame, io_stats_inodelk_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->inodelk, volume, loc, cmd, flock, + xdata); + return 0; } - int -io_stats_finodelk_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, dict_t *xdata) +io_stats_finodelk_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, dict_t *xdata) { - - UPDATE_PROFILE_STATS (frame, FINODELK); - STACK_UNWIND_STRICT (finodelk, frame, op_ret, op_errno, xdata); - return 0; + UPDATE_PROFILE_STATS(frame, FINODELK); + STACK_UNWIND_STRICT(finodelk, frame, op_ret, op_errno, xdata); + return 0; } - int -io_stats_finodelk (call_frame_t *frame, xlator_t *this, const char *volume, - fd_t *fd, int32_t cmd, struct gf_flock *flock, dict_t *xdata) +io_stats_finodelk(call_frame_t *frame, xlator_t *this, const char *volume, + fd_t *fd, int32_t cmd, struct gf_flock *flock, dict_t *xdata) { - START_FOP_LATENCY (frame); + START_FOP_LATENCY(frame); - STACK_WIND (frame, io_stats_finodelk_cbk, - FIRST_CHILD (this), - FIRST_CHILD (this)->fops->finodelk, - volume, fd, cmd, flock, xdata); - return 0; + STACK_WIND(frame, io_stats_finodelk_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->finodelk, volume, fd, cmd, flock, + xdata); + return 0; } - int -io_stats_xattrop (call_frame_t *frame, xlator_t *this, loc_t *loc, - gf_xattrop_flags_t flags, dict_t *dict, dict_t *xdata) +io_stats_xattrop(call_frame_t *frame, xlator_t *this, loc_t *loc, + gf_xattrop_flags_t flags, dict_t *dict, dict_t *xdata) { - START_FOP_LATENCY (frame); + START_FOP_LATENCY(frame); - STACK_WIND (frame, io_stats_xattrop_cbk, - FIRST_CHILD(this), - FIRST_CHILD(this)->fops->xattrop, - loc, flags, dict, xdata); - return 0; + STACK_WIND(frame, io_stats_xattrop_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->xattrop, loc, flags, dict, xdata); + return 0; } - int -io_stats_fxattrop (call_frame_t *frame, xlator_t *this, fd_t *fd, - gf_xattrop_flags_t flags, dict_t *dict, dict_t *xdata) +io_stats_fxattrop(call_frame_t *frame, xlator_t *this, fd_t *fd, + gf_xattrop_flags_t flags, dict_t *dict, dict_t *xdata) { - START_FOP_LATENCY (frame); + START_FOP_LATENCY(frame); - STACK_WIND (frame, io_stats_fxattrop_cbk, - FIRST_CHILD(this), - FIRST_CHILD(this)->fops->fxattrop, - fd, flags, dict, xdata); - return 0; + STACK_WIND(frame, io_stats_fxattrop_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->fxattrop, fd, flags, dict, xdata); + return 0; } - int -io_stats_lookup (call_frame_t *frame, xlator_t *this, - loc_t *loc, dict_t *xdata) +io_stats_lookup(call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *xdata) { - START_FOP_LATENCY (frame); + START_FOP_LATENCY(frame); - STACK_WIND (frame, io_stats_lookup_cbk, - FIRST_CHILD(this), - FIRST_CHILD(this)->fops->lookup, - loc, xdata); - return 0; + STACK_WIND(frame, io_stats_lookup_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->lookup, loc, xdata); + return 0; } - int -io_stats_stat (call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *xdata) +io_stats_stat(call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *xdata) { - START_FOP_LATENCY (frame); + START_FOP_LATENCY(frame); - STACK_WIND (frame, io_stats_stat_cbk, - FIRST_CHILD(this), - FIRST_CHILD(this)->fops->stat, - loc, xdata); - return 0; + STACK_WIND(frame, io_stats_stat_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->stat, loc, xdata); + return 0; } - int -io_stats_readlink (call_frame_t *frame, xlator_t *this, - loc_t *loc, size_t size, dict_t *xdata) +io_stats_readlink(call_frame_t *frame, xlator_t *this, loc_t *loc, size_t size, + dict_t *xdata) { - START_FOP_LATENCY (frame); + START_FOP_LATENCY(frame); - STACK_WIND (frame, io_stats_readlink_cbk, - FIRST_CHILD(this), - FIRST_CHILD(this)->fops->readlink, - loc, size, xdata); - return 0; + STACK_WIND(frame, io_stats_readlink_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->readlink, loc, size, xdata); + return 0; } - int -io_stats_mknod (call_frame_t *frame, xlator_t *this, loc_t *loc, - mode_t mode, dev_t dev, mode_t umask, dict_t *xdata) +io_stats_mknod(call_frame_t *frame, xlator_t *this, loc_t *loc, mode_t mode, + dev_t dev, mode_t umask, dict_t *xdata) { - START_FOP_LATENCY (frame); + START_FOP_LATENCY(frame); - STACK_WIND (frame, io_stats_mknod_cbk, - FIRST_CHILD(this), - FIRST_CHILD(this)->fops->mknod, - loc, mode, dev, umask, xdata); - return 0; + STACK_WIND(frame, io_stats_mknod_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->mknod, loc, mode, dev, umask, xdata); + return 0; } - int -io_stats_mkdir (call_frame_t *frame, xlator_t *this, - loc_t *loc, mode_t mode, mode_t umask, dict_t *xdata) +io_stats_mkdir(call_frame_t *frame, xlator_t *this, loc_t *loc, mode_t mode, + mode_t umask, dict_t *xdata) { - if (loc->path) - frame->local = gf_strdup (loc->path); + if (loc->path) + frame->local = gf_strdup(loc->path); - START_FOP_LATENCY (frame); + START_FOP_LATENCY(frame); - STACK_WIND (frame, io_stats_mkdir_cbk, - FIRST_CHILD(this), - FIRST_CHILD(this)->fops->mkdir, - loc, mode, umask, xdata); - return 0; + STACK_WIND(frame, io_stats_mkdir_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->mkdir, loc, mode, umask, xdata); + return 0; } - int -io_stats_unlink (call_frame_t *frame, xlator_t *this, - loc_t *loc, int xflag, dict_t *xdata) +io_stats_unlink(call_frame_t *frame, xlator_t *this, loc_t *loc, int xflag, + dict_t *xdata) { - START_FOP_LATENCY (frame); + START_FOP_LATENCY(frame); - STACK_WIND (frame, io_stats_unlink_cbk, - FIRST_CHILD(this), - FIRST_CHILD(this)->fops->unlink, - loc, xflag, xdata); - return 0; + STACK_WIND(frame, io_stats_unlink_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->unlink, loc, xflag, xdata); + return 0; } - int -io_stats_rmdir (call_frame_t *frame, xlator_t *this, - loc_t *loc, int flags, dict_t *xdata) +io_stats_rmdir(call_frame_t *frame, xlator_t *this, loc_t *loc, int flags, + dict_t *xdata) { - START_FOP_LATENCY (frame); + START_FOP_LATENCY(frame); - STACK_WIND (frame, io_stats_rmdir_cbk, - FIRST_CHILD(this), - FIRST_CHILD(this)->fops->rmdir, - loc, flags, xdata); - return 0; + STACK_WIND(frame, io_stats_rmdir_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->rmdir, loc, flags, xdata); + return 0; } - int -io_stats_symlink (call_frame_t *frame, xlator_t *this, const char *linkpath, - loc_t *loc, mode_t umask, dict_t *xdata) +io_stats_symlink(call_frame_t *frame, xlator_t *this, const char *linkpath, + loc_t *loc, mode_t umask, dict_t *xdata) { - START_FOP_LATENCY (frame); + START_FOP_LATENCY(frame); - STACK_WIND (frame, io_stats_symlink_cbk, - FIRST_CHILD(this), - FIRST_CHILD(this)->fops->symlink, - linkpath, loc, umask, xdata); - return 0; + STACK_WIND(frame, io_stats_symlink_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->symlink, linkpath, loc, umask, xdata); + return 0; } - int -io_stats_rename (call_frame_t *frame, xlator_t *this, - loc_t *oldloc, loc_t *newloc, dict_t *xdata) +io_stats_rename(call_frame_t *frame, xlator_t *this, loc_t *oldloc, + loc_t *newloc, dict_t *xdata) { - START_FOP_LATENCY (frame); + START_FOP_LATENCY(frame); - STACK_WIND (frame, io_stats_rename_cbk, - FIRST_CHILD(this), - FIRST_CHILD(this)->fops->rename, - oldloc, newloc, xdata); - return 0; + STACK_WIND(frame, io_stats_rename_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->rename, oldloc, newloc, xdata); + return 0; } - int -io_stats_link (call_frame_t *frame, xlator_t *this, - loc_t *oldloc, loc_t *newloc, dict_t *xdata) +io_stats_link(call_frame_t *frame, xlator_t *this, loc_t *oldloc, loc_t *newloc, + dict_t *xdata) { - START_FOP_LATENCY (frame); + START_FOP_LATENCY(frame); - STACK_WIND (frame, io_stats_link_cbk, - FIRST_CHILD(this), - FIRST_CHILD(this)->fops->link, - oldloc, newloc, xdata); - return 0; + STACK_WIND(frame, io_stats_link_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->link, oldloc, newloc, xdata); + return 0; } - int -io_stats_setattr (call_frame_t *frame, xlator_t *this, - loc_t *loc, struct iatt *stbuf, int32_t valid, dict_t *xdata) +io_stats_setattr(call_frame_t *frame, xlator_t *this, loc_t *loc, + struct iatt *stbuf, int32_t valid, dict_t *xdata) { - START_FOP_LATENCY (frame); + START_FOP_LATENCY(frame); - STACK_WIND (frame, io_stats_setattr_cbk, - FIRST_CHILD(this), - FIRST_CHILD(this)->fops->setattr, - loc, stbuf, valid, xdata); - return 0; + STACK_WIND(frame, io_stats_setattr_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->setattr, loc, stbuf, valid, xdata); + return 0; } - int -io_stats_truncate (call_frame_t *frame, xlator_t *this, - loc_t *loc, off_t offset, dict_t *xdata) +io_stats_truncate(call_frame_t *frame, xlator_t *this, loc_t *loc, off_t offset, + dict_t *xdata) { - START_FOP_LATENCY (frame); + START_FOP_LATENCY(frame); - STACK_WIND (frame, io_stats_truncate_cbk, - FIRST_CHILD(this), - FIRST_CHILD(this)->fops->truncate, - loc, offset, xdata); - return 0; + STACK_WIND(frame, io_stats_truncate_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->truncate, loc, offset, xdata); + return 0; } - int -io_stats_open (call_frame_t *frame, xlator_t *this, loc_t *loc, - int32_t flags, fd_t *fd, dict_t *xdata) +io_stats_open(call_frame_t *frame, xlator_t *this, loc_t *loc, int32_t flags, + fd_t *fd, dict_t *xdata) { - if (loc->path) - frame->local = gf_strdup (loc->path); + if (loc->path) + frame->local = gf_strdup(loc->path); - START_FOP_LATENCY (frame); + START_FOP_LATENCY(frame); - STACK_WIND (frame, io_stats_open_cbk, - FIRST_CHILD(this), - FIRST_CHILD(this)->fops->open, - loc, flags, fd, xdata); - return 0; + STACK_WIND(frame, io_stats_open_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->open, loc, flags, fd, xdata); + return 0; } - int -io_stats_create (call_frame_t *frame, xlator_t *this, - loc_t *loc, int32_t flags, mode_t mode, - mode_t umask, fd_t *fd, dict_t *xdata) +io_stats_create(call_frame_t *frame, xlator_t *this, loc_t *loc, int32_t flags, + mode_t mode, mode_t umask, fd_t *fd, dict_t *xdata) { - if (loc->path) - frame->local = gf_strdup (loc->path); + if (loc->path) + frame->local = gf_strdup(loc->path); - START_FOP_LATENCY (frame); + START_FOP_LATENCY(frame); - STACK_WIND (frame, io_stats_create_cbk, - FIRST_CHILD(this), - FIRST_CHILD(this)->fops->create, - loc, flags, mode, umask, fd, xdata); - return 0; + STACK_WIND(frame, io_stats_create_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->create, loc, flags, mode, umask, fd, + xdata); + return 0; } - int -io_stats_readv (call_frame_t *frame, xlator_t *this, - fd_t *fd, size_t size, off_t offset, uint32_t flags, dict_t *xdata) +io_stats_readv(call_frame_t *frame, xlator_t *this, fd_t *fd, size_t size, + off_t offset, uint32_t flags, dict_t *xdata) { - frame->local = fd; + frame->local = fd; - START_FOP_LATENCY (frame); + START_FOP_LATENCY(frame); - STACK_WIND (frame, io_stats_readv_cbk, - FIRST_CHILD(this), - FIRST_CHILD(this)->fops->readv, - fd, size, offset, flags, xdata); - return 0; + STACK_WIND(frame, io_stats_readv_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->readv, fd, size, offset, flags, xdata); + return 0; } - int -io_stats_writev (call_frame_t *frame, xlator_t *this, - fd_t *fd, struct iovec *vector, - int32_t count, off_t offset, - uint32_t flags, struct iobref *iobref, dict_t *xdata) +io_stats_writev(call_frame_t *frame, xlator_t *this, fd_t *fd, + struct iovec *vector, int32_t count, off_t offset, + uint32_t flags, struct iobref *iobref, dict_t *xdata) { - int len = 0; - - if (fd->inode) - frame->local = fd->inode; - len = iov_length (vector, count); + int len = 0; - ios_bump_write (this, fd, len); - START_FOP_LATENCY (frame); + if (fd->inode) + frame->local = fd->inode; + len = iov_length(vector, count); - STACK_WIND (frame, io_stats_writev_cbk, - FIRST_CHILD(this), - FIRST_CHILD(this)->fops->writev, - fd, vector, count, offset, flags, iobref, xdata); - return 0; + ios_bump_write(this, fd, len); + START_FOP_LATENCY(frame); + STACK_WIND(frame, io_stats_writev_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->writev, fd, vector, count, offset, + flags, iobref, xdata); + return 0; } - int -io_stats_statfs (call_frame_t *frame, xlator_t *this, - loc_t *loc, dict_t *xdata) +io_stats_statfs(call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *xdata) { - START_FOP_LATENCY (frame); + START_FOP_LATENCY(frame); - STACK_WIND (frame, io_stats_statfs_cbk, - FIRST_CHILD(this), - FIRST_CHILD(this)->fops->statfs, - loc, xdata); - return 0; + STACK_WIND(frame, io_stats_statfs_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->statfs, loc, xdata); + return 0; } - int -io_stats_flush (call_frame_t *frame, xlator_t *this, - fd_t *fd, dict_t *xdata) +io_stats_flush(call_frame_t *frame, xlator_t *this, fd_t *fd, dict_t *xdata) { - START_FOP_LATENCY (frame); + START_FOP_LATENCY(frame); - STACK_WIND (frame, io_stats_flush_cbk, - FIRST_CHILD(this), - FIRST_CHILD(this)->fops->flush, - fd, xdata); - return 0; + STACK_WIND(frame, io_stats_flush_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->flush, fd, xdata); + return 0; } - int -io_stats_fsync (call_frame_t *frame, xlator_t *this, - fd_t *fd, int32_t flags, dict_t *xdata) +io_stats_fsync(call_frame_t *frame, xlator_t *this, fd_t *fd, int32_t flags, + dict_t *xdata) { - START_FOP_LATENCY (frame); + START_FOP_LATENCY(frame); - STACK_WIND (frame, io_stats_fsync_cbk, - FIRST_CHILD(this), - FIRST_CHILD(this)->fops->fsync, - fd, flags, xdata); - return 0; + STACK_WIND(frame, io_stats_fsync_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->fsync, fd, flags, xdata); + return 0; } int -conditional_dump (dict_t *dict, char *key, data_t *value, void *data) -{ - struct { - xlator_t *this; - inode_t *inode; - const char *path; - } *stub; - xlator_t *this = NULL; - char *filename = NULL; - FILE *logfp = NULL; - struct ios_dump_args args = {0}; - int pid, namelen, dirlen; - char dump_key[100]; - char *slash_ptr = NULL; - char *path_in_value = NULL; - - stub = data; - this = stub->this; - - /* Create a file name that is appended with the io-stats instance - name as well. This helps when there is more than a single io-stats - instance in the graph, or the client and server processes are running - on the same node */ - /* For the sanity of where the file should be located, we should make - sure file is written only inside RUNDIR (ie, /var/run/gluster) */ - /* TODO: provide an option to dump it to different directory of - choice, based on options */ - /* name format: /var/run/gluster/<passed in path/filename>.<xlator name slashes to -> */ - - path_in_value = data_to_str (value); - - if (strstr (path_in_value, "../")) { - gf_log (this->name, GF_LOG_ERROR, - "%s: no \"../\" allowed in path", path_in_value); - return -1; - } - dirlen = strlen (IOS_STATS_DUMP_DIR); - namelen = (dirlen + value->len + strlen (this->name) + 3); - /* +3 for '/', '.' and '\0' added in snprintf below*/ - - filename = alloca0 (namelen); - - snprintf (filename, namelen, "%s/%s.%s", IOS_STATS_DUMP_DIR, - path_in_value, this->name); - - /* convert any slashes to '-' so that fopen works correctly */ - slash_ptr = strchr (filename + dirlen + 1, '/'); - while (slash_ptr) { - *slash_ptr = '-'; - slash_ptr = strchr (slash_ptr, '/'); - } - - pid = getpid (); - - if (!strncmp (filename, "", 1)) { - gf_log (this->name, GF_LOG_ERROR, "No filename given"); - return -1; - } - logfp = fopen (filename, "w+"); - if (!logfp) { - gf_log (this->name, GF_LOG_ERROR, "failed to open %s " - "for writing", filename); - return -1; - } - sprintf (dump_key, "*io*stat*%d_json_dump", pid); - if (fnmatch (dump_key, key, 0) == 0) { - (void) ios_dump_args_init ( - &args, IOS_DUMP_TYPE_JSON_FILE, - logfp); - } else { - (void) ios_dump_args_init (&args, IOS_DUMP_TYPE_FILE, - logfp); - } - io_stats_dump (this, &args, GF_CLI_INFO_ALL, _gf_false); - fclose (logfp); - return 0; +conditional_dump(dict_t *dict, char *key, data_t *value, void *data) +{ + struct { + xlator_t *this; + inode_t *inode; + const char *path; + } * stub; + xlator_t *this = NULL; + char *filename = NULL; + FILE *logfp = NULL; + struct ios_dump_args args = {0}; + int pid, namelen, dirlen; + char dump_key[100]; + char *slash_ptr = NULL; + char *path_in_value = NULL; + + stub = data; + this = stub->this; + + /* Create a file name that is appended with the io-stats instance + name as well. This helps when there is more than a single io-stats + instance in the graph, or the client and server processes are running + on the same node */ + /* For the sanity of where the file should be located, we should make + sure file is written only inside RUNDIR (ie, /var/run/gluster) */ + /* TODO: provide an option to dump it to different directory of + choice, based on options */ + /* name format: /var/run/gluster/<passed in path/filename>.<xlator name + * slashes to -> */ + + path_in_value = data_to_str(value); + + if (strstr(path_in_value, "../")) { + gf_log(this->name, GF_LOG_ERROR, "%s: no \"../\" allowed in path", + path_in_value); + return -1; + } + dirlen = strlen(IOS_STATS_DUMP_DIR); + namelen = (dirlen + value->len + strlen(this->name) + 3); + /* +3 for '/', '.' and '\0' added in snprintf below*/ + + filename = alloca0(namelen); + + snprintf(filename, namelen, "%s/%s.%s", IOS_STATS_DUMP_DIR, path_in_value, + this->name); + + /* convert any slashes to '-' so that fopen works correctly */ + slash_ptr = strchr(filename + dirlen + 1, '/'); + while (slash_ptr) { + *slash_ptr = '-'; + slash_ptr = strchr(slash_ptr, '/'); + } + + pid = getpid(); + + if (!strncmp(filename, "", 1)) { + gf_log(this->name, GF_LOG_ERROR, "No filename given"); + return -1; + } + logfp = fopen(filename, "w+"); + if (!logfp) { + gf_log(this->name, GF_LOG_ERROR, + "failed to open %s " + "for writing", + filename); + return -1; + } + sprintf(dump_key, "*io*stat*%d_json_dump", pid); + if (fnmatch(dump_key, key, 0) == 0) { + (void)ios_dump_args_init(&args, IOS_DUMP_TYPE_JSON_FILE, logfp); + } else { + (void)ios_dump_args_init(&args, IOS_DUMP_TYPE_FILE, logfp); + } + io_stats_dump(this, &args, GF_CLI_INFO_ALL, _gf_false); + fclose(logfp); + return 0; } int -_ios_destroy_dump_thread (struct ios_conf *conf) { - conf->dump_thread_should_die = _gf_true; - if (conf->dump_thread_running) { - (void) pthread_cancel (conf->dump_thread); - (void) pthread_join (conf->dump_thread, NULL); - } - return 0; +_ios_destroy_dump_thread(struct ios_conf *conf) +{ + conf->dump_thread_should_die = _gf_true; + if (conf->dump_thread_running) { + (void)pthread_cancel(conf->dump_thread); + (void)pthread_join(conf->dump_thread, NULL); + } + return 0; } void * -_ios_dump_thread (xlator_t *this) { - struct ios_conf *conf = NULL; - FILE *stats_logfp = NULL; - FILE *samples_logfp = NULL; - struct ios_dump_args args = {0}; - int i; - int stats_bytes_written = 0; - int samples_bytes_written = 0; - char stats_filename[PATH_MAX]; - char samples_filename[PATH_MAX]; - char *xlator_name; - char *instance_name; - gf_boolean_t log_stats_fopen_failure = _gf_true; - gf_boolean_t log_samples_fopen_failure = _gf_true; - int old_cancel_type; - - conf = this->private; - gf_log (this->name, GF_LOG_INFO, "IO stats dump thread started, " - "polling IO stats every %d seconds", conf->ios_dump_interval); - xlator_name = strdupa (conf->unique_id); - for (i = 0; i < strlen (xlator_name); i++) { - if (xlator_name[i] == '/') - xlator_name[i] = '_'; +_ios_dump_thread(xlator_t *this) +{ + struct ios_conf *conf = NULL; + FILE *stats_logfp = NULL; + FILE *samples_logfp = NULL; + struct ios_dump_args args = {0}; + int i; + int stats_bytes_written = 0; + int samples_bytes_written = 0; + char stats_filename[PATH_MAX]; + char samples_filename[PATH_MAX]; + char *xlator_name; + char *instance_name; + gf_boolean_t log_stats_fopen_failure = _gf_true; + gf_boolean_t log_samples_fopen_failure = _gf_true; + int old_cancel_type; + + conf = this->private; + gf_log(this->name, GF_LOG_INFO, + "IO stats dump thread started, " + "polling IO stats every %d seconds", + conf->ios_dump_interval); + xlator_name = strdupa(conf->unique_id); + for (i = 0; i < strlen(xlator_name); i++) { + if (xlator_name[i] == '/') + xlator_name[i] = '_'; + } + instance_name = this->instance_name; + if (this->name && strcmp(this->name, "glustershd") == 0) { + xlator_name = "shd"; + } else if (this->prev && strcmp(this->prev->name, "nfs-server") == 0) { + xlator_name = "nfsd"; + instance_name = this->prev->instance_name; + } + if (sys_mkdir(_IOS_DUMP_DIR, S_IRWXU | S_IRWXO | S_IRWXG) == (-1)) { + if (errno != EEXIST) { + gf_log(this->name, GF_LOG_ERROR, + "could not create stats-dump directory %s", _IOS_DUMP_DIR); + goto out; } - instance_name = this->instance_name; - if (this->name && strcmp (this->name, "glustershd") == 0) { - xlator_name = "shd"; - } else if (this->prev && - strcmp (this->prev->name, "nfs-server") == 0) { - xlator_name = "nfsd"; - instance_name = this->prev->instance_name; + } + if (sys_mkdir(_IOS_SAMP_DIR, S_IRWXU | S_IRWXO | S_IRWXG) == (-1)) { + if (errno != EEXIST) { + gf_log(this->name, GF_LOG_ERROR, + "could not create stats-sample directory %s", _IOS_SAMP_DIR); + goto out; } - if (sys_mkdir (_IOS_DUMP_DIR, S_IRWXU | S_IRWXO | S_IRWXG) == (-1)) { - if (errno != EEXIST) { - gf_log (this->name, GF_LOG_ERROR, - "could not create stats-dump directory %s", - _IOS_DUMP_DIR); - goto out; - } - } - if (sys_mkdir (_IOS_SAMP_DIR, S_IRWXU | S_IRWXO | S_IRWXG) == (-1)) { - if (errno != EEXIST) { - gf_log (this->name, GF_LOG_ERROR, - "could not create stats-sample directory %s", - _IOS_SAMP_DIR); - goto out; - } - } - if (instance_name) { - stats_bytes_written = snprintf (stats_filename, PATH_MAX, - "%s/%s_%s_%s.dump", _IOS_DUMP_DIR, - __progname, xlator_name, instance_name); - samples_bytes_written = snprintf (samples_filename, PATH_MAX, - "%s/%s_%s_%s.samp", _IOS_SAMP_DIR, - __progname, xlator_name, instance_name); - } else { - stats_bytes_written = snprintf (stats_filename, PATH_MAX, - "%s/%s_%s.dump", _IOS_DUMP_DIR, __progname, - xlator_name); - samples_bytes_written = snprintf (samples_filename, PATH_MAX, - "%s/%s_%s.samp", _IOS_SAMP_DIR, __progname, - xlator_name); + } + if (instance_name) { + stats_bytes_written = snprintf(stats_filename, PATH_MAX, + "%s/%s_%s_%s.dump", _IOS_DUMP_DIR, + __progname, xlator_name, instance_name); + samples_bytes_written = snprintf( + samples_filename, PATH_MAX, "%s/%s_%s_%s.samp", _IOS_SAMP_DIR, + __progname, xlator_name, instance_name); + } else { + stats_bytes_written = snprintf(stats_filename, PATH_MAX, + "%s/%s_%s.dump", _IOS_DUMP_DIR, + __progname, xlator_name); + samples_bytes_written = snprintf(samples_filename, PATH_MAX, + "%s/%s_%s.samp", _IOS_SAMP_DIR, + __progname, xlator_name); + } + if ((stats_bytes_written >= PATH_MAX) || + (samples_bytes_written >= PATH_MAX)) { + gf_log(this->name, GF_LOG_ERROR, + "Invalid path for stats dump (%s) and/or latency " + "samples (%s)", + stats_filename, samples_filename); + goto out; + } + while (1) { + if (conf->dump_thread_should_die) + break; + (void)pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, + &old_cancel_type); + sleep(conf->ios_dump_interval); + (void)pthread_setcanceltype(PTHREAD_CANCEL_DEFERRED, &old_cancel_type); + /* + * It's not clear whether we should reopen this each time, or + * just hold it open and rewind/truncate on each iteration. + * Leaving it alone for now. + */ + stats_logfp = fopen(stats_filename, "w+"); + if (stats_logfp) { + (void)ios_dump_args_init(&args, conf->dump_format, stats_logfp); + io_stats_dump(this, &args, GF_CLI_INFO_ALL, _gf_false); + fclose(stats_logfp); + log_stats_fopen_failure = _gf_true; + } else if (log_stats_fopen_failure) { + gf_log(this->name, GF_LOG_ERROR, + "could not open stats-dump file %s (%s)", stats_filename, + strerror(errno)); + log_stats_fopen_failure = _gf_false; } - if ((stats_bytes_written >= PATH_MAX) || - (samples_bytes_written >= PATH_MAX)) { - gf_log (this->name, GF_LOG_ERROR, - "Invalid path for stats dump (%s) and/or latency " - "samples (%s)", stats_filename, samples_filename); - goto out; - } - while (1) { - if (conf->dump_thread_should_die) - break; - (void) pthread_setcanceltype (PTHREAD_CANCEL_ASYNCHRONOUS, - &old_cancel_type); - sleep (conf->ios_dump_interval); - (void) pthread_setcanceltype (PTHREAD_CANCEL_DEFERRED, - &old_cancel_type); - /* - * It's not clear whether we should reopen this each time, or - * just hold it open and rewind/truncate on each iteration. - * Leaving it alone for now. - */ - stats_logfp = fopen (stats_filename, "w+"); - if (stats_logfp) { - (void) ios_dump_args_init (&args, - conf->dump_format, - stats_logfp); - io_stats_dump (this, &args, GF_CLI_INFO_ALL, _gf_false); - fclose (stats_logfp); - log_stats_fopen_failure = _gf_true; - } else if (log_stats_fopen_failure) { - gf_log (this->name, GF_LOG_ERROR, - "could not open stats-dump file %s (%s)", - stats_filename, strerror(errno)); - log_stats_fopen_failure = _gf_false; - } - samples_logfp = fopen (samples_filename, "w+"); - if (samples_logfp) { - io_stats_dump_latency_samples_logfp (this, - samples_logfp); - fclose (samples_logfp); - log_samples_fopen_failure = _gf_true; - } else if (log_samples_fopen_failure) { - gf_log (this->name, GF_LOG_ERROR, - "could not open samples-dump file %s (%s)", - samples_filename, strerror(errno)); - log_samples_fopen_failure = _gf_false; - } + samples_logfp = fopen(samples_filename, "w+"); + if (samples_logfp) { + io_stats_dump_latency_samples_logfp(this, samples_logfp); + fclose(samples_logfp); + log_samples_fopen_failure = _gf_true; + } else if (log_samples_fopen_failure) { + gf_log(this->name, GF_LOG_ERROR, + "could not open samples-dump file %s (%s)", samples_filename, + strerror(errno)); + log_samples_fopen_failure = _gf_false; } + } out: - conf->dump_thread_running = _gf_false; - gf_log (this->name, GF_LOG_INFO, "IO stats dump thread terminated"); - return NULL; + conf->dump_thread_running = _gf_false; + gf_log(this->name, GF_LOG_INFO, "IO stats dump thread terminated"); + return NULL; } static gf_boolean_t -match_special_xattr (dict_t *d, char *k, data_t *val, void *mdata) +match_special_xattr(dict_t *d, char *k, data_t *val, void *mdata) { - gf_boolean_t ret = _gf_false; - if (fnmatch ("*io*stat*dump", k, 0) == 0) { - ret = _gf_true; - } + gf_boolean_t ret = _gf_false; + if (fnmatch("*io*stat*dump", k, 0) == 0) { + ret = _gf_true; + } - return ret; + return ret; } int -io_stats_setxattr (call_frame_t *frame, xlator_t *this, - loc_t *loc, dict_t *dict, - int32_t flags, dict_t *xdata) +io_stats_setxattr(call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *dict, + int32_t flags, dict_t *xdata) { - struct { - xlator_t *this; - inode_t *inode; - const char *path; - } stub; + struct { + xlator_t *this; + inode_t *inode; + const char *path; + } stub; - stub.this = this; - stub.inode = loc->inode; - stub.path = loc->path; + stub.this = this; + stub.inode = loc->inode; + stub.path = loc->path; - (void) dict_foreach_match (dict, match_special_xattr, NULL, - conditional_dump, &stub); + (void)dict_foreach_match(dict, match_special_xattr, NULL, conditional_dump, + &stub); - START_FOP_LATENCY (frame); + START_FOP_LATENCY(frame); - STACK_WIND (frame, io_stats_setxattr_cbk, - FIRST_CHILD(this), - FIRST_CHILD(this)->fops->setxattr, - loc, dict, flags, xdata); - return 0; + STACK_WIND(frame, io_stats_setxattr_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->setxattr, loc, dict, flags, xdata); + return 0; } - int -io_stats_getxattr (call_frame_t *frame, xlator_t *this, - loc_t *loc, const char *name, dict_t *xdata) +io_stats_getxattr(call_frame_t *frame, xlator_t *this, loc_t *loc, + const char *name, dict_t *xdata) { - START_FOP_LATENCY (frame); + START_FOP_LATENCY(frame); - STACK_WIND (frame, io_stats_getxattr_cbk, - FIRST_CHILD(this), - FIRST_CHILD(this)->fops->getxattr, - loc, name, xdata); - return 0; + STACK_WIND(frame, io_stats_getxattr_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->getxattr, loc, name, xdata); + return 0; } - int -io_stats_removexattr (call_frame_t *frame, xlator_t *this, - loc_t *loc, const char *name, dict_t *xdata) +io_stats_removexattr(call_frame_t *frame, xlator_t *this, loc_t *loc, + const char *name, dict_t *xdata) { - START_FOP_LATENCY (frame); + START_FOP_LATENCY(frame); - STACK_WIND (frame, io_stats_removexattr_cbk, - FIRST_CHILD(this), - FIRST_CHILD(this)->fops->removexattr, - loc, name, xdata); - return 0; + STACK_WIND(frame, io_stats_removexattr_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->removexattr, loc, name, xdata); + return 0; } - int -io_stats_fsetxattr (call_frame_t *frame, xlator_t *this, - fd_t *fd, dict_t *dict, - int32_t flags, dict_t *xdata) +io_stats_fsetxattr(call_frame_t *frame, xlator_t *this, fd_t *fd, dict_t *dict, + int32_t flags, dict_t *xdata) { - START_FOP_LATENCY (frame); + START_FOP_LATENCY(frame); - STACK_WIND (frame, io_stats_fsetxattr_cbk, - FIRST_CHILD(this), - FIRST_CHILD(this)->fops->fsetxattr, - fd, dict, flags, xdata); - return 0; + STACK_WIND(frame, io_stats_fsetxattr_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->fsetxattr, fd, dict, flags, xdata); + return 0; } - int -io_stats_fgetxattr (call_frame_t *frame, xlator_t *this, - fd_t *fd, const char *name, dict_t *xdata) +io_stats_fgetxattr(call_frame_t *frame, xlator_t *this, fd_t *fd, + const char *name, dict_t *xdata) { - START_FOP_LATENCY (frame); + START_FOP_LATENCY(frame); - STACK_WIND (frame, io_stats_fgetxattr_cbk, - FIRST_CHILD(this), - FIRST_CHILD(this)->fops->fgetxattr, - fd, name, xdata); - return 0; + STACK_WIND(frame, io_stats_fgetxattr_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->fgetxattr, fd, name, xdata); + return 0; } - int -io_stats_fremovexattr (call_frame_t *frame, xlator_t *this, - fd_t *fd, const char *name, dict_t *xdata) +io_stats_fremovexattr(call_frame_t *frame, xlator_t *this, fd_t *fd, + const char *name, dict_t *xdata) { - START_FOP_LATENCY (frame); + START_FOP_LATENCY(frame); - STACK_WIND (frame, io_stats_fremovexattr_cbk, - FIRST_CHILD(this), - FIRST_CHILD(this)->fops->fremovexattr, - fd, name, xdata); - return 0; + STACK_WIND(frame, io_stats_fremovexattr_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->fremovexattr, fd, name, xdata); + return 0; } - int -io_stats_opendir (call_frame_t *frame, xlator_t *this, - loc_t *loc, fd_t *fd, dict_t *xdata) +io_stats_opendir(call_frame_t *frame, xlator_t *this, loc_t *loc, fd_t *fd, + dict_t *xdata) { + START_FOP_LATENCY(frame); - START_FOP_LATENCY (frame); - - STACK_WIND (frame, io_stats_opendir_cbk, - FIRST_CHILD(this), - FIRST_CHILD(this)->fops->opendir, - loc, fd, xdata); - return 0; + STACK_WIND(frame, io_stats_opendir_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->opendir, loc, fd, xdata); + return 0; } int -io_stats_readdirp (call_frame_t *frame, xlator_t *this, fd_t *fd, size_t size, - off_t offset, dict_t *dict) +io_stats_readdirp(call_frame_t *frame, xlator_t *this, fd_t *fd, size_t size, + off_t offset, dict_t *dict) { - frame->local = fd->inode; - START_FOP_LATENCY (frame); + frame->local = fd->inode; + START_FOP_LATENCY(frame); - STACK_WIND (frame, io_stats_readdirp_cbk, - FIRST_CHILD(this), - FIRST_CHILD(this)->fops->readdirp, - fd, size, offset, dict); - return 0; + STACK_WIND(frame, io_stats_readdirp_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->readdirp, fd, size, offset, dict); + return 0; } - int -io_stats_readdir (call_frame_t *frame, xlator_t *this, - fd_t *fd, size_t size, off_t offset, dict_t *xdata) +io_stats_readdir(call_frame_t *frame, xlator_t *this, fd_t *fd, size_t size, + off_t offset, dict_t *xdata) { - START_FOP_LATENCY (frame); + START_FOP_LATENCY(frame); - STACK_WIND (frame, io_stats_readdir_cbk, - FIRST_CHILD(this), - FIRST_CHILD(this)->fops->readdir, - fd, size, offset, xdata); - return 0; + STACK_WIND(frame, io_stats_readdir_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->readdir, fd, size, offset, xdata); + return 0; } - int -io_stats_fsyncdir (call_frame_t *frame, xlator_t *this, - fd_t *fd, int32_t datasync, dict_t *xdata) +io_stats_fsyncdir(call_frame_t *frame, xlator_t *this, fd_t *fd, + int32_t datasync, dict_t *xdata) { - START_FOP_LATENCY (frame); + START_FOP_LATENCY(frame); - STACK_WIND (frame, io_stats_fsyncdir_cbk, - FIRST_CHILD(this), - FIRST_CHILD(this)->fops->fsyncdir, - fd, datasync, xdata); - return 0; + STACK_WIND(frame, io_stats_fsyncdir_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->fsyncdir, fd, datasync, xdata); + return 0; } - int -io_stats_access (call_frame_t *frame, xlator_t *this, - loc_t *loc, int32_t mask, dict_t *xdata) +io_stats_access(call_frame_t *frame, xlator_t *this, loc_t *loc, int32_t mask, + dict_t *xdata) { - START_FOP_LATENCY (frame); + START_FOP_LATENCY(frame); - STACK_WIND (frame, io_stats_access_cbk, - FIRST_CHILD(this), - FIRST_CHILD(this)->fops->access, - loc, mask, xdata); - return 0; + STACK_WIND(frame, io_stats_access_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->access, loc, mask, xdata); + return 0; } - int -io_stats_ftruncate (call_frame_t *frame, xlator_t *this, - fd_t *fd, off_t offset, dict_t *xdata) +io_stats_ftruncate(call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset, + dict_t *xdata) { - START_FOP_LATENCY (frame); + START_FOP_LATENCY(frame); - STACK_WIND (frame, io_stats_ftruncate_cbk, - FIRST_CHILD(this), - FIRST_CHILD(this)->fops->ftruncate, - fd, offset, xdata); - return 0; + STACK_WIND(frame, io_stats_ftruncate_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->ftruncate, fd, offset, xdata); + return 0; } - int -io_stats_fsetattr (call_frame_t *frame, xlator_t *this, - fd_t *fd, struct iatt *stbuf, int32_t valid, dict_t *xdata) +io_stats_fsetattr(call_frame_t *frame, xlator_t *this, fd_t *fd, + struct iatt *stbuf, int32_t valid, dict_t *xdata) { - START_FOP_LATENCY (frame); + START_FOP_LATENCY(frame); - STACK_WIND (frame, io_stats_setattr_cbk, - FIRST_CHILD(this), - FIRST_CHILD(this)->fops->fsetattr, - fd, stbuf, valid, xdata); - return 0; + STACK_WIND(frame, io_stats_setattr_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->fsetattr, fd, stbuf, valid, xdata); + return 0; } - int -io_stats_fstat (call_frame_t *frame, xlator_t *this, - fd_t *fd, dict_t *xdata) +io_stats_fstat(call_frame_t *frame, xlator_t *this, fd_t *fd, dict_t *xdata) { - START_FOP_LATENCY (frame); + START_FOP_LATENCY(frame); - STACK_WIND (frame, io_stats_fstat_cbk, - FIRST_CHILD(this), - FIRST_CHILD(this)->fops->fstat, - fd, xdata); - return 0; + STACK_WIND(frame, io_stats_fstat_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->fstat, fd, xdata); + return 0; } - int io_stats_fallocate(call_frame_t *frame, xlator_t *this, fd_t *fd, int32_t mode, - off_t offset, size_t len, dict_t *xdata) + off_t offset, size_t len, dict_t *xdata) { - START_FOP_LATENCY(frame); + START_FOP_LATENCY(frame); - STACK_WIND(frame, io_stats_fallocate_cbk, FIRST_CHILD(this), - FIRST_CHILD(this)->fops->fallocate, fd, mode, offset, len, - xdata); + STACK_WIND(frame, io_stats_fallocate_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->fallocate, fd, mode, offset, len, + xdata); - return 0; + return 0; } - int io_stats_discard(call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset, - size_t len, dict_t *xdata) + size_t len, dict_t *xdata) { - START_FOP_LATENCY(frame); + START_FOP_LATENCY(frame); - STACK_WIND(frame, io_stats_discard_cbk, FIRST_CHILD(this), - FIRST_CHILD(this)->fops->discard, fd, offset, len, xdata); + STACK_WIND(frame, io_stats_discard_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->discard, fd, offset, len, xdata); - return 0; + return 0; } int io_stats_zerofill(call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset, - off_t len, dict_t *xdata) + off_t len, dict_t *xdata) { - START_FOP_LATENCY(frame); + START_FOP_LATENCY(frame); - STACK_WIND(frame, io_stats_zerofill_cbk, FIRST_CHILD(this), - FIRST_CHILD(this)->fops->zerofill, fd, offset, len, xdata); + STACK_WIND(frame, io_stats_zerofill_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->zerofill, fd, offset, len, xdata); - return 0; + return 0; } int32_t -io_stats_ipc (call_frame_t *frame, xlator_t *this, int32_t op, dict_t *xdata) +io_stats_ipc(call_frame_t *frame, xlator_t *this, int32_t op, dict_t *xdata) { - START_FOP_LATENCY(frame); + START_FOP_LATENCY(frame); - STACK_WIND (frame, io_stats_ipc_cbk, FIRST_CHILD(this), - FIRST_CHILD(this)->fops->ipc, op, xdata); - return 0; + STACK_WIND(frame, io_stats_ipc_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->ipc, op, xdata); + return 0; } int -io_stats_lk (call_frame_t *frame, xlator_t *this, - fd_t *fd, int32_t cmd, struct gf_flock *lock, dict_t *xdata) +io_stats_lk(call_frame_t *frame, xlator_t *this, fd_t *fd, int32_t cmd, + struct gf_flock *lock, dict_t *xdata) { - START_FOP_LATENCY (frame); + START_FOP_LATENCY(frame); - STACK_WIND (frame, io_stats_lk_cbk, - FIRST_CHILD(this), - FIRST_CHILD(this)->fops->lk, - fd, cmd, lock, xdata); - return 0; + STACK_WIND(frame, io_stats_lk_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->lk, fd, cmd, lock, xdata); + return 0; } int -io_stats_rchecksum (call_frame_t *frame, xlator_t *this, - fd_t *fd, off_t offset, int32_t len, dict_t *xdata) +io_stats_rchecksum(call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset, + int32_t len, dict_t *xdata) { - START_FOP_LATENCY (frame); + START_FOP_LATENCY(frame); - STACK_WIND (frame, io_stats_rchecksum_cbk, - FIRST_CHILD(this), - FIRST_CHILD(this)->fops->rchecksum, - fd, offset, len, xdata); - return 0; + STACK_WIND(frame, io_stats_rchecksum_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->rchecksum, fd, offset, len, xdata); + return 0; } int -io_stats_seek (call_frame_t *frame, xlator_t *this, fd_t *fd, - off_t offset, gf_seek_what_t what, dict_t *xdata) +io_stats_seek(call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset, + gf_seek_what_t what, dict_t *xdata) { - START_FOP_LATENCY (frame); + START_FOP_LATENCY(frame); - STACK_WIND (frame, io_stats_seek_cbk, - FIRST_CHILD(this), - FIRST_CHILD(this)->fops->seek, - fd, offset, what, xdata); - return 0; + STACK_WIND(frame, io_stats_seek_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->seek, fd, offset, what, xdata); + return 0; } int -io_stats_lease (call_frame_t *frame, xlator_t *this, loc_t *loc, - struct gf_lease *lease, dict_t *xdata) +io_stats_lease(call_frame_t *frame, xlator_t *this, loc_t *loc, + struct gf_lease *lease, dict_t *xdata) { - START_FOP_LATENCY (frame); + START_FOP_LATENCY(frame); - STACK_WIND (frame, io_stats_lease_cbk, - FIRST_CHILD(this), - FIRST_CHILD(this)->fops->lease, - loc, lease, xdata); - return 0; + STACK_WIND(frame, io_stats_lease_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->lease, loc, lease, xdata); + return 0; } int -io_stats_getactivelk (call_frame_t *frame, xlator_t *this, loc_t *loc, - dict_t *xdata) +io_stats_getactivelk(call_frame_t *frame, xlator_t *this, loc_t *loc, + dict_t *xdata) { - START_FOP_LATENCY (frame); + START_FOP_LATENCY(frame); - STACK_WIND (frame, io_stats_getactivelk_cbk, - FIRST_CHILD(this), - FIRST_CHILD(this)->fops->getactivelk, - loc, xdata); - return 0; + STACK_WIND(frame, io_stats_getactivelk_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->getactivelk, loc, xdata); + return 0; } int -io_stats_setactivelk (call_frame_t *frame, xlator_t *this, loc_t *loc, - lock_migration_info_t *locklist, dict_t *xdata) +io_stats_setactivelk(call_frame_t *frame, xlator_t *this, loc_t *loc, + lock_migration_info_t *locklist, dict_t *xdata) { - START_FOP_LATENCY (frame); + START_FOP_LATENCY(frame); - STACK_WIND (frame, io_stats_setactivelk_cbk, - FIRST_CHILD(this), - FIRST_CHILD(this)->fops->setactivelk, - loc, locklist, xdata); - return 0; + STACK_WIND(frame, io_stats_setactivelk_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->setactivelk, loc, locklist, xdata); + return 0; } int -io_stats_compound (call_frame_t *frame, xlator_t *this, - void *args, dict_t *xdata) +io_stats_compound(call_frame_t *frame, xlator_t *this, void *args, + dict_t *xdata) { - START_FOP_LATENCY (frame); + START_FOP_LATENCY(frame); - STACK_WIND (frame, io_stats_compound_cbk, - FIRST_CHILD(this), - FIRST_CHILD(this)->fops->compound, - args, xdata); - return 0; + STACK_WIND(frame, io_stats_compound_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->compound, args, xdata); + return 0; } int -io_stats_release (xlator_t *this, fd_t *fd) +io_stats_release(xlator_t *this, fd_t *fd) { - struct ios_fd *iosfd = NULL; - struct ios_conf *conf = NULL; + struct ios_fd *iosfd = NULL; + struct ios_conf *conf = NULL; - BUMP_FOP (RELEASE); + BUMP_FOP(RELEASE); - conf = this->private; + conf = this->private; - LOCK (&conf->lock); - { - conf->cumulative.nr_opens--; - } - UNLOCK (&conf->lock); + LOCK(&conf->lock); + { + conf->cumulative.nr_opens--; + } + UNLOCK(&conf->lock); - ios_fd_ctx_get (fd, this, &iosfd); - if (iosfd) { - io_stats_dump_fd (this, iosfd); + ios_fd_ctx_get(fd, this, &iosfd); + if (iosfd) { + io_stats_dump_fd(this, iosfd); - GF_FREE (iosfd->filename); - GF_FREE (iosfd); - } + GF_FREE(iosfd->filename); + GF_FREE(iosfd); + } - return 0; + return 0; } - int -io_stats_releasedir (xlator_t *this, fd_t *fd) +io_stats_releasedir(xlator_t *this, fd_t *fd) { - BUMP_FOP (RELEASEDIR); + BUMP_FOP(RELEASEDIR); - return 0; + return 0; } - int -io_stats_forget (xlator_t *this, inode_t *inode) +io_stats_forget(xlator_t *this, inode_t *inode) { - BUMP_FOP (FORGET); - ios_stats_cleanup (this, inode); - return 0; + BUMP_FOP(FORGET); + ios_stats_cleanup(this, inode); + return 0; } static int -ios_init_top_stats (struct ios_conf *conf) +ios_init_top_stats(struct ios_conf *conf) { - int i = 0; + int i = 0; - GF_ASSERT (conf); + GF_ASSERT(conf); - for (i = 0; i <IOS_STATS_TYPE_MAX; i++) { - conf->list[i].iosstats = GF_CALLOC (1, - sizeof(*conf->list[i].iosstats), - gf_io_stats_mt_ios_stat); + for (i = 0; i < IOS_STATS_TYPE_MAX; i++) { + conf->list[i].iosstats = GF_CALLOC(1, sizeof(*conf->list[i].iosstats), + gf_io_stats_mt_ios_stat); - if (!conf->list[i].iosstats) - return -1; + if (!conf->list[i].iosstats) + return -1; - INIT_LIST_HEAD(&conf->list[i].iosstats->list); - LOCK_INIT (&conf->list[i].lock); - } + INIT_LIST_HEAD(&conf->list[i].iosstats->list); + LOCK_INIT(&conf->list[i].lock); + } - for (i = 0; i < IOS_STATS_THRU_MAX; i ++) { - conf->thru_list[i].iosstats = GF_CALLOC (1, - sizeof (*conf->thru_list[i].iosstats), - gf_io_stats_mt_ios_stat); + for (i = 0; i < IOS_STATS_THRU_MAX; i++) { + conf->thru_list[i].iosstats = GF_CALLOC( + 1, sizeof(*conf->thru_list[i].iosstats), gf_io_stats_mt_ios_stat); - if (!conf->thru_list[i].iosstats) - return -1; + if (!conf->thru_list[i].iosstats) + return -1; - INIT_LIST_HEAD(&conf->thru_list[i].iosstats->list); - LOCK_INIT (&conf->thru_list[i].lock); - } + INIT_LIST_HEAD(&conf->thru_list[i].iosstats->list); + LOCK_INIT(&conf->thru_list[i].lock); + } - return 0; + return 0; } static void -ios_destroy_top_stats (struct ios_conf *conf) -{ - int i = 0; - struct ios_stat_head *list_head = NULL; - struct ios_stat_list *entry = NULL; - struct ios_stat_list *tmp = NULL; - struct ios_stat_list *list = NULL; - struct ios_stat *stat = NULL; - - GF_ASSERT (conf); - - LOCK (&conf->lock); - - conf->cumulative.nr_opens = 0; - conf->cumulative.max_nr_opens = 0; - conf->cumulative.max_openfd_time.tv_sec = 0; - conf->cumulative.max_openfd_time.tv_usec = 0; - - for (i = 0; i < IOS_STATS_TYPE_MAX; i++) { - list_head = &conf->list[i]; - if (!list_head) - continue; - list_for_each_entry_safe (entry, tmp, - &list_head->iosstats->list, list) { - list = entry; - stat = list->iosstat; - ios_stat_unref (stat); - list_del (&list->list); - GF_FREE (list); - list_head->members--; - } - GF_FREE (list_head->iosstats); - } +ios_destroy_top_stats(struct ios_conf *conf) +{ + int i = 0; + struct ios_stat_head *list_head = NULL; + struct ios_stat_list *entry = NULL; + struct ios_stat_list *tmp = NULL; + struct ios_stat_list *list = NULL; + struct ios_stat *stat = NULL; - for (i = 0; i < IOS_STATS_THRU_MAX; i++) { - list_head = &conf->thru_list[i]; - if (!list_head) - continue; - list_for_each_entry_safe (entry, tmp, - &list_head->iosstats->list, list) { - list = entry; - stat = list->iosstat; - ios_stat_unref (stat); - list_del (&list->list); - GF_FREE (list); - list_head->members--; - } - GF_FREE (list_head->iosstats); + GF_ASSERT(conf); + + LOCK(&conf->lock); + + conf->cumulative.nr_opens = 0; + conf->cumulative.max_nr_opens = 0; + conf->cumulative.max_openfd_time.tv_sec = 0; + conf->cumulative.max_openfd_time.tv_usec = 0; + + for (i = 0; i < IOS_STATS_TYPE_MAX; i++) { + list_head = &conf->list[i]; + if (!list_head) + continue; + list_for_each_entry_safe(entry, tmp, &list_head->iosstats->list, list) + { + list = entry; + stat = list->iosstat; + ios_stat_unref(stat); + list_del(&list->list); + GF_FREE(list); + list_head->members--; + } + GF_FREE(list_head->iosstats); + } + + for (i = 0; i < IOS_STATS_THRU_MAX; i++) { + list_head = &conf->thru_list[i]; + if (!list_head) + continue; + list_for_each_entry_safe(entry, tmp, &list_head->iosstats->list, list) + { + list = entry; + stat = list->iosstat; + ios_stat_unref(stat); + list_del(&list->list); + GF_FREE(list); + list_head->members--; } + GF_FREE(list_head->iosstats); + } - UNLOCK (&conf->lock); + UNLOCK(&conf->lock); - return; + return; } static int -io_stats_clear (struct ios_conf *conf) +io_stats_clear(struct ios_conf *conf) { - struct timeval now; - int ret = -1; + struct timeval now; + int ret = -1; - GF_ASSERT (conf); + GF_ASSERT(conf); - if (!gettimeofday (&now, NULL)) + if (!gettimeofday(&now, NULL)) { + LOCK(&conf->lock); { - LOCK (&conf->lock); - { - ios_global_stats_clear (&conf->cumulative, &now); - ios_global_stats_clear (&conf->incremental, &now); - conf->increment = 0; - } - UNLOCK (&conf->lock); - ret = 0; + ios_global_stats_clear(&conf->cumulative, &now); + ios_global_stats_clear(&conf->incremental, &now); + conf->increment = 0; } + UNLOCK(&conf->lock); + ret = 0; + } - return ret; + return ret; } int32_t -io_priv (xlator_t *this) -{ - int i; - char key[GF_DUMP_MAX_BUF_LEN]; - char key_prefix_cumulative[GF_DUMP_MAX_BUF_LEN]; - char key_prefix_incremental[GF_DUMP_MAX_BUF_LEN]; - double min, max, avg; - uint64_t count, total; - struct ios_conf *conf = NULL; - - conf = this->private; - if (!conf) - return -1; - - if(!conf->count_fop_hits || !conf->measure_latency) - return -1; - - gf_proc_dump_write ("cumulative.data_read", "%"GF_PRI_ATOMIC, - GF_ATOMIC_GET (conf->cumulative.data_read)); - gf_proc_dump_write ("cumulative.data_written", "%"GF_PRI_ATOMIC, - GF_ATOMIC_GET (conf->cumulative.data_written)); - - gf_proc_dump_write ("incremental.data_read", "%"GF_PRI_ATOMIC, - GF_ATOMIC_GET (conf->incremental.data_read)); - gf_proc_dump_write ("incremental.data_written", "%"GF_PRI_ATOMIC, - GF_ATOMIC_GET (conf->incremental.data_written)); - - snprintf (key_prefix_cumulative, GF_DUMP_MAX_BUF_LEN, "%s.cumulative", - this->name); - snprintf (key_prefix_incremental, GF_DUMP_MAX_BUF_LEN, "%s.incremental", - this->name); - - for (i = 0; i < GF_FOP_MAXVALUE; i++) { - count = GF_ATOMIC_GET (conf->cumulative.fop_hits[i]); - total = conf->cumulative.latency[i].total; - min = conf->cumulative.latency[i].min; - max = conf->cumulative.latency[i].max; - avg = conf->cumulative.latency[i].avg; - - gf_proc_dump_build_key (key, key_prefix_cumulative, "%s", - (char *)gf_fop_list[i]); - - gf_proc_dump_write (key,"%"PRId64",%"PRId64",%.03f,%.03f,%.03f", - count, total, min, max, avg); - - count = GF_ATOMIC_GET (conf->incremental.fop_hits[i]); - total = conf->incremental.latency[i].total; - min = conf->incremental.latency[i].min; - max = conf->incremental.latency[i].max; - avg = conf->incremental.latency[i].avg; - - gf_proc_dump_build_key (key, key_prefix_incremental, "%s", - (char *)gf_fop_list[i]); - - gf_proc_dump_write (key,"%"PRId64",%"PRId64",%.03f,%.03f,%.03f", - count, total, min, max, avg); +io_priv(xlator_t *this) +{ + int i; + char key[GF_DUMP_MAX_BUF_LEN]; + char key_prefix_cumulative[GF_DUMP_MAX_BUF_LEN]; + char key_prefix_incremental[GF_DUMP_MAX_BUF_LEN]; + double min, max, avg; + uint64_t count, total; + struct ios_conf *conf = NULL; - } + conf = this->private; + if (!conf) + return -1; - return 0; -} + if (!conf->count_fop_hits || !conf->measure_latency) + return -1; -static void -ios_set_log_format_code (struct ios_conf *conf) -{ - if (strcmp (conf->dump_format_str, "json") == 0) - conf->dump_format = IOS_DUMP_TYPE_JSON_FILE; - else if (strcmp (conf->dump_format_str, "text") == 0) - conf->dump_format = IOS_DUMP_TYPE_FILE; - else if (strcmp (conf->dump_format_str, "dict") == 0) - conf->dump_format = IOS_DUMP_TYPE_DICT; - else if (strcmp (conf->dump_format_str, "samples") == 0) - conf->dump_format = IOS_DUMP_TYPE_SAMPLES; -} + gf_proc_dump_write("cumulative.data_read", "%" GF_PRI_ATOMIC, + GF_ATOMIC_GET(conf->cumulative.data_read)); + gf_proc_dump_write("cumulative.data_written", "%" GF_PRI_ATOMIC, + GF_ATOMIC_GET(conf->cumulative.data_written)); -int -reconfigure (xlator_t *this, dict_t *options) -{ - struct ios_conf *conf = NULL; - int ret = -1; - char *sys_log_str = NULL; - char *log_format_str = NULL; - char *logger_str = NULL; - int sys_log_level = -1; - char *log_str = NULL; - int log_level = -1; - int log_format = -1; - int logger = -1; - uint32_t log_buf_size = 0; - uint32_t log_flush_timeout = 0; - int32_t old_dump_interval; - - if (!this || !this->private) - goto out; + gf_proc_dump_write("incremental.data_read", "%" GF_PRI_ATOMIC, + GF_ATOMIC_GET(conf->incremental.data_read)); + gf_proc_dump_write("incremental.data_written", "%" GF_PRI_ATOMIC, + GF_ATOMIC_GET(conf->incremental.data_written)); - conf = this->private; + snprintf(key_prefix_cumulative, GF_DUMP_MAX_BUF_LEN, "%s.cumulative", + this->name); + snprintf(key_prefix_incremental, GF_DUMP_MAX_BUF_LEN, "%s.incremental", + this->name); - GF_OPTION_RECONF ("dump-fd-stats", conf->dump_fd_stats, options, bool, - out); + for (i = 0; i < GF_FOP_MAXVALUE; i++) { + count = GF_ATOMIC_GET(conf->cumulative.fop_hits[i]); + total = conf->cumulative.latency[i].total; + min = conf->cumulative.latency[i].min; + max = conf->cumulative.latency[i].max; + avg = conf->cumulative.latency[i].avg; - GF_OPTION_RECONF ("count-fop-hits", conf->count_fop_hits, options, bool, - out); + gf_proc_dump_build_key(key, key_prefix_cumulative, "%s", + (char *)gf_fop_list[i]); - GF_OPTION_RECONF ("latency-measurement", conf->measure_latency, - options, bool, out); + gf_proc_dump_write(key, "%" PRId64 ",%" PRId64 ",%.03f,%.03f,%.03f", + count, total, min, max, avg); - old_dump_interval = conf->ios_dump_interval; - GF_OPTION_RECONF ("ios-dump-interval", conf->ios_dump_interval, options, - int32, out); - if ((old_dump_interval <= 0) && (conf->ios_dump_interval > 0)) { - conf->dump_thread_running = _gf_true; - conf->dump_thread_should_die = _gf_false; - ret = gf_thread_create (&conf->dump_thread, NULL, - (void *) &_ios_dump_thread, this, "iosdump"); - if (ret) { - conf->dump_thread_running = _gf_false; - gf_log (this ? this->name : "io-stats", - GF_LOG_ERROR, "Failed to start thread" - "while reconfigure. Returning %d", ret); - goto out; - } - } else if ((old_dump_interval > 0) && (conf->ios_dump_interval == 0)) { - _ios_destroy_dump_thread (conf); - } + count = GF_ATOMIC_GET(conf->incremental.fop_hits[i]); + total = conf->incremental.latency[i].total; + min = conf->incremental.latency[i].min; + max = conf->incremental.latency[i].max; + avg = conf->incremental.latency[i].avg; - GF_OPTION_RECONF ("ios-sample-interval", conf->ios_sample_interval, - options, int32, out); - GF_OPTION_RECONF ("ios-dump-format", conf->dump_format_str, options, - str, out); - ios_set_log_format_code (conf); - GF_OPTION_RECONF ("ios-sample-buf-size", conf->ios_sample_buf_size, - options, int32, out); - GF_OPTION_RECONF ("sys-log-level", sys_log_str, options, str, out); - if (sys_log_str) { - sys_log_level = glusterd_check_log_level (sys_log_str); - set_sys_log_level (sys_log_level); - } + gf_proc_dump_build_key(key, key_prefix_incremental, "%s", + (char *)gf_fop_list[i]); - GF_OPTION_RECONF ("log-level", log_str, options, str, out); - if (log_str) { - log_level = glusterd_check_log_level (log_str); - gf_log_set_loglevel (this->ctx, log_level); - } + gf_proc_dump_write(key, "%" PRId64 ",%" PRId64 ",%.03f,%.03f,%.03f", + count, total, min, max, avg); + } - GF_OPTION_RECONF ("logger", logger_str, options, str, out); - if (logger_str) { - logger = gf_check_logger (logger_str); - gf_log_set_logger (logger); - } + return 0; +} - GF_OPTION_RECONF ("log-format", log_format_str, options, str, out); - if (log_format_str) { - log_format = gf_check_log_format (log_format_str); - gf_log_set_logformat (log_format); - } +static void +ios_set_log_format_code(struct ios_conf *conf) +{ + if (strcmp(conf->dump_format_str, "json") == 0) + conf->dump_format = IOS_DUMP_TYPE_JSON_FILE; + else if (strcmp(conf->dump_format_str, "text") == 0) + conf->dump_format = IOS_DUMP_TYPE_FILE; + else if (strcmp(conf->dump_format_str, "dict") == 0) + conf->dump_format = IOS_DUMP_TYPE_DICT; + else if (strcmp(conf->dump_format_str, "samples") == 0) + conf->dump_format = IOS_DUMP_TYPE_SAMPLES; +} + +int +reconfigure(xlator_t *this, dict_t *options) +{ + struct ios_conf *conf = NULL; + int ret = -1; + char *sys_log_str = NULL; + char *log_format_str = NULL; + char *logger_str = NULL; + int sys_log_level = -1; + char *log_str = NULL; + int log_level = -1; + int log_format = -1; + int logger = -1; + uint32_t log_buf_size = 0; + uint32_t log_flush_timeout = 0; + int32_t old_dump_interval; + + if (!this || !this->private) + goto out; - GF_OPTION_RECONF ("log-buf-size", log_buf_size, options, uint32, out); - gf_log_set_log_buf_size (log_buf_size); + conf = this->private; - GF_OPTION_RECONF ("log-flush-timeout", log_flush_timeout, options, - time, out); - gf_log_set_log_flush_timeout (log_flush_timeout); + GF_OPTION_RECONF("dump-fd-stats", conf->dump_fd_stats, options, bool, out); - ret = 0; + GF_OPTION_RECONF("count-fop-hits", conf->count_fop_hits, options, bool, + out); + + GF_OPTION_RECONF("latency-measurement", conf->measure_latency, options, + bool, out); + + old_dump_interval = conf->ios_dump_interval; + GF_OPTION_RECONF("ios-dump-interval", conf->ios_dump_interval, options, + int32, out); + if ((old_dump_interval <= 0) && (conf->ios_dump_interval > 0)) { + conf->dump_thread_running = _gf_true; + conf->dump_thread_should_die = _gf_false; + ret = gf_thread_create(&conf->dump_thread, NULL, + (void *)&_ios_dump_thread, this, "iosdump"); + if (ret) { + conf->dump_thread_running = _gf_false; + gf_log(this ? this->name : "io-stats", GF_LOG_ERROR, + "Failed to start thread" + "while reconfigure. Returning %d", + ret); + goto out; + } + } else if ((old_dump_interval > 0) && (conf->ios_dump_interval == 0)) { + _ios_destroy_dump_thread(conf); + } + + GF_OPTION_RECONF("ios-sample-interval", conf->ios_sample_interval, options, + int32, out); + GF_OPTION_RECONF("ios-dump-format", conf->dump_format_str, options, str, + out); + ios_set_log_format_code(conf); + GF_OPTION_RECONF("ios-sample-buf-size", conf->ios_sample_buf_size, options, + int32, out); + GF_OPTION_RECONF("sys-log-level", sys_log_str, options, str, out); + if (sys_log_str) { + sys_log_level = glusterd_check_log_level(sys_log_str); + set_sys_log_level(sys_log_level); + } + + GF_OPTION_RECONF("log-level", log_str, options, str, out); + if (log_str) { + log_level = glusterd_check_log_level(log_str); + gf_log_set_loglevel(this->ctx, log_level); + } + + GF_OPTION_RECONF("logger", logger_str, options, str, out); + if (logger_str) { + logger = gf_check_logger(logger_str); + gf_log_set_logger(logger); + } + + GF_OPTION_RECONF("log-format", log_format_str, options, str, out); + if (log_format_str) { + log_format = gf_check_log_format(log_format_str); + gf_log_set_logformat(log_format); + } + + GF_OPTION_RECONF("log-buf-size", log_buf_size, options, uint32, out); + gf_log_set_log_buf_size(log_buf_size); + + GF_OPTION_RECONF("log-flush-timeout", log_flush_timeout, options, time, + out); + gf_log_set_log_flush_timeout(log_flush_timeout); + + ret = 0; out: - gf_log (this ? this->name : "io-stats", - GF_LOG_DEBUG, "reconfigure returning %d", ret); - return ret; + gf_log(this ? this->name : "io-stats", GF_LOG_DEBUG, + "reconfigure returning %d", ret); + return ret; } - int32_t -mem_acct_init (xlator_t *this) +mem_acct_init(xlator_t *this) { - int ret = -1; + int ret = -1; - if (!this) - return ret; + if (!this) + return ret; - ret = xlator_mem_acct_init (this, gf_io_stats_mt_end + 1); - - if (ret != 0) { - gf_log (this->name, GF_LOG_ERROR, "Memory accounting init" - " failed"); - return ret; - } + ret = xlator_mem_acct_init(this, gf_io_stats_mt_end + 1); + if (ret != 0) { + gf_log(this->name, GF_LOG_ERROR, + "Memory accounting init" + " failed"); return ret; + } + + return ret; } void -ios_conf_destroy (struct ios_conf *conf) +ios_conf_destroy(struct ios_conf *conf) { - if (!conf) - return; + if (!conf) + return; - ios_destroy_top_stats (conf); - _ios_destroy_dump_thread (conf); - ios_destroy_sample_buf (conf->ios_sample_buf); - LOCK_DESTROY (&conf->lock); - GF_FREE(conf->dnscache); - GF_FREE(conf); + ios_destroy_top_stats(conf); + _ios_destroy_dump_thread(conf); + ios_destroy_sample_buf(conf->ios_sample_buf); + LOCK_DESTROY(&conf->lock); + GF_FREE(conf->dnscache); + GF_FREE(conf); } static void -ios_init_stats (struct ios_global_stats *stats) +ios_init_stats(struct ios_global_stats *stats) { - int i = 0; + int i = 0; - GF_ATOMIC_INIT (stats->data_read, 0); - GF_ATOMIC_INIT (stats->data_written, 0); + GF_ATOMIC_INIT(stats->data_read, 0); + GF_ATOMIC_INIT(stats->data_written, 0); - for (i = 0; i < IOS_BLOCK_COUNT_SIZE; i++) { - GF_ATOMIC_INIT (stats->block_count_write[i], 0); - GF_ATOMIC_INIT (stats->block_count_read[i], 0); - } + for (i = 0; i < IOS_BLOCK_COUNT_SIZE; i++) { + GF_ATOMIC_INIT(stats->block_count_write[i], 0); + GF_ATOMIC_INIT(stats->block_count_read[i], 0); + } - for (i = 0; i < GF_FOP_MAXVALUE; i++) - GF_ATOMIC_INIT (stats->fop_hits[i], 0); + for (i = 0; i < GF_FOP_MAXVALUE; i++) + GF_ATOMIC_INIT(stats->fop_hits[i], 0); - for (i = 0; i < GF_UPCALL_FLAGS_MAXVALUE; i++) - GF_ATOMIC_INIT (stats->upcall_hits[i], 0); + for (i = 0; i < GF_UPCALL_FLAGS_MAXVALUE; i++) + GF_ATOMIC_INIT(stats->upcall_hits[i], 0); - gettimeofday (&stats->started_at, NULL); + gettimeofday(&stats->started_at, NULL); } int -init (xlator_t *this) -{ - struct ios_conf *conf = NULL; - char *sys_log_str = NULL; - char *logger_str = NULL; - char *log_format_str = NULL; - int logger = -1; - int log_format = -1; - int sys_log_level = -1; - char *log_str = NULL; - int log_level = -1; - int ret = -1; - uint32_t log_buf_size = 0; - uint32_t log_flush_timeout = 0; - - if (!this) - return -1; - - if (!this->children) { - gf_log (this->name, GF_LOG_ERROR, - "io_stats translator requires at least one subvolume"); - return -1; - } - - if (!this->parents) { - /* This is very much valid as io-stats currently is loaded - * on top of volumes on both client and server, hence this is - * not an warning message */ - gf_log (this->name, GF_LOG_DEBUG, - "dangling volume. check volfile "); - } - - conf = GF_CALLOC (1, sizeof(*conf), gf_io_stats_mt_ios_conf); - - if (!conf) - goto out; +init(xlator_t *this) +{ + struct ios_conf *conf = NULL; + char *sys_log_str = NULL; + char *logger_str = NULL; + char *log_format_str = NULL; + int logger = -1; + int log_format = -1; + int sys_log_level = -1; + char *log_str = NULL; + int log_level = -1; + int ret = -1; + uint32_t log_buf_size = 0; + uint32_t log_flush_timeout = 0; + + if (!this) + return -1; + + if (!this->children) { + gf_log(this->name, GF_LOG_ERROR, + "io_stats translator requires at least one subvolume"); + return -1; + } + + if (!this->parents) { + /* This is very much valid as io-stats currently is loaded + * on top of volumes on both client and server, hence this is + * not an warning message */ + gf_log(this->name, GF_LOG_DEBUG, "dangling volume. check volfile "); + } + + conf = GF_CALLOC(1, sizeof(*conf), gf_io_stats_mt_ios_conf); + + if (!conf) + goto out; - if (dict_get_str (this->options, "unique-id", &conf->unique_id) != 0) { - /* This is always set on servers, so we must be a client. */ - conf->unique_id = this->name; - } + if (dict_get_str(this->options, "unique-id", &conf->unique_id) != 0) { + /* This is always set on servers, so we must be a client. */ + conf->unique_id = this->name; + } - /* - * Init it just after calloc, so that we are sure the lock is inited - * in case of error paths. - */ - LOCK_INIT (&conf->lock); - LOCK_INIT (&conf->ios_sampling_lock); + /* + * Init it just after calloc, so that we are sure the lock is inited + * in case of error paths. + */ + LOCK_INIT(&conf->lock); + LOCK_INIT(&conf->ios_sampling_lock); - ios_init_stats (&conf->cumulative); - ios_init_stats (&conf->incremental); + ios_init_stats(&conf->cumulative); + ios_init_stats(&conf->incremental); - ret = ios_init_top_stats (conf); - if (ret) - goto out; + ret = ios_init_top_stats(conf); + if (ret) + goto out; - GF_OPTION_INIT ("dump-fd-stats", conf->dump_fd_stats, bool, out); + GF_OPTION_INIT("dump-fd-stats", conf->dump_fd_stats, bool, out); - GF_OPTION_INIT ("count-fop-hits", conf->count_fop_hits, bool, out); + GF_OPTION_INIT("count-fop-hits", conf->count_fop_hits, bool, out); - GF_OPTION_INIT ("latency-measurement", conf->measure_latency, - bool, out); + GF_OPTION_INIT("latency-measurement", conf->measure_latency, bool, out); - GF_OPTION_INIT ("ios-dump-interval", conf->ios_dump_interval, - int32, out); + GF_OPTION_INIT("ios-dump-interval", conf->ios_dump_interval, int32, out); - GF_OPTION_INIT ("ios-sample-interval", conf->ios_sample_interval, - int32, out); + GF_OPTION_INIT("ios-sample-interval", conf->ios_sample_interval, int32, + out); - GF_OPTION_INIT ("ios-dump-format", conf->dump_format_str, str, out); - ios_set_log_format_code (conf); + GF_OPTION_INIT("ios-dump-format", conf->dump_format_str, str, out); + ios_set_log_format_code(conf); - GF_OPTION_INIT ("ios-sample-buf-size", conf->ios_sample_buf_size, - int32, out); + GF_OPTION_INIT("ios-sample-buf-size", conf->ios_sample_buf_size, int32, + out); - ret = ios_init_sample_buf (conf); + ret = ios_init_sample_buf(conf); + if (ret) { + gf_log(this->name, GF_LOG_ERROR, "Out of memory."); + goto out; + } + + GF_OPTION_INIT("ios-dnscache-ttl-sec", conf->ios_dnscache_ttl_sec, int32, + out); + conf->dnscache = gf_dnscache_init(conf->ios_dnscache_ttl_sec); + + GF_OPTION_INIT("sys-log-level", sys_log_str, str, out); + if (sys_log_str) { + sys_log_level = glusterd_check_log_level(sys_log_str); + set_sys_log_level(sys_log_level); + } + + GF_OPTION_INIT("log-level", log_str, str, out); + if (log_str) { + log_level = glusterd_check_log_level(log_str); + if (DEFAULT_LOG_LEVEL != log_level) + gf_log_set_loglevel(this->ctx, log_level); + } + + GF_OPTION_INIT("logger", logger_str, str, out); + if (logger_str) { + logger = gf_check_logger(logger_str); + gf_log_set_logger(logger); + } + + GF_OPTION_INIT("log-format", log_format_str, str, out); + if (log_format_str) { + log_format = gf_check_log_format(log_format_str); + gf_log_set_logformat(log_format); + } + + GF_OPTION_INIT("log-buf-size", log_buf_size, uint32, out); + gf_log_set_log_buf_size(log_buf_size); + + GF_OPTION_INIT("log-flush-timeout", log_flush_timeout, time, out); + gf_log_set_log_flush_timeout(log_flush_timeout); + + this->private = conf; + if (conf->ios_dump_interval > 0) { + conf->dump_thread_running = _gf_true; + conf->dump_thread_should_die = _gf_false; + ret = gf_thread_create(&conf->dump_thread, NULL, + (void *)&_ios_dump_thread, this, "iosdump"); if (ret) { - gf_log (this->name, GF_LOG_ERROR, - "Out of memory."); - goto out; - } - - GF_OPTION_INIT ("ios-dnscache-ttl-sec", conf->ios_dnscache_ttl_sec, - int32, out); - conf->dnscache = gf_dnscache_init (conf->ios_dnscache_ttl_sec); - - GF_OPTION_INIT ("sys-log-level", sys_log_str, str, out); - if (sys_log_str) { - sys_log_level = glusterd_check_log_level (sys_log_str); - set_sys_log_level (sys_log_level); + conf->dump_thread_running = _gf_false; + gf_log(this ? this->name : "io-stats", GF_LOG_ERROR, + "Failed to start thread" + "in init. Returning %d", + ret); + goto out; } - - GF_OPTION_INIT ("log-level", log_str, str, out); - if (log_str) { - log_level = glusterd_check_log_level (log_str); - if (DEFAULT_LOG_LEVEL != log_level) - gf_log_set_loglevel (this->ctx, log_level); - } - - GF_OPTION_INIT ("logger", logger_str, str, out); - if (logger_str) { - logger = gf_check_logger (logger_str); - gf_log_set_logger (logger); - } - - GF_OPTION_INIT ("log-format", log_format_str, str, out); - if (log_format_str) { - log_format = gf_check_log_format (log_format_str); - gf_log_set_logformat (log_format); - } - - GF_OPTION_INIT ("log-buf-size", log_buf_size, uint32, out); - gf_log_set_log_buf_size (log_buf_size); - - GF_OPTION_INIT ("log-flush-timeout", log_flush_timeout, time, out); - gf_log_set_log_flush_timeout (log_flush_timeout); - - this->private = conf; - if (conf->ios_dump_interval > 0) { - conf->dump_thread_running = _gf_true; - conf->dump_thread_should_die = _gf_false; - ret = gf_thread_create (&conf->dump_thread, NULL, - (void *) &_ios_dump_thread, - this, "iosdump"); - if (ret) { - conf->dump_thread_running = _gf_false; - gf_log (this ? this->name : "io-stats", - GF_LOG_ERROR, "Failed to start thread" - "in init. Returning %d", ret); - goto out; - } - } - return 0; + } + return 0; out: - ios_conf_destroy (conf); - return ret; + ios_conf_destroy(conf); + return ret; } void -fini (xlator_t *this) +fini(xlator_t *this) { - struct ios_conf *conf = NULL; + struct ios_conf *conf = NULL; - if (!this) - return; + if (!this) + return; - conf = this->private; + conf = this->private; - ios_conf_destroy (conf); - this->private = NULL; - gf_log (this->name, GF_LOG_INFO, - "io-stats translator unloaded"); - return; + ios_conf_destroy(conf); + this->private = NULL; + gf_log(this->name, GF_LOG_INFO, "io-stats translator unloaded"); + return; } int -notify (xlator_t *this, int32_t event, void *data, ...) -{ - int ret = 0; - struct ios_dump_args args = {0}; - dict_t *output = NULL; - dict_t *dict = NULL; - int32_t op = 0; - int32_t list_cnt = 0; - double throughput = 0; - double time = 0; - gf_boolean_t is_peek = _gf_false; - va_list ap; - struct gf_upcall *up_data = NULL; - struct gf_upcall_cache_invalidation *up_ci = NULL; - - dict = data; - va_start (ap, data); - output = va_arg (ap, dict_t*); - va_end (ap); - switch (event) { +notify(xlator_t *this, int32_t event, void *data, ...) +{ + int ret = 0; + struct ios_dump_args args = {0}; + dict_t *output = NULL; + dict_t *dict = NULL; + int32_t op = 0; + int32_t list_cnt = 0; + double throughput = 0; + double time = 0; + gf_boolean_t is_peek = _gf_false; + va_list ap; + struct gf_upcall *up_data = NULL; + struct gf_upcall_cache_invalidation *up_ci = NULL; + + dict = data; + va_start(ap, data); + output = va_arg(ap, dict_t *); + va_end(ap); + switch (event) { case GF_EVENT_TRANSLATOR_INFO: - ret = dict_get_str_boolean (dict, "clear-stats", _gf_false); + ret = dict_get_str_boolean(dict, "clear-stats", _gf_false); + if (ret) { + ret = dict_set_int32(output, "top-op", op); if (ret) { - ret = dict_set_int32 (output, "top-op", op); - if (ret) { - gf_log (this->name, GF_LOG_ERROR, - "Failed to set top-op in dict"); - goto out; - } - ios_destroy_top_stats (this->private); - ret = ios_init_top_stats (this->private); + gf_log(this->name, GF_LOG_ERROR, + "Failed to set top-op in dict"); + goto out; + } + ios_destroy_top_stats(this->private); + ret = ios_init_top_stats(this->private); + if (ret) + gf_log(this->name, GF_LOG_ERROR, + "Failed to reset top stats"); + ret = dict_set_int32(output, "stats-cleared", ret ? 0 : 1); + if (ret) + gf_log(this->name, GF_LOG_ERROR, + "Failed to set stats-cleared" + " in dict"); + goto out; + } + + ret = dict_get_int32(dict, "top-op", &op); + if (!ret) { + ret = dict_get_int32(dict, "list-cnt", &list_cnt); + if (op > IOS_STATS_TYPE_NONE && op < IOS_STATS_TYPE_MAX) + ret = io_stats_dump_stats_to_dict(this, output, op, + list_cnt); + if (op == IOS_STATS_TYPE_READ_THROUGHPUT || + op == IOS_STATS_TYPE_WRITE_THROUGHPUT) { + ret = dict_get_double(dict, "throughput", &throughput); + if (!ret) { + ret = dict_get_double(dict, "time", &time); if (ret) - gf_log (this->name, GF_LOG_ERROR, - "Failed to reset top stats"); - ret = dict_set_int32 (output, "stats-cleared", - ret ? 0 : 1); + goto out; + ret = dict_set_double(output, "throughput", throughput); if (ret) - gf_log (this->name, GF_LOG_ERROR, - "Failed to set stats-cleared" - " in dict"); - goto out; + goto out; + ret = dict_set_double(output, "time", time); + if (ret) + goto out; + } + ret = 0; } + } else { + ret = dict_get_int32(dict, "info-op", &op); + if (ret || op < GF_CLI_INFO_ALL || GF_CLI_INFO_CLEAR < op) + op = GF_CLI_INFO_ALL; - ret = dict_get_int32 (dict, "top-op", &op); - if (!ret) { - ret = dict_get_int32 (dict, "list-cnt", &list_cnt); - if (op > IOS_STATS_TYPE_NONE && - op < IOS_STATS_TYPE_MAX) - ret = io_stats_dump_stats_to_dict (this, output, - op, list_cnt); - if (op == IOS_STATS_TYPE_READ_THROUGHPUT || - op == IOS_STATS_TYPE_WRITE_THROUGHPUT) { - ret = dict_get_double (dict, "throughput", - &throughput); - if (!ret) { - ret = dict_get_double (dict, "time", - &time); - if (ret) - goto out; - ret = dict_set_double (output, - "throughput", throughput); - if (ret) - goto out; - ret = dict_set_double (output, "time", - time); - if (ret) - goto out; - } - ret = 0; - - } + ret = dict_set_int32(output, "info-op", op); + if (ret) { + gf_log(this->name, GF_LOG_ERROR, + "Failed to set info-op in dict"); + goto out; + } + + if (GF_CLI_INFO_CLEAR == op) { + ret = io_stats_clear(this->private); + if (ret) + gf_log(this->name, GF_LOG_ERROR, + "Failed to clear info stats"); + + ret = dict_set_int32(output, "stats-cleared", ret ? 0 : 1); + if (ret) + gf_log(this->name, GF_LOG_ERROR, + "Failed to set stats-cleared" + " in dict"); } else { - ret = dict_get_int32 (dict, "info-op", &op); - if (ret || op < GF_CLI_INFO_ALL || - GF_CLI_INFO_CLEAR < op) - op = GF_CLI_INFO_ALL; - - ret = dict_set_int32 (output, "info-op", op); - if (ret) { - gf_log (this->name, GF_LOG_ERROR, - "Failed to set info-op in dict"); - goto out; - } - - if (GF_CLI_INFO_CLEAR == op) { - ret = io_stats_clear (this->private); - if (ret) - gf_log (this->name, GF_LOG_ERROR, - "Failed to clear info stats"); - - ret = dict_set_int32 (output, "stats-cleared", - ret ? 0 : 1); - if (ret) - gf_log (this->name, GF_LOG_ERROR, - "Failed to set stats-cleared" - " in dict"); - } - else { - ret = dict_get_str_boolean (dict, "peek", - _gf_false); - if (-1 != ret) - is_peek = ret; - - (void) ios_dump_args_init (&args, - IOS_DUMP_TYPE_DICT, output); - ret = io_stats_dump (this, &args, op, is_peek); - } + ret = dict_get_str_boolean(dict, "peek", _gf_false); + if (-1 != ret) + is_peek = ret; + + (void)ios_dump_args_init(&args, IOS_DUMP_TYPE_DICT, output); + ret = io_stats_dump(this, &args, op, is_peek); } - break; + } + break; case GF_EVENT_UPCALL: - up_data = (struct gf_upcall *)data; - ios_bump_upcall (this, GF_UPCALL); + up_data = (struct gf_upcall *)data; + ios_bump_upcall(this, GF_UPCALL); - switch (up_data->event_type) { + switch (up_data->event_type) { case GF_UPCALL_RECALL_LEASE: - ios_bump_upcall (this, GF_UPCALL_LEASE_RECALL); - break; + ios_bump_upcall(this, GF_UPCALL_LEASE_RECALL); + break; case GF_UPCALL_CACHE_INVALIDATION: - up_ci = (struct gf_upcall_cache_invalidation *)up_data->data; - if (up_ci->flags & (UP_XATTR | UP_XATTR_RM)) - ios_bump_upcall (this, GF_UPCALL_CI_XATTR); - if (up_ci->flags & IATT_UPDATE_FLAGS) - ios_bump_upcall (this, GF_UPCALL_CI_STAT); - if (up_ci->flags & UP_RENAME_FLAGS) - ios_bump_upcall (this, GF_UPCALL_CI_RENAME); - if (up_ci->flags & UP_FORGET) - ios_bump_upcall (this, GF_UPCALL_CI_FORGET); - if (up_ci->flags & UP_NLINK) - ios_bump_upcall (this, GF_UPCALL_CI_NLINK); - break; + up_ci = (struct gf_upcall_cache_invalidation *) + up_data->data; + if (up_ci->flags & (UP_XATTR | UP_XATTR_RM)) + ios_bump_upcall(this, GF_UPCALL_CI_XATTR); + if (up_ci->flags & IATT_UPDATE_FLAGS) + ios_bump_upcall(this, GF_UPCALL_CI_STAT); + if (up_ci->flags & UP_RENAME_FLAGS) + ios_bump_upcall(this, GF_UPCALL_CI_RENAME); + if (up_ci->flags & UP_FORGET) + ios_bump_upcall(this, GF_UPCALL_CI_FORGET); + if (up_ci->flags & UP_NLINK) + ios_bump_upcall(this, GF_UPCALL_CI_NLINK); + break; default: - gf_msg_debug (this->name, 0, "Unknown upcall event " - "type :%d", up_data->event_type); - break; - } + gf_msg_debug(this->name, 0, + "Unknown upcall event " + "type :%d", + up_data->event_type); + break; + } - default_notify (this, event, data); - break; + default_notify(this, event, data); + break; default: - default_notify (this, event, data); - break; - - } + default_notify(this, event, data); + break; + } out: - return ret; + return ret; } -struct xlator_dumpops dumpops = { - .priv = io_priv -}; +struct xlator_dumpops dumpops = {.priv = io_priv}; struct xlator_fops fops = { - .stat = io_stats_stat, - .readlink = io_stats_readlink, - .mknod = io_stats_mknod, - .mkdir = io_stats_mkdir, - .unlink = io_stats_unlink, - .rmdir = io_stats_rmdir, - .symlink = io_stats_symlink, - .rename = io_stats_rename, - .link = io_stats_link, - .truncate = io_stats_truncate, - .open = io_stats_open, - .readv = io_stats_readv, - .writev = io_stats_writev, - .statfs = io_stats_statfs, - .flush = io_stats_flush, - .fsync = io_stats_fsync, - .setxattr = io_stats_setxattr, - .getxattr = io_stats_getxattr, - .removexattr = io_stats_removexattr, - .fsetxattr = io_stats_fsetxattr, - .fgetxattr = io_stats_fgetxattr, - .fremovexattr = io_stats_fremovexattr, - .opendir = io_stats_opendir, - .readdir = io_stats_readdir, - .readdirp = io_stats_readdirp, - .fsyncdir = io_stats_fsyncdir, - .access = io_stats_access, - .ftruncate = io_stats_ftruncate, - .fstat = io_stats_fstat, - .create = io_stats_create, - .lk = io_stats_lk, - .inodelk = io_stats_inodelk, - .finodelk = io_stats_finodelk, - .entrylk = io_stats_entrylk, - .fentrylk = io_stats_fentrylk, - .lookup = io_stats_lookup, - .xattrop = io_stats_xattrop, - .fxattrop = io_stats_fxattrop, - .setattr = io_stats_setattr, - .fsetattr = io_stats_fsetattr, - .fallocate = io_stats_fallocate, - .discard = io_stats_discard, - .zerofill = io_stats_zerofill, - .ipc = io_stats_ipc, - .rchecksum = io_stats_rchecksum, - .seek = io_stats_seek, - .lease = io_stats_lease, - .getactivelk = io_stats_getactivelk, - .setactivelk = io_stats_setactivelk, - .compound = io_stats_compound, + .stat = io_stats_stat, + .readlink = io_stats_readlink, + .mknod = io_stats_mknod, + .mkdir = io_stats_mkdir, + .unlink = io_stats_unlink, + .rmdir = io_stats_rmdir, + .symlink = io_stats_symlink, + .rename = io_stats_rename, + .link = io_stats_link, + .truncate = io_stats_truncate, + .open = io_stats_open, + .readv = io_stats_readv, + .writev = io_stats_writev, + .statfs = io_stats_statfs, + .flush = io_stats_flush, + .fsync = io_stats_fsync, + .setxattr = io_stats_setxattr, + .getxattr = io_stats_getxattr, + .removexattr = io_stats_removexattr, + .fsetxattr = io_stats_fsetxattr, + .fgetxattr = io_stats_fgetxattr, + .fremovexattr = io_stats_fremovexattr, + .opendir = io_stats_opendir, + .readdir = io_stats_readdir, + .readdirp = io_stats_readdirp, + .fsyncdir = io_stats_fsyncdir, + .access = io_stats_access, + .ftruncate = io_stats_ftruncate, + .fstat = io_stats_fstat, + .create = io_stats_create, + .lk = io_stats_lk, + .inodelk = io_stats_inodelk, + .finodelk = io_stats_finodelk, + .entrylk = io_stats_entrylk, + .fentrylk = io_stats_fentrylk, + .lookup = io_stats_lookup, + .xattrop = io_stats_xattrop, + .fxattrop = io_stats_fxattrop, + .setattr = io_stats_setattr, + .fsetattr = io_stats_fsetattr, + .fallocate = io_stats_fallocate, + .discard = io_stats_discard, + .zerofill = io_stats_zerofill, + .ipc = io_stats_ipc, + .rchecksum = io_stats_rchecksum, + .seek = io_stats_seek, + .lease = io_stats_lease, + .getactivelk = io_stats_getactivelk, + .setactivelk = io_stats_setactivelk, + .compound = io_stats_compound, }; struct xlator_cbks cbks = { - .release = io_stats_release, - .releasedir = io_stats_releasedir, - .forget = io_stats_forget, + .release = io_stats_release, + .releasedir = io_stats_releasedir, + .forget = io_stats_forget, }; struct volume_options options[] = { - { .key = {"dump-fd-stats"}, - .op_version = {1}, - .flags = OPT_FLAG_SETTABLE | OPT_FLAG_DOC, - .tags = {"io-stats"}, - .type = GF_OPTION_TYPE_BOOL, - .default_value = "off", - .description = "If on stats related to file-operations would be " - "tracked inside GlusterFS data-structures." - }, - { .key = { "ios-dump-interval" }, - .type = GF_OPTION_TYPE_INT, - .op_version = {1}, - .flags = OPT_FLAG_SETTABLE | OPT_FLAG_DOC, - .tags = {"io-stats"}, - .min = 0, - .max = 3600, - .default_value = "0", - .description = "Interval (in seconds) at which to auto-dump " - "statistics. Zero disables automatic dumping." - }, - { .key = { "ios-sample-interval" }, - .type = GF_OPTION_TYPE_INT, - .op_version = {1}, - .flags = OPT_FLAG_SETTABLE | OPT_FLAG_DOC, - .tags = {"io-stats"}, - .min = 0, - .max = 65535, - .default_value = "0", - .description = "Interval in which we want to collect FOP latency " - "samples. 2 means collect a sample every 2nd FOP." - }, - { .key = {"ios-dump-format"}, - .type = GF_OPTION_TYPE_STR, - .op_version = {GD_OP_VERSION_3_12_0}, - .flags = OPT_FLAG_SETTABLE | OPT_FLAG_DOC, - .tags = {"io-stats"}, - .default_value = "json", - .description = " The dump-format option specifies the format in which" - " to dump the statistics. Select between \"text\", " - "\"json\", \"dict\" and \"samples\". Default is " - "\"json\".", - .value = { "text", "json", "dict", "samples"} - }, - { .key = { "ios-sample-buf-size" }, - .type = GF_OPTION_TYPE_INT, - .op_version = {1}, - .flags = OPT_FLAG_SETTABLE | OPT_FLAG_DOC, - .tags = {"io-stats"}, - .min = 1024, - .max = 1024*1024, - .default_value = "65535", - .description = "The maximum size of our FOP sampling ring buffer." - }, - { .key = { "ios-dnscache-ttl-sec" }, - .type = GF_OPTION_TYPE_INT, - .op_version = {1}, - .flags = OPT_FLAG_SETTABLE | OPT_FLAG_DOC, - .tags = {"io-stats"}, - .min = 1, - .max = 3600 * 72, - .default_value = "86400", - .description = "The interval after wish a cached DNS entry will be " - "re-validated. Default: 24 hrs" - }, - { .key = { "latency-measurement" }, - .type = GF_OPTION_TYPE_BOOL, - .op_version = {1}, - .flags = OPT_FLAG_SETTABLE | OPT_FLAG_DOC, - .tags = {"io-stats"}, - .default_value = "off", - .description = "If on stats related to the latency of each operation " - "would be tracked inside GlusterFS data-structures. " - }, - { .key = {"count-fop-hits"}, - .type = GF_OPTION_TYPE_BOOL, - .op_version = {1}, - .flags = OPT_FLAG_SETTABLE, - .tags = {"io-stats"}, - }, - { .key = {"log-level"}, - .type = GF_OPTION_TYPE_STR, - .value = { "DEBUG", "WARNING", "ERROR", "INFO", - "CRITICAL", "NONE", "TRACE"} - }, - - /* These are synthetic entries to assist validation of CLI's * - * volume set command */ - { .key = {"client-log-level"}, - .type = GF_OPTION_TYPE_STR, - .op_version = {1}, - .flags = OPT_FLAG_SETTABLE | OPT_FLAG_CLIENT_OPT | OPT_FLAG_DOC, - .tags = {"io-stats"}, - .default_value = "INFO", - .description = "Changes the log-level of the clients", - .value = { "DEBUG", "WARNING", "ERROR", "INFO", - "CRITICAL", "NONE", "TRACE"} - }, - { .key = {"sys-log-level"}, - .type = GF_OPTION_TYPE_STR, - .default_value = "CRITICAL", - .description = "Gluster's syslog log-level", - .value = { "WARNING", "ERROR", "INFO", "CRITICAL"} - }, - { .key = {"brick-log-level"}, - .type = GF_OPTION_TYPE_STR, - .op_version = {1}, - .flags = OPT_FLAG_SETTABLE | OPT_FLAG_DOC, - .tags = {"io-stats"}, - .default_value = "INFO", - .description = "Changes the log-level of the bricks", - .value = { "DEBUG", "WARNING", "ERROR", "INFO", - "CRITICAL", "NONE", "TRACE"} - }, - { .key = {"logger"}, - .type = GF_OPTION_TYPE_STR, - .value = { GF_LOGGER_GLUSTER_LOG, GF_LOGGER_SYSLOG} - }, - { .key = {"client-logger"}, - .type = GF_OPTION_TYPE_STR, - .op_version = {GD_OP_VERSION_3_6_0}, - .flags = OPT_FLAG_SETTABLE | OPT_FLAG_CLIENT_OPT | OPT_FLAG_DOC, - .tags = {"io-stats"}, - .default_value = GF_LOGGER_GLUSTER_LOG, - .description = "Changes the logging sub-system to log to, for the " - "clients", - .value = { GF_LOGGER_GLUSTER_LOG, GF_LOGGER_SYSLOG} - }, - { .key = {"brick-logger"}, - .type = GF_OPTION_TYPE_STR, - .op_version = {GD_OP_VERSION_3_6_0}, - .flags = OPT_FLAG_SETTABLE | OPT_FLAG_DOC, - .tags = {"io-stats"}, - .default_value = GF_LOGGER_GLUSTER_LOG, - .description = "Changes the logging sub-system to log to, for the " - "bricks", - .value = { GF_LOGGER_GLUSTER_LOG, GF_LOGGER_SYSLOG} - }, - { .key = {"log-format"}, - .type = GF_OPTION_TYPE_STR, - .value = { GF_LOG_FORMAT_NO_MSG_ID, GF_LOG_FORMAT_WITH_MSG_ID} - }, - { .key = {"client-log-format"}, - .type = GF_OPTION_TYPE_STR, - .op_version = {GD_OP_VERSION_3_6_0}, - .flags = OPT_FLAG_SETTABLE | OPT_FLAG_CLIENT_OPT | OPT_FLAG_DOC, - .tags = {"io-stats"}, - .default_value = GF_LOG_FORMAT_WITH_MSG_ID, - .description = "Changes log format for the clients", - .value = { GF_LOG_FORMAT_NO_MSG_ID, GF_LOG_FORMAT_WITH_MSG_ID} - }, - { .key = {"brick-log-format"}, - .type = GF_OPTION_TYPE_STR, - .op_version = {GD_OP_VERSION_3_6_0}, - .flags = OPT_FLAG_SETTABLE | OPT_FLAG_DOC, - .tags = {"io-stats"}, - .default_value = GF_LOG_FORMAT_WITH_MSG_ID, - .description = "Changes the log format for the bricks", - .value = { GF_LOG_FORMAT_NO_MSG_ID, GF_LOG_FORMAT_WITH_MSG_ID} - }, - { .key = {"log-buf-size"}, - .type = GF_OPTION_TYPE_INT, - .min = GF_LOG_LRU_BUFSIZE_MIN, - .max = GF_LOG_LRU_BUFSIZE_MAX, - .default_value = "5", - }, - { .key = {"client-log-buf-size"}, - .type = GF_OPTION_TYPE_INT, - .op_version = {GD_OP_VERSION_3_6_0}, - .flags = OPT_FLAG_SETTABLE | OPT_FLAG_CLIENT_OPT | OPT_FLAG_DOC, - .tags = {"io-stats"}, - .min = GF_LOG_LRU_BUFSIZE_MIN, - .max = GF_LOG_LRU_BUFSIZE_MAX, - .default_value = "5", - .description = "This option determines the maximum number of unique " - "log messages that can be buffered for a time equal to" - " the value of the option client-log-flush-timeout." - }, - { .key = {"brick-log-buf-size"}, - .type = GF_OPTION_TYPE_INT, - .op_version = {GD_OP_VERSION_3_6_0}, - .flags = OPT_FLAG_SETTABLE | OPT_FLAG_DOC, - .tags = {"io-stats"}, - .min = GF_LOG_LRU_BUFSIZE_MIN, - .max = GF_LOG_LRU_BUFSIZE_MAX, - .default_value = "5", - .description = "This option determines the maximum number of unique " - "log messages that can be buffered for a time equal to" - " the value of the option brick-log-flush-timeout." - }, - { .key = {"log-flush-timeout"}, - .type = GF_OPTION_TYPE_TIME, - .min = GF_LOG_FLUSH_TIMEOUT_MIN, - .max = GF_LOG_FLUSH_TIMEOUT_MAX, - .default_value = "120", - }, - { .key = {"client-log-flush-timeout"}, - .type = GF_OPTION_TYPE_TIME, - .op_version = {GD_OP_VERSION_3_6_0}, - .flags = OPT_FLAG_SETTABLE | OPT_FLAG_CLIENT_OPT | OPT_FLAG_DOC, - .tags = {"io-stats"}, - .min = GF_LOG_FLUSH_TIMEOUT_MIN, - .max = GF_LOG_FLUSH_TIMEOUT_MAX, - .default_value = "120", - .description = "This option determines the maximum number of unique " - "log messages that can be buffered for a time equal to" - " the value of the option client-log-flush-timeout." - }, - { .key = {"brick-log-flush-timeout"}, - .type = GF_OPTION_TYPE_TIME, - .op_version = {GD_OP_VERSION_3_6_0}, - .flags = OPT_FLAG_SETTABLE | OPT_FLAG_DOC, - .tags = {"io-stats"}, - .min = GF_LOG_FLUSH_TIMEOUT_MIN, - .max = GF_LOG_FLUSH_TIMEOUT_MAX, - .default_value = "120", - .description = "This option determines the maximum number of unique " - "log messages that can be buffered for a time equal to" - " the value of the option brick-log-flush-timeout." - }, - { .key = {"unique-id"}, - .type = GF_OPTION_TYPE_STR, - .default_value = "/no/such/path", - .description = "Unique ID for our files." - }, - { .key = {NULL} }, + {.key = {"dump-fd-stats"}, + .op_version = {1}, + .flags = OPT_FLAG_SETTABLE | OPT_FLAG_DOC, + .tags = {"io-stats"}, + .type = GF_OPTION_TYPE_BOOL, + .default_value = "off", + .description = "If on stats related to file-operations would be " + "tracked inside GlusterFS data-structures."}, + {.key = {"ios-dump-interval"}, + .type = GF_OPTION_TYPE_INT, + .op_version = {1}, + .flags = OPT_FLAG_SETTABLE | OPT_FLAG_DOC, + .tags = {"io-stats"}, + .min = 0, + .max = 3600, + .default_value = "0", + .description = "Interval (in seconds) at which to auto-dump " + "statistics. Zero disables automatic dumping."}, + {.key = {"ios-sample-interval"}, + .type = GF_OPTION_TYPE_INT, + .op_version = {1}, + .flags = OPT_FLAG_SETTABLE | OPT_FLAG_DOC, + .tags = {"io-stats"}, + .min = 0, + .max = 65535, + .default_value = "0", + .description = "Interval in which we want to collect FOP latency " + "samples. 2 means collect a sample every 2nd FOP."}, + {.key = {"ios-dump-format"}, + .type = GF_OPTION_TYPE_STR, + .op_version = {GD_OP_VERSION_3_12_0}, + .flags = OPT_FLAG_SETTABLE | OPT_FLAG_DOC, + .tags = {"io-stats"}, + .default_value = "json", + .description = " The dump-format option specifies the format in which" + " to dump the statistics. Select between \"text\", " + "\"json\", \"dict\" and \"samples\". Default is " + "\"json\".", + .value = {"text", "json", "dict", "samples"}}, + {.key = {"ios-sample-buf-size"}, + .type = GF_OPTION_TYPE_INT, + .op_version = {1}, + .flags = OPT_FLAG_SETTABLE | OPT_FLAG_DOC, + .tags = {"io-stats"}, + .min = 1024, + .max = 1024 * 1024, + .default_value = "65535", + .description = "The maximum size of our FOP sampling ring buffer."}, + {.key = {"ios-dnscache-ttl-sec"}, + .type = GF_OPTION_TYPE_INT, + .op_version = {1}, + .flags = OPT_FLAG_SETTABLE | OPT_FLAG_DOC, + .tags = {"io-stats"}, + .min = 1, + .max = 3600 * 72, + .default_value = "86400", + .description = "The interval after wish a cached DNS entry will be " + "re-validated. Default: 24 hrs"}, + {.key = {"latency-measurement"}, + .type = GF_OPTION_TYPE_BOOL, + .op_version = {1}, + .flags = OPT_FLAG_SETTABLE | OPT_FLAG_DOC, + .tags = {"io-stats"}, + .default_value = "off", + .description = "If on stats related to the latency of each operation " + "would be tracked inside GlusterFS data-structures. "}, + { + .key = {"count-fop-hits"}, + .type = GF_OPTION_TYPE_BOOL, + .op_version = {1}, + .flags = OPT_FLAG_SETTABLE, + .tags = {"io-stats"}, + }, + {.key = {"log-level"}, + .type = GF_OPTION_TYPE_STR, + .value = {"DEBUG", "WARNING", "ERROR", "INFO", "CRITICAL", "NONE", + "TRACE"}}, + + /* These are synthetic entries to assist validation of CLI's * + * volume set command */ + {.key = {"client-log-level"}, + .type = GF_OPTION_TYPE_STR, + .op_version = {1}, + .flags = OPT_FLAG_SETTABLE | OPT_FLAG_CLIENT_OPT | OPT_FLAG_DOC, + .tags = {"io-stats"}, + .default_value = "INFO", + .description = "Changes the log-level of the clients", + .value = {"DEBUG", "WARNING", "ERROR", "INFO", "CRITICAL", "NONE", + "TRACE"}}, + {.key = {"sys-log-level"}, + .type = GF_OPTION_TYPE_STR, + .default_value = "CRITICAL", + .description = "Gluster's syslog log-level", + .value = {"WARNING", "ERROR", "INFO", "CRITICAL"}}, + {.key = {"brick-log-level"}, + .type = GF_OPTION_TYPE_STR, + .op_version = {1}, + .flags = OPT_FLAG_SETTABLE | OPT_FLAG_DOC, + .tags = {"io-stats"}, + .default_value = "INFO", + .description = "Changes the log-level of the bricks", + .value = {"DEBUG", "WARNING", "ERROR", "INFO", "CRITICAL", "NONE", + "TRACE"}}, + {.key = {"logger"}, + .type = GF_OPTION_TYPE_STR, + .value = {GF_LOGGER_GLUSTER_LOG, GF_LOGGER_SYSLOG}}, + {.key = {"client-logger"}, + .type = GF_OPTION_TYPE_STR, + .op_version = {GD_OP_VERSION_3_6_0}, + .flags = OPT_FLAG_SETTABLE | OPT_FLAG_CLIENT_OPT | OPT_FLAG_DOC, + .tags = {"io-stats"}, + .default_value = GF_LOGGER_GLUSTER_LOG, + .description = "Changes the logging sub-system to log to, for the " + "clients", + .value = {GF_LOGGER_GLUSTER_LOG, GF_LOGGER_SYSLOG}}, + {.key = {"brick-logger"}, + .type = GF_OPTION_TYPE_STR, + .op_version = {GD_OP_VERSION_3_6_0}, + .flags = OPT_FLAG_SETTABLE | OPT_FLAG_DOC, + .tags = {"io-stats"}, + .default_value = GF_LOGGER_GLUSTER_LOG, + .description = "Changes the logging sub-system to log to, for the " + "bricks", + .value = {GF_LOGGER_GLUSTER_LOG, GF_LOGGER_SYSLOG}}, + {.key = {"log-format"}, + .type = GF_OPTION_TYPE_STR, + .value = {GF_LOG_FORMAT_NO_MSG_ID, GF_LOG_FORMAT_WITH_MSG_ID}}, + {.key = {"client-log-format"}, + .type = GF_OPTION_TYPE_STR, + .op_version = {GD_OP_VERSION_3_6_0}, + .flags = OPT_FLAG_SETTABLE | OPT_FLAG_CLIENT_OPT | OPT_FLAG_DOC, + .tags = {"io-stats"}, + .default_value = GF_LOG_FORMAT_WITH_MSG_ID, + .description = "Changes log format for the clients", + .value = {GF_LOG_FORMAT_NO_MSG_ID, GF_LOG_FORMAT_WITH_MSG_ID}}, + {.key = {"brick-log-format"}, + .type = GF_OPTION_TYPE_STR, + .op_version = {GD_OP_VERSION_3_6_0}, + .flags = OPT_FLAG_SETTABLE | OPT_FLAG_DOC, + .tags = {"io-stats"}, + .default_value = GF_LOG_FORMAT_WITH_MSG_ID, + .description = "Changes the log format for the bricks", + .value = {GF_LOG_FORMAT_NO_MSG_ID, GF_LOG_FORMAT_WITH_MSG_ID}}, + { + .key = {"log-buf-size"}, + .type = GF_OPTION_TYPE_INT, + .min = GF_LOG_LRU_BUFSIZE_MIN, + .max = GF_LOG_LRU_BUFSIZE_MAX, + .default_value = "5", + }, + {.key = {"client-log-buf-size"}, + .type = GF_OPTION_TYPE_INT, + .op_version = {GD_OP_VERSION_3_6_0}, + .flags = OPT_FLAG_SETTABLE | OPT_FLAG_CLIENT_OPT | OPT_FLAG_DOC, + .tags = {"io-stats"}, + .min = GF_LOG_LRU_BUFSIZE_MIN, + .max = GF_LOG_LRU_BUFSIZE_MAX, + .default_value = "5", + .description = "This option determines the maximum number of unique " + "log messages that can be buffered for a time equal to" + " the value of the option client-log-flush-timeout."}, + {.key = {"brick-log-buf-size"}, + .type = GF_OPTION_TYPE_INT, + .op_version = {GD_OP_VERSION_3_6_0}, + .flags = OPT_FLAG_SETTABLE | OPT_FLAG_DOC, + .tags = {"io-stats"}, + .min = GF_LOG_LRU_BUFSIZE_MIN, + .max = GF_LOG_LRU_BUFSIZE_MAX, + .default_value = "5", + .description = "This option determines the maximum number of unique " + "log messages that can be buffered for a time equal to" + " the value of the option brick-log-flush-timeout."}, + { + .key = {"log-flush-timeout"}, + .type = GF_OPTION_TYPE_TIME, + .min = GF_LOG_FLUSH_TIMEOUT_MIN, + .max = GF_LOG_FLUSH_TIMEOUT_MAX, + .default_value = "120", + }, + {.key = {"client-log-flush-timeout"}, + .type = GF_OPTION_TYPE_TIME, + .op_version = {GD_OP_VERSION_3_6_0}, + .flags = OPT_FLAG_SETTABLE | OPT_FLAG_CLIENT_OPT | OPT_FLAG_DOC, + .tags = {"io-stats"}, + .min = GF_LOG_FLUSH_TIMEOUT_MIN, + .max = GF_LOG_FLUSH_TIMEOUT_MAX, + .default_value = "120", + .description = "This option determines the maximum number of unique " + "log messages that can be buffered for a time equal to" + " the value of the option client-log-flush-timeout."}, + {.key = {"brick-log-flush-timeout"}, + .type = GF_OPTION_TYPE_TIME, + .op_version = {GD_OP_VERSION_3_6_0}, + .flags = OPT_FLAG_SETTABLE | OPT_FLAG_DOC, + .tags = {"io-stats"}, + .min = GF_LOG_FLUSH_TIMEOUT_MIN, + .max = GF_LOG_FLUSH_TIMEOUT_MAX, + .default_value = "120", + .description = "This option determines the maximum number of unique " + "log messages that can be buffered for a time equal to" + " the value of the option brick-log-flush-timeout."}, + {.key = {"unique-id"}, + .type = GF_OPTION_TYPE_STR, + .default_value = "/no/such/path", + .description = "Unique ID for our files."}, + {.key = {NULL}}, }; diff --git a/xlators/debug/sink/src/sink.c b/xlators/debug/sink/src/sink.c index dfd5685a969..fbbdd3a4847 100644 --- a/xlators/debug/sink/src/sink.c +++ b/xlators/debug/sink/src/sink.c @@ -12,37 +12,37 @@ #include "defaults.h" int32_t -init (xlator_t *this) +init(xlator_t *this) { - return 0; + return 0; } void -fini (xlator_t *this) +fini(xlator_t *this) { - return; + return; } /* * notify - when parent sends PARENT_UP, send CHILD_UP event from here */ int32_t -notify (xlator_t *this, int32_t event, void *data, ...) +notify(xlator_t *this, int32_t event, void *data, ...) { - switch (event) { + switch (event) { case GF_EVENT_PARENT_UP: - /* Tell the parent that this xlator is up */ - default_notify (this, GF_EVENT_CHILD_UP, data); - break; + /* Tell the parent that this xlator is up */ + default_notify(this, GF_EVENT_CHILD_UP, data); + break; case GF_EVENT_PARENT_DOWN: - /* Tell the parent that this xlator is down */ - default_notify (this, GF_EVENT_CHILD_DOWN, data); - break; + /* Tell the parent that this xlator is down */ + default_notify(this, GF_EVENT_CHILD_DOWN, data); + break; default: - break; - } + break; + } - return 0; + return 0; } /* @@ -53,27 +53,30 @@ notify (xlator_t *this, int32_t event, void *data, ...) * extended to support different LOOKUPs too. */ static int32_t -sink_lookup (call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *xdata) +sink_lookup(call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *xdata) { - struct iatt stbuf = { 0, }; - struct iatt postparent = { 0, }; + struct iatt stbuf = { + 0, + }; + struct iatt postparent = { + 0, + }; - /* the root of the volume always need to be a directory */ - stbuf.ia_type = IA_IFDIR; + /* the root of the volume always need to be a directory */ + stbuf.ia_type = IA_IFDIR; - STACK_UNWIND_STRICT (lookup, frame, 0, 0, loc ? loc->inode : NULL, - &stbuf, xdata, &postparent); + STACK_UNWIND_STRICT(lookup, frame, 0, 0, loc ? loc->inode : NULL, &stbuf, + xdata, &postparent); - return 0; + return 0; } struct xlator_fops fops = { - .lookup = sink_lookup, + .lookup = sink_lookup, }; -struct xlator_cbks cbks = { -}; +struct xlator_cbks cbks = {}; struct volume_options options[] = { - { .key = {NULL} }, + {.key = {NULL}}, }; diff --git a/xlators/debug/trace/src/trace.c b/xlators/debug/trace/src/trace.c index ec14a6dbb1b..86fa9d4611d 100644 --- a/xlators/debug/trace/src/trace.c +++ b/xlators/debug/trace/src/trace.c @@ -17,3351 +17,3506 @@ * their _cbk functions, which later passes the call to next layer. * Very helpful translator for debugging. */ -#define TRACE_STAT_TO_STR(buf, str) trace_stat_to_str (buf, str, sizeof (str)) +#define TRACE_STAT_TO_STR(buf, str) trace_stat_to_str(buf, str, sizeof(str)) static void trace_stat_to_str(struct iatt *buf, char *str, size_t len) { - char atime_buf[200] = {0,}; - char mtime_buf[200] = {0,}; - char ctime_buf[200] = {0,}; - - if (!buf) - return; + char atime_buf[200] = { + 0, + }; + char mtime_buf[200] = { + 0, + }; + char ctime_buf[200] = { + 0, + }; + + if (!buf) + return; - gf_time_fmt (atime_buf, sizeof atime_buf, buf->ia_atime, - gf_timefmt_dirent); + gf_time_fmt(atime_buf, sizeof atime_buf, buf->ia_atime, gf_timefmt_dirent); - gf_time_fmt (mtime_buf, sizeof mtime_buf, buf->ia_mtime, - gf_timefmt_dirent); + gf_time_fmt(mtime_buf, sizeof mtime_buf, buf->ia_mtime, gf_timefmt_dirent); - gf_time_fmt (ctime_buf, sizeof ctime_buf, buf->ia_ctime, - gf_timefmt_dirent); + gf_time_fmt(ctime_buf, sizeof ctime_buf, buf->ia_ctime, gf_timefmt_dirent); - snprintf (str, len, "gfid=%s ino=%"PRIu64", mode=%o, " - "nlink=%"GF_PRI_NLINK", uid=%u, gid=%u, size=%"PRIu64", " - "blocks=%"PRIu64", atime=%s mtime=%s ctime=%s " - "atime_sec=%"PRId64", atime_nsec=%"PRIu32"," - " mtime_sec=%"PRId64", mtime_nsec=%"PRIu32", " - "ctime_sec=%"PRId64", ctime_nsec=%"PRIu32"", - 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, - buf->ia_atime, buf->ia_atime_nsec, - buf->ia_mtime, buf->ia_mtime_nsec, - buf->ia_ctime, buf->ia_ctime_nsec); + snprintf(str, len, + "gfid=%s ino=%" PRIu64 + ", mode=%o, " + "nlink=%" GF_PRI_NLINK ", uid=%u, gid=%u, size=%" PRIu64 + ", " + "blocks=%" PRIu64 + ", atime=%s mtime=%s ctime=%s " + "atime_sec=%" PRId64 ", atime_nsec=%" PRIu32 + "," + " mtime_sec=%" PRId64 ", mtime_nsec=%" PRIu32 + ", " + "ctime_sec=%" PRId64 ", ctime_nsec=%" PRIu32 "", + 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, buf->ia_atime, buf->ia_atime_nsec, + buf->ia_mtime, buf->ia_mtime_nsec, buf->ia_ctime, + buf->ia_ctime_nsec); } - -int -dump_history_trace (circular_buffer_t *cb, void *data) +int +dump_history_trace(circular_buffer_t *cb, void *data) { - char timestr[256] = {0,}; + char timestr[256] = { + 0, + }; - /* 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 */ + /* 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 */ - gf_time_fmt (timestr, sizeof timestr, cb->tv.tv_sec, gf_timefmt_Ymd_T); - snprintf (timestr + strlen (timestr), 256 - strlen (timestr), - ".%"GF_PRI_SUSECONDS, cb->tv.tv_usec); - gf_proc_dump_write ("TIME", "%s", timestr); + gf_time_fmt(timestr, sizeof timestr, cb->tv.tv_sec, gf_timefmt_Ymd_T); + snprintf(timestr + strlen(timestr), 256 - strlen(timestr), + ".%" GF_PRI_SUSECONDS, cb->tv.tv_usec); + gf_proc_dump_write("TIME", "%s", timestr); - gf_proc_dump_write ("FOP", "%s\n", cb->data); + gf_proc_dump_write("FOP", "%s\n", cb->data); - return 0; + 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, - dict_t *xdata) +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, dict_t *xdata) { - char statstr[1024] = {0, }; - char preparentstr[1024] = {0, }; - char postparentstr[1024] = {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) { - 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 { - snprintf (string, sizeof (string), - "%"PRId64": (op_ret=%d, op_errno=%d)", - frame->root->unique, op_ret, - op_errno); - } - LOG_ELEMENT (conf, string); - } -out: - TRACE_STACK_UNWIND (create, frame, op_ret, op_errno, fd, inode, buf, - preparent, postparent, xdata); - return 0; -} + char statstr[1024] = { + 0, + }; + char preparentstr[1024] = { + 0, + }; + char postparentstr[1024] = { + 0, + }; + trace_conf_t *conf = NULL; -int -trace_open_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, fd_t *fd, dict_t *xdata) -{ - trace_conf_t *conf = NULL; + conf = this->private; - 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) { + TRACE_STAT_TO_STR(buf, statstr); + TRACE_STAT_TO_STR(preparent, preparentstr); + TRACE_STAT_TO_STR(postparent, postparentstr); - if (!conf->log_file && !conf->log_history) - goto out; - if (trace_fop_names[GF_FOP_OPEN].enabled) { - 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); + 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); - LOG_ELEMENT (conf, string); + /* for 'release' log */ + fd_ctx_set(fd, this, 0); + } else { + snprintf(string, sizeof(string), + "%" PRId64 ": (op_ret=%d, op_errno=%d)", + frame->root->unique, op_ret, op_errno); } - + LOG_ELEMENT(conf, string); + } out: - /* for 'release' log */ - if (op_ret >= 0) - fd_ctx_set (fd, this, 0); - - TRACE_STACK_UNWIND (open, frame, op_ret, op_errno, fd, xdata); - return 0; + TRACE_STACK_UNWIND(create, frame, op_ret, op_errno, fd, inode, buf, + preparent, postparent, 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, - dict_t *xdata) +trace_open_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, fd_t *fd, dict_t *xdata) { - char statstr[1024] = {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) { - char string[4096] = {0,}; - if (op_ret == 0) { - TRACE_STAT_TO_STR (buf, statstr); - (void)snprintf (string, sizeof (string), - "%"PRId64": gfid=%s op_ret=%d buf=%s", - frame->root->unique, - uuid_utoa (frame->local), op_ret, - statstr); - } else { - (void)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); - } -out: - TRACE_STACK_UNWIND (stat, frame, op_ret, op_errno, buf, xdata); - return 0; -} + trace_conf_t *conf = NULL; -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, - dict_t *xdata) -{ - char statstr[1024] = {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) { - 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 { - 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); - } -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, dict_t *xdata) -{ - char preopstr[1024] = {0, }; - char postopstr[1024] = {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) { - 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 { - 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); - } -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, - 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) { + 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); - conf = this->private; + LOG_ELEMENT(conf, string); + } - if (!conf->log_file && !conf->log_history) - goto out; - if (trace_fop_names[GF_FOP_READDIR].enabled) { - 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); - } out: - TRACE_STACK_UNWIND (readdir, frame, op_ret, op_errno, buf, xdata); + /* for 'release' log */ + if (op_ret >= 0) + fd_ctx_set(fd, this, 0); - return 0; + TRACE_STACK_UNWIND(open, frame, op_ret, op_errno, fd, 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, - dict_t *xdata) +trace_stat_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, struct iatt *buf, + dict_t *xdata) { - int count = 0; - char statstr[1024] = {0,}; - char string[4096] = {0,}; - trace_conf_t *conf = NULL; - gf_dirent_t *entry = NULL; - - conf = this->private; - - if (!conf->log_file && !conf->log_history) - goto out; - if (trace_fop_names[GF_FOP_READDIRP].enabled) { - 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); - } - if (op_ret < 0) - goto out; - - list_for_each_entry (entry, &buf->list, list) { - count++; - TRACE_STAT_TO_STR (&entry->d_stat, statstr); - snprintf (string, sizeof (string), "entry no. %d, pargfid=%s, " - "bname=%s *buf {%s}", count, uuid_utoa (frame->local), - entry->d_name, statstr); - 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, dict_t *xdata) + char statstr[1024] = { + 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) { + char string[4096] = { + 0, + }; + if (op_ret == 0) { + TRACE_STAT_TO_STR(buf, statstr); + (void)snprintf( + string, sizeof(string), "%" PRId64 ": gfid=%s op_ret=%d buf=%s", + frame->root->unique, uuid_utoa(frame->local), op_ret, statstr); + } else { + (void)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); + } +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, + dict_t *xdata) { - char preopstr[1024] = {0, }; - char postopstr[1024] = {0, }; - 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) { - 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 { - 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); - } -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, dict_t *xdata) + char statstr[1024] = { + 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) { + 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 { + 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); + } +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, dict_t *xdata) +{ + char preopstr[1024] = { + 0, + }; + char postopstr[1024] = { + 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) { + 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 { + 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); + } +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, + dict_t *xdata) { - char preopstr[1024] = {0, }; - char postopstr[1024] = {0, }; - trace_conf_t *conf = NULL; + trace_conf_t *conf = NULL; - conf = this->private; + 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 (op_ret == 0) { - TRACE_STAT_TO_STR (statpre, preopstr); - TRACE_STAT_TO_STR (statpost, postopstr); + if (!conf->log_file && !conf->log_history) + goto out; + if (trace_fop_names[GF_FOP_READDIR].enabled) { + 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); - snprintf (string, sizeof (string), - "%"PRId64": (op_ret=%d, " - "*prebuf = {%s}, *postbuf = {%s})", - frame->root->unique, op_ret, - preopstr, postopstr); - } 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); - } - LOG_ELEMENT (conf, string); - } -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, dict_t *xdata) -{ - char preopstr[1024] = {0, }; - char postopstr[1024] = {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 (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 { - 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); - } + LOG_ELEMENT(conf, string); + } out: - TRACE_STACK_UNWIND (fsetattr, frame, op_ret, op_errno, - statpre, statpost, xdata); - return 0; -} + TRACE_STACK_UNWIND(readdir, frame, op_ret, op_errno, buf, xdata); -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, - dict_t *xdata) -{ - char preparentstr[1024] = {0, }; - char postparentstr[1024] = {0, }; - 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) { - 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 { - 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); - } -out: - TRACE_STACK_UNWIND (unlink, frame, op_ret, op_errno, - preparent, postparent, xdata); - return 0; + 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, - dict_t *xdata) -{ - char statstr[1024] = {0, }; - char preoldparentstr[1024] = {0, }; - char postoldparentstr[1024] = {0, }; - char prenewparentstr[1024] = {0, }; - char postnewparentstr[1024] = {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[6044] = {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 { - 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); - } -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, dict_t *xdata) -{ - char statstr[1024] = {0, }; - 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) { - char string[4096] = {0,}; - if (op_ret == 0) { - 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); - } - - LOG_ELEMENT (conf, string); - } -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 *xdata, struct iatt *postparent) -{ - char statstr[1024] = {0, }; - char postparentstr[1024] = {0, }; - 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,}; - 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 { - 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); - } -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, +trace_readdirp_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, gf_dirent_t *buf, dict_t *xdata) { - char statstr[1024] = {0, }; - char preparentstr[1024] = {0, }; - char postparentstr[1024] = {0, }; - 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) { - 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 { - snprintf (string, sizeof (string), - "%"PRId64": op_ret=%d, op_errno=%d", - frame->root->unique, op_ret, - op_errno); - } - LOG_ELEMENT (conf, string); - } -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, dict_t *xdata) -{ - char statstr[1024] = {0, }; - char preparentstr[1024] = {0, }; - char postparentstr[1024] = {0, }; - 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_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 { - snprintf (string, sizeof (string), - "%"PRId64": (op_ret=%d, op_errno=%d)", - frame->root->unique, op_ret, - op_errno); - } - LOG_ELEMENT (conf, string); - } -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, dict_t *xdata) -{ - char statstr[1024] = {0, }; - char preparentstr[1024] = {0, }; - char postparentstr[1024] = {0, }; - 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) { - 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 { - snprintf (string, sizeof (string), - "%"PRId64": (op_ret=%d, op_errno=%d)", - frame->root->unique, op_ret, - op_errno); - } - LOG_ELEMENT (conf, string); - } -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, dict_t *xdata) -{ - char statstr[1024] = {0, }; - char preparentstr[1024] = {0, }; - char postparentstr[1024] = {0, }; - 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_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 { - 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); - } -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, dict_t *xdata) + int count = 0; + char statstr[1024] = { + 0, + }; + char string[4096] = { + 0, + }; + trace_conf_t *conf = NULL; + gf_dirent_t *entry = NULL; + + conf = this->private; + + if (!conf->log_file && !conf->log_history) + goto out; + if (trace_fop_names[GF_FOP_READDIRP].enabled) { + 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); + } + if (op_ret < 0) + goto out; + + list_for_each_entry(entry, &buf->list, list) + { + count++; + TRACE_STAT_TO_STR(&entry->d_stat, statstr); + snprintf(string, sizeof(string), + "entry no. %d, pargfid=%s, " + "bname=%s *buf {%s}", + count, uuid_utoa(frame->local), entry->d_name, statstr); + 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, dict_t *xdata) +{ + char preopstr[1024] = { + 0, + }; + char postopstr[1024] = { + 0, + }; + 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) { + 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 { + 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); + } +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, dict_t *xdata) +{ + char preopstr[1024] = { + 0, + }; + char postopstr[1024] = { + 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 (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 { + 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); + } +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, dict_t *xdata) +{ + char preopstr[1024] = { + 0, + }; + char postopstr[1024] = { + 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 (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 { + 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); + } +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, dict_t *xdata) +{ + char preparentstr[1024] = { + 0, + }; + char postparentstr[1024] = { + 0, + }; + 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) { + 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 { + 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); + } +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, + dict_t *xdata) +{ + char statstr[1024] = { + 0, + }; + char preoldparentstr[1024] = { + 0, + }; + char postoldparentstr[1024] = { + 0, + }; + char prenewparentstr[1024] = { + 0, + }; + char postnewparentstr[1024] = { + 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[6044] = { + 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 { + 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); + } +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, dict_t *xdata) +{ + char statstr[1024] = { + 0, + }; + 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) { + char string[4096] = { + 0, + }; + if (op_ret == 0) { + 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); + } + + LOG_ELEMENT(conf, string); + } +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 *xdata, struct iatt *postparent) +{ + char statstr[1024] = { + 0, + }; + char postparentstr[1024] = { + 0, + }; + 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, + }; + 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 { + 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); + } +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, dict_t *xdata) +{ + char statstr[1024] = { + 0, + }; + char preparentstr[1024] = { + 0, + }; + char postparentstr[1024] = { + 0, + }; + 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) { + 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 { + snprintf(string, sizeof(string), + "%" PRId64 ": op_ret=%d, op_errno=%d", frame->root->unique, + op_ret, op_errno); + } + LOG_ELEMENT(conf, string); + } +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, dict_t *xdata) +{ + char statstr[1024] = { + 0, + }; + char preparentstr[1024] = { + 0, + }; + char postparentstr[1024] = { + 0, + }; + 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_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 { + snprintf(string, sizeof(string), + "%" PRId64 ": (op_ret=%d, op_errno=%d)", + frame->root->unique, op_ret, op_errno); + } + LOG_ELEMENT(conf, string); + } +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, dict_t *xdata) +{ + char statstr[1024] = { + 0, + }; + char preparentstr[1024] = { + 0, + }; + char postparentstr[1024] = { + 0, + }; + 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) { + 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 { + snprintf(string, sizeof(string), + "%" PRId64 ": (op_ret=%d, op_errno=%d)", + frame->root->unique, op_ret, op_errno); + } + LOG_ELEMENT(conf, string); + } +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, dict_t *xdata) +{ + char statstr[1024] = { + 0, + }; + char preparentstr[1024] = { + 0, + }; + char postparentstr[1024] = { + 0, + }; + 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_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 { + 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); + } +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, 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) { + 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); + } +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, 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) { + 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); + + 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, dict_t *xdata) +{ + char preparentstr[1024] = { + 0, + }; + char postparentstr[1024] = { + 0, + }; + 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) { + 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 { + 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); + } +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, dict_t *xdata) +{ + char preopstr[1024] = { + 0, + }; + char postopstr[1024] = { + 0, + }; + 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) { + 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 { + 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); + } +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, + 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) { + 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 { + snprintf(string, sizeof(string), + "%" PRId64 + ": (op_ret=%d, " + "op_errno=%d)", + frame->root->unique, op_ret, op_errno); + } + LOG_ELEMENT(conf, string); + } +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, dict_t *xdata) { - trace_conf_t *conf = NULL; + trace_conf_t *conf = NULL; - conf = this->private; + conf = this->private; - if (!conf->log_file && !conf->log_history) - goto out; - char string[4096] = {0,}; - if (trace_fop_names[GF_FOP_FLUSH].enabled) { - 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 (!conf->log_file && !conf->log_history) + goto out; + if (trace_fop_names[GF_FOP_SETXATTR].enabled) { + 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); - } + LOG_ELEMENT(conf, string); + } out: - TRACE_STACK_UNWIND (flush, frame, op_ret, op_errno, xdata); - return 0; + TRACE_STACK_UNWIND(setxattr, 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, dict_t *xdata) +trace_getxattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, dict_t *dict, + dict_t *xdata) { - trace_conf_t *conf = NULL; + trace_conf_t *conf = NULL; - conf = this->private; + conf = this->private; - if (!conf->log_file && !conf->log_history) - goto out; - char string[4096] = {0,}; - if (trace_fop_names[GF_FOP_OPENDIR].enabled) { - 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); + if (!conf->log_file && !conf->log_history) + goto out; + if (trace_fop_names[GF_FOP_GETXATTR].enabled) { + 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); - LOG_ELEMENT (conf, string); - } + LOG_ELEMENT(conf, string); + } out: - /* for 'releasedir' log */ - if (op_ret >= 0) - fd_ctx_set (fd, this, 0); - - 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, dict_t *xdata) -{ - char preparentstr[1024] = {0, }; - char postparentstr[1024] = {0, }; - 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) { - 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 { - 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); - } -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, dict_t *xdata) -{ - char preopstr[1024] = {0, }; - char postopstr[1024] = {0, }; - 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) { - 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 { - 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); - } -out: - TRACE_STACK_UNWIND (truncate, frame, op_ret, op_errno, prebuf, - postbuf, xdata); - return 0; -} + TRACE_STACK_UNWIND(getxattr, frame, op_ret, op_errno, dict, xdata); -int -trace_statfs_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - 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) { - 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 { - snprintf (string, sizeof (string), - "%"PRId64": (op_ret=%d, " - "op_errno=%d)", - frame->root->unique, op_ret, - op_errno); - } - LOG_ELEMENT (conf, string); - } -out: - TRACE_STACK_UNWIND (statfs, frame, op_ret, op_errno, buf, xdata); - return 0; + return 0; } int -trace_setxattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this, +trace_fsetxattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int32_t op_ret, int32_t op_errno, dict_t *xdata) { - trace_conf_t *conf = NULL; + trace_conf_t *conf = NULL; - conf = this->private; + conf = this->private; - if (!conf->log_file && !conf->log_history) - goto out; - if (trace_fop_names[GF_FOP_SETXATTR].enabled) { - 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); + if (!conf->log_file && !conf->log_history) + goto out; + if (trace_fop_names[GF_FOP_FSETXATTR].enabled) { + 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); - } + LOG_ELEMENT(conf, string); + } out: - TRACE_STACK_UNWIND (setxattr, frame, op_ret, op_errno, xdata); - return 0; + TRACE_STACK_UNWIND(fsetxattr, frame, op_ret, op_errno, xdata); + return 0; } int -trace_getxattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this, +trace_fgetxattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int32_t op_ret, int32_t op_errno, dict_t *dict, dict_t *xdata) { - trace_conf_t *conf = NULL; + trace_conf_t *conf = NULL; - conf = this->private; + conf = this->private; - if (!conf->log_file && !conf->log_history) - goto out; - if (trace_fop_names[GF_FOP_GETXATTR].enabled) { - 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); + if (!conf->log_file && !conf->log_history) + goto out; + if (trace_fop_names[GF_FOP_FGETXATTR].enabled) { + 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); - LOG_ELEMENT (conf, string); - } + 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, 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) { - 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); + TRACE_STACK_UNWIND(fgetxattr, frame, op_ret, op_errno, dict, xdata); - LOG_ELEMENT (conf, string); - } -out: - TRACE_STACK_UNWIND (fsetxattr, frame, op_ret, op_errno, xdata); - return 0; + 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, - dict_t *xdata) +trace_removexattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, dict_t *xdata) { - trace_conf_t *conf = NULL; + trace_conf_t *conf = NULL; - conf = this->private; + conf = this->private; - if (!conf->log_file && !conf->log_history) - goto out; - if (trace_fop_names[GF_FOP_FGETXATTR].enabled) { - 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); + if (!conf->log_file && !conf->log_history) + goto out; + if (trace_fop_names[GF_FOP_REMOVEXATTR].enabled) { + 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); - } + LOG_ELEMENT(conf, string); + } out: - TRACE_STACK_UNWIND (fgetxattr, frame, op_ret, op_errno, dict, xdata); + TRACE_STACK_UNWIND(removexattr, frame, op_ret, op_errno, xdata); - return 0; + return 0; } int -trace_removexattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, dict_t *xdata) +trace_fsyncdir_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, dict_t *xdata) { - trace_conf_t *conf = NULL; + trace_conf_t *conf = NULL; - conf = this->private; + conf = this->private; - if (!conf->log_file && !conf->log_history) - goto out; - if (trace_fop_names[GF_FOP_REMOVEXATTR].enabled) { - 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); + if (!conf->log_file && !conf->log_history) + goto out; + if (trace_fop_names[GF_FOP_FSYNCDIR].enabled) { + 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); - } + LOG_ELEMENT(conf, string); + } out: - TRACE_STACK_UNWIND (removexattr, frame, op_ret, op_errno, xdata); - - return 0; + TRACE_STACK_UNWIND(fsyncdir, 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, dict_t *xdata) +trace_access_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + 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) { - 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); - } -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, + 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) { + 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); + } +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, dict_t *xdata) +{ + char prebufstr[1024] = { + 0, + }; + char postbufstr[1024] = { + 0, + }; + 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) { + 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 { + 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); + } +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, + dict_t *xdata) +{ + char statstr[1024] = { + 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) { + 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 { + 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); + } +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, 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) { + 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 { + 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); + } +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, dict_t *xdata) { - trace_conf_t *conf = NULL; + trace_conf_t *conf = NULL; - conf = this->private; + conf = this->private; - if (!conf->log_file && !conf->log_history) - goto out; - if (trace_fop_names[GF_FOP_ACCESS].enabled) { - 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); + if (!conf->log_file && !conf->log_history) + goto out; + if (trace_fop_names[GF_FOP_ENTRYLK].enabled) { + 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); - } + 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, dict_t *xdata) -{ - char prebufstr[1024] = {0, }; - char postbufstr[1024] = {0, }; - 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) { - 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 { - 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); - } -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, dict_t *xdata) -{ - char statstr[1024] = {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) { - 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 { - 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); - } -out: - TRACE_STACK_UNWIND (fstat, frame, op_ret, op_errno, buf, xdata); - return 0; + TRACE_STACK_UNWIND(entrylk, frame, op_ret, op_errno, 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, - 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) { - 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 { - 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); - } -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, +trace_fentrylk_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int32_t op_ret, int32_t op_errno, dict_t *xdata) { - trace_conf_t *conf = NULL; + trace_conf_t *conf = NULL; - conf = this->private; + conf = this->private; - if (!conf->log_file && !conf->log_history) - goto out; - if (trace_fop_names[GF_FOP_ENTRYLK].enabled) { - 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); + if (!conf->log_file && !conf->log_history) + goto out; + if (trace_fop_names[GF_FOP_FENTRYLK].enabled) { + 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); - } + LOG_ELEMENT(conf, string); + } out: - TRACE_STACK_UNWIND (entrylk, frame, op_ret, op_errno, xdata); - return 0; + TRACE_STACK_UNWIND(fentrylk, 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, dict_t *xdata) +trace_xattrop_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, dict_t *dict, dict_t *xdata) { - trace_conf_t *conf = NULL; + trace_conf_t *conf = NULL; - conf = this->private; + conf = this->private; - if (!conf->log_file && !conf->log_history) - goto out; - if (trace_fop_names[GF_FOP_FENTRYLK].enabled) { - 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); + if (!conf->log_file && !conf->log_history) + goto out; + if (trace_fop_names[GF_FOP_XATTROP].enabled) { + 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); - } + LOG_ELEMENT(conf, string); + } out: - TRACE_STACK_UNWIND (fentrylk, frame, op_ret, op_errno, xdata); - return 0; + TRACE_STACK_UNWIND(xattrop, frame, op_ret, op_errno, dict, xdata); + return 0; } int -trace_xattrop_cbk (call_frame_t *frame, void *cookie, xlator_t *this, +trace_fxattrop_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int32_t op_ret, int32_t op_errno, dict_t *dict, dict_t *xdata) { - trace_conf_t *conf = NULL; + trace_conf_t *conf = NULL; - conf = this->private; + conf = this->private; - if (!conf->log_file && !conf->log_history) - goto out; - if (trace_fop_names[GF_FOP_XATTROP].enabled) { - 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); + if (!conf->log_file && !conf->log_history) + goto out; + if (trace_fop_names[GF_FOP_FXATTROP].enabled) { + 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); - } + LOG_ELEMENT(conf, string); + } out: - TRACE_STACK_UNWIND (xattrop, frame, op_ret, op_errno, dict, xdata); - return 0; + TRACE_STACK_UNWIND(fxattrop, 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, - dict_t *xdata) +trace_inodelk_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, dict_t *xdata) { - trace_conf_t *conf = NULL; + trace_conf_t *conf = NULL; - conf = this->private; + conf = this->private; - if (!conf->log_file && !conf->log_history) - goto out; - if (trace_fop_names[GF_FOP_FXATTROP].enabled) { - 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); + if (!conf->log_file && !conf->log_history) + goto out; + if (trace_fop_names[GF_FOP_INODELK].enabled) { + 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); - } + LOG_ELEMENT(conf, string); + } out: - TRACE_STACK_UNWIND (fxattrop, frame, op_ret, op_errno, dict, xdata); - return 0; + TRACE_STACK_UNWIND(inodelk, frame, op_ret, op_errno, xdata); + return 0; } int -trace_inodelk_cbk (call_frame_t *frame, void *cookie, xlator_t *this, +trace_finodelk_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int32_t op_ret, int32_t op_errno, dict_t *xdata) { - trace_conf_t *conf = NULL; + trace_conf_t *conf = NULL; - conf = this->private; + conf = this->private; - if (!conf->log_file && !conf->log_history) - goto out; - if (trace_fop_names[GF_FOP_INODELK].enabled) { - 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); + if (!conf->log_file && !conf->log_history) + goto out; + if (trace_fop_names[GF_FOP_FINODELK].enabled) { + 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); - } -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, 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) { - 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); - } + LOG_ELEMENT(conf, string); + } out: - TRACE_STACK_UNWIND (finodelk, frame, op_ret, op_errno, xdata); - return 0; + 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, - dict_t *xdata) +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, dict_t *xdata) { - trace_conf_t *conf = NULL; + trace_conf_t *conf = NULL; - conf = this->private; + conf = this->private; - if (!conf->log_file && !conf->log_history) - goto out; - if (trace_fop_names[GF_FOP_RCHECKSUM].enabled) { - 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); + if (!conf->log_file && !conf->log_history) + goto out; + if (trace_fop_names[GF_FOP_RCHECKSUM].enabled) { + 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); - } + LOG_ELEMENT(conf, string); + } out: - TRACE_STACK_UNWIND (rchecksum, frame, op_ret, op_errno, weak_checksum, - strong_checksum, xdata); + TRACE_STACK_UNWIND(rchecksum, frame, op_ret, op_errno, weak_checksum, + strong_checksum, xdata); - return 0; + return 0; } /* *_cbk section over <----------> fop section start */ 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, dict_t *xdata) +trace_entrylk(call_frame_t *frame, xlator_t *this, const char *volume, + loc_t *loc, const char *basename, entrylk_cmd cmd, + entrylk_type type, dict_t *xdata) { - trace_conf_t *conf = NULL; + trace_conf_t *conf = NULL; - conf = this->private; + conf = this->private; - if (!conf->log_file && !conf->log_history) - goto out; - if (trace_fop_names[GF_FOP_ENTRYLK].enabled) { - 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")); + if (!conf->log_file && !conf->log_history) + goto out; + if (trace_fop_names[GF_FOP_ENTRYLK].enabled) { + 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; + frame->local = loc->inode->gfid; - LOG_ELEMENT (conf, string); - } + LOG_ELEMENT(conf, string); + } out: - STACK_WIND (frame, trace_entrylk_cbk, - FIRST_CHILD (this), - FIRST_CHILD (this)->fops->entrylk, - volume, loc, basename, cmd, type, xdata); - return 0; + STACK_WIND(frame, trace_entrylk_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->entrylk, 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, dict_t *xdata) +trace_inodelk(call_frame_t *frame, xlator_t *this, const char *volume, + loc_t *loc, int32_t cmd, struct gf_flock *flock, dict_t *xdata) { - char *cmd_str = NULL; - char *type_str = NULL; - trace_conf_t *conf = NULL; + char *cmd_str = NULL; + char *type_str = NULL; + trace_conf_t *conf = NULL; - conf = this->private; + 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 (!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: + case F_GETLK64: #endif - case F_GETLK: - cmd_str = "GETLK"; - break; + case F_GETLK: + cmd_str = "GETLK"; + break; #if F_SETLK != F_SETLK64 - case F_SETLK64: + case F_SETLK64: #endif - case F_SETLK: - cmd_str = "SETLK"; - break; + case F_SETLK: + cmd_str = "SETLK"; + break; #if F_SETLKW != F_SETLKW64 - case F_SETLKW64: + case F_SETLKW64: #endif - case F_SETLKW: - cmd_str = "SETLKW"; - break; - - default: - cmd_str = "UNKNOWN"; - break; - } - - switch (flock->l_type) { - case F_RDLCK: - type_str = "READ"; - break; - case F_WRLCK: - type_str = "WRITE"; - break; - case F_UNLCK: - type_str = "UNLOCK"; - break; - default: - type_str = "UNKNOWN"; - break; - } - - 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); + case F_SETLKW: + cmd_str = "SETLKW"; + break; + + default: + cmd_str = "UNKNOWN"; + break; + } + + switch (flock->l_type) { + case F_RDLCK: + type_str = "READ"; + break; + case F_WRLCK: + type_str = "WRITE"; + break; + case F_UNLCK: + type_str = "UNLOCK"; + break; + default: + type_str = "UNKNOWN"; + break; } + 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, xdata); - return 0; + STACK_WIND(frame, trace_inodelk_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->inodelk, 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, dict_t *xdata) +trace_finodelk(call_frame_t *frame, xlator_t *this, const char *volume, + fd_t *fd, int32_t cmd, struct gf_flock *flock, dict_t *xdata) { - char *cmd_str = NULL; - char *type_str = NULL; - trace_conf_t *conf = NULL; + char *cmd_str = NULL; + char *type_str = NULL; + trace_conf_t *conf = NULL; - conf = this->private; + 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 (!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: + case F_GETLK64: #endif - case F_GETLK: - cmd_str = "GETLK"; - break; + case F_GETLK: + cmd_str = "GETLK"; + break; #if F_SETLK != F_SETLK64 - case F_SETLK64: + case F_SETLK64: #endif - case F_SETLK: - cmd_str = "SETLK"; - break; + case F_SETLK: + cmd_str = "SETLK"; + break; #if F_SETLKW != F_SETLKW64 - case F_SETLKW64: + case F_SETLKW64: #endif - case F_SETLKW: - cmd_str = "SETLKW"; - break; - - default: - cmd_str = "UNKNOWN"; - break; - } - - switch (flock->l_type) { - case F_RDLCK: - type_str = "READ"; - break; - case F_WRLCK: - type_str = "WRITE"; - break; - case F_UNLCK: - type_str = "UNLOCK"; - break; - default: - type_str = "UNKNOWN"; - break; - } - - 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); + case F_SETLKW: + cmd_str = "SETLKW"; + break; + + default: + cmd_str = "UNKNOWN"; + break; } + + switch (flock->l_type) { + case F_RDLCK: + type_str = "READ"; + break; + case F_WRLCK: + type_str = "WRITE"; + break; + case F_UNLCK: + type_str = "UNLOCK"; + break; + default: + type_str = "UNKNOWN"; + break; + } + + 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, xdata); - return 0; + STACK_WIND(frame, trace_finodelk_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->finodelk, 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, dict_t *xdata) +trace_xattrop(call_frame_t *frame, xlator_t *this, loc_t *loc, + gf_xattrop_flags_t flags, dict_t *dict, dict_t *xdata) { - trace_conf_t *conf = NULL; + trace_conf_t *conf = NULL; - conf = this->private; + conf = this->private; - if (!conf->log_file && !conf->log_history) - goto out; - if (trace_fop_names[GF_FOP_XATTROP].enabled) { - 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); + if (!conf->log_file && !conf->log_history) + goto out; + if (trace_fop_names[GF_FOP_XATTROP].enabled) { + 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; + frame->local = loc->inode->gfid; - LOG_ELEMENT (conf, string); - } + LOG_ELEMENT(conf, string); + } out: - STACK_WIND (frame, trace_xattrop_cbk, - FIRST_CHILD(this), - FIRST_CHILD(this)->fops->xattrop, - loc, flags, dict, xdata); + STACK_WIND(frame, trace_xattrop_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->xattrop, loc, flags, dict, xdata); - return 0; + return 0; } int -trace_fxattrop (call_frame_t *frame, xlator_t *this, fd_t *fd, - gf_xattrop_flags_t flags, dict_t *dict, dict_t *xdata) +trace_fxattrop(call_frame_t *frame, xlator_t *this, fd_t *fd, + gf_xattrop_flags_t flags, dict_t *dict, dict_t *xdata) { - trace_conf_t *conf = NULL; + trace_conf_t *conf = NULL; - conf = this->private; + conf = this->private; - if (!conf->log_file && !conf->log_history) - goto out; - if (trace_fop_names[GF_FOP_FXATTROP].enabled) { - 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); + if (!conf->log_file && !conf->log_history) + goto out; + if (trace_fop_names[GF_FOP_FXATTROP].enabled) { + 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; + frame->local = fd->inode->gfid; - LOG_ELEMENT (conf, string); - } + LOG_ELEMENT(conf, string); + } out: - STACK_WIND (frame, trace_fxattrop_cbk, - FIRST_CHILD(this), - FIRST_CHILD(this)->fops->fxattrop, - fd, flags, dict, xdata); + STACK_WIND(frame, trace_fxattrop_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->fxattrop, fd, flags, dict, xdata); - return 0; + return 0; } int -trace_lookup (call_frame_t *frame, xlator_t *this, - loc_t *loc, dict_t *xdata) +trace_lookup(call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *xdata) { - trace_conf_t *conf = NULL; + trace_conf_t *conf = NULL; - conf = this->private; + 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 */ - snprintf (string, sizeof (string), - "%"PRId64": gfid=%s path=%s", - frame->root->unique, - uuid_utoa (loc->inode->gfid), loc->path); + 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 */ + snprintf(string, sizeof(string), "%" PRId64 ": gfid=%s path=%s", + frame->root->unique, uuid_utoa(loc->inode->gfid), loc->path); - frame->local = loc->inode->gfid; + frame->local = loc->inode->gfid; - LOG_ELEMENT (conf, string); - } + LOG_ELEMENT(conf, string); + } out: - STACK_WIND (frame, trace_lookup_cbk, - FIRST_CHILD(this), - FIRST_CHILD(this)->fops->lookup, - loc, xdata); + STACK_WIND(frame, trace_lookup_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->lookup, loc, xdata); - return 0; + return 0; } int -trace_stat (call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *xdata) +trace_stat(call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *xdata) { - trace_conf_t *conf = NULL; + trace_conf_t *conf = NULL; - conf = this->private; + conf = this->private; - if (!conf->log_file && !conf->log_history) - goto out; - if (trace_fop_names[GF_FOP_STAT].enabled) { - char string[4096] = {0,}; - snprintf (string, sizeof (string), - "%"PRId64": gfid=%s path=%s", - frame->root->unique, - uuid_utoa (loc->inode->gfid), loc->path); + if (!conf->log_file && !conf->log_history) + goto out; + if (trace_fop_names[GF_FOP_STAT].enabled) { + 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; + frame->local = loc->inode->gfid; - LOG_ELEMENT (conf, string); - } + LOG_ELEMENT(conf, string); + } out: - STACK_WIND (frame, trace_stat_cbk, - FIRST_CHILD(this), - FIRST_CHILD(this)->fops->stat, - loc, xdata); + STACK_WIND(frame, trace_stat_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->stat, loc, xdata); - return 0; + return 0; } int -trace_readlink (call_frame_t *frame, xlator_t *this, loc_t *loc, size_t size, - dict_t *xdata) +trace_readlink(call_frame_t *frame, xlator_t *this, loc_t *loc, size_t size, + dict_t *xdata) { - trace_conf_t *conf = NULL; + trace_conf_t *conf = NULL; - conf = this->private; + conf = this->private; - if (!conf->log_file && !conf->log_history) - goto out; - if (trace_fop_names[GF_FOP_READLINK].enabled) { - 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); + if (!conf->log_file && !conf->log_history) + goto out; + if (trace_fop_names[GF_FOP_READLINK].enabled) { + 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; + frame->local = loc->inode->gfid; - LOG_ELEMENT (conf, string); - } + LOG_ELEMENT(conf, string); + } out: - STACK_WIND (frame, trace_readlink_cbk, - FIRST_CHILD(this), - FIRST_CHILD(this)->fops->readlink, - loc, size, xdata); + STACK_WIND(frame, trace_readlink_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->readlink, loc, size, xdata); - return 0; + return 0; } int -trace_mknod (call_frame_t *frame, xlator_t *this, loc_t *loc, - mode_t mode, dev_t dev, mode_t umask, dict_t *xdata) +trace_mknod(call_frame_t *frame, xlator_t *this, loc_t *loc, mode_t mode, + dev_t dev, mode_t umask, dict_t *xdata) { - trace_conf_t *conf = NULL; + trace_conf_t *conf = NULL; - conf = this->private; + conf = this->private; - if (!conf->log_file && !conf->log_history) - goto out; - if (trace_fop_names[GF_FOP_MKNOD].enabled) { - 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); + if (!conf->log_file && !conf->log_history) + goto out; + if (trace_fop_names[GF_FOP_MKNOD].enabled) { + 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); - } + LOG_ELEMENT(conf, string); + } out: - STACK_WIND (frame, trace_mknod_cbk, - FIRST_CHILD(this), - FIRST_CHILD(this)->fops->mknod, - loc, mode, dev, umask, xdata); + STACK_WIND(frame, trace_mknod_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->mknod, loc, mode, dev, umask, xdata); - return 0; + return 0; } int -trace_mkdir (call_frame_t *frame, xlator_t *this, loc_t *loc, mode_t mode, - mode_t umask, dict_t *xdata) +trace_mkdir(call_frame_t *frame, xlator_t *this, loc_t *loc, mode_t mode, + mode_t umask, dict_t *xdata) { - trace_conf_t *conf = NULL; + trace_conf_t *conf = NULL; - conf = this->private; + conf = this->private; - if (!conf->log_file && !conf->log_history) - goto out; - if (trace_fop_names[GF_FOP_MKDIR].enabled) { - 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); + if (!conf->log_file && !conf->log_history) + goto out; + if (trace_fop_names[GF_FOP_MKDIR].enabled) { + 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); - } + LOG_ELEMENT(conf, string); + } out: - STACK_WIND (frame, trace_mkdir_cbk, - FIRST_CHILD(this), - FIRST_CHILD(this)->fops->mkdir, - loc, mode, umask, xdata); - return 0; + STACK_WIND(frame, trace_mkdir_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->mkdir, loc, mode, umask, xdata); + return 0; } int -trace_unlink (call_frame_t *frame, xlator_t *this, loc_t *loc, int xflag, - dict_t *xdata) +trace_unlink(call_frame_t *frame, xlator_t *this, loc_t *loc, int xflag, + dict_t *xdata) { - trace_conf_t *conf = NULL; + trace_conf_t *conf = NULL; - conf = this->private; + conf = this->private; - if (!conf->log_file && !conf->log_history) - goto out; - if (trace_fop_names[GF_FOP_UNLINK].enabled) { - 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); + if (!conf->log_file && !conf->log_history) + goto out; + if (trace_fop_names[GF_FOP_UNLINK].enabled) { + 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; + frame->local = loc->inode->gfid; - LOG_ELEMENT (conf, string); - } + LOG_ELEMENT(conf, string); + } out: - STACK_WIND (frame, trace_unlink_cbk, - FIRST_CHILD(this), - FIRST_CHILD(this)->fops->unlink, - loc, xflag, xdata); - return 0; + STACK_WIND(frame, trace_unlink_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->unlink, loc, xflag, xdata); + return 0; } int -trace_rmdir (call_frame_t *frame, xlator_t *this, loc_t *loc, int flags, - dict_t *xdata) +trace_rmdir(call_frame_t *frame, xlator_t *this, loc_t *loc, int flags, + dict_t *xdata) { - trace_conf_t *conf = NULL; + trace_conf_t *conf = NULL; - conf = this->private; + conf = this->private; - if (!conf->log_file && !conf->log_history) - goto out; - if (trace_fop_names[GF_FOP_RMDIR].enabled) { - 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); + if (!conf->log_file && !conf->log_history) + goto out; + if (trace_fop_names[GF_FOP_RMDIR].enabled) { + 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; + frame->local = loc->inode->gfid; - LOG_ELEMENT (conf, string); - } + LOG_ELEMENT(conf, string); + } out: - STACK_WIND (frame, trace_rmdir_cbk, - FIRST_CHILD(this), - FIRST_CHILD(this)->fops->rmdir, - loc, flags, xdata); + STACK_WIND(frame, trace_rmdir_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->rmdir, loc, flags, xdata); - return 0; + return 0; } int -trace_symlink (call_frame_t *frame, xlator_t *this, const char *linkpath, - loc_t *loc, mode_t umask, dict_t *xdata) +trace_symlink(call_frame_t *frame, xlator_t *this, const char *linkpath, + loc_t *loc, mode_t umask, dict_t *xdata) { - trace_conf_t *conf = NULL; + trace_conf_t *conf = NULL; - conf = this->private; + conf = this->private; - if (!conf->log_file && !conf->log_history) - goto out; - if (trace_fop_names[GF_FOP_SYMLINK].enabled) { - 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); + if (!conf->log_file && !conf->log_history) + goto out; + if (trace_fop_names[GF_FOP_SYMLINK].enabled) { + 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); - } + LOG_ELEMENT(conf, string); + } out: - STACK_WIND (frame, trace_symlink_cbk, - FIRST_CHILD(this), - FIRST_CHILD(this)->fops->symlink, - linkpath, loc, umask, xdata); + STACK_WIND(frame, trace_symlink_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->symlink, linkpath, loc, umask, xdata); - return 0; + return 0; } int -trace_rename (call_frame_t *frame, xlator_t *this, loc_t *oldloc, loc_t *newloc, - dict_t *xdata) +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,}; - trace_conf_t *conf = NULL; + char oldgfid[50] = { + 0, + }; + char newgfid[50] = { + 0, + }; + trace_conf_t *conf = NULL; - conf = this->private; + 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 - strcpy (newgfid, "0"); + 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 + strcpy(newgfid, "0"); - uuid_utoa_r (oldloc->inode->gfid, oldgfid); + uuid_utoa_r(oldloc->inode->gfid, oldgfid); - snprintf (string, sizeof (string), - "%"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; + frame->local = oldloc->inode->gfid; - LOG_ELEMENT (conf, string); - } + LOG_ELEMENT(conf, string); + } out: - STACK_WIND (frame, trace_rename_cbk, - FIRST_CHILD(this), - FIRST_CHILD(this)->fops->rename, - oldloc, newloc, xdata); + STACK_WIND(frame, trace_rename_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->rename, oldloc, newloc, xdata); - return 0; + return 0; } int -trace_link (call_frame_t *frame, xlator_t *this, loc_t *oldloc, loc_t *newloc, - dict_t *xdata) +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,}; - trace_conf_t *conf = NULL; + char oldgfid[50] = { + 0, + }; + char newgfid[50] = { + 0, + }; + trace_conf_t *conf = NULL; - conf = this->private; + 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 - strcpy (newgfid, "0"); + 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 + strcpy(newgfid, "0"); - uuid_utoa_r (oldloc->inode->gfid, oldgfid); + uuid_utoa_r(oldloc->inode->gfid, oldgfid); - snprintf (string, sizeof (string), - "%"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; + frame->local = oldloc->inode->gfid; - LOG_ELEMENT (conf, string); - } + LOG_ELEMENT(conf, string); + } out: - STACK_WIND (frame, trace_link_cbk, - FIRST_CHILD(this), - FIRST_CHILD(this)->fops->link, - oldloc, newloc, xdata); - return 0; + STACK_WIND(frame, trace_link_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->link, oldloc, newloc, xdata); + return 0; } int -trace_setattr (call_frame_t *frame, xlator_t *this, loc_t *loc, - struct iatt *stbuf, int32_t valid, dict_t *xdata) +trace_setattr(call_frame_t *frame, xlator_t *this, loc_t *loc, + struct iatt *stbuf, int32_t valid, dict_t *xdata) { - 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) { - 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)) { - 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)) { - gf_time_fmt (actime_str, sizeof actime_str, - stbuf->ia_atime, gf_timefmt_bdT); - - gf_time_fmt (modtime_str, sizeof modtime_str, - stbuf->ia_mtime, gf_timefmt_bdT); - - 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; + 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) { + 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)) { + 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)) { + gf_time_fmt(actime_str, sizeof actime_str, stbuf->ia_atime, + gf_timefmt_bdT); + + gf_time_fmt(modtime_str, sizeof modtime_str, stbuf->ia_mtime, + gf_timefmt_bdT); + + 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, xdata); + STACK_WIND(frame, trace_setattr_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->setattr, loc, stbuf, valid, xdata); - return 0; + return 0; } int -trace_fsetattr (call_frame_t *frame, xlator_t *this, fd_t *fd, - struct iatt *stbuf, int32_t valid, dict_t *xdata) +trace_fsetattr(call_frame_t *frame, xlator_t *this, fd_t *fd, + struct iatt *stbuf, int32_t valid, dict_t *xdata) { - char actime_str[256] = {0,}; - char modtime_str[256] = {0,}; - trace_conf_t *conf = NULL; + char actime_str[256] = { + 0, + }; + char modtime_str[256] = { + 0, + }; + trace_conf_t *conf = NULL; - conf = this->private; + 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) { - 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)); + 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) { + 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)); - } + LOG_ELEMENT(conf, string); + memset(string, 0, sizeof(string)); + } - if (valid & (GF_SET_ATTR_UID | GF_SET_ATTR_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); + if (valid & (GF_SET_ATTR_UID | GF_SET_ATTR_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)); - } + LOG_ELEMENT(conf, string); + memset(string, 0, sizeof(string)); + } - if (valid & (GF_SET_ATTR_ATIME | GF_SET_ATTR_MTIME)) { - gf_time_fmt (actime_str, sizeof actime_str, - stbuf->ia_atime, gf_timefmt_bdT); + if (valid & (GF_SET_ATTR_ATIME | GF_SET_ATTR_MTIME)) { + gf_time_fmt(actime_str, sizeof actime_str, stbuf->ia_atime, + gf_timefmt_bdT); - gf_time_fmt (modtime_str, sizeof modtime_str, - stbuf->ia_mtime, gf_timefmt_bdT); + gf_time_fmt(modtime_str, sizeof modtime_str, stbuf->ia_mtime, + gf_timefmt_bdT); - 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); + 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; + 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, xdata); + STACK_WIND(frame, trace_fsetattr_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->fsetattr, fd, stbuf, valid, xdata); - return 0; + return 0; } static int -trace_seek_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, off_t offset, dict_t *xdata) -{ - trace_conf_t *conf = this->private; - - if (!conf->log_file && !conf->log_history) - goto out; - if (trace_fop_names[GF_FOP_SEEK].enabled) { - char string[4096] = {0,}; - snprintf (string, sizeof (string), - "%"PRId64": gfid=%s op_ret=%d op_errno=%d, " - "offset=%"PRId64"", frame->root->unique, - uuid_utoa (frame->local), op_ret, op_errno, offset); - LOG_ELEMENT (conf, string); - } -out: - TRACE_STACK_UNWIND (seek, frame, op_ret, op_errno, offset, xdata); - return 0; +trace_seek_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, off_t offset, dict_t *xdata) +{ + trace_conf_t *conf = this->private; + + if (!conf->log_file && !conf->log_history) + goto out; + if (trace_fop_names[GF_FOP_SEEK].enabled) { + char string[4096] = { + 0, + }; + snprintf(string, sizeof(string), + "%" PRId64 + ": gfid=%s op_ret=%d op_errno=%d, " + "offset=%" PRId64 "", + frame->root->unique, uuid_utoa(frame->local), op_ret, op_errno, + offset); + LOG_ELEMENT(conf, string); + } +out: + TRACE_STACK_UNWIND(seek, frame, op_ret, op_errno, offset, xdata); + return 0; } static int -trace_seek (call_frame_t *frame, xlator_t *this, fd_t *fd, - off_t offset, gf_seek_what_t what, dict_t *xdata) +trace_seek(call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset, + gf_seek_what_t what, dict_t *xdata) { - trace_conf_t *conf = this->private; + trace_conf_t *conf = this->private; - if (!conf->log_file && !conf->log_history) - goto out; - if (trace_fop_names[GF_FOP_SEEK].enabled) { - char string[4096] = {0,}; - snprintf (string, sizeof (string), "%"PRId64": gfid=%s fd=%p " - "offset=%"PRId64" what=%d", frame->root->unique, - uuid_utoa (fd->inode->gfid), fd, offset, what); + if (!conf->log_file && !conf->log_history) + goto out; + if (trace_fop_names[GF_FOP_SEEK].enabled) { + char string[4096] = { + 0, + }; + snprintf(string, sizeof(string), + "%" PRId64 + ": gfid=%s fd=%p " + "offset=%" PRId64 " what=%d", + frame->root->unique, uuid_utoa(fd->inode->gfid), fd, offset, + what); - frame->local = fd->inode->gfid; - LOG_ELEMENT (conf, string); - } + frame->local = fd->inode->gfid; + LOG_ELEMENT(conf, string); + } out: - STACK_WIND (frame, trace_seek_cbk, FIRST_CHILD(this), - FIRST_CHILD(this)->fops->seek, fd, offset, what, xdata); + STACK_WIND(frame, trace_seek_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->seek, fd, offset, what, xdata); - return 0; + return 0; } int -trace_truncate (call_frame_t *frame, xlator_t *this, loc_t *loc, - off_t offset, dict_t *xdata) +trace_truncate(call_frame_t *frame, xlator_t *this, loc_t *loc, off_t offset, + dict_t *xdata) { - trace_conf_t *conf = NULL; + trace_conf_t *conf = NULL; - conf = this->private; + conf = this->private; - if (!conf->log_file && !conf->log_history) - goto out; - if (trace_fop_names[GF_FOP_TRUNCATE].enabled) { - 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); + if (!conf->log_file && !conf->log_history) + goto out; + if (trace_fop_names[GF_FOP_TRUNCATE].enabled) { + 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; + frame->local = loc->inode->gfid; - LOG_ELEMENT (conf, string); - } + LOG_ELEMENT(conf, string); + } out: - STACK_WIND (frame, trace_truncate_cbk, - FIRST_CHILD(this), - FIRST_CHILD(this)->fops->truncate, - loc, offset, xdata); + STACK_WIND(frame, trace_truncate_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->truncate, loc, offset, xdata); - return 0; + return 0; } int -trace_open (call_frame_t *frame, xlator_t *this, loc_t *loc, - int32_t flags, fd_t *fd, dict_t *xdata) +trace_open(call_frame_t *frame, xlator_t *this, loc_t *loc, int32_t flags, + fd_t *fd, dict_t *xdata) { - trace_conf_t *conf = NULL; + trace_conf_t *conf = NULL; - conf = this->private; + conf = this->private; - if (!conf->log_file && !conf->log_history) - goto out; - if (trace_fop_names[GF_FOP_OPEN].enabled) { - 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); + if (!conf->log_file && !conf->log_history) + goto out; + if (trace_fop_names[GF_FOP_OPEN].enabled) { + 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; + frame->local = loc->inode->gfid; - LOG_ELEMENT (conf, string); - } + LOG_ELEMENT(conf, string); + } out: - STACK_WIND (frame, trace_open_cbk, - FIRST_CHILD(this), - FIRST_CHILD(this)->fops->open, - loc, flags, fd, xdata); - return 0; + STACK_WIND(frame, trace_open_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->open, 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, mode_t umask, fd_t *fd, - dict_t *xdata) +trace_create(call_frame_t *frame, xlator_t *this, loc_t *loc, int32_t flags, + mode_t mode, mode_t umask, fd_t *fd, dict_t *xdata) { - trace_conf_t *conf = NULL; + trace_conf_t *conf = NULL; - conf = this->private; + conf = this->private; - if (!conf->log_file && !conf->log_history) - goto out; - if (trace_fop_names[GF_FOP_CREATE].enabled) { - 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); + if (!conf->log_file && !conf->log_history) + goto out; + if (trace_fop_names[GF_FOP_CREATE].enabled) { + 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); - } + LOG_ELEMENT(conf, string); + } out: - STACK_WIND (frame, trace_create_cbk, - FIRST_CHILD(this), - FIRST_CHILD(this)->fops->create, - loc, flags, mode, umask, fd, xdata); - return 0; + STACK_WIND(frame, trace_create_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->create, loc, flags, mode, umask, fd, + xdata); + return 0; } int -trace_readv (call_frame_t *frame, xlator_t *this, fd_t *fd, - size_t size, off_t offset, uint32_t flags, dict_t *xdata) +trace_readv(call_frame_t *frame, xlator_t *this, fd_t *fd, size_t size, + off_t offset, uint32_t flags, dict_t *xdata) { - trace_conf_t *conf = NULL; + trace_conf_t *conf = NULL; - conf = this->private; + conf = this->private; - if (!conf->log_file && !conf->log_history) - goto out; - if (trace_fop_names[GF_FOP_READ].enabled) { - 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); + if (!conf->log_file && !conf->log_history) + goto out; + if (trace_fop_names[GF_FOP_READ].enabled) { + 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; + frame->local = fd->inode->gfid; - LOG_ELEMENT (conf, string); - } + LOG_ELEMENT(conf, string); + } out: - STACK_WIND (frame, trace_readv_cbk, - FIRST_CHILD(this), - FIRST_CHILD(this)->fops->readv, - fd, size, offset, flags, xdata); - return 0; + STACK_WIND(frame, trace_readv_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->readv, fd, size, offset, flags, xdata); + return 0; } int -trace_writev (call_frame_t *frame, xlator_t *this, fd_t *fd, - struct iovec *vector, int32_t count, - off_t offset, uint32_t flags, struct iobref *iobref, dict_t *xdata) +trace_writev(call_frame_t *frame, xlator_t *this, fd_t *fd, + struct iovec *vector, int32_t count, off_t offset, uint32_t flags, + struct iobref *iobref, dict_t *xdata) { - trace_conf_t *conf = NULL; - int i = 0; - size_t total_size = 0; + trace_conf_t *conf = NULL; + int i = 0; + size_t total_size = 0; - conf = this->private; + conf = this->private; - if (!conf->log_file && !conf->log_history) - goto out; - if (trace_fop_names[GF_FOP_WRITE].enabled) { - char string[4096] = {0,}; - for (i = 0; i < count; i++) - total_size += vector[i].iov_len; + if (!conf->log_file && !conf->log_history) + goto out; + if (trace_fop_names[GF_FOP_WRITE].enabled) { + char string[4096] = { + 0, + }; + for (i = 0; i < count; i++) + total_size += vector[i].iov_len; - snprintf (string, sizeof (string), - "%"PRId64": gfid=%s fd=%p, count=%d, " - " offset=%"PRId64" flags=0%x write_size=%zu", - frame->root->unique, - uuid_utoa (fd->inode->gfid), fd, count, - offset, flags, total_size); + snprintf(string, sizeof(string), + "%" PRId64 + ": gfid=%s fd=%p, count=%d, " + " offset=%" PRId64 " flags=0%x write_size=%zu", + frame->root->unique, uuid_utoa(fd->inode->gfid), fd, count, + offset, flags, total_size); - frame->local = fd->inode->gfid; + frame->local = fd->inode->gfid; - LOG_ELEMENT (conf, string); - } + LOG_ELEMENT(conf, string); + } out: - STACK_WIND (frame, trace_writev_cbk, - FIRST_CHILD(this), - FIRST_CHILD(this)->fops->writev, - fd, vector, count, offset, flags, iobref, xdata); - return 0; + STACK_WIND(frame, trace_writev_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->writev, fd, vector, count, offset, + flags, iobref, xdata); + return 0; } int -trace_statfs (call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *xdata) +trace_statfs(call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *xdata) { - trace_conf_t *conf = NULL; + trace_conf_t *conf = NULL; - conf = this->private; + conf = this->private; - if (!conf->log_file && !conf->log_history) - goto out; - if (trace_fop_names[GF_FOP_STATFS].enabled) { - 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); + if (!conf->log_file && !conf->log_history) + goto out; + if (trace_fop_names[GF_FOP_STATFS].enabled) { + 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); - } + LOG_ELEMENT(conf, string); + } out: - STACK_WIND (frame, trace_statfs_cbk, - FIRST_CHILD(this), - FIRST_CHILD(this)->fops->statfs, - loc, xdata); - return 0; + STACK_WIND(frame, trace_statfs_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->statfs, loc, xdata); + return 0; } int -trace_flush (call_frame_t *frame, xlator_t *this, fd_t *fd, dict_t *xdata) +trace_flush(call_frame_t *frame, xlator_t *this, fd_t *fd, dict_t *xdata) { - trace_conf_t *conf = NULL; + trace_conf_t *conf = NULL; - conf = this->private; + conf = this->private; - if (!conf->log_file && !conf->log_history) - goto out; - if (trace_fop_names[GF_FOP_FLUSH].enabled) { - char string[4096] = {0,}; - snprintf (string, sizeof (string), - "%"PRId64": gfid=%s fd=%p", - frame->root->unique, - uuid_utoa (fd->inode->gfid), fd); + if (!conf->log_file && !conf->log_history) + goto out; + if (trace_fop_names[GF_FOP_FLUSH].enabled) { + 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; + frame->local = fd->inode->gfid; - LOG_ELEMENT (conf, string); - } + LOG_ELEMENT(conf, string); + } out: - STACK_WIND (frame, trace_flush_cbk, - FIRST_CHILD(this), - FIRST_CHILD(this)->fops->flush, - fd, xdata); - return 0; + STACK_WIND(frame, trace_flush_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->flush, fd, xdata); + return 0; } int -trace_fsync (call_frame_t *frame, xlator_t *this, fd_t *fd, int32_t flags, - dict_t *xdata) +trace_fsync(call_frame_t *frame, xlator_t *this, fd_t *fd, int32_t flags, + dict_t *xdata) { - trace_conf_t *conf = NULL; + trace_conf_t *conf = NULL; - conf = this->private; + conf = this->private; - if (!conf->log_file && !conf->log_history) - goto out; - if (trace_fop_names[GF_FOP_FSYNC].enabled) { - 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); + if (!conf->log_file && !conf->log_history) + goto out; + if (trace_fop_names[GF_FOP_FSYNC].enabled) { + 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; + frame->local = fd->inode->gfid; - LOG_ELEMENT (conf, string); - } + LOG_ELEMENT(conf, string); + } out: - STACK_WIND (frame, trace_fsync_cbk, - FIRST_CHILD(this), - FIRST_CHILD(this)->fops->fsync, - fd, flags, xdata); - return 0; + STACK_WIND(frame, trace_fsync_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->fsync, fd, flags, xdata); + return 0; } int -trace_setxattr (call_frame_t *frame, xlator_t *this, - loc_t *loc, dict_t *dict, int32_t flags, dict_t *xdata) +trace_setxattr(call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *dict, + int32_t flags, dict_t *xdata) { - trace_conf_t *conf = NULL; + trace_conf_t *conf = NULL; - conf = this->private; + conf = this->private; - if (!conf->log_file && !conf->log_history) - goto out; - if (trace_fop_names[GF_FOP_SETXATTR].enabled) { - 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); + if (!conf->log_file && !conf->log_history) + goto out; + if (trace_fop_names[GF_FOP_SETXATTR].enabled) { + 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; + frame->local = loc->inode->gfid; - LOG_ELEMENT (conf, string); - } + LOG_ELEMENT(conf, string); + } out: - STACK_WIND (frame, trace_setxattr_cbk, - FIRST_CHILD(this), - FIRST_CHILD(this)->fops->setxattr, - loc, dict, flags, xdata); - return 0; + STACK_WIND(frame, trace_setxattr_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->setxattr, loc, dict, flags, xdata); + return 0; } int -trace_getxattr (call_frame_t *frame, xlator_t *this, - loc_t *loc, const char *name, dict_t *xdata) +trace_getxattr(call_frame_t *frame, xlator_t *this, loc_t *loc, + const char *name, dict_t *xdata) { - trace_conf_t *conf = NULL; + trace_conf_t *conf = NULL; - conf = this->private; + conf = this->private; - if (!conf->log_file && !conf->log_history) - goto out; - if (trace_fop_names[GF_FOP_GETXATTR].enabled) { - 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); + if (!conf->log_file && !conf->log_history) + goto out; + if (trace_fop_names[GF_FOP_GETXATTR].enabled) { + 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; + frame->local = loc->inode->gfid; - LOG_ELEMENT (conf, string); - } + LOG_ELEMENT(conf, string); + } out: - STACK_WIND (frame, trace_getxattr_cbk, - FIRST_CHILD(this), - FIRST_CHILD(this)->fops->getxattr, - loc, name, xdata); - return 0; + STACK_WIND(frame, trace_getxattr_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->getxattr, loc, name, xdata); + return 0; } int -trace_removexattr (call_frame_t *frame, xlator_t *this, - loc_t *loc, const char *name, dict_t *xdata) +trace_removexattr(call_frame_t *frame, xlator_t *this, loc_t *loc, + const char *name, dict_t *xdata) { - trace_conf_t *conf = NULL; + trace_conf_t *conf = NULL; - conf = this->private; + conf = this->private; - if (!conf->log_file && !conf->log_history) - goto out; - if (trace_fop_names[GF_FOP_REMOVEXATTR].enabled) { - 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); + if (!conf->log_file && !conf->log_history) + goto out; + if (trace_fop_names[GF_FOP_REMOVEXATTR].enabled) { + 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; + frame->local = loc->inode->gfid; - LOG_ELEMENT (conf, string); - } + LOG_ELEMENT(conf, string); + } out: - STACK_WIND (frame, trace_removexattr_cbk, - FIRST_CHILD(this), - FIRST_CHILD(this)->fops->removexattr, - loc, name, xdata); + STACK_WIND(frame, trace_removexattr_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->removexattr, loc, name, xdata); - return 0; + return 0; } int -trace_opendir (call_frame_t *frame, xlator_t *this, loc_t *loc, fd_t *fd, - dict_t *xdata) +trace_opendir(call_frame_t *frame, xlator_t *this, loc_t *loc, fd_t *fd, + dict_t *xdata) { - trace_conf_t *conf = NULL; + trace_conf_t *conf = NULL; - conf = this->private; + conf = this->private; - if (!conf->log_file && !conf->log_history) - goto out; - if (trace_fop_names[GF_FOP_OPENDIR].enabled) { - 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); + if (!conf->log_file && !conf->log_history) + goto out; + if (trace_fop_names[GF_FOP_OPENDIR].enabled) { + 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; + frame->local = loc->inode->gfid; - LOG_ELEMENT (conf, string); - } + LOG_ELEMENT(conf, string); + } out: - STACK_WIND (frame, trace_opendir_cbk, - FIRST_CHILD(this), - FIRST_CHILD(this)->fops->opendir, - loc, fd, xdata); - return 0; + STACK_WIND(frame, trace_opendir_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->opendir, loc, fd, xdata); + return 0; } int -trace_readdirp (call_frame_t *frame, xlator_t *this, fd_t *fd, size_t size, - off_t offset, dict_t *dict) +trace_readdirp(call_frame_t *frame, xlator_t *this, fd_t *fd, size_t size, + off_t offset, dict_t *dict) { - trace_conf_t *conf = NULL; + trace_conf_t *conf = NULL; - conf = this->private; + conf = this->private; - if (!conf->log_file && !conf->log_history) - goto out; - if (trace_fop_names[GF_FOP_READDIRP].enabled) { - 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); + if (!conf->log_file && !conf->log_history) + goto out; + if (trace_fop_names[GF_FOP_READDIRP].enabled) { + 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; + frame->local = fd->inode->gfid; - LOG_ELEMENT (conf, string); - } + LOG_ELEMENT(conf, string); + } out: - STACK_WIND (frame, trace_readdirp_cbk, - FIRST_CHILD(this), - FIRST_CHILD(this)->fops->readdirp, - fd, size, offset, dict); + STACK_WIND(frame, trace_readdirp_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->readdirp, fd, size, offset, dict); - return 0; + return 0; } int -trace_readdir (call_frame_t *frame, xlator_t *this, fd_t *fd, - size_t size, off_t offset, dict_t *xdata) +trace_readdir(call_frame_t *frame, xlator_t *this, fd_t *fd, size_t size, + off_t offset, dict_t *xdata) { - trace_conf_t *conf = NULL; + trace_conf_t *conf = NULL; - conf = this->private; + conf = this->private; - if (!conf->log_file && !conf->log_history) - goto out; - if (trace_fop_names[GF_FOP_READDIR].enabled) { - 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); + if (!conf->log_file && !conf->log_history) + goto out; + if (trace_fop_names[GF_FOP_READDIR].enabled) { + 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; + frame->local = fd->inode->gfid; - LOG_ELEMENT (conf, string); - } + LOG_ELEMENT(conf, string); + } out: - STACK_WIND (frame, trace_readdir_cbk, - FIRST_CHILD(this), - FIRST_CHILD(this)->fops->readdir, - fd, size, offset, xdata); + STACK_WIND(frame, trace_readdir_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->readdir, fd, size, offset, xdata); - return 0; + return 0; } int -trace_fsyncdir (call_frame_t *frame, xlator_t *this, - fd_t *fd, int32_t datasync, dict_t *xdata) +trace_fsyncdir(call_frame_t *frame, xlator_t *this, fd_t *fd, int32_t datasync, + dict_t *xdata) { - trace_conf_t *conf = NULL; + trace_conf_t *conf = NULL; - conf = this->private; + conf = this->private; - if (!conf->log_file && !conf->log_history) - goto out; - if (trace_fop_names[GF_FOP_FSYNCDIR].enabled) { - 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); + if (!conf->log_file && !conf->log_history) + goto out; + if (trace_fop_names[GF_FOP_FSYNCDIR].enabled) { + 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; + frame->local = fd->inode->gfid; - LOG_ELEMENT (conf, string); - } + LOG_ELEMENT(conf, string); + } out: - STACK_WIND (frame, trace_fsyncdir_cbk, - FIRST_CHILD(this), - FIRST_CHILD(this)->fops->fsyncdir, - fd, datasync, xdata); - return 0; + STACK_WIND(frame, trace_fsyncdir_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->fsyncdir, fd, datasync, xdata); + return 0; } int -trace_access (call_frame_t *frame, xlator_t *this, loc_t *loc, int32_t mask, - dict_t *xdata) +trace_access(call_frame_t *frame, xlator_t *this, loc_t *loc, int32_t mask, + dict_t *xdata) { - trace_conf_t *conf = NULL; + trace_conf_t *conf = NULL; - conf = this->private; + conf = this->private; - if (!conf->log_file && !conf->log_history) - goto out; - if (trace_fop_names[GF_FOP_ACCESS].enabled) { - 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); + if (!conf->log_file && !conf->log_history) + goto out; + if (trace_fop_names[GF_FOP_ACCESS].enabled) { + 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; + frame->local = loc->inode->gfid; - LOG_ELEMENT (conf, string); - } + LOG_ELEMENT(conf, string); + } out: - STACK_WIND (frame, trace_access_cbk, - FIRST_CHILD(this), - FIRST_CHILD(this)->fops->access, - loc, mask, xdata); - return 0; + STACK_WIND(frame, trace_access_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->access, 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, dict_t *xdata) +trace_rchecksum(call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset, + int32_t len, dict_t *xdata) { + trace_conf_t *conf = NULL; - trace_conf_t *conf = NULL; + conf = this->private; - conf = this->private; + if (!conf->log_file && !conf->log_history) + goto out; + if (trace_fop_names[GF_FOP_RCHECKSUM].enabled) { + 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); - if (!conf->log_file && !conf->log_history) - goto out; - if (trace_fop_names[GF_FOP_RCHECKSUM].enabled) { - 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; - frame->local = fd->inode->gfid; - - LOG_ELEMENT (conf, string); - } + LOG_ELEMENT(conf, string); + } out: - STACK_WIND (frame, trace_rchecksum_cbk, - FIRST_CHILD(this), - FIRST_CHILD(this)->fops->rchecksum, - fd, offset, len, xdata); - - return 0; + STACK_WIND(frame, trace_rchecksum_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->rchecksum, fd, offset, len, xdata); + return 0; } 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, 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) { - 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); - } +trace_fentrylk(call_frame_t *frame, xlator_t *this, const char *volume, + fd_t *fd, const char *basename, entrylk_cmd cmd, + entrylk_type type, dict_t *xdata) +{ + trace_conf_t *conf = NULL; -out: - STACK_WIND (frame, trace_fentrylk_cbk, - FIRST_CHILD (this), - FIRST_CHILD (this)->fops->fentrylk, - volume, fd, basename, cmd, type, xdata); - return 0; + conf = this->private; + + if (!conf->log_file && !conf->log_history) + goto out; + if (trace_fop_names[GF_FOP_FENTRYLK].enabled) { + 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, xdata); + return 0; } int32_t -trace_fgetxattr (call_frame_t *frame, xlator_t *this, fd_t *fd, - const char *name, dict_t *xdata) +trace_fgetxattr(call_frame_t *frame, xlator_t *this, fd_t *fd, const char *name, + dict_t *xdata) { - trace_conf_t *conf = NULL; + trace_conf_t *conf = NULL; - conf = this->private; + conf = this->private; - if (!conf->log_file && !conf->log_history) - goto out; - if (trace_fop_names[GF_FOP_FGETXATTR].enabled) { - 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); + if (!conf->log_file && !conf->log_history) + goto out; + if (trace_fop_names[GF_FOP_FGETXATTR].enabled) { + 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; + frame->local = fd->inode->gfid; - LOG_ELEMENT (conf, string); - } + LOG_ELEMENT(conf, string); + } out: - STACK_WIND (frame, trace_fgetxattr_cbk, - FIRST_CHILD(this), - FIRST_CHILD(this)->fops->fgetxattr, - fd, name, xdata); - return 0; + STACK_WIND(frame, trace_fgetxattr_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->fgetxattr, 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 *xdata) +trace_fsetxattr(call_frame_t *frame, xlator_t *this, fd_t *fd, dict_t *dict, + int32_t flags, dict_t *xdata) { - trace_conf_t *conf = NULL; + trace_conf_t *conf = NULL; - conf = this->private; + conf = this->private; - if (!conf->log_file && !conf->log_history) - goto out; - if (trace_fop_names[GF_FOP_FSETXATTR].enabled) { - 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); + if (!conf->log_file && !conf->log_history) + goto out; + if (trace_fop_names[GF_FOP_FSETXATTR].enabled) { + 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; + frame->local = fd->inode->gfid; - LOG_ELEMENT (conf, string); - } + LOG_ELEMENT(conf, string); + } out: - STACK_WIND (frame, trace_fsetxattr_cbk, - FIRST_CHILD(this), - FIRST_CHILD(this)->fops->fsetxattr, - fd, dict, flags, xdata); - return 0; + STACK_WIND(frame, trace_fsetxattr_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->fsetxattr, fd, dict, flags, xdata); + return 0; } int -trace_ftruncate (call_frame_t *frame, xlator_t *this, - fd_t *fd, off_t offset, dict_t *xdata) +trace_ftruncate(call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset, + dict_t *xdata) { - trace_conf_t *conf = NULL; + trace_conf_t *conf = NULL; - conf = this->private; + conf = this->private; - if (!conf->log_file && !conf->log_history) - goto out; - if (trace_fop_names[GF_FOP_FTRUNCATE].enabled) { - 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); + if (!conf->log_file && !conf->log_history) + goto out; + if (trace_fop_names[GF_FOP_FTRUNCATE].enabled) { + 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; + frame->local = fd->inode->gfid; - LOG_ELEMENT (conf, string); - } + LOG_ELEMENT(conf, string); + } out: - STACK_WIND (frame, trace_ftruncate_cbk, - FIRST_CHILD(this), - FIRST_CHILD(this)->fops->ftruncate, - fd, offset, xdata); + STACK_WIND(frame, trace_ftruncate_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->ftruncate, fd, offset, xdata); - return 0; + return 0; } int -trace_fstat (call_frame_t *frame, xlator_t *this, fd_t *fd, dict_t *xdata) +trace_fstat(call_frame_t *frame, xlator_t *this, fd_t *fd, dict_t *xdata) { - trace_conf_t *conf = NULL; + trace_conf_t *conf = NULL; - conf = this->private; + conf = this->private; - if (!conf->log_file && !conf->log_history) - goto out; - if (trace_fop_names[GF_FOP_FSTAT].enabled) { - char string[4096] = {0,}; - snprintf (string, sizeof (string), - "%"PRId64": gfid=%s fd=%p", - frame->root->unique, - uuid_utoa (fd->inode->gfid), fd); + if (!conf->log_file && !conf->log_history) + goto out; + if (trace_fop_names[GF_FOP_FSTAT].enabled) { + 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; + frame->local = fd->inode->gfid; - LOG_ELEMENT (conf, string); - } + LOG_ELEMENT(conf, string); + } out: - STACK_WIND (frame, trace_fstat_cbk, - FIRST_CHILD(this), - FIRST_CHILD(this)->fops->fstat, - fd, xdata); - return 0; + STACK_WIND(frame, trace_fstat_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->fstat, fd, xdata); + return 0; } int -trace_lk (call_frame_t *frame, xlator_t *this, fd_t *fd, - int32_t cmd, struct gf_flock *lock, dict_t *xdata) +trace_lk(call_frame_t *frame, xlator_t *this, fd_t *fd, int32_t cmd, + struct gf_flock *lock, dict_t *xdata) { - trace_conf_t *conf = NULL; + trace_conf_t *conf = NULL; - conf = this->private; + conf = this->private; - if (!conf->log_file && !conf->log_history) - goto out; - if (trace_fop_names[GF_FOP_LK].enabled) { - 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); + if (!conf->log_file && !conf->log_history) + goto out; + if (trace_fop_names[GF_FOP_LK].enabled) { + 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; + frame->local = fd->inode->gfid; - LOG_ELEMENT (conf, string); - } + LOG_ELEMENT(conf, string); + } out: - STACK_WIND (frame, trace_lk_cbk, - FIRST_CHILD(this), - FIRST_CHILD(this)->fops->lk, - fd, cmd, lock, xdata); - return 0; + STACK_WIND(frame, trace_lk_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->lk, fd, cmd, lock, xdata); + return 0; } int32_t -trace_forget (xlator_t *this, inode_t *inode) +trace_forget(xlator_t *this, inode_t *inode) { - trace_conf_t *conf = NULL; + 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) { - char string[4096] = {0,}; - snprintf (string, sizeof (string), - "gfid=%s", uuid_utoa (inode->gfid)); + 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) { + char string[4096] = { + 0, + }; + snprintf(string, sizeof(string), "gfid=%s", uuid_utoa(inode->gfid)); - LOG_ELEMENT (conf, string); - } + LOG_ELEMENT(conf, string); + } out: - return 0; + return 0; } int32_t -trace_releasedir (xlator_t *this, fd_t *fd) +trace_releasedir(xlator_t *this, fd_t *fd) { - trace_conf_t *conf = NULL; + trace_conf_t *conf = NULL; - conf = this->private; + conf = this->private; - if (!conf->log_file && !conf->log_history) - goto out; - if (trace_fop_names[GF_FOP_OPENDIR].enabled) { - char string[4096] = {0,}; - snprintf (string, sizeof (string), - "gfid=%s fd=%p", - uuid_utoa (fd->inode->gfid), fd); + if (!conf->log_file && !conf->log_history) + goto out; + if (trace_fop_names[GF_FOP_OPENDIR].enabled) { + char string[4096] = { + 0, + }; + snprintf(string, sizeof(string), "gfid=%s fd=%p", + uuid_utoa(fd->inode->gfid), fd); - LOG_ELEMENT (conf, string); - } + LOG_ELEMENT(conf, string); + } out: - return 0; + return 0; } int32_t -trace_release (xlator_t *this, fd_t *fd) +trace_release(xlator_t *this, fd_t *fd) { - trace_conf_t *conf = NULL; + trace_conf_t *conf = NULL; - conf = this->private; + 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) { - char string[4096] = {0,}; - snprintf (string, sizeof (string), - "gfid=%s fd=%p", - uuid_utoa (fd->inode->gfid), fd); + if (!conf->log_file && !conf->log_history) + goto out; + if (trace_fop_names[GF_FOP_OPEN].enabled || + trace_fop_names[GF_FOP_CREATE].enabled) { + char string[4096] = { + 0, + }; + snprintf(string, sizeof(string), "gfid=%s fd=%p", + uuid_utoa(fd->inode->gfid), fd); - LOG_ELEMENT (conf, string); - } + LOG_ELEMENT(conf, string); + } out: - return 0; + return 0; } - void -enable_all_calls (int enabled) +enable_all_calls(int enabled) { - int i; + int i; - for (i = 0; i < GF_FOP_MAXVALUE; i++) - trace_fop_names[i].enabled = enabled; + for (i = 0; i < GF_FOP_MAXVALUE; i++) + trace_fop_names[i].enabled = enabled; } void -enable_call (const char *name, int enabled) +enable_call(const char *name, int enabled) { - int i; - for (i = 0; i < GF_FOP_MAXVALUE; i++) - if (!strcasecmp(trace_fop_names[i].name, name)) - trace_fop_names[i].enabled = enabled; + int i; + for (i = 0; i < GF_FOP_MAXVALUE; i++) + if (!strcasecmp(trace_fop_names[i].name, name)) + trace_fop_names[i].enabled = enabled; } - /* include = 1 for "include-ops" = 0 for "exclude-ops" */ void -process_call_list (const char *list, int include) +process_call_list(const char *list, int include) { - enable_all_calls (include ? 0 : 1); + enable_all_calls(include ? 0 : 1); - char *call = strsep ((char **)&list, ","); + char *call = strsep((char **)&list, ","); - while (call) { - enable_call (call, include); - call = strsep ((char **)&list, ","); - } + while (call) { + enable_call(call, include); + call = strsep((char **)&list, ","); + } } 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; +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; + return ret; } int32_t -mem_acct_init (xlator_t *this) +mem_acct_init(xlator_t *this) { - int ret = -1; - - if (!this) - return ret; + int ret = -1; - ret = xlator_mem_acct_init (this, gf_trace_mt_end + 1); + if (!this) + return ret; - if (ret != 0) { - gf_log (this->name, GF_LOG_ERROR, "Memory accounting init" - " failed"); - return ret; - } + ret = xlator_mem_acct_init(this, gf_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) +reconfigure(xlator_t *this, dict_t *options) { - int32_t ret = -1; - trace_conf_t *conf = NULL; - char *includes = NULL, *excludes = NULL; + 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); + 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; + conf = this->private; - includes = data_to_str (dict_get (options, "include-ops")); - excludes = data_to_str (dict_get (options, "exclude-ops")); + 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], - sizeof (trace_fop_names[i].name)); - else - strncpy (trace_fop_names[i].name, ":0", - sizeof (trace_fop_names[i].name)); - trace_fop_names[i].enabled = 1; - trace_fop_names[i].name[sizeof ( - trace_fop_names[i].name) - 1] = 0; - } + { + 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], + sizeof(trace_fop_names[i].name)); + else + strncpy(trace_fop_names[i].name, ":0", + sizeof(trace_fop_names[i].name)); + trace_fop_names[i].enabled = 1; + trace_fop_names[i].name[sizeof(trace_fop_names[i].name) - 1] = 0; } + } - if (includes && excludes) { - gf_log (this->name, - GF_LOG_ERROR, - "must specify only one of 'include-ops' and " - "'exclude-ops'"); - goto out; - } + 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); + 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); + /* 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); + GF_OPTION_RECONF("log-history", conf->log_history, options, bool, out); - ret = 0; + ret = 0; out: - return ret; + return ret; } int32_t -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; - - if (!this->children || this->children->next) { - gf_log (this->name, GF_LOG_ERROR, - "trace translator requires one subvolume"); - return -1; - } - if (!this->parents) { - gf_log (this->name, GF_LOG_WARNING, - "dangling volume. check volfile "); - } - - 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")); - 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], - sizeof (trace_fop_names[i].name)); - else - strncpy (trace_fop_names[i].name, ":O", - sizeof (trace_fop_names[i].name)); - trace_fop_names[i].enabled = 1; - trace_fop_names[i].name[sizeof ( - trace_fop_names[i].name) - 1] = 0; - } - } - - if (includes && excludes) { - gf_log (this->name, - GF_LOG_ERROR, - "must specify only one of 'include-ops' and " - "'exclude-ops'"); - return -1; - } - - if (includes) - process_call_list (includes, 1); - if (excludes) - process_call_list (excludes, 0); - - - GF_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")); - if (!forced_loglevel) - goto setloglevel; - - if (strcmp (forced_loglevel, "INFO") == 0) - conf->trace_log_level = GF_LOG_INFO; - else if (strcmp (forced_loglevel, "TRACE") == 0) - conf->trace_log_level = GF_LOG_TRACE; - else if (strcmp (forced_loglevel, "ERROR") == 0) - conf->trace_log_level = GF_LOG_ERROR; - else if (strcmp (forced_loglevel, "DEBUG") == 0) - conf->trace_log_level = GF_LOG_DEBUG; - else if (strcmp (forced_loglevel, "WARNING") == 0) - conf->trace_log_level = GF_LOG_WARNING; - else if (strcmp (forced_loglevel, "CRITICAL") == 0) - conf->trace_log_level = GF_LOG_CRITICAL; - else if (strcmp (forced_loglevel, "NONE") == 0) - conf->trace_log_level = GF_LOG_NONE; - } +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; + + if (!this->children || this->children->next) { + gf_log(this->name, GF_LOG_ERROR, + "trace translator requires one subvolume"); + return -1; + } + if (!this->parents) { + gf_log(this->name, GF_LOG_WARNING, "dangling volume. check volfile "); + } + + 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")); + 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], + sizeof(trace_fop_names[i].name)); + else + strncpy(trace_fop_names[i].name, ":O", + sizeof(trace_fop_names[i].name)); + trace_fop_names[i].enabled = 1; + trace_fop_names[i].name[sizeof(trace_fop_names[i].name) - 1] = 0; + } + } + + if (includes && excludes) { + gf_log(this->name, GF_LOG_ERROR, + "must specify only one of 'include-ops' and " + "'exclude-ops'"); + return -1; + } + + if (includes) + process_call_list(includes, 1); + if (excludes) + process_call_list(excludes, 0); + + GF_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")); + if (!forced_loglevel) + goto setloglevel; + + if (strcmp(forced_loglevel, "INFO") == 0) + conf->trace_log_level = GF_LOG_INFO; + else if (strcmp(forced_loglevel, "TRACE") == 0) + conf->trace_log_level = GF_LOG_TRACE; + else if (strcmp(forced_loglevel, "ERROR") == 0) + conf->trace_log_level = GF_LOG_ERROR; + else if (strcmp(forced_loglevel, "DEBUG") == 0) + conf->trace_log_level = GF_LOG_DEBUG; + else if (strcmp(forced_loglevel, "WARNING") == 0) + conf->trace_log_level = GF_LOG_WARNING; + else if (strcmp(forced_loglevel, "CRITICAL") == 0) + conf->trace_log_level = GF_LOG_CRITICAL; + else if (strcmp(forced_loglevel, "NONE") == 0) + conf->trace_log_level = GF_LOG_NONE; + } setloglevel: - gf_log_set_loglevel (this->ctx, conf->trace_log_level); - this->private = conf; - ret = 0; -out: - if (ret == -1) { - if (history) - GF_FREE (history); - if (conf) - GF_FREE (conf); - } + gf_log_set_loglevel(this->ctx, conf->trace_log_level); + this->private = conf; + ret = 0; +out: + if (ret == -1) { + if (history) + GF_FREE(history); + if (conf) + GF_FREE(conf); + } - return ret; + return ret; } void -fini (xlator_t *this) +fini(xlator_t *this) { - if (!this) - return; + if (!this) + return; - if (this->history) - eh_destroy (this->history); + if (this->history) + eh_destroy(this->history); - gf_log (this->name, GF_LOG_INFO, - "trace translator unloaded"); - return; + gf_log(this->name, GF_LOG_INFO, "trace translator unloaded"); + return; } struct xlator_fops fops = { - .stat = trace_stat, - .readlink = trace_readlink, - .mknod = trace_mknod, - .mkdir = trace_mkdir, - .unlink = trace_unlink, - .rmdir = trace_rmdir, - .symlink = trace_symlink, - .rename = trace_rename, - .link = trace_link, - .truncate = trace_truncate, - .open = trace_open, - .readv = trace_readv, - .writev = trace_writev, - .statfs = trace_statfs, - .flush = trace_flush, - .fsync = trace_fsync, - .setxattr = trace_setxattr, - .getxattr = trace_getxattr, - .fsetxattr = trace_fsetxattr, - .fgetxattr = trace_fgetxattr, - .removexattr = trace_removexattr, - .opendir = trace_opendir, - .readdir = trace_readdir, - .readdirp = trace_readdirp, - .fsyncdir = trace_fsyncdir, - .access = trace_access, - .ftruncate = trace_ftruncate, - .fstat = trace_fstat, - .create = trace_create, - .lk = trace_lk, - .inodelk = trace_inodelk, - .finodelk = trace_finodelk, - .entrylk = trace_entrylk, - .fentrylk = trace_fentrylk, - .lookup = trace_lookup, - .rchecksum = trace_rchecksum, - .xattrop = trace_xattrop, - .fxattrop = trace_fxattrop, - .setattr = trace_setattr, - .fsetattr = trace_fsetattr, - .seek = trace_seek, + .stat = trace_stat, + .readlink = trace_readlink, + .mknod = trace_mknod, + .mkdir = trace_mkdir, + .unlink = trace_unlink, + .rmdir = trace_rmdir, + .symlink = trace_symlink, + .rename = trace_rename, + .link = trace_link, + .truncate = trace_truncate, + .open = trace_open, + .readv = trace_readv, + .writev = trace_writev, + .statfs = trace_statfs, + .flush = trace_flush, + .fsync = trace_fsync, + .setxattr = trace_setxattr, + .getxattr = trace_getxattr, + .fsetxattr = trace_fsetxattr, + .fgetxattr = trace_fgetxattr, + .removexattr = trace_removexattr, + .opendir = trace_opendir, + .readdir = trace_readdir, + .readdirp = trace_readdirp, + .fsyncdir = trace_fsyncdir, + .access = trace_access, + .ftruncate = trace_ftruncate, + .fstat = trace_fstat, + .create = trace_create, + .lk = trace_lk, + .inodelk = trace_inodelk, + .finodelk = trace_finodelk, + .entrylk = trace_entrylk, + .fentrylk = trace_fentrylk, + .lookup = trace_lookup, + .rchecksum = trace_rchecksum, + .xattrop = trace_xattrop, + .fxattrop = trace_fxattrop, + .setattr = trace_setattr, + .fsetattr = trace_fsetattr, + .seek = trace_seek, }; struct xlator_cbks cbks = { - .release = trace_release, - .releasedir = trace_releasedir, - .forget = trace_forget, + .release = trace_release, + .releasedir = trace_releasedir, + .forget = trace_forget, }; struct volume_options options[] = { - { .key = {"include-ops", "include"}, - .type = GF_OPTION_TYPE_STR, - /*.value = { ""} */ - }, - { .key = {"exclude-ops", "exclude"}, - .type = GF_OPTION_TYPE_STR - /*.value = { ""} */ - }, - { .key = {"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} }, + { + .key = {"include-ops", "include"}, + .type = GF_OPTION_TYPE_STR, + /*.value = { ""} */ + }, + { + .key = {"exclude-ops", "exclude"}, + .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 -}; +struct xlator_dumpops dumpops = {.history = trace_dump_history}; |