Merge branch 'for-2.6.36' of git://git.kernel.dk/linux-2.6-block

* 'for-2.6.36' of git://git.kernel.dk/linux-2.6-block: (149 commits)
  block: make sure that REQ_* types are seen even with CONFIG_BLOCK=n
  xen-blkfront: fix missing out label
  blkdev: fix blkdev_issue_zeroout return value
  block: update request stacking methods to support discards
  block: fix missing export of blk_types.h
  writeback: fix bad _bh spinlock nesting
  drbd: revert "delay probes", feature is being re-implemented differently
  drbd: Initialize all members of sync_conf to their defaults [Bugz 315]
  drbd: Disable delay probes for the upcomming release
  writeback: cleanup bdi_register
  writeback: add new tracepoints
  writeback: remove unnecessary init_timer call
  writeback: optimize periodic bdi thread wakeups
  writeback: prevent unnecessary bdi threads wakeups
  writeback: move bdi threads exiting logic to the forker thread
  writeback: restructure bdi forker loop a little
  writeback: move last_active to bdi
  writeback: do not remove bdi from bdi_list
  writeback: simplify bdi code a little
  writeback: do not lose wake-ups in bdi threads
  ...

Fixed up pretty trivial conflicts in drivers/block/virtio_blk.c and
drivers/scsi/scsi_error.c as per Jens.

2 files changed, 169 insertions, 5 deletions

diff --git a/include/trace/events/block.h b/include/trace/events/block.h
index d870a918559c..d8ce278515c3 100644
--- a/include/trace/events/block.h
+++ b/include/trace/events/block.h
@@ -25,8 +25,10 @@ DECLARE_EVENT_CLASS(block_rq_with_error,
 
         TP_fast_assign(
                 __entry->dev       = rq->rq_disk ? disk_devt(rq->rq_disk) : 0;
-                __entry->sector    = blk_pc_request(rq) ? 0 : blk_rq_pos(rq);
-                __entry->nr_sector = blk_pc_request(rq) ? 0 : blk_rq_sectors(rq);
+                __entry->sector    = (rq->cmd_type == REQ_TYPE_BLOCK_PC) ?
+                                        0 : blk_rq_pos(rq);
+                __entry->nr_sector = (rq->cmd_type == REQ_TYPE_BLOCK_PC) ?
+                                        0 : blk_rq_sectors(rq);
                 __entry->errors    = rq->errors;
 
                 blk_fill_rwbs_rq(__entry->rwbs, rq);
@@ -109,9 +111,12 @@ DECLARE_EVENT_CLASS(block_rq,
 
         TP_fast_assign(
                 __entry->dev       = rq->rq_disk ? disk_devt(rq->rq_disk) : 0;
-                __entry->sector    = blk_pc_request(rq) ? 0 : blk_rq_pos(rq);
-                __entry->nr_sector = blk_pc_request(rq) ? 0 : blk_rq_sectors(rq);
-                __entry->bytes     = blk_pc_request(rq) ? blk_rq_bytes(rq) : 0;
+                __entry->sector    = (rq->cmd_type == REQ_TYPE_BLOCK_PC) ?
+                                        0 : blk_rq_pos(rq);
+                __entry->nr_sector = (rq->cmd_type == REQ_TYPE_BLOCK_PC) ?
+                                        0 : blk_rq_sectors(rq);
+                __entry->bytes     = (rq->cmd_type == REQ_TYPE_BLOCK_PC) ?
+                                        blk_rq_bytes(rq) : 0;
 
                 blk_fill_rwbs_rq(__entry->rwbs, rq);
                 blk_dump_cmd(__get_str(cmd), rq);
diff --git a/include/trace/events/writeback.h b/include/trace/events/writeback.h
new file mode 100644
index 000000000000..f345f66ae9d1
--- /dev/null
+++ b/include/trace/events/writeback.h
@@ -0,0 +1,159 @@
+#undef TRACE_SYSTEM
+#define TRACE_SYSTEM writeback
+
+#if !defined(_TRACE_WRITEBACK_H) || defined(TRACE_HEADER_MULTI_READ)
+#define _TRACE_WRITEBACK_H
+
+#include <linux/backing-dev.h>
+#include <linux/device.h>
+#include <linux/writeback.h>
+
+struct wb_writeback_work;
+
+DECLARE_EVENT_CLASS(writeback_work_class,
+        TP_PROTO(struct backing_dev_info *bdi, struct wb_writeback_work *work),
+        TP_ARGS(bdi, work),
+        TP_STRUCT__entry(
+                __array(char, name, 32)
+                __field(long, nr_pages)
+                __field(dev_t, sb_dev)
+                __field(int, sync_mode)
+                __field(int, for_kupdate)
+                __field(int, range_cyclic)
+                __field(int, for_background)
+        ),
+        TP_fast_assign(
+                strncpy(__entry->name, dev_name(bdi->dev), 32);
+                __entry->nr_pages = work->nr_pages;
+                __entry->sb_dev = work->sb ? work->sb->s_dev : 0;
+                __entry->sync_mode = work->sync_mode;
+                __entry->for_kupdate = work->for_kupdate;
+                __entry->range_cyclic = work->range_cyclic;
+                __entry->for_background = work->for_background;
+        ),
+        TP_printk("bdi %s: sb_dev %d:%d nr_pages=%ld sync_mode=%d "
+                  "kupdate=%d range_cyclic=%d background=%d",
+                  __entry->name,
+                  MAJOR(__entry->sb_dev), MINOR(__entry->sb_dev),
+                  __entry->nr_pages,
+                  __entry->sync_mode,
+                  __entry->for_kupdate,
+                  __entry->range_cyclic,
+                  __entry->for_background
+        )
+);
+#define DEFINE_WRITEBACK_WORK_EVENT(name) \
+DEFINE_EVENT(writeback_work_class, name, \
+        TP_PROTO(struct backing_dev_info *bdi, struct wb_writeback_work *work), \
+        TP_ARGS(bdi, work))
+DEFINE_WRITEBACK_WORK_EVENT(writeback_nothread);
+DEFINE_WRITEBACK_WORK_EVENT(writeback_queue);
+DEFINE_WRITEBACK_WORK_EVENT(writeback_exec);
+
+TRACE_EVENT(writeback_pages_written,
+        TP_PROTO(long pages_written),
+        TP_ARGS(pages_written),
+        TP_STRUCT__entry(
+                __field(long,           pages)
+        ),
+        TP_fast_assign(
+                __entry->pages          = pages_written;
+        ),
+        TP_printk("%ld", __entry->pages)
+);
+
+DECLARE_EVENT_CLASS(writeback_class,
+        TP_PROTO(struct backing_dev_info *bdi),
+        TP_ARGS(bdi),
+        TP_STRUCT__entry(
+                __array(char, name, 32)
+        ),
+        TP_fast_assign(
+                strncpy(__entry->name, dev_name(bdi->dev), 32);
+        ),
+        TP_printk("bdi %s",
+                  __entry->name
+        )
+);
+#define DEFINE_WRITEBACK_EVENT(name) \
+DEFINE_EVENT(writeback_class, name, \
+        TP_PROTO(struct backing_dev_info *bdi), \
+        TP_ARGS(bdi))
+
+DEFINE_WRITEBACK_EVENT(writeback_nowork);
+DEFINE_WRITEBACK_EVENT(writeback_wake_thread);
+DEFINE_WRITEBACK_EVENT(writeback_wake_forker_thread);
+DEFINE_WRITEBACK_EVENT(writeback_bdi_register);
+DEFINE_WRITEBACK_EVENT(writeback_bdi_unregister);
+DEFINE_WRITEBACK_EVENT(writeback_thread_start);
+DEFINE_WRITEBACK_EVENT(writeback_thread_stop);
+
+DECLARE_EVENT_CLASS(wbc_class,
+        TP_PROTO(struct writeback_control *wbc, struct backing_dev_info *bdi),
+        TP_ARGS(wbc, bdi),
+        TP_STRUCT__entry(
+                __array(char, name, 32)
+                __field(long, nr_to_write)
+                __field(long, pages_skipped)
+                __field(int, sync_mode)
+                __field(int, nonblocking)
+                __field(int, encountered_congestion)
+                __field(int, for_kupdate)
+                __field(int, for_background)
+                __field(int, for_reclaim)
+                __field(int, range_cyclic)
+                __field(int, more_io)
+                __field(unsigned long, older_than_this)
+                __field(long, range_start)
+                __field(long, range_end)
+        ),
+
+        TP_fast_assign(
+                strncpy(__entry->name, dev_name(bdi->dev), 32);
+                __entry->nr_to_write    = wbc->nr_to_write;
+                __entry->pages_skipped  = wbc->pages_skipped;
+                __entry->sync_mode      = wbc->sync_mode;
+                __entry->for_kupdate    = wbc->for_kupdate;
+                __entry->for_background = wbc->for_background;
+                __entry->for_reclaim    = wbc->for_reclaim;
+                __entry->range_cyclic   = wbc->range_cyclic;
+                __entry->more_io        = wbc->more_io;
+                __entry->older_than_this = wbc->older_than_this ?
+                                                *wbc->older_than_this : 0;
+                __entry->range_start    = (long)wbc->range_start;
+                __entry->range_end      = (long)wbc->range_end;
+        ),
+
+        TP_printk("bdi %s: towrt=%ld skip=%ld mode=%d kupd=%d "
+                "bgrd=%d reclm=%d cyclic=%d more=%d older=0x%lx "
+                "start=0x%lx end=0x%lx",
+                __entry->name,
+                __entry->nr_to_write,
+                __entry->pages_skipped,
+                __entry->sync_mode,
+                __entry->for_kupdate,
+                __entry->for_background,
+                __entry->for_reclaim,
+                __entry->range_cyclic,
+                __entry->more_io,
+                __entry->older_than_this,
+                __entry->range_start,
+                __entry->range_end)
+)
+
+#define DEFINE_WBC_EVENT(name) \
+DEFINE_EVENT(wbc_class, name, \
+        TP_PROTO(struct writeback_control *wbc, struct backing_dev_info *bdi), \
+        TP_ARGS(wbc, bdi))
+DEFINE_WBC_EVENT(wbc_writeback_start);
+DEFINE_WBC_EVENT(wbc_writeback_written);
+DEFINE_WBC_EVENT(wbc_writeback_wait);
+DEFINE_WBC_EVENT(wbc_balance_dirty_start);
+DEFINE_WBC_EVENT(wbc_balance_dirty_written);
+DEFINE_WBC_EVENT(wbc_balance_dirty_wait);
+DEFINE_WBC_EVENT(wbc_writepage);
+
+#endif /* _TRACE_WRITEBACK_H */
+
+/* This part must be outside protection */
+#include <trace/define_trace.h>