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