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 fpswa_interface_t *fpswa_interface;
  28 EXPORT_SYMBOL(fpswa_interface);
  29
  30 ATOMIC_NOTIFIER_HEAD(ia64die_chain);
  31
  32 int
  33 register_die_notifier(struct notifier_block *nb)
  34 {
  35         return atomic_notifier_chain_register(&ia64die_chain, nb);
  36 }
  37 EXPORT_SYMBOL_GPL(register_die_notifier);
  38
  39 int
  40 unregister_die_notifier(struct notifier_block *nb)
  41 {
  42         return atomic_notifier_chain_unregister(&ia64die_chain, nb);
  43 }
  44 EXPORT_SYMBOL_GPL(unregister_die_notifier);
  45
  46 void __init
  47 trap_init (void)
  48 {
  49         if (ia64_boot_param->fpswa)
  50                 /* FPSWA fixup: make the interface pointer a kernel virtual address: */
  51                 fpswa_interface = __va(ia64_boot_param->fpswa);
  52 }
  53
  54 void
  55 die (const char *str, struct pt_regs *regs, long err)
  56 {
  57         static struct {
  58                 spinlock_t lock;
  59                 u32 lock_owner;
  60                 int lock_owner_depth;
  61         } die = {
  62                 .lock =                 SPIN_LOCK_UNLOCKED,
  63                 .lock_owner =           -1,
  64                 .lock_owner_depth =     0
  65         };
  66         static int die_counter;
  67         int cpu = get_cpu();
  68
  69         if (die.lock_owner != cpu) {
  70                 console_verbose();
  71                 spin_lock_irq(&die.lock);
  72                 die.lock_owner = cpu;
  73                 die.lock_owner_depth = 0;
  74                 bust_spinlocks(1);
  75         }
  76         put_cpu();
  77
  78         if (++die.lock_owner_depth < 3) {
  79                 printk("%s[%d]: %s %ld [%d]\n",
  80                         current->comm, current->pid, str, err, ++die_counter);
  81                 (void) notify_die(DIE_OOPS, (char *)str, regs, err, 255, SIGSEGV);
  82                 show_regs(regs);
  83         } else
  84                 printk(KERN_ERR "Recursive die() failure, output suppressed\n");
  85
  86         bust_spinlocks(0);
  87         die.lock_owner = -1;
  88         spin_unlock_irq(&die.lock);
  89
  90         if (panic_on_oops)
  91                 panic("Fatal exception");
  92
  93         do_exit(SIGSEGV);
  94 }
  95
  96 void
  97 die_if_kernel (char *str, struct pt_regs *regs, long err)
  98 {
  99         if (!user_mode(regs))
 100                 die(str, regs, err);
 101 }
 102
 103 void
 104 __kprobes ia64_bad_break (unsigned long break_num, struct pt_regs *regs)
 105 {
 106         siginfo_t siginfo;
 107         int sig, code;
 108
 109         /* SIGILL, SIGFPE, SIGSEGV, and SIGBUS want these field initialized: */
 110         siginfo.si_addr = (void __user *) (regs->cr_iip + ia64_psr(regs)->ri);
 111         siginfo.si_imm = break_num;
 112         siginfo.si_flags = 0;           /* clear __ISR_VALID */
 113         siginfo.si_isr = 0;
 114
 115         switch (break_num) {
 116               case 0: /* unknown error (used by GCC for __builtin_abort()) */
 117                 if (notify_die(DIE_BREAK, "break 0", regs, break_num, TRAP_BRKPT, SIGTRAP)
 118                                 == NOTIFY_STOP)
 119                         return;
 120                 die_if_kernel("bugcheck!", regs, break_num);
 121                 sig = SIGILL; code = ILL_ILLOPC;
 122                 break;
 123
 124               case 1: /* integer divide by zero */
 125                 sig = SIGFPE; code = FPE_INTDIV;
 126                 break;
 127
 128               case 2: /* integer overflow */
 129                 sig = SIGFPE; code = FPE_INTOVF;
 130                 break;
 131
 132               case 3: /* range check/bounds check */
 133                 sig = SIGFPE; code = FPE_FLTSUB;
 134                 break;
 135
 136               case 4: /* null pointer dereference */
 137                 sig = SIGSEGV; code = SEGV_MAPERR;
 138                 break;
 139
 140               case 5: /* misaligned data */
 141                 sig = SIGSEGV; code = BUS_ADRALN;
 142                 break;
 143
 144               case 6: /* decimal overflow */
 145                 sig = SIGFPE; code = __FPE_DECOVF;
 146                 break;
 147
 148               case 7: /* decimal divide by zero */
 149                 sig = SIGFPE; code = __FPE_DECDIV;
 150                 break;
 151
 152               case 8: /* packed decimal error */
 153                 sig = SIGFPE; code = __FPE_DECERR;
 154                 break;
 155
 156               case 9: /* invalid ASCII digit */
 157                 sig = SIGFPE; code = __FPE_INVASC;
 158                 break;
 159
 160               case 10: /* invalid decimal digit */
 161                 sig = SIGFPE; code = __FPE_INVDEC;
 162                 break;
 163
 164               case 11: /* paragraph stack overflow */
 165                 sig = SIGSEGV; code = __SEGV_PSTKOVF;
 166                 break;
 167
 168               case 0x3f000 ... 0x3ffff: /* bundle-update in progress */
 169                 sig = SIGILL; code = __ILL_BNDMOD;
 170                 break;
 171
 172               default:
 173                 if (break_num < 0x40000 || break_num > 0x100000)
 174                         die_if_kernel("Bad break", regs, break_num);
 175
 176                 if (break_num < 0x80000) {
 177                         sig = SIGILL; code = __ILL_BREAK;
 178                 } else {
 179                         if (notify_die(DIE_BREAK, "bad break", regs, break_num, TRAP_BRKPT, SIGTRAP)
 180                                         == NOTIFY_STOP)
 181                                 return;
 182                         sig = SIGTRAP; code = TRAP_BRKPT;
 183                 }
 184         }
 185         siginfo.si_signo = sig;
 186         siginfo.si_errno = 0;
 187         siginfo.si_code = code;
 188         force_sig_info(sig, &siginfo, current);
 189 }
 190
 191 /*
 192  * disabled_fph_fault() is called when a user-level process attempts to access f32..f127
 193  * and it doesn't own the fp-high register partition.  When this happens, we save the
 194  * current fph partition in the task_struct of the fpu-owner (if necessary) and then load
 195  * the fp-high partition of the current task (if necessary).  Note that the kernel has
 196  * access to fph by the time we get here, as the IVT's "Disabled FP-Register" handler takes
 197  * care of clearing psr.dfh.
 198  */
 199 static inline void
 200 disabled_fph_fault (struct pt_regs *regs)
 201 {
 202         struct ia64_psr *psr = ia64_psr(regs);
 203
 204         /* first, grant user-level access to fph partition: */
 205         psr->dfh = 0;
 206
 207         /*
 208          * Make sure that no other task gets in on this processor
 209          * while we're claiming the FPU
 210          */
 211         preempt_disable();
 212 #ifndef CONFIG_SMP
 213         {
 214                 struct task_struct *fpu_owner
 215                         = (struct task_struct *)ia64_get_kr(IA64_KR_FPU_OWNER);
 216
 217                 if (ia64_is_local_fpu_owner(current)) {
 218                         preempt_enable_no_resched();
 219                         return;
 220                 }
 221
 222                 if (fpu_owner)
 223                         ia64_flush_fph(fpu_owner);
 224         }
 225 #endif /* !CONFIG_SMP */
 226         ia64_set_local_fpu_owner(current);
 227         if ((current->thread.flags & IA64_THREAD_FPH_VALID) != 0) {
 228                 __ia64_load_fpu(current->thread.fph);
 229                 psr->mfh = 0;
 230         } else {
 231                 __ia64_init_fpu();
 232                 /*
 233                  * Set mfh because the state in thread.fph does not match the state in
 234                  * the fph partition.
 235                  */
 236                 psr->mfh = 1;
 237         }
 238         preempt_enable_no_resched();
 239 }
 240
 241 static inline int
 242 fp_emulate (int fp_fault, void *bundle, long *ipsr, long *fpsr, long *isr, long *pr, long *ifs,
 243             struct pt_regs *regs)
 244 {
 245         fp_state_t fp_state;
 246         fpswa_ret_t ret;
 247
 248         if (!fpswa_interface)
 249                 return -1;
 250
 251         memset(&fp_state, 0, sizeof(fp_state_t));
 252
 253         /*
 254          * compute fp_state.  only FP registers f6 - f11 are used by the
 255          * kernel, so set those bits in the mask and set the low volatile
 256          * pointer to point to these registers.
 257          */
 258         fp_state.bitmask_low64 = 0xfc0;  /* bit6..bit11 */
 259
 260         fp_state.fp_state_low_volatile = (fp_state_low_volatile_t *) &regs->f6;
 261         /*
 262          * unsigned long (*EFI_FPSWA) (
 263          *      unsigned long    trap_type,
 264          *      void             *Bundle,
 265          *      unsigned long    *pipsr,
 266          *      unsigned long    *pfsr,
 267          *      unsigned long    *pisr,
 268          *      unsigned long    *ppreds,
 269          *      unsigned long    *pifs,
 270          *      void             *fp_state);
 271          */
 272         ret = (*fpswa_interface->fpswa)((unsigned long) fp_fault, bundle,
 273                                         (unsigned long *) ipsr, (unsigned long *) fpsr,
 274                                         (unsigned long *) isr, (unsigned long *) pr,
 275                                         (unsigned long *) ifs, &fp_state);
 276
 277         return ret.status;
 278 }
 279
 280 struct fpu_swa_msg {
 281         unsigned long count;
 282         unsigned long time;
 283 };
 284 static DEFINE_PER_CPU(struct fpu_swa_msg, cpulast);
 285 DECLARE_PER_CPU(struct fpu_swa_msg, cpulast);
 286 static struct fpu_swa_msg last __cacheline_aligned;
 287
 288
 289 /*
 290  * Handle floating-point assist faults and traps.
 291  */
 292 static int
 293 handle_fpu_swa (int fp_fault, struct pt_regs *regs, unsigned long isr)
 294 {
 295         long exception, bundle[2];
 296         unsigned long fault_ip;
 297         struct siginfo siginfo;
 298
 299         fault_ip = regs->cr_iip;
 300         if (!fp_fault && (ia64_psr(regs)->ri == 0))
 301                 fault_ip -= 16;
 302         if (copy_from_user(bundle, (void __user *) fault_ip, sizeof(bundle)))
 303                 return -1;
 304
 305         if (!(current->thread.flags & IA64_THREAD_FPEMU_NOPRINT))  {
 306                 unsigned long count, current_jiffies = jiffies;
 307                 struct fpu_swa_msg *cp = &__get_cpu_var(cpulast);
 308
 309                 if (unlikely(current_jiffies > cp->time))
 310                         cp->count = 0;
 311                 if (unlikely(cp->count < 5)) {
 312                         cp->count++;
 313                         cp->time = current_jiffies + 5 * HZ;
 314
 315                         /* minimize races by grabbing a copy of count BEFORE checking last.time. */
 316                         count = last.count;
 317                         barrier();
 318
 319                         /*
 320                          * Lower 4 bits are used as a count. Upper bits are a sequence
 321                          * number that is updated when count is reset. The cmpxchg will
 322                          * fail is seqno has changed. This minimizes mutiple cpus
 323                          * reseting the count.
 324                          */
 325                         if (current_jiffies > last.time)
 326                                 (void) cmpxchg_acq(&last.count, count, 16 + (count & ~15));
 327
 328                         /* used fetchadd to atomically update the count */
 329                         if ((last.count & 15) < 5 && (ia64_fetchadd(1, &last.count, acq) & 15) < 5) {
 330                                 last.time = current_jiffies + 5 * HZ;
 331                                 printk(KERN_WARNING
 332                                         "%s(%d): floating-point assist fault at ip %016lx, isr %016lx\n",
 333                                         current->comm, current->pid, regs->cr_iip + ia64_psr(regs)->ri, isr);
 334                         }
 335                 }
 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 }