arch/mips/kernel/kgdb.c

   1 /*
   2  *  Originally written by Glenn Engel, Lake Stevens Instrument Division
   3  *
   4  *  Contributed by HP Systems
   5  *
   6  *  Modified for Linux/MIPS (and MIPS in general) by Andreas Busse
   7  *  Send complaints, suggestions etc. to <andy@waldorf-gmbh.de>
   8  *
   9  *  Copyright (C) 1995 Andreas Busse
  10  *
  11  *  Copyright (C) 2003 MontaVista Software Inc.
  12  *  Author: Jun Sun, jsun@mvista.com or jsun@junsun.net
  13  *
  14  *  Copyright (C) 2004-2005 MontaVista Software Inc.
  15  *  Author: Manish Lachwani, mlachwani@mvista.com or manish@koffee-break.com
  16  *
  17  *  Copyright (C) 2007-2008 Wind River Systems, Inc.
  18  *  Author/Maintainer: Jason Wessel, jason.wessel@windriver.com
  19  *
  20  *  This file is licensed under the terms of the GNU General Public License
  21  *  version 2. This program is licensed "as is" without any warranty of any
  22  *  kind, whether express or implied.
  23  */
  24
  25 #include <linux/ptrace.h>               /* for linux pt_regs struct */
  26 #include <linux/kgdb.h>
  27 #include <linux/kdebug.h>
  28 #include <linux/sched.h>
  29 #include <linux/smp.h>
  30 #include <asm/inst.h>
  31 #include <asm/fpu.h>
  32 #include <asm/cacheflush.h>
  33 #include <asm/processor.h>
  34 #include <asm/sigcontext.h>
  35
  36 static struct hard_trap_info {
  37         unsigned char tt;       /* Trap type code for MIPS R3xxx and R4xxx */
  38         unsigned char signo;    /* Signal that we map this trap into */
  39 } hard_trap_info[] = {
  40         { 6, SIGBUS },          /* instruction bus error */
  41         { 7, SIGBUS },          /* data bus error */
  42         { 9, SIGTRAP },         /* break */
  43 /*      { 11, SIGILL }, */      /* CPU unusable */
  44         { 12, SIGFPE },         /* overflow */
  45         { 13, SIGTRAP },        /* trap */
  46         { 14, SIGSEGV },        /* virtual instruction cache coherency */
  47         { 15, SIGFPE },         /* floating point exception */
  48         { 23, SIGSEGV },        /* watch */
  49         { 31, SIGSEGV },        /* virtual data cache coherency */
  50         { 0, 0}                 /* Must be last */
  51 };
  52
  53 void arch_kgdb_breakpoint(void)
  54 {
  55         __asm__ __volatile__(
  56                 ".globl breakinst\n\t"
  57                 ".set\tnoreorder\n\t"
  58                 "nop\n"
  59                 "breakinst:\tbreak\n\t"
  60                 "nop\n\t"
  61                 ".set\treorder");
  62 }
  63
  64 static void kgdb_call_nmi_hook(void *ignored)
  65 {
  66         kgdb_nmicallback(raw_smp_processor_id(), NULL);
  67 }
  68
  69 void kgdb_roundup_cpus(unsigned long flags)
  70 {
  71         local_irq_enable();
  72         smp_call_function(kgdb_call_nmi_hook, NULL, 0);
  73         local_irq_disable();
  74 }
  75
  76 static int compute_signal(int tt)
  77 {
  78         struct hard_trap_info *ht;
  79
  80         for (ht = hard_trap_info; ht->tt && ht->signo; ht++)
  81                 if (ht->tt == tt)
  82                         return ht->signo;
  83
  84         return SIGHUP;          /* default for things we don't know about */
  85 }
  86
  87 void pt_regs_to_gdb_regs(unsigned long *gdb_regs, struct pt_regs *regs)
  88 {
  89         int reg;
  90
  91 #if (KGDB_GDB_REG_SIZE == 32)
  92         u32 *ptr = (u32 *)gdb_regs;
  93 #else
  94         u64 *ptr = (u64 *)gdb_regs;
  95 #endif
  96
  97         for (reg = 0; reg < 32; reg++)
  98                 *(ptr++) = regs->regs[reg];
  99
 100         *(ptr++) = regs->cp0_status;
 101         *(ptr++) = regs->lo;
 102         *(ptr++) = regs->hi;
 103         *(ptr++) = regs->cp0_badvaddr;
 104         *(ptr++) = regs->cp0_cause;
 105         *(ptr++) = regs->cp0_epc;
 106
 107         /* FP REGS */
 108         if (!(current && (regs->cp0_status & ST0_CU1)))
 109                 return;
 110
 111         save_fp(current);
 112         for (reg = 0; reg < 32; reg++)
 113                 *(ptr++) = current->thread.fpu.fpr[reg];
 114 }
 115
 116 void gdb_regs_to_pt_regs(unsigned long *gdb_regs, struct pt_regs *regs)
 117 {
 118         int reg;
 119
 120 #if (KGDB_GDB_REG_SIZE == 32)
 121         const u32 *ptr = (u32 *)gdb_regs;
 122 #else
 123         const u64 *ptr = (u64 *)gdb_regs;
 124 #endif
 125
 126         for (reg = 0; reg < 32; reg++)
 127                 regs->regs[reg] = *(ptr++);
 128
 129         regs->cp0_status = *(ptr++);
 130         regs->lo = *(ptr++);
 131         regs->hi = *(ptr++);
 132         regs->cp0_badvaddr = *(ptr++);
 133         regs->cp0_cause = *(ptr++);
 134         regs->cp0_epc = *(ptr++);
 135
 136         /* FP REGS from current */
 137         if (!(current && (regs->cp0_status & ST0_CU1)))
 138                 return;
 139
 140         for (reg = 0; reg < 32; reg++)
 141                 current->thread.fpu.fpr[reg] = *(ptr++);
 142         restore_fp(current);
 143 }
 144
 145 /*
 146  * Similar to regs_to_gdb_regs() except that process is sleeping and so
 147  * we may not be able to get all the info.
 148  */
 149 void sleeping_thread_to_gdb_regs(unsigned long *gdb_regs, struct task_struct *p)
 150 {
 151         int reg;
 152         struct thread_info *ti = task_thread_info(p);
 153         unsigned long ksp = (unsigned long)ti + THREAD_SIZE - 32;
 154         struct pt_regs *regs = (struct pt_regs *)ksp - 1;
 155 #if (KGDB_GDB_REG_SIZE == 32)
 156         u32 *ptr = (u32 *)gdb_regs;
 157 #else
 158         u64 *ptr = (u64 *)gdb_regs;
 159 #endif
 160
 161         for (reg = 0; reg < 16; reg++)
 162                 *(ptr++) = regs->regs[reg];
 163
 164         /* S0 - S7 */
 165         for (reg = 16; reg < 24; reg++)
 166                 *(ptr++) = regs->regs[reg];
 167
 168         for (reg = 24; reg < 28; reg++)
 169                 *(ptr++) = 0;
 170
 171         /* GP, SP, FP, RA */
 172         for (reg = 28; reg < 32; reg++)
 173                 *(ptr++) = regs->regs[reg];
 174
 175         *(ptr++) = regs->cp0_status;
 176         *(ptr++) = regs->lo;
 177         *(ptr++) = regs->hi;
 178         *(ptr++) = regs->cp0_badvaddr;
 179         *(ptr++) = regs->cp0_cause;
 180         *(ptr++) = regs->cp0_epc;
 181 }
 182
 183 /*
 184  * Calls linux_debug_hook before the kernel dies. If KGDB is enabled,
 185  * then try to fall into the debugger
 186  */
 187 static int kgdb_mips_notify(struct notifier_block *self, unsigned long cmd,
 188                             void *ptr)
 189 {
 190         struct die_args *args = (struct die_args *)ptr;
 191         struct pt_regs *regs = args->regs;
 192         int trap = (regs->cp0_cause & 0x7c) >> 2;
 193
 194         /* Userpace events, ignore. */
 195         if (user_mode(regs))
 196                 return NOTIFY_DONE;
 197
 198         if (atomic_read(&kgdb_active) != -1)
 199                 kgdb_nmicallback(smp_processor_id(), regs);
 200
 201         if (kgdb_handle_exception(trap, compute_signal(trap), 0, regs))
 202                 return NOTIFY_DONE;
 203
 204         if (atomic_read(&kgdb_setting_breakpoint))
 205                 if ((trap == 9) && (regs->cp0_epc == (unsigned long)breakinst))
 206                         regs->cp0_epc += 4;
 207
 208         /* In SMP mode, __flush_cache_all does IPI */
 209         local_irq_enable();
 210         __flush_cache_all();
 211
 212         return NOTIFY_STOP;
 213 }
 214
 215 static struct notifier_block kgdb_notifier = {
 216         .notifier_call = kgdb_mips_notify,
 217 };
 218
 219 /*
 220  * Handle the 's' and 'c' commands
 221  */
 222 int kgdb_arch_handle_exception(int vector, int signo, int err_code,
 223                                char *remcom_in_buffer, char *remcom_out_buffer,
 224                                struct pt_regs *regs)
 225 {
 226         char *ptr;
 227         unsigned long address;
 228         int cpu = smp_processor_id();
 229
 230         switch (remcom_in_buffer[0]) {
 231         case 's':
 232         case 'c':
 233                 /* handle the optional parameter */
 234                 ptr = &remcom_in_buffer[1];
 235                 if (kgdb_hex2long(&ptr, &address))
 236                         regs->cp0_epc = address;
 237
 238                 atomic_set(&kgdb_cpu_doing_single_step, -1);
 239                 if (remcom_in_buffer[0] == 's')
 240                         atomic_set(&kgdb_cpu_doing_single_step, cpu);
 241
 242                 return 0;
 243         }
 244
 245         return -1;
 246 }
 247
 248 struct kgdb_arch arch_kgdb_ops;
 249
 250 /*
 251  * We use kgdb_early_setup so that functions we need to call now don't
 252  * cause trouble when called again later.
 253  */
 254 int kgdb_arch_init(void)
 255 {
 256         union mips_instruction insn = {
 257                 .r_format = {
 258                         .opcode = spec_op,
 259                         .func   = break_op,
 260                 }
 261         };
 262         memcpy(arch_kgdb_ops.gdb_bpt_instr, insn.byte, BREAK_INSTR_SIZE);
 263
 264         register_die_notifier(&kgdb_notifier);
 265
 266         return 0;
 267 }
 268
 269 /*
 270  *      kgdb_arch_exit - Perform any architecture specific uninitalization.
 271  *
 272  *      This function will handle the uninitalization of any architecture
 273  *      specific callbacks, for dynamic registration and unregistration.
 274  */
 275 void kgdb_arch_exit(void)
 276 {
 277         unregister_die_notifier(&kgdb_notifier);
 278 }