11 files changed, 512 insertions, 64 deletions

diff --git a/kernel/trace/Kconfig b/kernel/trace/Kconfig
index e2a4ff6fc3a6..1c0b7504cab3 100644
--- a/kernel/trace/Kconfig
+++ b/kernel/trace/Kconfig
@@ -264,6 +264,27 @@ config HW_BRANCH_TRACER
           This tracer records all branches on the system in a circular
           buffer giving access to the last N branches for each cpu.
 
+config KMEMTRACE
+        bool "Trace SLAB allocations"
+        select TRACING
+        help
+          kmemtrace provides tracing for slab allocator functions, such as
+          kmalloc, kfree, kmem_cache_alloc, kmem_cache_free etc.. Collected
+          data is then fed to the userspace application in order to analyse
+          allocation hotspots, internal fragmentation and so on, making it
+          possible to see how well an allocator performs, as well as debug
+          and profile kernel code.
+
+          This requires an userspace application to use. See
+          Documentation/vm/kmemtrace.txt for more information.
+
+          Saying Y will make the kernel somewhat larger and slower. However,
+          if you disable kmemtrace at run-time or boot-time, the performance
+          impact is minimal (depending on the arch the kernel is built for).
+
+          If unsure, say N.
+
+
 config DYNAMIC_FTRACE
         bool "enable/disable ftrace tracepoints dynamically"
         depends on FUNCTION_TRACER
diff --git a/kernel/trace/Makefile b/kernel/trace/Makefile
index 31cd5fbc0eed..05c9182061de 100644
--- a/kernel/trace/Makefile
+++ b/kernel/trace/Makefile
@@ -35,5 +35,6 @@ obj-$(CONFIG_FUNCTION_GRAPH_TRACER) += trace_functions_graph.o
 obj-$(CONFIG_TRACE_BRANCH_PROFILING) += trace_branch.o
 obj-$(CONFIG_HW_BRANCH_TRACER) += trace_hw_branches.o
 obj-$(CONFIG_POWER_TRACER) += trace_power.o
+obj-$(CONFIG_KMEMTRACE) += kmemtrace.o
 
 libftrace-y := ftrace.o
diff --git a/kernel/trace/kmemtrace.c b/kernel/trace/kmemtrace.c
new file mode 100644
index 000000000000..faaa5ae7e75a
--- /dev/null
+++ b/kernel/trace/kmemtrace.c
@@ -0,0 +1,350 @@
+/*
+ * Memory allocator tracing
+ *
+ * Copyright (C) 2008 Eduard - Gabriel Munteanu
+ * Copyright (C) 2008 Pekka Enberg <penberg@cs.helsinki.fi>
+ * Copyright (C) 2008 Frederic Weisbecker <fweisbec@gmail.com>
+ */
+
+#include <linux/dcache.h>
+#include <linux/debugfs.h>
+#include <linux/fs.h>
+#include <linux/seq_file.h>
+#include <trace/kmemtrace.h>
+
+#include "trace.h"
+#include "trace_output.h"
+
+/* Select an alternative, minimalistic output than the original one */
+#define TRACE_KMEM_OPT_MINIMAL  0x1
+
+static struct tracer_opt kmem_opts[] = {
+        /* Default disable the minimalistic output */
+        { TRACER_OPT(kmem_minimalistic, TRACE_KMEM_OPT_MINIMAL) },
+        { }
+};
+
+static struct tracer_flags kmem_tracer_flags = {
+        .val = 0,
+        .opts = kmem_opts
+};
+
+
+static bool kmem_tracing_enabled __read_mostly;
+static struct trace_array *kmemtrace_array;
+
+static int kmem_trace_init(struct trace_array *tr)
+{
+        int cpu;
+        kmemtrace_array = tr;
+
+        for_each_cpu_mask(cpu, cpu_possible_map)
+                tracing_reset(tr, cpu);
+
+        kmem_tracing_enabled = true;
+
+        return 0;
+}
+
+static void kmem_trace_reset(struct trace_array *tr)
+{
+        kmem_tracing_enabled = false;
+}
+
+static void kmemtrace_headers(struct seq_file *s)
+{
+        /* Don't need headers for the original kmemtrace output */
+        if (!(kmem_tracer_flags.val & TRACE_KMEM_OPT_MINIMAL))
+                return;
+
+        seq_printf(s, "#\n");
+        seq_printf(s, "# ALLOC  TYPE  REQ   GIVEN  FLAGS     "
+                        "      POINTER         NODE    CALLER\n");
+        seq_printf(s, "# FREE   |      |     |       |       "
+                        "       |   |            |        |\n");
+        seq_printf(s, "# |\n\n");
+}
+
+/*
+ * The two following functions give the original output from kmemtrace,
+ * or something close to....perhaps they need some missing things
+ */
+static enum print_line_t
+kmemtrace_print_alloc_original(struct trace_iterator *iter,
+                                struct kmemtrace_alloc_entry *entry)
+{
+        struct trace_seq *s = &iter->seq;
+        int ret;
+
+        /* Taken from the old linux/kmemtrace.h */
+        ret = trace_seq_printf(s, "type_id %d call_site %lu ptr %lu "
+          "bytes_req %lu bytes_alloc %lu gfp_flags %lu node %d\n",
+           entry->type_id, entry->call_site, (unsigned long) entry->ptr,
+           (unsigned long) entry->bytes_req, (unsigned long) entry->bytes_alloc,
+           (unsigned long) entry->gfp_flags, entry->node);
+
+        if (!ret)
+                return TRACE_TYPE_PARTIAL_LINE;
+
+        return TRACE_TYPE_HANDLED;
+}
+
+static enum print_line_t
+kmemtrace_print_free_original(struct trace_iterator *iter,
+                                struct kmemtrace_free_entry *entry)
+{
+        struct trace_seq *s = &iter->seq;
+        int ret;
+
+        /* Taken from the old linux/kmemtrace.h */
+        ret = trace_seq_printf(s, "type_id %d call_site %lu ptr %lu\n",
+           entry->type_id, entry->call_site, (unsigned long) entry->ptr);
+
+        if (!ret)
+                return TRACE_TYPE_PARTIAL_LINE;
+
+        return TRACE_TYPE_HANDLED;
+}
+
+
+/* The two other following provide a more minimalistic output */
+static enum print_line_t
+kmemtrace_print_alloc_compress(struct trace_iterator *iter,
+                                        struct kmemtrace_alloc_entry *entry)
+{
+        struct trace_seq *s = &iter->seq;
+        int ret;
+
+        /* Alloc entry */
+        ret = trace_seq_printf(s, "  +      ");
+        if (!ret)
+                return TRACE_TYPE_PARTIAL_LINE;
+
+        /* Type */
+        switch (entry->type_id) {
+        case KMEMTRACE_TYPE_KMALLOC:
+                ret = trace_seq_printf(s, "K   ");
+                break;
+        case KMEMTRACE_TYPE_CACHE:
+                ret = trace_seq_printf(s, "C   ");
+                break;
+        case KMEMTRACE_TYPE_PAGES:
+                ret = trace_seq_printf(s, "P   ");
+                break;
+        default:
+                ret = trace_seq_printf(s, "?   ");
+        }
+
+        if (!ret)
+                return TRACE_TYPE_PARTIAL_LINE;
+
+        /* Requested */
+        ret = trace_seq_printf(s, "%4d   ", entry->bytes_req);
+        if (!ret)
+                return TRACE_TYPE_PARTIAL_LINE;
+
+        /* Allocated */
+        ret = trace_seq_printf(s, "%4d   ", entry->bytes_alloc);
+        if (!ret)
+                return TRACE_TYPE_PARTIAL_LINE;
+
+        /* Flags
+         * TODO: would be better to see the name of the GFP flag names
+         */
+        ret = trace_seq_printf(s, "%08x   ", entry->gfp_flags);
+        if (!ret)
+                return TRACE_TYPE_PARTIAL_LINE;
+
+        /* Pointer to allocated */
+        ret = trace_seq_printf(s, "0x%tx   ", (ptrdiff_t)entry->ptr);
+        if (!ret)
+                return TRACE_TYPE_PARTIAL_LINE;
+
+        /* Node */
+        ret = trace_seq_printf(s, "%4d   ", entry->node);
+        if (!ret)
+                return TRACE_TYPE_PARTIAL_LINE;
+
+        /* Call site */
+        ret = seq_print_ip_sym(s, entry->call_site, 0);
+        if (!ret)
+                return TRACE_TYPE_PARTIAL_LINE;
+
+        if (!trace_seq_printf(s, "\n"))
+                return TRACE_TYPE_PARTIAL_LINE;
+
+        return TRACE_TYPE_HANDLED;
+}
+
+static enum print_line_t
+kmemtrace_print_free_compress(struct trace_iterator *iter,
+                                struct kmemtrace_free_entry *entry)
+{
+        struct trace_seq *s = &iter->seq;
+        int ret;
+
+        /* Free entry */
+        ret = trace_seq_printf(s, "  -      ");
+        if (!ret)
+                return TRACE_TYPE_PARTIAL_LINE;
+
+        /* Type */
+        switch (entry->type_id) {
+        case KMEMTRACE_TYPE_KMALLOC:
+                ret = trace_seq_printf(s, "K     ");
+                break;
+        case KMEMTRACE_TYPE_CACHE:
+                ret = trace_seq_printf(s, "C     ");
+                break;
+        case KMEMTRACE_TYPE_PAGES:
+                ret = trace_seq_printf(s, "P     ");
+                break;
+        default:
+                ret = trace_seq_printf(s, "?     ");
+        }
+
+        if (!ret)
+                return TRACE_TYPE_PARTIAL_LINE;
+
+        /* Skip requested/allocated/flags */
+        ret = trace_seq_printf(s, "                       ");
+        if (!ret)
+                return TRACE_TYPE_PARTIAL_LINE;
+
+        /* Pointer to allocated */
+        ret = trace_seq_printf(s, "0x%tx   ", (ptrdiff_t)entry->ptr);
+        if (!ret)
+                return TRACE_TYPE_PARTIAL_LINE;
+
+        /* Skip node */
+        ret = trace_seq_printf(s, "       ");
+        if (!ret)
+                return TRACE_TYPE_PARTIAL_LINE;
+
+        /* Call site */
+        ret = seq_print_ip_sym(s, entry->call_site, 0);
+        if (!ret)
+                return TRACE_TYPE_PARTIAL_LINE;
+
+        if (!trace_seq_printf(s, "\n"))
+                return TRACE_TYPE_PARTIAL_LINE;
+
+        return TRACE_TYPE_HANDLED;
+}
+
+static enum print_line_t kmemtrace_print_line(struct trace_iterator *iter)
+{
+        struct trace_entry *entry = iter->ent;
+
+        switch (entry->type) {
+        case TRACE_KMEM_ALLOC: {
+                struct kmemtrace_alloc_entry *field;
+                trace_assign_type(field, entry);
+                if (kmem_tracer_flags.val & TRACE_KMEM_OPT_MINIMAL)
+                        return kmemtrace_print_alloc_compress(iter, field);
+                else
+                        return kmemtrace_print_alloc_original(iter, field);
+        }
+
+        case TRACE_KMEM_FREE: {
+                struct kmemtrace_free_entry *field;
+                trace_assign_type(field, entry);
+                if (kmem_tracer_flags.val & TRACE_KMEM_OPT_MINIMAL)
+                        return kmemtrace_print_free_compress(iter, field);
+                else
+                        return kmemtrace_print_free_original(iter, field);
+        }
+
+        default:
+                return TRACE_TYPE_UNHANDLED;
+        }
+}
+
+/* Trace allocations */
+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)
+{
+        struct ring_buffer_event *event;
+        struct kmemtrace_alloc_entry *entry;
+        struct trace_array *tr = kmemtrace_array;
+        unsigned long irq_flags;
+
+        if (!kmem_tracing_enabled)
+                return;
+
+        event = ring_buffer_lock_reserve(tr->buffer, sizeof(*entry),
+                                         &irq_flags);
+        if (!event)
+                return;
+        entry   = ring_buffer_event_data(event);
+        tracing_generic_entry_update(&entry->ent, 0, 0);
+
+        entry->ent.type = TRACE_KMEM_ALLOC;
+        entry->call_site = call_site;
+        entry->ptr = ptr;
+        entry->bytes_req = bytes_req;
+        entry->bytes_alloc = bytes_alloc;
+        entry->gfp_flags = gfp_flags;
+        entry->node     =       node;
+
+        ring_buffer_unlock_commit(tr->buffer, event, irq_flags);
+
+        trace_wake_up();
+}
+EXPORT_SYMBOL(kmemtrace_mark_alloc_node);
+
+void kmemtrace_mark_free(enum kmemtrace_type_id type_id,
+                       unsigned long call_site,
+                       const void *ptr)
+{
+        struct ring_buffer_event *event;
+        struct kmemtrace_free_entry *entry;
+        struct trace_array *tr = kmemtrace_array;
+        unsigned long irq_flags;
+
+        if (!kmem_tracing_enabled)
+                return;
+
+        event = ring_buffer_lock_reserve(tr->buffer, sizeof(*entry),
+                                         &irq_flags);
+        if (!event)
+                return;
+        entry   = ring_buffer_event_data(event);
+        tracing_generic_entry_update(&entry->ent, 0, 0);
+
+        entry->ent.type = TRACE_KMEM_FREE;
+        entry->type_id  = type_id;
+        entry->call_site = call_site;
+        entry->ptr = ptr;
+
+        ring_buffer_unlock_commit(tr->buffer, event, irq_flags);
+
+        trace_wake_up();
+}
+EXPORT_SYMBOL(kmemtrace_mark_free);
+
+static struct tracer kmem_tracer __read_mostly = {
+        .name           = "kmemtrace",
+        .init           = kmem_trace_init,
+        .reset          = kmem_trace_reset,
+        .print_line     = kmemtrace_print_line,
+        .print_header = kmemtrace_headers,
+        .flags          = &kmem_tracer_flags
+};
+
+void kmemtrace_init(void)
+{
+        /* earliest opportunity to start kmem tracing */
+}
+
+static int __init init_kmem_tracer(void)
+{
+        return register_tracer(&kmem_tracer);
+}
+
+device_initcall(init_kmem_tracer);
diff --git a/kernel/trace/ring_buffer.c b/kernel/trace/ring_buffer.c
index 76f34c0ef29c..a9d9760dc7b6 100644
--- a/kernel/trace/ring_buffer.c
+++ b/kernel/trace/ring_buffer.c
@@ -69,6 +69,7 @@ void tracing_on(void)
 {
         set_bit(RB_BUFFERS_ON_BIT, &ring_buffer_flags);
 }
+EXPORT_SYMBOL_GPL(tracing_on);
 
 /**
  * tracing_off - turn off all tracing buffers
@@ -82,6 +83,7 @@ void tracing_off(void)
 {
         clear_bit(RB_BUFFERS_ON_BIT, &ring_buffer_flags);
 }
+EXPORT_SYMBOL_GPL(tracing_off);
 
 /**
  * tracing_off_permanent - permanently disable ring buffers
@@ -111,12 +113,14 @@ u64 ring_buffer_time_stamp(int cpu)
 
         return time;
 }
+EXPORT_SYMBOL_GPL(ring_buffer_time_stamp);
 
 void ring_buffer_normalize_time_stamp(int cpu, u64 *ts)
 {
         /* Just stupid testing the normalize function and deltas */
         *ts >>= DEBUG_SHIFT;
 }
+EXPORT_SYMBOL_GPL(ring_buffer_normalize_time_stamp);
 
 #define RB_EVNT_HDR_SIZE (sizeof(struct ring_buffer_event))
 #define RB_ALIGNMENT_SHIFT      2
@@ -166,6 +170,7 @@ unsigned ring_buffer_event_length(struct ring_buffer_event *event)
 {
         return rb_event_length(event);
 }
+EXPORT_SYMBOL_GPL(ring_buffer_event_length);
 
 /* inline for ring buffer fast paths */
 static inline void *
@@ -187,9 +192,10 @@ void *ring_buffer_event_data(struct ring_buffer_event *event)
 {
         return rb_event_data(event);
 }
+EXPORT_SYMBOL_GPL(ring_buffer_event_data);
 
 #define for_each_buffer_cpu(buffer, cpu)                \
-        for_each_cpu_mask(cpu, buffer->cpumask)
+        for_each_cpu(cpu, buffer->cpumask)
 
 #define TS_SHIFT        27
 #define TS_MASK         ((1ULL << TS_SHIFT) - 1)
@@ -261,7 +267,7 @@ struct ring_buffer {
         unsigned                        pages;
         unsigned                        flags;
         int                             cpus;
-        cpumask_t                       cpumask;
+        cpumask_var_t                   cpumask;
         atomic_t                        record_disabled;
 
         struct mutex                    mutex;
@@ -427,7 +433,7 @@ extern int ring_buffer_page_too_big(void);
 
 /**
  * ring_buffer_alloc - allocate a new ring_buffer
- * @size: the size in bytes that is needed.
+ * @size: the size in bytes per cpu that is needed.
  * @flags: attributes to set for the ring buffer.
  *
  * Currently the only flag that is available is the RB_FL_OVERWRITE
@@ -452,6 +458,9 @@ struct ring_buffer *ring_buffer_alloc(unsigned long size, unsigned flags)
         if (!buffer)
                 return NULL;
 
+        if (!alloc_cpumask_var(&buffer->cpumask, GFP_KERNEL))
+                goto fail_free_buffer;
+
         buffer->pages = DIV_ROUND_UP(size, BUF_PAGE_SIZE);
         buffer->flags = flags;
 
@@ -459,14 +468,14 @@ struct ring_buffer *ring_buffer_alloc(unsigned long size, unsigned flags)
         if (buffer->pages == 1)
                 buffer->pages++;
 
-        buffer->cpumask = cpu_possible_map;
+        cpumask_copy(buffer->cpumask, cpu_possible_mask);
         buffer->cpus = nr_cpu_ids;
 
         bsize = sizeof(void *) * nr_cpu_ids;
         buffer->buffers = kzalloc(ALIGN(bsize, cache_line_size()),
                                   GFP_KERNEL);
         if (!buffer->buffers)
-                goto fail_free_buffer;
+                goto fail_free_cpumask;
 
         for_each_buffer_cpu(buffer, cpu) {
                 buffer->buffers[cpu] =
@@ -486,10 +495,14 @@ struct ring_buffer *ring_buffer_alloc(unsigned long size, unsigned flags)
         }
         kfree(buffer->buffers);
 
+ fail_free_cpumask:
+        free_cpumask_var(buffer->cpumask);
+
  fail_free_buffer:
         kfree(buffer);
         return NULL;
 }
+EXPORT_SYMBOL_GPL(ring_buffer_alloc);
 
 /**
  * ring_buffer_free - free a ring buffer.
@@ -503,8 +516,11 @@ ring_buffer_free(struct ring_buffer *buffer)
         for_each_buffer_cpu(buffer, cpu)
                 rb_free_cpu_buffer(buffer->buffers[cpu]);
 
+        free_cpumask_var(buffer->cpumask);
+
         kfree(buffer);
 }
+EXPORT_SYMBOL_GPL(ring_buffer_free);
 
 static void rb_reset_cpu(struct ring_buffer_per_cpu *cpu_buffer);
 
@@ -680,6 +696,7 @@ int ring_buffer_resize(struct ring_buffer *buffer, unsigned long size)
         mutex_unlock(&buffer->mutex);
         return -ENOMEM;
 }
+EXPORT_SYMBOL_GPL(ring_buffer_resize);
 
 static inline int rb_null_event(struct ring_buffer_event *event)
 {
@@ -1274,7 +1291,7 @@ ring_buffer_lock_reserve(struct ring_buffer *buffer,
 
         cpu = raw_smp_processor_id();
 
-        if (!cpu_isset(cpu, buffer->cpumask))
+        if (!cpumask_test_cpu(cpu, buffer->cpumask))
                 goto out;
 
         cpu_buffer = buffer->buffers[cpu];
@@ -1304,6 +1321,7 @@ ring_buffer_lock_reserve(struct ring_buffer *buffer,
         ftrace_preempt_enable(resched);
         return NULL;
 }
+EXPORT_SYMBOL_GPL(ring_buffer_lock_reserve);
 
 static void rb_commit(struct ring_buffer_per_cpu *cpu_buffer,
                       struct ring_buffer_event *event)
@@ -1350,6 +1368,7 @@ int ring_buffer_unlock_commit(struct ring_buffer *buffer,
 
         return 0;
 }
+EXPORT_SYMBOL_GPL(ring_buffer_unlock_commit);
 
 /**
  * ring_buffer_write - write data to the buffer without reserving
@@ -1385,7 +1404,7 @@ int ring_buffer_write(struct ring_buffer *buffer,
 
         cpu = raw_smp_processor_id();
 
-        if (!cpu_isset(cpu, buffer->cpumask))
+        if (!cpumask_test_cpu(cpu, buffer->cpumask))
                 goto out;
 
         cpu_buffer = buffer->buffers[cpu];
@@ -1411,6 +1430,7 @@ int ring_buffer_write(struct ring_buffer *buffer,
 
         return ret;
 }
+EXPORT_SYMBOL_GPL(ring_buffer_write);
 
 static inline int rb_per_cpu_empty(struct ring_buffer_per_cpu *cpu_buffer)
 {
@@ -1437,6 +1457,7 @@ void ring_buffer_record_disable(struct ring_buffer *buffer)
 {
         atomic_inc(&buffer->record_disabled);
 }
+EXPORT_SYMBOL_GPL(ring_buffer_record_disable);
 
 /**
  * ring_buffer_record_enable - enable writes to the buffer
@@ -1449,6 +1470,7 @@ void ring_buffer_record_enable(struct ring_buffer *buffer)
 {
         atomic_dec(&buffer->record_disabled);
 }
+EXPORT_SYMBOL_GPL(ring_buffer_record_enable);
 
 /**
  * ring_buffer_record_disable_cpu - stop all writes into the cpu_buffer
@@ -1464,12 +1486,13 @@ void ring_buffer_record_disable_cpu(struct ring_buffer *buffer, int cpu)
 {
         struct ring_buffer_per_cpu *cpu_buffer;
 
-        if (!cpu_isset(cpu, buffer->cpumask))
+        if (!cpumask_test_cpu(cpu, buffer->cpumask))
                 return;
 
         cpu_buffer = buffer->buffers[cpu];
         atomic_inc(&cpu_buffer->record_disabled);
 }
+EXPORT_SYMBOL_GPL(ring_buffer_record_disable_cpu);
 
 /**
  * ring_buffer_record_enable_cpu - enable writes to the buffer
@@ -1483,12 +1506,13 @@ void ring_buffer_record_enable_cpu(struct ring_buffer *buffer, int cpu)
 {
         struct ring_buffer_per_cpu *cpu_buffer;
 
-        if (!cpu_isset(cpu, buffer->cpumask))
+        if (!cpumask_test_cpu(cpu, buffer->cpumask))
                 return;
 
         cpu_buffer = buffer->buffers[cpu];
         atomic_dec(&cpu_buffer->record_disabled);
 }
+EXPORT_SYMBOL_GPL(ring_buffer_record_enable_cpu);
 
 /**
  * ring_buffer_entries_cpu - get the number of entries in a cpu buffer
@@ -1499,12 +1523,13 @@ unsigned long ring_buffer_entries_cpu(struct ring_buffer *buffer, int cpu)
 {
         struct ring_buffer_per_cpu *cpu_buffer;
 
-        if (!cpu_isset(cpu, buffer->cpumask))
+        if (!cpumask_test_cpu(cpu, buffer->cpumask))
                 return 0;
 
         cpu_buffer = buffer->buffers[cpu];
         return cpu_buffer->entries;
 }
+EXPORT_SYMBOL_GPL(ring_buffer_entries_cpu);
 
 /**
  * ring_buffer_overrun_cpu - get the number of overruns in a cpu_buffer
@@ -1515,12 +1540,13 @@ unsigned long ring_buffer_overrun_cpu(struct ring_buffer *buffer, int cpu)
 {
         struct ring_buffer_per_cpu *cpu_buffer;
 
-        if (!cpu_isset(cpu, buffer->cpumask))
+        if (!cpumask_test_cpu(cpu, buffer->cpumask))
                 return 0;
 
         cpu_buffer = buffer->buffers[cpu];
         return cpu_buffer->overrun;
 }
+EXPORT_SYMBOL_GPL(ring_buffer_overrun_cpu);
 
 /**
  * ring_buffer_entries - get the number of entries in a buffer
@@ -1543,6 +1569,7 @@ unsigned long ring_buffer_entries(struct ring_buffer *buffer)
 
         return entries;
 }
+EXPORT_SYMBOL_GPL(ring_buffer_entries);
 
 /**
  * ring_buffer_overrun_cpu - get the number of overruns in buffer
@@ -1565,6 +1592,7 @@ unsigned long ring_buffer_overruns(struct ring_buffer *buffer)
 
         return overruns;
 }
+EXPORT_SYMBOL_GPL(ring_buffer_overruns);
 
 static void rb_iter_reset(struct ring_buffer_iter *iter)
 {
@@ -1600,6 +1628,7 @@ void ring_buffer_iter_reset(struct ring_buffer_iter *iter)
         rb_iter_reset(iter);
         spin_unlock_irqrestore(&cpu_buffer->reader_lock, flags);
 }
+EXPORT_SYMBOL_GPL(ring_buffer_iter_reset);
 
 /**
  * ring_buffer_iter_empty - check if an iterator has no more to read
@@ -1614,6 +1643,7 @@ int ring_buffer_iter_empty(struct ring_buffer_iter *iter)
         return iter->head_page == cpu_buffer->commit_page &&
                 iter->head == rb_commit_index(cpu_buffer);
 }
+EXPORT_SYMBOL_GPL(ring_buffer_iter_empty);
 
 static void
 rb_update_read_stamp(struct ring_buffer_per_cpu *cpu_buffer,
@@ -1828,7 +1858,7 @@ rb_buffer_peek(struct ring_buffer *buffer, int cpu, u64 *ts)
         struct buffer_page *reader;
         int nr_loops = 0;
 
-        if (!cpu_isset(cpu, buffer->cpumask))
+        if (!cpumask_test_cpu(cpu, buffer->cpumask))
                 return NULL;
 
         cpu_buffer = buffer->buffers[cpu];
@@ -1880,6 +1910,7 @@ rb_buffer_peek(struct ring_buffer *buffer, int cpu, u64 *ts)
 
         return NULL;
 }
+EXPORT_SYMBOL_GPL(ring_buffer_peek);
 
 static struct ring_buffer_event *
 rb_iter_peek(struct ring_buffer_iter *iter, u64 *ts)
@@ -1940,6 +1971,7 @@ rb_iter_peek(struct ring_buffer_iter *iter, u64 *ts)
 
         return NULL;
 }
+EXPORT_SYMBOL_GPL(ring_buffer_iter_peek);
 
 /**
  * ring_buffer_peek - peek at the next event to be read
@@ -2001,7 +2033,7 @@ ring_buffer_consume(struct ring_buffer *buffer, int cpu, u64 *ts)
         struct ring_buffer_event *event;
         unsigned long flags;
 
-        if (!cpu_isset(cpu, buffer->cpumask))
+        if (!cpumask_test_cpu(cpu, buffer->cpumask))
                 return NULL;
 
         spin_lock_irqsave(&cpu_buffer->reader_lock, flags);
@@ -2017,6 +2049,7 @@ ring_buffer_consume(struct ring_buffer *buffer, int cpu, u64 *ts)
 
         return event;
 }
+EXPORT_SYMBOL_GPL(ring_buffer_consume);
 
 /**
  * ring_buffer_read_start - start a non consuming read of the buffer
@@ -2037,7 +2070,7 @@ ring_buffer_read_start(struct ring_buffer *buffer, int cpu)
         struct ring_buffer_iter *iter;
         unsigned long flags;
 
-        if (!cpu_isset(cpu, buffer->cpumask))
+        if (!cpumask_test_cpu(cpu, buffer->cpumask))
                 return NULL;
 
         iter = kmalloc(sizeof(*iter), GFP_KERNEL);
@@ -2059,6 +2092,7 @@ ring_buffer_read_start(struct ring_buffer *buffer, int cpu)
 
         return iter;
 }
+EXPORT_SYMBOL_GPL(ring_buffer_read_start);
 
 /**
  * ring_buffer_finish - finish reading the iterator of the buffer
@@ -2075,6 +2109,7 @@ ring_buffer_read_finish(struct ring_buffer_iter *iter)
         atomic_dec(&cpu_buffer->record_disabled);
         kfree(iter);
 }
+EXPORT_SYMBOL_GPL(ring_buffer_read_finish);
 
 /**
  * ring_buffer_read - read the next item in the ring buffer by the iterator
@@ -2101,6 +2136,7 @@ ring_buffer_read(struct ring_buffer_iter *iter, u64 *ts)
 
         return event;
 }
+EXPORT_SYMBOL_GPL(ring_buffer_read);
 
 /**
  * ring_buffer_size - return the size of the ring buffer (in bytes)
@@ -2110,6 +2146,7 @@ unsigned long ring_buffer_size(struct ring_buffer *buffer)
 {
         return BUF_PAGE_SIZE * buffer->pages;
 }
+EXPORT_SYMBOL_GPL(ring_buffer_size);
 
 static void
 rb_reset_cpu(struct ring_buffer_per_cpu *cpu_buffer)
@@ -2143,7 +2180,7 @@ void ring_buffer_reset_cpu(struct ring_buffer *buffer, int cpu)
         struct ring_buffer_per_cpu *cpu_buffer = buffer->buffers[cpu];
         unsigned long flags;
 
-        if (!cpu_isset(cpu, buffer->cpumask))
+        if (!cpumask_test_cpu(cpu, buffer->cpumask))
                 return;
 
         spin_lock_irqsave(&cpu_buffer->reader_lock, flags);
@@ -2156,6 +2193,7 @@ void ring_buffer_reset_cpu(struct ring_buffer *buffer, int cpu)
 
         spin_unlock_irqrestore(&cpu_buffer->reader_lock, flags);
 }
+EXPORT_SYMBOL_GPL(ring_buffer_reset_cpu);
 
 /**
  * ring_buffer_reset - reset a ring buffer
@@ -2168,6 +2206,7 @@ void ring_buffer_reset(struct ring_buffer *buffer)
         for_each_buffer_cpu(buffer, cpu)
                 ring_buffer_reset_cpu(buffer, cpu);
 }
+EXPORT_SYMBOL_GPL(ring_buffer_reset);
 
 /**
  * rind_buffer_empty - is the ring buffer empty?
@@ -2186,6 +2225,7 @@ int ring_buffer_empty(struct ring_buffer *buffer)
         }
         return 1;
 }
+EXPORT_SYMBOL_GPL(ring_buffer_empty);
 
 /**
  * ring_buffer_empty_cpu - is a cpu buffer of a ring buffer empty?
@@ -2196,12 +2236,13 @@ int ring_buffer_empty_cpu(struct ring_buffer *buffer, int cpu)
 {
         struct ring_buffer_per_cpu *cpu_buffer;
 
-        if (!cpu_isset(cpu, buffer->cpumask))
+        if (!cpumask_test_cpu(cpu, buffer->cpumask))
                 return 1;
 
         cpu_buffer = buffer->buffers[cpu];
         return rb_per_cpu_empty(cpu_buffer);
 }
+EXPORT_SYMBOL_GPL(ring_buffer_empty_cpu);
 
 /**
  * ring_buffer_swap_cpu - swap a CPU buffer between two ring buffers
@@ -2219,8 +2260,8 @@ int ring_buffer_swap_cpu(struct ring_buffer *buffer_a,
         struct ring_buffer_per_cpu *cpu_buffer_a;
         struct ring_buffer_per_cpu *cpu_buffer_b;
 
-        if (!cpu_isset(cpu, buffer_a->cpumask) ||
-            !cpu_isset(cpu, buffer_b->cpumask))
+        if (!cpumask_test_cpu(cpu, buffer_a->cpumask) ||
+            !cpumask_test_cpu(cpu, buffer_b->cpumask))
                 return -EINVAL;
 
         /* At least make sure the two buffers are somewhat the same */
@@ -2250,6 +2291,7 @@ int ring_buffer_swap_cpu(struct ring_buffer *buffer_a,
 
         return 0;
 }
+EXPORT_SYMBOL_GPL(ring_buffer_swap_cpu);
 
 static void rb_remove_entries(struct ring_buffer_per_cpu *cpu_buffer,
                               struct buffer_data_page *bpage)
diff --git a/kernel/trace/trace.c b/kernel/trace/trace.c
index b789c010512c..0418fc338b5c 100644
--- a/kernel/trace/trace.c
+++ b/kernel/trace/trace.c
@@ -30,7 +30,6 @@
 #include <linux/gfp.h>
 #include <linux/fs.h>
 #include <linux/kprobes.h>
-#include <linux/seq_file.h>
 #include <linux/writeback.h>
 
 #include <linux/stacktrace.h>
@@ -91,10 +90,10 @@ static inline void ftrace_enable_cpu(void)
         preempt_enable();
 }
 
-static cpumask_t __read_mostly          tracing_buffer_mask;
+static cpumask_var_t __read_mostly      tracing_buffer_mask;
 
 #define for_each_tracing_cpu(cpu)       \
-        for_each_cpu_mask(cpu, tracing_buffer_mask)
+        for_each_cpu(cpu, tracing_buffer_mask)
 
 /*
  * ftrace_dump_on_oops - variable to dump ftrace buffer on oops
@@ -1185,7 +1184,7 @@ enum trace_file_type {
         TRACE_FILE_ANNOTATE     = 2,
 };
 
-static void trace_iterator_increment(struct trace_iterator *iter, int cpu)
+static void trace_iterator_increment(struct trace_iterator *iter)
 {
         /* Don't allow ftrace to trace into the ring buffers */
         ftrace_disable_cpu();
@@ -1264,7 +1263,7 @@ static void *find_next_entry_inc(struct trace_iterator *iter)
         iter->ent = __find_next_entry(iter, &iter->cpu, &iter->ts);
 
         if (iter->ent)
-                trace_iterator_increment(iter, iter->cpu);
+                trace_iterator_increment(iter);
 
         return iter->ent ? iter : NULL;
 }
@@ -1493,10 +1492,10 @@ static void test_cpu_buff_start(struct trace_iterator *iter)
         if (!(iter->iter_flags & TRACE_FILE_ANNOTATE))
                 return;
 
-        if (cpu_isset(iter->cpu, iter->started))
+        if (cpumask_test_cpu(iter->cpu, iter->started))
                 return;
 
-        cpu_set(iter->cpu, iter->started);
+        cpumask_set_cpu(iter->cpu, iter->started);
         trace_seq_printf(s, "##### CPU %u buffer started ####\n", iter->cpu);
 }
 
@@ -1987,13 +1986,7 @@ static struct file_operations show_traces_fops = {
 /*
  * Only trace on a CPU if the bitmask is set:
  */
-static cpumask_t tracing_cpumask = CPU_MASK_ALL;
-
-/*
- * When tracing/tracing_cpu_mask is modified then this holds
- * the new bitmask we are about to install:
- */
-static cpumask_t tracing_cpumask_new;
+static cpumask_var_t tracing_cpumask;
 
 /*
  * The tracer itself will not take this lock, but still we want
@@ -2034,6 +2027,10 @@ tracing_cpumask_write(struct file *filp, const char __user *ubuf,
                       size_t count, loff_t *ppos)
 {
         int err, cpu;
+        cpumask_var_t tracing_cpumask_new;
+
+        if (!alloc_cpumask_var(&tracing_cpumask_new, GFP_KERNEL))
+                return -ENOMEM;
 
         mutex_lock(&tracing_cpumask_update_lock);
         err = cpumask_parse_user(ubuf, count, tracing_cpumask_new);
@@ -2047,26 +2044,28 @@ tracing_cpumask_write(struct file *filp, const char __user *ubuf,
                  * Increase/decrease the disabled counter if we are
                  * about to flip a bit in the cpumask:
                  */
-                if (cpu_isset(cpu, tracing_cpumask) &&
-                                !cpu_isset(cpu, tracing_cpumask_new)) {
+                if (cpumask_test_cpu(cpu, tracing_cpumask) &&
+                                !cpumask_test_cpu(cpu, tracing_cpumask_new)) {
                         atomic_inc(&global_trace.data[cpu]->disabled);
                 }
-                if (!cpu_isset(cpu, tracing_cpumask) &&
-                                cpu_isset(cpu, tracing_cpumask_new)) {
+                if (!cpumask_test_cpu(cpu, tracing_cpumask) &&
+                                cpumask_test_cpu(cpu, tracing_cpumask_new)) {
                         atomic_dec(&global_trace.data[cpu]->disabled);
                 }
         }
         __raw_spin_unlock(&ftrace_max_lock);
         local_irq_enable();
 
-        tracing_cpumask = tracing_cpumask_new;
+        cpumask_copy(tracing_cpumask, tracing_cpumask_new);
 
         mutex_unlock(&tracing_cpumask_update_lock);
+        free_cpumask_var(tracing_cpumask_new);
 
         return count;
 
 err_unlock:
         mutex_unlock(&tracing_cpumask_update_lock);
+        free_cpumask_var(tracing_cpumask);
 
         return err;
 }
@@ -2456,10 +2455,15 @@ static int tracing_open_pipe(struct inode *inode, struct file *filp)
         if (!iter)
                 return -ENOMEM;
 
+        if (!alloc_cpumask_var(&iter->started, GFP_KERNEL)) {
+                kfree(iter);
+                return -ENOMEM;
+        }
+
         mutex_lock(&trace_types_lock);
 
         /* trace pipe does not show start of buffer */
-        cpus_setall(iter->started);
+        cpumask_setall(iter->started);
 
         iter->tr = &global_trace;
         iter->trace = current_trace;
@@ -2476,6 +2480,7 @@ static int tracing_release_pipe(struct inode *inode, struct file *file)
 {
         struct trace_iterator *iter = file->private_data;
 
+        free_cpumask_var(iter->started);
         kfree(iter);
         atomic_dec(&tracing_reader);
 
@@ -3094,7 +3099,6 @@ void ftrace_dump(void)
         static DEFINE_SPINLOCK(ftrace_dump_lock);
         /* use static because iter can be a bit big for the stack */
         static struct trace_iterator iter;
-        static cpumask_t mask;
         static int dump_ran;
         unsigned long flags;
         int cnt = 0, cpu;
@@ -3128,8 +3132,6 @@ void ftrace_dump(void)
          * and then release the locks again.
          */
 
-        cpus_clear(mask);
-
         while (!trace_empty(&iter)) {
 
                 if (!cnt)
@@ -3165,19 +3167,28 @@ __init static int tracer_alloc_buffers(void)
 {
         struct trace_array_cpu *data;
         int i;
+        int ret = -ENOMEM;
 
-        /* TODO: make the number of buffers hot pluggable with CPUS */
-        tracing_buffer_mask = cpu_possible_map;
+        if (!alloc_cpumask_var(&tracing_buffer_mask, GFP_KERNEL))
+                goto out;
+
+        if (!alloc_cpumask_var(&tracing_cpumask, GFP_KERNEL))
+                goto out_free_buffer_mask;
+
+        cpumask_copy(tracing_buffer_mask, cpu_possible_mask);
+        cpumask_copy(tracing_cpumask, cpu_all_mask);
 
+        /* TODO: make the number of buffers hot pluggable with CPUS */
         global_trace.buffer = ring_buffer_alloc(trace_buf_size,
                                                    TRACE_BUFFER_FLAGS);
         if (!global_trace.buffer) {
                 printk(KERN_ERR "tracer: failed to allocate ring buffer!\n");
                 WARN_ON(1);
-                return 0;
+                goto out_free_cpumask;
         }
         global_trace.entries = ring_buffer_size(global_trace.buffer);
 
+
 #ifdef CONFIG_TRACER_MAX_TRACE
         max_tr.buffer = ring_buffer_alloc(trace_buf_size,
                                              TRACE_BUFFER_FLAGS);
@@ -3185,7 +3196,7 @@ __init static int tracer_alloc_buffers(void)
                 printk(KERN_ERR "tracer: failed to allocate max ring buffer!\n");
                 WARN_ON(1);
                 ring_buffer_free(global_trace.buffer);
-                return 0;
+                goto out_free_cpumask;
         }
         max_tr.entries = ring_buffer_size(max_tr.buffer);
         WARN_ON(max_tr.entries != global_trace.entries);
@@ -3215,8 +3226,14 @@ __init static int tracer_alloc_buffers(void)
                                        &trace_panic_notifier);
 
         register_die_notifier(&trace_die_notifier);
+        ret = 0;
 
-        return 0;
+out_free_cpumask:
+        free_cpumask_var(tracing_cpumask);
+out_free_buffer_mask:
+        free_cpumask_var(tracing_buffer_mask);
+out:
+        return ret;
 }
 early_initcall(tracer_alloc_buffers);
 fs_initcall(tracer_init_debugfs);
diff --git a/kernel/trace/trace.h b/kernel/trace/trace.h
index a8b624ccd4d6..94ed45e93a80 100644
--- a/kernel/trace/trace.h
+++ b/kernel/trace/trace.h
@@ -9,6 +9,7 @@
 #include <linux/mmiotrace.h>
 #include <linux/ftrace.h>
 #include <trace/boot.h>
+#include <trace/kmemtrace.h>
 
 enum trace_type {
         __TRACE_FIRST_TYPE = 0,
@@ -28,6 +29,8 @@ enum trace_type {
         TRACE_GRAPH_ENT,
         TRACE_USER_STACK,
         TRACE_HW_BRANCHES,
+        TRACE_KMEM_ALLOC,
+        TRACE_KMEM_FREE,
         TRACE_POWER,
 
         __TRACE_LAST_TYPE,
@@ -169,6 +172,24 @@ struct trace_power {
         struct power_trace      state_data;
 };
 
+struct kmemtrace_alloc_entry {
+        struct trace_entry      ent;
+        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;
+};
+
+struct kmemtrace_free_entry {
+        struct trace_entry      ent;
+        enum kmemtrace_type_id type_id;
+        unsigned long call_site;
+        const void *ptr;
+};
+
 /*
  * trace_flag_type is an enumeration that holds different
  * states when a trace occurs. These are:
@@ -276,6 +297,10 @@ extern void __ftrace_bad_type(void);
                           TRACE_GRAPH_RET);             \
                 IF_ASSIGN(var, ent, struct hw_branch_entry, TRACE_HW_BRANCHES);\
                 IF_ASSIGN(var, ent, struct trace_power, TRACE_POWER); \
+                IF_ASSIGN(var, ent, struct kmemtrace_alloc_entry,       \
+                          TRACE_KMEM_ALLOC);    \
+                IF_ASSIGN(var, ent, struct kmemtrace_free_entry,        \
+                          TRACE_KMEM_FREE);     \
                 __ftrace_bad_type();                                    \
         } while (0)
 
@@ -379,7 +404,7 @@ struct trace_iterator {
         loff_t                  pos;
         long                    idx;
 
-        cpumask_t               started;
+        cpumask_var_t           started;
 };
 
 int tracing_is_enabled(void);
diff --git a/kernel/trace/trace_boot.c b/kernel/trace/trace_boot.c
index cb2ff3e297b1..0e94b3d091f7 100644
--- a/kernel/trace/trace_boot.c
+++ b/kernel/trace/trace_boot.c
@@ -43,7 +43,7 @@ static int boot_trace_init(struct trace_array *tr)
         int cpu;
         boot_trace = tr;
 
-        for_each_cpu_mask(cpu, cpu_possible_map)
+        for_each_cpu(cpu, cpu_possible_mask)
                 tracing_reset(tr, cpu);
 
         tracing_sched_switch_assign_trace(tr);
diff --git a/kernel/trace/trace_functions_graph.c b/kernel/trace/trace_functions_graph.c
index f8ac5417afc8..3c545984816f 100644
--- a/kernel/trace/trace_functions_graph.c
+++ b/kernel/trace/trace_functions_graph.c
@@ -80,7 +80,7 @@ print_graph_cpu(struct trace_seq *s, int cpu)
         int i;
         int ret;
         int log10_this = log10_cpu(cpu);
-        int log10_all = log10_cpu(cpus_weight_nr(cpu_online_map));
+        int log10_all = log10_cpu(cpumask_weight(cpu_online_mask));
 
 
         /*
diff --git a/kernel/trace/trace_hw_branches.c b/kernel/trace/trace_hw_branches.c
index 879752b006b3..df21c1e72b95 100644
--- a/kernel/trace/trace_hw_branches.c
+++ b/kernel/trace/trace_hw_branches.c
@@ -47,7 +47,7 @@ static void bts_trace_start(struct trace_array *tr)
 
         tracing_reset_online_cpus(tr);
 
-        for_each_cpu_mask(cpu, cpu_possible_map)
+        for_each_cpu(cpu, cpu_possible_mask)
                 smp_call_function_single(cpu, bts_trace_start_cpu, NULL, 1);
 }
 
@@ -63,7 +63,7 @@ static void bts_trace_stop(struct trace_array *tr)
 {
         int cpu;
 
-        for_each_cpu_mask(cpu, cpu_possible_map)
+        for_each_cpu(cpu, cpu_possible_mask)
                 smp_call_function_single(cpu, bts_trace_stop_cpu, NULL, 1);
 }
 
@@ -173,7 +173,7 @@ static void trace_bts_prepare(struct trace_iterator *iter)
 {
         int cpu;
 
-        for_each_cpu_mask(cpu, cpu_possible_map)
+        for_each_cpu(cpu, cpu_possible_mask)
                 smp_call_function_single(cpu, trace_bts_cpu, iter->tr, 1);
 }
 
diff --git a/kernel/trace/trace_power.c b/kernel/trace/trace_power.c
index b9b13c39b4bb..faa6ab7a1f5c 100644
--- a/kernel/trace/trace_power.c
+++ b/kernel/trace/trace_power.c
@@ -40,7 +40,7 @@ static int power_trace_init(struct trace_array *tr)
 
         trace_power_enabled = 1;
 
-        for_each_cpu_mask(cpu, cpu_possible_map)
+        for_each_cpu(cpu, cpu_possible_mask)
                 tracing_reset(tr, cpu);
         return 0;
 }
diff --git a/kernel/trace/trace_sysprof.c b/kernel/trace/trace_sysprof.c
index 01becf1f19ff..eaca5ad803ff 100644
--- a/kernel/trace/trace_sysprof.c
+++ b/kernel/trace/trace_sysprof.c
@@ -196,27 +196,19 @@ static enum hrtimer_restart stack_trace_timer_fn(struct hrtimer *hrtimer)
         return HRTIMER_RESTART;
 }
 
-static void start_stack_timer(int cpu)
+static void start_stack_timer(void *unused)
 {
-        struct hrtimer *hrtimer = &per_cpu(stack_trace_hrtimer, cpu);
+        struct hrtimer *hrtimer = &__get_cpu_var(stack_trace_hrtimer);
 
         hrtimer_init(hrtimer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
         hrtimer->function = stack_trace_timer_fn;
-        hrtimer->cb_mode = HRTIMER_CB_IRQSAFE_PERCPU;
 
         hrtimer_start(hrtimer, ns_to_ktime(sample_period), HRTIMER_MODE_REL);
 }
 
 static void start_stack_timers(void)
 {
-        cpumask_t saved_mask = current->cpus_allowed;
-        int cpu;
-
-        for_each_online_cpu(cpu) {
-                set_cpus_allowed_ptr(current, &cpumask_of_cpu(cpu));
-                start_stack_timer(cpu);
-        }
-        set_cpus_allowed_ptr(current, &saved_mask);
+        on_each_cpu(start_stack_timer, NULL, 1);
 }
 
 static void stop_stack_timer(int cpu)