1 /* Remote target communications for serial-line targets in custom GDB protocol
2 Copyright 1988, 1991, 1992 Free Software Foundation, Inc.
4 This file is part of GDB.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
20 /* Remote communication protocol.
21 All values are encoded in ascii hex digits.
26 reply XX....X Each byte of register data
27 is described by two hex digits.
28 Registers are in the internal order
29 for GDB, and the bytes in a register
30 are in the same order the machine uses.
33 write regs GXX..XX Each byte of register data
34 is described by two hex digits.
38 read mem mAA..AA,LLLL AA..AA is address, LLLL is length.
39 reply XX..XX XX..XX is mem contents
42 write mem MAA..AA,LLLL:XX..XX
44 LLLL is number of bytes,
49 cont cAA..AA AA..AA is address to resume
51 resume at same address.
53 step sAA..AA AA..AA is address to resume
55 resume at same address.
57 last signal ? Reply the current reason for stopping.
58 This is the same reply as is generated
59 for step or cont : SAA where AA is the
62 There is no immediate reply to step or cont.
63 The reply comes when the machine stops.
64 It is SAA AA is the "signal number"
66 or... TAAPPPPPPPPFFFFFFFF
67 where AA is the signal number,
68 PPPPPPPP is the PC (PC_REGNUM), and
69 FFFFFFFF is the frame ptr (FP_REGNUM).
84 #if !defined(DONT_USE_REMOTE)
86 #include <sys/types.h>
91 /* Prototypes for local functions */
94 remote_write_bytes
PARAMS ((CORE_ADDR
, char *, int));
97 remote_read_bytes
PARAMS ((CORE_ADDR
, char *, int));
100 remote_files_info
PARAMS ((struct target_ops
*));
103 remote_xfer_memory
PARAMS ((CORE_ADDR
, char *, int, int, struct target_ops
*));
106 remote_prepare_to_store
PARAMS ((void));
109 remote_fetch_registers
PARAMS ((int));
112 remote_resume
PARAMS ((int, int));
115 remote_open
PARAMS ((char *, int));
118 remote_close
PARAMS ((int));
121 remote_store_registers
PARAMS ((int));
124 getpkt
PARAMS ((char *));
127 putpkt
PARAMS ((char *));
130 remote_send
PARAMS ((char *));
133 readchar
PARAMS ((void));
136 remote_wait
PARAMS ((WAITTYPE
*));
139 tohex
PARAMS ((int));
142 fromhex
PARAMS ((int));
145 remote_detach
PARAMS ((char *, int));
148 extern struct target_ops remote_ops
; /* Forward decl */
150 static int kiodebug
= 0;
151 static int timeout
= 5;
157 /* Descriptor for I/O to remote machine. Initialize it to -1 so that
158 remote_open knows that we don't have a file open when the program
160 int remote_desc
= -1;
164 /* Maximum number of bytes to read/write at once. The value here
165 is chosen to fill up a packet (the headers account for the 32). */
166 #define MAXBUFBYTES ((PBUFSIZ-32)/2)
168 /* Round up PBUFSIZ to hold all the registers, at least. */
169 #if REGISTER_BYTES > MAXBUFBYTES
171 #define PBUFSIZ (REGISTER_BYTES * 2 + 32)
174 /* Called when SIGALRM signal sent due to alarm() timeout. */
181 printf ("remote_timer called\n");
187 /* Clean up connection to a remote debugger. */
191 remote_close (quitting
)
194 if (remote_desc
>= 0)
199 /* Translate baud rates from integers to damn B_codes. Unix should
200 have outgrown this crap years ago, but even POSIX wouldn't buck it. */
211 static struct {int rate
, damn_b
;} baudtab
[] = {
237 for (i
= 0; baudtab
[i
].rate
!= -1; i
++)
238 if (rate
== baudtab
[i
].rate
) return baudtab
[i
].damn_b
;
239 return B38400
; /* Random */
242 /* Open a connection to a remote debugger.
243 NAME is the filename used for communication. */
246 remote_open (name
, from_tty
)
251 int a_rate
, b_rate
= 0;
252 int baudrate_set
= 0;
256 "To open a remote debug connection, you need to specify what serial\n\
257 device is attached to the remote system (e.g. /dev/ttya).");
259 target_preopen (from_tty
);
267 remote_desc
= open (name
, O_RDWR
);
269 perror_with_name (name
);
273 if (sscanf (baud_rate
, "%d", &a_rate
) == 1)
275 b_rate
= damn_b (a_rate
);
280 ioctl (remote_desc
, TIOCGETP
, &sg
);
282 sg
.c_cc
[VMIN
] = 0; /* read with timeout. */
283 sg
.c_cc
[VTIME
] = timeout
* 10;
284 sg
.c_lflag
&= ~(ICANON
| ECHO
);
285 sg
.c_cflag
&= ~PARENB
; /* No parity */
286 sg
.c_cflag
|= CS8
; /* 8-bit path */
288 sg
.c_cflag
= (sg
.c_cflag
& ~CBAUD
) | b_rate
;
290 sg
.sg_flags
|= RAW
| ANYP
;
291 sg
.sg_flags
&= ~ECHO
;
294 sg
.sg_ispeed
= b_rate
;
295 sg
.sg_ospeed
= b_rate
;
298 ioctl (remote_desc
, TIOCSETP
, &sg
);
301 printf ("Remote debugging using %s\n", name
);
302 push_target (&remote_ops
); /* Switch to using remote target now */
305 #ifndef NO_SIGINTERRUPT
306 /* Cause SIGALRM's to make reads fail. */
307 if (siginterrupt (SIGALRM
, 1) != 0)
308 perror ("remote_open: error in siginterrupt");
311 /* Set up read timeout timer. */
312 if ((void (*)()) signal (SIGALRM
, remote_timer
) == (void (*)()) -1)
313 perror ("remote_open: error in signal");
316 /* Ack any packet which the remote side has already sent. */
317 write (remote_desc
, "+\r", 2);
318 putpkt ("?"); /* initiate a query from remote machine */
320 start_remote (); /* Initialize gdb process mechanisms */
324 takes a program previously attached to and detaches it.
325 We better not have left any breakpoints
326 in the program or it'll die when it hits one.
327 Close the open connection to the remote debugger.
328 Use this when you want to detach and do something else
332 remote_detach (args
, from_tty
)
337 error ("Argument given to \"detach\" when remotely debugging.");
341 printf ("Ending remote debugging.\n");
344 /* Convert hex digit A to a number. */
350 if (a
>= '0' && a
<= '9')
352 else if (a
>= 'a' && a
<= 'f')
355 error ("Reply contains invalid hex digit");
359 /* Convert number NIB to a hex digit. */
371 /* Tell the remote machine to resume. */
374 remote_resume (step
, siggnal
)
380 error ("Can't send signals to a remote system. Try `handle %d ignore'.",
387 strcpy (buf
, step
? "s": "c");
392 /* Send ^C to target to halt it. Target will respond, and send us a
395 void remote_interrupt(signo
)
400 printf ("remote_interrupt called\n");
402 write (remote_desc
, "\003", 1); /* Send a ^C */
406 /* Wait until the remote machine stops, then return,
407 storing status in STATUS just as `wait' would.
408 Returns "pid" (though it's not clear what, if anything, that
409 means in the case of this target). */
415 unsigned char buf
[PBUFSIZ
];
420 char regs
[MAX_REGISTER_RAW_SIZE
];
422 WSETEXIT ((*status
), 0);
424 ofunc
= (void (*)()) signal (SIGINT
, remote_interrupt
);
425 getpkt ((char *) buf
);
426 signal (SIGINT
, ofunc
);
429 error ("Remote failure reply: %s", buf
);
432 /* Expedited reply, containing Signal, {regno, reg} repeat */
433 /* format is: 'Tssn...:r...;n...:r...;n...:r...;#cc', where
435 n... = register number
436 r... = register contents
439 p
= &buf
[3]; /* after Txx */
443 regno
= strtol (p
, &p
, 16); /* Read the register number */
446 || regno
>= NUM_REGS
)
447 error ("Remote sent bad register number %s", buf
);
449 for (i
= 0; i
< REGISTER_RAW_SIZE (regno
); i
++)
451 if (p
[0] == 0 || p
[1] == 0)
452 error ("Remote reply is too short: %s", buf
);
453 regs
[i
] = fromhex (p
[0]) * 16 + fromhex (p
[1]);
458 error("Remote register badly formatted: %s", buf
);
460 supply_register (regno
, regs
);
463 else if (buf
[0] != 'S')
464 error ("Invalid remote reply: %s", buf
);
466 WSETSTOP ((*status
), (((fromhex (buf
[1])) << 4) + (fromhex (buf
[2]))));
471 /* Read the remote registers into the block REGS. */
472 /* Currently we just read all the registers, so we don't use regno. */
475 remote_fetch_registers (regno
)
481 char regs
[REGISTER_BYTES
];
486 /* Reply describes registers byte by byte, each byte encoded as two
487 hex characters. Suck them all up, then supply them to the
488 register cacheing/storage mechanism. */
491 for (i
= 0; i
< REGISTER_BYTES
; i
++)
493 if (p
[0] == 0 || p
[1] == 0)
494 error ("Remote reply is too short: %s", buf
);
495 regs
[i
] = fromhex (p
[0]) * 16 + fromhex (p
[1]);
498 for (i
= 0; i
< NUM_REGS
; i
++)
499 supply_register (i
, ®s
[REGISTER_BYTE(i
)]);
502 /* Prepare to store registers. Since we send them all, we have to
503 read out the ones we don't want to change first. */
506 remote_prepare_to_store ()
508 /* Make sure the entire registers array is valid. */
509 read_register_bytes (0, (char *)NULL
, REGISTER_BYTES
);
512 /* Store the remote registers from the contents of the block REGISTERS.
513 FIXME, eventually just store one register if that's all that is needed. */
517 remote_store_registers (regno
)
526 /* Command describes registers byte by byte,
527 each byte encoded as two hex characters. */
530 for (i
= 0; i
< REGISTER_BYTES
; i
++)
532 *p
++ = tohex ((registers
[i
] >> 4) & 0xf);
533 *p
++ = tohex (registers
[i
] & 0xf);
541 /* Read a word from remote address ADDR and return it.
542 This goes through the data cache. */
545 remote_fetch_word (addr
)
550 extern CORE_ADDR text_start
, text_end
;
552 if (addr
>= text_start
&& addr
< text_end
)
555 xfer_core_file (addr
, &buffer
, sizeof (int));
559 return dcache_fetch (addr
);
562 /* Write a word WORD into remote address ADDR.
563 This goes through the data cache. */
566 remote_store_word (addr
, word
)
570 dcache_poke (addr
, word
);
574 /* Write memory data directly to the remote machine.
575 This does not inform the data cache; the data cache uses this.
576 MEMADDR is the address in the remote memory space.
577 MYADDR is the address of the buffer in our space.
578 LEN is the number of bytes. */
581 remote_write_bytes (memaddr
, myaddr
, len
)
590 if (len
> PBUFSIZ
/ 2 - 20)
593 sprintf (buf
, "M%x,%x:", memaddr
, len
);
595 /* We send target system values byte by byte, in increasing byte addresses,
596 each byte encoded as two hex characters. */
598 p
= buf
+ strlen (buf
);
599 for (i
= 0; i
< len
; i
++)
601 *p
++ = tohex ((myaddr
[i
] >> 4) & 0xf);
602 *p
++ = tohex (myaddr
[i
] & 0xf);
609 /* Read memory data directly from the remote machine.
610 This does not use the data cache; the data cache uses this.
611 MEMADDR is the address in the remote memory space.
612 MYADDR is the address of the buffer in our space.
613 LEN is the number of bytes. */
616 remote_read_bytes (memaddr
, myaddr
, len
)
625 if (len
> PBUFSIZ
/ 2 - 1)
628 sprintf (buf
, "m%x,%x", memaddr
, len
);
631 /* Reply describes memory byte by byte,
632 each byte encoded as two hex characters. */
635 for (i
= 0; i
< len
; i
++)
637 if (p
[0] == 0 || p
[1] == 0)
638 error ("Remote reply is too short: %s", buf
);
639 myaddr
[i
] = fromhex (p
[0]) * 16 + fromhex (p
[1]);
644 /* Read or write LEN bytes from inferior memory at MEMADDR, transferring
645 to or from debugger address MYADDR. Write to inferior if SHOULD_WRITE is
646 nonzero. Returns length of data written or read; 0 for error. */
650 remote_xfer_memory(memaddr
, myaddr
, len
, should_write
, target
)
655 struct target_ops
*target
; /* ignored */
661 if (len
> MAXBUFBYTES
)
662 xfersize
= MAXBUFBYTES
;
667 remote_write_bytes(memaddr
, myaddr
, xfersize
);
669 remote_read_bytes (memaddr
, myaddr
, xfersize
);
674 return origlen
; /* no error possible */
678 remote_files_info (ignore
)
679 struct target_ops
*ignore
;
681 printf ("Debugging a target over a serial line.\n");
686 A debug packet whose contents are <data>
687 is encapsulated for transmission in the form:
689 $ <data> # CSUM1 CSUM2
691 <data> must be ASCII alphanumeric and cannot include characters
694 CSUM1 and CSUM2 are ascii hex representation of an 8-bit
695 checksum of <data>, the most significant nibble is sent first.
696 the hex digits 0-9,a-f are used.
698 Receiver responds with:
700 + - if CSUM is correct and ready for next packet
701 - - if CSUM is incorrect
705 /* Read a single character from the remote end.
706 (If supported, we actually read many characters and buffer them up.) */
711 static int inbuf_index
, inbuf_count
;
712 #define INBUFSIZE PBUFSIZ
713 static char inbuf
[INBUFSIZE
];
715 if (inbuf_index
>= inbuf_count
)
717 /* Time to do another read... */
720 inbuf
[0] = 0; /* Just in case */
722 /* termio does the timeout for us. */
723 inbuf_count
= read (remote_desc
, inbuf
, INBUFSIZE
);
726 inbuf_count
= read (remote_desc
, inbuf
, INBUFSIZE
);
731 /* Just return the next character from the buffer. */
732 return inbuf
[inbuf_index
++] & 0x7f;
735 /* Send the command in BUF to the remote machine,
736 and read the reply into BUF.
737 Report an error if we get an error reply. */
748 error ("Remote failure reply: %s", buf
);
751 /* Send a packet to the remote machine, with error checking.
752 The data of the packet is in BUF. */
759 unsigned char csum
= 0;
761 int cnt
= strlen (buf
);
765 /* Copy the packet into buffer BUF2, encapsulating it
766 and giving it a checksum. */
768 if (cnt
> sizeof(buf2
) - 5) /* Prosanity check */
774 for (i
= 0; i
< cnt
; i
++)
780 *p
++ = tohex ((csum
>> 4) & 0xf);
781 *p
++ = tohex (csum
& 0xf);
783 /* Send it over and over until we get a positive ack. */
789 printf ("Sending packet: %s...", buf2
); fflush(stdout
);
791 write (remote_desc
, buf2
, p
- buf2
);
793 /* read until either a timeout occurs (\0) or '+' is read */
800 printf ("%02X%c ", ch
&0xFF, ch
);
802 } while ((ch
!= '+') && (ch
!= '\0'));
806 /* Read a packet from the remote machine, with error checking,
807 and store it in BUF. BUF is expected to be of size PBUFSIZ. */
816 unsigned char c1
, c2
;
818 #define MAX_RETRIES 10
821 /* Sorry, this will cause all hell to break loose, i.e. we'll end
822 up in the command loop with an inferior, but (at least if this
823 happens in remote_wait or some such place) without a current_frame,
824 having set up prev_* in wait_for_inferior, etc.
826 If it is necessary to have such an "emergency exit", seems like
827 the only plausible thing to do is to say the inferior died, and
828 make the user reattach if they want to. Perhaps with a prompt
829 asking for confirmation. */
831 /* allow immediate quit while reading from device, it could be hung */
837 /* Force csum to be zero here because of possible error retry. */
840 while ((c
= readchar()) != '$');
848 if (bp
>= buf
+PBUFSIZ
-1)
851 printf_filtered ("Remote packet too long: %s\n", buf
);
859 c1
= fromhex (readchar ());
860 c2
= fromhex (readchar ());
861 if ((csum
& 0xff) == (c1
<< 4) + c2
)
863 printf_filtered ("Bad checksum, sentsum=0x%x, csum=0x%x, buf=%s\n",
864 (c1
<< 4) + c2
, csum
& 0xff, buf
);
866 /* Try the whole thing again. */
868 if (++retries
< MAX_RETRIES
)
870 write (remote_desc
, "-", 1);
874 printf ("Ignoring packet error, continuing...\n");
883 write (remote_desc
, "+", 1);
886 fprintf (stderr
,"Packet received: %s\n", buf
);
889 /* The data cache leads to incorrect results because it doesn't know about
890 volatile variables, thus making it impossible to debug functions which
891 use hardware registers. Therefore it is #if 0'd out. Effect on
892 performance is some, for backtraces of functions with a few
893 arguments each. For functions with many arguments, the stack
894 frames don't fit in the cache blocks, which makes the cache less
895 helpful. Disabling the cache is a big performance win for fetching
896 large structures, because the cache code fetched data in 16-byte
899 /* The data cache records all the data read from the remote machine
900 since the last time it stopped.
902 Each cache block holds 16 bytes of data
903 starting at a multiple-of-16 address. */
905 #define DCACHE_SIZE 64 /* Number of cache blocks */
907 struct dcache_block
{
908 struct dcache_block
*next
, *last
;
909 unsigned int addr
; /* Address for which data is recorded. */
913 struct dcache_block dcache_free
, dcache_valid
;
915 /* Free all the data cache blocks, thus discarding all cached data. */
920 register struct dcache_block
*db
;
922 while ((db
= dcache_valid
.next
) != &dcache_valid
)
925 insque (db
, &dcache_free
);
930 * If addr is present in the dcache, return the address of the block
934 struct dcache_block
*
937 register struct dcache_block
*db
;
942 /* Search all cache blocks for one that is at this address. */
943 db
= dcache_valid
.next
;
944 while (db
!= &dcache_valid
)
946 if ((addr
& 0xfffffff0) == db
->addr
)
953 /* Return the int data at address ADDR in dcache block DC. */
956 dcache_value (db
, addr
)
957 struct dcache_block
*db
;
962 return (db
->data
[(addr
>>2)&3]);
965 /* Get a free cache block, put it on the valid list,
966 and return its address. The caller should store into the block
967 the address and data that it describes. */
969 struct dcache_block
*
972 register struct dcache_block
*db
;
974 if ((db
= dcache_free
.next
) == &dcache_free
)
975 /* If we can't get one from the free list, take last valid */
976 db
= dcache_valid
.last
;
979 insque (db
, &dcache_valid
);
983 /* Return the contents of the word at address ADDR in the remote machine,
984 using the data cache. */
990 register struct dcache_block
*db
;
992 db
= dcache_hit (addr
);
995 db
= dcache_alloc ();
996 remote_read_bytes (addr
& ~0xf, db
->data
, 16);
997 db
->addr
= addr
& ~0xf;
999 return (dcache_value (db
, addr
));
1002 /* Write the word at ADDR both in the data cache and in the remote machine. */
1004 dcache_poke (addr
, data
)
1008 register struct dcache_block
*db
;
1010 /* First make sure the word is IN the cache. DB is its cache block. */
1011 db
= dcache_hit (addr
);
1014 db
= dcache_alloc ();
1015 remote_read_bytes (addr
& ~0xf, db
->data
, 16);
1016 db
->addr
= addr
& ~0xf;
1019 /* Modify the word in the cache. */
1020 db
->data
[(addr
>>2)&3] = data
;
1022 /* Send the changed word. */
1023 remote_write_bytes (addr
, &data
, 4);
1026 /* Initialize the data cache. */
1031 register struct dcache_block
*db
;
1033 db
= (struct dcache_block
*) xmalloc (sizeof (struct dcache_block
) *
1035 dcache_free
.next
= dcache_free
.last
= &dcache_free
;
1036 dcache_valid
.next
= dcache_valid
.last
= &dcache_valid
;
1037 for (i
=0;i
<DCACHE_SIZE
;i
++,db
++)
1038 insque (db
, &dcache_free
);
1042 /* Define the target subroutine names */
1044 struct target_ops remote_ops
= {
1045 "remote", /* to_shortname */
1046 "Remote serial target in gdb-specific protocol", /* to_longname */
1047 "Use a remote computer via a serial line, using a gdb-specific protocol.\n\
1048 Specify the serial device it is connected to (e.g. /dev/ttya).", /* to_doc */
1049 remote_open
, /* to_open */
1050 remote_close
, /* to_close */
1051 NULL
, /* to_attach */
1052 remote_detach
, /* to_detach */
1053 remote_resume
, /* to_resume */
1054 remote_wait
, /* to_wait */
1055 remote_fetch_registers
, /* to_fetch_registers */
1056 remote_store_registers
, /* to_store_registers */
1057 remote_prepare_to_store
, /* to_prepare_to_store */
1058 remote_xfer_memory
, /* to_xfer_memory */
1059 remote_files_info
, /* to_files_info */
1060 NULL
, /* to_insert_breakpoint */
1061 NULL
, /* to_remove_breakpoint */
1062 NULL
, /* to_terminal_init */
1063 NULL
, /* to_terminal_inferior */
1064 NULL
, /* to_terminal_ours_for_output */
1065 NULL
, /* to_terminal_ours */
1066 NULL
, /* to_terminal_info */
1069 NULL
, /* to_lookup_symbol */
1070 NULL
, /* to_create_inferior */
1071 NULL
, /* to_mourn_inferior */
1073 process_stratum
, /* to_stratum */
1075 1, /* to_has_all_memory */
1076 1, /* to_has_memory */
1077 1, /* to_has_stack */
1078 1, /* to_has_registers */
1079 1, /* to_has_execution */
1080 NULL
, /* sections */
1081 NULL
, /* sections_end */
1082 OPS_MAGIC
/* to_magic */
1086 _initialize_remote ()
1088 add_target (&remote_ops
);
1091 add_set_cmd ("remotedebug", no_class
, var_boolean
, (char *)&kiodebug
,
1092 "Set debugging of remote serial I/O.\n\
1093 When enabled, each packet sent or received with the remote target\n\
1094 is displayed.", &setlist
),