Merge commit 'linus/master' into tracing/kprobes

Conflicts:
	kernel/trace/Makefile
	kernel/trace/trace.h
	kernel/trace/trace_event_types.h
	kernel/trace/trace_export.c

Merge reason:
	Sync with latest significant tracing core changes.

11 files changed, 1076 insertions, 107 deletions

diff --git a/include/trace/events/block.h b/include/trace/events/block.h
index 9a74b468a229..d86af94691c2 100644
--- a/include/trace/events/block.h
+++ b/include/trace/events/block.h
@@ -171,6 +171,7 @@ TRACE_EVENT(block_rq_complete,
                   (unsigned long long)__entry->sector,
                   __entry->nr_sector, __entry->errors)
 );
+
 TRACE_EVENT(block_bio_bounce,
 
         TP_PROTO(struct request_queue *q, struct bio *bio),
@@ -186,7 +187,8 @@ TRACE_EVENT(block_bio_bounce,
         ),
 
         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;
                 blk_fill_rwbs(__entry->rwbs, bio->bi_rw, bio->bi_size);
diff --git a/include/trace/events/ext4.h b/include/trace/events/ext4.h
index 7d8b5bc74185..c1bd8f1e8b94 100644
--- a/include/trace/events/ext4.h
+++ b/include/trace/events/ext4.h
@@ -5,10 +5,15 @@
 #define _TRACE_EXT4_H
 
 #include <linux/writeback.h>
-#include "../../../fs/ext4/ext4.h"
-#include "../../../fs/ext4/mballoc.h"
 #include <linux/tracepoint.h>
 
+struct ext4_allocation_context;
+struct ext4_allocation_request;
+struct ext4_prealloc_space;
+struct ext4_inode_info;
+
+#define EXT4_I(inode) (container_of(inode, struct ext4_inode_info, vfs_inode))
+
 TRACE_EVENT(ext4_free_inode,
         TP_PROTO(struct inode *inode),
 
@@ -33,8 +38,8 @@ TRACE_EVENT(ext4_free_inode,
         ),
 
         TP_printk("dev %s ino %lu mode %d uid %u gid %u blocks %llu",
-                  jbd2_dev_to_name(__entry->dev), __entry->ino, __entry->mode,
-                  __entry->uid, __entry->gid,
+                  jbd2_dev_to_name(__entry->dev), (unsigned long) __entry->ino,
+                  __entry->mode, __entry->uid, __entry->gid,
                   (unsigned long long) __entry->blocks)
 );
 
@@ -56,7 +61,8 @@ TRACE_EVENT(ext4_request_inode,
         ),
 
         TP_printk("dev %s dir %lu mode %d",
-                  jbd2_dev_to_name(__entry->dev), __entry->dir, __entry->mode)
+                  jbd2_dev_to_name(__entry->dev), (unsigned long) __entry->dir,
+                  __entry->mode)
 );
 
 TRACE_EVENT(ext4_allocate_inode,
@@ -79,7 +85,8 @@ TRACE_EVENT(ext4_allocate_inode,
         ),
 
         TP_printk("dev %s ino %lu dir %lu mode %d",
-                  jbd2_dev_to_name(__entry->dev), __entry->ino, __entry->dir, __entry->mode)
+                  jbd2_dev_to_name(__entry->dev), (unsigned long) __entry->ino,
+                  (unsigned long) __entry->dir, __entry->mode)
 );
 
 TRACE_EVENT(ext4_write_begin,
@@ -106,8 +113,8 @@ TRACE_EVENT(ext4_write_begin,
         ),
 
         TP_printk("dev %s ino %lu pos %llu len %u flags %u",
-                  jbd2_dev_to_name(__entry->dev), __entry->ino, __entry->pos, __entry->len,
-                  __entry->flags)
+                  jbd2_dev_to_name(__entry->dev), (unsigned long) __entry->ino,
+                  __entry->pos, __entry->len, __entry->flags)
 );
 
 TRACE_EVENT(ext4_ordered_write_end,
@@ -133,8 +140,8 @@ TRACE_EVENT(ext4_ordered_write_end,
         ),
 
         TP_printk("dev %s ino %lu pos %llu len %u copied %u",
-                  jbd2_dev_to_name(__entry->dev), __entry->ino, __entry->pos, __entry->len,
-                  __entry->copied)
+                  jbd2_dev_to_name(__entry->dev), (unsigned long) __entry->ino,
+                  __entry->pos, __entry->len, __entry->copied)
 );
 
 TRACE_EVENT(ext4_writeback_write_end,
@@ -160,8 +167,8 @@ TRACE_EVENT(ext4_writeback_write_end,
         ),
 
         TP_printk("dev %s ino %lu pos %llu len %u copied %u",
-                  jbd2_dev_to_name(__entry->dev), __entry->ino, __entry->pos, __entry->len,
-                  __entry->copied)
+                  jbd2_dev_to_name(__entry->dev), (unsigned long) __entry->ino,
+                  __entry->pos, __entry->len, __entry->copied)
 );
 
 TRACE_EVENT(ext4_journalled_write_end,
@@ -186,8 +193,8 @@ TRACE_EVENT(ext4_journalled_write_end,
         ),
 
         TP_printk("dev %s ino %lu pos %llu len %u copied %u",
-                  jbd2_dev_to_name(__entry->dev), __entry->ino, __entry->pos, __entry->len,
-                  __entry->copied)
+                  jbd2_dev_to_name(__entry->dev), (unsigned long) __entry->ino,
+                  __entry->pos, __entry->len, __entry->copied)
 );
 
 TRACE_EVENT(ext4_writepage,
@@ -209,7 +216,8 @@ TRACE_EVENT(ext4_writepage,
         ),
 
         TP_printk("dev %s ino %lu page_index %lu",
-                  jbd2_dev_to_name(__entry->dev), __entry->ino, __entry->index)
+                  jbd2_dev_to_name(__entry->dev), (unsigned long) __entry->ino,
+                  __entry->index)
 );
 
 TRACE_EVENT(ext4_da_writepages,
@@ -227,7 +235,6 @@ TRACE_EVENT(ext4_da_writepages,
                 __field(        char,   nonblocking             )
                 __field(        char,   for_kupdate             )
                 __field(        char,   for_reclaim             )
-                __field(        char,   for_writepages          )
                 __field(        char,   range_cyclic            )
         ),
 
@@ -241,16 +248,50 @@ TRACE_EVENT(ext4_da_writepages,
                 __entry->nonblocking    = wbc->nonblocking;
                 __entry->for_kupdate    = wbc->for_kupdate;
                 __entry->for_reclaim    = wbc->for_reclaim;
-                __entry->for_writepages = wbc->for_writepages;
                 __entry->range_cyclic   = wbc->range_cyclic;
         ),
 
-        TP_printk("dev %s ino %lu nr_t_write %ld pages_skipped %ld range_start %llu range_end %llu nonblocking %d for_kupdate %d for_reclaim %d for_writepages %d range_cyclic %d",
-                  jbd2_dev_to_name(__entry->dev), __entry->ino, __entry->nr_to_write,
+        TP_printk("dev %s ino %lu nr_to_write %ld pages_skipped %ld range_start %llu range_end %llu nonblocking %d for_kupdate %d for_reclaim %d range_cyclic %d",
+                  jbd2_dev_to_name(__entry->dev),
+                  (unsigned long) __entry->ino, __entry->nr_to_write,
                   __entry->pages_skipped, __entry->range_start,
                   __entry->range_end, __entry->nonblocking,
                   __entry->for_kupdate, __entry->for_reclaim,
-                  __entry->for_writepages, __entry->range_cyclic)
+                  __entry->range_cyclic)
+);
+
+TRACE_EVENT(ext4_da_write_pages,
+        TP_PROTO(struct inode *inode, struct mpage_da_data *mpd),
+
+        TP_ARGS(inode, mpd),
+
+        TP_STRUCT__entry(
+                __field(        dev_t,  dev                     )
+                __field(        ino_t,  ino                     )
+                __field(        __u64,  b_blocknr               )
+                __field(        __u32,  b_size                  )
+                __field(        __u32,  b_state                 )
+                __field(        unsigned long,  first_page      )
+                __field(        int,    io_done                 )
+                __field(        int,    pages_written           )
+        ),
+
+        TP_fast_assign(
+                __entry->dev            = inode->i_sb->s_dev;
+                __entry->ino            = inode->i_ino;
+                __entry->b_blocknr      = mpd->b_blocknr;
+                __entry->b_size         = mpd->b_size;
+                __entry->b_state        = mpd->b_state;
+                __entry->first_page     = mpd->first_page;
+                __entry->io_done        = mpd->io_done;
+                __entry->pages_written  = mpd->pages_written;
+        ),
+
+        TP_printk("dev %s ino %lu b_blocknr %llu b_size %u b_state 0x%04x first_page %lu io_done %d pages_written %d",
+                  jbd2_dev_to_name(__entry->dev), (unsigned long) __entry->ino,
+                  __entry->b_blocknr, __entry->b_size,
+                  __entry->b_state, __entry->first_page,
+                  __entry->io_done, __entry->pages_written)
 );
 
 TRACE_EVENT(ext4_da_writepages_result,
@@ -282,7 +323,8 @@ TRACE_EVENT(ext4_da_writepages_result,
         ),
 
         TP_printk("dev %s ino %lu ret %d pages_written %d pages_skipped %ld congestion %d more_io %d no_nrwrite_index_update %d",
-                  jbd2_dev_to_name(__entry->dev), __entry->ino, __entry->ret,
+                  jbd2_dev_to_name(__entry->dev),
+                  (unsigned long) __entry->ino, __entry->ret,
                   __entry->pages_written, __entry->pages_skipped,
                   __entry->encountered_congestion, __entry->more_io,
                   __entry->no_nrwrite_index_update)
@@ -311,8 +353,8 @@ TRACE_EVENT(ext4_da_write_begin,
         ),
 
         TP_printk("dev %s ino %lu pos %llu len %u flags %u",
-                  jbd2_dev_to_name(__entry->dev), __entry->ino, __entry->pos, __entry->len,
-                  __entry->flags)
+                  jbd2_dev_to_name(__entry->dev), (unsigned long) __entry->ino,
+                  __entry->pos, __entry->len, __entry->flags)
 );
 
 TRACE_EVENT(ext4_da_write_end,
@@ -338,8 +380,8 @@ TRACE_EVENT(ext4_da_write_end,
         ),
 
         TP_printk("dev %s ino %lu pos %llu len %u copied %u",
-                  jbd2_dev_to_name(__entry->dev), __entry->ino, __entry->pos, __entry->len,
-                  __entry->copied)
+                  jbd2_dev_to_name(__entry->dev), (unsigned long) __entry->ino,
+                  __entry->pos, __entry->len, __entry->copied)
 );
 
 TRACE_EVENT(ext4_discard_blocks,
@@ -389,8 +431,8 @@ TRACE_EVENT(ext4_mb_new_inode_pa,
         ),
 
         TP_printk("dev %s ino %lu pstart %llu len %u lstart %llu",
-                  jbd2_dev_to_name(__entry->dev), __entry->ino, __entry->pa_pstart,
-                  __entry->pa_len, __entry->pa_lstart)
+                  jbd2_dev_to_name(__entry->dev), (unsigned long) __entry->ino,
+                  __entry->pa_pstart, __entry->pa_len, __entry->pa_lstart)
 );
 
 TRACE_EVENT(ext4_mb_new_group_pa,
@@ -417,8 +459,8 @@ TRACE_EVENT(ext4_mb_new_group_pa,
         ),
 
         TP_printk("dev %s ino %lu pstart %llu len %u lstart %llu",
-                  jbd2_dev_to_name(__entry->dev), __entry->ino, __entry->pa_pstart,
-                  __entry->pa_len, __entry->pa_lstart)
+                  jbd2_dev_to_name(__entry->dev), (unsigned long) __entry->ino,
+                  __entry->pa_pstart, __entry->pa_len, __entry->pa_lstart)
 );
 
 TRACE_EVENT(ext4_mb_release_inode_pa,
@@ -444,8 +486,8 @@ TRACE_EVENT(ext4_mb_release_inode_pa,
         ),
 
         TP_printk("dev %s ino %lu block %llu count %u",
-                  jbd2_dev_to_name(__entry->dev), __entry->ino, __entry->block,
-                  __entry->count)
+                  jbd2_dev_to_name(__entry->dev), (unsigned long) __entry->ino,
+                  __entry->block, __entry->count)
 );
 
 TRACE_EVENT(ext4_mb_release_group_pa,
@@ -490,7 +532,7 @@ TRACE_EVENT(ext4_discard_preallocations,
         ),
 
         TP_printk("dev %s ino %lu",
-                  jbd2_dev_to_name(__entry->dev), __entry->ino)
+                  jbd2_dev_to_name(__entry->dev), (unsigned long) __entry->ino)
 );
 
 TRACE_EVENT(ext4_mb_discard_preallocations,
@@ -545,8 +587,8 @@ TRACE_EVENT(ext4_request_blocks,
         ),
 
         TP_printk("dev %s ino %lu flags %u len %u lblk %llu goal %llu lleft %llu lright %llu pleft %llu pright %llu ",
-                  jbd2_dev_to_name(__entry->dev), __entry->ino, __entry->flags,
-                  __entry->len,
+                  jbd2_dev_to_name(__entry->dev), (unsigned long) __entry->ino,
+                  __entry->flags, __entry->len,
                   (unsigned long long) __entry->logical,
                   (unsigned long long) __entry->goal,
                   (unsigned long long) __entry->lleft,
@@ -589,8 +631,8 @@ TRACE_EVENT(ext4_allocate_blocks,
         ),
 
         TP_printk("dev %s ino %lu flags %u len %u block %llu lblk %llu goal %llu lleft %llu lright %llu pleft %llu pright %llu ",
-                  jbd2_dev_to_name(__entry->dev), __entry->ino, __entry->flags,
-                  __entry->len, __entry->block,
+                  jbd2_dev_to_name(__entry->dev), (unsigned long) __entry->ino,
+                  __entry->flags, __entry->len, __entry->block,
                   (unsigned long long) __entry->logical,
                   (unsigned long long) __entry->goal,
                   (unsigned long long) __entry->lleft,
@@ -623,8 +665,8 @@ TRACE_EVENT(ext4_free_blocks,
         ),
 
         TP_printk("dev %s ino %lu block %llu count %lu metadata %d",
-                  jbd2_dev_to_name(__entry->dev), __entry->ino, __entry->block,
-                  __entry->count, __entry->metadata)
+                  jbd2_dev_to_name(__entry->dev), (unsigned long) __entry->ino,
+                  __entry->block, __entry->count, __entry->metadata)
 );
 
 TRACE_EVENT(ext4_sync_file,
@@ -647,8 +689,8 @@ TRACE_EVENT(ext4_sync_file,
         ),
 
         TP_printk("dev %s ino %ld parent %ld datasync %d ",
-                  jbd2_dev_to_name(__entry->dev), __entry->ino, __entry->parent,
-                  __entry->datasync)
+                  jbd2_dev_to_name(__entry->dev), (unsigned long) __entry->ino,
+                  (unsigned long) __entry->parent, __entry->datasync)
 );
 
 TRACE_EVENT(ext4_sync_fs,
@@ -671,6 +713,30 @@ TRACE_EVENT(ext4_sync_fs,
                   __entry->wait)
 );
 
+TRACE_EVENT(ext4_alloc_da_blocks,
+        TP_PROTO(struct inode *inode),
+
+        TP_ARGS(inode),
+
+        TP_STRUCT__entry(
+                __field(        dev_t,  dev                     )
+                __field(        ino_t,  ino                     )
+                __field( unsigned int,  data_blocks     )
+                __field( unsigned int,  meta_blocks     )
+        ),
+
+        TP_fast_assign(
+                __entry->dev    = inode->i_sb->s_dev;
+                __entry->ino    = inode->i_ino;
+                __entry->data_blocks = EXT4_I(inode)->i_reserved_data_blocks;
+                __entry->meta_blocks = EXT4_I(inode)->i_reserved_meta_blocks;
+        ),
+
+        TP_printk("dev %s ino %lu data_blocks %u meta_blocks %u",
+                  jbd2_dev_to_name(__entry->dev), (unsigned long) __entry->ino,
+                  __entry->data_blocks, __entry->meta_blocks)
+);
+
 #endif /* _TRACE_EXT4_H */
 
 /* This part must be outside protection */
diff --git a/include/trace/events/irq.h b/include/trace/events/irq.h
index 1cb0c3aa11e6..b89f9db4a404 100644
--- a/include/trace/events/irq.h
+++ b/include/trace/events/irq.h
@@ -8,16 +8,17 @@
 #include <linux/interrupt.h>
 
 #define softirq_name(sirq) { sirq##_SOFTIRQ, #sirq }
-#define show_softirq_name(val)                  \
-        __print_symbolic(val,                   \
-                         softirq_name(HI),      \
-                         softirq_name(TIMER),   \
-                         softirq_name(NET_TX),  \
-                         softirq_name(NET_RX),  \
-                         softirq_name(BLOCK),   \
-                         softirq_name(TASKLET), \
-                         softirq_name(SCHED),   \
-                         softirq_name(HRTIMER), \
+#define show_softirq_name(val)                          \
+        __print_symbolic(val,                           \
+                         softirq_name(HI),              \
+                         softirq_name(TIMER),           \
+                         softirq_name(NET_TX),          \
+                         softirq_name(NET_RX),          \
+                         softirq_name(BLOCK),           \
+                         softirq_name(BLOCK_IOPOLL),    \
+                         softirq_name(TASKLET),         \
+                         softirq_name(SCHED),           \
+                         softirq_name(HRTIMER),         \
                          softirq_name(RCU))
 
 /**
diff --git a/include/trace/events/jbd2.h b/include/trace/events/jbd2.h
index 10813fa0c8d0..b851f0b4701c 100644
--- a/include/trace/events/jbd2.h
+++ b/include/trace/events/jbd2.h
@@ -159,7 +159,7 @@ TRACE_EVENT(jbd2_submit_inode_data,
         ),
 
         TP_printk("dev %s ino %lu",
-                  jbd2_dev_to_name(__entry->dev), __entry->ino)
+                  jbd2_dev_to_name(__entry->dev), (unsigned long) __entry->ino)
 );
 
 #endif /* _TRACE_JBD2_H */
diff --git a/include/trace/events/kmem.h b/include/trace/events/kmem.h
index 1493c541f9c4..eaf46bdd18a5 100644
--- a/include/trace/events/kmem.h
+++ b/include/trace/events/kmem.h
@@ -225,6 +225,169 @@ TRACE_EVENT(kmem_cache_free,
 
         TP_printk("call_site=%lx ptr=%p", __entry->call_site, __entry->ptr)
 );
+
+TRACE_EVENT(mm_page_free_direct,
+
+        TP_PROTO(struct page *page, unsigned int order),
+
+        TP_ARGS(page, order),
+
+        TP_STRUCT__entry(
+                __field(        struct page *,  page            )
+                __field(        unsigned int,   order           )
+        ),
+
+        TP_fast_assign(
+                __entry->page           = page;
+                __entry->order          = order;
+        ),
+
+        TP_printk("page=%p pfn=%lu order=%d",
+                        __entry->page,
+                        page_to_pfn(__entry->page),
+                        __entry->order)
+);
+
+TRACE_EVENT(mm_pagevec_free,
+
+        TP_PROTO(struct page *page, int cold),
+
+        TP_ARGS(page, cold),
+
+        TP_STRUCT__entry(
+                __field(        struct page *,  page            )
+                __field(        int,            cold            )
+        ),
+
+        TP_fast_assign(
+                __entry->page           = page;
+                __entry->cold           = cold;
+        ),
+
+        TP_printk("page=%p pfn=%lu order=0 cold=%d",
+                        __entry->page,
+                        page_to_pfn(__entry->page),
+                        __entry->cold)
+);
+
+TRACE_EVENT(mm_page_alloc,
+
+        TP_PROTO(struct page *page, unsigned int order,
+                        gfp_t gfp_flags, int migratetype),
+
+        TP_ARGS(page, order, gfp_flags, migratetype),
+
+        TP_STRUCT__entry(
+                __field(        struct page *,  page            )
+                __field(        unsigned int,   order           )
+                __field(        gfp_t,          gfp_flags       )
+                __field(        int,            migratetype     )
+        ),
+
+        TP_fast_assign(
+                __entry->page           = page;
+                __entry->order          = order;
+                __entry->gfp_flags      = gfp_flags;
+                __entry->migratetype    = migratetype;
+        ),
+
+        TP_printk("page=%p pfn=%lu order=%d migratetype=%d gfp_flags=%s",
+                __entry->page,
+                page_to_pfn(__entry->page),
+                __entry->order,
+                __entry->migratetype,
+                show_gfp_flags(__entry->gfp_flags))
+);
+
+TRACE_EVENT(mm_page_alloc_zone_locked,
+
+        TP_PROTO(struct page *page, unsigned int order, int migratetype),
+
+        TP_ARGS(page, order, migratetype),
+
+        TP_STRUCT__entry(
+                __field(        struct page *,  page            )
+                __field(        unsigned int,   order           )
+                __field(        int,            migratetype     )
+        ),
+
+        TP_fast_assign(
+                __entry->page           = page;
+                __entry->order          = order;
+                __entry->migratetype    = migratetype;
+        ),
+
+        TP_printk("page=%p pfn=%lu order=%u migratetype=%d percpu_refill=%d",
+                __entry->page,
+                page_to_pfn(__entry->page),
+                __entry->order,
+                __entry->migratetype,
+                __entry->order == 0)
+);
+
+TRACE_EVENT(mm_page_pcpu_drain,
+
+        TP_PROTO(struct page *page, int order, int migratetype),
+
+        TP_ARGS(page, order, migratetype),
+
+        TP_STRUCT__entry(
+                __field(        struct page *,  page            )
+                __field(        int,            order           )
+                __field(        int,            migratetype     )
+        ),
+
+        TP_fast_assign(
+                __entry->page           = page;
+                __entry->order          = order;
+                __entry->migratetype    = migratetype;
+        ),
+
+        TP_printk("page=%p pfn=%lu order=%d migratetype=%d",
+                __entry->page,
+                page_to_pfn(__entry->page),
+                __entry->order,
+                __entry->migratetype)
+);
+
+TRACE_EVENT(mm_page_alloc_extfrag,
+
+        TP_PROTO(struct page *page,
+                        int alloc_order, int fallback_order,
+                        int alloc_migratetype, int fallback_migratetype),
+
+        TP_ARGS(page,
+                alloc_order, fallback_order,
+                alloc_migratetype, fallback_migratetype),
+
+        TP_STRUCT__entry(
+                __field(        struct page *,  page                    )
+                __field(        int,            alloc_order             )
+                __field(        int,            fallback_order          )
+                __field(        int,            alloc_migratetype       )
+                __field(        int,            fallback_migratetype    )
+        ),
+
+        TP_fast_assign(
+                __entry->page                   = page;
+                __entry->alloc_order            = alloc_order;
+                __entry->fallback_order         = fallback_order;
+                __entry->alloc_migratetype      = alloc_migratetype;
+                __entry->fallback_migratetype   = fallback_migratetype;
+        ),
+
+        TP_printk("page=%p pfn=%lu alloc_order=%d fallback_order=%d pageblock_order=%d alloc_migratetype=%d fallback_migratetype=%d fragmenting=%d change_ownership=%d",
+                __entry->page,
+                page_to_pfn(__entry->page),
+                __entry->alloc_order,
+                __entry->fallback_order,
+                pageblock_order,
+                __entry->alloc_migratetype,
+                __entry->fallback_migratetype,
+                __entry->fallback_order < pageblock_order,
+                __entry->alloc_migratetype == __entry->fallback_migratetype)
+);
+
 #endif /* _TRACE_KMEM_H */
 
 /* This part must be outside protection */
diff --git a/include/trace/events/kvm.h b/include/trace/events/kvm.h
new file mode 100644
index 000000000000..dbe108455275
--- /dev/null
+++ b/include/trace/events/kvm.h
@@ -0,0 +1,151 @@
+#if !defined(_TRACE_KVM_MAIN_H) || defined(TRACE_HEADER_MULTI_READ)
+#define _TRACE_KVM_MAIN_H
+
+#include <linux/tracepoint.h>
+
+#undef TRACE_SYSTEM
+#define TRACE_SYSTEM kvm
+#define TRACE_INCLUDE_FILE kvm
+
+#if defined(__KVM_HAVE_IOAPIC)
+TRACE_EVENT(kvm_set_irq,
+        TP_PROTO(unsigned int gsi, int level, int irq_source_id),
+        TP_ARGS(gsi, level, irq_source_id),
+
+        TP_STRUCT__entry(
+                __field(        unsigned int,   gsi             )
+                __field(        int,            level           )
+                __field(        int,            irq_source_id   )
+        ),
+
+        TP_fast_assign(
+                __entry->gsi            = gsi;
+                __entry->level          = level;
+                __entry->irq_source_id  = irq_source_id;
+        ),
+
+        TP_printk("gsi %u level %d source %d",
+                  __entry->gsi, __entry->level, __entry->irq_source_id)
+);
+
+#define kvm_deliver_mode                \
+        {0x0, "Fixed"},                 \
+        {0x1, "LowPrio"},               \
+        {0x2, "SMI"},                   \
+        {0x3, "Res3"},                  \
+        {0x4, "NMI"},                   \
+        {0x5, "INIT"},                  \
+        {0x6, "SIPI"},                  \
+        {0x7, "ExtINT"}
+
+TRACE_EVENT(kvm_ioapic_set_irq,
+            TP_PROTO(__u64 e, int pin, bool coalesced),
+            TP_ARGS(e, pin, coalesced),
+
+        TP_STRUCT__entry(
+                __field(        __u64,          e               )
+                __field(        int,            pin             )
+                __field(        bool,           coalesced       )
+        ),
+
+        TP_fast_assign(
+                __entry->e              = e;
+                __entry->pin            = pin;
+                __entry->coalesced      = coalesced;
+        ),
+
+        TP_printk("pin %u dst %x vec=%u (%s|%s|%s%s)%s",
+                  __entry->pin, (u8)(__entry->e >> 56), (u8)__entry->e,
+                  __print_symbolic((__entry->e >> 8 & 0x7), kvm_deliver_mode),
+                  (__entry->e & (1<<11)) ? "logical" : "physical",
+                  (__entry->e & (1<<15)) ? "level" : "edge",
+                  (__entry->e & (1<<16)) ? "|masked" : "",
+                  __entry->coalesced ? " (coalesced)" : "")
+);
+
+TRACE_EVENT(kvm_msi_set_irq,
+            TP_PROTO(__u64 address, __u64 data),
+            TP_ARGS(address, data),
+
+        TP_STRUCT__entry(
+                __field(        __u64,          address         )
+                __field(        __u64,          data            )
+        ),
+
+        TP_fast_assign(
+                __entry->address        = address;
+                __entry->data           = data;
+        ),
+
+        TP_printk("dst %u vec %x (%s|%s|%s%s)",
+                  (u8)(__entry->address >> 12), (u8)__entry->data,
+                  __print_symbolic((__entry->data >> 8 & 0x7), kvm_deliver_mode),
+                  (__entry->address & (1<<2)) ? "logical" : "physical",
+                  (__entry->data & (1<<15)) ? "level" : "edge",
+                  (__entry->address & (1<<3)) ? "|rh" : "")
+);
+
+#define kvm_irqchips                                            \
+        {KVM_IRQCHIP_PIC_MASTER,        "PIC master"},          \
+        {KVM_IRQCHIP_PIC_SLAVE,         "PIC slave"},           \
+        {KVM_IRQCHIP_IOAPIC,            "IOAPIC"}
+
+TRACE_EVENT(kvm_ack_irq,
+        TP_PROTO(unsigned int irqchip, unsigned int pin),
+        TP_ARGS(irqchip, pin),
+
+        TP_STRUCT__entry(
+                __field(        unsigned int,   irqchip         )
+                __field(        unsigned int,   pin             )
+        ),
+
+        TP_fast_assign(
+                __entry->irqchip        = irqchip;
+                __entry->pin            = pin;
+        ),
+
+        TP_printk("irqchip %s pin %u",
+                  __print_symbolic(__entry->irqchip, kvm_irqchips),
+                 __entry->pin)
+);
+
+
+
+#endif /* defined(__KVM_HAVE_IOAPIC) */
+
+#define KVM_TRACE_MMIO_READ_UNSATISFIED 0
+#define KVM_TRACE_MMIO_READ 1
+#define KVM_TRACE_MMIO_WRITE 2
+
+#define kvm_trace_symbol_mmio \
+        { KVM_TRACE_MMIO_READ_UNSATISFIED, "unsatisfied-read" }, \
+        { KVM_TRACE_MMIO_READ, "read" }, \
+        { KVM_TRACE_MMIO_WRITE, "write" }
+
+TRACE_EVENT(kvm_mmio,
+        TP_PROTO(int type, int len, u64 gpa, u64 val),
+        TP_ARGS(type, len, gpa, val),
+
+        TP_STRUCT__entry(
+                __field(        u32,    type            )
+                __field(        u32,    len             )
+                __field(        u64,    gpa             )
+                __field(        u64,    val             )
+        ),
+
+        TP_fast_assign(
+                __entry->type           = type;
+                __entry->len            = len;
+                __entry->gpa            = gpa;
+                __entry->val            = val;
+        ),
+
+        TP_printk("mmio %s len %u gpa 0x%llx val 0x%llx",
+                  __print_symbolic(__entry->type, kvm_trace_symbol_mmio),
+                  __entry->len, __entry->gpa, __entry->val)
+);
+
+#endif /* _TRACE_KVM_MAIN_H */
+
+/* This part must be outside protection */
+#include <trace/define_trace.h>
diff --git a/include/trace/events/power.h b/include/trace/events/power.h
new file mode 100644
index 000000000000..ea6d579261ad
--- /dev/null
+++ b/include/trace/events/power.h
@@ -0,0 +1,81 @@
+#undef TRACE_SYSTEM
+#define TRACE_SYSTEM power
+
+#if !defined(_TRACE_POWER_H) || defined(TRACE_HEADER_MULTI_READ)
+#define _TRACE_POWER_H
+
+#include <linux/ktime.h>
+#include <linux/tracepoint.h>
+
+#ifndef _TRACE_POWER_ENUM_
+#define _TRACE_POWER_ENUM_
+enum {
+        POWER_NONE = 0,
+        POWER_CSTATE = 1,
+        POWER_PSTATE = 2,
+};
+#endif
+
+
+
+TRACE_EVENT(power_start,
+
+        TP_PROTO(unsigned int type, unsigned int state),
+
+        TP_ARGS(type, state),
+
+        TP_STRUCT__entry(
+                __field(        u64,            type            )
+                __field(        u64,            state           )
+        ),
+
+        TP_fast_assign(
+                __entry->type = type;
+                __entry->state = state;
+        ),
+
+        TP_printk("type=%lu state=%lu", (unsigned long)__entry->type, (unsigned long)__entry->state)
+);
+
+TRACE_EVENT(power_end,
+
+        TP_PROTO(int dummy),
+
+        TP_ARGS(dummy),
+
+        TP_STRUCT__entry(
+                __field(        u64,            dummy           )
+        ),
+
+        TP_fast_assign(
+                __entry->dummy = 0xffff;
+        ),
+
+        TP_printk("dummy=%lu", (unsigned long)__entry->dummy)
+
+);
+
+
+TRACE_EVENT(power_frequency,
+
+        TP_PROTO(unsigned int type, unsigned int state),
+
+        TP_ARGS(type, state),
+
+        TP_STRUCT__entry(
+                __field(        u64,            type            )
+                __field(        u64,            state           )
+        ),
+
+        TP_fast_assign(
+                __entry->type = type;
+                __entry->state = state;
+        ),
+
+        TP_printk("type=%lu state=%lu", (unsigned long)__entry->type, (unsigned long) __entry->state)
+);
+
+#endif /* _TRACE_POWER_H */
+
+/* This part must be outside protection */
+#include <trace/define_trace.h>
diff --git a/include/trace/events/sched.h b/include/trace/events/sched.h
index a581ef211ff5..4069c43f4187 100644
--- a/include/trace/events/sched.h
+++ b/include/trace/events/sched.h
@@ -344,6 +344,134 @@ TRACE_EVENT(sched_signal_send,
                   __entry->sig, __entry->comm, __entry->pid)
 );
 
+/*
+ * XXX the below sched_stat tracepoints only apply to SCHED_OTHER/BATCH/IDLE
+ *     adding sched_stat support to SCHED_FIFO/RR would be welcome.
+ */
+
+/*
+ * Tracepoint for accounting wait time (time the task is runnable
+ * but not actually running due to scheduler contention).
+ */
+TRACE_EVENT(sched_stat_wait,
+
+        TP_PROTO(struct task_struct *tsk, u64 delay),
+
+        TP_ARGS(tsk, delay),
+
+        TP_STRUCT__entry(
+                __array( char,  comm,   TASK_COMM_LEN   )
+                __field( pid_t, pid                     )
+                __field( u64,   delay                   )
+        ),
+
+        TP_fast_assign(
+                memcpy(__entry->comm, tsk->comm, TASK_COMM_LEN);
+                __entry->pid    = tsk->pid;
+                __entry->delay  = delay;
+        )
+        TP_perf_assign(
+                __perf_count(delay);
+        ),
+
+        TP_printk("task: %s:%d wait: %Lu [ns]",
+                        __entry->comm, __entry->pid,
+                        (unsigned long long)__entry->delay)
+);
+
+/*
+ * Tracepoint for accounting runtime (time the task is executing
+ * on a CPU).
+ */
+TRACE_EVENT(sched_stat_runtime,
+
+        TP_PROTO(struct task_struct *tsk, u64 runtime, u64 vruntime),
+
+        TP_ARGS(tsk, runtime, vruntime),
+
+        TP_STRUCT__entry(
+                __array( char,  comm,   TASK_COMM_LEN   )
+                __field( pid_t, pid                     )
+                __field( u64,   runtime                 )
+                __field( u64,   vruntime                        )
+        ),
+
+        TP_fast_assign(
+                memcpy(__entry->comm, tsk->comm, TASK_COMM_LEN);
+                __entry->pid            = tsk->pid;
+                __entry->runtime        = runtime;
+                __entry->vruntime       = vruntime;
+        )
+        TP_perf_assign(
+                __perf_count(runtime);
+        ),
+
+        TP_printk("task: %s:%d runtime: %Lu [ns], vruntime: %Lu [ns]",
+                        __entry->comm, __entry->pid,
+                        (unsigned long long)__entry->runtime,
+                        (unsigned long long)__entry->vruntime)
+);
+
+/*
+ * Tracepoint for accounting sleep time (time the task is not runnable,
+ * including iowait, see below).
+ */
+TRACE_EVENT(sched_stat_sleep,
+
+        TP_PROTO(struct task_struct *tsk, u64 delay),
+
+        TP_ARGS(tsk, delay),
+
+        TP_STRUCT__entry(
+                __array( char,  comm,   TASK_COMM_LEN   )
+                __field( pid_t, pid                     )
+                __field( u64,   delay                   )
+        ),
+
+        TP_fast_assign(
+                memcpy(__entry->comm, tsk->comm, TASK_COMM_LEN);
+                __entry->pid    = tsk->pid;
+                __entry->delay  = delay;
+        )
+        TP_perf_assign(
+                __perf_count(delay);
+        ),
+
+        TP_printk("task: %s:%d sleep: %Lu [ns]",
+                        __entry->comm, __entry->pid,
+                        (unsigned long long)__entry->delay)
+);
+
+/*
+ * Tracepoint for accounting iowait time (time the task is not runnable
+ * due to waiting on IO to complete).
+ */
+TRACE_EVENT(sched_stat_iowait,
+
+        TP_PROTO(struct task_struct *tsk, u64 delay),
+
+        TP_ARGS(tsk, delay),
+
+        TP_STRUCT__entry(
+                __array( char,  comm,   TASK_COMM_LEN   )
+                __field( pid_t, pid                     )
+                __field( u64,   delay                   )
+        ),
+
+        TP_fast_assign(
+                memcpy(__entry->comm, tsk->comm, TASK_COMM_LEN);
+                __entry->pid    = tsk->pid;
+                __entry->delay  = delay;
+        )
+        TP_perf_assign(
+                __perf_count(delay);
+        ),
+
+        TP_printk("task: %s:%d iowait: %Lu [ns]",
+                        __entry->comm, __entry->pid,
+                        (unsigned long long)__entry->delay)
+);
+
 #endif /* _TRACE_SCHED_H */
 
 /* This part must be outside protection */
diff --git a/include/trace/events/skb.h b/include/trace/events/skb.h
index e499863b9669..4b2be6dc76f0 100644
--- a/include/trace/events/skb.h
+++ b/include/trace/events/skb.h
@@ -5,6 +5,7 @@
 #define _TRACE_SKB_H
 
 #include <linux/skbuff.h>
+#include <linux/netdevice.h>
 #include <linux/tracepoint.h>
 
 /*
@@ -34,6 +35,25 @@ TRACE_EVENT(kfree_skb,
                 __entry->skbaddr, __entry->protocol, __entry->location)
 );
 
+TRACE_EVENT(skb_copy_datagram_iovec,
+
+        TP_PROTO(const struct sk_buff *skb, int len),
+
+        TP_ARGS(skb, len),
+
+        TP_STRUCT__entry(
+                __field(        const void *,           skbaddr         )
+                __field(        int,                    len             )
+        ),
+
+        TP_fast_assign(
+                __entry->skbaddr = skb;
+                __entry->len = len;
+        ),
+
+        TP_printk("skbaddr=%p len=%d", __entry->skbaddr, __entry->len)
+);
+
 #endif /* _TRACE_SKB_H */
 
 /* This part must be outside protection */
diff --git a/include/trace/events/timer.h b/include/trace/events/timer.h
new file mode 100644
index 000000000000..1844c48d640e
--- /dev/null
+++ b/include/trace/events/timer.h
@@ -0,0 +1,342 @@
+#undef TRACE_SYSTEM
+#define TRACE_SYSTEM timer
+
+#if !defined(_TRACE_TIMER_H) || defined(TRACE_HEADER_MULTI_READ)
+#define _TRACE_TIMER_H
+
+#include <linux/tracepoint.h>
+#include <linux/hrtimer.h>
+#include <linux/timer.h>
+
+/**
+ * timer_init - called when the timer is initialized
+ * @timer:      pointer to struct timer_list
+ */
+TRACE_EVENT(timer_init,
+
+        TP_PROTO(struct timer_list *timer),
+
+        TP_ARGS(timer),
+
+        TP_STRUCT__entry(
+                __field( void *,        timer   )
+        ),
+
+        TP_fast_assign(
+                __entry->timer  = timer;
+        ),
+
+        TP_printk("timer %p", __entry->timer)
+);
+
+/**
+ * timer_start - called when the timer is started
+ * @timer:      pointer to struct timer_list
+ * @expires:    the timers expiry time
+ */
+TRACE_EVENT(timer_start,
+
+        TP_PROTO(struct timer_list *timer, unsigned long expires),
+
+        TP_ARGS(timer, expires),
+
+        TP_STRUCT__entry(
+                __field( void *,        timer           )
+                __field( void *,        function        )
+                __field( unsigned long, expires         )
+                __field( unsigned long, now             )
+        ),
+
+        TP_fast_assign(
+                __entry->timer          = timer;
+                __entry->function       = timer->function;
+                __entry->expires        = expires;
+                __entry->now            = jiffies;
+        ),
+
+        TP_printk("timer %p: func %pf, expires %lu, timeout %ld",
+                  __entry->timer, __entry->function, __entry->expires,
+                  (long)__entry->expires - __entry->now)
+);
+
+/**
+ * timer_expire_entry - called immediately before the timer callback
+ * @timer:      pointer to struct timer_list
+ *
+ * Allows to determine the timer latency.
+ */
+TRACE_EVENT(timer_expire_entry,
+
+        TP_PROTO(struct timer_list *timer),
+
+        TP_ARGS(timer),
+
+        TP_STRUCT__entry(
+                __field( void *,        timer   )
+                __field( unsigned long, now     )
+        ),
+
+        TP_fast_assign(
+                __entry->timer          = timer;
+                __entry->now            = jiffies;
+        ),
+
+        TP_printk("timer %p: now %lu", __entry->timer, __entry->now)
+);
+
+/**
+ * timer_expire_exit - called immediately after the timer callback returns
+ * @timer:      pointer to struct timer_list
+ *
+ * When used in combination with the timer_expire_entry tracepoint we can
+ * determine the runtime of the timer callback function.
+ *
+ * NOTE: Do NOT derefernce timer in TP_fast_assign. The pointer might
+ * be invalid. We solely track the pointer.
+ */
+TRACE_EVENT(timer_expire_exit,
+
+        TP_PROTO(struct timer_list *timer),
+
+        TP_ARGS(timer),
+
+        TP_STRUCT__entry(
+                __field(void *, timer   )
+        ),
+
+        TP_fast_assign(
+                __entry->timer  = timer;
+        ),
+
+        TP_printk("timer %p", __entry->timer)
+);
+
+/**
+ * timer_cancel - called when the timer is canceled
+ * @timer:      pointer to struct timer_list
+ */
+TRACE_EVENT(timer_cancel,
+
+        TP_PROTO(struct timer_list *timer),
+
+        TP_ARGS(timer),
+
+        TP_STRUCT__entry(
+                __field( void *,        timer   )
+        ),
+
+        TP_fast_assign(
+                __entry->timer  = timer;
+        ),
+
+        TP_printk("timer %p", __entry->timer)
+);
+
+/**
+ * hrtimer_init - called when the hrtimer is initialized
+ * @timer:      pointer to struct hrtimer
+ * @clockid:    the hrtimers clock
+ * @mode:       the hrtimers mode
+ */
+TRACE_EVENT(hrtimer_init,
+
+        TP_PROTO(struct hrtimer *timer, clockid_t clockid,
+                 enum hrtimer_mode mode),
+
+        TP_ARGS(timer, clockid, mode),
+
+        TP_STRUCT__entry(
+                __field( void *,                timer           )
+                __field( clockid_t,             clockid         )
+                __field( enum hrtimer_mode,     mode            )
+        ),
+
+        TP_fast_assign(
+                __entry->timer          = timer;
+                __entry->clockid        = clockid;
+                __entry->mode           = mode;
+        ),
+
+        TP_printk("hrtimer %p, clockid %s, mode %s", __entry->timer,
+                  __entry->clockid == CLOCK_REALTIME ?
+                        "CLOCK_REALTIME" : "CLOCK_MONOTONIC",
+                  __entry->mode == HRTIMER_MODE_ABS ?
+                        "HRTIMER_MODE_ABS" : "HRTIMER_MODE_REL")
+);
+
+/**
+ * hrtimer_start - called when the hrtimer is started
+ * @timer: pointer to struct hrtimer
+ */
+TRACE_EVENT(hrtimer_start,
+
+        TP_PROTO(struct hrtimer *timer),
+
+        TP_ARGS(timer),
+
+        TP_STRUCT__entry(
+                __field( void *,        timer           )
+                __field( void *,        function        )
+                __field( s64,           expires         )
+                __field( s64,           softexpires     )
+        ),
+
+        TP_fast_assign(
+                __entry->timer          = timer;
+                __entry->function       = timer->function;
+                __entry->expires        = hrtimer_get_expires(timer).tv64;
+                __entry->softexpires    = hrtimer_get_softexpires(timer).tv64;
+        ),
+
+        TP_printk("hrtimer %p, func %pf, expires %llu, softexpires %llu",
+                  __entry->timer, __entry->function,
+                  (unsigned long long)ktime_to_ns((ktime_t) {
+                                  .tv64 = __entry->expires }),
+                  (unsigned long long)ktime_to_ns((ktime_t) {
+                                  .tv64 = __entry->softexpires }))
+);
+
+/**
+ * htimmer_expire_entry - called immediately before the hrtimer callback
+ * @timer:      pointer to struct hrtimer
+ * @now:        pointer to variable which contains current time of the
+ *              timers base.
+ *
+ * Allows to determine the timer latency.
+ */
+TRACE_EVENT(hrtimer_expire_entry,
+
+        TP_PROTO(struct hrtimer *timer, ktime_t *now),
+
+        TP_ARGS(timer, now),
+
+        TP_STRUCT__entry(
+                __field( void *,        timer   )
+                __field( s64,           now     )
+        ),
+
+        TP_fast_assign(
+                __entry->timer  = timer;
+                __entry->now    = now->tv64;
+        ),
+
+        TP_printk("hrtimer %p, now %llu", __entry->timer,
+                  (unsigned long long)ktime_to_ns((ktime_t) {
+                                  .tv64 = __entry->now }))
+ );
+
+/**
+ * hrtimer_expire_exit - called immediately after the hrtimer callback returns
+ * @timer:      pointer to struct hrtimer
+ *
+ * When used in combination with the hrtimer_expire_entry tracepoint we can
+ * determine the runtime of the callback function.
+ */
+TRACE_EVENT(hrtimer_expire_exit,
+
+        TP_PROTO(struct hrtimer *timer),
+
+        TP_ARGS(timer),
+
+        TP_STRUCT__entry(
+                __field( void *,        timer   )
+        ),
+
+        TP_fast_assign(
+                __entry->timer  = timer;
+        ),
+
+        TP_printk("hrtimer %p", __entry->timer)
+);
+
+/**
+ * hrtimer_cancel - called when the hrtimer is canceled
+ * @timer:      pointer to struct hrtimer
+ */
+TRACE_EVENT(hrtimer_cancel,
+
+        TP_PROTO(struct hrtimer *timer),
+
+        TP_ARGS(timer),
+
+        TP_STRUCT__entry(
+                __field( void *,        timer   )
+        ),
+
+        TP_fast_assign(
+                __entry->timer  = timer;
+        ),
+
+        TP_printk("hrtimer %p", __entry->timer)
+);
+
+/**
+ * itimer_state - called when itimer is started or canceled
+ * @which:      name of the interval timer
+ * @value:      the itimers value, itimer is canceled if value->it_value is
+ *              zero, otherwise it is started
+ * @expires:    the itimers expiry time
+ */
+TRACE_EVENT(itimer_state,
+
+        TP_PROTO(int which, const struct itimerval *const value,
+                 cputime_t expires),
+
+        TP_ARGS(which, value, expires),
+
+        TP_STRUCT__entry(
+                __field(        int,            which           )
+                __field(        cputime_t,      expires         )
+                __field(        long,           value_sec       )
+                __field(        long,           value_usec      )
+                __field(        long,           interval_sec    )
+                __field(        long,           interval_usec   )
+        ),
+
+        TP_fast_assign(
+                __entry->which          = which;
+                __entry->expires        = expires;
+                __entry->value_sec      = value->it_value.tv_sec;
+                __entry->value_usec     = value->it_value.tv_usec;
+                __entry->interval_sec   = value->it_interval.tv_sec;
+                __entry->interval_usec  = value->it_interval.tv_usec;
+        ),
+
+        TP_printk("which %d, expires %lu, it_value %lu.%lu, it_interval %lu.%lu",
+                  __entry->which, __entry->expires,
+                  __entry->value_sec, __entry->value_usec,
+                  __entry->interval_sec, __entry->interval_usec)
+);
+
+/**
+ * itimer_expire - called when itimer expires
+ * @which:      type of the interval timer
+ * @pid:        pid of the process which owns the timer
+ * @now:        current time, used to calculate the latency of itimer
+ */
+TRACE_EVENT(itimer_expire,
+
+        TP_PROTO(int which, struct pid *pid, cputime_t now),
+
+        TP_ARGS(which, pid, now),
+
+        TP_STRUCT__entry(
+                __field( int ,          which   )
+                __field( pid_t,         pid     )
+                __field( cputime_t,     now     )
+        ),
+
+        TP_fast_assign(
+                __entry->which  = which;
+                __entry->now    = now;
+                __entry->pid    = pid_nr(pid);
+        ),
+
+            TP_printk("which %d, pid %d, now %lu", __entry->which,
+                      (int) __entry->pid, __entry->now)
+);
+
+#endif /*  _TRACE_TIMER_H */
+
+/* This part must be outside protection */
+#include <trace/define_trace.h>
diff --git a/include/trace/ftrace.h b/include/trace/ftrace.h
index 5d3df2a5049d..54d02c06ae7e 100644
--- a/include/trace/ftrace.h
+++ b/include/trace/ftrace.h
@@ -239,9 +239,9 @@ ftrace_format_##call(struct ftrace_event_call *unused,			\
 #undef __print_flags
 #define __print_flags(flag, delim, flag_array...)                       \
         ({                                                              \
-                static const struct trace_print_flags flags[] =         \
+                static const struct trace_print_flags __flags[] =       \
                         { flag_array, { -1, NULL }};                    \
-                ftrace_print_flags_seq(p, delim, flag, flags);          \
+                ftrace_print_flags_seq(p, delim, flag, __flags);        \
         })
 
 #undef __print_symbolic
@@ -254,7 +254,7 @@ ftrace_format_##call(struct ftrace_event_call *unused,			\
 
 #undef TRACE_EVENT
 #define TRACE_EVENT(call, proto, args, tstruct, assign, print)          \
-enum print_line_t                                                       \
+static enum print_line_t                                                \
 ftrace_raw_output_##call(struct trace_iterator *iter, int flags)        \
 {                                                                       \
         struct trace_seq *s = &iter->seq;                               \
@@ -317,7 +317,7 @@ ftrace_raw_output_##call(struct trace_iterator *iter, int flags)	\
 
 #undef TRACE_EVENT
 #define TRACE_EVENT(call, proto, args, tstruct, func, print)            \
-int                                                                     \
+static int                                                              \
 ftrace_define_fields_##call(struct ftrace_event_call *event_call)       \
 {                                                                       \
         struct ftrace_raw_##call field;                                 \
@@ -378,24 +378,18 @@ static inline int ftrace_get_offsets_##call(				\
 #ifdef CONFIG_EVENT_PROFILE
 
 /*
- * Generate the functions needed for tracepoint perf_counter support.
+ * Generate the functions needed for tracepoint perf_event support.
  *
  * NOTE: The insertion profile callback (ftrace_profile_<call>) is defined later
  *
- * static int ftrace_profile_enable_<call>(struct ftrace_event_call *event_call)
+ * static int ftrace_profile_enable_<call>(void)
  * {
- *      int ret = 0;
- *
- *      if (!atomic_inc_return(&event_call->profile_count))
- *              ret = register_trace_<call>(ftrace_profile_<call>);
- *
- *      return ret;
+ *      return register_trace_<call>(ftrace_profile_<call>);
  * }
  *
- * static void ftrace_profile_disable_<call>(struct ftrace_event_call *event_call)
+ * static void ftrace_profile_disable_<call>(void)
  * {
- *      if (atomic_add_negative(-1, &event->call->profile_count))
- *              unregister_trace_<call>(ftrace_profile_<call>);
+ *      unregister_trace_<call>(ftrace_profile_<call>);
  * }
  *
  */
@@ -405,20 +399,14 @@ static inline int ftrace_get_offsets_##call(				\
                                                                         \
 static void ftrace_profile_##call(proto);                               \
                                                                         \
-static int ftrace_profile_enable_##call(struct ftrace_event_call *event_call) \
+static int ftrace_profile_enable_##call(struct ftrace_event_call *unused)\
 {                                                                       \
-        int ret = 0;                                                    \
-                                                                        \
-        if (!atomic_inc_return(&event_call->profile_count))             \
-                ret = register_trace_##call(ftrace_profile_##call);     \
-                                                                        \
-        return ret;                                                     \
+        return register_trace_##call(ftrace_profile_##call);            \
 }                                                                       \
                                                                         \
-static void ftrace_profile_disable_##call(struct ftrace_event_call *event_call)\
+static void ftrace_profile_disable_##call(struct ftrace_event_call *unused)\
 {                                                                       \
-        if (atomic_add_negative(-1, &event_call->profile_count))        \
-                unregister_trace_##call(ftrace_profile_##call);         \
+        unregister_trace_##call(ftrace_profile_##call);                 \
 }
 
 #include TRACE_INCLUDE(TRACE_INCLUDE_FILE)
@@ -656,15 +644,16 @@ __attribute__((section("_ftrace_events"))) event_##call = {		\
  * {
  *      struct ftrace_data_offsets_<call> __maybe_unused __data_offsets;
  *      struct ftrace_event_call *event_call = &event_<call>;
- *      extern void perf_tpcounter_event(int, u64, u64, void *, int);
+ *      extern void perf_tp_event(int, u64, u64, void *, int);
  *      struct ftrace_raw_##call *entry;
  *      u64 __addr = 0, __count = 1;
  *      unsigned long irq_flags;
+ *      struct trace_entry *ent;
  *      int __entry_size;
  *      int __data_size;
+ *      int __cpu
  *      int pc;
  *
- *      local_save_flags(irq_flags);
  *      pc = preempt_count();
  *
  *      __data_size = ftrace_get_offsets_<call>(&__data_offsets, args);
@@ -675,25 +664,34 @@ __attribute__((section("_ftrace_events"))) event_##call = {		\
  *                           sizeof(u64));
  *      __entry_size -= sizeof(u32);
  *
- *      do {
- *              char raw_data[__entry_size]; <- allocate our sample in the stack
- *              struct trace_entry *ent;
+ *      // Protect the non nmi buffer
+ *      // This also protects the rcu read side
+ *      local_irq_save(irq_flags);
+ *      __cpu = smp_processor_id();
+ *
+ *      if (in_nmi())
+ *              raw_data = rcu_dereference(trace_profile_buf_nmi);
+ *      else
+ *              raw_data = rcu_dereference(trace_profile_buf);
+ *
+ *      if (!raw_data)
+ *              goto end;
  *
- *              zero dead bytes from alignment to avoid stack leak to userspace:
+ *      raw_data = per_cpu_ptr(raw_data, __cpu);
  *
- *              *(u64 *)(&raw_data[__entry_size - sizeof(u64)]) = 0ULL;
- *              entry = (struct ftrace_raw_<call> *)raw_data;
- *              ent = &entry->ent;
- *              tracing_generic_entry_update(ent, irq_flags, pc);
- *              ent->type = event_call->id;
+ *      //zero dead bytes from alignment to avoid stack leak to userspace:
+ *      *(u64 *)(&raw_data[__entry_size - sizeof(u64)]) = 0ULL;
+ *      entry = (struct ftrace_raw_<call> *)raw_data;
+ *      ent = &entry->ent;
+ *      tracing_generic_entry_update(ent, irq_flags, pc);
+ *      ent->type = event_call->id;
  *
- *              <tstruct> <- do some jobs with dynamic arrays
+ *      <tstruct> <- do some jobs with dynamic arrays
  *
- *              <assign>  <- affect our values
+ *      <assign>  <- affect our values
  *
- *              perf_tpcounter_event(event_call->id, __addr, __count, entry,
- *                           __entry_size);  <- submit them to perf counter
- *      } while (0);
+ *      perf_tp_event(event_call->id, __addr, __count, entry,
+ *                   __entry_size);  <- submit them to perf counter
  *
  * }
  */
@@ -712,15 +710,17 @@ static void ftrace_profile_##call(proto)				\
 {                                                                       \
         struct ftrace_data_offsets_##call __maybe_unused __data_offsets;\
         struct ftrace_event_call *event_call = &event_##call;           \
-        extern void perf_tpcounter_event(int, u64, u64, void *, int);   \
+        extern void perf_tp_event(int, u64, u64, void *, int);  \
         struct ftrace_raw_##call *entry;                                \
         u64 __addr = 0, __count = 1;                                    \
         unsigned long irq_flags;                                        \
+        struct trace_entry *ent;                                        \
         int __entry_size;                                               \
         int __data_size;                                                \
+        char *raw_data;                                                 \
+        int __cpu;                                                      \
         int pc;                                                         \
                                                                         \
-        local_save_flags(irq_flags);                                    \
         pc = preempt_count();                                           \
                                                                         \
         __data_size = ftrace_get_offsets_##call(&__data_offsets, args); \
@@ -728,23 +728,38 @@ static void ftrace_profile_##call(proto)				\
                              sizeof(u64));                              \
         __entry_size -= sizeof(u32);                                    \
                                                                         \
-        do {                                                            \
-                char raw_data[__entry_size];                            \
-                struct trace_entry *ent;                                \
+        if (WARN_ONCE(__entry_size > FTRACE_MAX_PROFILE_SIZE,           \
+                      "profile buffer not large enough"))               \
+                return;                                                 \
+                                                                        \
+        local_irq_save(irq_flags);                                      \
+        __cpu = smp_processor_id();                                     \
                                                                         \
-                *(u64 *)(&raw_data[__entry_size - sizeof(u64)]) = 0ULL; \
-                entry = (struct ftrace_raw_##call *)raw_data;           \
-                ent = &entry->ent;                                      \
-                tracing_generic_entry_update(ent, irq_flags, pc);       \
-                ent->type = event_call->id;                             \
+        if (in_nmi())                                                   \
+                raw_data = rcu_dereference(trace_profile_buf_nmi);              \
+        else                                                            \
+                raw_data = rcu_dereference(trace_profile_buf);          \
                                                                         \
-                tstruct                                                 \
+        if (!raw_data)                                                  \
+                goto end;                                               \
                                                                         \
-                { assign; }                                             \
+        raw_data = per_cpu_ptr(raw_data, __cpu);                        \
                                                                         \
-                perf_tpcounter_event(event_call->id, __addr, __count, entry,\
+        *(u64 *)(&raw_data[__entry_size - sizeof(u64)]) = 0ULL;         \
+        entry = (struct ftrace_raw_##call *)raw_data;                   \
+        ent = &entry->ent;                                              \
+        tracing_generic_entry_update(ent, irq_flags, pc);               \
+        ent->type = event_call->id;                                     \
+                                                                        \
+        tstruct                                                         \
+                                                                        \
+        { assign; }                                                     \
+                                                                        \
+        perf_tp_event(event_call->id, __addr, __count, entry,           \
                              __entry_size);                             \
-        } while (0);                                                    \
+                                                                        \
+end:                                                                    \
+        local_irq_restore(irq_flags);                                   \
                                                                         \
 }