Merge tag 'trace-v4.4' of git://git.kernel.org/pub/scm/linux/kernel/git/rostedt/linux-trace

Pull tracking updates from Steven Rostedt:
 "Most of the changes are clean ups and small fixes.  Some of them have
  stable tags to them.  I searched through my INBOX just as the merge
  window opened and found lots of patches to pull.  I ran them through
  all my tests and they were in linux-next for a few days.

  Features added this release:
  ----------------------------

   - Module globbing.  You can now filter function tracing to several
     modules.  # echo '*:mod:*snd*' > set_ftrace_filter (Dmitry Safonov)

   - Tracer specific options are now visible even when the tracer is not
     active.  It was rather annoying that you can only see and modify
     tracer options after enabling the tracer.  Now they are in the
     options/ directory even when the tracer is not active.  Although
     they are still only visible when the tracer is active in the
     trace_options file.

   - Trace options are now per instance (although some of the tracer
     specific options are global)

   - New tracefs file: set_event_pid.  If any pid is added to this file,
     then all events in the instance will filter out events that are not
     part of this pid.  sched_switch and sched_wakeup events handle next
     and the wakee pids"

* tag 'trace-v4.4' of git://git.kernel.org/pub/scm/linux/kernel/git/rostedt/linux-trace: (68 commits)
  tracefs: Fix refcount imbalance in start_creating()
  tracing: Put back comma for empty fields in boot string parsing
  tracing: Apply tracer specific options from kernel command line.
  tracing: Add some documentation about set_event_pid
  ring_buffer: Remove unneeded smp_wmb() before wakeup of reader benchmark
  tracing: Allow dumping traces without tracking trace started cpus
  ring_buffer: Fix more races when terminating the producer in the benchmark
  ring_buffer: Do no not complete benchmark reader too early
  tracing: Remove redundant TP_ARGS redefining
  tracing: Rename max_stack_lock to stack_trace_max_lock
  tracing: Allow arch-specific stack tracer
  recordmcount: arm64: Replace the ignored mcount call into nop
  recordmcount: Fix endianness handling bug for nop_mcount
  tracepoints: Fix documentation of RCU lockdep checks
  tracing: ftrace_event_is_function() can return boolean
  tracing: is_legal_op() can return boolean
  ring-buffer: rb_event_is_commit() can return boolean
  ring-buffer: rb_per_cpu_empty() can return boolean
  ring_buffer: ring_buffer_empty{cpu}() can return boolean
  ring-buffer: rb_is_reader_page() can return boolean
  ...

1 files changed, 49 insertions, 43 deletions

diff --git a/kernel/trace/trace_stack.c b/kernel/trace/trace_stack.c
index 8abf1ba18085..dda9e6742950 100644
--- a/kernel/trace/trace_stack.c
+++ b/kernel/trace/trace_stack.c
@@ -16,24 +16,22 @@
 
 #include "trace.h"
 
-#define STACK_TRACE_ENTRIES 500
-
 static unsigned long stack_dump_trace[STACK_TRACE_ENTRIES+1] =
          { [0 ... (STACK_TRACE_ENTRIES)] = ULONG_MAX };
-static unsigned stack_dump_index[STACK_TRACE_ENTRIES];
+unsigned stack_trace_index[STACK_TRACE_ENTRIES];
 
 /*
  * Reserve one entry for the passed in ip. This will allow
  * us to remove most or all of the stack size overhead
  * added by the stack tracer itself.
  */
-static struct stack_trace max_stack_trace = {
+struct stack_trace stack_trace_max = {
         .max_entries            = STACK_TRACE_ENTRIES - 1,
         .entries                = &stack_dump_trace[0],
 };
 
-static unsigned long max_stack_size;
-static arch_spinlock_t max_stack_lock =
+unsigned long stack_trace_max_size;
+arch_spinlock_t stack_trace_max_lock =
         (arch_spinlock_t)__ARCH_SPIN_LOCK_UNLOCKED;
 
 static DEFINE_PER_CPU(int, trace_active);
@@ -42,30 +40,38 @@ static DEFINE_MUTEX(stack_sysctl_mutex);
 int stack_tracer_enabled;
 static int last_stack_tracer_enabled;
 
-static inline void print_max_stack(void)
+void stack_trace_print(void)
 {
         long i;
         int size;
 
         pr_emerg("        Depth    Size   Location    (%d entries)\n"
                            "        -----    ----   --------\n",
-                           max_stack_trace.nr_entries);
+                           stack_trace_max.nr_entries);
 
-        for (i = 0; i < max_stack_trace.nr_entries; i++) {
+        for (i = 0; i < stack_trace_max.nr_entries; i++) {
                 if (stack_dump_trace[i] == ULONG_MAX)
                         break;
-                if (i+1 == max_stack_trace.nr_entries ||
+                if (i+1 == stack_trace_max.nr_entries ||
                                 stack_dump_trace[i+1] == ULONG_MAX)
-                        size = stack_dump_index[i];
+                        size = stack_trace_index[i];
                 else
-                        size = stack_dump_index[i] - stack_dump_index[i+1];
+                        size = stack_trace_index[i] - stack_trace_index[i+1];
 
-                pr_emerg("%3ld) %8d   %5d   %pS\n", i, stack_dump_index[i],
+                pr_emerg("%3ld) %8d   %5d   %pS\n", i, stack_trace_index[i],
                                 size, (void *)stack_dump_trace[i]);
         }
 }
 
-static inline void
+/*
+ * When arch-specific code overides this function, the following
+ * data should be filled up, assuming stack_trace_max_lock is held to
+ * prevent concurrent updates.
+ *     stack_trace_index[]
+ *     stack_trace_max
+ *     stack_trace_max_size
+ */
+void __weak
 check_stack(unsigned long ip, unsigned long *stack)
 {
         unsigned long this_size, flags; unsigned long *p, *top, *start;
@@ -78,7 +84,7 @@ check_stack(unsigned long ip, unsigned long *stack)
         /* Remove the frame of the tracer */
         this_size -= frame_size;
 
-        if (this_size <= max_stack_size)
+        if (this_size <= stack_trace_max_size)
                 return;
 
         /* we do not handle interrupt stacks yet */
@@ -90,7 +96,7 @@ check_stack(unsigned long ip, unsigned long *stack)
                 return;
 
         local_irq_save(flags);
-        arch_spin_lock(&max_stack_lock);
+        arch_spin_lock(&stack_trace_max_lock);
 
         /*
          * RCU may not be watching, make it see us.
@@ -103,18 +109,18 @@ check_stack(unsigned long ip, unsigned long *stack)
                 this_size -= tracer_frame;
 
         /* a race could have already updated it */
-        if (this_size <= max_stack_size)
+        if (this_size <= stack_trace_max_size)
                 goto out;
 
-        max_stack_size = this_size;
+        stack_trace_max_size = this_size;
 
-        max_stack_trace.nr_entries = 0;
-        max_stack_trace.skip = 3;
+        stack_trace_max.nr_entries = 0;
+        stack_trace_max.skip = 3;
 
-        save_stack_trace(&max_stack_trace);
+        save_stack_trace(&stack_trace_max);
 
         /* Skip over the overhead of the stack tracer itself */
-        for (i = 0; i < max_stack_trace.nr_entries; i++) {
+        for (i = 0; i < stack_trace_max.nr_entries; i++) {
                 if (stack_dump_trace[i] == ip)
                         break;
         }
@@ -134,18 +140,18 @@ check_stack(unsigned long ip, unsigned long *stack)
          * loop will only happen once. This code only takes place
          * on a new max, so it is far from a fast path.
          */
-        while (i < max_stack_trace.nr_entries) {
+        while (i < stack_trace_max.nr_entries) {
                 int found = 0;
 
-                stack_dump_index[x] = this_size;
+                stack_trace_index[x] = this_size;
                 p = start;
 
-                for (; p < top && i < max_stack_trace.nr_entries; p++) {
+                for (; p < top && i < stack_trace_max.nr_entries; p++) {
                         if (stack_dump_trace[i] == ULONG_MAX)
                                 break;
                         if (*p == stack_dump_trace[i]) {
                                 stack_dump_trace[x] = stack_dump_trace[i++];
-                                this_size = stack_dump_index[x++] =
+                                this_size = stack_trace_index[x++] =
                                         (top - p) * sizeof(unsigned long);
                                 found = 1;
                                 /* Start the search from here */
@@ -160,7 +166,7 @@ check_stack(unsigned long ip, unsigned long *stack)
                                 if (unlikely(!tracer_frame)) {
                                         tracer_frame = (p - stack) *
                                                 sizeof(unsigned long);
-                                        max_stack_size -= tracer_frame;
+                                        stack_trace_max_size -= tracer_frame;
                                 }
                         }
                 }
@@ -169,18 +175,18 @@ check_stack(unsigned long ip, unsigned long *stack)
                         i++;
         }
 
-        max_stack_trace.nr_entries = x;
+        stack_trace_max.nr_entries = x;
         for (; x < i; x++)
                 stack_dump_trace[x] = ULONG_MAX;
 
         if (task_stack_end_corrupted(current)) {
-                print_max_stack();
+                stack_trace_print();
                 BUG();
         }
 
  out:
         rcu_irq_exit();
-        arch_spin_unlock(&max_stack_lock);
+        arch_spin_unlock(&stack_trace_max_lock);
         local_irq_restore(flags);
 }
 
@@ -251,9 +257,9 @@ stack_max_size_write(struct file *filp, const char __user *ubuf,
         cpu = smp_processor_id();
         per_cpu(trace_active, cpu)++;
 
-        arch_spin_lock(&max_stack_lock);
+        arch_spin_lock(&stack_trace_max_lock);
         *ptr = val;
-        arch_spin_unlock(&max_stack_lock);
+        arch_spin_unlock(&stack_trace_max_lock);
 
         per_cpu(trace_active, cpu)--;
         local_irq_restore(flags);
@@ -273,7 +279,7 @@ __next(struct seq_file *m, loff_t *pos)
 {
         long n = *pos - 1;
 
-        if (n > max_stack_trace.nr_entries || stack_dump_trace[n] == ULONG_MAX)
+        if (n > stack_trace_max.nr_entries || stack_dump_trace[n] == ULONG_MAX)
                 return NULL;
 
         m->private = (void *)n;
@@ -296,7 +302,7 @@ static void *t_start(struct seq_file *m, loff_t *pos)
         cpu = smp_processor_id();
         per_cpu(trace_active, cpu)++;
 
-        arch_spin_lock(&max_stack_lock);
+        arch_spin_lock(&stack_trace_max_lock);
 
         if (*pos == 0)
                 return SEQ_START_TOKEN;
@@ -308,7 +314,7 @@ static void t_stop(struct seq_file *m, void *p)
 {
         int cpu;
 
-        arch_spin_unlock(&max_stack_lock);
+        arch_spin_unlock(&stack_trace_max_lock);
 
         cpu = smp_processor_id();
         per_cpu(trace_active, cpu)--;
@@ -343,9 +349,9 @@ static int t_show(struct seq_file *m, void *v)
                 seq_printf(m, "        Depth    Size   Location"
                            "    (%d entries)\n"
                            "        -----    ----   --------\n",
-                           max_stack_trace.nr_entries);
+                           stack_trace_max.nr_entries);
 
-                if (!stack_tracer_enabled && !max_stack_size)
+                if (!stack_tracer_enabled && !stack_trace_max_size)
                         print_disabled(m);
 
                 return 0;
@@ -353,17 +359,17 @@ static int t_show(struct seq_file *m, void *v)
 
         i = *(long *)v;
 
-        if (i >= max_stack_trace.nr_entries ||
+        if (i >= stack_trace_max.nr_entries ||
             stack_dump_trace[i] == ULONG_MAX)
                 return 0;
 
-        if (i+1 == max_stack_trace.nr_entries ||
+        if (i+1 == stack_trace_max.nr_entries ||
             stack_dump_trace[i+1] == ULONG_MAX)
-                size = stack_dump_index[i];
+                size = stack_trace_index[i];
         else
-                size = stack_dump_index[i] - stack_dump_index[i+1];
+                size = stack_trace_index[i] - stack_trace_index[i+1];
 
-        seq_printf(m, "%3ld) %8d   %5d   ", i, stack_dump_index[i], size);
+        seq_printf(m, "%3ld) %8d   %5d   ", i, stack_trace_index[i], size);
 
         trace_lookup_stack(m, i);
 
@@ -453,7 +459,7 @@ static __init int stack_trace_init(void)
                 return 0;
 
         trace_create_file("stack_max_size", 0644, d_tracer,
-                        &max_stack_size, &stack_max_size_fops);
+                        &stack_trace_max_size, &stack_max_size_fops);
 
         trace_create_file("stack_trace", 0444, d_tracer,
                         NULL, &stack_trace_fops);