?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
e1000: For sanity, reformat e1000_set_mac_type(), struct e1000_hw[_stats]
[linux-2.6/verdex.git] / arch / ia64 / kernel / traps.c
blobab684747036fbcf71b6ce464a9561942f982e48d
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 struct fpu_swa_msg {
311 unsigned long count;
312 unsigned long time;
313 };
314 static DEFINE_PER_CPU(struct fpu_swa_msg, cpulast);
315 DECLARE_PER_CPU(struct fpu_swa_msg, cpulast);
316 static struct fpu_swa_msg last __cacheline_aligned;
317
318
319 /*
320 * Handle floating-point assist faults and traps.
321 */
322 static int
323 handle_fpu_swa (int fp_fault, struct pt_regs *regs, unsigned long isr)
324 {
325 long exception, bundle[2];
326 unsigned long fault_ip;
327 struct siginfo siginfo;
328
329 fault_ip = regs->cr_iip;
330 if (!fp_fault && (ia64_psr(regs)->ri == 0))
331 fault_ip -= 16;
332 if (copy_from_user(bundle, (void __user *) fault_ip, sizeof(bundle)))
333 return -1;
334
335 if (!(current->thread.flags & IA64_THREAD_FPEMU_NOPRINT)) {
336 unsigned long count, current_jiffies = jiffies;
337 struct fpu_swa_msg *cp = &__get_cpu_var(cpulast);
338
339 if (unlikely(current_jiffies > cp->time))
340 cp->count = 0;
341 if (unlikely(cp->count < 5)) {
342 cp->count++;
343 cp->time = current_jiffies + 5 * HZ;
344
345 /* minimize races by grabbing a copy of count BEFORE checking last.time. */
346 count = last.count;
347 barrier();
348
349 /*
350 * Lower 4 bits are used as a count. Upper bits are a sequence
351 * number that is updated when count is reset. The cmpxchg will
352 * fail is seqno has changed. This minimizes mutiple cpus
353 * reseting the count.
354 */
355 if (current_jiffies > last.time)
356 (void) cmpxchg_acq(&last.count, count, 16 + (count & ~15));
357
358 /* used fetchadd to atomically update the count */
359 if ((last.count & 15) < 5 && (ia64_fetchadd(1, &last.count, acq) & 15) < 5) {
360 last.time = current_jiffies + 5 * HZ;
361 printk(KERN_WARNING
362 "%s(%d): floating-point assist fault at ip %016lx, isr %016lx\n",
363 current->comm, current->pid, regs->cr_iip + ia64_psr(regs)->ri, isr);
364 }
365 }
366 }
367
368 exception = fp_emulate(fp_fault, bundle, &regs->cr_ipsr, &regs->ar_fpsr, &isr, &regs->pr,
369 &regs->cr_ifs, regs);
370 if (fp_fault) {
371 if (exception == 0) {
372 /* emulation was successful */
373 ia64_increment_ip(regs);
374 } else if (exception == -1) {
375 printk(KERN_ERR "handle_fpu_swa: fp_emulate() returned -1\n");
376 return -1;
377 } else {
378 /* is next instruction a trap? */
379 if (exception & 2) {
380 ia64_increment_ip(regs);
381 }
382 siginfo.si_signo = SIGFPE;
383 siginfo.si_errno = 0;
384 siginfo.si_code = __SI_FAULT; /* default code */
385 siginfo.si_addr = (void __user *) (regs->cr_iip + ia64_psr(regs)->ri);
386 if (isr & 0x11) {
387 siginfo.si_code = FPE_FLTINV;
388 } else if (isr & 0x22) {
389 /* denormal operand gets the same si_code as underflow
390 * see arch/i386/kernel/traps.c:math_error() */
391 siginfo.si_code = FPE_FLTUND;
392 } else if (isr & 0x44) {
393 siginfo.si_code = FPE_FLTDIV;
394 }
395 siginfo.si_isr = isr;
396 siginfo.si_flags = __ISR_VALID;
397 siginfo.si_imm = 0;
398 force_sig_info(SIGFPE, &siginfo, current);
399 }
400 } else {
401 if (exception == -1) {
402 printk(KERN_ERR "handle_fpu_swa: fp_emulate() returned -1\n");
403 return -1;
404 } else if (exception != 0) {
405 /* raise exception */
406 siginfo.si_signo = SIGFPE;
407 siginfo.si_errno = 0;
408 siginfo.si_code = __SI_FAULT; /* default code */
409 siginfo.si_addr = (void __user *) (regs->cr_iip + ia64_psr(regs)->ri);
410 if (isr & 0x880) {
411 siginfo.si_code = FPE_FLTOVF;
412 } else if (isr & 0x1100) {
413 siginfo.si_code = FPE_FLTUND;
414 } else if (isr & 0x2200) {
415 siginfo.si_code = FPE_FLTRES;
416 }
417 siginfo.si_isr = isr;
418 siginfo.si_flags = __ISR_VALID;
419 siginfo.si_imm = 0;
420 force_sig_info(SIGFPE, &siginfo, current);
421 }
422 }
423 return 0;
424 }
425
426 struct illegal_op_return {
427 unsigned long fkt, arg1, arg2, arg3;
428 };
429
430 struct illegal_op_return
431 ia64_illegal_op_fault (unsigned long ec, long arg1, long arg2, long arg3,
432 long arg4, long arg5, long arg6, long arg7,
433 struct pt_regs regs)
434 {
435 struct illegal_op_return rv;
436 struct siginfo si;
437 char buf[128];
438
439 #ifdef CONFIG_IA64_BRL_EMU
440 {
441 extern struct illegal_op_return ia64_emulate_brl (struct pt_regs *, unsigned long);
442
443 rv = ia64_emulate_brl(&regs, ec);
444 if (rv.fkt != (unsigned long) -1)
445 return rv;
446 }
447 #endif
448
449 sprintf(buf, "IA-64 Illegal operation fault");
450 die_if_kernel(buf, &regs, 0);
451
452 memset(&si, 0, sizeof(si));
453 si.si_signo = SIGILL;
454 si.si_code = ILL_ILLOPC;
455 si.si_addr = (void __user *) (regs.cr_iip + ia64_psr(&regs)->ri);
456 force_sig_info(SIGILL, &si, current);
457 rv.fkt = 0;
458 return rv;
459 }
460
461 void __kprobes
462 ia64_fault (unsigned long vector, unsigned long isr, unsigned long ifa,
463 unsigned long iim, unsigned long itir, long arg5, long arg6,
464 long arg7, struct pt_regs regs)
465 {
466 unsigned long code, error = isr, iip;
467 struct siginfo siginfo;
468 char buf[128];
469 int result, sig;
470 static const char *reason[] = {
471 "IA-64 Illegal Operation fault",
472 "IA-64 Privileged Operation fault",
473 "IA-64 Privileged Register fault",
474 "IA-64 Reserved Register/Field fault",
475 "Disabled Instruction Set Transition fault",
476 "Unknown fault 5", "Unknown fault 6", "Unknown fault 7", "Illegal Hazard fault",
477 "Unknown fault 9", "Unknown fault 10", "Unknown fault 11", "Unknown fault 12",
478 "Unknown fault 13", "Unknown fault 14", "Unknown fault 15"
479 };
480
481 if ((isr & IA64_ISR_NA) && ((isr & IA64_ISR_CODE_MASK) == IA64_ISR_CODE_LFETCH)) {
482 /*
483 * This fault was due to lfetch.fault, set "ed" bit in the psr to cancel
484 * the lfetch.
485 */
486 ia64_psr(&regs)->ed = 1;
487 return;
488 }
489
490 iip = regs.cr_iip + ia64_psr(&regs)->ri;
491
492 switch (vector) {
493 case 24: /* General Exception */
494 code = (isr >> 4) & 0xf;
495 sprintf(buf, "General Exception: %s%s", reason[code],
496 (code == 3) ? ((isr & (1UL << 37))
497 ? " (RSE access)" : " (data access)") : "");
498 if (code == 8) {
499 # ifdef CONFIG_IA64_PRINT_HAZARDS
500 printk("%s[%d]: possible hazard @ ip=%016lx (pr = %016lx)\n",
501 current->comm, current->pid,
502 regs.cr_iip + ia64_psr(&regs)->ri, regs.pr);
503 # endif
504 return;
505 }
506 break;
507
508 case 25: /* Disabled FP-Register */
509 if (isr & 2) {
510 disabled_fph_fault(&regs);
511 return;
512 }
513 sprintf(buf, "Disabled FPL fault---not supposed to happen!");
514 break;
515
516 case 26: /* NaT Consumption */
517 if (user_mode(&regs)) {
518 void __user *addr;
519
520 if (((isr >> 4) & 0xf) == 2) {
521 /* NaT page consumption */
522 sig = SIGSEGV;
523 code = SEGV_ACCERR;
524 addr = (void __user *) ifa;
525 } else {
526 /* register NaT consumption */
527 sig = SIGILL;
528 code = ILL_ILLOPN;
529 addr = (void __user *) (regs.cr_iip
530 + ia64_psr(&regs)->ri);
531 }
532 siginfo.si_signo = sig;
533 siginfo.si_code = code;
534 siginfo.si_errno = 0;
535 siginfo.si_addr = addr;
536 siginfo.si_imm = vector;
537 siginfo.si_flags = __ISR_VALID;
538 siginfo.si_isr = isr;
539 force_sig_info(sig, &siginfo, current);
540 return;
541 } else if (ia64_done_with_exception(&regs))
542 return;
543 sprintf(buf, "NaT consumption");
544 break;
545
546 case 31: /* Unsupported Data Reference */
547 if (user_mode(&regs)) {
548 siginfo.si_signo = SIGILL;
549 siginfo.si_code = ILL_ILLOPN;
550 siginfo.si_errno = 0;
551 siginfo.si_addr = (void __user *) iip;
552 siginfo.si_imm = vector;
553 siginfo.si_flags = __ISR_VALID;
554 siginfo.si_isr = isr;
555 force_sig_info(SIGILL, &siginfo, current);
556 return;
557 }
558 sprintf(buf, "Unsupported data reference");
559 break;
560
561 case 29: /* Debug */
562 case 35: /* Taken Branch Trap */
563 case 36: /* Single Step Trap */
564 if (fsys_mode(current, &regs)) {
565 extern char __kernel_syscall_via_break[];
566 /*
567 * Got a trap in fsys-mode: Taken Branch Trap
568 * and Single Step trap need special handling;
569 * Debug trap is ignored (we disable it here
570 * and re-enable it in the lower-privilege trap).
571 */
572 if (unlikely(vector == 29)) {
573 set_thread_flag(TIF_DB_DISABLED);
574 ia64_psr(&regs)->db = 0;
575 ia64_psr(&regs)->lp = 1;
576 return;
577 }
578 /* re-do the system call via break 0x100000: */
579 regs.cr_iip = (unsigned long) __kernel_syscall_via_break;
580 ia64_psr(&regs)->ri = 0;
581 ia64_psr(&regs)->cpl = 3;
582 return;
583 }
584 switch (vector) {
585 case 29:
586 siginfo.si_code = TRAP_HWBKPT;
587 #ifdef CONFIG_ITANIUM
588 /*
589 * Erratum 10 (IFA may contain incorrect address) now has
590 * "NoFix" status. There are no plans for fixing this.
591 */
592 if (ia64_psr(&regs)->is == 0)
593 ifa = regs.cr_iip;
594 #endif
595 break;
596 case 35: siginfo.si_code = TRAP_BRANCH; ifa = 0; break;
597 case 36: siginfo.si_code = TRAP_TRACE; ifa = 0; break;
598 }
599 if (notify_die(DIE_FAULT, "ia64_fault", &regs, vector, siginfo.si_code, SIGTRAP)
600 == NOTIFY_STOP)
601 return;
602 siginfo.si_signo = SIGTRAP;
603 siginfo.si_errno = 0;
604 siginfo.si_addr = (void __user *) ifa;
605 siginfo.si_imm = 0;
606 siginfo.si_flags = __ISR_VALID;
607 siginfo.si_isr = isr;
608 force_sig_info(SIGTRAP, &siginfo, current);
609 return;
610
611 case 32: /* fp fault */
612 case 33: /* fp trap */
613 result = handle_fpu_swa((vector == 32) ? 1 : 0, &regs, isr);
614 if ((result < 0) || (current->thread.flags & IA64_THREAD_FPEMU_SIGFPE)) {
615 siginfo.si_signo = SIGFPE;
616 siginfo.si_errno = 0;
617 siginfo.si_code = FPE_FLTINV;
618 siginfo.si_addr = (void __user *) iip;
619 siginfo.si_flags = __ISR_VALID;
620 siginfo.si_isr = isr;
621 siginfo.si_imm = 0;
622 force_sig_info(SIGFPE, &siginfo, current);
623 }
624 return;
625
626 case 34:
627 if (isr & 0x2) {
628 /* Lower-Privilege Transfer Trap */
629
630 /* If we disabled debug traps during an fsyscall,
631 * re-enable them here.
632 */
633 if (test_thread_flag(TIF_DB_DISABLED)) {
634 clear_thread_flag(TIF_DB_DISABLED);
635 ia64_psr(&regs)->db = 1;
636 }
637
638 /*
639 * Just clear PSR.lp and then return immediately:
640 * all the interesting work (e.g., signal delivery)
641 * is done in the kernel exit path.
642 */
643 ia64_psr(&regs)->lp = 0;
644 return;
645 } else {
646 /* Unimplemented Instr. Address Trap */
647 if (user_mode(&regs)) {
648 siginfo.si_signo = SIGILL;
649 siginfo.si_code = ILL_BADIADDR;
650 siginfo.si_errno = 0;
651 siginfo.si_flags = 0;
652 siginfo.si_isr = 0;
653 siginfo.si_imm = 0;
654 siginfo.si_addr = (void __user *) iip;
655 force_sig_info(SIGILL, &siginfo, current);
656 return;
657 }
658 sprintf(buf, "Unimplemented Instruction Address fault");
659 }
660 break;
661
662 case 45:
663 #ifdef CONFIG_IA32_SUPPORT
664 if (ia32_exception(&regs, isr) == 0)
665 return;
666 #endif
667 printk(KERN_ERR "Unexpected IA-32 exception (Trap 45)\n");
668 printk(KERN_ERR " iip - 0x%lx, ifa - 0x%lx, isr - 0x%lx\n",
669 iip, ifa, isr);
670 force_sig(SIGSEGV, current);
671 break;
672
673 case 46:
674 #ifdef CONFIG_IA32_SUPPORT
675 if (ia32_intercept(&regs, isr) == 0)
676 return;
677 #endif
678 printk(KERN_ERR "Unexpected IA-32 intercept trap (Trap 46)\n");
679 printk(KERN_ERR " iip - 0x%lx, ifa - 0x%lx, isr - 0x%lx, iim - 0x%lx\n",
680 iip, ifa, isr, iim);
681 force_sig(SIGSEGV, current);
682 return;
683
684 case 47:
685 sprintf(buf, "IA-32 Interruption Fault (int 0x%lx)", isr >> 16);
686 break;
687
688 default:
689 sprintf(buf, "Fault %lu", vector);
690 break;
691 }
692 die_if_kernel(buf, &regs, error);
693 force_sig(SIGILL, current);
694 }
Verdex Pro support