6 files changed, 449 insertions, 89 deletions

diff --git a/include/trace/events/ext4.h b/include/trace/events/ext4.h
index 8d433c4e3709..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,
@@ -243,14 +251,49 @@ TRACE_EVENT(ext4_da_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 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->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,
         TP_PROTO(struct inode *inode, struct writeback_control *wbc,
                         int ret, int pages_written),
@@ -280,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)
@@ -309,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,
@@ -336,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,
@@ -387,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,
@@ -415,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,
@@ -442,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,
@@ -488,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,
@@ -543,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,
@@ -587,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,
@@ -621,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,
@@ -645,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,
@@ -669,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/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/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 b48f1ad7c946..4069c43f4187 100644
--- a/include/trace/events/sched.h
+++ b/include/trace/events/sched.h
@@ -380,6 +380,39 @@ TRACE_EVENT(sched_stat_wait,
 );
 
 /*
+ * 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).
  */
diff --git a/include/trace/ftrace.h b/include/trace/ftrace.h
index 72a3b437b829..cc0d9667e182 100644
--- a/include/trace/ftrace.h
+++ b/include/trace/ftrace.h
@@ -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(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);                 \
 }
 
 #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);                                   \
                                                                         \
 }