projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge branch 'release' of git://git.kernel.org/pub/scm/linux/kernel/git/aegl/linux-2.6
[deliverable/linux.git] / arch / sh / kernel / kgdb_stub.c
1 /*
2 * May be copied or modified under the terms of the GNU General Public
3 * License. See linux/COPYING for more information.
4 *
5 * Contains extracts from code by Glenn Engel, Jim Kingdon,
6 * David Grothe <dave@gcom.com>, Tigran Aivazian <tigran@sco.com>,
7 * Amit S. Kale <akale@veritas.com>, William Gatliff <bgat@open-widgets.com>,
8 * Ben Lee, Steve Chamberlain and Benoit Miller <fulg@iname.com>.
9 *
10 * This version by Henry Bell <henry.bell@st.com>
11 * Minor modifications by Jeremy Siegel <jsiegel@mvista.com>
12 *
13 * Contains low-level support for remote debug using GDB.
14 *
15 * To enable debugger support, two things need to happen. A call to
16 * set_debug_traps() is necessary in order to allow any breakpoints
17 * or error conditions to be properly intercepted and reported to gdb.
18 * A breakpoint also needs to be generated to begin communication. This
19 * is most easily accomplished by a call to breakpoint() which does
20 * a trapa if the initialisation phase has been successfully completed.
21 *
22 * In this case, set_debug_traps() is not used to "take over" exceptions;
23 * other kernel code is modified instead to enter the kgdb functions here
24 * when appropriate (see entry.S for breakpoint traps and NMI interrupts,
25 * see traps.c for kernel error exceptions).
26 *
27 * The following gdb commands are supported:
28 *
29 * Command Function Return value
30 *
31 * g return the value of the CPU registers hex data or ENN
32 * G set the value of the CPU registers OK or ENN
33 *
34 * mAA..AA,LLLL Read LLLL bytes at address AA..AA hex data or ENN
35 * MAA..AA,LLLL: Write LLLL bytes at address AA.AA OK or ENN
36 * XAA..AA,LLLL: Same, but data is binary (not hex) OK or ENN
37 *
38 * c Resume at current address SNN ( signal NN)
39 * cAA..AA Continue at address AA..AA SNN
40 * CNN; Resume at current address with signal SNN
41 * CNN;AA..AA Resume at address AA..AA with signal SNN
42 *
43 * s Step one instruction SNN
44 * sAA..AA Step one instruction from AA..AA SNN
45 * SNN; Step one instruction with signal SNN
46 * SNNAA..AA Step one instruction from AA..AA w/NN SNN
47 *
48 * k kill (Detach GDB)
49 *
50 * d Toggle debug flag
51 * D Detach GDB
52 *
53 * Hct Set thread t for operations, OK or ENN
54 * c = 'c' (step, cont), c = 'g' (other
55 * operations)
56 *
57 * qC Query current thread ID QCpid
58 * qfThreadInfo Get list of current threads (first) m<id>
59 * qsThreadInfo " " " " " (subsequent)
60 * qOffsets Get section offsets Text=x;Data=y;Bss=z
61 *
62 * TXX Find if thread XX is alive OK or ENN
63 * ? What was the last sigval ? SNN (signal NN)
64 * O Output to GDB console
65 *
66 * Remote communication protocol.
67 *
68 * A debug packet whose contents are <data> is encapsulated for
69 * transmission in the form:
70 *
71 * $ <data> # CSUM1 CSUM2
72 *
73 * <data> must be ASCII alphanumeric and cannot include characters
74 * '$' or '#'. If <data> starts with two characters followed by
75 * ':', then the existing stubs interpret this as a sequence number.
76 *
77 * CSUM1 and CSUM2 are ascii hex representation of an 8-bit
78 * checksum of <data>, the most significant nibble is sent first.
79 * the hex digits 0-9,a-f are used.
80 *
81 * Receiver responds with:
82 *
83 * + - if CSUM is correct and ready for next packet
84 * - - if CSUM is incorrect
85 *
86 * Responses can be run-length encoded to save space. A '*' means that
87 * the next character is an ASCII encoding giving a repeat count which
88 * stands for that many repetitions of the character preceding the '*'.
89 * The encoding is n+29, yielding a printable character where n >=3
90 * (which is where RLE starts to win). Don't use an n > 126.
91 *
92 * So "0* " means the same as "0000".
93 */
94
95 #include <linux/string.h>
96 #include <linux/kernel.h>
97 #include <linux/sched.h>
98 #include <linux/smp.h>
99 #include <linux/spinlock.h>
100 #include <linux/delay.h>
101 #include <linux/linkage.h>
102 #include <linux/init.h>
103 #include <linux/console.h>
104 #include <linux/sysrq.h>
105 #include <asm/system.h>
106 #include <asm/cacheflush.h>
107 #include <asm/current.h>
108 #include <asm/signal.h>
109 #include <asm/pgtable.h>
110 #include <asm/ptrace.h>
111 #include <asm/kgdb.h>
112 #include <asm/io.h>
113
114 /* Function pointers for linkage */
115 kgdb_debug_hook_t *kgdb_debug_hook;
116 kgdb_bus_error_hook_t *kgdb_bus_err_hook;
117
118 int (*kgdb_getchar)(void);
119 void (*kgdb_putchar)(int);
120
121 static void put_debug_char(int c)
122 {
123 if (!kgdb_putchar)
124 return;
125 (*kgdb_putchar)(c);
126 }
127 static int get_debug_char(void)
128 {
129 if (!kgdb_getchar)
130 return -1;
131 return (*kgdb_getchar)();
132 }
133
134 /* Num chars in in/out bound buffers, register packets need NUMREGBYTES * 2 */
135 #define BUFMAX 1024
136 #define NUMREGBYTES (MAXREG*4)
137 #define OUTBUFMAX (NUMREGBYTES*2+512)
138
139 enum regs {
140 R0 = 0, R1, R2, R3, R4, R5, R6, R7,
141 R8, R9, R10, R11, R12, R13, R14, R15,
142 PC, PR, GBR, VBR, MACH, MACL, SR,
143 /* */
144 MAXREG
145 };
146
147 static unsigned int registers[MAXREG];
148 struct kgdb_regs trap_registers;
149
150 char kgdb_in_gdb_mode;
151 char in_nmi; /* Set during NMI to prevent reentry */
152 int kgdb_nofault; /* Boolean to ignore bus errs (i.e. in GDB) */
153
154 /* Default values for SCI (can override via kernel args in setup.c) */
155 #ifndef CONFIG_KGDB_DEFPORT
156 #define CONFIG_KGDB_DEFPORT 1
157 #endif
158
159 #ifndef CONFIG_KGDB_DEFBAUD
160 #define CONFIG_KGDB_DEFBAUD 115200
161 #endif
162
163 #if defined(CONFIG_KGDB_DEFPARITY_E)
164 #define CONFIG_KGDB_DEFPARITY 'E'
165 #elif defined(CONFIG_KGDB_DEFPARITY_O)
166 #define CONFIG_KGDB_DEFPARITY 'O'
167 #else /* CONFIG_KGDB_DEFPARITY_N */
168 #define CONFIG_KGDB_DEFPARITY 'N'
169 #endif
170
171 #ifdef CONFIG_KGDB_DEFBITS_7
172 #define CONFIG_KGDB_DEFBITS '7'
173 #else /* CONFIG_KGDB_DEFBITS_8 */
174 #define CONFIG_KGDB_DEFBITS '8'
175 #endif
176
177 /* SCI/UART settings, used in kgdb_console_setup() */
178 int kgdb_portnum = CONFIG_KGDB_DEFPORT;
179 int kgdb_baud = CONFIG_KGDB_DEFBAUD;
180 char kgdb_parity = CONFIG_KGDB_DEFPARITY;
181 char kgdb_bits = CONFIG_KGDB_DEFBITS;
182
183 /* Jump buffer for setjmp/longjmp */
184 static jmp_buf rem_com_env;
185
186 /* TRA differs sh3/4 */
187 #if defined(CONFIG_CPU_SH3)
188 #define TRA 0xffffffd0
189 #elif defined(CONFIG_CPU_SH4)
190 #define TRA 0xff000020
191 #endif
192
193 /* Macros for single step instruction identification */
194 #define OPCODE_BT(op) (((op) & 0xff00) == 0x8900)
195 #define OPCODE_BF(op) (((op) & 0xff00) == 0x8b00)
196 #define OPCODE_BTF_DISP(op) (((op) & 0x80) ? (((op) | 0xffffff80) << 1) : \
197 (((op) & 0x7f ) << 1))
198 #define OPCODE_BFS(op) (((op) & 0xff00) == 0x8f00)
199 #define OPCODE_BTS(op) (((op) & 0xff00) == 0x8d00)
200 #define OPCODE_BRA(op) (((op) & 0xf000) == 0xa000)
201 #define OPCODE_BRA_DISP(op) (((op) & 0x800) ? (((op) | 0xfffff800) << 1) : \
202 (((op) & 0x7ff) << 1))
203 #define OPCODE_BRAF(op) (((op) & 0xf0ff) == 0x0023)
204 #define OPCODE_BRAF_REG(op) (((op) & 0x0f00) >> 8)
205 #define OPCODE_BSR(op) (((op) & 0xf000) == 0xb000)
206 #define OPCODE_BSR_DISP(op) (((op) & 0x800) ? (((op) | 0xfffff800) << 1) : \
207 (((op) & 0x7ff) << 1))
208 #define OPCODE_BSRF(op) (((op) & 0xf0ff) == 0x0003)
209 #define OPCODE_BSRF_REG(op) (((op) >> 8) & 0xf)
210 #define OPCODE_JMP(op) (((op) & 0xf0ff) == 0x402b)
211 #define OPCODE_JMP_REG(op) (((op) >> 8) & 0xf)
212 #define OPCODE_JSR(op) (((op) & 0xf0ff) == 0x400b)
213 #define OPCODE_JSR_REG(op) (((op) >> 8) & 0xf)
214 #define OPCODE_RTS(op) ((op) == 0xb)
215 #define OPCODE_RTE(op) ((op) == 0x2b)
216
217 #define SR_T_BIT_MASK 0x1
218 #define STEP_OPCODE 0xc320
219 #define BIOS_CALL_TRAP 0x3f
220
221 /* Exception codes as per SH-4 core manual */
222 #define ADDRESS_ERROR_LOAD_VEC 7
223 #define ADDRESS_ERROR_STORE_VEC 8
224 #define TRAP_VEC 11
225 #define INVALID_INSN_VEC 12
226 #define INVALID_SLOT_VEC 13
227 #define NMI_VEC 14
228 #define USER_BREAK_VEC 15
229 #define SERIAL_BREAK_VEC 58
230
231 /* Misc static */
232 static int stepped_address;
233 static short stepped_opcode;
234 static char in_buffer[BUFMAX];
235 static char out_buffer[OUTBUFMAX];
236
237 static void kgdb_to_gdb(const char *s);
238
239 /* Convert ch to hex */
240 static int hex(const char ch)
241 {
242 if ((ch >= 'a') && (ch <= 'f'))
243 return (ch - 'a' + 10);
244 if ((ch >= '0') && (ch <= '9'))
245 return (ch - '0');
246 if ((ch >= 'A') && (ch <= 'F'))
247 return (ch - 'A' + 10);
248 return (-1);
249 }
250
251 /* Convert the memory pointed to by mem into hex, placing result in buf.
252 Returns a pointer to the last char put in buf (null) */
253 static char *mem_to_hex(const char *mem, char *buf, const int count)
254 {
255 int i;
256 int ch;
257 unsigned short s_val;
258 unsigned long l_val;
259
260 /* Check for 16 or 32 */
261 if (count == 2 && ((long) mem & 1) == 0) {
262 s_val = *(unsigned short *) mem;
263 mem = (char *) &s_val;
264 } else if (count == 4 && ((long) mem & 3) == 0) {
265 l_val = *(unsigned long *) mem;
266 mem = (char *) &l_val;
267 }
268 for (i = 0; i < count; i++) {
269 ch = *mem++;
270 *buf++ = highhex(ch);
271 *buf++ = lowhex(ch);
272 }
273 *buf = 0;
274 return (buf);
275 }
276
277 /* Convert the hex array pointed to by buf into binary, to be placed in mem.
278 Return a pointer to the character after the last byte written */
279 static char *hex_to_mem(const char *buf, char *mem, const int count)
280 {
281 int i;
282 unsigned char ch;
283
284 for (i = 0; i < count; i++) {
285 ch = hex(*buf++) << 4;
286 ch = ch + hex(*buf++);
287 *mem++ = ch;
288 }
289 return (mem);
290 }
291
292 /* While finding valid hex chars, convert to an integer, then return it */
293 static int hex_to_int(char **ptr, int *int_value)
294 {
295 int num_chars = 0;
296 int hex_value;
297
298 *int_value = 0;
299
300 while (**ptr) {
301 hex_value = hex(**ptr);
302 if (hex_value >= 0) {
303 *int_value = (*int_value << 4) | hex_value;
304 num_chars++;
305 } else
306 break;
307 (*ptr)++;
308 }
309 return num_chars;
310 }
311
312 /* Copy the binary array pointed to by buf into mem. Fix $, #,
313 and 0x7d escaped with 0x7d. Return a pointer to the character
314 after the last byte written. */
315 static char *ebin_to_mem(const char *buf, char *mem, int count)
316 {
317 for (; count > 0; count--, buf++) {
318 if (*buf == 0x7d)
319 *mem++ = *(++buf) ^ 0x20;
320 else
321 *mem++ = *buf;
322 }
323 return mem;
324 }
325
326 /* Pack a hex byte */
327 static char *pack_hex_byte(char *pkt, int byte)
328 {
329 *pkt++ = hexchars[(byte >> 4) & 0xf];
330 *pkt++ = hexchars[(byte & 0xf)];
331 return pkt;
332 }
333
334 /* Scan for the start char '$', read the packet and check the checksum */
335 static void get_packet(char *buffer, int buflen)
336 {
337 unsigned char checksum;
338 unsigned char xmitcsum;
339 int i;
340 int count;
341 char ch;
342
343 do {
344 /* Ignore everything until the start character */
345 while ((ch = get_debug_char()) != '$');
346
347 checksum = 0;
348 xmitcsum = -1;
349 count = 0;
350
351 /* Now, read until a # or end of buffer is found */
352 while (count < (buflen - 1)) {
353 ch = get_debug_char();
354
355 if (ch == '#')
356 break;
357
358 checksum = checksum + ch;
359 buffer[count] = ch;
360 count = count + 1;
361 }
362
363 buffer[count] = 0;
364
365 /* Continue to read checksum following # */
366 if (ch == '#') {
367 xmitcsum = hex(get_debug_char()) << 4;
368 xmitcsum += hex(get_debug_char());
369
370 /* Checksum */
371 if (checksum != xmitcsum)
372 put_debug_char('-'); /* Failed checksum */
373 else {
374 /* Ack successful transfer */
375 put_debug_char('+');
376
377 /* If a sequence char is present, reply
378 the sequence ID */
379 if (buffer[2] == ':') {
380 put_debug_char(buffer[0]);
381 put_debug_char(buffer[1]);
382
383 /* Remove sequence chars from buffer */
384 count = strlen(buffer);
385 for (i = 3; i <= count; i++)
386 buffer[i - 3] = buffer[i];
387 }
388 }
389 }
390 }
391 while (checksum != xmitcsum); /* Keep trying while we fail */
392 }
393
394 /* Send the packet in the buffer with run-length encoding */
395 static void put_packet(char *buffer)
396 {
397 int checksum;
398 char *src;
399 int runlen;
400 int encode;
401
402 do {
403 src = buffer;
404 put_debug_char('$');
405 checksum = 0;
406
407 /* Continue while we still have chars left */
408 while (*src) {
409 /* Check for runs up to 99 chars long */
410 for (runlen = 1; runlen < 99; runlen++) {
411 if (src[0] != src[runlen])
412 break;
413 }
414
415 if (runlen > 3) {
416 /* Got a useful amount, send encoding */
417 encode = runlen + ' ' - 4;
418 put_debug_char(*src); checksum += *src;
419 put_debug_char('*'); checksum += '*';
420 put_debug_char(encode); checksum += encode;
421 src += runlen;
422 } else {
423 /* Otherwise just send the current char */
424 put_debug_char(*src); checksum += *src;
425 src += 1;
426 }
427 }
428
429 /* '#' Separator, put high and low components of checksum */
430 put_debug_char('#');
431 put_debug_char(highhex(checksum));
432 put_debug_char(lowhex(checksum));
433 }
434 while ((get_debug_char()) != '+'); /* While no ack */
435 }
436
437 /* A bus error has occurred - perform a longjmp to return execution and
438 allow handling of the error */
439 static void kgdb_handle_bus_error(void)
440 {
441 longjmp(rem_com_env, 1);
442 }
443
444 /* Translate SH-3/4 exception numbers to unix-like signal values */
445 static int compute_signal(const int excep_code)
446 {
447 int sigval;
448
449 switch (excep_code) {
450
451 case INVALID_INSN_VEC:
452 case INVALID_SLOT_VEC:
453 sigval = SIGILL;
454 break;
455 case ADDRESS_ERROR_LOAD_VEC:
456 case ADDRESS_ERROR_STORE_VEC:
457 sigval = SIGSEGV;
458 break;
459
460 case SERIAL_BREAK_VEC:
461 case NMI_VEC:
462 sigval = SIGINT;
463 break;
464
465 case USER_BREAK_VEC:
466 case TRAP_VEC:
467 sigval = SIGTRAP;
468 break;
469
470 default:
471 sigval = SIGBUS; /* "software generated" */
472 break;
473 }
474
475 return (sigval);
476 }
477
478 /* Make a local copy of the registers passed into the handler (bletch) */
479 static void kgdb_regs_to_gdb_regs(const struct kgdb_regs *regs,
480 int *gdb_regs)
481 {
482 gdb_regs[R0] = regs->regs[R0];
483 gdb_regs[R1] = regs->regs[R1];
484 gdb_regs[R2] = regs->regs[R2];
485 gdb_regs[R3] = regs->regs[R3];
486 gdb_regs[R4] = regs->regs[R4];
487 gdb_regs[R5] = regs->regs[R5];
488 gdb_regs[R6] = regs->regs[R6];
489 gdb_regs[R7] = regs->regs[R7];
490 gdb_regs[R8] = regs->regs[R8];
491 gdb_regs[R9] = regs->regs[R9];
492 gdb_regs[R10] = regs->regs[R10];
493 gdb_regs[R11] = regs->regs[R11];
494 gdb_regs[R12] = regs->regs[R12];
495 gdb_regs[R13] = regs->regs[R13];
496 gdb_regs[R14] = regs->regs[R14];
497 gdb_regs[R15] = regs->regs[R15];
498 gdb_regs[PC] = regs->pc;
499 gdb_regs[PR] = regs->pr;
500 gdb_regs[GBR] = regs->gbr;
501 gdb_regs[MACH] = regs->mach;
502 gdb_regs[MACL] = regs->macl;
503 gdb_regs[SR] = regs->sr;
504 gdb_regs[VBR] = regs->vbr;
505 }
506
507 /* Copy local gdb registers back to kgdb regs, for later copy to kernel */
508 static void gdb_regs_to_kgdb_regs(const int *gdb_regs,
509 struct kgdb_regs *regs)
510 {
511 regs->regs[R0] = gdb_regs[R0];
512 regs->regs[R1] = gdb_regs[R1];
513 regs->regs[R2] = gdb_regs[R2];
514 regs->regs[R3] = gdb_regs[R3];
515 regs->regs[R4] = gdb_regs[R4];
516 regs->regs[R5] = gdb_regs[R5];
517 regs->regs[R6] = gdb_regs[R6];
518 regs->regs[R7] = gdb_regs[R7];
519 regs->regs[R8] = gdb_regs[R8];
520 regs->regs[R9] = gdb_regs[R9];
521 regs->regs[R10] = gdb_regs[R10];
522 regs->regs[R11] = gdb_regs[R11];
523 regs->regs[R12] = gdb_regs[R12];
524 regs->regs[R13] = gdb_regs[R13];
525 regs->regs[R14] = gdb_regs[R14];
526 regs->regs[R15] = gdb_regs[R15];
527 regs->pc = gdb_regs[PC];
528 regs->pr = gdb_regs[PR];
529 regs->gbr = gdb_regs[GBR];
530 regs->mach = gdb_regs[MACH];
531 regs->macl = gdb_regs[MACL];
532 regs->sr = gdb_regs[SR];
533 regs->vbr = gdb_regs[VBR];
534 }
535
536 /* Calculate the new address for after a step */
537 static short *get_step_address(void)
538 {
539 short op = *(short *) trap_registers.pc;
540 long addr;
541
542 /* BT */
543 if (OPCODE_BT(op)) {
544 if (trap_registers.sr & SR_T_BIT_MASK)
545 addr = trap_registers.pc + 4 + OPCODE_BTF_DISP(op);
546 else
547 addr = trap_registers.pc + 2;
548 }
549
550 /* BTS */
551 else if (OPCODE_BTS(op)) {
552 if (trap_registers.sr & SR_T_BIT_MASK)
553 addr = trap_registers.pc + 4 + OPCODE_BTF_DISP(op);
554 else
555 addr = trap_registers.pc + 4; /* Not in delay slot */
556 }
557
558 /* BF */
559 else if (OPCODE_BF(op)) {
560 if (!(trap_registers.sr & SR_T_BIT_MASK))
561 addr = trap_registers.pc + 4 + OPCODE_BTF_DISP(op);
562 else
563 addr = trap_registers.pc + 2;
564 }
565
566 /* BFS */
567 else if (OPCODE_BFS(op)) {
568 if (!(trap_registers.sr & SR_T_BIT_MASK))
569 addr = trap_registers.pc + 4 + OPCODE_BTF_DISP(op);
570 else
571 addr = trap_registers.pc + 4; /* Not in delay slot */
572 }
573
574 /* BRA */
575 else if (OPCODE_BRA(op))
576 addr = trap_registers.pc + 4 + OPCODE_BRA_DISP(op);
577
578 /* BRAF */
579 else if (OPCODE_BRAF(op))
580 addr = trap_registers.pc + 4
581 + trap_registers.regs[OPCODE_BRAF_REG(op)];
582
583 /* BSR */
584 else if (OPCODE_BSR(op))
585 addr = trap_registers.pc + 4 + OPCODE_BSR_DISP(op);
586
587 /* BSRF */
588 else if (OPCODE_BSRF(op))
589 addr = trap_registers.pc + 4
590 + trap_registers.regs[OPCODE_BSRF_REG(op)];
591
592 /* JMP */
593 else if (OPCODE_JMP(op))
594 addr = trap_registers.regs[OPCODE_JMP_REG(op)];
595
596 /* JSR */
597 else if (OPCODE_JSR(op))
598 addr = trap_registers.regs[OPCODE_JSR_REG(op)];
599
600 /* RTS */
601 else if (OPCODE_RTS(op))
602 addr = trap_registers.pr;
603
604 /* RTE */
605 else if (OPCODE_RTE(op))
606 addr = trap_registers.regs[15];
607
608 /* Other */
609 else
610 addr = trap_registers.pc + 2;
611
612 flush_icache_range(addr, addr + 2);
613 return (short *) addr;
614 }
615
616 /* Set up a single-step. Replace the instruction immediately after the
617 current instruction (i.e. next in the expected flow of control) with a
618 trap instruction, so that returning will cause only a single instruction
619 to be executed. Note that this model is slightly broken for instructions
620 with delay slots (e.g. B[TF]S, BSR, BRA etc), where both the branch
621 and the instruction in the delay slot will be executed. */
622 static void do_single_step(void)
623 {
624 unsigned short *addr = 0;
625
626 /* Determine where the target instruction will send us to */
627 addr = get_step_address();
628 stepped_address = (int)addr;
629
630 /* Replace it */
631 stepped_opcode = *(short *)addr;
632 *addr = STEP_OPCODE;
633
634 /* Flush and return */
635 flush_icache_range((long) addr, (long) addr + 2);
636 }
637
638 /* Undo a single step */
639 static void undo_single_step(void)
640 {
641 /* If we have stepped, put back the old instruction */
642 /* Use stepped_address in case we stopped elsewhere */
643 if (stepped_opcode != 0) {
644 *(short*)stepped_address = stepped_opcode;
645 flush_icache_range(stepped_address, stepped_address + 2);
646 }
647 stepped_opcode = 0;
648 }
649
650 /* Send a signal message */
651 static void send_signal_msg(const int signum)
652 {
653 out_buffer[0] = 'S';
654 out_buffer[1] = highhex(signum);
655 out_buffer[2] = lowhex(signum);
656 out_buffer[3] = 0;
657 put_packet(out_buffer);
658 }
659
660 /* Reply that all was well */
661 static void send_ok_msg(void)
662 {
663 strcpy(out_buffer, "OK");
664 put_packet(out_buffer);
665 }
666
667 /* Reply that an error occurred */
668 static void send_err_msg(void)
669 {
670 strcpy(out_buffer, "E01");
671 put_packet(out_buffer);
672 }
673
674 /* Empty message indicates unrecognised command */
675 static void send_empty_msg(void)
676 {
677 put_packet("");
678 }
679
680 /* Read memory due to 'm' message */
681 static void read_mem_msg(void)
682 {
683 char *ptr;
684 int addr;
685 int length;
686
687 /* Jmp, disable bus error handler */
688 if (setjmp(rem_com_env) == 0) {
689
690 kgdb_nofault = 1;
691
692 /* Walk through, have m<addr>,<length> */
693 ptr = &in_buffer[1];
694 if (hex_to_int(&ptr, &addr) && (*ptr++ == ','))
695 if (hex_to_int(&ptr, &length)) {
696 ptr = 0;
697 if (length * 2 > OUTBUFMAX)
698 length = OUTBUFMAX / 2;
699 mem_to_hex((char *) addr, out_buffer, length);
700 }
701 if (ptr)
702 send_err_msg();
703 else
704 put_packet(out_buffer);
705 } else
706 send_err_msg();
707
708 /* Restore bus error handler */
709 kgdb_nofault = 0;
710 }
711
712 /* Write memory due to 'M' or 'X' message */
713 static void write_mem_msg(int binary)
714 {
715 char *ptr;
716 int addr;
717 int length;
718
719 if (setjmp(rem_com_env) == 0) {
720
721 kgdb_nofault = 1;
722
723 /* Walk through, have M<addr>,<length>:<data> */
724 ptr = &in_buffer[1];
725 if (hex_to_int(&ptr, &addr) && (*ptr++ == ','))
726 if (hex_to_int(&ptr, &length) && (*ptr++ == ':')) {
727 if (binary)
728 ebin_to_mem(ptr, (char*)addr, length);
729 else
730 hex_to_mem(ptr, (char*)addr, length);
731 flush_icache_range(addr, addr + length);
732 ptr = 0;
733 send_ok_msg();
734 }
735 if (ptr)
736 send_err_msg();
737 } else
738 send_err_msg();
739
740 /* Restore bus error handler */
741 kgdb_nofault = 0;
742 }
743
744 /* Continue message */
745 static void continue_msg(void)
746 {
747 /* Try to read optional parameter, PC unchanged if none */
748 char *ptr = &in_buffer[1];
749 int addr;
750
751 if (hex_to_int(&ptr, &addr))
752 trap_registers.pc = addr;
753 }
754
755 /* Continue message with signal */
756 static void continue_with_sig_msg(void)
757 {
758 int signal;
759 char *ptr = &in_buffer[1];
760 int addr;
761
762 /* Report limitation */
763 kgdb_to_gdb("Cannot force signal in kgdb, continuing anyway.\n");
764
765 /* Signal */
766 hex_to_int(&ptr, &signal);
767 if (*ptr == ';')
768 ptr++;
769
770 /* Optional address */
771 if (hex_to_int(&ptr, &addr))
772 trap_registers.pc = addr;
773 }
774
775 /* Step message */
776 static void step_msg(void)
777 {
778 continue_msg();
779 do_single_step();
780 }
781
782 /* Step message with signal */
783 static void step_with_sig_msg(void)
784 {
785 continue_with_sig_msg();
786 do_single_step();
787 }
788
789 /* Send register contents */
790 static void send_regs_msg(void)
791 {
792 kgdb_regs_to_gdb_regs(&trap_registers, registers);
793 mem_to_hex((char *) registers, out_buffer, NUMREGBYTES);
794 put_packet(out_buffer);
795 }
796
797 /* Set register contents - currently can't set other thread's registers */
798 static void set_regs_msg(void)
799 {
800 kgdb_regs_to_gdb_regs(&trap_registers, registers);
801 hex_to_mem(&in_buffer[1], (char *) registers, NUMREGBYTES);
802 gdb_regs_to_kgdb_regs(registers, &trap_registers);
803 send_ok_msg();
804 }
805
806 #ifdef CONFIG_SH_KGDB_CONSOLE
807 /*
808 * Bring up the ports..
809 */
810 static int __init kgdb_serial_setup(void)
811 {
812 struct console dummy;
813 return kgdb_console_setup(&dummy, 0);
814 }
815 #else
816 #define kgdb_serial_setup() 0
817 #endif
818
819 /* The command loop, read and act on requests */
820 static void kgdb_command_loop(const int excep_code, const int trapa_value)
821 {
822 int sigval;
823
824 /* Enter GDB mode (e.g. after detach) */
825 if (!kgdb_in_gdb_mode) {
826 /* Do serial setup, notify user, issue preemptive ack */
827 printk(KERN_NOTICE "KGDB: Waiting for GDB\n");
828 kgdb_in_gdb_mode = 1;
829 put_debug_char('+');
830 }
831
832 /* Reply to host that an exception has occurred */
833 sigval = compute_signal(excep_code);
834 send_signal_msg(sigval);
835
836 /* TRAP_VEC exception indicates a software trap inserted in place of
837 code by GDB so back up PC by one instruction, as this instruction
838 will later be replaced by its original one. Do NOT do this for
839 trap 0xff, since that indicates a compiled-in breakpoint which
840 will not be replaced (and we would retake the trap forever) */
841 if ((excep_code == TRAP_VEC) && (trapa_value != (0x3c << 2)))
842 trap_registers.pc -= 2;
843
844 /* Undo any stepping we may have done */
845 undo_single_step();
846
847 while (1) {
848 out_buffer[0] = 0;
849 get_packet(in_buffer, BUFMAX);
850
851 /* Examine first char of buffer to see what we need to do */
852 switch (in_buffer[0]) {
853 case '?': /* Send which signal we've received */
854 send_signal_msg(sigval);
855 break;
856
857 case 'g': /* Return the values of the CPU registers */
858 send_regs_msg();
859 break;
860
861 case 'G': /* Set the value of the CPU registers */
862 set_regs_msg();
863 break;
864
865 case 'm': /* Read LLLL bytes address AA..AA */
866 read_mem_msg();
867 break;
868
869 case 'M': /* Write LLLL bytes address AA..AA, ret OK */
870 write_mem_msg(0); /* 0 = data in hex */
871 break;
872
873 case 'X': /* Write LLLL bytes esc bin address AA..AA */
874 if (kgdb_bits == '8')
875 write_mem_msg(1); /* 1 = data in binary */
876 else
877 send_empty_msg();
878 break;
879
880 case 'C': /* Continue, signum included, we ignore it */
881 continue_with_sig_msg();
882 return;
883
884 case 'c': /* Continue at address AA..AA (optional) */
885 continue_msg();
886 return;
887
888 case 'S': /* Step, signum included, we ignore it */
889 step_with_sig_msg();
890 return;
891
892 case 's': /* Step one instruction from AA..AA */
893 step_msg();
894 return;
895
896 case 'k': /* 'Kill the program' with a kernel ? */
897 break;
898
899 case 'D': /* Detach from program, send reply OK */
900 kgdb_in_gdb_mode = 0;
901 send_ok_msg();
902 get_debug_char();
903 return;
904
905 default:
906 send_empty_msg();
907 break;
908 }
909 }
910 }
911
912 /* There has been an exception, most likely a breakpoint. */
913 static void handle_exception(struct pt_regs *regs)
914 {
915 int excep_code, vbr_val;
916 int count;
917 int trapa_value = ctrl_inl(TRA);
918
919 /* Copy kernel regs (from stack) */
920 for (count = 0; count < 16; count++)
921 trap_registers.regs[count] = regs->regs[count];
922 trap_registers.pc = regs->pc;
923 trap_registers.pr = regs->pr;
924 trap_registers.sr = regs->sr;
925 trap_registers.gbr = regs->gbr;
926 trap_registers.mach = regs->mach;
927 trap_registers.macl = regs->macl;
928
929 asm("stc vbr, %0":"=r"(vbr_val));
930 trap_registers.vbr = vbr_val;
931
932 /* Get excode for command loop call, user access */
933 asm("stc r2_bank, %0":"=r"(excep_code));
934
935 /* Act on the exception */
936 kgdb_command_loop(excep_code, trapa_value);
937
938 /* Copy back the (maybe modified) registers */
939 for (count = 0; count < 16; count++)
940 regs->regs[count] = trap_registers.regs[count];
941 regs->pc = trap_registers.pc;
942 regs->pr = trap_registers.pr;
943 regs->sr = trap_registers.sr;
944 regs->gbr = trap_registers.gbr;
945 regs->mach = trap_registers.mach;
946 regs->macl = trap_registers.macl;
947
948 vbr_val = trap_registers.vbr;
949 asm("ldc %0, vbr": :"r"(vbr_val));
950 }
951
952 asmlinkage void kgdb_handle_exception(unsigned long r4, unsigned long r5,
953 unsigned long r6, unsigned long r7,
954 struct pt_regs __regs)
955 {
956 struct pt_regs *regs = RELOC_HIDE(&__regs, 0);
957 handle_exception(regs);
958 }
959
960 /* Initialise the KGDB data structures and serial configuration */
961 int __init kgdb_init(void)
962 {
963 in_nmi = 0;
964 kgdb_nofault = 0;
965 stepped_opcode = 0;
966 kgdb_in_gdb_mode = 0;
967
968 if (kgdb_serial_setup() != 0) {
969 printk(KERN_NOTICE "KGDB: serial setup error\n");
970 return -1;
971 }
972
973 /* Init ptr to exception handler */
974 kgdb_debug_hook = handle_exception;
975 kgdb_bus_err_hook = kgdb_handle_bus_error;
976
977 /* Enter kgdb now if requested, or just report init done */
978 printk(KERN_NOTICE "KGDB: stub is initialized.\n");
979
980 return 0;
981 }
982
983 /* Make function available for "user messages"; console will use it too. */
984
985 char gdbmsgbuf[BUFMAX];
986 #define MAXOUT ((BUFMAX-2)/2)
987
988 static void kgdb_msg_write(const char *s, unsigned count)
989 {
990 int i;
991 int wcount;
992 char *bufptr;
993
994 /* 'O'utput */
995 gdbmsgbuf[0] = 'O';
996
997 /* Fill and send buffers... */
998 while (count > 0) {
999 bufptr = gdbmsgbuf + 1;
1000
1001 /* Calculate how many this time */
1002 wcount = (count > MAXOUT) ? MAXOUT : count;
1003
1004 /* Pack in hex chars */
1005 for (i = 0; i < wcount; i++)
1006 bufptr = pack_hex_byte(bufptr, s[i]);
1007 *bufptr = '\0';
1008
1009 /* Move up */
1010 s += wcount;
1011 count -= wcount;
1012
1013 /* Write packet */
1014 put_packet(gdbmsgbuf);
1015 }
1016 }
1017
1018 static void kgdb_to_gdb(const char *s)
1019 {
1020 kgdb_msg_write(s, strlen(s));
1021 }
1022
1023 #ifdef CONFIG_SH_KGDB_CONSOLE
1024 void kgdb_console_write(struct console *co, const char *s, unsigned count)
1025 {
1026 /* Bail if we're not talking to GDB */
1027 if (!kgdb_in_gdb_mode)
1028 return;
1029
1030 kgdb_msg_write(s, count);
1031 }
1032 #endif
1033
1034 #ifdef CONFIG_KGDB_SYSRQ
1035 static void sysrq_handle_gdb(int key, struct tty_struct *tty)
1036 {
1037 printk("Entering GDB stub\n");
1038 breakpoint();
1039 }
1040
1041 static struct sysrq_key_op sysrq_gdb_op = {
1042 .handler = sysrq_handle_gdb,
1043 .help_msg = "Gdb",
1044 .action_msg = "GDB",
1045 };
1046
1047 static int gdb_register_sysrq(void)
1048 {
1049 printk("Registering GDB sysrq handler\n");
1050 register_sysrq_key('g', &sysrq_gdb_op);
1051 return 0;
1052 }
1053 module_init(gdb_register_sysrq);
1054 #endif
Linux kernel - Deliverables
This page took 0.076443 seconds and 5 git commands to generate.