Merge branch 'master' of git://git.kernel.org/pub/scm/linux/kernel/git/linville/wirel...

[linux-drm-fsl-dcu.git] / arch / um / kernel / sysrq.c

diff --git a/arch/um/kernel/sysrq.c b/arch/um/kernel/sysrq.c
index 0dc4d1c6f98a19b5ed018c58d7aeb683d468ae1c..799d7e413bf57247f258b25ad6306a91b363e67c 100644 (file)
--- a/arch/um/kernel/sysrq.c
+++ b/arch/um/kernel/sysrq.c
@@ -1,6 +1,10 @@
 /*
  * Copyright (C) 2001 - 2007 Jeff Dike (jdike@{addtoit,linux.intel}.com)
- * Licensed under the GPL
+ * Copyright (C) 2013 Richard Weinberger <richrd@nod.at>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
  */
 
 #include <linux/kallsyms.h>
@@ -8,59 +12,87 @@
 #include <linux/module.h>
 #include <linux/sched.h>
 #include <asm/sysrq.h>
+#include <os.h>
 
-/* Catch non-i386 SUBARCH's. */
-#if !defined(CONFIG_UML_X86) || defined(CONFIG_64BIT)
-void show_trace(struct task_struct *task, unsigned long * stack)
+struct stack_frame {
+       struct stack_frame *next_frame;
+       unsigned long return_address;
+};
+
+static void do_stack_trace(unsigned long *sp, unsigned long bp)
 {
+       int reliable;
        unsigned long addr;
+       struct stack_frame *frame = (struct stack_frame *)bp;
 
-       if (!stack) {
-               stack = (unsigned long*) &stack;
-               WARN_ON(1);
-       }
-
-       printk(KERN_INFO "Call Trace: \n");
-       while (((long) stack & (THREAD_SIZE-1)) != 0) {
-               addr = *stack;
+       printk(KERN_INFO "Call Trace:\n");
+       while (((long) sp & (THREAD_SIZE-1)) != 0) {
+               addr = *sp;
                if (__kernel_text_address(addr)) {
-                       printk(KERN_INFO "%08lx:  [<%08lx>]",
-                              (unsigned long) stack, addr);
-                       print_symbol(KERN_CONT " %s", addr);
+                       reliable = 0;
+                       if ((unsigned long) sp == bp + sizeof(long)) {
+                               frame = frame ? frame->next_frame : NULL;
+                               bp = (unsigned long)frame;
+                               reliable = 1;
+                       }
+
+                       printk(KERN_INFO " [<%08lx>]", addr);
+                       printk(KERN_CONT " %s", reliable ? "" : "? ");
+                       print_symbol(KERN_CONT "%s", addr);
                        printk(KERN_CONT "\n");
                }
-               stack++;
+               sp++;
        }
        printk(KERN_INFO "\n");
 }
-#endif
 
-/*Stolen from arch/i386/kernel/traps.c */
-static const int kstack_depth_to_print = 24;
+static unsigned long get_frame_pointer(struct task_struct *task,
+                                      struct pt_regs *segv_regs)
+{
+       if (!task || task == current)
+               return segv_regs ? PT_REGS_BP(segv_regs) : current_bp();
+       else
+               return KSTK_EBP(task);
+}
 
-/* This recently started being used in arch-independent code too, as in
- * kernel/sched/core.c.*/
-void show_stack(struct task_struct *task, unsigned long *esp)
+static unsigned long *get_stack_pointer(struct task_struct *task,
+                                       struct pt_regs *segv_regs)
 {
-       unsigned long *stack;
+       if (!task || task == current)
+               return segv_regs ? (unsigned long *)PT_REGS_SP(segv_regs) : current_sp();
+       else
+               return (unsigned long *)KSTK_ESP(task);
+}
+
+void show_stack(struct task_struct *task, unsigned long *stack)
+{
+       unsigned long *sp = stack, bp = 0;
+       struct pt_regs *segv_regs = current->thread.segv_regs;
        int i;
 
-       if (esp == NULL) {
-               if (task != current && task != NULL) {
-                       esp = (unsigned long *) KSTK_ESP(task);
-               } else {
-                       esp = (unsigned long *) &esp;
-               }
+       if (!segv_regs && os_is_signal_stack()) {
+               printk(KERN_ERR "Received SIGSEGV in SIGSEGV handler,"
+                               " aborting stack trace!\n");
+               return;
        }
 
-       stack = esp;
-       for (i = 0; i < kstack_depth_to_print; i++) {
+#ifdef CONFIG_FRAME_POINTER
+       bp = get_frame_pointer(task, segv_regs);
+#endif
+
+       if (!stack)
+               sp = get_stack_pointer(task, segv_regs);
+
+       printk(KERN_INFO "Stack:\n");
+       stack = sp;
+       for (i = 0; i < 3 * STACKSLOTS_PER_LINE; i++) {
                if (kstack_end(stack))
                        break;
-               if (i && ((i % 8) == 0))
-                       printk(KERN_INFO "       ");
-               printk(KERN_CONT "%08lx ", *stack++);
+               if (i && ((i % STACKSLOTS_PER_LINE) == 0))
+                       printk(KERN_CONT "\n");
+               printk(KERN_CONT " %08lx", *stack++);
        }
+       printk(KERN_CONT "\n");
 
-       show_trace(task, esp);
+       do_stack_trace(sp, bp);
 }