git.oblomov.eu Git - linux-2.6/blob - 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: panic_on_oops");
 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 }