ab684747036fbcf71b6ce464a9561942f982e48d
[linux-2.6.git] / arch / ia64 / kernel / traps.c
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 }