1 // SPDX-License-Identifier: GPL-2.0 2 // Copyright (C) 2018 Hangzhou C-SKY Microsystems co.,ltd. 3 4 #include <linux/cpu.h> 5 #include <linux/sched.h> 6 #include <linux/signal.h> 7 #include <linux/kernel.h> 8 #include <linux/mm.h> 9 #include <linux/module.h> 10 #include <linux/user.h> 11 #include <linux/string.h> 12 #include <linux/linkage.h> 13 #include <linux/init.h> 14 #include <linux/ptrace.h> 15 #include <linux/kallsyms.h> 16 #include <linux/rtc.h> 17 #include <linux/uaccess.h> 18 #include <linux/kprobes.h> 19 #include <linux/kdebug.h> 20 #include <linux/sched/debug.h> 21 22 #include <asm/setup.h> 23 #include <asm/traps.h> 24 #include <asm/pgalloc.h> 25 #include <asm/siginfo.h> 26 27 #include <asm/mmu_context.h> 28 29 #ifdef CONFIG_CPU_HAS_FPU 30 #include <abi/fpu.h> 31 #endif 32 33 int show_unhandled_signals = 1; 34 35 /* Defined in entry.S */ 36 asmlinkage void csky_trap(void); 37 38 asmlinkage void csky_systemcall(void); 39 asmlinkage void csky_cmpxchg(void); 40 asmlinkage void csky_get_tls(void); 41 asmlinkage void csky_irq(void); 42 43 asmlinkage void csky_pagefault(void); 44 45 /* Defined in head.S */ 46 asmlinkage void _start_smp_secondary(void); 47 48 void __init pre_trap_init(void) 49 { 50 int i; 51 52 mtcr("vbr", vec_base); 53 54 for (i = 1; i < 128; i++) 55 VEC_INIT(i, csky_trap); 56 } 57 58 void __init trap_init(void) 59 { 60 VEC_INIT(VEC_AUTOVEC, csky_irq); 61 62 /* setup trap0 trap2 trap3 */ 63 VEC_INIT(VEC_TRAP0, csky_systemcall); 64 VEC_INIT(VEC_TRAP2, csky_cmpxchg); 65 VEC_INIT(VEC_TRAP3, csky_get_tls); 66 67 /* setup MMU TLB exception */ 68 VEC_INIT(VEC_TLBINVALIDL, csky_pagefault); 69 VEC_INIT(VEC_TLBINVALIDS, csky_pagefault); 70 VEC_INIT(VEC_TLBMODIFIED, csky_pagefault); 71 72 #ifdef CONFIG_CPU_HAS_FPU 73 init_fpu(); 74 #endif 75 76 #ifdef CONFIG_SMP 77 mtcr("cr<28, 0>", virt_to_phys(vec_base)); 78 79 VEC_INIT(VEC_RESET, (void *)virt_to_phys(_start_smp_secondary)); 80 #endif 81 } 82 83 static DEFINE_SPINLOCK(die_lock); 84 85 void die(struct pt_regs *regs, const char *str) 86 { 87 static int die_counter; 88 int ret; 89 90 oops_enter(); 91 92 spin_lock_irq(&die_lock); 93 console_verbose(); 94 bust_spinlocks(1); 95 96 pr_emerg("%s [#%d]\n", str, ++die_counter); 97 print_modules(); 98 show_regs(regs); 99 show_stack(current, (unsigned long *)regs->regs[4], KERN_INFO); 100 101 ret = notify_die(DIE_OOPS, str, regs, 0, trap_no(regs), SIGSEGV); 102 103 bust_spinlocks(0); 104 add_taint(TAINT_DIE, LOCKDEP_NOW_UNRELIABLE); 105 spin_unlock_irq(&die_lock); 106 oops_exit(); 107 108 if (in_interrupt()) 109 panic("Fatal exception in interrupt"); 110 if (panic_on_oops) 111 panic("Fatal exception"); 112 if (ret != NOTIFY_STOP) 113 make_task_dead(SIGSEGV); 114 } 115 116 void do_trap(struct pt_regs *regs, int signo, int code, unsigned long addr) 117 { 118 struct task_struct *tsk = current; 119 120 if (show_unhandled_signals && unhandled_signal(tsk, signo) 121 && printk_ratelimit()) { 122 pr_info("%s[%d]: unhandled signal %d code 0x%x at 0x%08lx", 123 tsk->comm, task_pid_nr(tsk), signo, code, addr); 124 print_vma_addr(KERN_CONT " in ", instruction_pointer(regs)); 125 pr_cont("\n"); 126 show_regs(regs); 127 } 128 129 force_sig_fault(signo, code, (void __user *)addr); 130 } 131 132 static void do_trap_error(struct pt_regs *regs, int signo, int code, 133 unsigned long addr, const char *str) 134 { 135 current->thread.trap_no = trap_no(regs); 136 137 if (user_mode(regs)) { 138 do_trap(regs, signo, code, addr); 139 } else { 140 if (!fixup_exception(regs)) 141 die(regs, str); 142 } 143 } 144 145 #define DO_ERROR_INFO(name, signo, code, str) \ 146 asmlinkage __visible void name(struct pt_regs *regs) \ 147 { \ 148 do_trap_error(regs, signo, code, regs->pc, "Oops - " str); \ 149 } 150 151 DO_ERROR_INFO(do_trap_unknown, 152 SIGILL, ILL_ILLTRP, "unknown exception"); 153 DO_ERROR_INFO(do_trap_zdiv, 154 SIGFPE, FPE_INTDIV, "error zero div exception"); 155 DO_ERROR_INFO(do_trap_buserr, 156 SIGSEGV, ILL_ILLADR, "error bus error exception"); 157 158 asmlinkage void do_trap_misaligned(struct pt_regs *regs) 159 { 160 #ifdef CONFIG_CPU_NEED_SOFTALIGN 161 csky_alignment(regs); 162 #else 163 current->thread.trap_no = trap_no(regs); 164 do_trap_error(regs, SIGBUS, BUS_ADRALN, regs->pc, 165 "Oops - load/store address misaligned"); 166 #endif 167 } 168 169 asmlinkage void do_trap_bkpt(struct pt_regs *regs) 170 { 171 #ifdef CONFIG_KPROBES 172 if (kprobe_single_step_handler(regs)) 173 return; 174 #endif 175 #ifdef CONFIG_UPROBES 176 if (uprobe_single_step_handler(regs)) 177 return; 178 #endif 179 if (user_mode(regs)) { 180 send_sig(SIGTRAP, current, 0); 181 return; 182 } 183 184 do_trap_error(regs, SIGILL, ILL_ILLTRP, regs->pc, 185 "Oops - illegal trap exception"); 186 } 187 188 asmlinkage void do_trap_illinsn(struct pt_regs *regs) 189 { 190 current->thread.trap_no = trap_no(regs); 191 192 #ifdef CONFIG_KPROBES 193 if (kprobe_breakpoint_handler(regs)) 194 return; 195 #endif 196 #ifdef CONFIG_UPROBES 197 if (uprobe_breakpoint_handler(regs)) 198 return; 199 #endif 200 #ifndef CONFIG_CPU_NO_USER_BKPT 201 if (*(uint16_t *)instruction_pointer(regs) != USR_BKPT) { 202 send_sig(SIGTRAP, current, 0); 203 return; 204 } 205 #endif 206 207 do_trap_error(regs, SIGILL, ILL_ILLOPC, regs->pc, 208 "Oops - illegal instruction exception"); 209 } 210 211 asmlinkage void do_trap_fpe(struct pt_regs *regs) 212 { 213 #ifdef CONFIG_CPU_HAS_FPU 214 return fpu_fpe(regs); 215 #else 216 do_trap_error(regs, SIGILL, ILL_ILLOPC, regs->pc, 217 "Oops - fpu instruction exception"); 218 #endif 219 } 220 221 asmlinkage void do_trap_priv(struct pt_regs *regs) 222 { 223 #ifdef CONFIG_CPU_HAS_FPU 224 if (user_mode(regs) && fpu_libc_helper(regs)) 225 return; 226 #endif 227 do_trap_error(regs, SIGILL, ILL_PRVOPC, regs->pc, 228 "Oops - illegal privileged exception"); 229 } 230 231 asmlinkage void trap_c(struct pt_regs *regs) 232 { 233 switch (trap_no(regs)) { 234 case VEC_ZERODIV: 235 do_trap_zdiv(regs); 236 break; 237 case VEC_TRACE: 238 do_trap_bkpt(regs); 239 break; 240 case VEC_ILLEGAL: 241 do_trap_illinsn(regs); 242 break; 243 case VEC_TRAP1: 244 case VEC_BREAKPOINT: 245 do_trap_bkpt(regs); 246 break; 247 case VEC_ACCESS: 248 do_trap_buserr(regs); 249 break; 250 case VEC_ALIGN: 251 do_trap_misaligned(regs); 252 break; 253 case VEC_FPE: 254 do_trap_fpe(regs); 255 break; 256 case VEC_PRIV: 257 do_trap_priv(regs); 258 break; 259 default: 260 do_trap_unknown(regs); 261 break; 262 } 263 } 264