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>

3 files changed, 206 insertions, 0 deletions

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)
+{
+}