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