arch/sparc64/kernel/traps.c

Name: Public Git Hosting - davej-history.git/blob - arch/sparc64/kernel/traps.c
Rating: 4.9 (5338 reviews)
 1 /* $Id: traps.c,v 1.59 1999/05/18 16:57:10 jj Exp $
 2  * arch/sparc64/kernel/traps.c
 3  *
 4  * Copyright (C) 1995,1997 David S. Miller (davem@caip.rutgers.edu)
 5  * Copyright (C) 1997,1999 Jakub Jelinek (jj@sunsite.mff.cuni.cz)
 6  */
 7
 8 /*
 9  * I like traps on v9, :))))
 10  */
 11
 12 #include <linux/config.h>
 13 #include <linux/sched.h>/* for jiffies */
 14 #include <linux/kernel.h>
 15 #include <linux/signal.h>
 16 #include <linux/smp.h>
 17 #include <linux/smp_lock.h>
 18
 19 #include <asm/delay.h>
 20 #include <asm/system.h>
 21 #include <asm/ptrace.h>
 22 #include <asm/oplib.h>
 23 #include <asm/page.h>
 24 #include <asm/pgtable.h>
 25 #include <asm/unistd.h>
 26 #include <asm/uaccess.h>
 27 #include <asm/fpumacro.h>
 28 #include <asm/lsu.h>
 29 #ifdef CONFIG_KMOD
 30 #include <linux/kmod.h>
 31 #endif
 32
 33 /* #define SYSCALL_TRACING */
 34 /* #define VERBOSE_SYSCALL_TRACING */
 35 /* #define DEBUG_FPU */
 36
 37 #ifdef SYSCALL_TRACING
 38 #ifdef VERBOSE_SYSCALL_TRACING
 39 struct sdesc {
 40 int scall_num;
 41 char*name;
 42 int num_args;
 43 char arg_is_string[6];
 44 } sdesc_entries[] = {
 45 {0,"setup",0, },
 46 {1,"exit",1, {0, } },
 47 {2,"fork",0, },
 48 {3,"read",3, {0,0,0, } },
 49 {4,"write",3, {0,0,0, } },
 50 {5,"open",3, {1,0,0, } },
 51 {6,"close",1, {0, } },
 52 {7,"wait4",4, {0,0,0,0, } },
 53 {8,"creat",2, {1,0, } },
 54 {9,"link",2, {1,1, } },
 55 {10,"unlink",1, {1, } },
 56 {11,"execv",2, {1,0, } },
 57 {12,"chdir",1, {1, } },
 58 {15,"chmod",2, {1,0, } },
 59 {16,"chown",3, {1,0,0, } },
 60 {17,"brk",1, {0, } },
 61 {19,"lseek",3, {0,0,0, } },
 62 {27,"alarm",1, {0, } },
 63 {29,"pause",0, },
 64 {33,"access",2, {1,0, } },
 65 {36,"sync",0, },
 66 {37,"kill",2, {0,0, } },
 67 {38,"stat",2, {1,0, } },
 68 {40,"lstat",2, {1,0, } },
 69 {41,"dup",1, {0, } },
 70 {42,"pipd",0, },
 71 {54,"ioctl",3, {0,0,0, } },
 72 {57,"symlink",2, {1,1, } },
 73 {58,"readlink",3, {1,0,0, } },
 74 {59,"execve",3, {1,0,0, } },
 75 {60,"umask",1, {0, } },
 76 {62,"fstat",2, {0,0, } },
 77 {64,"getpagesize",0, },
 78 {71,"mmap",6, {0,0,0,0,0,0, } },
 79 {73,"munmap",2, {0,0, } },
 80 {74,"mprotect",3, {0,0,0, } },
 81 {83,"setitimer",3, {0,0,0, } },
 82 {90,"dup2",2, {0,0, } },
 83 {92,"fcntl",3, {0,0,0, } },
 84 {93,"select",5, {0,0,0,0,0, } },
 85 {97,"socket",3, {0,0,0, } },
 86 {98,"connect",3, {0,0,0, } },
 87 {99,"accept",3, {0,0,0, } },
 88 {101,"send",4, {0,0,0,0, } },
 89 {102,"recv",4, {0,0,0,0, } },
 90 {104,"bind",3, {0,0,0, } },
 91 {105,"setsockopt",5, {0,0,0,0,0, } },
 92 {106,"listen",2, {0,0, } },
 93 {120,"readv",3, {0,0,0, } },
 94 {121,"writev",3, {0,0,0, } },
 95 {123,"fchown",3, {0,0,0, } },
 96 {124,"fchmod",2, {0,0, } },
 97 {128,"rename",2, {1,1, } },
 98 {129,"truncate",2, {1,0, } },
 99 {130,"ftruncate",2, {0,0, } },
 100 {131,"flock",2, {0,0, } },
 101 {136,"mkdir",2, {1,0, } },
 102 {137,"rmdir",1, {1, } },
 103 {146,"killpg",1, {0, } },
 104 {157,"statfs",2, {1,0, } },
 105 {158,"fstatfs",2, {0,0, } },
 106 {159,"umount",1, {1, } },
 107 {167,"mount",5, {1,1,1,0,0, } },
 108 {174,"getdents",3, {0,0,0, } },
 109 {176,"fchdir",2, {0,0, } },
 110 {198,"sigaction",3, {0,0,0, } },
 111 {201,"sigsuspend",1, {0, } },
 112 {206,"socketcall",2, {0,0, } },
 113 {216,"sigreturn",0, },
 114 {230,"newselect",5, {0,0,0,0,0, } },
 115 {236,"llseek",5, {0,0,0,0,0, } },
 116 {251,"sysctl",1, {0, } },
 117 };
 118 #define NUM_SDESC_ENTRIES (sizeof(sdesc_entries) / sizeof(sdesc_entries[0]))
 119 #endif
 120
 121 #ifdef VERBOSE_SYSCALL_TRACING
 122 static char scall_strbuf[512];
 123 #endif
 124
 125 voidsyscall_trace_entry(unsigned long g1,struct pt_regs *regs)
 126 {
 127 #ifdef VERBOSE_SYSCALL_TRACING
 128 struct sdesc *sdp;
 129 int i;
 130 #endif
 131
 132 #if 0
 133 if(!current->pid)return;
 134 #endif
 135 printk("SYS[%s:%d]: PC(%016lx) <%3d> ",
 136  current->comm, current->pid, regs->tpc, (int)g1);
 137 #ifdef VERBOSE_SYSCALL_TRACING
 138  sdp = NULL;
 139 for(i =0; i < NUM_SDESC_ENTRIES; i++)
 140 if(sdesc_entries[i].scall_num == g1) {
 141  sdp = &sdesc_entries[i];
 142 break;
 143 }
 144 if(sdp) {
 145 printk("%s(", sdp->name);
 146 for(i =0; i < sdp->num_args; i++) {
 147 if(i)
 148 printk(",");
 149 if(!sdp->arg_is_string[i]) {
 150 if(current->tss.flags & SPARC_FLAG_32BIT)
 151 printk("%08x", (unsigned int)regs->u_regs[UREG_I0 + i]);
 152 else
 153 printk("%016lx", regs->u_regs[UREG_I0 + i]);
 154 }else{
 155 if(current->tss.flags & SPARC_FLAG_32BIT)
 156 strncpy_from_user(scall_strbuf,
 157 (char*)(regs->u_regs[UREG_I0 + i] &0xffffffff),
 158 512);
 159 else
 160 strncpy_from_user(scall_strbuf,
 161 (char*)regs->u_regs[UREG_I0 + i],
 162 512);
 163 printk("%s", scall_strbuf);
 164 }
 165 }
 166 printk(") ");
 167 }
 168 #endif
 169 }
 170
 171 unsigned longsyscall_trace_exit(unsigned long retval,struct pt_regs *regs)
 172 {
 173 #if 0
 174 if(current->pid)
 175 #endif
 176 printk("ret[%016lx]\n", retval);
 177 return retval;
 178 }
 179 #endif/* SYSCALL_TRACING */
 180
 181 #if 0
 182 voidrtrap_check(struct pt_regs *regs)
 183 {
 184 registerunsigned long pgd_phys asm("o1");
 185 registerunsigned long pgd_cache asm("o2");
 186 registerunsigned long g1_or_g3 asm("o3");
 187 registerunsigned long g2 asm("o4");
 188 unsigned long ctx;
 189
 190 #if 0
 191 do{
 192 unsigned long test;
 193  __asm__ __volatile__("rdpr %%pstate, %0"
 194 :"=r"(test));
 195 if((test & PSTATE_MG) !=0||
 196 (test & PSTATE_IE) ==0) {
 197 printk("rtrap_check: Bogus pstate[%016lx]\n", test);
 198 return;
 199 }
 200 }while(0);
 201 #endif
 202
 203  __asm__ __volatile__("
 204  rdpr %%pstate, %%o5
 205  wrpr %%o5, %4, %%pstate
 206  or %%g1, %%g3, %2
 207  mov %%g2, %3
 208  mov %%g7, %0
 209  mov %5, %1
 210  ldxa [%1] %6, %1
 211  wrpr %%o5, 0x0, %%pstate"
 212 :"=r"(pgd_phys),"=r"(pgd_cache),
 213 "=r"(g1_or_g3),"=r"(g2)
 214 :"i"(PSTATE_IE | PSTATE_MG),"i"(TSB_REG),
 215 "i"(ASI_DMMU)
 216 :"o5");
 217
 218  ctx =spitfire_get_secondary_context();
 219
 220 if((pgd_phys !=__pa(current->mm->pgd)) ||
 221 ((pgd_cache !=0) &&
 222 (pgd_cache !=pgd_val(current->mm->pgd[0]))) ||
 223 (g1_or_g3 != (0xfffffffe00000000UL |0x0000000000000018UL)) ||
 224 #define KERN_HIGHBITS ((_PAGE_VALID | _PAGE_SZ4MB) ^ 0xfffff80000000000)
 225 #define KERN_LOWBITS (_PAGE_CP | _PAGE_CV | _PAGE_P | _PAGE_W)
 226 (g2 != (KERN_HIGHBITS | KERN_LOWBITS)) ||
 227 #undef KERN_HIGHBITS
 228 #undef KERN_LOWBITS
 229 ((ctx != (current->mm->context &0x3ff)) ||
 230 (ctx ==0) ||
 231 (current->tss.ctx != ctx))) {
 232 printk("SHIT[%s:%d]: "
 233 "(PP[%016lx] CACH[%016lx] CTX[%x] g1g3[%016lx] g2[%016lx]) ",
 234  current->comm, current->pid,
 235  pgd_phys, pgd_cache, ctx, g1_or_g3, g2);
 236 printk("SHIT[%s:%d]: "
 237 "[PP[%016lx] CACH[%016lx] CTX[%x:%x]] PC[%016lx:%016lx]\n",
 238  current->comm, current->pid,
 239 __pa(current->mm->pgd),
 240 pgd_val(current->mm->pgd[0]),
 241  current->mm->context &0x3ff,
 242  current->tss.ctx,
 243  regs->tpc, regs->tnpc);
 244 show_regs(regs);
 245 #if 1
 246 __sti();
 247 while(1)
 248 barrier();
 249 #endif
 250 }
 251 }
 252 #endif
 253
 254 voidbad_trap(struct pt_regs *regs,long lvl)
 255 {
 256 lock_kernel();
 257 if(lvl <0x100) {
 258 char buffer[24];
 259
 260 sprintf(buffer,"Bad hw trap %lx at tl0\n", lvl);
 261 die_if_kernel(buffer, regs);
 262 }
 263 if(regs->tstate & TSTATE_PRIV)
 264 die_if_kernel("Kernel bad trap", regs);
 265  current->tss.sig_desc =SUBSIG_BADTRAP(lvl -0x100);
 266  current->tss.sig_address = regs->tpc;
 267 force_sig(SIGILL, current);
 268 unlock_kernel();
 269 }
 270
 271 voidbad_trap_tl1(struct pt_regs *regs,long lvl)
 272 {
 273 char buffer[24];
 274
 275 lock_kernel();
 276 sprintf(buffer,"Bad trap %lx at tl>0", lvl);
 277 die_if_kernel(buffer, regs);
 278 unlock_kernel();
 279 }
 280
 281 voidinstruction_access_exception(struct pt_regs *regs,
 282 unsigned long sfsr,unsigned long sfar)
 283 {
 284 lock_kernel();
 285 #if 1
 286 printk("instruction_access_exception: Shit SFSR[%016lx] SFAR[%016lx], going.\n",
 287  sfsr, sfar);
 288 #endif
 289 die_if_kernel("Iax", regs);
 290 unlock_kernel();
 291 }
 292
 293 voiddata_access_exception(struct pt_regs *regs,
 294 unsigned long sfsr,unsigned long sfar)
 295 {
 296 if(regs->tstate & TSTATE_PRIV) {
 297 /* Test if this comes from uaccess places. */
 298 unsigned long fixup, g2;
 299
 300  g2 = regs->u_regs[UREG_G2];
 301 if((fixup =search_exception_table(regs->tpc, &g2))) {
 302 /* Ouch, somebody is trying ugly VM hole tricks on us... */
 303 #ifdef DEBUG_EXCEPTIONS
 304 printk("Exception: PC<%016lx> faddr<UNKNOWN>\n", regs->tpc);
 305 printk("EX_TABLE: insn<%016lx> fixup<%016lx> "
 306 "g2<%016lx>\n", regs->tpc, fixup, g2);
 307 #endif
 308  regs->tpc = fixup;
 309  regs->tnpc = regs->tpc +4;
 310  regs->u_regs[UREG_G2] = g2;
 311 return;
 312 }
 313 /* Shit... */
 314 #if 1
 315 printk("data_access_exception: Shit SFSR[%016lx] SFAR[%016lx], going.\n",
 316  sfsr, sfar);
 317 #endif
 318 die_if_kernel("Dax", regs);
 319 }
 320 #if 0
 321 else
 322 rtrap_check(regs);
 323 #endif
 324 lock_kernel();
 325 force_sig(SIGSEGV, current);
 326 unlock_kernel();
 327 }
 328
 329 #ifdef CONFIG_PCI
 330 /* This is really pathetic... */
 331 /* #define DEBUG_PCI_POKES */
 332 extern volatileint pci_poke_in_progress;
 333 extern volatileint pci_poke_faulted;
 334 #endif
 335
 336 /* When access exceptions happen, we must do this. */
 337 static __inline__ voidclean_and_reenable_l1_caches(void)
 338 {
 339 unsigned long va;
 340
 341 /* Clean 'em. */
 342 for(va =0; va < (PAGE_SIZE <<1); va +=32) {
 343 spitfire_put_icache_tag(va,0x0);
 344 spitfire_put_dcache_tag(va,0x0);
 345 }
 346
 347 /* Re-enable. */
 348  __asm__ __volatile__("flush %%g6\n\t"
 349 "membar #Sync\n\t"
 350 "stxa %0, [%%g0] %1\n\t"
 351 "membar #Sync"
 352 :/* no outputs */
 353 :"r"(LSU_CONTROL_IC | LSU_CONTROL_DC |
 354  LSU_CONTROL_IM | LSU_CONTROL_DM),
 355 "i"(ASI_LSU_CONTROL)
 356 :"memory");
 357 }
 358
 359 voiddo_dae(struct pt_regs *regs)
 360 {
 361 #ifdef CONFIG_PCI
 362 if(pci_poke_in_progress) {
 363 #ifdef DEBUG_PCI_POKES
 364 prom_printf(" (POKE tpc[%016lx] tnpc[%016lx] ",
 365  regs->tpc, regs->tnpc);
 366 #endif
 367  pci_poke_faulted =1;
 368  regs->tnpc = regs->tpc +4;
 369
 370
 371 #ifdef DEBUG_PCI_POKES
 372 prom_printf("PCI) ");
 373 /* prom_halt(); */
 374 #endif
 375 clean_and_reenable_l1_caches();
 376 return;
 377 }
 378 #endif
 379 clean_and_reenable_l1_caches();
 380 lock_kernel();
 381 force_sig(SIGSEGV, current);
 382 unlock_kernel();
 383 }
 384
 385 voiddo_iae(struct pt_regs *regs)
 386 {
 387 clean_and_reenable_l1_caches();
 388
 389 lock_kernel();
 390 force_sig(SIGSEGV, current);
 391 unlock_kernel();
 392 }
 393
 394 voiddo_fpe_common(struct pt_regs *regs)
 395 {
 396 if(regs->tstate & TSTATE_PRIV) {
 397  regs->tpc = regs->tnpc;
 398  regs->tnpc +=4;
 399 }else{
 400  current->tss.sig_address = regs->tpc;
 401  current->tss.sig_desc = SUBSIG_FPERROR;
 402 send_sig(SIGFPE, current,1);
 403 }
 404 }
 405
 406 voiddo_fpieee(struct pt_regs *regs)
 407 {
 408 #ifdef DEBUG_FPU
 409 printk("fpieee %016lx\n", current->tss.xfsr[0]);
 410 #endif
 411 do_fpe_common(regs);
 412 }
 413
 414 externintdo_mathemu(struct pt_regs *,struct fpustate *);
 415
 416 voiddo_fpother(struct pt_regs *regs)
 417 {
 418 struct fpustate *f = FPUSTATE;
 419 int ret =0;
 420
 421 switch((current->tss.xfsr[0] &0x1c000)) {
 422 case(2<<14):/* unfinished_FPop */
 423 case(3<<14):/* unimplemented_FPop */
 424  ret =do_mathemu(regs, f);
 425 break;
 426 }
 427 if(ret)return;
 428 #ifdef DEBUG_FPU
 429 printk("fpother %016lx\n", current->tss.xfsr[0]);
 430 #endif
 431 do_fpe_common(regs);
 432 }
 433
 434 voiddo_tof(struct pt_regs *regs)
 435 {
 436 if(regs->tstate & TSTATE_PRIV)
 437 die_if_kernel("Penguin overflow trap from kernel mode", regs);
 438  current->tss.sig_address = regs->tpc;
 439  current->tss.sig_desc = SUBSIG_TAG;/* as good as any */
 440 send_sig(SIGEMT, current,1);
 441 }
 442
 443 voiddo_div0(struct pt_regs *regs)
 444 {
 445 send_sig(SIGILL, current,1);
 446 }
 447
 448 voidinstruction_dump(unsigned int*pc)
 449 {
 450 int i;
 451
 452 if((((unsigned long) pc) &3))
 453 return;
 454
 455 printk("Instruction DUMP:");
 456 for(i = -3; i <6; i++)
 457 printk("%c%08x%c",i?' ':'<',pc[i],i?' ':'>');
 458 printk("\n");
 459 }
 460
 461 voiduser_instruction_dump(unsigned int*pc)
 462 {
 463 int i;
 464 unsigned int buf[9];
 465
 466 if((((unsigned long) pc) &3))
 467 return;
 468
 469 if(copy_from_user(buf, pc -3,sizeof(buf)))
 470 return;
 471
 472 printk("Instruction DUMP:");
 473 for(i =0; i <9; i++)
 474 printk("%c%08x%c",i==3?' ':'<',buf[i],i==3?' ':'>');
 475 printk("\n");
 476 }
 477
 478 voiddie_if_kernel(char*str,struct pt_regs *regs)
 479 {
 480 externvoid__show_regs(struct pt_regs * regs);
 481 externvoidsmp_report_regs(void);
 482 int count =0;
 483 struct reg_window *lastrw;
 484
 485 /* Amuse the user. */
 486 printk(
 487 "\\|/ ____\\|/\n"
 488 "\"@'/ ..\\`@\"\n"
 489 " /_|\\__/ |_\\\n"
 490 "\\__U_/\n");
 491
 492 printk("%s(%d): %s\n", current->comm, current->pid, str);
 493  __asm__ __volatile__("flushw");
 494 __show_regs(regs);
 495 if(regs->tstate & TSTATE_PRIV) {
 496 struct reg_window *rw = (struct reg_window *)
 497 (regs->u_regs[UREG_FP] + STACK_BIAS);
 498
 499 /* Stop the back trace when we hit userland or we
 500  * find some badly aligned kernel stack.
 501  */
 502  lastrw = (struct reg_window *)current;
 503 while(rw &&
 504  count++ <30&&
 505  rw >= lastrw &&
 506 (char*) rw < ((char*) current)
 507 +sizeof(union task_union) &&
 508 !(((unsigned long) rw) &0x7)) {
 509 printk("Caller[%016lx]\n", rw->ins[7]);
 510  lastrw = rw;
 511  rw = (struct reg_window *)
 512 (rw->ins[6] + STACK_BIAS);
 513 }
 514 instruction_dump((unsigned int*) regs->tpc);
 515 }else
 516 user_instruction_dump((unsigned int*) regs->tpc);
 517 #ifdef __SMP__
 518 smp_report_regs();
 519 #endif
 520
 521 lock_kernel();/* Or else! */
 522 if(regs->tstate & TSTATE_PRIV)
 523 do_exit(SIGKILL);
 524 do_exit(SIGSEGV);
 525 }
 526
 527 externinthandle_popc(u32 insn,struct pt_regs *regs);
 528 externinthandle_ldf_stq(u32 insn,struct pt_regs *regs);
 529
 530 voiddo_illegal_instruction(struct pt_regs *regs)
 531 {
 532 unsigned long pc = regs->tpc;
 533 unsigned long tstate = regs->tstate;
 534  u32 insn;
 535
 536 if(tstate & TSTATE_PRIV)
 537 die_if_kernel("Kernel illegal instruction", regs);
 538 if(current->tss.flags & SPARC_FLAG_32BIT)
 539  pc = (u32)pc;
 540 if(get_user(insn, (u32 *)pc) != -EFAULT) {
 541 if((insn &0xc1ffc000) ==0x81700000)/* POPC */{
 542 if(handle_popc(insn, regs))
 543 return;
 544 }else if((insn &0xc1580000) ==0xc1100000)/* LDQ/STQ */{
 545 if(handle_ldf_stq(insn, regs))
 546 return;
 547 }
 548 }
 549  current->tss.sig_address = pc;
 550  current->tss.sig_desc = SUBSIG_ILLINST;
 551 send_sig(SIGILL, current,1);
 552 }
 553
 554 voidmem_address_unaligned(struct pt_regs *regs,unsigned long sfar,unsigned long sfsr)
 555 {
 556 if(regs->tstate & TSTATE_PRIV) {
 557 externvoidkernel_unaligned_trap(struct pt_regs *regs,
 558 unsigned int insn,
 559 unsigned long sfar,unsigned long sfsr);
 560
 561 returnkernel_unaligned_trap(regs, *((unsigned int*)regs->tpc), sfar, sfsr);
 562 }else{
 563  current->tss.sig_address = regs->tpc;
 564  current->tss.sig_desc = SUBSIG_PRIVINST;
 565 send_sig(SIGBUS, current,1);
 566 }
 567 }
 568
 569 voiddo_privop(struct pt_regs *regs)
 570 {
 571  current->tss.sig_address = regs->tpc;
 572  current->tss.sig_desc = SUBSIG_PRIVINST;
 573 send_sig(SIGILL, current,1);
 574 }
 575
 576 voiddo_privact(struct pt_regs *regs)
 577 {
 578  current->tss.sig_address = regs->tpc;
 579  current->tss.sig_desc = SUBSIG_PRIVINST;
 580 send_sig(SIGILL, current,1);
 581 }
 582
 583 voiddo_priv_instruction(struct pt_regs *regs,unsigned long pc,unsigned long npc,
 584 unsigned long tstate)
 585 {
 586 if(tstate & TSTATE_PRIV)
 587 die_if_kernel("Penguin instruction from Penguin mode??!?!", regs);
 588  current->tss.sig_address = pc;
 589  current->tss.sig_desc = SUBSIG_PRIVINST;
 590 send_sig(SIGILL, current,1);
 591 }
 592
 593 voidhandle_hw_divzero(struct pt_regs *regs,unsigned long pc,unsigned long npc,
 594 unsigned long psr)
 595 {
 596 send_sig(SIGILL, current,1);
 597 }
 598
 599 /* Trap level 1 stuff or other traps we should never see... */
 600 voiddo_cee(struct pt_regs *regs)
 601 {
 602 die_if_kernel("TL0: Cache Error Exception", regs);
 603 }
 604
 605 voiddo_cee_tl1(struct pt_regs *regs)
 606 {
 607 die_if_kernel("TL1: Cache Error Exception", regs);
 608 }
 609
 610 voiddo_dae_tl1(struct pt_regs *regs)
 611 {
 612 die_if_kernel("TL1: Data Access Exception", regs);
 613 }
 614
 615 voiddo_iae_tl1(struct pt_regs *regs)
 616 {
 617 die_if_kernel("TL1: Instruction Access Exception", regs);
 618 }
 619
 620 voiddo_div0_tl1(struct pt_regs *regs)
 621 {
 622 die_if_kernel("TL1: DIV0 Exception", regs);
 623 }
 624
 625 voiddo_fpdis_tl1(struct pt_regs *regs)
 626 {
 627 die_if_kernel("TL1: FPU Disabled", regs);
 628 }
 629
 630 voiddo_fpieee_tl1(struct pt_regs *regs)
 631 {
 632 die_if_kernel("TL1: FPU IEEE Exception", regs);
 633 }
 634
 635 voiddo_fpother_tl1(struct pt_regs *regs)
 636 {
 637 die_if_kernel("TL1: FPU Other Exception", regs);
 638 }
 639
 640 voiddo_ill_tl1(struct pt_regs *regs)
 641 {
 642 die_if_kernel("TL1: Illegal Instruction Exception", regs);
 643 }
 644
 645 voiddo_irq_tl1(struct pt_regs *regs)
 646 {
 647 die_if_kernel("TL1: IRQ Exception", regs);
 648 }
 649
 650 voiddo_lddfmna_tl1(struct pt_regs *regs)
 651 {
 652 die_if_kernel("TL1: LDDF Exception", regs);
 653 }
 654
 655 voiddo_stdfmna_tl1(struct pt_regs *regs)
 656 {
 657 die_if_kernel("TL1: STDF Exception", regs);
 658 }
 659
 660 voiddo_paw(struct pt_regs *regs)
 661 {
 662 die_if_kernel("TL0: Phys Watchpoint Exception", regs);
 663 }
 664
 665 voiddo_paw_tl1(struct pt_regs *regs)
 666 {
 667 die_if_kernel("TL1: Phys Watchpoint Exception", regs);
 668 }
 669
 670 voiddo_vaw(struct pt_regs *regs)
 671 {
 672 die_if_kernel("TL0: Virt Watchpoint Exception", regs);
 673 }
 674
 675 voiddo_vaw_tl1(struct pt_regs *regs)
 676 {
 677 die_if_kernel("TL1: Virt Watchpoint Exception", regs);
 678 }
 679
 680 voiddo_tof_tl1(struct pt_regs *regs)
 681 {
 682 die_if_kernel("TL1: Tag Overflow Exception", regs);
 683 }
 684
 685 #ifdef CONFIG_EC_FLUSH_TRAP
 686 voidcache_flush_trap(struct pt_regs *regs)
 687 {
 688 #ifndef __SMP__
 689 unsigned node = linux_cpus[get_cpuid()].prom_node;
 690 #else
 691 #error cache_flush_trap not supported on sparc64/SMP yet
 692 #endif
 693
 694 #if 0
 695 /* Broken */
 696 int size =prom_getintdefault(node,"ecache-size",512*1024);
 697 int i, j;
 698 unsigned long addr;
 699 struct page *page, *end;
 700
 701  regs->tpc = regs->tnpc;
 702  regs->tnpc = regs->tnpc +4;
 703 if(!capable(CAP_SYS_ADMIN))return;
 704  size >>= PAGE_SHIFT;
 705  addr = PAGE_OFFSET - PAGE_SIZE;
 706  page = mem_map -1;
 707  end = mem_map + max_mapnr;
 708 for(i =0; i < size; i++) {
 709 do{
 710  addr += PAGE_SIZE;
 711  page++;
 712 if(page >= end)
 713 return;
 714 }while(!PageReserved(page));
 715 /* E-Cache line size is 64B. Let us pollute it :)) */
 716 for(j =0; j < PAGE_SIZE; j +=64)
 717  __asm__ __volatile__("ldx [%0 + %1], %%g1": :"r"(j),"r"(addr) :"g1");
 718 }
 719 #endif
 720 }
 721 #endif
 722
 723 voidtrap_init(void)
 724 {
 725 }