sh: Add kprobe-based event tracer.
Paul Mundt [Mon, 14 Jun 2010 06:16:53 +0000 (15:16 +0900)]
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>

arch/sh/Kconfig
arch/sh/include/asm/kprobes.h
arch/sh/include/asm/processor_32.h
arch/sh/include/asm/processor_64.h
arch/sh/include/asm/ptrace.h
arch/sh/kernel/Makefile
arch/sh/kernel/ptrace.c [new file with mode: 0644]
arch/sh/kernel/ptrace_32.c
arch/sh/kernel/ptrace_64.c

index 573fca1..e6b1f20 100644 (file)
@@ -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
index 036c331..134f398 100644 (file)
@@ -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
 
index 61a445d..46d5179 100644 (file)
@@ -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
index 621bc46..2a541dd 100644 (file)
@@ -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 */
index 2168fde..33b3f37 100644 (file)
@@ -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;
index e25f3c6..1086ba1 100644 (file)
@@ -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 (file)
index 0000000..0a05983
--- /dev/null
@@ -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;
+}
index 6c4bbba..2cd42b5 100644 (file)
@@ -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.
  */
index 5fd644d..b978170 100644 (file)
@@ -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.
  */