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
  ...

2 files changed, 17 insertions, 25 deletions

diff --git a/mm/kasan/common.c b/mm/kasan/common.c
index 09c586474511..36afcf64e016 100644
--- a/mm/kasan/common.c
+++ b/mm/kasan/common.c
@@ -49,37 +49,28 @@ static inline int in_irqentry_text(unsigned long ptr)
                  ptr < (unsigned long)&__softirqentry_text_end);
 }
 
-static inline void filter_irq_stacks(struct stack_trace *trace)
+static inline unsigned int filter_irq_stacks(unsigned long *entries,
+                                             unsigned int nr_entries)
 {
-        int i;
+        unsigned int i;
 
-        if (!trace->nr_entries)
-                return;
-        for (i = 0; i < trace->nr_entries; i++)
-                if (in_irqentry_text(trace->entries[i])) {
+        for (i = 0; i < nr_entries; i++) {
+                if (in_irqentry_text(entries[i])) {
                         /* Include the irqentry function into the stack. */
-                        trace->nr_entries = i + 1;
-                        break;
+                        return i + 1;
                 }
+        }
+        return nr_entries;
 }
 
 static inline depot_stack_handle_t save_stack(gfp_t flags)
 {
         unsigned long entries[KASAN_STACK_DEPTH];
-        struct stack_trace trace = {
-                .nr_entries = 0,
-                .entries = entries,
-                .max_entries = KASAN_STACK_DEPTH,
-                .skip = 0
-        };
-
-        save_stack_trace(&trace);
-        filter_irq_stacks(&trace);
-        if (trace.nr_entries != 0 &&
-            trace.entries[trace.nr_entries-1] == ULONG_MAX)
-                trace.nr_entries--;
-
-        return depot_save_stack(&trace, flags);
+        unsigned int nr_entries;
+
+        nr_entries = stack_trace_save(entries, ARRAY_SIZE(entries), 0);
+        nr_entries = filter_irq_stacks(entries, nr_entries);
+        return stack_depot_save(entries, nr_entries, flags);
 }
 
 static inline void set_track(struct kasan_track *track, gfp_t flags)
diff --git a/mm/kasan/report.c b/mm/kasan/report.c
index 0772820ad098..03a443579386 100644
--- a/mm/kasan/report.c
+++ b/mm/kasan/report.c
@@ -100,10 +100,11 @@ static void print_track(struct kasan_track *track, const char *prefix)
 {
         pr_err("%s by task %u:\n", prefix, track->pid);
         if (track->stack) {
-                struct stack_trace trace;
+                unsigned long *entries;
+                unsigned int nr_entries;
 
-                depot_fetch_stack(track->stack, &trace);
-                print_stack_trace(&trace, 0);
+                nr_entries = stack_depot_fetch(track->stack, &entries);
+                stack_trace_print(entries, nr_entries, 0);
         } else {
                 pr_err("(stack is not available)\n");
         }