xfs: event tracing support

Convert the old xfs tracing support that could only be used with the
out of tree kdb and xfsidbg patches to use the generic event tracer.

To use it make sure CONFIG_EVENT_TRACING is enabled and then enable
all xfs trace channels by:

   echo 1 > /sys/kernel/debug/tracing/events/xfs/enable

or alternatively enable single events by just doing the same in one
event subdirectory, e.g.

   echo 1 > /sys/kernel/debug/tracing/events/xfs/xfs_ihold/enable

or set more complex filters, etc. In Documentation/trace/events.txt
all this is desctribed in more detail.  To reads the events do a

   cat /sys/kernel/debug/tracing/trace

Compared to the last posting this patch converts the tracing mostly to
the one tracepoint per callsite model that other users of the new
tracing facility also employ.  This allows a very fine-grained control
of the tracing, a cleaner output of the traces and also enables the
perf tool to use each tracepoint as a virtual performance counter,
     allowing us to e.g. count how often certain workloads git various
     spots in XFS.  Take a look at

    http://lwn.net/Articles/346470/

for some examples.

Also the btree tracing isn't included at all yet, as it will require
additional core tracing features not in mainline yet, I plan to
deliver it later.

And the really nice thing about this patch is that it actually removes
many lines of code while adding this nice functionality:

 fs/xfs/Makefile                |    8
 fs/xfs/linux-2.6/xfs_acl.c     |    1
 fs/xfs/linux-2.6/xfs_aops.c    |   52 -
 fs/xfs/linux-2.6/xfs_aops.h    |    2
 fs/xfs/linux-2.6/xfs_buf.c     |  117 +--
 fs/xfs/linux-2.6/xfs_buf.h     |   33
 fs/xfs/linux-2.6/xfs_fs_subr.c |    3
 fs/xfs/linux-2.6/xfs_ioctl.c   |    1
 fs/xfs/linux-2.6/xfs_ioctl32.c |    1
 fs/xfs/linux-2.6/xfs_iops.c    |    1
 fs/xfs/linux-2.6/xfs_linux.h   |    1
 fs/xfs/linux-2.6/xfs_lrw.c     |   87 --
 fs/xfs/linux-2.6/xfs_lrw.h     |   45 -
 fs/xfs/linux-2.6/xfs_super.c   |  104 ---
 fs/xfs/linux-2.6/xfs_super.h   |    7
 fs/xfs/linux-2.6/xfs_sync.c    |    1
 fs/xfs/linux-2.6/xfs_trace.c   |   75 ++
 fs/xfs/linux-2.6/xfs_trace.h   | 1369 +++++++++++++++++++++++++++++++++++++++++
 fs/xfs/linux-2.6/xfs_vnode.h   |    4
 fs/xfs/quota/xfs_dquot.c       |  110 ---
 fs/xfs/quota/xfs_dquot.h       |   21
 fs/xfs/quota/xfs_qm.c          |   40 -
 fs/xfs/quota/xfs_qm_syscalls.c |    4
 fs/xfs/support/ktrace.c        |  323 ---------
 fs/xfs/support/ktrace.h        |   85 --
 fs/xfs/xfs.h                   |   16
 fs/xfs/xfs_ag.h                |   14
 fs/xfs/xfs_alloc.c             |  230 +-----
 fs/xfs/xfs_alloc.h             |   27
 fs/xfs/xfs_alloc_btree.c       |    1
 fs/xfs/xfs_attr.c              |  107 ---
 fs/xfs/xfs_attr.h              |   10
 fs/xfs/xfs_attr_leaf.c         |   14
 fs/xfs/xfs_attr_sf.h           |   40 -
 fs/xfs/xfs_bmap.c              |  507 +++------------
 fs/xfs/xfs_bmap.h              |   49 -
 fs/xfs/xfs_bmap_btree.c        |    6
 fs/xfs/xfs_btree.c             |    5
 fs/xfs/xfs_btree_trace.h       |   17
 fs/xfs/xfs_buf_item.c          |   87 --
 fs/xfs/xfs_buf_item.h          |   20
 fs/xfs/xfs_da_btree.c          |    3
 fs/xfs/xfs_da_btree.h          |    7
 fs/xfs/xfs_dfrag.c             |    2
 fs/xfs/xfs_dir2.c              |    8
 fs/xfs/xfs_dir2_block.c        |   20
 fs/xfs/xfs_dir2_leaf.c         |   21
 fs/xfs/xfs_dir2_node.c         |   27
 fs/xfs/xfs_dir2_sf.c           |   26
 fs/xfs/xfs_dir2_trace.c        |  216 ------
 fs/xfs/xfs_dir2_trace.h        |   72 --
 fs/xfs/xfs_filestream.c        |    8
 fs/xfs/xfs_fsops.c             |    2
 fs/xfs/xfs_iget.c              |  111 ---
 fs/xfs/xfs_inode.c             |   67 --
 fs/xfs/xfs_inode.h             |   76 --
 fs/xfs/xfs_inode_item.c        |    5
 fs/xfs/xfs_iomap.c             |   85 --
 fs/xfs/xfs_iomap.h             |    8
 fs/xfs/xfs_log.c               |  181 +----
 fs/xfs/xfs_log_priv.h          |   20
 fs/xfs/xfs_log_recover.c       |    1
 fs/xfs/xfs_mount.c             |    2
 fs/xfs/xfs_quota.h             |    8
 fs/xfs/xfs_rename.c            |    1
 fs/xfs/xfs_rtalloc.c           |    1
 fs/xfs/xfs_rw.c                |    3
 fs/xfs/xfs_trans.h             |   47 +
 fs/xfs/xfs_trans_buf.c         |   62 -
 fs/xfs/xfs_vnodeops.c          |    8
 70 files changed, 2151 insertions(+), 2592 deletions(-)

Signed-off-by: Christoph Hellwig <hch@lst.de>
Signed-off-by: Alex Elder <aelder@sgi.com>

1 files changed, 26 insertions, 36 deletions

diff --git a/fs/xfs/xfs_trans_buf.c b/fs/xfs/xfs_trans_buf.c
index 03a1f701fea8..49130628d5ef 100644
--- a/fs/xfs/xfs_trans_buf.c
+++ b/fs/xfs/xfs_trans_buf.c
@@ -38,6 +38,7 @@
 #include "xfs_trans_priv.h"
 #include "xfs_error.h"
 #include "xfs_rw.h"
+#include "xfs_trace.h"
 
 
 STATIC xfs_buf_t *xfs_trans_buf_item_match(xfs_trans_t *, xfs_buftarg_t *,
@@ -95,26 +96,23 @@ xfs_trans_get_buf(xfs_trans_t	*tp,
         }
         if (bp != NULL) {
                 ASSERT(XFS_BUF_VALUSEMA(bp) <= 0);
-                if (XFS_FORCED_SHUTDOWN(tp->t_mountp)) {
-                        xfs_buftrace("TRANS GET RECUR SHUT", bp);
+                if (XFS_FORCED_SHUTDOWN(tp->t_mountp))
                         XFS_BUF_SUPER_STALE(bp);
-                }
+
                 /*
                  * If the buffer is stale then it was binval'ed
                  * since last read.  This doesn't matter since the
                  * caller isn't allowed to use the data anyway.
                  */
-                else if (XFS_BUF_ISSTALE(bp)) {
-                        xfs_buftrace("TRANS GET RECUR STALE", bp);
+                else if (XFS_BUF_ISSTALE(bp))
                         ASSERT(!XFS_BUF_ISDELAYWRITE(bp));
-                }
+
                 ASSERT(XFS_BUF_FSPRIVATE2(bp, xfs_trans_t *) == tp);
                 bip = XFS_BUF_FSPRIVATE(bp, xfs_buf_log_item_t *);
                 ASSERT(bip != NULL);
                 ASSERT(atomic_read(&bip->bli_refcount) > 0);
                 bip->bli_recur++;
-                xfs_buftrace("TRANS GET RECUR", bp);
-                xfs_buf_item_trace("GET RECUR", bip);
+                trace_xfs_trans_get_buf_recur(bip);
                 return (bp);
         }
 
@@ -166,8 +164,7 @@ xfs_trans_get_buf(xfs_trans_t	*tp,
          */
         XFS_BUF_SET_FSPRIVATE2(bp, tp);
 
-        xfs_buftrace("TRANS GET", bp);
-        xfs_buf_item_trace("GET", bip);
+        trace_xfs_trans_get_buf(bip);
         return (bp);
 }
 
@@ -207,7 +204,7 @@ xfs_trans_getsb(xfs_trans_t	*tp,
                 ASSERT(bip != NULL);
                 ASSERT(atomic_read(&bip->bli_refcount) > 0);
                 bip->bli_recur++;
-                xfs_buf_item_trace("GETSB RECUR", bip);
+                trace_xfs_trans_getsb_recur(bip);
                 return (bp);
         }
 
@@ -249,7 +246,7 @@ xfs_trans_getsb(xfs_trans_t	*tp,
          */
         XFS_BUF_SET_FSPRIVATE2(bp, tp);
 
-        xfs_buf_item_trace("GETSB", bip);
+        trace_xfs_trans_getsb(bip);
         return (bp);
 }
 
@@ -347,7 +344,7 @@ xfs_trans_read_buf(
                 ASSERT(XFS_BUF_FSPRIVATE(bp, void *) != NULL);
                 ASSERT((XFS_BUF_ISERROR(bp)) == 0);
                 if (!(XFS_BUF_ISDONE(bp))) {
-                        xfs_buftrace("READ_BUF_INCORE !DONE", bp);
+                        trace_xfs_trans_read_buf_io(bp, _RET_IP_);
                         ASSERT(!XFS_BUF_ISASYNC(bp));
                         XFS_BUF_READ(bp);
                         xfsbdstrat(tp->t_mountp, bp);
@@ -372,7 +369,7 @@ xfs_trans_read_buf(
                  * brelse it either. Just get out.
                  */
                 if (XFS_FORCED_SHUTDOWN(mp)) {
-                        xfs_buftrace("READ_BUF_INCORE XFSSHUTDN", bp);
+                        trace_xfs_trans_read_buf_shut(bp, _RET_IP_);
                         *bpp = NULL;
                         return XFS_ERROR(EIO);
                 }
@@ -382,7 +379,7 @@ xfs_trans_read_buf(
                 bip->bli_recur++;
 
                 ASSERT(atomic_read(&bip->bli_refcount) > 0);
-                xfs_buf_item_trace("READ RECUR", bip);
+                trace_xfs_trans_read_buf_recur(bip);
                 *bpp = bp;
                 return 0;
         }
@@ -402,7 +399,6 @@ xfs_trans_read_buf(
         }
         if (XFS_BUF_GETERROR(bp) != 0) {
             XFS_BUF_SUPER_STALE(bp);
-                xfs_buftrace("READ ERROR", bp);
                 error = XFS_BUF_GETERROR(bp);
 
                 xfs_ioerror_alert("xfs_trans_read_buf", mp,
@@ -461,8 +457,7 @@ xfs_trans_read_buf(
          */
         XFS_BUF_SET_FSPRIVATE2(bp, tp);
 
-        xfs_buftrace("TRANS READ", bp);
-        xfs_buf_item_trace("READ", bip);
+        trace_xfs_trans_read_buf(bip);
         *bpp = bp;
         return 0;
 
@@ -480,7 +475,7 @@ shutdown_abort:
         ASSERT((XFS_BUF_BFLAGS(bp) & (XFS_B_STALE|XFS_B_DELWRI)) !=
                                                 (XFS_B_STALE|XFS_B_DELWRI));
 
-        xfs_buftrace("READ_BUF XFSSHUTDN", bp);
+        trace_xfs_trans_read_buf_shut(bp, _RET_IP_);
         xfs_buf_relse(bp);
         *bpp = NULL;
         return XFS_ERROR(EIO);
@@ -546,13 +541,14 @@ xfs_trans_brelse(xfs_trans_t	*tp,
         lidp = xfs_trans_find_item(tp, (xfs_log_item_t*)bip);
         ASSERT(lidp != NULL);
 
+        trace_xfs_trans_brelse(bip);
+
         /*
          * If the release is just for a recursive lock,
          * then decrement the count and return.
          */
         if (bip->bli_recur > 0) {
                 bip->bli_recur--;
-                xfs_buf_item_trace("RELSE RECUR", bip);
                 return;
         }
 
@@ -560,10 +556,8 @@ xfs_trans_brelse(xfs_trans_t	*tp,
          * If the buffer is dirty within this transaction, we can't
          * release it until we commit.
          */
-        if (lidp->lid_flags & XFS_LID_DIRTY) {
-                xfs_buf_item_trace("RELSE DIRTY", bip);
+        if (lidp->lid_flags & XFS_LID_DIRTY)
                 return;
-        }
 
         /*
          * If the buffer has been invalidated, then we can't release
@@ -571,13 +565,10 @@ xfs_trans_brelse(xfs_trans_t	*tp,
          * as part of this transaction.  This prevents us from pulling
          * the item from the AIL before we should.
          */
-        if (bip->bli_flags & XFS_BLI_STALE) {
-                xfs_buf_item_trace("RELSE STALE", bip);
+        if (bip->bli_flags & XFS_BLI_STALE)
                 return;
-        }
 
         ASSERT(!(bip->bli_flags & XFS_BLI_LOGGED));
-        xfs_buf_item_trace("RELSE", bip);
 
         /*
          * Free up the log item descriptor tracking the released item.
@@ -674,7 +665,7 @@ xfs_trans_bjoin(xfs_trans_t	*tp,
          */
         XFS_BUF_SET_FSPRIVATE2(bp, tp);
 
-        xfs_buf_item_trace("BJOIN", bip);
+        trace_xfs_trans_bjoin(bip);
 }
 
 /*
@@ -698,7 +689,7 @@ xfs_trans_bhold(xfs_trans_t	*tp,
         ASSERT(!(bip->bli_format.blf_flags & XFS_BLI_CANCEL));
         ASSERT(atomic_read(&bip->bli_refcount) > 0);
         bip->bli_flags |= XFS_BLI_HOLD;
-        xfs_buf_item_trace("BHOLD", bip);
+        trace_xfs_trans_bhold(bip);
 }
 
 /*
@@ -721,7 +712,8 @@ xfs_trans_bhold_release(xfs_trans_t	*tp,
         ASSERT(atomic_read(&bip->bli_refcount) > 0);
         ASSERT(bip->bli_flags & XFS_BLI_HOLD);
         bip->bli_flags &= ~XFS_BLI_HOLD;
-        xfs_buf_item_trace("BHOLD RELEASE", bip);
+
+        trace_xfs_trans_bhold_release(bip);
 }
 
 /*
@@ -767,6 +759,8 @@ xfs_trans_log_buf(xfs_trans_t	*tp,
         XFS_BUF_SET_IODONE_FUNC(bp, xfs_buf_iodone_callbacks);
         bip->bli_item.li_cb = (void(*)(xfs_buf_t*,xfs_log_item_t*))xfs_buf_iodone;
 
+        trace_xfs_trans_log_buf(bip);
+
         /*
          * If we invalidated the buffer within this transaction, then
          * cancel the invalidation now that we're dirtying the buffer
@@ -774,7 +768,6 @@ xfs_trans_log_buf(xfs_trans_t	*tp,
          * because we have a reference to the buffer this entire time.
          */
         if (bip->bli_flags & XFS_BLI_STALE) {
-                xfs_buf_item_trace("BLOG UNSTALE", bip);
                 bip->bli_flags &= ~XFS_BLI_STALE;
                 ASSERT(XFS_BUF_ISSTALE(bp));
                 XFS_BUF_UNSTALE(bp);
@@ -789,7 +782,6 @@ xfs_trans_log_buf(xfs_trans_t	*tp,
         lidp->lid_flags &= ~XFS_LID_BUF_STALE;
         bip->bli_flags |= XFS_BLI_LOGGED;
         xfs_buf_item_log(bip, first, last);
-        xfs_buf_item_trace("BLOG", bip);
 }
 
 
@@ -828,6 +820,8 @@ xfs_trans_binval(
         ASSERT(lidp != NULL);
         ASSERT(atomic_read(&bip->bli_refcount) > 0);
 
+        trace_xfs_trans_binval(bip);
+
         if (bip->bli_flags & XFS_BLI_STALE) {
                 /*
                  * If the buffer is already invalidated, then
@@ -840,8 +834,6 @@ xfs_trans_binval(
                 ASSERT(bip->bli_format.blf_flags & XFS_BLI_CANCEL);
                 ASSERT(lidp->lid_flags & XFS_LID_DIRTY);
                 ASSERT(tp->t_flags & XFS_TRANS_DIRTY);
-                xfs_buftrace("XFS_BINVAL RECUR", bp);
-                xfs_buf_item_trace("BINVAL RECUR", bip);
                 return;
         }
 
@@ -875,8 +867,6 @@ xfs_trans_binval(
               (bip->bli_format.blf_map_size * sizeof(uint)));
         lidp->lid_flags |= XFS_LID_DIRTY|XFS_LID_BUF_STALE;
         tp->t_flags |= XFS_TRANS_DIRTY;
-        xfs_buftrace("XFS_BINVAL", bp);
-        xfs_buf_item_trace("BINVAL", bip);
 }
 
 /*