arch/csky/kernel/traps.c

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