Added missing tegra files.HEADmaster

3 files changed, 1124 insertions, 0 deletions

diff --git a/kernel/trace/trace_workqueue.c b/kernel/trace/trace_workqueue.c
new file mode 100644
index 00000000000..209b379a472
--- /dev/null
+++ b/kernel/trace/trace_workqueue.c
@@ -0,0 +1,300 @@
+/*
+ * Workqueue statistical tracer.
+ *
+ * Copyright (C) 2008 Frederic Weisbecker <fweisbec@gmail.com>
+ *
+ */
+
+
+#include <trace/events/workqueue.h>
+#include <linux/list.h>
+#include <linux/percpu.h>
+#include <linux/slab.h>
+#include <linux/kref.h>
+#include "trace_stat.h"
+#include "trace.h"
+
+
+/* A cpu workqueue thread */
+struct cpu_workqueue_stats {
+        struct list_head            list;
+        struct kref                 kref;
+        int                         cpu;
+        pid_t                       pid;
+/* Can be inserted from interrupt or user context, need to be atomic */
+        atomic_t                    inserted;
+/*
+ *  Don't need to be atomic, works are serialized in a single workqueue thread
+ *  on a single CPU.
+ */
+        unsigned int                executed;
+};
+
+/* List of workqueue threads on one cpu */
+struct workqueue_global_stats {
+        struct list_head        list;
+        spinlock_t              lock;
+};
+
+/* Don't need a global lock because allocated before the workqueues, and
+ * never freed.
+ */
+static DEFINE_PER_CPU(struct workqueue_global_stats, all_workqueue_stat);
+#define workqueue_cpu_stat(cpu) (&per_cpu(all_workqueue_stat, cpu))
+
+static void cpu_workqueue_stat_free(struct kref *kref)
+{
+        kfree(container_of(kref, struct cpu_workqueue_stats, kref));
+}
+
+/* Insertion of a work */
+static void
+probe_workqueue_insertion(void *ignore,
+                          struct task_struct *wq_thread,
+                          struct work_struct *work)
+{
+        int cpu = cpumask_first(&wq_thread->cpus_allowed);
+        struct cpu_workqueue_stats *node;
+        unsigned long flags;
+
+        spin_lock_irqsave(&workqueue_cpu_stat(cpu)->lock, flags);
+        list_for_each_entry(node, &workqueue_cpu_stat(cpu)->list, list) {
+                if (node->pid == wq_thread->pid) {
+                        atomic_inc(&node->inserted);
+                        goto found;
+                }
+        }
+        pr_debug("trace_workqueue: entry not found\n");
+found:
+        spin_unlock_irqrestore(&workqueue_cpu_stat(cpu)->lock, flags);
+}
+
+/* Execution of a work */
+static void
+probe_workqueue_execution(void *ignore,
+                          struct task_struct *wq_thread,
+                          struct work_struct *work)
+{
+        int cpu = cpumask_first(&wq_thread->cpus_allowed);
+        struct cpu_workqueue_stats *node;
+        unsigned long flags;
+
+        spin_lock_irqsave(&workqueue_cpu_stat(cpu)->lock, flags);
+        list_for_each_entry(node, &workqueue_cpu_stat(cpu)->list, list) {
+                if (node->pid == wq_thread->pid) {
+                        node->executed++;
+                        goto found;
+                }
+        }
+        pr_debug("trace_workqueue: entry not found\n");
+found:
+        spin_unlock_irqrestore(&workqueue_cpu_stat(cpu)->lock, flags);
+}
+
+/* Creation of a cpu workqueue thread */
+static void probe_workqueue_creation(void *ignore,
+                                     struct task_struct *wq_thread, int cpu)
+{
+        struct cpu_workqueue_stats *cws;
+        unsigned long flags;
+
+        WARN_ON(cpu < 0);
+
+        /* Workqueues are sometimes created in atomic context */
+        cws = kzalloc(sizeof(struct cpu_workqueue_stats), GFP_ATOMIC);
+        if (!cws) {
+                pr_warning("trace_workqueue: not enough memory\n");
+                return;
+        }
+        INIT_LIST_HEAD(&cws->list);
+        kref_init(&cws->kref);
+        cws->cpu = cpu;
+        cws->pid = wq_thread->pid;
+
+        spin_lock_irqsave(&workqueue_cpu_stat(cpu)->lock, flags);
+        list_add_tail(&cws->list, &workqueue_cpu_stat(cpu)->list);
+        spin_unlock_irqrestore(&workqueue_cpu_stat(cpu)->lock, flags);
+}
+
+/* Destruction of a cpu workqueue thread */
+static void
+probe_workqueue_destruction(void *ignore, struct task_struct *wq_thread)
+{
+        /* Workqueue only execute on one cpu */
+        int cpu = cpumask_first(&wq_thread->cpus_allowed);
+        struct cpu_workqueue_stats *node, *next;
+        unsigned long flags;
+
+        spin_lock_irqsave(&workqueue_cpu_stat(cpu)->lock, flags);
+        list_for_each_entry_safe(node, next, &workqueue_cpu_stat(cpu)->list,
+                                                        list) {
+                if (node->pid == wq_thread->pid) {
+                        list_del(&node->list);
+                        kref_put(&node->kref, cpu_workqueue_stat_free);
+                        goto found;
+                }
+        }
+
+        pr_debug("trace_workqueue: don't find workqueue to destroy\n");
+found:
+        spin_unlock_irqrestore(&workqueue_cpu_stat(cpu)->lock, flags);
+
+}
+
+static struct cpu_workqueue_stats *workqueue_stat_start_cpu(int cpu)
+{
+        unsigned long flags;
+        struct cpu_workqueue_stats *ret = NULL;
+
+
+        spin_lock_irqsave(&workqueue_cpu_stat(cpu)->lock, flags);
+
+        if (!list_empty(&workqueue_cpu_stat(cpu)->list)) {
+                ret = list_entry(workqueue_cpu_stat(cpu)->list.next,
+                                 struct cpu_workqueue_stats, list);
+                kref_get(&ret->kref);
+        }
+
+        spin_unlock_irqrestore(&workqueue_cpu_stat(cpu)->lock, flags);
+
+        return ret;
+}
+
+static void *workqueue_stat_start(struct tracer_stat *trace)
+{
+        int cpu;
+        void *ret = NULL;
+
+        for_each_possible_cpu(cpu) {
+                ret = workqueue_stat_start_cpu(cpu);
+                if (ret)
+                        return ret;
+        }
+        return NULL;
+}
+
+static void *workqueue_stat_next(void *prev, int idx)
+{
+        struct cpu_workqueue_stats *prev_cws = prev;
+        struct cpu_workqueue_stats *ret;
+        int cpu = prev_cws->cpu;
+        unsigned long flags;
+
+        spin_lock_irqsave(&workqueue_cpu_stat(cpu)->lock, flags);
+        if (list_is_last(&prev_cws->list, &workqueue_cpu_stat(cpu)->list)) {
+                spin_unlock_irqrestore(&workqueue_cpu_stat(cpu)->lock, flags);
+                do {
+                        cpu = cpumask_next(cpu, cpu_possible_mask);
+                        if (cpu >= nr_cpu_ids)
+                                return NULL;
+                } while (!(ret = workqueue_stat_start_cpu(cpu)));
+                return ret;
+        } else {
+                ret = list_entry(prev_cws->list.next,
+                                 struct cpu_workqueue_stats, list);
+                kref_get(&ret->kref);
+        }
+        spin_unlock_irqrestore(&workqueue_cpu_stat(cpu)->lock, flags);
+
+        return ret;
+}
+
+static int workqueue_stat_show(struct seq_file *s, void *p)
+{
+        struct cpu_workqueue_stats *cws = p;
+        struct pid *pid;
+        struct task_struct *tsk;
+
+        pid = find_get_pid(cws->pid);
+        if (pid) {
+                tsk = get_pid_task(pid, PIDTYPE_PID);
+                if (tsk) {
+                        seq_printf(s, "%3d %6d     %6u       %s\n", cws->cpu,
+                                   atomic_read(&cws->inserted), cws->executed,
+                                   tsk->comm);
+                        put_task_struct(tsk);
+                }
+                put_pid(pid);
+        }
+
+        return 0;
+}
+
+static void workqueue_stat_release(void *stat)
+{
+        struct cpu_workqueue_stats *node = stat;
+
+        kref_put(&node->kref, cpu_workqueue_stat_free);
+}
+
+static int workqueue_stat_headers(struct seq_file *s)
+{
+        seq_printf(s, "# CPU  INSERTED  EXECUTED   NAME\n");
+        seq_printf(s, "# |      |         |          |\n");
+        return 0;
+}
+
+struct tracer_stat workqueue_stats __read_mostly = {
+        .name = "workqueues",
+        .stat_start = workqueue_stat_start,
+        .stat_next = workqueue_stat_next,
+        .stat_show = workqueue_stat_show,
+        .stat_release = workqueue_stat_release,
+        .stat_headers = workqueue_stat_headers
+};
+
+
+int __init stat_workqueue_init(void)
+{
+        if (register_stat_tracer(&workqueue_stats)) {
+                pr_warning("Unable to register workqueue stat tracer\n");
+                return 1;
+        }
+
+        return 0;
+}
+fs_initcall(stat_workqueue_init);
+
+/*
+ * Workqueues are created very early, just after pre-smp initcalls.
+ * So we must register our tracepoints at this stage.
+ */
+int __init trace_workqueue_early_init(void)
+{
+        int ret, cpu;
+
+        for_each_possible_cpu(cpu) {
+                spin_lock_init(&workqueue_cpu_stat(cpu)->lock);
+                INIT_LIST_HEAD(&workqueue_cpu_stat(cpu)->list);
+        }
+
+        ret = register_trace_workqueue_insertion(probe_workqueue_insertion, NULL);
+        if (ret)
+                goto out;
+
+        ret = register_trace_workqueue_execution(probe_workqueue_execution, NULL);
+        if (ret)
+                goto no_insertion;
+
+        ret = register_trace_workqueue_creation(probe_workqueue_creation, NULL);
+        if (ret)
+                goto no_execution;
+
+        ret = register_trace_workqueue_destruction(probe_workqueue_destruction, NULL);
+        if (ret)
+                goto no_creation;
+
+        return 0;
+
+no_creation:
+        unregister_trace_workqueue_creation(probe_workqueue_creation, NULL);
+no_execution:
+        unregister_trace_workqueue_execution(probe_workqueue_execution, NULL);
+no_insertion:
+        unregister_trace_workqueue_insertion(probe_workqueue_insertion, NULL);
+out:
+        pr_warning("trace_workqueue: unable to trace workqueues\n");
+
+        return 1;
+}
+early_initcall(trace_workqueue_early_init);
diff --git a/kernel/trace/tracedump.c b/kernel/trace/tracedump.c
new file mode 100644
index 00000000000..a83532bc36d
--- /dev/null
+++ b/kernel/trace/tracedump.c
@@ -0,0 +1,682 @@
+/*
+ * kernel/trace/tracedump.c
+ *
+ * Copyright (c) 2011, NVIDIA CORPORATION.  All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ */
+
+#include <linux/console.h>
+#include <linux/cpumask.h>
+#include <linux/init.h>
+#include <linux/irqflags.h>
+#include <linux/module.h>
+#include <linux/moduleparam.h>
+#include <linux/mutex.h>
+#include <linux/notifier.h>
+#include <linux/proc_fs.h>
+#include <linux/ring_buffer.h>
+#include <linux/sched.h>
+#include <linux/smp.h>
+#include <linux/string.h>
+#include <linux/threads.h>
+#include <linux/tracedump.h>
+#include <linux/uaccess.h>
+#include <linux/vmalloc.h>
+#include <linux/zlib.h>
+
+#include "trace.h"
+#include "trace_output.h"
+
+#define CPU_MAX (NR_CPUS-1)
+
+#define TRYM(fn, ...) do {              \
+        int try_error = (fn);           \
+        if (try_error < 0) {            \
+                printk(__VA_ARGS__);    \
+                return try_error;       \
+        }                               \
+} while (0)
+
+#define TRY(fn) TRYM(fn, TAG "Caught error from %s in %s\n", #fn, __func__)
+
+/* Stolen from printk.c */
+#define for_each_console(con) \
+        for (con = console_drivers; con != NULL; con = con->next)
+
+#define TAG KERN_ERR "tracedump: "
+
+#define TD_MIN_CONSUME 2000
+#define TD_COMPRESS_CHUNK 0x8000
+
+static DEFINE_MUTEX(tracedump_proc_lock);
+
+static const char MAGIC_NUMBER[9] = "TRACEDUMP";
+static const char CPU_DELIM[7] = "CPU_END";
+#define CMDLINE_DELIM "|"
+
+/* Type of output */
+static bool current_format;
+static bool format_ascii;
+module_param(format_ascii, bool, S_IRUGO | S_IWUSR);
+MODULE_PARM_DESC(format_ascii, "Dump ascii or raw data");
+
+/* Max size of output */
+static uint panic_size = 0x80000;
+module_param(panic_size, uint, S_IRUGO | S_IWUSR);
+MODULE_PARM_DESC(panic_size, "Max dump size during kernel panic (bytes)");
+
+static uint compress_level = 9;
+module_param(compress_level, uint, S_IRUGO | S_IWUSR);
+MODULE_PARM_DESC(compress_level, "Level of compression to use. [0-9]");
+
+static char out_buf[TD_COMPRESS_CHUNK];
+static z_stream stream;
+static int compress_done;
+static int flush;
+
+static int old_trace_flags;
+
+static struct trace_iterator iter;
+static struct pager_s {
+        struct trace_array      *tr;
+        void                    *spare;
+        int                     cpu;
+        int                     len;
+        char __user             *ubuf;
+} pager;
+
+static char cmdline_buf[16+TASK_COMM_LEN];
+
+static int print_to_console(const char *buf, size_t len)
+{
+        struct console *con;
+
+        /* Stolen from printk.c */
+        for_each_console(con) {
+                if ((con->flags & CON_ENABLED) && con->write &&
+                   (cpu_online(smp_processor_id()) ||
+                   (con->flags & CON_ANYTIME)))
+                        con->write(con, buf, len);
+        }
+        return 0;
+}
+
+static int print_to_user(const char *buf, size_t len)
+{
+        int size;
+        size = copy_to_user(pager.ubuf, buf, len);
+        if (size > 0) {
+                printk(TAG "Failed to copy to user %d bytes\n", size);
+                return -EINVAL;
+        }
+        return 0;
+}
+
+static int print(const char *buf, size_t len, int print_to)
+{
+        if (print_to == TD_PRINT_CONSOLE)
+                TRY(print_to_console(buf, len));
+        else if (print_to == TD_PRINT_USER)
+                TRY(print_to_user(buf, len));
+        return 0;
+}
+
+/* print_magic will print MAGIC_NUMBER using the
+ * print function selected by print_to.
+ */
+static inline ssize_t print_magic(int print_to)
+{
+        print(MAGIC_NUMBER, sizeof(MAGIC_NUMBER), print_to);
+        return sizeof(MAGIC_NUMBER);
+}
+
+static int iter_init(void)
+{
+        int cpu;
+
+        /* Make iter point to global ring buffer used in trace. */
+        trace_init_global_iter(&iter);
+
+        /* Disable tracing */
+        for_each_tracing_cpu(cpu) {
+                atomic_inc(&iter.tr->data[cpu]->disabled);
+        }
+
+        /* Save flags */
+        old_trace_flags = trace_flags;
+
+        /* Dont look at memory in panic mode. */
+        trace_flags &= ~TRACE_ITER_SYM_USEROBJ;
+
+        /* Prepare ring buffer iter */
+        for_each_tracing_cpu(cpu) {
+                iter.buffer_iter[cpu] =
+                 ring_buffer_read_prepare(iter.tr->buffer, cpu);
+        }
+        ring_buffer_read_prepare_sync();
+        for_each_tracing_cpu(cpu) {
+                ring_buffer_read_start(iter.buffer_iter[cpu]);
+                tracing_iter_reset(&iter, cpu);
+        }
+        return 0;
+}
+
+/* iter_next gets the next entry in the ring buffer, ordered by time.
+ * If there are no more entries, returns 0.
+ */
+static ssize_t iter_next(void)
+{
+        /* Zero out the iterator's seq */
+        memset(&iter.seq, 0,
+                sizeof(struct trace_iterator) -
+                offsetof(struct trace_iterator, seq));
+
+        while (!trace_empty(&iter)) {
+                if (trace_find_next_entry_inc(&iter) == NULL) {
+                        printk(TAG "trace_find_next_entry failed!\n");
+                        return -EINVAL;
+                }
+
+                /* Copy the ring buffer data to iterator's seq */
+                print_trace_line(&iter);
+                if (iter.seq.len != 0)
+                        return iter.seq.len;
+        }
+        return 0;
+}
+
+static int iter_deinit(void)
+{
+        int cpu;
+        /* Enable tracing */
+        for_each_tracing_cpu(cpu) {
+                ring_buffer_read_finish(iter.buffer_iter[cpu]);
+        }
+        for_each_tracing_cpu(cpu) {
+                atomic_dec(&iter.tr->data[cpu]->disabled);
+        }
+
+        /* Restore flags */
+        trace_flags = old_trace_flags;
+        return 0;
+}
+
+static int pager_init(void)
+{
+        int cpu;
+
+        /* Need to do this to get a pointer to global_trace (iter.tr).
+           Lame, I know. */
+        trace_init_global_iter(&iter);
+
+        /* Turn off tracing */
+        for_each_tracing_cpu(cpu) {
+                atomic_inc(&iter.tr->data[cpu]->disabled);
+        }
+
+        memset(&pager, 0, sizeof(pager));
+        pager.tr = iter.tr;
+        pager.len = TD_COMPRESS_CHUNK;
+
+        return 0;
+}
+
+/* pager_next_cpu moves the pager to the next cpu.
+ * Returns 0 if pager is done, else 1.
+ */
+static ssize_t pager_next_cpu(void)
+{
+        if (pager.cpu <= CPU_MAX) {
+                pager.cpu += 1;
+                return 1;
+        }
+
+        return 0;
+}
+
+/* pager_next gets the next page of data from the ring buffer
+ * of the current cpu. Returns page size or 0 if no more data.
+ */
+static ssize_t pager_next(void)
+{
+        int ret;
+
+        if (pager.cpu > CPU_MAX)
+                return 0;
+
+        if (!pager.spare)
+                pager.spare = ring_buffer_alloc_read_page(pager.tr->buffer, pager.cpu);
+        if (!pager.spare) {
+                printk(TAG "ring_buffer_alloc_read_page failed!");
+                return -ENOMEM;
+        }
+
+        ret = ring_buffer_read_page(pager.tr->buffer,
+                                    &pager.spare,
+                                    pager.len,
+                                    pager.cpu, 0);
+        if (ret < 0)
+                return 0;
+
+        return PAGE_SIZE;
+}
+
+static int pager_deinit(void)
+{
+        int cpu;
+        if (pager.spare != NULL)
+                ring_buffer_free_read_page(pager.tr->buffer, pager.spare);
+
+        for_each_tracing_cpu(cpu) {
+                atomic_dec(&iter.tr->data[cpu]->disabled);
+        }
+        return 0;
+}
+
+/* cmdline_next gets the next saved cmdline from the trace and
+ * puts it in cmdline_buf. Returns the size of the cmdline, or 0 if empty.
+ * but will reset itself on a subsequent call.
+ */
+static ssize_t cmdline_next(void)
+{
+        static int pid;
+        ssize_t size = 0;
+
+        if (pid >= PID_MAX_DEFAULT)
+                pid = -1;
+
+        while (size == 0 && pid < PID_MAX_DEFAULT) {
+                pid++;
+                trace_find_cmdline(pid, cmdline_buf);
+                if (!strncmp(cmdline_buf, "<...>", 5))
+                        continue;
+
+                sprintf(&cmdline_buf[strlen(cmdline_buf)], " %d"
+                                     CMDLINE_DELIM, pid);
+                size = strlen(cmdline_buf);
+        }
+        return size;
+}
+
+/* comsume_events removes the first 'num' entries from the ring buffer. */
+static int consume_events(size_t num)
+{
+        TRY(iter_init());
+        for (; num > 0 && !trace_empty(&iter); num--) {
+                trace_find_next_entry_inc(&iter);
+                ring_buffer_consume(iter.tr->buffer, iter.cpu, &iter.ts,
+                                    &iter.lost_events);
+        }
+        TRY(iter_deinit());
+        return 0;
+}
+
+static int data_init(void)
+{
+        if (current_format)
+                TRY(iter_init());
+        else
+                TRY(pager_init());
+        return 0;
+}
+
+/* data_next will figure out the right 'next' function to
+ * call and will select the right buffer to pass back
+ * to compress_next.
+ *
+ * iter_next should be used to get data entry-by-entry, ordered
+ * by time, which is what we need in order to convert it to ascii.
+ *
+ * pager_next will return a full page of raw data at a time, one
+ * CPU at a time. pager_next_cpu must be called to get the next CPU.
+ * cmdline_next will get the next saved cmdline
+ */
+static ssize_t data_next(const char **buf)
+{
+        ssize_t size;
+
+        if (current_format) {
+                TRY(size = iter_next());
+                *buf = iter.seq.buffer;
+        } else {
+                TRY(size = pager_next());
+                *buf = pager.spare;
+                if (size == 0) {
+                        if (pager_next_cpu()) {
+                                size = sizeof(CPU_DELIM);
+                                *buf = CPU_DELIM;
+                        } else {
+                                TRY(size = cmdline_next());
+                                *buf = cmdline_buf;
+                        }
+                }
+        }
+        return size;
+}
+
+static int data_deinit(void)
+{
+        if (current_format)
+                TRY(iter_deinit());
+        else
+                TRY(pager_deinit());
+        return 0;
+}
+
+static int compress_init(void)
+{
+        int workspacesize, ret;
+
+        compress_done = 0;
+        flush = Z_NO_FLUSH;
+        stream.data_type = current_format ? Z_ASCII : Z_BINARY;
+        workspacesize = zlib_deflate_workspacesize(MAX_WBITS, MAX_MEM_LEVEL);
+        stream.workspace = vmalloc(workspacesize);
+        if (!stream.workspace) {
+                printk(TAG "Could not allocate "
+                           "enough memory for zlib!\n");
+                return -ENOMEM;
+        }
+        memset(stream.workspace, 0, workspacesize);
+
+        ret = zlib_deflateInit(&stream, compress_level);
+        if (ret != Z_OK) {
+                printk(TAG "%s\n", stream.msg);
+                return ret;
+        }
+        stream.avail_in = 0;
+        stream.avail_out = 0;
+        TRY(data_init());
+        return 0;
+}
+
+/* compress_next will compress up to min(max_out, TD_COMPRESS_CHUNK) bytes
+ * of data into the output buffer. It gets the data by calling data_next.
+ * It will return the most data it possibly can. If it returns 0, then
+ * there is no more data.
+ *
+ * By the way that zlib works, each call to zlib_deflate will possibly
+ * consume up to avail_in bytes from next_in, and will fill up to
+ * avail_out bytes in next_out. Once flush == Z_FINISH, it can not take
+ * any more input. It will output until it is finished, and will return
+ * Z_STREAM_END.
+ */
+static ssize_t compress_next(size_t max_out)
+{
+        ssize_t ret;
+        max_out = min(max_out, (size_t)TD_COMPRESS_CHUNK);
+        stream.next_out = out_buf;
+        stream.avail_out = max_out;
+        while (stream.avail_out > 0 && !compress_done) {
+                if (stream.avail_in == 0 && flush != Z_FINISH) {
+                        TRY(stream.avail_in =
+                            data_next((const char **)&stream.next_in));
+                        flush = (stream.avail_in == 0) ? Z_FINISH : Z_NO_FLUSH;
+                }
+                if (stream.next_in != NULL) {
+                        TRYM((ret = zlib_deflate(&stream, flush)),
+                             "zlib: %s\n", stream.msg);
+                        compress_done = (ret == Z_STREAM_END);
+                }
+        }
+        ret = max_out - stream.avail_out;
+        return ret;
+}
+
+static int compress_deinit(void)
+{
+        TRY(data_deinit());
+
+        zlib_deflateEnd(&stream);
+        vfree(stream.workspace);
+
+        /* TODO: remove */
+        printk(TAG "Total in: %ld\n", stream.total_in);
+        printk(TAG "Total out: %ld\n", stream.total_out);
+        return stream.total_out;
+}
+
+static int compress_reset(void)
+{
+        TRY(compress_deinit());
+        TRY(compress_init());
+        return 0;
+}
+
+/* tracedump_init initializes all tracedump components.
+ * Call this before tracedump_next
+ */
+int tracedump_init(void)
+{
+        TRY(compress_init());
+        return 0;
+}
+
+/* tracedump_next will print up to max_out data from the tracing ring
+ * buffers using the print function selected by print_to. The data is
+ * compressed using zlib.
+ *
+ * The output type of the data is specified by the format_ascii module
+ * parameter. If format_ascii == 1, human-readable data will be output.
+ * Otherwise, it will output raw data from the ring buffer in cpu order,
+ * followed by the saved_cmdlines data.
+ */
+ssize_t tracedump_next(size_t max_out, int print_to)
+{
+        ssize_t size;
+        TRY(size = compress_next(max_out));
+        print(out_buf, size, print_to);
+        return size;
+}
+
+/* tracedump_all will print all data in the tracing ring buffers using
+ * the print function selected by print_to. The data is compressed using
+ * zlib, and is surrounded by MAGIC_NUMBER.
+ *
+ * The output type of the data is specified by the format_ascii module
+ * parameter. If format_ascii == 1, human-readable data will be output.
+ * Otherwise, it will output raw data from the ring buffer in cpu order,
+ * followed by the saved_cmdlines data.
+ */
+ssize_t tracedump_all(int print_to)
+{
+        ssize_t ret, size = 0;
+        TRY(size += print_magic(print_to));
+
+        do {
+                /* Here the size used doesn't really matter,
+                 * since we're dumping everything. */
+                TRY(ret = tracedump_next(0xFFFFFFFF, print_to));
+                size += ret;
+        } while (ret > 0);
+
+        TRY(size += print_magic(print_to));
+
+        return size;
+}
+
+/* tracedump_deinit deinitializes all tracedump components.
+ * This must be called, even on error.
+ */
+int tracedump_deinit(void)
+{
+        TRY(compress_deinit());
+        return 0;
+}
+
+/* tracedump_reset reinitializes all tracedump components. */
+int tracedump_reset(void)
+{
+        TRY(compress_reset());
+        return 0;
+}
+
+
+
+/* tracedump_open opens the tracedump file for reading. */
+static int tracedump_open(struct inode *inode, struct file *file)
+{
+        int ret;
+        mutex_lock(&tracedump_proc_lock);
+        current_format = format_ascii;
+        ret = tracedump_init();
+        if (ret < 0)
+                goto err;
+
+        ret = nonseekable_open(inode, file);
+        if (ret < 0)
+                goto err;
+        return ret;
+
+err:
+        mutex_unlock(&tracedump_proc_lock);
+        return ret;
+}
+
+/* tracedump_read will reads data from tracedump_next and prints
+ * it to userspace. It will surround the data with MAGIC_NUMBER.
+ */
+static ssize_t tracedump_read(struct file *file, char __user *buf,
+                              size_t len, loff_t *offset)
+{
+        static int done;
+        ssize_t size = 0;
+
+        pager.ubuf = buf;
+
+        if (*offset == 0) {
+                done = 0;
+                TRY(size = print_magic(TD_PRINT_USER));
+        } else if (!done) {
+                TRY(size = tracedump_next(len, TD_PRINT_USER));
+                if (size == 0) {
+                        TRY(size = print_magic(TD_PRINT_USER));
+                        done = 1;
+                }
+        }
+
+        *offset += size;
+
+        return size;
+}
+
+static int tracedump_release(struct inode *inode, struct file *file)
+{
+        int ret;
+        ret = tracedump_deinit();
+        mutex_unlock(&tracedump_proc_lock);
+        return ret;
+}
+
+/* tracedump_dump dumps all tracing data from the tracing ring buffers
+ * to all consoles. For details about the output format, see
+ * tracedump_all.
+
+ * At most max_out bytes are dumped. To accomplish this,
+ * tracedump_dump calls tracedump_all several times without writing the data,
+ * each time tossing out old data until it reaches its goal.
+ *
+ * Note: dumping raw pages currently does NOT follow the size limit.
+ */
+
+int tracedump_dump(size_t max_out)
+{
+        ssize_t size;
+        size_t consume;
+
+        printk(TAG "\n");
+
+        tracedump_init();
+
+        if (format_ascii) {
+                size = tracedump_all(TD_NO_PRINT);
+                if (size < 0) {
+                        printk(TAG "failed to dump\n");
+                        goto out;
+                }
+                while (size > max_out) {
+                        TRY(tracedump_deinit());
+                        /* Events take more or less 60 ascii bytes each,
+                           not counting compression */
+                        consume = TD_MIN_CONSUME + (size - max_out) /
+                                        (60 / (compress_level + 1));
+                        TRY(consume_events(consume));
+                        TRY(tracedump_init());
+                        size = tracedump_all(TD_NO_PRINT);
+                        if (size < 0) {
+                                printk(TAG "failed to dump\n");
+                                goto out;
+                        }
+                }
+
+                TRY(tracedump_reset());
+        }
+        size = tracedump_all(TD_PRINT_CONSOLE);
+        if (size < 0) {
+                printk(TAG "failed to dump\n");
+                goto out;
+        }
+
+out:
+        tracedump_deinit();
+        printk(KERN_INFO "\n" TAG " end\n");
+        return size;
+}
+
+static const struct file_operations tracedump_fops = {
+        .owner = THIS_MODULE,
+        .open = tracedump_open,
+        .read = tracedump_read,
+        .release = tracedump_release,
+};
+
+#ifdef CONFIG_TRACEDUMP_PANIC
+static int tracedump_panic_handler(struct notifier_block *this,
+                                   unsigned long event, void *unused)
+{
+        tracedump_dump(panic_size);
+        return 0;
+}
+
+static struct notifier_block tracedump_panic_notifier = {
+        .notifier_call  = tracedump_panic_handler,
+        .next           = NULL,
+        .priority       = 150   /* priority: INT_MAX >= x >= 0 */
+};
+#endif
+
+static int __init tracedump_initcall(void)
+{
+#ifdef CONFIG_TRACEDUMP_PROCFS
+        struct proc_dir_entry *entry;
+
+        /* Create a procfs file for easy dumping */
+        entry = create_proc_entry("tracedump", S_IFREG | S_IRUGO, NULL);
+        if (!entry)
+                printk(TAG "failed to create proc entry\n");
+        else
+                entry->proc_fops = &tracedump_fops;
+#endif
+
+#ifdef CONFIG_TRACEDUMP_PANIC
+        /* Automatically dump to console on a kernel panic */
+        atomic_notifier_chain_register(&panic_notifier_list,
+                                       &tracedump_panic_notifier);
+#endif
+        return 0;
+}
+
+early_initcall(tracedump_initcall);
diff --git a/kernel/trace/tracelevel.c b/kernel/trace/tracelevel.c
new file mode 100644
index 00000000000..9f8b8eedbb5
--- /dev/null
+++ b/kernel/trace/tracelevel.c
@@ -0,0 +1,142 @@
+/*
+ * kernel/trace/tracelevel.c
+ *
+ * Copyright (c) 2011, NVIDIA CORPORATION.  All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ */
+
+#include <linux/ftrace_event.h>
+#include <linux/list.h>
+#include <linux/moduleparam.h>
+#include <linux/mutex.h>
+#include <linux/tracelevel.h>
+#include <linux/vmalloc.h>
+
+#include "trace.h"
+
+#define TAG KERN_ERR "tracelevel: "
+
+struct tracelevel_record {
+        struct list_head list;
+        char *name;
+        int level;
+};
+
+static LIST_HEAD(tracelevel_list);
+
+static bool started;
+static unsigned int tracelevel_level = TRACELEVEL_DEFAULT;
+
+static DEFINE_MUTEX(tracelevel_record_lock);
+
+/* tracelevel_set_event sets a single event if set = 1, or
+ * clears an event if set = 0.
+ */
+static int tracelevel_set_event(struct tracelevel_record *evt, bool set)
+{
+        if (trace_set_clr_event(NULL, evt->name, set) < 0) {
+                printk(TAG "failed to set event %s\n", evt->name);
+                return -EINVAL;
+        }
+        return 0;
+}
+
+/* Registers an event. If possible, it also sets it.
+ * If not, we'll set it in tracelevel_init.
+ */
+int __tracelevel_register(char *name, unsigned int level)
+{
+        struct tracelevel_record *evt = (struct tracelevel_record *)
+                vmalloc(sizeof(struct tracelevel_record));
+        if (!evt) {
+                printk(TAG "failed to allocate tracelevel_record for %s\n",
+                        name);
+                return -ENOMEM;
+        }
+
+        evt->name = name;
+        evt->level = level;
+
+        mutex_lock(&tracelevel_record_lock);
+        list_add(&evt->list, &tracelevel_list);
+        mutex_unlock(&tracelevel_record_lock);
+
+        if (level >= tracelevel_level && started)
+                tracelevel_set_event(evt, 1);
+        return 0;
+}
+
+/* tracelevel_set_level sets the global level, clears events
+ * lower than that level, and enables events greater or equal.
+ */
+int tracelevel_set_level(int level)
+{
+        struct tracelevel_record *evt = NULL;
+
+        if (level < 0 || level > TRACELEVEL_MAX)
+                return -EINVAL;
+        tracelevel_level = level;
+
+        mutex_lock(&tracelevel_record_lock);
+        list_for_each_entry(evt, &tracelevel_list, list) {
+                if (evt->level >= level)
+                        tracelevel_set_event(evt, 1);
+                else
+                        tracelevel_set_event(evt, 0);
+        }
+        mutex_unlock(&tracelevel_record_lock);
+        return 0;
+}
+
+static int param_set_level(const char *val, const struct kernel_param *kp)
+{
+        int level, ret;
+        ret = strict_strtol(val, 0, &level);
+        if (ret < 0)
+                return ret;
+        return tracelevel_set_level(level);
+}
+
+static int param_get_level(char *buffer, const struct kernel_param *kp)
+{
+        return param_get_int(buffer, kp);
+}
+
+static struct kernel_param_ops tracelevel_level_ops = {
+        .set = param_set_level,
+        .get = param_get_level
+};
+
+module_param_cb(level, &tracelevel_level_ops, &tracelevel_level, 0644);
+
+/* Turn on the tracing that has been registered thus far. */
+static int __init tracelevel_init(void)
+{
+        int ret;
+        started = true;
+
+        /* Ring buffer is initialize to 1 page until the user sets a tracer.
+         * Since we're doing this manually, we need to ask for expanded buffer.
+         */
+        ret = tracing_update_buffers();
+        if (ret < 0)
+                return ret;
+
+        return tracelevel_set_level(tracelevel_level);
+}
+
+/* Tracing mechanism is set up during fs_initcall. */
+fs_initcall_sync(tracelevel_init);