dump_stack: consolidate dump_stack() implementations and unify their behaviors
[linux-3.10.git] / arch / hexagon / kernel / traps.c
1 /*
2  * Kernel traps/events for Hexagon processor
3  *
4  * Copyright (c) 2010-2011, The Linux Foundation. All rights reserved.
5  *
6  * This program is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License version 2 and
8  * only version 2 as published by the Free Software Foundation.
9  *
10  * This program is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13  * GNU General Public License for more details.
14  *
15  * You should have received a copy of the GNU General Public License
16  * along with this program; if not, write to the Free Software
17  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
18  * 02110-1301, USA.
19  */
20
21 #include <linux/init.h>
22 #include <linux/sched.h>
23 #include <linux/module.h>
24 #include <linux/kallsyms.h>
25 #include <linux/kdebug.h>
26 #include <linux/syscalls.h>
27 #include <linux/signal.h>
28 #include <linux/tracehook.h>
29 #include <asm/traps.h>
30 #include <asm/vm_fault.h>
31 #include <asm/syscall.h>
32 #include <asm/registers.h>
33 #include <asm/unistd.h>
34 #include <asm/sections.h>
35 #ifdef CONFIG_KGDB
36 # include <linux/kgdb.h>
37 #endif
38
39 #define TRAP_SYSCALL    1
40 #define TRAP_DEBUG      0xdb
41
42 void __init trap_init(void)
43 {
44 }
45
46 #ifdef CONFIG_GENERIC_BUG
47 /* Maybe should resemble arch/sh/kernel/traps.c ?? */
48 int is_valid_bugaddr(unsigned long addr)
49 {
50         return 1;
51 }
52 #endif /* CONFIG_GENERIC_BUG */
53
54 static const char *ex_name(int ex)
55 {
56         switch (ex) {
57         case HVM_GE_C_XPROT:
58         case HVM_GE_C_XUSER:
59                 return "Execute protection fault";
60         case HVM_GE_C_RPROT:
61         case HVM_GE_C_RUSER:
62                 return "Read protection fault";
63         case HVM_GE_C_WPROT:
64         case HVM_GE_C_WUSER:
65                 return "Write protection fault";
66         case HVM_GE_C_XMAL:
67                 return "Misaligned instruction";
68         case HVM_GE_C_RMAL:
69                 return "Misaligned data load";
70         case HVM_GE_C_WMAL:
71                 return "Misaligned data store";
72         case HVM_GE_C_INVI:
73         case HVM_GE_C_PRIVI:
74                 return "Illegal instruction";
75         case HVM_GE_C_BUS:
76                 return "Precise bus error";
77         case HVM_GE_C_CACHE:
78                 return "Cache error";
79
80         case 0xdb:
81                 return "Debugger trap";
82
83         default:
84                 return "Unrecognized exception";
85         }
86 }
87
88 static void do_show_stack(struct task_struct *task, unsigned long *fp,
89                           unsigned long ip)
90 {
91         int kstack_depth_to_print = 24;
92         unsigned long offset, size;
93         const char *name = NULL;
94         unsigned long *newfp;
95         unsigned long low, high;
96         char tmpstr[128];
97         char *modname;
98         int i;
99
100         if (task == NULL)
101                 task = current;
102
103         printk(KERN_INFO "CPU#%d, %s/%d, Call Trace:\n",
104                raw_smp_processor_id(), task->comm,
105                task_pid_nr(task));
106
107         if (fp == NULL) {
108                 if (task == current) {
109                         asm("%0 = r30" : "=r" (fp));
110                 } else {
111                         fp = (unsigned long *)
112                              ((struct hexagon_switch_stack *)
113                              task->thread.switch_sp)->fp;
114                 }
115         }
116
117         if ((((unsigned long) fp) & 0x3) || ((unsigned long) fp < 0x1000)) {
118                 printk(KERN_INFO "-- Corrupt frame pointer %p\n", fp);
119                 return;
120         }
121
122         /* Saved link reg is one word above FP */
123         if (!ip)
124                 ip = *(fp+1);
125
126         /* Expect kernel stack to be in-bounds */
127         low = (unsigned long)task_stack_page(task);
128         high = low + THREAD_SIZE - 8;
129         low += sizeof(struct thread_info);
130
131         for (i = 0; i < kstack_depth_to_print; i++) {
132
133                 name = kallsyms_lookup(ip, &size, &offset, &modname, tmpstr);
134
135                 printk(KERN_INFO "[%p] 0x%lx: %s + 0x%lx", fp, ip, name,
136                         offset);
137                 if (((unsigned long) fp < low) || (high < (unsigned long) fp))
138                         printk(KERN_CONT " (FP out of bounds!)");
139                 if (modname)
140                         printk(KERN_CONT " [%s] ", modname);
141                 printk(KERN_CONT "\n");
142
143                 newfp = (unsigned long *) *fp;
144
145                 if (((unsigned long) newfp) & 0x3) {
146                         printk(KERN_INFO "-- Corrupt frame pointer %p\n",
147                                 newfp);
148                         break;
149                 }
150
151                 /* Attempt to continue past exception. */
152                 if (0 == newfp) {
153                         struct pt_regs *regs = (struct pt_regs *) (((void *)fp)
154                                                 + 8);
155
156                         if (regs->syscall_nr != -1) {
157                                 printk(KERN_INFO "-- trap0 -- syscall_nr: %ld",
158                                         regs->syscall_nr);
159                                 printk(KERN_CONT "  psp: %lx  elr: %lx\n",
160                                          pt_psp(regs), pt_elr(regs));
161                                 break;
162                         } else {
163                                 /* really want to see more ... */
164                                 kstack_depth_to_print += 6;
165                                 printk(KERN_INFO "-- %s (0x%lx)  badva: %lx\n",
166                                         ex_name(pt_cause(regs)), pt_cause(regs),
167                                         pt_badva(regs));
168                         }
169
170                         newfp = (unsigned long *) regs->r30;
171                         ip = pt_elr(regs);
172                 } else {
173                         ip = *(newfp + 1);
174                 }
175
176                 /* If link reg is null, we are done. */
177                 if (ip == 0x0)
178                         break;
179
180                 /* If newfp isn't larger, we're tracing garbage. */
181                 if (newfp > fp)
182                         fp = newfp;
183                 else
184                         break;
185         }
186 }
187
188 void show_stack(struct task_struct *task, unsigned long *fp)
189 {
190         /* Saved link reg is one word above FP */
191         do_show_stack(task, fp, 0);
192 }
193
194 int die(const char *str, struct pt_regs *regs, long err)
195 {
196         static struct {
197                 spinlock_t lock;
198                 int counter;
199         } die = {
200                 .lock = __SPIN_LOCK_UNLOCKED(die.lock),
201                 .counter = 0
202         };
203
204         console_verbose();
205         oops_enter();
206
207         spin_lock_irq(&die.lock);
208         bust_spinlocks(1);
209         printk(KERN_EMERG "Oops: %s[#%d]:\n", str, ++die.counter);
210
211         if (notify_die(DIE_OOPS, str, regs, err, pt_cause(regs), SIGSEGV) ==
212             NOTIFY_STOP)
213                 return 1;
214
215         print_modules();
216         show_regs(regs);
217         do_show_stack(current, &regs->r30, pt_elr(regs));
218
219         bust_spinlocks(0);
220         add_taint(TAINT_DIE, LOCKDEP_NOW_UNRELIABLE);
221
222         spin_unlock_irq(&die.lock);
223
224         if (in_interrupt())
225                 panic("Fatal exception in interrupt");
226
227         if (panic_on_oops)
228                 panic("Fatal exception");
229
230         oops_exit();
231         do_exit(err);
232         return 0;
233 }
234
235 int die_if_kernel(char *str, struct pt_regs *regs, long err)
236 {
237         if (!user_mode(regs))
238                 return die(str, regs, err);
239         else
240                 return 0;
241 }
242
243 /*
244  * It's not clear that misaligned fetches are ever recoverable.
245  */
246 static void misaligned_instruction(struct pt_regs *regs)
247 {
248         die_if_kernel("Misaligned Instruction", regs, 0);
249         force_sig(SIGBUS, current);
250 }
251
252 /*
253  * Misaligned loads and stores, on the other hand, can be
254  * emulated, and probably should be, some day.  But for now
255  * they will be considered fatal.
256  */
257 static void misaligned_data_load(struct pt_regs *regs)
258 {
259         die_if_kernel("Misaligned Data Load", regs, 0);
260         force_sig(SIGBUS, current);
261 }
262
263 static void misaligned_data_store(struct pt_regs *regs)
264 {
265         die_if_kernel("Misaligned Data Store", regs, 0);
266         force_sig(SIGBUS, current);
267 }
268
269 static void illegal_instruction(struct pt_regs *regs)
270 {
271         die_if_kernel("Illegal Instruction", regs, 0);
272         force_sig(SIGILL, current);
273 }
274
275 /*
276  * Precise bus errors may be recoverable with a a retry,
277  * but for now, treat them as irrecoverable.
278  */
279 static void precise_bus_error(struct pt_regs *regs)
280 {
281         die_if_kernel("Precise Bus Error", regs, 0);
282         force_sig(SIGBUS, current);
283 }
284
285 /*
286  * If anything is to be done here other than panic,
287  * it will probably be complex and migrate to another
288  * source module.  For now, just die.
289  */
290 static void cache_error(struct pt_regs *regs)
291 {
292         die("Cache Error", regs, 0);
293 }
294
295 /*
296  * General exception handler
297  */
298 void do_genex(struct pt_regs *regs)
299 {
300         /*
301          * Decode Cause and Dispatch
302          */
303         switch (pt_cause(regs)) {
304         case HVM_GE_C_XPROT:
305         case HVM_GE_C_XUSER:
306                 execute_protection_fault(regs);
307                 break;
308         case HVM_GE_C_RPROT:
309         case HVM_GE_C_RUSER:
310                 read_protection_fault(regs);
311                 break;
312         case HVM_GE_C_WPROT:
313         case HVM_GE_C_WUSER:
314                 write_protection_fault(regs);
315                 break;
316         case HVM_GE_C_XMAL:
317                 misaligned_instruction(regs);
318                 break;
319         case HVM_GE_C_RMAL:
320                 misaligned_data_load(regs);
321                 break;
322         case HVM_GE_C_WMAL:
323                 misaligned_data_store(regs);
324                 break;
325         case HVM_GE_C_INVI:
326         case HVM_GE_C_PRIVI:
327                 illegal_instruction(regs);
328                 break;
329         case HVM_GE_C_BUS:
330                 precise_bus_error(regs);
331                 break;
332         case HVM_GE_C_CACHE:
333                 cache_error(regs);
334                 break;
335         default:
336                 /* Halt and catch fire */
337                 panic("Unrecognized exception 0x%lx\n", pt_cause(regs));
338                 break;
339         }
340 }
341
342 /* Indirect system call dispatch */
343 long sys_syscall(void)
344 {
345         printk(KERN_ERR "sys_syscall invoked!\n");
346         return -ENOSYS;
347 }
348
349 void do_trap0(struct pt_regs *regs)
350 {
351         unsigned long syscallret = 0;
352         syscall_fn syscall;
353
354         switch (pt_cause(regs)) {
355         case TRAP_SYSCALL:
356                 /* System call is trap0 #1 */
357
358                 /* allow strace to catch syscall args  */
359                 if (unlikely(test_thread_flag(TIF_SYSCALL_TRACE) &&
360                         tracehook_report_syscall_entry(regs)))
361                         return;  /*  return -ENOSYS somewhere?  */
362
363                 /* Interrupts should be re-enabled for syscall processing */
364                 __vmsetie(VM_INT_ENABLE);
365
366                 /*
367                  * System call number is in r6, arguments in r0..r5.
368                  * Fortunately, no Linux syscall has more than 6 arguments,
369                  * and Hexagon ABI passes first 6 arguments in registers.
370                  * 64-bit arguments are passed in odd/even register pairs.
371                  * Fortunately, we have no system calls that take more
372                  * than three arguments with more than one 64-bit value.
373                  * Should that change, we'd need to redesign to copy
374                  * between user and kernel stacks.
375                  */
376                 regs->syscall_nr = regs->r06;
377
378                 /*
379                  * GPR R0 carries the first parameter, and is also used
380                  * to report the return value.  We need a backup of
381                  * the user's value in case we need to do a late restart
382                  * of the system call.
383                  */
384                 regs->restart_r0 = regs->r00;
385
386                 if ((unsigned long) regs->syscall_nr >= __NR_syscalls) {
387                         regs->r00 = -1;
388                 } else {
389                         syscall = (syscall_fn)
390                                   (sys_call_table[regs->syscall_nr]);
391                         syscallret = syscall(regs->r00, regs->r01,
392                                    regs->r02, regs->r03,
393                                    regs->r04, regs->r05);
394                 }
395
396                 /*
397                  * If it was a sigreturn system call, don't overwrite
398                  * r0 value in stack frame with return value.
399                  *
400                  * __NR_sigreturn doesn't seem to exist in new unistd.h
401                  */
402
403                 if (regs->syscall_nr != __NR_rt_sigreturn)
404                         regs->r00 = syscallret;
405
406                 /* allow strace to get the syscall return state  */
407                 if (unlikely(test_thread_flag(TIF_SYSCALL_TRACE)))
408                         tracehook_report_syscall_exit(regs, 0);
409
410                 break;
411         case TRAP_DEBUG:
412                 /* Trap0 0xdb is debug breakpoint */
413                 if (user_mode(regs)) {
414                         struct siginfo info;
415
416                         info.si_signo = SIGTRAP;
417                         info.si_errno = 0;
418                         /*
419                          * Some architecures add some per-thread state
420                          * to distinguish between breakpoint traps and
421                          * trace traps.  We may want to do that, and
422                          * set the si_code value appropriately, or we
423                          * may want to use a different trap0 flavor.
424                          */
425                         info.si_code = TRAP_BRKPT;
426                         info.si_addr = (void __user *) pt_elr(regs);
427                         send_sig_info(SIGTRAP, &info, current);
428                 } else {
429 #ifdef CONFIG_KGDB
430                         kgdb_handle_exception(pt_cause(regs), SIGTRAP,
431                                               TRAP_BRKPT, regs);
432 #endif
433                 }
434                 break;
435         }
436         /* Ignore other trap0 codes for now, especially 0 (Angel calls) */
437 }
438
439 /*
440  * Machine check exception handler
441  */
442 void do_machcheck(struct pt_regs *regs)
443 {
444         /* Halt and catch fire */
445         __vmstop();
446 }