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>

6 files changed, 209 insertions, 1 deletions

diff --git a/arch/xtensa/Kconfig b/arch/xtensa/Kconfig
index f83780f8f290..f61f7362c8f6 100644
--- 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 afec8f000c4a..136224b74d4f 100644
--- 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 0ace2acbbad0..70d5a9e33573 100644
--- 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
index 000000000000..69ffbe80f184
--- /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
index 000000000000..66f32ee2c982
--- /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
index 000000000000..a67eea379766
--- /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)
+{
+}