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 #include <linux/kdebug.h>
  20 #include <linux/uaccess.h>
  21
  22 #include <asm/fpswa.h>
  23 #include <asm/intrinsics.h>
  24 #include <asm/processor.h>
  25 #include <asm/exception.h>
  26 #include <asm/setup.h>
  27
  28 fpswa_interface_t *fpswa_interface;
  29 EXPORT_SYMBOL(fpswa_interface);
  30
  31 void __init
  32 trap_init (void)
  33 {
  34         if (ia64_boot_param->fpswa)
  35                 /* FPSWA fixup: make the interface pointer a kernel virtual address: */
  36                 fpswa_interface = __va(ia64_boot_param->fpswa);
  37 }
  38
  39 int
  40 die (const char *str, struct pt_regs *regs, long err)
  41 {
  42         static struct {
  43                 spinlock_t lock;
  44                 u32 lock_owner;
  45                 int lock_owner_depth;
  46         } die = {
  47                 .lock = __SPIN_LOCK_UNLOCKED(die.lock),
  48                 .lock_owner = -1,
  49                 .lock_owner_depth = 0
  50         };
  51         static int die_counter;
  52         int cpu = get_cpu();
  53
  54         if (die.lock_owner != cpu) {
  55                 console_verbose();
  56                 spin_lock_irq(&die.lock);
  57                 die.lock_owner = cpu;
  58                 die.lock_owner_depth = 0;
  59                 bust_spinlocks(1);
  60         }
  61         put_cpu();
  62
  63         if (++die.lock_owner_depth < 3) {
  64                 printk("%s[%d]: %s %ld [%d]\n",
  65                 current->comm, task_pid_nr(current), str, err, ++die_counter);
  66                 if (notify_die(DIE_OOPS, str, regs, err, 255, SIGSEGV)
  67                     != NOTIFY_STOP)
  68                         show_regs(regs);
  69                 else
  70                         regs = NULL;
  71         } else
  72                 printk(KERN_ERR "Recursive die() failure, output suppressed\n");
  73
  74         bust_spinlocks(0);
  75         die.lock_owner = -1;
  76         add_taint(TAINT_DIE, LOCKDEP_NOW_UNRELIABLE);
  77         spin_unlock_irq(&die.lock);
  78
  79         if (!regs)
  80                 return 1;
  81
  82         if (panic_on_oops)
  83                 panic("Fatal exception");
  84
  85         do_exit(SIGSEGV);
  86         return 0;
  87 }
  88
  89 int
  90 die_if_kernel (char *str, struct pt_regs *regs, long err)
  91 {
  92         if (!user_mode(regs))
  93                 return die(str, regs, err);
  94         return 0;
  95 }
  96
  97 void
  98 __kprobes ia64_bad_break (unsigned long break_num, struct pt_regs *regs)
  99 {
 100         siginfo_t siginfo;
 101         int sig, code;
 102
 103         /* SIGILL, SIGFPE, SIGSEGV, and SIGBUS want these field initialized: */
 104         siginfo.si_addr = (void __user *) (regs->cr_iip + ia64_psr(regs)->ri);
 105         siginfo.si_imm = break_num;
 106         siginfo.si_flags = 0;           /* clear __ISR_VALID */
 107         siginfo.si_isr = 0;
 108
 109         switch (break_num) {
 110               case 0: /* unknown error (used by GCC for __builtin_abort()) */
 111                 if (notify_die(DIE_BREAK, "break 0", regs, break_num, TRAP_BRKPT, SIGTRAP)
 112                                 == NOTIFY_STOP)
 113                         return;
 114                 if (die_if_kernel("bugcheck!", regs, break_num))
 115                         return;
 116                 sig = SIGILL; code = ILL_ILLOPC;
 117                 break;
 118
 119               case 1: /* integer divide by zero */
 120                 sig = SIGFPE; code = FPE_INTDIV;
 121                 break;
 122
 123               case 2: /* integer overflow */
 124                 sig = SIGFPE; code = FPE_INTOVF;
 125                 break;
 126
 127               case 3: /* range check/bounds check */
 128                 sig = SIGFPE; code = FPE_FLTSUB;
 129                 break;
 130
 131               case 4: /* null pointer dereference */
 132                 sig = SIGSEGV; code = SEGV_MAPERR;
 133                 break;
 134
 135               case 5: /* misaligned data */
 136                 sig = SIGSEGV; code = BUS_ADRALN;
 137                 break;
 138
 139               case 6: /* decimal overflow */
 140                 sig = SIGFPE; code = __FPE_DECOVF;
 141                 break;
 142
 143               case 7: /* decimal divide by zero */
 144                 sig = SIGFPE; code = __FPE_DECDIV;
 145                 break;
 146
 147               case 8: /* packed decimal error */
 148                 sig = SIGFPE; code = __FPE_DECERR;
 149                 break;
 150
 151               case 9: /* invalid ASCII digit */
 152                 sig = SIGFPE; code = __FPE_INVASC;
 153                 break;
 154
 155               case 10: /* invalid decimal digit */
 156                 sig = SIGFPE; code = __FPE_INVDEC;
 157                 break;
 158
 159               case 11: /* paragraph stack overflow */
 160                 sig = SIGSEGV; code = __SEGV_PSTKOVF;
 161                 break;
 162
 163               case 0x3f000 ... 0x3ffff: /* bundle-update in progress */
 164                 sig = SIGILL; code = __ILL_BNDMOD;
 165                 break;
 166
 167               default:
 168                 if ((break_num < 0x40000 || break_num > 0x100000)
 169                     && die_if_kernel("Bad break", regs, break_num))
 170                         return;
 171
 172                 if (break_num < 0x80000) {
 173                         sig = SIGILL; code = __ILL_BREAK;
 174                 } else {
 175                         if (notify_die(DIE_BREAK, "bad break", regs, break_num, TRAP_BRKPT, SIGTRAP)
 176                                         == NOTIFY_STOP)
 177                                 return;
 178                         sig = SIGTRAP; code = TRAP_BRKPT;
 179                 }
 180         }
 181         siginfo.si_signo = sig;
 182         siginfo.si_errno = 0;
 183         siginfo.si_code = code;
 184         force_sig_info(sig, &siginfo, current);
 185 }
 186
 187 /*
 188  * disabled_fph_fault() is called when a user-level process attempts to access f32..f127
 189  * and it doesn't own the fp-high register partition.  When this happens, we save the
 190  * current fph partition in the task_struct of the fpu-owner (if necessary) and then load
 191  * the fp-high partition of the current task (if necessary).  Note that the kernel has
 192  * access to fph by the time we get here, as the IVT's "Disabled FP-Register" handler takes
 193  * care of clearing psr.dfh.
 194  */
 195 static inline void
 196 disabled_fph_fault (struct pt_regs *regs)
 197 {
 198         struct ia64_psr *psr = ia64_psr(regs);
 199
 200         /* first, grant user-level access to fph partition: */
 201         psr->dfh = 0;
 202
 203         /*
 204          * Make sure that no other task gets in on this processor
 205          * while we're claiming the FPU
 206          */
 207         preempt_disable();
 208 #ifndef CONFIG_SMP
 209         {
 210                 struct task_struct *fpu_owner
 211                         = (struct task_struct *)ia64_get_kr(IA64_KR_FPU_OWNER);
 212
 213                 if (ia64_is_local_fpu_owner(current)) {
 214                         preempt_enable_no_resched();
 215                         return;
 216                 }
 217
 218                 if (fpu_owner)
 219                         ia64_flush_fph(fpu_owner);
 220         }
 221 #endif /* !CONFIG_SMP */
 222         ia64_set_local_fpu_owner(current);
 223         if ((current->thread.flags & IA64_THREAD_FPH_VALID) != 0) {
 224                 __ia64_load_fpu(current->thread.fph);
 225                 psr->mfh = 0;
 226         } else {
 227                 __ia64_init_fpu();
 228                 /*
 229                  * Set mfh because the state in thread.fph does not match the state in
 230                  * the fph partition.
 231                  */
 232                 psr->mfh = 1;
 233         }
 234         preempt_enable_no_resched();
 235 }
 236
 237 static inline int
 238 fp_emulate (int fp_fault, void *bundle, long *ipsr, long *fpsr, long *isr, long *pr, long *ifs,
 239             struct pt_regs *regs)
 240 {
 241         fp_state_t fp_state;
 242         fpswa_ret_t ret;
 243
 244         if (!fpswa_interface)
 245                 return -1;
 246
 247         memset(&fp_state, 0, sizeof(fp_state_t));
 248
 249         /*
 250          * compute fp_state.  only FP registers f6 - f11 are used by the
 251          * kernel, so set those bits in the mask and set the low volatile
 252          * pointer to point to these registers.
 253          */
 254         fp_state.bitmask_low64 = 0xfc0;  /* bit6..bit11 */
 255
 256         fp_state.fp_state_low_volatile = (fp_state_low_volatile_t *) &regs->f6;
 257         /*
 258          * unsigned long (*EFI_FPSWA) (
 259          *      unsigned long    trap_type,
 260          *      void             *Bundle,
 261          *      unsigned long    *pipsr,
 262          *      unsigned long    *pfsr,
 263          *      unsigned long    *pisr,
 264          *      unsigned long    *ppreds,
 265          *      unsigned long    *pifs,
 266          *      void             *fp_state);
 267          */
 268         ret = (*fpswa_interface->fpswa)((unsigned long) fp_fault, bundle,
 269                                         (unsigned long *) ipsr, (unsigned long *) fpsr,
 270                                         (unsigned long *) isr, (unsigned long *) pr,
 271                                         (unsigned long *) ifs, &fp_state);
 272
 273         return ret.status;
 274 }
 275
 276 struct fpu_swa_msg {
 277         unsigned long count;
 278         unsigned long time;
 279 };
 280 static DEFINE_PER_CPU(struct fpu_swa_msg, cpulast);
 281 DECLARE_PER_CPU(struct fpu_swa_msg, cpulast);
 282 static struct fpu_swa_msg last __cacheline_aligned;
 283
 284
 285 /*
 286  * Handle floating-point assist faults and traps.
 287  */
 288 static int
 289 handle_fpu_swa (int fp_fault, struct pt_regs *regs, unsigned long isr)
 290 {
 291         long exception, bundle[2];
 292         unsigned long fault_ip;
 293         struct siginfo siginfo;
 294
 295         fault_ip = regs->cr_iip;
 296         if (!fp_fault && (ia64_psr(regs)->ri == 0))
 297                 fault_ip -= 16;
 298         if (copy_from_user(bundle, (void __user *) fault_ip, sizeof(bundle)))
 299                 return -1;
 300
 301         if (!(current->thread.flags & IA64_THREAD_FPEMU_NOPRINT))  {
 302                 unsigned long count, current_jiffies = jiffies;
 303                 struct fpu_swa_msg *cp = this_cpu_ptr(&cpulast);
 304
 305                 if (unlikely(current_jiffies > cp->time))
 306                         cp->count = 0;
 307                 if (unlikely(cp->count < 5)) {
 308                         cp->count++;
 309                         cp->time = current_jiffies + 5 * HZ;
 310
 311                         /* minimize races by grabbing a copy of count BEFORE checking last.time. */
 312                         count = last.count;
 313                         barrier();
 314
 315                         /*
 316                          * Lower 4 bits are used as a count. Upper bits are a sequence
 317                          * number that is updated when count is reset. The cmpxchg will
 318                          * fail is seqno has changed. This minimizes mutiple cpus
 319                          * resetting the count.
 320                          */
 321                         if (current_jiffies > last.time)
 322                                 (void) cmpxchg_acq(&last.count, count, 16 + (count & ~15));
 323
 324                         /* used fetchadd to atomically update the count */
 325                         if ((last.count & 15) < 5 && (ia64_fetchadd(1, &last.count, acq) & 15) < 5) {
 326                                 last.time = current_jiffies + 5 * HZ;
 327                                 printk(KERN_WARNING
 328                                         "%s(%d): floating-point assist fault at ip %016lx, isr %016lx\n",
 329                                         current->comm, task_pid_nr(current), regs->cr_iip + ia64_psr(regs)->ri, isr);
 330                         }
 331                 }
 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         rv.fkt = 0;
 417         if (die_if_kernel(buf, &regs, 0))
 418                 return rv;
 419
 420         memset(&si, 0, sizeof(si));
 421         si.si_signo = SIGILL;
 422         si.si_code = ILL_ILLOPC;
 423         si.si_addr = (void __user *) (regs.cr_iip + ia64_psr(&regs)->ri);
 424         force_sig_info(SIGILL, &si, current);
 425         return rv;
 426 }
 427
 428 void __kprobes
 429 ia64_fault (unsigned long vector, unsigned long isr, unsigned long ifa,
 430             unsigned long iim, unsigned long itir, long arg5, long arg6,
 431             long arg7, struct pt_regs regs)
 432 {
 433         unsigned long code, error = isr, iip;
 434         struct siginfo siginfo;
 435         char buf[128];
 436         int result, sig;
 437         static const char *reason[] = {
 438                 "IA-64 Illegal Operation fault",
 439                 "IA-64 Privileged Operation fault",
 440                 "IA-64 Privileged Register fault",
 441                 "IA-64 Reserved Register/Field fault",
 442                 "Disabled Instruction Set Transition fault",
 443                 "Unknown fault 5", "Unknown fault 6", "Unknown fault 7", "Illegal Hazard fault",
 444                 "Unknown fault 9", "Unknown fault 10", "Unknown fault 11", "Unknown fault 12",
 445                 "Unknown fault 13", "Unknown fault 14", "Unknown fault 15"
 446         };
 447
 448         if ((isr & IA64_ISR_NA) && ((isr & IA64_ISR_CODE_MASK) == IA64_ISR_CODE_LFETCH)) {
 449                 /*
 450                  * This fault was due to lfetch.fault, set "ed" bit in the psr to cancel
 451                  * the lfetch.
 452                  */
 453                 ia64_psr(&regs)->ed = 1;
 454                 return;
 455         }
 456
 457         iip = regs.cr_iip + ia64_psr(&regs)->ri;
 458
 459         switch (vector) {
 460               case 24: /* General Exception */
 461                 code = (isr >> 4) & 0xf;
 462                 sprintf(buf, "General Exception: %s%s", reason[code],
 463                         (code == 3) ? ((isr & (1UL << 37))
 464                                        ? " (RSE access)" : " (data access)") : "");
 465                 if (code == 8) {
 466 # ifdef CONFIG_IA64_PRINT_HAZARDS
 467                         printk("%s[%d]: possible hazard @ ip=%016lx (pr = %016lx)\n",
 468                                current->comm, task_pid_nr(current),
 469                                regs.cr_iip + ia64_psr(&regs)->ri, regs.pr);
 470 # endif
 471                         return;
 472                 }
 473                 break;
 474
 475               case 25: /* Disabled FP-Register */
 476                 if (isr & 2) {
 477                         disabled_fph_fault(&regs);
 478                         return;
 479                 }
 480                 sprintf(buf, "Disabled FPL fault---not supposed to happen!");
 481                 break;
 482
 483               case 26: /* NaT Consumption */
 484                 if (user_mode(&regs)) {
 485                         void __user *addr;
 486
 487                         if (((isr >> 4) & 0xf) == 2) {
 488                                 /* NaT page consumption */
 489                                 sig = SIGSEGV;
 490                                 code = SEGV_ACCERR;
 491                                 addr = (void __user *) ifa;
 492                         } else {
 493                                 /* register NaT consumption */
 494                                 sig = SIGILL;
 495                                 code = ILL_ILLOPN;
 496                                 addr = (void __user *) (regs.cr_iip
 497                                                         + ia64_psr(&regs)->ri);
 498                         }
 499                         siginfo.si_signo = sig;
 500                         siginfo.si_code = code;
 501                         siginfo.si_errno = 0;
 502                         siginfo.si_addr = addr;
 503                         siginfo.si_imm = vector;
 504                         siginfo.si_flags = __ISR_VALID;
 505                         siginfo.si_isr = isr;
 506                         force_sig_info(sig, &siginfo, current);
 507                         return;
 508                 } else if (ia64_done_with_exception(&regs))
 509                         return;
 510                 sprintf(buf, "NaT consumption");
 511                 break;
 512
 513               case 31: /* Unsupported Data Reference */
 514                 if (user_mode(&regs)) {
 515                         siginfo.si_signo = SIGILL;
 516                         siginfo.si_code = ILL_ILLOPN;
 517                         siginfo.si_errno = 0;
 518                         siginfo.si_addr = (void __user *) iip;
 519                         siginfo.si_imm = vector;
 520                         siginfo.si_flags = __ISR_VALID;
 521                         siginfo.si_isr = isr;
 522                         force_sig_info(SIGILL, &siginfo, current);
 523                         return;
 524                 }
 525                 sprintf(buf, "Unsupported data reference");
 526                 break;
 527
 528               case 29: /* Debug */
 529               case 35: /* Taken Branch Trap */
 530               case 36: /* Single Step Trap */
 531                 if (fsys_mode(current, &regs)) {
 532                         extern char __kernel_syscall_via_break[];
 533                         /*
 534                          * Got a trap in fsys-mode: Taken Branch Trap
 535                          * and Single Step trap need special handling;
 536                          * Debug trap is ignored (we disable it here
 537                          * and re-enable it in the lower-privilege trap).
 538                          */
 539                         if (unlikely(vector == 29)) {
 540                                 set_thread_flag(TIF_DB_DISABLED);
 541                                 ia64_psr(&regs)->db = 0;
 542                                 ia64_psr(&regs)->lp = 1;
 543                                 return;
 544                         }
 545                         /* re-do the system call via break 0x100000: */
 546                         regs.cr_iip = (unsigned long) __kernel_syscall_via_break;
 547                         ia64_psr(&regs)->ri = 0;
 548                         ia64_psr(&regs)->cpl = 3;
 549                         return;
 550                 }
 551                 switch (vector) {
 552                       default:
 553                       case 29:
 554                         siginfo.si_code = TRAP_HWBKPT;
 555 #ifdef CONFIG_ITANIUM
 556                         /*
 557                          * Erratum 10 (IFA may contain incorrect address) now has
 558                          * "NoFix" status.  There are no plans for fixing this.
 559                          */
 560                         if (ia64_psr(&regs)->is == 0)
 561                           ifa = regs.cr_iip;
 562 #endif
 563                         break;
 564                       case 35: siginfo.si_code = TRAP_BRANCH; ifa = 0; break;
 565                       case 36: siginfo.si_code = TRAP_TRACE; ifa = 0; break;
 566                 }
 567                 if (notify_die(DIE_FAULT, "ia64_fault", &regs, vector, siginfo.si_code, SIGTRAP)
 568                                 == NOTIFY_STOP)
 569                         return;
 570                 siginfo.si_signo = SIGTRAP;
 571                 siginfo.si_errno = 0;
 572                 siginfo.si_addr  = (void __user *) ifa;
 573                 siginfo.si_imm   = 0;
 574                 siginfo.si_flags = __ISR_VALID;
 575                 siginfo.si_isr   = isr;
 576                 force_sig_info(SIGTRAP, &siginfo, current);
 577                 return;
 578
 579               case 32: /* fp fault */
 580               case 33: /* fp trap */
 581                 result = handle_fpu_swa((vector == 32) ? 1 : 0, &regs, isr);
 582                 if ((result < 0) || (current->thread.flags & IA64_THREAD_FPEMU_SIGFPE)) {
 583                         siginfo.si_signo = SIGFPE;
 584                         siginfo.si_errno = 0;
 585                         siginfo.si_code = FPE_FLTINV;
 586                         siginfo.si_addr = (void __user *) iip;
 587                         siginfo.si_flags = __ISR_VALID;
 588                         siginfo.si_isr = isr;
 589                         siginfo.si_imm = 0;
 590                         force_sig_info(SIGFPE, &siginfo, current);
 591                 }
 592                 return;
 593
 594               case 34:
 595                 if (isr & 0x2) {
 596                         /* Lower-Privilege Transfer Trap */
 597
 598                         /* If we disabled debug traps during an fsyscall,
 599                          * re-enable them here.
 600                          */
 601                         if (test_thread_flag(TIF_DB_DISABLED)) {
 602                                 clear_thread_flag(TIF_DB_DISABLED);
 603                                 ia64_psr(&regs)->db = 1;
 604                         }
 605
 606                         /*
 607                          * Just clear PSR.lp and then return immediately:
 608                          * all the interesting work (e.g., signal delivery)
 609                          * is done in the kernel exit path.
 610                          */
 611                         ia64_psr(&regs)->lp = 0;
 612                         return;
 613                 } else {
 614                         /* Unimplemented Instr. Address Trap */
 615                         if (user_mode(&regs)) {
 616                                 siginfo.si_signo = SIGILL;
 617                                 siginfo.si_code = ILL_BADIADDR;
 618                                 siginfo.si_errno = 0;
 619                                 siginfo.si_flags = 0;
 620                                 siginfo.si_isr = 0;
 621                                 siginfo.si_imm = 0;
 622                                 siginfo.si_addr = (void __user *) iip;
 623                                 force_sig_info(SIGILL, &siginfo, current);
 624                                 return;
 625                         }
 626                         sprintf(buf, "Unimplemented Instruction Address fault");
 627                 }
 628                 break;
 629
 630               case 45:
 631                 printk(KERN_ERR "Unexpected IA-32 exception (Trap 45)\n");
 632                 printk(KERN_ERR "  iip - 0x%lx, ifa - 0x%lx, isr - 0x%lx\n",
 633                        iip, ifa, isr);
 634                 force_sig(SIGSEGV, current);
 635                 return;
 636
 637               case 46:
 638                 printk(KERN_ERR "Unexpected IA-32 intercept trap (Trap 46)\n");
 639                 printk(KERN_ERR "  iip - 0x%lx, ifa - 0x%lx, isr - 0x%lx, iim - 0x%lx\n",
 640                        iip, ifa, isr, iim);
 641                 force_sig(SIGSEGV, current);
 642                 return;
 643
 644               case 47:
 645                 sprintf(buf, "IA-32 Interruption Fault (int 0x%lx)", isr >> 16);
 646                 break;
 647
 648               default:
 649                 sprintf(buf, "Fault %lu", vector);
 650                 break;
 651         }
 652         if (!die_if_kernel(buf, &regs, error))
 653                 force_sig(SIGILL, current);
 654 }