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> | |
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 | { | |
9391d6bb | 66 | kgdb_nmicallback(raw_smp_processor_id(), NULL); |
88547001 JW |
67 | } |
68 | ||
69 | void kgdb_roundup_cpus(unsigned long flags) | |
70 | { | |
71 | local_irq_enable(); | |
e522b7cc | 72 | smp_call_function(kgdb_call_nmi_hook, NULL, 0); |
88547001 JW |
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 | ||
dcc78711 JW |
183 | void kgdb_arch_set_pc(struct pt_regs *regs, unsigned long pc) |
184 | { | |
185 | regs->cp0_epc = pc; | |
186 | } | |
187 | ||
88547001 JW |
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 | ||
88547001 JW |
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), 0, 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 | static struct notifier_block kgdb_notifier = { | |
221 | .notifier_call = kgdb_mips_notify, | |
222 | }; | |
223 | ||
224 | /* | |
225 | * Handle the 's' and 'c' commands | |
226 | */ | |
227 | int kgdb_arch_handle_exception(int vector, int signo, int err_code, | |
228 | char *remcom_in_buffer, char *remcom_out_buffer, | |
229 | struct pt_regs *regs) | |
230 | { | |
231 | char *ptr; | |
232 | unsigned long address; | |
233 | int cpu = smp_processor_id(); | |
234 | ||
235 | switch (remcom_in_buffer[0]) { | |
236 | case 's': | |
237 | case 'c': | |
238 | /* handle the optional parameter */ | |
239 | ptr = &remcom_in_buffer[1]; | |
240 | if (kgdb_hex2long(&ptr, &address)) | |
241 | regs->cp0_epc = address; | |
242 | ||
243 | atomic_set(&kgdb_cpu_doing_single_step, -1); | |
244 | if (remcom_in_buffer[0] == 's') | |
d7161a65 | 245 | atomic_set(&kgdb_cpu_doing_single_step, cpu); |
88547001 JW |
246 | |
247 | return 0; | |
248 | } | |
249 | ||
250 | return -1; | |
251 | } | |
252 | ||
253 | struct kgdb_arch arch_kgdb_ops; | |
254 | ||
255 | /* | |
256 | * We use kgdb_early_setup so that functions we need to call now don't | |
257 | * cause trouble when called again later. | |
258 | */ | |
259 | int kgdb_arch_init(void) | |
260 | { | |
261 | union mips_instruction insn = { | |
262 | .r_format = { | |
263 | .opcode = spec_op, | |
264 | .func = break_op, | |
265 | } | |
266 | }; | |
267 | memcpy(arch_kgdb_ops.gdb_bpt_instr, insn.byte, BREAK_INSTR_SIZE); | |
268 | ||
269 | register_die_notifier(&kgdb_notifier); | |
270 | ||
271 | return 0; | |
272 | } | |
273 | ||
274 | /* | |
275 | * kgdb_arch_exit - Perform any architecture specific uninitalization. | |
276 | * | |
277 | * This function will handle the uninitalization of any architecture | |
278 | * specific callbacks, for dynamic registration and unregistration. | |
279 | */ | |
280 | void kgdb_arch_exit(void) | |
281 | { | |
282 | unregister_die_notifier(&kgdb_notifier); | |
283 | } |