Merge branch 'for-linus' of git://oss.sgi.com/xfs/xfs

[sfrench/cifs-2.6.git] / fs / xfs / linux-2.6 / xfs_buf.c

diff --git a/fs/xfs/linux-2.6/xfs_buf.c b/fs/xfs/linux-2.6/xfs_buf.c
index 4ddc973aea7ab0a99e67e97a0fadb97b3567f31f..b4c7d4248aac03e3ce4d1fa1e6396c1ff6c84a6f 100644 (file)
--- a/fs/xfs/linux-2.6/xfs_buf.c
+++ b/fs/xfs/linux-2.6/xfs_buf.c
@@ -39,6 +39,7 @@
 #include "xfs_ag.h"
 #include "xfs_dmapi.h"
 #include "xfs_mount.h"
+#include "xfs_trace.h"
 
 static kmem_zone_t *xfs_buf_zone;
 STATIC int xfsbufd(void *);
@@ -53,34 +54,6 @@ static struct workqueue_struct *xfslogd_workqueue;
 struct workqueue_struct *xfsdatad_workqueue;
 struct workqueue_struct *xfsconvertd_workqueue;
 
-#ifdef XFS_BUF_TRACE
-void
-xfs_buf_trace(
-       xfs_buf_t       *bp,
-       char            *id,
-       void            *data,
-       void            *ra)
-{
-       ktrace_enter(xfs_buf_trace_buf,
-               bp, id,
-               (void *)(unsigned long)bp->b_flags,
-               (void *)(unsigned long)bp->b_hold.counter,
-               (void *)(unsigned long)bp->b_sema.count,
-               (void *)current,
-               data, ra,
-               (void *)(unsigned long)((bp->b_file_offset>>32) & 0xffffffff),
-               (void *)(unsigned long)(bp->b_file_offset & 0xffffffff),
-               (void *)(unsigned long)bp->b_buffer_length,
-               NULL, NULL, NULL, NULL, NULL);
-}
-ktrace_t *xfs_buf_trace_buf;
-#define XFS_BUF_TRACE_SIZE     4096
-#define XB_TRACE(bp, id, data) \
-       xfs_buf_trace(bp, id, (void *)data, (void *)__builtin_return_address(0))
-#else
-#define XB_TRACE(bp, id, data) do { } while (0)
-#endif
-
 #ifdef XFS_BUF_LOCK_TRACKING
 # define XB_SET_OWNER(bp)      ((bp)->b_last_holder = current->pid)
 # define XB_CLEAR_OWNER(bp)    ((bp)->b_last_holder = -1)
@@ -279,7 +252,8 @@ _xfs_buf_initialize(
        init_waitqueue_head(&bp->b_waiters);
 
        XFS_STATS_INC(xb_create);
-       XB_TRACE(bp, "initialize", target);
+
+       trace_xfs_buf_init(bp, _RET_IP_);
 }
 
 /*
@@ -332,7 +306,7 @@ void
 xfs_buf_free(
        xfs_buf_t               *bp)
 {
-       XB_TRACE(bp, "free", 0);
+       trace_xfs_buf_free(bp, _RET_IP_);
 
        ASSERT(list_empty(&bp->b_hash_list));
 
@@ -445,7 +419,6 @@ _xfs_buf_lookup_pages(
        if (page_count == bp->b_page_count)
                bp->b_flags |= XBF_DONE;
 
-       XB_TRACE(bp, "lookup_pages", (long)page_count);
        return error;
 }
 
@@ -548,7 +521,6 @@ found:
        if (down_trylock(&bp->b_sema)) {
                if (!(flags & XBF_TRYLOCK)) {
                        /* wait for buffer ownership */
-                       XB_TRACE(bp, "get_lock", 0);
                        xfs_buf_lock(bp);
                        XFS_STATS_INC(xb_get_locked_waited);
                } else {
@@ -571,7 +543,8 @@ found:
                ASSERT((bp->b_flags & _XBF_DELWRI_Q) == 0);
                bp->b_flags &= XBF_MAPPED;
        }
-       XB_TRACE(bp, "got_lock", 0);
+
+       trace_xfs_buf_find(bp, flags, _RET_IP_);
        XFS_STATS_INC(xb_get_locked);
        return bp;
 }
@@ -627,7 +600,7 @@ xfs_buf_get(
        bp->b_bn = ioff;
        bp->b_count_desired = bp->b_buffer_length;
 
-       XB_TRACE(bp, "get", (unsigned long)flags);
+       trace_xfs_buf_get(bp, flags, _RET_IP_);
        return bp;
 
  no_buffer:
@@ -644,8 +617,6 @@ _xfs_buf_read(
 {
        int                     status;
 
-       XB_TRACE(bp, "_xfs_buf_read", (unsigned long)flags);
-
        ASSERT(!(flags & (XBF_DELWRI|XBF_WRITE)));
        ASSERT(bp->b_bn != XFS_BUF_DADDR_NULL);
 
@@ -673,19 +644,18 @@ xfs_buf_read(
 
        bp = xfs_buf_get(target, ioff, isize, flags);
        if (bp) {
+               trace_xfs_buf_read(bp, flags, _RET_IP_);
+
                if (!XFS_BUF_ISDONE(bp)) {
-                       XB_TRACE(bp, "read", (unsigned long)flags);
                        XFS_STATS_INC(xb_get_read);
                        _xfs_buf_read(bp, flags);
                } else if (flags & XBF_ASYNC) {
-                       XB_TRACE(bp, "read_async", (unsigned long)flags);
                        /*
                         * Read ahead call which is already satisfied,
                         * drop the buffer
                         */
                        goto no_buffer;
                } else {
-                       XB_TRACE(bp, "read_done", (unsigned long)flags);
                        /* We do not want read in the flags */
                        bp->b_flags &= ~XBF_READ;
                }
@@ -823,7 +793,7 @@ xfs_buf_get_noaddr(
 
        xfs_buf_unlock(bp);
 
-       XB_TRACE(bp, "no_daddr", len);
+       trace_xfs_buf_get_noaddr(bp, _RET_IP_);
        return bp;
 
  fail_free_mem:
@@ -845,8 +815,8 @@ void
 xfs_buf_hold(
        xfs_buf_t               *bp)
 {
+       trace_xfs_buf_hold(bp, _RET_IP_);
        atomic_inc(&bp->b_hold);
-       XB_TRACE(bp, "hold", 0);
 }
 
 /*
@@ -859,7 +829,7 @@ xfs_buf_rele(
 {
        xfs_bufhash_t           *hash = bp->b_hash;
 
-       XB_TRACE(bp, "rele", bp->b_relse);
+       trace_xfs_buf_rele(bp, _RET_IP_);
 
        if (unlikely(!hash)) {
                ASSERT(!bp->b_relse);
@@ -909,21 +879,19 @@ xfs_buf_cond_lock(
        int                     locked;
 
        locked = down_trylock(&bp->b_sema) == 0;
-       if (locked) {
+       if (locked)
                XB_SET_OWNER(bp);
-       }
-       XB_TRACE(bp, "cond_lock", (long)locked);
+
+       trace_xfs_buf_cond_lock(bp, _RET_IP_);
        return locked ? 0 : -EBUSY;
 }
 
-#if defined(DEBUG) || defined(XFS_BLI_TRACE)
 int
 xfs_buf_lock_value(
        xfs_buf_t               *bp)
 {
        return bp->b_sema.count;
 }
-#endif
 
 /*
  *     Locks a buffer object.
@@ -935,12 +903,14 @@ void
 xfs_buf_lock(
        xfs_buf_t               *bp)
 {
-       XB_TRACE(bp, "lock", 0);
+       trace_xfs_buf_lock(bp, _RET_IP_);
+
        if (atomic_read(&bp->b_io_remaining))
                blk_run_address_space(bp->b_target->bt_mapping);
        down(&bp->b_sema);
        XB_SET_OWNER(bp);
-       XB_TRACE(bp, "locked", 0);
+
+       trace_xfs_buf_lock_done(bp, _RET_IP_);
 }
 
 /*
@@ -962,7 +932,8 @@ xfs_buf_unlock(
 
        XB_CLEAR_OWNER(bp);
        up(&bp->b_sema);
-       XB_TRACE(bp, "unlock", 0);
+
+       trace_xfs_buf_unlock(bp, _RET_IP_);
 }
 
 
@@ -974,17 +945,18 @@ void
 xfs_buf_pin(
        xfs_buf_t               *bp)
 {
+       trace_xfs_buf_pin(bp, _RET_IP_);
        atomic_inc(&bp->b_pin_count);
-       XB_TRACE(bp, "pin", (long)bp->b_pin_count.counter);
 }
 
 void
 xfs_buf_unpin(
        xfs_buf_t               *bp)
 {
+       trace_xfs_buf_unpin(bp, _RET_IP_);
+
        if (atomic_dec_and_test(&bp->b_pin_count))
                wake_up_all(&bp->b_waiters);
-       XB_TRACE(bp, "unpin", (long)bp->b_pin_count.counter);
 }
 
 int
@@ -1035,7 +1007,7 @@ xfs_buf_iodone_work(
         */
        if ((bp->b_error == EOPNOTSUPP) &&
            (bp->b_flags & (XBF_ORDERED|XBF_ASYNC)) == (XBF_ORDERED|XBF_ASYNC)) {
-               XB_TRACE(bp, "ordered_retry", bp->b_iodone);
+               trace_xfs_buf_ordered_retry(bp, _RET_IP_);
                bp->b_flags &= ~XBF_ORDERED;
                bp->b_flags |= _XFS_BARRIER_FAILED;
                xfs_buf_iorequest(bp);
@@ -1050,12 +1022,12 @@ xfs_buf_ioend(
        xfs_buf_t               *bp,
        int                     schedule)
 {
+       trace_xfs_buf_iodone(bp, _RET_IP_);
+
        bp->b_flags &= ~(XBF_READ | XBF_WRITE | XBF_READ_AHEAD);
        if (bp->b_error == 0)
                bp->b_flags |= XBF_DONE;
 
-       XB_TRACE(bp, "iodone", bp->b_iodone);
-
        if ((bp->b_iodone) || (bp->b_flags & XBF_ASYNC)) {
                if (schedule) {
                        INIT_WORK(&bp->b_iodone_work, xfs_buf_iodone_work);
@@ -1075,7 +1047,7 @@ xfs_buf_ioerror(
 {
        ASSERT(error >= 0 && error <= 0xffff);
        bp->b_error = (unsigned short)error;
-       XB_TRACE(bp, "ioerror", (unsigned long)error);
+       trace_xfs_buf_ioerror(bp, error, _RET_IP_);
 }
 
 int
@@ -1083,7 +1055,7 @@ xfs_bawrite(
        void                    *mp,
        struct xfs_buf          *bp)
 {
-       XB_TRACE(bp, "bawrite", 0);
+       trace_xfs_buf_bawrite(bp, _RET_IP_);
 
        ASSERT(bp->b_bn != XFS_BUF_DADDR_NULL);
 
@@ -1102,7 +1074,7 @@ xfs_bdwrite(
        void                    *mp,
        struct xfs_buf          *bp)
 {
-       XB_TRACE(bp, "bdwrite", 0);
+       trace_xfs_buf_bdwrite(bp, _RET_IP_);
 
        bp->b_strat = xfs_bdstrat_cb;
        bp->b_mount = mp;
@@ -1253,7 +1225,7 @@ int
 xfs_buf_iorequest(
        xfs_buf_t               *bp)
 {
-       XB_TRACE(bp, "iorequest", 0);
+       trace_xfs_buf_iorequest(bp, _RET_IP_);
 
        if (bp->b_flags & XBF_DELWRI) {
                xfs_buf_delwri_queue(bp, 1);
@@ -1287,11 +1259,13 @@ int
 xfs_buf_iowait(
        xfs_buf_t               *bp)
 {
-       XB_TRACE(bp, "iowait", 0);
+       trace_xfs_buf_iowait(bp, _RET_IP_);
+
        if (atomic_read(&bp->b_io_remaining))
                blk_run_address_space(bp->b_target->bt_mapping);
        wait_for_completion(&bp->b_iowait);
-       XB_TRACE(bp, "iowaited", (long)bp->b_error);
+
+       trace_xfs_buf_iowait_done(bp, _RET_IP_);
        return bp->b_error;
 }
 
@@ -1604,7 +1578,8 @@ xfs_buf_delwri_queue(
        struct list_head        *dwq = &bp->b_target->bt_delwrite_queue;
        spinlock_t              *dwlk = &bp->b_target->bt_delwrite_lock;
 
-       XB_TRACE(bp, "delwri_q", (long)unlock);
+       trace_xfs_buf_delwri_queue(bp, _RET_IP_);
+
        ASSERT((bp->b_flags&(XBF_DELWRI|XBF_ASYNC)) == (XBF_DELWRI|XBF_ASYNC));
 
        spin_lock(dwlk);
@@ -1644,7 +1619,7 @@ xfs_buf_delwri_dequeue(
        if (dequeued)
                xfs_buf_rele(bp);
 
-       XB_TRACE(bp, "delwri_dq", (long)dequeued);
+       trace_xfs_buf_delwri_dequeue(bp, _RET_IP_);
 }
 
 STATIC void
@@ -1692,7 +1667,7 @@ xfs_buf_delwri_split(
        INIT_LIST_HEAD(list);
        spin_lock(dwlk);
        list_for_each_entry_safe(bp, n, dwq, b_list) {
-               XB_TRACE(bp, "walkq1", (long)xfs_buf_ispin(bp));
+               trace_xfs_buf_delwri_split(bp, _RET_IP_);
                ASSERT(bp->b_flags & XBF_DELWRI);
 
                if (!xfs_buf_ispin(bp) && !xfs_buf_cond_lock(bp)) {
@@ -1816,14 +1791,10 @@ xfs_flush_buftarg(
 int __init
 xfs_buf_init(void)
 {
-#ifdef XFS_BUF_TRACE
-       xfs_buf_trace_buf = ktrace_alloc(XFS_BUF_TRACE_SIZE, KM_NOFS);
-#endif
-
        xfs_buf_zone = kmem_zone_init_flags(sizeof(xfs_buf_t), "xfs_buf",
                                                KM_ZONE_HWALIGN, NULL);
        if (!xfs_buf_zone)
-               goto out_free_trace_buf;
+               goto out;
 
        xfslogd_workqueue = create_workqueue("xfslogd");
        if (!xfslogd_workqueue)
@@ -1846,10 +1817,7 @@ xfs_buf_init(void)
        destroy_workqueue(xfslogd_workqueue);
  out_free_buf_zone:
        kmem_zone_destroy(xfs_buf_zone);
- out_free_trace_buf:
-#ifdef XFS_BUF_TRACE
-       ktrace_free(xfs_buf_trace_buf);
-#endif
+ out:
        return -ENOMEM;
 }
 
@@ -1861,9 +1829,6 @@ xfs_buf_terminate(void)
        destroy_workqueue(xfsdatad_workqueue);
        destroy_workqueue(xfslogd_workqueue);
        kmem_zone_destroy(xfs_buf_zone);
-#ifdef XFS_BUF_TRACE
-       ktrace_free(xfs_buf_trace_buf);
-#endif
 }
 
 #ifdef CONFIG_KDB_MODULES