[deliverable/linux.git] / arch / powerpc / oprofile / backtrace.c

/**
 * Copyright (C) 2005 Brian Rogan <bcr6@cornell.edu>, IBM
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version
 * 2 of the License, or (at your option) any later version.
**/

#include <linux/oprofile.h>
#include <linux/sched.h>
#include <asm/processor.h>
#include <linux/uaccess.h>
#include <asm/compat.h>
#include <asm/oprofile_impl.h>

#define STACK_SP(STACK)		*(STACK)

#define STACK_LR64(STACK)	*((unsigned long *)(STACK) + 2)
#define STACK_LR32(STACK)	*((unsigned int *)(STACK) + 1)

#ifdef CONFIG_PPC64
#define STACK_LR(STACK)		STACK_LR64(STACK)
#else
#define STACK_LR(STACK)		STACK_LR32(STACK)
#endif

static unsigned int user_getsp32(unsigned int sp, int is_first)
{
	unsigned int stack_frame[2];
	void __user *p = compat_ptr(sp);

	if (!access_ok(VERIFY_READ, p, sizeof(stack_frame)))
		return 0;

	/*
	 * The most likely reason for this is that we returned -EFAULT,
	 * which means that we've done all that we can do from
	 * interrupt context.
	 */
	if (__copy_from_user_inatomic(stack_frame, p, sizeof(stack_frame)))
		return 0;

	if (!is_first)
		oprofile_add_trace(STACK_LR32(stack_frame));

	/*
	 * We do not enforce increasing stack addresses here because
	 * we may transition to a different stack, eg a signal handler.
	 */
	return STACK_SP(stack_frame);
}

#ifdef CONFIG_PPC64
static unsigned long user_getsp64(unsigned long sp, int is_first)
{
	unsigned long stack_frame[3];

	if (!access_ok(VERIFY_READ, (void __user *)sp, sizeof(stack_frame)))
		return 0;

	if (__copy_from_user_inatomic(stack_frame, (void __user *)sp,
					sizeof(stack_frame)))
		return 0;

	if (!is_first)
		oprofile_add_trace(STACK_LR64(stack_frame));

	return STACK_SP(stack_frame);
}
#endif

static unsigned long kernel_getsp(unsigned long sp, int is_first)
{
	unsigned long *stack_frame = (unsigned long *)sp;

	if (!validate_sp(sp, current, STACK_FRAME_OVERHEAD))
		return 0;

	if (!is_first)
		oprofile_add_trace(STACK_LR(stack_frame));

	/*
	 * We do not enforce increasing stack addresses here because
	 * we might be transitioning from an interrupt stack to a kernel
	 * stack. validate_sp() is designed to understand this, so just
	 * use it.
	 */
	return STACK_SP(stack_frame);
}

void op_powerpc_backtrace(struct pt_regs * const regs, unsigned int depth)
{
	unsigned long sp = regs->gpr[1];
	int first_frame = 1;

	/* We ditch the top stackframe so need to loop through an extra time */
	depth += 1;

	if (!user_mode(regs)) {
		while (depth--) {
			sp = kernel_getsp(sp, first_frame);
			if (!sp)
				break;
			first_frame = 0;
		}
	} else {
		pagefault_disable();
#ifdef CONFIG_PPC64
		if (!is_32bit_task()) {
			while (depth--) {
				sp = user_getsp64(sp, first_frame);
				if (!sp)
					break;
				first_frame = 0;
			}
			pagefault_enable();
			return;
		}
#endif

		while (depth--) {
			sp = user_getsp32(sp, first_frame);
			if (!sp)
				break;
			first_frame = 0;
		}
		pagefault_enable();
	}
}
Commit	Line	Data
6c6bd754 BR	1	/**
	2	* Copyright (C) 2005 Brian Rogan <bcr6@cornell.edu>, IBM
	3	*
	4	* This program is free software; you can redistribute it and/or
	5	* modify it under the terms of the GNU General Public License
	6	* as published by the Free Software Foundation; either version
	7	* 2 of the License, or (at your option) any later version.
	8	**/
	9
	10	#include <linux/oprofile.h>
	11	#include <linux/sched.h>
	12	#include <asm/processor.h>
0de3b56b	13	#include <linux/uaccess.h>
62034f03	14	#include <asm/compat.h>
1217d34b	15	#include <asm/oprofile_impl.h>
6c6bd754 BR	16
	17	#define STACK_SP(STACK) *(STACK)
	18
	19	#define STACK_LR64(STACK) ((unsigned long )(STACK) + 2)
	20	#define STACK_LR32(STACK) ((unsigned int )(STACK) + 1)
	21
	22	#ifdef CONFIG_PPC64
	23	#define STACK_LR(STACK) STACK_LR64(STACK)
	24	#else
	25	#define STACK_LR(STACK) STACK_LR32(STACK)
	26	#endif
	27
	28	static unsigned int user_getsp32(unsigned int sp, int is_first)
	29	{
	30	unsigned int stack_frame[2];
62034f03	31	void __user *p = compat_ptr(sp);
6c6bd754	32
62034f03	33	if (!access_ok(VERIFY_READ, p, sizeof(stack_frame)))
6c6bd754 BR	34	return 0;
	35
	36	/*
	37	* The most likely reason for this is that we returned -EFAULT,
	38	* which means that we've done all that we can do from
	39	* interrupt context.
	40	*/
62034f03	41	if (__copy_from_user_inatomic(stack_frame, p, sizeof(stack_frame)))
6c6bd754 BR	42	return 0;
	43
	44	if (!is_first)
	45	oprofile_add_trace(STACK_LR32(stack_frame));
	46
	47	/*
	48	* We do not enforce increasing stack addresses here because
	49	* we may transition to a different stack, eg a signal handler.
	50	*/
	51	return STACK_SP(stack_frame);
	52	}
	53
	54	#ifdef CONFIG_PPC64
	55	static unsigned long user_getsp64(unsigned long sp, int is_first)
	56	{
	57	unsigned long stack_frame[3];
	58
62034f03	59	if (!access_ok(VERIFY_READ, (void __user *)sp, sizeof(stack_frame)))
6c6bd754 BR	60	return 0;
6c6bd754 BR	61
62034f03	62	if (__copy_from_user_inatomic(stack_frame, (void __user *)sp,
6c6bd754 BR	63	sizeof(stack_frame)))
	64	return 0;
	65
	66	if (!is_first)
	67	oprofile_add_trace(STACK_LR64(stack_frame));
	68
	69	return STACK_SP(stack_frame);
	70	}
	71	#endif
	72
	73	static unsigned long kernel_getsp(unsigned long sp, int is_first)
	74	{
	75	unsigned long stack_frame = (unsigned long )sp;
	76
	77	if (!validate_sp(sp, current, STACK_FRAME_OVERHEAD))
	78	return 0;
	79
	80	if (!is_first)
	81	oprofile_add_trace(STACK_LR(stack_frame));
	82
	83	/*
	84	* We do not enforce increasing stack addresses here because
	85	* we might be transitioning from an interrupt stack to a kernel
	86	* stack. validate_sp() is designed to understand this, so just
	87	* use it.
	88	*/
	89	return STACK_SP(stack_frame);
	90	}
	91
	92	void op_powerpc_backtrace(struct pt_regs * const regs, unsigned int depth)
	93	{
	94	unsigned long sp = regs->gpr[1];
	95	int first_frame = 1;
	96
	97	/* We ditch the top stackframe so need to loop through an extra time */
	98	depth += 1;
	99
	100	if (!user_mode(regs)) {
	101	while (depth--) {
	102	sp = kernel_getsp(sp, first_frame);
	103	if (!sp)
	104	break;
	105	first_frame = 0;
	106	}
	107	} else {
0de3b56b	108	pagefault_disable();
6c6bd754	109	#ifdef CONFIG_PPC64
cab175f9	110	if (!is_32bit_task()) {
6c6bd754 BR	111	while (depth--) {
	112	sp = user_getsp64(sp, first_frame);
	113	if (!sp)
	114	break;
	115	first_frame = 0;
	116	}
0de3b56b	117	pagefault_enable();
6c6bd754 BR	118	return;
	119	}
	120	#endif
	121
	122	while (depth--) {
	123	sp = user_getsp32(sp, first_frame);
	124	if (!sp)
	125	break;
	126	first_frame = 0;
	127	}
0de3b56b	128	pagefault_enable();
6c6bd754 BR	129	}
6c6bd754 BR	130	}