[net-next-2.6.git] / arch / parisc / kernel / unwind.c

/*
 * Kernel unwinding support
 *
 * (c) 2002-2004 Randolph Chung <tausq@debian.org>
 *
 * Derived partially from the IA64 implementation. The PA-RISC
 * Runtime Architecture Document is also a useful reference to
 * understand what is happening here
 */

#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/sched.h>
#include <linux/slab.h>
#include <linux/kallsyms.h>
#include <linux/sort.h>

#include <asm/uaccess.h>
#include <asm/assembly.h>
#include <asm/asm-offsets.h>
#include <asm/ptrace.h>

#include <asm/unwind.h>

/* #define DEBUG 1 */
#ifdef DEBUG
#define dbg(x...) printk(x)
#else
#define dbg(x...)
#endif

#define KERNEL_START (KERNEL_BINARY_TEXT_START)

extern struct unwind_table_entry __start___unwind[];
extern struct unwind_table_entry __stop___unwind[];

static spinlock_t unwind_lock;
/*
 * the kernel unwind block is not dynamically allocated so that
 * we can call unwind_init as early in the bootup process as 
 * possible (before the slab allocator is initialized)
 */
static struct unwind_table kernel_unwind_table __read_mostly;
static LIST_HEAD(unwind_tables);

static inline const struct unwind_table_entry *
find_unwind_entry_in_table(const struct unwind_table *table, unsigned long addr)
{
	const struct unwind_table_entry *e = NULL;
	unsigned long lo, hi, mid;

	lo = 0; 
	hi = table->length - 1; 
	
	while (lo <= hi) {
		mid = (hi - lo) / 2 + lo;
		e = &table->table[mid];
		if (addr < e->region_start)
			hi = mid - 1;
		else if (addr > e->region_end)
			lo = mid + 1;
		else
			return e;
	}

	return NULL;
}

static const struct unwind_table_entry *
find_unwind_entry(unsigned long addr)
{
	struct unwind_table *table;
	const struct unwind_table_entry *e = NULL;

	if (addr >= kernel_unwind_table.start && 
	    addr <= kernel_unwind_table.end)
		e = find_unwind_entry_in_table(&kernel_unwind_table, addr);
	else 
		list_for_each_entry(table, &unwind_tables, list) {
			if (addr >= table->start && 
			    addr <= table->end)
				e = find_unwind_entry_in_table(table, addr);
			if (e) {
				/* Move-to-front to exploit common traces */
				list_move(&table->list, &unwind_tables);
				break;
			}
		}

	return e;
}

static void
unwind_table_init(struct unwind_table *table, const char *name,
		  unsigned long base_addr, unsigned long gp,
		  void *table_start, void *table_end)
{
	struct unwind_table_entry *start = table_start;
	struct unwind_table_entry *end = 
		(struct unwind_table_entry *)table_end - 1;

	table->name = name;
	table->base_addr = base_addr;
	table->gp = gp;
	table->start = base_addr + start->region_start;
	table->end = base_addr + end->region_end;
	table->table = (struct unwind_table_entry *)table_start;
	table->length = end - start + 1;
	INIT_LIST_HEAD(&table->list);

	for (; start <= end; start++) {
		if (start < end && 
		    start->region_end > (start+1)->region_start) {
			printk("WARNING: Out of order unwind entry! %p and %p\n", start, start+1);
		}

		start->region_start += base_addr;
		start->region_end += base_addr;
	}
}

static int cmp_unwind_table_entry(const void *a, const void *b)
{
	return ((const struct unwind_table_entry *)a)->region_start
	     - ((const struct unwind_table_entry *)b)->region_start;
}

static void
unwind_table_sort(struct unwind_table_entry *start,
		  struct unwind_table_entry *finish)
{
	sort(start, finish - start, sizeof(struct unwind_table_entry),
	     cmp_unwind_table_entry, NULL);
}

struct unwind_table *
unwind_table_add(const char *name, unsigned long base_addr, 
		 unsigned long gp,
                 void *start, void *end)
{
	struct unwind_table *table;
	unsigned long flags;
	struct unwind_table_entry *s = (struct unwind_table_entry *)start;
	struct unwind_table_entry *e = (struct unwind_table_entry *)end;

	unwind_table_sort(s, e);

	table = kmalloc(sizeof(struct unwind_table), GFP_USER);
	if (table == NULL)
		return NULL;
	unwind_table_init(table, name, base_addr, gp, start, end);
	spin_lock_irqsave(&unwind_lock, flags);
	list_add_tail(&table->list, &unwind_tables);
	spin_unlock_irqrestore(&unwind_lock, flags);

	return table;
}

void unwind_table_remove(struct unwind_table *table)
{
	unsigned long flags;

	spin_lock_irqsave(&unwind_lock, flags);
	list_del(&table->list);
	spin_unlock_irqrestore(&unwind_lock, flags);

	kfree(table);
}

/* Called from setup_arch to import the kernel unwind info */
int unwind_init(void)
{
	long start, stop;
	register unsigned long gp __asm__ ("r27");

	start = (long)&__start___unwind[0];
	stop = (long)&__stop___unwind[0];

	spin_lock_init(&unwind_lock);

	printk("unwind_init: start = 0x%lx, end = 0x%lx, entries = %lu\n", 
	    start, stop,
	    (stop - start) / sizeof(struct unwind_table_entry));

	unwind_table_init(&kernel_unwind_table, "kernel", KERNEL_START,
			  gp, 
			  &__start___unwind[0], &__stop___unwind[0]);
#if 0
	{
		int i;
		for (i = 0; i < 10; i++)
		{
			printk("region 0x%x-0x%x\n", 
				__start___unwind[i].region_start, 
				__start___unwind[i].region_end);
		}
	}
#endif
	return 0;
}

#ifdef CONFIG_64BIT
#define get_func_addr(fptr) fptr[2]
#else
#define get_func_addr(fptr) fptr[0]
#endif

static int unwind_special(struct unwind_frame_info *info, unsigned long pc, int frame_size)
{
	extern void handle_interruption(int, struct pt_regs *);
	static unsigned long *hi = (unsigned long *)&handle_interruption;

	if (pc == get_func_addr(hi)) {
		struct pt_regs *regs = (struct pt_regs *)(info->sp - frame_size - PT_SZ_ALGN);
		dbg("Unwinding through handle_interruption()\n");
		info->prev_sp = regs->gr[30];
		info->prev_ip = regs->iaoq[0];

		return 1;
	}

	return 0;
}

static void unwind_frame_regs(struct unwind_frame_info *info)
{
	const struct unwind_table_entry *e;
	unsigned long npc;
	unsigned int insn;
	long frame_size = 0;
	int looking_for_rp, rpoffset = 0;

	e = find_unwind_entry(info->ip);
	if (e == NULL) {
		unsigned long sp;
		extern char _stext[], _etext[];

		dbg("Cannot find unwind entry for 0x%lx; forced unwinding\n", info->ip);

#ifdef CONFIG_KALLSYMS
		/* Handle some frequent special cases.... */
		{
			char symname[KSYM_NAME_LEN];
			char *modname;

			kallsyms_lookup(info->ip, NULL, NULL, &modname,
				symname);

			dbg("info->ip = 0x%lx, name = %s\n", info->ip, symname);

			if (strcmp(symname, "_switch_to_ret") == 0) {
				info->prev_sp = info->sp - CALLEE_SAVE_FRAME_SIZE;
				info->prev_ip = *(unsigned long *)(info->prev_sp - RP_OFFSET);
				dbg("_switch_to_ret @ %lx - setting "
				    "prev_sp=%lx prev_ip=%lx\n", 
				    info->ip, info->prev_sp, 
				    info->prev_ip);
				return;
			} else if (strcmp(symname, "ret_from_kernel_thread") == 0 ||
				   strcmp(symname, "syscall_exit") == 0) {
				info->prev_ip = info->prev_sp = 0;
				return;
			}
		}
#endif

		/* Since we are doing the unwinding blind, we don't know if
		   we are adjusting the stack correctly or extracting the rp
		   correctly. The rp is checked to see if it belongs to the
		   kernel text section, if not we assume we don't have a 
		   correct stack frame and we continue to unwind the stack.
		   This is not quite correct, and will fail for loadable
		   modules. */
		sp = info->sp & ~63;
		do {
			unsigned long tmp;

			info->prev_sp = sp - 64;
			info->prev_ip = 0;
			if (get_user(tmp, (unsigned long *)(info->prev_sp - RP_OFFSET))) 
				break;
			info->prev_ip = tmp;
			sp = info->prev_sp;
		} while (info->prev_ip < (unsigned long)_stext ||
			 info->prev_ip > (unsigned long)_etext);

		info->rp = 0;

		dbg("analyzing func @ %lx with no unwind info, setting "
		    "prev_sp=%lx prev_ip=%lx\n", info->ip, 
		    info->prev_sp, info->prev_ip);
	} else {
		dbg("e->start = 0x%x, e->end = 0x%x, Save_SP = %d, "
		    "Save_RP = %d, Millicode = %d size = %u\n", 
		    e->region_start, e->region_end, e->Save_SP, e->Save_RP, 
		    e->Millicode, e->Total_frame_size);

		looking_for_rp = e->Save_RP;

		for (npc = e->region_start; 
		     (frame_size < (e->Total_frame_size << 3) || 
		      looking_for_rp) && 
		     npc < info->ip; 
		     npc += 4) {

			insn = *(unsigned int *)npc;

			if ((insn & 0xffffc000) == 0x37de0000 ||
			    (insn & 0xffe00000) == 0x6fc00000) {
				/* ldo X(sp), sp, or stwm X,D(sp) */
				frame_size += (insn & 0x1 ? -1 << 13 : 0) | 
					((insn & 0x3fff) >> 1);
				dbg("analyzing func @ %lx, insn=%08x @ "
				    "%lx, frame_size = %ld\n", info->ip,
				    insn, npc, frame_size);
			} else if ((insn & 0xffe00008) == 0x73c00008) {
				/* std,ma X,D(sp) */
				frame_size += (insn & 0x1 ? -1 << 13 : 0) | 
					(((insn >> 4) & 0x3ff) << 3);
				dbg("analyzing func @ %lx, insn=%08x @ "
				    "%lx, frame_size = %ld\n", info->ip,
				    insn, npc, frame_size);
			} else if (insn == 0x6bc23fd9) { 
				/* stw rp,-20(sp) */
				rpoffset = 20;
				looking_for_rp = 0;
				dbg("analyzing func @ %lx, insn=stw rp,"
				    "-20(sp) @ %lx\n", info->ip, npc);
			} else if (insn == 0x0fc212c1) {
				/* std rp,-16(sr0,sp) */
				rpoffset = 16;
				looking_for_rp = 0;
				dbg("analyzing func @ %lx, insn=std rp,"
				    "-16(sp) @ %lx\n", info->ip, npc);
			}
		}

		if (!unwind_special(info, e->region_start, frame_size)) {
			info->prev_sp = info->sp - frame_size;
			if (e->Millicode)
				info->rp = info->r31;
			else if (rpoffset)
				info->rp = *(unsigned long *)(info->prev_sp - rpoffset);
			info->prev_ip = info->rp;
			info->rp = 0;
		}

		dbg("analyzing func @ %lx, setting prev_sp=%lx "
		    "prev_ip=%lx npc=%lx\n", info->ip, info->prev_sp, 
		    info->prev_ip, npc);
	}
}

void unwind_frame_init(struct unwind_frame_info *info, struct task_struct *t, 
		       struct pt_regs *regs)
{
	memset(info, 0, sizeof(struct unwind_frame_info));
	info->t = t;
	info->sp = regs->gr[30];
	info->ip = regs->iaoq[0];
	info->rp = regs->gr[2];
	info->r31 = regs->gr[31];

	dbg("(%d) Start unwind from sp=%08lx ip=%08lx\n", 
	    t ? (int)t->pid : -1, info->sp, info->ip);
}

void unwind_frame_init_from_blocked_task(struct unwind_frame_info *info, struct task_struct *t)
{
	struct pt_regs *r = &t->thread.regs;
	struct pt_regs *r2;

	r2 = kmalloc(sizeof(struct pt_regs), GFP_ATOMIC);
	if (!r2)
		return;
	*r2 = *r;
	r2->gr[30] = r->ksp;
	r2->iaoq[0] = r->kpc;
	unwind_frame_init(info, t, r2);
	kfree(r2);
}

void unwind_frame_init_running(struct unwind_frame_info *info, struct pt_regs *regs)
{
	unwind_frame_init(info, current, regs);
}

int unwind_once(struct unwind_frame_info *next_frame)
{
	unwind_frame_regs(next_frame);

	if (next_frame->prev_sp == 0 ||
	    next_frame->prev_ip == 0)
		return -1;

	next_frame->sp = next_frame->prev_sp;
	next_frame->ip = next_frame->prev_ip;
	next_frame->prev_sp = 0;
	next_frame->prev_ip = 0;

	dbg("(%d) Continue unwind to sp=%08lx ip=%08lx\n", 
	    next_frame->t ? (int)next_frame->t->pid : -1, 
	    next_frame->sp, next_frame->ip);

	return 0;
}

int unwind_to_user(struct unwind_frame_info *info)
{
	int ret;
	
	do {
		ret = unwind_once(info);
	} while (!ret && !(info->ip & 3));

	return ret;
}

unsigned long return_address(unsigned int level)
{
	struct unwind_frame_info info;
	struct pt_regs r;
	unsigned long sp;

	/* initialize unwind info */
	asm volatile ("copy %%r30, %0" : "=r"(sp));
	memset(&r, 0, sizeof(struct pt_regs));
	r.iaoq[0] = (unsigned long) current_text_addr();
	r.gr[2] = (unsigned long) __builtin_return_address(0);
	r.gr[30] = sp;
	unwind_frame_init(&info, current, &r);

	/* unwind stack */
	++level;
	do {
		if (unwind_once(&info) < 0 || info.ip == 0)
			return 0;
		if (!__kernel_text_address(info.ip)) {
			return 0;
		}
	} while (info.ip && level--);

	return info.ip;
}
Commit	Line	Data
1da177e4 LT	1	/*
	2	* Kernel unwinding support
	3	*
	4	* (c) 2002-2004 Randolph Chung <tausq@debian.org>
	5	*
	6	* Derived partially from the IA64 implementation. The PA-RISC
	7	* Runtime Architecture Document is also a useful reference to
	8	* understand what is happening here
	9	*/
	10
1da177e4 LT	11	#include <linux/kernel.h>
1da177e4 LT	12	#include <linux/init.h>
e6fc0449	13	#include <linux/sched.h>
1da177e4 LT	14	#include <linux/slab.h>
1da177e4 LT	15	#include <linux/kallsyms.h>
8f78df87	16	#include <linux/sort.h>
1da177e4 LT	17
	18	#include <asm/uaccess.h>
	19	#include <asm/assembly.h>
05dc16d6 RC	20	#include <asm/asm-offsets.h>
05dc16d6 RC	21	#include <asm/ptrace.h>
1da177e4 LT	22
	23	#include <asm/unwind.h>
	24
	25	/* #define DEBUG 1 */
	26	#ifdef DEBUG
	27	#define dbg(x...) printk(x)
	28	#else
	29	#define dbg(x...)
	30	#endif
	31
33a932d1	32	#define KERNEL_START (KERNEL_BINARY_TEXT_START)
e036306a	33
1da177e4 LT	34	extern struct unwind_table_entry __start___unwind[];
	35	extern struct unwind_table_entry __stop___unwind[];
	36
	37	static spinlock_t unwind_lock;
	38	/*
	39	* the kernel unwind block is not dynamically allocated so that
	40	* we can call unwind_init as early in the bootup process as
	41	* possible (before the slab allocator is initialized)
	42	*/
8039de10	43	static struct unwind_table kernel_unwind_table __read_mostly;
1da177e4 LT	44	static LIST_HEAD(unwind_tables);
	45
	46	static inline const struct unwind_table_entry *
	47	find_unwind_entry_in_table(const struct unwind_table *table, unsigned long addr)
	48	{
	49	const struct unwind_table_entry *e = NULL;
	50	unsigned long lo, hi, mid;
	51
	52	lo = 0;
	53	hi = table->length - 1;
	54
	55	while (lo <= hi) {
	56	mid = (hi - lo) / 2 + lo;
	57	e = &table->table[mid];
	58	if (addr < e->region_start)
	59	hi = mid - 1;
	60	else if (addr > e->region_end)
	61	lo = mid + 1;
	62	else
	63	return e;
	64	}
	65
	66	return NULL;
	67	}
	68
	69	static const struct unwind_table_entry *
	70	find_unwind_entry(unsigned long addr)
	71	{
	72	struct unwind_table *table;
	73	const struct unwind_table_entry *e = NULL;
	74
	75	if (addr >= kernel_unwind_table.start &&
	76	addr <= kernel_unwind_table.end)
	77	e = find_unwind_entry_in_table(&kernel_unwind_table, addr);
	78	else
	79	list_for_each_entry(table, &unwind_tables, list) {
	80	if (addr >= table->start &&
	81	addr <= table->end)
	82	e = find_unwind_entry_in_table(table, addr);
b1b1d4a6 PC	83	if (e) {
	84	/* Move-to-front to exploit common traces */
	85	list_move(&table->list, &unwind_tables);
1da177e4	86	break;
b1b1d4a6	87	}
1da177e4 LT	88	}
	89
	90	return e;
	91	}
	92
	93	static void
	94	unwind_table_init(struct unwind_table table, const char name,
	95	unsigned long base_addr, unsigned long gp,
	96	void table_start, void table_end)
	97	{
	98	struct unwind_table_entry *start = table_start;
	99	struct unwind_table_entry *end =
	100	(struct unwind_table_entry *)table_end - 1;
	101
	102	table->name = name;
	103	table->base_addr = base_addr;
	104	table->gp = gp;
	105	table->start = base_addr + start->region_start;
	106	table->end = base_addr + end->region_end;
	107	table->table = (struct unwind_table_entry *)table_start;
	108	table->length = end - start + 1;
	109	INIT_LIST_HEAD(&table->list);
	110
	111	for (; start <= end; start++) {
	112	if (start < end &&
	113	start->region_end > (start+1)->region_start) {
	114	printk("WARNING: Out of order unwind entry! %p and %p\n", start, start+1);
	115	}
	116
	117	start->region_start += base_addr;
	118	start->region_end += base_addr;
	119	}
	120	}
	121
8f78df87 HD	122	static int cmp_unwind_table_entry(const void a, const void b)
	123	{
	124	return ((const struct unwind_table_entry *)a)->region_start
	125	- ((const struct unwind_table_entry *)b)->region_start;
	126	}
	127
1da177e4 LT	128	static void
	129	unwind_table_sort(struct unwind_table_entry *start,
	130	struct unwind_table_entry *finish)
	131	{
8f78df87 HD	132	sort(start, finish - start, sizeof(struct unwind_table_entry),
8f78df87 HD	133	cmp_unwind_table_entry, NULL);
1da177e4 LT	134	}
	135
	136	struct unwind_table *
	137	unwind_table_add(const char *name, unsigned long base_addr,
	138	unsigned long gp,
	139	void start, void end)
	140	{
	141	struct unwind_table *table;
	142	unsigned long flags;
	143	struct unwind_table_entry s = (struct unwind_table_entry )start;
	144	struct unwind_table_entry e = (struct unwind_table_entry )end;
	145
	146	unwind_table_sort(s, e);
	147
	148	table = kmalloc(sizeof(struct unwind_table), GFP_USER);
	149	if (table == NULL)
	150	return NULL;
	151	unwind_table_init(table, name, base_addr, gp, start, end);
	152	spin_lock_irqsave(&unwind_lock, flags);
	153	list_add_tail(&table->list, &unwind_tables);
	154	spin_unlock_irqrestore(&unwind_lock, flags);
	155
	156	return table;
	157	}
	158
	159	void unwind_table_remove(struct unwind_table *table)
	160	{
	161	unsigned long flags;
	162
	163	spin_lock_irqsave(&unwind_lock, flags);
	164	list_del(&table->list);
	165	spin_unlock_irqrestore(&unwind_lock, flags);
	166
	167	kfree(table);
	168	}
	169
	170	/* Called from setup_arch to import the kernel unwind info */
f0514ae3	171	int unwind_init(void)
1da177e4 LT	172	{
	173	long start, stop;
	174	register unsigned long gp __asm__ ("r27");
	175
	176	start = (long)&__start___unwind[0];
	177	stop = (long)&__stop___unwind[0];
	178
	179	spin_lock_init(&unwind_lock);
	180
	181	printk("unwind_init: start = 0x%lx, end = 0x%lx, entries = %lu\n",
	182	start, stop,
	183	(stop - start) / sizeof(struct unwind_table_entry));
	184
	185	unwind_table_init(&kernel_unwind_table, "kernel", KERNEL_START,
	186	gp,
	187	&__start___unwind[0], &__stop___unwind[0]);
	188	#if 0
	189	{
	190	int i;
	191	for (i = 0; i < 10; i++)
	192	{
	193	printk("region 0x%x-0x%x\n",
	194	__start___unwind[i].region_start,
	195	__start___unwind[i].region_end);
	196	}
	197	}
	198	#endif
	199	return 0;
	200	}
	201
05dc16d6 RC	202	#ifdef CONFIG_64BIT
	203	#define get_func_addr(fptr) fptr[2]
	204	#else
	205	#define get_func_addr(fptr) fptr[0]
	206	#endif
	207
	208	static int unwind_special(struct unwind_frame_info *info, unsigned long pc, int frame_size)
	209	{
78199943 KM	210	extern void handle_interruption(int, struct pt_regs *);
78199943 KM	211	static unsigned long hi = (unsigned long )&handle_interruption;
05dc16d6 RC	212
	213	if (pc == get_func_addr(hi)) {
	214	struct pt_regs regs = (struct pt_regs )(info->sp - frame_size - PT_SZ_ALGN);
	215	dbg("Unwinding through handle_interruption()\n");
	216	info->prev_sp = regs->gr[30];
	217	info->prev_ip = regs->iaoq[0];
	218
	219	return 1;
	220	}
	221
	222	return 0;
	223	}
	224
1da177e4 LT	225	static void unwind_frame_regs(struct unwind_frame_info *info)
	226	{
	227	const struct unwind_table_entry *e;
	228	unsigned long npc;
	229	unsigned int insn;
	230	long frame_size = 0;
	231	int looking_for_rp, rpoffset = 0;
	232
	233	e = find_unwind_entry(info->ip);
	234	if (e == NULL) {
	235	unsigned long sp;
	236	extern char _stext[], _etext[];
	237
	238	dbg("Cannot find unwind entry for 0x%lx; forced unwinding\n", info->ip);
	239
	240	#ifdef CONFIG_KALLSYMS
	241	/* Handle some frequent special cases.... */
	242	{
9281acea	243	char symname[KSYM_NAME_LEN];
cb957795	244	char *modname;
1da177e4	245
cb957795 KM	246	kallsyms_lookup(info->ip, NULL, NULL, &modname,
cb957795 KM	247	symname);
1da177e4 LT	248
	249	dbg("info->ip = 0x%lx, name = %s\n", info->ip, symname);
	250
	251	if (strcmp(symname, "_switch_to_ret") == 0) {
	252	info->prev_sp = info->sp - CALLEE_SAVE_FRAME_SIZE;
	253	info->prev_ip = (unsigned long )(info->prev_sp - RP_OFFSET);
	254	dbg("_switch_to_ret @ %lx - setting "
	255	"prev_sp=%lx prev_ip=%lx\n",
	256	info->ip, info->prev_sp,
	257	info->prev_ip);
	258	return;
	259	} else if (strcmp(symname, "ret_from_kernel_thread") == 0 \|\|
	260	strcmp(symname, "syscall_exit") == 0) {
	261	info->prev_ip = info->prev_sp = 0;
	262	return;
	263	}
	264	}
	265	#endif
	266
	267	/* Since we are doing the unwinding blind, we don't know if
	268	we are adjusting the stack correctly or extracting the rp
	269	correctly. The rp is checked to see if it belongs to the
	270	kernel text section, if not we assume we don't have a
	271	correct stack frame and we continue to unwind the stack.
	272	This is not quite correct, and will fail for loadable
	273	modules. */
	274	sp = info->sp & ~63;
	275	do {
	276	unsigned long tmp;
	277
	278	info->prev_sp = sp - 64;
	279	info->prev_ip = 0;
	280	if (get_user(tmp, (unsigned long *)(info->prev_sp - RP_OFFSET)))
	281	break;
	282	info->prev_ip = tmp;
	283	sp = info->prev_sp;
	284	} while (info->prev_ip < (unsigned long)_stext \|\|
	285	info->prev_ip > (unsigned long)_etext);
	286
	287	info->rp = 0;
	288
	289	dbg("analyzing func @ %lx with no unwind info, setting "
	290	"prev_sp=%lx prev_ip=%lx\n", info->ip,
	291	info->prev_sp, info->prev_ip);
	292	} else {
	293	dbg("e->start = 0x%x, e->end = 0x%x, Save_SP = %d, "
	294	"Save_RP = %d, Millicode = %d size = %u\n",
	295	e->region_start, e->region_end, e->Save_SP, e->Save_RP,
	296	e->Millicode, e->Total_frame_size);
	297
	298	looking_for_rp = e->Save_RP;
	299
	300	for (npc = e->region_start;
	301	(frame_size < (e->Total_frame_size << 3) \|\|
	302	looking_for_rp) &&
	303	npc < info->ip;
	304	npc += 4) {
	305
	306	insn = (unsigned int )npc;
	307
	308	if ((insn & 0xffffc000) == 0x37de0000 \|\|
	309	(insn & 0xffe00000) == 0x6fc00000) {
	310	/* ldo X(sp), sp, or stwm X,D(sp) */
	311	frame_size += (insn & 0x1 ? -1 << 13 : 0) \|
312	((insn & 0x3fff) >> 1);
313	dbg("analyzing func @ %lx, insn=%08x @ "
314	"%lx, frame_size = %ld\n", info->ip,
315	insn, npc, frame_size);
316	} else if ((insn & 0xffe00008) == 0x73c00008) {
317	/* std,ma X,D(sp) */
318	frame_size += (insn & 0x1 ? -1 << 13 : 0) \|
319	(((insn >> 4) & 0x3ff) << 3);
320	dbg("analyzing func @ %lx, insn=%08x @ "
321	"%lx, frame_size = %ld\n", info->ip,
322	insn, npc, frame_size);
323	} else if (insn == 0x6bc23fd9) {
324	/* stw rp,-20(sp) */
325	rpoffset = 20;
326	looking_for_rp = 0;
327	dbg("analyzing func @ %lx, insn=stw rp,"
328	"-20(sp) @ %lx\n", info->ip, npc);
329	} else if (insn == 0x0fc212c1) {
330	/* std rp,-16(sr0,sp) */
331	rpoffset = 16;
332	looking_for_rp = 0;
333	dbg("analyzing func @ %lx, insn=std rp,"
334	"-16(sp) @ %lx\n", info->ip, npc);
335	}
336	}
337
05dc16d6 RC	338	if (!unwind_special(info, e->region_start, frame_size)) {
	339	info->prev_sp = info->sp - frame_size;
	340	if (e->Millicode)
	341	info->rp = info->r31;
	342	else if (rpoffset)
	343	info->rp = (unsigned long )(info->prev_sp - rpoffset);
	344	info->prev_ip = info->rp;
	345	info->rp = 0;
	346	}
1da177e4 LT	347
	348	dbg("analyzing func @ %lx, setting prev_sp=%lx "
	349	"prev_ip=%lx npc=%lx\n", info->ip, info->prev_sp,
	350	info->prev_ip, npc);
	351	}
	352	}
	353
	354	void unwind_frame_init(struct unwind_frame_info info, struct task_struct t,
	355	struct pt_regs *regs)
	356	{
	357	memset(info, 0, sizeof(struct unwind_frame_info));
	358	info->t = t;
	359	info->sp = regs->gr[30];
	360	info->ip = regs->iaoq[0];
	361	info->rp = regs->gr[2];
	362	info->r31 = regs->gr[31];
	363
	364	dbg("(%d) Start unwind from sp=%08lx ip=%08lx\n",
	365	t ? (int)t->pid : -1, info->sp, info->ip);
	366	}
	367
	368	void unwind_frame_init_from_blocked_task(struct unwind_frame_info info, struct task_struct t)
	369	{
	370	struct pt_regs *r = &t->thread.regs;
	371	struct pt_regs *r2;
	372
e0e7ed48	373	r2 = kmalloc(sizeof(struct pt_regs), GFP_ATOMIC);
1da177e4 LT	374	if (!r2)
	375	return;
	376	r2 = r;
	377	r2->gr[30] = r->ksp;
	378	r2->iaoq[0] = r->kpc;
	379	unwind_frame_init(info, t, r2);
	380	kfree(r2);
	381	}
	382
	383	void unwind_frame_init_running(struct unwind_frame_info info, struct pt_regs regs)
	384	{
	385	unwind_frame_init(info, current, regs);
	386	}
	387
	388	int unwind_once(struct unwind_frame_info *next_frame)
	389	{
	390	unwind_frame_regs(next_frame);
	391
	392	if (next_frame->prev_sp == 0 \|\|
	393	next_frame->prev_ip == 0)
	394	return -1;
	395
	396	next_frame->sp = next_frame->prev_sp;
	397	next_frame->ip = next_frame->prev_ip;
	398	next_frame->prev_sp = 0;
	399	next_frame->prev_ip = 0;
	400
	401	dbg("(%d) Continue unwind to sp=%08lx ip=%08lx\n",
	402	next_frame->t ? (int)next_frame->t->pid : -1,
	403	next_frame->sp, next_frame->ip);
	404
	405	return 0;
	406	}
	407
	408	int unwind_to_user(struct unwind_frame_info *info)
	409	{
	410	int ret;
	411
	412	do {
	413	ret = unwind_once(info);
	414	} while (!ret && !(info->ip & 3));
	415
	416	return ret;
	417	}
11e17809 HD	418
	419	unsigned long return_address(unsigned int level)
	420	{
	421	struct unwind_frame_info info;
	422	struct pt_regs r;
	423	unsigned long sp;
	424
	425	/* initialize unwind info */
	426	asm volatile ("copy %%r30, %0" : "=r"(sp));
	427	memset(&r, 0, sizeof(struct pt_regs));
	428	r.iaoq[0] = (unsigned long) current_text_addr();
	429	r.gr[2] = (unsigned long) __builtin_return_address(0);
	430	r.gr[30] = sp;
	431	unwind_frame_init(&info, current, &r);
	432
	433	/* unwind stack */
	434	++level;
	435	do {
	436	if (unwind_once(&info) < 0 \|\| info.ip == 0)
	437	return 0;
	438	if (!__kernel_text_address(info.ip)) {
	439	return 0;
	440	}
	441	} while (info.ip && level--);
	442
	443	return info.ip;
	444	}