MIPS: oprofile: Add callgraph support

Stack unwinding is done by code examination. For kernelspace, the already existing unwind function is utilized that uses kallsyms to quickly find the beginning of functions. For userspace a new function was added that examines code at and before the pc. Signed-off-by: Daniel Kalmar <kalmard@homejinni.com> Signed-off-by: Gergely Kis <gergely@homejinni.com> Signed-off-by: Robert Richter <robert.richter@amd.com>

MIPS: oprofile: Add callgraph support
Stack unwinding is done by code examination. For kernelspace, the already existing unwind function is utilized that uses kallsyms to quickly find the beginning of functions. For userspace a new function was added that examines code at and before the pc. Signed-off-by: Daniel Kalmar <kalmard@homejinni.com> Signed-off-by: Gergely Kis <gergely@homejinni.com> Signed-off-by: Robert Richter <robert.richter@amd.com>
Daniel Kalmar · Robert Richter
1 parent 94ea09c6a8
Showing 4 changed files with 179 additions and 1 deletions Side-by-side Diff
arch/mips/oprofile/Makefile
arch/mips/oprofile/backtrace.c
arch/mips/oprofile/common.c
arch/mips/oprofile/op_impl.h
@@ -8,7 +8,7 @@
 		oprofilefs.o oprofile_stats.o \
 		timer_int.o )
  
-oprofile-y				:= $(DRIVER_OBJS) common.o
+oprofile-y				:= $(DRIVER_OBJS) common.o backtrace.o
  
 oprofile-$(CONFIG_CPU_MIPS32)		+= op_model_mipsxx.o
 oprofile-$(CONFIG_CPU_MIPS64)		+= op_model_mipsxx.o
+#include <linux/oprofile.h>
+#include <linux/sched.h>
+#include <linux/mm.h>
+#include <linux/uaccess.h>
+#include <asm/ptrace.h>
+#include <asm/stacktrace.h>
+#include <linux/stacktrace.h>
+#include <linux/kernel.h>
+#include <asm/sections.h>
+#include <asm/inst.h>
+
+struct stackframe {
+	unsigned long sp;
+	unsigned long pc;
+	unsigned long ra;
+};
+
+static inline int get_mem(unsigned long addr, unsigned long *result)
+{
+	unsigned long *address = (unsigned long *) addr;
+	if (!access_ok(VERIFY_READ, addr, sizeof(unsigned long)))
+		return -1;
+	if (__copy_from_user_inatomic(result, address, sizeof(unsigned long)))
+		return -3;
+	return 0;
+}
+
+/*
+ * These two instruction helpers were taken from process.c
+ */
+static inline int is_ra_save_ins(union mips_instruction *ip)
+{
+	/* sw / sd $ra, offset($sp) */
+	return (ip->i_format.opcode == sw_op || ip->i_format.opcode == sd_op)
+		&& ip->i_format.rs == 29 && ip->i_format.rt == 31;
+}
+
+static inline int is_sp_move_ins(union mips_instruction *ip)
+{
+	/* addiu/daddiu sp,sp,-imm */
+	if (ip->i_format.rs != 29 || ip->i_format.rt != 29)
+		return 0;
+	if (ip->i_format.opcode == addiu_op || ip->i_format.opcode == daddiu_op)
+		return 1;
+	return 0;
+}
+
+/*
+ * Looks for specific instructions that mark the end of a function.
+ * This usually means we ran into the code area of the previous function.
+ */
+static inline int is_end_of_function_marker(union mips_instruction *ip)
+{
+	/* jr ra */
+	if (ip->r_format.func == jr_op && ip->r_format.rs == 31)
+		return 1;
+	/* lui gp */
+	if (ip->i_format.opcode == lui_op && ip->i_format.rt == 28)
+		return 1;
+	return 0;
+}
+
+/*
+ * TODO for userspace stack unwinding:
+ * - handle cases where the stack is adjusted inside a function
+ *     (generally doesn't happen)
+ * - find optimal value for max_instr_check
+ * - try to find a way to handle leaf functions
+ */
+
+static inline int unwind_user_frame(struct stackframe *old_frame,
+				    const unsigned int max_instr_check)
+{
+	struct stackframe new_frame = *old_frame;
+	off_t ra_offset = 0;
+	size_t stack_size = 0;
+	unsigned long addr;
+
+	if (old_frame->pc == 0 || old_frame->sp == 0 || old_frame->ra == 0)
+		return -9;
+
+	for (addr = new_frame.pc; (addr + max_instr_check > new_frame.pc)
+		&& (!ra_offset || !stack_size); --addr) {
+		union mips_instruction ip;
+
+		if (get_mem(addr, (unsigned long *) &ip))
+			return -11;
+
+		if (is_sp_move_ins(&ip)) {
+			int stack_adjustment = ip.i_format.simmediate;
+			if (stack_adjustment > 0)
+				/* This marks the end of the previous function,
+				   which means we overran. */
+				break;
+			stack_size = (unsigned) stack_adjustment;
+		} else if (is_ra_save_ins(&ip)) {
+			int ra_slot = ip.i_format.simmediate;
+			if (ra_slot < 0)
+				/* This shouldn't happen. */
+				break;
+			ra_offset = ra_slot;
+		} else if (is_end_of_function_marker(&ip))
+			break;
+	}
+
+	if (!ra_offset || !stack_size)
+		return -1;
+
+	if (ra_offset) {
+		new_frame.ra = old_frame->sp + ra_offset;
+		if (get_mem(new_frame.ra, &(new_frame.ra)))
+			return -13;
+	}
+
+	if (stack_size) {
+		new_frame.sp = old_frame->sp + stack_size;
+		if (get_mem(new_frame.sp, &(new_frame.sp)))
+			return -14;
+	}
+
+	if (new_frame.sp > old_frame->sp)
+		return -2;
+
+	new_frame.pc = old_frame->ra;
+	*old_frame = new_frame;
+
+	return 0;
+}
+
+static inline void do_user_backtrace(unsigned long low_addr,
+				     struct stackframe *frame,
+				     unsigned int depth)
+{
+	const unsigned int max_instr_check = 512;
+	const unsigned long high_addr = low_addr + THREAD_SIZE;
+
+	while (depth-- && !unwind_user_frame(frame, max_instr_check)) {
+		oprofile_add_trace(frame->ra);
+		if (frame->sp < low_addr || frame->sp > high_addr)
+			break;
+	}
+}
+
+#ifndef CONFIG_KALLSYMS
+static inline void do_kernel_backtrace(unsigned long low_addr,
+				       struct stackframe *frame,
+				       unsigned int depth) { }
+#else
+static inline void do_kernel_backtrace(unsigned long low_addr,
+				       struct stackframe *frame,
+				       unsigned int depth)
+{
+	while (depth-- && frame->pc) {
+		frame->pc = unwind_stack_by_address(low_addr,
+						    &(frame->sp),
+						    frame->pc,
+						    &(frame->ra));
+		oprofile_add_trace(frame->ra);
+	}
+}
+#endif
+
+void notrace op_mips_backtrace(struct pt_regs *const regs, unsigned int depth)
+{
+	struct stackframe frame = { .sp = regs->regs[29],
+				    .pc = regs->cp0_epc,
+				    .ra = regs->regs[31] };
+	const int userspace = user_mode(regs);
+	const unsigned long low_addr = ALIGN(frame.sp, THREAD_SIZE);
+
+	if (userspace)
+		do_user_backtrace(low_addr, &frame, depth);
+	else
+		do_kernel_backtrace(low_addr, &frame, depth);
+}
@@ -115,6 +115,7 @@
 	ops->start		= op_mips_start;
 	ops->stop		= op_mips_stop;
 	ops->cpu_type		= lmodel->cpu_type;
+	ops->backtrace		= op_mips_backtrace;
  
 	printk(KERN_INFO "oprofile: using %s performance monitoring.\n",
 	       lmodel->cpu_type);
@@ -36,5 +36,7 @@
 	unsigned char num_counters;
 };
  
+void op_mips_backtrace(struct pt_regs * const regs, unsigned int depth);
+
 #endif
...	...	@@ -8,7 +8,7 @@
8	8	oprofilefs.o oprofile_stats.o \
9	9	timer_int.o )
10	10
11		-oprofile-y := $(DRIVER_OBJS) common.o
	11	+oprofile-y := $(DRIVER_OBJS) common.o backtrace.o
12	12
13	13	oprofile-$(CONFIG_CPU_MIPS32) += op_model_mipsxx.o
14	14	oprofile-$(CONFIG_CPU_MIPS64) += op_model_mipsxx.o
	1	+#include <linux/oprofile.h>
	2	+#include <linux/sched.h>
	3	+#include <linux/mm.h>
	4	+#include <linux/uaccess.h>
	5	+#include <asm/ptrace.h>
	6	+#include <asm/stacktrace.h>
	7	+#include <linux/stacktrace.h>
	8	+#include <linux/kernel.h>
	9	+#include <asm/sections.h>
	10	+#include <asm/inst.h>
	11	+
	12	+struct stackframe {
	13	+ unsigned long sp;
	14	+ unsigned long pc;
	15	+ unsigned long ra;
	16	+};
	17	+
	18	+static inline int get_mem(unsigned long addr, unsigned long *result)
	19	+{
	20	+ unsigned long address = (unsigned long ) addr;
	21	+ if (!access_ok(VERIFY_READ, addr, sizeof(unsigned long)))
	22	+ return -1;
	23	+ if (__copy_from_user_inatomic(result, address, sizeof(unsigned long)))
	24	+ return -3;
	25	+ return 0;
	26	+}
	27	+
	28	+/*
	29	+ * These two instruction helpers were taken from process.c
	30	+ */
	31	+static inline int is_ra_save_ins(union mips_instruction *ip)
	32	+{
	33	+ /* sw / sd $ra, offset($sp) */
	34	+ return (ip->i_format.opcode == sw_op \|\| ip->i_format.opcode == sd_op)
	35	+ && ip->i_format.rs == 29 && ip->i_format.rt == 31;
	36	+}
	37	+
	38	+static inline int is_sp_move_ins(union mips_instruction *ip)
	39	+{
	40	+ /* addiu/daddiu sp,sp,-imm */
	41	+ if (ip->i_format.rs != 29 \|\| ip->i_format.rt != 29)
	42	+ return 0;
	43	+ if (ip->i_format.opcode == addiu_op \|\| ip->i_format.opcode == daddiu_op)
	44	+ return 1;
	45	+ return 0;
	46	+}
	47	+
	48	+/*
	49	+ * Looks for specific instructions that mark the end of a function.
	50	+ * This usually means we ran into the code area of the previous function.
	51	+ */
	52	+static inline int is_end_of_function_marker(union mips_instruction *ip)
	53	+{
	54	+ /* jr ra */
	55	+ if (ip->r_format.func == jr_op && ip->r_format.rs == 31)
	56	+ return 1;
	57	+ /* lui gp */
	58	+ if (ip->i_format.opcode == lui_op && ip->i_format.rt == 28)
	59	+ return 1;
	60	+ return 0;
	61	+}
	62	+
	63	+/*
	64	+ * TODO for userspace stack unwinding:
	65	+ * - handle cases where the stack is adjusted inside a function
	66	+ * (generally doesn't happen)
	67	+ * - find optimal value for max_instr_check
	68	+ * - try to find a way to handle leaf functions
	69	+ */
	70	+
	71	+static inline int unwind_user_frame(struct stackframe *old_frame,
	72	+ const unsigned int max_instr_check)
	73	+{
	74	+ struct stackframe new_frame = *old_frame;
	75	+ off_t ra_offset = 0;
	76	+ size_t stack_size = 0;
	77	+ unsigned long addr;
	78	+
	79	+ if (old_frame->pc == 0 \|\| old_frame->sp == 0 \|\| old_frame->ra == 0)
	80	+ return -9;
	81	+
	82	+ for (addr = new_frame.pc; (addr + max_instr_check > new_frame.pc)
	83	+ && (!ra_offset \|\| !stack_size); --addr) {
	84	+ union mips_instruction ip;
	85	+
	86	+ if (get_mem(addr, (unsigned long *) &ip))
	87	+ return -11;
	88	+
	89	+ if (is_sp_move_ins(&ip)) {
	90	+ int stack_adjustment = ip.i_format.simmediate;
	91	+ if (stack_adjustment > 0)
	92	+ /* This marks the end of the previous function,
	93	+ which means we overran. */
	94	+ break;
	95	+ stack_size = (unsigned) stack_adjustment;
	96	+ } else if (is_ra_save_ins(&ip)) {
	97	+ int ra_slot = ip.i_format.simmediate;
	98	+ if (ra_slot < 0)
	99	+ /* This shouldn't happen. */
	100	+ break;
	101	+ ra_offset = ra_slot;
	102	+ } else if (is_end_of_function_marker(&ip))
	103	+ break;
	104	+ }
	105	+
	106	+ if (!ra_offset \|\| !stack_size)
	107	+ return -1;
	108	+
	109	+ if (ra_offset) {
	110	+ new_frame.ra = old_frame->sp + ra_offset;
	111	+ if (get_mem(new_frame.ra, &(new_frame.ra)))
	112	+ return -13;
	113	+ }
	114	+
	115	+ if (stack_size) {
	116	+ new_frame.sp = old_frame->sp + stack_size;
	117	+ if (get_mem(new_frame.sp, &(new_frame.sp)))
	118	+ return -14;
	119	+ }
	120	+
	121	+ if (new_frame.sp > old_frame->sp)
	122	+ return -2;
	123	+
	124	+ new_frame.pc = old_frame->ra;
	125	+ *old_frame = new_frame;
	126	+
	127	+ return 0;
	128	+}
	129	+
	130	+static inline void do_user_backtrace(unsigned long low_addr,
	131	+ struct stackframe *frame,
	132	+ unsigned int depth)
	133	+{
	134	+ const unsigned int max_instr_check = 512;
	135	+ const unsigned long high_addr = low_addr + THREAD_SIZE;
	136	+
	137	+ while (depth-- && !unwind_user_frame(frame, max_instr_check)) {
	138	+ oprofile_add_trace(frame->ra);
	139	+ if (frame->sp < low_addr \|\| frame->sp > high_addr)
	140	+ break;
	141	+ }
	142	+}
	143	+
	144	+#ifndef CONFIG_KALLSYMS
	145	+static inline void do_kernel_backtrace(unsigned long low_addr,
	146	+ struct stackframe *frame,
	147	+ unsigned int depth) { }
	148	+#else
	149	+static inline void do_kernel_backtrace(unsigned long low_addr,
	150	+ struct stackframe *frame,
	151	+ unsigned int depth)
	152	+{
	153	+ while (depth-- && frame->pc) {
	154	+ frame->pc = unwind_stack_by_address(low_addr,
	155	+ &(frame->sp),
	156	+ frame->pc,
	157	+ &(frame->ra));
	158	+ oprofile_add_trace(frame->ra);
	159	+ }
	160	+}
	161	+#endif
	162	+
	163	+void notrace op_mips_backtrace(struct pt_regs *const regs, unsigned int depth)
	164	+{
	165	+ struct stackframe frame = { .sp = regs->regs[29],
	166	+ .pc = regs->cp0_epc,
	167	+ .ra = regs->regs[31] };
	168	+ const int userspace = user_mode(regs);
	169	+ const unsigned long low_addr = ALIGN(frame.sp, THREAD_SIZE);
	170	+
	171	+ if (userspace)
	172	+ do_user_backtrace(low_addr, &frame, depth);
	173	+ else
	174	+ do_kernel_backtrace(low_addr, &frame, depth);
	175	+}
...	...	@@ -115,6 +115,7 @@
115	115	ops->start = op_mips_start;
116	116	ops->stop = op_mips_stop;
117	117	ops->cpu_type = lmodel->cpu_type;
	118	+ ops->backtrace = op_mips_backtrace;
118	119
119	120	printk(KERN_INFO "oprofile: using %s performance monitoring.\n",
120	121	lmodel->cpu_type);
...	...	@@ -36,5 +36,7 @@
36	36	unsigned char num_counters;
37	37	};
38	38
	39	+void op_mips_backtrace(struct pt_regs * const regs, unsigned int depth);
	40	+
39	41	#endif