3 files changed, 120 insertions, 211 deletions

diff --git a/arch/x86_64/kernel/stacktrace.c b/arch/x86_64/kernel/stacktrace.c
index 1c022af8fe1e..6026b31d037e 100644
--- a/arch/x86_64/kernel/stacktrace.c
+++ b/arch/x86_64/kernel/stacktrace.c
@@ -7,211 +7,49 @@
  */
 #include <linux/sched.h>
 #include <linux/stacktrace.h>
+#include <linux/module.h>
+#include <asm/stacktrace.h>
 
-#include <asm/smp.h>
-
-static inline int
-in_range(unsigned long start, unsigned long addr, unsigned long end)
+static void save_stack_warning(void *data, char *msg)
 {
-        return addr >= start && addr <= end;
 }
 
-static unsigned long
-get_stack_end(struct task_struct *task, unsigned long stack)
+static void
+save_stack_warning_symbol(void *data, char *msg, unsigned long symbol)
 {
-        unsigned long stack_start, stack_end, flags;
-        int i, cpu;
-
-        /*
-         * The most common case is that we are in the task stack:
-         */
-        stack_start = (unsigned long)task->thread_info;
-        stack_end = stack_start + THREAD_SIZE;
-
-        if (in_range(stack_start, stack, stack_end))
-                return stack_end;
-
-        /*
-         * We are in an interrupt if irqstackptr is set:
-         */
-        raw_local_irq_save(flags);
-        cpu = safe_smp_processor_id();
-        stack_end = (unsigned long)cpu_pda(cpu)->irqstackptr;
-
-        if (stack_end) {
-                stack_start = stack_end & ~(IRQSTACKSIZE-1);
-                if (in_range(stack_start, stack, stack_end))
-                        goto out_restore;
-                /*
-                 * We get here if we are in an IRQ context but we
-                 * are also in an exception stack.
-                 */
-        }
-
-        /*
-         * Iterate over all exception stacks, and figure out whether
-         * 'stack' is in one of them:
-         */
-        for (i = 0; i < N_EXCEPTION_STACKS; i++) {
-                /*
-                 * set 'end' to the end of the exception stack.
-                 */
-                stack_end = per_cpu(init_tss, cpu).ist[i];
-                stack_start = stack_end - EXCEPTION_STKSZ;
-
-                /*
-                 * Is 'stack' above this exception frame's end?
-                 * If yes then skip to the next frame.
-                 */
-                if (stack >= stack_end)
-                        continue;
-                /*
-                 * Is 'stack' above this exception frame's start address?
-                 * If yes then we found the right frame.
-                 */
-                if (stack >= stack_start)
-                        goto out_restore;
-
-                /*
-                 * If this is a debug stack, and if it has a larger size than
-                 * the usual exception stacks, then 'stack' might still
-                 * be within the lower portion of the debug stack:
-                 */
-#if DEBUG_STKSZ > EXCEPTION_STKSZ
-                if (i == DEBUG_STACK - 1 && stack >= stack_end - DEBUG_STKSZ) {
-                        /*
-                         * Black magic. A large debug stack is composed of
-                         * multiple exception stack entries, which we
-                         * iterate through now. Dont look:
-                         */
-                        do {
-                                stack_end -= EXCEPTION_STKSZ;
-                                stack_start -= EXCEPTION_STKSZ;
-                        } while (stack < stack_start);
-
-                        goto out_restore;
-                }
-#endif
-        }
-        /*
-         * Ok, 'stack' is not pointing to any of the system stacks.
-         */
-        stack_end = 0;
-
-out_restore:
-        raw_local_irq_restore(flags);
-
-        return stack_end;
 }
 
-
-/*
- * Save stack-backtrace addresses into a stack_trace buffer:
- */
-static inline unsigned long
-save_context_stack(struct stack_trace *trace,
-                   unsigned long stack, unsigned long stack_end)
+static int save_stack_stack(void *data, char *name)
 {
-        int skip = trace->skip;
-        unsigned long addr;
-
-#ifdef CONFIG_FRAME_POINTER
-        unsigned long prev_stack = 0;
+        struct stack_trace *trace = (struct stack_trace *)data;
+        return trace->all_contexts ? 0 : -1;
+}
 
-        while (in_range(prev_stack, stack, stack_end)) {
-                pr_debug("stack:          %p\n", (void *)stack);
-                addr = (unsigned long)(((unsigned long *)stack)[1]);
-                pr_debug("addr:           %p\n", (void *)addr);
-                if (!skip)
-                        trace->entries[trace->nr_entries++] = addr-1;
-                else
-                        skip--;
-                if (trace->nr_entries >= trace->max_entries)
-                        break;
-                if (!addr)
-                        return 0;
-                /*
-                 * Stack frames must go forwards (otherwise a loop could
-                 * happen if the stackframe is corrupted), so we move
-                 * prev_stack forwards:
-                 */
-                prev_stack = stack;
-                stack = (unsigned long)(((unsigned long *)stack)[0]);
-        }
-        pr_debug("invalid:        %p\n", (void *)stack);
-#else
-        while (stack < stack_end) {
-                addr = ((unsigned long *)stack)[0];
-                stack += sizeof(long);
-                if (__kernel_text_address(addr)) {
-                        if (!skip)
-                                trace->entries[trace->nr_entries++] = addr-1;
-                        else
-                                skip--;
-                        if (trace->nr_entries >= trace->max_entries)
-                                break;
-                }
+static void save_stack_address(void *data, unsigned long addr)
+{
+        struct stack_trace *trace = (struct stack_trace *)data;
+        if (trace->skip > 0) {
+                trace->skip--;
+                return;
         }
-#endif
-        return stack;
+        if (trace->nr_entries < trace->max_entries - 1)
+                trace->entries[trace->nr_entries++] = addr;
 }
 
-#define MAX_STACKS 10
+static struct stacktrace_ops save_stack_ops = {
+        .warning = save_stack_warning,
+        .warning_symbol = save_stack_warning_symbol,
+        .stack = save_stack_stack,
+        .address = save_stack_address,
+};
 
 /*
  * Save stack-backtrace addresses into a stack_trace buffer.
  */
 void save_stack_trace(struct stack_trace *trace, struct task_struct *task)
 {
-        unsigned long stack = (unsigned long)&stack;
-        int i, nr_stacks = 0, stacks_done[MAX_STACKS];
-
-        WARN_ON(trace->nr_entries || !trace->max_entries);
-
-        if (!task)
-                task = current;
-
-        pr_debug("task: %p, ti: %p\n", task, task->thread_info);
-
-        if (!task || task == current) {
-                /* Grab rbp right from our regs: */
-                asm ("mov %%rbp, %0" : "=r" (stack));
-                pr_debug("rbp:            %p\n", (void *)stack);
-        } else {
-                /* rbp is the last reg pushed by switch_to(): */
-                stack = task->thread.rsp;
-                pr_debug("other task rsp: %p\n", (void *)stack);
-                stack = (unsigned long)(((unsigned long *)stack)[0]);
-                pr_debug("other task rbp: %p\n", (void *)stack);
-        }
-
-        while (1) {
-                unsigned long stack_end = get_stack_end(task, stack);
-
-                pr_debug("stack:          %p\n", (void *)stack);
-                pr_debug("stack end:      %p\n", (void *)stack_end);
-
-                /*
-                 * Invalid stack addres?
-                 */
-                if (!stack_end)
-                        return;
-                /*
-                 * Were we in this stack already? (recursion)
-                 */
-                for (i = 0; i < nr_stacks; i++)
-                        if (stacks_done[i] == stack_end)
-                                return;
-                stacks_done[nr_stacks] = stack_end;
-
-                stack = save_context_stack(trace, stack, stack_end);
-                if (!stack || trace->nr_entries >= trace->max_entries)
-                        return;
-                trace->entries[trace->nr_entries++] = ULONG_MAX;
-                if (trace->nr_entries >= trace->max_entries)
-                        return;
-                if (++nr_stacks >= MAX_STACKS)
-                        return;
-        }
+        dump_trace(task, NULL, NULL, &save_stack_ops, trace);
+        trace->entries[trace->nr_entries++] = ULONG_MAX;
 }
+EXPORT_SYMBOL(save_stack_trace);
 
diff --git a/arch/x86_64/kernel/traps.c b/arch/x86_64/kernel/traps.c
index 9ec2b1d5893d..4ac18b02eada 100644
--- a/arch/x86_64/kernel/traps.c
+++ b/arch/x86_64/kernel/traps.c
@@ -45,6 +45,7 @@
 #include <asm/pda.h>
 #include <asm/proto.h>
 #include <asm/nmi.h>
+#include <asm/stacktrace.h>
 
 asmlinkage void divide_error(void);
 asmlinkage void debug(void);
@@ -142,7 +143,7 @@ void printk_address(unsigned long address)
 #endif
 
 static unsigned long *in_exception_stack(unsigned cpu, unsigned long stack,
-                                        unsigned *usedp, const char **idp)
+                                        unsigned *usedp, char **idp)
 {
         static char ids[][8] = {
                 [DEBUG_STACK - 1] = "#DB",
@@ -234,13 +235,19 @@ static unsigned long *in_exception_stack(unsigned cpu, unsigned long stack,
         return NULL;
 }
 
-static int show_trace_unwind(struct unwind_frame_info *info, void *context)
+struct ops_and_data {
+        struct stacktrace_ops *ops;
+        void *data;
+};
+
+static int dump_trace_unwind(struct unwind_frame_info *info, void *context)
 {
+        struct ops_and_data *oad = (struct ops_and_data *)context;
         int n = 0;
 
         while (unwind(info) == 0 && UNW_PC(info)) {
                 n++;
-                printk_address(UNW_PC(info));
+                oad->ops->address(oad->data, UNW_PC(info));
                 if (arch_unw_user_mode(info))
                         break;
         }
@@ -254,45 +261,51 @@ static int show_trace_unwind(struct unwind_frame_info *info, void *context)
  * severe exception (double fault, nmi, stack fault, debug, mce) hardware stack
  */
 
-void show_trace(struct task_struct *tsk, struct pt_regs *regs, unsigned long * stack)
+void dump_trace(struct task_struct *tsk, struct pt_regs *regs, unsigned long * stack,
+                struct stacktrace_ops *ops, void *data)
 {
         const unsigned cpu = safe_smp_processor_id();
         unsigned long *irqstack_end = (unsigned long *)cpu_pda(cpu)->irqstackptr;
         unsigned used = 0;
 
-        printk("\nCall Trace:\n");
-
         if (!tsk)
                 tsk = current;
 
         if (call_trace >= 0) {
                 int unw_ret = 0;
                 struct unwind_frame_info info;
+                struct ops_and_data oad = { .ops = ops, .data = data };
 
                 if (regs) {
                         if (unwind_init_frame_info(&info, tsk, regs) == 0)
-                                unw_ret = show_trace_unwind(&info, NULL);
+                                unw_ret = dump_trace_unwind(&info, &oad);
                 } else if (tsk == current)
-                        unw_ret = unwind_init_running(&info, show_trace_unwind, NULL);
+                        unw_ret = unwind_init_running(&info, dump_trace_unwind, &oad);
                 else {
                         if (unwind_init_blocked(&info, tsk) == 0)
-                                unw_ret = show_trace_unwind(&info, NULL);
+                                unw_ret = dump_trace_unwind(&info, &oad);
                 }
                 if (unw_ret > 0) {
                         if (call_trace == 1 && !arch_unw_user_mode(&info)) {
-                                print_symbol("DWARF2 unwinder stuck at %s\n",
+                                ops->warning_symbol(data, "DWARF2 unwinder stuck at %s\n",
                                              UNW_PC(&info));
                                 if ((long)UNW_SP(&info) < 0) {
-                                        printk("Leftover inexact backtrace:\n");
+                                        ops->warning(data, "Leftover inexact backtrace:\n");
                                         stack = (unsigned long *)UNW_SP(&info);
                                 } else
-                                        printk("Full inexact backtrace again:\n");
+                                        ops->warning(data, "Full inexact backtrace again:\n");
                         } else if (call_trace >= 1)
                                 return;
                         else
-                                printk("Full inexact backtrace again:\n");
+                                ops->warning(data, "Full inexact backtrace again:\n");
                 } else
-                        printk("Inexact backtrace:\n");
+                        ops->warning(data, "Inexact backtrace:\n");
+        }
+        if (!stack) {
+                unsigned long dummy;
+                stack = &dummy;
+                if (tsk && tsk != current)
+                        stack = (unsigned long *)tsk->thread.rsp;
         }
 
         /*
@@ -312,7 +325,7 @@ void show_trace(struct task_struct *tsk, struct pt_regs *regs, unsigned long * s
                          * down the cause of the crash will be able to figure \
                          * out the call path that was taken. \
                          */ \
-                        printk_address(addr); \
+                        ops->address(data, addr);   \
                 } \
         } while (0)
 
@@ -321,16 +334,17 @@ void show_trace(struct task_struct *tsk, struct pt_regs *regs, unsigned long * s
          * current stack address. If the stacks consist of nested
          * exceptions
          */
-        for ( ; ; ) {
-                const char *id;
+        for (;;) {
+                char *id;
                 unsigned long *estack_end;
                 estack_end = in_exception_stack(cpu, (unsigned long)stack,
                                                 &used, &id);
 
                 if (estack_end) {
-                        printk(" <%s>", id);
+                        if (ops->stack(data, id) < 0)
+                                break;
                         HANDLE_STACK (stack < estack_end);
-                        printk(" <EOE>");
+                        ops->stack(data, "<EOE>");
                         /*
                          * We link to the next stack via the
                          * second-to-last pointer (index -2 to end) in the
@@ -345,7 +359,8 @@ void show_trace(struct task_struct *tsk, struct pt_regs *regs, unsigned long * s
                                 (IRQSTACKSIZE - 64) / sizeof(*irqstack);
 
                         if (stack >= irqstack && stack < irqstack_end) {
-                                printk(" <IRQ>");
+                                if (ops->stack(data, "IRQ") < 0)
+                                        break;
                                 HANDLE_STACK (stack < irqstack_end);
                                 /*
                                  * We link to the next stack (which would be
@@ -354,7 +369,7 @@ void show_trace(struct task_struct *tsk, struct pt_regs *regs, unsigned long * s
                                  */
                                 stack = (unsigned long *) (irqstack_end[-1]);
                                 irqstack_end = NULL;
-                                printk(" <EOI>");
+                                ops->stack(data, "EOI");
                                 continue;
                         }
                 }
@@ -362,15 +377,53 @@ void show_trace(struct task_struct *tsk, struct pt_regs *regs, unsigned long * s
         }
 
         /*
-         * This prints the process stack:
+         * This handles the process stack:
          */
         HANDLE_STACK (((long) stack & (THREAD_SIZE-1)) != 0);
 #undef HANDLE_STACK
+}
+EXPORT_SYMBOL(dump_trace);
 
+static void
+print_trace_warning_symbol(void *data, char *msg, unsigned long symbol)
+{
+        print_symbol(msg, symbol);
+        printk("\n");
+}
+
+static void print_trace_warning(void *data, char *msg)
+{
+        printk("%s\n", msg);
+}
+
+static int print_trace_stack(void *data, char *name)
+{
+        printk(" <%s> ", name);
+        return 0;
+}
+
+static void print_trace_address(void *data, unsigned long addr)
+{
+        printk_address(addr);
+}
+
+static struct stacktrace_ops print_trace_ops = {
+        .warning = print_trace_warning,
+        .warning_symbol = print_trace_warning_symbol,
+        .stack = print_trace_stack,
+        .address = print_trace_address,
+};
+
+void
+show_trace(struct task_struct *tsk, struct pt_regs *regs, unsigned long *stack)
+{
+        printk("\nCall Trace:\n");
+        dump_trace(tsk, regs, stack, &print_trace_ops, NULL);
         printk("\n");
 }
 
-static void _show_stack(struct task_struct *tsk, struct pt_regs *regs, unsigned long * rsp)
+static void
+_show_stack(struct task_struct *tsk, struct pt_regs *regs, unsigned long *rsp)
 {
         unsigned long *stack;
         int i;
diff --git a/include/asm-x86_64/stacktrace.h b/include/asm-x86_64/stacktrace.h
new file mode 100644
index 000000000000..5eb9799bef76
--- /dev/null
+++ b/include/asm-x86_64/stacktrace.h
@@ -0,0 +1,18 @@
+#ifndef _ASM_STACKTRACE_H
+#define _ASM_STACKTRACE_H 1
+
+/* Generic stack tracer with callbacks */
+
+struct stacktrace_ops {
+        void (*warning)(void *data, char *msg);
+        /* msg must contain %s for the symbol */
+        void (*warning_symbol)(void *data, char *msg, unsigned long symbol);
+        void (*address)(void *data, unsigned long address);
+        /* On negative return stop dumping */
+        int (*stack)(void *data, char *name);
+};
+
+void dump_trace(struct task_struct *tsk, struct pt_regs *regs, unsigned long *stack,
+                struct stacktrace_ops *ops, void *data);
+
+#endif