1 /* Remote target communications for serial-line targets in custom GDB protocol
2 Copyright 1988, 1991, 1992, 1993, 1994 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.
22 A debug packet whose contents are <data>
23 is encapsulated for transmission in the form:
25 $ <data> # CSUM1 CSUM2
27 <data> must be ASCII alphanumeric and cannot include characters
30 CSUM1 and CSUM2 are ascii hex representation of an 8-bit
31 checksum of <data>, the most significant nibble is sent first.
32 the hex digits 0-9,a-f are used.
34 Receiver responds with:
36 + - if CSUM is correct and ready for next packet
37 - - if CSUM is incorrect
40 All values are encoded in ascii hex digits.
45 reply XX....X Each byte of register data
46 is described by two hex digits.
47 Registers are in the internal order
48 for GDB, and the bytes in a register
49 are in the same order the machine uses.
52 write regs GXX..XX Each byte of register data
53 is described by two hex digits.
57 write reg Pn...:r... Write register n... with value r...,
58 which contains two hex digits for each
59 byte in the register (target byte
63 (not supported by all stubs).
65 read mem mAA..AA,LLLL AA..AA is address, LLLL is length.
66 reply XX..XX XX..XX is mem contents
67 Can be fewer bytes than requested
68 if able to read only part of the data.
71 write mem MAA..AA,LLLL:XX..XX
73 LLLL is number of bytes,
76 ENN for an error (this includes the case
77 where only part of the data was
80 cont cAA..AA AA..AA is address to resume
82 resume at same address.
84 step sAA..AA AA..AA is address to resume
86 resume at same address.
88 last signal ? Reply the current reason for stopping.
89 This is the same reply as is generated
90 for step or cont : SAA where AA is the
93 There is no immediate reply to step or cont.
94 The reply comes when the machine stops.
95 It is SAA AA is the "signal number"
97 or... TAAn...:r...;n:r...;n...:r...;
99 n... = register number
100 r... = register contents
101 or... WAA The process exited, and AA is
102 the exit status. This is only
103 applicable for certains sorts of
107 toggle debug d toggle debug flag (see 386 & 68k stubs)
108 reset r reset -- see sparc stub.
109 reserved <other> On other requests, the stub should
110 ignore the request and send an empty
111 response ($#<checksum>). This way
112 we can extend the protocol and GDB
113 can tell whether the stub it is
114 talking to uses the old or the new.
115 search tAA:PP,MM Search backwards starting at address
116 AA for a match with pattern PP and
117 mask MM. PP and MM are 4 bytes.
118 Not supported by all stubs.
120 general query qXXXX Request info about XXXX.
121 general set QXXXX=yyyy Set value of XXXX to yyyy.
122 query sect offs qOffsets Get section offsets. Reply is
123 Text=xxx;Data=yyy;Bss=zzz
125 Responses can be run-length encoded to save space. A '*' means that
126 the next two characters are hex digits giving a repeat count which
127 stands for that many repititions of the character preceding the '*'.
128 Note that this means that responses cannot contain '*'. Example:
129 "0*03" means the same as "0000". */
135 #include "inferior.h"
140 #include "terminal.h"
142 #include "objfiles.h"
143 #include "gdb-stabs.h"
147 #if !defined(DONT_USE_REMOTE)
149 #include <sys/types.h>
155 /* Prototypes for local functions */
158 remote_write_bytes
PARAMS ((CORE_ADDR memaddr
, unsigned char *myaddr
, int len
));
161 remote_read_bytes
PARAMS ((CORE_ADDR memaddr
, unsigned char *myaddr
, int len
));
164 remote_files_info
PARAMS ((struct target_ops
*ignore
));
167 remote_xfer_memory
PARAMS ((CORE_ADDR memaddr
, char *myaddr
, int len
,
168 int should_write
, struct target_ops
*target
));
171 remote_prepare_to_store
PARAMS ((void));
174 remote_fetch_registers
PARAMS ((int regno
));
177 remote_resume
PARAMS ((int pid
, int step
, enum target_signal siggnal
));
180 remote_start_remote
PARAMS ((char *dummy
));
183 remote_open
PARAMS ((char *name
, int from_tty
));
186 remote_close
PARAMS ((int quitting
));
189 remote_store_registers
PARAMS ((int regno
));
192 getpkt
PARAMS ((char *buf
, int forever
));
195 putpkt
PARAMS ((char *buf
));
198 remote_send
PARAMS ((char *buf
));
201 readchar
PARAMS ((void));
203 static int remote_wait
PARAMS ((int pid
, struct target_waitstatus
*status
));
206 tohex
PARAMS ((int nib
));
209 fromhex
PARAMS ((int a
));
212 remote_detach
PARAMS ((char *args
, int from_tty
));
215 remote_interrupt
PARAMS ((int signo
));
218 remote_interrupt_twice
PARAMS ((int signo
));
221 interrupt_query
PARAMS ((void));
223 extern struct target_ops remote_ops
; /* Forward decl */
225 /* This was 5 seconds, which is a long time to sit and wait.
226 Unless this is going though some terminal server or multiplexer or
227 other form of hairy serial connection, I would think 2 seconds would
229 static int timeout
= 2;
235 /* Descriptor for I/O to remote machine. Initialize it to NULL so that
236 remote_open knows that we don't have a file open when the program
238 serial_t remote_desc
= NULL
;
240 /* Having this larger than 400 causes us to be incompatible with m68k-stub.c
241 and i386-stub.c. Normally, no one would notice because it only matters
242 for writing large chunks of memory (e.g. in downloads). Also, this needs
243 to be more than 400 if required to hold the registers (see below, where
244 we round it up based on REGISTER_BYTES). */
247 /* Maximum number of bytes to read/write at once. The value here
248 is chosen to fill up a packet (the headers account for the 32). */
249 #define MAXBUFBYTES ((PBUFSIZ-32)/2)
251 /* Round up PBUFSIZ to hold all the registers, at least. */
252 #if REGISTER_BYTES > MAXBUFBYTES
254 #define PBUFSIZ (REGISTER_BYTES * 2 + 32)
257 /* Should we try the 'P' request? If this is set to one when the stub
258 doesn't support 'P', the only consequence is some unnecessary traffic. */
259 static int stub_supports_P
= 1;
262 /* Clean up connection to a remote debugger. */
266 remote_close (quitting
)
270 SERIAL_CLOSE (remote_desc
);
274 /* Query the remote side for the text, data and bss offsets. */
279 unsigned char buf
[PBUFSIZ
];
281 CORE_ADDR text_addr
, data_addr
, bss_addr
;
282 struct section_offsets
*offs
;
290 warning ("Remote failure reply: %s", buf
);
294 nvals
= sscanf (buf
, "Text=%lx;Data=%lx;Bss=%lx", &text_addr
, &data_addr
,
297 error ("Malformed response to offset query, %s", buf
);
299 if (symfile_objfile
== NULL
)
302 offs
= (struct section_offsets
*) alloca (sizeof (struct section_offsets
)
303 + symfile_objfile
->num_sections
304 * sizeof (offs
->offsets
));
305 memcpy (offs
, symfile_objfile
->section_offsets
,
306 sizeof (struct section_offsets
)
307 + symfile_objfile
->num_sections
308 * sizeof (offs
->offsets
));
310 /* FIXME: This code assumes gdb-stabs.h is being used; it's broken
311 for xcoff, dwarf, sdb-coff, etc. But there is no simple
312 canonical representation for this stuff. (Just what does "text"
313 as seen by the stub mean, anyway? I think it means all sections
314 with SEC_CODE set, but we currently have no way to deal with that). */
316 ANOFFSET (offs
, SECT_OFF_TEXT
) = text_addr
;
317 ANOFFSET (offs
, SECT_OFF_DATA
) = data_addr
;
318 ANOFFSET (offs
, SECT_OFF_BSS
) = bss_addr
;
320 objfile_relocate (symfile_objfile
, offs
);
323 /* Stub for catch_errors. */
326 remote_start_remote (dummy
)
329 immediate_quit
= 1; /* Allow user to interrupt it */
331 /* Ack any packet which the remote side has already sent. */
333 SERIAL_WRITE (remote_desc
, "+", 1);
335 get_offsets (); /* Get text, data & bss offsets */
337 putpkt ("?"); /* initiate a query from remote machine */
340 start_remote (); /* Initialize gdb process mechanisms */
345 /* Open a connection to a remote debugger.
346 NAME is the filename used for communication. */
348 static DCACHE
*remote_dcache
;
351 remote_open (name
, from_tty
)
357 "To open a remote debug connection, you need to specify what serial\n\
358 device is attached to the remote system (e.g. /dev/ttya).");
360 target_preopen (from_tty
);
362 unpush_target (&remote_ops
);
364 remote_dcache
= dcache_init (remote_read_bytes
, remote_write_bytes
);
366 remote_desc
= SERIAL_OPEN (name
);
368 perror_with_name (name
);
372 if (SERIAL_SETBAUDRATE (remote_desc
, baud_rate
))
374 SERIAL_CLOSE (remote_desc
);
375 perror_with_name (name
);
379 SERIAL_RAW (remote_desc
);
381 /* If there is something sitting in the buffer we might take it as a
382 response to a command, which would be bad. */
383 SERIAL_FLUSH_INPUT (remote_desc
);
387 puts_filtered ("Remote debugging using ");
388 puts_filtered (name
);
389 puts_filtered ("\n");
391 push_target (&remote_ops
); /* Switch to using remote target now */
393 /* Start out by trying the 'P' request to set registers. We set this each
394 time that we open a new target so that if the user switches from one
395 stub to another, we can (if the target is closed and reopened) cope. */
398 /* Start the remote connection; if error (0), discard this target.
399 In particular, if the user quits, be sure to discard it
400 (we'd be in an inconsistent state otherwise). */
401 if (!catch_errors (remote_start_remote
, (char *)0,
402 "Couldn't establish connection to remote target\n", RETURN_MASK_ALL
))
407 takes a program previously attached to and detaches it.
408 We better not have left any breakpoints
409 in the program or it'll die when it hits one.
410 Close the open connection to the remote debugger.
411 Use this when you want to detach and do something else
415 remote_detach (args
, from_tty
)
420 error ("Argument given to \"detach\" when remotely debugging.");
424 puts_filtered ("Ending remote debugging.\n");
427 /* Convert hex digit A to a number. */
433 if (a
>= '0' && a
<= '9')
435 else if (a
>= 'a' && a
<= 'f')
438 error ("Reply contains invalid hex digit");
442 /* Convert number NIB to a hex digit. */
454 /* Tell the remote machine to resume. */
457 remote_resume (pid
, step
, siggnal
)
459 enum target_signal siggnal
;
466 target_terminal_ours_for_output ();
468 ("Can't send signals to a remote system. %s not sent.\n",
469 target_signal_to_name (siggnal
));
470 target_terminal_inferior ();
473 dcache_flush (remote_dcache
);
475 strcpy (buf
, step
? "s": "c");
480 /* Send ^C to target to halt it. Target will respond, and send us a
484 remote_interrupt (signo
)
487 /* If this doesn't work, try more severe steps. */
488 signal (signo
, remote_interrupt_twice
);
491 printf_unfiltered ("remote_interrupt called\n");
493 SERIAL_WRITE (remote_desc
, "\003", 1); /* Send a ^C */
496 static void (*ofunc
)();
498 /* The user typed ^C twice. */
500 remote_interrupt_twice (signo
)
503 signal (signo
, ofunc
);
507 signal (signo
, remote_interrupt
);
510 /* Ask the user what to do when an interrupt is received. */
515 target_terminal_ours ();
517 if (query ("Interrupted while waiting for the program.\n\
518 Give up (and stop debugging it)? "))
520 target_mourn_inferior ();
521 return_to_top_level (RETURN_QUIT
);
524 target_terminal_inferior ();
527 /* Wait until the remote machine stops, then return,
528 storing status in STATUS just as `wait' would.
529 Returns "pid" (though it's not clear what, if anything, that
530 means in the case of this target). */
533 remote_wait (pid
, status
)
535 struct target_waitstatus
*status
;
537 unsigned char buf
[PBUFSIZ
];
539 status
->kind
= TARGET_WAITKIND_EXITED
;
540 status
->value
.integer
= 0;
546 ofunc
= (void (*)()) signal (SIGINT
, remote_interrupt
);
547 getpkt ((char *) buf
, 1);
548 signal (SIGINT
, ofunc
);
551 warning ("Remote failure reply: %s", buf
);
552 else if (buf
[0] == 'T')
556 char regs
[MAX_REGISTER_RAW_SIZE
];
558 /* Expedited reply, containing Signal, {regno, reg} repeat */
559 /* format is: 'Tssn...:r...;n...:r...;n...:r...;#cc', where
561 n... = register number
562 r... = register contents
565 p
= &buf
[3]; /* after Txx */
571 regno
= strtol (p
, &p1
, 16); /* Read the register number */
574 warning ("Remote sent badly formed register number: %s\nPacket: '%s'\n",
580 warning ("Malformed packet (missing colon): %s\nPacket: '%s'\n",
583 if (regno
>= NUM_REGS
)
584 warning ("Remote sent bad register number %d: %s\nPacket: '%s'\n",
587 for (i
= 0; i
< REGISTER_RAW_SIZE (regno
); i
++)
589 if (p
[0] == 0 || p
[1] == 0)
590 warning ("Remote reply is too short: %s", buf
);
591 regs
[i
] = fromhex (p
[0]) * 16 + fromhex (p
[1]);
596 warning ("Remote register badly formatted: %s", buf
);
598 supply_register (regno
, regs
);
602 else if (buf
[0] == 'W')
604 /* The remote process exited. */
605 status
->kind
= TARGET_WAITKIND_EXITED
;
606 status
->value
.integer
= (fromhex (buf
[1]) << 4) + fromhex (buf
[2]);
609 else if (buf
[0] == 'S')
612 warning ("Invalid remote reply: %s", buf
);
615 status
->kind
= TARGET_WAITKIND_STOPPED
;
616 status
->value
.sig
= (enum target_signal
)
617 (((fromhex (buf
[1])) << 4) + (fromhex (buf
[2])));
622 /* Number of bytes of registers this stub implements. */
623 static int register_bytes_found
;
625 /* Read the remote registers into the block REGS. */
626 /* Currently we just read all the registers, so we don't use regno. */
629 remote_fetch_registers (regno
)
635 char regs
[REGISTER_BYTES
];
640 /* Unimplemented registers read as all bits zero. */
641 memset (regs
, 0, REGISTER_BYTES
);
643 /* We can get out of synch in various cases. If the first character
644 in the buffer is not a hex character, assume that has happened
645 and try to fetch another packet to read. */
646 while ((buf
[0] < '0' || buf
[0] > '9')
647 && (buf
[0] < 'a' || buf
[0] > 'f'))
650 printf_unfiltered ("Bad register packet; fetching a new packet\n");
654 /* Reply describes registers byte by byte, each byte encoded as two
655 hex characters. Suck them all up, then supply them to the
656 register cacheing/storage mechanism. */
659 for (i
= 0; i
< REGISTER_BYTES
; i
++)
665 warning ("Remote reply is of odd length: %s", buf
);
666 /* Don't change register_bytes_found in this case, and don't
667 print a second warning. */
670 regs
[i
] = fromhex (p
[0]) * 16 + fromhex (p
[1]);
674 if (i
!= register_bytes_found
)
676 register_bytes_found
= i
;
677 #ifdef REGISTER_BYTES_OK
678 if (!REGISTER_BYTES_OK (i
))
679 warning ("Remote reply is too short: %s", buf
);
684 for (i
= 0; i
< NUM_REGS
; i
++)
685 supply_register (i
, ®s
[REGISTER_BYTE(i
)]);
688 /* Prepare to store registers. Since we may send them all (using a
689 'G' request), we have to read out the ones we don't want to change
693 remote_prepare_to_store ()
695 /* Make sure the entire registers array is valid. */
696 read_register_bytes (0, (char *)NULL
, REGISTER_BYTES
);
699 /* Store register REGNO, or all registers if REGNO == -1, from the contents
700 of REGISTERS. FIXME: ignores errors. */
703 remote_store_registers (regno
)
710 if (regno
>= 0 && stub_supports_P
)
712 /* Try storing a single register. */
715 sprintf (buf
, "P%x:", regno
);
716 p
= buf
+ strlen (buf
);
717 regp
= ®isters
[REGISTER_BYTE (regno
)];
718 for (i
= 0; i
< REGISTER_RAW_SIZE (regno
); ++i
)
720 *p
++ = tohex ((regp
[i
] >> 4) & 0xf);
721 *p
++ = tohex (regp
[i
] & 0xf);
727 /* The stub understands the 'P' request. We are done. */
731 /* The stub does not support the 'P' request. Use 'G' instead,
732 and don't try using 'P' in the future (it will just waste our
739 /* Command describes registers byte by byte,
740 each byte encoded as two hex characters. */
743 /* remote_prepare_to_store insures that register_bytes_found gets set. */
744 for (i
= 0; i
< register_bytes_found
; i
++)
746 *p
++ = tohex ((registers
[i
] >> 4) & 0xf);
747 *p
++ = tohex (registers
[i
] & 0xf);
756 /* Use of the data cache is disabled because it loses for looking at
757 and changing hardware I/O ports and the like. Accepting `volatile'
758 would perhaps be one way to fix it, but a better way which would
759 win for more cases would be to use the executable file for the text
760 segment, like the `icache' code below but done cleanly (in some
761 target-independent place, perhaps in target_xfer_memory, perhaps
762 based on assigning each target a speed or perhaps by some simpler
765 /* Read a word from remote address ADDR and return it.
766 This goes through the data cache. */
769 remote_fetch_word (addr
)
775 extern CORE_ADDR text_start
, text_end
;
777 if (addr
>= text_start
&& addr
< text_end
)
780 xfer_core_file (addr
, &buffer
, sizeof (int));
785 return dcache_fetch (remote_dcache
, addr
);
788 /* Write a word WORD into remote address ADDR.
789 This goes through the data cache. */
792 remote_store_word (addr
, word
)
796 dcache_poke (remote_dcache
, addr
, word
);
800 /* Write memory data directly to the remote machine.
801 This does not inform the data cache; the data cache uses this.
802 MEMADDR is the address in the remote memory space.
803 MYADDR is the address of the buffer in our space.
804 LEN is the number of bytes.
806 Returns number of bytes transferred, or 0 for error. */
809 remote_write_bytes (memaddr
, myaddr
, len
)
811 unsigned char *myaddr
;
818 /* FIXME-32x64: Need a version of print_address_numeric which doesn't
819 set use_local (and also puts the result in a buffer like sprintf). */
820 sprintf (buf
, "M%lx,%x:", (unsigned long) memaddr
, len
);
822 /* We send target system values byte by byte, in increasing byte addresses,
823 each byte encoded as two hex characters. */
825 p
= buf
+ strlen (buf
);
826 for (i
= 0; i
< len
; i
++)
828 *p
++ = tohex ((myaddr
[i
] >> 4) & 0xf);
829 *p
++ = tohex (myaddr
[i
] & 0xf);
838 /* There is no correspondance between what the remote protocol uses
839 for errors and errno codes. We would like a cleaner way of
840 representing errors (big enough to include errno codes, bfd_error
841 codes, and others). But for now just return EIO. */
848 /* Read memory data directly from the remote machine.
849 This does not use the data cache; the data cache uses this.
850 MEMADDR is the address in the remote memory space.
851 MYADDR is the address of the buffer in our space.
852 LEN is the number of bytes.
854 Returns number of bytes transferred, or 0 for error. */
857 remote_read_bytes (memaddr
, myaddr
, len
)
859 unsigned char *myaddr
;
866 if (len
> PBUFSIZ
/ 2 - 1)
869 /* FIXME-32x64: Need a version of print_address_numeric which doesn't
870 set use_local (and also puts the result in a buffer like sprintf). */
871 sprintf (buf
, "m%lx,%x", (unsigned long) memaddr
, len
);
877 /* There is no correspondance between what the remote protocol uses
878 for errors and errno codes. We would like a cleaner way of
879 representing errors (big enough to include errno codes, bfd_error
880 codes, and others). But for now just return EIO. */
885 /* Reply describes memory byte by byte,
886 each byte encoded as two hex characters. */
889 for (i
= 0; i
< len
; i
++)
891 if (p
[0] == 0 || p
[1] == 0)
892 /* Reply is short. This means that we were able to read only part
893 of what we wanted to. */
895 myaddr
[i
] = fromhex (p
[0]) * 16 + fromhex (p
[1]);
901 /* Read or write LEN bytes from inferior memory at MEMADDR, transferring
902 to or from debugger address MYADDR. Write to inferior if SHOULD_WRITE is
903 nonzero. Returns length of data written or read; 0 for error. */
907 remote_xfer_memory(memaddr
, myaddr
, len
, should_write
, target
)
912 struct target_ops
*target
; /* ignored */
916 int total_xferred
= 0;
920 if (len
> MAXBUFBYTES
)
921 xfersize
= MAXBUFBYTES
;
926 bytes_xferred
= remote_write_bytes (memaddr
,
927 (unsigned char *)myaddr
, xfersize
);
929 bytes_xferred
= remote_read_bytes (memaddr
,
930 (unsigned char *)myaddr
, xfersize
);
932 /* If we get an error, we are done xferring. */
933 if (bytes_xferred
== 0)
936 memaddr
+= bytes_xferred
;
937 myaddr
+= bytes_xferred
;
938 len
-= bytes_xferred
;
939 total_xferred
+= bytes_xferred
;
941 return total_xferred
;
945 /* Enable after 4.12. */
948 remote_search (len
, data
, mask
, startaddr
, increment
, lorange
, hirange
949 addr_found
, data_found
)
957 CORE_ADDR
*addr_found
;
960 if (increment
== -4 && len
== 4)
962 long mask_long
, data_long
;
963 long data_found_long
;
964 CORE_ADDR addr_we_found
;
966 long returned_long
[2];
969 mask_long
= extract_unsigned_integer (mask
, len
);
970 data_long
= extract_unsigned_integer (data
, len
);
971 sprintf (buf
, "t%x:%x,%x", startaddr
, data_long
, mask_long
);
976 /* The stub doesn't support the 't' request. We might want to
977 remember this fact, but on the other hand the stub could be
978 switched on us. Maybe we should remember it only until
979 the next "target remote". */
980 generic_search (len
, data
, mask
, startaddr
, increment
, lorange
,
981 hirange
, addr_found
, data_found
);
986 /* There is no correspondance between what the remote protocol uses
987 for errors and errno codes. We would like a cleaner way of
988 representing errors (big enough to include errno codes, bfd_error
989 codes, and others). But for now just use EIO. */
990 memory_error (EIO
, startaddr
);
993 while (*p
!= '\0' && *p
!= ',')
994 addr_we_found
= (addr_we_found
<< 4) + fromhex (*p
++);
996 error ("Protocol error: short return for search");
999 while (*p
!= '\0' && *p
!= ',')
1000 data_found_long
= (data_found_long
<< 4) + fromhex (*p
++);
1001 /* Ignore anything after this comma, for future extensions. */
1003 if (addr_we_found
< lorange
|| addr_we_found
>= hirange
)
1009 *addr_found
= addr_we_found
;
1010 *data_found
= store_unsigned_integer (data_we_found
, len
);
1013 generic_search (len
, data
, mask
, startaddr
, increment
, lorange
,
1014 hirange
, addr_found
, data_found
);
1019 remote_files_info (ignore
)
1020 struct target_ops
*ignore
;
1022 puts_filtered ("Debugging a target over a serial line.\n");
1025 /* Stuff for dealing with the packets which are part of this protocol.
1026 See comment at top of file for details. */
1028 /* Read a single character from the remote end, masking it down to 7 bits. */
1035 ch
= SERIAL_READCHAR (remote_desc
, timeout
);
1043 /* Send the command in BUF to the remote machine,
1044 and read the reply into BUF.
1045 Report an error if we get an error reply. */
1056 error ("Remote failure reply: %s", buf
);
1059 /* Send a packet to the remote machine, with error checking.
1060 The data of the packet is in BUF. */
1067 unsigned char csum
= 0;
1069 int cnt
= strlen (buf
);
1073 /* Copy the packet into buffer BUF2, encapsulating it
1074 and giving it a checksum. */
1076 if (cnt
> sizeof(buf2
) - 5) /* Prosanity check */
1082 for (i
= 0; i
< cnt
; i
++)
1088 *p
++ = tohex ((csum
>> 4) & 0xf);
1089 *p
++ = tohex (csum
& 0xf);
1091 /* Send it over and over until we get a positive ack. */
1098 printf_unfiltered ("Sending packet: %s...", buf2
); gdb_flush(gdb_stdout
);
1100 if (SERIAL_WRITE (remote_desc
, buf2
, p
- buf2
))
1101 perror_with_name ("putpkt: write failed");
1103 /* read until either a timeout occurs (-2) or '+' is read */
1112 printf_unfiltered("Ack\n");
1114 case SERIAL_TIMEOUT
:
1115 break; /* Retransmit buffer */
1117 perror_with_name ("putpkt: couldn't read ACK");
1119 error ("putpkt: EOF while trying to read ACK");
1122 printf_unfiltered ("%02X %c ", ch
&0xFF, ch
);
1125 break; /* Here to retransmit */
1129 /* This is wrong. If doing a long backtrace, the user should be
1130 able to get out next time we call QUIT, without anything as violent
1131 as interrupt_query. If we want to provide a way out of here
1132 without getting to the next QUIT, it should be based on hitting
1133 ^C twice as in remote_wait. */
1143 /* Read a packet from the remote machine, with error checking,
1144 and store it in BUF. BUF is expected to be of size PBUFSIZ.
1145 If FOREVER, wait forever rather than timing out; this is used
1146 while the target is executing user code. */
1149 getpkt (retbuf
, forever
)
1156 unsigned char c1
, c2
;
1160 #define MAX_RETRIES 10
1165 /* This is wrong. If doing a long backtrace, the user should be
1166 able to get out time next we call QUIT, without anything as violent
1167 as interrupt_query. If we want to provide a way out of here
1168 without getting to the next QUIT, it should be based on hitting
1169 ^C twice as in remote_wait. */
1177 /* This can loop forever if the remote side sends us characters
1178 continuously, but if it pauses, we'll get a zero from readchar
1179 because of timeout. Then we'll count that as a retry. */
1182 if (c
> 0 && c
!= '$')
1185 if (c
== SERIAL_TIMEOUT
)
1189 if (++retries
>= MAX_RETRIES
)
1190 if (remote_debug
) puts_filtered ("Timed out.\n");
1194 if (c
== SERIAL_EOF
)
1195 error ("Remote connection closed");
1196 if (c
== SERIAL_ERROR
)
1197 perror_with_name ("Remote communication error");
1199 /* Force csum to be zero here because of possible error retry. */
1206 if (c
== SERIAL_TIMEOUT
)
1209 puts_filtered ("Timeout in mid-packet, retrying\n");
1210 goto whole
; /* Start a new packet, count retries */
1215 puts_filtered ("Saw new packet start in middle of old one\n");
1216 goto whole
; /* Start a new packet, count retries */
1220 if (bp
>= buf
+PBUFSIZ
-1)
1223 puts_filtered ("Remote packet too long: ");
1224 puts_filtered (buf
);
1225 puts_filtered ("\n");
1233 c1
= fromhex (readchar ());
1234 c2
= fromhex (readchar ());
1235 if ((csum
& 0xff) == (c1
<< 4) + c2
)
1237 printf_filtered ("Bad checksum, sentsum=0x%x, csum=0x%x, buf=",
1238 (c1
<< 4) + c2
, csum
& 0xff);
1239 puts_filtered (buf
);
1240 puts_filtered ("\n");
1242 /* Try the whole thing again. */
1244 if (++retries
< MAX_RETRIES
)
1246 SERIAL_WRITE (remote_desc
, "-", 1);
1250 printf_unfiltered ("Ignoring packet error, continuing...\n");
1255 /* Deal with run-length encoding. */
1258 char *dest
= retbuf
;
1264 if (src
[1] == '\0' || src
[2] == '\0')
1267 puts_filtered ("Packet too short, retrying\n");
1270 repeat
= (fromhex (src
[1]) << 4) + fromhex (src
[2]);
1271 for (i
= 0; i
< repeat
; ++i
)
1281 } while (*src
++ != '\0');
1285 SERIAL_WRITE (remote_desc
, "+", 1);
1288 fprintf_unfiltered (gdb_stderr
,"Packet received: %s\n", buf
);
1295 /* Don't wait for it to die. I'm not really sure it matters whether
1296 we do or not. For the existing stubs, kill is a noop. */
1297 target_mourn_inferior ();
1303 unpush_target (&remote_ops
);
1304 generic_mourn_inferior ();
1307 #ifdef REMOTE_BREAKPOINT
1309 /* On some machines, e.g. 68k, we may use a different breakpoint instruction
1310 than other targets. */
1311 static unsigned char break_insn
[] = REMOTE_BREAKPOINT
;
1313 /* Check that it fits in BREAKPOINT_MAX bytes. */
1314 static unsigned char check_break_insn_size
[BREAKPOINT_MAX
] = REMOTE_BREAKPOINT
;
1316 #else /* No REMOTE_BREAKPOINT. */
1318 /* Same old breakpoint instruction. This code does nothing different
1319 than mem-break.c. */
1320 static unsigned char break_insn
[] = BREAKPOINT
;
1322 #endif /* No REMOTE_BREAKPOINT. */
1324 /* Insert a breakpoint on targets that don't have any better breakpoint
1325 support. We read the contents of the target location and stash it,
1326 then overwrite it with a breakpoint instruction. ADDR is the target
1327 location in the target machine. CONTENTS_CACHE is a pointer to
1328 memory allocated for saving the target contents. It is guaranteed
1329 by the caller to be long enough to save sizeof BREAKPOINT bytes (this
1330 is accomplished via BREAKPOINT_MAX). */
1333 remote_insert_breakpoint (addr
, contents_cache
)
1335 char *contents_cache
;
1339 val
= target_read_memory (addr
, contents_cache
, sizeof break_insn
);
1342 val
= target_write_memory (addr
, (char *)break_insn
, sizeof break_insn
);
1348 remote_remove_breakpoint (addr
, contents_cache
)
1350 char *contents_cache
;
1352 return target_write_memory (addr
, contents_cache
, sizeof break_insn
);
1355 /* Define the target subroutine names */
1357 struct target_ops remote_ops
= {
1358 "remote", /* to_shortname */
1359 "Remote serial target in gdb-specific protocol", /* to_longname */
1360 "Use a remote computer via a serial line, using a gdb-specific protocol.\n\
1361 Specify the serial device it is connected to (e.g. /dev/ttya).", /* to_doc */
1362 remote_open
, /* to_open */
1363 remote_close
, /* to_close */
1364 NULL
, /* to_attach */
1365 remote_detach
, /* to_detach */
1366 remote_resume
, /* to_resume */
1367 remote_wait
, /* to_wait */
1368 remote_fetch_registers
, /* to_fetch_registers */
1369 remote_store_registers
, /* to_store_registers */
1370 remote_prepare_to_store
, /* to_prepare_to_store */
1371 remote_xfer_memory
, /* to_xfer_memory */
1372 remote_files_info
, /* to_files_info */
1374 remote_insert_breakpoint
, /* to_insert_breakpoint */
1375 remote_remove_breakpoint
, /* to_remove_breakpoint */
1377 NULL
, /* to_terminal_init */
1378 NULL
, /* to_terminal_inferior */
1379 NULL
, /* to_terminal_ours_for_output */
1380 NULL
, /* to_terminal_ours */
1381 NULL
, /* to_terminal_info */
1382 remote_kill
, /* to_kill */
1383 generic_load
, /* to_load */
1384 NULL
, /* to_lookup_symbol */
1385 NULL
, /* to_create_inferior */
1386 remote_mourn
, /* to_mourn_inferior */
1388 0, /* to_notice_signals */
1389 process_stratum
, /* to_stratum */
1391 1, /* to_has_all_memory */
1392 1, /* to_has_memory */
1393 1, /* to_has_stack */
1394 1, /* to_has_registers */
1395 1, /* to_has_execution */
1396 NULL
, /* sections */
1397 NULL
, /* sections_end */
1398 OPS_MAGIC
/* to_magic */
1400 #endif /* Use remote. */
1403 _initialize_remote ()
1405 #if !defined(DONT_USE_REMOTE)
1406 add_target (&remote_ops
);