xfs: consolidate btree block allocation tracepoints

Don't waste tracepoint segment memory on per-btree block allocation
tracepoints when we can do it from the generic btree code.

With this patch applied, two tracepoints are collapsed into one
tracepoint, with the following effects on objdump -hx xfs.ko output:

Before:

 10 __tracepoints_ptrs 00000b38  0000000000000000  0000000000000000  001412f0  2**2
 14 __tracepoints_strings 00005433  0000000000000000  0000000000000000  001689a0  2**5
 29 __tracepoints 00010d30  0000000000000000  0000000000000000  0023fe00  2**5

After:

 10 __tracepoints_ptrs 00000b34  0000000000000000  0000000000000000  001417b0  2**2
 14 __tracepoints_strings 00005413  0000000000000000  0000000000000000  00168e80  2**5
 29 __tracepoints 00010cd0  0000000000000000  0000000000000000  00240760  2**5

Column 3 is the section size in bytes; removing these two tracepoints
reduces the size of the ELF segments by 132 bytes.

Signed-off-by: Darrick J. Wong <djwong@kernel.org>
Reviewed-by: Christoph Hellwig <hch@lst.de>

diff --git a/fs/xfs/libxfs/xfs_btree.c b/fs/xfs/libxfs/xfs_btree.c
index fd86996aa626294315df284b97aa1787eff3fa1d..322553f1981d714e88a979e254f7ee6bcc3c951c 100644 (file)
--- a/fs/xfs/libxfs/xfs_btree.c
+++ b/fs/xfs/libxfs/xfs_btree.c
@@ -2693,6 +2693,20 @@ error1:
        return error;
 }
 
+static inline int
+xfs_btree_alloc_block(
+       struct xfs_btree_cur            *cur,
+       const union xfs_btree_ptr       *hint_block,
+       union xfs_btree_ptr             *new_block,
+       int                             *stat)
+{
+       int                             error;
+
+       error = cur->bc_ops->alloc_block(cur, hint_block, new_block, stat);
+       trace_xfs_btree_alloc_block(cur, new_block, *stat, error);
+       return error;
+}
+
 /*
  * Split cur/level block in half.
  * Return new block number and the key to its first
@@ -2736,7 +2750,7 @@ __xfs_btree_split(
        xfs_btree_buf_to_ptr(cur, lbp, &lptr);
 
        /* Allocate the new block. If we can't do it, we're toast. Give up. */
-       error = cur->bc_ops->alloc_block(cur, &lptr, &rptr, stat);
+       error = xfs_btree_alloc_block(cur, &lptr, &rptr, stat);
        if (error)
                goto error0;
        if (*stat == 0)
@@ -3016,7 +3030,7 @@ xfs_btree_new_iroot(
        pp = xfs_btree_ptr_addr(cur, 1, block);
 
        /* Allocate the new block. If we can't do it, we're toast. Give up. */
-       error = cur->bc_ops->alloc_block(cur, pp, &nptr, stat);
+       error = xfs_btree_alloc_block(cur, pp, &nptr, stat);
        if (error)
                goto error0;
        if (*stat == 0)
@@ -3116,7 +3130,7 @@ xfs_btree_new_root(
        cur->bc_ops->init_ptr_from_cur(cur, &rptr);
 
        /* Allocate the new block. If we can't do it, we're toast. Give up. */
-       error = cur->bc_ops->alloc_block(cur, &rptr, &lptr, stat);
+       error = xfs_btree_alloc_block(cur, &rptr, &lptr, stat);
        if (error)
                goto error0;
        if (*stat == 0)

diff --git a/fs/xfs/libxfs/xfs_refcount_btree.c b/fs/xfs/libxfs/xfs_refcount_btree.c
index a346e49981ac31405c246adf94a0ef09bf1f2869..f904a92d1b590d7cc5e780ee0d72c32b09dbdc92 100644 (file)
--- a/fs/xfs/libxfs/xfs_refcount_btree.c
+++ b/fs/xfs/libxfs/xfs_refcount_btree.c
@@ -77,8 +77,6 @@ xfs_refcountbt_alloc_block(
                                        xfs_refc_block(args.mp)));
        if (error)
                goto out_error;
-       trace_xfs_refcountbt_alloc_block(cur->bc_mp, cur->bc_ag.pag->pag_agno,
-                       args.agbno, 1);
        if (args.fsbno == NULLFSBLOCK) {
                *stat = 0;
                return 0;

diff --git a/fs/xfs/libxfs/xfs_rmap_btree.c b/fs/xfs/libxfs/xfs_rmap_btree.c
index 0dc086bc528f70756cb705b5cb1c681fcffd19f5..43ff2236f62373a12afa43ddf01663c4f068ddb7 100644 (file)
--- a/fs/xfs/libxfs/xfs_rmap_btree.c
+++ b/fs/xfs/libxfs/xfs_rmap_btree.c
@@ -94,8 +94,6 @@ xfs_rmapbt_alloc_block(
                                       &bno, 1);
        if (error)
                return error;
-
-       trace_xfs_rmapbt_alloc_block(cur->bc_mp, pag->pag_agno, bno, 1);
        if (bno == NULLAGBLOCK) {
                *stat = 0;
                return 0;

diff --git a/fs/xfs/xfs_trace.h b/fs/xfs/xfs_trace.h
index fc6190340b95b8d9bac068dba2b89437d7973f85..5115037c127b0539e53b0580c7063fbdac2482d4 100644 (file)
--- a/fs/xfs/xfs_trace.h
+++ b/fs/xfs/xfs_trace.h
@@ -2496,6 +2496,53 @@ DEFINE_EVENT(xfs_btree_cur_class, name, \
 DEFINE_BTREE_CUR_EVENT(xfs_btree_updkeys);
 DEFINE_BTREE_CUR_EVENT(xfs_btree_overlapped_query_range);
 
+TRACE_EVENT(xfs_btree_alloc_block,
+       TP_PROTO(struct xfs_btree_cur *cur, union xfs_btree_ptr *ptr, int stat,
+                int error),
+       TP_ARGS(cur, ptr, stat, error),
+       TP_STRUCT__entry(
+               __field(dev_t, dev)
+               __field(xfs_agnumber_t, agno)
+               __field(xfs_ino_t, ino)
+               __field(xfs_btnum_t, btnum)
+               __field(int, error)
+               __field(xfs_agblock_t, agbno)
+       ),
+       TP_fast_assign(
+               __entry->dev = cur->bc_mp->m_super->s_dev;
+               if (cur->bc_flags & XFS_BTREE_ROOT_IN_INODE) {
+                       __entry->agno = 0;
+                       __entry->ino = cur->bc_ino.ip->i_ino;
+               } else {
+                       __entry->agno = cur->bc_ag.pag->pag_agno;
+                       __entry->ino = 0;
+               }
+               __entry->btnum = cur->bc_btnum;
+               __entry->error = error;
+               if (!error && stat) {
+                       if (cur->bc_flags & XFS_BTREE_LONG_PTRS) {
+                               xfs_fsblock_t   fsb = be64_to_cpu(ptr->l);
+
+                               __entry->agno = XFS_FSB_TO_AGNO(cur->bc_mp,
+                                                               fsb);
+                               __entry->agbno = XFS_FSB_TO_AGBNO(cur->bc_mp,
+                                                               fsb);
+                       } else {
+                               __entry->agbno = be32_to_cpu(ptr->s);
+                       }
+               } else {
+                       __entry->agbno = NULLAGBLOCK;
+               }
+       ),
+       TP_printk("dev %d:%d btree %s agno 0x%x ino 0x%llx agbno 0x%x error %d",
+                 MAJOR(__entry->dev), MINOR(__entry->dev),
+                 __print_symbolic(__entry->btnum, XFS_BTNUM_STRINGS),
+                 __entry->agno,
+                 __entry->ino,
+                 __entry->agbno,
+                 __entry->error)
+);
+
 TRACE_EVENT(xfs_btree_free_block,
        TP_PROTO(struct xfs_btree_cur *cur, struct xfs_buf *bp),
        TP_ARGS(cur, bp),
@@ -2888,7 +2935,6 @@ DEFINE_EVENT(xfs_rmapbt_class, name, \
 DEFINE_RMAP_DEFERRED_EVENT(xfs_rmap_defer);
 DEFINE_RMAP_DEFERRED_EVENT(xfs_rmap_deferred);
 
-DEFINE_BUSY_EVENT(xfs_rmapbt_alloc_block);
 DEFINE_RMAPBT_EVENT(xfs_rmap_update);
 DEFINE_RMAPBT_EVENT(xfs_rmap_insert);
 DEFINE_RMAPBT_EVENT(xfs_rmap_delete);
@@ -3246,7 +3292,6 @@ DEFINE_EVENT(xfs_refcount_triple_extent_class, name, \
        TP_ARGS(mp, agno, i1, i2, i3))
 
 /* refcount btree tracepoints */
-DEFINE_BUSY_EVENT(xfs_refcountbt_alloc_block);
 DEFINE_AG_BTREE_LOOKUP_EVENT(xfs_refcount_lookup);
 DEFINE_REFCOUNT_EXTENT_EVENT(xfs_refcount_get);
 DEFINE_REFCOUNT_EXTENT_EVENT(xfs_refcount_update);