681a3145305c6bcbf7ff11ba917aa9c3cc7efc53
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. */
180 printf ("remote_timer called\n");
186 /* Clean up connection to a remote debugger. */
190 remote_close (quitting
)
193 if (remote_desc
>= 0)
198 /* Translate baud rates from integers to damn B_codes. Unix should
199 have outgrown this crap years ago, but even POSIX wouldn't buck it. */
210 static struct {int rate
, damn_b
;} baudtab
[] = {
236 for (i
= 0; baudtab
[i
].rate
!= -1; i
++)
237 if (rate
== baudtab
[i
].rate
) return baudtab
[i
].damn_b
;
238 return B38400
; /* Random */
241 /* Open a connection to a remote debugger.
242 NAME is the filename used for communication. */
245 remote_open (name
, from_tty
)
250 int a_rate
, b_rate
= 0;
251 int baudrate_set
= 0;
255 "To open a remote debug connection, you need to specify what serial\n\
256 device is attached to the remote system (e.g. /dev/ttya).");
258 target_preopen (from_tty
);
266 remote_desc
= open (name
, O_RDWR
);
268 perror_with_name (name
);
272 if (1 != sscanf (baud_rate
, "%d ", &a_rate
))
274 b_rate
= damn_b (a_rate
);
279 ioctl (remote_desc
, TIOCGETP
, &sg
);
281 sg
.c_cc
[VMIN
] = 0; /* read with timeout. */
282 sg
.c_cc
[VTIME
] = timeout
* 10;
283 sg
.c_lflag
&= ~(ICANON
| ECHO
);
284 sg
.c_cflag
&= ~PARENB
; /* No parity */
285 sg
.c_cflag
|= CS8
; /* 8-bit path */
287 sg
.c_cflag
= (sg
.c_cflag
& ~CBAUD
) | b_rate
;
289 sg
.sg_flags
|= RAW
| ANYP
;
290 sg
.sg_flags
&= ~ECHO
;
293 sg
.sg_ispeed
= b_rate
;
294 sg
.sg_ospeed
= b_rate
;
297 ioctl (remote_desc
, TIOCSETP
, &sg
);
300 printf ("Remote debugging using %s\n", name
);
301 push_target (&remote_ops
); /* Switch to using remote target now */
304 #ifndef NO_SIGINTERRUPT
305 /* Cause SIGALRM's to make reads fail. */
306 if (siginterrupt (SIGALRM
, 1) != 0)
307 perror ("remote_open: error in siginterrupt");
310 /* Set up read timeout timer. */
311 if ((void (*)()) signal (SIGALRM
, remote_timer
) == (void (*)()) -1)
312 perror ("remote_open: error in signal");
315 /* Ack any packet which the remote side has already sent. */
316 write (remote_desc
, "+\r", 2);
317 putpkt ("?"); /* initiate a query from remote machine */
319 start_remote (); /* Initialize gdb process mechanisms */
323 takes a program previously attached to and detaches it.
324 We better not have left any breakpoints
325 in the program or it'll die when it hits one.
326 Close the open connection to the remote debugger.
327 Use this when you want to detach and do something else
331 remote_detach (args
, from_tty
)
336 error ("Argument given to \"detach\" when remotely debugging.");
340 printf ("Ending remote debugging.\n");
343 /* Convert hex digit A to a number. */
349 if (a
>= '0' && a
<= '9')
351 else if (a
>= 'a' && a
<= 'f')
354 error ("Reply contains invalid hex digit");
358 /* Convert number NIB to a hex digit. */
370 /* Tell the remote machine to resume. */
373 remote_resume (step
, siggnal
)
379 error ("Can't send signals to a remote system. Try `handle %d ignore'.",
386 strcpy (buf
, step
? "s": "c");
391 /* Send ^C to target to halt it. Target will respond, and send us a
394 void remote_interrupt()
398 printf ("remote_interrupt called\n");
400 write (remote_desc
, "\003", 1); /* Send a ^C */
404 /* Wait until the remote machine stops, then return,
405 storing status in STATUS just as `wait' would.
406 Returns "pid" (though it's not clear what, if anything, that
407 means in the case of this target). */
413 unsigned char buf
[PBUFSIZ
];
417 char regs
[REGISTER_RAW_SIZE (PC_REGNUM
) + REGISTER_RAW_SIZE (FP_REGNUM
)];
419 WSETEXIT ((*status
), 0);
421 ofunc
= signal (SIGINT
, remote_interrupt
);
422 getpkt ((char *) buf
);
423 signal (SIGINT
, ofunc
);
426 error ("Remote failure reply: %s", buf
);
429 /* Expedited reply, containing Signal, PC, and FP. */
430 p
= &buf
[3]; /* after Txx */
431 for (i
= 0; i
< sizeof (regs
); i
++)
433 if (p
[0] == 0 || p
[1] == 0)
434 error ("Remote reply is too short: %s", buf
);
435 regs
[i
] = fromhex (p
[0]) * 16 + fromhex (p
[1]);
438 supply_register (PC_REGNUM
, ®s
[0]);
439 supply_register (FP_REGNUM
, ®s
[REGISTER_RAW_SIZE (PC_REGNUM
)]);
441 else if (buf
[0] != 'S')
442 error ("Invalid remote reply: %s", buf
);
444 WSETSTOP ((*status
), (((fromhex (buf
[1])) << 4) + (fromhex (buf
[2]))));
449 /* Read the remote registers into the block REGS. */
450 /* Currently we just read all the registers, so we don't use regno. */
453 remote_fetch_registers (regno
)
459 char regs
[REGISTER_BYTES
];
464 /* Reply describes registers byte by byte, each byte encoded as two
465 hex characters. Suck them all up, then supply them to the
466 register cacheing/storage mechanism. */
469 for (i
= 0; i
< REGISTER_BYTES
; i
++)
471 if (p
[0] == 0 || p
[1] == 0)
472 error ("Remote reply is too short: %s", buf
);
473 regs
[i
] = fromhex (p
[0]) * 16 + fromhex (p
[1]);
476 for (i
= 0; i
< NUM_REGS
; i
++)
477 supply_register (i
, ®s
[REGISTER_BYTE(i
)]);
480 /* Prepare to store registers. Since we send them all, we have to
481 read out the ones we don't want to change first. */
484 remote_prepare_to_store ()
486 remote_fetch_registers (-1);
489 /* Store the remote registers from the contents of the block REGISTERS.
490 FIXME, eventually just store one register if that's all that is needed. */
494 remote_store_registers (regno
)
503 /* Command describes registers byte by byte,
504 each byte encoded as two hex characters. */
507 for (i
= 0; i
< REGISTER_BYTES
; i
++)
509 *p
++ = tohex ((registers
[i
] >> 4) & 0xf);
510 *p
++ = tohex (registers
[i
] & 0xf);
518 /* Read a word from remote address ADDR and return it.
519 This goes through the data cache. */
522 remote_fetch_word (addr
)
527 extern CORE_ADDR text_start
, text_end
;
529 if (addr
>= text_start
&& addr
< text_end
)
532 xfer_core_file (addr
, &buffer
, sizeof (int));
536 return dcache_fetch (addr
);
539 /* Write a word WORD into remote address ADDR.
540 This goes through the data cache. */
543 remote_store_word (addr
, word
)
547 dcache_poke (addr
, word
);
551 /* Write memory data directly to the remote machine.
552 This does not inform the data cache; the data cache uses this.
553 MEMADDR is the address in the remote memory space.
554 MYADDR is the address of the buffer in our space.
555 LEN is the number of bytes. */
558 remote_write_bytes (memaddr
, myaddr
, len
)
567 if (len
> PBUFSIZ
/ 2 - 20)
570 sprintf (buf
, "M%x,%x:", memaddr
, len
);
572 /* We send target system values byte by byte, in increasing byte addresses,
573 each byte encoded as two hex characters. */
575 p
= buf
+ strlen (buf
);
576 for (i
= 0; i
< len
; i
++)
578 *p
++ = tohex ((myaddr
[i
] >> 4) & 0xf);
579 *p
++ = tohex (myaddr
[i
] & 0xf);
586 /* Read memory data directly from the remote machine.
587 This does not use the data cache; the data cache uses this.
588 MEMADDR is the address in the remote memory space.
589 MYADDR is the address of the buffer in our space.
590 LEN is the number of bytes. */
593 remote_read_bytes (memaddr
, myaddr
, len
)
602 if (len
> PBUFSIZ
/ 2 - 1)
605 sprintf (buf
, "m%x,%x", memaddr
, len
);
608 /* Reply describes memory byte by byte,
609 each byte encoded as two hex characters. */
612 for (i
= 0; i
< len
; i
++)
614 if (p
[0] == 0 || p
[1] == 0)
615 error ("Remote reply is too short: %s", buf
);
616 myaddr
[i
] = fromhex (p
[0]) * 16 + fromhex (p
[1]);
621 /* Read or write LEN bytes from inferior memory at MEMADDR, transferring
622 to or from debugger address MYADDR. Write to inferior if SHOULD_WRITE is
623 nonzero. Returns length of data written or read; 0 for error. */
627 remote_xfer_memory(memaddr
, myaddr
, len
, should_write
, target
)
632 struct target_ops
*target
; /* ignored */
638 if (len
> MAXBUFBYTES
)
639 xfersize
= MAXBUFBYTES
;
644 remote_write_bytes(memaddr
, myaddr
, xfersize
);
646 remote_read_bytes (memaddr
, myaddr
, xfersize
);
651 return origlen
; /* no error possible */
655 remote_files_info (ignore
)
656 struct target_ops
*ignore
;
658 printf ("Debugging a target over a serial line.\n");
663 A debug packet whose contents are <data>
664 is encapsulated for transmission in the form:
666 $ <data> # CSUM1 CSUM2
668 <data> must be ASCII alphanumeric and cannot include characters
671 CSUM1 and CSUM2 are ascii hex representation of an 8-bit
672 checksum of <data>, the most significant nibble is sent first.
673 the hex digits 0-9,a-f are used.
675 Receiver responds with:
677 + - if CSUM is correct and ready for next packet
678 - - if CSUM is incorrect
682 /* Read a single character from the remote end.
683 (If supported, we actually read many characters and buffer them up.) */
688 static int inbuf_index
, inbuf_count
;
689 #define INBUFSIZE PBUFSIZ
690 static char inbuf
[INBUFSIZE
];
692 if (inbuf_index
>= inbuf_count
)
694 /* Time to do another read... */
697 inbuf
[0] = 0; /* Just in case */
699 /* termio does the timeout for us. */
700 inbuf_count
= read (remote_desc
, inbuf
, INBUFSIZE
);
703 inbuf_count
= read (remote_desc
, inbuf
, INBUFSIZE
);
708 /* Just return the next character from the buffer. */
709 return inbuf
[inbuf_index
++] & 0x7f;
712 /* Send the command in BUF to the remote machine,
713 and read the reply into BUF.
714 Report an error if we get an error reply. */
725 error ("Remote failure reply: %s", buf
);
728 /* Send a packet to the remote machine, with error checking.
729 The data of the packet is in BUF. */
736 unsigned char csum
= 0;
738 int cnt
= strlen (buf
);
742 /* Copy the packet into buffer BUF2, encapsulating it
743 and giving it a checksum. */
745 if (cnt
> sizeof(buf2
) - 5) /* Prosanity check */
751 for (i
= 0; i
< cnt
; i
++)
757 *p
++ = tohex ((csum
>> 4) & 0xf);
758 *p
++ = tohex (csum
& 0xf);
760 /* Send it over and over until we get a positive ack. */
766 printf ("Sending packet: %s...", buf2
); fflush(stdout
);
768 write (remote_desc
, buf2
, p
- buf2
);
770 /* read until either a timeout occurs (\0) or '+' is read */
777 printf ("%02X%c ", ch
&0xFF, ch
);
779 } while ((ch
!= '+') && (ch
!= '\0'));
783 /* Read a packet from the remote machine, with error checking,
784 and store it in BUF. BUF is expected to be of size PBUFSIZ. */
793 unsigned char c1
, c2
;
796 /* Sorry, this will cause all hell to break loose, i.e. we'll end
797 up in the command loop with an inferior, but (at least if this
798 happens in remote_wait or some such place) without a current_frame,
799 having set up prev_* in wait_for_inferior, etc.
801 If it is necessary to have such an "emergency exit", seems like
802 the only plausible thing to do is to say the inferior died, and
803 make the user reattach if they want to. Perhaps with a prompt
804 asking for confirmation. */
806 /* allow immediate quit while reading from device, it could be hung */
812 /* Force csum to be zero here because of possible error retry. */
815 while ((c
= readchar()) != '$');
823 if (bp
>= buf
+PBUFSIZ
-1)
826 printf_filtered ("Remote packet too long: %s\n", buf
);
834 c1
= fromhex (readchar ());
835 c2
= fromhex (readchar ());
836 if ((csum
& 0xff) == (c1
<< 4) + c2
)
838 printf_filtered ("Bad checksum, sentsum=0x%x, csum=0x%x, buf=%s\n",
839 (c1
<< 4) + c2
, csum
& 0xff, buf
);
840 /* Try the whole thing again. */
842 write (remote_desc
, "-", 1);
849 write (remote_desc
, "+", 1);
852 fprintf (stderr
,"Packet received: %s\n", buf
);
855 /* The data cache leads to incorrect results because it doesn't know about
856 volatile variables, thus making it impossible to debug functions which
857 use hardware registers. Therefore it is #if 0'd out. Effect on
858 performance is some, for backtraces of functions with a few
859 arguments each. For functions with many arguments, the stack
860 frames don't fit in the cache blocks, which makes the cache less
861 helpful. Disabling the cache is a big performance win for fetching
862 large structures, because the cache code fetched data in 16-byte
865 /* The data cache records all the data read from the remote machine
866 since the last time it stopped.
868 Each cache block holds 16 bytes of data
869 starting at a multiple-of-16 address. */
871 #define DCACHE_SIZE 64 /* Number of cache blocks */
873 struct dcache_block
{
874 struct dcache_block
*next
, *last
;
875 unsigned int addr
; /* Address for which data is recorded. */
879 struct dcache_block dcache_free
, dcache_valid
;
881 /* Free all the data cache blocks, thus discarding all cached data. */
886 register struct dcache_block
*db
;
888 while ((db
= dcache_valid
.next
) != &dcache_valid
)
891 insque (db
, &dcache_free
);
896 * If addr is present in the dcache, return the address of the block
900 struct dcache_block
*
903 register struct dcache_block
*db
;
908 /* Search all cache blocks for one that is at this address. */
909 db
= dcache_valid
.next
;
910 while (db
!= &dcache_valid
)
912 if ((addr
& 0xfffffff0) == db
->addr
)
919 /* Return the int data at address ADDR in dcache block DC. */
922 dcache_value (db
, addr
)
923 struct dcache_block
*db
;
928 return (db
->data
[(addr
>>2)&3]);
931 /* Get a free cache block, put it on the valid list,
932 and return its address. The caller should store into the block
933 the address and data that it describes. */
935 struct dcache_block
*
938 register struct dcache_block
*db
;
940 if ((db
= dcache_free
.next
) == &dcache_free
)
941 /* If we can't get one from the free list, take last valid */
942 db
= dcache_valid
.last
;
945 insque (db
, &dcache_valid
);
949 /* Return the contents of the word at address ADDR in the remote machine,
950 using the data cache. */
956 register struct dcache_block
*db
;
958 db
= dcache_hit (addr
);
961 db
= dcache_alloc ();
962 remote_read_bytes (addr
& ~0xf, db
->data
, 16);
963 db
->addr
= addr
& ~0xf;
965 return (dcache_value (db
, addr
));
968 /* Write the word at ADDR both in the data cache and in the remote machine. */
970 dcache_poke (addr
, data
)
974 register struct dcache_block
*db
;
976 /* First make sure the word is IN the cache. DB is its cache block. */
977 db
= dcache_hit (addr
);
980 db
= dcache_alloc ();
981 remote_read_bytes (addr
& ~0xf, db
->data
, 16);
982 db
->addr
= addr
& ~0xf;
985 /* Modify the word in the cache. */
986 db
->data
[(addr
>>2)&3] = data
;
988 /* Send the changed word. */
989 remote_write_bytes (addr
, &data
, 4);
992 /* Initialize the data cache. */
997 register struct dcache_block
*db
;
999 db
= (struct dcache_block
*) xmalloc (sizeof (struct dcache_block
) *
1001 dcache_free
.next
= dcache_free
.last
= &dcache_free
;
1002 dcache_valid
.next
= dcache_valid
.last
= &dcache_valid
;
1003 for (i
=0;i
<DCACHE_SIZE
;i
++,db
++)
1004 insque (db
, &dcache_free
);
1008 /* Define the target subroutine names */
1010 struct target_ops remote_ops
= {
1011 "remote", /* to_shortname */
1012 "Remote serial target in gdb-specific protocol", /* to_longname */
1013 "Use a remote computer via a serial line, using a gdb-specific protocol.\n\
1014 Specify the serial device it is connected to (e.g. /dev/ttya).", /* to_doc */
1015 remote_open
, /* to_open */
1016 remote_close
, /* to_close */
1017 NULL
, /* to_attach */
1018 remote_detach
, /* to_detach */
1019 remote_resume
, /* to_resume */
1020 remote_wait
, /* to_wait */
1021 remote_fetch_registers
, /* to_fetch_registers */
1022 remote_store_registers
, /* to_store_registers */
1023 remote_prepare_to_store
, /* to_prepare_to_store */
1024 NULL
, /* to_convert_to_virtual */
1025 NULL
, /* to_convert_from_virtual */
1026 remote_xfer_memory
, /* to_xfer_memory */
1027 remote_files_info
, /* to_files_info */
1028 NULL
, /* to_insert_breakpoint */
1029 NULL
, /* to_remove_breakpoint */
1030 NULL
, /* to_terminal_init */
1031 NULL
, /* to_terminal_inferior */
1032 NULL
, /* to_terminal_ours_for_output */
1033 NULL
, /* to_terminal_ours */
1034 NULL
, /* to_terminal_info */
1037 NULL
, /* to_lookup_symbol */
1038 NULL
, /* to_create_inferior */
1039 NULL
, /* to_mourn_inferior */
1040 process_stratum
, /* to_stratum */
1042 1, /* to_has_all_memory */
1043 1, /* to_has_memory */
1044 1, /* to_has_stack */
1045 1, /* to_has_registers */
1046 1, /* to_has_execution */
1047 NULL
, /* sections */
1048 NULL
, /* sections_end */
1049 OPS_MAGIC
/* to_magic */
1053 _initialize_remote ()
1055 add_target (&remote_ops
);
1058 add_set_cmd ("remotedebug", no_class
, var_boolean
, (char *)&kiodebug
,
1059 "Set debugging of remote serial I/O.\n\
1060 When enabled, each packet sent or received with the remote target\n\
1061 is displayed.", &setlist
),
This page took 0.050991 seconds and 4 git commands to generate.