Merge tag 'v3.9-rc3' into drm-intel-next-queued

Backmerge so that I can merge Imre Deak's coalesced sg entries fixes,
which depend upon the new for_each_sg_page introduce in

commit a321e91b6d73ed011ffceed384c40d2785cf723b
Author: Imre Deak <imre.deak@intel.com>
Date:   Wed Feb 27 17:02:56 2013 -0800

    lib/scatterlist: add simple page iterator

The merge itself is just two trivial conflicts:

Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>

9 files changed, 578 insertions, 158 deletions

diff --git a/include/trace/events/block.h b/include/trace/events/block.h
index 05c5e61f0a7c..9961726523d0 100644
--- a/include/trace/events/block.h
+++ b/include/trace/events/block.h
@@ -6,10 +6,61 @@
 
 #include <linux/blktrace_api.h>
 #include <linux/blkdev.h>
+#include <linux/buffer_head.h>
 #include <linux/tracepoint.h>
 
 #define RWBS_LEN        8
 
+DECLARE_EVENT_CLASS(block_buffer,
+
+        TP_PROTO(struct buffer_head *bh),
+
+        TP_ARGS(bh),
+
+        TP_STRUCT__entry (
+                __field(  dev_t,        dev                     )
+                __field(  sector_t,     sector                  )
+                __field(  size_t,       size                    )
+        ),
+
+        TP_fast_assign(
+                __entry->dev            = bh->b_bdev->bd_dev;
+                __entry->sector         = bh->b_blocknr;
+                __entry->size           = bh->b_size;
+        ),
+
+        TP_printk("%d,%d sector=%llu size=%zu",
+                MAJOR(__entry->dev), MINOR(__entry->dev),
+                (unsigned long long)__entry->sector, __entry->size
+        )
+);
+
+/**
+ * block_touch_buffer - mark a buffer accessed
+ * @bh: buffer_head being touched
+ *
+ * Called from touch_buffer().
+ */
+DEFINE_EVENT(block_buffer, block_touch_buffer,
+
+        TP_PROTO(struct buffer_head *bh),
+
+        TP_ARGS(bh)
+);
+
+/**
+ * block_dirty_buffer - mark a buffer dirty
+ * @bh: buffer_head being dirtied
+ *
+ * Called from mark_buffer_dirty().
+ */
+DEFINE_EVENT(block_buffer, block_dirty_buffer,
+
+        TP_PROTO(struct buffer_head *bh),
+
+        TP_ARGS(bh)
+);
+
 DECLARE_EVENT_CLASS(block_rq_with_error,
 
         TP_PROTO(struct request_queue *q, struct request *rq),
@@ -206,7 +257,6 @@ TRACE_EVENT(block_bio_bounce,
 
 /**
  * block_bio_complete - completed all work on the block operation
- * @q: queue holding the block operation
  * @bio: block operation completed
  * @error: io error value
  *
@@ -215,9 +265,9 @@ TRACE_EVENT(block_bio_bounce,
  */
 TRACE_EVENT(block_bio_complete,
 
-        TP_PROTO(struct request_queue *q, struct bio *bio, int error),
+        TP_PROTO(struct bio *bio, int error),
 
-        TP_ARGS(q, bio, error),
+        TP_ARGS(bio, error),
 
         TP_STRUCT__entry(
                 __field( dev_t,         dev             )
@@ -228,7 +278,8 @@ TRACE_EVENT(block_bio_complete,
         ),
 
         TP_fast_assign(
-                __entry->dev            = bio->bi_bdev->bd_dev;
+                __entry->dev            = bio->bi_bdev ?
+                                          bio->bi_bdev->bd_dev : 0;
                 __entry->sector         = bio->bi_sector;
                 __entry->nr_sector      = bio->bi_size >> 9;
                 __entry->error          = error;
@@ -241,11 +292,11 @@ TRACE_EVENT(block_bio_complete,
                   __entry->nr_sector, __entry->error)
 );
 
-DECLARE_EVENT_CLASS(block_bio,
+DECLARE_EVENT_CLASS(block_bio_merge,
 
-        TP_PROTO(struct request_queue *q, struct bio *bio),
+        TP_PROTO(struct request_queue *q, struct request *rq, struct bio *bio),
 
-        TP_ARGS(q, bio),
+        TP_ARGS(q, rq, bio),
 
         TP_STRUCT__entry(
                 __field( dev_t,         dev                     )
@@ -272,31 +323,33 @@ DECLARE_EVENT_CLASS(block_bio,
 /**
  * block_bio_backmerge - merging block operation to the end of an existing operation
  * @q: queue holding operation
+ * @rq: request bio is being merged into
  * @bio: new block operation to merge
  *
  * Merging block request @bio to the end of an existing block request
  * in queue @q.
  */
-DEFINE_EVENT(block_bio, block_bio_backmerge,
+DEFINE_EVENT(block_bio_merge, block_bio_backmerge,
 
-        TP_PROTO(struct request_queue *q, struct bio *bio),
+        TP_PROTO(struct request_queue *q, struct request *rq, struct bio *bio),
 
-        TP_ARGS(q, bio)
+        TP_ARGS(q, rq, bio)
 );
 
 /**
  * block_bio_frontmerge - merging block operation to the beginning of an existing operation
  * @q: queue holding operation
+ * @rq: request bio is being merged into
  * @bio: new block operation to merge
  *
  * Merging block IO operation @bio to the beginning of an existing block
  * operation in queue @q.
  */
-DEFINE_EVENT(block_bio, block_bio_frontmerge,
+DEFINE_EVENT(block_bio_merge, block_bio_frontmerge,
 
-        TP_PROTO(struct request_queue *q, struct bio *bio),
+        TP_PROTO(struct request_queue *q, struct request *rq, struct bio *bio),
 
-        TP_ARGS(q, bio)
+        TP_ARGS(q, rq, bio)
 );
 
 /**
@@ -306,11 +359,32 @@ DEFINE_EVENT(block_bio, block_bio_frontmerge,
  *
  * About to place the block IO operation @bio into queue @q.
  */
-DEFINE_EVENT(block_bio, block_bio_queue,
+TRACE_EVENT(block_bio_queue,
 
         TP_PROTO(struct request_queue *q, struct bio *bio),
 
-        TP_ARGS(q, bio)
+        TP_ARGS(q, bio),
+
+        TP_STRUCT__entry(
+                __field( dev_t,         dev                     )
+                __field( sector_t,      sector                  )
+                __field( unsigned int,  nr_sector               )
+                __array( char,          rwbs,   RWBS_LEN        )
+                __array( char,          comm,   TASK_COMM_LEN   )
+        ),
+
+        TP_fast_assign(
+                __entry->dev            = bio->bi_bdev->bd_dev;
+                __entry->sector         = bio->bi_sector;
+                __entry->nr_sector      = bio->bi_size >> 9;
+                blk_fill_rwbs(__entry->rwbs, bio->bi_rw, bio->bi_size);
+                memcpy(__entry->comm, current->comm, TASK_COMM_LEN);
+        ),
+
+        TP_printk("%d,%d %s %llu + %u [%s]",
+                  MAJOR(__entry->dev), MINOR(__entry->dev), __entry->rwbs,
+                  (unsigned long long)__entry->sector,
+                  __entry->nr_sector, __entry->comm)
 );
 
 DECLARE_EVENT_CLASS(block_get_rq,
diff --git a/include/trace/events/ext4.h b/include/trace/events/ext4.h
index 7e8c36bc7082..4ee471003859 100644
--- a/include/trace/events/ext4.h
+++ b/include/trace/events/ext4.h
@@ -1324,6 +1324,31 @@ TRACE_EVENT(ext4_fallocate_exit,
                   __entry->ret)
 );
 
+TRACE_EVENT(ext4_punch_hole,
+        TP_PROTO(struct inode *inode, loff_t offset, loff_t len),
+
+        TP_ARGS(inode, offset, len),
+
+        TP_STRUCT__entry(
+                __field(        dev_t,  dev                     )
+                __field(        ino_t,  ino                     )
+                __field(        loff_t, offset                  )
+                __field(        loff_t, len                     )
+        ),
+
+        TP_fast_assign(
+                __entry->dev    = inode->i_sb->s_dev;
+                __entry->ino    = inode->i_ino;
+                __entry->offset = offset;
+                __entry->len    = len;
+        ),
+
+        TP_printk("dev %d,%d ino %lu offset %lld len %lld",
+                  MAJOR(__entry->dev), MINOR(__entry->dev),
+                  (unsigned long) __entry->ino,
+                  __entry->offset, __entry->len)
+);
+
 TRACE_EVENT(ext4_unlink_enter,
         TP_PROTO(struct inode *parent, struct dentry *dentry),
 
@@ -2068,103 +2093,210 @@ TRACE_EVENT(ext4_ext_remove_space_done,
 );
 
 TRACE_EVENT(ext4_es_insert_extent,
-        TP_PROTO(struct inode *inode, ext4_lblk_t start, ext4_lblk_t len),
+        TP_PROTO(struct inode *inode, struct extent_status *es),
 
-        TP_ARGS(inode, start, len),
+        TP_ARGS(inode, es),
 
         TP_STRUCT__entry(
-                __field(        dev_t,  dev                     )
-                __field(        ino_t,  ino                     )
-                __field(        loff_t, start                   )
-                __field(        loff_t, len                     )
+                __field(        dev_t,          dev             )
+                __field(        ino_t,          ino             )
+                __field(        ext4_lblk_t,    lblk            )
+                __field(        ext4_lblk_t,    len             )
+                __field(        ext4_fsblk_t,   pblk            )
+                __field(        unsigned long long, status      )
         ),
 
         TP_fast_assign(
                 __entry->dev    = inode->i_sb->s_dev;
                 __entry->ino    = inode->i_ino;
-                __entry->start  = start;
-                __entry->len    = len;
+                __entry->lblk   = es->es_lblk;
+                __entry->len    = es->es_len;
+                __entry->pblk   = ext4_es_pblock(es);
+                __entry->status = ext4_es_status(es);
         ),
 
-        TP_printk("dev %d,%d ino %lu es [%lld/%lld)",
+        TP_printk("dev %d,%d ino %lu es [%u/%u) mapped %llu status %llx",
                   MAJOR(__entry->dev), MINOR(__entry->dev),
                   (unsigned long) __entry->ino,
-                  __entry->start, __entry->len)
+                  __entry->lblk, __entry->len,
+                  __entry->pblk, __entry->status)
 );
 
 TRACE_EVENT(ext4_es_remove_extent,
-        TP_PROTO(struct inode *inode, ext4_lblk_t start, ext4_lblk_t len),
+        TP_PROTO(struct inode *inode, ext4_lblk_t lblk, ext4_lblk_t len),
 
-        TP_ARGS(inode, start, len),
+        TP_ARGS(inode, lblk, len),
 
         TP_STRUCT__entry(
                 __field(        dev_t,  dev                     )
                 __field(        ino_t,  ino                     )
-                __field(        loff_t, start                   )
+                __field(        loff_t, lblk                    )
                 __field(        loff_t, len                     )
         ),
 
         TP_fast_assign(
                 __entry->dev    = inode->i_sb->s_dev;
                 __entry->ino    = inode->i_ino;
-                __entry->start  = start;
+                __entry->lblk   = lblk;
                 __entry->len    = len;
         ),
 
         TP_printk("dev %d,%d ino %lu es [%lld/%lld)",
                   MAJOR(__entry->dev), MINOR(__entry->dev),
                   (unsigned long) __entry->ino,
-                  __entry->start, __entry->len)
+                  __entry->lblk, __entry->len)
 );
 
-TRACE_EVENT(ext4_es_find_extent_enter,
-        TP_PROTO(struct inode *inode, ext4_lblk_t start),
+TRACE_EVENT(ext4_es_find_delayed_extent_enter,
+        TP_PROTO(struct inode *inode, ext4_lblk_t lblk),
 
-        TP_ARGS(inode, start),
+        TP_ARGS(inode, lblk),
 
         TP_STRUCT__entry(
                 __field(        dev_t,          dev             )
                 __field(        ino_t,          ino             )
-                __field(        ext4_lblk_t,    start           )
+                __field(        ext4_lblk_t,    lblk            )
         ),
 
         TP_fast_assign(
                 __entry->dev    = inode->i_sb->s_dev;
                 __entry->ino    = inode->i_ino;
-                __entry->start  = start;
+                __entry->lblk   = lblk;
         ),
 
-        TP_printk("dev %d,%d ino %lu start %u",
+        TP_printk("dev %d,%d ino %lu lblk %u",
                   MAJOR(__entry->dev), MINOR(__entry->dev),
-                  (unsigned long) __entry->ino, __entry->start)
+                  (unsigned long) __entry->ino, __entry->lblk)
 );
 
-TRACE_EVENT(ext4_es_find_extent_exit,
-        TP_PROTO(struct inode *inode, struct extent_status *es,
-                 ext4_lblk_t ret),
+TRACE_EVENT(ext4_es_find_delayed_extent_exit,
+        TP_PROTO(struct inode *inode, struct extent_status *es),
 
-        TP_ARGS(inode, es, ret),
+        TP_ARGS(inode, es),
 
         TP_STRUCT__entry(
                 __field(        dev_t,          dev             )
                 __field(        ino_t,          ino             )
-                __field(        ext4_lblk_t,    start           )
+                __field(        ext4_lblk_t,    lblk            )
                 __field(        ext4_lblk_t,    len             )
-                __field(        ext4_lblk_t,    ret             )
+                __field(        ext4_fsblk_t,   pblk            )
+                __field(        unsigned long long, status      )
         ),
 
         TP_fast_assign(
                 __entry->dev    = inode->i_sb->s_dev;
                 __entry->ino    = inode->i_ino;
-                __entry->start  = es->start;
-                __entry->len    = es->len;
-                __entry->ret    = ret;
+                __entry->lblk   = es->es_lblk;
+                __entry->len    = es->es_len;
+                __entry->pblk   = ext4_es_pblock(es);
+                __entry->status = ext4_es_status(es);
         ),
 
-        TP_printk("dev %d,%d ino %lu es [%u/%u) ret %u",
+        TP_printk("dev %d,%d ino %lu es [%u/%u) mapped %llu status %llx",
                   MAJOR(__entry->dev), MINOR(__entry->dev),
                   (unsigned long) __entry->ino,
-                  __entry->start, __entry->len, __entry->ret)
+                  __entry->lblk, __entry->len,
+                  __entry->pblk, __entry->status)
+);
+
+TRACE_EVENT(ext4_es_lookup_extent_enter,
+        TP_PROTO(struct inode *inode, ext4_lblk_t lblk),
+
+        TP_ARGS(inode, lblk),
+
+        TP_STRUCT__entry(
+                __field(        dev_t,          dev             )
+                __field(        ino_t,          ino             )
+                __field(        ext4_lblk_t,    lblk            )
+        ),
+
+        TP_fast_assign(
+                __entry->dev    = inode->i_sb->s_dev;
+                __entry->ino    = inode->i_ino;
+                __entry->lblk   = lblk;
+        ),
+
+        TP_printk("dev %d,%d ino %lu lblk %u",
+                  MAJOR(__entry->dev), MINOR(__entry->dev),
+                  (unsigned long) __entry->ino, __entry->lblk)
+);
+
+TRACE_EVENT(ext4_es_lookup_extent_exit,
+        TP_PROTO(struct inode *inode, struct extent_status *es,
+                 int found),
+
+        TP_ARGS(inode, es, found),
+
+        TP_STRUCT__entry(
+                __field(        dev_t,          dev             )
+                __field(        ino_t,          ino             )
+                __field(        ext4_lblk_t,    lblk            )
+                __field(        ext4_lblk_t,    len             )
+                __field(        ext4_fsblk_t,   pblk            )
+                __field(        unsigned long long,     status  )
+                __field(        int,            found           )
+        ),
+
+        TP_fast_assign(
+                __entry->dev    = inode->i_sb->s_dev;
+                __entry->ino    = inode->i_ino;
+                __entry->lblk   = es->es_lblk;
+                __entry->len    = es->es_len;
+                __entry->pblk   = ext4_es_pblock(es);
+                __entry->status = ext4_es_status(es);
+                __entry->found  = found;
+        ),
+
+        TP_printk("dev %d,%d ino %lu found %d [%u/%u) %llu %llx",
+                  MAJOR(__entry->dev), MINOR(__entry->dev),
+                  (unsigned long) __entry->ino, __entry->found,
+                  __entry->lblk, __entry->len,
+                  __entry->found ? __entry->pblk : 0,
+                  __entry->found ? __entry->status : 0)
+);
+
+TRACE_EVENT(ext4_es_shrink_enter,
+        TP_PROTO(struct super_block *sb, int nr_to_scan, int cache_cnt),
+
+        TP_ARGS(sb, nr_to_scan, cache_cnt),
+
+        TP_STRUCT__entry(
+                __field(        dev_t,  dev                     )
+                __field(        int,    nr_to_scan              )
+                __field(        int,    cache_cnt               )
+        ),
+
+        TP_fast_assign(
+                __entry->dev            = sb->s_dev;
+                __entry->nr_to_scan     = nr_to_scan;
+                __entry->cache_cnt      = cache_cnt;
+        ),
+
+        TP_printk("dev %d,%d nr_to_scan %d cache_cnt %d",
+                  MAJOR(__entry->dev), MINOR(__entry->dev),
+                  __entry->nr_to_scan, __entry->cache_cnt)
+);
+
+TRACE_EVENT(ext4_es_shrink_exit,
+        TP_PROTO(struct super_block *sb, int shrunk_nr, int cache_cnt),
+
+        TP_ARGS(sb, shrunk_nr, cache_cnt),
+
+        TP_STRUCT__entry(
+                __field(        dev_t,  dev                     )
+                __field(        int,    shrunk_nr               )
+                __field(        int,    cache_cnt               )
+        ),
+
+        TP_fast_assign(
+                __entry->dev            = sb->s_dev;
+                __entry->shrunk_nr      = shrunk_nr;
+                __entry->cache_cnt      = cache_cnt;
+        ),
+
+        TP_printk("dev %d,%d shrunk_nr %d cache_cnt %d",
+                  MAJOR(__entry->dev), MINOR(__entry->dev),
+                  __entry->shrunk_nr, __entry->cache_cnt)
 );
 
 #endif /* _TRACE_EXT4_H */
diff --git a/include/trace/events/jbd2.h b/include/trace/events/jbd2.h
index 127993dbf322..070df49e4a1d 100644
--- a/include/trace/events/jbd2.h
+++ b/include/trace/events/jbd2.h
@@ -132,6 +132,104 @@ TRACE_EVENT(jbd2_submit_inode_data,
                   (unsigned long) __entry->ino)
 );
 
+TRACE_EVENT(jbd2_handle_start,
+        TP_PROTO(dev_t dev, unsigned long tid, unsigned int type,
+                 unsigned int line_no, int requested_blocks),
+
+        TP_ARGS(dev, tid, type, line_no, requested_blocks),
+
+        TP_STRUCT__entry(
+                __field(                dev_t,  dev             )
+                __field(        unsigned long,  tid             )
+                __field(         unsigned int,  type            )
+                __field(         unsigned int,  line_no         )
+                __field(                  int,  requested_blocks)
+        ),
+
+        TP_fast_assign(
+                __entry->dev              = dev;
+                __entry->tid              = tid;
+                __entry->type             = type;
+                __entry->line_no          = line_no;
+                __entry->requested_blocks = requested_blocks;
+        ),
+
+        TP_printk("dev %d,%d tid %lu type %u line_no %u "
+                  "requested_blocks %d",
+                  MAJOR(__entry->dev), MINOR(__entry->dev), __entry->tid,
+                  __entry->type, __entry->line_no, __entry->requested_blocks)
+);
+
+TRACE_EVENT(jbd2_handle_extend,
+        TP_PROTO(dev_t dev, unsigned long tid, unsigned int type,
+                 unsigned int line_no, int buffer_credits,
+                 int requested_blocks),
+
+        TP_ARGS(dev, tid, type, line_no, buffer_credits, requested_blocks),
+
+        TP_STRUCT__entry(
+                __field(                dev_t,  dev             )
+                __field(        unsigned long,  tid             )
+                __field(         unsigned int,  type            )
+                __field(         unsigned int,  line_no         )
+                __field(                  int,  buffer_credits  )
+                __field(                  int,  requested_blocks)
+        ),
+
+        TP_fast_assign(
+                __entry->dev              = dev;
+                __entry->tid              = tid;
+                __entry->type             = type;
+                __entry->line_no          = line_no;
+                __entry->buffer_credits   = buffer_credits;
+                __entry->requested_blocks = requested_blocks;
+        ),
+
+        TP_printk("dev %d,%d tid %lu type %u line_no %u "
+                  "buffer_credits %d requested_blocks %d",
+                  MAJOR(__entry->dev), MINOR(__entry->dev), __entry->tid,
+                  __entry->type, __entry->line_no, __entry->buffer_credits,
+                  __entry->requested_blocks)
+);
+
+TRACE_EVENT(jbd2_handle_stats,
+        TP_PROTO(dev_t dev, unsigned long tid, unsigned int type,
+                 unsigned int line_no, int interval, int sync,
+                 int requested_blocks, int dirtied_blocks),
+
+        TP_ARGS(dev, tid, type, line_no, interval, sync,
+                requested_blocks, dirtied_blocks),
+
+        TP_STRUCT__entry(
+                __field(                dev_t,  dev             )
+                __field(        unsigned long,  tid             )
+                __field(         unsigned int,  type            )
+                __field(         unsigned int,  line_no         )
+                __field(                  int,  interval        )
+                __field(                  int,  sync            )
+                __field(                  int,  requested_blocks)
+                __field(                  int,  dirtied_blocks  )
+        ),
+
+        TP_fast_assign(
+                __entry->dev              = dev;
+                __entry->tid              = tid;
+                __entry->type             = type;
+                __entry->line_no          = line_no;
+                __entry->interval         = interval;
+                __entry->sync             = sync;
+                __entry->requested_blocks = requested_blocks;
+                __entry->dirtied_blocks   = dirtied_blocks;
+        ),
+
+        TP_printk("dev %d,%d tid %lu type %u line_no %u interval %d "
+                  "sync %d requested_blocks %d dirtied_blocks %d",
+                  MAJOR(__entry->dev), MINOR(__entry->dev), __entry->tid,
+                  __entry->type, __entry->line_no, __entry->interval,
+                  __entry->sync, __entry->requested_blocks,
+                  __entry->dirtied_blocks)
+);
+
 TRACE_EVENT(jbd2_run_stats,
         TP_PROTO(dev_t dev, unsigned long tid,
                  struct transaction_run_stats_s *stats),
@@ -142,6 +240,7 @@ TRACE_EVENT(jbd2_run_stats,
                 __field(                dev_t,  dev             )
                 __field(        unsigned long,  tid             )
                 __field(        unsigned long,  wait            )
+                __field(        unsigned long,  request_delay   )
                 __field(        unsigned long,  running         )
                 __field(        unsigned long,  locked          )
                 __field(        unsigned long,  flushing        )
@@ -155,6 +254,7 @@ TRACE_EVENT(jbd2_run_stats,
                 __entry->dev            = dev;
                 __entry->tid            = tid;
                 __entry->wait           = stats->rs_wait;
+                __entry->request_delay  = stats->rs_request_delay;
                 __entry->running        = stats->rs_running;
                 __entry->locked         = stats->rs_locked;
                 __entry->flushing       = stats->rs_flushing;
@@ -164,10 +264,12 @@ TRACE_EVENT(jbd2_run_stats,
                 __entry->blocks_logged  = stats->rs_blocks_logged;
         ),
 
-        TP_printk("dev %d,%d tid %lu wait %u running %u locked %u flushing %u "
-                  "logging %u handle_count %u blocks %u blocks_logged %u",
+        TP_printk("dev %d,%d tid %lu wait %u request_delay %u running %u "
+                  "locked %u flushing %u logging %u handle_count %u "
+                  "blocks %u blocks_logged %u",
                   MAJOR(__entry->dev), MINOR(__entry->dev), __entry->tid,
                   jiffies_to_msecs(__entry->wait),
+                  jiffies_to_msecs(__entry->request_delay),
                   jiffies_to_msecs(__entry->running),
                   jiffies_to_msecs(__entry->locked),
                   jiffies_to_msecs(__entry->flushing),
diff --git a/include/trace/events/kvm.h b/include/trace/events/kvm.h
index 7ef9e759f499..19911dddaeb7 100644
--- a/include/trace/events/kvm.h
+++ b/include/trace/events/kvm.h
@@ -14,7 +14,7 @@
         ERSN(SHUTDOWN), ERSN(FAIL_ENTRY), ERSN(INTR), ERSN(SET_TPR),    \
         ERSN(TPR_ACCESS), ERSN(S390_SIEIC), ERSN(S390_RESET), ERSN(DCR),\
         ERSN(NMI), ERSN(INTERNAL_ERROR), ERSN(OSI), ERSN(PAPR_HCALL),   \
-        ERSN(S390_UCONTROL)
+        ERSN(S390_UCONTROL), ERSN(WATCHDOG), ERSN(S390_TSCH)
 
 TRACE_EVENT(kvm_userspace_exit,
             TP_PROTO(__u32 reason, int errno),
diff --git a/include/trace/events/power.h b/include/trace/events/power.h
index 0c9783841a30..427acab5d69a 100644
--- a/include/trace/events/power.h
+++ b/include/trace/events/power.h
@@ -99,98 +99,6 @@ DEFINE_EVENT(wakeup_source, wakeup_source_deactivate,
         TP_ARGS(name, state)
 );
 
-#ifdef CONFIG_EVENT_POWER_TRACING_DEPRECATED
-
-/*
- * The power events are used for cpuidle & suspend (power_start, power_end)
- *  and for cpufreq (power_frequency)
- */
-DECLARE_EVENT_CLASS(power,
-
-        TP_PROTO(unsigned int type, unsigned int state, unsigned int cpu_id),
-
-        TP_ARGS(type, state, cpu_id),
-
-        TP_STRUCT__entry(
-                __field(        u64,            type            )
-                __field(        u64,            state           )
-                __field(        u64,            cpu_id          )
-        ),
-
-        TP_fast_assign(
-                __entry->type = type;
-                __entry->state = state;
-                __entry->cpu_id = cpu_id;
-        ),
-
-        TP_printk("type=%lu state=%lu cpu_id=%lu", (unsigned long)__entry->type,
-                (unsigned long)__entry->state, (unsigned long)__entry->cpu_id)
-);
-
-DEFINE_EVENT(power, power_start,
-
-        TP_PROTO(unsigned int type, unsigned int state, unsigned int cpu_id),
-
-        TP_ARGS(type, state, cpu_id)
-);
-
-DEFINE_EVENT(power, power_frequency,
-
-        TP_PROTO(unsigned int type, unsigned int state, unsigned int cpu_id),
-
-        TP_ARGS(type, state, cpu_id)
-);
-
-TRACE_EVENT(power_end,
-
-        TP_PROTO(unsigned int cpu_id),
-
-        TP_ARGS(cpu_id),
-
-        TP_STRUCT__entry(
-                __field(        u64,            cpu_id          )
-        ),
-
-        TP_fast_assign(
-                __entry->cpu_id = cpu_id;
-        ),
-
-        TP_printk("cpu_id=%lu", (unsigned long)__entry->cpu_id)
-
-);
-
-/* Deprecated dummy functions must be protected against multi-declartion */
-#ifndef _PWR_EVENT_AVOID_DOUBLE_DEFINING_DEPRECATED
-#define _PWR_EVENT_AVOID_DOUBLE_DEFINING_DEPRECATED
-
-enum {
-        POWER_NONE = 0,
-        POWER_CSTATE = 1,
-        POWER_PSTATE = 2,
-};
-#endif /* _PWR_EVENT_AVOID_DOUBLE_DEFINING_DEPRECATED */
-
-#else /* CONFIG_EVENT_POWER_TRACING_DEPRECATED */
-
-#ifndef _PWR_EVENT_AVOID_DOUBLE_DEFINING_DEPRECATED
-#define _PWR_EVENT_AVOID_DOUBLE_DEFINING_DEPRECATED
-enum {
-       POWER_NONE = 0,
-       POWER_CSTATE = 1,
-       POWER_PSTATE = 2,
-};
-
-/* These dummy declaration have to be ripped out when the deprecated
-   events get removed */
-static inline void trace_power_start(u64 type, u64 state, u64 cpuid) {};
-static inline void trace_power_end(u64 cpuid) {};
-static inline void trace_power_start_rcuidle(u64 type, u64 state, u64 cpuid) {};
-static inline void trace_power_end_rcuidle(u64 cpuid) {};
-static inline void trace_power_frequency(u64 type, u64 state, u64 cpuid) {};
-#endif /* _PWR_EVENT_AVOID_DOUBLE_DEFINING_DEPRECATED */
-
-#endif /* CONFIG_EVENT_POWER_TRACING_DEPRECATED */
-
 /*
  * The clock events are used for clock enable/disable and for
  *  clock rate change
diff --git a/include/trace/events/ras.h b/include/trace/events/ras.h
new file mode 100644
index 000000000000..88b878383797
--- /dev/null
+++ b/include/trace/events/ras.h
@@ -0,0 +1,77 @@
+#undef TRACE_SYSTEM
+#define TRACE_SYSTEM ras
+
+#if !defined(_TRACE_AER_H) || defined(TRACE_HEADER_MULTI_READ)
+#define _TRACE_AER_H
+
+#include <linux/tracepoint.h>
+#include <linux/edac.h>
+
+
+/*
+ * PCIe AER Trace event
+ *
+ * These events are generated when hardware detects a corrected or
+ * uncorrected event on a PCIe device. The event report has
+ * the following structure:
+ *
+ * char * dev_name -    The name of the slot where the device resides
+ *                      ([domain:]bus:device.function).
+ * u32 status -         Either the correctable or uncorrectable register
+ *                      indicating what error or errors have been seen
+ * u8 severity -        error severity 0:NONFATAL 1:FATAL 2:CORRECTED
+ */
+
+#define aer_correctable_errors          \
+        {BIT(0),        "Receiver Error"},              \
+        {BIT(6),        "Bad TLP"},                     \
+        {BIT(7),        "Bad DLLP"},                    \
+        {BIT(8),        "RELAY_NUM Rollover"},          \
+        {BIT(12),       "Replay Timer Timeout"},        \
+        {BIT(13),       "Advisory Non-Fatal"}
+
+#define aer_uncorrectable_errors                \
+        {BIT(4),        "Data Link Protocol"},          \
+        {BIT(12),       "Poisoned TLP"},                \
+        {BIT(13),       "Flow Control Protocol"},       \
+        {BIT(14),       "Completion Timeout"},          \
+        {BIT(15),       "Completer Abort"},             \
+        {BIT(16),       "Unexpected Completion"},       \
+        {BIT(17),       "Receiver Overflow"},           \
+        {BIT(18),       "Malformed TLP"},               \
+        {BIT(19),       "ECRC"},                        \
+        {BIT(20),       "Unsupported Request"}
+
+TRACE_EVENT(aer_event,
+        TP_PROTO(const char *dev_name,
+                 const u32 status,
+                 const u8 severity),
+
+        TP_ARGS(dev_name, status, severity),
+
+        TP_STRUCT__entry(
+                __string(       dev_name,       dev_name        )
+                __field(        u32,            status          )
+                __field(        u8,             severity        )
+        ),
+
+        TP_fast_assign(
+                __assign_str(dev_name, dev_name);
+                __entry->status         = status;
+                __entry->severity       = severity;
+        ),
+
+        TP_printk("%s PCIe Bus Error: severity=%s, %s\n",
+                __get_str(dev_name),
+                __entry->severity == HW_EVENT_ERR_CORRECTED ? "Corrected" :
+                        __entry->severity == HW_EVENT_ERR_FATAL ?
+                        "Fatal" : "Uncorrected",
+                __entry->severity == HW_EVENT_ERR_CORRECTED ?
+                __print_flags(__entry->status, "|", aer_correctable_errors) :
+                __print_flags(__entry->status, "|", aer_uncorrectable_errors))
+);
+
+#endif /* _TRACE_AER_H */
+
+/* This part must be outside protection */
+#include <trace/define_trace.h>
diff --git a/include/trace/events/rcu.h b/include/trace/events/rcu.h
index d4f559b1ec34..1918e832da4f 100644
--- a/include/trace/events/rcu.h
+++ b/include/trace/events/rcu.h
@@ -44,8 +44,10 @@ TRACE_EVENT(rcu_utilization,
  * of a new grace period or the end of an old grace period ("cpustart"
  * and "cpuend", respectively), a CPU passing through a quiescent
  * state ("cpuqs"), a CPU coming online or going offline ("cpuonl"
- * and "cpuofl", respectively), and a CPU being kicked for being too
- * long in dyntick-idle mode ("kick").
+ * and "cpuofl", respectively), a CPU being kicked for being too
+ * long in dyntick-idle mode ("kick"), a CPU accelerating its new
+ * callbacks to RCU_NEXT_READY_TAIL ("AccReadyCB"), and a CPU
+ * accelerating its new callbacks to RCU_WAIT_TAIL ("AccWaitCB").
  */
 TRACE_EVENT(rcu_grace_period,
 
@@ -393,7 +395,7 @@ TRACE_EVENT(rcu_kfree_callback,
  */
 TRACE_EVENT(rcu_batch_start,
 
-        TP_PROTO(char *rcuname, long qlen_lazy, long qlen, int blimit),
+        TP_PROTO(char *rcuname, long qlen_lazy, long qlen, long blimit),
 
         TP_ARGS(rcuname, qlen_lazy, qlen, blimit),
 
@@ -401,7 +403,7 @@ TRACE_EVENT(rcu_batch_start,
                 __field(char *, rcuname)
                 __field(long, qlen_lazy)
                 __field(long, qlen)
-                __field(int, blimit)
+                __field(long, blimit)
         ),
 
         TP_fast_assign(
@@ -411,7 +413,7 @@ TRACE_EVENT(rcu_batch_start,
                 __entry->blimit = blimit;
         ),
 
-        TP_printk("%s CBs=%ld/%ld bl=%d",
+        TP_printk("%s CBs=%ld/%ld bl=%ld",
                   __entry->rcuname, __entry->qlen_lazy, __entry->qlen,
                   __entry->blimit)
 );
@@ -523,22 +525,30 @@ TRACE_EVENT(rcu_batch_end,
  */
 TRACE_EVENT(rcu_torture_read,
 
-        TP_PROTO(char *rcutorturename, struct rcu_head *rhp),
+        TP_PROTO(char *rcutorturename, struct rcu_head *rhp,
+                 unsigned long secs, unsigned long c_old, unsigned long c),
 
-        TP_ARGS(rcutorturename, rhp),
+        TP_ARGS(rcutorturename, rhp, secs, c_old, c),
 
         TP_STRUCT__entry(
                 __field(char *, rcutorturename)
                 __field(struct rcu_head *, rhp)
+                __field(unsigned long, secs)
+                __field(unsigned long, c_old)
+                __field(unsigned long, c)
         ),
 
         TP_fast_assign(
                 __entry->rcutorturename = rcutorturename;
                 __entry->rhp = rhp;
+                __entry->secs = secs;
+                __entry->c_old = c_old;
+                __entry->c = c;
         ),
 
-        TP_printk("%s torture read %p",
-                  __entry->rcutorturename, __entry->rhp)
+        TP_printk("%s torture read %p %luus c: %lu %lu",
+                  __entry->rcutorturename, __entry->rhp,
+                  __entry->secs, __entry->c_old, __entry->c)
 );
 
 /*
@@ -608,7 +618,8 @@ TRACE_EVENT(rcu_barrier,
 #define trace_rcu_invoke_kfree_callback(rcuname, rhp, offset) do { } while (0)
 #define trace_rcu_batch_end(rcuname, callbacks_invoked, cb, nr, iit, risk) \
         do { } while (0)
-#define trace_rcu_torture_read(rcutorturename, rhp) do { } while (0)
+#define trace_rcu_torture_read(rcutorturename, rhp, secs, c_old, c) \
+        do { } while (0)
 #define trace_rcu_barrier(name, s, cpu, cnt, done) do { } while (0)
 
 #endif /* #else #ifdef CONFIG_RCU_TRACE */
diff --git a/include/trace/events/workqueue.h b/include/trace/events/workqueue.h
index f28d1b65f178..bf0e18ba6cfb 100644
--- a/include/trace/events/workqueue.h
+++ b/include/trace/events/workqueue.h
@@ -27,7 +27,7 @@ DECLARE_EVENT_CLASS(workqueue_work,
 /**
  * workqueue_queue_work - called when a work gets queued
  * @req_cpu:    the requested cpu
- * @cwq:        pointer to struct cpu_workqueue_struct
+ * @pwq:        pointer to struct pool_workqueue
  * @work:       pointer to struct work_struct
  *
  * This event occurs when a work is queued immediately or once a
@@ -36,10 +36,10 @@ DECLARE_EVENT_CLASS(workqueue_work,
  */
 TRACE_EVENT(workqueue_queue_work,
 
-        TP_PROTO(unsigned int req_cpu, struct cpu_workqueue_struct *cwq,
+        TP_PROTO(unsigned int req_cpu, struct pool_workqueue *pwq,
                  struct work_struct *work),
 
-        TP_ARGS(req_cpu, cwq, work),
+        TP_ARGS(req_cpu, pwq, work),
 
         TP_STRUCT__entry(
                 __field( void *,        work    )
@@ -52,9 +52,9 @@ TRACE_EVENT(workqueue_queue_work,
         TP_fast_assign(
                 __entry->work           = work;
                 __entry->function       = work->func;
-                __entry->workqueue      = cwq->wq;
+                __entry->workqueue      = pwq->wq;
                 __entry->req_cpu        = req_cpu;
-                __entry->cpu            = cwq->pool->gcwq->cpu;
+                __entry->cpu            = pwq->pool->cpu;
         ),
 
         TP_printk("work struct=%p function=%pf workqueue=%p req_cpu=%u cpu=%u",
diff --git a/include/trace/events/writeback.h b/include/trace/events/writeback.h
index b453d92c2253..6a16fd2e70ed 100644
--- a/include/trace/events/writeback.h
+++ b/include/trace/events/writeback.h
@@ -32,6 +32,115 @@
 
 struct wb_writeback_work;
 
+TRACE_EVENT(writeback_dirty_page,
+
+        TP_PROTO(struct page *page, struct address_space *mapping),
+
+        TP_ARGS(page, mapping),
+
+        TP_STRUCT__entry (
+                __array(char, name, 32)
+                __field(unsigned long, ino)
+                __field(pgoff_t, index)
+        ),
+
+        TP_fast_assign(
+                strncpy(__entry->name,
+                        mapping ? dev_name(mapping->backing_dev_info->dev) : "(unknown)", 32);
+                __entry->ino = mapping ? mapping->host->i_ino : 0;
+                __entry->index = page->index;
+        ),
+
+        TP_printk("bdi %s: ino=%lu index=%lu",
+                __entry->name,
+                __entry->ino,
+                __entry->index
+        )
+);
+
+DECLARE_EVENT_CLASS(writeback_dirty_inode_template,
+
+        TP_PROTO(struct inode *inode, int flags),
+
+        TP_ARGS(inode, flags),
+
+        TP_STRUCT__entry (
+                __array(char, name, 32)
+                __field(unsigned long, ino)
+                __field(unsigned long, flags)
+        ),
+
+        TP_fast_assign(
+                struct backing_dev_info *bdi = inode->i_mapping->backing_dev_info;
+
+                /* may be called for files on pseudo FSes w/ unregistered bdi */
+                strncpy(__entry->name,
+                        bdi->dev ? dev_name(bdi->dev) : "(unknown)", 32);
+                __entry->ino            = inode->i_ino;
+                __entry->flags          = flags;
+        ),
+
+        TP_printk("bdi %s: ino=%lu flags=%s",
+                __entry->name,
+                __entry->ino,
+                show_inode_state(__entry->flags)
+        )
+);
+
+DEFINE_EVENT(writeback_dirty_inode_template, writeback_dirty_inode_start,
+
+        TP_PROTO(struct inode *inode, int flags),
+
+        TP_ARGS(inode, flags)
+);
+
+DEFINE_EVENT(writeback_dirty_inode_template, writeback_dirty_inode,
+
+        TP_PROTO(struct inode *inode, int flags),
+
+        TP_ARGS(inode, flags)
+);
+
+DECLARE_EVENT_CLASS(writeback_write_inode_template,
+
+        TP_PROTO(struct inode *inode, struct writeback_control *wbc),
+
+        TP_ARGS(inode, wbc),
+
+        TP_STRUCT__entry (
+                __array(char, name, 32)
+                __field(unsigned long, ino)
+                __field(int, sync_mode)
+        ),
+
+        TP_fast_assign(
+                strncpy(__entry->name,
+                        dev_name(inode->i_mapping->backing_dev_info->dev), 32);
+                __entry->ino            = inode->i_ino;
+                __entry->sync_mode      = wbc->sync_mode;
+        ),
+
+        TP_printk("bdi %s: ino=%lu sync_mode=%d",
+                __entry->name,
+                __entry->ino,
+                __entry->sync_mode
+        )
+);
+
+DEFINE_EVENT(writeback_write_inode_template, writeback_write_inode_start,
+
+        TP_PROTO(struct inode *inode, struct writeback_control *wbc),
+
+        TP_ARGS(inode, wbc)
+);
+
+DEFINE_EVENT(writeback_write_inode_template, writeback_write_inode,
+
+        TP_PROTO(struct inode *inode, struct writeback_control *wbc),
+
+        TP_ARGS(inode, wbc)
+);
+
 DECLARE_EVENT_CLASS(writeback_work_class,
         TP_PROTO(struct backing_dev_info *bdi, struct wb_writeback_work *work),
         TP_ARGS(bdi, work),
@@ -479,6 +588,13 @@ DECLARE_EVENT_CLASS(writeback_single_inode_template,
         )
 );
 
+DEFINE_EVENT(writeback_single_inode_template, writeback_single_inode_start,
+        TP_PROTO(struct inode *inode,
+                 struct writeback_control *wbc,
+                 unsigned long nr_to_write),
+        TP_ARGS(inode, wbc, nr_to_write)
+);
+
 DEFINE_EVENT(writeback_single_inode_template, writeback_single_inode,
         TP_PROTO(struct inode *inode,
                  struct writeback_control *wbc,