arch/parisc/kernel/traps.c

   1 /*
   2  *  linux/arch/parisc/traps.c
   3  *
   4  *  Copyright (C) 1991, 1992  Linus Torvalds
   5  *  Copyright (C) 1999, 2000  Philipp Rumpf <prumpf@tux.org>
   6  */
   7
   8 /*
   9  * 'Traps.c' handles hardware traps and faults after we have saved some
  10  * state in 'asm.s'.
  11  */
  12
  13 #include <linux/config.h>
  14 #include <linux/sched.h>
  15 #include <linux/kernel.h>
  16 #include <linux/string.h>
  17 #include <linux/errno.h>
  18 #include <linux/ptrace.h>
  19 #include <linux/timer.h>
  20 #include <linux/mm.h>
  21 #include <linux/module.h>
  22 #include <linux/smp.h>
  23 #include <linux/smp_lock.h>
  24 #include <linux/spinlock.h>
  25 #include <linux/init.h>
  26 #include <linux/interrupt.h>
  27 #include <linux/console.h>
  28 #include <linux/kallsyms.h>
  29
  30 #include <asm/assembly.h>
  31 #include <asm/system.h>
  32 #include <asm/uaccess.h>
  33 #include <asm/io.h>
  34 #include <asm/irq.h>
  35 #include <asm/traps.h>
  36 #include <asm/unaligned.h>
  37 #include <asm/atomic.h>
  38 #include <asm/smp.h>
  39 #include <asm/pdc.h>
  40 #include <asm/pdc_chassis.h>
  41 #include <asm/unwind.h>
  42
  43 #include "../math-emu/math-emu.h"       /* for handle_fpe() */
  44
  45 #define PRINT_USER_FAULTS /* (turn this on if you want user faults to be */
  46                           /*  dumped to the console via printk)          */
  47
  48 #if defined(CONFIG_SMP) || defined(CONFIG_DEBUG_SPINLOCK)
  49 DEFINE_SPINLOCK(pa_dbit_lock);
  50 #endif
  51
  52 int printbinary(char *buf, unsigned long x, int nbits)
  53 {
  54         unsigned long mask = 1UL << (nbits - 1);
  55         while (mask != 0) {
  56                 *buf++ = (mask & x ? '1' : '0');
  57                 mask >>= 1;
  58         }
  59         *buf = '\0';
  60
  61         return nbits;
  62 }
  63
  64 #ifdef __LP64__
  65 #define RFMT "%016lx"
  66 #else
  67 #define RFMT "%08lx"
  68 #endif
  69
  70 void show_regs(struct pt_regs *regs)
  71 {
  72         int i;
  73         char buf[128], *p;
  74         char *level;
  75         unsigned long cr30;
  76         unsigned long cr31;
  77
  78         level = user_mode(regs) ? KERN_DEBUG : KERN_CRIT;
  79
  80         printk("%s\n", level); /* don't want to have that pretty register dump messed up */
  81
  82         printk("%s     YZrvWESTHLNXBCVMcbcbcbcbOGFRQPDI\n", level);
  83         printbinary(buf, regs->gr[0], 32);
  84         printk("%sPSW: %s %s\n", level, buf, print_tainted());
  85
  86         for (i = 0; i < 32; i += 4) {
  87                 int j;
  88                 p = buf;
  89                 p += sprintf(p, "%sr%02d-%02d ", level, i, i + 3);
  90                 for (j = 0; j < 4; j++) {
  91                         p += sprintf(p, " " RFMT, (i+j) == 0 ? 0 : regs->gr[i + j]);
  92                 }
  93                 printk("%s\n", buf);
  94         }
  95
  96         for (i = 0; i < 8; i += 4) {
  97                 int j;
  98                 p = buf;
  99                 p += sprintf(p, "%ssr%d-%d  ", level, i, i + 3);
 100                 for (j = 0; j < 4; j++) {
 101                         p += sprintf(p, " " RFMT, regs->sr[i + j]);
 102                 }
 103                 printk("%s\n", buf);
 104         }
 105
 106 #if RIDICULOUSLY_VERBOSE
 107         for (i = 0; i < 32; i += 2)
 108                 printk("%sFR%02d : %016lx  FR%2d : %016lx", level, i,
 109                                 regs->fr[i], i+1, regs->fr[i+1]);
 110 #endif
 111
 112         cr30 = mfctl(30);
 113         cr31 = mfctl(31);
 114         printk("%s\n", level);
 115         printk("%sIASQ: " RFMT " " RFMT " IAOQ: " RFMT " " RFMT "\n",
 116                level, regs->iasq[0], regs->iasq[1], regs->iaoq[0], regs->iaoq[1]);
 117         printk("%s IIR: %08lx    ISR: " RFMT "  IOR: " RFMT "\n",
 118                level, regs->iir, regs->isr, regs->ior);
 119         printk("%s CPU: %8d   CR30: " RFMT " CR31: " RFMT "\n",
 120                level, current_thread_info()->cpu, cr30, cr31);
 121         printk("%s ORIG_R28: " RFMT "\n", level, regs->orig_r28);
 122         printk(level);
 123         print_symbol(" IAOQ[0]: %s\n", regs->iaoq[0]);
 124         printk(level);
 125         print_symbol(" IAOQ[1]: %s\n", regs->iaoq[1]);
 126         printk(level);
 127         print_symbol(" RP(r2): %s\n", regs->gr[2]);
 128 }
 129
 130
 131 void dump_stack(void)
 132 {
 133         show_stack(NULL, NULL);
 134 }
 135
 136 EXPORT_SYMBOL(dump_stack);
 137
 138 static void do_show_stack(struct unwind_frame_info *info)
 139 {
 140         int i = 1;
 141
 142         printk("Backtrace:\n");
 143         while (i <= 16) {
 144                 if (unwind_once(info) < 0 || info->ip == 0)
 145                         break;
 146
 147                 if (__kernel_text_address(info->ip)) {
 148                         printk(" [<" RFMT ">] ", info->ip);
 149 #ifdef CONFIG_KALLSYMS
 150                         print_symbol("%s\n", info->ip);
 151 #else
 152                         if ((i & 0x03) == 0)
 153                                 printk("\n");
 154 #endif
 155                         i++;
 156                 }
 157         }
 158         printk("\n");
 159 }
 160
 161 void show_stack(struct task_struct *task, unsigned long *s)
 162 {
 163         struct unwind_frame_info info;
 164
 165         if (!task) {
 166                 unsigned long sp;
 167                 struct pt_regs *r;
 168
 169 HERE:
 170                 asm volatile ("copy %%r30, %0" : "=r"(sp));
 171                 r = (struct pt_regs *)kmalloc(sizeof(struct pt_regs), GFP_KERNEL);
 172                 if (!r)
 173                         return;
 174                 memset(r, 0, sizeof(struct pt_regs));
 175                 r->iaoq[0] = (unsigned long)&&HERE;
 176                 r->gr[2] = (unsigned long)__builtin_return_address(0);
 177                 r->gr[30] = sp;
 178                 unwind_frame_init(&info, current, r);
 179                 kfree(r);
 180         } else {
 181                 unwind_frame_init_from_blocked_task(&info, task);
 182         }
 183
 184         do_show_stack(&info);
 185 }
 186
 187 void die_if_kernel(char *str, struct pt_regs *regs, long err)
 188 {
 189         if (user_mode(regs)) {
 190                 if (err == 0)
 191                         return; /* STFU */
 192
 193                 printk(KERN_CRIT "%s (pid %d): %s (code %ld) at " RFMT "\n",
 194                         current->comm, current->pid, str, err, regs->iaoq[0]);
 195 #ifdef PRINT_USER_FAULTS
 196                 /* XXX for debugging only */
 197                 show_regs(regs);
 198 #endif
 199                 return;
 200         }
 201
 202         oops_in_progress = 1;
 203
 204         /* Amuse the user in a SPARC fashion */
 205         printk(
 206 "      _______________________________ \n"
 207 "     < Your System ate a SPARC! Gah! >\n"
 208 "      ------------------------------- \n"
 209 "             \\   ^__^\n"
 210 "              \\  (xx)\\_______\n"
 211 "                 (__)\\       )\\/\\\n"
 212 "                  U  ||----w |\n"
 213 "                     ||     ||\n");
 214
 215         /* unlock the pdc lock if necessary */
 216         pdc_emergency_unlock();
 217
 218         /* maybe the kernel hasn't booted very far yet and hasn't been able
 219          * to initialize the serial or STI console. In that case we should
 220          * re-enable the pdc console, so that the user will be able to
 221          * identify the problem. */
 222         if (!console_drivers)
 223                 pdc_console_restart();
 224
 225         printk(KERN_CRIT "%s (pid %d): %s (code %ld)\n",
 226                 current->comm, current->pid, str, err);
 227         show_regs(regs);
 228
 229         /* Wot's wrong wif bein' racy? */
 230         if (current->thread.flags & PARISC_KERNEL_DEATH) {
 231                 printk(KERN_CRIT "%s() recursion detected.\n", __FUNCTION__);
 232                 local_irq_enable();
 233                 while (1);
 234         }
 235
 236         current->thread.flags |= PARISC_KERNEL_DEATH;
 237         do_exit(SIGSEGV);
 238 }
 239
 240 int syscall_ipi(int (*syscall) (struct pt_regs *), struct pt_regs *regs)
 241 {
 242         return syscall(regs);
 243 }
 244
 245 /* gdb uses break 4,8 */
 246 #define GDB_BREAK_INSN 0x10004
 247 void handle_gdb_break(struct pt_regs *regs, int wot)
 248 {
 249         struct siginfo si;
 250
 251         si.si_code = wot;
 252         si.si_addr = (void __user *) (regs->iaoq[0] & ~3);
 253         si.si_signo = SIGTRAP;
 254         si.si_errno = 0;
 255         force_sig_info(SIGTRAP, &si, current);
 256 }
 257
 258 void handle_break(unsigned iir, struct pt_regs *regs)
 259 {
 260         struct siginfo si;
 261
 262         switch(iir) {
 263         case 0x00:
 264 #ifdef PRINT_USER_FAULTS
 265                 printk(KERN_DEBUG "break 0,0: pid=%d command='%s'\n",
 266                        current->pid, current->comm);
 267 #endif
 268                 die_if_kernel("Breakpoint", regs, 0);
 269 #ifdef PRINT_USER_FAULTS
 270                 show_regs(regs);
 271 #endif
 272                 si.si_code = TRAP_BRKPT;
 273                 si.si_addr = (void __user *) (regs->iaoq[0] & ~3);
 274                 si.si_signo = SIGTRAP;
 275                 force_sig_info(SIGTRAP, &si, current);
 276                 break;
 277
 278         case GDB_BREAK_INSN:
 279                 die_if_kernel("Breakpoint", regs, 0);
 280                 handle_gdb_break(regs, TRAP_BRKPT);
 281                 break;
 282
 283         default:
 284 #ifdef PRINT_USER_FAULTS
 285                 printk(KERN_DEBUG "break %#08x: pid=%d command='%s'\n",
 286                        iir, current->pid, current->comm);
 287                 show_regs(regs);
 288 #endif
 289                 si.si_signo = SIGTRAP;
 290                 si.si_code = TRAP_BRKPT;
 291                 si.si_addr = (void __user *) (regs->iaoq[0] & ~3);
 292                 force_sig_info(SIGTRAP, &si, current);
 293                 return;
 294         }
 295 }
 296
 297
 298 int handle_toc(void)
 299 {
 300         printk(KERN_CRIT "TOC call.\n");
 301         return 0;
 302 }
 303
 304 static void default_trap(int code, struct pt_regs *regs)
 305 {
 306         printk(KERN_ERR "Trap %d on CPU %d\n", code, smp_processor_id());
 307         show_regs(regs);
 308 }
 309
 310 void (*cpu_lpmc) (int code, struct pt_regs *regs) = default_trap;
 311
 312
 313 void transfer_pim_to_trap_frame(struct pt_regs *regs)
 314 {
 315     register int i;
 316     extern unsigned int hpmc_pim_data[];
 317     struct pdc_hpmc_pim_11 *pim_narrow;
 318     struct pdc_hpmc_pim_20 *pim_wide;
 319
 320     if (boot_cpu_data.cpu_type >= pcxu) {
 321
 322         pim_wide = (struct pdc_hpmc_pim_20 *)hpmc_pim_data;
 323
 324         /*
 325          * Note: The following code will probably generate a
 326          * bunch of truncation error warnings from the compiler.
 327          * Could be handled with an ifdef, but perhaps there
 328          * is a better way.
 329          */
 330
 331         regs->gr[0] = pim_wide->cr[22];
 332
 333         for (i = 1; i < 32; i++)
 334             regs->gr[i] = pim_wide->gr[i];
 335
 336         for (i = 0; i < 32; i++)
 337             regs->fr[i] = pim_wide->fr[i];
 338
 339         for (i = 0; i < 8; i++)
 340             regs->sr[i] = pim_wide->sr[i];
 341
 342         regs->iasq[0] = pim_wide->cr[17];
 343         regs->iasq[1] = pim_wide->iasq_back;
 344         regs->iaoq[0] = pim_wide->cr[18];
 345         regs->iaoq[1] = pim_wide->iaoq_back;
 346
 347         regs->sar  = pim_wide->cr[11];
 348         regs->iir  = pim_wide->cr[19];
 349         regs->isr  = pim_wide->cr[20];
 350         regs->ior  = pim_wide->cr[21];
 351     }
 352     else {
 353         pim_narrow = (struct pdc_hpmc_pim_11 *)hpmc_pim_data;
 354
 355         regs->gr[0] = pim_narrow->cr[22];
 356
 357         for (i = 1; i < 32; i++)
 358             regs->gr[i] = pim_narrow->gr[i];
 359
 360         for (i = 0; i < 32; i++)
 361             regs->fr[i] = pim_narrow->fr[i];
 362
 363         for (i = 0; i < 8; i++)
 364             regs->sr[i] = pim_narrow->sr[i];
 365
 366         regs->iasq[0] = pim_narrow->cr[17];
 367         regs->iasq[1] = pim_narrow->iasq_back;
 368         regs->iaoq[0] = pim_narrow->cr[18];
 369         regs->iaoq[1] = pim_narrow->iaoq_back;
 370
 371         regs->sar  = pim_narrow->cr[11];
 372         regs->iir  = pim_narrow->cr[19];
 373         regs->isr  = pim_narrow->cr[20];
 374         regs->ior  = pim_narrow->cr[21];
 375     }
 376
 377     /*
 378      * The following fields only have meaning if we came through
 379      * another path. So just zero them here.
 380      */
 381
 382     regs->ksp = 0;
 383     regs->kpc = 0;
 384     regs->orig_r28 = 0;
 385 }
 386
 387
 388 /*
 389  * This routine is called as a last resort when everything else
 390  * has gone clearly wrong. We get called for faults in kernel space,
 391  * and HPMC's.
 392  */
 393 void parisc_terminate(char *msg, struct pt_regs *regs, int code, unsigned long offset)
 394 {
 395         static DEFINE_SPINLOCK(terminate_lock);
 396
 397         oops_in_progress = 1;
 398
 399         set_eiem(0);
 400         local_irq_disable();
 401         spin_lock(&terminate_lock);
 402
 403         /* unlock the pdc lock if necessary */
 404         pdc_emergency_unlock();
 405
 406         /* restart pdc console if necessary */
 407         if (!console_drivers)
 408                 pdc_console_restart();
 409
 410         /* Not all paths will gutter the processor... */
 411         switch(code){
 412
 413         case 1:
 414                 transfer_pim_to_trap_frame(regs);
 415                 break;
 416
 417         default:
 418                 /* Fall through */
 419                 break;
 420
 421         }
 422
 423         {
 424                 /* show_stack(NULL, (unsigned long *)regs->gr[30]); */
 425                 struct unwind_frame_info info;
 426                 unwind_frame_init(&info, current, regs);
 427                 do_show_stack(&info);
 428         }
 429
 430         printk("\n");
 431         printk(KERN_CRIT "%s: Code=%d regs=%p (Addr=" RFMT ")\n",
 432                         msg, code, regs, offset);
 433         show_regs(regs);
 434
 435         spin_unlock(&terminate_lock);
 436
 437         /* put soft power button back under hardware control;
 438          * if the user had pressed it once at any time, the
 439          * system will shut down immediately right here. */
 440         pdc_soft_power_button(0);
 441
 442         /* Call kernel panic() so reboot timeouts work properly
 443          * FIXME: This function should be on the list of
 444          * panic notifiers, and we should call panic
 445          * directly from the location that we wish.
 446          * e.g. We should not call panic from
 447          * parisc_terminate, but rather the oter way around.
 448          * This hack works, prints the panic message twice,
 449          * and it enables reboot timers!
 450          */
 451         panic(msg);
 452 }
 453
 454 void handle_interruption(int code, struct pt_regs *regs)
 455 {
 456         unsigned long fault_address = 0;
 457         unsigned long fault_space = 0;
 458         struct siginfo si;
 459
 460         if (code == 1)
 461             pdc_console_restart();  /* switch back to pdc if HPMC */
 462         else
 463             local_irq_enable();
 464
 465         /* Security check:
 466          * If the priority level is still user, and the
 467          * faulting space is not equal to the active space
 468          * then the user is attempting something in a space
 469          * that does not belong to them. Kill the process.
 470          *
 471          * This is normally the situation when the user
 472          * attempts to jump into the kernel space at the
 473          * wrong offset, be it at the gateway page or a
 474          * random location.
 475          *
 476          * We cannot normally signal the process because it
 477          * could *be* on the gateway page, and processes
 478          * executing on the gateway page can't have signals
 479          * delivered.
 480          *
 481          * We merely readjust the address into the users
 482          * space, at a destination address of zero, and
 483          * allow processing to continue.
 484          */
 485         if (((unsigned long)regs->iaoq[0] & 3) &&
 486             ((unsigned long)regs->iasq[0] != (unsigned long)regs->sr[7])) {
 487                 /* Kill the user process later */
 488                 regs->iaoq[0] = 0 | 3;
 489                 regs->iaoq[1] = regs->iaoq[0] + 4;
 490                 regs->iasq[0] = regs->iasq[0] = regs->sr[7];
 491                 regs->gr[0] &= ~PSW_B;
 492                 return;
 493         }
 494
 495 #if 0
 496         printk(KERN_CRIT "Interruption # %d\n", code);
 497 #endif
 498
 499         switch(code) {
 500
 501         case  1:
 502                 /* High-priority machine check (HPMC) */
 503
 504                 /* set up a new led state on systems shipped with a LED State panel */
 505                 pdc_chassis_send_status(PDC_CHASSIS_DIRECT_HPMC);
 506
 507                 parisc_terminate("High Priority Machine Check (HPMC)",
 508                                 regs, code, 0);
 509                 /* NOT REACHED */
 510
 511         case  2:
 512                 /* Power failure interrupt */
 513                 printk(KERN_CRIT "Power failure interrupt !\n");
 514                 return;
 515
 516         case  3:
 517                 /* Recovery counter trap */
 518                 regs->gr[0] &= ~PSW_R;
 519                 if (user_space(regs))
 520                         handle_gdb_break(regs, TRAP_TRACE);
 521                 /* else this must be the start of a syscall - just let it run */
 522                 return;
 523
 524         case  5:
 525                 /* Low-priority machine check */
 526                 pdc_chassis_send_status(PDC_CHASSIS_DIRECT_LPMC);
 527
 528                 flush_all_caches();
 529                 cpu_lpmc(5, regs);
 530                 return;
 531
 532         case  6:
 533                 /* Instruction TLB miss fault/Instruction page fault */
 534                 fault_address = regs->iaoq[0];
 535                 fault_space   = regs->iasq[0];
 536                 break;
 537
 538         case  8:
 539                 /* Illegal instruction trap */
 540                 die_if_kernel("Illegal instruction", regs, code);
 541                 si.si_code = ILL_ILLOPC;
 542                 goto give_sigill;
 543
 544         case  9:
 545                 /* Break instruction trap */
 546                 handle_break(regs->iir,regs);
 547                 return;
 548
 549         case 10:
 550                 /* Privileged operation trap */
 551                 die_if_kernel("Privileged operation", regs, code);
 552                 si.si_code = ILL_PRVOPC;
 553                 goto give_sigill;
 554
 555         case 11:
 556                 /* Privileged register trap */
 557                 if ((regs->iir & 0xffdfffe0) == 0x034008a0) {
 558
 559                         /* This is a MFCTL cr26/cr27 to gr instruction.
 560                          * PCXS traps on this, so we need to emulate it.
 561                          */
 562
 563                         if (regs->iir & 0x00200000)
 564                                 regs->gr[regs->iir & 0x1f] = mfctl(27);
 565                         else
 566                                 regs->gr[regs->iir & 0x1f] = mfctl(26);
 567
 568                         regs->iaoq[0] = regs->iaoq[1];
 569                         regs->iaoq[1] += 4;
 570                         regs->iasq[0] = regs->iasq[1];
 571                         return;
 572                 }
 573
 574                 die_if_kernel("Privileged register usage", regs, code);
 575                 si.si_code = ILL_PRVREG;
 576         give_sigill:
 577                 si.si_signo = SIGILL;
 578                 si.si_errno = 0;
 579                 si.si_addr = (void __user *) regs->iaoq[0];
 580                 force_sig_info(SIGILL, &si, current);
 581                 return;
 582
 583         case 12:
 584                 /* Overflow Trap, let the userland signal handler do the cleanup */
 585                 si.si_signo = SIGFPE;
 586                 si.si_code = FPE_INTOVF;
 587                 si.si_addr = (void __user *) regs->iaoq[0];
 588                 force_sig_info(SIGFPE, &si, current);
 589                 return;
 590
 591         case 13:
 592                 /* Conditional Trap
 593                    The condition succees in an instruction which traps
 594                    on condition  */
 595                 if(user_mode(regs)){
 596                         si.si_signo = SIGFPE;
 597                         /* Set to zero, and let the userspace app figure it out from
 598                            the insn pointed to by si_addr */
 599                         si.si_code = 0;
 600                         si.si_addr = (void __user *) regs->iaoq[0];
 601                         force_sig_info(SIGFPE, &si, current);
 602                         return;
 603                 }
 604                 /* The kernel doesn't want to handle condition codes */
 605                 break;
 606
 607         case 14:
 608                 /* Assist Exception Trap, i.e. floating point exception. */
 609                 die_if_kernel("Floating point exception", regs, 0); /* quiet */
 610                 handle_fpe(regs);
 611                 return;
 612
 613         case 15:
 614                 /* Data TLB miss fault/Data page fault */
 615                 /* Fall through */
 616         case 16:
 617                 /* Non-access instruction TLB miss fault */
 618                 /* The instruction TLB entry needed for the target address of the FIC
 619                    is absent, and hardware can't find it, so we get to cleanup */
 620                 /* Fall through */
 621         case 17:
 622                 /* Non-access data TLB miss fault/Non-access data page fault */
 623                 /* FIXME:
 624                          Still need to add slow path emulation code here!
 625                          If the insn used a non-shadow register, then the tlb
 626                          handlers could not have their side-effect (e.g. probe
 627                          writing to a target register) emulated since rfir would
 628                          erase the changes to said register. Instead we have to
 629                          setup everything, call this function we are in, and emulate
 630                          by hand. Technically we need to emulate:
 631                          fdc,fdce,pdc,"fic,4f",prober,probeir,probew, probeiw
 632                 */
 633                 fault_address = regs->ior;
 634                 fault_space = regs->isr;
 635                 break;
 636
 637         case 18:
 638                 /* PCXS only -- later cpu's split this into types 26,27 & 28 */
 639                 /* Check for unaligned access */
 640                 if (check_unaligned(regs)) {
 641                         handle_unaligned(regs);
 642                         return;
 643                 }
 644                 /* Fall Through */
 645         case 26:
 646                 /* PCXL: Data memory access rights trap */
 647                 fault_address = regs->ior;
 648                 fault_space   = regs->isr;
 649                 break;
 650
 651         case 19:
 652                 /* Data memory break trap */
 653                 regs->gr[0] |= PSW_X; /* So we can single-step over the trap */
 654                 /* fall thru */
 655         case 21:
 656                 /* Page reference trap */
 657                 handle_gdb_break(regs, TRAP_HWBKPT);
 658                 return;
 659
 660         case 25:
 661                 /* Taken branch trap */
 662                 regs->gr[0] &= ~PSW_T;
 663                 if (user_space(regs))
 664                         handle_gdb_break(regs, TRAP_BRANCH);
 665                 /* else this must be the start of a syscall - just let it
 666                  * run.
 667                  */
 668                 return;
 669
 670         case  7:
 671                 /* Instruction access rights */
 672                 /* PCXL: Instruction memory protection trap */
 673
 674                 /*
 675                  * This could be caused by either: 1) a process attempting
 676                  * to execute within a vma that does not have execute
 677                  * permission, or 2) an access rights violation caused by a
 678                  * flush only translation set up by ptep_get_and_clear().
 679                  * So we check the vma permissions to differentiate the two.
 680                  * If the vma indicates we have execute permission, then
 681                  * the cause is the latter one. In this case, we need to
 682                  * call do_page_fault() to fix the problem.
 683                  */
 684
 685                 if (user_mode(regs)) {
 686                         struct vm_area_struct *vma;
 687
 688                         down_read(&current->mm->mmap_sem);
 689                         vma = find_vma(current->mm,regs->iaoq[0]);
 690                         if (vma && (regs->iaoq[0] >= vma->vm_start)
 691                                 && (vma->vm_flags & VM_EXEC)) {
 692
 693                                 fault_address = regs->iaoq[0];
 694                                 fault_space = regs->iasq[0];
 695
 696                                 up_read(&current->mm->mmap_sem);
 697                                 break; /* call do_page_fault() */
 698                         }
 699                         up_read(&current->mm->mmap_sem);
 700                 }
 701                 /* Fall Through */
 702         case 27:
 703                 /* Data memory protection ID trap */
 704                 die_if_kernel("Protection id trap", regs, code);
 705                 si.si_code = SEGV_MAPERR;
 706                 si.si_signo = SIGSEGV;
 707                 si.si_errno = 0;
 708                 if (code == 7)
 709                     si.si_addr = (void __user *) regs->iaoq[0];
 710                 else
 711                     si.si_addr = (void __user *) regs->ior;
 712                 force_sig_info(SIGSEGV, &si, current);
 713                 return;
 714
 715         case 28:
 716                 /* Unaligned data reference trap */
 717                 handle_unaligned(regs);
 718                 return;
 719
 720         default:
 721                 if (user_mode(regs)) {
 722 #ifdef PRINT_USER_FAULTS
 723                         printk(KERN_DEBUG "\nhandle_interruption() pid=%d command='%s'\n",
 724                             current->pid, current->comm);
 725                         show_regs(regs);
 726 #endif
 727                         /* SIGBUS, for lack of a better one. */
 728                         si.si_signo = SIGBUS;
 729                         si.si_code = BUS_OBJERR;
 730                         si.si_errno = 0;
 731                         si.si_addr = (void __user *) regs->ior;
 732                         force_sig_info(SIGBUS, &si, current);
 733                         return;
 734                 }
 735                 pdc_chassis_send_status(PDC_CHASSIS_DIRECT_PANIC);
 736
 737                 parisc_terminate("Unexpected interruption", regs, code, 0);
 738                 /* NOT REACHED */
 739         }
 740
 741         if (user_mode(regs)) {
 742             if ((fault_space >> SPACEID_SHIFT) != (regs->sr[7] >> SPACEID_SHIFT)) {
 743 #ifdef PRINT_USER_FAULTS
 744                 if (fault_space == 0)
 745                         printk(KERN_DEBUG "User Fault on Kernel Space ");
 746                 else
 747                         printk(KERN_DEBUG "User Fault (long pointer) (fault %d) ",
 748                                code);
 749                 printk("pid=%d command='%s'\n", current->pid, current->comm);
 750                 show_regs(regs);
 751 #endif
 752                 si.si_signo = SIGSEGV;
 753                 si.si_errno = 0;
 754                 si.si_code = SEGV_MAPERR;
 755                 si.si_addr = (void __user *) regs->ior;
 756                 force_sig_info(SIGSEGV, &si, current);
 757                 return;
 758             }
 759         }
 760         else {
 761
 762             /*
 763              * The kernel should never fault on its own address space.
 764              */
 765
 766             if (fault_space == 0)
 767             {
 768                 pdc_chassis_send_status(PDC_CHASSIS_DIRECT_PANIC);
 769                 parisc_terminate("Kernel Fault", regs, code, fault_address);
 770
 771             }
 772         }
 773
 774         do_page_fault(regs, code, fault_address);
 775 }
 776
 777
 778 int __init check_ivt(void *iva)
 779 {
 780         int i;
 781         u32 check = 0;
 782         u32 *ivap;
 783         u32 *hpmcp;
 784         u32 length;
 785         extern void os_hpmc(void);
 786         extern void os_hpmc_end(void);
 787
 788         if (strcmp((char *)iva, "cows can fly"))
 789                 return -1;
 790
 791         ivap = (u32 *)iva;
 792
 793         for (i = 0; i < 8; i++)
 794             *ivap++ = 0;
 795
 796         /* Compute Checksum for HPMC handler */
 797
 798         length = (u32)((unsigned long)os_hpmc_end - (unsigned long)os_hpmc);
 799         ivap[7] = length;
 800
 801         hpmcp = (u32 *)os_hpmc;
 802
 803         for (i=0; i<length/4; i++)
 804             check += *hpmcp++;
 805
 806         for (i=0; i<8; i++)
 807             check += ivap[i];
 808
 809         ivap[5] = -check;
 810
 811         return 0;
 812 }
 813
 814 #ifndef __LP64__
 815 extern const void fault_vector_11;
 816 #endif
 817 extern const void fault_vector_20;
 818
 819 void __init trap_init(void)
 820 {
 821         void *iva;
 822
 823         if (boot_cpu_data.cpu_type >= pcxu)
 824                 iva = (void *) &fault_vector_20;
 825         else
 826 #ifdef __LP64__
 827                 panic("Can't boot 64-bit OS on PA1.1 processor!");
 828 #else
 829                 iva = (void *) &fault_vector_11;
 830 #endif
 831
 832         if (check_ivt(iva))
 833                 panic("IVT invalid");
 834 }