16 files changed, 512 insertions, 136 deletions

diff --git a/include/asm-generic/vmlinux.lds.h b/include/asm-generic/vmlinux.lds.h
index c61fab1dd2f8..0add6b28c366 100644
--- a/include/asm-generic/vmlinux.lds.h
+++ b/include/asm-generic/vmlinux.lds.h
@@ -61,6 +61,14 @@
 #define BRANCH_PROFILE()
 #endif
 
+#ifdef CONFIG_EVENT_TRACER
+#define FTRACE_EVENTS() VMLINUX_SYMBOL(__start_ftrace_events) = .;      \
+                        *(_ftrace_events)                               \
+                        VMLINUX_SYMBOL(__stop_ftrace_events) = .;
+#else
+#define FTRACE_EVENTS()
+#endif
+
 /* .data section */
 #define DATA_DATA                                                       \
         *(.data)                                                        \
@@ -81,7 +89,8 @@
         *(__tracepoints)                                                \
         VMLINUX_SYMBOL(__stop___tracepoints) = .;                       \
         LIKELY_PROFILE()                                                \
-        BRANCH_PROFILE()
+        BRANCH_PROFILE()                                                \
+        FTRACE_EVENTS()
 
 #define RO_DATA(align)                                                  \
         . = ALIGN((align));                                             \
diff --git a/include/linux/blktrace_api.h b/include/linux/blktrace_api.h
index 6e915878e88c..d960889e92ef 100644
--- a/include/linux/blktrace_api.h
+++ b/include/linux/blktrace_api.h
@@ -144,6 +144,9 @@ struct blk_user_trace_setup {
 
 #ifdef __KERNEL__
 #if defined(CONFIG_BLK_DEV_IO_TRACE)
+
+#include <linux/sysfs.h>
+
 struct blk_trace {
         int trace_state;
         struct rchan *rchan;
@@ -194,6 +197,8 @@ extern int blk_trace_setup(struct request_queue *q, char *name, dev_t dev,
 extern int blk_trace_startstop(struct request_queue *q, int start);
 extern int blk_trace_remove(struct request_queue *q);
 
+extern struct attribute_group blk_trace_attr_group;
+
 #else /* !CONFIG_BLK_DEV_IO_TRACE */
 #define blk_trace_ioctl(bdev, cmd, arg)         (-ENOTTY)
 #define blk_trace_shutdown(q)                   do { } while (0)
diff --git a/include/linux/ftrace.h b/include/linux/ftrace.h
index 677432b9cb7e..847bb3c48dd0 100644
--- a/include/linux/ftrace.h
+++ b/include/linux/ftrace.h
@@ -95,10 +95,44 @@ stack_trace_sysctl(struct ctl_table *table, int write,
                    loff_t *ppos);
 #endif
 
+struct ftrace_func_command {
+        struct list_head        list;
+        char                    *name;
+        int                     (*func)(char *func, char *cmd,
+                                        char *params, int enable);
+};
+
 #ifdef CONFIG_DYNAMIC_FTRACE
 /* asm/ftrace.h must be defined for archs supporting dynamic ftrace */
 #include <asm/ftrace.h>
 
+int ftrace_arch_code_modify_prepare(void);
+int ftrace_arch_code_modify_post_process(void);
+
+struct seq_file;
+
+struct ftrace_probe_ops {
+        void                    (*func)(unsigned long ip,
+                                        unsigned long parent_ip,
+                                        void **data);
+        int                     (*callback)(unsigned long ip, void **data);
+        void                    (*free)(void **data);
+        int                     (*print)(struct seq_file *m,
+                                         unsigned long ip,
+                                         struct ftrace_probe_ops *ops,
+                                         void *data);
+};
+
+extern int
+register_ftrace_function_probe(char *glob, struct ftrace_probe_ops *ops,
+                              void *data);
+extern void
+unregister_ftrace_function_probe(char *glob, struct ftrace_probe_ops *ops,
+                                void *data);
+extern void
+unregister_ftrace_function_probe_func(char *glob, struct ftrace_probe_ops *ops);
+extern void unregister_ftrace_function_probe_all(char *glob);
+
 enum {
         FTRACE_FL_FREE          = (1 << 0),
         FTRACE_FL_FAILED        = (1 << 1),
@@ -119,6 +153,9 @@ struct dyn_ftrace {
 int ftrace_force_update(void);
 void ftrace_set_filter(unsigned char *buf, int len, int reset);
 
+int register_ftrace_command(struct ftrace_func_command *cmd);
+int unregister_ftrace_command(struct ftrace_func_command *cmd);
+
 /* defined in arch */
 extern int ftrace_ip_converted(unsigned long ip);
 extern int ftrace_dyn_arch_init(void *data);
@@ -126,6 +163,10 @@ extern int ftrace_update_ftrace_func(ftrace_func_t func);
 extern void ftrace_caller(void);
 extern void ftrace_call(void);
 extern void mcount_call(void);
+
+#ifndef FTRACE_ADDR
+#define FTRACE_ADDR ((unsigned long)ftrace_caller)
+#endif
 #ifdef CONFIG_FUNCTION_GRAPH_TRACER
 extern void ftrace_graph_caller(void);
 extern int ftrace_enable_ftrace_graph_caller(void);
@@ -136,7 +177,7 @@ static inline int ftrace_disable_ftrace_graph_caller(void) { return 0; }
 #endif
 
 /**
- * ftrace_make_nop - convert code into top
+ * ftrace_make_nop - convert code into nop
  * @mod: module structure if called by module load initialization
  * @rec: the mcount call site record
  * @addr: the address that the call site should be calling
@@ -198,6 +239,14 @@ extern void ftrace_enable_daemon(void);
 # define ftrace_disable_daemon()                do { } while (0)
 # define ftrace_enable_daemon()                 do { } while (0)
 static inline void ftrace_release(void *start, unsigned long size) { }
+static inline int register_ftrace_command(struct ftrace_func_command *cmd)
+{
+        return -EINVAL;
+}
+static inline int unregister_ftrace_command(char *cmd_name)
+{
+        return -EINVAL;
+}
 #endif /* CONFIG_DYNAMIC_FTRACE */
 
 /* totally disable ftrace - can not re-enable after this */
@@ -298,6 +347,9 @@ ftrace_special(unsigned long arg1, unsigned long arg2, unsigned long arg3);
 extern int
 __ftrace_printk(unsigned long ip, const char *fmt, ...)
         __attribute__ ((format (printf, 2, 3)));
+# define ftrace_vprintk(fmt, ap) __ftrace_printk(_THIS_IP_, fmt, ap)
+extern int
+__ftrace_vprintk(unsigned long ip, const char *fmt, va_list ap);
 extern void ftrace_dump(void);
 #else
 static inline void
@@ -313,6 +365,11 @@ ftrace_printk(const char *fmt, ...)
 {
         return 0;
 }
+static inline int
+ftrace_vprintk(const char *fmt, va_list ap)
+{
+        return 0;
+}
 static inline void ftrace_dump(void) { }
 #endif
 
@@ -327,36 +384,6 @@ ftrace_init_module(struct module *mod,
                    unsigned long *start, unsigned long *end) { }
 #endif
 
-enum {
-        POWER_NONE = 0,
-        POWER_CSTATE = 1,
-        POWER_PSTATE = 2,
-};
-
-struct power_trace {
-#ifdef CONFIG_POWER_TRACER
-        ktime_t                 stamp;
-        ktime_t                 end;
-        int                     type;
-        int                     state;
-#endif
-};
-
-#ifdef CONFIG_POWER_TRACER
-extern void trace_power_start(struct power_trace *it, unsigned int type,
-                                        unsigned int state);
-extern void trace_power_mark(struct power_trace *it, unsigned int type,
-                                        unsigned int state);
-extern void trace_power_end(struct power_trace *it);
-#else
-static inline void trace_power_start(struct power_trace *it, unsigned int type,
-                                        unsigned int state) { }
-static inline void trace_power_mark(struct power_trace *it, unsigned int type,
-                                        unsigned int state) { }
-static inline void trace_power_end(struct power_trace *it) { }
-#endif
-
-
 /*
  * Structure that defines an entry function trace.
  */
@@ -380,6 +407,30 @@ struct ftrace_graph_ret {
 #ifdef CONFIG_FUNCTION_GRAPH_TRACER
 
 /*
+ * Stack of return addresses for functions
+ * of a thread.
+ * Used in struct thread_info
+ */
+struct ftrace_ret_stack {
+        unsigned long ret;
+        unsigned long func;
+        unsigned long long calltime;
+};
+
+/*
+ * Primary handler of a function return.
+ * It relays on ftrace_return_to_handler.
+ * Defined in entry_32/64.S
+ */
+extern void return_to_handler(void);
+
+extern int
+ftrace_push_return_trace(unsigned long ret, unsigned long long time,
+                         unsigned long func, int *depth);
+extern void
+ftrace_pop_return_trace(struct ftrace_graph_ret *trace, unsigned long *ret);
+
+/*
  * Sometimes we don't want to trace a function with the function
  * graph tracer but we want them to keep traced by the usual function
  * tracer if the function graph tracer is not configured.
@@ -492,4 +543,17 @@ static inline int test_tsk_trace_graph(struct task_struct *tsk)
 
 #endif /* CONFIG_TRACING */
 
+
+#ifdef CONFIG_HW_BRANCH_TRACER
+
+void trace_hw_branch(u64 from, u64 to);
+void trace_hw_branch_oops(void);
+
+#else /* CONFIG_HW_BRANCH_TRACER */
+
+static inline void trace_hw_branch(u64 from, u64 to) {}
+static inline void trace_hw_branch_oops(void) {}
+
+#endif /* CONFIG_HW_BRANCH_TRACER */
+
 #endif /* _LINUX_FTRACE_H */
diff --git a/include/linux/ftrace_irq.h b/include/linux/ftrace_irq.h
index 366a054d0b05..dca7bf8cffe2 100644
--- a/include/linux/ftrace_irq.h
+++ b/include/linux/ftrace_irq.h
@@ -2,7 +2,7 @@
 #define _LINUX_FTRACE_IRQ_H
 
 
-#if defined(CONFIG_DYNAMIC_FTRACE) || defined(CONFIG_FUNCTION_GRAPH_TRACER)
+#ifdef CONFIG_FTRACE_NMI_ENTER
 extern void ftrace_nmi_enter(void);
 extern void ftrace_nmi_exit(void);
 #else
diff --git a/include/linux/hardirq.h b/include/linux/hardirq.h
index f83288347dda..faa1cf848bcd 100644
--- a/include/linux/hardirq.h
+++ b/include/linux/hardirq.h
@@ -15,55 +15,61 @@
  * - bits 0-7 are the preemption count (max preemption depth: 256)
  * - bits 8-15 are the softirq count (max # of softirqs: 256)
  *
- * The hardirq count can be overridden per architecture, the default is:
+ * The hardirq count can in theory reach the same as NR_IRQS.
+ * In reality, the number of nested IRQS is limited to the stack
+ * size as well. For archs with over 1000 IRQS it is not practical
+ * to expect that they will all nest. We give a max of 10 bits for
+ * hardirq nesting. An arch may choose to give less than 10 bits.
+ * m68k expects it to be 8.
  *
- * - bits 16-27 are the hardirq count (max # of hardirqs: 4096)
- * - ( bit 28 is the PREEMPT_ACTIVE flag. )
+ * - bits 16-25 are the hardirq count (max # of nested hardirqs: 1024)
+ * - bit 26 is the NMI_MASK
+ * - bit 28 is the PREEMPT_ACTIVE flag
  *
  * PREEMPT_MASK: 0x000000ff
  * SOFTIRQ_MASK: 0x0000ff00
- * HARDIRQ_MASK: 0x0fff0000
+ * HARDIRQ_MASK: 0x03ff0000
+ *     NMI_MASK: 0x04000000
  */
 #define PREEMPT_BITS    8
 #define SOFTIRQ_BITS    8
+#define NMI_BITS        1
 
-#ifndef HARDIRQ_BITS
-#define HARDIRQ_BITS    12
+#define MAX_HARDIRQ_BITS 10
 
-#ifndef MAX_HARDIRQS_PER_CPU
-#define MAX_HARDIRQS_PER_CPU NR_IRQS
+#ifndef HARDIRQ_BITS
+# define HARDIRQ_BITS   MAX_HARDIRQ_BITS
 #endif
 
-/*
- * The hardirq mask has to be large enough to have space for potentially
- * all IRQ sources in the system nesting on a single CPU.
- */
-#if (1 << HARDIRQ_BITS) < MAX_HARDIRQS_PER_CPU
-# error HARDIRQ_BITS is too low!
-#endif
+#if HARDIRQ_BITS > MAX_HARDIRQ_BITS
+#error HARDIRQ_BITS too high!
 #endif
 
 #define PREEMPT_SHIFT   0
 #define SOFTIRQ_SHIFT   (PREEMPT_SHIFT + PREEMPT_BITS)
 #define HARDIRQ_SHIFT   (SOFTIRQ_SHIFT + SOFTIRQ_BITS)
+#define NMI_SHIFT       (HARDIRQ_SHIFT + HARDIRQ_BITS)
 
 #define __IRQ_MASK(x)   ((1UL << (x))-1)
 
 #define PREEMPT_MASK    (__IRQ_MASK(PREEMPT_BITS) << PREEMPT_SHIFT)
 #define SOFTIRQ_MASK    (__IRQ_MASK(SOFTIRQ_BITS) << SOFTIRQ_SHIFT)
 #define HARDIRQ_MASK    (__IRQ_MASK(HARDIRQ_BITS) << HARDIRQ_SHIFT)
+#define NMI_MASK        (__IRQ_MASK(NMI_BITS)     << NMI_SHIFT)
 
 #define PREEMPT_OFFSET  (1UL << PREEMPT_SHIFT)
 #define SOFTIRQ_OFFSET  (1UL << SOFTIRQ_SHIFT)
 #define HARDIRQ_OFFSET  (1UL << HARDIRQ_SHIFT)
+#define NMI_OFFSET      (1UL << NMI_SHIFT)
 
-#if PREEMPT_ACTIVE < (1 << (HARDIRQ_SHIFT + HARDIRQ_BITS))
+#if PREEMPT_ACTIVE < (1 << (NMI_SHIFT + NMI_BITS))
 #error PREEMPT_ACTIVE is too low!
 #endif
 
 #define hardirq_count() (preempt_count() & HARDIRQ_MASK)
 #define softirq_count() (preempt_count() & SOFTIRQ_MASK)
-#define irq_count()     (preempt_count() & (HARDIRQ_MASK | SOFTIRQ_MASK))
+#define irq_count()     (preempt_count() & (HARDIRQ_MASK | SOFTIRQ_MASK \
+                                 | NMI_MASK))
 
 /*
  * Are we doing bottom half or hardware interrupt processing?
@@ -73,6 +79,11 @@
 #define in_softirq()            (softirq_count())
 #define in_interrupt()          (irq_count())
 
+/*
+ * Are we in NMI context?
+ */
+#define in_nmi()        (preempt_count() & NMI_MASK)
+
 #if defined(CONFIG_PREEMPT)
 # define PREEMPT_INATOMIC_BASE kernel_locked()
 # define PREEMPT_CHECK_OFFSET 1
@@ -164,20 +175,24 @@ extern void irq_enter(void);
  */
 extern void irq_exit(void);
 
-#define nmi_enter()                             \
-        do {                                    \
-                ftrace_nmi_enter();             \
-                lockdep_off();                  \
-                rcu_nmi_enter();                \
-                __irq_enter();                  \
+#define nmi_enter()                                             \
+        do {                                                    \
+                ftrace_nmi_enter();                             \
+                BUG_ON(in_nmi());                               \
+                add_preempt_count(NMI_OFFSET + HARDIRQ_OFFSET); \
+                lockdep_off();                                  \
+                rcu_nmi_enter();                                \
+                trace_hardirq_enter();                          \
         } while (0)
 
-#define nmi_exit()                              \
-        do {                                    \
-                __irq_exit();                   \
-                rcu_nmi_exit();                 \
-                lockdep_on();                   \
-                ftrace_nmi_exit();              \
+#define nmi_exit()                                              \
+        do {                                                    \
+                trace_hardirq_exit();                           \
+                rcu_nmi_exit();                                 \
+                lockdep_on();                                   \
+                BUG_ON(!in_nmi());                              \
+                sub_preempt_count(NMI_OFFSET + HARDIRQ_OFFSET); \
+                ftrace_nmi_exit();                              \
         } while (0)
 
 #endif /* LINUX_HARDIRQ_H */
diff --git a/include/linux/ring_buffer.h b/include/linux/ring_buffer.h
index b3b359660082..f5e793d69bd3 100644
--- a/include/linux/ring_buffer.h
+++ b/include/linux/ring_buffer.h
@@ -8,7 +8,7 @@ struct ring_buffer;
 struct ring_buffer_iter;
 
 /*
- * Don't reference this struct directly, use functions below.
+ * Don't refer to this struct directly, use functions below.
  */
 struct ring_buffer_event {
         u32             type:2, len:3, time_delta:27;
@@ -74,13 +74,10 @@ void ring_buffer_free(struct ring_buffer *buffer);
 
 int ring_buffer_resize(struct ring_buffer *buffer, unsigned long size);
 
-struct ring_buffer_event *
-ring_buffer_lock_reserve(struct ring_buffer *buffer,
-                         unsigned long length,
-                         unsigned long *flags);
+struct ring_buffer_event *ring_buffer_lock_reserve(struct ring_buffer *buffer,
+                                                   unsigned long length);
 int ring_buffer_unlock_commit(struct ring_buffer *buffer,
-                              struct ring_buffer_event *event,
-                              unsigned long flags);
+                              struct ring_buffer_event *event);
 int ring_buffer_write(struct ring_buffer *buffer,
                       unsigned long length, void *data);
 
@@ -124,9 +121,20 @@ unsigned long ring_buffer_overrun_cpu(struct ring_buffer *buffer, int cpu);
 u64 ring_buffer_time_stamp(int cpu);
 void ring_buffer_normalize_time_stamp(int cpu, u64 *ts);
 
+/*
+ * The below functions are fine to use outside the tracing facility.
+ */
+#ifdef CONFIG_RING_BUFFER
 void tracing_on(void);
 void tracing_off(void);
 void tracing_off_permanent(void);
+int tracing_is_on(void);
+#else
+static inline void tracing_on(void) { }
+static inline void tracing_off(void) { }
+static inline void tracing_off_permanent(void) { }
+static inline int tracing_is_on(void) { return 0; }
+#endif
 
 void *ring_buffer_alloc_read_page(struct ring_buffer *buffer);
 void ring_buffer_free_read_page(struct ring_buffer *buffer, void *data);
diff --git a/include/linux/sched.h b/include/linux/sched.h
index 8981e52c714f..426666dd8203 100644
--- a/include/linux/sched.h
+++ b/include/linux/sched.h
@@ -137,6 +137,8 @@ extern unsigned long nr_uninterruptible(void);
 extern unsigned long nr_active(void);
 extern unsigned long nr_iowait(void);
 
+extern unsigned long get_parent_ip(unsigned long addr);
+
 struct seq_file;
 struct cfs_rq;
 struct task_group;
diff --git a/include/linux/slab_def.h b/include/linux/slab_def.h
index 6ca6a7b66d75..f4523651fa42 100644
--- a/include/linux/slab_def.h
+++ b/include/linux/slab_def.h
@@ -14,6 +14,7 @@
 #include <asm/page.h>           /* kmalloc_sizes.h needs PAGE_SIZE */
 #include <asm/cache.h>          /* kmalloc_sizes.h needs L1_CACHE_BYTES */
 #include <linux/compiler.h>
+#include <trace/kmemtrace.h>
 
 /* Size description struct for general caches. */
 struct cache_sizes {
@@ -28,8 +29,26 @@ extern struct cache_sizes malloc_sizes[];
 void *kmem_cache_alloc(struct kmem_cache *, gfp_t);
 void *__kmalloc(size_t size, gfp_t flags);
 
-static inline void *kmalloc(size_t size, gfp_t flags)
+#ifdef CONFIG_KMEMTRACE
+extern void *kmem_cache_alloc_notrace(struct kmem_cache *cachep, gfp_t flags);
+extern size_t slab_buffer_size(struct kmem_cache *cachep);
+#else
+static __always_inline void *
+kmem_cache_alloc_notrace(struct kmem_cache *cachep, gfp_t flags)
 {
+        return kmem_cache_alloc(cachep, flags);
+}
+static inline size_t slab_buffer_size(struct kmem_cache *cachep)
+{
+        return 0;
+}
+#endif
+
+static __always_inline void *kmalloc(size_t size, gfp_t flags)
+{
+        struct kmem_cache *cachep;
+        void *ret;
+
         if (__builtin_constant_p(size)) {
                 int i = 0;
 
@@ -47,10 +66,17 @@ static inline void *kmalloc(size_t size, gfp_t flags)
 found:
 #ifdef CONFIG_ZONE_DMA
                 if (flags & GFP_DMA)
-                        return kmem_cache_alloc(malloc_sizes[i].cs_dmacachep,
-                                                flags);
+                        cachep = malloc_sizes[i].cs_dmacachep;
+                else
 #endif
-                return kmem_cache_alloc(malloc_sizes[i].cs_cachep, flags);
+                        cachep = malloc_sizes[i].cs_cachep;
+
+                ret = kmem_cache_alloc_notrace(cachep, flags);
+
+                kmemtrace_mark_alloc(KMEMTRACE_TYPE_KMALLOC, _THIS_IP_, ret,
+                                     size, slab_buffer_size(cachep), flags);
+
+                return ret;
         }
         return __kmalloc(size, flags);
 }
@@ -59,8 +85,25 @@ found:
 extern void *__kmalloc_node(size_t size, gfp_t flags, int node);
 extern void *kmem_cache_alloc_node(struct kmem_cache *, gfp_t flags, int node);
 
-static inline void *kmalloc_node(size_t size, gfp_t flags, int node)
+#ifdef CONFIG_KMEMTRACE
+extern void *kmem_cache_alloc_node_notrace(struct kmem_cache *cachep,
+                                           gfp_t flags,
+                                           int nodeid);
+#else
+static __always_inline void *
+kmem_cache_alloc_node_notrace(struct kmem_cache *cachep,
+                              gfp_t flags,
+                              int nodeid)
+{
+        return kmem_cache_alloc_node(cachep, flags, nodeid);
+}
+#endif
+
+static __always_inline void *kmalloc_node(size_t size, gfp_t flags, int node)
 {
+        struct kmem_cache *cachep;
+        void *ret;
+
         if (__builtin_constant_p(size)) {
                 int i = 0;
 
@@ -78,11 +121,18 @@ static inline void *kmalloc_node(size_t size, gfp_t flags, int node)
 found:
 #ifdef CONFIG_ZONE_DMA
                 if (flags & GFP_DMA)
-                        return kmem_cache_alloc_node(malloc_sizes[i].cs_dmacachep,
-                                                flags, node);
+                        cachep = malloc_sizes[i].cs_dmacachep;
+                else
 #endif
-                return kmem_cache_alloc_node(malloc_sizes[i].cs_cachep,
-                                                flags, node);
+                        cachep = malloc_sizes[i].cs_cachep;
+
+                ret = kmem_cache_alloc_node_notrace(cachep, flags, node);
+
+                kmemtrace_mark_alloc_node(KMEMTRACE_TYPE_KMALLOC, _THIS_IP_,
+                                          ret, size, slab_buffer_size(cachep),
+                                          flags, node);
+
+                return ret;
         }
         return __kmalloc_node(size, flags, node);
 }
diff --git a/include/linux/slob_def.h b/include/linux/slob_def.h
index 59a3fa476ab9..0ec00b39d006 100644
--- a/include/linux/slob_def.h
+++ b/include/linux/slob_def.h
@@ -3,14 +3,15 @@
 
 void *kmem_cache_alloc_node(struct kmem_cache *, gfp_t flags, int node);
 
-static inline void *kmem_cache_alloc(struct kmem_cache *cachep, gfp_t flags)
+static __always_inline void *kmem_cache_alloc(struct kmem_cache *cachep,
+                                              gfp_t flags)
 {
         return kmem_cache_alloc_node(cachep, flags, -1);
 }
 
 void *__kmalloc_node(size_t size, gfp_t flags, int node);
 
-static inline void *kmalloc_node(size_t size, gfp_t flags, int node)
+static __always_inline void *kmalloc_node(size_t size, gfp_t flags, int node)
 {
         return __kmalloc_node(size, flags, node);
 }
@@ -23,12 +24,12 @@ static inline void *kmalloc_node(size_t size, gfp_t flags, int node)
  * kmalloc is the normal method of allocating memory
  * in the kernel.
  */
-static inline void *kmalloc(size_t size, gfp_t flags)
+static __always_inline void *kmalloc(size_t size, gfp_t flags)
 {
         return __kmalloc_node(size, flags, -1);
 }
 
-static inline void *__kmalloc(size_t size, gfp_t flags)
+static __always_inline void *__kmalloc(size_t size, gfp_t flags)
 {
         return kmalloc(size, flags);
 }
diff --git a/include/linux/slub_def.h b/include/linux/slub_def.h
index 2f5c16b1aacd..9e3a575b2c30 100644
--- a/include/linux/slub_def.h
+++ b/include/linux/slub_def.h
@@ -10,6 +10,7 @@
 #include <linux/gfp.h>
 #include <linux/workqueue.h>
 #include <linux/kobject.h>
+#include <trace/kmemtrace.h>
 
 enum stat_item {
         ALLOC_FASTPATH,         /* Allocation from cpu slab */
@@ -121,10 +122,23 @@ struct kmem_cache {
 #define KMALLOC_SHIFT_LOW ilog2(KMALLOC_MIN_SIZE)
 
 /*
+ * Maximum kmalloc object size handled by SLUB. Larger object allocations
+ * are passed through to the page allocator. The page allocator "fastpath"
+ * is relatively slow so we need this value sufficiently high so that
+ * performance critical objects are allocated through the SLUB fastpath.
+ *
+ * This should be dropped to PAGE_SIZE / 2 once the page allocator
+ * "fastpath" becomes competitive with the slab allocator fastpaths.
+ */
+#define SLUB_MAX_SIZE (PAGE_SIZE)
+
+#define SLUB_PAGE_SHIFT (PAGE_SHIFT + 1)
+
+/*
  * We keep the general caches in an array of slab caches that are used for
  * 2^x bytes of allocations.
  */
-extern struct kmem_cache kmalloc_caches[PAGE_SHIFT + 1];
+extern struct kmem_cache kmalloc_caches[SLUB_PAGE_SHIFT];
 
 /*
  * Sorry that the following has to be that ugly but some versions of GCC
@@ -204,15 +218,33 @@ static __always_inline struct kmem_cache *kmalloc_slab(size_t size)
 void *kmem_cache_alloc(struct kmem_cache *, gfp_t);
 void *__kmalloc(size_t size, gfp_t flags);
 
+#ifdef CONFIG_KMEMTRACE
+extern void *kmem_cache_alloc_notrace(struct kmem_cache *s, gfp_t gfpflags);
+#else
+static __always_inline void *
+kmem_cache_alloc_notrace(struct kmem_cache *s, gfp_t gfpflags)
+{
+        return kmem_cache_alloc(s, gfpflags);
+}
+#endif
+
 static __always_inline void *kmalloc_large(size_t size, gfp_t flags)
 {
-        return (void *)__get_free_pages(flags | __GFP_COMP, get_order(size));
+        unsigned int order = get_order(size);
+        void *ret = (void *) __get_free_pages(flags | __GFP_COMP, order);
+
+        kmemtrace_mark_alloc(KMEMTRACE_TYPE_KMALLOC, _THIS_IP_, ret,
+                             size, PAGE_SIZE << order, flags);
+
+        return ret;
 }
 
 static __always_inline void *kmalloc(size_t size, gfp_t flags)
 {
+        void *ret;
+
         if (__builtin_constant_p(size)) {
-                if (size > PAGE_SIZE)
+                if (size > SLUB_MAX_SIZE)
                         return kmalloc_large(size, flags);
 
                 if (!(flags & SLUB_DMA)) {
@@ -221,7 +253,13 @@ static __always_inline void *kmalloc(size_t size, gfp_t flags)
                         if (!s)
                                 return ZERO_SIZE_PTR;
 
-                        return kmem_cache_alloc(s, flags);
+                        ret = kmem_cache_alloc_notrace(s, flags);
+
+                        kmemtrace_mark_alloc(KMEMTRACE_TYPE_KMALLOC,
+                                             _THIS_IP_, ret,
+                                             size, s->size, flags);
+
+                        return ret;
                 }
         }
         return __kmalloc(size, flags);
@@ -231,16 +269,38 @@ static __always_inline void *kmalloc(size_t size, gfp_t flags)
 void *__kmalloc_node(size_t size, gfp_t flags, int node);
 void *kmem_cache_alloc_node(struct kmem_cache *, gfp_t flags, int node);
 
+#ifdef CONFIG_KMEMTRACE
+extern void *kmem_cache_alloc_node_notrace(struct kmem_cache *s,
+                                           gfp_t gfpflags,
+                                           int node);
+#else
+static __always_inline void *
+kmem_cache_alloc_node_notrace(struct kmem_cache *s,
+                              gfp_t gfpflags,
+                              int node)
+{
+        return kmem_cache_alloc_node(s, gfpflags, node);
+}
+#endif
+
 static __always_inline void *kmalloc_node(size_t size, gfp_t flags, int node)
 {
+        void *ret;
+
         if (__builtin_constant_p(size) &&
-                size <= PAGE_SIZE && !(flags & SLUB_DMA)) {
+                size <= SLUB_MAX_SIZE && !(flags & SLUB_DMA)) {
                         struct kmem_cache *s = kmalloc_slab(size);
 
                 if (!s)
                         return ZERO_SIZE_PTR;
 
-                return kmem_cache_alloc_node(s, flags, node);
+                ret = kmem_cache_alloc_node_notrace(s, flags, node);
+
+                kmemtrace_mark_alloc_node(KMEMTRACE_TYPE_KMALLOC,
+                                          _THIS_IP_, ret,
+                                          size, s->size, flags, node);
+
+                return ret;
         }
         return __kmalloc_node(size, flags, node);
 }
diff --git a/include/linux/tracepoint.h b/include/linux/tracepoint.h
index 757005458366..34ae464effff 100644
--- a/include/linux/tracepoint.h
+++ b/include/linux/tracepoint.h
@@ -153,4 +153,7 @@ static inline void tracepoint_synchronize_unregister(void)
         synchronize_sched();
 }
 
+#define DEFINE_TRACE_FMT(name, proto, args, fmt)                \
+        DECLARE_TRACE(name, TPPROTO(proto), TPARGS(args))
+
 #endif
diff --git a/include/trace/kmemtrace.h b/include/trace/kmemtrace.h
new file mode 100644
index 000000000000..ad8b7857855a
--- /dev/null
+++ b/include/trace/kmemtrace.h
@@ -0,0 +1,75 @@
+/*
+ * 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/types.h>
+#include <linux/marker.h>
+
+enum kmemtrace_type_id {
+        KMEMTRACE_TYPE_KMALLOC = 0,     /* kmalloc() or kfree(). */
+        KMEMTRACE_TYPE_CACHE,           /* kmem_cache_*(). */
+        KMEMTRACE_TYPE_PAGES,           /* __get_free_pages() and friends. */
+};
+
+#ifdef CONFIG_KMEMTRACE
+
+extern void kmemtrace_init(void);
+
+extern void kmemtrace_mark_alloc_node(enum kmemtrace_type_id type_id,
+                                             unsigned long call_site,
+                                             const void *ptr,
+                                             size_t bytes_req,
+                                             size_t bytes_alloc,
+                                             gfp_t gfp_flags,
+                                             int node);
+
+extern void kmemtrace_mark_free(enum kmemtrace_type_id type_id,
+                                       unsigned long call_site,
+                                       const void *ptr);
+
+#else /* CONFIG_KMEMTRACE */
+
+static inline void kmemtrace_init(void)
+{
+}
+
+static inline void kmemtrace_mark_alloc_node(enum kmemtrace_type_id type_id,
+                                             unsigned long call_site,
+                                             const void *ptr,
+                                             size_t bytes_req,
+                                             size_t bytes_alloc,
+                                             gfp_t gfp_flags,
+                                             int node)
+{
+}
+
+static inline void kmemtrace_mark_free(enum kmemtrace_type_id type_id,
+                                       unsigned long call_site,
+                                       const void *ptr)
+{
+}
+
+#endif /* CONFIG_KMEMTRACE */
+
+static inline void kmemtrace_mark_alloc(enum kmemtrace_type_id type_id,
+                                        unsigned long call_site,
+                                        const void *ptr,
+                                        size_t bytes_req,
+                                        size_t bytes_alloc,
+                                        gfp_t gfp_flags)
+{
+        kmemtrace_mark_alloc_node(type_id, call_site, ptr,
+                                  bytes_req, bytes_alloc, gfp_flags, -1);
+}
+
+#endif /* __KERNEL__ */
+
+#endif /* _LINUX_KMEMTRACE_H */
+
diff --git a/include/trace/power.h b/include/trace/power.h
new file mode 100644
index 000000000000..2c733e58e89c
--- /dev/null
+++ b/include/trace/power.h
@@ -0,0 +1,34 @@
+#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 {
+#ifdef CONFIG_POWER_TRACER
+        ktime_t                 stamp;
+        ktime_t                 end;
+        int                     type;
+        int                     state;
+#endif
+};
+
+DECLARE_TRACE(power_start,
+        TPPROTO(struct power_trace *it, unsigned int type, unsigned int state),
+                TPARGS(it, type, state));
+
+DECLARE_TRACE(power_mark,
+        TPPROTO(struct power_trace *it, unsigned int type, unsigned int state),
+                TPARGS(it, type, state));
+
+DECLARE_TRACE(power_end,
+        TPPROTO(struct power_trace *it),
+                TPARGS(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..a4f662940f4e
--- /dev/null
+++ b/include/trace/sched_event_types.h
@@ -0,0 +1,72 @@
+
+/* use <trace/sched.h> instead */
+#ifndef DEFINE_TRACE_FMT
+# error Do not include this file directly.
+# error Unless you know what you are doing.
+#endif
+
+DEFINE_TRACE_FMT(sched_kthread_stop,
+        TPPROTO(struct task_struct *t),
+        TPARGS(t),
+        TPFMT("task %s:%d", t->comm, t->pid));
+
+DEFINE_TRACE_FMT(sched_kthread_stop_ret,
+        TPPROTO(int ret),
+        TPARGS(ret),
+        TPFMT("ret=%d", ret));
+
+DEFINE_TRACE_FMT(sched_wait_task,
+        TPPROTO(struct rq *rq, struct task_struct *p),
+        TPARGS(rq, p),
+        TPFMT("task %s:%d", p->comm, p->pid));
+
+DEFINE_TRACE_FMT(sched_wakeup,
+        TPPROTO(struct rq *rq, struct task_struct *p, int success),
+        TPARGS(rq, p, success),
+        TPFMT("task %s:%d %s",
+              p->comm, p->pid, success?"succeeded":"failed"));
+
+DEFINE_TRACE_FMT(sched_wakeup_new,
+        TPPROTO(struct rq *rq, struct task_struct *p, int success),
+        TPARGS(rq, p, success),
+        TPFMT("task %s:%d",
+              p->comm, p->pid, success?"succeeded":"failed"));
+
+DEFINE_TRACE_FMT(sched_switch,
+        TPPROTO(struct rq *rq, struct task_struct *prev,
+                struct task_struct *next),
+        TPARGS(rq, prev, next),
+        TPFMT("task %s:%d ==> %s:%d",
+              prev->comm, prev->pid, next->comm, next->pid));
+
+DEFINE_TRACE_FMT(sched_migrate_task,
+        TPPROTO(struct task_struct *p, int orig_cpu, int dest_cpu),
+        TPARGS(p, orig_cpu, dest_cpu),
+        TPFMT("task %s:%d from: %d  to: %d",
+              p->comm, p->pid, orig_cpu, dest_cpu));
+
+DEFINE_TRACE_FMT(sched_process_free,
+        TPPROTO(struct task_struct *p),
+        TPARGS(p),
+        TPFMT("task %s:%d", p->comm, p->pid));
+
+DEFINE_TRACE_FMT(sched_process_exit,
+        TPPROTO(struct task_struct *p),
+        TPARGS(p),
+        TPFMT("task %s:%d", p->comm, p->pid));
+
+DEFINE_TRACE_FMT(sched_process_wait,
+        TPPROTO(struct pid *pid),
+        TPARGS(pid),
+        TPFMT("pid %d", pid));
+
+DEFINE_TRACE_FMT(sched_process_fork,
+        TPPROTO(struct task_struct *parent, struct task_struct *child),
+        TPARGS(parent, child),
+        TPFMT("parent %s:%d  child %s:%d",
+              parent->comm, parent->pid, child->comm, child->pid));
+
+DEFINE_TRACE_FMT(sched_signal_send,
+        TPPROTO(int sig, struct task_struct *p),
+        TPARGS(sig, p),
+        TPFMT("sig: %d   task %s:%d", sig, p->comm, p->pid));
diff --git a/include/trace/workqueue.h b/include/trace/workqueue.h
new file mode 100644
index 000000000000..867829df4571
--- /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,
+           TPPROTO(struct task_struct *wq_thread, struct work_struct *work),
+           TPARGS(wq_thread, work));
+
+DECLARE_TRACE(workqueue_execution,
+           TPPROTO(struct task_struct *wq_thread, struct work_struct *work),
+           TPARGS(wq_thread, work));
+
+/* Trace the creation of one workqueue thread on a cpu */
+DECLARE_TRACE(workqueue_creation,
+           TPPROTO(struct task_struct *wq_thread, int cpu),
+           TPARGS(wq_thread, cpu));
+
+DECLARE_TRACE(workqueue_destruction,
+           TPPROTO(struct task_struct *wq_thread),
+           TPARGS(wq_thread));
+
+#endif /* __TRACE_WORKQUEUE_H */