projects / deliverable / linux.git / blob
? search:


2f7e66877f3bd17c6b078d00f058f9c1959ff081
[deliverable/linux.git] / arch / frv / kernel / traps.c
1 /* traps.c: high-level exception handler for FR-V
2 *
3 * Copyright (C) 2003 Red Hat, Inc. All Rights Reserved.
4 * Written by David Howells (dhowells@redhat.com)
5 *
6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU General Public License
8 * as published by the Free Software Foundation; either version
9 * 2 of the License, or (at your option) any later version.
10 */
11
12 #include <linux/sched.h>
13 #include <linux/signal.h>
14 #include <linux/kernel.h>
15 #include <linux/mm.h>
16 #include <linux/types.h>
17 #include <linux/user.h>
18 #include <linux/string.h>
19 #include <linux/linkage.h>
20 #include <linux/init.h>
21 #include <linux/module.h>
22
23 #include <asm/asm-offsets.h>
24 #include <asm/setup.h>
25 #include <asm/fpu.h>
26 #include <asm/system.h>
27 #include <asm/uaccess.h>
28 #include <asm/pgtable.h>
29 #include <asm/siginfo.h>
30 #include <asm/unaligned.h>
31
32 void show_backtrace(struct pt_regs *, unsigned long);
33
34 extern asmlinkage void __break_hijack_kernel_event(void);
35
36 /*****************************************************************************/
37 /*
38 * instruction access error
39 */
40 asmlinkage void insn_access_error(unsigned long esfr1, unsigned long epcr0, unsigned long esr0)
41 {
42 siginfo_t info;
43
44 die_if_kernel("-- Insn Access Error --\n"
45 "EPCR0 : %08lx\n"
46 "ESR0 : %08lx\n",
47 epcr0, esr0);
48
49 info.si_signo = SIGSEGV;
50 info.si_code = SEGV_ACCERR;
51 info.si_errno = 0;
52 info.si_addr = (void *) ((epcr0 & EPCR0_V) ? (epcr0 & EPCR0_PC) : __frame->pc);
53
54 force_sig_info(info.si_signo, &info, current);
55 } /* end insn_access_error() */
56
57 /*****************************************************************************/
58 /*
59 * handler for:
60 * - illegal instruction
61 * - privileged instruction
62 * - unsupported trap
63 * - debug exceptions
64 */
65 asmlinkage void illegal_instruction(unsigned long esfr1, unsigned long epcr0, unsigned long esr0)
66 {
67 siginfo_t info;
68
69 die_if_kernel("-- Illegal Instruction --\n"
70 "EPCR0 : %08lx\n"
71 "ESR0 : %08lx\n"
72 "ESFR1 : %08lx\n",
73 epcr0, esr0, esfr1);
74
75 info.si_errno = 0;
76 info.si_addr = (void *) ((epcr0 & EPCR0_PC) ? (epcr0 & EPCR0_PC) : __frame->pc);
77
78 switch (__frame->tbr & TBR_TT) {
79 case TBR_TT_ILLEGAL_INSTR:
80 info.si_signo = SIGILL;
81 info.si_code = ILL_ILLOPC;
82 break;
83 case TBR_TT_PRIV_INSTR:
84 info.si_signo = SIGILL;
85 info.si_code = ILL_PRVOPC;
86 break;
87 case TBR_TT_TRAP2 ... TBR_TT_TRAP126:
88 info.si_signo = SIGILL;
89 info.si_code = ILL_ILLTRP;
90 break;
91 /* GDB uses "tira gr0, #1" as a breakpoint instruction. */
92 case TBR_TT_TRAP1:
93 case TBR_TT_BREAK:
94 info.si_signo = SIGTRAP;
95 info.si_code =
96 (__frame->__status & REG__STATUS_STEPPED) ? TRAP_TRACE : TRAP_BRKPT;
97 break;
98 }
99
100 force_sig_info(info.si_signo, &info, current);
101 } /* end illegal_instruction() */
102
103 /*****************************************************************************/
104 /*
105 * handle atomic operations with errors
106 * - arguments in gr8, gr9, gr10
107 * - original memory value placed in gr5
108 * - replacement memory value placed in gr9
109 */
110 asmlinkage void atomic_operation(unsigned long esfr1, unsigned long epcr0,
111 unsigned long esr0)
112 {
113 static DEFINE_SPINLOCK(atomic_op_lock);
114 unsigned long x, y, z, *p;
115 mm_segment_t oldfs;
116 siginfo_t info;
117 int ret;
118
119 y = 0;
120 z = 0;
121
122 oldfs = get_fs();
123 if (!user_mode(__frame))
124 set_fs(KERNEL_DS);
125
126 switch (__frame->tbr & TBR_TT) {
127 /* TIRA gr0,#120
128 * u32 __atomic_user_cmpxchg32(u32 *ptr, u32 test, u32 new)
129 */
130 case TBR_TT_ATOMIC_CMPXCHG32:
131 p = (unsigned long *) __frame->gr8;
132 x = __frame->gr9;
133 y = __frame->gr10;
134
135 for (;;) {
136 ret = get_user(z, p);
137 if (ret < 0)
138 goto error;
139
140 if (z != x)
141 goto done;
142
143 spin_lock_irq(&atomic_op_lock);
144
145 if (__get_user(z, p) == 0) {
146 if (z != x)
147 goto done2;
148
149 if (__put_user(y, p) == 0)
150 goto done2;
151 goto error2;
152 }
153
154 spin_unlock_irq(&atomic_op_lock);
155 }
156
157 /* TIRA gr0,#121
158 * u32 __atomic_kernel_xchg32(void *v, u32 new)
159 */
160 case TBR_TT_ATOMIC_XCHG32:
161 p = (unsigned long *) __frame->gr8;
162 y = __frame->gr9;
163
164 for (;;) {
165 ret = get_user(z, p);
166 if (ret < 0)
167 goto error;
168
169 spin_lock_irq(&atomic_op_lock);
170
171 if (__get_user(z, p) == 0) {
172 if (__put_user(y, p) == 0)
173 goto done2;
174 goto error2;
175 }
176
177 spin_unlock_irq(&atomic_op_lock);
178 }
179
180 /* TIRA gr0,#122
181 * ulong __atomic_kernel_XOR_return(ulong i, ulong *v)
182 */
183 case TBR_TT_ATOMIC_XOR:
184 p = (unsigned long *) __frame->gr8;
185 x = __frame->gr9;
186
187 for (;;) {
188 ret = get_user(z, p);
189 if (ret < 0)
190 goto error;
191
192 spin_lock_irq(&atomic_op_lock);
193
194 if (__get_user(z, p) == 0) {
195 y = x ^ z;
196 if (__put_user(y, p) == 0)
197 goto done2;
198 goto error2;
199 }
200
201 spin_unlock_irq(&atomic_op_lock);
202 }
203
204 /* TIRA gr0,#123
205 * ulong __atomic_kernel_OR_return(ulong i, ulong *v)
206 */
207 case TBR_TT_ATOMIC_OR:
208 p = (unsigned long *) __frame->gr8;
209 x = __frame->gr9;
210
211 for (;;) {
212 ret = get_user(z, p);
213 if (ret < 0)
214 goto error;
215
216 spin_lock_irq(&atomic_op_lock);
217
218 if (__get_user(z, p) == 0) {
219 y = x ^ z;
220 if (__put_user(y, p) == 0)
221 goto done2;
222 goto error2;
223 }
224
225 spin_unlock_irq(&atomic_op_lock);
226 }
227
228 /* TIRA gr0,#124
229 * ulong __atomic_kernel_AND_return(ulong i, ulong *v)
230 */
231 case TBR_TT_ATOMIC_AND:
232 p = (unsigned long *) __frame->gr8;
233 x = __frame->gr9;
234
235 for (;;) {
236 ret = get_user(z, p);
237 if (ret < 0)
238 goto error;
239
240 spin_lock_irq(&atomic_op_lock);
241
242 if (__get_user(z, p) == 0) {
243 y = x & z;
244 if (__put_user(y, p) == 0)
245 goto done2;
246 goto error2;
247 }
248
249 spin_unlock_irq(&atomic_op_lock);
250 }
251
252 /* TIRA gr0,#125
253 * int __atomic_user_sub_return(atomic_t *v, int i)
254 */
255 case TBR_TT_ATOMIC_SUB:
256 p = (unsigned long *) __frame->gr8;
257 x = __frame->gr9;
258
259 for (;;) {
260 ret = get_user(z, p);
261 if (ret < 0)
262 goto error;
263
264 spin_lock_irq(&atomic_op_lock);
265
266 if (__get_user(z, p) == 0) {
267 y = z - x;
268 if (__put_user(y, p) == 0)
269 goto done2;
270 goto error2;
271 }
272
273 spin_unlock_irq(&atomic_op_lock);
274 }
275
276 /* TIRA gr0,#126
277 * int __atomic_user_add_return(atomic_t *v, int i)
278 */
279 case TBR_TT_ATOMIC_ADD:
280 p = (unsigned long *) __frame->gr8;
281 x = __frame->gr9;
282
283 for (;;) {
284 ret = get_user(z, p);
285 if (ret < 0)
286 goto error;
287
288 spin_lock_irq(&atomic_op_lock);
289
290 if (__get_user(z, p) == 0) {
291 y = z + x;
292 if (__put_user(y, p) == 0)
293 goto done2;
294 goto error2;
295 }
296
297 spin_unlock_irq(&atomic_op_lock);
298 }
299
300 default:
301 BUG();
302 }
303
304 done2:
305 spin_unlock_irq(&atomic_op_lock);
306 done:
307 if (!user_mode(__frame))
308 set_fs(oldfs);
309 __frame->gr5 = z;
310 __frame->gr9 = y;
311 return;
312
313 error2:
314 spin_unlock_irq(&atomic_op_lock);
315 error:
316 if (!user_mode(__frame))
317 set_fs(oldfs);
318 __frame->pc -= 4;
319
320 die_if_kernel("-- Atomic Op Error --\n");
321
322 info.si_signo = SIGSEGV;
323 info.si_code = SEGV_ACCERR;
324 info.si_errno = 0;
325 info.si_addr = (void *) __frame->pc;
326
327 force_sig_info(info.si_signo, &info, current);
328 }
329
330 /*****************************************************************************/
331 /*
332 *
333 */
334 asmlinkage void media_exception(unsigned long msr0, unsigned long msr1)
335 {
336 siginfo_t info;
337
338 die_if_kernel("-- Media Exception --\n"
339 "MSR0 : %08lx\n"
340 "MSR1 : %08lx\n",
341 msr0, msr1);
342
343 info.si_signo = SIGFPE;
344 info.si_code = FPE_MDAOVF;
345 info.si_errno = 0;
346 info.si_addr = (void *) __frame->pc;
347
348 force_sig_info(info.si_signo, &info, current);
349 } /* end media_exception() */
350
351 /*****************************************************************************/
352 /*
353 * instruction or data access exception
354 */
355 asmlinkage void memory_access_exception(unsigned long esr0,
356 unsigned long ear0,
357 unsigned long epcr0)
358 {
359 siginfo_t info;
360
361 #ifdef CONFIG_MMU
362 unsigned long fixup;
363
364 if ((esr0 & ESRx_EC) == ESRx_EC_DATA_ACCESS)
365 if (handle_misalignment(esr0, ear0, epcr0) == 0)
366 return;
367
368 if ((fixup = search_exception_table(__frame->pc)) != 0) {
369 __frame->pc = fixup;
370 return;
371 }
372 #endif
373
374 die_if_kernel("-- Memory Access Exception --\n"
375 "ESR0 : %08lx\n"
376 "EAR0 : %08lx\n"
377 "EPCR0 : %08lx\n",
378 esr0, ear0, epcr0);
379
380 info.si_signo = SIGSEGV;
381 info.si_code = SEGV_ACCERR;
382 info.si_errno = 0;
383 info.si_addr = NULL;
384
385 if ((esr0 & (ESRx_VALID | ESR0_EAV)) == (ESRx_VALID | ESR0_EAV))
386 info.si_addr = (void *) ear0;
387
388 force_sig_info(info.si_signo, &info, current);
389
390 } /* end memory_access_exception() */
391
392 /*****************************************************************************/
393 /*
394 * data access error
395 * - double-word data load from CPU control area (0xFExxxxxx)
396 * - read performed on inactive or self-refreshing SDRAM
397 * - error notification from slave device
398 * - misaligned address
399 * - access to out of bounds memory region
400 * - user mode accessing privileged memory region
401 * - write to R/O memory region
402 */
403 asmlinkage void data_access_error(unsigned long esfr1, unsigned long esr15, unsigned long ear15)
404 {
405 siginfo_t info;
406
407 die_if_kernel("-- Data Access Error --\n"
408 "ESR15 : %08lx\n"
409 "EAR15 : %08lx\n",
410 esr15, ear15);
411
412 info.si_signo = SIGSEGV;
413 info.si_code = SEGV_ACCERR;
414 info.si_errno = 0;
415 info.si_addr = (void *)
416 (((esr15 & (ESRx_VALID|ESR15_EAV)) == (ESRx_VALID|ESR15_EAV)) ? ear15 : 0);
417
418 force_sig_info(info.si_signo, &info, current);
419 } /* end data_access_error() */
420
421 /*****************************************************************************/
422 /*
423 * data store error - should only happen if accessing inactive or self-refreshing SDRAM
424 */
425 asmlinkage void data_store_error(unsigned long esfr1, unsigned long esr15)
426 {
427 die_if_kernel("-- Data Store Error --\n"
428 "ESR15 : %08lx\n",
429 esr15);
430 BUG();
431 } /* end data_store_error() */
432
433 /*****************************************************************************/
434 /*
435 *
436 */
437 asmlinkage void division_exception(unsigned long esfr1, unsigned long esr0, unsigned long isr)
438 {
439 siginfo_t info;
440
441 die_if_kernel("-- Division Exception --\n"
442 "ESR0 : %08lx\n"
443 "ISR : %08lx\n",
444 esr0, isr);
445
446 info.si_signo = SIGFPE;
447 info.si_code = FPE_INTDIV;
448 info.si_errno = 0;
449 info.si_addr = (void *) __frame->pc;
450
451 force_sig_info(info.si_signo, &info, current);
452 } /* end division_exception() */
453
454 /*****************************************************************************/
455 /*
456 *
457 */
458 asmlinkage void compound_exception(unsigned long esfr1,
459 unsigned long esr0, unsigned long esr14, unsigned long esr15,
460 unsigned long msr0, unsigned long msr1)
461 {
462 die_if_kernel("-- Compound Exception --\n"
463 "ESR0 : %08lx\n"
464 "ESR15 : %08lx\n"
465 "ESR15 : %08lx\n"
466 "MSR0 : %08lx\n"
467 "MSR1 : %08lx\n",
468 esr0, esr14, esr15, msr0, msr1);
469 BUG();
470 } /* end compound_exception() */
471
472 /*****************************************************************************/
473 /*
474 * The architecture-independent backtrace generator
475 */
476 void dump_stack(void)
477 {
478 show_stack(NULL, NULL);
479 }
480
481 EXPORT_SYMBOL(dump_stack);
482
483 void show_stack(struct task_struct *task, unsigned long *sp)
484 {
485 }
486
487 void show_trace_task(struct task_struct *tsk)
488 {
489 printk("CONTEXT: stack=0x%lx frame=0x%p LR=0x%lx RET=0x%lx\n",
490 tsk->thread.sp, tsk->thread.frame, tsk->thread.lr, tsk->thread.sched_lr);
491 }
492
493 static const char *regnames[] = {
494 "PSR ", "ISR ", "CCR ", "CCCR",
495 "LR ", "LCR ", "PC ", "_stt",
496 "sys ", "GR8*", "GNE0", "GNE1",
497 "IACH", "IACL",
498 "TBR ", "SP ", "FP ", "GR3 ",
499 "GR4 ", "GR5 ", "GR6 ", "GR7 ",
500 "GR8 ", "GR9 ", "GR10", "GR11",
501 "GR12", "GR13", "GR14", "GR15",
502 "GR16", "GR17", "GR18", "GR19",
503 "GR20", "GR21", "GR22", "GR23",
504 "GR24", "GR25", "GR26", "GR27",
505 "EFRM", "CURR", "GR30", "BFRM"
506 };
507
508 void show_regs(struct pt_regs *regs)
509 {
510 unsigned long *reg;
511 int loop;
512
513 printk("\n");
514
515 printk("Frame: @%08lx [%s]\n",
516 (unsigned long) regs,
517 regs->psr & PSR_S ? "kernel" : "user");
518
519 reg = (unsigned long *) regs;
520 for (loop = 0; loop < NR_PT_REGS; loop++) {
521 printk("%s %08lx", regnames[loop + 0], reg[loop + 0]);
522
523 if (loop == NR_PT_REGS - 1 || loop % 5 == 4)
524 printk("\n");
525 else
526 printk(" | ");
527 }
528
529 printk("Process %s (pid: %d)\n", current->comm, current->pid);
530 }
531
532 void die_if_kernel(const char *str, ...)
533 {
534 char buffer[256];
535 va_list va;
536
537 if (user_mode(__frame))
538 return;
539
540 va_start(va, str);
541 vsprintf(buffer, str, va);
542 va_end(va);
543
544 console_verbose();
545 printk("\n===================================\n");
546 printk("%s\n", buffer);
547 show_backtrace(__frame, 0);
548
549 __break_hijack_kernel_event();
550 do_exit(SIGSEGV);
551 }
552
553 /*****************************************************************************/
554 /*
555 * dump the contents of an exception frame
556 */
557 static void show_backtrace_regs(struct pt_regs *frame)
558 {
559 unsigned long *reg;
560 int loop;
561
562 /* print the registers for this frame */
563 printk("<-- %s Frame: @%p -->\n",
564 frame->psr & PSR_S ? "Kernel Mode" : "User Mode",
565 frame);
566
567 reg = (unsigned long *) frame;
568 for (loop = 0; loop < NR_PT_REGS; loop++) {
569 printk("%s %08lx", regnames[loop + 0], reg[loop + 0]);
570
571 if (loop == NR_PT_REGS - 1 || loop % 5 == 4)
572 printk("\n");
573 else
574 printk(" | ");
575 }
576
577 printk("--------\n");
578 } /* end show_backtrace_regs() */
579
580 /*****************************************************************************/
581 /*
582 * generate a backtrace of the kernel stack
583 */
584 void show_backtrace(struct pt_regs *frame, unsigned long sp)
585 {
586 struct pt_regs *frame0;
587 unsigned long tos = 0, stop = 0, base;
588 int format;
589
590 base = ((((unsigned long) frame) + 8191) & ~8191) - sizeof(struct user_context);
591 frame0 = (struct pt_regs *) base;
592
593 if (sp) {
594 tos = sp;
595 stop = (unsigned long) frame;
596 }
597
598 printk("\nProcess %s (pid: %d)\n\n", current->comm, current->pid);
599
600 for (;;) {
601 /* dump stack segment between frames */
602 //printk("%08lx -> %08lx\n", tos, stop);
603 format = 0;
604 while (tos < stop) {
605 if (format == 0)
606 printk(" %04lx :", tos & 0xffff);
607
608 printk(" %08lx", *(unsigned long *) tos);
609
610 tos += 4;
611 format++;
612 if (format == 8) {
613 printk("\n");
614 format = 0;
615 }
616 }
617
618 if (format > 0)
619 printk("\n");
620
621 /* dump frame 0 outside of the loop */
622 if (frame == frame0)
623 break;
624
625 tos = frame->sp;
626 if (((unsigned long) frame) + sizeof(*frame) != tos) {
627 printk("-- TOS %08lx does not follow frame %p --\n",
628 tos, frame);
629 break;
630 }
631
632 show_backtrace_regs(frame);
633
634 /* dump the stack between this frame and the next */
635 stop = (unsigned long) frame->next_frame;
636 if (stop != base &&
637 (stop < tos ||
638 stop > base ||
639 (stop < base && stop + sizeof(*frame) > base) ||
640 stop & 3)) {
641 printk("-- next_frame %08lx is invalid (range %08lx-%08lx) --\n",
642 stop, tos, base);
643 break;
644 }
645
646 /* move to next frame */
647 frame = frame->next_frame;
648 }
649
650 /* we can always dump frame 0, even if the rest of the stack is corrupt */
651 show_backtrace_regs(frame0);
652
653 } /* end show_backtrace() */
654
655 /*****************************************************************************/
656 /*
657 * initialise traps
658 */
659 void __init trap_init (void)
660 {
661 } /* end trap_init() */
Linux kernel - Deliverables
This page took 0.044851 seconds and 4 git commands to generate.