1/* 2 * arch/score/kernel/traps.c 3 * 4 * Score Processor version. 5 * 6 * Copyright (C) 2009 Sunplus Core Technology Co., Ltd. 7 * Chen Liqin <liqin.chen@sunplusct.com> 8 * Lennox Wu <lennox.wu@sunplusct.com> 9 * 10 * This program is free software; you can redistribute it and/or modify 11 * it under the terms of the GNU General Public License as published by 12 * the Free Software Foundation; either version 2 of the License, or 13 * (at your option) any later version. 14 * 15 * This program is distributed in the hope that it will be useful, 16 * but WITHOUT ANY WARRANTY; without even the implied warranty of 17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 18 * GNU General Public License for more details. 19 * 20 * You should have received a copy of the GNU General Public License 21 * along with this program; if not, see the file COPYING, or write 22 * to the Free Software Foundation, Inc., 23 * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA 24 */ 25 26#include <linux/module.h> 27#include <linux/sched.h> 28 29#include <asm/cacheflush.h> 30#include <asm/irq.h> 31#include <asm/irq_regs.h> 32 33unsigned long exception_handlers[32]; 34 35/* 36 * The architecture-independent show_stack generator 37 */ 38void show_stack(struct task_struct *task, unsigned long *sp) 39{ 40 int i; 41 long stackdata; 42 43 sp = sp ? sp : (unsigned long *)&sp; 44 45 printk(KERN_NOTICE "Stack: "); 46 i = 1; 47 while ((long) sp & (PAGE_SIZE - 1)) { 48 if (i && ((i % 8) == 0)) 49 printk(KERN_NOTICE "\n"); 50 if (i > 40) { 51 printk(KERN_NOTICE " ..."); 52 break; 53 } 54 55 if (__get_user(stackdata, sp++)) { 56 printk(KERN_NOTICE " (Bad stack address)"); 57 break; 58 } 59 60 printk(KERN_NOTICE " %08lx", stackdata); 61 i++; 62 } 63 printk(KERN_NOTICE "\n"); 64} 65 66static void show_trace(long *sp) 67{ 68 int i; 69 long addr; 70 71 sp = sp ? sp : (long *) &sp; 72 73 printk(KERN_NOTICE "Call Trace: "); 74 i = 1; 75 while ((long) sp & (PAGE_SIZE - 1)) { 76 if (__get_user(addr, sp++)) { 77 if (i && ((i % 6) == 0)) 78 printk(KERN_NOTICE "\n"); 79 printk(KERN_NOTICE " (Bad stack address)\n"); 80 break; 81 } 82 83 if (kernel_text_address(addr)) { 84 if (i && ((i % 6) == 0)) 85 printk(KERN_NOTICE "\n"); 86 if (i > 40) { 87 printk(KERN_NOTICE " ..."); 88 break; 89 } 90 91 printk(KERN_NOTICE " [<%08lx>]", addr); 92 i++; 93 } 94 } 95 printk(KERN_NOTICE "\n"); 96} 97 98static void show_code(unsigned int *pc) 99{ 100 long i; 101 102 printk(KERN_NOTICE "\nCode:"); 103 104 for (i = -3; i < 6; i++) { 105 unsigned long insn; 106 if (__get_user(insn, pc + i)) { 107 printk(KERN_NOTICE " (Bad address in epc)\n"); 108 break; 109 } 110 printk(KERN_NOTICE "%c%08lx%c", (i ? ' ' : '<'), 111 insn, (i ? ' ' : '>')); 112 } 113} 114 115void show_regs(struct pt_regs *regs) 116{ 117 printk("r0 : %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n", 118 regs->regs[0], regs->regs[1], regs->regs[2], regs->regs[3], 119 regs->regs[4], regs->regs[5], regs->regs[6], regs->regs[7]); 120 printk("r8 : %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n", 121 regs->regs[8], regs->regs[9], regs->regs[10], regs->regs[11], 122 regs->regs[12], regs->regs[13], regs->regs[14], regs->regs[15]); 123 printk("r16: %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n", 124 regs->regs[16], regs->regs[17], regs->regs[18], regs->regs[19], 125 regs->regs[20], regs->regs[21], regs->regs[22], regs->regs[23]); 126 printk("r24: %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n", 127 regs->regs[24], regs->regs[25], regs->regs[26], regs->regs[27], 128 regs->regs[28], regs->regs[29], regs->regs[30], regs->regs[31]); 129 130 printk("CEH : %08lx\n", regs->ceh); 131 printk("CEL : %08lx\n", regs->cel); 132 133 printk("EMA:%08lx, epc:%08lx %s\nPSR: %08lx\nECR:%08lx\nCondition : %08lx\n", 134 regs->cp0_ema, regs->cp0_epc, print_tainted(), regs->cp0_psr, 135 regs->cp0_ecr, regs->cp0_condition); 136} 137 138static void show_registers(struct pt_regs *regs) 139{ 140 show_regs(regs); 141 printk(KERN_NOTICE "Process %s (pid: %d, stackpage=%08lx)\n", 142 current->comm, current->pid, (unsigned long) current); 143 show_stack(current_thread_info()->task, (long *) regs->regs[0]); 144 show_trace((long *) regs->regs[0]); 145 show_code((unsigned int *) regs->cp0_epc); 146 printk(KERN_NOTICE "\n"); 147} 148 149/* 150 * The architecture-independent dump_stack generator 151 */ 152void dump_stack(void) 153{ 154 show_stack(current_thread_info()->task, 155 (long *) get_irq_regs()->regs[0]); 156} 157EXPORT_SYMBOL(dump_stack); 158 159void __die(const char *str, struct pt_regs *regs, const char *file, 160 const char *func, unsigned long line) 161{ 162 console_verbose(); 163 printk("%s", str); 164 if (file && func) 165 printk(" in %s:%s, line %ld", file, func, line); 166 printk(":\n"); 167 show_registers(regs); 168 do_exit(SIGSEGV); 169} 170 171void __die_if_kernel(const char *str, struct pt_regs *regs, 172 const char *file, const char *func, unsigned long line) 173{ 174 if (!user_mode(regs)) 175 __die(str, regs, file, func, line); 176} 177 178asmlinkage void do_adelinsn(struct pt_regs *regs) 179{ 180 printk("do_ADE-linsn:ema:0x%08lx:epc:0x%08lx\n", 181 regs->cp0_ema, regs->cp0_epc); 182 die_if_kernel("do_ade execution Exception\n", regs); 183 force_sig(SIGBUS, current); 184} 185 186asmlinkage void do_adedata(struct pt_regs *regs) 187{ 188 const struct exception_table_entry *fixup; 189 fixup = search_exception_tables(regs->cp0_epc); 190 if (fixup) { 191 regs->cp0_epc = fixup->fixup; 192 return; 193 } 194 printk("do_ADE-data:ema:0x%08lx:epc:0x%08lx\n", 195 regs->cp0_ema, regs->cp0_epc); 196 die_if_kernel("do_ade execution Exception\n", regs); 197 force_sig(SIGBUS, current); 198} 199 200asmlinkage void do_pel(struct pt_regs *regs) 201{ 202 die_if_kernel("do_pel execution Exception", regs); 203 force_sig(SIGFPE, current); 204} 205 206asmlinkage void do_cee(struct pt_regs *regs) 207{ 208 die_if_kernel("do_cee execution Exception", regs); 209 force_sig(SIGFPE, current); 210} 211 212asmlinkage void do_cpe(struct pt_regs *regs) 213{ 214 die_if_kernel("do_cpe execution Exception", regs); 215 force_sig(SIGFPE, current); 216} 217 218asmlinkage void do_be(struct pt_regs *regs) 219{ 220 die_if_kernel("do_be execution Exception", regs); 221 force_sig(SIGBUS, current); 222} 223 224asmlinkage void do_ov(struct pt_regs *regs) 225{ 226 siginfo_t info; 227 228 die_if_kernel("do_ov execution Exception", regs); 229 230 info.si_code = FPE_INTOVF; 231 info.si_signo = SIGFPE; 232 info.si_errno = 0; 233 info.si_addr = (void *)regs->cp0_epc; 234 force_sig_info(SIGFPE, &info, current); 235} 236 237asmlinkage void do_tr(struct pt_regs *regs) 238{ 239 die_if_kernel("do_tr execution Exception", regs); 240 force_sig(SIGTRAP, current); 241} 242 243asmlinkage void do_ri(struct pt_regs *regs) 244{ 245 unsigned long epc_insn; 246 unsigned long epc = regs->cp0_epc; 247 248 read_tsk_long(current, epc, &epc_insn); 249 if (current->thread.single_step == 1) { 250 if ((epc == current->thread.addr1) || 251 (epc == current->thread.addr2)) { 252 user_disable_single_step(current); 253 force_sig(SIGTRAP, current); 254 return; 255 } else 256 BUG(); 257 } else if ((epc_insn == BREAKPOINT32_INSN) || 258 ((epc_insn & 0x0000FFFF) == 0x7002) || 259 ((epc_insn & 0xFFFF0000) == 0x70020000)) { 260 force_sig(SIGTRAP, current); 261 return; 262 } else { 263 die_if_kernel("do_ri execution Exception", regs); 264 force_sig(SIGILL, current); 265 } 266} 267 268asmlinkage void do_ccu(struct pt_regs *regs) 269{ 270 die_if_kernel("do_ccu execution Exception", regs); 271 force_sig(SIGILL, current); 272} 273 274asmlinkage void do_reserved(struct pt_regs *regs) 275{ 276 /* 277 * Game over - no way to handle this if it ever occurs. Most probably 278 * caused by a new unknown cpu type or after another deadly 279 * hard/software error. 280 */ 281 die_if_kernel("do_reserved execution Exception", regs); 282 show_regs(regs); 283 panic("Caught reserved exception - should not happen."); 284} 285 286/* 287 * NMI exception handler. 288 */ 289void nmi_exception_handler(struct pt_regs *regs) 290{ 291 die_if_kernel("nmi_exception_handler execution Exception", regs); 292 die("NMI", regs); 293} 294 295/* Install CPU exception handler */ 296void *set_except_vector(int n, void *addr) 297{ 298 unsigned long handler = (unsigned long) addr; 299 unsigned long old_handler = exception_handlers[n]; 300 301 exception_handlers[n] = handler; 302 return (void *)old_handler; 303} 304 305void __init trap_init(void) 306{ 307 int i; 308 309 pgd_current = (unsigned long)init_mm.pgd; 310 /* DEBUG EXCEPTION */ 311 memcpy((void *)DEBUG_VECTOR_BASE_ADDR, 312 &debug_exception_vector, DEBUG_VECTOR_SIZE); 313 /* NMI EXCEPTION */ 314 memcpy((void *)GENERAL_VECTOR_BASE_ADDR, 315 &general_exception_vector, GENERAL_VECTOR_SIZE); 316 317 /* 318 * Initialise exception handlers 319 */ 320 for (i = 0; i <= 31; i++) 321 set_except_vector(i, handle_reserved); 322 323 set_except_vector(1, handle_nmi); 324 set_except_vector(2, handle_adelinsn); 325 set_except_vector(3, handle_tlb_refill); 326 set_except_vector(4, handle_tlb_invaild); 327 set_except_vector(5, handle_ibe); 328 set_except_vector(6, handle_pel); 329 set_except_vector(7, handle_sys); 330 set_except_vector(8, handle_ccu); 331 set_except_vector(9, handle_ri); 332 set_except_vector(10, handle_tr); 333 set_except_vector(11, handle_adedata); 334 set_except_vector(12, handle_adedata); 335 set_except_vector(13, handle_tlb_refill); 336 set_except_vector(14, handle_tlb_invaild); 337 set_except_vector(15, handle_mod); 338 set_except_vector(16, handle_cee); 339 set_except_vector(17, handle_cpe); 340 set_except_vector(18, handle_dbe); 341 flush_icache_range(DEBUG_VECTOR_BASE_ADDR, IRQ_VECTOR_BASE_ADDR); 342 343 atomic_inc(&init_mm.mm_count); 344 current->active_mm = &init_mm; 345 cpu_cache_init(); 346} 347