xtensa: move oprofile stack tracing to stacktrace.c

Old oprofile interface will share user stack tracing with new perf
interface. Move oprofile user/kernel stack tracing to stacktrace.c to
make it possible.

Signed-off-by: Max Filippov <jcmvbkbc@gmail.com>

diff --git a/arch/xtensa/include/asm/stacktrace.h b/arch/xtensa/include/asm/stacktrace.h
index 6a05fcb0a20de444d05d0706ff49795e0028ea94..fe06e8ed162b754ce2c6cceec4ddb9682030f088 100644 (file)
--- a/arch/xtensa/include/asm/stacktrace.h
+++ b/arch/xtensa/include/asm/stacktrace.h
@@ -33,4 +33,12 @@ void walk_stackframe(unsigned long *sp,
                int (*fn)(struct stackframe *frame, void *data),
                void *data);
 
+void xtensa_backtrace_kernel(struct pt_regs *regs, unsigned int depth,
+                            int (*kfn)(struct stackframe *frame, void *data),
+                            int (*ufn)(struct stackframe *frame, void *data),
+                            void *data);
+void xtensa_backtrace_user(struct pt_regs *regs, unsigned int depth,
+                          int (*ufn)(struct stackframe *frame, void *data),
+                          void *data);
+
 #endif /* _XTENSA_STACKTRACE_H */

diff --git a/arch/xtensa/kernel/stacktrace.c b/arch/xtensa/kernel/stacktrace.c
index 7d2c317bd98b30eb2a82e2770d0ff236de66fe03..7538d802b65abbc88f2e3769ff77e117282470c7 100644 (file)
--- a/arch/xtensa/kernel/stacktrace.c
+++ b/arch/xtensa/kernel/stacktrace.c
@@ -1,11 +1,12 @@
 /*
- * arch/xtensa/kernel/stacktrace.c
+ * Kernel and userspace stack tracing.
  *
  * This file is subject to the terms and conditions of the GNU General Public
  * License.  See the file "COPYING" in the main directory of this archive
  * for more details.
  *
  * Copyright (C) 2001 - 2013 Tensilica Inc.
+ * Copyright (C) 2015 Cadence Design Systems Inc.
  */
 #include <linux/export.h>
 #include <linux/sched.h>
@@ -13,6 +14,170 @@
 
 #include <asm/stacktrace.h>
 #include <asm/traps.h>
+#include <asm/uaccess.h>
+
+#if IS_ENABLED(CONFIG_OPROFILE) || IS_ENABLED(CONFIG_PERF_EVENTS)
+
+/* Address of common_exception_return, used to check the
+ * transition from kernel to user space.
+ */
+extern int common_exception_return;
+
+/* A struct that maps to the part of the frame containing the a0 and
+ * a1 registers.
+ */
+struct frame_start {
+       unsigned long a0;
+       unsigned long a1;
+};
+
+void xtensa_backtrace_user(struct pt_regs *regs, unsigned int depth,
+                          int (*ufn)(struct stackframe *frame, void *data),
+                          void *data)
+{
+       unsigned long windowstart = regs->windowstart;
+       unsigned long windowbase = regs->windowbase;
+       unsigned long a0 = regs->areg[0];
+       unsigned long a1 = regs->areg[1];
+       unsigned long pc = regs->pc;
+       struct stackframe frame;
+       int index;
+
+       if (!depth--)
+               return;
+
+       frame.pc = pc;
+       frame.sp = a1;
+
+       if (pc == 0 || pc >= TASK_SIZE || ufn(&frame, data))
+               return;
+
+       /* Two steps:
+        *
+        * 1. Look through the register window for the
+        * previous PCs in the call trace.
+        *
+        * 2. Look on the stack.
+        */
+
+       /* Step 1.  */
+       /* Rotate WINDOWSTART to move the bit corresponding to
+        * the current window to the bit #0.
+        */
+       windowstart = (windowstart << WSBITS | windowstart) >> windowbase;
+
+       /* Look for bits that are set, they correspond to
+        * valid windows.
+        */
+       for (index = WSBITS - 1; (index > 0) && depth; depth--, index--)
+               if (windowstart & (1 << index)) {
+                       /* Get the PC from a0 and a1. */
+                       pc = MAKE_PC_FROM_RA(a0, pc);
+                       /* Read a0 and a1 from the
+                        * corresponding position in AREGs.
+                        */
+                       a0 = regs->areg[index * 4];
+                       a1 = regs->areg[index * 4 + 1];
+
+                       frame.pc = pc;
+                       frame.sp = a1;
+
+                       if (pc == 0 || pc >= TASK_SIZE || ufn(&frame, data))
+                               return;
+               }
+
+       /* Step 2. */
+       /* We are done with the register window, we need to
+        * look through the stack.
+        */
+       if (!depth)
+               return;
+
+       /* Start from the a1 register. */
+       /* a1 = regs->areg[1]; */
+       while (a0 != 0 && depth--) {
+               struct frame_start frame_start;
+               /* Get the location for a1, a0 for the
+                * previous frame from the current a1.
+                */
+               unsigned long *psp = (unsigned long *)a1;
+
+               psp -= 4;
+
+               /* Check if the region is OK to access. */
+               if (!access_ok(VERIFY_READ, psp, sizeof(frame_start)))
+                       return;
+               /* Copy a1, a0 from user space stack frame. */
+               if (__copy_from_user_inatomic(&frame_start, psp,
+                                             sizeof(frame_start)))
+                       return;
+
+               pc = MAKE_PC_FROM_RA(a0, pc);
+               a0 = frame_start.a0;
+               a1 = frame_start.a1;
+
+               frame.pc = pc;
+               frame.sp = a1;
+
+               if (pc == 0 || pc >= TASK_SIZE || ufn(&frame, data))
+                       return;
+       }
+}
+EXPORT_SYMBOL(xtensa_backtrace_user);
+
+void xtensa_backtrace_kernel(struct pt_regs *regs, unsigned int depth,
+                            int (*kfn)(struct stackframe *frame, void *data),
+                            int (*ufn)(struct stackframe *frame, void *data),
+                            void *data)
+{
+       unsigned long pc = regs->depc > VALID_DOUBLE_EXCEPTION_ADDRESS ?
+               regs->depc : regs->pc;
+       unsigned long sp_start, sp_end;
+       unsigned long a0 = regs->areg[0];
+       unsigned long a1 = regs->areg[1];
+
+       sp_start = a1 & ~(THREAD_SIZE - 1);
+       sp_end = sp_start + THREAD_SIZE;
+
+       /* Spill the register window to the stack first. */
+       spill_registers();
+
+       /* Read the stack frames one by one and create the PC
+        * from the a0 and a1 registers saved there.
+        */
+       while (a1 > sp_start && a1 < sp_end && depth--) {
+               struct stackframe frame;
+               unsigned long *psp = (unsigned long *)a1;
+
+               frame.pc = pc;
+               frame.sp = a1;
+
+               if (kernel_text_address(pc) && kfn(&frame, data))
+                       return;
+
+               if (pc == (unsigned long)&common_exception_return) {
+                       regs = (struct pt_regs *)a1;
+                       if (user_mode(regs)) {
+                               if (ufn == NULL)
+                                       return;
+                               xtensa_backtrace_user(regs, depth, ufn, data);
+                               return;
+                       }
+                       a0 = regs->areg[0];
+                       a1 = regs->areg[1];
+                       continue;
+               }
+
+               sp_start = a1;
+
+               pc = MAKE_PC_FROM_RA(a0, pc);
+               a0 = *(psp - 4);
+               a1 = *(psp - 3);
+       }
+}
+EXPORT_SYMBOL(xtensa_backtrace_kernel);
+
+#endif
 
 void walk_stackframe(unsigned long *sp,
                int (*fn)(struct stackframe *frame, void *data),

diff --git a/arch/xtensa/oprofile/backtrace.c b/arch/xtensa/oprofile/backtrace.c
index 5f03a593d84f9000d6db447f599f40af7048af42..8f952034e161b03ab806555ac36b06f8f4c74f76 100644 (file)
--- a/arch/xtensa/oprofile/backtrace.c
+++ b/arch/xtensa/oprofile/backtrace.c
@@ -2,168 +2,26 @@
  * @file backtrace.c
  *
  * @remark Copyright 2008 Tensilica Inc.
+ * Copyright (C) 2015 Cadence Design Systems Inc.
  * @remark Read the file COPYING
  *
  */
 
 #include <linux/oprofile.h>
-#include <linux/sched.h>
-#include <linux/mm.h>
 #include <asm/ptrace.h>
-#include <asm/uaccess.h>
-#include <asm/traps.h>
+#include <asm/stacktrace.h>
 
-/* Address of common_exception_return, used to check the
- * transition from kernel to user space.
- */
-extern int common_exception_return;
-
-/* A struct that maps to the part of the frame containing the a0 and
- * a1 registers.
- */
-struct frame_start {
-       unsigned long a0;
-       unsigned long a1;
-};
-
-static void xtensa_backtrace_user(struct pt_regs *regs, unsigned int depth)
-{
-       unsigned long windowstart = regs->windowstart;
-       unsigned long windowbase = regs->windowbase;
-       unsigned long a0 = regs->areg[0];
-       unsigned long a1 = regs->areg[1];
-       unsigned long pc = MAKE_PC_FROM_RA(a0, regs->pc);
-       int index;
-
-       /* First add the current PC to the trace. */
-       if (pc != 0 && pc <= TASK_SIZE)
-               oprofile_add_trace(pc);
-       else
-               return;
-
-       /* Two steps:
-        *
-        * 1. Look through the register window for the
-        * previous PCs in the call trace.
-        *
-        * 2. Look on the stack.
-        */
-
-       /* Step 1.  */
-       /* Rotate WINDOWSTART to move the bit corresponding to
-        * the current window to the bit #0.
-        */
-       windowstart = (windowstart << WSBITS | windowstart) >> windowbase;
-
-       /* Look for bits that are set, they correspond to
-        * valid windows.
-        */
-       for (index = WSBITS - 1; (index > 0) && depth; depth--, index--)
-               if (windowstart & (1 << index)) {
-                       /* Read a0 and a1 from the
-                        * corresponding position in AREGs.
-                        */
-                       a0 = regs->areg[index * 4];
-                       a1 = regs->areg[index * 4 + 1];
-                       /* Get the PC from a0 and a1. */
-                       pc = MAKE_PC_FROM_RA(a0, pc);
-
-                       /* Add the PC to the trace. */
-                       if (pc != 0 && pc <= TASK_SIZE)
-                               oprofile_add_trace(pc);
-                       else
-                               return;
-               }
-
-       /* Step 2. */
-       /* We are done with the register window, we need to
-        * look through the stack.
-        */
-       if (depth > 0) {
-               /* Start from the a1 register. */
-               /* a1 = regs->areg[1]; */
-               while (a0 != 0 && depth--) {
-
-                       struct frame_start frame_start;
-                       /* Get the location for a1, a0 for the
-                        * previous frame from the current a1.
-                        */
-                       unsigned long *psp = (unsigned long *)a1;
-                       psp -= 4;
-
-                       /* Check if the region is OK to access. */
-                       if (!access_ok(VERIFY_READ, psp, sizeof(frame_start)))
-                               return;
-                       /* Copy a1, a0 from user space stack frame. */
-                       if (__copy_from_user_inatomic(&frame_start, psp,
-                                               sizeof(frame_start)))
-                               return;
-
-                       a0 = frame_start.a0;
-                       a1 = frame_start.a1;
-                       pc = MAKE_PC_FROM_RA(a0, pc);
-
-                       if (pc != 0 && pc <= TASK_SIZE)
-                               oprofile_add_trace(pc);
-                       else
-                               return;
-               }
-       }
-}
-
-static void xtensa_backtrace_kernel(struct pt_regs *regs, unsigned int depth)
+static int xtensa_backtrace_cb(struct stackframe *frame, void *data)
 {
-       unsigned long pc = regs->pc;
-       unsigned long *psp;
-       unsigned long sp_start, sp_end;
-       unsigned long a0 = regs->areg[0];
-       unsigned long a1 = regs->areg[1];
-
-       sp_start = a1 & ~(THREAD_SIZE-1);
-       sp_end = sp_start + THREAD_SIZE;
-
-       /* Spill the register window to the stack first. */
-       spill_registers();
-
-       /* Read the stack frames one by one and create the PC
-        * from the a0 and a1 registers saved there.
-        */
-       while (a1 > sp_start && a1 < sp_end && depth--) {
-               pc = MAKE_PC_FROM_RA(a0, pc);
-
-               /* Add the PC to the trace. */
-               oprofile_add_trace(pc);
-               if (pc == (unsigned long) &common_exception_return) {
-                       regs = (struct pt_regs *)a1;
-                       if (user_mode(regs)) {
-                               pc = regs->pc;
-                               if (pc != 0 && pc <= TASK_SIZE)
-                                       oprofile_add_trace(pc);
-                               else
-                                       return;
-                               return xtensa_backtrace_user(regs, depth);
-                       }
-                       a0 = regs->areg[0];
-                       a1 = regs->areg[1];
-                       continue;
-               }
-
-               psp = (unsigned long *)a1;
-
-               a0 = *(psp - 4);
-               a1 = *(psp - 3);
-
-               if (a1 <= (unsigned long)psp)
-                       return;
-
-       }
-       return;
+       oprofile_add_trace(frame->pc);
+       return 0;
 }
 
 void xtensa_backtrace(struct pt_regs * const regs, unsigned int depth)
 {
        if (user_mode(regs))
-               xtensa_backtrace_user(regs, depth);
+               xtensa_backtrace_user(regs, depth, xtensa_backtrace_cb, NULL);
        else
-               xtensa_backtrace_kernel(regs, depth);
+               xtensa_backtrace_kernel(regs, depth, xtensa_backtrace_cb,
+                                       xtensa_backtrace_cb, NULL);
 }