1 // SPDX-License-Identifier: GPL-2.0-only
3 * Kernel traps/events for Hexagon processor
5 * Copyright (c) 2010-2014, The Linux Foundation. All rights reserved.
8 #include <linux/init.h>
9 #include <linux/sched/signal.h>
10 #include <linux/sched/debug.h>
11 #include <linux/sched/task_stack.h>
12 #include <linux/module.h>
13 #include <linux/kallsyms.h>
14 #include <linux/kdebug.h>
15 #include <linux/syscalls.h>
16 #include <linux/signal.h>
17 #include <linux/tracehook.h>
18 #include <asm/traps.h>
19 #include <asm/vm_fault.h>
20 #include <asm/syscall.h>
21 #include <asm/registers.h>
22 #include <asm/unistd.h>
23 #include <asm/sections.h>
25 # include <linux/kgdb.h>
28 #define TRAP_SYSCALL 1
29 #define TRAP_DEBUG 0xdb
31 void __init trap_init(void)
35 #ifdef CONFIG_GENERIC_BUG
36 /* Maybe should resemble arch/sh/kernel/traps.c ?? */
37 int is_valid_bugaddr(unsigned long addr)
41 #endif /* CONFIG_GENERIC_BUG */
43 static const char *ex_name(int ex)
48 return "Execute protection fault";
51 return "Read protection fault";
54 return "Write protection fault";
56 return "Misaligned instruction";
58 return "Multiple writes to same register in packet";
60 return "Program counter values that are not properly aligned";
62 return "Misaligned data load";
64 return "Misaligned data store";
67 return "Illegal instruction";
69 return "Precise bus error";
74 return "Debugger trap";
77 return "Unrecognized exception";
81 static void do_show_stack(struct task_struct *task, unsigned long *fp,
82 unsigned long ip, const char *loglvl)
84 int kstack_depth_to_print = 24;
85 unsigned long offset, size;
86 const char *name = NULL;
88 unsigned long low, high;
96 printk("%sCPU#%d, %s/%d, Call Trace:\n", loglvl, raw_smp_processor_id(),
97 task->comm, task_pid_nr(task));
100 if (task == current) {
101 asm("%0 = r30" : "=r" (fp));
103 fp = (unsigned long *)
104 ((struct hexagon_switch_stack *)
105 task->thread.switch_sp)->fp;
109 if ((((unsigned long) fp) & 0x3) || ((unsigned long) fp < 0x1000)) {
110 printk("%s-- Corrupt frame pointer %p\n", loglvl, fp);
114 /* Saved link reg is one word above FP */
118 /* Expect kernel stack to be in-bounds */
119 low = (unsigned long)task_stack_page(task);
120 high = low + THREAD_SIZE - 8;
121 low += sizeof(struct thread_info);
123 for (i = 0; i < kstack_depth_to_print; i++) {
125 name = kallsyms_lookup(ip, &size, &offset, &modname, tmpstr);
127 printk("%s[%p] 0x%lx: %s + 0x%lx", loglvl, fp, ip, name, offset);
128 if (((unsigned long) fp < low) || (high < (unsigned long) fp))
129 printk(KERN_CONT " (FP out of bounds!)");
131 printk(KERN_CONT " [%s] ", modname);
132 printk(KERN_CONT "\n");
134 newfp = (unsigned long *) *fp;
136 if (((unsigned long) newfp) & 0x3) {
137 printk("%s-- Corrupt frame pointer %p\n", loglvl, newfp);
141 /* Attempt to continue past exception. */
143 struct pt_regs *regs = (struct pt_regs *) (((void *)fp)
146 if (regs->syscall_nr != -1) {
147 printk("%s-- trap0 -- syscall_nr: %ld", loglvl,
149 printk(KERN_CONT " psp: %lx elr: %lx\n",
150 pt_psp(regs), pt_elr(regs));
153 /* really want to see more ... */
154 kstack_depth_to_print += 6;
155 printk("%s-- %s (0x%lx) badva: %lx\n", loglvl,
156 ex_name(pt_cause(regs)), pt_cause(regs),
160 newfp = (unsigned long *) regs->r30;
166 /* If link reg is null, we are done. */
170 /* If newfp isn't larger, we're tracing garbage. */
178 void show_stack(struct task_struct *task, unsigned long *fp, const char *loglvl)
180 /* Saved link reg is one word above FP */
181 do_show_stack(task, fp, 0, loglvl);
184 int die(const char *str, struct pt_regs *regs, long err)
190 .lock = __SPIN_LOCK_UNLOCKED(die.lock),
197 spin_lock_irq(&die.lock);
199 printk(KERN_EMERG "Oops: %s[#%d]:\n", str, ++die.counter);
201 if (notify_die(DIE_OOPS, str, regs, err, pt_cause(regs), SIGSEGV) ==
207 do_show_stack(current, ®s->r30, pt_elr(regs), KERN_EMERG);
210 add_taint(TAINT_DIE, LOCKDEP_NOW_UNRELIABLE);
212 spin_unlock_irq(&die.lock);
215 panic("Fatal exception in interrupt");
218 panic("Fatal exception");
225 int die_if_kernel(char *str, struct pt_regs *regs, long err)
227 if (!user_mode(regs))
228 return die(str, regs, err);
234 * It's not clear that misaligned fetches are ever recoverable.
236 static void misaligned_instruction(struct pt_regs *regs)
238 die_if_kernel("Misaligned Instruction", regs, 0);
243 * Misaligned loads and stores, on the other hand, can be
244 * emulated, and probably should be, some day. But for now
245 * they will be considered fatal.
247 static void misaligned_data_load(struct pt_regs *regs)
249 die_if_kernel("Misaligned Data Load", regs, 0);
253 static void misaligned_data_store(struct pt_regs *regs)
255 die_if_kernel("Misaligned Data Store", regs, 0);
259 static void illegal_instruction(struct pt_regs *regs)
261 die_if_kernel("Illegal Instruction", regs, 0);
266 * Precise bus errors may be recoverable with a a retry,
267 * but for now, treat them as irrecoverable.
269 static void precise_bus_error(struct pt_regs *regs)
271 die_if_kernel("Precise Bus Error", regs, 0);
276 * If anything is to be done here other than panic,
277 * it will probably be complex and migrate to another
278 * source module. For now, just die.
280 static void cache_error(struct pt_regs *regs)
282 die("Cache Error", regs, 0);
286 * General exception handler
288 void do_genex(struct pt_regs *regs)
291 * Decode Cause and Dispatch
293 switch (pt_cause(regs)) {
296 execute_protection_fault(regs);
300 read_protection_fault(regs);
304 write_protection_fault(regs);
307 misaligned_instruction(regs);
310 illegal_instruction(regs);
313 misaligned_instruction(regs);
316 misaligned_data_load(regs);
319 misaligned_data_store(regs);
323 illegal_instruction(regs);
326 precise_bus_error(regs);
332 /* Halt and catch fire */
333 panic("Unrecognized exception 0x%lx\n", pt_cause(regs));
338 /* Indirect system call dispatch */
339 long sys_syscall(void)
341 printk(KERN_ERR "sys_syscall invoked!\n");
345 void do_trap0(struct pt_regs *regs)
349 switch (pt_cause(regs)) {
351 /* System call is trap0 #1 */
353 /* allow strace to catch syscall args */
354 if (unlikely(test_thread_flag(TIF_SYSCALL_TRACE) &&
355 tracehook_report_syscall_entry(regs)))
356 return; /* return -ENOSYS somewhere? */
358 /* Interrupts should be re-enabled for syscall processing */
359 __vmsetie(VM_INT_ENABLE);
362 * System call number is in r6, arguments in r0..r5.
363 * Fortunately, no Linux syscall has more than 6 arguments,
364 * and Hexagon ABI passes first 6 arguments in registers.
365 * 64-bit arguments are passed in odd/even register pairs.
366 * Fortunately, we have no system calls that take more
367 * than three arguments with more than one 64-bit value.
368 * Should that change, we'd need to redesign to copy
369 * between user and kernel stacks.
371 regs->syscall_nr = regs->r06;
374 * GPR R0 carries the first parameter, and is also used
375 * to report the return value. We need a backup of
376 * the user's value in case we need to do a late restart
377 * of the system call.
379 regs->restart_r0 = regs->r00;
381 if ((unsigned long) regs->syscall_nr >= __NR_syscalls) {
384 syscall = (syscall_fn)
385 (sys_call_table[regs->syscall_nr]);
386 regs->r00 = syscall(regs->r00, regs->r01,
387 regs->r02, regs->r03,
388 regs->r04, regs->r05);
391 /* allow strace to get the syscall return state */
392 if (unlikely(test_thread_flag(TIF_SYSCALL_TRACE)))
393 tracehook_report_syscall_exit(regs, 0);
397 /* Trap0 0xdb is debug breakpoint */
398 if (user_mode(regs)) {
400 * Some architecures add some per-thread state
401 * to distinguish between breakpoint traps and
402 * trace traps. We may want to do that, and
403 * set the si_code value appropriately, or we
404 * may want to use a different trap0 flavor.
406 force_sig_fault(SIGTRAP, TRAP_BRKPT,
407 (void __user *) pt_elr(regs));
410 kgdb_handle_exception(pt_cause(regs), SIGTRAP,
416 /* Ignore other trap0 codes for now, especially 0 (Angel calls) */
420 * Machine check exception handler
422 void do_machcheck(struct pt_regs *regs)
424 /* Halt and catch fire */
429 * Treat this like the old 0xdb trap.
432 void do_debug_exception(struct pt_regs *regs)
434 regs->hvmer.vmest &= ~HVM_VMEST_CAUSE_MSK;
435 regs->hvmer.vmest |= (TRAP_DEBUG << HVM_VMEST_CAUSE_SFT);