Merge branch 'tracing-fixes-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tip/linux-2.6-tip

* 'tracing-fixes-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tip/linux-2.6-tip:
  kernel/profile.c: Switch /proc/irq/prof_cpu_mask to seq_file
  tracing: Export trace_profile_buf symbols
  tracing/events: use list_for_entry_continue
  tracing: remove max_tracer_type_len
  function-graph: use ftrace_graph_funcs directly
  tracing: Remove markers
  tracing: Allocate the ftrace event profile buffer dynamically
  tracing: Factorize the events profile accounting

6 files changed, 193 insertions, 108 deletions

diff --git a/kernel/trace/ftrace.c b/kernel/trace/ftrace.c
index cc615f84751b..c71e91bf7372 100644
--- a/kernel/trace/ftrace.c
+++ b/kernel/trace/ftrace.c
@@ -2414,11 +2414,9 @@ unsigned long ftrace_graph_funcs[FTRACE_GRAPH_MAX_FUNCS] __read_mostly;
 static void *
 __g_next(struct seq_file *m, loff_t *pos)
 {
-        unsigned long *array = m->private;
-
         if (*pos >= ftrace_graph_count)
                 return NULL;
-        return &array[*pos];
+        return &ftrace_graph_funcs[*pos];
 }
 
 static void *
@@ -2482,16 +2480,10 @@ ftrace_graph_open(struct inode *inode, struct file *file)
                 ftrace_graph_count = 0;
                 memset(ftrace_graph_funcs, 0, sizeof(ftrace_graph_funcs));
         }
+        mutex_unlock(&graph_lock);
 
-        if (file->f_mode & FMODE_READ) {
+        if (file->f_mode & FMODE_READ)
                 ret = seq_open(file, &ftrace_graph_seq_ops);
-                if (!ret) {
-                        struct seq_file *m = file->private_data;
-                        m->private = ftrace_graph_funcs;
-                }
-        } else
-                file->private_data = ftrace_graph_funcs;
-        mutex_unlock(&graph_lock);
 
         return ret;
 }
@@ -2560,7 +2552,6 @@ ftrace_graph_write(struct file *file, const char __user *ubuf,
                    size_t cnt, loff_t *ppos)
 {
         struct trace_parser parser;
-        unsigned long *array;
         size_t read = 0;
         ssize_t ret;
 
@@ -2574,12 +2565,6 @@ ftrace_graph_write(struct file *file, const char __user *ubuf,
                 goto out;
         }
 
-        if (file->f_mode & FMODE_READ) {
-                struct seq_file *m = file->private_data;
-                array = m->private;
-        } else
-                array = file->private_data;
-
         if (trace_parser_get_init(&parser, FTRACE_BUFF_MAX)) {
                 ret = -ENOMEM;
                 goto out;
@@ -2591,7 +2576,7 @@ ftrace_graph_write(struct file *file, const char __user *ubuf,
                 parser.buffer[parser.idx] = 0;
 
                 /* we allow only one expression at a time */
-                ret = ftrace_set_func(array, &ftrace_graph_count,
+                ret = ftrace_set_func(ftrace_graph_funcs, &ftrace_graph_count,
                                         parser.buffer);
                 if (ret)
                         goto out;
diff --git a/kernel/trace/trace.c b/kernel/trace/trace.c
index fd52a19dd172..861308072d28 100644
--- a/kernel/trace/trace.c
+++ b/kernel/trace/trace.c
@@ -125,13 +125,13 @@ int ftrace_dump_on_oops;
 
 static int tracing_set_tracer(const char *buf);
 
-#define BOOTUP_TRACER_SIZE              100
-static char bootup_tracer_buf[BOOTUP_TRACER_SIZE] __initdata;
+#define MAX_TRACER_SIZE         100
+static char bootup_tracer_buf[MAX_TRACER_SIZE] __initdata;
 static char *default_bootup_tracer;
 
 static int __init set_ftrace(char *str)
 {
-        strncpy(bootup_tracer_buf, str, BOOTUP_TRACER_SIZE);
+        strncpy(bootup_tracer_buf, str, MAX_TRACER_SIZE);
         default_bootup_tracer = bootup_tracer_buf;
         /* We are using ftrace early, expand it */
         ring_buffer_expanded = 1;
@@ -242,13 +242,6 @@ static struct tracer		*trace_types __read_mostly;
 static struct tracer            *current_trace __read_mostly;
 
 /*
- * max_tracer_type_len is used to simplify the allocating of
- * buffers to read userspace tracer names. We keep track of
- * the longest tracer name registered.
- */
-static int                      max_tracer_type_len;
-
-/*
  * trace_types_lock is used to protect the trace_types list.
  * This lock is also used to keep user access serialized.
  * Accesses from userspace will grab this lock while userspace
@@ -619,7 +612,6 @@ __releases(kernel_lock)
 __acquires(kernel_lock)
 {
         struct tracer *t;
-        int len;
         int ret = 0;
 
         if (!type->name) {
@@ -627,6 +619,11 @@ __acquires(kernel_lock)
                 return -1;
         }
 
+        if (strlen(type->name) > MAX_TRACER_SIZE) {
+                pr_info("Tracer has a name longer than %d\n", MAX_TRACER_SIZE);
+                return -1;
+        }
+
         /*
          * When this gets called we hold the BKL which means that
          * preemption is disabled. Various trace selftests however
@@ -641,7 +638,7 @@ __acquires(kernel_lock)
         for (t = trace_types; t; t = t->next) {
                 if (strcmp(type->name, t->name) == 0) {
                         /* already found */
-                        pr_info("Trace %s already registered\n",
+                        pr_info("Tracer %s already registered\n",
                                 type->name);
                         ret = -1;
                         goto out;
@@ -692,9 +689,6 @@ __acquires(kernel_lock)
 
         type->next = trace_types;
         trace_types = type;
-        len = strlen(type->name);
-        if (len > max_tracer_type_len)
-                max_tracer_type_len = len;
 
  out:
         tracing_selftest_running = false;
@@ -703,7 +697,7 @@ __acquires(kernel_lock)
         if (ret || !default_bootup_tracer)
                 goto out_unlock;
 
-        if (strncmp(default_bootup_tracer, type->name, BOOTUP_TRACER_SIZE))
+        if (strncmp(default_bootup_tracer, type->name, MAX_TRACER_SIZE))
                 goto out_unlock;
 
         printk(KERN_INFO "Starting tracer '%s'\n", type->name);
@@ -725,14 +719,13 @@ __acquires(kernel_lock)
 void unregister_tracer(struct tracer *type)
 {
         struct tracer **t;
-        int len;
 
         mutex_lock(&trace_types_lock);
         for (t = &trace_types; *t; t = &(*t)->next) {
                 if (*t == type)
                         goto found;
         }
-        pr_info("Trace %s not registered\n", type->name);
+        pr_info("Tracer %s not registered\n", type->name);
         goto out;
 
  found:
@@ -745,17 +738,7 @@ void unregister_tracer(struct tracer *type)
                         current_trace->stop(&global_trace);
                 current_trace = &nop_trace;
         }
-
-        if (strlen(type->name) != max_tracer_type_len)
-                goto out;
-
-        max_tracer_type_len = 0;
-        for (t = &trace_types; *t; t = &(*t)->next) {
-                len = strlen((*t)->name);
-                if (len > max_tracer_type_len)
-                        max_tracer_type_len = len;
-        }
- out:
+out:
         mutex_unlock(&trace_types_lock);
 }
 
@@ -2604,7 +2587,7 @@ static ssize_t
 tracing_set_trace_read(struct file *filp, char __user *ubuf,
                        size_t cnt, loff_t *ppos)
 {
-        char buf[max_tracer_type_len+2];
+        char buf[MAX_TRACER_SIZE+2];
         int r;
 
         mutex_lock(&trace_types_lock);
@@ -2754,15 +2737,15 @@ static ssize_t
 tracing_set_trace_write(struct file *filp, const char __user *ubuf,
                         size_t cnt, loff_t *ppos)
 {
-        char buf[max_tracer_type_len+1];
+        char buf[MAX_TRACER_SIZE+1];
         int i;
         size_t ret;
         int err;
 
         ret = cnt;
 
-        if (cnt > max_tracer_type_len)
-                cnt = max_tracer_type_len;
+        if (cnt > MAX_TRACER_SIZE)
+                cnt = MAX_TRACER_SIZE;
 
         if (copy_from_user(&buf, ubuf, cnt))
                 return -EFAULT;
diff --git a/kernel/trace/trace_event_profile.c b/kernel/trace/trace_event_profile.c
index 55a25c933d15..dd44b8768867 100644
--- a/kernel/trace/trace_event_profile.c
+++ b/kernel/trace/trace_event_profile.c
@@ -8,6 +8,57 @@
 #include <linux/module.h>
 #include "trace.h"
 
+/*
+ * We can't use a size but a type in alloc_percpu()
+ * So let's create a dummy type that matches the desired size
+ */
+typedef struct {char buf[FTRACE_MAX_PROFILE_SIZE];} profile_buf_t;
+
+char            *trace_profile_buf;
+EXPORT_SYMBOL_GPL(trace_profile_buf);
+
+char            *trace_profile_buf_nmi;
+EXPORT_SYMBOL_GPL(trace_profile_buf_nmi);
+
+/* Count the events in use (per event id, not per instance) */
+static int      total_profile_count;
+
+static int ftrace_profile_enable_event(struct ftrace_event_call *event)
+{
+        char *buf;
+        int ret = -ENOMEM;
+
+        if (atomic_inc_return(&event->profile_count))
+                return 0;
+
+        if (!total_profile_count++) {
+                buf = (char *)alloc_percpu(profile_buf_t);
+                if (!buf)
+                        goto fail_buf;
+
+                rcu_assign_pointer(trace_profile_buf, buf);
+
+                buf = (char *)alloc_percpu(profile_buf_t);
+                if (!buf)
+                        goto fail_buf_nmi;
+
+                rcu_assign_pointer(trace_profile_buf_nmi, buf);
+        }
+
+        ret = event->profile_enable();
+        if (!ret)
+                return 0;
+
+        kfree(trace_profile_buf_nmi);
+fail_buf_nmi:
+        kfree(trace_profile_buf);
+fail_buf:
+        total_profile_count--;
+        atomic_dec(&event->profile_count);
+
+        return ret;
+}
+
 int ftrace_profile_enable(int event_id)
 {
         struct ftrace_event_call *event;
@@ -17,7 +68,7 @@ int ftrace_profile_enable(int event_id)
         list_for_each_entry(event, &ftrace_events, list) {
                 if (event->id == event_id && event->profile_enable &&
                     try_module_get(event->mod)) {
-                        ret = event->profile_enable(event);
+                        ret = ftrace_profile_enable_event(event);
                         break;
                 }
         }
@@ -26,6 +77,33 @@ int ftrace_profile_enable(int event_id)
         return ret;
 }
 
+static void ftrace_profile_disable_event(struct ftrace_event_call *event)
+{
+        char *buf, *nmi_buf;
+
+        if (!atomic_add_negative(-1, &event->profile_count))
+                return;
+
+        event->profile_disable();
+
+        if (!--total_profile_count) {
+                buf = trace_profile_buf;
+                rcu_assign_pointer(trace_profile_buf, NULL);
+
+                nmi_buf = trace_profile_buf_nmi;
+                rcu_assign_pointer(trace_profile_buf_nmi, NULL);
+
+                /*
+                 * Ensure every events in profiling have finished before
+                 * releasing the buffers
+                 */
+                synchronize_sched();
+
+                free_percpu(buf);
+                free_percpu(nmi_buf);
+        }
+}
+
 void ftrace_profile_disable(int event_id)
 {
         struct ftrace_event_call *event;
@@ -33,7 +111,7 @@ void ftrace_profile_disable(int event_id)
         mutex_lock(&event_mutex);
         list_for_each_entry(event, &ftrace_events, list) {
                 if (event->id == event_id) {
-                        event->profile_disable(event);
+                        ftrace_profile_disable_event(event);
                         module_put(event->mod);
                         break;
                 }
diff --git a/kernel/trace/trace_events.c b/kernel/trace/trace_events.c
index 56c260b83a9c..6f03c8a1105e 100644
--- a/kernel/trace/trace_events.c
+++ b/kernel/trace/trace_events.c
@@ -271,42 +271,32 @@ ftrace_event_write(struct file *file, const char __user *ubuf,
 static void *
 t_next(struct seq_file *m, void *v, loff_t *pos)
 {
-        struct list_head *list = m->private;
-        struct ftrace_event_call *call;
+        struct ftrace_event_call *call = v;
 
         (*pos)++;
 
-        for (;;) {
-                if (list == &ftrace_events)
-                        return NULL;
-
-                call = list_entry(list, struct ftrace_event_call, list);
-
+        list_for_each_entry_continue(call, &ftrace_events, list) {
                 /*
                  * The ftrace subsystem is for showing formats only.
                  * They can not be enabled or disabled via the event files.
                  */
                 if (call->regfunc)
-                        break;
-
-                list = list->next;
+                        return call;
         }
 
-        m->private = list->next;
-
-        return call;
+        return NULL;
 }
 
 static void *t_start(struct seq_file *m, loff_t *pos)
 {
-        struct ftrace_event_call *call = NULL;
+        struct ftrace_event_call *call;
         loff_t l;
 
         mutex_lock(&event_mutex);
 
-        m->private = ftrace_events.next;
+        call = list_entry(&ftrace_events, struct ftrace_event_call, list);
         for (l = 0; l <= *pos; ) {
-                call = t_next(m, NULL, &l);
+                call = t_next(m, call, &l);
                 if (!call)
                         break;
         }
@@ -316,37 +306,28 @@ static void *t_start(struct seq_file *m, loff_t *pos)
 static void *
 s_next(struct seq_file *m, void *v, loff_t *pos)
 {
-        struct list_head *list = m->private;
-        struct ftrace_event_call *call;
+        struct ftrace_event_call *call = v;
 
         (*pos)++;
 
- retry:
-        if (list == &ftrace_events)
-                return NULL;
-
-        call = list_entry(list, struct ftrace_event_call, list);
-
-        if (!call->enabled) {
-                list = list->next;
-                goto retry;
+        list_for_each_entry_continue(call, &ftrace_events, list) {
+                if (call->enabled)
+                        return call;
         }
 
-        m->private = list->next;
-
-        return call;
+        return NULL;
 }
 
 static void *s_start(struct seq_file *m, loff_t *pos)
 {
-        struct ftrace_event_call *call = NULL;
+        struct ftrace_event_call *call;
         loff_t l;
 
         mutex_lock(&event_mutex);
 
-        m->private = ftrace_events.next;
+        call = list_entry(&ftrace_events, struct ftrace_event_call, list);
         for (l = 0; l <= *pos; ) {
-                call = s_next(m, NULL, &l);
+                call = s_next(m, call, &l);
                 if (!call)
                         break;
         }
diff --git a/kernel/trace/trace_printk.c b/kernel/trace/trace_printk.c
index 687699d365ae..2547d8813cf0 100644
--- a/kernel/trace/trace_printk.c
+++ b/kernel/trace/trace_printk.c
@@ -11,7 +11,6 @@
 #include <linux/ftrace.h>
 #include <linux/string.h>
 #include <linux/module.h>
-#include <linux/marker.h>
 #include <linux/mutex.h>
 #include <linux/ctype.h>
 #include <linux/list.h>
diff --git a/kernel/trace/trace_syscalls.c b/kernel/trace/trace_syscalls.c
index 8712ce3c6a0e..7a3550cf2597 100644
--- a/kernel/trace/trace_syscalls.c
+++ b/kernel/trace/trace_syscalls.c
@@ -384,10 +384,13 @@ static int sys_prof_refcount_exit;
 
 static void prof_syscall_enter(struct pt_regs *regs, long id)
 {
-        struct syscall_trace_enter *rec;
         struct syscall_metadata *sys_data;
+        struct syscall_trace_enter *rec;
+        unsigned long flags;
+        char *raw_data;
         int syscall_nr;
         int size;
+        int cpu;
 
         syscall_nr = syscall_get_nr(current, regs);
         if (!test_bit(syscall_nr, enabled_prof_enter_syscalls))
@@ -402,20 +405,38 @@ static void prof_syscall_enter(struct pt_regs *regs, long id)
         size = ALIGN(size + sizeof(u32), sizeof(u64));
         size -= sizeof(u32);
 
-        do {
-                char raw_data[size];
+        if (WARN_ONCE(size > FTRACE_MAX_PROFILE_SIZE,
+                      "profile buffer not large enough"))
+                return;
+
+        /* Protect the per cpu buffer, begin the rcu read side */
+        local_irq_save(flags);
 
-                /* zero the dead bytes from align to not leak stack to user */
-                *(u64 *)(&raw_data[size - sizeof(u64)]) = 0ULL;
+        cpu = smp_processor_id();
+
+        if (in_nmi())
+                raw_data = rcu_dereference(trace_profile_buf_nmi);
+        else
+                raw_data = rcu_dereference(trace_profile_buf);
+
+        if (!raw_data)
+                goto end;
 
-                rec = (struct syscall_trace_enter *) raw_data;
-                tracing_generic_entry_update(&rec->ent, 0, 0);
-                rec->ent.type = sys_data->enter_id;
-                rec->nr = syscall_nr;
-                syscall_get_arguments(current, regs, 0, sys_data->nb_args,
-                                       (unsigned long *)&rec->args);
-                perf_tpcounter_event(sys_data->enter_id, 0, 1, rec, size);
-        } while(0);
+        raw_data = per_cpu_ptr(raw_data, cpu);
+
+        /* zero the dead bytes from align to not leak stack to user */
+        *(u64 *)(&raw_data[size - sizeof(u64)]) = 0ULL;
+
+        rec = (struct syscall_trace_enter *) raw_data;
+        tracing_generic_entry_update(&rec->ent, 0, 0);
+        rec->ent.type = sys_data->enter_id;
+        rec->nr = syscall_nr;
+        syscall_get_arguments(current, regs, 0, sys_data->nb_args,
+                               (unsigned long *)&rec->args);
+        perf_tpcounter_event(sys_data->enter_id, 0, 1, rec, size);
+
+end:
+        local_irq_restore(flags);
 }
 
 int reg_prof_syscall_enter(char *name)
@@ -460,8 +481,12 @@ void unreg_prof_syscall_enter(char *name)
 static void prof_syscall_exit(struct pt_regs *regs, long ret)
 {
         struct syscall_metadata *sys_data;
-        struct syscall_trace_exit rec;
+        struct syscall_trace_exit *rec;
+        unsigned long flags;
         int syscall_nr;
+        char *raw_data;
+        int size;
+        int cpu;
 
         syscall_nr = syscall_get_nr(current, regs);
         if (!test_bit(syscall_nr, enabled_prof_exit_syscalls))
@@ -471,12 +496,46 @@ static void prof_syscall_exit(struct pt_regs *regs, long ret)
         if (!sys_data)
                 return;
 
-        tracing_generic_entry_update(&rec.ent, 0, 0);
-        rec.ent.type = sys_data->exit_id;
-        rec.nr = syscall_nr;
-        rec.ret = syscall_get_return_value(current, regs);
+        /* We can probably do that at build time */
+        size = ALIGN(sizeof(*rec) + sizeof(u32), sizeof(u64));
+        size -= sizeof(u32);
 
-        perf_tpcounter_event(sys_data->exit_id, 0, 1, &rec, sizeof(rec));
+        /*
+         * Impossible, but be paranoid with the future
+         * How to put this check outside runtime?
+         */
+        if (WARN_ONCE(size > FTRACE_MAX_PROFILE_SIZE,
+                "exit event has grown above profile buffer size"))
+                return;
+
+        /* Protect the per cpu buffer, begin the rcu read side */
+        local_irq_save(flags);
+        cpu = smp_processor_id();
+
+        if (in_nmi())
+                raw_data = rcu_dereference(trace_profile_buf_nmi);
+        else
+                raw_data = rcu_dereference(trace_profile_buf);
+
+        if (!raw_data)
+                goto end;
+
+        raw_data = per_cpu_ptr(raw_data, cpu);
+
+        /* zero the dead bytes from align to not leak stack to user */
+        *(u64 *)(&raw_data[size - sizeof(u64)]) = 0ULL;
+
+        rec = (struct syscall_trace_exit *)raw_data;
+
+        tracing_generic_entry_update(&rec->ent, 0, 0);
+        rec->ent.type = sys_data->exit_id;
+        rec->nr = syscall_nr;
+        rec->ret = syscall_get_return_value(current, regs);
+
+        perf_tpcounter_event(sys_data->exit_id, 0, 1, rec, size);
+
+end:
+        local_irq_restore(flags);
 }
 
 int reg_prof_syscall_exit(char *name)