xtensa: add support for oprofile

Support call graph profiling.
Keep upper two bits of PC unchanged through backtrace rather than take
them from sp (a1). The stack pointer is usually in the same GB (same
upper 2 bits) as PC, but technically doesn't always have to be (and
might not in the future, when taking full advantage of MMU v3).

Signed-off-by: Dan Nicolaescu <dann@xtensa-linux.org>
Signed-off-by: Pete Delaney <piet@tensilica.com>
Signed-off-by: Max Filippov <jcmvbkbc@gmail.com>
Signed-off-by: Chris Zankel <chris@zankel.net>

diff --git a/arch/xtensa/Kconfig b/arch/xtensa/Kconfig
index f83780f8f2909d65938aa7bd51973dc9103d5a63..f61f7362c8f66a0c98b015c36b9f760c138d66ea 100644 (file)
--- a/arch/xtensa/Kconfig
+++ b/arch/xtensa/Kconfig
@@ -17,6 +17,7 @@ config XTENSA
        select ARCH_WANT_OPTIONAL_GPIOLIB
        select CLONE_BACKWARDS
        select IRQ_DOMAIN
+       select HAVE_OPROFILE
        help
          Xtensa processors are 32-bit RISC machines designed by Tensilica
          primarily for embedded systems.  These processors are both

diff --git a/arch/xtensa/Makefile b/arch/xtensa/Makefile
index afec8f000c4a093e303a8b177d66f69292f5d773..136224b74d4f0e99f9970fd011916cf1133499ba 100644 (file)
--- a/arch/xtensa/Makefile
+++ b/arch/xtensa/Makefile
@@ -87,6 +87,7 @@ core-y                += arch/xtensa/kernel/ arch/xtensa/mm/
 core-y         += $(buildvar) $(buildplf)
 
 libs-y         += arch/xtensa/lib/ $(LIBGCC)
+drivers-$(CONFIG_OPROFILE)     += arch/xtensa/oprofile/
 
 ifneq ($(CONFIG_BUILTIN_DTB),"")
 core-$(CONFIG_OF) += arch/xtensa/boot/dts/

diff --git a/arch/xtensa/kernel/entry.S b/arch/xtensa/kernel/entry.S
index 0ace2acbbad0489b4537b8a61cb8c41fd8355b2c..70d5a9e33573a38ec1247d6214269c3828729631 100644 (file)
--- a/arch/xtensa/kernel/entry.S
+++ b/arch/xtensa/kernel/entry.S
@@ -399,7 +399,7 @@ common_exception:
        callx4  a4
 
        /* Jump here for exception exit */
-
+       .global common_exception_return
 common_exception_return:
 
        /* Jump if we are returning from kernel exceptions. */

diff --git a/arch/xtensa/oprofile/Makefile b/arch/xtensa/oprofile/Makefile
new file mode 100644 (file)
index 0000000..69ffbe8
--- /dev/null
+++ b/arch/xtensa/oprofile/Makefile
@@ -0,0 +1,9 @@
+obj-$(CONFIG_OPROFILE) += oprofile.o
+
+DRIVER_OBJS = $(addprefix ../../../drivers/oprofile/, \
+               oprof.o cpu_buffer.o buffer_sync.o \
+               event_buffer.o oprofile_files.o \
+               oprofilefs.o oprofile_stats.o \
+               timer_int.o )
+
+oprofile-y := $(DRIVER_OBJS) init.o backtrace.o

diff --git a/arch/xtensa/oprofile/backtrace.c b/arch/xtensa/oprofile/backtrace.c
new file mode 100644 (file)
index 0000000..66f32ee
--- /dev/null
+++ b/arch/xtensa/oprofile/backtrace.c
@@ -0,0 +1,171 @@
+/**
+ * @file backtrace.c
+ *
+ * @remark Copyright 2008 Tensilica 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>
+
+/* 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)
+{
+       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. */
+               if (kernel_text_address(pc))
+                       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;
+}
+
+void xtensa_backtrace(struct pt_regs * const regs, unsigned int depth)
+{
+       if (user_mode(regs))
+               xtensa_backtrace_user(regs, depth);
+       else
+               xtensa_backtrace_kernel(regs, depth);
+}

diff --git a/arch/xtensa/oprofile/init.c b/arch/xtensa/oprofile/init.c
new file mode 100644 (file)
index 0000000..a67eea3
--- /dev/null
+++ b/arch/xtensa/oprofile/init.c
@@ -0,0 +1,26 @@
+/**
+ * @file init.c
+ *
+ * @remark Copyright 2008 Tensilica Inc.
+ * @remark Read the file COPYING
+ *
+ */
+
+#include <linux/kernel.h>
+#include <linux/oprofile.h>
+#include <linux/errno.h>
+#include <linux/init.h>
+
+
+extern void xtensa_backtrace(struct pt_regs *const regs, unsigned int depth);
+
+int __init oprofile_arch_init(struct oprofile_operations *ops)
+{
+       ops->backtrace = xtensa_backtrace;
+       return -ENODEV;
+}
+
+
+void oprofile_arch_exit(void)
+{
+}