arch/riscv/kernel/traps.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * Copyright (C) 2012 Regents of the University of California
   4  */
   5
   6 #include <linux/cpu.h>
   7 #include <linux/kernel.h>
   8 #include <linux/init.h>
   9 #include <linux/randomize_kstack.h>
  10 #include <linux/sched.h>
  11 #include <linux/sched/debug.h>
  12 #include <linux/sched/signal.h>
  13 #include <linux/signal.h>
  14 #include <linux/kdebug.h>
  15 #include <linux/uaccess.h>
  16 #include <linux/kprobes.h>
  17 #include <linux/uprobes.h>
  18 #include <asm/uprobes.h>
  19 #include <linux/mm.h>
  20 #include <linux/module.h>
  21 #include <linux/irq.h>
  22 #include <linux/kexec.h>
  23 #include <linux/entry-common.h>
  24
  25 #include <asm/asm-prototypes.h>
  26 #include <asm/bug.h>
  27 #include <asm/cfi.h>
  28 #include <asm/csr.h>
  29 #include <asm/processor.h>
  30 #include <asm/ptrace.h>
  31 #include <asm/syscall.h>
  32 #include <asm/thread_info.h>
  33 #include <asm/vector.h>
  34 #include <asm/irq_stack.h>
  35
  36 int show_unhandled_signals = 1;
  37
  38 static DEFINE_SPINLOCK(die_lock);
  39
  40 static int copy_code(struct pt_regs *regs, u16 *val, const u16 *insns)
  41 {
  42         const void __user *uaddr = (__force const void __user *)insns;
  43
  44         if (!user_mode(regs))
  45                 return get_kernel_nofault(*val, insns);
  46
  47         /* The user space code from other tasks cannot be accessed. */
  48         if (regs != task_pt_regs(current))
  49                 return -EPERM;
  50
  51         return copy_from_user_nofault(val, uaddr, sizeof(*val));
  52 }
  53
  54 static void dump_instr(const char *loglvl, struct pt_regs *regs)
  55 {
  56         char str[sizeof("0000 ") * 12 + 2 + 1], *p = str;
  57         const u16 *insns = (u16 *)instruction_pointer(regs);
  58         long bad;
  59         u16 val;
  60         int i;
  61
  62         for (i = -10; i < 2; i++) {
  63                 bad = copy_code(regs, &val, &insns[i]);
  64                 if (!bad) {
  65                         p += sprintf(p, i == 0 ? "(%04hx) " : "%04hx ", val);
  66                 } else {
  67                         printk("%sCode: Unable to access instruction at 0x%px.\n",
  68                                loglvl, &insns[i]);
  69                         return;
  70                 }
  71         }
  72         printk("%sCode: %s\n", loglvl, str);
  73 }
  74
  75 void die(struct pt_regs *regs, const char *str)
  76 {
  77         static int die_counter;
  78         int ret;
  79         long cause;
  80         unsigned long flags;
  81
  82         oops_enter();
  83
  84         spin_lock_irqsave(&die_lock, flags);
  85         console_verbose();
  86         bust_spinlocks(1);
  87
  88         pr_emerg("%s [#%d]\n", str, ++die_counter);
  89         print_modules();
  90         if (regs) {
  91                 show_regs(regs);
  92                 dump_instr(KERN_EMERG, regs);
  93         }
  94
  95         cause = regs ? regs->cause : -1;
  96         ret = notify_die(DIE_OOPS, str, regs, 0, cause, SIGSEGV);
  97
  98         if (kexec_should_crash(current))
  99                 crash_kexec(regs);
 100
 101         bust_spinlocks(0);
 102         add_taint(TAINT_DIE, LOCKDEP_NOW_UNRELIABLE);
 103         spin_unlock_irqrestore(&die_lock, flags);
 104         oops_exit();
 105
 106         if (in_interrupt())
 107                 panic("Fatal exception in interrupt");
 108         if (panic_on_oops)
 109                 panic("Fatal exception");
 110         if (ret != NOTIFY_STOP)
 111                 make_task_dead(SIGSEGV);
 112 }
 113
 114 void do_trap(struct pt_regs *regs, int signo, int code, unsigned long addr)
 115 {
 116         struct task_struct *tsk = current;
 117
 118         if (show_unhandled_signals && unhandled_signal(tsk, signo)
 119             && printk_ratelimit()) {
 120                 pr_info("%s[%d]: unhandled signal %d code 0x%x at 0x" REG_FMT,
 121                         tsk->comm, task_pid_nr(tsk), signo, code, addr);
 122                 print_vma_addr(KERN_CONT " in ", instruction_pointer(regs));
 123                 pr_cont("\n");
 124                 __show_regs(regs);
 125                 dump_instr(KERN_EMERG, 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.bad_cause = regs->cause;
 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 #if defined(CONFIG_XIP_KERNEL) && defined(CONFIG_RISCV_ALTERNATIVE)
 145 #define __trap_section __noinstr_section(".xip.traps")
 146 #else
 147 #define __trap_section noinstr
 148 #endif
 149 #define DO_ERROR_INFO(name, signo, code, str)                                   \
 150 asmlinkage __visible __trap_section void name(struct pt_regs *regs)             \
 151 {                                                                               \
 152         if (user_mode(regs)) {                                                  \
 153                 irqentry_enter_from_user_mode(regs);                            \
 154                 do_trap_error(regs, signo, code, regs->epc, "Oops - " str);     \
 155                 irqentry_exit_to_user_mode(regs);                               \
 156         } else {                                                                \
 157                 irqentry_state_t state = irqentry_nmi_enter(regs);              \
 158                 do_trap_error(regs, signo, code, regs->epc, "Oops - " str);     \
 159                 irqentry_nmi_exit(regs, state);                                 \
 160         }                                                                       \
 161 }
 162
 163 DO_ERROR_INFO(do_trap_unknown,
 164         SIGILL, ILL_ILLTRP, "unknown exception");
 165 DO_ERROR_INFO(do_trap_insn_misaligned,
 166         SIGBUS, BUS_ADRALN, "instruction address misaligned");
 167 DO_ERROR_INFO(do_trap_insn_fault,
 168         SIGSEGV, SEGV_ACCERR, "instruction access fault");
 169
 170 asmlinkage __visible __trap_section void do_trap_insn_illegal(struct pt_regs *regs)
 171 {
 172         bool handled;
 173
 174         if (user_mode(regs)) {
 175                 irqentry_enter_from_user_mode(regs);
 176
 177                 local_irq_enable();
 178
 179                 handled = riscv_v_first_use_handler(regs);
 180
 181                 local_irq_disable();
 182
 183                 if (!handled)
 184                         do_trap_error(regs, SIGILL, ILL_ILLOPC, regs->epc,
 185                                       "Oops - illegal instruction");
 186
 187                 irqentry_exit_to_user_mode(regs);
 188         } else {
 189                 irqentry_state_t state = irqentry_nmi_enter(regs);
 190
 191                 do_trap_error(regs, SIGILL, ILL_ILLOPC, regs->epc,
 192                               "Oops - illegal instruction");
 193
 194                 irqentry_nmi_exit(regs, state);
 195         }
 196 }
 197
 198 DO_ERROR_INFO(do_trap_load_fault,
 199         SIGSEGV, SEGV_ACCERR, "load access fault");
 200
 201 asmlinkage __visible __trap_section void do_trap_load_misaligned(struct pt_regs *regs)
 202 {
 203         if (user_mode(regs)) {
 204                 irqentry_enter_from_user_mode(regs);
 205
 206                 if (handle_misaligned_load(regs))
 207                         do_trap_error(regs, SIGBUS, BUS_ADRALN, regs->epc,
 208                               "Oops - load address misaligned");
 209
 210                 irqentry_exit_to_user_mode(regs);
 211         } else {
 212                 irqentry_state_t state = irqentry_nmi_enter(regs);
 213
 214                 if (handle_misaligned_load(regs))
 215                         do_trap_error(regs, SIGBUS, BUS_ADRALN, regs->epc,
 216                               "Oops - load address misaligned");
 217
 218                 irqentry_nmi_exit(regs, state);
 219         }
 220 }
 221
 222 asmlinkage __visible __trap_section void do_trap_store_misaligned(struct pt_regs *regs)
 223 {
 224         if (user_mode(regs)) {
 225                 irqentry_enter_from_user_mode(regs);
 226
 227                 if (handle_misaligned_store(regs))
 228                         do_trap_error(regs, SIGBUS, BUS_ADRALN, regs->epc,
 229                                 "Oops - store (or AMO) address misaligned");
 230
 231                 irqentry_exit_to_user_mode(regs);
 232         } else {
 233                 irqentry_state_t state = irqentry_nmi_enter(regs);
 234
 235                 if (handle_misaligned_store(regs))
 236                         do_trap_error(regs, SIGBUS, BUS_ADRALN, regs->epc,
 237                                 "Oops - store (or AMO) address misaligned");
 238
 239                 irqentry_nmi_exit(regs, state);
 240         }
 241 }
 242 DO_ERROR_INFO(do_trap_store_fault,
 243         SIGSEGV, SEGV_ACCERR, "store (or AMO) access fault");
 244 DO_ERROR_INFO(do_trap_ecall_s,
 245         SIGILL, ILL_ILLTRP, "environment call from S-mode");
 246 DO_ERROR_INFO(do_trap_ecall_m,
 247         SIGILL, ILL_ILLTRP, "environment call from M-mode");
 248
 249 static inline unsigned long get_break_insn_length(unsigned long pc)
 250 {
 251         bug_insn_t insn;
 252
 253         if (get_kernel_nofault(insn, (bug_insn_t *)pc))
 254                 return 0;
 255
 256         return GET_INSN_LENGTH(insn);
 257 }
 258
 259 static bool probe_single_step_handler(struct pt_regs *regs)
 260 {
 261         bool user = user_mode(regs);
 262
 263         return user ? uprobe_single_step_handler(regs) : kprobe_single_step_handler(regs);
 264 }
 265
 266 static bool probe_breakpoint_handler(struct pt_regs *regs)
 267 {
 268         bool user = user_mode(regs);
 269
 270         return user ? uprobe_breakpoint_handler(regs) : kprobe_breakpoint_handler(regs);
 271 }
 272
 273 void handle_break(struct pt_regs *regs)
 274 {
 275         if (probe_single_step_handler(regs))
 276                 return;
 277
 278         if (probe_breakpoint_handler(regs))
 279                 return;
 280
 281         current->thread.bad_cause = regs->cause;
 282
 283         if (user_mode(regs))
 284                 force_sig_fault(SIGTRAP, TRAP_BRKPT, (void __user *)regs->epc);
 285 #ifdef CONFIG_KGDB
 286         else if (notify_die(DIE_TRAP, "EBREAK", regs, 0, regs->cause, SIGTRAP)
 287                                                                 == NOTIFY_STOP)
 288                 return;
 289 #endif
 290         else if (report_bug(regs->epc, regs) == BUG_TRAP_TYPE_WARN ||
 291                  handle_cfi_failure(regs) == BUG_TRAP_TYPE_WARN)
 292                 regs->epc += get_break_insn_length(regs->epc);
 293         else
 294                 die(regs, "Kernel BUG");
 295 }
 296
 297 asmlinkage __visible __trap_section void do_trap_break(struct pt_regs *regs)
 298 {
 299         if (user_mode(regs)) {
 300                 irqentry_enter_from_user_mode(regs);
 301
 302                 handle_break(regs);
 303
 304                 irqentry_exit_to_user_mode(regs);
 305         } else {
 306                 irqentry_state_t state = irqentry_nmi_enter(regs);
 307
 308                 handle_break(regs);
 309
 310                 irqentry_nmi_exit(regs, state);
 311         }
 312 }
 313
 314 asmlinkage __visible __trap_section  __no_stack_protector
 315 void do_trap_ecall_u(struct pt_regs *regs)
 316 {
 317         if (user_mode(regs)) {
 318                 long syscall = regs->a7;
 319
 320                 regs->epc += 4;
 321                 regs->orig_a0 = regs->a0;
 322
 323                 riscv_v_vstate_discard(regs);
 324
 325                 syscall = syscall_enter_from_user_mode(regs, syscall);
 326
 327                 add_random_kstack_offset();
 328
 329                 if (syscall >= 0 && syscall < NR_syscalls)
 330                         syscall_handler(regs, syscall);
 331                 else if (syscall != -1)
 332                         regs->a0 = -ENOSYS;
 333                 /*
 334                  * Ultimately, this value will get limited by KSTACK_OFFSET_MAX(),
 335                  * so the maximum stack offset is 1k bytes (10 bits).
 336                  *
 337                  * The actual entropy will be further reduced by the compiler when
 338                  * applying stack alignment constraints: 16-byte (i.e. 4-bit) aligned
 339                  * for RV32I or RV64I.
 340                  *
 341                  * The resulting 6 bits of entropy is seen in SP[9:4].
 342                  */
 343                 choose_random_kstack_offset(get_random_u16());
 344
 345                 syscall_exit_to_user_mode(regs);
 346         } else {
 347                 irqentry_state_t state = irqentry_nmi_enter(regs);
 348
 349                 do_trap_error(regs, SIGILL, ILL_ILLTRP, regs->epc,
 350                         "Oops - environment call from U-mode");
 351
 352                 irqentry_nmi_exit(regs, state);
 353         }
 354
 355 }
 356
 357 #ifdef CONFIG_MMU
 358 asmlinkage __visible noinstr void do_page_fault(struct pt_regs *regs)
 359 {
 360         irqentry_state_t state = irqentry_enter(regs);
 361
 362         handle_page_fault(regs);
 363
 364         local_irq_disable();
 365
 366         irqentry_exit(regs, state);
 367 }
 368 #endif
 369
 370 static void noinstr handle_riscv_irq(struct pt_regs *regs)
 371 {
 372         struct pt_regs *old_regs;
 373
 374         irq_enter_rcu();
 375         old_regs = set_irq_regs(regs);
 376         handle_arch_irq(regs);
 377         set_irq_regs(old_regs);
 378         irq_exit_rcu();
 379 }
 380
 381 asmlinkage void noinstr do_irq(struct pt_regs *regs)
 382 {
 383         irqentry_state_t state = irqentry_enter(regs);
 384
 385         if (IS_ENABLED(CONFIG_IRQ_STACKS) && on_thread_stack())
 386                 call_on_irq_stack(regs, handle_riscv_irq);
 387         else
 388                 handle_riscv_irq(regs);
 389
 390         irqentry_exit(regs, state);
 391 }
 392
 393 #ifdef CONFIG_GENERIC_BUG
 394 int is_valid_bugaddr(unsigned long pc)
 395 {
 396         bug_insn_t insn;
 397
 398         if (pc < VMALLOC_START)
 399                 return 0;
 400         if (get_kernel_nofault(insn, (bug_insn_t *)pc))
 401                 return 0;
 402         if ((insn & __INSN_LENGTH_MASK) == __INSN_LENGTH_32)
 403                 return (insn == __BUG_INSN_32);
 404         else
 405                 return ((insn & __COMPRESSED_INSN_MASK) == __BUG_INSN_16);
 406 }
 407 #endif /* CONFIG_GENERIC_BUG */
 408
 409 #ifdef CONFIG_VMAP_STACK
 410 DEFINE_PER_CPU(unsigned long [OVERFLOW_STACK_SIZE/sizeof(long)],
 411                 overflow_stack)__aligned(16);
 412
 413 asmlinkage void handle_bad_stack(struct pt_regs *regs)
 414 {
 415         unsigned long tsk_stk = (unsigned long)current->stack;
 416         unsigned long ovf_stk = (unsigned long)this_cpu_ptr(overflow_stack);
 417
 418         console_verbose();
 419
 420         pr_emerg("Insufficient stack space to handle exception!\n");
 421         pr_emerg("Task stack:     [0x%016lx..0x%016lx]\n",
 422                         tsk_stk, tsk_stk + THREAD_SIZE);
 423         pr_emerg("Overflow stack: [0x%016lx..0x%016lx]\n",
 424                         ovf_stk, ovf_stk + OVERFLOW_STACK_SIZE);
 425
 426         __show_regs(regs);
 427         panic("Kernel stack overflow");
 428
 429         for (;;)
 430                 wait_for_interrupt();
 431 }
 432 #endif