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