Merge branch 'core-stacktrace-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip

Pull stack trace updates from Ingo Molnar:
 "So Thomas looked at the stacktrace code recently and noticed a few
  weirdnesses, and we all know how such stories of crummy kernel code
  meeting German engineering perfection end: a 45-patch series to clean
  it all up! :-)

  Here's the changes in Thomas's words:

   'Struct stack_trace is a sinkhole for input and output parameters
    which is largely pointless for most usage sites. In fact if embedded
    into other data structures it creates indirections and extra storage
    overhead for no benefit.

    Looking at all usage sites makes it clear that they just require an
    interface which is based on a storage array. That array is either on
    stack, global or embedded into some other data structure.

    Some of the stack depot usage sites are outright wrong, but
    fortunately the wrongness just causes more stack being used for
    nothing and does not have functional impact.

    Another oddity is the inconsistent termination of the stack trace
    with ULONG_MAX. It's pointless as the number of entries is what
    determines the length of the stored trace. In fact quite some call
    sites remove the ULONG_MAX marker afterwards with or without nasty
    comments about it. Not all architectures do that and those which do,
    do it inconsistenly either conditional on nr_entries == 0 or
    unconditionally.

    The following series cleans that up by:

      1) Removing the ULONG_MAX termination in the architecture code

      2) Removing the ULONG_MAX fixups at the call sites

      3) Providing plain storage array based interfaces for stacktrace
         and stackdepot.

      4) Cleaning up the mess at the callsites including some related
         cleanups.

      5) Removing the struct stack_trace based interfaces

    This is not changing the struct stack_trace interfaces at the
    architecture level, but it removes the exposure to the generic
    code'"

* 'core-stacktrace-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip: (45 commits)
  x86/stacktrace: Use common infrastructure
  stacktrace: Provide common infrastructure
  lib/stackdepot: Remove obsolete functions
  stacktrace: Remove obsolete functions
  livepatch: Simplify stack trace retrieval
  tracing: Remove the last struct stack_trace usage
  tracing: Simplify stack trace retrieval
  tracing: Make ftrace_trace_userstack() static and conditional
  tracing: Use percpu stack trace buffer more intelligently
  tracing: Simplify stacktrace retrieval in histograms
  lockdep: Simplify stack trace handling
  lockdep: Remove save argument from check_prev_add()
  lockdep: Remove unused trace argument from print_circular_bug()
  drm: Simplify stacktrace handling
  dm persistent data: Simplify stack trace handling
  dm bufio: Simplify stack trace retrieval
  btrfs: ref-verify: Simplify stack trace retrieval
  dma/debug: Simplify stracktrace retrieval
  fault-inject: Simplify stacktrace retrieval
  mm/page_owner: Simplify stack trace handling
  ...

1 files changed, 38 insertions, 49 deletions

diff --git a/kernel/locking/lockdep.c b/kernel/locking/lockdep.c
index e221be724fe8..91c6b89f04df 100644
--- a/kernel/locking/lockdep.c
+++ b/kernel/locking/lockdep.c
@@ -434,29 +434,14 @@ static void print_lockdep_off(const char *bug_msg)
 #endif
 }
 
-static int save_trace(struct stack_trace *trace)
+static int save_trace(struct lock_trace *trace)
 {
-        trace->nr_entries = 0;
-        trace->max_entries = MAX_STACK_TRACE_ENTRIES - nr_stack_trace_entries;
-        trace->entries = stack_trace + nr_stack_trace_entries;
-
-        trace->skip = 3;
-
-        save_stack_trace(trace);
-
-        /*
-         * Some daft arches put -1 at the end to indicate its a full trace.
-         *
-         * <rant> this is buggy anyway, since it takes a whole extra entry so a
-         * complete trace that maxes out the entries provided will be reported
-         * as incomplete, friggin useless </rant>
-         */
-        if (trace->nr_entries != 0 &&
-            trace->entries[trace->nr_entries-1] == ULONG_MAX)
-                trace->nr_entries--;
-
-        trace->max_entries = trace->nr_entries;
+        unsigned long *entries = stack_trace + nr_stack_trace_entries;
+        unsigned int max_entries;
 
+        trace->offset = nr_stack_trace_entries;
+        max_entries = MAX_STACK_TRACE_ENTRIES - nr_stack_trace_entries;
+        trace->nr_entries = stack_trace_save(entries, max_entries, 3);
         nr_stack_trace_entries += trace->nr_entries;
 
         if (nr_stack_trace_entries >= MAX_STACK_TRACE_ENTRIES-1) {
@@ -1207,7 +1192,7 @@ static struct lock_list *alloc_list_entry(void)
 static int add_lock_to_list(struct lock_class *this,
                             struct lock_class *links_to, struct list_head *head,
                             unsigned long ip, int distance,
-                            struct stack_trace *trace)
+                            struct lock_trace *trace)
 {
         struct lock_list *entry;
         /*
@@ -1426,6 +1411,13 @@ static inline int __bfs_backwards(struct lock_list *src_entry,
  * checking.
  */
 
+static void print_lock_trace(struct lock_trace *trace, unsigned int spaces)
+{
+        unsigned long *entries = stack_trace + trace->offset;
+
+        stack_trace_print(entries, trace->nr_entries, spaces);
+}
+
 /*
  * Print a dependency chain entry (this is only done when a deadlock
  * has been detected):
@@ -1438,8 +1430,7 @@ print_circular_bug_entry(struct lock_list *target, int depth)
         printk("\n-> #%u", depth);
         print_lock_name(target->class);
         printk(KERN_CONT ":\n");
-        print_stack_trace(&target->trace, 6);
-
+        print_lock_trace(&target->trace, 6);
         return 0;
 }
 
@@ -1533,10 +1524,9 @@ static inline int class_equal(struct lock_list *entry, void *data)
 }
 
 static noinline int print_circular_bug(struct lock_list *this,
-                                struct lock_list *target,
-                                struct held_lock *check_src,
-                                struct held_lock *check_tgt,
-                                struct stack_trace *trace)
+                                       struct lock_list *target,
+                                       struct held_lock *check_src,
+                                       struct held_lock *check_tgt)
 {
         struct task_struct *curr = current;
         struct lock_list *parent;
@@ -1752,7 +1742,7 @@ static void print_lock_class_header(struct lock_class *class, int depth)
 
                         len += printk("%*s   %s", depth, "", usage_str[bit]);
                         len += printk(KERN_CONT " at:\n");
-                        print_stack_trace(class->usage_traces + bit, len);
+                        print_lock_trace(class->usage_traces + bit, len);
                 }
         }
         printk("%*s }\n", depth, "");
@@ -1777,7 +1767,7 @@ print_shortest_lock_dependencies(struct lock_list *leaf,
         do {
                 print_lock_class_header(entry->class, depth);
                 printk("%*s ... acquired at:\n", depth, "");
-                print_stack_trace(&entry->trace, 2);
+                print_lock_trace(&entry->trace, 2);
                 printk("\n");
 
                 if (depth == 0 && (entry != root)) {
@@ -1890,14 +1880,14 @@ print_bad_irq_dependency(struct task_struct *curr,
         print_lock_name(backwards_entry->class);
         pr_warn("\n... which became %s-irq-safe at:\n", irqclass);
 
-        print_stack_trace(backwards_entry->class->usage_traces + bit1, 1);
+        print_lock_trace(backwards_entry->class->usage_traces + bit1, 1);
 
         pr_warn("\nto a %s-irq-unsafe lock:\n", irqclass);
         print_lock_name(forwards_entry->class);
         pr_warn("\n... which became %s-irq-unsafe at:\n", irqclass);
         pr_warn("...");
 
-        print_stack_trace(forwards_entry->class->usage_traces + bit2, 1);
+        print_lock_trace(forwards_entry->class->usage_traces + bit2, 1);
 
         pr_warn("\nother info that might help us debug this:\n\n");
         print_irq_lock_scenario(backwards_entry, forwards_entry,
@@ -2170,8 +2160,7 @@ check_deadlock(struct task_struct *curr, struct held_lock *next,
  */
 static int
 check_prev_add(struct task_struct *curr, struct held_lock *prev,
-               struct held_lock *next, int distance, struct stack_trace *trace,
-               int (*save)(struct stack_trace *trace))
+               struct held_lock *next, int distance, struct lock_trace *trace)
 {
         struct lock_list *uninitialized_var(target_entry);
         struct lock_list *entry;
@@ -2209,15 +2198,15 @@ check_prev_add(struct task_struct *curr, struct held_lock *prev,
         this.parent = NULL;
         ret = check_noncircular(&this, hlock_class(prev), &target_entry);
         if (unlikely(!ret)) {
-                if (!trace->entries) {
+                if (!trace->nr_entries) {
                         /*
-                         * If @save fails here, the printing might trigger
-                         * a WARN but because of the !nr_entries it should
-                         * not do bad things.
+                         * If save_trace fails here, the printing might
+                         * trigger a WARN but because of the !nr_entries it
+                         * should not do bad things.
                          */
-                        save(trace);
+                        save_trace(trace);
                 }
-                return print_circular_bug(&this, target_entry, next, prev, trace);
+                return print_circular_bug(&this, target_entry, next, prev);
         }
         else if (unlikely(ret < 0))
                 return print_bfs_bug(ret);
@@ -2265,7 +2254,7 @@ check_prev_add(struct task_struct *curr, struct held_lock *prev,
                 return print_bfs_bug(ret);
 
 
-        if (!trace->entries && !save(trace))
+        if (!trace->nr_entries && !save_trace(trace))
                 return 0;
 
         /*
@@ -2297,14 +2286,9 @@ check_prev_add(struct task_struct *curr, struct held_lock *prev,
 static int
 check_prevs_add(struct task_struct *curr, struct held_lock *next)
 {
+        struct lock_trace trace = { .nr_entries = 0 };
         int depth = curr->lockdep_depth;
         struct held_lock *hlock;
-        struct stack_trace trace = {
-                .nr_entries = 0,
-                .max_entries = 0,
-                .entries = NULL,
-                .skip = 0,
-        };
 
         /*
          * Debugging checks.
@@ -2330,7 +2314,8 @@ check_prevs_add(struct task_struct *curr, struct held_lock *next)
                  * added:
                  */
                 if (hlock->read != 2 && hlock->check) {
-                        int ret = check_prev_add(curr, hlock, next, distance, &trace, save_trace);
+                        int ret = check_prev_add(curr, hlock, next, distance,
+                                                 &trace);
                         if (!ret)
                                 return 0;
 
@@ -2731,6 +2716,10 @@ static inline int validate_chain(struct task_struct *curr,
 {
         return 1;
 }
+
+static void print_lock_trace(struct lock_trace *trace, unsigned int spaces)
+{
+}
 #endif
 
 /*
@@ -2827,7 +2816,7 @@ print_usage_bug(struct task_struct *curr, struct held_lock *this,
         print_lock(this);
 
         pr_warn("{%s} state was registered at:\n", usage_str[prev_bit]);
-        print_stack_trace(hlock_class(this)->usage_traces + prev_bit, 1);
+        print_lock_trace(hlock_class(this)->usage_traces + prev_bit, 1);
 
         print_irqtrace_events(curr);
         pr_warn("\nother info that might help us debug this:\n");