Commit 5f307491 authored by Daniel Kalmar's avatar Daniel Kalmar Committed by Robert Richter
Browse files

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: default avatarDaniel Kalmar <kalmard@homejinni.com>
Signed-off-by: default avatarGergely Kis <gergely@homejinni.com>
Signed-off-by: default avatarRobert Richter <robert.richter@amd.com>
parent 94ea09c6

arch/mips/oprofile/Makefile

+1 −1
Original line number Original line Diff line number Diff line
@@ -8,7 +8,7 @@ DRIVER_OBJS = $(addprefix ../../../drivers/oprofile/, \ 
		oprofilefs.o oprofile_stats.o \

		oprofilefs.o oprofile_stats.o \

		timer_int.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_MIPS32)		+= op_model_mipsxx.o

oprofile-$(CONFIG_CPU_MIPS64)		+= op_model_mipsxx.o

oprofile-$(CONFIG_CPU_MIPS64)		+= op_model_mipsxx.o

arch/mips/oprofile/backtrace.c

0 → 100644
+175 −0
Original line number Original line Diff line number Diff line 
#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);

}

arch/mips/oprofile/common.c

+1 −0
Original line number Original line Diff line number Diff line
@@ -115,6 +115,7 @@ int __init oprofile_arch_init(struct oprofile_operations *ops) 
	ops->start		= op_mips_start;

	ops->start		= op_mips_start;

	ops->stop		= op_mips_stop;

	ops->stop		= op_mips_stop;

	ops->cpu_type		= lmodel->cpu_type;

	ops->cpu_type		= lmodel->cpu_type;

	ops->backtrace		= op_mips_backtrace;





	printk(KERN_INFO "oprofile: using %s performance monitoring.\n",

	printk(KERN_INFO "oprofile: using %s performance monitoring.\n",

	       lmodel->cpu_type);

	       lmodel->cpu_type);

arch/mips/oprofile/op_impl.h

+2 −0
Original line number Original line Diff line number Diff line
@@ -36,4 +36,6 @@ struct op_mips_model { 
	unsigned char num_counters;

	unsigned char num_counters;

};

};





void op_mips_backtrace(struct pt_regs * const regs, unsigned int depth);



#endif
 
#endif