[MIPS] kgdb: add arch support for the kernel's kgdb core

The new kgdb architecture specific handler registers and unregisters
dynamically for exceptions depending on when you configure a kgdb I/O
driver.

Aside from initializing the exceptions earlier in the boot process,
kgdb should have no impact on a device when it is compiled in so long
as an I/O module is not configured for use.

There have been quite a number of contributors during the existence of
this patch (see arch/mips/kernel/kgdb.c).  Most recently Jason
re-wrote the mips kgdb logic to use the die notification handlers.

Signed-off-by: Jason Wessel <jason.wessel@windriver.com>
Signed-off-by: Ralf Baechle <ralf@linux-mips.org>

diff --git a/arch/mips/Kconfig b/arch/mips/Kconfig
index 34b13f1d8a0ed3a4d31de5577455d617147ff2e2..4da736e25333abc8ce46440dcb8b97c4c9f2be9d 100644 (file)
--- a/arch/mips/Kconfig
+++ b/arch/mips/Kconfig
@@ -3,6 +3,7 @@ config MIPS
        default y
        select HAVE_IDE
        select HAVE_OPROFILE
+       select HAVE_ARCH_KGDB
        # Horrible source of confusion.  Die, die, die ...
        select EMBEDDED
        select RTC_LIB

diff --git a/arch/mips/kernel/Makefile b/arch/mips/kernel/Makefile
index 73ff048eaa55dae99cb753acf466c5665f7d8e7c..706f9397479770265d69b0307df9d76ea3739178 100644 (file)
--- a/arch/mips/kernel/Makefile
+++ b/arch/mips/kernel/Makefile
@@ -71,6 +71,7 @@ obj-$(CONFIG_MIPS32_COMPAT)   += linux32.o ptrace32.o signal32.o
 obj-$(CONFIG_MIPS32_N32)       += binfmt_elfn32.o scall64-n32.o signal_n32.o
 obj-$(CONFIG_MIPS32_O32)       += binfmt_elfo32.o scall64-o32.o
 
+obj-$(CONFIG_KGDB)             += kgdb.o
 obj-$(CONFIG_PROC_FS)          += proc.o
 
 obj-$(CONFIG_64BIT)            += cpu-bugs64.o

diff --git a/arch/mips/kernel/irq.c b/arch/mips/kernel/irq.c
index 8acba0880d9ff69d63e21df5bcc1af517b2c878e..4b4007b3083a8f881cef80371e68a2a688c55f32 100644 (file)
--- a/arch/mips/kernel/irq.c
+++ b/arch/mips/kernel/irq.c
@@ -21,11 +21,16 @@
 #include <linux/sched.h>
 #include <linux/seq_file.h>
 #include <linux/kallsyms.h>
+#include <linux/kgdb.h>
 
 #include <asm/atomic.h>
 #include <asm/system.h>
 #include <asm/uaccess.h>
 
+#ifdef CONFIG_KGDB
+int kgdb_early_setup;
+#endif
+
 static unsigned long irq_map[NR_IRQS / BITS_PER_LONG];
 
 int allocate_irqno(void)
@@ -130,8 +135,18 @@ void __init init_IRQ(void)
 {
        int i;
 
+#ifdef CONFIG_KGDB
+       if (kgdb_early_setup)
+               return;
+#endif
+
        for (i = 0; i < NR_IRQS; i++)
                set_irq_noprobe(i);
 
        arch_init_irq();
+
+#ifdef CONFIG_KGDB
+       if (!kgdb_early_setup)
+               kgdb_early_setup = 1;
+#endif
 }

diff --git a/arch/mips/kernel/kgdb.c b/arch/mips/kernel/kgdb.c
new file mode 100644 (file)
index 0000000..c5a8b2d
--- /dev/null
+++ b/arch/mips/kernel/kgdb.c
@@ -0,0 +1,281 @@
+/*
+ *  Originally written by Glenn Engel, Lake Stevens Instrument Division
+ *
+ *  Contributed by HP Systems
+ *
+ *  Modified for Linux/MIPS (and MIPS in general) by Andreas Busse
+ *  Send complaints, suggestions etc. to <andy@waldorf-gmbh.de>
+ *
+ *  Copyright (C) 1995 Andreas Busse
+ *
+ *  Copyright (C) 2003 MontaVista Software Inc.
+ *  Author: Jun Sun, jsun@mvista.com or jsun@junsun.net
+ *
+ *  Copyright (C) 2004-2005 MontaVista Software Inc.
+ *  Author: Manish Lachwani, mlachwani@mvista.com or manish@koffee-break.com
+ *
+ *  Copyright (C) 2007-2008 Wind River Systems, Inc.
+ *  Author/Maintainer: Jason Wessel, jason.wessel@windriver.com
+ *
+ *  This file is licensed under the terms of the GNU General Public License
+ *  version 2. This program is licensed "as is" without any warranty of any
+ *  kind, whether express or implied.
+ */
+
+#include <linux/ptrace.h>              /* for linux pt_regs struct */
+#include <linux/kgdb.h>
+#include <linux/kdebug.h>
+#include <linux/sched.h>
+#include <asm/inst.h>
+#include <asm/fpu.h>
+#include <asm/cacheflush.h>
+#include <asm/processor.h>
+#include <asm/sigcontext.h>
+
+static struct hard_trap_info {
+       unsigned char tt;       /* Trap type code for MIPS R3xxx and R4xxx */
+       unsigned char signo;    /* Signal that we map this trap into */
+} hard_trap_info[] = {
+       { 6, SIGBUS },          /* instruction bus error */
+       { 7, SIGBUS },          /* data bus error */
+       { 9, SIGTRAP },         /* break */
+/*     { 11, SIGILL }, */      /* CPU unusable */
+       { 12, SIGFPE },         /* overflow */
+       { 13, SIGTRAP },        /* trap */
+       { 14, SIGSEGV },        /* virtual instruction cache coherency */
+       { 15, SIGFPE },         /* floating point exception */
+       { 23, SIGSEGV },        /* watch */
+       { 31, SIGSEGV },        /* virtual data cache coherency */
+       { 0, 0}                 /* Must be last */
+};
+
+void arch_kgdb_breakpoint(void)
+{
+       __asm__ __volatile__(
+               ".globl breakinst\n\t"
+               ".set\tnoreorder\n\t"
+               "nop\n"
+               "breakinst:\tbreak\n\t"
+               "nop\n\t"
+               ".set\treorder");
+}
+
+static void kgdb_call_nmi_hook(void *ignored)
+{
+       kgdb_nmicallback(raw_smp_processor_id(), (void *)0);
+}
+
+void kgdb_roundup_cpus(unsigned long flags)
+{
+       local_irq_enable();
+       smp_call_function(kgdb_call_nmi_hook, NULL, NULL);
+       local_irq_disable();
+}
+
+static int compute_signal(int tt)
+{
+       struct hard_trap_info *ht;
+
+       for (ht = hard_trap_info; ht->tt && ht->signo; ht++)
+               if (ht->tt == tt)
+                       return ht->signo;
+
+       return SIGHUP;          /* default for things we don't know about */
+}
+
+void pt_regs_to_gdb_regs(unsigned long *gdb_regs, struct pt_regs *regs)
+{
+       int reg;
+
+#if (KGDB_GDB_REG_SIZE == 32)
+       u32 *ptr = (u32 *)gdb_regs;
+#else
+       u64 *ptr = (u64 *)gdb_regs;
+#endif
+
+       for (reg = 0; reg < 32; reg++)
+               *(ptr++) = regs->regs[reg];
+
+       *(ptr++) = regs->cp0_status;
+       *(ptr++) = regs->lo;
+       *(ptr++) = regs->hi;
+       *(ptr++) = regs->cp0_badvaddr;
+       *(ptr++) = regs->cp0_cause;
+       *(ptr++) = regs->cp0_epc;
+
+       /* FP REGS */
+       if (!(current && (regs->cp0_status & ST0_CU1)))
+               return;
+
+       save_fp(current);
+       for (reg = 0; reg < 32; reg++)
+               *(ptr++) = current->thread.fpu.fpr[reg];
+}
+
+void gdb_regs_to_pt_regs(unsigned long *gdb_regs, struct pt_regs *regs)
+{
+       int reg;
+
+#if (KGDB_GDB_REG_SIZE == 32)
+       const u32 *ptr = (u32 *)gdb_regs;
+#else
+       const u64 *ptr = (u64 *)gdb_regs;
+#endif
+
+       for (reg = 0; reg < 32; reg++)
+               regs->regs[reg] = *(ptr++);
+
+       regs->cp0_status = *(ptr++);
+       regs->lo = *(ptr++);
+       regs->hi = *(ptr++);
+       regs->cp0_badvaddr = *(ptr++);
+       regs->cp0_cause = *(ptr++);
+       regs->cp0_epc = *(ptr++);
+
+       /* FP REGS from current */
+       if (!(current && (regs->cp0_status & ST0_CU1)))
+               return;
+
+       for (reg = 0; reg < 32; reg++)
+               current->thread.fpu.fpr[reg] = *(ptr++);
+       restore_fp(current);
+}
+
+/*
+ * Similar to regs_to_gdb_regs() except that process is sleeping and so
+ * we may not be able to get all the info.
+ */
+void sleeping_thread_to_gdb_regs(unsigned long *gdb_regs, struct task_struct *p)
+{
+       int reg;
+       struct thread_info *ti = task_thread_info(p);
+       unsigned long ksp = (unsigned long)ti + THREAD_SIZE - 32;
+       struct pt_regs *regs = (struct pt_regs *)ksp - 1;
+#if (KGDB_GDB_REG_SIZE == 32)
+       u32 *ptr = (u32 *)gdb_regs;
+#else
+       u64 *ptr = (u64 *)gdb_regs;
+#endif
+
+       for (reg = 0; reg < 16; reg++)
+               *(ptr++) = regs->regs[reg];
+
+       /* S0 - S7 */
+       for (reg = 16; reg < 24; reg++)
+               *(ptr++) = regs->regs[reg];
+
+       for (reg = 24; reg < 28; reg++)
+               *(ptr++) = 0;
+
+       /* GP, SP, FP, RA */
+       for (reg = 28; reg < 32; reg++)
+               *(ptr++) = regs->regs[reg];
+
+       *(ptr++) = regs->cp0_status;
+       *(ptr++) = regs->lo;
+       *(ptr++) = regs->hi;
+       *(ptr++) = regs->cp0_badvaddr;
+       *(ptr++) = regs->cp0_cause;
+       *(ptr++) = regs->cp0_epc;
+}
+
+/*
+ * Calls linux_debug_hook before the kernel dies. If KGDB is enabled,
+ * then try to fall into the debugger
+ */
+static int kgdb_mips_notify(struct notifier_block *self, unsigned long cmd,
+                           void *ptr)
+{
+       struct die_args *args = (struct die_args *)ptr;
+       struct pt_regs *regs = args->regs;
+       int trap = (regs->cp0_cause & 0x7c) >> 2;
+
+       if (fixup_exception(regs))
+               return NOTIFY_DONE;
+
+       /* Userpace events, ignore. */
+       if (user_mode(regs))
+               return NOTIFY_DONE;
+
+       if (atomic_read(&kgdb_active) != -1)
+               kgdb_nmicallback(smp_processor_id(), regs);
+
+       if (kgdb_handle_exception(trap, compute_signal(trap), 0, regs))
+               return NOTIFY_DONE;
+
+       if (atomic_read(&kgdb_setting_breakpoint))
+               if ((trap == 9) && (regs->cp0_epc == (unsigned long)breakinst))
+                       regs->cp0_epc += 4;
+
+       /* In SMP mode, __flush_cache_all does IPI */
+       local_irq_enable();
+       __flush_cache_all();
+
+       return NOTIFY_STOP;
+}
+
+static struct notifier_block kgdb_notifier = {
+       .notifier_call = kgdb_mips_notify,
+};
+
+/*
+ * Handle the 's' and 'c' commands
+ */
+int kgdb_arch_handle_exception(int vector, int signo, int err_code,
+                              char *remcom_in_buffer, char *remcom_out_buffer,
+                              struct pt_regs *regs)
+{
+       char *ptr;
+       unsigned long address;
+       int cpu = smp_processor_id();
+
+       switch (remcom_in_buffer[0]) {
+       case 's':
+       case 'c':
+               /* handle the optional parameter */
+               ptr = &remcom_in_buffer[1];
+               if (kgdb_hex2long(&ptr, &address))
+                       regs->cp0_epc = address;
+
+               atomic_set(&kgdb_cpu_doing_single_step, -1);
+               if (remcom_in_buffer[0] == 's')
+                       if (kgdb_contthread)
+                               atomic_set(&kgdb_cpu_doing_single_step, cpu);
+
+               return 0;
+       }
+
+       return -1;
+}
+
+struct kgdb_arch arch_kgdb_ops;
+
+/*
+ * We use kgdb_early_setup so that functions we need to call now don't
+ * cause trouble when called again later.
+ */
+int kgdb_arch_init(void)
+{
+       union mips_instruction insn = {
+               .r_format = {
+                       .opcode = spec_op,
+                       .func   = break_op,
+               }
+       };
+       memcpy(arch_kgdb_ops.gdb_bpt_instr, insn.byte, BREAK_INSTR_SIZE);
+
+       register_die_notifier(&kgdb_notifier);
+
+       return 0;
+}
+
+/*
+ *     kgdb_arch_exit - Perform any architecture specific uninitalization.
+ *
+ *     This function will handle the uninitalization of any architecture
+ *     specific callbacks, for dynamic registration and unregistration.
+ */
+void kgdb_arch_exit(void)
+{
+       unregister_die_notifier(&kgdb_notifier);
+}

diff --git a/arch/mips/kernel/traps.c b/arch/mips/kernel/traps.c
index b8ea4e9d0d87ee8c169feafb93c8000231d3158b..426cced1e9dce3e4d6e560fad38d26136a8c02e9 100644 (file)
--- a/arch/mips/kernel/traps.c
+++ b/arch/mips/kernel/traps.c
@@ -23,6 +23,8 @@
 #include <linux/bootmem.h>
 #include <linux/interrupt.h>
 #include <linux/ptrace.h>
+#include <linux/kgdb.h>
+#include <linux/kdebug.h>
 
 #include <asm/bootinfo.h>
 #include <asm/branch.h>
@@ -425,6 +427,10 @@ asmlinkage void do_be(struct pt_regs *regs)
        printk(KERN_ALERT "%s bus error, epc == %0*lx, ra == %0*lx\n",
               data ? "Data" : "Instruction",
               field, regs->cp0_epc, field, regs->regs[31]);
+       if (notify_die(DIE_OOPS, "bus error", regs, SIGBUS, 0, 0)
+           == NOTIFY_STOP)
+               return;
+
        die_if_kernel("Oops", regs);
        force_sig(SIGBUS, current);
 }
@@ -623,6 +629,9 @@ asmlinkage void do_fpe(struct pt_regs *regs, unsigned long fcr31)
 {
        siginfo_t info;
 
+       if (notify_die(DIE_FP, "FP exception", regs, SIGFPE, 0, 0)
+           == NOTIFY_STOP)
+               return;
        die_if_kernel("FP exception in kernel code", regs);
 
        if (fcr31 & FPU_CSR_UNI_X) {
@@ -682,6 +691,9 @@ static void do_trap_or_bp(struct pt_regs *regs, unsigned int code,
        siginfo_t info;
        char b[40];
 
+       if (notify_die(DIE_TRAP, str, regs, code, 0, 0) == NOTIFY_STOP)
+               return;
+
        /*
         * A short test says that IRIX 5.3 sends SIGTRAP for all trap
         * insns, even for trap and break codes that indicate arithmetic
@@ -762,6 +774,10 @@ asmlinkage void do_ri(struct pt_regs *regs)
        unsigned int opcode = 0;
        int status = -1;
 
+       if (notify_die(DIE_RI, "RI Fault", regs, SIGSEGV, 0, 0)
+           == NOTIFY_STOP)
+               return;
+
        die_if_kernel("Reserved instruction in kernel code", regs);
 
        if (unlikely(compute_return_epc(regs) < 0))
@@ -1537,6 +1553,11 @@ void __init trap_init(void)
        extern char except_vec4;
        unsigned long i;
 
+#if defined(CONFIG_KGDB)
+       if (kgdb_early_setup)
+               return; /* Already done */
+#endif
+
        if (cpu_has_veic || cpu_has_vint)
                ebase = (unsigned long) alloc_bootmem_low_pages(0x200 + VECTORSPACING*64);
        else

diff --git a/include/asm-mips/kdebug.h b/include/asm-mips/kdebug.h
index 6ece1b0376655be5d6ab0fbcdbc6369f7f68acac..5bf62aafc8909308c40d3de0452f764eab88a55c 100644 (file)
--- a/include/asm-mips/kdebug.h
+++ b/include/asm-mips/kdebug.h
@@ -1 +1,13 @@
-#include <asm-generic/kdebug.h>
+#ifndef _ASM_MIPS_KDEBUG_H
+#define _ASM_MIPS_KDEBUG_H
+
+#include <linux/notifier.h>
+
+enum die_val {
+       DIE_OOPS = 1,
+       DIE_FP,
+       DIE_TRAP,
+       DIE_RI,
+};
+
+#endif /* _ASM_MIPS_KDEBUG_H */

diff --git a/include/asm-mips/kgdb.h b/include/asm-mips/kgdb.h
new file mode 100644 (file)
index 0000000..48223b0
--- /dev/null
+++ b/include/asm-mips/kgdb.h
@@ -0,0 +1,44 @@
+#ifndef __ASM_KGDB_H_
+#define __ASM_KGDB_H_
+
+#ifdef __KERNEL__
+
+#include <asm/sgidefs.h>
+
+#if (_MIPS_ISA == _MIPS_ISA_MIPS1) || (_MIPS_ISA == _MIPS_ISA_MIPS2) || \
+       (_MIPS_ISA == _MIPS_ISA_MIPS32)
+
+#define KGDB_GDB_REG_SIZE 32
+
+#elif (_MIPS_ISA == _MIPS_ISA_MIPS3) || (_MIPS_ISA == _MIPS_ISA_MIPS4) || \
+       (_MIPS_ISA == _MIPS_ISA_MIPS64)
+
+#ifdef CONFIG_32BIT
+#define KGDB_GDB_REG_SIZE 32
+#else /* CONFIG_CPU_32BIT */
+#define KGDB_GDB_REG_SIZE 64
+#endif
+#else
+#error "Need to set KGDB_GDB_REG_SIZE for MIPS ISA"
+#endif /* _MIPS_ISA */
+
+#define BUFMAX                 2048
+#if (KGDB_GDB_REG_SIZE == 32)
+#define NUMREGBYTES            (90*sizeof(u32))
+#define NUMCRITREGBYTES                (12*sizeof(u32))
+#else
+#define NUMREGBYTES            (90*sizeof(u64))
+#define NUMCRITREGBYTES                (12*sizeof(u64))
+#endif
+#define BREAK_INSTR_SIZE       4
+#define CACHE_FLUSH_IS_SAFE    0
+
+extern void arch_kgdb_breakpoint(void);
+extern int kgdb_early_setup;
+extern void *saved_vectors[32];
+extern void handle_exception(struct pt_regs *regs);
+extern void breakinst(void);
+
+#endif                         /* __KERNEL__ */
+
+#endif /* __ASM_KGDB_H_ */