Merge branch 'devel' into next

[mv-sheeva.git] / kernel / trace / trace.c

diff --git a/kernel/trace/trace.c b/kernel/trace/trace.c
index 0feae23d98931e1f1a725296fc0977411fc09eb3..868e121c8e385f36604271ddf93d97bb92f24dd0 100644 (file)
--- a/kernel/trace/trace.c
+++ b/kernel/trace/trace.c
@@ -27,6 +27,7 @@
 #include <linux/poll.h>
 #include <linux/gfp.h>
 #include <linux/fs.h>
+#include <linux/kprobes.h>
 #include <linux/writeback.h>
 
 #include <linux/stacktrace.h>
@@ -42,11 +43,6 @@ static cpumask_t __read_mostly               tracing_buffer_mask;
 #define for_each_tracing_cpu(cpu)      \
        for_each_cpu_mask(cpu, tracing_buffer_mask)
 
-/* dummy trace to disable tracing */
-static struct tracer no_tracer __read_mostly = {
-       .name           = "none",
-};
-
 static int trace_alloc_page(void);
 static int trace_free_page(void);
 
@@ -100,6 +96,9 @@ static DEFINE_PER_CPU(struct trace_array_cpu, max_data);
 /* tracer_enabled is used to toggle activation of a tracer */
 static int                     tracer_enabled = 1;
 
+/* function tracing enabled */
+int                            ftrace_function_enabled;
+
 /*
  * trace_nr_entries is the number of entries that is allocated
  * for a buffer. Note, the number of entries is always rounded
@@ -134,6 +133,24 @@ static DECLARE_WAIT_QUEUE_HEAD(trace_wait);
 /* trace_flags holds iter_ctrl options */
 unsigned long trace_flags = TRACE_ITER_PRINT_PARENT;
 
+static notrace void no_trace_init(struct trace_array *tr)
+{
+       int cpu;
+
+       ftrace_function_enabled = 0;
+       if(tr->ctrl)
+               for_each_online_cpu(cpu)
+                       tracing_reset(tr->data[cpu]);
+       tracer_enabled = 0;
+}
+
+/* dummy trace to disable tracing */
+static struct tracer no_tracer __read_mostly = {
+       .name           = "none",
+       .init           = no_trace_init
+};
+
+
 /**
  * trace_wake_up - wake up tasks waiting for trace input
  *
@@ -835,6 +852,48 @@ ftrace(struct trace_array *tr, struct trace_array_cpu *data,
                trace_function(tr, data, ip, parent_ip, flags);
 }
 
+#ifdef CONFIG_MMIOTRACE
+void __trace_mmiotrace_rw(struct trace_array *tr, struct trace_array_cpu *data,
+                                               struct mmiotrace_rw *rw)
+{
+       struct trace_entry *entry;
+       unsigned long irq_flags;
+
+       raw_local_irq_save(irq_flags);
+       __raw_spin_lock(&data->lock);
+
+       entry                   = tracing_get_trace_entry(tr, data);
+       tracing_generic_entry_update(entry, 0);
+       entry->type             = TRACE_MMIO_RW;
+       entry->mmiorw           = *rw;
+
+       __raw_spin_unlock(&data->lock);
+       raw_local_irq_restore(irq_flags);
+
+       trace_wake_up();
+}
+
+void __trace_mmiotrace_map(struct trace_array *tr, struct trace_array_cpu *data,
+                                               struct mmiotrace_map *map)
+{
+       struct trace_entry *entry;
+       unsigned long irq_flags;
+
+       raw_local_irq_save(irq_flags);
+       __raw_spin_lock(&data->lock);
+
+       entry                   = tracing_get_trace_entry(tr, data);
+       tracing_generic_entry_update(entry, 0);
+       entry->type             = TRACE_MMIO_MAP;
+       entry->mmiomap          = *map;
+
+       __raw_spin_unlock(&data->lock);
+       raw_local_irq_restore(irq_flags);
+
+       trace_wake_up();
+}
+#endif
+
 void __trace_stack(struct trace_array *tr,
                   struct trace_array_cpu *data,
                   unsigned long flags,
@@ -972,7 +1031,10 @@ function_trace_call(unsigned long ip, unsigned long parent_ip)
        long disabled;
        int cpu;
 
-       if (unlikely(!tracer_enabled))
+       if (unlikely(!ftrace_function_enabled))
+               return;
+
+       if (skip_trace(ip))
                return;
 
        local_irq_save(flags);
@@ -994,11 +1056,15 @@ static struct ftrace_ops trace_ops __read_mostly =
 
 void tracing_start_function_trace(void)
 {
+       ftrace_function_enabled = 0;
        register_ftrace_function(&trace_ops);
+       if (tracer_enabled)
+               ftrace_function_enabled = 1;
 }
 
 void tracing_stop_function_trace(void)
 {
+       ftrace_function_enabled = 0;
        unregister_ftrace_function(&trace_ops);
 }
 #endif
@@ -1199,6 +1265,20 @@ static void s_stop(struct seq_file *m, void *p)
        mutex_unlock(&trace_types_lock);
 }
 
+#define KRETPROBE_MSG "[unknown/kretprobe'd]"
+
+#ifdef CONFIG_KRETPROBES
+static inline int kretprobed(unsigned long addr)
+{
+       return addr == (unsigned long)kretprobe_trampoline;
+}
+#else
+static inline int kretprobed(unsigned long addr)
+{
+       return 0;
+}
+#endif /* CONFIG_KRETPROBES */
+
 static int
 seq_print_sym_short(struct trace_seq *s, const char *fmt, unsigned long address)
 {
@@ -1311,7 +1391,7 @@ print_trace_header(struct seq_file *m, struct trace_iterator *iter)
                   "server",
 #elif defined(CONFIG_PREEMPT_VOLUNTARY)
                   "desktop",
-#elif defined(CONFIG_PREEMPT_DESKTOP)
+#elif defined(CONFIG_PREEMPT)
                   "preempt",
 #else
                   "unknown",
@@ -1434,7 +1514,10 @@ print_lat_fmt(struct trace_iterator *iter, unsigned int trace_idx, int cpu)
        case TRACE_FN:
                seq_print_ip_sym(s, entry->fn.ip, sym_flags);
                trace_seq_puts(s, " (");
-               seq_print_ip_sym(s, entry->fn.parent_ip, sym_flags);
+               if (kretprobed(entry->fn.parent_ip))
+                       trace_seq_puts(s, KRETPROBE_MSG);
+               else
+                       seq_print_ip_sym(s, entry->fn.parent_ip, sym_flags);
                trace_seq_puts(s, ")\n");
                break;
        case TRACE_CTX:
@@ -1514,8 +1597,11 @@ static int print_trace_fmt(struct trace_iterator *iter)
                        ret = trace_seq_printf(s, " <-");
                        if (!ret)
                                return 0;
-                       ret = seq_print_ip_sym(s, entry->fn.parent_ip,
-                                              sym_flags);
+                       if (kretprobed(entry->fn.parent_ip))
+                               ret = trace_seq_puts(s, KRETPROBE_MSG);
+                       else
+                               ret = seq_print_ip_sym(s, entry->fn.parent_ip,
+                                                      sym_flags);
                        if (!ret)
                                return 0;
                }
@@ -1814,8 +1900,10 @@ __tracing_open(struct inode *inode, struct file *file, int *ret)
                m->private = iter;
 
                /* stop the trace while dumping */
-               if (iter->tr->ctrl)
+               if (iter->tr->ctrl) {
                        tracer_enabled = 0;
+                       ftrace_function_enabled = 0;
+               }
 
                if (iter->trace && iter->trace->open)
                        iter->trace->open(iter);
@@ -1848,8 +1936,14 @@ int tracing_release(struct inode *inode, struct file *file)
                iter->trace->close(iter);
 
        /* reenable tracing if it was previously enabled */
-       if (iter->tr->ctrl)
+       if (iter->tr->ctrl) {
                tracer_enabled = 1;
+               /*
+                * It is safe to enable function tracing even if it
+                * isn't used
+                */
+               ftrace_function_enabled = 1;
+       }
        mutex_unlock(&trace_types_lock);
 
        seq_release(inode, file);
@@ -2835,6 +2929,9 @@ static __init void tracer_init_debugfs(void)
                pr_warning("Could not create debugfs "
                           "'dyn_ftrace_total_info' entry\n");
 #endif
+#ifdef CONFIG_SYSPROF_TRACER
+       init_tracer_sysprof_debugfs(d_tracer);
+#endif
 }
 
 static int trace_alloc_page(void)
@@ -3018,9 +3115,8 @@ __init static int tracer_alloc_buffers(void)
        }
        max_tr.entries = global_trace.entries;
 
-       pr_info("tracer: %d pages allocated for %ld",
-               pages, trace_nr_entries);
-       pr_info(" entries of %ld bytes\n", (long)TRACE_ENTRY_SIZE);
+       pr_info("tracer: %d pages allocated for %ld entries of %ld bytes\n",
+               pages, trace_nr_entries, (long)TRACE_ENTRY_SIZE);
        pr_info("   actual entries %ld\n", global_trace.entries);
 
        tracer_init_debugfs();