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

14 files changed, 657 insertions, 85 deletions

diff --git a/include/trace/block.h b/include/trace/block.h
index 25c6a1fd5b77..25b7068b819e 100644
--- a/include/trace/block.h
+++ b/include/trace/block.h
@@ -5,72 +5,72 @@
 #include <linux/tracepoint.h>
 
 DECLARE_TRACE(block_rq_abort,
-        TPPROTO(struct request_queue *q, struct request *rq),
-                TPARGS(q, rq));
+        TP_PROTO(struct request_queue *q, struct request *rq),
+              TP_ARGS(q, rq));
 
 DECLARE_TRACE(block_rq_insert,
-        TPPROTO(struct request_queue *q, struct request *rq),
-                TPARGS(q, rq));
+        TP_PROTO(struct request_queue *q, struct request *rq),
+              TP_ARGS(q, rq));
 
 DECLARE_TRACE(block_rq_issue,
-        TPPROTO(struct request_queue *q, struct request *rq),
-                TPARGS(q, rq));
+        TP_PROTO(struct request_queue *q, struct request *rq),
+              TP_ARGS(q, rq));
 
 DECLARE_TRACE(block_rq_requeue,
-        TPPROTO(struct request_queue *q, struct request *rq),
-                TPARGS(q, rq));
+        TP_PROTO(struct request_queue *q, struct request *rq),
+              TP_ARGS(q, rq));
 
 DECLARE_TRACE(block_rq_complete,
-        TPPROTO(struct request_queue *q, struct request *rq),
-                TPARGS(q, rq));
+        TP_PROTO(struct request_queue *q, struct request *rq),
+              TP_ARGS(q, rq));
 
 DECLARE_TRACE(block_bio_bounce,
-        TPPROTO(struct request_queue *q, struct bio *bio),
-                TPARGS(q, bio));
+        TP_PROTO(struct request_queue *q, struct bio *bio),
+              TP_ARGS(q, bio));
 
 DECLARE_TRACE(block_bio_complete,
-        TPPROTO(struct request_queue *q, struct bio *bio),
-                TPARGS(q, bio));
+        TP_PROTO(struct request_queue *q, struct bio *bio),
+              TP_ARGS(q, bio));
 
 DECLARE_TRACE(block_bio_backmerge,
-        TPPROTO(struct request_queue *q, struct bio *bio),
-                TPARGS(q, bio));
+        TP_PROTO(struct request_queue *q, struct bio *bio),
+              TP_ARGS(q, bio));
 
 DECLARE_TRACE(block_bio_frontmerge,
-        TPPROTO(struct request_queue *q, struct bio *bio),
-                TPARGS(q, bio));
+        TP_PROTO(struct request_queue *q, struct bio *bio),
+              TP_ARGS(q, bio));
 
 DECLARE_TRACE(block_bio_queue,
-        TPPROTO(struct request_queue *q, struct bio *bio),
-                TPARGS(q, bio));
+        TP_PROTO(struct request_queue *q, struct bio *bio),
+              TP_ARGS(q, bio));
 
 DECLARE_TRACE(block_getrq,
-        TPPROTO(struct request_queue *q, struct bio *bio, int rw),
-                TPARGS(q, bio, rw));
+        TP_PROTO(struct request_queue *q, struct bio *bio, int rw),
+              TP_ARGS(q, bio, rw));
 
 DECLARE_TRACE(block_sleeprq,
-        TPPROTO(struct request_queue *q, struct bio *bio, int rw),
-                TPARGS(q, bio, rw));
+        TP_PROTO(struct request_queue *q, struct bio *bio, int rw),
+              TP_ARGS(q, bio, rw));
 
 DECLARE_TRACE(block_plug,
-        TPPROTO(struct request_queue *q),
-                TPARGS(q));
+        TP_PROTO(struct request_queue *q),
+              TP_ARGS(q));
 
 DECLARE_TRACE(block_unplug_timer,
-        TPPROTO(struct request_queue *q),
-                TPARGS(q));
+        TP_PROTO(struct request_queue *q),
+              TP_ARGS(q));
 
 DECLARE_TRACE(block_unplug_io,
-        TPPROTO(struct request_queue *q),
-                TPARGS(q));
+        TP_PROTO(struct request_queue *q),
+              TP_ARGS(q));
 
 DECLARE_TRACE(block_split,
-        TPPROTO(struct request_queue *q, struct bio *bio, unsigned int pdu),
-                TPARGS(q, bio, pdu));
+        TP_PROTO(struct request_queue *q, struct bio *bio, unsigned int pdu),
+              TP_ARGS(q, bio, pdu));
 
 DECLARE_TRACE(block_remap,
-        TPPROTO(struct request_queue *q, struct bio *bio, dev_t dev,
-                sector_t from, sector_t to),
-                TPARGS(q, bio, dev, from, to));
+        TP_PROTO(struct request_queue *q, struct bio *bio, dev_t dev,
+                 sector_t from, sector_t to),
+              TP_ARGS(q, bio, dev, from, to));
 
 #endif
diff --git a/include/trace/irq.h b/include/trace/irq.h
new file mode 100644
index 000000000000..ff5d4495dc37
--- /dev/null
+++ b/include/trace/irq.h
@@ -0,0 +1,9 @@
+#ifndef _TRACE_IRQ_H
+#define _TRACE_IRQ_H
+
+#include <linux/interrupt.h>
+#include <linux/tracepoint.h>
+
+#include <trace/irq_event_types.h>
+
+#endif
diff --git a/include/trace/irq_event_types.h b/include/trace/irq_event_types.h
new file mode 100644
index 000000000000..85964ebd47ec
--- /dev/null
+++ b/include/trace/irq_event_types.h
@@ -0,0 +1,55 @@
+
+/* use <trace/irq.h> instead */
+#ifndef TRACE_FORMAT
+# error Do not include this file directly.
+# error Unless you know what you are doing.
+#endif
+
+#undef TRACE_SYSTEM
+#define TRACE_SYSTEM irq
+
+/*
+ * Tracepoint for entry of interrupt handler:
+ */
+TRACE_FORMAT(irq_handler_entry,
+        TP_PROTO(int irq, struct irqaction *action),
+        TP_ARGS(irq, action),
+        TP_FMT("irq=%d handler=%s", irq, action->name)
+        );
+
+/*
+ * Tracepoint for return of an interrupt handler:
+ */
+TRACE_EVENT(irq_handler_exit,
+
+        TP_PROTO(int irq, struct irqaction *action, int ret),
+
+        TP_ARGS(irq, action, ret),
+
+        TP_STRUCT__entry(
+                __field(        int,    irq     )
+                __field(        int,    ret     )
+        ),
+
+        TP_fast_assign(
+                __entry->irq    = irq;
+                __entry->ret    = ret;
+        ),
+
+        TP_printk("irq=%d return=%s",
+                  __entry->irq, __entry->ret ? "handled" : "unhandled")
+);
+
+TRACE_FORMAT(softirq_entry,
+        TP_PROTO(struct softirq_action *h, struct softirq_action *vec),
+        TP_ARGS(h, vec),
+        TP_FMT("softirq=%d action=%s", (int)(h - vec), softirq_to_name[h-vec])
+        );
+
+TRACE_FORMAT(softirq_exit,
+        TP_PROTO(struct softirq_action *h, struct softirq_action *vec),
+        TP_ARGS(h, vec),
+        TP_FMT("softirq=%d action=%s", (int)(h - vec), softirq_to_name[h-vec])
+        );
+
+#undef TRACE_SYSTEM
diff --git a/include/trace/kmemtrace.h b/include/trace/kmemtrace.h
new file mode 100644
index 000000000000..28ee69f9cd46
--- /dev/null
+++ b/include/trace/kmemtrace.h
@@ -0,0 +1,63 @@
+/*
+ * Copyright (C) 2008 Eduard - Gabriel Munteanu
+ *
+ * This file is released under GPL version 2.
+ */
+
+#ifndef _LINUX_KMEMTRACE_H
+#define _LINUX_KMEMTRACE_H
+
+#ifdef __KERNEL__
+
+#include <linux/tracepoint.h>
+#include <linux/types.h>
+
+#ifdef CONFIG_KMEMTRACE
+extern void kmemtrace_init(void);
+#else
+static inline void kmemtrace_init(void)
+{
+}
+#endif
+
+DECLARE_TRACE(kmalloc,
+              TP_PROTO(unsigned long call_site,
+                      const void *ptr,
+                      size_t bytes_req,
+                      size_t bytes_alloc,
+                      gfp_t gfp_flags),
+              TP_ARGS(call_site, ptr, bytes_req, bytes_alloc, gfp_flags));
+DECLARE_TRACE(kmem_cache_alloc,
+              TP_PROTO(unsigned long call_site,
+                      const void *ptr,
+                      size_t bytes_req,
+                      size_t bytes_alloc,
+                      gfp_t gfp_flags),
+              TP_ARGS(call_site, ptr, bytes_req, bytes_alloc, gfp_flags));
+DECLARE_TRACE(kmalloc_node,
+              TP_PROTO(unsigned long call_site,
+                      const void *ptr,
+                      size_t bytes_req,
+                      size_t bytes_alloc,
+                      gfp_t gfp_flags,
+                      int node),
+              TP_ARGS(call_site, ptr, bytes_req, bytes_alloc, gfp_flags, node));
+DECLARE_TRACE(kmem_cache_alloc_node,
+              TP_PROTO(unsigned long call_site,
+                      const void *ptr,
+                      size_t bytes_req,
+                      size_t bytes_alloc,
+                      gfp_t gfp_flags,
+                      int node),
+              TP_ARGS(call_site, ptr, bytes_req, bytes_alloc, gfp_flags, node));
+DECLARE_TRACE(kfree,
+              TP_PROTO(unsigned long call_site, const void *ptr),
+              TP_ARGS(call_site, ptr));
+DECLARE_TRACE(kmem_cache_free,
+              TP_PROTO(unsigned long call_site, const void *ptr),
+              TP_ARGS(call_site, ptr));
+
+#endif /* __KERNEL__ */
+
+#endif /* _LINUX_KMEMTRACE_H */
+
diff --git a/include/trace/lockdep.h b/include/trace/lockdep.h
new file mode 100644
index 000000000000..5ca67df87f2a
--- /dev/null
+++ b/include/trace/lockdep.h
@@ -0,0 +1,9 @@
+#ifndef _TRACE_LOCKDEP_H
+#define _TRACE_LOCKDEP_H
+
+#include <linux/lockdep.h>
+#include <linux/tracepoint.h>
+
+#include <trace/lockdep_event_types.h>
+
+#endif
diff --git a/include/trace/lockdep_event_types.h b/include/trace/lockdep_event_types.h
new file mode 100644
index 000000000000..adccfcd2ec8f
--- /dev/null
+++ b/include/trace/lockdep_event_types.h
@@ -0,0 +1,44 @@
+
+#ifndef TRACE_FORMAT
+# error Do not include this file directly.
+# error Unless you know what you are doing.
+#endif
+
+#undef TRACE_SYSTEM
+#define TRACE_SYSTEM lock
+
+#ifdef CONFIG_LOCKDEP
+
+TRACE_FORMAT(lock_acquire,
+        TP_PROTO(struct lockdep_map *lock, unsigned int subclass,
+                int trylock, int read, int check,
+                struct lockdep_map *next_lock, unsigned long ip),
+        TP_ARGS(lock, subclass, trylock, read, check, next_lock, ip),
+        TP_FMT("%s%s%s", trylock ? "try " : "",
+                read ? "read " : "", lock->name)
+        );
+
+TRACE_FORMAT(lock_release,
+        TP_PROTO(struct lockdep_map *lock, int nested, unsigned long ip),
+        TP_ARGS(lock, nested, ip),
+        TP_FMT("%s", lock->name)
+        );
+
+#ifdef CONFIG_LOCK_STAT
+
+TRACE_FORMAT(lock_contended,
+        TP_PROTO(struct lockdep_map *lock, unsigned long ip),
+        TP_ARGS(lock, ip),
+        TP_FMT("%s", lock->name)
+        );
+
+TRACE_FORMAT(lock_acquired,
+        TP_PROTO(struct lockdep_map *lock, unsigned long ip),
+        TP_ARGS(lock, ip),
+        TP_FMT("%s", lock->name)
+        );
+
+#endif
+#endif
+
+#undef TRACE_SYSTEM
diff --git a/include/trace/power.h b/include/trace/power.h
new file mode 100644
index 000000000000..ef204666e983
--- /dev/null
+++ b/include/trace/power.h
@@ -0,0 +1,32 @@
+#ifndef _TRACE_POWER_H
+#define _TRACE_POWER_H
+
+#include <linux/ktime.h>
+#include <linux/tracepoint.h>
+
+enum {
+        POWER_NONE = 0,
+        POWER_CSTATE = 1,
+        POWER_PSTATE = 2,
+};
+
+struct power_trace {
+        ktime_t                 stamp;
+        ktime_t                 end;
+        int                     type;
+        int                     state;
+};
+
+DECLARE_TRACE(power_start,
+        TP_PROTO(struct power_trace *it, unsigned int type, unsigned int state),
+              TP_ARGS(it, type, state));
+
+DECLARE_TRACE(power_mark,
+        TP_PROTO(struct power_trace *it, unsigned int type, unsigned int state),
+              TP_ARGS(it, type, state));
+
+DECLARE_TRACE(power_end,
+        TP_PROTO(struct power_trace *it),
+              TP_ARGS(it));
+
+#endif /* _TRACE_POWER_H */
diff --git a/include/trace/sched.h b/include/trace/sched.h
index 0d81098ee9fc..4e372a1a29bf 100644
--- a/include/trace/sched.h
+++ b/include/trace/sched.h
@@ -4,53 +4,6 @@
 #include <linux/sched.h>
 #include <linux/tracepoint.h>
 
-DECLARE_TRACE(sched_kthread_stop,
-        TPPROTO(struct task_struct *t),
-                TPARGS(t));
-
-DECLARE_TRACE(sched_kthread_stop_ret,
-        TPPROTO(int ret),
-                TPARGS(ret));
-
-DECLARE_TRACE(sched_wait_task,
-        TPPROTO(struct rq *rq, struct task_struct *p),
-                TPARGS(rq, p));
-
-DECLARE_TRACE(sched_wakeup,
-        TPPROTO(struct rq *rq, struct task_struct *p, int success),
-                TPARGS(rq, p, success));
-
-DECLARE_TRACE(sched_wakeup_new,
-        TPPROTO(struct rq *rq, struct task_struct *p, int success),
-                TPARGS(rq, p, success));
-
-DECLARE_TRACE(sched_switch,
-        TPPROTO(struct rq *rq, struct task_struct *prev,
-                struct task_struct *next),
-                TPARGS(rq, prev, next));
-
-DECLARE_TRACE(sched_migrate_task,
-        TPPROTO(struct task_struct *p, int orig_cpu, int dest_cpu),
-                TPARGS(p, orig_cpu, dest_cpu));
-
-DECLARE_TRACE(sched_process_free,
-        TPPROTO(struct task_struct *p),
-                TPARGS(p));
-
-DECLARE_TRACE(sched_process_exit,
-        TPPROTO(struct task_struct *p),
-                TPARGS(p));
-
-DECLARE_TRACE(sched_process_wait,
-        TPPROTO(struct pid *pid),
-                TPARGS(pid));
-
-DECLARE_TRACE(sched_process_fork,
-        TPPROTO(struct task_struct *parent, struct task_struct *child),
-                TPARGS(parent, child));
-
-DECLARE_TRACE(sched_signal_send,
-        TPPROTO(int sig, struct task_struct *p),
-                TPARGS(sig, p));
+#include <trace/sched_event_types.h>
 
 #endif
diff --git a/include/trace/sched_event_types.h b/include/trace/sched_event_types.h
new file mode 100644
index 000000000000..63547dc1125f
--- /dev/null
+++ b/include/trace/sched_event_types.h
@@ -0,0 +1,337 @@
+
+/* use <trace/sched.h> instead */
+#ifndef TRACE_EVENT
+# error Do not include this file directly.
+# error Unless you know what you are doing.
+#endif
+
+#undef TRACE_SYSTEM
+#define TRACE_SYSTEM sched
+
+/*
+ * Tracepoint for calling kthread_stop, performed to end a kthread:
+ */
+TRACE_EVENT(sched_kthread_stop,
+
+        TP_PROTO(struct task_struct *t),
+
+        TP_ARGS(t),
+
+        TP_STRUCT__entry(
+                __array(        char,   comm,   TASK_COMM_LEN   )
+                __field(        pid_t,  pid                     )
+        ),
+
+        TP_fast_assign(
+                memcpy(__entry->comm, t->comm, TASK_COMM_LEN);
+                __entry->pid    = t->pid;
+        ),
+
+        TP_printk("task %s:%d", __entry->comm, __entry->pid)
+);
+
+/*
+ * Tracepoint for the return value of the kthread stopping:
+ */
+TRACE_EVENT(sched_kthread_stop_ret,
+
+        TP_PROTO(int ret),
+
+        TP_ARGS(ret),
+
+        TP_STRUCT__entry(
+                __field(        int,    ret     )
+        ),
+
+        TP_fast_assign(
+                __entry->ret    = ret;
+        ),
+
+        TP_printk("ret %d", __entry->ret)
+);
+
+/*
+ * Tracepoint for waiting on task to unschedule:
+ *
+ * (NOTE: the 'rq' argument is not used by generic trace events,
+ *        but used by the latency tracer plugin. )
+ */
+TRACE_EVENT(sched_wait_task,
+
+        TP_PROTO(struct rq *rq, struct task_struct *p),
+
+        TP_ARGS(rq, p),
+
+        TP_STRUCT__entry(
+                __array(        char,   comm,   TASK_COMM_LEN   )
+                __field(        pid_t,  pid                     )
+                __field(        int,    prio                    )
+        ),
+
+        TP_fast_assign(
+                memcpy(__entry->comm, p->comm, TASK_COMM_LEN);
+                __entry->pid    = p->pid;
+                __entry->prio   = p->prio;
+        ),
+
+        TP_printk("task %s:%d [%d]",
+                  __entry->comm, __entry->pid, __entry->prio)
+);
+
+/*
+ * Tracepoint for waking up a task:
+ *
+ * (NOTE: the 'rq' argument is not used by generic trace events,
+ *        but used by the latency tracer plugin. )
+ */
+TRACE_EVENT(sched_wakeup,
+
+        TP_PROTO(struct rq *rq, struct task_struct *p, int success),
+
+        TP_ARGS(rq, p, success),
+
+        TP_STRUCT__entry(
+                __array(        char,   comm,   TASK_COMM_LEN   )
+                __field(        pid_t,  pid                     )
+                __field(        int,    prio                    )
+                __field(        int,    success                 )
+        ),
+
+        TP_fast_assign(
+                memcpy(__entry->comm, p->comm, TASK_COMM_LEN);
+                __entry->pid            = p->pid;
+                __entry->prio           = p->prio;
+                __entry->success        = success;
+        ),
+
+        TP_printk("task %s:%d [%d] success=%d",
+                  __entry->comm, __entry->pid, __entry->prio,
+                  __entry->success)
+);
+
+/*
+ * Tracepoint for waking up a new task:
+ *
+ * (NOTE: the 'rq' argument is not used by generic trace events,
+ *        but used by the latency tracer plugin. )
+ */
+TRACE_EVENT(sched_wakeup_new,
+
+        TP_PROTO(struct rq *rq, struct task_struct *p, int success),
+
+        TP_ARGS(rq, p, success),
+
+        TP_STRUCT__entry(
+                __array(        char,   comm,   TASK_COMM_LEN   )
+                __field(        pid_t,  pid                     )
+                __field(        int,    prio                    )
+                __field(        int,    success                 )
+        ),
+
+        TP_fast_assign(
+                memcpy(__entry->comm, p->comm, TASK_COMM_LEN);
+                __entry->pid            = p->pid;
+                __entry->prio           = p->prio;
+                __entry->success        = success;
+        ),
+
+        TP_printk("task %s:%d [%d] success=%d",
+                  __entry->comm, __entry->pid, __entry->prio,
+                  __entry->success)
+);
+
+/*
+ * Tracepoint for task switches, performed by the scheduler:
+ *
+ * (NOTE: the 'rq' argument is not used by generic trace events,
+ *        but used by the latency tracer plugin. )
+ */
+TRACE_EVENT(sched_switch,
+
+        TP_PROTO(struct rq *rq, struct task_struct *prev,
+                 struct task_struct *next),
+
+        TP_ARGS(rq, prev, next),
+
+        TP_STRUCT__entry(
+                __array(        char,   prev_comm,      TASK_COMM_LEN   )
+                __field(        pid_t,  prev_pid                        )
+                __field(        int,    prev_prio                       )
+                __array(        char,   next_comm,      TASK_COMM_LEN   )
+                __field(        pid_t,  next_pid                        )
+                __field(        int,    next_prio                       )
+        ),
+
+        TP_fast_assign(
+                memcpy(__entry->next_comm, next->comm, TASK_COMM_LEN);
+                __entry->prev_pid       = prev->pid;
+                __entry->prev_prio      = prev->prio;
+                memcpy(__entry->prev_comm, prev->comm, TASK_COMM_LEN);
+                __entry->next_pid       = next->pid;
+                __entry->next_prio      = next->prio;
+        ),
+
+        TP_printk("task %s:%d [%d] ==> %s:%d [%d]",
+                __entry->prev_comm, __entry->prev_pid, __entry->prev_prio,
+                __entry->next_comm, __entry->next_pid, __entry->next_prio)
+);
+
+/*
+ * Tracepoint for a task being migrated:
+ */
+TRACE_EVENT(sched_migrate_task,
+
+        TP_PROTO(struct task_struct *p, int orig_cpu, int dest_cpu),
+
+        TP_ARGS(p, orig_cpu, dest_cpu),
+
+        TP_STRUCT__entry(
+                __array(        char,   comm,   TASK_COMM_LEN   )
+                __field(        pid_t,  pid                     )
+                __field(        int,    prio                    )
+                __field(        int,    orig_cpu                )
+                __field(        int,    dest_cpu                )
+        ),
+
+        TP_fast_assign(
+                memcpy(__entry->comm, p->comm, TASK_COMM_LEN);
+                __entry->pid            = p->pid;
+                __entry->prio           = p->prio;
+                __entry->orig_cpu       = orig_cpu;
+                __entry->dest_cpu       = dest_cpu;
+        ),
+
+        TP_printk("task %s:%d [%d] from: %d  to: %d",
+                  __entry->comm, __entry->pid, __entry->prio,
+                  __entry->orig_cpu, __entry->dest_cpu)
+);
+
+/*
+ * Tracepoint for freeing a task:
+ */
+TRACE_EVENT(sched_process_free,
+
+        TP_PROTO(struct task_struct *p),
+
+        TP_ARGS(p),
+
+        TP_STRUCT__entry(
+                __array(        char,   comm,   TASK_COMM_LEN   )
+                __field(        pid_t,  pid                     )
+                __field(        int,    prio                    )
+        ),
+
+        TP_fast_assign(
+                memcpy(__entry->comm, p->comm, TASK_COMM_LEN);
+                __entry->pid            = p->pid;
+                __entry->prio           = p->prio;
+        ),
+
+        TP_printk("task %s:%d [%d]",
+                  __entry->comm, __entry->pid, __entry->prio)
+);
+
+/*
+ * Tracepoint for a task exiting:
+ */
+TRACE_EVENT(sched_process_exit,
+
+        TP_PROTO(struct task_struct *p),
+
+        TP_ARGS(p),
+
+        TP_STRUCT__entry(
+                __array(        char,   comm,   TASK_COMM_LEN   )
+                __field(        pid_t,  pid                     )
+                __field(        int,    prio                    )
+        ),
+
+        TP_fast_assign(
+                memcpy(__entry->comm, p->comm, TASK_COMM_LEN);
+                __entry->pid            = p->pid;
+                __entry->prio           = p->prio;
+        ),
+
+        TP_printk("task %s:%d [%d]",
+                  __entry->comm, __entry->pid, __entry->prio)
+);
+
+/*
+ * Tracepoint for a waiting task:
+ */
+TRACE_EVENT(sched_process_wait,
+
+        TP_PROTO(struct pid *pid),
+
+        TP_ARGS(pid),
+
+        TP_STRUCT__entry(
+                __array(        char,   comm,   TASK_COMM_LEN   )
+                __field(        pid_t,  pid                     )
+                __field(        int,    prio                    )
+        ),
+
+        TP_fast_assign(
+                memcpy(__entry->comm, current->comm, TASK_COMM_LEN);
+                __entry->pid            = pid_nr(pid);
+                __entry->prio           = current->prio;
+        ),
+
+        TP_printk("task %s:%d [%d]",
+                  __entry->comm, __entry->pid, __entry->prio)
+);
+
+/*
+ * Tracepoint for do_fork:
+ */
+TRACE_EVENT(sched_process_fork,
+
+        TP_PROTO(struct task_struct *parent, struct task_struct *child),
+
+        TP_ARGS(parent, child),
+
+        TP_STRUCT__entry(
+                __array(        char,   parent_comm,    TASK_COMM_LEN   )
+                __field(        pid_t,  parent_pid                      )
+                __array(        char,   child_comm,     TASK_COMM_LEN   )
+                __field(        pid_t,  child_pid                       )
+        ),
+
+        TP_fast_assign(
+                memcpy(__entry->parent_comm, parent->comm, TASK_COMM_LEN);
+                __entry->parent_pid     = parent->pid;
+                memcpy(__entry->child_comm, child->comm, TASK_COMM_LEN);
+                __entry->child_pid      = child->pid;
+        ),
+
+        TP_printk("parent %s:%d  child %s:%d",
+                __entry->parent_comm, __entry->parent_pid,
+                __entry->child_comm, __entry->child_pid)
+);
+
+/*
+ * Tracepoint for sending a signal:
+ */
+TRACE_EVENT(sched_signal_send,
+
+        TP_PROTO(int sig, struct task_struct *p),
+
+        TP_ARGS(sig, p),
+
+        TP_STRUCT__entry(
+                __field(        int,    sig                     )
+                __array(        char,   comm,   TASK_COMM_LEN   )
+                __field(        pid_t,  pid                     )
+        ),
+
+        TP_fast_assign(
+                memcpy(__entry->comm, p->comm, TASK_COMM_LEN);
+                __entry->pid    = p->pid;
+                __entry->sig    = sig;
+        ),
+
+        TP_printk("sig: %d  task %s:%d",
+                  __entry->sig, __entry->comm, __entry->pid)
+);
+
+#undef TRACE_SYSTEM
diff --git a/include/trace/skb.h b/include/trace/skb.h
index a96610f92f69..b66206d9be72 100644
--- a/include/trace/skb.h
+++ b/include/trace/skb.h
@@ -5,7 +5,7 @@
 #include <linux/tracepoint.h>
 
 DECLARE_TRACE(kfree_skb,
-        TPPROTO(struct sk_buff *skb, void *location),
-        TPARGS(skb, location));
+        TP_PROTO(struct sk_buff *skb, void *location),
+        TP_ARGS(skb, location));
 
 #endif
diff --git a/include/trace/syscall.h b/include/trace/syscall.h
new file mode 100644
index 000000000000..8cfe515cbc47
--- /dev/null
+++ b/include/trace/syscall.h
@@ -0,0 +1,35 @@
+#ifndef _TRACE_SYSCALL_H
+#define _TRACE_SYSCALL_H
+
+#include <asm/ptrace.h>
+
+/*
+ * A syscall entry in the ftrace syscalls array.
+ *
+ * @name: name of the syscall
+ * @nb_args: number of parameters it takes
+ * @types: list of types as strings
+ * @args: list of args as strings (args[i] matches types[i])
+ */
+struct syscall_metadata {
+        const char      *name;
+        int             nb_args;
+        const char      **types;
+        const char      **args;
+};
+
+#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)    { }
+#endif
+
+#endif /* _TRACE_SYSCALL_H */
diff --git a/include/trace/trace_event_types.h b/include/trace/trace_event_types.h
new file mode 100644
index 000000000000..df56f5694be6
--- /dev/null
+++ b/include/trace/trace_event_types.h
@@ -0,0 +1,5 @@
+/* trace/<type>_event_types.h here */
+
+#include <trace/sched_event_types.h>
+#include <trace/irq_event_types.h>
+#include <trace/lockdep_event_types.h>
diff --git a/include/trace/trace_events.h b/include/trace/trace_events.h
new file mode 100644
index 000000000000..fd13750ca4ba
--- /dev/null
+++ b/include/trace/trace_events.h
@@ -0,0 +1,5 @@
+/* trace/<type>.h here */
+
+#include <trace/sched.h>
+#include <trace/irq.h>
+#include <trace/lockdep.h>
diff --git a/include/trace/workqueue.h b/include/trace/workqueue.h
new file mode 100644
index 000000000000..7626523deeba
--- /dev/null
+++ b/include/trace/workqueue.h
@@ -0,0 +1,25 @@
+#ifndef __TRACE_WORKQUEUE_H
+#define __TRACE_WORKQUEUE_H
+
+#include <linux/tracepoint.h>
+#include <linux/workqueue.h>
+#include <linux/sched.h>
+
+DECLARE_TRACE(workqueue_insertion,
+           TP_PROTO(struct task_struct *wq_thread, struct work_struct *work),
+           TP_ARGS(wq_thread, work));
+
+DECLARE_TRACE(workqueue_execution,
+           TP_PROTO(struct task_struct *wq_thread, struct work_struct *work),
+           TP_ARGS(wq_thread, work));
+
+/* Trace the creation of one workqueue thread on a cpu */
+DECLARE_TRACE(workqueue_creation,
+           TP_PROTO(struct task_struct *wq_thread, int cpu),
+           TP_ARGS(wq_thread, cpu));
+
+DECLARE_TRACE(workqueue_destruction,
+           TP_PROTO(struct task_struct *wq_thread),
+           TP_ARGS(wq_thread));
+
+#endif /* __TRACE_WORKQUEUE_H */