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 void kgdb_arch_set_pc(struct pt_regs *regs, unsigned long pc)
 184 {
 185         regs->cp0_epc = pc;
 186 }
 187
 188 /*
 189  * Calls linux_debug_hook before the kernel dies. If KGDB is enabled,
 190  * then try to fall into the debugger
 191  */
 192 static int kgdb_mips_notify(struct notifier_block *self, unsigned long cmd,
 193                             void *ptr)
 194 {
 195         struct die_args *args = (struct die_args *)ptr;
 196         struct pt_regs *regs = args->regs;
 197         int trap = (regs->cp0_cause & 0x7c) >> 2;
 198
 199         /* Userpace events, ignore. */
 200         if (user_mode(regs))
 201                 return NOTIFY_DONE;
 202
 203         if (atomic_read(&kgdb_active) != -1)
 204                 kgdb_nmicallback(smp_processor_id(), regs);
 205
 206         if (kgdb_handle_exception(trap, compute_signal(trap), cmd, regs))
 207                 return NOTIFY_DONE;
 208
 209         if (atomic_read(&kgdb_setting_breakpoint))
 210                 if ((trap == 9) && (regs->cp0_epc == (unsigned long)breakinst))
 211                         regs->cp0_epc += 4;
 212
 213         /* In SMP mode, __flush_cache_all does IPI */
 214         local_irq_enable();
 215         __flush_cache_all();
 216
 217         return NOTIFY_STOP;
 218 }
 219
 220 #ifdef CONFIG_KGDB_LOW_LEVEL_TRAP
 221 int kgdb_ll_trap(int cmd, const char *str,
 222                  struct pt_regs *regs, long err, int trap, int sig)
 223 {
 224         struct die_args args = {
 225                 .regs   = regs,
 226                 .str    = str,
 227                 .err    = err,
 228                 .trapnr = trap,
 229                 .signr  = sig,
 230
 231         };
 232
 233         if (!kgdb_io_module_registered)
 234                 return NOTIFY_DONE;
 235
 236         return kgdb_mips_notify(NULL, cmd, &args);
 237 }
 238 #endif /* CONFIG_KGDB_LOW_LEVEL_TRAP */
 239
 240 static struct notifier_block kgdb_notifier = {
 241         .notifier_call = kgdb_mips_notify,
 242 };
 243
 244 /*
 245  * Handle the 's' and 'c' commands
 246  */
 247 int kgdb_arch_handle_exception(int vector, int signo, int err_code,
 248                                char *remcom_in_buffer, char *remcom_out_buffer,
 249                                struct pt_regs *regs)
 250 {
 251         char *ptr;
 252         unsigned long address;
 253         int cpu = smp_processor_id();
 254
 255         switch (remcom_in_buffer[0]) {
 256         case 's':
 257         case 'c':
 258                 /* handle the optional parameter */
 259                 ptr = &remcom_in_buffer[1];
 260                 if (kgdb_hex2long(&ptr, &address))
 261                         regs->cp0_epc = address;
 262
 263                 atomic_set(&kgdb_cpu_doing_single_step, -1);
 264                 if (remcom_in_buffer[0] == 's')
 265                         atomic_set(&kgdb_cpu_doing_single_step, cpu);
 266
 267                 return 0;
 268         }
 269
 270         return -1;
 271 }
 272
 273 struct kgdb_arch arch_kgdb_ops;
 274
 275 /*
 276  * We use kgdb_early_setup so that functions we need to call now don't
 277  * cause trouble when called again later.
 278  */
 279 int kgdb_arch_init(void)
 280 {
 281         union mips_instruction insn = {
 282                 .r_format = {
 283                         .opcode = spec_op,
 284                         .func   = break_op,
 285                 }
 286         };
 287         memcpy(arch_kgdb_ops.gdb_bpt_instr, insn.byte, BREAK_INSTR_SIZE);
 288
 289         register_die_notifier(&kgdb_notifier);
 290
 291         return 0;
 292 }
 293
 294 /*
 295  *      kgdb_arch_exit - Perform any architecture specific uninitalization.
 296  *
 297  *      This function will handle the uninitalization of any architecture
 298  *      specific callbacks, for dynamic registration and unregistration.
 299  */
 300 void kgdb_arch_exit(void)
 301 {
 302         unregister_die_notifier(&kgdb_notifier);
 303 }