1 files changed, 19 insertions, 104 deletions

diff --git a/fs/xfs/xfs_attr.c b/fs/xfs/xfs_attr.c
index 4ece1906bd4..e953b6cfb2a 100644
--- a/fs/xfs/xfs_attr.c
+++ b/fs/xfs/xfs_attr.c
@@ -47,6 +47,7 @@
 #include "xfs_trans_space.h"
 #include "xfs_rw.h"
 #include "xfs_vnodeops.h"
+#include "xfs_trace.h"
 
 /*
  * xfs_attr.c
@@ -89,10 +90,6 @@ STATIC int xfs_attr_rmtval_remove(xfs_da_args_t *args);
 
 #define ATTR_RMTVALUE_MAPSIZE   1       /* # of map entries at once */
 
-#if defined(XFS_ATTR_TRACE)
-ktrace_t *xfs_attr_trace_buf;
-#endif
-
 STATIC int
 xfs_attr_name_to_xname(
         struct xfs_name *xname,
@@ -123,9 +120,13 @@ xfs_inode_hasattr(
  * Overall external interface routines.
  *========================================================================*/
 
-int
-xfs_attr_fetch(xfs_inode_t *ip, struct xfs_name *name,
-                char *value, int *valuelenp, int flags)
+STATIC int
+xfs_attr_get_int(
+        struct xfs_inode        *ip,
+        struct xfs_name         *name,
+        char                    *value,
+        int                     *valuelenp,
+        int                     flags)
 {
         xfs_da_args_t   args;
         int             error;
@@ -188,7 +189,7 @@ xfs_attr_get(
                 return error;
 
         xfs_ilock(ip, XFS_ILOCK_SHARED);
-        error = xfs_attr_fetch(ip, &xname, value, valuelenp, flags);
+        error = xfs_attr_get_int(ip, &xname, value, valuelenp, flags);
         xfs_iunlock(ip, XFS_ILOCK_SHARED);
         return(error);
 }
@@ -636,7 +637,6 @@ xfs_attr_list_int(xfs_attr_list_context_t *context)
                 return EIO;
 
         xfs_ilock(dp, XFS_ILOCK_SHARED);
-        xfs_attr_trace_l_c("syscall start", context);
 
         /*
          * Decide on what work routines to call based on the inode size.
@@ -652,7 +652,6 @@ xfs_attr_list_int(xfs_attr_list_context_t *context)
         }
 
         xfs_iunlock(dp, XFS_ILOCK_SHARED);
-        xfs_attr_trace_l_c("syscall end", context);
 
         return error;
 }
@@ -698,7 +697,7 @@ xfs_attr_put_listent(xfs_attr_list_context_t *context, int flags,
                         context->count * sizeof(alist->al_offset[0]);
         context->firstu -= ATTR_ENTSIZE(namelen);
         if (context->firstu < arraytop) {
-                xfs_attr_trace_l_c("buffer full", context);
+                trace_xfs_attr_list_full(context);
                 alist->al_more = 1;
                 context->seen_enough = 1;
                 return 1;
@@ -710,7 +709,7 @@ xfs_attr_put_listent(xfs_attr_list_context_t *context, int flags,
         aep->a_name[namelen] = 0;
         alist->al_offset[context->count++] = context->firstu;
         alist->al_count = context->count;
-        xfs_attr_trace_l_c("add", context);
+        trace_xfs_attr_list_add(context);
         return 0;
 }
 
@@ -1849,7 +1848,7 @@ xfs_attr_node_list(xfs_attr_list_context_t *context)
                         node = bp->data;
                         switch (be16_to_cpu(node->hdr.info.magic)) {
                         case XFS_DA_NODE_MAGIC:
-                                xfs_attr_trace_l_cn("wrong blk", context, node);
+                                trace_xfs_attr_list_wrong_blk(context);
                                 xfs_da_brelse(NULL, bp);
                                 bp = NULL;
                                 break;
@@ -1857,20 +1856,18 @@ xfs_attr_node_list(xfs_attr_list_context_t *context)
                                 leaf = bp->data;
                                 if (cursor->hashval > be32_to_cpu(leaf->entries[
                                     be16_to_cpu(leaf->hdr.count)-1].hashval)) {
-                                        xfs_attr_trace_l_cl("wrong blk",
-                                                           context, leaf);
+                                        trace_xfs_attr_list_wrong_blk(context);
                                         xfs_da_brelse(NULL, bp);
                                         bp = NULL;
                                 } else if (cursor->hashval <=
                                              be32_to_cpu(leaf->entries[0].hashval)) {
-                                        xfs_attr_trace_l_cl("maybe wrong blk",
-                                                           context, leaf);
+                                        trace_xfs_attr_list_wrong_blk(context);
                                         xfs_da_brelse(NULL, bp);
                                         bp = NULL;
                                 }
                                 break;
                         default:
-                                xfs_attr_trace_l_c("wrong blk - ??", context);
+                                trace_xfs_attr_list_wrong_blk(context);
                                 xfs_da_brelse(NULL, bp);
                                 bp = NULL;
                         }
@@ -1915,8 +1912,8 @@ xfs_attr_node_list(xfs_attr_list_context_t *context)
                                 if (cursor->hashval
                                                 <= be32_to_cpu(btree->hashval)) {
                                         cursor->blkno = be32_to_cpu(btree->before);
-                                        xfs_attr_trace_l_cb("descending",
-                                                            context, btree);
+                                        trace_xfs_attr_list_node_descend(context,
+                                                                         btree);
                                         break;
                                 }
                         }
@@ -2143,8 +2140,8 @@ xfs_attr_rmtval_set(xfs_da_args_t *args)
                 dblkno = XFS_FSB_TO_DADDR(mp, map.br_startblock),
                 blkcnt = XFS_FSB_TO_BB(mp, map.br_blockcount);
 
-                bp = xfs_buf_get_flags(mp->m_ddev_targp, dblkno, blkcnt,
-                                       XFS_BUF_LOCK | XBF_DONT_BLOCK);
+                bp = xfs_buf_get(mp->m_ddev_targp, dblkno, blkcnt,
+                                 XFS_BUF_LOCK | XBF_DONT_BLOCK);
                 ASSERT(bp);
                 ASSERT(!XFS_BUF_GETERROR(bp));
 
@@ -2266,85 +2263,3 @@ xfs_attr_rmtval_remove(xfs_da_args_t *args)
         }
         return(0);
 }
-
-#if defined(XFS_ATTR_TRACE)
-/*
- * Add a trace buffer entry for an attr_list context structure.
- */
-void
-xfs_attr_trace_l_c(char *where, struct xfs_attr_list_context *context)
-{
-        xfs_attr_trace_enter(XFS_ATTR_KTRACE_L_C, where, context,
-                (__psunsigned_t)NULL,
-                (__psunsigned_t)NULL,
-                (__psunsigned_t)NULL);
-}
-
-/*
- * Add a trace buffer entry for a context structure and a Btree node.
- */
-void
-xfs_attr_trace_l_cn(char *where, struct xfs_attr_list_context *context,
-                         struct xfs_da_intnode *node)
-{
-        xfs_attr_trace_enter(XFS_ATTR_KTRACE_L_CN, where, context,
-                (__psunsigned_t)be16_to_cpu(node->hdr.count),
-                (__psunsigned_t)be32_to_cpu(node->btree[0].hashval),
-                (__psunsigned_t)be32_to_cpu(node->btree[
-                                    be16_to_cpu(node->hdr.count)-1].hashval));
-}
-
-/*
- * Add a trace buffer entry for a context structure and a Btree element.
- */
-void
-xfs_attr_trace_l_cb(char *where, struct xfs_attr_list_context *context,
-                          struct xfs_da_node_entry *btree)
-{
-        xfs_attr_trace_enter(XFS_ATTR_KTRACE_L_CB, where, context,
-                (__psunsigned_t)be32_to_cpu(btree->hashval),
-                (__psunsigned_t)be32_to_cpu(btree->before),
-                (__psunsigned_t)NULL);
-}
-
-/*
- * Add a trace buffer entry for a context structure and a leaf block.
- */
-void
-xfs_attr_trace_l_cl(char *where, struct xfs_attr_list_context *context,
-                              struct xfs_attr_leafblock *leaf)
-{
-        xfs_attr_trace_enter(XFS_ATTR_KTRACE_L_CL, where, context,
-                (__psunsigned_t)be16_to_cpu(leaf->hdr.count),
-                (__psunsigned_t)be32_to_cpu(leaf->entries[0].hashval),
-                (__psunsigned_t)be32_to_cpu(leaf->entries[
-                                be16_to_cpu(leaf->hdr.count)-1].hashval));
-}
-
-/*
- * Add a trace buffer entry for the arguments given to the routine,
- * generic form.
- */
-void
-xfs_attr_trace_enter(int type, char *where,
-                         struct xfs_attr_list_context *context,
-                         __psunsigned_t a13, __psunsigned_t a14,
-                         __psunsigned_t a15)
-{
-        ASSERT(xfs_attr_trace_buf);
-        ktrace_enter(xfs_attr_trace_buf, (void *)((__psunsigned_t)type),
-                (void *)((__psunsigned_t)where),
-                (void *)((__psunsigned_t)context->dp),
-                (void *)((__psunsigned_t)context->cursor->hashval),
-                (void *)((__psunsigned_t)context->cursor->blkno),
-                (void *)((__psunsigned_t)context->cursor->offset),
-                (void *)((__psunsigned_t)context->alist),
-                (void *)((__psunsigned_t)context->bufsize),
-                (void *)((__psunsigned_t)context->count),
-                (void *)((__psunsigned_t)context->firstu),
-                NULL,
-                (void *)((__psunsigned_t)context->dupcnt),
-                (void *)((__psunsigned_t)context->flags),
-                (void *)a13, (void *)a14, (void *)a15);
-}
-#endif  /* XFS_ATTR_TRACE */