diff options
author | Jason Wessel <jason.wessel@windriver.com> | 2010-04-02 12:48:03 -0400 |
---|---|---|
committer | Jason Wessel <jason.wessel@windriver.com> | 2010-05-20 22:04:19 -0400 |
commit | 53197fc49549240f6c6a963b2713a4cd9517964b (patch) | |
tree | 5a89c338ef8acd188e4aa1503370a4e928c33edd /kernel/debug/gdbstub.c | |
parent | c433820971ffa854feda6adc17f5f24201354f11 (diff) |
Separate the gdbstub from the debug core
Split the former kernel/kgdb.c into debug_core.c which contains the
kernel debugger exception logic and to the gdbstub.c which contains
the logic for allowing gdb to talk to the debug core.
This also created a private include file called debug_core.h which
contains all the definitions to glue the debug_core to any other
debugger connections.
CC: Ingo Molnar <mingo@elte.hu>
Signed-off-by: Jason Wessel <jason.wessel@windriver.com>
Diffstat (limited to 'kernel/debug/gdbstub.c')
-rw-r--r-- | kernel/debug/gdbstub.c | 934 |
1 files changed, 934 insertions, 0 deletions
diff --git a/kernel/debug/gdbstub.c b/kernel/debug/gdbstub.c new file mode 100644 index 000000000000..ccdf0929f12d --- /dev/null +++ b/kernel/debug/gdbstub.c | |||
@@ -0,0 +1,934 @@ | |||
1 | /* | ||
2 | * Kernel Debug Core | ||
3 | * | ||
4 | * Maintainer: Jason Wessel <jason.wessel@windriver.com> | ||
5 | * | ||
6 | * Copyright (C) 2000-2001 VERITAS Software Corporation. | ||
7 | * Copyright (C) 2002-2004 Timesys Corporation | ||
8 | * Copyright (C) 2003-2004 Amit S. Kale <amitkale@linsyssoft.com> | ||
9 | * Copyright (C) 2004 Pavel Machek <pavel@suse.cz> | ||
10 | * Copyright (C) 2004-2006 Tom Rini <trini@kernel.crashing.org> | ||
11 | * Copyright (C) 2004-2006 LinSysSoft Technologies Pvt. Ltd. | ||
12 | * Copyright (C) 2005-2009 Wind River Systems, Inc. | ||
13 | * Copyright (C) 2007 MontaVista Software, Inc. | ||
14 | * Copyright (C) 2008 Red Hat, Inc., Ingo Molnar <mingo@redhat.com> | ||
15 | * | ||
16 | * Contributors at various stages not listed above: | ||
17 | * Jason Wessel ( jason.wessel@windriver.com ) | ||
18 | * George Anzinger <george@mvista.com> | ||
19 | * Anurekh Saxena (anurekh.saxena@timesys.com) | ||
20 | * Lake Stevens Instrument Division (Glenn Engel) | ||
21 | * Jim Kingdon, Cygnus Support. | ||
22 | * | ||
23 | * Original KGDB stub: David Grothe <dave@gcom.com>, | ||
24 | * Tigran Aivazian <tigran@sco.com> | ||
25 | * | ||
26 | * This file is licensed under the terms of the GNU General Public License | ||
27 | * version 2. This program is licensed "as is" without any warranty of any | ||
28 | * kind, whether express or implied. | ||
29 | */ | ||
30 | |||
31 | #include <linux/kernel.h> | ||
32 | #include <linux/kgdb.h> | ||
33 | #include <linux/reboot.h> | ||
34 | #include <linux/uaccess.h> | ||
35 | #include <asm/cacheflush.h> | ||
36 | #include <asm/unaligned.h> | ||
37 | #include "debug_core.h" | ||
38 | |||
39 | #define KGDB_MAX_THREAD_QUERY 17 | ||
40 | |||
41 | /* Our I/O buffers. */ | ||
42 | static char remcom_in_buffer[BUFMAX]; | ||
43 | static char remcom_out_buffer[BUFMAX]; | ||
44 | |||
45 | /* Storage for the registers, in GDB format. */ | ||
46 | static unsigned long gdb_regs[(NUMREGBYTES + | ||
47 | sizeof(unsigned long) - 1) / | ||
48 | sizeof(unsigned long)]; | ||
49 | |||
50 | /* | ||
51 | * GDB remote protocol parser: | ||
52 | */ | ||
53 | |||
54 | static int hex(char ch) | ||
55 | { | ||
56 | if ((ch >= 'a') && (ch <= 'f')) | ||
57 | return ch - 'a' + 10; | ||
58 | if ((ch >= '0') && (ch <= '9')) | ||
59 | return ch - '0'; | ||
60 | if ((ch >= 'A') && (ch <= 'F')) | ||
61 | return ch - 'A' + 10; | ||
62 | return -1; | ||
63 | } | ||
64 | |||
65 | /* scan for the sequence $<data>#<checksum> */ | ||
66 | static void get_packet(char *buffer) | ||
67 | { | ||
68 | unsigned char checksum; | ||
69 | unsigned char xmitcsum; | ||
70 | int count; | ||
71 | char ch; | ||
72 | |||
73 | do { | ||
74 | /* | ||
75 | * Spin and wait around for the start character, ignore all | ||
76 | * other characters: | ||
77 | */ | ||
78 | while ((ch = (dbg_io_ops->read_char())) != '$') | ||
79 | /* nothing */; | ||
80 | |||
81 | kgdb_connected = 1; | ||
82 | checksum = 0; | ||
83 | xmitcsum = -1; | ||
84 | |||
85 | count = 0; | ||
86 | |||
87 | /* | ||
88 | * now, read until a # or end of buffer is found: | ||
89 | */ | ||
90 | while (count < (BUFMAX - 1)) { | ||
91 | ch = dbg_io_ops->read_char(); | ||
92 | if (ch == '#') | ||
93 | break; | ||
94 | checksum = checksum + ch; | ||
95 | buffer[count] = ch; | ||
96 | count = count + 1; | ||
97 | } | ||
98 | buffer[count] = 0; | ||
99 | |||
100 | if (ch == '#') { | ||
101 | xmitcsum = hex(dbg_io_ops->read_char()) << 4; | ||
102 | xmitcsum += hex(dbg_io_ops->read_char()); | ||
103 | |||
104 | if (checksum != xmitcsum) | ||
105 | /* failed checksum */ | ||
106 | dbg_io_ops->write_char('-'); | ||
107 | else | ||
108 | /* successful transfer */ | ||
109 | dbg_io_ops->write_char('+'); | ||
110 | if (dbg_io_ops->flush) | ||
111 | dbg_io_ops->flush(); | ||
112 | } | ||
113 | } while (checksum != xmitcsum); | ||
114 | } | ||
115 | |||
116 | /* | ||
117 | * Send the packet in buffer. | ||
118 | * Check for gdb connection if asked for. | ||
119 | */ | ||
120 | static void put_packet(char *buffer) | ||
121 | { | ||
122 | unsigned char checksum; | ||
123 | int count; | ||
124 | char ch; | ||
125 | |||
126 | /* | ||
127 | * $<packet info>#<checksum>. | ||
128 | */ | ||
129 | while (1) { | ||
130 | dbg_io_ops->write_char('$'); | ||
131 | checksum = 0; | ||
132 | count = 0; | ||
133 | |||
134 | while ((ch = buffer[count])) { | ||
135 | dbg_io_ops->write_char(ch); | ||
136 | checksum += ch; | ||
137 | count++; | ||
138 | } | ||
139 | |||
140 | dbg_io_ops->write_char('#'); | ||
141 | dbg_io_ops->write_char(hex_asc_hi(checksum)); | ||
142 | dbg_io_ops->write_char(hex_asc_lo(checksum)); | ||
143 | if (dbg_io_ops->flush) | ||
144 | dbg_io_ops->flush(); | ||
145 | |||
146 | /* Now see what we get in reply. */ | ||
147 | ch = dbg_io_ops->read_char(); | ||
148 | |||
149 | if (ch == 3) | ||
150 | ch = dbg_io_ops->read_char(); | ||
151 | |||
152 | /* If we get an ACK, we are done. */ | ||
153 | if (ch == '+') | ||
154 | return; | ||
155 | |||
156 | /* | ||
157 | * If we get the start of another packet, this means | ||
158 | * that GDB is attempting to reconnect. We will NAK | ||
159 | * the packet being sent, and stop trying to send this | ||
160 | * packet. | ||
161 | */ | ||
162 | if (ch == '$') { | ||
163 | dbg_io_ops->write_char('-'); | ||
164 | if (dbg_io_ops->flush) | ||
165 | dbg_io_ops->flush(); | ||
166 | return; | ||
167 | } | ||
168 | } | ||
169 | } | ||
170 | |||
171 | static char gdbmsgbuf[BUFMAX + 1]; | ||
172 | |||
173 | void gdbstub_msg_write(const char *s, int len) | ||
174 | { | ||
175 | char *bufptr; | ||
176 | int wcount; | ||
177 | int i; | ||
178 | |||
179 | /* 'O'utput */ | ||
180 | gdbmsgbuf[0] = 'O'; | ||
181 | |||
182 | /* Fill and send buffers... */ | ||
183 | while (len > 0) { | ||
184 | bufptr = gdbmsgbuf + 1; | ||
185 | |||
186 | /* Calculate how many this time */ | ||
187 | if ((len << 1) > (BUFMAX - 2)) | ||
188 | wcount = (BUFMAX - 2) >> 1; | ||
189 | else | ||
190 | wcount = len; | ||
191 | |||
192 | /* Pack in hex chars */ | ||
193 | for (i = 0; i < wcount; i++) | ||
194 | bufptr = pack_hex_byte(bufptr, s[i]); | ||
195 | *bufptr = '\0'; | ||
196 | |||
197 | /* Move up */ | ||
198 | s += wcount; | ||
199 | len -= wcount; | ||
200 | |||
201 | /* Write packet */ | ||
202 | put_packet(gdbmsgbuf); | ||
203 | } | ||
204 | } | ||
205 | |||
206 | /* | ||
207 | * Convert the memory pointed to by mem into hex, placing result in | ||
208 | * buf. Return a pointer to the last char put in buf (null). May | ||
209 | * return an error. | ||
210 | */ | ||
211 | int kgdb_mem2hex(char *mem, char *buf, int count) | ||
212 | { | ||
213 | char *tmp; | ||
214 | int err; | ||
215 | |||
216 | /* | ||
217 | * We use the upper half of buf as an intermediate buffer for the | ||
218 | * raw memory copy. Hex conversion will work against this one. | ||
219 | */ | ||
220 | tmp = buf + count; | ||
221 | |||
222 | err = probe_kernel_read(tmp, mem, count); | ||
223 | if (!err) { | ||
224 | while (count > 0) { | ||
225 | buf = pack_hex_byte(buf, *tmp); | ||
226 | tmp++; | ||
227 | count--; | ||
228 | } | ||
229 | |||
230 | *buf = 0; | ||
231 | } | ||
232 | |||
233 | return err; | ||
234 | } | ||
235 | |||
236 | /* | ||
237 | * Convert the hex array pointed to by buf into binary to be placed in | ||
238 | * mem. Return a pointer to the character AFTER the last byte | ||
239 | * written. May return an error. | ||
240 | */ | ||
241 | int kgdb_hex2mem(char *buf, char *mem, int count) | ||
242 | { | ||
243 | char *tmp_raw; | ||
244 | char *tmp_hex; | ||
245 | |||
246 | /* | ||
247 | * We use the upper half of buf as an intermediate buffer for the | ||
248 | * raw memory that is converted from hex. | ||
249 | */ | ||
250 | tmp_raw = buf + count * 2; | ||
251 | |||
252 | tmp_hex = tmp_raw - 1; | ||
253 | while (tmp_hex >= buf) { | ||
254 | tmp_raw--; | ||
255 | *tmp_raw = hex(*tmp_hex--); | ||
256 | *tmp_raw |= hex(*tmp_hex--) << 4; | ||
257 | } | ||
258 | |||
259 | return probe_kernel_write(mem, tmp_raw, count); | ||
260 | } | ||
261 | |||
262 | /* | ||
263 | * While we find nice hex chars, build a long_val. | ||
264 | * Return number of chars processed. | ||
265 | */ | ||
266 | int kgdb_hex2long(char **ptr, unsigned long *long_val) | ||
267 | { | ||
268 | int hex_val; | ||
269 | int num = 0; | ||
270 | int negate = 0; | ||
271 | |||
272 | *long_val = 0; | ||
273 | |||
274 | if (**ptr == '-') { | ||
275 | negate = 1; | ||
276 | (*ptr)++; | ||
277 | } | ||
278 | while (**ptr) { | ||
279 | hex_val = hex(**ptr); | ||
280 | if (hex_val < 0) | ||
281 | break; | ||
282 | |||
283 | *long_val = (*long_val << 4) | hex_val; | ||
284 | num++; | ||
285 | (*ptr)++; | ||
286 | } | ||
287 | |||
288 | if (negate) | ||
289 | *long_val = -*long_val; | ||
290 | |||
291 | return num; | ||
292 | } | ||
293 | |||
294 | /* | ||
295 | * Copy the binary array pointed to by buf into mem. Fix $, #, and | ||
296 | * 0x7d escaped with 0x7d. Return -EFAULT on failure or 0 on success. | ||
297 | * The input buf is overwitten with the result to write to mem. | ||
298 | */ | ||
299 | static int kgdb_ebin2mem(char *buf, char *mem, int count) | ||
300 | { | ||
301 | int size = 0; | ||
302 | char *c = buf; | ||
303 | |||
304 | while (count-- > 0) { | ||
305 | c[size] = *buf++; | ||
306 | if (c[size] == 0x7d) | ||
307 | c[size] = *buf++ ^ 0x20; | ||
308 | size++; | ||
309 | } | ||
310 | |||
311 | return probe_kernel_write(mem, c, size); | ||
312 | } | ||
313 | |||
314 | /* Write memory due to an 'M' or 'X' packet. */ | ||
315 | static int write_mem_msg(int binary) | ||
316 | { | ||
317 | char *ptr = &remcom_in_buffer[1]; | ||
318 | unsigned long addr; | ||
319 | unsigned long length; | ||
320 | int err; | ||
321 | |||
322 | if (kgdb_hex2long(&ptr, &addr) > 0 && *(ptr++) == ',' && | ||
323 | kgdb_hex2long(&ptr, &length) > 0 && *(ptr++) == ':') { | ||
324 | if (binary) | ||
325 | err = kgdb_ebin2mem(ptr, (char *)addr, length); | ||
326 | else | ||
327 | err = kgdb_hex2mem(ptr, (char *)addr, length); | ||
328 | if (err) | ||
329 | return err; | ||
330 | if (CACHE_FLUSH_IS_SAFE) | ||
331 | flush_icache_range(addr, addr + length); | ||
332 | return 0; | ||
333 | } | ||
334 | |||
335 | return -EINVAL; | ||
336 | } | ||
337 | |||
338 | static void error_packet(char *pkt, int error) | ||
339 | { | ||
340 | error = -error; | ||
341 | pkt[0] = 'E'; | ||
342 | pkt[1] = hex_asc[(error / 10)]; | ||
343 | pkt[2] = hex_asc[(error % 10)]; | ||
344 | pkt[3] = '\0'; | ||
345 | } | ||
346 | |||
347 | /* | ||
348 | * Thread ID accessors. We represent a flat TID space to GDB, where | ||
349 | * the per CPU idle threads (which under Linux all have PID 0) are | ||
350 | * remapped to negative TIDs. | ||
351 | */ | ||
352 | |||
353 | #define BUF_THREAD_ID_SIZE 16 | ||
354 | |||
355 | static char *pack_threadid(char *pkt, unsigned char *id) | ||
356 | { | ||
357 | char *limit; | ||
358 | |||
359 | limit = pkt + BUF_THREAD_ID_SIZE; | ||
360 | while (pkt < limit) | ||
361 | pkt = pack_hex_byte(pkt, *id++); | ||
362 | |||
363 | return pkt; | ||
364 | } | ||
365 | |||
366 | static void int_to_threadref(unsigned char *id, int value) | ||
367 | { | ||
368 | unsigned char *scan; | ||
369 | int i = 4; | ||
370 | |||
371 | scan = (unsigned char *)id; | ||
372 | while (i--) | ||
373 | *scan++ = 0; | ||
374 | put_unaligned_be32(value, scan); | ||
375 | } | ||
376 | |||
377 | static struct task_struct *getthread(struct pt_regs *regs, int tid) | ||
378 | { | ||
379 | /* | ||
380 | * Non-positive TIDs are remapped to the cpu shadow information | ||
381 | */ | ||
382 | if (tid == 0 || tid == -1) | ||
383 | tid = -atomic_read(&kgdb_active) - 2; | ||
384 | if (tid < -1 && tid > -NR_CPUS - 2) { | ||
385 | if (kgdb_info[-tid - 2].task) | ||
386 | return kgdb_info[-tid - 2].task; | ||
387 | else | ||
388 | return idle_task(-tid - 2); | ||
389 | } | ||
390 | if (tid <= 0) { | ||
391 | printk(KERN_ERR "KGDB: Internal thread select error\n"); | ||
392 | dump_stack(); | ||
393 | return NULL; | ||
394 | } | ||
395 | |||
396 | /* | ||
397 | * find_task_by_pid_ns() does not take the tasklist lock anymore | ||
398 | * but is nicely RCU locked - hence is a pretty resilient | ||
399 | * thing to use: | ||
400 | */ | ||
401 | return find_task_by_pid_ns(tid, &init_pid_ns); | ||
402 | } | ||
403 | |||
404 | |||
405 | /* | ||
406 | * Remap normal tasks to their real PID, | ||
407 | * CPU shadow threads are mapped to -CPU - 2 | ||
408 | */ | ||
409 | static inline int shadow_pid(int realpid) | ||
410 | { | ||
411 | if (realpid) | ||
412 | return realpid; | ||
413 | |||
414 | return -raw_smp_processor_id() - 2; | ||
415 | } | ||
416 | |||
417 | /* | ||
418 | * All the functions that start with gdb_cmd are the various | ||
419 | * operations to implement the handlers for the gdbserial protocol | ||
420 | * where KGDB is communicating with an external debugger | ||
421 | */ | ||
422 | |||
423 | /* Handle the '?' status packets */ | ||
424 | static void gdb_cmd_status(struct kgdb_state *ks) | ||
425 | { | ||
426 | /* | ||
427 | * We know that this packet is only sent | ||
428 | * during initial connect. So to be safe, | ||
429 | * we clear out our breakpoints now in case | ||
430 | * GDB is reconnecting. | ||
431 | */ | ||
432 | dbg_remove_all_break(); | ||
433 | |||
434 | remcom_out_buffer[0] = 'S'; | ||
435 | pack_hex_byte(&remcom_out_buffer[1], ks->signo); | ||
436 | } | ||
437 | |||
438 | /* Handle the 'g' get registers request */ | ||
439 | static void gdb_cmd_getregs(struct kgdb_state *ks) | ||
440 | { | ||
441 | struct task_struct *thread; | ||
442 | void *local_debuggerinfo; | ||
443 | int i; | ||
444 | |||
445 | thread = kgdb_usethread; | ||
446 | if (!thread) { | ||
447 | thread = kgdb_info[ks->cpu].task; | ||
448 | local_debuggerinfo = kgdb_info[ks->cpu].debuggerinfo; | ||
449 | } else { | ||
450 | local_debuggerinfo = NULL; | ||
451 | for_each_online_cpu(i) { | ||
452 | /* | ||
453 | * Try to find the task on some other | ||
454 | * or possibly this node if we do not | ||
455 | * find the matching task then we try | ||
456 | * to approximate the results. | ||
457 | */ | ||
458 | if (thread == kgdb_info[i].task) | ||
459 | local_debuggerinfo = kgdb_info[i].debuggerinfo; | ||
460 | } | ||
461 | } | ||
462 | |||
463 | /* | ||
464 | * All threads that don't have debuggerinfo should be | ||
465 | * in schedule() sleeping, since all other CPUs | ||
466 | * are in kgdb_wait, and thus have debuggerinfo. | ||
467 | */ | ||
468 | if (local_debuggerinfo) { | ||
469 | pt_regs_to_gdb_regs(gdb_regs, local_debuggerinfo); | ||
470 | } else { | ||
471 | /* | ||
472 | * Pull stuff saved during switch_to; nothing | ||
473 | * else is accessible (or even particularly | ||
474 | * relevant). | ||
475 | * | ||
476 | * This should be enough for a stack trace. | ||
477 | */ | ||
478 | sleeping_thread_to_gdb_regs(gdb_regs, thread); | ||
479 | } | ||
480 | kgdb_mem2hex((char *)gdb_regs, remcom_out_buffer, NUMREGBYTES); | ||
481 | } | ||
482 | |||
483 | /* Handle the 'G' set registers request */ | ||
484 | static void gdb_cmd_setregs(struct kgdb_state *ks) | ||
485 | { | ||
486 | kgdb_hex2mem(&remcom_in_buffer[1], (char *)gdb_regs, NUMREGBYTES); | ||
487 | |||
488 | if (kgdb_usethread && kgdb_usethread != current) { | ||
489 | error_packet(remcom_out_buffer, -EINVAL); | ||
490 | } else { | ||
491 | gdb_regs_to_pt_regs(gdb_regs, ks->linux_regs); | ||
492 | strcpy(remcom_out_buffer, "OK"); | ||
493 | } | ||
494 | } | ||
495 | |||
496 | /* Handle the 'm' memory read bytes */ | ||
497 | static void gdb_cmd_memread(struct kgdb_state *ks) | ||
498 | { | ||
499 | char *ptr = &remcom_in_buffer[1]; | ||
500 | unsigned long length; | ||
501 | unsigned long addr; | ||
502 | int err; | ||
503 | |||
504 | if (kgdb_hex2long(&ptr, &addr) > 0 && *ptr++ == ',' && | ||
505 | kgdb_hex2long(&ptr, &length) > 0) { | ||
506 | err = kgdb_mem2hex((char *)addr, remcom_out_buffer, length); | ||
507 | if (err) | ||
508 | error_packet(remcom_out_buffer, err); | ||
509 | } else { | ||
510 | error_packet(remcom_out_buffer, -EINVAL); | ||
511 | } | ||
512 | } | ||
513 | |||
514 | /* Handle the 'M' memory write bytes */ | ||
515 | static void gdb_cmd_memwrite(struct kgdb_state *ks) | ||
516 | { | ||
517 | int err = write_mem_msg(0); | ||
518 | |||
519 | if (err) | ||
520 | error_packet(remcom_out_buffer, err); | ||
521 | else | ||
522 | strcpy(remcom_out_buffer, "OK"); | ||
523 | } | ||
524 | |||
525 | /* Handle the 'X' memory binary write bytes */ | ||
526 | static void gdb_cmd_binwrite(struct kgdb_state *ks) | ||
527 | { | ||
528 | int err = write_mem_msg(1); | ||
529 | |||
530 | if (err) | ||
531 | error_packet(remcom_out_buffer, err); | ||
532 | else | ||
533 | strcpy(remcom_out_buffer, "OK"); | ||
534 | } | ||
535 | |||
536 | /* Handle the 'D' or 'k', detach or kill packets */ | ||
537 | static void gdb_cmd_detachkill(struct kgdb_state *ks) | ||
538 | { | ||
539 | int error; | ||
540 | |||
541 | /* The detach case */ | ||
542 | if (remcom_in_buffer[0] == 'D') { | ||
543 | error = dbg_remove_all_break(); | ||
544 | if (error < 0) { | ||
545 | error_packet(remcom_out_buffer, error); | ||
546 | } else { | ||
547 | strcpy(remcom_out_buffer, "OK"); | ||
548 | kgdb_connected = 0; | ||
549 | } | ||
550 | put_packet(remcom_out_buffer); | ||
551 | } else { | ||
552 | /* | ||
553 | * Assume the kill case, with no exit code checking, | ||
554 | * trying to force detach the debugger: | ||
555 | */ | ||
556 | dbg_remove_all_break(); | ||
557 | kgdb_connected = 0; | ||
558 | } | ||
559 | } | ||
560 | |||
561 | /* Handle the 'R' reboot packets */ | ||
562 | static int gdb_cmd_reboot(struct kgdb_state *ks) | ||
563 | { | ||
564 | /* For now, only honor R0 */ | ||
565 | if (strcmp(remcom_in_buffer, "R0") == 0) { | ||
566 | printk(KERN_CRIT "Executing emergency reboot\n"); | ||
567 | strcpy(remcom_out_buffer, "OK"); | ||
568 | put_packet(remcom_out_buffer); | ||
569 | |||
570 | /* | ||
571 | * Execution should not return from | ||
572 | * machine_emergency_restart() | ||
573 | */ | ||
574 | machine_emergency_restart(); | ||
575 | kgdb_connected = 0; | ||
576 | |||
577 | return 1; | ||
578 | } | ||
579 | return 0; | ||
580 | } | ||
581 | |||
582 | /* Handle the 'q' query packets */ | ||
583 | static void gdb_cmd_query(struct kgdb_state *ks) | ||
584 | { | ||
585 | struct task_struct *g; | ||
586 | struct task_struct *p; | ||
587 | unsigned char thref[8]; | ||
588 | char *ptr; | ||
589 | int i; | ||
590 | int cpu; | ||
591 | int finished = 0; | ||
592 | |||
593 | switch (remcom_in_buffer[1]) { | ||
594 | case 's': | ||
595 | case 'f': | ||
596 | if (memcmp(remcom_in_buffer + 2, "ThreadInfo", 10)) { | ||
597 | error_packet(remcom_out_buffer, -EINVAL); | ||
598 | break; | ||
599 | } | ||
600 | |||
601 | i = 0; | ||
602 | remcom_out_buffer[0] = 'm'; | ||
603 | ptr = remcom_out_buffer + 1; | ||
604 | if (remcom_in_buffer[1] == 'f') { | ||
605 | /* Each cpu is a shadow thread */ | ||
606 | for_each_online_cpu(cpu) { | ||
607 | ks->thr_query = 0; | ||
608 | int_to_threadref(thref, -cpu - 2); | ||
609 | pack_threadid(ptr, thref); | ||
610 | ptr += BUF_THREAD_ID_SIZE; | ||
611 | *(ptr++) = ','; | ||
612 | i++; | ||
613 | } | ||
614 | } | ||
615 | |||
616 | do_each_thread(g, p) { | ||
617 | if (i >= ks->thr_query && !finished) { | ||
618 | int_to_threadref(thref, p->pid); | ||
619 | pack_threadid(ptr, thref); | ||
620 | ptr += BUF_THREAD_ID_SIZE; | ||
621 | *(ptr++) = ','; | ||
622 | ks->thr_query++; | ||
623 | if (ks->thr_query % KGDB_MAX_THREAD_QUERY == 0) | ||
624 | finished = 1; | ||
625 | } | ||
626 | i++; | ||
627 | } while_each_thread(g, p); | ||
628 | |||
629 | *(--ptr) = '\0'; | ||
630 | break; | ||
631 | |||
632 | case 'C': | ||
633 | /* Current thread id */ | ||
634 | strcpy(remcom_out_buffer, "QC"); | ||
635 | ks->threadid = shadow_pid(current->pid); | ||
636 | int_to_threadref(thref, ks->threadid); | ||
637 | pack_threadid(remcom_out_buffer + 2, thref); | ||
638 | break; | ||
639 | case 'T': | ||
640 | if (memcmp(remcom_in_buffer + 1, "ThreadExtraInfo,", 16)) { | ||
641 | error_packet(remcom_out_buffer, -EINVAL); | ||
642 | break; | ||
643 | } | ||
644 | ks->threadid = 0; | ||
645 | ptr = remcom_in_buffer + 17; | ||
646 | kgdb_hex2long(&ptr, &ks->threadid); | ||
647 | if (!getthread(ks->linux_regs, ks->threadid)) { | ||
648 | error_packet(remcom_out_buffer, -EINVAL); | ||
649 | break; | ||
650 | } | ||
651 | if ((int)ks->threadid > 0) { | ||
652 | kgdb_mem2hex(getthread(ks->linux_regs, | ||
653 | ks->threadid)->comm, | ||
654 | remcom_out_buffer, 16); | ||
655 | } else { | ||
656 | static char tmpstr[23 + BUF_THREAD_ID_SIZE]; | ||
657 | |||
658 | sprintf(tmpstr, "shadowCPU%d", | ||
659 | (int)(-ks->threadid - 2)); | ||
660 | kgdb_mem2hex(tmpstr, remcom_out_buffer, strlen(tmpstr)); | ||
661 | } | ||
662 | break; | ||
663 | } | ||
664 | } | ||
665 | |||
666 | /* Handle the 'H' task query packets */ | ||
667 | static void gdb_cmd_task(struct kgdb_state *ks) | ||
668 | { | ||
669 | struct task_struct *thread; | ||
670 | char *ptr; | ||
671 | |||
672 | switch (remcom_in_buffer[1]) { | ||
673 | case 'g': | ||
674 | ptr = &remcom_in_buffer[2]; | ||
675 | kgdb_hex2long(&ptr, &ks->threadid); | ||
676 | thread = getthread(ks->linux_regs, ks->threadid); | ||
677 | if (!thread && ks->threadid > 0) { | ||
678 | error_packet(remcom_out_buffer, -EINVAL); | ||
679 | break; | ||
680 | } | ||
681 | kgdb_usethread = thread; | ||
682 | ks->kgdb_usethreadid = ks->threadid; | ||
683 | strcpy(remcom_out_buffer, "OK"); | ||
684 | break; | ||
685 | case 'c': | ||
686 | ptr = &remcom_in_buffer[2]; | ||
687 | kgdb_hex2long(&ptr, &ks->threadid); | ||
688 | if (!ks->threadid) { | ||
689 | kgdb_contthread = NULL; | ||
690 | } else { | ||
691 | thread = getthread(ks->linux_regs, ks->threadid); | ||
692 | if (!thread && ks->threadid > 0) { | ||
693 | error_packet(remcom_out_buffer, -EINVAL); | ||
694 | break; | ||
695 | } | ||
696 | kgdb_contthread = thread; | ||
697 | } | ||
698 | strcpy(remcom_out_buffer, "OK"); | ||
699 | break; | ||
700 | } | ||
701 | } | ||
702 | |||
703 | /* Handle the 'T' thread query packets */ | ||
704 | static void gdb_cmd_thread(struct kgdb_state *ks) | ||
705 | { | ||
706 | char *ptr = &remcom_in_buffer[1]; | ||
707 | struct task_struct *thread; | ||
708 | |||
709 | kgdb_hex2long(&ptr, &ks->threadid); | ||
710 | thread = getthread(ks->linux_regs, ks->threadid); | ||
711 | if (thread) | ||
712 | strcpy(remcom_out_buffer, "OK"); | ||
713 | else | ||
714 | error_packet(remcom_out_buffer, -EINVAL); | ||
715 | } | ||
716 | |||
717 | /* Handle the 'z' or 'Z' breakpoint remove or set packets */ | ||
718 | static void gdb_cmd_break(struct kgdb_state *ks) | ||
719 | { | ||
720 | /* | ||
721 | * Since GDB-5.3, it's been drafted that '0' is a software | ||
722 | * breakpoint, '1' is a hardware breakpoint, so let's do that. | ||
723 | */ | ||
724 | char *bpt_type = &remcom_in_buffer[1]; | ||
725 | char *ptr = &remcom_in_buffer[2]; | ||
726 | unsigned long addr; | ||
727 | unsigned long length; | ||
728 | int error = 0; | ||
729 | |||
730 | if (arch_kgdb_ops.set_hw_breakpoint && *bpt_type >= '1') { | ||
731 | /* Unsupported */ | ||
732 | if (*bpt_type > '4') | ||
733 | return; | ||
734 | } else { | ||
735 | if (*bpt_type != '0' && *bpt_type != '1') | ||
736 | /* Unsupported. */ | ||
737 | return; | ||
738 | } | ||
739 | |||
740 | /* | ||
741 | * Test if this is a hardware breakpoint, and | ||
742 | * if we support it: | ||
743 | */ | ||
744 | if (*bpt_type == '1' && !(arch_kgdb_ops.flags & KGDB_HW_BREAKPOINT)) | ||
745 | /* Unsupported. */ | ||
746 | return; | ||
747 | |||
748 | if (*(ptr++) != ',') { | ||
749 | error_packet(remcom_out_buffer, -EINVAL); | ||
750 | return; | ||
751 | } | ||
752 | if (!kgdb_hex2long(&ptr, &addr)) { | ||
753 | error_packet(remcom_out_buffer, -EINVAL); | ||
754 | return; | ||
755 | } | ||
756 | if (*(ptr++) != ',' || | ||
757 | !kgdb_hex2long(&ptr, &length)) { | ||
758 | error_packet(remcom_out_buffer, -EINVAL); | ||
759 | return; | ||
760 | } | ||
761 | |||
762 | if (remcom_in_buffer[0] == 'Z' && *bpt_type == '0') | ||
763 | error = dbg_set_sw_break(addr); | ||
764 | else if (remcom_in_buffer[0] == 'z' && *bpt_type == '0') | ||
765 | error = dbg_remove_sw_break(addr); | ||
766 | else if (remcom_in_buffer[0] == 'Z') | ||
767 | error = arch_kgdb_ops.set_hw_breakpoint(addr, | ||
768 | (int)length, *bpt_type - '0'); | ||
769 | else if (remcom_in_buffer[0] == 'z') | ||
770 | error = arch_kgdb_ops.remove_hw_breakpoint(addr, | ||
771 | (int) length, *bpt_type - '0'); | ||
772 | |||
773 | if (error == 0) | ||
774 | strcpy(remcom_out_buffer, "OK"); | ||
775 | else | ||
776 | error_packet(remcom_out_buffer, error); | ||
777 | } | ||
778 | |||
779 | /* Handle the 'C' signal / exception passing packets */ | ||
780 | static int gdb_cmd_exception_pass(struct kgdb_state *ks) | ||
781 | { | ||
782 | /* C09 == pass exception | ||
783 | * C15 == detach kgdb, pass exception | ||
784 | */ | ||
785 | if (remcom_in_buffer[1] == '0' && remcom_in_buffer[2] == '9') { | ||
786 | |||
787 | ks->pass_exception = 1; | ||
788 | remcom_in_buffer[0] = 'c'; | ||
789 | |||
790 | } else if (remcom_in_buffer[1] == '1' && remcom_in_buffer[2] == '5') { | ||
791 | |||
792 | ks->pass_exception = 1; | ||
793 | remcom_in_buffer[0] = 'D'; | ||
794 | dbg_remove_all_break(); | ||
795 | kgdb_connected = 0; | ||
796 | return 1; | ||
797 | |||
798 | } else { | ||
799 | gdbstub_msg_write("KGDB only knows signal 9 (pass)" | ||
800 | " and 15 (pass and disconnect)\n" | ||
801 | "Executing a continue without signal passing\n", 0); | ||
802 | remcom_in_buffer[0] = 'c'; | ||
803 | } | ||
804 | |||
805 | /* Indicate fall through */ | ||
806 | return -1; | ||
807 | } | ||
808 | |||
809 | /* | ||
810 | * This function performs all gdbserial command procesing | ||
811 | */ | ||
812 | int gdb_serial_stub(struct kgdb_state *ks) | ||
813 | { | ||
814 | int error = 0; | ||
815 | int tmp; | ||
816 | |||
817 | /* Clear the out buffer. */ | ||
818 | memset(remcom_out_buffer, 0, sizeof(remcom_out_buffer)); | ||
819 | |||
820 | if (kgdb_connected) { | ||
821 | unsigned char thref[8]; | ||
822 | char *ptr; | ||
823 | |||
824 | /* Reply to host that an exception has occurred */ | ||
825 | ptr = remcom_out_buffer; | ||
826 | *ptr++ = 'T'; | ||
827 | ptr = pack_hex_byte(ptr, ks->signo); | ||
828 | ptr += strlen(strcpy(ptr, "thread:")); | ||
829 | int_to_threadref(thref, shadow_pid(current->pid)); | ||
830 | ptr = pack_threadid(ptr, thref); | ||
831 | *ptr++ = ';'; | ||
832 | put_packet(remcom_out_buffer); | ||
833 | } | ||
834 | |||
835 | kgdb_usethread = kgdb_info[ks->cpu].task; | ||
836 | ks->kgdb_usethreadid = shadow_pid(kgdb_info[ks->cpu].task->pid); | ||
837 | ks->pass_exception = 0; | ||
838 | |||
839 | while (1) { | ||
840 | error = 0; | ||
841 | |||
842 | /* Clear the out buffer. */ | ||
843 | memset(remcom_out_buffer, 0, sizeof(remcom_out_buffer)); | ||
844 | |||
845 | get_packet(remcom_in_buffer); | ||
846 | |||
847 | switch (remcom_in_buffer[0]) { | ||
848 | case '?': /* gdbserial status */ | ||
849 | gdb_cmd_status(ks); | ||
850 | break; | ||
851 | case 'g': /* return the value of the CPU registers */ | ||
852 | gdb_cmd_getregs(ks); | ||
853 | break; | ||
854 | case 'G': /* set the value of the CPU registers - return OK */ | ||
855 | gdb_cmd_setregs(ks); | ||
856 | break; | ||
857 | case 'm': /* mAA..AA,LLLL Read LLLL bytes at address AA..AA */ | ||
858 | gdb_cmd_memread(ks); | ||
859 | break; | ||
860 | case 'M': /* MAA..AA,LLLL: Write LLLL bytes at address AA..AA */ | ||
861 | gdb_cmd_memwrite(ks); | ||
862 | break; | ||
863 | case 'X': /* XAA..AA,LLLL: Write LLLL bytes at address AA..AA */ | ||
864 | gdb_cmd_binwrite(ks); | ||
865 | break; | ||
866 | /* kill or detach. KGDB should treat this like a | ||
867 | * continue. | ||
868 | */ | ||
869 | case 'D': /* Debugger detach */ | ||
870 | case 'k': /* Debugger detach via kill */ | ||
871 | gdb_cmd_detachkill(ks); | ||
872 | goto default_handle; | ||
873 | case 'R': /* Reboot */ | ||
874 | if (gdb_cmd_reboot(ks)) | ||
875 | goto default_handle; | ||
876 | break; | ||
877 | case 'q': /* query command */ | ||
878 | gdb_cmd_query(ks); | ||
879 | break; | ||
880 | case 'H': /* task related */ | ||
881 | gdb_cmd_task(ks); | ||
882 | break; | ||
883 | case 'T': /* Query thread status */ | ||
884 | gdb_cmd_thread(ks); | ||
885 | break; | ||
886 | case 'z': /* Break point remove */ | ||
887 | case 'Z': /* Break point set */ | ||
888 | gdb_cmd_break(ks); | ||
889 | break; | ||
890 | case 'C': /* Exception passing */ | ||
891 | tmp = gdb_cmd_exception_pass(ks); | ||
892 | if (tmp > 0) | ||
893 | goto default_handle; | ||
894 | if (tmp == 0) | ||
895 | break; | ||
896 | /* Fall through on tmp < 0 */ | ||
897 | case 'c': /* Continue packet */ | ||
898 | case 's': /* Single step packet */ | ||
899 | if (kgdb_contthread && kgdb_contthread != current) { | ||
900 | /* Can't switch threads in kgdb */ | ||
901 | error_packet(remcom_out_buffer, -EINVAL); | ||
902 | break; | ||
903 | } | ||
904 | dbg_activate_sw_breakpoints(); | ||
905 | /* Fall through to default processing */ | ||
906 | default: | ||
907 | default_handle: | ||
908 | error = kgdb_arch_handle_exception(ks->ex_vector, | ||
909 | ks->signo, | ||
910 | ks->err_code, | ||
911 | remcom_in_buffer, | ||
912 | remcom_out_buffer, | ||
913 | ks->linux_regs); | ||
914 | /* | ||
915 | * Leave cmd processing on error, detach, | ||
916 | * kill, continue, or single step. | ||
917 | */ | ||
918 | if (error >= 0 || remcom_in_buffer[0] == 'D' || | ||
919 | remcom_in_buffer[0] == 'k') { | ||
920 | error = 0; | ||
921 | goto kgdb_exit; | ||
922 | } | ||
923 | |||
924 | } | ||
925 | |||
926 | /* reply to the request */ | ||
927 | put_packet(remcom_out_buffer); | ||
928 | } | ||
929 | |||
930 | kgdb_exit: | ||
931 | if (ks->pass_exception) | ||
932 | error = 1; | ||
933 | return error; | ||
934 | } | ||