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