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"
80 #include <sys/types.h>
85 /* Prototypes for local functions */
88 remote_write_bytes
PARAMS ((CORE_ADDR
, char *, int));
91 remote_read_bytes
PARAMS ((CORE_ADDR
, char *, int));
94 remote_files_info
PARAMS ((struct target_ops
*));
97 remote_xfer_memory
PARAMS ((CORE_ADDR
, char *, int, int, struct target_ops
*));
100 remote_prepare_to_store
PARAMS ((void));
103 remote_fetch_registers
PARAMS ((int));
106 remote_resume
PARAMS ((int, int));
109 remote_open
PARAMS ((char *, int));
112 remote_close
PARAMS ((int));
115 remote_store_registers
PARAMS ((int));
118 getpkt
PARAMS ((char *));
121 putpkt
PARAMS ((char *));
124 remote_send
PARAMS ((char *));
127 readchar
PARAMS ((void));
130 remote_wait
PARAMS ((WAITTYPE
*));
133 tohex
PARAMS ((int));
136 fromhex
PARAMS ((int));
139 remote_detach
PARAMS ((char *, int));
142 extern struct target_ops remote_ops
; /* Forward decl */
145 static int timeout
= 5;
151 /* Descriptor for I/O to remote machine. Initialize it to -1 so that
152 remote_open knows that we don't have a file open when the program
154 int remote_desc
= -1;
158 /* Maximum number of bytes to read/write at once. The value here
159 is chosen to fill up a packet (the headers account for the 32). */
160 #define MAXBUFBYTES ((PBUFSIZ-32)/2)
162 /* Round up PBUFSIZ to hold all the registers, at least. */
163 #if REGISTER_BYTES > MAXBUFBYTES
165 #define PBUFSIZ (REGISTER_BYTES * 2 + 32)
168 /* Called when SIGALRM signal sent due to alarm() timeout. */
174 printf ("remote_timer called\n");
180 /* Clean up connection to a remote debugger. */
184 remote_close (quitting
)
187 if (remote_desc
>= 0)
192 /* Translate baud rates from integers to damn B_codes. Unix should
193 have outgrown this crap years ago, but even POSIX wouldn't buck it. */
202 static struct {int rate
, damn_b
;} baudtab
[] = {
228 for (i
= 0; baudtab
[i
].rate
!= -1; i
++)
229 if (rate
== baudtab
[i
].rate
) return baudtab
[i
].damn_b
;
230 return B38400
; /* Random */
233 /* Open a connection to a remote debugger.
234 NAME is the filename used for communication. */
237 remote_open (name
, from_tty
)
243 int baudrate_set
= 0;
247 "To open a remote debug connection, you need to specify what serial\n\
248 device is attached to the remote system (e.g. /dev/ttya).");
250 target_preopen (from_tty
);
258 remote_desc
= open (name
, O_RDWR
);
260 perror_with_name (name
);
264 if (1 != sscanf (baud_rate
, "%d ", &a_rate
))
266 b_rate
= damn_b (a_rate
);
271 ioctl (remote_desc
, TIOCGETP
, &sg
);
273 sg
.c_cc
[VMIN
] = 0; /* read with timeout. */
274 sg
.c_cc
[VTIME
] = timeout
* 10;
275 sg
.c_lflag
&= ~(ICANON
| ECHO
);
276 sg
.c_cflag
&= ~PARENB
; /* No parity */
277 sg
.c_cflag
|= CS8
; /* 8-bit path */
279 sg
.c_cflag
= (sb
.c_cflag
& ~CBAUD
) | b_rate
;
281 sg
.sg_flags
|= RAW
| ANYP
;
282 sg
.sg_flags
&= ~ECHO
;
285 sg
.sg_ispeed
= b_rate
;
286 sg
.sg_ospeed
= b_rate
;
289 ioctl (remote_desc
, TIOCSETP
, &sg
);
292 printf ("Remote debugging using %s\n", name
);
293 push_target (&remote_ops
); /* Switch to using remote target now */
296 #ifndef NO_SIGINTERRUPT
297 /* Cause SIGALRM's to make reads fail. */
298 if (siginterrupt (SIGALRM
, 1) != 0)
299 perror ("remote_open: error in siginterrupt");
302 /* Set up read timeout timer. */
303 if ((void (*)()) signal (SIGALRM
, remote_timer
) == (void (*)()) -1)
304 perror ("remote_open: error in signal");
307 /* Ack any packet which the remote side has already sent. */
308 write (remote_desc
, "+", 1);
309 putpkt ("?"); /* initiate a query from remote machine */
311 start_remote (); /* Initialize gdb process mechanisms */
315 takes a program previously attached to and detaches it.
316 We better not have left any breakpoints
317 in the program or it'll die when it hits one.
318 Close the open connection to the remote debugger.
319 Use this when you want to detach and do something else
323 remote_detach (args
, from_tty
)
328 error ("Argument given to \"detach\" when remotely debugging.");
332 printf ("Ending remote debugging.\n");
335 /* Convert hex digit A to a number. */
341 if (a
>= '0' && a
<= '9')
343 else if (a
>= 'a' && a
<= 'f')
346 error ("Reply contains invalid hex digit");
350 /* Convert number NIB to a hex digit. */
362 /* Tell the remote machine to resume. */
365 remote_resume (step
, siggnal
)
371 error ("Can't send signals to a remote system.");
377 strcpy (buf
, step
? "s": "c");
382 /* Send ^C to target to halt it. Target will respond, and send us a
385 void remote_interrupt()
387 write (remote_desc
, "\003", 1); /* Send a ^C */
391 /* Wait until the remote machine stops, then return,
392 storing status in STATUS just as `wait' would.
393 Returns "pid" (though it's not clear what, if anything, that
394 means in the case of this target). */
400 unsigned char buf
[PBUFSIZ
];
403 WSETEXIT ((*status
), 0);
405 ofunc
= signal (SIGINT
, remote_interrupt
);
406 getpkt ((char *) buf
);
407 signal (SIGINT
, ofunc
);
410 error ("Remote failure reply: %s", buf
);
412 error ("Invalid remote reply: %s", buf
);
413 WSETSTOP ((*status
), (((fromhex (buf
[1])) << 4) + (fromhex (buf
[2]))));
417 /* Read the remote registers into the block REGS. */
419 /* Currently we just read all the registers, so we don't use regno. */
422 remote_fetch_registers (regno
)
428 char regs
[REGISTER_BYTES
];
433 /* Reply describes registers byte by byte, each byte encoded as two
434 hex characters. Suck them all up, then supply them to the
435 register cacheing/storage mechanism. */
438 for (i
= 0; i
< REGISTER_BYTES
; i
++)
440 if (p
[0] == 0 || p
[1] == 0)
441 error ("Remote reply is too short: %s", buf
);
442 regs
[i
] = fromhex (p
[0]) * 16 + fromhex (p
[1]);
445 for (i
= 0; i
< NUM_REGS
; i
++)
446 supply_register (i
, ®s
[REGISTER_BYTE(i
)]);
449 /* Prepare to store registers. Since we send them all, we have to
450 read out the ones we don't want to change first. */
453 remote_prepare_to_store ()
455 remote_fetch_registers (-1);
458 /* Store the remote registers from the contents of the block REGISTERS.
459 FIXME, eventually just store one register if that's all that is needed. */
463 remote_store_registers (regno
)
472 /* Command describes registers byte by byte,
473 each byte encoded as two hex characters. */
476 for (i
= 0; i
< REGISTER_BYTES
; i
++)
478 *p
++ = tohex ((registers
[i
] >> 4) & 0xf);
479 *p
++ = tohex (registers
[i
] & 0xf);
487 /* Read a word from remote address ADDR and return it.
488 This goes through the data cache. */
491 remote_fetch_word (addr
)
496 extern CORE_ADDR text_start
, text_end
;
498 if (addr
>= text_start
&& addr
< text_end
)
501 xfer_core_file (addr
, &buffer
, sizeof (int));
505 return dcache_fetch (addr
);
508 /* Write a word WORD into remote address ADDR.
509 This goes through the data cache. */
512 remote_store_word (addr
, word
)
516 dcache_poke (addr
, word
);
520 /* Write memory data directly to the remote machine.
521 This does not inform the data cache; the data cache uses this.
522 MEMADDR is the address in the remote memory space.
523 MYADDR is the address of the buffer in our space.
524 LEN is the number of bytes. */
527 remote_write_bytes (memaddr
, myaddr
, len
)
536 if (len
> PBUFSIZ
/ 2 - 20)
539 sprintf (buf
, "M%x,%x:", memaddr
, len
);
541 /* We send target system values byte by byte, in increasing byte addresses,
542 each byte encoded as two hex characters. */
544 p
= buf
+ strlen (buf
);
545 for (i
= 0; i
< len
; i
++)
547 *p
++ = tohex ((myaddr
[i
] >> 4) & 0xf);
548 *p
++ = tohex (myaddr
[i
] & 0xf);
555 /* Read memory data directly from the remote machine.
556 This does not use the data cache; the data cache uses this.
557 MEMADDR is the address in the remote memory space.
558 MYADDR is the address of the buffer in our space.
559 LEN is the number of bytes. */
562 remote_read_bytes (memaddr
, myaddr
, len
)
571 if (len
> PBUFSIZ
/ 2 - 1)
574 sprintf (buf
, "m%x,%x", memaddr
, len
);
577 /* Reply describes memory byte by byte,
578 each byte encoded as two hex characters. */
581 for (i
= 0; i
< len
; i
++)
583 if (p
[0] == 0 || p
[1] == 0)
584 error ("Remote reply is too short: %s", buf
);
585 myaddr
[i
] = fromhex (p
[0]) * 16 + fromhex (p
[1]);
590 /* Read or write LEN bytes from inferior memory at MEMADDR, transferring
591 to or from debugger address MYADDR. Write to inferior if SHOULD_WRITE is
592 nonzero. Returns length of data written or read; 0 for error. */
596 remote_xfer_memory(memaddr
, myaddr
, len
, should_write
, target
)
601 struct target_ops
*target
; /* ignored */
607 if (len
> MAXBUFBYTES
)
608 xfersize
= MAXBUFBYTES
;
613 remote_write_bytes(memaddr
, myaddr
, xfersize
);
615 remote_read_bytes (memaddr
, myaddr
, xfersize
);
620 return origlen
; /* no error possible */
624 remote_files_info (target
)
625 struct target_ops
*target
;
627 printf ("remote files info missing here. FIXME.\n");
632 A debug packet whose contents are <data>
633 is encapsulated for transmission in the form:
635 $ <data> # CSUM1 CSUM2
637 <data> must be ASCII alphanumeric and cannot include characters
640 CSUM1 and CSUM2 are ascii hex representation of an 8-bit
641 checksum of <data>, the most significant nibble is sent first.
642 the hex digits 0-9,a-f are used.
644 Receiver responds with:
646 + - if CSUM is correct and ready for next packet
647 - - if CSUM is incorrect
651 /* Read a single character from the remote end.
652 (If supported, we actually read many characters and buffer them up.) */
658 static int inbuf_index
, inbuf_count
;
659 #define INBUFSIZE PBUFSIZ
660 static char inbuf
[INBUFSIZE
];
662 if (inbuf_index
>= inbuf_count
)
664 /* Time to do another read... */
667 inbuf
[0] = 0; /* Just in case */
669 /* termio does the timeout for us. */
670 inbuf_count
= read (remote_desc
, inbuf
, INBUFSIZE
);
673 inbuf_count
= read (remote_desc
, inbuf
, INBUFSIZE
);
678 /* Just return the next character from the buffer. */
679 return inbuf
[inbuf_index
++] & 0x7f;
682 /* Send the command in BUF to the remote machine,
683 and read the reply into BUF.
684 Report an error if we get an error reply. */
695 error ("Remote failure reply: %s", buf
);
698 /* Send a packet to the remote machine, with error checking.
699 The data of the packet is in BUF. */
706 unsigned char csum
= 0;
708 int cnt
= strlen (buf
);
712 /* Copy the packet into buffer BUF2, encapsulating it
713 and giving it a checksum. */
715 if (cnt
> sizeof(buf2
) - 5) /* Prosanity check */
721 for (i
= 0; i
< cnt
; i
++)
727 *p
++ = tohex ((csum
>> 4) & 0xf);
728 *p
++ = tohex (csum
& 0xf);
730 /* Send it over and over until we get a positive ack. */
736 printf ("Sending packet: %s (%s)\n", buf2
, buf
);
738 write (remote_desc
, buf2
, p
- buf2
);
740 /* read until either a timeout occurs (\0) or '+' is read */
743 } while ((ch
!= '+') && (ch
!= '\0'));
747 /* Read a packet from the remote machine, with error checking,
748 and store it in BUF. */
757 unsigned char c1
, c2
;
760 /* Sorry, this will cause all hell to break loose, i.e. we'll end
761 up in the command loop with an inferior, but (at least if this
762 happens in remote_wait or some such place) without a current_frame,
763 having set up prev_* in wait_for_inferior, etc.
765 If it is necessary to have such an "emergency exit", seems like
766 the only plausible thing to do is to say the inferior died, and
767 make the user reattach if they want to. Perhaps with a prompt
768 asking for confirmation. */
770 /* allow immediate quit while reading from device, it could be hung */
776 /* Force csum to be zero here because of possible error retry. */
779 while ((c
= readchar()) != '$');
792 c1
= fromhex (readchar ());
793 c2
= fromhex (readchar ());
794 if ((csum
& 0xff) == (c1
<< 4) + c2
)
796 printf ("Bad checksum, sentsum=0x%x, csum=0x%x, buf=%s\n",
797 (c1
<< 4) + c2
, csum
& 0xff, buf
);
798 write (remote_desc
, "-", 1);
805 write (remote_desc
, "+", 1);
808 fprintf (stderr
,"Packet received :%s\n", buf
);
811 /* The data cache leads to incorrect results because it doesn't know about
812 volatile variables, thus making it impossible to debug functions which
813 use hardware registers. Therefore it is #if 0'd out. Effect on
814 performance is some, for backtraces of functions with a few
815 arguments each. For functions with many arguments, the stack
816 frames don't fit in the cache blocks, which makes the cache less
817 helpful. Disabling the cache is a big performance win for fetching
818 large structures, because the cache code fetched data in 16-byte
821 /* The data cache records all the data read from the remote machine
822 since the last time it stopped.
824 Each cache block holds 16 bytes of data
825 starting at a multiple-of-16 address. */
827 #define DCACHE_SIZE 64 /* Number of cache blocks */
829 struct dcache_block
{
830 struct dcache_block
*next
, *last
;
831 unsigned int addr
; /* Address for which data is recorded. */
835 struct dcache_block dcache_free
, dcache_valid
;
837 /* Free all the data cache blocks, thus discarding all cached data. */
842 register struct dcache_block
*db
;
844 while ((db
= dcache_valid
.next
) != &dcache_valid
)
847 insque (db
, &dcache_free
);
852 * If addr is present in the dcache, return the address of the block
856 struct dcache_block
*
859 register struct dcache_block
*db
;
864 /* Search all cache blocks for one that is at this address. */
865 db
= dcache_valid
.next
;
866 while (db
!= &dcache_valid
)
868 if ((addr
& 0xfffffff0) == db
->addr
)
875 /* Return the int data at address ADDR in dcache block DC. */
878 dcache_value (db
, addr
)
879 struct dcache_block
*db
;
884 return (db
->data
[(addr
>>2)&3]);
887 /* Get a free cache block, put it on the valid list,
888 and return its address. The caller should store into the block
889 the address and data that it describes. */
891 struct dcache_block
*
894 register struct dcache_block
*db
;
896 if ((db
= dcache_free
.next
) == &dcache_free
)
897 /* If we can't get one from the free list, take last valid */
898 db
= dcache_valid
.last
;
901 insque (db
, &dcache_valid
);
905 /* Return the contents of the word at address ADDR in the remote machine,
906 using the data cache. */
912 register struct dcache_block
*db
;
914 db
= dcache_hit (addr
);
917 db
= dcache_alloc ();
918 remote_read_bytes (addr
& ~0xf, db
->data
, 16);
919 db
->addr
= addr
& ~0xf;
921 return (dcache_value (db
, addr
));
924 /* Write the word at ADDR both in the data cache and in the remote machine. */
926 dcache_poke (addr
, data
)
930 register struct dcache_block
*db
;
932 /* First make sure the word is IN the cache. DB is its cache block. */
933 db
= dcache_hit (addr
);
936 db
= dcache_alloc ();
937 remote_read_bytes (addr
& ~0xf, db
->data
, 16);
938 db
->addr
= addr
& ~0xf;
941 /* Modify the word in the cache. */
942 db
->data
[(addr
>>2)&3] = data
;
944 /* Send the changed word. */
945 remote_write_bytes (addr
, &data
, 4);
948 /* Initialize the data cache. */
953 register struct dcache_block
*db
;
955 db
= (struct dcache_block
*) xmalloc (sizeof (struct dcache_block
) *
957 dcache_free
.next
= dcache_free
.last
= &dcache_free
;
958 dcache_valid
.next
= dcache_valid
.last
= &dcache_valid
;
959 for (i
=0;i
<DCACHE_SIZE
;i
++,db
++)
960 insque (db
, &dcache_free
);
964 /* Define the target subroutine names */
966 struct target_ops remote_ops
= {
967 "remote", /* to_shortname */
968 "Remote serial target in gdb-specific protocol", /* to_longname */
969 "Use a remote computer via a serial line, using a gdb-specific protocol.\n\
970 Specify the serial device it is connected to (e.g. /dev/ttya).", /* to_doc */
971 remote_open
, /* to_open */
972 remote_close
, /* to_close */
973 NULL
, /* to_attach */
974 remote_detach
, /* to_detach */
975 remote_resume
, /* to_resume */
976 remote_wait
, /* to_wait */
977 remote_fetch_registers
, /* to_fetch_registers */
978 remote_store_registers
, /* to_store_registers */
979 remote_prepare_to_store
, /* to_prepare_to_store */
980 NULL
, /* to_convert_to_virtual */
981 NULL
, /* to_convert_from_virtual */
982 remote_xfer_memory
, /* to_xfer_memory */
983 remote_files_info
, /* to_files_info */
984 NULL
, /* to_insert_breakpoint */
985 NULL
, /* to_remove_breakpoint */
986 NULL
, /* to_terminal_init */
987 NULL
, /* to_terminal_inferior */
988 NULL
, /* to_terminal_ours_for_output */
989 NULL
, /* to_terminal_ours */
990 NULL
, /* to_terminal_info */
993 NULL
, /* to_lookup_symbol */
994 NULL
, /* to_create_inferior */
995 NULL
, /* to_mourn_inferior */
996 process_stratum
, /* to_stratum */
998 1, /* to_has_all_memory */
999 1, /* to_has_memory */
1000 1, /* to_has_stack */
1001 1, /* to_has_registers */
1002 1, /* to_has_execution */
1003 NULL
, /* sections */
1004 NULL
, /* sections_end */
1005 OPS_MAGIC
/* to_magic */
1009 _initialize_remote ()
1011 add_target (&remote_ops
);