git.oblomov.eu Git - linux-2.6/blob - arch/ia64/kernel/traps.c

   1 /*
   2  * Architecture-specific trap handling.
   3  *
   4  * Copyright (C) 1998-2003 Hewlett-Packard Co
   5  *      David Mosberger-Tang <davidm@hpl.hp.com>
   6  *
   7  * 05/12/00 grao <goutham.rao@intel.com> : added isr in siginfo for SIGFPE
   8  */
   9
  10 #include <linux/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
  19 #include <asm/fpswa.h>
  20 #include <asm/ia32.h>
  21 #include <asm/intrinsics.h>
  22 #include <asm/processor.h>
  23 #include <asm/uaccess.h>
  24 #include <asm/kdebug.h>
  25
  26 extern spinlock_t timerlist_lock;
  27
  28 fpswa_interface_t *fpswa_interface;
  29 EXPORT_SYMBOL(fpswa_interface);
  30
  31 struct notifier_block *ia64die_chain;
  32 static DEFINE_SPINLOCK(die_notifier_lock);
  33
  34 int register_die_notifier(struct notifier_block *nb)
  35 {
  36         int err = 0;
  37         unsigned long flags;
  38         spin_lock_irqsave(&die_notifier_lock, flags);
  39         err = notifier_chain_register(&ia64die_chain, nb);
  40         spin_unlock_irqrestore(&die_notifier_lock, flags);
  41         return err;
  42 }
  43
  44 void __init
  45 trap_init (void)
  46 {
  47         if (ia64_boot_param->fpswa)
  48                 /* FPSWA fixup: make the interface pointer a kernel virtual address: */
  49                 fpswa_interface = __va(ia64_boot_param->fpswa);
  50 }
  51
  52 /*
  53  * Unlock any spinlocks which will prevent us from getting the message out (timerlist_lock
  54  * is acquired through the console unblank code)
  55  */
  56 void
  57 bust_spinlocks (int yes)
  58 {
  59         int loglevel_save = console_loglevel;
  60
  61         if (yes) {
  62                 oops_in_progress = 1;
  63                 return;
  64         }
  65
  66 #ifdef CONFIG_VT
  67         unblank_screen();
  68 #endif
  69         oops_in_progress = 0;
  70         /*
  71          * OK, the message is on the console.  Now we call printk() without
  72          * oops_in_progress set so that printk will give klogd a poke.  Hold onto
  73          * your hats...
  74          */
  75         console_loglevel = 15;          /* NMI oopser may have shut the console up */
  76         printk(" ");
  77         console_loglevel = loglevel_save;
  78 }
  79
  80 void
  81 die (const char *str, struct pt_regs *regs, long err)
  82 {
  83         static struct {
  84                 spinlock_t lock;
  85                 u32 lock_owner;
  86                 int lock_owner_depth;
  87         } die = {
  88                 .lock =                 SPIN_LOCK_UNLOCKED,
  89                 .lock_owner =           -1,
  90                 .lock_owner_depth =     0
  91         };
  92         static int die_counter;
  93
  94         if (die.lock_owner != smp_processor_id()) {
  95                 console_verbose();
  96                 spin_lock_irq(&die.lock);
  97                 die.lock_owner = smp_processor_id();
  98                 die.lock_owner_depth = 0;
  99                 bust_spinlocks(1);
 100         }
 101
 102         if (++die.lock_owner_depth < 3) {
 103                 printk("%s[%d]: %s %ld [%d]\n",
 104                         current->comm, current->pid, str, err, ++die_counter);
 105                 show_regs(regs);
 106         } else
 107                 printk(KERN_ERR "Recursive die() failure, output suppressed\n");
 108
 109         bust_spinlocks(0);
 110         die.lock_owner = -1;
 111         spin_unlock_irq(&die.lock);
 112         do_exit(SIGSEGV);
 113 }
 114
 115 void
 116 die_if_kernel (char *str, struct pt_regs *regs, long err)
 117 {
 118         if (!user_mode(regs))
 119                 die(str, regs, err);
 120 }
 121
 122 void
 123 ia64_bad_break (unsigned long break_num, struct pt_regs *regs)
 124 {
 125         siginfo_t siginfo;
 126         int sig, code;
 127
 128         /* break.b always sets cr.iim to 0, which causes problems for
 129          * debuggers.  Get the real break number from the original instruction,
 130          * but only for kernel code.  User space break.b is left alone, to
 131          * preserve the existing behaviour.  All break codings have the same
 132          * format, so there is no need to check the slot type.
 133          */
 134         if (break_num == 0 && !user_mode(regs)) {
 135                 struct ia64_psr *ipsr = ia64_psr(regs);
 136                 unsigned long *bundle = (unsigned long *)regs->cr_iip;
 137                 unsigned long slot;
 138                 switch (ipsr->ri) {
 139                       case 0:  slot = (bundle[0] >>  5); break;
 140                       case 1:  slot = (bundle[0] >> 46) | (bundle[1] << 18); break;
 141                       default: slot = (bundle[1] >> 23); break;
 142                 }
 143                 break_num = ((slot >> 36 & 1) << 20) | (slot >> 6 & 0xfffff);
 144         }
 145
 146         /* SIGILL, SIGFPE, SIGSEGV, and SIGBUS want these field initialized: */
 147         siginfo.si_addr = (void __user *) (regs->cr_iip + ia64_psr(regs)->ri);
 148         siginfo.si_imm = break_num;
 149         siginfo.si_flags = 0;           /* clear __ISR_VALID */
 150         siginfo.si_isr = 0;
 151
 152         switch (break_num) {
 153               case 0: /* unknown error (used by GCC for __builtin_abort()) */
 154                 if (notify_die(DIE_BREAK, "break 0", regs, break_num, TRAP_BRKPT, SIGTRAP)
 155                                 == NOTIFY_STOP) {
 156                         return;
 157                 }
 158                 die_if_kernel("bugcheck!", regs, break_num);
 159                 sig = SIGILL; code = ILL_ILLOPC;
 160                 break;
 161
 162               case 1: /* integer divide by zero */
 163                 sig = SIGFPE; code = FPE_INTDIV;
 164                 break;
 165
 166               case 2: /* integer overflow */
 167                 sig = SIGFPE; code = FPE_INTOVF;
 168                 break;
 169
 170               case 3: /* range check/bounds check */
 171                 sig = SIGFPE; code = FPE_FLTSUB;
 172                 break;
 173
 174               case 4: /* null pointer dereference */
 175                 sig = SIGSEGV; code = SEGV_MAPERR;
 176                 break;
 177
 178               case 5: /* misaligned data */
 179                 sig = SIGSEGV; code = BUS_ADRALN;
 180                 break;
 181
 182               case 6: /* decimal overflow */
 183                 sig = SIGFPE; code = __FPE_DECOVF;
 184                 break;
 185
 186               case 7: /* decimal divide by zero */
 187                 sig = SIGFPE; code = __FPE_DECDIV;
 188                 break;
 189
 190               case 8: /* packed decimal error */
 191                 sig = SIGFPE; code = __FPE_DECERR;
 192                 break;
 193
 194               case 9: /* invalid ASCII digit */
 195                 sig = SIGFPE; code = __FPE_INVASC;
 196                 break;
 197
 198               case 10: /* invalid decimal digit */
 199                 sig = SIGFPE; code = __FPE_INVDEC;
 200                 break;
 201
 202               case 11: /* paragraph stack overflow */
 203                 sig = SIGSEGV; code = __SEGV_PSTKOVF;
 204                 break;
 205
 206               case 0x3f000 ... 0x3ffff: /* bundle-update in progress */
 207                 sig = SIGILL; code = __ILL_BNDMOD;
 208                 break;
 209
 210               case 0x80200:
 211               case 0x80300:
 212                 if (notify_die(DIE_BREAK, "kprobe", regs, break_num, TRAP_BRKPT, SIGTRAP)
 213                                 == NOTIFY_STOP) {
 214                         return;
 215                 }
 216                 sig = SIGTRAP; code = TRAP_BRKPT;
 217                 break;
 218
 219               default:
 220                 if (break_num < 0x40000 || break_num > 0x100000)
 221                         die_if_kernel("Bad break", regs, break_num);
 222
 223                 if (break_num < 0x80000) {
 224                         sig = SIGILL; code = __ILL_BREAK;
 225                 } else {
 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
 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:
 579                               if (notify_die(DIE_SS, "ss", &regs, vector,
 580                                              vector, SIGTRAP) == NOTIFY_STOP)
 581                                       return;
 582                               siginfo.si_code = TRAP_TRACE; ifa = 0; break;
 583                 }
 584                 siginfo.si_signo = SIGTRAP;
 585                 siginfo.si_errno = 0;
 586                 siginfo.si_addr  = (void __user *) ifa;
 587                 siginfo.si_imm   = 0;
 588                 siginfo.si_flags = __ISR_VALID;
 589                 siginfo.si_isr   = isr;
 590                 force_sig_info(SIGTRAP, &siginfo, current);
 591                 return;
 592
 593               case 32: /* fp fault */
 594               case 33: /* fp trap */
 595                 result = handle_fpu_swa((vector == 32) ? 1 : 0, &regs, isr);
 596                 if ((result < 0) || (current->thread.flags & IA64_THREAD_FPEMU_SIGFPE)) {
 597                         siginfo.si_signo = SIGFPE;
 598                         siginfo.si_errno = 0;
 599                         siginfo.si_code = FPE_FLTINV;
 600                         siginfo.si_addr = (void __user *) iip;
 601                         siginfo.si_flags = __ISR_VALID;
 602                         siginfo.si_isr = isr;
 603                         siginfo.si_imm = 0;
 604                         force_sig_info(SIGFPE, &siginfo, current);
 605                 }
 606                 return;
 607
 608               case 34:
 609                 if (isr & 0x2) {
 610                         /* Lower-Privilege Transfer Trap */
 611                         /*
 612                          * Just clear PSR.lp and then return immediately: all the
 613                          * interesting work (e.g., signal delivery is done in the kernel
 614                          * exit path).
 615                          */
 616                         ia64_psr(&regs)->lp = 0;
 617                         return;
 618                 } else {
 619                         /* Unimplemented Instr. Address Trap */
 620                         if (user_mode(&regs)) {
 621                                 siginfo.si_signo = SIGILL;
 622                                 siginfo.si_code = ILL_BADIADDR;
 623                                 siginfo.si_errno = 0;
 624                                 siginfo.si_flags = 0;
 625                                 siginfo.si_isr = 0;
 626                                 siginfo.si_imm = 0;
 627                                 siginfo.si_addr = (void __user *) iip;
 628                                 force_sig_info(SIGILL, &siginfo, current);
 629                                 return;
 630                         }
 631                         sprintf(buf, "Unimplemented Instruction Address fault");
 632                 }
 633                 break;
 634
 635               case 45:
 636 #ifdef CONFIG_IA32_SUPPORT
 637                 if (ia32_exception(&regs, isr) == 0)
 638                         return;
 639 #endif
 640                 printk(KERN_ERR "Unexpected IA-32 exception (Trap 45)\n");
 641                 printk(KERN_ERR "  iip - 0x%lx, ifa - 0x%lx, isr - 0x%lx\n",
 642                        iip, ifa, isr);
 643                 force_sig(SIGSEGV, current);
 644                 break;
 645
 646               case 46:
 647 #ifdef CONFIG_IA32_SUPPORT
 648                 if (ia32_intercept(&regs, isr) == 0)
 649                         return;
 650 #endif
 651                 printk(KERN_ERR "Unexpected IA-32 intercept trap (Trap 46)\n");
 652                 printk(KERN_ERR "  iip - 0x%lx, ifa - 0x%lx, isr - 0x%lx, iim - 0x%lx\n",
 653                        iip, ifa, isr, iim);
 654                 force_sig(SIGSEGV, current);
 655                 return;
 656
 657               case 47:
 658                 sprintf(buf, "IA-32 Interruption Fault (int 0x%lx)", isr >> 16);
 659                 break;
 660
 661               default:
 662                 sprintf(buf, "Fault %lu", vector);
 663                 break;
 664         }
 665         die_if_kernel(buf, &regs, error);
 666         force_sig(SIGILL, current);
 667 }