Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
gdb-stub.c
Go to the documentation of this file.
1 /* MN10300 GDB stub
2  *
3  * Originally written by Glenn Engel, Lake Stevens Instrument Division
4  *
5  * Contributed by HP Systems
6  *
7  * Modified for SPARC by Stu Grossman, Cygnus Support.
8  *
9  * Modified for Linux/MIPS (and MIPS in general) by Andreas Busse
10  * Send complaints, suggestions etc. to <[email protected]>
11  *
12  * Copyright (C) 1995 Andreas Busse
13  *
14  * Copyright (C) 2007 Red Hat, Inc. All Rights Reserved.
15  * Modified for Linux/mn10300 by David Howells <[email protected]>
16  */
17 
18 /*
19  * To enable debugger support, two things need to happen. One, a
20  * call to set_debug_traps() is necessary in order to allow any breakpoints
21  * or error conditions to be properly intercepted and reported to gdb.
22  * Two, a breakpoint needs to be generated to begin communication. This
23  * is most easily accomplished by a call to breakpoint(). Breakpoint()
24  * simulates a breakpoint by executing a BREAK instruction.
25  *
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  *
37  * c Resume at current address SNN ( signal NN)
38  * cAA..AA Continue at address AA..AA SNN
39  *
40  * s Step one instruction SNN
41  * sAA..AA Step one instruction from AA..AA SNN
42  *
43  * k kill
44  *
45  * ? What was the last sigval ? SNN (signal NN)
46  *
47  * bBB..BB Set baud rate to BB..BB OK or BNN, then sets
48  * baud rate
49  *
50  * All commands and responses are sent with a packet which includes a
51  * checksum. A packet consists of
52  *
53  * $<packet info>#<checksum>.
54  *
55  * where
56  * <packet info> :: <characters representing the command or response>
57  * <checksum> :: < two hex digits computed as modulo 256 sum of <packetinfo>>
58  *
59  * When a packet is received, it is first acknowledged with either '+' or '-'.
60  * '+' indicates a successful transfer. '-' indicates a failed transfer.
61  *
62  * Example:
63  *
64  * Host: Reply:
65  * $m0,10#2a +$00010203040506070809101112131415#42
66  *
67  *
68  * ==============
69  * MORE EXAMPLES:
70  * ==============
71  *
72  * For reference -- the following are the steps that one
73  * company took (RidgeRun Inc) to get remote gdb debugging
74  * going. In this scenario the host machine was a PC and the
75  * target platform was a Galileo EVB64120A MIPS evaluation
76  * board.
77  *
78  * Step 1:
79  * First download gdb-5.0.tar.gz from the internet.
80  * and then build/install the package.
81  *
82  * Example:
83  * $ tar zxf gdb-5.0.tar.gz
84  * $ cd gdb-5.0
85  * $ ./configure --target=am33_2.0-linux-gnu
86  * $ make
87  * $ install
88  * am33_2.0-linux-gnu-gdb
89  *
90  * Step 2:
91  * Configure linux for remote debugging and build it.
92  *
93  * Example:
94  * $ cd ~/linux
95  * $ make menuconfig <go to "Kernel Hacking" and turn on remote debugging>
96  * $ make dep; make vmlinux
97  *
98  * Step 3:
99  * Download the kernel to the remote target and start
100  * the kernel running. It will promptly halt and wait
101  * for the host gdb session to connect. It does this
102  * since the "Kernel Hacking" option has defined
103  * CONFIG_REMOTE_DEBUG which in turn enables your calls
104  * to:
105  * set_debug_traps();
106  * breakpoint();
107  *
108  * Step 4:
109  * Start the gdb session on the host.
110  *
111  * Example:
112  * $ am33_2.0-linux-gnu-gdb vmlinux
113  * (gdb) set remotebaud 115200
114  * (gdb) target remote /dev/ttyS1
115  * ...at this point you are connected to
116  * the remote target and can use gdb
117  * in the normal fasion. Setting
118  * breakpoints, single stepping,
119  * printing variables, etc.
120  *
121  */
122 
123 #include <linux/string.h>
124 #include <linux/kernel.h>
125 #include <linux/signal.h>
126 #include <linux/sched.h>
127 #include <linux/mm.h>
128 #include <linux/console.h>
129 #include <linux/init.h>
130 #include <linux/bug.h>
131 
132 #include <asm/pgtable.h>
133 #include <asm/gdb-stub.h>
134 #include <asm/exceptions.h>
135 #include <asm/debugger.h>
136 #include <asm/serial-regs.h>
137 #include <asm/busctl-regs.h>
138 #include <unit/leds.h>
139 #include <unit/serial.h>
140 
141 /* define to use F7F7 rather than FF which is subverted by JTAG debugger */
142 #undef GDBSTUB_USE_F7F7_AS_BREAKPOINT
143 
144 /*
145  * BUFMAX defines the maximum number of characters in inbound/outbound buffers
146  * at least NUMREGBYTES*2 are needed for register packets
147  */
148 #define BUFMAX 2048
149 
150 static const char gdbstub_banner[] =
151  "Linux/MN10300 GDB Stub (c) RedHat 2007\n";
152 
159 
160 static u8 gdbstub_flush_caches;
161 static char input_buffer[BUFMAX];
162 static char output_buffer[BUFMAX];
163 static char trans_buffer[BUFMAX];
164 
165 struct gdbstub_bkpt {
166  u8 *addr; /* address of breakpoint */
167  u8 len; /* size of breakpoint */
168  u8 origbytes[7]; /* original bytes */
169 };
170 
171 static struct gdbstub_bkpt gdbstub_bkpts[256];
172 
173 /*
174  * local prototypes
175  */
176 static void getpacket(char *buffer);
177 static int putpacket(char *buffer);
178 static int computeSignal(enum exception_code excep);
179 static int hex(unsigned char ch);
180 static int hexToInt(char **ptr, int *intValue);
181 static unsigned char *mem2hex(const void *mem, char *buf, int count,
182  int may_fault);
183 static const char *hex2mem(const char *buf, void *_mem, int count,
184  int may_fault);
185 
186 /*
187  * Convert ch from a hex digit to an int
188  */
189 static int hex(unsigned char ch)
190 {
191  if (ch >= 'a' && ch <= 'f')
192  return ch - 'a' + 10;
193  if (ch >= '0' && ch <= '9')
194  return ch - '0';
195  if (ch >= 'A' && ch <= 'F')
196  return ch - 'A' + 10;
197  return -1;
198 }
199 
200 #ifdef CONFIG_GDBSTUB_DEBUGGING
201 
202 void debug_to_serial(const char *p, int n)
203 {
204  __debug_to_serial(p, n);
205  /* gdbstub_console_write(NULL, p, n); */
206 }
207 
208 void gdbstub_printk(const char *fmt, ...)
209 {
210  va_list args;
211  int len;
212 
213  /* Emit the output into the temporary buffer */
214  va_start(args, fmt);
215  len = vsnprintf(trans_buffer, sizeof(trans_buffer), fmt, args);
216  va_end(args);
217  debug_to_serial(trans_buffer, len);
218 }
219 
220 #endif
221 
222 static inline char *gdbstub_strcpy(char *dst, const char *src)
223 {
224  int loop = 0;
225  while ((dst[loop] = src[loop]))
226  loop++;
227  return dst;
228 }
229 
230 /*
231  * scan for the sequence $<data>#<checksum>
232  */
233 static void getpacket(char *buffer)
234 {
235  unsigned char checksum;
236  unsigned char xmitcsum;
237  unsigned char ch;
238  int count, i, ret, error;
239 
240  for (;;) {
241  /*
242  * wait around for the start character,
243  * ignore all other characters
244  */
245  do {
246  gdbstub_io_rx_char(&ch, 0);
247  } while (ch != '$');
248 
249  checksum = 0;
250  xmitcsum = -1;
251  count = 0;
252  error = 0;
253 
254  /*
255  * now, read until a # or end of buffer is found
256  */
257  while (count < BUFMAX) {
258  ret = gdbstub_io_rx_char(&ch, 0);
259  if (ret < 0)
260  error = ret;
261 
262  if (ch == '#')
263  break;
264  checksum += ch;
265  buffer[count] = ch;
266  count++;
267  }
268 
269  if (error == -EIO) {
270  gdbstub_proto("### GDB Rx Error - Skipping packet"
271  " ###\n");
272  gdbstub_proto("### GDB Tx NAK\n");
273  gdbstub_io_tx_char('-');
274  continue;
275  }
276 
277  if (count >= BUFMAX || error)
278  continue;
279 
280  buffer[count] = 0;
281 
282  /* read the checksum */
283  ret = gdbstub_io_rx_char(&ch, 0);
284  if (ret < 0)
285  error = ret;
286  xmitcsum = hex(ch) << 4;
287 
288  ret = gdbstub_io_rx_char(&ch, 0);
289  if (ret < 0)
290  error = ret;
291  xmitcsum |= hex(ch);
292 
293  if (error) {
294  if (error == -EIO)
295  gdbstub_io("### GDB Rx Error -"
296  " Skipping packet\n");
297  gdbstub_io("### GDB Tx NAK\n");
298  gdbstub_io_tx_char('-');
299  continue;
300  }
301 
302  /* check the checksum */
303  if (checksum != xmitcsum) {
304  gdbstub_io("### GDB Tx NAK\n");
305  gdbstub_io_tx_char('-'); /* failed checksum */
306  continue;
307  }
308 
309  gdbstub_proto("### GDB Rx '$%s#%02x' ###\n", buffer, checksum);
310  gdbstub_io("### GDB Tx ACK\n");
311  gdbstub_io_tx_char('+'); /* successful transfer */
312 
313  /*
314  * if a sequence char is present,
315  * reply the sequence ID
316  */
317  if (buffer[2] == ':') {
318  gdbstub_io_tx_char(buffer[0]);
319  gdbstub_io_tx_char(buffer[1]);
320 
321  /*
322  * remove sequence chars from buffer
323  */
324  count = 0;
325  while (buffer[count])
326  count++;
327  for (i = 3; i <= count; i++)
328  buffer[i - 3] = buffer[i];
329  }
330 
331  break;
332  }
333 }
334 
335 /*
336  * send the packet in buffer.
337  * - return 0 if successfully ACK'd
338  * - return 1 if abandoned due to new incoming packet
339  */
340 static int putpacket(char *buffer)
341 {
342  unsigned char checksum;
343  unsigned char ch;
344  int count;
345 
346  /*
347  * $<packet info>#<checksum>.
348  */
349  gdbstub_proto("### GDB Tx $'%s'#?? ###\n", buffer);
350 
351  do {
352  gdbstub_io_tx_char('$');
353  checksum = 0;
354  count = 0;
355 
356  while ((ch = buffer[count]) != 0) {
357  gdbstub_io_tx_char(ch);
358  checksum += ch;
359  count += 1;
360  }
361 
362  gdbstub_io_tx_char('#');
363  gdbstub_io_tx_char(hex_asc_hi(checksum));
364  gdbstub_io_tx_char(hex_asc_lo(checksum));
365 
366  } while (gdbstub_io_rx_char(&ch, 0),
367  ch == '-' && (gdbstub_io("### GDB Rx NAK\n"), 0),
368  ch != '-' && ch != '+' &&
369  (gdbstub_io("### GDB Rx ??? %02x\n", ch), 0),
370  ch != '+' && ch != '$');
371 
372  if (ch == '+') {
373  gdbstub_io("### GDB Rx ACK\n");
374  return 0;
375  }
376 
377  gdbstub_io("### GDB Tx Abandoned\n");
378  gdbstub_rx_unget = ch;
379  return 1;
380 }
381 
382 /*
383  * While we find nice hex chars, build an int.
384  * Return number of chars processed.
385  */
386 static int hexToInt(char **ptr, int *intValue)
387 {
388  int numChars = 0;
389  int hexValue;
390 
391  *intValue = 0;
392 
393  while (**ptr) {
394  hexValue = hex(**ptr);
395  if (hexValue < 0)
396  break;
397 
398  *intValue = (*intValue << 4) | hexValue;
399  numChars++;
400 
401  (*ptr)++;
402  }
403 
404  return (numChars);
405 }
406 
407 #ifdef CONFIG_GDBSTUB_ALLOW_SINGLE_STEP
408 /*
409  * We single-step by setting breakpoints. When an exception
410  * is handled, we need to restore the instructions hoisted
411  * when the breakpoints were set.
412  *
413  * This is where we save the original instructions.
414  */
415 static struct gdb_bp_save {
416  u8 *addr;
417  u8 opcode[2];
418 } step_bp[2];
419 
420 static const unsigned char gdbstub_insn_sizes[256] =
421 {
422  /* 1 2 3 4 5 6 7 8 9 a b c d e f */
423  1, 3, 3, 3, 1, 3, 3, 3, 1, 3, 3, 3, 1, 3, 3, 3, /* 0 */
424  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 1 */
425  2, 2, 2, 2, 3, 3, 3, 3, 2, 2, 2, 2, 3, 3, 3, 3, /* 2 */
426  3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 1, 1, 1, 1, /* 3 */
427  1, 1, 2, 2, 1, 1, 2, 2, 1, 1, 2, 2, 1, 1, 2, 2, /* 4 */
428  1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, /* 5 */
429  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 6 */
430  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 7 */
431  2, 1, 1, 1, 1, 2, 1, 1, 1, 1, 2, 1, 1, 1, 1, 2, /* 8 */
432  2, 1, 1, 1, 1, 2, 1, 1, 1, 1, 2, 1, 1, 1, 1, 2, /* 9 */
433  2, 1, 1, 1, 1, 2, 1, 1, 1, 1, 2, 1, 1, 1, 1, 2, /* a */
434  2, 1, 1, 1, 1, 2, 1, 1, 1, 1, 2, 1, 1, 1, 1, 2, /* b */
435  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 2, 2, /* c */
436  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* d */
437  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* e */
438  0, 2, 2, 2, 2, 2, 2, 4, 0, 3, 0, 4, 0, 6, 7, 1 /* f */
439 };
440 
441 static int __gdbstub_mark_bp(u8 *addr, int ix)
442 {
443  /* vmalloc area */
444  if (((u8 *) VMALLOC_START <= addr) && (addr < (u8 *) VMALLOC_END))
445  goto okay;
446  /* SRAM, SDRAM */
447  if (((u8 *) 0x80000000UL <= addr) && (addr < (u8 *) 0xa0000000UL))
448  goto okay;
449  return 0;
450 
451 okay:
452  if (gdbstub_read_byte(addr + 0, &step_bp[ix].opcode[0]) < 0 ||
453  gdbstub_read_byte(addr + 1, &step_bp[ix].opcode[1]) < 0)
454  return 0;
455 
456  step_bp[ix].addr = addr;
457  return 1;
458 }
459 
460 static inline void __gdbstub_restore_bp(void)
461 {
462 #ifdef GDBSTUB_USE_F7F7_AS_BREAKPOINT
463  if (step_bp[0].addr) {
464  gdbstub_write_byte(step_bp[0].opcode[0], step_bp[0].addr + 0);
465  gdbstub_write_byte(step_bp[0].opcode[1], step_bp[0].addr + 1);
466  }
467  if (step_bp[1].addr) {
468  gdbstub_write_byte(step_bp[1].opcode[0], step_bp[1].addr + 0);
469  gdbstub_write_byte(step_bp[1].opcode[1], step_bp[1].addr + 1);
470  }
471 #else
472  if (step_bp[0].addr)
473  gdbstub_write_byte(step_bp[0].opcode[0], step_bp[0].addr + 0);
474  if (step_bp[1].addr)
475  gdbstub_write_byte(step_bp[1].opcode[0], step_bp[1].addr + 0);
476 #endif
477 
478  gdbstub_flush_caches = 1;
479 
480  step_bp[0].addr = NULL;
481  step_bp[0].opcode[0] = 0;
482  step_bp[0].opcode[1] = 0;
483  step_bp[1].addr = NULL;
484  step_bp[1].opcode[0] = 0;
485  step_bp[1].opcode[1] = 0;
486 }
487 
488 /*
489  * emulate single stepping by means of breakpoint instructions
490  */
491 static int gdbstub_single_step(struct pt_regs *regs)
492 {
493  unsigned size;
494  uint32_t x;
495  uint8_t cur, *pc, *sp;
496 
497  step_bp[0].addr = NULL;
498  step_bp[0].opcode[0] = 0;
499  step_bp[0].opcode[1] = 0;
500  step_bp[1].addr = NULL;
501  step_bp[1].opcode[0] = 0;
502  step_bp[1].opcode[1] = 0;
503  x = 0;
504 
505  pc = (u8 *) regs->pc;
506  sp = (u8 *) (regs + 1);
507  if (gdbstub_read_byte(pc, &cur) < 0)
508  return -EFAULT;
509 
510  gdbstub_bkpt("Single Step from %p { %02x }\n", pc, cur);
511 
512  gdbstub_flush_caches = 1;
513 
514  size = gdbstub_insn_sizes[cur];
515  if (size > 0) {
516  if (!__gdbstub_mark_bp(pc + size, 0))
517  goto fault;
518  } else {
519  switch (cur) {
520  /* Bxx (d8,PC) */
521  case 0xc0 ... 0xca:
522  if (gdbstub_read_byte(pc + 1, (u8 *) &x) < 0)
523  goto fault;
524  if (!__gdbstub_mark_bp(pc + 2, 0))
525  goto fault;
526  if ((x < 0 || x > 2) &&
527  !__gdbstub_mark_bp(pc + (s8) x, 1))
528  goto fault;
529  break;
530 
531  /* LXX (d8,PC) */
532  case 0xd0 ... 0xda:
533  if (!__gdbstub_mark_bp(pc + 1, 0))
534  goto fault;
535  if (regs->pc != regs->lar &&
536  !__gdbstub_mark_bp((u8 *) regs->lar, 1))
537  goto fault;
538  break;
539 
540  /* SETLB - loads the next for bytes into the LIR
541  * register */
542  case 0xdb:
543  if (!__gdbstub_mark_bp(pc + 1, 0))
544  goto fault;
545  break;
546 
547  /* JMP (d16,PC) or CALL (d16,PC) */
548  case 0xcc:
549  case 0xcd:
550  if (gdbstub_read_byte(pc + 1, ((u8 *) &x) + 0) < 0 ||
551  gdbstub_read_byte(pc + 2, ((u8 *) &x) + 1) < 0)
552  goto fault;
553  if (!__gdbstub_mark_bp(pc + (s16) x, 0))
554  goto fault;
555  break;
556 
557  /* JMP (d32,PC) or CALL (d32,PC) */
558  case 0xdc:
559  case 0xdd:
560  if (gdbstub_read_byte(pc + 1, ((u8 *) &x) + 0) < 0 ||
561  gdbstub_read_byte(pc + 2, ((u8 *) &x) + 1) < 0 ||
562  gdbstub_read_byte(pc + 3, ((u8 *) &x) + 2) < 0 ||
563  gdbstub_read_byte(pc + 4, ((u8 *) &x) + 3) < 0)
564  goto fault;
565  if (!__gdbstub_mark_bp(pc + (s32) x, 0))
566  goto fault;
567  break;
568 
569  /* RETF */
570  case 0xde:
571  if (!__gdbstub_mark_bp((u8 *) regs->mdr, 0))
572  goto fault;
573  break;
574 
575  /* RET */
576  case 0xdf:
577  if (gdbstub_read_byte(pc + 2, (u8 *) &x) < 0)
578  goto fault;
579  sp += (s8)x;
580  if (gdbstub_read_byte(sp + 0, ((u8 *) &x) + 0) < 0 ||
581  gdbstub_read_byte(sp + 1, ((u8 *) &x) + 1) < 0 ||
582  gdbstub_read_byte(sp + 2, ((u8 *) &x) + 2) < 0 ||
583  gdbstub_read_byte(sp + 3, ((u8 *) &x) + 3) < 0)
584  goto fault;
585  if (!__gdbstub_mark_bp((u8 *) x, 0))
586  goto fault;
587  break;
588 
589  case 0xf0:
590  if (gdbstub_read_byte(pc + 1, &cur) < 0)
591  goto fault;
592 
593  if (cur >= 0xf0 && cur <= 0xf7) {
594  /* JMP (An) / CALLS (An) */
595  switch (cur & 3) {
596  case 0: x = regs->a0; break;
597  case 1: x = regs->a1; break;
598  case 2: x = regs->a2; break;
599  case 3: x = regs->a3; break;
600  }
601  if (!__gdbstub_mark_bp((u8 *) x, 0))
602  goto fault;
603  } else if (cur == 0xfc) {
604  /* RETS */
605  if (gdbstub_read_byte(
606  sp + 0, ((u8 *) &x) + 0) < 0 ||
608  sp + 1, ((u8 *) &x) + 1) < 0 ||
610  sp + 2, ((u8 *) &x) + 2) < 0 ||
612  sp + 3, ((u8 *) &x) + 3) < 0)
613  goto fault;
614  if (!__gdbstub_mark_bp((u8 *) x, 0))
615  goto fault;
616  } else if (cur == 0xfd) {
617  /* RTI */
618  if (gdbstub_read_byte(
619  sp + 4, ((u8 *) &x) + 0) < 0 ||
621  sp + 5, ((u8 *) &x) + 1) < 0 ||
623  sp + 6, ((u8 *) &x) + 2) < 0 ||
625  sp + 7, ((u8 *) &x) + 3) < 0)
626  goto fault;
627  if (!__gdbstub_mark_bp((u8 *) x, 0))
628  goto fault;
629  } else {
630  if (!__gdbstub_mark_bp(pc + 2, 0))
631  goto fault;
632  }
633 
634  break;
635 
636  /* potential 3-byte conditional branches */
637  case 0xf8:
638  if (gdbstub_read_byte(pc + 1, &cur) < 0)
639  goto fault;
640  if (!__gdbstub_mark_bp(pc + 3, 0))
641  goto fault;
642 
643  if (cur >= 0xe8 && cur <= 0xeb) {
644  if (gdbstub_read_byte(
645  pc + 2, ((u8 *) &x) + 0) < 0)
646  goto fault;
647  if ((x < 0 || x > 3) &&
648  !__gdbstub_mark_bp(pc + (s8) x, 1))
649  goto fault;
650  }
651  break;
652 
653  case 0xfa:
654  if (gdbstub_read_byte(pc + 1, &cur) < 0)
655  goto fault;
656 
657  if (cur == 0xff) {
658  /* CALLS (d16,PC) */
659  if (gdbstub_read_byte(
660  pc + 2, ((u8 *) &x) + 0) < 0 ||
662  pc + 3, ((u8 *) &x) + 1) < 0)
663  goto fault;
664  if (!__gdbstub_mark_bp(pc + (s16) x, 0))
665  goto fault;
666  } else {
667  if (!__gdbstub_mark_bp(pc + 4, 0))
668  goto fault;
669  }
670  break;
671 
672  case 0xfc:
673  if (gdbstub_read_byte(pc + 1, &cur) < 0)
674  goto fault;
675  if (cur == 0xff) {
676  /* CALLS (d32,PC) */
677  if (gdbstub_read_byte(
678  pc + 2, ((u8 *) &x) + 0) < 0 ||
680  pc + 3, ((u8 *) &x) + 1) < 0 ||
682  pc + 4, ((u8 *) &x) + 2) < 0 ||
684  pc + 5, ((u8 *) &x) + 3) < 0)
685  goto fault;
686  if (!__gdbstub_mark_bp(
687  pc + (s32) x, 0))
688  goto fault;
689  } else {
690  if (!__gdbstub_mark_bp(
691  pc + 6, 0))
692  goto fault;
693  }
694  break;
695 
696  }
697  }
698 
699  gdbstub_bkpt("Step: %02x at %p; %02x at %p\n",
700  step_bp[0].opcode[0], step_bp[0].addr,
701  step_bp[1].opcode[0], step_bp[1].addr);
702 
703  if (step_bp[0].addr) {
704 #ifdef GDBSTUB_USE_F7F7_AS_BREAKPOINT
705  if (gdbstub_write_byte(0xF7, step_bp[0].addr + 0) < 0 ||
706  gdbstub_write_byte(0xF7, step_bp[0].addr + 1) < 0)
707  goto fault;
708 #else
709  if (gdbstub_write_byte(0xFF, step_bp[0].addr + 0) < 0)
710  goto fault;
711 #endif
712  }
713 
714  if (step_bp[1].addr) {
715 #ifdef GDBSTUB_USE_F7F7_AS_BREAKPOINT
716  if (gdbstub_write_byte(0xF7, step_bp[1].addr + 0) < 0 ||
717  gdbstub_write_byte(0xF7, step_bp[1].addr + 1) < 0)
718  goto fault;
719 #else
720  if (gdbstub_write_byte(0xFF, step_bp[1].addr + 0) < 0)
721  goto fault;
722 #endif
723  }
724 
725  return 0;
726 
727  fault:
728  /* uh-oh - silly address alert, try and restore things */
729  __gdbstub_restore_bp();
730  return -EFAULT;
731 }
732 #endif /* CONFIG_GDBSTUB_ALLOW_SINGLE_STEP */
733 
734 #ifdef CONFIG_GDBSTUB_CONSOLE
735 
736 void gdbstub_console_write(struct console *con, const char *p, unsigned n)
737 {
738  static const char gdbstub_cr[] = { 0x0d };
739  char outbuf[26];
740  int qty;
741  u8 busy;
742 
743  busy = gdbstub_busy;
744  gdbstub_busy = 1;
745 
746  outbuf[0] = 'O';
747 
748  while (n > 0) {
749  qty = 1;
750 
751  while (n > 0 && qty < 20) {
752  mem2hex(p, outbuf + qty, 2, 0);
753  qty += 2;
754  if (*p == 0x0a) {
755  mem2hex(gdbstub_cr, outbuf + qty, 2, 0);
756  qty += 2;
757  }
758  p++;
759  n--;
760  }
761 
762  outbuf[qty] = 0;
763  putpacket(outbuf);
764  }
765 
766  gdbstub_busy = busy;
767 }
768 
769 static kdev_t gdbstub_console_dev(struct console *con)
770 {
771  return MKDEV(1, 3); /* /dev/null */
772 }
773 
774 static struct console gdbstub_console = {
775  .name = "gdb",
776  .write = gdbstub_console_write,
777  .device = gdbstub_console_dev,
778  .flags = CON_PRINTBUFFER,
779  .index = -1,
780 };
781 
782 #endif
783 
784 /*
785  * Convert the memory pointed to by mem into hex, placing result in buf.
786  * - if successful, return a pointer to the last char put in buf (NUL)
787  * - in case of mem fault, return NULL
788  * may_fault is non-zero if we are reading from arbitrary memory, but is
789  * currently not used.
790  */
791 static
792 unsigned char *mem2hex(const void *_mem, char *buf, int count, int may_fault)
793 {
794  const u8 *mem = _mem;
795  u8 ch[4];
796 
797  if ((u32) mem & 1 && count >= 1) {
798  if (gdbstub_read_byte(mem, ch) != 0)
799  return 0;
800  buf = hex_byte_pack(buf, ch[0]);
801  mem++;
802  count--;
803  }
804 
805  if ((u32) mem & 3 && count >= 2) {
806  if (gdbstub_read_word(mem, ch) != 0)
807  return 0;
808  buf = hex_byte_pack(buf, ch[0]);
809  buf = hex_byte_pack(buf, ch[1]);
810  mem += 2;
811  count -= 2;
812  }
813 
814  while (count >= 4) {
815  if (gdbstub_read_dword(mem, ch) != 0)
816  return 0;
817  buf = hex_byte_pack(buf, ch[0]);
818  buf = hex_byte_pack(buf, ch[1]);
819  buf = hex_byte_pack(buf, ch[2]);
820  buf = hex_byte_pack(buf, ch[3]);
821  mem += 4;
822  count -= 4;
823  }
824 
825  if (count >= 2) {
826  if (gdbstub_read_word(mem, ch) != 0)
827  return 0;
828  buf = hex_byte_pack(buf, ch[0]);
829  buf = hex_byte_pack(buf, ch[1]);
830  mem += 2;
831  count -= 2;
832  }
833 
834  if (count >= 1) {
835  if (gdbstub_read_byte(mem, ch) != 0)
836  return 0;
837  buf = hex_byte_pack(buf, ch[0]);
838  }
839 
840  *buf = 0;
841  return buf;
842 }
843 
844 /*
845  * convert the hex array pointed to by buf into binary to be placed in mem
846  * return a pointer to the character AFTER the last byte written
847  * may_fault is non-zero if we are reading from arbitrary memory, but is
848  * currently not used.
849  */
850 static
851 const char *hex2mem(const char *buf, void *_mem, int count, int may_fault)
852 {
853  u8 *mem = _mem;
854  union {
855  u32 val;
856  u8 b[4];
857  } ch;
858 
859  if ((u32) mem & 1 && count >= 1) {
860  ch.b[0] = hex(*buf++) << 4;
861  ch.b[0] |= hex(*buf++);
862  if (gdbstub_write_byte(ch.val, mem) != 0)
863  return 0;
864  mem++;
865  count--;
866  }
867 
868  if ((u32) mem & 3 && count >= 2) {
869  ch.b[0] = hex(*buf++) << 4;
870  ch.b[0] |= hex(*buf++);
871  ch.b[1] = hex(*buf++) << 4;
872  ch.b[1] |= hex(*buf++);
873  if (gdbstub_write_word(ch.val, mem) != 0)
874  return 0;
875  mem += 2;
876  count -= 2;
877  }
878 
879  while (count >= 4) {
880  ch.b[0] = hex(*buf++) << 4;
881  ch.b[0] |= hex(*buf++);
882  ch.b[1] = hex(*buf++) << 4;
883  ch.b[1] |= hex(*buf++);
884  ch.b[2] = hex(*buf++) << 4;
885  ch.b[2] |= hex(*buf++);
886  ch.b[3] = hex(*buf++) << 4;
887  ch.b[3] |= hex(*buf++);
888  if (gdbstub_write_dword(ch.val, mem) != 0)
889  return 0;
890  mem += 4;
891  count -= 4;
892  }
893 
894  if (count >= 2) {
895  ch.b[0] = hex(*buf++) << 4;
896  ch.b[0] |= hex(*buf++);
897  ch.b[1] = hex(*buf++) << 4;
898  ch.b[1] |= hex(*buf++);
899  if (gdbstub_write_word(ch.val, mem) != 0)
900  return 0;
901  mem += 2;
902  count -= 2;
903  }
904 
905  if (count >= 1) {
906  ch.b[0] = hex(*buf++) << 4;
907  ch.b[0] |= hex(*buf++);
908  if (gdbstub_write_byte(ch.val, mem) != 0)
909  return 0;
910  }
911 
912  return buf;
913 }
914 
915 /*
916  * This table contains the mapping between MN10300 exception codes, and
917  * signals, which are primarily what GDB understands. It also indicates
918  * which hardware traps we need to commandeer when initializing the stub.
919  */
920 static const struct excep_to_sig_map {
921  enum exception_code excep; /* MN10300 exception code */
922  unsigned char signo; /* Signal that we map this into */
923 } excep_to_sig_map[] = {
924  { EXCEP_ITLBMISS, SIGSEGV },
925  { EXCEP_DTLBMISS, SIGSEGV },
926  { EXCEP_TRAP, SIGTRAP },
927  { EXCEP_ISTEP, SIGTRAP },
928  { EXCEP_IBREAK, SIGTRAP },
929  { EXCEP_OBREAK, SIGTRAP },
930  { EXCEP_UNIMPINS, SIGILL },
932  { EXCEP_MEMERR, SIGSEGV },
933  { EXCEP_MISALIGN, SIGSEGV },
934  { EXCEP_BUSERROR, SIGBUS },
937  { EXCEP_IOINSACC, SIGSEGV },
943  { EXCEP_WDT, SIGALRM },
944  { EXCEP_NMI, SIGQUIT },
952  { 0, 0}
953 };
954 
955 /*
956  * convert the MN10300 exception code into a UNIX signal number
957  */
958 static int computeSignal(enum exception_code excep)
959 {
960  const struct excep_to_sig_map *map;
961 
962  for (map = excep_to_sig_map; map->signo; map++)
963  if (map->excep == excep)
964  return map->signo;
965 
966  return SIGHUP; /* default for things we don't know about */
967 }
968 
969 static u32 gdbstub_fpcr, gdbstub_fpufs_array[32];
970 
971 /*
972  *
973  */
974 static void gdbstub_store_fpu(void)
975 {
976 #ifdef CONFIG_FPU
977 
978  asm volatile(
979  "or %2,epsw\n"
980 #ifdef CONFIG_MN10300_PROC_MN103E010
981  "nop\n"
982  "nop\n"
983 #endif
984  "mov %1, a1\n"
985  "fmov fs0, (a1+)\n"
986  "fmov fs1, (a1+)\n"
987  "fmov fs2, (a1+)\n"
988  "fmov fs3, (a1+)\n"
989  "fmov fs4, (a1+)\n"
990  "fmov fs5, (a1+)\n"
991  "fmov fs6, (a1+)\n"
992  "fmov fs7, (a1+)\n"
993  "fmov fs8, (a1+)\n"
994  "fmov fs9, (a1+)\n"
995  "fmov fs10, (a1+)\n"
996  "fmov fs11, (a1+)\n"
997  "fmov fs12, (a1+)\n"
998  "fmov fs13, (a1+)\n"
999  "fmov fs14, (a1+)\n"
1000  "fmov fs15, (a1+)\n"
1001  "fmov fs16, (a1+)\n"
1002  "fmov fs17, (a1+)\n"
1003  "fmov fs18, (a1+)\n"
1004  "fmov fs19, (a1+)\n"
1005  "fmov fs20, (a1+)\n"
1006  "fmov fs21, (a1+)\n"
1007  "fmov fs22, (a1+)\n"
1008  "fmov fs23, (a1+)\n"
1009  "fmov fs24, (a1+)\n"
1010  "fmov fs25, (a1+)\n"
1011  "fmov fs26, (a1+)\n"
1012  "fmov fs27, (a1+)\n"
1013  "fmov fs28, (a1+)\n"
1014  "fmov fs29, (a1+)\n"
1015  "fmov fs30, (a1+)\n"
1016  "fmov fs31, (a1+)\n"
1017  "fmov fpcr, %0\n"
1018  : "=d"(gdbstub_fpcr)
1019  : "g" (&gdbstub_fpufs_array), "i"(EPSW_FE)
1020  : "a1"
1021  );
1022 #endif
1023 }
1024 
1025 /*
1026  *
1027  */
1028 static void gdbstub_load_fpu(void)
1029 {
1030 #ifdef CONFIG_FPU
1031 
1032  asm volatile(
1033  "or %1,epsw\n"
1034 #ifdef CONFIG_MN10300_PROC_MN103E010
1035  "nop\n"
1036  "nop\n"
1037 #endif
1038  "mov %0, a1\n"
1039  "fmov (a1+), fs0\n"
1040  "fmov (a1+), fs1\n"
1041  "fmov (a1+), fs2\n"
1042  "fmov (a1+), fs3\n"
1043  "fmov (a1+), fs4\n"
1044  "fmov (a1+), fs5\n"
1045  "fmov (a1+), fs6\n"
1046  "fmov (a1+), fs7\n"
1047  "fmov (a1+), fs8\n"
1048  "fmov (a1+), fs9\n"
1049  "fmov (a1+), fs10\n"
1050  "fmov (a1+), fs11\n"
1051  "fmov (a1+), fs12\n"
1052  "fmov (a1+), fs13\n"
1053  "fmov (a1+), fs14\n"
1054  "fmov (a1+), fs15\n"
1055  "fmov (a1+), fs16\n"
1056  "fmov (a1+), fs17\n"
1057  "fmov (a1+), fs18\n"
1058  "fmov (a1+), fs19\n"
1059  "fmov (a1+), fs20\n"
1060  "fmov (a1+), fs21\n"
1061  "fmov (a1+), fs22\n"
1062  "fmov (a1+), fs23\n"
1063  "fmov (a1+), fs24\n"
1064  "fmov (a1+), fs25\n"
1065  "fmov (a1+), fs26\n"
1066  "fmov (a1+), fs27\n"
1067  "fmov (a1+), fs28\n"
1068  "fmov (a1+), fs29\n"
1069  "fmov (a1+), fs30\n"
1070  "fmov (a1+), fs31\n"
1071  "fmov %2, fpcr\n"
1072  :
1073  : "g" (&gdbstub_fpufs_array), "i"(EPSW_FE), "d"(gdbstub_fpcr)
1074  : "a1"
1075  );
1076 #endif
1077 }
1078 
1079 /*
1080  * set a software breakpoint
1081  */
1082 int gdbstub_set_breakpoint(u8 *addr, int len)
1083 {
1084  int bkpt, loop, xloop;
1085 
1086 #ifdef GDBSTUB_USE_F7F7_AS_BREAKPOINT
1087  len = (len + 1) & ~1;
1088 #endif
1089 
1090  gdbstub_bkpt("setbkpt(%p,%d)\n", addr, len);
1091 
1092  for (bkpt = 255; bkpt >= 0; bkpt--)
1093  if (!gdbstub_bkpts[bkpt].addr)
1094  break;
1095  if (bkpt < 0)
1096  return -ENOSPC;
1097 
1098  for (loop = 0; loop < len; loop++)
1099  if (gdbstub_read_byte(&addr[loop],
1100  &gdbstub_bkpts[bkpt].origbytes[loop]
1101  ) < 0)
1102  return -EFAULT;
1103 
1104  gdbstub_flush_caches = 1;
1105 
1106 #ifdef GDBSTUB_USE_F7F7_AS_BREAKPOINT
1107  for (loop = 0; loop < len; loop++)
1108  if (gdbstub_write_byte(0xF7, &addr[loop]) < 0)
1109  goto restore;
1110 #else
1111  for (loop = 0; loop < len; loop++)
1112  if (gdbstub_write_byte(0xFF, &addr[loop]) < 0)
1113  goto restore;
1114 #endif
1115 
1116  gdbstub_bkpts[bkpt].addr = addr;
1117  gdbstub_bkpts[bkpt].len = len;
1118 
1119  gdbstub_bkpt("Set BKPT[%02x]: %p-%p {%02x%02x%02x%02x%02x%02x%02x}\n",
1120  bkpt,
1121  gdbstub_bkpts[bkpt].addr,
1122  gdbstub_bkpts[bkpt].addr + gdbstub_bkpts[bkpt].len - 1,
1123  gdbstub_bkpts[bkpt].origbytes[0],
1124  gdbstub_bkpts[bkpt].origbytes[1],
1125  gdbstub_bkpts[bkpt].origbytes[2],
1126  gdbstub_bkpts[bkpt].origbytes[3],
1127  gdbstub_bkpts[bkpt].origbytes[4],
1128  gdbstub_bkpts[bkpt].origbytes[5],
1129  gdbstub_bkpts[bkpt].origbytes[6]
1130  );
1131 
1132  return 0;
1133 
1134 restore:
1135  for (xloop = 0; xloop < loop; xloop++)
1136  gdbstub_write_byte(gdbstub_bkpts[bkpt].origbytes[xloop],
1137  addr + xloop);
1138  return -EFAULT;
1139 }
1140 
1141 /*
1142  * clear a software breakpoint
1143  */
1144 int gdbstub_clear_breakpoint(u8 *addr, int len)
1145 {
1146  int bkpt, loop;
1147 
1148 #ifdef GDBSTUB_USE_F7F7_AS_BREAKPOINT
1149  len = (len + 1) & ~1;
1150 #endif
1151 
1152  gdbstub_bkpt("clearbkpt(%p,%d)\n", addr, len);
1153 
1154  for (bkpt = 255; bkpt >= 0; bkpt--)
1155  if (gdbstub_bkpts[bkpt].addr == addr &&
1156  gdbstub_bkpts[bkpt].len == len)
1157  break;
1158  if (bkpt < 0)
1159  return -ENOENT;
1160 
1161  gdbstub_bkpts[bkpt].addr = NULL;
1162 
1163  gdbstub_flush_caches = 1;
1164 
1165  for (loop = 0; loop < len; loop++)
1166  if (gdbstub_write_byte(gdbstub_bkpts[bkpt].origbytes[loop],
1167  addr + loop) < 0)
1168  return -EFAULT;
1169 
1170  return 0;
1171 }
1172 
1173 /*
1174  * This function does all command processing for interfacing to gdb
1175  * - returns 0 if the exception should be skipped, -ERROR otherwise.
1176  */
1177 static int gdbstub(struct pt_regs *regs, enum exception_code excep)
1178 {
1179  unsigned long *stack;
1180  unsigned long epsw, mdr;
1181  uint32_t zero, ssp;
1182  uint8_t broke;
1183  char *ptr;
1184  int sigval;
1185  int addr;
1186  int length;
1187  int loop;
1188 
1189  if (excep == EXCEP_FPU_DISABLED)
1190  return -ENOTSUPP;
1191 
1192  gdbstub_flush_caches = 0;
1193 
1195 
1196  asm volatile("mov mdr,%0" : "=d"(mdr));
1197  local_save_flags(epsw);
1198  arch_local_change_intr_mask_level(
1199  NUM2EPSW_IM(CONFIG_DEBUGGER_IRQ_LEVEL + 1));
1200 
1201  gdbstub_store_fpu();
1202 
1203 #ifdef CONFIG_GDBSTUB_IMMEDIATE
1204  /* skip the initial pause loop */
1205  if (regs->pc == (unsigned long) __gdbstub_pause)
1206  regs->pc = (unsigned long) start_kernel;
1207 #endif
1208 
1209  /* if we were single stepping, restore the opcodes hoisted for the
1210  * breakpoint[s] */
1211  broke = 0;
1212 #ifdef CONFIG_GDBSTUB_ALLOW_SINGLE_STEP
1213  if ((step_bp[0].addr && step_bp[0].addr == (u8 *) regs->pc) ||
1214  (step_bp[1].addr && step_bp[1].addr == (u8 *) regs->pc))
1215  broke = 1;
1216 
1217  __gdbstub_restore_bp();
1218 #endif
1219 
1220  if (gdbstub_rx_unget) {
1221  sigval = SIGINT;
1222  if (gdbstub_rx_unget != 3)
1223  goto packet_waiting;
1224  gdbstub_rx_unget = 0;
1225  }
1226 
1227  stack = (unsigned long *) regs->sp;
1228  sigval = broke ? SIGTRAP : computeSignal(excep);
1229 
1230  /* send information about a BUG() */
1231  if (!user_mode(regs) && excep == EXCEP_SYSCALL15) {
1232  const struct bug_entry *bug;
1233 
1234  bug = find_bug(regs->pc);
1235  if (bug)
1236  goto found_bug;
1237  length = snprintf(trans_buffer, sizeof(trans_buffer),
1238  "BUG() at address %lx\n", regs->pc);
1239  goto send_bug_pkt;
1240 
1241  found_bug:
1242  length = snprintf(trans_buffer, sizeof(trans_buffer),
1243  "BUG() at address %lx (%s:%d)\n",
1244  regs->pc, bug->file, bug->line);
1245 
1246  send_bug_pkt:
1247  ptr = output_buffer;
1248  *ptr++ = 'O';
1249  ptr = mem2hex(trans_buffer, ptr, length, 0);
1250  *ptr = 0;
1251  putpacket(output_buffer);
1252 
1253  regs->pc -= 2;
1254  sigval = SIGABRT;
1255  } else if (regs->pc == (unsigned long) __gdbstub_bug_trap) {
1256  regs->pc = regs->mdr;
1257  sigval = SIGABRT;
1258  }
1259 
1260  /*
1261  * send a message to the debugger's user saying what happened if it may
1262  * not be clear cut (we can't map exceptions onto signals properly)
1263  */
1264  if (sigval != SIGINT && sigval != SIGTRAP && sigval != SIGILL) {
1265  static const char title[] = "Excep ", tbcberr[] = "BCBERR ";
1266  static const char crlf[] = "\r\n";
1267  char hx;
1268  u32 bcberr = BCBERR;
1269 
1270  ptr = output_buffer;
1271  *ptr++ = 'O';
1272  ptr = mem2hex(title, ptr, sizeof(title) - 1, 0);
1273 
1274  hx = hex_asc_hi(excep >> 8);
1275  ptr = hex_byte_pack(ptr, hx);
1276  hx = hex_asc_lo(excep >> 8);
1277  ptr = hex_byte_pack(ptr, hx);
1278  hx = hex_asc_hi(excep);
1279  ptr = hex_byte_pack(ptr, hx);
1280  hx = hex_asc_lo(excep);
1281  ptr = hex_byte_pack(ptr, hx);
1282 
1283  ptr = mem2hex(crlf, ptr, sizeof(crlf) - 1, 0);
1284  *ptr = 0;
1285  putpacket(output_buffer); /* send it off... */
1286 
1287  /* BCBERR */
1288  ptr = output_buffer;
1289  *ptr++ = 'O';
1290  ptr = mem2hex(tbcberr, ptr, sizeof(tbcberr) - 1, 0);
1291 
1292  hx = hex_asc_hi(bcberr >> 24);
1293  ptr = hex_byte_pack(ptr, hx);
1294  hx = hex_asc_lo(bcberr >> 24);
1295  ptr = hex_byte_pack(ptr, hx);
1296  hx = hex_asc_hi(bcberr >> 16);
1297  ptr = hex_byte_pack(ptr, hx);
1298  hx = hex_asc_lo(bcberr >> 16);
1299  ptr = hex_byte_pack(ptr, hx);
1300  hx = hex_asc_hi(bcberr >> 8);
1301  ptr = hex_byte_pack(ptr, hx);
1302  hx = hex_asc_lo(bcberr >> 8);
1303  ptr = hex_byte_pack(ptr, hx);
1304  hx = hex_asc_hi(bcberr);
1305  ptr = hex_byte_pack(ptr, hx);
1306  hx = hex_asc_lo(bcberr);
1307  ptr = hex_byte_pack(ptr, hx);
1308 
1309  ptr = mem2hex(crlf, ptr, sizeof(crlf) - 1, 0);
1310  *ptr = 0;
1311  putpacket(output_buffer); /* send it off... */
1312  }
1313 
1314  /*
1315  * tell the debugger that an exception has occurred
1316  */
1317  ptr = output_buffer;
1318 
1319  /*
1320  * Send trap type (converted to signal)
1321  */
1322  *ptr++ = 'T';
1323  ptr = hex_byte_pack(ptr, sigval);
1324 
1325  /*
1326  * Send Error PC
1327  */
1328  ptr = hex_byte_pack(ptr, GDB_REGID_PC);
1329  *ptr++ = ':';
1330  ptr = mem2hex(&regs->pc, ptr, 4, 0);
1331  *ptr++ = ';';
1332 
1333  /*
1334  * Send frame pointer
1335  */
1336  ptr = hex_byte_pack(ptr, GDB_REGID_FP);
1337  *ptr++ = ':';
1338  ptr = mem2hex(&regs->a3, ptr, 4, 0);
1339  *ptr++ = ';';
1340 
1341  /*
1342  * Send stack pointer
1343  */
1344  ssp = (unsigned long) (regs + 1);
1345  ptr = hex_byte_pack(ptr, GDB_REGID_SP);
1346  *ptr++ = ':';
1347  ptr = mem2hex(&ssp, ptr, 4, 0);
1348  *ptr++ = ';';
1349 
1350  *ptr++ = 0;
1351  putpacket(output_buffer); /* send it off... */
1352 
1353 packet_waiting:
1354  /*
1355  * Wait for input from remote GDB
1356  */
1357  while (1) {
1358  output_buffer[0] = 0;
1359  getpacket(input_buffer);
1360 
1361  switch (input_buffer[0]) {
1362  /* request repeat of last signal number */
1363  case '?':
1364  output_buffer[0] = 'S';
1365  output_buffer[1] = hex_asc_hi(sigval);
1366  output_buffer[2] = hex_asc_lo(sigval);
1367  output_buffer[3] = 0;
1368  break;
1369 
1370  case 'd':
1371  /* toggle debug flag */
1372  break;
1373 
1374  /*
1375  * Return the value of the CPU registers
1376  */
1377  case 'g':
1378  zero = 0;
1379  ssp = (u32) (regs + 1);
1380  ptr = output_buffer;
1381  ptr = mem2hex(&regs->d0, ptr, 4, 0);
1382  ptr = mem2hex(&regs->d1, ptr, 4, 0);
1383  ptr = mem2hex(&regs->d2, ptr, 4, 0);
1384  ptr = mem2hex(&regs->d3, ptr, 4, 0);
1385  ptr = mem2hex(&regs->a0, ptr, 4, 0);
1386  ptr = mem2hex(&regs->a1, ptr, 4, 0);
1387  ptr = mem2hex(&regs->a2, ptr, 4, 0);
1388  ptr = mem2hex(&regs->a3, ptr, 4, 0);
1389 
1390  ptr = mem2hex(&ssp, ptr, 4, 0); /* 8 */
1391  ptr = mem2hex(&regs->pc, ptr, 4, 0);
1392  ptr = mem2hex(&regs->mdr, ptr, 4, 0);
1393  ptr = mem2hex(&regs->epsw, ptr, 4, 0);
1394  ptr = mem2hex(&regs->lir, ptr, 4, 0);
1395  ptr = mem2hex(&regs->lar, ptr, 4, 0);
1396  ptr = mem2hex(&regs->mdrq, ptr, 4, 0);
1397 
1398  ptr = mem2hex(&regs->e0, ptr, 4, 0); /* 15 */
1399  ptr = mem2hex(&regs->e1, ptr, 4, 0);
1400  ptr = mem2hex(&regs->e2, ptr, 4, 0);
1401  ptr = mem2hex(&regs->e3, ptr, 4, 0);
1402  ptr = mem2hex(&regs->e4, ptr, 4, 0);
1403  ptr = mem2hex(&regs->e5, ptr, 4, 0);
1404  ptr = mem2hex(&regs->e6, ptr, 4, 0);
1405  ptr = mem2hex(&regs->e7, ptr, 4, 0);
1406 
1407  ptr = mem2hex(&ssp, ptr, 4, 0);
1408  ptr = mem2hex(&regs, ptr, 4, 0);
1409  ptr = mem2hex(&regs->sp, ptr, 4, 0);
1410  ptr = mem2hex(&regs->mcrh, ptr, 4, 0); /* 26 */
1411  ptr = mem2hex(&regs->mcrl, ptr, 4, 0);
1412  ptr = mem2hex(&regs->mcvf, ptr, 4, 0);
1413 
1414  ptr = mem2hex(&gdbstub_fpcr, ptr, 4, 0); /* 29 - FPCR */
1415  ptr = mem2hex(&zero, ptr, 4, 0);
1416  ptr = mem2hex(&zero, ptr, 4, 0);
1417  for (loop = 0; loop < 32; loop++)
1418  ptr = mem2hex(&gdbstub_fpufs_array[loop],
1419  ptr, 4, 0); /* 32 - FS0-31 */
1420 
1421  break;
1422 
1423  /*
1424  * set the value of the CPU registers - return OK
1425  */
1426  case 'G':
1427  {
1428  const char *ptr;
1429 
1430  ptr = &input_buffer[1];
1431  ptr = hex2mem(ptr, &regs->d0, 4, 0);
1432  ptr = hex2mem(ptr, &regs->d1, 4, 0);
1433  ptr = hex2mem(ptr, &regs->d2, 4, 0);
1434  ptr = hex2mem(ptr, &regs->d3, 4, 0);
1435  ptr = hex2mem(ptr, &regs->a0, 4, 0);
1436  ptr = hex2mem(ptr, &regs->a1, 4, 0);
1437  ptr = hex2mem(ptr, &regs->a2, 4, 0);
1438  ptr = hex2mem(ptr, &regs->a3, 4, 0);
1439 
1440  ptr = hex2mem(ptr, &ssp, 4, 0); /* 8 */
1441  ptr = hex2mem(ptr, &regs->pc, 4, 0);
1442  ptr = hex2mem(ptr, &regs->mdr, 4, 0);
1443  ptr = hex2mem(ptr, &regs->epsw, 4, 0);
1444  ptr = hex2mem(ptr, &regs->lir, 4, 0);
1445  ptr = hex2mem(ptr, &regs->lar, 4, 0);
1446  ptr = hex2mem(ptr, &regs->mdrq, 4, 0);
1447 
1448  ptr = hex2mem(ptr, &regs->e0, 4, 0); /* 15 */
1449  ptr = hex2mem(ptr, &regs->e1, 4, 0);
1450  ptr = hex2mem(ptr, &regs->e2, 4, 0);
1451  ptr = hex2mem(ptr, &regs->e3, 4, 0);
1452  ptr = hex2mem(ptr, &regs->e4, 4, 0);
1453  ptr = hex2mem(ptr, &regs->e5, 4, 0);
1454  ptr = hex2mem(ptr, &regs->e6, 4, 0);
1455  ptr = hex2mem(ptr, &regs->e7, 4, 0);
1456 
1457  ptr = hex2mem(ptr, &ssp, 4, 0);
1458  ptr = hex2mem(ptr, &zero, 4, 0);
1459  ptr = hex2mem(ptr, &regs->sp, 4, 0);
1460  ptr = hex2mem(ptr, &regs->mcrh, 4, 0); /* 26 */
1461  ptr = hex2mem(ptr, &regs->mcrl, 4, 0);
1462  ptr = hex2mem(ptr, &regs->mcvf, 4, 0);
1463 
1464  ptr = hex2mem(ptr, &zero, 4, 0); /* 29 - FPCR */
1465  ptr = hex2mem(ptr, &zero, 4, 0);
1466  ptr = hex2mem(ptr, &zero, 4, 0);
1467  for (loop = 0; loop < 32; loop++) /* 32 - FS0-31 */
1468  ptr = hex2mem(ptr, &zero, 4, 0);
1469 
1470 #if 0
1471  /*
1472  * See if the stack pointer has moved. If so, then copy
1473  * the saved locals and ins to the new location.
1474  */
1475  unsigned long *newsp = (unsigned long *) registers[SP];
1476  if (sp != newsp)
1477  sp = memcpy(newsp, sp, 16 * 4);
1478 #endif
1479 
1480  gdbstub_strcpy(output_buffer, "OK");
1481  }
1482  break;
1483 
1484  /*
1485  * mAA..AA,LLLL Read LLLL bytes at address AA..AA
1486  */
1487  case 'm':
1488  ptr = &input_buffer[1];
1489 
1490  if (hexToInt(&ptr, &addr) &&
1491  *ptr++ == ',' &&
1492  hexToInt(&ptr, &length)
1493  ) {
1494  if (mem2hex((char *) addr, output_buffer,
1495  length, 1))
1496  break;
1497  gdbstub_strcpy(output_buffer, "E03");
1498  } else {
1499  gdbstub_strcpy(output_buffer, "E01");
1500  }
1501  break;
1502 
1503  /*
1504  * MAA..AA,LLLL: Write LLLL bytes at address AA.AA
1505  * return OK
1506  */
1507  case 'M':
1508  ptr = &input_buffer[1];
1509 
1510  if (hexToInt(&ptr, &addr) &&
1511  *ptr++ == ',' &&
1512  hexToInt(&ptr, &length) &&
1513  *ptr++ == ':'
1514  ) {
1515  if (hex2mem(ptr, (char *) addr, length, 1))
1516  gdbstub_strcpy(output_buffer, "OK");
1517  else
1518  gdbstub_strcpy(output_buffer, "E03");
1519 
1520  gdbstub_flush_caches = 1;
1521  } else {
1522  gdbstub_strcpy(output_buffer, "E02");
1523  }
1524  break;
1525 
1526  /*
1527  * cAA..AA Continue at address AA..AA(optional)
1528  */
1529  case 'c':
1530  /* try to read optional parameter, pc unchanged if no
1531  * parm */
1532 
1533  ptr = &input_buffer[1];
1534  if (hexToInt(&ptr, &addr))
1535  regs->pc = addr;
1536  goto done;
1537 
1538  /*
1539  * kill the program
1540  */
1541  case 'k' :
1542  goto done; /* just continue */
1543 
1544  /*
1545  * Reset the whole machine (FIXME: system dependent)
1546  */
1547  case 'r':
1548  break;
1549 
1550  /*
1551  * Step to next instruction
1552  */
1553  case 's':
1554  /* Using the T flag doesn't seem to perform single
1555  * stepping (it seems to wind up being caught by the
1556  * JTAG unit), so we have to use breakpoints and
1557  * continue instead.
1558  */
1559 #ifdef CONFIG_GDBSTUB_ALLOW_SINGLE_STEP
1560  if (gdbstub_single_step(regs) < 0)
1561  /* ignore any fault error for now */
1562  gdbstub_printk("unable to set single-step"
1563  " bp\n");
1564  goto done;
1565 #else
1566  gdbstub_strcpy(output_buffer, "E01");
1567  break;
1568 #endif
1569 
1570  /*
1571  * Set baud rate (bBB)
1572  */
1573  case 'b':
1574  do {
1575  int baudrate;
1576 
1577  ptr = &input_buffer[1];
1578  if (!hexToInt(&ptr, &baudrate)) {
1579  gdbstub_strcpy(output_buffer, "B01");
1580  break;
1581  }
1582 
1583  if (baudrate) {
1584  /* ACK before changing speed */
1585  putpacket("OK");
1586  gdbstub_io_set_baud(baudrate);
1587  }
1588  } while (0);
1589  break;
1590 
1591  /*
1592  * Set breakpoint
1593  */
1594  case 'Z':
1595  ptr = &input_buffer[1];
1596 
1597  if (!hexToInt(&ptr, &loop) || *ptr++ != ',' ||
1598  !hexToInt(&ptr, &addr) || *ptr++ != ',' ||
1599  !hexToInt(&ptr, &length)
1600  ) {
1601  gdbstub_strcpy(output_buffer, "E01");
1602  break;
1603  }
1604 
1605  /* only support software breakpoints */
1606  gdbstub_strcpy(output_buffer, "E03");
1607  if (loop != 0 ||
1608  length < 1 ||
1609  length > 7 ||
1610  (unsigned long) addr < 4096)
1611  break;
1612 
1613  if (gdbstub_set_breakpoint((u8 *) addr, length) < 0)
1614  break;
1615 
1616  gdbstub_strcpy(output_buffer, "OK");
1617  break;
1618 
1619  /*
1620  * Clear breakpoint
1621  */
1622  case 'z':
1623  ptr = &input_buffer[1];
1624 
1625  if (!hexToInt(&ptr, &loop) || *ptr++ != ',' ||
1626  !hexToInt(&ptr, &addr) || *ptr++ != ',' ||
1627  !hexToInt(&ptr, &length)
1628  ) {
1629  gdbstub_strcpy(output_buffer, "E01");
1630  break;
1631  }
1632 
1633  /* only support software breakpoints */
1634  gdbstub_strcpy(output_buffer, "E03");
1635  if (loop != 0 ||
1636  length < 1 ||
1637  length > 7 ||
1638  (unsigned long) addr < 4096)
1639  break;
1640 
1641  if (gdbstub_clear_breakpoint((u8 *) addr, length) < 0)
1642  break;
1643 
1644  gdbstub_strcpy(output_buffer, "OK");
1645  break;
1646 
1647  default:
1648  gdbstub_proto("### GDB Unsupported Cmd '%s'\n",
1649  input_buffer);
1650  break;
1651  }
1652 
1653  /* reply to the request */
1654  putpacket(output_buffer);
1655  }
1656 
1657 done:
1658  /*
1659  * Need to flush the instruction cache here, as we may
1660  * have deposited a breakpoint, and the icache probably
1661  * has no way of knowing that a data ref to some location
1662  * may have changed something that is in the instruction
1663  * cache.
1664  * NB: We flush both caches, just to be sure...
1665  */
1666  if (gdbstub_flush_caches)
1667  debugger_local_cache_flushinv();
1668 
1669  gdbstub_load_fpu();
1671  if (excep == EXCEP_NMI)
1672  NMICR = NMICR_NMIF;
1673 
1675 
1676  local_irq_restore(epsw);
1677  return 0;
1678 }
1679 
1680 /*
1681  * Determine if we hit a debugger special breakpoint that needs skipping over
1682  * automatically.
1683  */
1685 {
1686  return 0;
1687 }
1688 
1689 /*
1690  * handle event interception
1691  */
1693  int signo, int si_code, struct pt_regs *regs)
1694 {
1695  static u8 notfirst = 1;
1696  int ret;
1697 
1698  if (gdbstub_busy)
1699  gdbstub_printk("--> gdbstub reentered itself\n");
1700  gdbstub_busy = 1;
1701 
1702  if (notfirst) {
1703  unsigned long mdr;
1704  asm("mov mdr,%0" : "=d"(mdr));
1705 
1706  gdbstub_entry(
1707  "--> debugger_intercept(%p,%04x) [MDR=%lx PC=%lx]\n",
1708  regs, excep, mdr, regs->pc);
1709 
1710  gdbstub_entry(
1711  "PC: %08lx EPSW: %08lx SSP: %08lx mode: %s\n",
1712  regs->pc, regs->epsw, (unsigned long) &ret,
1713  user_mode(regs) ? "User" : "Super");
1714  gdbstub_entry(
1715  "d0: %08lx d1: %08lx d2: %08lx d3: %08lx\n",
1716  regs->d0, regs->d1, regs->d2, regs->d3);
1717  gdbstub_entry(
1718  "a0: %08lx a1: %08lx a2: %08lx a3: %08lx\n",
1719  regs->a0, regs->a1, regs->a2, regs->a3);
1720  gdbstub_entry(
1721  "e0: %08lx e1: %08lx e2: %08lx e3: %08lx\n",
1722  regs->e0, regs->e1, regs->e2, regs->e3);
1723  gdbstub_entry(
1724  "e4: %08lx e5: %08lx e6: %08lx e7: %08lx\n",
1725  regs->e4, regs->e5, regs->e6, regs->e7);
1726  gdbstub_entry(
1727  "lar: %08lx lir: %08lx mdr: %08lx usp: %08lx\n",
1728  regs->lar, regs->lir, regs->mdr, regs->sp);
1729  gdbstub_entry(
1730  "cvf: %08lx crl: %08lx crh: %08lx drq: %08lx\n",
1731  regs->mcvf, regs->mcrl, regs->mcrh, regs->mdrq);
1732  gdbstub_entry(
1733  "threadinfo=%p task=%p)\n",
1735  } else {
1736  notfirst = 1;
1737  }
1738 
1739  ret = gdbstub(regs, excep);
1740 
1741  gdbstub_entry("<-- debugger_intercept()\n");
1742  gdbstub_busy = 0;
1743  return ret;
1744 }
1745 
1746 /*
1747  * handle the GDB stub itself causing an exception
1748  */
1750  enum exception_code excep)
1751 {
1752  unsigned long mdr;
1753 
1754  asm("mov mdr,%0" : "=d"(mdr));
1755  gdbstub_entry("--> gdbstub exception({%p},%04x) [MDR=%lx]\n",
1756  regs, excep, mdr);
1757 
1758  while ((unsigned long) regs == 0xffffffff) {}
1759 
1760  /* handle guarded memory accesses where we know it might fault */
1761  if (regs->pc == (unsigned) gdbstub_read_byte_guard) {
1762  regs->pc = (unsigned) gdbstub_read_byte_cont;
1763  goto fault;
1764  }
1765 
1766  if (regs->pc == (unsigned) gdbstub_read_word_guard) {
1767  regs->pc = (unsigned) gdbstub_read_word_cont;
1768  goto fault;
1769  }
1770 
1771  if (regs->pc == (unsigned) gdbstub_read_dword_guard) {
1772  regs->pc = (unsigned) gdbstub_read_dword_cont;
1773  goto fault;
1774  }
1775 
1776  if (regs->pc == (unsigned) gdbstub_write_byte_guard) {
1777  regs->pc = (unsigned) gdbstub_write_byte_cont;
1778  goto fault;
1779  }
1780 
1781  if (regs->pc == (unsigned) gdbstub_write_word_guard) {
1782  regs->pc = (unsigned) gdbstub_write_word_cont;
1783  goto fault;
1784  }
1785 
1786  if (regs->pc == (unsigned) gdbstub_write_dword_guard) {
1787  regs->pc = (unsigned) gdbstub_write_dword_cont;
1788  goto fault;
1789  }
1790 
1791  gdbstub_printk("\n### GDB stub caused an exception ###\n");
1792 
1793  /* something went horribly wrong */
1794  console_verbose();
1795  show_registers(regs);
1796 
1797  panic("GDB Stub caused an unexpected exception - can't continue\n");
1798 
1799  /* we caught an attempt by the stub to access silly memory */
1800 fault:
1801  gdbstub_entry("<-- gdbstub exception() = EFAULT\n");
1802  regs->d0 = -EFAULT;
1803  return;
1804 }
1805 
1806 /*
1807  * send an exit message to GDB
1808  */
1810 {
1811  unsigned char checksum;
1812  unsigned char ch;
1813  int count;
1814 
1815  gdbstub_busy = 1;
1816  output_buffer[0] = 'W';
1817  output_buffer[1] = hex_asc_hi(status);
1818  output_buffer[2] = hex_asc_lo(status);
1819  output_buffer[3] = 0;
1820 
1821  gdbstub_io_tx_char('$');
1822  checksum = 0;
1823  count = 0;
1824 
1825  while ((ch = output_buffer[count]) != 0) {
1826  gdbstub_io_tx_char(ch);
1827  checksum += ch;
1828  count += 1;
1829  }
1830 
1831  gdbstub_io_tx_char('#');
1832  gdbstub_io_tx_char(hex_asc_hi(checksum));
1833  gdbstub_io_tx_char(hex_asc_lo(checksum));
1834 
1835  /* make sure the output is flushed, or else RedBoot might clobber it */
1837 
1838  gdbstub_busy = 0;
1839 }
1840 
1841 /*
1842  * initialise the GDB stub
1843  */
1845 {
1846 #ifdef CONFIG_GDBSTUB_IMMEDIATE
1847  unsigned char ch;
1848  int ret;
1849 #endif
1850 
1851  gdbstub_busy = 1;
1852 
1853  printk(KERN_INFO "%s", gdbstub_banner);
1854 
1855  gdbstub_io_init();
1856 
1857  gdbstub_entry("--> gdbstub_init\n");
1858 
1859  /* try to talk to GDB (or anyone insane enough to want to type GDB
1860  * protocol by hand) */
1861  gdbstub_io("### GDB Tx ACK\n");
1862  gdbstub_io_tx_char('+'); /* 'hello world' */
1863 
1864 #ifdef CONFIG_GDBSTUB_IMMEDIATE
1865  gdbstub_printk("GDB Stub waiting for packet\n");
1866 
1867  /* in case GDB is started before us, ACK any packets that are already
1868  * sitting there (presumably "$?#xx")
1869  */
1870  do { gdbstub_io_rx_char(&ch, 0); } while (ch != '$');
1871  do { gdbstub_io_rx_char(&ch, 0); } while (ch != '#');
1872  /* eat first csum byte */
1873  do { ret = gdbstub_io_rx_char(&ch, 0); } while (ret != 0);
1874  /* eat second csum byte */
1875  do { ret = gdbstub_io_rx_char(&ch, 0); } while (ret != 0);
1876 
1877  gdbstub_io("### GDB Tx NAK\n");
1878  gdbstub_io_tx_char('-'); /* NAK it */
1879 
1880 #else
1881  printk("GDB Stub ready\n");
1882 #endif
1883 
1884  gdbstub_busy = 0;
1885  gdbstub_entry("<-- gdbstub_init\n");
1886 }
1887 
1888 /*
1889  * register the console at a more appropriate time
1890  */
1891 #ifdef CONFIG_GDBSTUB_CONSOLE
1892 static int __init gdbstub_postinit(void)
1893 {
1894  printk(KERN_NOTICE "registering console\n");
1895  register_console(&gdbstub_console);
1896  return 0;
1897 }
1898 
1899 __initcall(gdbstub_postinit);
1900 #endif
1901 
1902 /*
1903  * handle character reception on GDB serial port
1904  * - jump into the GDB stub if BREAK is detected on the serial line
1905  */
1906 asmlinkage void gdbstub_rx_irq(struct pt_regs *regs, enum exception_code excep)
1907 {
1908  char ch;
1909  int ret;
1910 
1911  gdbstub_entry("--> gdbstub_rx_irq\n");
1912 
1913  do {
1914  ret = gdbstub_io_rx_char(&ch, 1);
1915  if (ret != -EIO && ret != -EAGAIN) {
1916  if (ret != -EINTR)
1917  gdbstub_rx_unget = ch;
1918  gdbstub(regs, excep);
1919  }
1920  } while (ret != -EAGAIN);
1921 
1922  gdbstub_entry("<-- gdbstub_rx_irq\n");
1923 }