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