[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/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];
			char *modname;
			unsigned long symsize, offset;

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

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