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