[mirror_ubuntu-bionic-kernel.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/kallsyms.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...) 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 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) {
			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 __init unwind_init(void)
{
	long start, stop;
	register unsigned long gp __asm__ ("r27");

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

	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;

		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;

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

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
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 LT	15	#include <linux/slab.h>
1da177e4 LT	16	#include <linux/kallsyms.h>
8f78df87	17	#include <linux/sort.h>
1da177e4	18
7c0f6ba6	19	#include <linux/uaccess.h>
1da177e4	20	#include <asm/assembly.h>
05dc16d6 RC	21	#include <asm/asm-offsets.h>
05dc16d6 RC	22	#include <asm/ptrace.h>
1da177e4 LT	23
	24	#include <asm/unwind.h>
	25
	26	/* #define DEBUG 1 */
	27	#ifdef DEBUG
	28	#define dbg(x...) printk(x)
	29	#else
	30	#define dbg(x...)
	31	#endif
	32
33a932d1	33	#define KERNEL_START (KERNEL_BINARY_TEXT_START)
e036306a	34
1da177e4 LT	35	extern struct unwind_table_entry __start___unwind[];
	36	extern struct unwind_table_entry __stop___unwind[];
	37
76cffeb6	38	static DEFINE_SPINLOCK(unwind_lock);
1da177e4 LT	39	/*
	40	* the kernel unwind block is not dynamically allocated so that
	41	* we can call unwind_init as early in the bootup process as
	42	* possible (before the slab allocator is initialized)
	43	*/
8039de10	44	static struct unwind_table kernel_unwind_table __read_mostly;
1da177e4 LT	45	static LIST_HEAD(unwind_tables);
	46
	47	static inline const struct unwind_table_entry *
	48	find_unwind_entry_in_table(const struct unwind_table *table, unsigned long addr)
	49	{
	50	const struct unwind_table_entry *e = NULL;
	51	unsigned long lo, hi, mid;
	52
	53	lo = 0;
	54	hi = table->length - 1;
	55
	56	while (lo <= hi) {
	57	mid = (hi - lo) / 2 + lo;
	58	e = &table->table[mid];
	59	if (addr < e->region_start)
	60	hi = mid - 1;
	61	else if (addr > e->region_end)
	62	lo = mid + 1;
	63	else
	64	return e;
	65	}
	66
	67	return NULL;
	68	}
	69
	70	static const struct unwind_table_entry *
	71	find_unwind_entry(unsigned long addr)
	72	{
	73	struct unwind_table *table;
	74	const struct unwind_table_entry *e = NULL;
	75
	76	if (addr >= kernel_unwind_table.start &&
	77	addr <= kernel_unwind_table.end)
	78	e = find_unwind_entry_in_table(&kernel_unwind_table, addr);
be24a897 MP	79	else {
	80	unsigned long flags;
	81
	82	spin_lock_irqsave(&unwind_lock, flags);
1da177e4 LT	83	list_for_each_entry(table, &unwind_tables, list) {
	84	if (addr >= table->start &&
	85	addr <= table->end)
	86	e = find_unwind_entry_in_table(table, addr);
b1b1d4a6 PC	87	if (e) {
	88	/* Move-to-front to exploit common traces */
	89	list_move(&table->list, &unwind_tables);
1da177e4	90	break;
b1b1d4a6	91	}
1da177e4	92	}
be24a897 MP	93	spin_unlock_irqrestore(&unwind_lock, flags);
be24a897 MP	94	}
1da177e4 LT	95
	96	return e;
	97	}
	98
	99	static void
	100	unwind_table_init(struct unwind_table table, const char name,
	101	unsigned long base_addr, unsigned long gp,
	102	void table_start, void table_end)
	103	{
	104	struct unwind_table_entry *start = table_start;
	105	struct unwind_table_entry *end =
	106	(struct unwind_table_entry *)table_end - 1;
	107
	108	table->name = name;
	109	table->base_addr = base_addr;
	110	table->gp = gp;
	111	table->start = base_addr + start->region_start;
	112	table->end = base_addr + end->region_end;
	113	table->table = (struct unwind_table_entry *)table_start;
	114	table->length = end - start + 1;
	115	INIT_LIST_HEAD(&table->list);
	116
	117	for (; start <= end; start++) {
	118	if (start < end &&
	119	start->region_end > (start+1)->region_start) {
	120	printk("WARNING: Out of order unwind entry! %p and %p\n", start, start+1);
	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
1da177e4 LT	185	printk("unwind_init: start = 0x%lx, end = 0x%lx, entries = %lu\n",
	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	#ifdef CONFIG_64BIT
	207	#define get_func_addr(fptr) fptr[2]
	208	#else
	209	#define get_func_addr(fptr) fptr[0]
	210	#endif
	211
	212	static int unwind_special(struct unwind_frame_info *info, unsigned long pc, int frame_size)
	213	{
78199943 KM	214	extern void handle_interruption(int, struct pt_regs *);
78199943 KM	215	static unsigned long hi = (unsigned long )&handle_interruption;
05dc16d6 RC	216
	217	if (pc == get_func_addr(hi)) {
	218	struct pt_regs regs = (struct pt_regs )(info->sp - frame_size - PT_SZ_ALGN);
	219	dbg("Unwinding through handle_interruption()\n");
	220	info->prev_sp = regs->gr[30];
	221	info->prev_ip = regs->iaoq[0];
	222
	223	return 1;
	224	}
	225
	226	return 0;
	227	}
	228
1da177e4 LT	229	static void unwind_frame_regs(struct unwind_frame_info *info)
	230	{
	231	const struct unwind_table_entry *e;
	232	unsigned long npc;
	233	unsigned int insn;
	234	long frame_size = 0;
	235	int looking_for_rp, rpoffset = 0;
	236
	237	e = find_unwind_entry(info->ip);
	238	if (e == NULL) {
	239	unsigned long sp;
1da177e4 LT	240
	241	dbg("Cannot find unwind entry for 0x%lx; forced unwinding\n", info->ip);
	242
	243	#ifdef CONFIG_KALLSYMS
	244	/* Handle some frequent special cases.... */
	245	{
9281acea	246	char symname[KSYM_NAME_LEN];
cb957795	247	char *modname;
1da177e4	248
cb957795 KM	249	kallsyms_lookup(info->ip, NULL, NULL, &modname,
cb957795 KM	250	symname);
1da177e4 LT	251
	252	dbg("info->ip = 0x%lx, name = %s\n", info->ip, symname);
	253
	254	if (strcmp(symname, "_switch_to_ret") == 0) {
	255	info->prev_sp = info->sp - CALLEE_SAVE_FRAME_SIZE;
	256	info->prev_ip = (unsigned long )(info->prev_sp - RP_OFFSET);
	257	dbg("_switch_to_ret @ %lx - setting "
	258	"prev_sp=%lx prev_ip=%lx\n",
	259	info->ip, info->prev_sp,
	260	info->prev_ip);
	261	return;
	262	} else if (strcmp(symname, "ret_from_kernel_thread") == 0 \|\|
	263	strcmp(symname, "syscall_exit") == 0) {
	264	info->prev_ip = info->prev_sp = 0;
	265	return;
	266	}
	267	}
	268	#endif
	269
	270	/* Since we are doing the unwinding blind, we don't know if
	271	we are adjusting the stack correctly or extracting the rp
	272	correctly. The rp is checked to see if it belongs to the
	273	kernel text section, if not we assume we don't have a
	274	correct stack frame and we continue to unwind the stack.
	275	This is not quite correct, and will fail for loadable
	276	modules. */
	277	sp = info->sp & ~63;
	278	do {
	279	unsigned long tmp;
	280
	281	info->prev_sp = sp - 64;
	282	info->prev_ip = 0;
e77900ab HD	283
	284	/* The stack is at the end inside the thread_union
	285	* struct. If we reach data, we have reached the
	286	* beginning of the stack and should stop unwinding. */
	287	if (info->prev_sp >= (unsigned long) task_thread_info(info->t) &&
	288	info->prev_sp < ((unsigned long) task_thread_info(info->t)
	289	+ THREAD_SZ_ALGN)) {
	290	info->prev_sp = 0;
	291	break;
	292	}
	293
1da177e4 LT	294	if (get_user(tmp, (unsigned long *)(info->prev_sp - RP_OFFSET)))
	295	break;
	296	info->prev_ip = tmp;
	297	sp = info->prev_sp;
c790b41b	298	} while (!kernel_text_address(info->prev_ip));
1da177e4 LT	299
	300	info->rp = 0;
	301
	302	dbg("analyzing func @ %lx with no unwind info, setting "
	303	"prev_sp=%lx prev_ip=%lx\n", info->ip,
	304	info->prev_sp, info->prev_ip);
	305	} else {
	306	dbg("e->start = 0x%x, e->end = 0x%x, Save_SP = %d, "
	307	"Save_RP = %d, Millicode = %d size = %u\n",
	308	e->region_start, e->region_end, e->Save_SP, e->Save_RP,
	309	e->Millicode, e->Total_frame_size);
	310
	311	looking_for_rp = e->Save_RP;
	312
	313	for (npc = e->region_start;
	314	(frame_size < (e->Total_frame_size << 3) \|\|
	315	looking_for_rp) &&
	316	npc < info->ip;
	317	npc += 4) {
	318
	319	insn = (unsigned int )npc;
	320
be24a897 MP	321	if ((insn & 0xffffc001) == 0x37de0000 \|\|
be24a897 MP	322	(insn & 0xffe00001) == 0x6fc00000) {
1da177e4	323	/* ldo X(sp), sp, or stwm X,D(sp) */
be24a897	324	frame_size += (insn & 0x3fff) >> 1;
1da177e4 LT	325	dbg("analyzing func @ %lx, insn=%08x @ "
	326	"%lx, frame_size = %ld\n", info->ip,
	327	insn, npc, frame_size);
be24a897	328	} else if ((insn & 0xffe00009) == 0x73c00008) {
1da177e4	329	/* std,ma X,D(sp) */
be24a897	330	frame_size += ((insn >> 4) & 0x3ff) << 3;
1da177e4 LT	331	dbg("analyzing func @ %lx, insn=%08x @ "
	332	"%lx, frame_size = %ld\n", info->ip,
	333	insn, npc, frame_size);
	334	} else if (insn == 0x6bc23fd9) {
	335	/* stw rp,-20(sp) */
	336	rpoffset = 20;
	337	looking_for_rp = 0;
	338	dbg("analyzing func @ %lx, insn=stw rp,"
	339	"-20(sp) @ %lx\n", info->ip, npc);
	340	} else if (insn == 0x0fc212c1) {
	341	/* std rp,-16(sr0,sp) */
	342	rpoffset = 16;
	343	looking_for_rp = 0;
	344	dbg("analyzing func @ %lx, insn=std rp,"
	345	"-16(sp) @ %lx\n", info->ip, npc);
	346	}
	347	}
	348
be24a897 MP	349	if (frame_size > e->Total_frame_size << 3)
	350	frame_size = e->Total_frame_size << 3;
	351
05dc16d6 RC	352	if (!unwind_special(info, e->region_start, frame_size)) {
	353	info->prev_sp = info->sp - frame_size;
	354	if (e->Millicode)
	355	info->rp = info->r31;
	356	else if (rpoffset)
	357	info->rp = (unsigned long )(info->prev_sp - rpoffset);
	358	info->prev_ip = info->rp;
	359	info->rp = 0;
	360	}
1da177e4 LT	361
	362	dbg("analyzing func @ %lx, setting prev_sp=%lx "
	363	"prev_ip=%lx npc=%lx\n", info->ip, info->prev_sp,
	364	info->prev_ip, npc);
	365	}
	366	}
	367
	368	void unwind_frame_init(struct unwind_frame_info info, struct task_struct t,
	369	struct pt_regs *regs)
	370	{
	371	memset(info, 0, sizeof(struct unwind_frame_info));
	372	info->t = t;
	373	info->sp = regs->gr[30];
	374	info->ip = regs->iaoq[0];
	375	info->rp = regs->gr[2];
	376	info->r31 = regs->gr[31];
	377
	378	dbg("(%d) Start unwind from sp=%08lx ip=%08lx\n",
	379	t ? (int)t->pid : -1, info->sp, info->ip);
	380	}
	381
	382	void unwind_frame_init_from_blocked_task(struct unwind_frame_info info, struct task_struct t)
	383	{
	384	struct pt_regs *r = &t->thread.regs;
	385	struct pt_regs *r2;
	386
e0e7ed48	387	r2 = kmalloc(sizeof(struct pt_regs), GFP_ATOMIC);
1da177e4 LT	388	if (!r2)
	389	return;
	390	r2 = r;
	391	r2->gr[30] = r->ksp;
	392	r2->iaoq[0] = r->kpc;
	393	unwind_frame_init(info, t, r2);
	394	kfree(r2);
	395	}
	396
	397	void unwind_frame_init_running(struct unwind_frame_info info, struct pt_regs regs)
	398	{
	399	unwind_frame_init(info, current, regs);
	400	}
	401
	402	int unwind_once(struct unwind_frame_info *next_frame)
	403	{
	404	unwind_frame_regs(next_frame);
	405
	406	if (next_frame->prev_sp == 0 \|\|
	407	next_frame->prev_ip == 0)
	408	return -1;
	409
	410	next_frame->sp = next_frame->prev_sp;
	411	next_frame->ip = next_frame->prev_ip;
	412	next_frame->prev_sp = 0;
	413	next_frame->prev_ip = 0;
	414
	415	dbg("(%d) Continue unwind to sp=%08lx ip=%08lx\n",
	416	next_frame->t ? (int)next_frame->t->pid : -1,
	417	next_frame->sp, next_frame->ip);
	418
	419	return 0;
	420	}
	421
	422	int unwind_to_user(struct unwind_frame_info *info)
	423	{
	424	int ret;
	425
	426	do {
	427	ret = unwind_once(info);
	428	} while (!ret && !(info->ip & 3));
	429
	430	return ret;
	431	}
11e17809 HD	432
	433	unsigned long return_address(unsigned int level)
	434	{
	435	struct unwind_frame_info info;
	436	struct pt_regs r;
	437	unsigned long sp;
	438
	439	/* initialize unwind info */
	440	asm volatile ("copy %%r30, %0" : "=r"(sp));
	441	memset(&r, 0, sizeof(struct pt_regs));
	442	r.iaoq[0] = (unsigned long) current_text_addr();
	443	r.gr[2] = (unsigned long) __builtin_return_address(0);
	444	r.gr[30] = sp;
	445	unwind_frame_init(&info, current, &r);
	446
	447	/* unwind stack */
	448	++level;
	449	do {
	450	if (unwind_once(&info) < 0 \|\| info.ip == 0)
	451	return 0;
c790b41b	452	if (!kernel_text_address(info.ip))
11e17809	453	return 0;
11e17809 HD	454	} while (info.ip && level--);
	455
	456	return info.ip;
	457	}