]>
Commit | Line | Data |
---|---|---|
88547001 JW |
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> | |
631330f5 | 29 | #include <linux/smp.h> |
88547001 JW |
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> | |
6ebda44f | 35 | #include <asm/uaccess.h> |
88547001 JW |
36 | |
37 | static struct hard_trap_info { | |
38 | unsigned char tt; /* Trap type code for MIPS R3xxx and R4xxx */ | |
39 | unsigned char signo; /* Signal that we map this trap into */ | |
40 | } hard_trap_info[] = { | |
41 | { 6, SIGBUS }, /* instruction bus error */ | |
42 | { 7, SIGBUS }, /* data bus error */ | |
43 | { 9, SIGTRAP }, /* break */ | |
70342287 | 44 | /* { 11, SIGILL }, */ /* CPU unusable */ |
88547001 JW |
45 | { 12, SIGFPE }, /* overflow */ |
46 | { 13, SIGTRAP }, /* trap */ | |
47 | { 14, SIGSEGV }, /* virtual instruction cache coherency */ | |
48 | { 15, SIGFPE }, /* floating point exception */ | |
49 | { 23, SIGSEGV }, /* watch */ | |
50 | { 31, SIGSEGV }, /* virtual data cache coherency */ | |
51 | { 0, 0} /* Must be last */ | |
52 | }; | |
53 | ||
0896a9be JW |
54 | struct dbg_reg_def_t dbg_reg_def[DBG_MAX_REG_NUM] = |
55 | { | |
56 | { "zero", GDB_SIZEOF_REG, offsetof(struct pt_regs, regs[0]) }, | |
57 | { "at", GDB_SIZEOF_REG, offsetof(struct pt_regs, regs[1]) }, | |
58 | { "v0", GDB_SIZEOF_REG, offsetof(struct pt_regs, regs[2]) }, | |
59 | { "v1", GDB_SIZEOF_REG, offsetof(struct pt_regs, regs[3]) }, | |
60 | { "a0", GDB_SIZEOF_REG, offsetof(struct pt_regs, regs[4]) }, | |
61 | { "a1", GDB_SIZEOF_REG, offsetof(struct pt_regs, regs[5]) }, | |
62 | { "a2", GDB_SIZEOF_REG, offsetof(struct pt_regs, regs[6]) }, | |
63 | { "a3", GDB_SIZEOF_REG, offsetof(struct pt_regs, regs[7]) }, | |
64 | { "t0", GDB_SIZEOF_REG, offsetof(struct pt_regs, regs[8]) }, | |
65 | { "t1", GDB_SIZEOF_REG, offsetof(struct pt_regs, regs[9]) }, | |
66 | { "t2", GDB_SIZEOF_REG, offsetof(struct pt_regs, regs[10]) }, | |
67 | { "t3", GDB_SIZEOF_REG, offsetof(struct pt_regs, regs[11]) }, | |
68 | { "t4", GDB_SIZEOF_REG, offsetof(struct pt_regs, regs[12]) }, | |
69 | { "t5", GDB_SIZEOF_REG, offsetof(struct pt_regs, regs[13]) }, | |
70 | { "t6", GDB_SIZEOF_REG, offsetof(struct pt_regs, regs[14]) }, | |
71 | { "t7", GDB_SIZEOF_REG, offsetof(struct pt_regs, regs[15]) }, | |
72 | { "s0", GDB_SIZEOF_REG, offsetof(struct pt_regs, regs[16]) }, | |
73 | { "s1", GDB_SIZEOF_REG, offsetof(struct pt_regs, regs[17]) }, | |
74 | { "s2", GDB_SIZEOF_REG, offsetof(struct pt_regs, regs[18]) }, | |
75 | { "s3", GDB_SIZEOF_REG, offsetof(struct pt_regs, regs[19]) }, | |
76 | { "s4", GDB_SIZEOF_REG, offsetof(struct pt_regs, regs[20]) }, | |
77 | { "s5", GDB_SIZEOF_REG, offsetof(struct pt_regs, regs[21]) }, | |
78 | { "s6", GDB_SIZEOF_REG, offsetof(struct pt_regs, regs[22]) }, | |
79 | { "s7", GDB_SIZEOF_REG, offsetof(struct pt_regs, regs[23]) }, | |
80 | { "t8", GDB_SIZEOF_REG, offsetof(struct pt_regs, regs[24]) }, | |
81 | { "t9", GDB_SIZEOF_REG, offsetof(struct pt_regs, regs[25]) }, | |
82 | { "k0", GDB_SIZEOF_REG, offsetof(struct pt_regs, regs[26]) }, | |
83 | { "k1", GDB_SIZEOF_REG, offsetof(struct pt_regs, regs[27]) }, | |
84 | { "gp", GDB_SIZEOF_REG, offsetof(struct pt_regs, regs[28]) }, | |
85 | { "sp", GDB_SIZEOF_REG, offsetof(struct pt_regs, regs[29]) }, | |
86 | { "s8", GDB_SIZEOF_REG, offsetof(struct pt_regs, regs[30]) }, | |
87 | { "ra", GDB_SIZEOF_REG, offsetof(struct pt_regs, regs[31]) }, | |
88 | { "sr", GDB_SIZEOF_REG, offsetof(struct pt_regs, cp0_status) }, | |
89 | { "lo", GDB_SIZEOF_REG, offsetof(struct pt_regs, lo) }, | |
90 | { "hi", GDB_SIZEOF_REG, offsetof(struct pt_regs, hi) }, | |
91 | { "bad", GDB_SIZEOF_REG, offsetof(struct pt_regs, cp0_badvaddr) }, | |
92 | { "cause", GDB_SIZEOF_REG, offsetof(struct pt_regs, cp0_cause) }, | |
93 | { "pc", GDB_SIZEOF_REG, offsetof(struct pt_regs, cp0_epc) }, | |
94 | { "f0", GDB_SIZEOF_REG, 0 }, | |
95 | { "f1", GDB_SIZEOF_REG, 1 }, | |
96 | { "f2", GDB_SIZEOF_REG, 2 }, | |
97 | { "f3", GDB_SIZEOF_REG, 3 }, | |
98 | { "f4", GDB_SIZEOF_REG, 4 }, | |
99 | { "f5", GDB_SIZEOF_REG, 5 }, | |
100 | { "f6", GDB_SIZEOF_REG, 6 }, | |
101 | { "f7", GDB_SIZEOF_REG, 7 }, | |
102 | { "f8", GDB_SIZEOF_REG, 8 }, | |
103 | { "f9", GDB_SIZEOF_REG, 9 }, | |
104 | { "f10", GDB_SIZEOF_REG, 10 }, | |
105 | { "f11", GDB_SIZEOF_REG, 11 }, | |
106 | { "f12", GDB_SIZEOF_REG, 12 }, | |
107 | { "f13", GDB_SIZEOF_REG, 13 }, | |
108 | { "f14", GDB_SIZEOF_REG, 14 }, | |
109 | { "f15", GDB_SIZEOF_REG, 15 }, | |
110 | { "f16", GDB_SIZEOF_REG, 16 }, | |
111 | { "f17", GDB_SIZEOF_REG, 17 }, | |
112 | { "f18", GDB_SIZEOF_REG, 18 }, | |
113 | { "f19", GDB_SIZEOF_REG, 19 }, | |
114 | { "f20", GDB_SIZEOF_REG, 20 }, | |
115 | { "f21", GDB_SIZEOF_REG, 21 }, | |
116 | { "f22", GDB_SIZEOF_REG, 22 }, | |
117 | { "f23", GDB_SIZEOF_REG, 23 }, | |
118 | { "f24", GDB_SIZEOF_REG, 24 }, | |
119 | { "f25", GDB_SIZEOF_REG, 25 }, | |
120 | { "f26", GDB_SIZEOF_REG, 26 }, | |
121 | { "f27", GDB_SIZEOF_REG, 27 }, | |
122 | { "f28", GDB_SIZEOF_REG, 28 }, | |
123 | { "f29", GDB_SIZEOF_REG, 29 }, | |
124 | { "f30", GDB_SIZEOF_REG, 30 }, | |
125 | { "f31", GDB_SIZEOF_REG, 31 }, | |
126 | { "fsr", GDB_SIZEOF_REG, 0 }, | |
127 | { "fir", GDB_SIZEOF_REG, 0 }, | |
128 | }; | |
129 | ||
130 | int dbg_set_reg(int regno, void *mem, struct pt_regs *regs) | |
131 | { | |
132 | int fp_reg; | |
133 | ||
134 | if (regno < 0 || regno >= DBG_MAX_REG_NUM) | |
135 | return -EINVAL; | |
136 | ||
137 | if (dbg_reg_def[regno].offset != -1 && regno < 38) { | |
138 | memcpy((void *)regs + dbg_reg_def[regno].offset, mem, | |
139 | dbg_reg_def[regno].size); | |
140 | } else if (current && dbg_reg_def[regno].offset != -1 && regno < 72) { | |
141 | /* FP registers 38 -> 69 */ | |
142 | if (!(regs->cp0_status & ST0_CU1)) | |
143 | return 0; | |
144 | if (regno == 70) { | |
145 | /* Process the fcr31/fsr (register 70) */ | |
146 | memcpy((void *)¤t->thread.fpu.fcr31, mem, | |
147 | dbg_reg_def[regno].size); | |
148 | goto out_save; | |
149 | } else if (regno == 71) { | |
150 | /* Ignore the fir (register 71) */ | |
151 | goto out_save; | |
152 | } | |
153 | fp_reg = dbg_reg_def[regno].offset; | |
154 | memcpy((void *)¤t->thread.fpu.fpr[fp_reg], mem, | |
155 | dbg_reg_def[regno].size); | |
156 | out_save: | |
157 | restore_fp(current); | |
158 | } | |
159 | ||
160 | return 0; | |
161 | } | |
162 | ||
163 | char *dbg_get_reg(int regno, void *mem, struct pt_regs *regs) | |
164 | { | |
165 | int fp_reg; | |
166 | ||
167 | if (regno >= DBG_MAX_REG_NUM || regno < 0) | |
168 | return NULL; | |
169 | ||
170 | if (dbg_reg_def[regno].offset != -1 && regno < 38) { | |
171 | /* First 38 registers */ | |
172 | memcpy(mem, (void *)regs + dbg_reg_def[regno].offset, | |
173 | dbg_reg_def[regno].size); | |
174 | } else if (current && dbg_reg_def[regno].offset != -1 && regno < 72) { | |
175 | /* FP registers 38 -> 69 */ | |
176 | if (!(regs->cp0_status & ST0_CU1)) | |
177 | goto out; | |
178 | save_fp(current); | |
179 | if (regno == 70) { | |
180 | /* Process the fcr31/fsr (register 70) */ | |
181 | memcpy(mem, (void *)¤t->thread.fpu.fcr31, | |
182 | dbg_reg_def[regno].size); | |
183 | goto out; | |
184 | } else if (regno == 71) { | |
185 | /* Ignore the fir (register 71) */ | |
186 | memset(mem, 0, dbg_reg_def[regno].size); | |
187 | goto out; | |
188 | } | |
189 | fp_reg = dbg_reg_def[regno].offset; | |
190 | memcpy(mem, (void *)¤t->thread.fpu.fpr[fp_reg], | |
191 | dbg_reg_def[regno].size); | |
192 | } | |
193 | ||
194 | out: | |
195 | return dbg_reg_def[regno].name; | |
196 | ||
197 | } | |
198 | ||
88547001 JW |
199 | void arch_kgdb_breakpoint(void) |
200 | { | |
201 | __asm__ __volatile__( | |
202 | ".globl breakinst\n\t" | |
203 | ".set\tnoreorder\n\t" | |
204 | "nop\n" | |
205 | "breakinst:\tbreak\n\t" | |
206 | "nop\n\t" | |
207 | ".set\treorder"); | |
208 | } | |
209 | ||
210 | static void kgdb_call_nmi_hook(void *ignored) | |
211 | { | |
6ebda44f LY |
212 | mm_segment_t old_fs; |
213 | ||
214 | old_fs = get_fs(); | |
215 | set_fs(get_ds()); | |
216 | ||
9391d6bb | 217 | kgdb_nmicallback(raw_smp_processor_id(), NULL); |
6ebda44f LY |
218 | |
219 | set_fs(old_fs); | |
88547001 JW |
220 | } |
221 | ||
222 | void kgdb_roundup_cpus(unsigned long flags) | |
223 | { | |
224 | local_irq_enable(); | |
e522b7cc | 225 | smp_call_function(kgdb_call_nmi_hook, NULL, 0); |
88547001 JW |
226 | local_irq_disable(); |
227 | } | |
228 | ||
229 | static int compute_signal(int tt) | |
230 | { | |
231 | struct hard_trap_info *ht; | |
232 | ||
233 | for (ht = hard_trap_info; ht->tt && ht->signo; ht++) | |
234 | if (ht->tt == tt) | |
235 | return ht->signo; | |
236 | ||
237 | return SIGHUP; /* default for things we don't know about */ | |
238 | } | |
239 | ||
88547001 JW |
240 | /* |
241 | * Similar to regs_to_gdb_regs() except that process is sleeping and so | |
242 | * we may not be able to get all the info. | |
243 | */ | |
244 | void sleeping_thread_to_gdb_regs(unsigned long *gdb_regs, struct task_struct *p) | |
245 | { | |
246 | int reg; | |
247 | struct thread_info *ti = task_thread_info(p); | |
248 | unsigned long ksp = (unsigned long)ti + THREAD_SIZE - 32; | |
249 | struct pt_regs *regs = (struct pt_regs *)ksp - 1; | |
250 | #if (KGDB_GDB_REG_SIZE == 32) | |
251 | u32 *ptr = (u32 *)gdb_regs; | |
252 | #else | |
253 | u64 *ptr = (u64 *)gdb_regs; | |
254 | #endif | |
255 | ||
256 | for (reg = 0; reg < 16; reg++) | |
257 | *(ptr++) = regs->regs[reg]; | |
258 | ||
259 | /* S0 - S7 */ | |
260 | for (reg = 16; reg < 24; reg++) | |
261 | *(ptr++) = regs->regs[reg]; | |
262 | ||
263 | for (reg = 24; reg < 28; reg++) | |
264 | *(ptr++) = 0; | |
265 | ||
266 | /* GP, SP, FP, RA */ | |
267 | for (reg = 28; reg < 32; reg++) | |
268 | *(ptr++) = regs->regs[reg]; | |
269 | ||
270 | *(ptr++) = regs->cp0_status; | |
271 | *(ptr++) = regs->lo; | |
272 | *(ptr++) = regs->hi; | |
273 | *(ptr++) = regs->cp0_badvaddr; | |
274 | *(ptr++) = regs->cp0_cause; | |
275 | *(ptr++) = regs->cp0_epc; | |
276 | } | |
277 | ||
dcc78711 JW |
278 | void kgdb_arch_set_pc(struct pt_regs *regs, unsigned long pc) |
279 | { | |
280 | regs->cp0_epc = pc; | |
281 | } | |
282 | ||
88547001 JW |
283 | /* |
284 | * Calls linux_debug_hook before the kernel dies. If KGDB is enabled, | |
285 | * then try to fall into the debugger | |
286 | */ | |
287 | static int kgdb_mips_notify(struct notifier_block *self, unsigned long cmd, | |
288 | void *ptr) | |
289 | { | |
290 | struct die_args *args = (struct die_args *)ptr; | |
291 | struct pt_regs *regs = args->regs; | |
292 | int trap = (regs->cp0_cause & 0x7c) >> 2; | |
6ebda44f | 293 | mm_segment_t old_fs; |
88547001 | 294 | |
f0a996ee JW |
295 | #ifdef CONFIG_KPROBES |
296 | /* | |
297 | * Return immediately if the kprobes fault notifier has set | |
298 | * DIE_PAGE_FAULT. | |
299 | */ | |
300 | if (cmd == DIE_PAGE_FAULT) | |
301 | return NOTIFY_DONE; | |
302 | #endif /* CONFIG_KPROBES */ | |
303 | ||
eefc3f32 | 304 | /* Userspace events, ignore. */ |
88547001 JW |
305 | if (user_mode(regs)) |
306 | return NOTIFY_DONE; | |
307 | ||
6ebda44f LY |
308 | /* Kernel mode. Set correct address limit */ |
309 | old_fs = get_fs(); | |
310 | set_fs(get_ds()); | |
311 | ||
88547001 JW |
312 | if (atomic_read(&kgdb_active) != -1) |
313 | kgdb_nmicallback(smp_processor_id(), regs); | |
314 | ||
6ebda44f LY |
315 | if (kgdb_handle_exception(trap, compute_signal(trap), cmd, regs)) { |
316 | set_fs(old_fs); | |
88547001 | 317 | return NOTIFY_DONE; |
6ebda44f | 318 | } |
88547001 JW |
319 | |
320 | if (atomic_read(&kgdb_setting_breakpoint)) | |
321 | if ((trap == 9) && (regs->cp0_epc == (unsigned long)breakinst)) | |
322 | regs->cp0_epc += 4; | |
323 | ||
324 | /* In SMP mode, __flush_cache_all does IPI */ | |
325 | local_irq_enable(); | |
326 | __flush_cache_all(); | |
327 | ||
6ebda44f | 328 | set_fs(old_fs); |
88547001 JW |
329 | return NOTIFY_STOP; |
330 | } | |
331 | ||
5dd11d5d JW |
332 | #ifdef CONFIG_KGDB_LOW_LEVEL_TRAP |
333 | int kgdb_ll_trap(int cmd, const char *str, | |
334 | struct pt_regs *regs, long err, int trap, int sig) | |
335 | { | |
336 | struct die_args args = { | |
337 | .regs = regs, | |
338 | .str = str, | |
339 | .err = err, | |
70342287 | 340 | .trapnr = trap, |
5dd11d5d JW |
341 | .signr = sig, |
342 | ||
343 | }; | |
344 | ||
345 | if (!kgdb_io_module_registered) | |
346 | return NOTIFY_DONE; | |
347 | ||
348 | return kgdb_mips_notify(NULL, cmd, &args); | |
349 | } | |
350 | #endif /* CONFIG_KGDB_LOW_LEVEL_TRAP */ | |
351 | ||
88547001 JW |
352 | static struct notifier_block kgdb_notifier = { |
353 | .notifier_call = kgdb_mips_notify, | |
354 | }; | |
355 | ||
356 | /* | |
7aeb48b7 | 357 | * Handle the 'c' command |
88547001 JW |
358 | */ |
359 | int kgdb_arch_handle_exception(int vector, int signo, int err_code, | |
360 | char *remcom_in_buffer, char *remcom_out_buffer, | |
361 | struct pt_regs *regs) | |
362 | { | |
363 | char *ptr; | |
364 | unsigned long address; | |
88547001 JW |
365 | |
366 | switch (remcom_in_buffer[0]) { | |
88547001 JW |
367 | case 'c': |
368 | /* handle the optional parameter */ | |
369 | ptr = &remcom_in_buffer[1]; | |
370 | if (kgdb_hex2long(&ptr, &address)) | |
371 | regs->cp0_epc = address; | |
372 | ||
88547001 JW |
373 | return 0; |
374 | } | |
375 | ||
376 | return -1; | |
377 | } | |
378 | ||
379 | struct kgdb_arch arch_kgdb_ops; | |
380 | ||
381 | /* | |
382 | * We use kgdb_early_setup so that functions we need to call now don't | |
383 | * cause trouble when called again later. | |
384 | */ | |
385 | int kgdb_arch_init(void) | |
386 | { | |
387 | union mips_instruction insn = { | |
388 | .r_format = { | |
389 | .opcode = spec_op, | |
70342287 | 390 | .func = break_op, |
88547001 JW |
391 | } |
392 | }; | |
393 | memcpy(arch_kgdb_ops.gdb_bpt_instr, insn.byte, BREAK_INSTR_SIZE); | |
394 | ||
395 | register_die_notifier(&kgdb_notifier); | |
396 | ||
397 | return 0; | |
398 | } | |
399 | ||
400 | /* | |
401 | * kgdb_arch_exit - Perform any architecture specific uninitalization. | |
402 | * | |
403 | * This function will handle the uninitalization of any architecture | |
404 | * specific callbacks, for dynamic registration and unregistration. | |
405 | */ | |
406 | void kgdb_arch_exit(void) | |
407 | { | |
408 | unregister_die_notifier(&kgdb_notifier); | |
409 | } |