Hexagon: Provide basic debugging and system trap support.
Richard Kuo [Mon, 31 Oct 2011 23:44:34 +0000 (18:44 -0500)]
Signed-off-by: Richard Kuo <rkuo@codeaurora.org>
Signed-off-by: Linas Vepstas <linas@codeaurora.org>
Acked-by: Arnd Bergmann <arnd@arndb.de>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>

arch/hexagon/include/asm/traps.h [new file with mode: 0644]
arch/hexagon/kernel/traps.c [new file with mode: 0644]

diff --git a/arch/hexagon/include/asm/traps.h b/arch/hexagon/include/asm/traps.h
new file mode 100644 (file)
index 0000000..6a407f6
--- /dev/null
@@ -0,0 +1,29 @@
+/*
+ * Trap support for Hexagon
+ *
+ * Copyright (c) 2010-2011, Code Aurora Forum. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 and
+ * only version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+ * 02110-1301, USA.
+ */
+
+#ifndef _ASM_HEXAGON_TRAPS_H
+#define _ASM_HEXAGON_TRAPS_H
+
+#include <asm/registers.h>
+
+extern int die(const char *str, struct pt_regs *regs, long err);
+extern int die_if_kernel(char *str, struct pt_regs *regs, long err);
+
+#endif /* _ASM_HEXAGON_TRAPS_H */
diff --git a/arch/hexagon/kernel/traps.c b/arch/hexagon/kernel/traps.c
new file mode 100644 (file)
index 0000000..f08857d
--- /dev/null
@@ -0,0 +1,454 @@
+/*
+ * Kernel traps/events for Hexagon processor
+ *
+ * Copyright (c) 2010-2011, Code Aurora Forum. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 and
+ * only version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+ * 02110-1301, USA.
+ */
+
+#include <linux/init.h>
+#include <linux/sched.h>
+#include <linux/module.h>
+#include <linux/kallsyms.h>
+#include <linux/kdebug.h>
+#include <linux/syscalls.h>
+#include <linux/signal.h>
+#include <linux/tracehook.h>
+#include <asm/traps.h>
+#include <asm/vm_fault.h>
+#include <asm/syscall.h>
+#include <asm/registers.h>
+#include <asm/unistd.h>
+#include <asm/sections.h>
+#ifdef CONFIG_KGDB
+# include <linux/kgdb.h>
+#endif
+
+#define TRAP_SYSCALL   1
+#define TRAP_DEBUG     0xdb
+
+void __init trap_init(void)
+{
+}
+
+#ifdef CONFIG_GENERIC_BUG
+/* Maybe should resemble arch/sh/kernel/traps.c ?? */
+int is_valid_bugaddr(unsigned long addr)
+{
+       return 1;
+}
+#endif /* CONFIG_GENERIC_BUG */
+
+static const char *ex_name(int ex)
+{
+       switch (ex) {
+       case HVM_GE_C_XPROT:
+       case HVM_GE_C_XUSER:
+               return "Execute protection fault";
+       case HVM_GE_C_RPROT:
+       case HVM_GE_C_RUSER:
+               return "Read protection fault";
+       case HVM_GE_C_WPROT:
+       case HVM_GE_C_WUSER:
+               return "Write protection fault";
+       case HVM_GE_C_XMAL:
+               return "Misaligned instruction";
+       case HVM_GE_C_RMAL:
+               return "Misaligned data load";
+       case HVM_GE_C_WMAL:
+               return "Misaligned data store";
+       case HVM_GE_C_INVI:
+       case HVM_GE_C_PRIVI:
+               return "Illegal instruction";
+       case HVM_GE_C_BUS:
+               return "Precise bus error";
+       case HVM_GE_C_CACHE:
+               return "Cache error";
+
+       case 0xdb:
+               return "Debugger trap";
+
+       default:
+               return "Unrecognized exception";
+       }
+}
+
+static void do_show_stack(struct task_struct *task, unsigned long *fp,
+                         unsigned long ip)
+{
+       int kstack_depth_to_print = 24;
+       unsigned long offset, size;
+       const char *name = NULL;
+       unsigned long *newfp;
+       unsigned long low, high;
+       char tmpstr[128];
+       char *modname;
+       int i;
+
+       if (task == NULL)
+               task = current;
+
+       printk(KERN_INFO "CPU#%d, %s/%d, Call Trace:\n",
+              raw_smp_processor_id(), task->comm,
+              task_pid_nr(task));
+
+       if (fp == NULL) {
+               if (task == current) {
+                       asm("%0 = r30" : "=r" (fp));
+               } else {
+                       fp = (unsigned long *)
+                            ((struct hexagon_switch_stack *)
+                            task->thread.switch_sp)->fp;
+               }
+       }
+
+       if ((((unsigned long) fp) & 0x3) || ((unsigned long) fp < 0x1000)) {
+               printk(KERN_INFO "-- Corrupt frame pointer %p\n", fp);
+               return;
+       }
+
+       /* Saved link reg is one word above FP */
+       if (!ip)
+               ip = *(fp+1);
+
+       /* Expect kernel stack to be in-bounds */
+       low = (unsigned long)task_stack_page(task);
+       high = low + THREAD_SIZE - 8;
+       low += sizeof(struct thread_info);
+
+       for (i = 0; i < kstack_depth_to_print; i++) {
+
+               name = kallsyms_lookup(ip, &size, &offset, &modname, tmpstr);
+
+               printk(KERN_INFO "[%p] 0x%lx: %s + 0x%lx", fp, ip, name,
+                       offset);
+               if (((unsigned long) fp < low) || (high < (unsigned long) fp))
+                       printk(KERN_CONT " (FP out of bounds!)");
+               if (modname)
+                       printk(KERN_CONT " [%s] ", modname);
+               printk(KERN_CONT "\n");
+
+               newfp = (unsigned long *) *fp;
+
+               if (((unsigned long) newfp) & 0x3) {
+                       printk(KERN_INFO "-- Corrupt frame pointer %p\n",
+                               newfp);
+                       break;
+               }
+
+               /* Attempt to continue past exception. */
+               if (0 == newfp) {
+                       struct pt_regs *regs = (struct pt_regs *) (((void *)fp)
+                                               + 8);
+
+                       if (regs->syscall_nr != -1) {
+                               printk(KERN_INFO "-- trap0 -- syscall_nr: %ld",
+                                       regs->syscall_nr);
+                               printk(KERN_CONT "  psp: %lx  elr: %lx\n",
+                                        pt_psp(regs), pt_elr(regs));
+                               break;
+                       } else {
+                               /* really want to see more ... */
+                               kstack_depth_to_print += 6;
+                               printk(KERN_INFO "-- %s (0x%lx)  badva: %lx\n",
+                                       ex_name(pt_cause(regs)), pt_cause(regs),
+                                       pt_badva(regs));
+                       }
+
+                       newfp = (unsigned long *) regs->r30;
+                       ip = pt_elr(regs);
+               } else {
+                       ip = *(newfp + 1);
+               }
+
+               /* If link reg is null, we are done. */
+               if (ip == 0x0)
+                       break;
+
+               /* If newfp isn't larger, we're tracing garbage. */
+               if (newfp > fp)
+                       fp = newfp;
+               else
+                       break;
+       }
+}
+
+void show_stack(struct task_struct *task, unsigned long *fp)
+{
+       /* Saved link reg is one word above FP */
+       do_show_stack(task, fp, 0);
+}
+
+void dump_stack(void)
+{
+       unsigned long *fp;
+       asm("%0 = r30" : "=r" (fp));
+       show_stack(current, fp);
+}
+EXPORT_SYMBOL(dump_stack);
+
+int die(const char *str, struct pt_regs *regs, long err)
+{
+       static struct {
+               spinlock_t lock;
+               int counter;
+       } die = {
+               .lock = __SPIN_LOCK_UNLOCKED(die.lock),
+               .counter = 0
+       };
+
+       console_verbose();
+       oops_enter();
+
+       spin_lock_irq(&die.lock);
+       bust_spinlocks(1);
+       printk(KERN_EMERG "Oops: %s[#%d]:\n", str, ++die.counter);
+
+       if (notify_die(DIE_OOPS, str, regs, err, pt_cause(regs), SIGSEGV) ==
+           NOTIFY_STOP)
+               return 1;
+
+       print_modules();
+       show_regs(regs);
+       do_show_stack(current, &regs->r30, pt_elr(regs));
+
+       bust_spinlocks(0);
+       add_taint(TAINT_DIE);
+
+       spin_unlock_irq(&die.lock);
+
+       if (in_interrupt())
+               panic("Fatal exception in interrupt");
+
+       if (panic_on_oops)
+               panic("Fatal exception");
+
+       oops_exit();
+       do_exit(err);
+       return 0;
+}
+
+int die_if_kernel(char *str, struct pt_regs *regs, long err)
+{
+       if (!user_mode(regs))
+               return die(str, regs, err);
+       else
+               return 0;
+}
+
+/*
+ * It's not clear that misaligned fetches are ever recoverable.
+ */
+static void misaligned_instruction(struct pt_regs *regs)
+{
+       die_if_kernel("Misaligned Instruction", regs, 0);
+       force_sig(SIGBUS, current);
+}
+
+/*
+ * Misaligned loads and stores, on the other hand, can be
+ * emulated, and probably should be, some day.  But for now
+ * they will be considered fatal.
+ */
+static void misaligned_data_load(struct pt_regs *regs)
+{
+       die_if_kernel("Misaligned Data Load", regs, 0);
+       force_sig(SIGBUS, current);
+}
+
+static void misaligned_data_store(struct pt_regs *regs)
+{
+       die_if_kernel("Misaligned Data Store", regs, 0);
+       force_sig(SIGBUS, current);
+}
+
+static void illegal_instruction(struct pt_regs *regs)
+{
+       die_if_kernel("Illegal Instruction", regs, 0);
+       force_sig(SIGILL, current);
+}
+
+/*
+ * Precise bus errors may be recoverable with a a retry,
+ * but for now, treat them as irrecoverable.
+ */
+static void precise_bus_error(struct pt_regs *regs)
+{
+       die_if_kernel("Precise Bus Error", regs, 0);
+       force_sig(SIGBUS, current);
+}
+
+/*
+ * If anything is to be done here other than panic,
+ * it will probably be complex and migrate to another
+ * source module.  For now, just die.
+ */
+static void cache_error(struct pt_regs *regs)
+{
+       die("Cache Error", regs, 0);
+}
+
+/*
+ * General exception handler
+ */
+void do_genex(struct pt_regs *regs)
+{
+       /*
+        * Decode Cause and Dispatch
+        */
+       switch (pt_cause(regs)) {
+       case HVM_GE_C_XPROT:
+       case HVM_GE_C_XUSER:
+               execute_protection_fault(regs);
+               break;
+       case HVM_GE_C_RPROT:
+       case HVM_GE_C_RUSER:
+               read_protection_fault(regs);
+               break;
+       case HVM_GE_C_WPROT:
+       case HVM_GE_C_WUSER:
+               write_protection_fault(regs);
+               break;
+       case HVM_GE_C_XMAL:
+               misaligned_instruction(regs);
+               break;
+       case HVM_GE_C_RMAL:
+               misaligned_data_load(regs);
+               break;
+       case HVM_GE_C_WMAL:
+               misaligned_data_store(regs);
+               break;
+       case HVM_GE_C_INVI:
+       case HVM_GE_C_PRIVI:
+               illegal_instruction(regs);
+               break;
+       case HVM_GE_C_BUS:
+               precise_bus_error(regs);
+               break;
+       case HVM_GE_C_CACHE:
+               cache_error(regs);
+               break;
+       default:
+               /* Halt and catch fire */
+               panic("Unrecognized exception 0x%lx\n", pt_cause(regs));
+               break;
+       }
+}
+
+/* Indirect system call dispatch */
+long sys_syscall(void)
+{
+       printk(KERN_ERR "sys_syscall invoked!\n");
+       return -ENOSYS;
+}
+
+void do_trap0(struct pt_regs *regs)
+{
+       unsigned long syscallret = 0;
+       syscall_fn syscall;
+
+       switch (pt_cause(regs)) {
+       case TRAP_SYSCALL:
+               /* System call is trap0 #1 */
+
+               /* allow strace to catch syscall args  */
+               if (unlikely(test_thread_flag(TIF_SYSCALL_TRACE) &&
+                       tracehook_report_syscall_entry(regs)))
+                       return;  /*  return -ENOSYS somewhere?  */
+
+               /* Interrupts should be re-enabled for syscall processing */
+               __vmsetie(VM_INT_ENABLE);
+
+               /*
+                * System call number is in r6, arguments in r0..r5.
+                * Fortunately, no Linux syscall has more than 6 arguments,
+                * and Hexagon ABI passes first 6 arguments in registers.
+                * 64-bit arguments are passed in odd/even register pairs.
+                * Fortunately, we have no system calls that take more
+                * than three arguments with more than one 64-bit value.
+                * Should that change, we'd need to redesign to copy
+                * between user and kernel stacks.
+                */
+               regs->syscall_nr = regs->r06;
+
+               /*
+                * GPR R0 carries the first parameter, and is also used
+                * to report the return value.  We need a backup of
+                * the user's value in case we need to do a late restart
+                * of the system call.
+                */
+               regs->restart_r0 = regs->r00;
+
+               if ((unsigned long) regs->syscall_nr >= __NR_syscalls) {
+                       regs->r00 = -1;
+               } else {
+                       syscall = (syscall_fn)
+                                 (sys_call_table[regs->syscall_nr]);
+                       syscallret = syscall(regs->r00, regs->r01,
+                                  regs->r02, regs->r03,
+                                  regs->r04, regs->r05);
+               }
+
+               /*
+                * If it was a sigreturn system call, don't overwrite
+                * r0 value in stack frame with return value.
+                *
+                * __NR_sigreturn doesn't seem to exist in new unistd.h
+                */
+
+               if (regs->syscall_nr != __NR_rt_sigreturn)
+                       regs->r00 = syscallret;
+
+               /* allow strace to get the syscall return state  */
+               if (unlikely(test_thread_flag(TIF_SYSCALL_TRACE)))
+                       tracehook_report_syscall_exit(regs, 0);
+
+               break;
+       case TRAP_DEBUG:
+               /* Trap0 0xdb is debug breakpoint */
+               if (user_mode(regs)) {
+                       struct siginfo info;
+
+                       info.si_signo = SIGTRAP;
+                       info.si_errno = 0;
+                       /*
+                        * Some architecures add some per-thread state
+                        * to distinguish between breakpoint traps and
+                        * trace traps.  We may want to do that, and
+                        * set the si_code value appropriately, or we
+                        * may want to use a different trap0 flavor.
+                        */
+                       info.si_code = TRAP_BRKPT;
+                       info.si_addr = (void __user *) pt_elr(regs);
+                       send_sig_info(SIGTRAP, &info, current);
+               } else {
+#ifdef CONFIG_KGDB
+                       kgdb_handle_exception(pt_cause(regs), SIGTRAP,
+                                             TRAP_BRKPT, regs);
+#endif
+               }
+               break;
+       }
+       /* Ignore other trap0 codes for now, especially 0 (Angel calls) */
+}
+
+/*
+ * Machine check exception handler
+ */
+void do_machcheck(struct pt_regs *regs)
+{
+       /* Halt and catch fire */
+       __vmstop();
+}