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