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