?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[MIPS] Discard .exit.text at linktime.
[linux-2.6/linux-loongson.git] / arch / ia64 / kernel / traps.c
blobfffa9e0826bc3b8eab092da56ead23c7349d27b6
1 /*
2 * Architecture-specific trap handling.
3 *
4 * Copyright (C) 1998-2003 Hewlett-Packard Co
5 * David Mosberger-Tang <davidm@hpl.hp.com>
6 *
7 * 05/12/00 grao <goutham.rao@intel.com> : added isr in siginfo for SIGFPE
8 */
9
10 #include <linux/kernel.h>
11 #include <linux/init.h>
12 #include <linux/sched.h>
13 #include <linux/tty.h>
14 #include <linux/vt_kern.h> /* For unblank_screen() */
15 #include <linux/module.h> /* for EXPORT_SYMBOL */
16 #include <linux/hardirq.h>
17 #include <linux/kprobes.h>
18 #include <linux/delay.h> /* for ssleep() */
19
20 #include <asm/fpswa.h>
21 #include <asm/ia32.h>
22 #include <asm/intrinsics.h>
23 #include <asm/processor.h>
24 #include <asm/uaccess.h>
25 #include <asm/kdebug.h>
26
27 extern spinlock_t timerlist_lock;
28
29 fpswa_interface_t *fpswa_interface;
30 EXPORT_SYMBOL(fpswa_interface);
31
32 ATOMIC_NOTIFIER_HEAD(ia64die_chain);
33
34 int
35 register_die_notifier(struct notifier_block *nb)
36 {
37 return atomic_notifier_chain_register(&ia64die_chain, nb);
38 }
39 EXPORT_SYMBOL_GPL(register_die_notifier);
40
41 int
42 unregister_die_notifier(struct notifier_block *nb)
43 {
44 return atomic_notifier_chain_unregister(&ia64die_chain, nb);
45 }
46 EXPORT_SYMBOL_GPL(unregister_die_notifier);
47
48 void __init
49 trap_init (void)
50 {
51 if (ia64_boot_param->fpswa)
52 /* FPSWA fixup: make the interface pointer a kernel virtual address: */
53 fpswa_interface = __va(ia64_boot_param->fpswa);
54 }
55
56 /*
57 * Unlock any spinlocks which will prevent us from getting the message out (timerlist_lock
58 * is acquired through the console unblank code)
59 */
60 void
61 bust_spinlocks (int yes)
62 {
63 int loglevel_save = console_loglevel;
64
65 if (yes) {
66 oops_in_progress = 1;
67 return;
68 }
69
70 #ifdef CONFIG_VT
71 unblank_screen();
72 #endif
73 oops_in_progress = 0;
74 /*
75 * OK, the message is on the console. Now we call printk() without
76 * oops_in_progress set so that printk will give klogd a poke. Hold onto
77 * your hats...
78 */
79 console_loglevel = 15; /* NMI oopser may have shut the console up */
80 printk(" ");
81 console_loglevel = loglevel_save;
82 }
83
84 void
85 die (const char *str, struct pt_regs *regs, long err)
86 {
87 static struct {
88 spinlock_t lock;
89 u32 lock_owner;
90 int lock_owner_depth;
91 } die = {
92 .lock = SPIN_LOCK_UNLOCKED,
93 .lock_owner = -1,
94 .lock_owner_depth = 0
95 };
96 static int die_counter;
97 int cpu = get_cpu();
98
99 if (die.lock_owner != cpu) {
100 console_verbose();
101 spin_lock_irq(&die.lock);
102 die.lock_owner = cpu;
103 die.lock_owner_depth = 0;
104 bust_spinlocks(1);
105 }
106 put_cpu();
107
108 if (++die.lock_owner_depth < 3) {
109 printk("%s[%d]: %s %ld [%d]\n",
110 current->comm, current->pid, str, err, ++die_counter);
111 (void) notify_die(DIE_OOPS, (char *)str, regs, err, 255, SIGSEGV);
112 show_regs(regs);
113 } else
114 printk(KERN_ERR "Recursive die() failure, output suppressed\n");
115
116 bust_spinlocks(0);
117 die.lock_owner = -1;
118 spin_unlock_irq(&die.lock);
119
120 if (panic_on_oops)
121 panic("Fatal exception");
122
123 do_exit(SIGSEGV);
124 }
125
126 void
127 die_if_kernel (char *str, struct pt_regs *regs, long err)
128 {
129 if (!user_mode(regs))
130 die(str, regs, err);
131 }
132
133 void
134 __kprobes ia64_bad_break (unsigned long break_num, struct pt_regs *regs)
135 {
136 siginfo_t siginfo;
137 int sig, code;
138
139 /* SIGILL, SIGFPE, SIGSEGV, and SIGBUS want these field initialized: */
140 siginfo.si_addr = (void __user *) (regs->cr_iip + ia64_psr(regs)->ri);
141 siginfo.si_imm = break_num;
142 siginfo.si_flags = 0; /* clear __ISR_VALID */
143 siginfo.si_isr = 0;
144
145 switch (break_num) {
146 case 0: /* unknown error (used by GCC for __builtin_abort()) */
147 if (notify_die(DIE_BREAK, "break 0", regs, break_num, TRAP_BRKPT, SIGTRAP)
148 == NOTIFY_STOP)
149 return;
150 die_if_kernel("bugcheck!", regs, break_num);
151 sig = SIGILL; code = ILL_ILLOPC;
152 break;
153
154 case 1: /* integer divide by zero */
155 sig = SIGFPE; code = FPE_INTDIV;
156 break;
157
158 case 2: /* integer overflow */
159 sig = SIGFPE; code = FPE_INTOVF;
160 break;
161
162 case 3: /* range check/bounds check */
163 sig = SIGFPE; code = FPE_FLTSUB;
164 break;
165
166 case 4: /* null pointer dereference */
167 sig = SIGSEGV; code = SEGV_MAPERR;
168 break;
169
170 case 5: /* misaligned data */
171 sig = SIGSEGV; code = BUS_ADRALN;
172 break;
173
174 case 6: /* decimal overflow */
175 sig = SIGFPE; code = __FPE_DECOVF;
176 break;
177
178 case 7: /* decimal divide by zero */
179 sig = SIGFPE; code = __FPE_DECDIV;
180 break;
181
182 case 8: /* packed decimal error */
183 sig = SIGFPE; code = __FPE_DECERR;
184 break;
185
186 case 9: /* invalid ASCII digit */
187 sig = SIGFPE; code = __FPE_INVASC;
188 break;
189
190 case 10: /* invalid decimal digit */
191 sig = SIGFPE; code = __FPE_INVDEC;
192 break;
193
194 case 11: /* paragraph stack overflow */
195 sig = SIGSEGV; code = __SEGV_PSTKOVF;
196 break;
197
198 case 0x3f000 ... 0x3ffff: /* bundle-update in progress */
199 sig = SIGILL; code = __ILL_BNDMOD;
200 break;
201
202 default:
203 if (break_num < 0x40000 || break_num > 0x100000)
204 die_if_kernel("Bad break", regs, break_num);
205
206 if (break_num < 0x80000) {
207 sig = SIGILL; code = __ILL_BREAK;
208 } else {
209 if (notify_die(DIE_BREAK, "bad break", regs, break_num, TRAP_BRKPT, SIGTRAP)
210 == NOTIFY_STOP)
211 return;
212 sig = SIGTRAP; code = TRAP_BRKPT;
213 }
214 }
215 siginfo.si_signo = sig;
216 siginfo.si_errno = 0;
217 siginfo.si_code = code;
218 force_sig_info(sig, &siginfo, current);
219 }
220
221 /*
222 * disabled_fph_fault() is called when a user-level process attempts to access f32..f127
223 * and it doesn't own the fp-high register partition. When this happens, we save the
224 * current fph partition in the task_struct of the fpu-owner (if necessary) and then load
225 * the fp-high partition of the current task (if necessary). Note that the kernel has
226 * access to fph by the time we get here, as the IVT's "Disabled FP-Register" handler takes
227 * care of clearing psr.dfh.
228 */
229 static inline void
230 disabled_fph_fault (struct pt_regs *regs)
231 {
232 struct ia64_psr *psr = ia64_psr(regs);
233
234 /* first, grant user-level access to fph partition: */
235 psr->dfh = 0;
236
237 /*
238 * Make sure that no other task gets in on this processor
239 * while we're claiming the FPU
240 */
241 preempt_disable();
242 #ifndef CONFIG_SMP
243 {
244 struct task_struct *fpu_owner
245 = (struct task_struct *)ia64_get_kr(IA64_KR_FPU_OWNER);
246
247 if (ia64_is_local_fpu_owner(current)) {
248 preempt_enable_no_resched();
249 return;
250 }
251
252 if (fpu_owner)
253 ia64_flush_fph(fpu_owner);
254 }
255 #endif /* !CONFIG_SMP */
256 ia64_set_local_fpu_owner(current);
257 if ((current->thread.flags & IA64_THREAD_FPH_VALID) != 0) {
258 __ia64_load_fpu(current->thread.fph);
259 psr->mfh = 0;
260 } else {
261 __ia64_init_fpu();
262 /*
263 * Set mfh because the state in thread.fph does not match the state in
264 * the fph partition.
265 */
266 psr->mfh = 1;
267 }
268 preempt_enable_no_resched();
269 }
270
271 static inline int
272 fp_emulate (int fp_fault, void *bundle, long *ipsr, long *fpsr, long *isr, long *pr, long *ifs,
273 struct pt_regs *regs)
274 {
275 fp_state_t fp_state;
276 fpswa_ret_t ret;
277
278 if (!fpswa_interface)
279 return -1;
280
281 memset(&fp_state, 0, sizeof(fp_state_t));
282
283 /*
284 * compute fp_state. only FP registers f6 - f11 are used by the
285 * kernel, so set those bits in the mask and set the low volatile
286 * pointer to point to these registers.
287 */
288 fp_state.bitmask_low64 = 0xfc0; /* bit6..bit11 */
289
290 fp_state.fp_state_low_volatile = (fp_state_low_volatile_t *) &regs->f6;
291 /*
292 * unsigned long (*EFI_FPSWA) (
293 * unsigned long trap_type,
294 * void *Bundle,
295 * unsigned long *pipsr,
296 * unsigned long *pfsr,
297 * unsigned long *pisr,
298 * unsigned long *ppreds,
299 * unsigned long *pifs,
300 * void *fp_state);
301 */
302 ret = (*fpswa_interface->fpswa)((unsigned long) fp_fault, bundle,
303 (unsigned long *) ipsr, (unsigned long *) fpsr,
304 (unsigned long *) isr, (unsigned long *) pr,
305 (unsigned long *) ifs, &fp_state);
306
307 return ret.status;
308 }
309
310 /*
311 * Handle floating-point assist faults and traps.
312 */
313 static int
314 handle_fpu_swa (int fp_fault, struct pt_regs *regs, unsigned long isr)
315 {
316 long exception, bundle[2];
317 unsigned long fault_ip;
318 struct siginfo siginfo;
319 static int fpu_swa_count = 0;
320 static unsigned long last_time;
321
322 fault_ip = regs->cr_iip;
323 if (!fp_fault && (ia64_psr(regs)->ri == 0))
324 fault_ip -= 16;
325 if (copy_from_user(bundle, (void __user *) fault_ip, sizeof(bundle)))
326 return -1;
327
328 if (jiffies - last_time > 5*HZ)
329 fpu_swa_count = 0;
330 if ((fpu_swa_count < 4) && !(current->thread.flags & IA64_THREAD_FPEMU_NOPRINT)) {
331 last_time = jiffies;
332 ++fpu_swa_count;
333 printk(KERN_WARNING
334 "%s(%d): floating-point assist fault at ip %016lx, isr %016lx\n",
335 current->comm, current->pid, regs->cr_iip + ia64_psr(regs)->ri, isr);
336 }
337
338 exception = fp_emulate(fp_fault, bundle, &regs->cr_ipsr, &regs->ar_fpsr, &isr, &regs->pr,
339 &regs->cr_ifs, regs);
340 if (fp_fault) {
341 if (exception == 0) {
342 /* emulation was successful */
343 ia64_increment_ip(regs);
344 } else if (exception == -1) {
345 printk(KERN_ERR "handle_fpu_swa: fp_emulate() returned -1\n");
346 return -1;
347 } else {
348 /* is next instruction a trap? */
349 if (exception & 2) {
350 ia64_increment_ip(regs);
351 }
352 siginfo.si_signo = SIGFPE;
353 siginfo.si_errno = 0;
354 siginfo.si_code = __SI_FAULT; /* default code */
355 siginfo.si_addr = (void __user *) (regs->cr_iip + ia64_psr(regs)->ri);
356 if (isr & 0x11) {
357 siginfo.si_code = FPE_FLTINV;
358 } else if (isr & 0x22) {
359 /* denormal operand gets the same si_code as underflow
360 * see arch/i386/kernel/traps.c:math_error() */
361 siginfo.si_code = FPE_FLTUND;
362 } else if (isr & 0x44) {
363 siginfo.si_code = FPE_FLTDIV;
364 }
365 siginfo.si_isr = isr;
366 siginfo.si_flags = __ISR_VALID;
367 siginfo.si_imm = 0;
368 force_sig_info(SIGFPE, &siginfo, current);
369 }
370 } else {
371 if (exception == -1) {
372 printk(KERN_ERR "handle_fpu_swa: fp_emulate() returned -1\n");
373 return -1;
374 } else if (exception != 0) {
375 /* raise exception */
376 siginfo.si_signo = SIGFPE;
377 siginfo.si_errno = 0;
378 siginfo.si_code = __SI_FAULT; /* default code */
379 siginfo.si_addr = (void __user *) (regs->cr_iip + ia64_psr(regs)->ri);
380 if (isr & 0x880) {
381 siginfo.si_code = FPE_FLTOVF;
382 } else if (isr & 0x1100) {
383 siginfo.si_code = FPE_FLTUND;
384 } else if (isr & 0x2200) {
385 siginfo.si_code = FPE_FLTRES;
386 }
387 siginfo.si_isr = isr;
388 siginfo.si_flags = __ISR_VALID;
389 siginfo.si_imm = 0;
390 force_sig_info(SIGFPE, &siginfo, current);
391 }
392 }
393 return 0;
394 }
395
396 struct illegal_op_return {
397 unsigned long fkt, arg1, arg2, arg3;
398 };
399
400 struct illegal_op_return
401 ia64_illegal_op_fault (unsigned long ec, long arg1, long arg2, long arg3,
402 long arg4, long arg5, long arg6, long arg7,
403 struct pt_regs regs)
404 {
405 struct illegal_op_return rv;
406 struct siginfo si;
407 char buf[128];
408
409 #ifdef CONFIG_IA64_BRL_EMU
410 {
411 extern struct illegal_op_return ia64_emulate_brl (struct pt_regs *, unsigned long);
412
413 rv = ia64_emulate_brl(&regs, ec);
414 if (rv.fkt != (unsigned long) -1)
415 return rv;
416 }
417 #endif
418
419 sprintf(buf, "IA-64 Illegal operation fault");
420 die_if_kernel(buf, &regs, 0);
421
422 memset(&si, 0, sizeof(si));
423 si.si_signo = SIGILL;
424 si.si_code = ILL_ILLOPC;
425 si.si_addr = (void __user *) (regs.cr_iip + ia64_psr(&regs)->ri);
426 force_sig_info(SIGILL, &si, current);
427 rv.fkt = 0;
428 return rv;
429 }
430
431 void __kprobes
432 ia64_fault (unsigned long vector, unsigned long isr, unsigned long ifa,
433 unsigned long iim, unsigned long itir, long arg5, long arg6,
434 long arg7, struct pt_regs regs)
435 {
436 unsigned long code, error = isr, iip;
437 struct siginfo siginfo;
438 char buf[128];
439 int result, sig;
440 static const char *reason[] = {
441 "IA-64 Illegal Operation fault",
442 "IA-64 Privileged Operation fault",
443 "IA-64 Privileged Register fault",
444 "IA-64 Reserved Register/Field fault",
445 "Disabled Instruction Set Transition fault",
446 "Unknown fault 5", "Unknown fault 6", "Unknown fault 7", "Illegal Hazard fault",
447 "Unknown fault 9", "Unknown fault 10", "Unknown fault 11", "Unknown fault 12",
448 "Unknown fault 13", "Unknown fault 14", "Unknown fault 15"
449 };
450
451 if ((isr & IA64_ISR_NA) && ((isr & IA64_ISR_CODE_MASK) == IA64_ISR_CODE_LFETCH)) {
452 /*
453 * This fault was due to lfetch.fault, set "ed" bit in the psr to cancel
454 * the lfetch.
455 */
456 ia64_psr(&regs)->ed = 1;
457 return;
458 }
459
460 iip = regs.cr_iip + ia64_psr(&regs)->ri;
461
462 switch (vector) {
463 case 24: /* General Exception */
464 code = (isr >> 4) & 0xf;
465 sprintf(buf, "General Exception: %s%s", reason[code],
466 (code == 3) ? ((isr & (1UL << 37))
467 ? " (RSE access)" : " (data access)") : "");
468 if (code == 8) {
469 # ifdef CONFIG_IA64_PRINT_HAZARDS
470 printk("%s[%d]: possible hazard @ ip=%016lx (pr = %016lx)\n",
471 current->comm, current->pid,
472 regs.cr_iip + ia64_psr(&regs)->ri, regs.pr);
473 # endif
474 return;
475 }
476 break;
477
478 case 25: /* Disabled FP-Register */
479 if (isr & 2) {
480 disabled_fph_fault(&regs);
481 return;
482 }
483 sprintf(buf, "Disabled FPL fault---not supposed to happen!");
484 break;
485
486 case 26: /* NaT Consumption */
487 if (user_mode(&regs)) {
488 void __user *addr;
489
490 if (((isr >> 4) & 0xf) == 2) {
491 /* NaT page consumption */
492 sig = SIGSEGV;
493 code = SEGV_ACCERR;
494 addr = (void __user *) ifa;
495 } else {
496 /* register NaT consumption */
497 sig = SIGILL;
498 code = ILL_ILLOPN;
499 addr = (void __user *) (regs.cr_iip
500 + ia64_psr(&regs)->ri);
501 }
502 siginfo.si_signo = sig;
503 siginfo.si_code = code;
504 siginfo.si_errno = 0;
505 siginfo.si_addr = addr;
506 siginfo.si_imm = vector;
507 siginfo.si_flags = __ISR_VALID;
508 siginfo.si_isr = isr;
509 force_sig_info(sig, &siginfo, current);
510 return;
511 } else if (ia64_done_with_exception(&regs))
512 return;
513 sprintf(buf, "NaT consumption");
514 break;
515
516 case 31: /* Unsupported Data Reference */
517 if (user_mode(&regs)) {
518 siginfo.si_signo = SIGILL;
519 siginfo.si_code = ILL_ILLOPN;
520 siginfo.si_errno = 0;
521 siginfo.si_addr = (void __user *) iip;
522 siginfo.si_imm = vector;
523 siginfo.si_flags = __ISR_VALID;
524 siginfo.si_isr = isr;
525 force_sig_info(SIGILL, &siginfo, current);
526 return;
527 }
528 sprintf(buf, "Unsupported data reference");
529 break;
530
531 case 29: /* Debug */
532 case 35: /* Taken Branch Trap */
533 case 36: /* Single Step Trap */
534 if (fsys_mode(current, &regs)) {
535 extern char __kernel_syscall_via_break[];
536 /*
537 * Got a trap in fsys-mode: Taken Branch Trap
538 * and Single Step trap need special handling;
539 * Debug trap is ignored (we disable it here
540 * and re-enable it in the lower-privilege trap).
541 */
542 if (unlikely(vector == 29)) {
543 set_thread_flag(TIF_DB_DISABLED);
544 ia64_psr(&regs)->db = 0;
545 ia64_psr(&regs)->lp = 1;
546 return;
547 }
548 /* re-do the system call via break 0x100000: */
549 regs.cr_iip = (unsigned long) __kernel_syscall_via_break;
550 ia64_psr(&regs)->ri = 0;
551 ia64_psr(&regs)->cpl = 3;
552 return;
553 }
554 switch (vector) {
555 case 29:
556 siginfo.si_code = TRAP_HWBKPT;
557 #ifdef CONFIG_ITANIUM
558 /*
559 * Erratum 10 (IFA may contain incorrect address) now has
560 * "NoFix" status. There are no plans for fixing this.
561 */
562 if (ia64_psr(&regs)->is == 0)
563 ifa = regs.cr_iip;
564 #endif
565 break;
566 case 35: siginfo.si_code = TRAP_BRANCH; ifa = 0; break;
567 case 36: siginfo.si_code = TRAP_TRACE; ifa = 0; break;
568 }
569 if (notify_die(DIE_FAULT, "ia64_fault", &regs, vector, siginfo.si_code, SIGTRAP)
570 == NOTIFY_STOP)
571 return;
572 siginfo.si_signo = SIGTRAP;
573 siginfo.si_errno = 0;
574 siginfo.si_addr = (void __user *) ifa;
575 siginfo.si_imm = 0;
576 siginfo.si_flags = __ISR_VALID;
577 siginfo.si_isr = isr;
578 force_sig_info(SIGTRAP, &siginfo, current);
579 return;
580
581 case 32: /* fp fault */
582 case 33: /* fp trap */
583 result = handle_fpu_swa((vector == 32) ? 1 : 0, &regs, isr);
584 if ((result < 0) || (current->thread.flags & IA64_THREAD_FPEMU_SIGFPE)) {
585 siginfo.si_signo = SIGFPE;
586 siginfo.si_errno = 0;
587 siginfo.si_code = FPE_FLTINV;
588 siginfo.si_addr = (void __user *) iip;
589 siginfo.si_flags = __ISR_VALID;
590 siginfo.si_isr = isr;
591 siginfo.si_imm = 0;
592 force_sig_info(SIGFPE, &siginfo, current);
593 }
594 return;
595
596 case 34:
597 if (isr & 0x2) {
598 /* Lower-Privilege Transfer Trap */
599
600 /* If we disabled debug traps during an fsyscall,
601 * re-enable them here.
602 */
603 if (test_thread_flag(TIF_DB_DISABLED)) {
604 clear_thread_flag(TIF_DB_DISABLED);
605 ia64_psr(&regs)->db = 1;
606 }
607
608 /*
609 * Just clear PSR.lp and then return immediately:
610 * all the interesting work (e.g., signal delivery)
611 * is done in the kernel exit path.
612 */
613 ia64_psr(&regs)->lp = 0;
614 return;
615 } else {
616 /* Unimplemented Instr. Address Trap */
617 if (user_mode(&regs)) {
618 siginfo.si_signo = SIGILL;
619 siginfo.si_code = ILL_BADIADDR;
620 siginfo.si_errno = 0;
621 siginfo.si_flags = 0;
622 siginfo.si_isr = 0;
623 siginfo.si_imm = 0;
624 siginfo.si_addr = (void __user *) iip;
625 force_sig_info(SIGILL, &siginfo, current);
626 return;
627 }
628 sprintf(buf, "Unimplemented Instruction Address fault");
629 }
630 break;
631
632 case 45:
633 #ifdef CONFIG_IA32_SUPPORT
634 if (ia32_exception(&regs, isr) == 0)
635 return;
636 #endif
637 printk(KERN_ERR "Unexpected IA-32 exception (Trap 45)\n");
638 printk(KERN_ERR " iip - 0x%lx, ifa - 0x%lx, isr - 0x%lx\n",
639 iip, ifa, isr);
640 force_sig(SIGSEGV, current);
641 break;
642
643 case 46:
644 #ifdef CONFIG_IA32_SUPPORT
645 if (ia32_intercept(&regs, isr) == 0)
646 return;
647 #endif
648 printk(KERN_ERR "Unexpected IA-32 intercept trap (Trap 46)\n");
649 printk(KERN_ERR " iip - 0x%lx, ifa - 0x%lx, isr - 0x%lx, iim - 0x%lx\n",
650 iip, ifa, isr, iim);
651 force_sig(SIGSEGV, current);
652 return;
653
654 case 47:
655 sprintf(buf, "IA-32 Interruption Fault (int 0x%lx)", isr >> 16);
656 break;
657
658 default:
659 sprintf(buf, "Fault %lu", vector);
660 break;
661 }
662 die_if_kernel(buf, &regs, error);
663 force_sig(SIGILL, current);
664 }
linux kernel for loongson