?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
mm: fix exec activate_mm vs TLB shootdown and lazy tlb switching race
[linux/fpc-iii.git] / arch / frv / kernel / traps.c
blobfb08ebe0dab4273fed42f064db4a4363546e5f37
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/signal.h>
13 #include <linux/sched/debug.h>
14 #include <linux/signal.h>
15 #include <linux/kernel.h>
16 #include <linux/mm.h>
17 #include <linux/types.h>
18 #include <linux/user.h>
19 #include <linux/string.h>
20 #include <linux/linkage.h>
21 #include <linux/init.h>
22 #include <linux/module.h>
23
24 #include <asm/asm-offsets.h>
25 #include <asm/setup.h>
26 #include <asm/fpu.h>
27 #include <linux/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 __user *) ((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 __user *) ((epcr0 & EPCR0_V) ? (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;
115 unsigned long __user *p;
116 mm_segment_t oldfs;
117 siginfo_t info;
118 int ret;
119
120 y = 0;
121 z = 0;
122
123 oldfs = get_fs();
124 if (!user_mode(__frame))
125 set_fs(KERNEL_DS);
126
127 switch (__frame->tbr & TBR_TT) {
128 /* TIRA gr0,#120
129 * u32 __atomic_user_cmpxchg32(u32 *ptr, u32 test, u32 new)
130 */
131 case TBR_TT_ATOMIC_CMPXCHG32:
132 p = (unsigned long __user *) __frame->gr8;
133 x = __frame->gr9;
134 y = __frame->gr10;
135
136 for (;;) {
137 ret = get_user(z, p);
138 if (ret < 0)
139 goto error;
140
141 if (z != x)
142 goto done;
143
144 spin_lock_irq(&atomic_op_lock);
145
146 if (__get_user(z, p) == 0) {
147 if (z != x)
148 goto done2;
149
150 if (__put_user(y, p) == 0)
151 goto done2;
152 goto error2;
153 }
154
155 spin_unlock_irq(&atomic_op_lock);
156 }
157
158 /* TIRA gr0,#121
159 * u32 __atomic_kernel_xchg32(void *v, u32 new)
160 */
161 case TBR_TT_ATOMIC_XCHG32:
162 p = (unsigned long __user *) __frame->gr8;
163 y = __frame->gr9;
164
165 for (;;) {
166 ret = get_user(z, p);
167 if (ret < 0)
168 goto error;
169
170 spin_lock_irq(&atomic_op_lock);
171
172 if (__get_user(z, p) == 0) {
173 if (__put_user(y, p) == 0)
174 goto done2;
175 goto error2;
176 }
177
178 spin_unlock_irq(&atomic_op_lock);
179 }
180
181 /* TIRA gr0,#122
182 * ulong __atomic_kernel_XOR_return(ulong i, ulong *v)
183 */
184 case TBR_TT_ATOMIC_XOR:
185 p = (unsigned long __user *) __frame->gr8;
186 x = __frame->gr9;
187
188 for (;;) {
189 ret = get_user(z, p);
190 if (ret < 0)
191 goto error;
192
193 spin_lock_irq(&atomic_op_lock);
194
195 if (__get_user(z, p) == 0) {
196 y = x ^ z;
197 if (__put_user(y, p) == 0)
198 goto done2;
199 goto error2;
200 }
201
202 spin_unlock_irq(&atomic_op_lock);
203 }
204
205 /* TIRA gr0,#123
206 * ulong __atomic_kernel_OR_return(ulong i, ulong *v)
207 */
208 case TBR_TT_ATOMIC_OR:
209 p = (unsigned long __user *) __frame->gr8;
210 x = __frame->gr9;
211
212 for (;;) {
213 ret = get_user(z, p);
214 if (ret < 0)
215 goto error;
216
217 spin_lock_irq(&atomic_op_lock);
218
219 if (__get_user(z, p) == 0) {
220 y = x ^ z;
221 if (__put_user(y, p) == 0)
222 goto done2;
223 goto error2;
224 }
225
226 spin_unlock_irq(&atomic_op_lock);
227 }
228
229 /* TIRA gr0,#124
230 * ulong __atomic_kernel_AND_return(ulong i, ulong *v)
231 */
232 case TBR_TT_ATOMIC_AND:
233 p = (unsigned long __user *) __frame->gr8;
234 x = __frame->gr9;
235
236 for (;;) {
237 ret = get_user(z, p);
238 if (ret < 0)
239 goto error;
240
241 spin_lock_irq(&atomic_op_lock);
242
243 if (__get_user(z, p) == 0) {
244 y = x & z;
245 if (__put_user(y, p) == 0)
246 goto done2;
247 goto error2;
248 }
249
250 spin_unlock_irq(&atomic_op_lock);
251 }
252
253 /* TIRA gr0,#125
254 * int __atomic_user_sub_return(atomic_t *v, int i)
255 */
256 case TBR_TT_ATOMIC_SUB:
257 p = (unsigned long __user *) __frame->gr8;
258 x = __frame->gr9;
259
260 for (;;) {
261 ret = get_user(z, p);
262 if (ret < 0)
263 goto error;
264
265 spin_lock_irq(&atomic_op_lock);
266
267 if (__get_user(z, p) == 0) {
268 y = z - x;
269 if (__put_user(y, p) == 0)
270 goto done2;
271 goto error2;
272 }
273
274 spin_unlock_irq(&atomic_op_lock);
275 }
276
277 /* TIRA gr0,#126
278 * int __atomic_user_add_return(atomic_t *v, int i)
279 */
280 case TBR_TT_ATOMIC_ADD:
281 p = (unsigned long __user *) __frame->gr8;
282 x = __frame->gr9;
283
284 for (;;) {
285 ret = get_user(z, p);
286 if (ret < 0)
287 goto error;
288
289 spin_lock_irq(&atomic_op_lock);
290
291 if (__get_user(z, p) == 0) {
292 y = z + x;
293 if (__put_user(y, p) == 0)
294 goto done2;
295 goto error2;
296 }
297
298 spin_unlock_irq(&atomic_op_lock);
299 }
300
301 default:
302 BUG();
303 }
304
305 done2:
306 spin_unlock_irq(&atomic_op_lock);
307 done:
308 if (!user_mode(__frame))
309 set_fs(oldfs);
310 __frame->gr5 = z;
311 __frame->gr9 = y;
312 return;
313
314 error2:
315 spin_unlock_irq(&atomic_op_lock);
316 error:
317 if (!user_mode(__frame))
318 set_fs(oldfs);
319 __frame->pc -= 4;
320
321 die_if_kernel("-- Atomic Op Error --\n");
322
323 info.si_signo = SIGSEGV;
324 info.si_code = SEGV_ACCERR;
325 info.si_errno = 0;
326 info.si_addr = (void __user *) __frame->pc;
327
328 force_sig_info(info.si_signo, &info, current);
329 }
330
331 /*****************************************************************************/
332 /*
333 *
334 */
335 asmlinkage void media_exception(unsigned long msr0, unsigned long msr1)
336 {
337 siginfo_t info;
338
339 die_if_kernel("-- Media Exception --\n"
340 "MSR0 : %08lx\n"
341 "MSR1 : %08lx\n",
342 msr0, msr1);
343
344 info.si_signo = SIGFPE;
345 info.si_code = FPE_MDAOVF;
346 info.si_errno = 0;
347 info.si_addr = (void __user *) __frame->pc;
348
349 force_sig_info(info.si_signo, &info, current);
350 } /* end media_exception() */
351
352 /*****************************************************************************/
353 /*
354 * instruction or data access exception
355 */
356 asmlinkage void memory_access_exception(unsigned long esr0,
357 unsigned long ear0,
358 unsigned long epcr0)
359 {
360 siginfo_t info;
361
362 #ifdef CONFIG_MMU
363 if (fixup_exception(__frame))
364 return;
365 #endif
366
367 die_if_kernel("-- Memory Access Exception --\n"
368 "ESR0 : %08lx\n"
369 "EAR0 : %08lx\n"
370 "EPCR0 : %08lx\n",
371 esr0, ear0, epcr0);
372
373 info.si_signo = SIGSEGV;
374 info.si_code = SEGV_ACCERR;
375 info.si_errno = 0;
376 info.si_addr = NULL;
377
378 if ((esr0 & (ESRx_VALID | ESR0_EAV)) == (ESRx_VALID | ESR0_EAV))
379 info.si_addr = (void __user *) ear0;
380
381 force_sig_info(info.si_signo, &info, current);
382
383 } /* end memory_access_exception() */
384
385 /*****************************************************************************/
386 /*
387 * data access error
388 * - double-word data load from CPU control area (0xFExxxxxx)
389 * - read performed on inactive or self-refreshing SDRAM
390 * - error notification from slave device
391 * - misaligned address
392 * - access to out of bounds memory region
393 * - user mode accessing privileged memory region
394 * - write to R/O memory region
395 */
396 asmlinkage void data_access_error(unsigned long esfr1, unsigned long esr15, unsigned long ear15)
397 {
398 siginfo_t info;
399
400 die_if_kernel("-- Data Access Error --\n"
401 "ESR15 : %08lx\n"
402 "EAR15 : %08lx\n",
403 esr15, ear15);
404
405 info.si_signo = SIGSEGV;
406 info.si_code = SEGV_ACCERR;
407 info.si_errno = 0;
408 info.si_addr = (void __user *)
409 (((esr15 & (ESRx_VALID|ESR15_EAV)) == (ESRx_VALID|ESR15_EAV)) ? ear15 : 0);
410
411 force_sig_info(info.si_signo, &info, current);
412 } /* end data_access_error() */
413
414 /*****************************************************************************/
415 /*
416 * data store error - should only happen if accessing inactive or self-refreshing SDRAM
417 */
418 asmlinkage void data_store_error(unsigned long esfr1, unsigned long esr15)
419 {
420 die_if_kernel("-- Data Store Error --\n"
421 "ESR15 : %08lx\n",
422 esr15);
423 BUG();
424 } /* end data_store_error() */
425
426 /*****************************************************************************/
427 /*
428 *
429 */
430 asmlinkage void division_exception(unsigned long esfr1, unsigned long esr0, unsigned long isr)
431 {
432 siginfo_t info;
433
434 die_if_kernel("-- Division Exception --\n"
435 "ESR0 : %08lx\n"
436 "ISR : %08lx\n",
437 esr0, isr);
438
439 info.si_signo = SIGFPE;
440 info.si_code = FPE_INTDIV;
441 info.si_errno = 0;
442 info.si_addr = (void __user *) __frame->pc;
443
444 force_sig_info(info.si_signo, &info, current);
445 } /* end division_exception() */
446
447 /*****************************************************************************/
448 /*
449 *
450 */
451 asmlinkage void compound_exception(unsigned long esfr1,
452 unsigned long esr0, unsigned long esr14, unsigned long esr15,
453 unsigned long msr0, unsigned long msr1)
454 {
455 die_if_kernel("-- Compound Exception --\n"
456 "ESR0 : %08lx\n"
457 "ESR15 : %08lx\n"
458 "ESR15 : %08lx\n"
459 "MSR0 : %08lx\n"
460 "MSR1 : %08lx\n",
461 esr0, esr14, esr15, msr0, msr1);
462 BUG();
463 } /* end compound_exception() */
464
465 void show_stack(struct task_struct *task, unsigned long *sp)
466 {
467 }
468
469 void show_trace_task(struct task_struct *tsk)
470 {
471 printk("CONTEXT: stack=0x%lx frame=0x%p LR=0x%lx RET=0x%lx\n",
472 tsk->thread.sp, tsk->thread.frame, tsk->thread.lr, tsk->thread.sched_lr);
473 }
474
475 static const char *regnames[] = {
476 "PSR ", "ISR ", "CCR ", "CCCR",
477 "LR ", "LCR ", "PC ", "_stt",
478 "sys ", "GR8*", "GNE0", "GNE1",
479 "IACH", "IACL",
480 "TBR ", "SP ", "FP ", "GR3 ",
481 "GR4 ", "GR5 ", "GR6 ", "GR7 ",
482 "GR8 ", "GR9 ", "GR10", "GR11",
483 "GR12", "GR13", "GR14", "GR15",
484 "GR16", "GR17", "GR18", "GR19",
485 "GR20", "GR21", "GR22", "GR23",
486 "GR24", "GR25", "GR26", "GR27",
487 "EFRM", "CURR", "GR30", "BFRM"
488 };
489
490 void show_regs(struct pt_regs *regs)
491 {
492 unsigned long *reg;
493 int loop;
494
495 printk("\n");
496 show_regs_print_info(KERN_DEFAULT);
497
498 printk("Frame: @%08lx [%s]\n",
499 (unsigned long) regs,
500 regs->psr & PSR_S ? "kernel" : "user");
501
502 reg = (unsigned long *) regs;
503 for (loop = 0; loop < NR_PT_REGS; loop++) {
504 printk("%s %08lx", regnames[loop + 0], reg[loop + 0]);
505
506 if (loop == NR_PT_REGS - 1 || loop % 5 == 4)
507 printk("\n");
508 else
509 printk(" | ");
510 }
511 }
512
513 void die_if_kernel(const char *str, ...)
514 {
515 char buffer[256];
516 va_list va;
517
518 if (user_mode(__frame))
519 return;
520
521 va_start(va, str);
522 vsnprintf(buffer, sizeof(buffer), str, va);
523 va_end(va);
524
525 console_verbose();
526 printk("\n===================================\n");
527 printk("%s\n", buffer);
528 show_backtrace(__frame, 0);
529
530 __break_hijack_kernel_event();
531 do_exit(SIGSEGV);
532 }
533
534 /*****************************************************************************/
535 /*
536 * dump the contents of an exception frame
537 */
538 static void show_backtrace_regs(struct pt_regs *frame)
539 {
540 unsigned long *reg;
541 int loop;
542
543 /* print the registers for this frame */
544 printk("<-- %s Frame: @%p -->\n",
545 frame->psr & PSR_S ? "Kernel Mode" : "User Mode",
546 frame);
547
548 reg = (unsigned long *) frame;
549 for (loop = 0; loop < NR_PT_REGS; loop++) {
550 printk("%s %08lx", regnames[loop + 0], reg[loop + 0]);
551
552 if (loop == NR_PT_REGS - 1 || loop % 5 == 4)
553 printk("\n");
554 else
555 printk(" | ");
556 }
557
558 printk("--------\n");
559 } /* end show_backtrace_regs() */
560
561 /*****************************************************************************/
562 /*
563 * generate a backtrace of the kernel stack
564 */
565 void show_backtrace(struct pt_regs *frame, unsigned long sp)
566 {
567 struct pt_regs *frame0;
568 unsigned long tos = 0, stop = 0, base;
569 int format;
570
571 base = ((((unsigned long) frame) + 8191) & ~8191) - sizeof(struct user_context);
572 frame0 = (struct pt_regs *) base;
573
574 if (sp) {
575 tos = sp;
576 stop = (unsigned long) frame;
577 }
578
579 printk("\nProcess %s (pid: %d)\n\n", current->comm, current->pid);
580
581 for (;;) {
582 /* dump stack segment between frames */
583 //printk("%08lx -> %08lx\n", tos, stop);
584 format = 0;
585 while (tos < stop) {
586 if (format == 0)
587 printk(" %04lx :", tos & 0xffff);
588
589 printk(" %08lx", *(unsigned long *) tos);
590
591 tos += 4;
592 format++;
593 if (format == 8) {
594 printk("\n");
595 format = 0;
596 }
597 }
598
599 if (format > 0)
600 printk("\n");
601
602 /* dump frame 0 outside of the loop */
603 if (frame == frame0)
604 break;
605
606 tos = frame->sp;
607 if (((unsigned long) frame) + sizeof(*frame) != tos) {
608 printk("-- TOS %08lx does not follow frame %p --\n",
609 tos, frame);
610 break;
611 }
612
613 show_backtrace_regs(frame);
614
615 /* dump the stack between this frame and the next */
616 stop = (unsigned long) frame->next_frame;
617 if (stop != base &&
618 (stop < tos ||
619 stop > base ||
620 (stop < base && stop + sizeof(*frame) > base) ||
621 stop & 3)) {
622 printk("-- next_frame %08lx is invalid (range %08lx-%08lx) --\n",
623 stop, tos, base);
624 break;
625 }
626
627 /* move to next frame */
628 frame = frame->next_frame;
629 }
630
631 /* we can always dump frame 0, even if the rest of the stack is corrupt */
632 show_backtrace_regs(frame0);
633
634 } /* end show_backtrace() */
635
636 /*****************************************************************************/
637 /*
638 * initialise traps
639 */
640 void __init trap_init (void)
641 {
642 } /* end trap_init() */
Linux with added FPC-III support