Merge branch 'master' of git://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux-2.6

Conflicts:
	drivers/mtd/mtdcore.c

Merged in order that I can apply the Nomadik nand/onenand support patches.

12 files changed, 702 insertions, 101 deletions

diff --git a/include/trace/define_trace.h b/include/trace/define_trace.h
index f7a7ae1e8f90..2a4b3bf74033 100644
--- a/include/trace/define_trace.h
+++ b/include/trace/define_trace.h
@@ -26,6 +26,11 @@
 #define TRACE_EVENT(name, proto, args, tstruct, assign, print)  \
         DEFINE_TRACE(name)
 
+#undef TRACE_EVENT_FN
+#define TRACE_EVENT_FN(name, proto, args, tstruct,              \
+                assign, print, reg, unreg)                      \
+        DEFINE_TRACE_FN(name, reg, unreg)
+
 #undef DECLARE_TRACE
 #define DECLARE_TRACE(name, proto, args)        \
         DEFINE_TRACE(name)
@@ -56,6 +61,8 @@
 #include <trace/ftrace.h>
 #endif
 
+#undef TRACE_EVENT
+#undef TRACE_EVENT_FN
 #undef TRACE_HEADER_MULTI_READ
 
 /* Only undef what we defined in this file */
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/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/module.h b/include/trace/events/module.h
new file mode 100644
index 000000000000..84160fb18478
--- /dev/null
+++ b/include/trace/events/module.h
@@ -0,0 +1,126 @@
+#undef TRACE_SYSTEM
+#define TRACE_SYSTEM module
+
+#if !defined(_TRACE_MODULE_H) || defined(TRACE_HEADER_MULTI_READ)
+#define _TRACE_MODULE_H
+
+#include <linux/tracepoint.h>
+
+#ifdef CONFIG_MODULES
+
+struct module;
+
+#define show_module_flags(flags) __print_flags(flags, "",       \
+        { (1UL << TAINT_PROPRIETARY_MODULE),    "P" },          \
+        { (1UL << TAINT_FORCED_MODULE),         "F" },          \
+        { (1UL << TAINT_CRAP),                  "C" })
+
+TRACE_EVENT(module_load,
+
+        TP_PROTO(struct module *mod),
+
+        TP_ARGS(mod),
+
+        TP_STRUCT__entry(
+                __field(        unsigned int,   taints          )
+                __string(       name,           mod->name       )
+        ),
+
+        TP_fast_assign(
+                __entry->taints = mod->taints;
+                __assign_str(name, mod->name);
+        ),
+
+        TP_printk("%s %s", __get_str(name), show_module_flags(__entry->taints))
+);
+
+TRACE_EVENT(module_free,
+
+        TP_PROTO(struct module *mod),
+
+        TP_ARGS(mod),
+
+        TP_STRUCT__entry(
+                __string(       name,           mod->name       )
+        ),
+
+        TP_fast_assign(
+                __assign_str(name, mod->name);
+        ),
+
+        TP_printk("%s", __get_str(name))
+);
+
+TRACE_EVENT(module_get,
+
+        TP_PROTO(struct module *mod, unsigned long ip, int refcnt),
+
+        TP_ARGS(mod, ip, refcnt),
+
+        TP_STRUCT__entry(
+                __field(        unsigned long,  ip              )
+                __field(        int,            refcnt          )
+                __string(       name,           mod->name       )
+        ),
+
+        TP_fast_assign(
+                __entry->ip     = ip;
+                __entry->refcnt = refcnt;
+                __assign_str(name, mod->name);
+        ),
+
+        TP_printk("%s call_site=%pf refcnt=%d",
+                  __get_str(name), (void *)__entry->ip, __entry->refcnt)
+);
+
+TRACE_EVENT(module_put,
+
+        TP_PROTO(struct module *mod, unsigned long ip, int refcnt),
+
+        TP_ARGS(mod, ip, refcnt),
+
+        TP_STRUCT__entry(
+                __field(        unsigned long,  ip              )
+                __field(        int,            refcnt          )
+                __string(       name,           mod->name       )
+        ),
+
+        TP_fast_assign(
+                __entry->ip     = ip;
+                __entry->refcnt = refcnt;
+                __assign_str(name, mod->name);
+        ),
+
+        TP_printk("%s call_site=%pf refcnt=%d",
+                  __get_str(name), (void *)__entry->ip, __entry->refcnt)
+);
+
+TRACE_EVENT(module_request,
+
+        TP_PROTO(char *name, bool wait, unsigned long ip),
+
+        TP_ARGS(name, wait, ip),
+
+        TP_STRUCT__entry(
+                __field(        bool,           wait            )
+                __field(        unsigned long,  ip              )
+                __string(       name,           name            )
+        ),
+
+        TP_fast_assign(
+                __entry->wait   = wait;
+                __entry->ip     = ip;
+                __assign_str(name, name);
+        ),
+
+        TP_printk("%s wait=%d call_site=%pf",
+                  __get_str(name), (int)__entry->wait, (void *)__entry->ip)
+);
+
+#endif /* CONFIG_MODULES */
+
+#endif /* _TRACE_MODULE_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 8949bb7eb082..b48f1ad7c946 100644
--- a/include/trace/events/sched.h
+++ b/include/trace/events/sched.h
@@ -94,6 +94,7 @@ TRACE_EVENT(sched_wakeup,
                 __field(        pid_t,  pid                     )
                 __field(        int,    prio                    )
                 __field(        int,    success                 )
+                __field(        int,    cpu                     )
         ),
 
         TP_fast_assign(
@@ -101,11 +102,12 @@ TRACE_EVENT(sched_wakeup,
                 __entry->pid            = p->pid;
                 __entry->prio           = p->prio;
                 __entry->success        = success;
+                __entry->cpu            = task_cpu(p);
         ),
 
-        TP_printk("task %s:%d [%d] success=%d",
+        TP_printk("task %s:%d [%d] success=%d [%03d]",
                   __entry->comm, __entry->pid, __entry->prio,
-                  __entry->success)
+                  __entry->success, __entry->cpu)
 );
 
 /*
@@ -125,6 +127,7 @@ TRACE_EVENT(sched_wakeup_new,
                 __field(        pid_t,  pid                     )
                 __field(        int,    prio                    )
                 __field(        int,    success                 )
+                __field(        int,    cpu                     )
         ),
 
         TP_fast_assign(
@@ -132,11 +135,12 @@ TRACE_EVENT(sched_wakeup_new,
                 __entry->pid            = p->pid;
                 __entry->prio           = p->prio;
                 __entry->success        = success;
+                __entry->cpu            = task_cpu(p);
         ),
 
-        TP_printk("task %s:%d [%d] success=%d",
+        TP_printk("task %s:%d [%d] success=%d [%03d]",
                   __entry->comm, __entry->pid, __entry->prio,
-                  __entry->success)
+                  __entry->success, __entry->cpu)
 );
 
 /*
@@ -340,6 +344,101 @@ 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 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/syscalls.h b/include/trace/events/syscalls.h
new file mode 100644
index 000000000000..397dff2dbd5a
--- /dev/null
+++ b/include/trace/events/syscalls.h
@@ -0,0 +1,70 @@
+#undef TRACE_SYSTEM
+#define TRACE_SYSTEM syscalls
+
+#if !defined(_TRACE_EVENTS_SYSCALLS_H) || defined(TRACE_HEADER_MULTI_READ)
+#define _TRACE_EVENTS_SYSCALLS_H
+
+#include <linux/tracepoint.h>
+
+#include <asm/ptrace.h>
+#include <asm/syscall.h>
+
+
+#ifdef CONFIG_HAVE_SYSCALL_TRACEPOINTS
+
+extern void syscall_regfunc(void);
+extern void syscall_unregfunc(void);
+
+TRACE_EVENT_FN(sys_enter,
+
+        TP_PROTO(struct pt_regs *regs, long id),
+
+        TP_ARGS(regs, id),
+
+        TP_STRUCT__entry(
+                __field(        long,           id              )
+                __array(        unsigned long,  args,   6       )
+        ),
+
+        TP_fast_assign(
+                __entry->id     = id;
+                syscall_get_arguments(current, regs, 0, 6, __entry->args);
+        ),
+
+        TP_printk("NR %ld (%lx, %lx, %lx, %lx, %lx, %lx)",
+                  __entry->id,
+                  __entry->args[0], __entry->args[1], __entry->args[2],
+                  __entry->args[3], __entry->args[4], __entry->args[5]),
+
+        syscall_regfunc, syscall_unregfunc
+);
+
+TRACE_EVENT_FN(sys_exit,
+
+        TP_PROTO(struct pt_regs *regs, long ret),
+
+        TP_ARGS(regs, ret),
+
+        TP_STRUCT__entry(
+                __field(        long,   id      )
+                __field(        long,   ret     )
+        ),
+
+        TP_fast_assign(
+                __entry->id     = syscall_get_nr(current, regs);
+                __entry->ret    = ret;
+        ),
+
+        TP_printk("NR %ld = %ld",
+                  __entry->id, __entry->ret),
+
+        syscall_regfunc, syscall_unregfunc
+);
+
+#endif /* CONFIG_HAVE_SYSCALL_TRACEPOINTS */
+
+#endif /* _TRACE_EVENTS_SYSCALLS_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 f64fbaae781a..72a3b437b829 100644
--- a/include/trace/ftrace.h
+++ b/include/trace/ftrace.h
@@ -21,11 +21,14 @@
 #undef __field
 #define __field(type, item)             type    item;
 
+#undef __field_ext
+#define __field_ext(type, item, filter_type)    type    item;
+
 #undef __array
 #define __array(type, item, len)        type    item[len];
 
 #undef __dynamic_array
-#define __dynamic_array(type, item, len) unsigned short __data_loc_##item;
+#define __dynamic_array(type, item, len) u32 __data_loc_##item;
 
 #undef __string
 #define __string(item, src) __dynamic_array(char, item, -1)
@@ -42,6 +45,16 @@
         };                                                      \
         static struct ftrace_event_call event_##name
 
+#undef __cpparg
+#define __cpparg(arg...) arg
+
+/* Callbacks are meaningless to ftrace. */
+#undef TRACE_EVENT_FN
+#define TRACE_EVENT_FN(name, proto, args, tstruct,                      \
+                assign, print, reg, unreg)                              \
+        TRACE_EVENT(name, __cpparg(proto), __cpparg(args),              \
+                __cpparg(tstruct), __cpparg(assign), __cpparg(print))   \
+
 #include TRACE_INCLUDE(TRACE_INCLUDE_FILE)
 
 
@@ -51,23 +64,27 @@
  * Include the following:
  *
  * struct ftrace_data_offsets_<call> {
- *      int                             <item1>;
- *      int                             <item2>;
+ *      u32                             <item1>;
+ *      u32                             <item2>;
  *      [...]
  * };
  *
- * The __dynamic_array() macro will create each int <item>, this is
+ * The __dynamic_array() macro will create each u32 <item>, this is
  * to keep the offset of each array from the beginning of the event.
+ * The size of an array is also encoded, in the higher 16 bits of <item>.
  */
 
 #undef __field
-#define __field(type, item);
+#define __field(type, item)
+
+#undef __field_ext
+#define __field_ext(type, item, filter_type)
 
 #undef __array
 #define __array(type, item, len)
 
 #undef __dynamic_array
-#define __dynamic_array(type, item, len)        int item;
+#define __dynamic_array(type, item, len)        u32 item;
 
 #undef __string
 #define __string(item, src) __dynamic_array(char, item, -1)
@@ -109,6 +126,9 @@
         if (!ret)                                                       \
                 return 0;
 
+#undef __field_ext
+#define __field_ext(type, item, filter_type)    __field(type, item)
+
 #undef __array
 #define __array(type, item, len)                                                \
         ret = trace_seq_printf(s, "\tfield:" #type " " #item "[" #len "];\t"    \
@@ -120,7 +140,7 @@
 
 #undef __dynamic_array
 #define __dynamic_array(type, item, len)                                       \
-        ret = trace_seq_printf(s, "\tfield:__data_loc " #item ";\t"            \
+        ret = trace_seq_printf(s, "\tfield:__data_loc " #type "[] " #item ";\t"\
                                "offset:%u;\tsize:%u;\n",                       \
                                (unsigned int)offsetof(typeof(field),           \
                                         __data_loc_##item),                    \
@@ -150,7 +170,8 @@
 #undef TRACE_EVENT
 #define TRACE_EVENT(call, proto, args, tstruct, func, print)            \
 static int                                                              \
-ftrace_format_##call(struct trace_seq *s)                               \
+ftrace_format_##call(struct ftrace_event_call *unused,                  \
+                      struct trace_seq *s)                              \
 {                                                                       \
         struct ftrace_raw_##call field __attribute__((unused));         \
         int ret = 0;                                                    \
@@ -210,7 +231,7 @@ ftrace_format_##call(struct trace_seq *s)				\
 
 #undef __get_dynamic_array
 #define __get_dynamic_array(field)      \
-                ((void *)__entry + __entry->__data_loc_##field)
+                ((void *)__entry + (__entry->__data_loc_##field & 0xffff))
 
 #undef __get_str
 #define __get_str(field) (char *)__get_dynamic_array(field)
@@ -218,9 +239,9 @@ ftrace_format_##call(struct trace_seq *s)				\
 #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
@@ -233,7 +254,7 @@ ftrace_format_##call(struct trace_seq *s)				\
 
 #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;                               \
@@ -263,46 +284,48 @@ ftrace_raw_output_##call(struct trace_iterator *iter, int flags)	\
         
 #include TRACE_INCLUDE(TRACE_INCLUDE_FILE)
 
-#undef __field
-#define __field(type, item)                                             \
+#undef __field_ext
+#define __field_ext(type, item, filter_type)                            \
         ret = trace_define_field(event_call, #type, #item,              \
                                  offsetof(typeof(field), item),         \
-                                 sizeof(field.item), is_signed_type(type));     \
+                                 sizeof(field.item),                    \
+                                 is_signed_type(type), filter_type);    \
         if (ret)                                                        \
                 return ret;
 
+#undef __field
+#define __field(type, item)     __field_ext(type, item, FILTER_OTHER)
+
 #undef __array
 #define __array(type, item, len)                                        \
         BUILD_BUG_ON(len > MAX_FILTER_STR_VAL);                         \
         ret = trace_define_field(event_call, #type "[" #len "]", #item, \
                                  offsetof(typeof(field), item),         \
-                                 sizeof(field.item), 0);                \
+                                 sizeof(field.item), 0, FILTER_OTHER);  \
         if (ret)                                                        \
                 return ret;
 
 #undef __dynamic_array
 #define __dynamic_array(type, item, len)                                       \
-        ret = trace_define_field(event_call, "__data_loc" "[" #type "]", #item,\
-                                offsetof(typeof(field), __data_loc_##item),    \
-                                 sizeof(field.__data_loc_##item), 0);
+        ret = trace_define_field(event_call, "__data_loc " #type "[]", #item,  \
+                                 offsetof(typeof(field), __data_loc_##item),   \
+                                 sizeof(field.__data_loc_##item), 0,           \
+                                 FILTER_OTHER);
 
 #undef __string
 #define __string(item, src) __dynamic_array(char, item, -1)
 
 #undef TRACE_EVENT
 #define TRACE_EVENT(call, proto, args, tstruct, func, print)            \
-int                                                                     \
-ftrace_define_fields_##call(void)                                       \
+static int                                                              \
+ftrace_define_fields_##call(struct ftrace_event_call *event_call)       \
 {                                                                       \
         struct ftrace_raw_##call field;                                 \
-        struct ftrace_event_call *event_call = &event_##call;           \
         int ret;                                                        \
                                                                         \
-        __common_field(int, type, 1);                                   \
-        __common_field(unsigned char, flags, 0);                        \
-        __common_field(unsigned char, preempt_count, 0);                \
-        __common_field(int, pid, 1);                                    \
-        __common_field(int, tgid, 1);                                   \
+        ret = trace_define_common_fields(event_call);                   \
+        if (ret)                                                        \
+                return ret;                                             \
                                                                         \
         tstruct;                                                        \
                                                                         \
@@ -321,6 +344,9 @@ ftrace_define_fields_##call(void)					\
 #undef __field
 #define __field(type, item)
 
+#undef __field_ext
+#define __field_ext(type, item, filter_type)
+
 #undef __array
 #define __array(type, item, len)
 
@@ -328,6 +354,7 @@ ftrace_define_fields_##call(void)					\
 #define __dynamic_array(type, item, len)                                \
         __data_offsets->item = __data_size +                            \
                                offsetof(typeof(*entry), __data);        \
+        __data_offsets->item |= (len * sizeof(type)) << 16;             \
         __data_size += (len) * sizeof(type);
 
 #undef __string
@@ -433,13 +460,15 @@ static void ftrace_profile_disable_##call(struct ftrace_event_call *event_call)\
  * {
  *      struct ring_buffer_event *event;
  *      struct ftrace_raw_<call> *entry; <-- defined in stage 1
+ *      struct ring_buffer *buffer;
  *      unsigned long irq_flags;
  *      int pc;
  *
  *      local_save_flags(irq_flags);
  *      pc = preempt_count();
  *
- *      event = trace_current_buffer_lock_reserve(event_<call>.id,
+ *      event = trace_current_buffer_lock_reserve(&buffer,
+ *                                event_<call>.id,
  *                                sizeof(struct ftrace_raw_<call>),
  *                                irq_flags, pc);
  *      if (!event)
@@ -449,7 +478,7 @@ static void ftrace_profile_disable_##call(struct ftrace_event_call *event_call)\
  *      <assign>;  <-- Here we assign the entries by the __field and
  *                      __array macros.
  *
- *      trace_current_buffer_unlock_commit(event, irq_flags, pc);
+ *      trace_current_buffer_unlock_commit(buffer, event, irq_flags, pc);
  * }
  *
  * static int ftrace_raw_reg_event_<call>(void)
@@ -541,6 +570,7 @@ static void ftrace_raw_event_##call(proto)				\
         struct ftrace_event_call *event_call = &event_##call;           \
         struct ring_buffer_event *event;                                \
         struct ftrace_raw_##call *entry;                                \
+        struct ring_buffer *buffer;                                     \
         unsigned long irq_flags;                                        \
         int __data_size;                                                \
         int pc;                                                         \
@@ -550,7 +580,8 @@ static void ftrace_raw_event_##call(proto)				\
                                                                         \
         __data_size = ftrace_get_offsets_##call(&__data_offsets, args); \
                                                                         \
-        event = trace_current_buffer_lock_reserve(event_##call.id,      \
+        event = trace_current_buffer_lock_reserve(&buffer,              \
+                                 event_##call.id,                       \
                                  sizeof(*entry) + __data_size,          \
                                  irq_flags, pc);                        \
         if (!event)                                                     \
@@ -562,11 +593,12 @@ static void ftrace_raw_event_##call(proto)				\
                                                                         \
         { assign; }                                                     \
                                                                         \
-        if (!filter_current_check_discard(event_call, entry, event))    \
-                trace_nowake_buffer_unlock_commit(event, irq_flags, pc); \
+        if (!filter_current_check_discard(buffer, event_call, entry, event)) \
+                trace_nowake_buffer_unlock_commit(buffer,               \
+                                                  event, irq_flags, pc); \
 }                                                                       \
                                                                         \
-static int ftrace_raw_reg_event_##call(void)                            \
+static int ftrace_raw_reg_event_##call(void *ptr)                       \
 {                                                                       \
         int ret;                                                        \
                                                                         \
@@ -577,7 +609,7 @@ static int ftrace_raw_reg_event_##call(void)				\
         return ret;                                                     \
 }                                                                       \
                                                                         \
-static void ftrace_raw_unreg_event_##call(void)                         \
+static void ftrace_raw_unreg_event_##call(void *ptr)                    \
 {                                                                       \
         unregister_trace_##call(ftrace_raw_event_##call);               \
 }                                                                       \
@@ -595,7 +627,6 @@ static int ftrace_raw_init_event_##call(void)				\
                 return -ENODEV;                                         \
         event_##call.id = id;                                           \
         INIT_LIST_HEAD(&event_##call.fields);                           \
-        init_preds(&event_##call);                                      \
         return 0;                                                       \
 }                                                                       \
                                                                         \
diff --git a/include/trace/syscall.h b/include/trace/syscall.h
index 8cfe515cbc47..5dc283ba5ae0 100644
--- a/include/trace/syscall.h
+++ b/include/trace/syscall.h
@@ -1,8 +1,13 @@
 #ifndef _TRACE_SYSCALL_H
 #define _TRACE_SYSCALL_H
 
+#include <linux/tracepoint.h>
+#include <linux/unistd.h>
+#include <linux/ftrace_event.h>
+
 #include <asm/ptrace.h>
 
+
 /*
  * A syscall entry in the ftrace syscalls array.
  *
@@ -10,26 +15,49 @@
  * @nb_args: number of parameters it takes
  * @types: list of types as strings
  * @args: list of args as strings (args[i] matches types[i])
+ * @enter_id: associated ftrace enter event id
+ * @exit_id: associated ftrace exit event id
+ * @enter_event: associated syscall_enter trace event
+ * @exit_event: associated syscall_exit trace event
  */
 struct syscall_metadata {
         const char      *name;
         int             nb_args;
         const char      **types;
         const char      **args;
+        int             enter_id;
+        int             exit_id;
+
+        struct ftrace_event_call *enter_event;
+        struct ftrace_event_call *exit_event;
 };
 
 #ifdef CONFIG_FTRACE_SYSCALLS
-extern void arch_init_ftrace_syscalls(void);
 extern struct syscall_metadata *syscall_nr_to_meta(int nr);
-extern void start_ftrace_syscalls(void);
-extern void stop_ftrace_syscalls(void);
-extern void ftrace_syscall_enter(struct pt_regs *regs);
-extern void ftrace_syscall_exit(struct pt_regs *regs);
-#else
-static inline void start_ftrace_syscalls(void)                  { }
-static inline void stop_ftrace_syscalls(void)                   { }
-static inline void ftrace_syscall_enter(struct pt_regs *regs)   { }
-static inline void ftrace_syscall_exit(struct pt_regs *regs)    { }
+extern int syscall_name_to_nr(char *name);
+void set_syscall_enter_id(int num, int id);
+void set_syscall_exit_id(int num, int id);
+extern struct trace_event event_syscall_enter;
+extern struct trace_event event_syscall_exit;
+extern int reg_event_syscall_enter(void *ptr);
+extern void unreg_event_syscall_enter(void *ptr);
+extern int reg_event_syscall_exit(void *ptr);
+extern void unreg_event_syscall_exit(void *ptr);
+extern int syscall_enter_format(struct ftrace_event_call *call,
+                                struct trace_seq *s);
+extern int syscall_exit_format(struct ftrace_event_call *call,
+                                struct trace_seq *s);
+extern int syscall_enter_define_fields(struct ftrace_event_call *call);
+extern int syscall_exit_define_fields(struct ftrace_event_call *call);
+enum print_line_t print_syscall_enter(struct trace_iterator *iter, int flags);
+enum print_line_t print_syscall_exit(struct trace_iterator *iter, int flags);
+#endif
+#ifdef CONFIG_EVENT_PROFILE
+int reg_prof_syscall_enter(char *name);
+void unreg_prof_syscall_enter(char *name);
+int reg_prof_syscall_exit(char *name);
+void unreg_prof_syscall_exit(char *name);
+
 #endif
 
 #endif /* _TRACE_SYSCALL_H */