1/*
2 * arch/sh/kernel/cpu/sh5/unwind.c
3 *
4 * Copyright (C) 2004  Paul Mundt
5 * Copyright (C) 2004  Richard Curnow
6 *
7 * This file is subject to the terms and conditions of the GNU General Public
8 * License.  See the file "COPYING" in the main directory of this archive
9 * for more details.
10 */
11#include <linux/kallsyms.h>
12#include <linux/kernel.h>
13#include <linux/types.h>
14#include <linux/errno.h>
15#include <asm/page.h>
16#include <asm/ptrace.h>
17#include <asm/processor.h>
18#include <asm/io.h>
19#include <asm/unwinder.h>
20#include <asm/stacktrace.h>
21
22static u8 regcache[63];
23
24/*
25 * Finding the previous stack frame isn't horribly straightforward as it is
26 * on some other platforms. In the sh64 case, we don't have "linked" stack
27 * frames, so we need to do a bit of work to determine the previous frame,
28 * and in turn, the previous r14/r18 pair.
29 *
30 * There are generally a few cases which determine where we can find out
31 * the r14/r18 values. In the general case, this can be determined by poking
32 * around the prologue of the symbol PC is in (note that we absolutely must
33 * have frame pointer support as well as the kernel symbol table mapped,
34 * otherwise we can't even get this far).
35 *
36 * In other cases, such as the interrupt/exception path, we can poke around
37 * the sp/fp.
38 *
39 * Notably, this entire approach is somewhat error prone, and in the event
40 * that the previous frame cannot be determined, that's all we can do.
41 * Either way, this still leaves us with a more correct backtrace then what
42 * we would be able to come up with by walking the stack (which is garbage
43 * for anything beyond the first frame).
44 *						-- PFM.
45 */
46static int lookup_prev_stack_frame(unsigned long fp, unsigned long pc,
47		      unsigned long *pprev_fp, unsigned long *pprev_pc,
48		      struct pt_regs *regs)
49{
50	const char *sym;
51	char namebuf[128];
52	unsigned long offset;
53	unsigned long prologue = 0;
54	unsigned long fp_displacement = 0;
55	unsigned long fp_prev = 0;
56	unsigned long offset_r14 = 0, offset_r18 = 0;
57	int i, found_prologue_end = 0;
58
59	sym = kallsyms_lookup(pc, NULL, &offset, NULL, namebuf);
60	if (!sym)
61		return -EINVAL;
62
63	prologue = pc - offset;
64	if (!prologue)
65		return -EINVAL;
66
67	/* Validate fp, to avoid risk of dereferencing a bad pointer later.
68	   Assume 128Mb since that's the amount of RAM on a Cayman.  Modify
69	   when there is an SH-5 board with more. */
70	if ((fp < (unsigned long) phys_to_virt(__MEMORY_START)) ||
71	    (fp >= (unsigned long)(phys_to_virt(__MEMORY_START)) + 128*1024*1024) ||
72	    ((fp & 7) != 0)) {
73		return -EINVAL;
74	}
75
76	/*
77	 * Depth to walk, depth is completely arbitrary.
78	 */
79	for (i = 0; i < 100; i++, prologue += sizeof(unsigned long)) {
80		unsigned long op;
81		u8 major, minor;
82		u8 src, dest, disp;
83
84		op = *(unsigned long *)prologue;
85
86		major = (op >> 26) & 0x3f;
87		src   = (op >> 20) & 0x3f;
88		minor = (op >> 16) & 0xf;
89		disp  = (op >> 10) & 0x3f;
90		dest  = (op >>  4) & 0x3f;
91
92		/*
93		 * Stack frame creation happens in a number of ways.. in the
94		 * general case when the stack frame is less than 511 bytes,
95		 * it's generally created by an addi or addi.l:
96		 *
97		 *	addi/addi.l r15, -FRAME_SIZE, r15
98		 *
99		 * in the event that the frame size is bigger than this, it's
100		 * typically created using a movi/sub pair as follows:
101		 *
102		 *	movi	FRAME_SIZE, rX
103		 *	sub	r15, rX, r15
104		 */
105
106		switch (major) {
107		case (0x00 >> 2):
108			switch (minor) {
109			case 0x8: /* add.l */
110			case 0x9: /* add */
111				/* Look for r15, r63, r14 */
112				if (src == 15 && disp == 63 && dest == 14)
113					found_prologue_end = 1;
114
115				break;
116			case 0xa: /* sub.l */
117			case 0xb: /* sub */
118				if (src != 15 || dest != 15)
119					continue;
120
121				fp_displacement -= regcache[disp];
122				fp_prev = fp - fp_displacement;
123				break;
124			}
125			break;
126		case (0xa8 >> 2): /* st.l */
127			if (src != 15)
128				continue;
129
130			switch (dest) {
131			case 14:
132				if (offset_r14 || fp_displacement == 0)
133					continue;
134
135				offset_r14 = (u64)(((((s64)op >> 10) & 0x3ff) << 54) >> 54);
136				offset_r14 *= sizeof(unsigned long);
137				offset_r14 += fp_displacement;
138				break;
139			case 18:
140				if (offset_r18 || fp_displacement == 0)
141					continue;
142
143				offset_r18 = (u64)(((((s64)op >> 10) & 0x3ff) << 54) >> 54);
144				offset_r18 *= sizeof(unsigned long);
145				offset_r18 += fp_displacement;
146				break;
147			}
148
149			break;
150		case (0xcc >> 2): /* movi */
151			if (dest >= 63) {
152				printk(KERN_NOTICE "%s: Invalid dest reg %d "
153				       "specified in movi handler. Failed "
154				       "opcode was 0x%lx: ", __func__,
155				       dest, op);
156
157				continue;
158			}
159
160			/* Sign extend */
161			regcache[dest] =
162				((((s64)(u64)op >> 10) & 0xffff) << 54) >> 54;
163			break;
164		case (0xd0 >> 2): /* addi */
165		case (0xd4 >> 2): /* addi.l */
166			/* Look for r15, -FRAME_SIZE, r15 */
167			if (src != 15 || dest != 15)
168				continue;
169
170			/* Sign extended frame size.. */
171			fp_displacement +=
172				(u64)(((((s64)op >> 10) & 0x3ff) << 54) >> 54);
173			fp_prev = fp - fp_displacement;
174			break;
175		}
176
177		if (found_prologue_end && offset_r14 && (offset_r18 || *pprev_pc) && fp_prev)
178			break;
179	}
180
181	if (offset_r14 == 0 || fp_prev == 0) {
182		if (!offset_r14)
183			pr_debug("Unable to find r14 offset\n");
184		if (!fp_prev)
185			pr_debug("Unable to find previous fp\n");
186
187		return -EINVAL;
188	}
189
190	/* For innermost leaf function, there might not be a offset_r18 */
191	if (!*pprev_pc && (offset_r18 == 0))
192		return -EINVAL;
193
194	*pprev_fp = *(unsigned long *)(fp_prev + offset_r14);
195
196	if (offset_r18)
197		*pprev_pc = *(unsigned long *)(fp_prev + offset_r18);
198
199	*pprev_pc &= ~1;
200
201	return 0;
202}
203
204/*
205 * Don't put this on the stack since we'll want to call in to
206 * sh64_unwinder_dump() when we're close to underflowing the stack
207 * anyway.
208 */
209static struct pt_regs here_regs;
210
211extern const char syscall_ret;
212extern const char ret_from_syscall;
213extern const char ret_from_exception;
214extern const char ret_from_irq;
215
216static void sh64_unwind_inner(const struct stacktrace_ops *ops,
217			      void *data, struct pt_regs *regs);
218
219static inline void unwind_nested(const struct stacktrace_ops *ops, void *data,
220				 unsigned long pc, unsigned long fp)
221{
222	if ((fp >= __MEMORY_START) &&
223	    ((fp & 7) == 0))
224		sh64_unwind_inner(ops, data, (struct pt_regs *)fp);
225}
226
227static void sh64_unwind_inner(const struct stacktrace_ops *ops,
228			      void *data, struct pt_regs *regs)
229{
230	unsigned long pc, fp;
231	int ofs = 0;
232	int first_pass;
233
234	pc = regs->pc & ~1;
235	fp = regs->regs[14];
236
237	first_pass = 1;
238	for (;;) {
239		int cond;
240		unsigned long next_fp, next_pc;
241
242		if (pc == ((unsigned long)&syscall_ret & ~1)) {
243			printk("SYSCALL\n");
244			unwind_nested(ops, data, pc, fp);
245			return;
246		}
247
248		if (pc == ((unsigned long)&ret_from_syscall & ~1)) {
249			printk("SYSCALL (PREEMPTED)\n");
250			unwind_nested(ops, data, pc, fp);
251			return;
252		}
253
254		/* In this case, the PC is discovered by lookup_prev_stack_frame but
255		   it has 4 taken off it to look like the 'caller' */
256		if (pc == ((unsigned long)&ret_from_exception & ~1)) {
257			printk("EXCEPTION\n");
258			unwind_nested(ops, data, pc, fp);
259			return;
260		}
261
262		if (pc == ((unsigned long)&ret_from_irq & ~1)) {
263			printk("IRQ\n");
264			unwind_nested(ops, data, pc, fp);
265			return;
266		}
267
268		cond = ((pc >= __MEMORY_START) && (fp >= __MEMORY_START) &&
269			((pc & 3) == 0) && ((fp & 7) == 0));
270
271		pc -= ofs;
272
273		ops->address(data, pc, 1);
274
275		if (first_pass) {
276			/* If the innermost frame is a leaf function, it's
277			 * possible that r18 is never saved out to the stack.
278			 */
279			next_pc = regs->regs[18];
280		} else {
281			next_pc = 0;
282		}
283
284		if (lookup_prev_stack_frame(fp, pc, &next_fp, &next_pc, regs) == 0) {
285			ofs = sizeof(unsigned long);
286			pc = next_pc & ~1;
287			fp = next_fp;
288		} else {
289			printk("Unable to lookup previous stack frame\n");
290			break;
291		}
292		first_pass = 0;
293	}
294
295	printk("\n");
296}
297
298static void sh64_unwinder_dump(struct task_struct *task,
299			       struct pt_regs *regs,
300			       unsigned long *sp,
301			       const struct stacktrace_ops *ops,
302			       void *data)
303{
304	if (!regs) {
305		/*
306		 * Fetch current regs if we have no other saved state to back
307		 * trace from.
308		 */
309		regs = &here_regs;
310
311		__asm__ __volatile__ ("ori r14, 0, %0" : "=r" (regs->regs[14]));
312		__asm__ __volatile__ ("ori r15, 0, %0" : "=r" (regs->regs[15]));
313		__asm__ __volatile__ ("ori r18, 0, %0" : "=r" (regs->regs[18]));
314
315		__asm__ __volatile__ ("gettr tr0, %0" : "=r" (regs->tregs[0]));
316		__asm__ __volatile__ ("gettr tr1, %0" : "=r" (regs->tregs[1]));
317		__asm__ __volatile__ ("gettr tr2, %0" : "=r" (regs->tregs[2]));
318		__asm__ __volatile__ ("gettr tr3, %0" : "=r" (regs->tregs[3]));
319		__asm__ __volatile__ ("gettr tr4, %0" : "=r" (regs->tregs[4]));
320		__asm__ __volatile__ ("gettr tr5, %0" : "=r" (regs->tregs[5]));
321		__asm__ __volatile__ ("gettr tr6, %0" : "=r" (regs->tregs[6]));
322		__asm__ __volatile__ ("gettr tr7, %0" : "=r" (regs->tregs[7]));
323
324		__asm__ __volatile__ (
325			"pta 0f, tr0\n\t"
326			"blink tr0, %0\n\t"
327			"0: nop"
328			: "=r" (regs->pc)
329		);
330	}
331
332	sh64_unwind_inner(ops, data, regs);
333}
334
335static struct unwinder sh64_unwinder = {
336	.name	= "sh64-unwinder",
337	.dump	= sh64_unwinder_dump,
338	.rating	= 150,
339};
340
341static int __init sh64_unwinder_init(void)
342{
343	return unwinder_register(&sh64_unwinder);
344}
345early_initcall(sh64_unwinder_init);
346