[deliverable/linux.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 <asm/uaccess.h>
#include <asm/assembly.h>

#include <asm/unwind.h>

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

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)
				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 void
unwind_table_sort(struct unwind_table_entry *start,
		  struct unwind_table_entry *finish)
{
	struct unwind_table_entry el, *p, *q;

	for (p = start + 1; p < finish; ++p) {
		if (p[0].region_start < p[-1].region_start) {
			el = *p;
			q = p;
			do {
				q[0] = q[-1];
				--q;
			} while (q > start && 
				 el.region_start < q[-1].region_start);
			*q = el;
		}
	}
}

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

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+1];

			kallsyms_lookup(info->ip, NULL, NULL, NULL, 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);
			}
		}

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

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