sh: Add kprobe-based event tracer.

This follows the x86/ppc changes for kprobe-based event tracing on sh.
While kprobes is only supported on 32-bit sh, we provide the API for
HAVE_REGS_AND_STACK_ACCESS_API for both 32 and 64-bit.

Signed-off-by: Paul Mundt <lethal@linux-sh.org>

9 files changed, 227 insertions, 11 deletions

diff --git a/arch/sh/Kconfig b/arch/sh/Kconfig
index 573fca1fbd9b..e6b1f207f7ab 100644
--- a/arch/sh/Kconfig
+++ b/arch/sh/Kconfig
@@ -23,6 +23,7 @@ config SUPERH
         select HAVE_KERNEL_LZMA
         select HAVE_KERNEL_LZO
         select HAVE_SYSCALL_TRACEPOINTS
+        select HAVE_REGS_AND_STACK_ACCESS_API
         select RTC_LIB
         select GENERIC_ATOMIC64
         help
diff --git a/arch/sh/include/asm/kprobes.h b/arch/sh/include/asm/kprobes.h
index 036c3311233c..134f3980e44a 100644
--- a/arch/sh/include/asm/kprobes.h
+++ b/arch/sh/include/asm/kprobes.h
@@ -16,7 +16,6 @@ typedef insn_size_t kprobe_opcode_t;
         ? (MAX_STACK_SIZE) \
         : (((unsigned long)current_thread_info()) + THREAD_SIZE - (ADDR)))
 
-#define regs_return_value(_regs)                ((_regs)->regs[0])
 #define flush_insn_slot(p)              do { } while (0)
 #define kretprobe_blacklist_size        0
 
diff --git a/arch/sh/include/asm/processor_32.h b/arch/sh/include/asm/processor_32.h
index 61a445d2d02a..46d5179c9f49 100644
--- a/arch/sh/include/asm/processor_32.h
+++ b/arch/sh/include/asm/processor_32.h
@@ -13,7 +13,6 @@
 #include <linux/linkage.h>
 #include <asm/page.h>
 #include <asm/types.h>
-#include <asm/ptrace.h>
 #include <asm/hw_breakpoint.h>
 
 /*
@@ -194,8 +193,6 @@ extern unsigned long get_wchan(struct task_struct *p);
 #define KSTK_EIP(tsk)  (task_pt_regs(tsk)->pc)
 #define KSTK_ESP(tsk)  (task_pt_regs(tsk)->regs[15])
 
-#define user_stack_pointer(_regs)       ((_regs)->regs[15])
-
 #if defined(CONFIG_CPU_SH2A) || defined(CONFIG_CPU_SH4)
 #define PREFETCH_STRIDE         L1_CACHE_BYTES
 #define ARCH_HAS_PREFETCH
diff --git a/arch/sh/include/asm/processor_64.h b/arch/sh/include/asm/processor_64.h
index 621bc4618c6b..2a541ddb5a1b 100644
--- a/arch/sh/include/asm/processor_64.h
+++ b/arch/sh/include/asm/processor_64.h
@@ -17,7 +17,6 @@
 #include <linux/compiler.h>
 #include <asm/page.h>
 #include <asm/types.h>
-#include <asm/ptrace.h>
 #include <cpu/registers.h>
 
 /*
@@ -231,7 +230,5 @@ extern unsigned long get_wchan(struct task_struct *p);
 #define KSTK_EIP(tsk)  ((tsk)->thread.pc)
 #define KSTK_ESP(tsk)  ((tsk)->thread.sp)
 
-#define user_stack_pointer(_regs)       ((_regs)->regs[15])
-
 #endif  /* __ASSEMBLY__ */
 #endif /* __ASM_SH_PROCESSOR_64_H */
diff --git a/arch/sh/include/asm/ptrace.h b/arch/sh/include/asm/ptrace.h
index 2168fde25611..33b3f37dcdbb 100644
--- a/arch/sh/include/asm/ptrace.h
+++ b/arch/sh/include/asm/ptrace.h
@@ -1,6 +1,8 @@
 #ifndef __ASM_SH_PTRACE_H
 #define __ASM_SH_PTRACE_H
 
+#include <linux/stringify.h>
+
 /*
  * Copyright (C) 1999, 2000  Niibe Yutaka
  *
@@ -14,6 +16,13 @@ struct pt_regs {
         unsigned long long tregs[8];
         unsigned long long pad[2];
 };
+
+#define MAX_REG_OFFSET          offsetof(struct pt_regs, tregs[7])
+#define regs_return_value(regs) ((regs)->regs[3])
+
+#define TREGS_OFFSET_NAME(num)  \
+        {.name = __stringify(tr##num), .offset = offsetof(struct pt_regs, tregs[num])}
+
 #else
 /*
  * GCC defines register number like this:
@@ -66,6 +75,9 @@ struct pt_regs {
         long tra;
 };
 
+#define MAX_REG_OFFSET          offsetof(struct pt_regs, tra)
+#define regs_return_value(regs) ((regs)->regs[0])
+
 /*
  * This struct defines the way the DSP registers are stored on the
  * kernel stack during a system call or other kernel entry.
@@ -113,16 +125,87 @@ struct pt_dspregs {
 #include <asm/system.h>
 
 #define user_mode(regs)                 (((regs)->sr & 0x40000000)==0)
+#define user_stack_pointer(regs)        ((unsigned long)(regs)->regs[15])
+#define kernel_stack_pointer(regs)      ((unsigned long)(regs)->regs[15])
 #define instruction_pointer(regs)       ((unsigned long)(regs)->pc)
 
 extern void show_regs(struct pt_regs *);
 
+#define arch_has_single_step()  (1)
+
 /*
- * These are defined as per linux/ptrace.h.
+ * kprobe-based event tracer support
  */
-struct task_struct;
+#include <linux/stddef.h>
+#include <linux/thread_info.h>
 
-#define arch_has_single_step()  (1)
+struct pt_regs_offset {
+        const char *name;
+        int offset;
+};
+
+#define REG_OFFSET_NAME(r) {.name = #r, .offset = offsetof(struct pt_regs, r)}
+#define REGS_OFFSET_NAME(num)   \
+        {.name = __stringify(r##num), .offset = offsetof(struct pt_regs, regs[num])}
+#define REG_OFFSET_END {.name = NULL, .offset = 0}
+
+/* Query offset/name of register from its name/offset */
+extern int regs_query_register_offset(const char *name);
+extern const char *regs_query_register_name(unsigned int offset);
+
+extern const struct pt_regs_offset regoffset_table[];
+
+/**
+ * regs_get_register() - get register value from its offset
+ * @regs:       pt_regs from which register value is gotten.
+ * @offset:     offset number of the register.
+ *
+ * regs_get_register returns the value of a register. The @offset is the
+ * offset of the register in struct pt_regs address which specified by @regs.
+ * If @offset is bigger than MAX_REG_OFFSET, this returns 0.
+ */
+static inline unsigned long regs_get_register(struct pt_regs *regs,
+                                              unsigned int offset)
+{
+        if (unlikely(offset > MAX_REG_OFFSET))
+                return 0;
+        return *(unsigned long *)((unsigned long)regs + offset);
+}
+
+/**
+ * regs_within_kernel_stack() - check the address in the stack
+ * @regs:       pt_regs which contains kernel stack pointer.
+ * @addr:       address which is checked.
+ *
+ * regs_within_kernel_stack() checks @addr is within the kernel stack page(s).
+ * If @addr is within the kernel stack, it returns true. If not, returns false.
+ */
+static inline int regs_within_kernel_stack(struct pt_regs *regs,
+                                           unsigned long addr)
+{
+        return ((addr & ~(THREAD_SIZE - 1))  ==
+                (kernel_stack_pointer(regs) & ~(THREAD_SIZE - 1)));
+}
+
+/**
+ * regs_get_kernel_stack_nth() - get Nth entry of the stack
+ * @regs:       pt_regs which contains kernel stack pointer.
+ * @n:          stack entry number.
+ *
+ * regs_get_kernel_stack_nth() returns @n th entry of the kernel stack which
+ * is specified by @regs. If the @n th entry is NOT in the kernel stack,
+ * this returns 0.
+ */
+static inline unsigned long regs_get_kernel_stack_nth(struct pt_regs *regs,
+                                                      unsigned int n)
+{
+        unsigned long *addr = (unsigned long *)kernel_stack_pointer(regs);
+        addr += n;
+        if (regs_within_kernel_stack(regs, (unsigned long)addr))
+                return *addr;
+        else
+                return 0;
+}
 
 struct perf_event;
 struct perf_sample_data;
diff --git a/arch/sh/kernel/Makefile b/arch/sh/kernel/Makefile
index e25f3c69525d..1086ba1abdab 100644
--- a/arch/sh/kernel/Makefile
+++ b/arch/sh/kernel/Makefile
@@ -14,7 +14,7 @@ CFLAGS_REMOVE_return_address.o = -pg
 obj-y   := clkdev.o debugtraps.o dma-nommu.o dumpstack.o                \
            idle.o io.o irq.o                                            \
            irq_$(BITS).o machvec.o nmi_debug.o process.o                \
-           process_$(BITS).o ptrace_$(BITS).o                           \
+           process_$(BITS).o ptrace.o ptrace_$(BITS).o                  \
            reboot.o return_address.o                                    \
            setup.o signal_$(BITS).o sys_sh.o sys_sh$(BITS).o            \
            syscalls_$(BITS).o time.o topology.o traps.o                 \
diff --git a/arch/sh/kernel/ptrace.c b/arch/sh/kernel/ptrace.c
new file mode 100644
index 000000000000..0a05983633ca
--- /dev/null
+++ b/arch/sh/kernel/ptrace.c
@@ -0,0 +1,33 @@
+#include <linux/ptrace.h>
+
+/**
+ * regs_query_register_offset() - query register offset from its name
+ * @name:       the name of a register
+ *
+ * regs_query_register_offset() returns the offset of a register in struct
+ * pt_regs from its name. If the name is invalid, this returns -EINVAL;
+ */
+int regs_query_register_offset(const char *name)
+{
+        const struct pt_regs_offset *roff;
+        for (roff = regoffset_table; roff->name != NULL; roff++)
+                if (!strcmp(roff->name, name))
+                        return roff->offset;
+        return -EINVAL;
+}
+
+/**
+ * regs_query_register_name() - query register name from its offset
+ * @offset:     the offset of a register in struct pt_regs.
+ *
+ * regs_query_register_name() returns the name of a register from its
+ * offset in struct pt_regs. If the @offset is invalid, this returns NULL;
+ */
+const char *regs_query_register_name(unsigned int offset)
+{
+        const struct pt_regs_offset *roff;
+        for (roff = regoffset_table; roff->name != NULL; roff++)
+                if (roff->offset == offset)
+                        return roff->name;
+        return NULL;
+}
diff --git a/arch/sh/kernel/ptrace_32.c b/arch/sh/kernel/ptrace_32.c
index 6c4bbba2a675..2cd42b58cb20 100644
--- a/arch/sh/kernel/ptrace_32.c
+++ b/arch/sh/kernel/ptrace_32.c
@@ -274,6 +274,33 @@ static int dspregs_active(struct task_struct *target,
 }
 #endif
 
+const struct pt_regs_offset regoffset_table[] = {
+        REGS_OFFSET_NAME(0),
+        REGS_OFFSET_NAME(1),
+        REGS_OFFSET_NAME(2),
+        REGS_OFFSET_NAME(3),
+        REGS_OFFSET_NAME(4),
+        REGS_OFFSET_NAME(5),
+        REGS_OFFSET_NAME(6),
+        REGS_OFFSET_NAME(7),
+        REGS_OFFSET_NAME(8),
+        REGS_OFFSET_NAME(9),
+        REGS_OFFSET_NAME(10),
+        REGS_OFFSET_NAME(11),
+        REGS_OFFSET_NAME(12),
+        REGS_OFFSET_NAME(13),
+        REGS_OFFSET_NAME(14),
+        REGS_OFFSET_NAME(15),
+        REG_OFFSET_NAME(pc),
+        REG_OFFSET_NAME(pr),
+        REG_OFFSET_NAME(sr),
+        REG_OFFSET_NAME(gbr),
+        REG_OFFSET_NAME(mach),
+        REG_OFFSET_NAME(macl),
+        REG_OFFSET_NAME(tra),
+        REG_OFFSET_END,
+};
+
 /*
  * These are our native regset flavours.
  */
diff --git a/arch/sh/kernel/ptrace_64.c b/arch/sh/kernel/ptrace_64.c
index 5fd644da7f02..b97817016b6a 100644
--- a/arch/sh/kernel/ptrace_64.c
+++ b/arch/sh/kernel/ptrace_64.c
@@ -252,6 +252,85 @@ static int fpregs_active(struct task_struct *target,
 }
 #endif
 
+const struct pt_regs_offset regoffset_table[] = {
+        REG_OFFSET_NAME(pc),
+        REG_OFFSET_NAME(sr),
+        REG_OFFSET_NAME(syscall_nr),
+        REGS_OFFSET_NAME(0),
+        REGS_OFFSET_NAME(1),
+        REGS_OFFSET_NAME(2),
+        REGS_OFFSET_NAME(3),
+        REGS_OFFSET_NAME(4),
+        REGS_OFFSET_NAME(5),
+        REGS_OFFSET_NAME(6),
+        REGS_OFFSET_NAME(7),
+        REGS_OFFSET_NAME(8),
+        REGS_OFFSET_NAME(9),
+        REGS_OFFSET_NAME(10),
+        REGS_OFFSET_NAME(11),
+        REGS_OFFSET_NAME(12),
+        REGS_OFFSET_NAME(13),
+        REGS_OFFSET_NAME(14),
+        REGS_OFFSET_NAME(15),
+        REGS_OFFSET_NAME(16),
+        REGS_OFFSET_NAME(17),
+        REGS_OFFSET_NAME(18),
+        REGS_OFFSET_NAME(19),
+        REGS_OFFSET_NAME(20),
+        REGS_OFFSET_NAME(21),
+        REGS_OFFSET_NAME(22),
+        REGS_OFFSET_NAME(23),
+        REGS_OFFSET_NAME(24),
+        REGS_OFFSET_NAME(25),
+        REGS_OFFSET_NAME(26),
+        REGS_OFFSET_NAME(27),
+        REGS_OFFSET_NAME(28),
+        REGS_OFFSET_NAME(29),
+        REGS_OFFSET_NAME(30),
+        REGS_OFFSET_NAME(31),
+        REGS_OFFSET_NAME(32),
+        REGS_OFFSET_NAME(33),
+        REGS_OFFSET_NAME(34),
+        REGS_OFFSET_NAME(35),
+        REGS_OFFSET_NAME(36),
+        REGS_OFFSET_NAME(37),
+        REGS_OFFSET_NAME(38),
+        REGS_OFFSET_NAME(39),
+        REGS_OFFSET_NAME(40),
+        REGS_OFFSET_NAME(41),
+        REGS_OFFSET_NAME(42),
+        REGS_OFFSET_NAME(43),
+        REGS_OFFSET_NAME(44),
+        REGS_OFFSET_NAME(45),
+        REGS_OFFSET_NAME(46),
+        REGS_OFFSET_NAME(47),
+        REGS_OFFSET_NAME(48),
+        REGS_OFFSET_NAME(49),
+        REGS_OFFSET_NAME(50),
+        REGS_OFFSET_NAME(51),
+        REGS_OFFSET_NAME(52),
+        REGS_OFFSET_NAME(53),
+        REGS_OFFSET_NAME(54),
+        REGS_OFFSET_NAME(55),
+        REGS_OFFSET_NAME(56),
+        REGS_OFFSET_NAME(57),
+        REGS_OFFSET_NAME(58),
+        REGS_OFFSET_NAME(59),
+        REGS_OFFSET_NAME(60),
+        REGS_OFFSET_NAME(61),
+        REGS_OFFSET_NAME(62),
+        REGS_OFFSET_NAME(63),
+        TREGS_OFFSET_NAME(0),
+        TREGS_OFFSET_NAME(1),
+        TREGS_OFFSET_NAME(2),
+        TREGS_OFFSET_NAME(3),
+        TREGS_OFFSET_NAME(4),
+        TREGS_OFFSET_NAME(5),
+        TREGS_OFFSET_NAME(6),
+        TREGS_OFFSET_NAME(7),
+        REG_OFFSET_END,
+};
+
 /*
  * These are our native regset flavours.
  */