Linux 2.6.31-rc6
[linux-2.6] / 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 }