[linux-2.6-block.git] / arch / parisc / kernel / unwind.c

// SPDX-License-Identifier: GPL-2.0
/*
 * 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/sort.h>

#include <linux/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...) pr_debug(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 DEFINE_SPINLOCK(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 {
		unsigned long flags;

		spin_lock_irqsave(&unwind_lock, flags);
		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;
			}
		}
		spin_unlock_irqrestore(&unwind_lock, flags);
	}

	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) {
			pr_warn("Out of order unwind entry! %px and %px\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 __init unwind_init(void)
{
	long start, stop;
	register unsigned long gp __asm__ ("r27");

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

	dbg("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;
}

static int unwind_special(struct unwind_frame_info *info, unsigned long pc, int frame_size)
{
	/*
	 * We have to use void * instead of a function pointer, because
	 * function pointers aren't a pointer to the function on 64-bit.
	 * Make them const so the compiler knows they live in .text
	 * Note: We could use dereference_kernel_function_descriptor()
	 * instead but we want to keep it simple here.
	 */
	extern void * const handle_interruption;
	extern void * const ret_from_kernel_thread;
	extern void * const syscall_exit;
	extern void * const intr_return;
	extern void * const _switch_to_ret;
#ifdef CONFIG_IRQSTACKS
	extern void * const _call_on_stack;
#endif /* CONFIG_IRQSTACKS */

	if (pc == (unsigned long) &handle_interruption) {
		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;
	}

	if (pc == (unsigned long) &ret_from_kernel_thread ||
	    pc == (unsigned long) &syscall_exit) {
		info->prev_sp = info->prev_ip = 0;
		return 1;
	}

	if (pc == (unsigned long) &intr_return) {
		struct pt_regs *regs;

		dbg("Found intr_return()\n");
		regs = (struct pt_regs *)(info->sp - PT_SZ_ALGN);
		info->prev_sp = regs->gr[30];
		info->prev_ip = regs->iaoq[0];
		info->rp = regs->gr[2];
		return 1;
	}

	if (pc == (unsigned long) &_switch_to_ret) {
		info->prev_sp = info->sp - CALLEE_SAVE_FRAME_SIZE;
		info->prev_ip = *(unsigned long *)(info->prev_sp - RP_OFFSET);
		return 1;
	}

#ifdef CONFIG_IRQSTACKS
	if (pc == (unsigned long) &_call_on_stack) {
		info->prev_sp = *(unsigned long *)(info->sp - FRAME_SIZE - REG_SZ);
		info->prev_ip = *(unsigned long *)(info->sp - FRAME_SIZE - RP_OFFSET);
		return 1;
	}
#endif

	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;

		dbg("Cannot find unwind entry for %pS; forced unwinding\n",
			(void *) info->ip);

		/* 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;

			/* The stack is at the end inside the thread_union
			 * struct. If we reach data, we have reached the
			 * beginning of the stack and should stop unwinding. */
			if (info->prev_sp >= (unsigned long) task_thread_info(info->t) &&
			    info->prev_sp < ((unsigned long) task_thread_info(info->t)
						+ THREAD_SZ_ALGN)) {
				info->prev_sp = 0;
				break;
			}

			if (get_user(tmp, (unsigned long *)(info->prev_sp - RP_OFFSET))) 
				break;
			info->prev_ip = tmp;
			sp = info->prev_sp;
		} while (!kernel_text_address(info->prev_ip));

		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 & 0xffffc001) == 0x37de0000 ||
			    (insn & 0xffe00001) == 0x6fc00000) {
				/* ldo X(sp), sp, or stwm X,D(sp) */
				frame_size += (insn & 0x3fff) >> 1;
				dbg("analyzing func @ %lx, insn=%08x @ "
				    "%lx, frame_size = %ld\n", info->ip,
				    insn, npc, frame_size);
			} else if ((insn & 0xffe00009) == 0x73c00008) {
				/* std,ma X,D(sp) */
				frame_size += ((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 (frame_size > e->Total_frame_size << 3)
			frame_size = e->Total_frame_size << 3;

		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);
}

#define get_parisc_stackpointer() ({ \
	unsigned long sp; \
	__asm__("copy %%r30, %0" : "=r"(sp)); \
	(sp); \
})

void unwind_frame_init_task(struct unwind_frame_info *info,
	struct task_struct *task, struct pt_regs *regs)
{
	task = task ? task : current;

	if (task == current) {
		struct pt_regs r;

		if (!regs) {
			memset(&r, 0, sizeof(r));
			r.iaoq[0] =  _THIS_IP_;
			r.gr[2] = _RET_IP_;
			r.gr[30] = get_parisc_stackpointer();
			regs = &r;
		}
		unwind_frame_init(info, task, regs);
	} else {
		unwind_frame_init_from_blocked_task(info, task);
	}
}

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;

	/* initialize unwind info */
	unwind_frame_init_task(&info, current, NULL);

	/* unwind stack */
	level += 2;
	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
b2441318	1	// SPDX-License-Identifier: GPL-2.0
1da177e4 LT	2	/*
	3	* Kernel unwinding support
	4	*
	5	* (c) 2002-2004 Randolph Chung <tausq@debian.org>
	6	*
	7	* Derived partially from the IA64 implementation. The PA-RISC
	8	* Runtime Architecture Document is also a useful reference to
	9	* understand what is happening here
	10	*/
	11
1da177e4 LT	12	#include <linux/kernel.h>
1da177e4 LT	13	#include <linux/init.h>
e6fc0449	14	#include <linux/sched.h>
1da177e4	15	#include <linux/slab.h>
8f78df87	16	#include <linux/sort.h>
1da177e4	17
7c0f6ba6	18	#include <linux/uaccess.h>
1da177e4	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
63ba82c0	27	#define dbg(x...) pr_debug(x)
1da177e4 LT	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
76cffeb6	37	static DEFINE_SPINLOCK(unwind_lock);
1da177e4 LT	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);
be24a897 MP	78	else {
	79	unsigned long flags;
	80
	81	spin_lock_irqsave(&unwind_lock, flags);
1da177e4 LT	82	list_for_each_entry(table, &unwind_tables, list) {
	83	if (addr >= table->start &&
	84	addr <= table->end)
	85	e = find_unwind_entry_in_table(table, addr);
b1b1d4a6 PC	86	if (e) {
	87	/* Move-to-front to exploit common traces */
	88	list_move(&table->list, &unwind_tables);
1da177e4	89	break;
b1b1d4a6	90	}
1da177e4	91	}
be24a897 MP	92	spin_unlock_irqrestore(&unwind_lock, flags);
be24a897 MP	93	}
1da177e4 LT	94
	95	return e;
	96	}
	97
	98	static void
	99	unwind_table_init(struct unwind_table table, const char name,
	100	unsigned long base_addr, unsigned long gp,
	101	void table_start, void table_end)
	102	{
	103	struct unwind_table_entry *start = table_start;
	104	struct unwind_table_entry *end =
	105	(struct unwind_table_entry *)table_end - 1;
	106
	107	table->name = name;
	108	table->base_addr = base_addr;
	109	table->gp = gp;
	110	table->start = base_addr + start->region_start;
	111	table->end = base_addr + end->region_end;
	112	table->table = (struct unwind_table_entry *)table_start;
	113	table->length = end - start + 1;
	114	INIT_LIST_HEAD(&table->list);
	115
	116	for (; start <= end; start++) {
	117	if (start < end &&
	118	start->region_end > (start+1)->region_start) {
c8921d72 HD	119	pr_warn("Out of order unwind entry! %px and %px\n",
c8921d72 HD	120	start, start+1);
1da177e4 LT	121	}
	122
	123	start->region_start += base_addr;
	124	start->region_end += base_addr;
	125	}
	126	}
	127
8f78df87 HD	128	static int cmp_unwind_table_entry(const void a, const void b)
	129	{
	130	return ((const struct unwind_table_entry *)a)->region_start
	131	- ((const struct unwind_table_entry *)b)->region_start;
	132	}
	133
1da177e4 LT	134	static void
	135	unwind_table_sort(struct unwind_table_entry *start,
	136	struct unwind_table_entry *finish)
	137	{
8f78df87 HD	138	sort(start, finish - start, sizeof(struct unwind_table_entry),
8f78df87 HD	139	cmp_unwind_table_entry, NULL);
1da177e4 LT	140	}
	141
	142	struct unwind_table *
	143	unwind_table_add(const char *name, unsigned long base_addr,
	144	unsigned long gp,
	145	void start, void end)
	146	{
	147	struct unwind_table *table;
	148	unsigned long flags;
	149	struct unwind_table_entry s = (struct unwind_table_entry )start;
	150	struct unwind_table_entry e = (struct unwind_table_entry )end;
	151
	152	unwind_table_sort(s, e);
	153
	154	table = kmalloc(sizeof(struct unwind_table), GFP_USER);
	155	if (table == NULL)
	156	return NULL;
	157	unwind_table_init(table, name, base_addr, gp, start, end);
	158	spin_lock_irqsave(&unwind_lock, flags);
	159	list_add_tail(&table->list, &unwind_tables);
	160	spin_unlock_irqrestore(&unwind_lock, flags);
	161
	162	return table;
	163	}
	164
	165	void unwind_table_remove(struct unwind_table *table)
	166	{
	167	unsigned long flags;
	168
	169	spin_lock_irqsave(&unwind_lock, flags);
	170	list_del(&table->list);
	171	spin_unlock_irqrestore(&unwind_lock, flags);
	172
	173	kfree(table);
	174	}
	175
	176	/* Called from setup_arch to import the kernel unwind info */
c790b41b	177	int __init unwind_init(void)
1da177e4 LT	178	{
	179	long start, stop;
	180	register unsigned long gp __asm__ ("r27");
	181
	182	start = (long)&__start___unwind[0];
	183	stop = (long)&__stop___unwind[0];
	184
63ba82c0	185	dbg("unwind_init: start = 0x%lx, end = 0x%lx, entries = %lu\n",
1da177e4 LT	186	start, stop,
	187	(stop - start) / sizeof(struct unwind_table_entry));
	188
	189	unwind_table_init(&kernel_unwind_table, "kernel", KERNEL_START,
	190	gp,
	191	&__start___unwind[0], &__stop___unwind[0]);
	192	#if 0
	193	{
	194	int i;
	195	for (i = 0; i < 10; i++)
	196	{
	197	printk("region 0x%x-0x%x\n",
	198	__start___unwind[i].region_start,
	199	__start___unwind[i].region_end);
	200	}
	201	}
	202	#endif
	203	return 0;
	204	}
	205
05dc16d6 RC	206	static int unwind_special(struct unwind_frame_info *info, unsigned long pc, int frame_size)
05dc16d6 RC	207	{
c8921d72 HD	208	/*
	209	* We have to use void * instead of a function pointer, because
	210	* function pointers aren't a pointer to the function on 64-bit.
	211	* Make them const so the compiler knows they live in .text
8801ccb9 HD	212	* Note: We could use dereference_kernel_function_descriptor()
8801ccb9 HD	213	* instead but we want to keep it simple here.
c8921d72 HD	214	*/
	215	extern void * const handle_interruption;
	216	extern void * const ret_from_kernel_thread;
	217	extern void * const syscall_exit;
	218	extern void * const intr_return;
	219	extern void * const _switch_to_ret;
	220	#ifdef CONFIG_IRQSTACKS
8801ccb9	221	extern void * const _call_on_stack;
c8921d72 HD	222	#endif /* CONFIG_IRQSTACKS */
	223
	224	if (pc == (unsigned long) &handle_interruption) {
05dc16d6 RC	225	struct pt_regs regs = (struct pt_regs )(info->sp - frame_size - PT_SZ_ALGN);
	226	dbg("Unwinding through handle_interruption()\n");
	227	info->prev_sp = regs->gr[30];
	228	info->prev_ip = regs->iaoq[0];
c8921d72 HD	229	return 1;
	230	}
	231
	232	if (pc == (unsigned long) &ret_from_kernel_thread \|\|
	233	pc == (unsigned long) &syscall_exit) {
	234	info->prev_sp = info->prev_ip = 0;
	235	return 1;
	236	}
	237
	238	if (pc == (unsigned long) &intr_return) {
	239	struct pt_regs *regs;
	240
	241	dbg("Found intr_return()\n");
	242	regs = (struct pt_regs *)(info->sp - PT_SZ_ALGN);
	243	info->prev_sp = regs->gr[30];
	244	info->prev_ip = regs->iaoq[0];
	245	info->rp = regs->gr[2];
	246	return 1;
	247	}
	248
	249	if (pc == (unsigned long) &_switch_to_ret) {
	250	info->prev_sp = info->sp - CALLEE_SAVE_FRAME_SIZE;
	251	info->prev_ip = (unsigned long )(info->prev_sp - RP_OFFSET);
	252	return 1;
	253	}
05dc16d6	254
c8921d72	255	#ifdef CONFIG_IRQSTACKS
8801ccb9	256	if (pc == (unsigned long) &_call_on_stack) {
c8921d72 HD	257	info->prev_sp = (unsigned long )(info->sp - FRAME_SIZE - REG_SZ);
c8921d72 HD	258	info->prev_ip = (unsigned long )(info->sp - FRAME_SIZE - RP_OFFSET);
05dc16d6 RC	259	return 1;
05dc16d6 RC	260	}
c8921d72	261	#endif
05dc16d6 RC	262
	263	return 0;
	264	}
	265
1da177e4 LT	266	static void unwind_frame_regs(struct unwind_frame_info *info)
	267	{
	268	const struct unwind_table_entry *e;
	269	unsigned long npc;
	270	unsigned int insn;
	271	long frame_size = 0;
	272	int looking_for_rp, rpoffset = 0;
	273
	274	e = find_unwind_entry(info->ip);
	275	if (e == NULL) {
	276	unsigned long sp;
1da177e4	277
c8921d72 HD	278	dbg("Cannot find unwind entry for %pS; forced unwinding\n",
c8921d72 HD	279	(void *) info->ip);
1da177e4 LT	280
	281	/* Since we are doing the unwinding blind, we don't know if
	282	we are adjusting the stack correctly or extracting the rp
	283	correctly. The rp is checked to see if it belongs to the
	284	kernel text section, if not we assume we don't have a
	285	correct stack frame and we continue to unwind the stack.
	286	This is not quite correct, and will fail for loadable
	287	modules. */
	288	sp = info->sp & ~63;
	289	do {
	290	unsigned long tmp;
	291
	292	info->prev_sp = sp - 64;
	293	info->prev_ip = 0;
e77900ab HD	294
	295	/* The stack is at the end inside the thread_union
	296	* struct. If we reach data, we have reached the
	297	* beginning of the stack and should stop unwinding. */
	298	if (info->prev_sp >= (unsigned long) task_thread_info(info->t) &&
	299	info->prev_sp < ((unsigned long) task_thread_info(info->t)
	300	+ THREAD_SZ_ALGN)) {
	301	info->prev_sp = 0;
	302	break;
	303	}
	304
1da177e4 LT	305	if (get_user(tmp, (unsigned long *)(info->prev_sp - RP_OFFSET)))
	306	break;
	307	info->prev_ip = tmp;
	308	sp = info->prev_sp;
c790b41b	309	} while (!kernel_text_address(info->prev_ip));
1da177e4 LT	310
	311	info->rp = 0;
	312
	313	dbg("analyzing func @ %lx with no unwind info, setting "
	314	"prev_sp=%lx prev_ip=%lx\n", info->ip,
	315	info->prev_sp, info->prev_ip);
	316	} else {
	317	dbg("e->start = 0x%x, e->end = 0x%x, Save_SP = %d, "
	318	"Save_RP = %d, Millicode = %d size = %u\n",
	319	e->region_start, e->region_end, e->Save_SP, e->Save_RP,
	320	e->Millicode, e->Total_frame_size);
	321
	322	looking_for_rp = e->Save_RP;
	323
	324	for (npc = e->region_start;
	325	(frame_size < (e->Total_frame_size << 3) \|\|
	326	looking_for_rp) &&
	327	npc < info->ip;
	328	npc += 4) {
	329
	330	insn = (unsigned int )npc;
	331
be24a897 MP	332	if ((insn & 0xffffc001) == 0x37de0000 \|\|
be24a897 MP	333	(insn & 0xffe00001) == 0x6fc00000) {
1da177e4	334	/* ldo X(sp), sp, or stwm X,D(sp) */
be24a897	335	frame_size += (insn & 0x3fff) >> 1;
1da177e4 LT	336	dbg("analyzing func @ %lx, insn=%08x @ "
	337	"%lx, frame_size = %ld\n", info->ip,
	338	insn, npc, frame_size);
be24a897	339	} else if ((insn & 0xffe00009) == 0x73c00008) {
1da177e4	340	/* std,ma X,D(sp) */
be24a897	341	frame_size += ((insn >> 4) & 0x3ff) << 3;
1da177e4 LT	342	dbg("analyzing func @ %lx, insn=%08x @ "
	343	"%lx, frame_size = %ld\n", info->ip,
	344	insn, npc, frame_size);
	345	} else if (insn == 0x6bc23fd9) {
	346	/* stw rp,-20(sp) */
	347	rpoffset = 20;
	348	looking_for_rp = 0;
	349	dbg("analyzing func @ %lx, insn=stw rp,"
	350	"-20(sp) @ %lx\n", info->ip, npc);
	351	} else if (insn == 0x0fc212c1) {
	352	/* std rp,-16(sr0,sp) */
	353	rpoffset = 16;
	354	looking_for_rp = 0;
	355	dbg("analyzing func @ %lx, insn=std rp,"
	356	"-16(sp) @ %lx\n", info->ip, npc);
	357	}
	358	}
	359
be24a897 MP	360	if (frame_size > e->Total_frame_size << 3)
	361	frame_size = e->Total_frame_size << 3;
	362
05dc16d6 RC	363	if (!unwind_special(info, e->region_start, frame_size)) {
	364	info->prev_sp = info->sp - frame_size;
	365	if (e->Millicode)
	366	info->rp = info->r31;
	367	else if (rpoffset)
	368	info->rp = (unsigned long )(info->prev_sp - rpoffset);
	369	info->prev_ip = info->rp;
	370	info->rp = 0;
	371	}
1da177e4 LT	372
	373	dbg("analyzing func @ %lx, setting prev_sp=%lx "
	374	"prev_ip=%lx npc=%lx\n", info->ip, info->prev_sp,
	375	info->prev_ip, npc);
	376	}
	377	}
	378
	379	void unwind_frame_init(struct unwind_frame_info info, struct task_struct t,
	380	struct pt_regs *regs)
	381	{
	382	memset(info, 0, sizeof(struct unwind_frame_info));
	383	info->t = t;
	384	info->sp = regs->gr[30];
	385	info->ip = regs->iaoq[0];
	386	info->rp = regs->gr[2];
	387	info->r31 = regs->gr[31];
	388
	389	dbg("(%d) Start unwind from sp=%08lx ip=%08lx\n",
	390	t ? (int)t->pid : -1, info->sp, info->ip);
	391	}
	392
	393	void unwind_frame_init_from_blocked_task(struct unwind_frame_info info, struct task_struct t)
	394	{
	395	struct pt_regs *r = &t->thread.regs;
	396	struct pt_regs *r2;
	397
e0e7ed48	398	r2 = kmalloc(sizeof(struct pt_regs), GFP_ATOMIC);
1da177e4 LT	399	if (!r2)
	400	return;
	401	r2 = r;
	402	r2->gr[30] = r->ksp;
	403	r2->iaoq[0] = r->kpc;
	404	unwind_frame_init(info, t, r2);
	405	kfree(r2);
	406	}
	407
9e0d5c45 HD	408	#define get_parisc_stackpointer() ({ \
	409	unsigned long sp; \
	410	__asm__("copy %%r30, %0" : "=r"(sp)); \
	411	(sp); \
	412	})
	413
	414	void unwind_frame_init_task(struct unwind_frame_info *info,
	415	struct task_struct task, struct pt_regs regs)
1da177e4	416	{
9e0d5c45 HD	417	task = task ? task : current;
	418
	419	if (task == current) {
	420	struct pt_regs r;
	421
	422	if (!regs) {
	423	memset(&r, 0, sizeof(r));
	424	r.iaoq[0] = _THIS_IP_;
	425	r.gr[2] = _RET_IP_;
	426	r.gr[30] = get_parisc_stackpointer();
	427	regs = &r;
	428	}
cf8afe5c	429	unwind_frame_init(info, task, regs);
9e0d5c45 HD	430	} else {
	431	unwind_frame_init_from_blocked_task(info, task);
	432	}
1da177e4 LT	433	}
	434
	435	int unwind_once(struct unwind_frame_info *next_frame)
	436	{
	437	unwind_frame_regs(next_frame);
	438
	439	if (next_frame->prev_sp == 0 \|\|
	440	next_frame->prev_ip == 0)
	441	return -1;
	442
	443	next_frame->sp = next_frame->prev_sp;
	444	next_frame->ip = next_frame->prev_ip;
	445	next_frame->prev_sp = 0;
	446	next_frame->prev_ip = 0;
	447
	448	dbg("(%d) Continue unwind to sp=%08lx ip=%08lx\n",
	449	next_frame->t ? (int)next_frame->t->pid : -1,
	450	next_frame->sp, next_frame->ip);
	451
	452	return 0;
	453	}
	454
	455	int unwind_to_user(struct unwind_frame_info *info)
	456	{
	457	int ret;
	458
	459	do {
	460	ret = unwind_once(info);
	461	} while (!ret && !(info->ip & 3));
	462
	463	return ret;
	464	}
11e17809 HD	465
	466	unsigned long return_address(unsigned int level)
	467	{
	468	struct unwind_frame_info info;
11e17809 HD	469
11e17809 HD	470	/* initialize unwind info */
9e0d5c45	471	unwind_frame_init_task(&info, current, NULL);
11e17809 HD	472
11e17809 HD	473	/* unwind stack */
9e0d5c45	474	level += 2;
11e17809 HD	475	do {
	476	if (unwind_once(&info) < 0 \|\| info.ip == 0)
	477	return 0;
c790b41b	478	if (!kernel_text_address(info.ip))
11e17809	479	return 0;
11e17809 HD	480	} while (info.ip && level--);
	481
	482	return info.ip;
	483	}