1 /*
2  * Backtrace support for Microblaze
3  *
4  * Copyright (C) 2010  Digital Design Corporation
5  *
6  * Based on arch/sh/kernel/cpu/sh5/unwind.c code which is:
7  * Copyright (C) 2004  Paul Mundt
8  * Copyright (C) 2004  Richard Curnow
9  *
10  * This file is subject to the terms and conditions of the GNU General Public
11  * License.  See the file "COPYING" in the main directory of this archive
12  * for more details.
13  */
14 
15 /* #define DEBUG 1 */
16 #include <linux/export.h>
17 #include <linux/kallsyms.h>
18 #include <linux/kernel.h>
19 #include <linux/sched.h>
20 #include <linux/sched/task_stack.h>
21 #include <linux/stacktrace.h>
22 #include <linux/types.h>
23 #include <linux/errno.h>
24 #include <linux/io.h>
25 #include <asm/sections.h>
26 #include <asm/exceptions.h>
27 #include <asm/unwind.h>
28 #include <asm/switch_to.h>
29 
30 struct stack_trace;
31 
32 /*
33  * On Microblaze, finding the previous stack frame is a little tricky.
34  * At this writing (3/2010), Microblaze does not support CONFIG_FRAME_POINTERS,
35  * and even if it did, gcc (4.1.2) does not store the frame pointer at
36  * a consistent offset within each frame. To determine frame size, it is
37  * necessary to search for the assembly instruction that creates or reclaims
38  * the frame and extract the size from it.
39  *
40  * Microblaze stores the stack pointer in r1, and creates a frame via
41  *
42  *     addik r1, r1, -FRAME_SIZE
43  *
44  * The frame is reclaimed via
45  *
46  *     addik r1, r1, FRAME_SIZE
47  *
48  * Frame creation occurs at or near the top of a function.
49  * Depending on the compiler, reclaim may occur at the end, or before
50  * a mid-function return.
51  *
52  * A stack frame is usually not created in a leaf function.
53  *
54  */
55 
56 /**
57  * get_frame_size - Extract the stack adjustment from an
58  *                  "addik r1, r1, adjust" instruction
59  * @instr : Microblaze instruction
60  *
61  * Return - Number of stack bytes the instruction reserves or reclaims
62  */
get_frame_size(unsigned long instr)63 static inline long get_frame_size(unsigned long instr)
64 {
65 	return abs((s16)(instr & 0xFFFF));
66 }
67 
68 /**
69  * find_frame_creation - Search backward to find the instruction that creates
70  *                       the stack frame (hopefully, for the same function the
71  *                       initial PC is in).
72  * @pc : Program counter at which to begin the search
73  *
74  * Return - PC at which stack frame creation occurs
75  *          NULL if this cannot be found, i.e. a leaf function
76  */
find_frame_creation(unsigned long * pc)77 static unsigned long *find_frame_creation(unsigned long *pc)
78 {
79 	int i;
80 
81 	/* NOTE: Distance to search is arbitrary
82 	 *	 250 works well for most things,
83 	 *	 750 picks up things like tcp_recvmsg(),
84 	 *	1000 needed for fat_fill_super()
85 	 */
86 	for (i = 0; i < 1000; i++, pc--) {
87 		unsigned long instr;
88 		s16 frame_size;
89 
90 		if (!kernel_text_address((unsigned long) pc))
91 			return NULL;
92 
93 		instr = *pc;
94 
95 		/* addik r1, r1, foo ? */
96 		if ((instr & 0xFFFF0000) != 0x30210000)
97 			continue;	/* No */
98 
99 		frame_size = get_frame_size(instr);
100 		if ((frame_size < 8) || (frame_size & 3)) {
101 			pr_debug("    Invalid frame size %d at 0x%p\n",
102 				 frame_size, pc);
103 			return NULL;
104 		}
105 
106 		pr_debug("    Found frame creation at 0x%p, size %d\n", pc,
107 			 frame_size);
108 		return pc;
109 	}
110 
111 	return NULL;
112 }
113 
114 /**
115  * lookup_prev_stack_frame - Find the stack frame of the previous function.
116  * @fp          : Frame (stack) pointer for current function
117  * @pc          : Program counter within current function
118  * @leaf_return : r15 value within current function. If the current function
119  *		  is a leaf, this is the caller's return address.
120  * @pprev_fp    : On exit, set to frame (stack) pointer for previous function
121  * @pprev_pc    : On exit, set to current function caller's return address
122  *
123  * Return - 0 on success, -EINVAL if the previous frame cannot be found
124  */
lookup_prev_stack_frame(unsigned long fp,unsigned long pc,unsigned long leaf_return,unsigned long * pprev_fp,unsigned long * pprev_pc)125 static int lookup_prev_stack_frame(unsigned long fp, unsigned long pc,
126 				   unsigned long leaf_return,
127 				   unsigned long *pprev_fp,
128 				   unsigned long *pprev_pc)
129 {
130 	unsigned long *prologue = NULL;
131 
132 	/* _switch_to is a special leaf function */
133 	if (pc != (unsigned long) &_switch_to)
134 		prologue = find_frame_creation((unsigned long *)pc);
135 
136 	if (prologue) {
137 		long frame_size = get_frame_size(*prologue);
138 
139 		*pprev_fp = fp + frame_size;
140 		*pprev_pc = *(unsigned long *)fp;
141 	} else {
142 		if (!leaf_return)
143 			return -EINVAL;
144 		*pprev_pc = leaf_return;
145 		*pprev_fp = fp;
146 	}
147 
148 	/* NOTE: don't check kernel_text_address here, to allow display
149 	 *	 of userland return address
150 	 */
151 	return (!*pprev_pc || (*pprev_pc & 3)) ? -EINVAL : 0;
152 }
153 
154 static void microblaze_unwind_inner(struct task_struct *task,
155 				    unsigned long pc, unsigned long fp,
156 				    unsigned long leaf_return,
157 				    struct stack_trace *trace,
158 				    const char *loglvl);
159 
160 /**
161  * unwind_trap - Unwind through a system trap, that stored previous state
162  *		 on the stack.
163  */
unwind_trap(struct task_struct * task,unsigned long pc,unsigned long fp,struct stack_trace * trace,const char * loglvl)164 static inline void unwind_trap(struct task_struct *task, unsigned long pc,
165 				unsigned long fp, struct stack_trace *trace,
166 				const char *loglvl)
167 {
168 	/* To be implemented */
169 }
170 
171 /**
172  * microblaze_unwind_inner - Unwind the stack from the specified point
173  * @task  : Task whose stack we are to unwind (may be NULL)
174  * @pc    : Program counter from which we start unwinding
175  * @fp    : Frame (stack) pointer from which we start unwinding
176  * @leaf_return : Value of r15 at pc. If the function is a leaf, this is
177  *				  the caller's return address.
178  * @trace : Where to store stack backtrace (PC values).
179  *	    NULL == print backtrace to kernel log
180  * @loglvl : Used for printk log level if (trace == NULL).
181  */
microblaze_unwind_inner(struct task_struct * task,unsigned long pc,unsigned long fp,unsigned long leaf_return,struct stack_trace * trace,const char * loglvl)182 static void microblaze_unwind_inner(struct task_struct *task,
183 			     unsigned long pc, unsigned long fp,
184 			     unsigned long leaf_return,
185 			     struct stack_trace *trace,
186 			     const char *loglvl)
187 {
188 	int ofs = 0;
189 
190 	pr_debug("    Unwinding with PC=%p, FP=%p\n", (void *)pc, (void *)fp);
191 	if (!pc || !fp || (pc & 3) || (fp & 3)) {
192 		pr_debug("    Invalid state for unwind, aborting\n");
193 		return;
194 	}
195 	for (; pc != 0;) {
196 		unsigned long next_fp, next_pc = 0;
197 		unsigned long return_to = pc +  2 * sizeof(unsigned long);
198 		const struct trap_handler_info *handler =
199 			&microblaze_trap_handlers;
200 
201 		/* Is previous function the HW exception handler? */
202 		if ((return_to >= (unsigned long)&_hw_exception_handler)
203 		    &&(return_to < (unsigned long)&ex_handler_unhandled)) {
204 			/*
205 			 * HW exception handler doesn't save all registers,
206 			 * so we open-code a special case of unwind_trap()
207 			 */
208 			printk("%sHW EXCEPTION\n", loglvl);
209 			return;
210 		}
211 
212 		/* Is previous function a trap handler? */
213 		for (; handler->start_addr; ++handler) {
214 			if ((return_to >= handler->start_addr)
215 			    && (return_to <= handler->end_addr)) {
216 				if (!trace)
217 					printk("%s%s\n", loglvl, handler->trap_name);
218 				unwind_trap(task, pc, fp, trace, loglvl);
219 				return;
220 			}
221 		}
222 		pc -= ofs;
223 
224 		if (trace) {
225 #ifdef CONFIG_STACKTRACE
226 			if (trace->skip > 0)
227 				trace->skip--;
228 			else
229 				trace->entries[trace->nr_entries++] = pc;
230 
231 			if (trace->nr_entries >= trace->max_entries)
232 				break;
233 #endif
234 		} else {
235 			/* Have we reached userland? */
236 			if (unlikely(pc == task_pt_regs(task)->pc)) {
237 				printk("%s[<%p>] PID %lu [%s]\n",
238 					loglvl, (void *) pc,
239 					(unsigned long) task->pid,
240 					task->comm);
241 				break;
242 			} else
243 				print_ip_sym(loglvl, pc);
244 		}
245 
246 		/* Stop when we reach anything not part of the kernel */
247 		if (!kernel_text_address(pc))
248 			break;
249 
250 		if (lookup_prev_stack_frame(fp, pc, leaf_return, &next_fp,
251 					    &next_pc) == 0) {
252 			ofs = sizeof(unsigned long);
253 			pc = next_pc & ~3;
254 			fp = next_fp;
255 			leaf_return = 0;
256 		} else {
257 			pr_debug("    Failed to find previous stack frame\n");
258 			break;
259 		}
260 
261 		pr_debug("    Next PC=%p, next FP=%p\n",
262 			 (void *)next_pc, (void *)next_fp);
263 	}
264 }
265 
266 /**
267  * microblaze_unwind - Stack unwinder for Microblaze (external entry point)
268  * @task  : Task whose stack we are to unwind (NULL == current)
269  * @trace : Where to store stack backtrace (PC values).
270  *	    NULL == print backtrace to kernel log
271  * @loglvl : Used for printk log level if (trace == NULL).
272  */
microblaze_unwind(struct task_struct * task,struct stack_trace * trace,const char * loglvl)273 void microblaze_unwind(struct task_struct *task, struct stack_trace *trace,
274 		       const char *loglvl)
275 {
276 	if (task) {
277 		if (task == current) {
278 			const struct pt_regs *regs = task_pt_regs(task);
279 			microblaze_unwind_inner(task, regs->pc, regs->r1,
280 						regs->r15, trace, loglvl);
281 		} else {
282 			struct thread_info *thread_info =
283 				(struct thread_info *)(task->stack);
284 			const struct cpu_context *cpu_context =
285 				&thread_info->cpu_context;
286 
287 			microblaze_unwind_inner(task,
288 						(unsigned long) &_switch_to,
289 						cpu_context->r1,
290 						cpu_context->r15,
291 						trace, loglvl);
292 		}
293 	} else {
294 		unsigned long pc, fp;
295 
296 		__asm__ __volatile__ ("or %0, r1, r0" : "=r" (fp));
297 
298 		__asm__ __volatile__ (
299 			"brlid %0, 0f;"
300 			"nop;"
301 			"0:"
302 			: "=r" (pc)
303 		);
304 
305 		/* Since we are not a leaf function, use leaf_return = 0 */
306 		microblaze_unwind_inner(current, pc, fp, 0, trace, loglvl);
307 	}
308 }
309 
310