1 /* 2 * arch/sparc/kernel/traps.c 3 * 4 * Copyright 1995, 2008 David S. Miller (davem@davemloft.net) 5 * Copyright 2000 Jakub Jelinek (jakub@redhat.com) 6 */ 7 8 /* 9 * I hate traps on the sparc, grrr... 10 */ 11 12 #include <linux/sched.h> /* for jiffies */ 13 #include <linux/kernel.h> 14 #include <linux/signal.h> 15 #include <linux/smp.h> 16 #include <linux/kdebug.h> 17 #include <linux/export.h> 18 19 #include <asm/delay.h> 20 #include <asm/ptrace.h> 21 #include <asm/oplib.h> 22 #include <asm/page.h> 23 #include <asm/pgtable.h> 24 #include <asm/unistd.h> 25 #include <asm/traps.h> 26 27 #include "entry.h" 28 #include "kernel.h" 29 30 /* #define TRAP_DEBUG */ 31 32 static void instruction_dump(unsigned long *pc) 33 { 34 int i; 35 36 if((((unsigned long) pc) & 3)) 37 return; 38 39 for(i = -3; i < 6; i++) 40 printk("%c%08lx%c",i?' ':'<',pc[i],i?' ':'>'); 41 printk("\n"); 42 } 43 44 #define __SAVE __asm__ __volatile__("save %sp, -0x40, %sp\n\t") 45 #define __RESTORE __asm__ __volatile__("restore %g0, %g0, %g0\n\t") 46 47 void __noreturn die_if_kernel(char *str, struct pt_regs *regs) 48 { 49 static int die_counter; 50 int count = 0; 51 52 /* Amuse the user. */ 53 printk( 54 " \\|/ ____ \\|/\n" 55 " \"@'/ ,. \\`@\"\n" 56 " /_| \\__/ |_\\\n" 57 " \\__U_/\n"); 58 59 printk("%s(%d): %s [#%d]\n", current->comm, task_pid_nr(current), str, ++die_counter); 60 show_regs(regs); 61 add_taint(TAINT_DIE, LOCKDEP_NOW_UNRELIABLE); 62 63 __SAVE; __SAVE; __SAVE; __SAVE; 64 __SAVE; __SAVE; __SAVE; __SAVE; 65 __RESTORE; __RESTORE; __RESTORE; __RESTORE; 66 __RESTORE; __RESTORE; __RESTORE; __RESTORE; 67 68 { 69 struct reg_window32 *rw = (struct reg_window32 *)regs->u_regs[UREG_FP]; 70 71 /* Stop the back trace when we hit userland or we 72 * find some badly aligned kernel stack. Set an upper 73 * bound in case our stack is trashed and we loop. 74 */ 75 while(rw && 76 count++ < 30 && 77 (((unsigned long) rw) >= PAGE_OFFSET) && 78 !(((unsigned long) rw) & 0x7)) { 79 printk("Caller[%08lx]: %pS\n", rw->ins[7], 80 (void *) rw->ins[7]); 81 rw = (struct reg_window32 *)rw->ins[6]; 82 } 83 } 84 printk("Instruction DUMP:"); 85 instruction_dump ((unsigned long *) regs->pc); 86 if(regs->psr & PSR_PS) 87 do_exit(SIGKILL); 88 do_exit(SIGSEGV); 89 } 90 91 void do_hw_interrupt(struct pt_regs *regs, unsigned long type) 92 { 93 siginfo_t info; 94 95 if(type < 0x80) { 96 /* Sun OS's puke from bad traps, Linux survives! */ 97 printk("Unimplemented Sparc TRAP, type = %02lx\n", type); 98 die_if_kernel("Whee... Hello Mr. Penguin", regs); 99 } 100 101 if(regs->psr & PSR_PS) 102 die_if_kernel("Kernel bad trap", regs); 103 104 info.si_signo = SIGILL; 105 info.si_errno = 0; 106 info.si_code = ILL_ILLTRP; 107 info.si_addr = (void __user *)regs->pc; 108 info.si_trapno = type - 0x80; 109 force_sig_info(SIGILL, &info, current); 110 } 111 112 void do_illegal_instruction(struct pt_regs *regs, unsigned long pc, unsigned long npc, 113 unsigned long psr) 114 { 115 siginfo_t info; 116 117 if(psr & PSR_PS) 118 die_if_kernel("Kernel illegal instruction", regs); 119 #ifdef TRAP_DEBUG 120 printk("Ill instr. at pc=%08lx instruction is %08lx\n", 121 regs->pc, *(unsigned long *)regs->pc); 122 #endif 123 124 info.si_signo = SIGILL; 125 info.si_errno = 0; 126 info.si_code = ILL_ILLOPC; 127 info.si_addr = (void __user *)pc; 128 info.si_trapno = 0; 129 send_sig_info(SIGILL, &info, current); 130 } 131 132 void do_priv_instruction(struct pt_regs *regs, unsigned long pc, unsigned long npc, 133 unsigned long psr) 134 { 135 siginfo_t info; 136 137 if(psr & PSR_PS) 138 die_if_kernel("Penguin instruction from Penguin mode??!?!", regs); 139 info.si_signo = SIGILL; 140 info.si_errno = 0; 141 info.si_code = ILL_PRVOPC; 142 info.si_addr = (void __user *)pc; 143 info.si_trapno = 0; 144 send_sig_info(SIGILL, &info, current); 145 } 146 147 /* XXX User may want to be allowed to do this. XXX */ 148 149 void do_memaccess_unaligned(struct pt_regs *regs, unsigned long pc, unsigned long npc, 150 unsigned long psr) 151 { 152 siginfo_t info; 153 154 if(regs->psr & PSR_PS) { 155 printk("KERNEL MNA at pc %08lx npc %08lx called by %08lx\n", pc, npc, 156 regs->u_regs[UREG_RETPC]); 157 die_if_kernel("BOGUS", regs); 158 /* die_if_kernel("Kernel MNA access", regs); */ 159 } 160 #if 0 161 show_regs (regs); 162 instruction_dump ((unsigned long *) regs->pc); 163 printk ("do_MNA!\n"); 164 #endif 165 info.si_signo = SIGBUS; 166 info.si_errno = 0; 167 info.si_code = BUS_ADRALN; 168 info.si_addr = /* FIXME: Should dig out mna address */ (void *)0; 169 info.si_trapno = 0; 170 send_sig_info(SIGBUS, &info, current); 171 } 172 173 static unsigned long init_fsr = 0x0UL; 174 static unsigned long init_fregs[32] __attribute__ ((aligned (8))) = 175 { ~0UL, ~0UL, ~0UL, ~0UL, ~0UL, ~0UL, ~0UL, ~0UL, 176 ~0UL, ~0UL, ~0UL, ~0UL, ~0UL, ~0UL, ~0UL, ~0UL, 177 ~0UL, ~0UL, ~0UL, ~0UL, ~0UL, ~0UL, ~0UL, ~0UL, 178 ~0UL, ~0UL, ~0UL, ~0UL, ~0UL, ~0UL, ~0UL, ~0UL }; 179 180 void do_fpd_trap(struct pt_regs *regs, unsigned long pc, unsigned long npc, 181 unsigned long psr) 182 { 183 /* Sanity check... */ 184 if(psr & PSR_PS) 185 die_if_kernel("Kernel gets FloatingPenguinUnit disabled trap", regs); 186 187 put_psr(get_psr() | PSR_EF); /* Allow FPU ops. */ 188 regs->psr |= PSR_EF; 189 #ifndef CONFIG_SMP 190 if(last_task_used_math == current) 191 return; 192 if(last_task_used_math) { 193 /* Other processes fpu state, save away */ 194 struct task_struct *fptask = last_task_used_math; 195 fpsave(&fptask->thread.float_regs[0], &fptask->thread.fsr, 196 &fptask->thread.fpqueue[0], &fptask->thread.fpqdepth); 197 } 198 last_task_used_math = current; 199 if(used_math()) { 200 fpload(¤t->thread.float_regs[0], ¤t->thread.fsr); 201 } else { 202 /* Set initial sane state. */ 203 fpload(&init_fregs[0], &init_fsr); 204 set_used_math(); 205 } 206 #else 207 if(!used_math()) { 208 fpload(&init_fregs[0], &init_fsr); 209 set_used_math(); 210 } else { 211 fpload(¤t->thread.float_regs[0], ¤t->thread.fsr); 212 } 213 set_thread_flag(TIF_USEDFPU); 214 #endif 215 } 216 217 static unsigned long fake_regs[32] __attribute__ ((aligned (8))); 218 static unsigned long fake_fsr; 219 static unsigned long fake_queue[32] __attribute__ ((aligned (8))); 220 static unsigned long fake_depth; 221 222 void do_fpe_trap(struct pt_regs *regs, unsigned long pc, unsigned long npc, 223 unsigned long psr) 224 { 225 static int calls; 226 siginfo_t info; 227 unsigned long fsr; 228 int ret = 0; 229 #ifndef CONFIG_SMP 230 struct task_struct *fpt = last_task_used_math; 231 #else 232 struct task_struct *fpt = current; 233 #endif 234 put_psr(get_psr() | PSR_EF); 235 /* If nobody owns the fpu right now, just clear the 236 * error into our fake static buffer and hope it don't 237 * happen again. Thank you crashme... 238 */ 239 #ifndef CONFIG_SMP 240 if(!fpt) { 241 #else 242 if (!test_tsk_thread_flag(fpt, TIF_USEDFPU)) { 243 #endif 244 fpsave(&fake_regs[0], &fake_fsr, &fake_queue[0], &fake_depth); 245 regs->psr &= ~PSR_EF; 246 return; 247 } 248 fpsave(&fpt->thread.float_regs[0], &fpt->thread.fsr, 249 &fpt->thread.fpqueue[0], &fpt->thread.fpqdepth); 250 #ifdef DEBUG_FPU 251 printk("Hmm, FP exception, fsr was %016lx\n", fpt->thread.fsr); 252 #endif 253 254 switch ((fpt->thread.fsr & 0x1c000)) { 255 /* switch on the contents of the ftt [floating point trap type] field */ 256 #ifdef DEBUG_FPU 257 case (1 << 14): 258 printk("IEEE_754_exception\n"); 259 break; 260 #endif 261 case (2 << 14): /* unfinished_FPop (underflow & co) */ 262 case (3 << 14): /* unimplemented_FPop (quad stuff, maybe sqrt) */ 263 ret = do_mathemu(regs, fpt); 264 break; 265 #ifdef DEBUG_FPU 266 case (4 << 14): 267 printk("sequence_error (OS bug...)\n"); 268 break; 269 case (5 << 14): 270 printk("hardware_error (uhoh!)\n"); 271 break; 272 case (6 << 14): 273 printk("invalid_fp_register (user error)\n"); 274 break; 275 #endif /* DEBUG_FPU */ 276 } 277 /* If we successfully emulated the FPop, we pretend the trap never happened :-> */ 278 if (ret) { 279 fpload(¤t->thread.float_regs[0], ¤t->thread.fsr); 280 return; 281 } 282 /* nope, better SIGFPE the offending process... */ 283 284 #ifdef CONFIG_SMP 285 clear_tsk_thread_flag(fpt, TIF_USEDFPU); 286 #endif 287 if(psr & PSR_PS) { 288 /* The first fsr store/load we tried trapped, 289 * the second one will not (we hope). 290 */ 291 printk("WARNING: FPU exception from kernel mode. at pc=%08lx\n", 292 regs->pc); 293 regs->pc = regs->npc; 294 regs->npc += 4; 295 calls++; 296 if(calls > 2) 297 die_if_kernel("Too many Penguin-FPU traps from kernel mode", 298 regs); 299 return; 300 } 301 302 fsr = fpt->thread.fsr; 303 info.si_signo = SIGFPE; 304 info.si_errno = 0; 305 info.si_addr = (void __user *)pc; 306 info.si_trapno = 0; 307 info.si_code = __SI_FAULT; 308 if ((fsr & 0x1c000) == (1 << 14)) { 309 if (fsr & 0x10) 310 info.si_code = FPE_FLTINV; 311 else if (fsr & 0x08) 312 info.si_code = FPE_FLTOVF; 313 else if (fsr & 0x04) 314 info.si_code = FPE_FLTUND; 315 else if (fsr & 0x02) 316 info.si_code = FPE_FLTDIV; 317 else if (fsr & 0x01) 318 info.si_code = FPE_FLTRES; 319 } 320 send_sig_info(SIGFPE, &info, fpt); 321 #ifndef CONFIG_SMP 322 last_task_used_math = NULL; 323 #endif 324 regs->psr &= ~PSR_EF; 325 if(calls > 0) 326 calls=0; 327 } 328 329 void handle_tag_overflow(struct pt_regs *regs, unsigned long pc, unsigned long npc, 330 unsigned long psr) 331 { 332 siginfo_t info; 333 334 if(psr & PSR_PS) 335 die_if_kernel("Penguin overflow trap from kernel mode", regs); 336 info.si_signo = SIGEMT; 337 info.si_errno = 0; 338 info.si_code = EMT_TAGOVF; 339 info.si_addr = (void __user *)pc; 340 info.si_trapno = 0; 341 send_sig_info(SIGEMT, &info, current); 342 } 343 344 void handle_watchpoint(struct pt_regs *regs, unsigned long pc, unsigned long npc, 345 unsigned long psr) 346 { 347 #ifdef TRAP_DEBUG 348 printk("Watchpoint detected at PC %08lx NPC %08lx PSR %08lx\n", 349 pc, npc, psr); 350 #endif 351 if(psr & PSR_PS) 352 panic("Tell me what a watchpoint trap is, and I'll then deal " 353 "with such a beast..."); 354 } 355 356 void handle_reg_access(struct pt_regs *regs, unsigned long pc, unsigned long npc, 357 unsigned long psr) 358 { 359 siginfo_t info; 360 361 #ifdef TRAP_DEBUG 362 printk("Register Access Exception at PC %08lx NPC %08lx PSR %08lx\n", 363 pc, npc, psr); 364 #endif 365 info.si_signo = SIGBUS; 366 info.si_errno = 0; 367 info.si_code = BUS_OBJERR; 368 info.si_addr = (void __user *)pc; 369 info.si_trapno = 0; 370 force_sig_info(SIGBUS, &info, current); 371 } 372 373 void handle_cp_disabled(struct pt_regs *regs, unsigned long pc, unsigned long npc, 374 unsigned long psr) 375 { 376 siginfo_t info; 377 378 info.si_signo = SIGILL; 379 info.si_errno = 0; 380 info.si_code = ILL_COPROC; 381 info.si_addr = (void __user *)pc; 382 info.si_trapno = 0; 383 send_sig_info(SIGILL, &info, current); 384 } 385 386 void handle_cp_exception(struct pt_regs *regs, unsigned long pc, unsigned long npc, 387 unsigned long psr) 388 { 389 siginfo_t info; 390 391 #ifdef TRAP_DEBUG 392 printk("Co-Processor Exception at PC %08lx NPC %08lx PSR %08lx\n", 393 pc, npc, psr); 394 #endif 395 info.si_signo = SIGILL; 396 info.si_errno = 0; 397 info.si_code = ILL_COPROC; 398 info.si_addr = (void __user *)pc; 399 info.si_trapno = 0; 400 send_sig_info(SIGILL, &info, current); 401 } 402 403 void handle_hw_divzero(struct pt_regs *regs, unsigned long pc, unsigned long npc, 404 unsigned long psr) 405 { 406 siginfo_t info; 407 408 info.si_signo = SIGFPE; 409 info.si_errno = 0; 410 info.si_code = FPE_INTDIV; 411 info.si_addr = (void __user *)pc; 412 info.si_trapno = 0; 413 send_sig_info(SIGFPE, &info, current); 414 } 415 416 #ifdef CONFIG_DEBUG_BUGVERBOSE 417 void do_BUG(const char *file, int line) 418 { 419 // bust_spinlocks(1); XXX Not in our original BUG() 420 printk("kernel BUG at %s:%d!\n", file, line); 421 } 422 EXPORT_SYMBOL(do_BUG); 423 #endif 424 425 /* Since we have our mappings set up, on multiprocessors we can spin them 426 * up here so that timer interrupts work during initialization. 427 */ 428 429 void trap_init(void) 430 { 431 extern void thread_info_offsets_are_bolixed_pete(void); 432 433 /* Force linker to barf if mismatched */ 434 if (TI_UWINMASK != offsetof(struct thread_info, uwinmask) || 435 TI_TASK != offsetof(struct thread_info, task) || 436 TI_FLAGS != offsetof(struct thread_info, flags) || 437 TI_CPU != offsetof(struct thread_info, cpu) || 438 TI_PREEMPT != offsetof(struct thread_info, preempt_count) || 439 TI_SOFTIRQ != offsetof(struct thread_info, softirq_count) || 440 TI_HARDIRQ != offsetof(struct thread_info, hardirq_count) || 441 TI_KSP != offsetof(struct thread_info, ksp) || 442 TI_KPC != offsetof(struct thread_info, kpc) || 443 TI_KPSR != offsetof(struct thread_info, kpsr) || 444 TI_KWIM != offsetof(struct thread_info, kwim) || 445 TI_REG_WINDOW != offsetof(struct thread_info, reg_window) || 446 TI_RWIN_SPTRS != offsetof(struct thread_info, rwbuf_stkptrs) || 447 TI_W_SAVED != offsetof(struct thread_info, w_saved)) 448 thread_info_offsets_are_bolixed_pete(); 449 450 /* Attach to the address space of init_task. */ 451 atomic_inc(&init_mm.mm_count); 452 current->active_mm = &init_mm; 453 454 /* NOTE: Other cpus have this done as they are started 455 * up on SMP. 456 */ 457 } 458