6 files changed, 50 insertions, 32 deletions

diff --git a/kernel/Makefile b/kernel/Makefile
index 703cf3b7389c..19fad003b19d 100644
--- a/kernel/Makefile
+++ b/kernel/Makefile
@@ -21,10 +21,6 @@ CFLAGS_REMOVE_cgroup-debug.o = -pg
 CFLAGS_REMOVE_sched_clock.o = -pg
 CFLAGS_REMOVE_sched.o = -pg
 endif
-ifdef CONFIG_FUNCTION_GRAPH_TRACER
-CFLAGS_REMOVE_extable.o = -pg # For __kernel_text_address()
-CFLAGS_REMOVE_module.o = -pg # For __module_text_address()
-endif
 
 obj-$(CONFIG_FREEZER) += freezer.o
 obj-$(CONFIG_PROFILING) += profile.o
diff --git a/kernel/extable.c b/kernel/extable.c
index a26cb2e17023..feb0317cf09a 100644
--- a/kernel/extable.c
+++ b/kernel/extable.c
@@ -17,6 +17,7 @@
 */
 #include <linux/module.h>
 #include <linux/init.h>
+#include <linux/ftrace.h>
 #include <asm/uaccess.h>
 #include <asm/sections.h>
 
@@ -40,7 +41,7 @@ const struct exception_table_entry *search_exception_tables(unsigned long addr)
         return e;
 }
 
-int core_kernel_text(unsigned long addr)
+__notrace_funcgraph int core_kernel_text(unsigned long addr)
 {
         if (addr >= (unsigned long)_stext &&
             addr <= (unsigned long)_etext)
@@ -53,7 +54,7 @@ int core_kernel_text(unsigned long addr)
         return 0;
 }
 
-int __kernel_text_address(unsigned long addr)
+__notrace_funcgraph int __kernel_text_address(unsigned long addr)
 {
         if (core_kernel_text(addr))
                 return 1;
diff --git a/kernel/module.c b/kernel/module.c
index 89bcf7c1327d..dd2a54155b54 100644
--- a/kernel/module.c
+++ b/kernel/module.c
@@ -2704,7 +2704,7 @@ int is_module_address(unsigned long addr)
 
 
 /* Is this a valid kernel address? */
-struct module *__module_text_address(unsigned long addr)
+__notrace_funcgraph struct module *__module_text_address(unsigned long addr)
 {
         struct module *mod;
 
diff --git a/kernel/trace/ftrace.c b/kernel/trace/ftrace.c
index 2971fe48f55e..a12f80efceaa 100644
--- a/kernel/trace/ftrace.c
+++ b/kernel/trace/ftrace.c
@@ -1998,6 +1998,7 @@ static int alloc_retstack_tasklist(struct ftrace_ret_stack **ret_stack_list)
                         /* Make sure IRQs see the -1 first: */
                         barrier();
                         t->ret_stack = ret_stack_list[start++];
+                        atomic_set(&t->tracing_graph_pause, 0);
                         atomic_set(&t->trace_overrun, 0);
                 }
         } while_each_thread(g, t);
@@ -2077,6 +2078,7 @@ void ftrace_graph_init_task(struct task_struct *t)
                 if (!t->ret_stack)
                         return;
                 t->curr_ret_stack = -1;
+                atomic_set(&t->tracing_graph_pause, 0);
                 atomic_set(&t->trace_overrun, 0);
         } else
                 t->ret_stack = NULL;
diff --git a/kernel/trace/trace.c b/kernel/trace/trace.c
index 7a93c663e52a..8ebe0070c47a 100644
--- a/kernel/trace/trace.c
+++ b/kernel/trace/trace.c
@@ -44,13 +44,14 @@
 unsigned long __read_mostly     tracing_max_latency = (cycle_t)ULONG_MAX;
 unsigned long __read_mostly     tracing_thresh;
 
-/* We need to change this state when a selftest is running.
+/*
+ * We need to change this state when a selftest is running.
  * A selftest will lurk into the ring-buffer to count the
  * entries inserted during the selftest although some concurrent
  * insertions into the ring-buffer such as ftrace_printk could occurred
  * at the same time, giving false positive or negative results.
  */
-static atomic_t tracing_selftest_running = ATOMIC_INIT(0);
+static bool __read_mostly tracing_selftest_running;
 
 /* For tracers that don't implement custom flags */
 static struct tracer_opt dummy_tracer_opt[] = {
@@ -574,6 +575,8 @@ int register_tracer(struct tracer *type)
         unlock_kernel();
         mutex_lock(&trace_types_lock);
 
+        tracing_selftest_running = true;
+
         for (t = trace_types; t; t = t->next) {
                 if (strcmp(type->name, t->name) == 0) {
                         /* already found */
@@ -598,7 +601,6 @@ int register_tracer(struct tracer *type)
                 struct trace_array *tr = &global_trace;
                 int i;
 
-                atomic_set(&tracing_selftest_running, 1);
                 /*
                  * Run a selftest on this tracer.
                  * Here we reset the trace buffer, and set the current
@@ -613,7 +615,6 @@ int register_tracer(struct tracer *type)
                 /* the test is responsible for initializing and enabling */
                 pr_info("Testing tracer %s: ", type->name);
                 ret = type->selftest(type, tr);
-                atomic_set(&tracing_selftest_running, 0);
                 /* the test is responsible for resetting too */
                 current_trace = saved_tracer;
                 if (ret) {
@@ -635,6 +636,7 @@ int register_tracer(struct tracer *type)
                 max_tracer_type_len = len;
 
  out:
+        tracing_selftest_running = false;
         mutex_unlock(&trace_types_lock);
         lock_kernel();
 
@@ -3588,24 +3590,17 @@ static __init int tracer_init_debugfs(void)
 
 int trace_vprintk(unsigned long ip, int depth, const char *fmt, va_list args)
 {
-        /*
-         * Raw Spinlock because a normal spinlock would be traced here
-         * and append an irrelevant couple spin_lock_irqsave/
-         * spin_unlock_irqrestore traced by ftrace around this
-         * TRACE_PRINTK trace.
-         */
-        static raw_spinlock_t trace_buf_lock =
-                                (raw_spinlock_t)__RAW_SPIN_LOCK_UNLOCKED;
+        static DEFINE_SPINLOCK(trace_buf_lock);
         static char trace_buf[TRACE_BUF_SIZE];
 
         struct ring_buffer_event *event;
         struct trace_array *tr = &global_trace;
         struct trace_array_cpu *data;
-        struct print_entry *entry;
-        unsigned long flags, irq_flags;
         int cpu, len = 0, size, pc;
+        struct print_entry *entry;
+        unsigned long irq_flags;
 
-        if (tracing_disabled || atomic_read(&tracing_selftest_running))
+        if (tracing_disabled || tracing_selftest_running)
                 return 0;
 
         pc = preempt_count();
@@ -3616,8 +3611,8 @@ int trace_vprintk(unsigned long ip, int depth, const char *fmt, va_list args)
         if (unlikely(atomic_read(&data->disabled)))
                 goto out;
 
-        local_irq_save(flags);
-        __raw_spin_lock(&trace_buf_lock);
+        pause_graph_tracing();
+        spin_lock_irqsave(&trace_buf_lock, irq_flags);
         len = vsnprintf(trace_buf, TRACE_BUF_SIZE, fmt, args);
 
         len = min(len, TRACE_BUF_SIZE-1);
@@ -3628,7 +3623,7 @@ int trace_vprintk(unsigned long ip, int depth, const char *fmt, va_list args)
         if (!event)
                 goto out_unlock;
         entry = ring_buffer_event_data(event);
-        tracing_generic_entry_update(&entry->ent, flags, pc);
+        tracing_generic_entry_update(&entry->ent, irq_flags, pc);
         entry->ent.type                 = TRACE_PRINT;
         entry->ip                       = ip;
         entry->depth                    = depth;
@@ -3638,9 +3633,8 @@ int trace_vprintk(unsigned long ip, int depth, const char *fmt, va_list args)
         ring_buffer_unlock_commit(tr->buffer, event, irq_flags);
 
  out_unlock:
-        __raw_spin_unlock(&trace_buf_lock);
-        local_irq_restore(flags);
-
+        spin_unlock_irqrestore(&trace_buf_lock, irq_flags);
+        unpause_graph_tracing();
  out:
         preempt_enable_notrace();
 
diff --git a/kernel/trace/trace_functions_graph.c b/kernel/trace/trace_functions_graph.c
index 32b7fb9a19df..af60eef4cbcc 100644
--- a/kernel/trace/trace_functions_graph.c
+++ b/kernel/trace/trace_functions_graph.c
@@ -570,11 +570,36 @@ print_graph_function(struct trace_iterator *iter)
         }
 }
 
+static void print_graph_headers(struct seq_file *s)
+{
+        /* 1st line */
+        seq_printf(s, "# ");
+        if (tracer_flags.val & TRACE_GRAPH_PRINT_CPU)
+                seq_printf(s, "CPU ");
+        if (tracer_flags.val & TRACE_GRAPH_PRINT_PROC)
+                seq_printf(s, "TASK/PID     ");
+        if (tracer_flags.val & TRACE_GRAPH_PRINT_OVERHEAD)
+                seq_printf(s, "OVERHEAD/");
+        seq_printf(s, "DURATION            FUNCTION CALLS\n");
+
+        /* 2nd line */
+        seq_printf(s, "# ");
+        if (tracer_flags.val & TRACE_GRAPH_PRINT_CPU)
+                seq_printf(s, "|   ");
+        if (tracer_flags.val & TRACE_GRAPH_PRINT_PROC)
+                seq_printf(s, "|      |     ");
+        if (tracer_flags.val & TRACE_GRAPH_PRINT_OVERHEAD) {
+                seq_printf(s, "|        ");
+                seq_printf(s, "|                   |   |   |   |\n");
+        } else
+                seq_printf(s, "    |               |   |   |   |\n");
+}
 static struct tracer graph_trace __read_mostly = {
-        .name        = "function_graph",
-        .init        = graph_trace_init,
-        .reset       = graph_trace_reset,
-        .print_line = print_graph_function,
+        .name           = "function_graph",
+        .init           = graph_trace_init,
+        .reset          = graph_trace_reset,
+        .print_line     = print_graph_function,
+        .print_header   = print_graph_headers,
         .flags          = &tracer_flags,
 };