1 /* 2 * OpenRISC traps.c 3 * 4 * Linux architectural port borrowing liberally from similar works of 5 * others. All original copyrights apply as per the original source 6 * declaration. 7 * 8 * Modifications for the OpenRISC architecture: 9 * Copyright (C) 2003 Matjaz Breskvar <phoenix@bsemi.com> 10 * Copyright (C) 2010-2011 Jonas Bonn <jonas@southpole.se> 11 * 12 * This program is free software; you can redistribute it and/or 13 * modify it under the terms of the GNU General Public License 14 * as published by the Free Software Foundation; either version 15 * 2 of the License, or (at your option) any later version. 16 * 17 * Here we handle the break vectors not used by the system call 18 * mechanism, as well as some general stack/register dumping 19 * things. 20 * 21 */ 22 23 #include <linux/init.h> 24 #include <linux/sched.h> 25 #include <linux/sched/debug.h> 26 #include <linux/sched/task_stack.h> 27 #include <linux/kernel.h> 28 #include <linux/extable.h> 29 #include <linux/kmod.h> 30 #include <linux/string.h> 31 #include <linux/errno.h> 32 #include <linux/ptrace.h> 33 #include <linux/timer.h> 34 #include <linux/mm.h> 35 #include <linux/kallsyms.h> 36 #include <linux/uaccess.h> 37 38 #include <asm/segment.h> 39 #include <asm/io.h> 40 #include <asm/pgtable.h> 41 #include <asm/unwinder.h> 42 43 extern char _etext, _stext; 44 45 int kstack_depth_to_print = 0x180; 46 int lwa_flag; 47 unsigned long __user *lwa_addr; 48 49 void print_trace(void *data, unsigned long addr, int reliable) 50 { 51 pr_emerg("[<%p>] %s%pS\n", (void *) addr, reliable ? "" : "? ", 52 (void *) addr); 53 } 54 55 /* displays a short stack trace */ 56 void show_stack(struct task_struct *task, unsigned long *esp) 57 { 58 if (esp == NULL) 59 esp = (unsigned long *)&esp; 60 61 pr_emerg("Call trace:\n"); 62 unwind_stack(NULL, esp, print_trace); 63 } 64 65 void show_trace_task(struct task_struct *tsk) 66 { 67 /* 68 * TODO: SysRq-T trace dump... 69 */ 70 } 71 72 void show_registers(struct pt_regs *regs) 73 { 74 int i; 75 int in_kernel = 1; 76 unsigned long esp; 77 78 esp = (unsigned long)(regs->sp); 79 if (user_mode(regs)) 80 in_kernel = 0; 81 82 printk("CPU #: %d\n" 83 " PC: %08lx SR: %08lx SP: %08lx\n", 84 smp_processor_id(), regs->pc, regs->sr, regs->sp); 85 printk("GPR00: %08lx GPR01: %08lx GPR02: %08lx GPR03: %08lx\n", 86 0L, regs->gpr[1], regs->gpr[2], regs->gpr[3]); 87 printk("GPR04: %08lx GPR05: %08lx GPR06: %08lx GPR07: %08lx\n", 88 regs->gpr[4], regs->gpr[5], regs->gpr[6], regs->gpr[7]); 89 printk("GPR08: %08lx GPR09: %08lx GPR10: %08lx GPR11: %08lx\n", 90 regs->gpr[8], regs->gpr[9], regs->gpr[10], regs->gpr[11]); 91 printk("GPR12: %08lx GPR13: %08lx GPR14: %08lx GPR15: %08lx\n", 92 regs->gpr[12], regs->gpr[13], regs->gpr[14], regs->gpr[15]); 93 printk("GPR16: %08lx GPR17: %08lx GPR18: %08lx GPR19: %08lx\n", 94 regs->gpr[16], regs->gpr[17], regs->gpr[18], regs->gpr[19]); 95 printk("GPR20: %08lx GPR21: %08lx GPR22: %08lx GPR23: %08lx\n", 96 regs->gpr[20], regs->gpr[21], regs->gpr[22], regs->gpr[23]); 97 printk("GPR24: %08lx GPR25: %08lx GPR26: %08lx GPR27: %08lx\n", 98 regs->gpr[24], regs->gpr[25], regs->gpr[26], regs->gpr[27]); 99 printk("GPR28: %08lx GPR29: %08lx GPR30: %08lx GPR31: %08lx\n", 100 regs->gpr[28], regs->gpr[29], regs->gpr[30], regs->gpr[31]); 101 printk(" RES: %08lx oGPR11: %08lx\n", 102 regs->gpr[11], regs->orig_gpr11); 103 104 printk("Process %s (pid: %d, stackpage=%08lx)\n", 105 current->comm, current->pid, (unsigned long)current); 106 /* 107 * When in-kernel, we also print out the stack and code at the 108 * time of the fault.. 109 */ 110 if (in_kernel) { 111 112 printk("\nStack: "); 113 show_stack(NULL, (unsigned long *)esp); 114 115 printk("\nCode: "); 116 if (regs->pc < PAGE_OFFSET) 117 goto bad; 118 119 for (i = -24; i < 24; i++) { 120 unsigned char c; 121 if (__get_user(c, &((unsigned char *)regs->pc)[i])) { 122 bad: 123 printk(" Bad PC value."); 124 break; 125 } 126 127 if (i == 0) 128 printk("(%02x) ", c); 129 else 130 printk("%02x ", c); 131 } 132 } 133 printk("\n"); 134 } 135 136 void nommu_dump_state(struct pt_regs *regs, 137 unsigned long ea, unsigned long vector) 138 { 139 int i; 140 unsigned long addr, stack = regs->sp; 141 142 printk("\n\r[nommu_dump_state] :: ea %lx, vector %lx\n\r", ea, vector); 143 144 printk("CPU #: %d\n" 145 " PC: %08lx SR: %08lx SP: %08lx\n", 146 0, regs->pc, regs->sr, regs->sp); 147 printk("GPR00: %08lx GPR01: %08lx GPR02: %08lx GPR03: %08lx\n", 148 0L, regs->gpr[1], regs->gpr[2], regs->gpr[3]); 149 printk("GPR04: %08lx GPR05: %08lx GPR06: %08lx GPR07: %08lx\n", 150 regs->gpr[4], regs->gpr[5], regs->gpr[6], regs->gpr[7]); 151 printk("GPR08: %08lx GPR09: %08lx GPR10: %08lx GPR11: %08lx\n", 152 regs->gpr[8], regs->gpr[9], regs->gpr[10], regs->gpr[11]); 153 printk("GPR12: %08lx GPR13: %08lx GPR14: %08lx GPR15: %08lx\n", 154 regs->gpr[12], regs->gpr[13], regs->gpr[14], regs->gpr[15]); 155 printk("GPR16: %08lx GPR17: %08lx GPR18: %08lx GPR19: %08lx\n", 156 regs->gpr[16], regs->gpr[17], regs->gpr[18], regs->gpr[19]); 157 printk("GPR20: %08lx GPR21: %08lx GPR22: %08lx GPR23: %08lx\n", 158 regs->gpr[20], regs->gpr[21], regs->gpr[22], regs->gpr[23]); 159 printk("GPR24: %08lx GPR25: %08lx GPR26: %08lx GPR27: %08lx\n", 160 regs->gpr[24], regs->gpr[25], regs->gpr[26], regs->gpr[27]); 161 printk("GPR28: %08lx GPR29: %08lx GPR30: %08lx GPR31: %08lx\n", 162 regs->gpr[28], regs->gpr[29], regs->gpr[30], regs->gpr[31]); 163 printk(" RES: %08lx oGPR11: %08lx\n", 164 regs->gpr[11], regs->orig_gpr11); 165 166 printk("Process %s (pid: %d, stackpage=%08lx)\n", 167 ((struct task_struct *)(__pa(current)))->comm, 168 ((struct task_struct *)(__pa(current)))->pid, 169 (unsigned long)current); 170 171 printk("\nStack: "); 172 printk("Stack dump [0x%08lx]:\n", (unsigned long)stack); 173 for (i = 0; i < kstack_depth_to_print; i++) { 174 if (((long)stack & (THREAD_SIZE - 1)) == 0) 175 break; 176 stack++; 177 178 printk("%lx :: sp + %02d: 0x%08lx\n", stack, i * 4, 179 *((unsigned long *)(__pa(stack)))); 180 } 181 printk("\n"); 182 183 printk("Call Trace: "); 184 i = 1; 185 while (((long)stack & (THREAD_SIZE - 1)) != 0) { 186 addr = *((unsigned long *)__pa(stack)); 187 stack++; 188 189 if (kernel_text_address(addr)) { 190 if (i && ((i % 6) == 0)) 191 printk("\n "); 192 printk(" [<%08lx>]", addr); 193 i++; 194 } 195 } 196 printk("\n"); 197 198 printk("\nCode: "); 199 200 for (i = -24; i < 24; i++) { 201 unsigned char c; 202 c = ((unsigned char *)(__pa(regs->pc)))[i]; 203 204 if (i == 0) 205 printk("(%02x) ", c); 206 else 207 printk("%02x ", c); 208 } 209 printk("\n"); 210 } 211 212 /* This is normally the 'Oops' routine */ 213 void die(const char *str, struct pt_regs *regs, long err) 214 { 215 216 console_verbose(); 217 printk("\n%s#: %04lx\n", str, err & 0xffff); 218 show_registers(regs); 219 #ifdef CONFIG_JUMP_UPON_UNHANDLED_EXCEPTION 220 printk("\n\nUNHANDLED_EXCEPTION: entering infinite loop\n"); 221 222 /* shut down interrupts */ 223 local_irq_disable(); 224 225 __asm__ __volatile__("l.nop 1"); 226 do {} while (1); 227 #endif 228 do_exit(SIGSEGV); 229 } 230 231 /* This is normally the 'Oops' routine */ 232 void die_if_kernel(const char *str, struct pt_regs *regs, long err) 233 { 234 if (user_mode(regs)) 235 return; 236 237 die(str, regs, err); 238 } 239 240 void unhandled_exception(struct pt_regs *regs, int ea, int vector) 241 { 242 printk("Unable to handle exception at EA =0x%x, vector 0x%x", 243 ea, vector); 244 die("Oops", regs, 9); 245 } 246 247 void __init trap_init(void) 248 { 249 /* Nothing needs to be done */ 250 } 251 252 asmlinkage void do_trap(struct pt_regs *regs, unsigned long address) 253 { 254 siginfo_t info; 255 memset(&info, 0, sizeof(info)); 256 info.si_signo = SIGTRAP; 257 info.si_code = TRAP_TRACE; 258 info.si_addr = (void *)address; 259 force_sig_info(SIGTRAP, &info, current); 260 261 regs->pc += 4; 262 } 263 264 asmlinkage void do_unaligned_access(struct pt_regs *regs, unsigned long address) 265 { 266 siginfo_t info; 267 268 if (user_mode(regs)) { 269 /* Send a SIGSEGV */ 270 info.si_signo = SIGSEGV; 271 info.si_errno = 0; 272 /* info.si_code has been set above */ 273 info.si_addr = (void *)address; 274 force_sig_info(SIGSEGV, &info, current); 275 } else { 276 printk("KERNEL: Unaligned Access 0x%.8lx\n", address); 277 show_registers(regs); 278 die("Die:", regs, address); 279 } 280 281 } 282 283 asmlinkage void do_bus_fault(struct pt_regs *regs, unsigned long address) 284 { 285 siginfo_t info; 286 287 if (user_mode(regs)) { 288 /* Send a SIGBUS */ 289 info.si_signo = SIGBUS; 290 info.si_errno = 0; 291 info.si_code = BUS_ADRERR; 292 info.si_addr = (void *)address; 293 force_sig_info(SIGBUS, &info, current); 294 } else { /* Kernel mode */ 295 printk("KERNEL: Bus error (SIGBUS) 0x%.8lx\n", address); 296 show_registers(regs); 297 die("Die:", regs, address); 298 } 299 } 300 301 static inline int in_delay_slot(struct pt_regs *regs) 302 { 303 #ifdef CONFIG_OPENRISC_NO_SPR_SR_DSX 304 /* No delay slot flag, do the old way */ 305 unsigned int op, insn; 306 307 insn = *((unsigned int *)regs->pc); 308 op = insn >> 26; 309 switch (op) { 310 case 0x00: /* l.j */ 311 case 0x01: /* l.jal */ 312 case 0x03: /* l.bnf */ 313 case 0x04: /* l.bf */ 314 case 0x11: /* l.jr */ 315 case 0x12: /* l.jalr */ 316 return 1; 317 default: 318 return 0; 319 } 320 #else 321 return regs->sr & SPR_SR_DSX; 322 #endif 323 } 324 325 static inline void adjust_pc(struct pt_regs *regs, unsigned long address) 326 { 327 int displacement; 328 unsigned int rb, op, jmp; 329 330 if (unlikely(in_delay_slot(regs))) { 331 /* In delay slot, instruction at pc is a branch, simulate it */ 332 jmp = *((unsigned int *)regs->pc); 333 334 displacement = sign_extend32(((jmp) & 0x3ffffff) << 2, 27); 335 rb = (jmp & 0x0000ffff) >> 11; 336 op = jmp >> 26; 337 338 switch (op) { 339 case 0x00: /* l.j */ 340 regs->pc += displacement; 341 return; 342 case 0x01: /* l.jal */ 343 regs->pc += displacement; 344 regs->gpr[9] = regs->pc + 8; 345 return; 346 case 0x03: /* l.bnf */ 347 if (regs->sr & SPR_SR_F) 348 regs->pc += 8; 349 else 350 regs->pc += displacement; 351 return; 352 case 0x04: /* l.bf */ 353 if (regs->sr & SPR_SR_F) 354 regs->pc += displacement; 355 else 356 regs->pc += 8; 357 return; 358 case 0x11: /* l.jr */ 359 regs->pc = regs->gpr[rb]; 360 return; 361 case 0x12: /* l.jalr */ 362 regs->pc = regs->gpr[rb]; 363 regs->gpr[9] = regs->pc + 8; 364 return; 365 default: 366 break; 367 } 368 } else { 369 regs->pc += 4; 370 } 371 } 372 373 static inline void simulate_lwa(struct pt_regs *regs, unsigned long address, 374 unsigned int insn) 375 { 376 unsigned int ra, rd; 377 unsigned long value; 378 unsigned long orig_pc; 379 long imm; 380 381 const struct exception_table_entry *entry; 382 383 orig_pc = regs->pc; 384 adjust_pc(regs, address); 385 386 ra = (insn >> 16) & 0x1f; 387 rd = (insn >> 21) & 0x1f; 388 imm = (short)insn; 389 lwa_addr = (unsigned long __user *)(regs->gpr[ra] + imm); 390 391 if ((unsigned long)lwa_addr & 0x3) { 392 do_unaligned_access(regs, address); 393 return; 394 } 395 396 if (get_user(value, lwa_addr)) { 397 if (user_mode(regs)) { 398 force_sig(SIGSEGV, current); 399 return; 400 } 401 402 if ((entry = search_exception_tables(orig_pc))) { 403 regs->pc = entry->fixup; 404 return; 405 } 406 407 /* kernel access in kernel space, load it directly */ 408 value = *((unsigned long *)lwa_addr); 409 } 410 411 lwa_flag = 1; 412 regs->gpr[rd] = value; 413 } 414 415 static inline void simulate_swa(struct pt_regs *regs, unsigned long address, 416 unsigned int insn) 417 { 418 unsigned long __user *vaddr; 419 unsigned long orig_pc; 420 unsigned int ra, rb; 421 long imm; 422 423 const struct exception_table_entry *entry; 424 425 orig_pc = regs->pc; 426 adjust_pc(regs, address); 427 428 ra = (insn >> 16) & 0x1f; 429 rb = (insn >> 11) & 0x1f; 430 imm = (short)(((insn & 0x2200000) >> 10) | (insn & 0x7ff)); 431 vaddr = (unsigned long __user *)(regs->gpr[ra] + imm); 432 433 if (!lwa_flag || vaddr != lwa_addr) { 434 regs->sr &= ~SPR_SR_F; 435 return; 436 } 437 438 if ((unsigned long)vaddr & 0x3) { 439 do_unaligned_access(regs, address); 440 return; 441 } 442 443 if (put_user(regs->gpr[rb], vaddr)) { 444 if (user_mode(regs)) { 445 force_sig(SIGSEGV, current); 446 return; 447 } 448 449 if ((entry = search_exception_tables(orig_pc))) { 450 regs->pc = entry->fixup; 451 return; 452 } 453 454 /* kernel access in kernel space, store it directly */ 455 *((unsigned long *)vaddr) = regs->gpr[rb]; 456 } 457 458 lwa_flag = 0; 459 regs->sr |= SPR_SR_F; 460 } 461 462 #define INSN_LWA 0x1b 463 #define INSN_SWA 0x33 464 465 asmlinkage void do_illegal_instruction(struct pt_regs *regs, 466 unsigned long address) 467 { 468 siginfo_t info; 469 unsigned int op; 470 unsigned int insn = *((unsigned int *)address); 471 472 op = insn >> 26; 473 474 switch (op) { 475 case INSN_LWA: 476 simulate_lwa(regs, address, insn); 477 return; 478 479 case INSN_SWA: 480 simulate_swa(regs, address, insn); 481 return; 482 483 default: 484 break; 485 } 486 487 if (user_mode(regs)) { 488 /* Send a SIGILL */ 489 info.si_signo = SIGILL; 490 info.si_errno = 0; 491 info.si_code = ILL_ILLOPC; 492 info.si_addr = (void *)address; 493 force_sig_info(SIGBUS, &info, current); 494 } else { /* Kernel mode */ 495 printk("KERNEL: Illegal instruction (SIGILL) 0x%.8lx\n", 496 address); 497 show_registers(regs); 498 die("Die:", regs, address); 499 } 500 } 501