1 /* Remote target communications for serial-line targets in custom GDB protocol
2 Copyright 1988, 1991, 1992, 1993, 1994, 1995 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
28 '$' or '#'. If <data> starts with two characters followed by
29 ':', then the existing stubs interpret this as a sequence number.
31 CSUM1 and CSUM2 are ascii hex representation of an 8-bit
32 checksum of <data>, the most significant nibble is sent first.
33 the hex digits 0-9,a-f are used.
35 Receiver responds with:
37 + - if CSUM is correct and ready for next packet
38 - - if CSUM is incorrect
41 Most values are encoded in ascii hex digits. Signal numbers are according
42 to the numbering in target.h.
46 set thread Hct... Set thread for subsequent operations.
47 c = 'c' for thread used in step and
48 continue; t... can be -1 for all
50 c = 'g' for thread used in other
51 operations. If zero, pick a thread,
57 reply XX....X Each byte of register data
58 is described by two hex digits.
59 Registers are in the internal order
60 for GDB, and the bytes in a register
61 are in the same order the machine uses.
64 write regs GXX..XX Each byte of register data
65 is described by two hex digits.
69 write reg Pn...=r... Write register n... with value r...,
70 which contains two hex digits for each
71 byte in the register (target byte
75 (not supported by all stubs).
77 read mem mAA..AA,LLLL AA..AA is address, LLLL is length.
78 reply XX..XX XX..XX is mem contents
79 Can be fewer bytes than requested
80 if able to read only part of the data.
83 write mem MAA..AA,LLLL:XX..XX
85 LLLL is number of bytes,
88 ENN for an error (this includes the case
89 where only part of the data was
92 continue cAA..AA AA..AA is address to resume
94 resume at same address.
96 step sAA..AA AA..AA is address to resume
98 resume at same address.
100 continue with Csig;AA Continue with signal sig (hex signal
103 step with Ssig;AA Like 'C' but step not continue.
106 last signal ? Reply the current reason for stopping.
107 This is the same reply as is generated
108 for step or cont : SAA where AA is the
111 There is no immediate reply to step or cont.
112 The reply comes when the machine stops.
113 It is SAA AA is the signal number.
115 or... TAAn...:r...;n...:r...;n...:r...;
117 n... = register number (hex)
118 r... = register contents
120 r... = thread process ID. This is
122 n... = other string not starting
123 with valid hex digit.
124 gdb should ignore this n,r pair
125 and go on to the next. This way
126 we can extend the protocol.
127 or... WAA The process exited, and AA is
128 the exit status. This is only
129 applicable for certains sorts of
131 or... XAA The process terminated with signal
133 or... Otext Send text to stdout. This can happen
134 at any time while the program is
135 running and the debugger should
136 continue to wait for 'W', 'T', etc.
140 toggle debug d toggle debug flag (see 386 & 68k stubs)
141 reset r reset -- see sparc stub.
142 reserved <other> On other requests, the stub should
143 ignore the request and send an empty
144 response ($#<checksum>). This way
145 we can extend the protocol and GDB
146 can tell whether the stub it is
147 talking to uses the old or the new.
148 search tAA:PP,MM Search backwards starting at address
149 AA for a match with pattern PP and
150 mask MM. PP and MM are 4 bytes.
151 Not supported by all stubs.
153 general query qXXXX Request info about XXXX.
154 general set QXXXX=yyyy Set value of XXXX to yyyy.
155 query sect offs qOffsets Get section offsets. Reply is
156 Text=xxx;Data=yyy;Bss=zzz
158 Responses can be run-length encoded to save space. A '*' means that
159 the next character is an ASCII encoding giving a repeat count which
160 stands for that many repititions of the character preceding the '*'.
161 The encoding is n+29, yielding a printable character where n >=3
162 (which is where rle starts to win). Don't use an n > 126.
165 "0* " means the same as "0000". */
171 #include "inferior.h"
176 #include "terminal.h"
178 #include "objfiles.h"
179 #include "gdb-stabs.h"
185 #include <sys/types.h>
191 /* Prototypes for local functions */
193 static int remote_write_bytes
PARAMS ((CORE_ADDR memaddr
,
194 unsigned char *myaddr
, int len
));
196 static int remote_read_bytes
PARAMS ((CORE_ADDR memaddr
,
197 unsigned char *myaddr
, int len
));
199 static void remote_files_info
PARAMS ((struct target_ops
*ignore
));
201 static int remote_xfer_memory
PARAMS ((CORE_ADDR memaddr
, char *myaddr
,
202 int len
, int should_write
,
203 struct target_ops
*target
));
205 static void remote_prepare_to_store
PARAMS ((void));
207 static void remote_fetch_registers
PARAMS ((int regno
));
209 static void remote_resume
PARAMS ((int pid
, int step
,
210 enum target_signal siggnal
));
212 static int remote_start_remote
PARAMS ((char *dummy
));
214 static void remote_open
PARAMS ((char *name
, int from_tty
));
216 static void remote_close
PARAMS ((int quitting
));
218 static void remote_store_registers
PARAMS ((int regno
));
220 static void getpkt
PARAMS ((char *buf
, int forever
));
222 static int putpkt
PARAMS ((char *buf
));
224 static void remote_send
PARAMS ((char *buf
));
226 static int readchar
PARAMS ((int timeout
));
228 static int remote_wait
PARAMS ((int pid
, struct target_waitstatus
*status
));
230 static void remote_kill
PARAMS ((void));
232 static int tohex
PARAMS ((int nib
));
234 static int fromhex
PARAMS ((int a
));
236 static void remote_detach
PARAMS ((char *args
, int from_tty
));
238 static void remote_interrupt
PARAMS ((int signo
));
240 static void remote_interrupt_twice
PARAMS ((int signo
));
242 static void interrupt_query
PARAMS ((void));
244 extern struct target_ops remote_ops
; /* Forward decl */
246 /* This was 5 seconds, which is a long time to sit and wait.
247 Unless this is going though some terminal server or multiplexer or
248 other form of hairy serial connection, I would think 2 seconds would
251 static int remote_timeout
= 2;
253 /* Descriptor for I/O to remote machine. Initialize it to NULL so that
254 remote_open knows that we don't have a file open when the program
256 serial_t remote_desc
= NULL
;
258 /* Having this larger than 400 causes us to be incompatible with m68k-stub.c
259 and i386-stub.c. Normally, no one would notice because it only matters
260 for writing large chunks of memory (e.g. in downloads). Also, this needs
261 to be more than 400 if required to hold the registers (see below, where
262 we round it up based on REGISTER_BYTES). */
265 /* Maximum number of bytes to read/write at once. The value here
266 is chosen to fill up a packet (the headers account for the 32). */
267 #define MAXBUFBYTES ((PBUFSIZ-32)/2)
269 /* Round up PBUFSIZ to hold all the registers, at least. */
270 /* The blank line after the #if seems to be required to work around a
271 bug in HP's PA compiler. */
272 #if REGISTER_BYTES > MAXBUFBYTES
275 #define PBUFSIZ (REGISTER_BYTES * 2 + 32)
278 /* Should we try the 'P' request? If this is set to one when the stub
279 doesn't support 'P', the only consequence is some unnecessary traffic. */
280 static int stub_supports_P
= 1;
283 /* These are the threads which we last sent to the remote system. -1 for all
284 or -2 for not sent yet. */
294 int state
= gen
? general_thread
: cont_thread
;
298 buf
[1] = gen
? 'g' : 'c';
305 sprintf (&buf
[2], "-%x", -th
);
307 sprintf (&buf
[2], "%x", th
);
316 /* Clean up connection to a remote debugger. */
320 remote_close (quitting
)
324 SERIAL_CLOSE (remote_desc
);
328 /* Query the remote side for the text, data and bss offsets. */
335 CORE_ADDR text_addr
, data_addr
, bss_addr
;
336 struct section_offsets
*offs
;
342 if (buf
[0] == '\000')
343 return; /* Return silently. Stub doesn't support this
347 warning ("Remote failure reply: %s", buf
);
351 nvals
= sscanf (buf
, "Text=%lx;Data=%lx;Bss=%lx", &text_addr
, &data_addr
,
354 error ("Malformed response to offset query, %s", buf
);
356 if (symfile_objfile
== NULL
)
359 offs
= (struct section_offsets
*) alloca (sizeof (struct section_offsets
)
360 + symfile_objfile
->num_sections
361 * sizeof (offs
->offsets
));
362 memcpy (offs
, symfile_objfile
->section_offsets
,
363 sizeof (struct section_offsets
)
364 + symfile_objfile
->num_sections
365 * sizeof (offs
->offsets
));
367 ANOFFSET (offs
, SECT_OFF_TEXT
) = text_addr
;
369 /* This is a temporary kludge to force data and bss to use the same offsets
370 because that's what nlmconv does now. The real solution requires changes
371 to the stub and remote.c that I don't have time to do right now. */
373 ANOFFSET (offs
, SECT_OFF_DATA
) = data_addr
;
374 ANOFFSET (offs
, SECT_OFF_BSS
) = data_addr
;
376 objfile_relocate (symfile_objfile
, offs
);
379 /* Stub for catch_errors. */
382 remote_start_remote (dummy
)
385 immediate_quit
= 1; /* Allow user to interrupt it */
387 /* Ack any packet which the remote side has already sent. */
388 SERIAL_WRITE (remote_desc
, "+", 1);
390 /* Let the stub know that we want it to return the thread. */
393 get_offsets (); /* Get text, data & bss offsets */
395 putpkt ("?"); /* initiate a query from remote machine */
398 start_remote (); /* Initialize gdb process mechanisms */
402 /* Open a connection to a remote debugger.
403 NAME is the filename used for communication. */
405 static DCACHE
*remote_dcache
;
408 remote_open (name
, from_tty
)
413 error ("To open a remote debug connection, you need to specify what serial\n\
414 device is attached to the remote system (e.g. /dev/ttya).");
416 target_preopen (from_tty
);
418 unpush_target (&remote_ops
);
420 remote_dcache
= dcache_init (remote_read_bytes
, remote_write_bytes
);
422 remote_desc
= SERIAL_OPEN (name
);
424 perror_with_name (name
);
428 if (SERIAL_SETBAUDRATE (remote_desc
, baud_rate
))
430 SERIAL_CLOSE (remote_desc
);
431 perror_with_name (name
);
436 SERIAL_RAW (remote_desc
);
438 /* If there is something sitting in the buffer we might take it as a
439 response to a command, which would be bad. */
440 SERIAL_FLUSH_INPUT (remote_desc
);
444 puts_filtered ("Remote debugging using ");
445 puts_filtered (name
);
446 puts_filtered ("\n");
448 push_target (&remote_ops
); /* Switch to using remote target now */
450 /* Start out by trying the 'P' request to set registers. We set this each
451 time that we open a new target so that if the user switches from one
452 stub to another, we can (if the target is closed and reopened) cope. */
458 /* Without this, some commands which require an active target (such as kill)
459 won't work. This variable serves (at least) double duty as both the pid
460 of the target process (if it has such), and as a flag indicating that a
461 target is active. These functions should be split out into seperate
462 variables, especially since GDB will someday have a notion of debugging
463 several processes. */
465 inferior_pid
= 42000;
466 /* Start the remote connection; if error (0), discard this target.
467 In particular, if the user quits, be sure to discard it
468 (we'd be in an inconsistent state otherwise). */
469 if (!catch_errors (remote_start_remote
, (char *)0,
470 "Couldn't establish connection to remote target\n", RETURN_MASK_ALL
))
475 takes a program previously attached to and detaches it.
476 We better not have left any breakpoints
477 in the program or it'll die when it hits one.
478 Close the open connection to the remote debugger.
479 Use this when you want to detach and do something else
483 remote_detach (args
, from_tty
)
488 error ("Argument given to \"detach\" when remotely debugging.");
492 puts_filtered ("Ending remote debugging.\n");
495 /* Convert hex digit A to a number. */
501 if (a
>= '0' && a
<= '9')
503 else if (a
>= 'a' && a
<= 'f')
506 error ("Reply contains invalid hex digit %d", a
);
509 /* Convert number NIB to a hex digit. */
521 /* Tell the remote machine to resume. */
523 static enum target_signal last_sent_signal
= TARGET_SIGNAL_0
;
527 remote_resume (pid
, step
, siggnal
)
529 enum target_signal siggnal
;
534 set_thread (inferior_pid
, 0);
538 dcache_flush (remote_dcache
);
540 last_sent_signal
= siggnal
;
541 last_sent_step
= step
;
543 if (siggnal
!= TARGET_SIGNAL_0
)
545 buf
[0] = step
? 'S' : 'C';
546 buf
[1] = tohex (((int)siggnal
>> 4) & 0xf);
547 buf
[2] = tohex ((int)siggnal
& 0xf);
551 strcpy (buf
, step
? "s": "c");
556 /* Send ^C to target to halt it. Target will respond, and send us a
560 remote_interrupt (signo
)
563 /* If this doesn't work, try more severe steps. */
564 signal (signo
, remote_interrupt_twice
);
567 printf_unfiltered ("remote_interrupt called\n");
569 SERIAL_WRITE (remote_desc
, "\003", 1); /* Send a ^C */
572 static void (*ofunc
)();
574 /* The user typed ^C twice. */
576 remote_interrupt_twice (signo
)
579 signal (signo
, ofunc
);
583 signal (signo
, remote_interrupt
);
586 /* Ask the user what to do when an interrupt is received. */
591 target_terminal_ours ();
593 if (query ("Interrupted while waiting for the program.\n\
594 Give up (and stop debugging it)? "))
596 target_mourn_inferior ();
597 return_to_top_level (RETURN_QUIT
);
600 target_terminal_inferior ();
603 /* If nonzero, ignore the next kill. */
606 /* Wait until the remote machine stops, then return,
607 storing status in STATUS just as `wait' would.
608 Returns "pid" (though it's not clear what, if anything, that
609 means in the case of this target). */
612 remote_wait (pid
, status
)
614 struct target_waitstatus
*status
;
616 unsigned char buf
[PBUFSIZ
];
619 status
->kind
= TARGET_WAITKIND_EXITED
;
620 status
->value
.integer
= 0;
626 ofunc
= (void (*)()) signal (SIGINT
, remote_interrupt
);
627 getpkt ((char *) buf
, 1);
628 signal (SIGINT
, ofunc
);
632 case 'E': /* Error of some sort */
633 warning ("Remote failure reply: %s", buf
);
635 case 'T': /* Status with PC, SP, FP, ... */
639 char regs
[MAX_REGISTER_RAW_SIZE
];
641 /* Expedited reply, containing Signal, {regno, reg} repeat */
642 /* format is: 'Tssn...:r...;n...:r...;n...:r...;#cc', where
644 n... = register number
645 r... = register contents
648 p
= &buf
[3]; /* after Txx */
655 regno
= strtol (p
, &p_temp
, 16); /* Read the register number */
656 p1
= (unsigned char *)p_temp
;
660 p1
= (unsigned char *) strchr (p
, ':');
662 warning ("Malformed packet (missing colon): %s\n\
665 if (strncmp (p
, "thread", p1
- p
) == 0)
667 thread_num
= strtol (++p1
, &p_temp
, 16);
668 p
= (unsigned char *)p_temp
;
676 warning ("Malformed packet (missing colon): %s\n\
680 if (regno
>= NUM_REGS
)
681 warning ("Remote sent bad register number %d: %s\n\
685 for (i
= 0; i
< REGISTER_RAW_SIZE (regno
); i
++)
687 if (p
[0] == 0 || p
[1] == 0)
688 warning ("Remote reply is too short: %s", buf
);
689 regs
[i
] = fromhex (p
[0]) * 16 + fromhex (p
[1]);
692 supply_register (regno
, regs
);
696 warning ("Remote register badly formatted: %s", buf
);
700 case 'S': /* Old style status, just signal only */
701 status
->kind
= TARGET_WAITKIND_STOPPED
;
702 status
->value
.sig
= (enum target_signal
)
703 (((fromhex (buf
[1])) << 4) + (fromhex (buf
[2])));
706 case 'W': /* Target exited */
708 /* The remote process exited. */
709 status
->kind
= TARGET_WAITKIND_EXITED
;
710 status
->value
.integer
= (fromhex (buf
[1]) << 4) + fromhex (buf
[2]);
714 status
->kind
= TARGET_WAITKIND_SIGNALLED
;
715 status
->value
.sig
= (enum target_signal
)
716 (((fromhex (buf
[1])) << 4) + (fromhex (buf
[2])));
720 case 'O': /* Console output */
721 fputs_filtered ((char *)(buf
+ 1), gdb_stdout
);
724 if (last_sent_signal
!= TARGET_SIGNAL_0
)
726 /* Zero length reply means that we tried 'S' or 'C' and
727 the remote system doesn't support it. */
728 target_terminal_ours_for_output ();
730 ("Can't send signals to this remote system. %s not sent.\n",
731 target_signal_to_name (last_sent_signal
));
732 last_sent_signal
= TARGET_SIGNAL_0
;
733 target_terminal_inferior ();
735 strcpy (buf
, last_sent_step
? "s" : "c");
739 /* else fallthrough */
741 warning ("Invalid remote reply: %s", buf
);
746 if (thread_num
!= -1)
748 /* Initial thread value can only be acquired via wait, so deal with
749 this marker which is used before the first thread value is
751 if (inferior_pid
== 42000)
753 inferior_pid
= thread_num
;
754 add_thread (inferior_pid
);
761 /* Number of bytes of registers this stub implements. */
762 static int register_bytes_found
;
764 /* Read the remote registers into the block REGS. */
765 /* Currently we just read all the registers, so we don't use regno. */
768 remote_fetch_registers (regno
)
774 char regs
[REGISTER_BYTES
];
776 set_thread (inferior_pid
, 1);
781 /* Unimplemented registers read as all bits zero. */
782 memset (regs
, 0, REGISTER_BYTES
);
784 /* We can get out of synch in various cases. If the first character
785 in the buffer is not a hex character, assume that has happened
786 and try to fetch another packet to read. */
787 while ((buf
[0] < '0' || buf
[0] > '9')
788 && (buf
[0] < 'a' || buf
[0] > 'f'))
791 printf_unfiltered ("Bad register packet; fetching a new packet\n");
795 /* Reply describes registers byte by byte, each byte encoded as two
796 hex characters. Suck them all up, then supply them to the
797 register cacheing/storage mechanism. */
800 for (i
= 0; i
< REGISTER_BYTES
; i
++)
806 warning ("Remote reply is of odd length: %s", buf
);
807 /* Don't change register_bytes_found in this case, and don't
808 print a second warning. */
811 regs
[i
] = fromhex (p
[0]) * 16 + fromhex (p
[1]);
815 if (i
!= register_bytes_found
)
817 register_bytes_found
= i
;
818 #ifdef REGISTER_BYTES_OK
819 if (!REGISTER_BYTES_OK (i
))
820 warning ("Remote reply is too short: %s", buf
);
825 for (i
= 0; i
< NUM_REGS
; i
++)
826 supply_register (i
, ®s
[REGISTER_BYTE(i
)]);
829 /* Prepare to store registers. Since we may send them all (using a
830 'G' request), we have to read out the ones we don't want to change
834 remote_prepare_to_store ()
836 /* Make sure the entire registers array is valid. */
837 read_register_bytes (0, (char *)NULL
, REGISTER_BYTES
);
840 /* Store register REGNO, or all registers if REGNO == -1, from the contents
841 of REGISTERS. FIXME: ignores errors. */
844 remote_store_registers (regno
)
851 set_thread (inferior_pid
, 1);
853 if (regno
>= 0 && stub_supports_P
)
855 /* Try storing a single register. */
858 sprintf (buf
, "P%x=", regno
);
859 p
= buf
+ strlen (buf
);
860 regp
= ®isters
[REGISTER_BYTE (regno
)];
861 for (i
= 0; i
< REGISTER_RAW_SIZE (regno
); ++i
)
863 *p
++ = tohex ((regp
[i
] >> 4) & 0xf);
864 *p
++ = tohex (regp
[i
] & 0xf);
870 /* The stub understands the 'P' request. We are done. */
874 /* The stub does not support the 'P' request. Use 'G' instead,
875 and don't try using 'P' in the future (it will just waste our
882 /* Command describes registers byte by byte,
883 each byte encoded as two hex characters. */
886 /* remote_prepare_to_store insures that register_bytes_found gets set. */
887 for (i
= 0; i
< register_bytes_found
; i
++)
889 *p
++ = tohex ((registers
[i
] >> 4) & 0xf);
890 *p
++ = tohex (registers
[i
] & 0xf);
898 Use of the data cache *used* to be disabled because it loses for looking at
899 and changing hardware I/O ports and the like. Accepting `volatile'
900 would perhaps be one way to fix it. Another idea would be to use the
901 executable file for the text segment (for all SEC_CODE sections?
902 For all SEC_READONLY sections?). This has problems if you want to
903 actually see what the memory contains (e.g. self-modifying code,
904 clobbered memory, user downloaded the wrong thing).
906 Because it speeds so much up, it's now enabled, if you're playing
907 with registers you turn it of (set remotecache 0)
910 /* Read a word from remote address ADDR and return it.
911 This goes through the data cache. */
914 remote_fetch_word (addr
)
917 return dcache_fetch (remote_dcache
, addr
);
920 /* Write a word WORD into remote address ADDR.
921 This goes through the data cache. */
924 remote_store_word (addr
, word
)
928 dcache_poke (remote_dcache
, addr
, word
);
932 /* Write memory data directly to the remote machine.
933 This does not inform the data cache; the data cache uses this.
934 MEMADDR is the address in the remote memory space.
935 MYADDR is the address of the buffer in our space.
936 LEN is the number of bytes.
938 Returns number of bytes transferred, or 0 for error. */
941 remote_write_bytes (memaddr
, myaddr
, len
)
943 unsigned char *myaddr
;
950 /* FIXME-32x64: Need a version of print_address_numeric which puts the
951 result in a buffer like sprintf. */
952 sprintf (buf
, "M%lx,%x:", (unsigned long) memaddr
, len
);
954 /* We send target system values byte by byte, in increasing byte addresses,
955 each byte encoded as two hex characters. */
957 p
= buf
+ strlen (buf
);
958 for (i
= 0; i
< len
; i
++)
960 *p
++ = tohex ((myaddr
[i
] >> 4) & 0xf);
961 *p
++ = tohex (myaddr
[i
] & 0xf);
970 /* There is no correspondance between what the remote protocol uses
971 for errors and errno codes. We would like a cleaner way of
972 representing errors (big enough to include errno codes, bfd_error
973 codes, and others). But for now just return EIO. */
980 /* Read memory data directly from the remote machine.
981 This does not use the data cache; the data cache uses this.
982 MEMADDR is the address in the remote memory space.
983 MYADDR is the address of the buffer in our space.
984 LEN is the number of bytes.
986 Returns number of bytes transferred, or 0 for error. */
989 remote_read_bytes (memaddr
, myaddr
, len
)
991 unsigned char *myaddr
;
998 if (len
> PBUFSIZ
/ 2 - 1)
1001 /* FIXME-32x64: Need a version of print_address_numeric which puts the
1002 result in a buffer like sprintf. */
1003 sprintf (buf
, "m%lx,%x", (unsigned long) memaddr
, len
);
1009 /* There is no correspondance between what the remote protocol uses
1010 for errors and errno codes. We would like a cleaner way of
1011 representing errors (big enough to include errno codes, bfd_error
1012 codes, and others). But for now just return EIO. */
1017 /* Reply describes memory byte by byte,
1018 each byte encoded as two hex characters. */
1021 for (i
= 0; i
< len
; i
++)
1023 if (p
[0] == 0 || p
[1] == 0)
1024 /* Reply is short. This means that we were able to read only part
1025 of what we wanted to. */
1027 myaddr
[i
] = fromhex (p
[0]) * 16 + fromhex (p
[1]);
1033 /* Read or write LEN bytes from inferior memory at MEMADDR, transferring
1034 to or from debugger address MYADDR. Write to inferior if SHOULD_WRITE is
1035 nonzero. Returns length of data written or read; 0 for error. */
1039 remote_xfer_memory(memaddr
, myaddr
, len
, should_write
, target
)
1044 struct target_ops
*target
; /* ignored */
1046 return dcache_xfer_memory (remote_dcache
, memaddr
, myaddr
, len
, should_write
);
1051 /* Enable after 4.12. */
1054 remote_search (len
, data
, mask
, startaddr
, increment
, lorange
, hirange
1055 addr_found
, data_found
)
1059 CORE_ADDR startaddr
;
1063 CORE_ADDR
*addr_found
;
1066 if (increment
== -4 && len
== 4)
1068 long mask_long
, data_long
;
1069 long data_found_long
;
1070 CORE_ADDR addr_we_found
;
1072 long returned_long
[2];
1075 mask_long
= extract_unsigned_integer (mask
, len
);
1076 data_long
= extract_unsigned_integer (data
, len
);
1077 sprintf (buf
, "t%x:%x,%x", startaddr
, data_long
, mask_long
);
1082 /* The stub doesn't support the 't' request. We might want to
1083 remember this fact, but on the other hand the stub could be
1084 switched on us. Maybe we should remember it only until
1085 the next "target remote". */
1086 generic_search (len
, data
, mask
, startaddr
, increment
, lorange
,
1087 hirange
, addr_found
, data_found
);
1092 /* There is no correspondance between what the remote protocol uses
1093 for errors and errno codes. We would like a cleaner way of
1094 representing errors (big enough to include errno codes, bfd_error
1095 codes, and others). But for now just use EIO. */
1096 memory_error (EIO
, startaddr
);
1099 while (*p
!= '\0' && *p
!= ',')
1100 addr_we_found
= (addr_we_found
<< 4) + fromhex (*p
++);
1102 error ("Protocol error: short return for search");
1104 data_found_long
= 0;
1105 while (*p
!= '\0' && *p
!= ',')
1106 data_found_long
= (data_found_long
<< 4) + fromhex (*p
++);
1107 /* Ignore anything after this comma, for future extensions. */
1109 if (addr_we_found
< lorange
|| addr_we_found
>= hirange
)
1115 *addr_found
= addr_we_found
;
1116 *data_found
= store_unsigned_integer (data_we_found
, len
);
1119 generic_search (len
, data
, mask
, startaddr
, increment
, lorange
,
1120 hirange
, addr_found
, data_found
);
1125 remote_files_info (ignore
)
1126 struct target_ops
*ignore
;
1128 puts_filtered ("Debugging a target over a serial line.\n");
1131 /* Stuff for dealing with the packets which are part of this protocol.
1132 See comment at top of file for details. */
1134 /* Read a single character from the remote end, masking it down to 7 bits. */
1142 ch
= SERIAL_READCHAR (remote_desc
, timeout
);
1147 error ("Remote connection closed");
1149 perror_with_name ("Remote communication error");
1150 case SERIAL_TIMEOUT
:
1157 /* Send the command in BUF to the remote machine,
1158 and read the reply into BUF.
1159 Report an error if we get an error reply. */
1169 error ("Remote failure reply: %s", buf
);
1172 /* Send a packet to the remote machine, with error checking.
1173 The data of the packet is in BUF. */
1180 unsigned char csum
= 0;
1182 int cnt
= strlen (buf
);
1187 /* Copy the packet into buffer BUF2, encapsulating it
1188 and giving it a checksum. */
1190 if (cnt
> sizeof(buf2
) - 5) /* Prosanity check */
1196 for (i
= 0; i
< cnt
; i
++)
1202 *p
++ = tohex ((csum
>> 4) & 0xf);
1203 *p
++ = tohex (csum
& 0xf);
1205 /* Send it over and over until we get a positive ack. */
1209 int started_error_output
= 0;
1214 printf_unfiltered ("Sending packet: %s...", buf2
);
1215 gdb_flush(gdb_stdout
);
1217 if (SERIAL_WRITE (remote_desc
, buf2
, p
- buf2
))
1218 perror_with_name ("putpkt: write failed");
1220 /* read until either a timeout occurs (-2) or '+' is read */
1223 ch
= readchar (remote_timeout
);
1230 case SERIAL_TIMEOUT
:
1232 if (started_error_output
)
1234 putchar_unfiltered ('\n');
1235 started_error_output
= 0;
1244 printf_unfiltered("Ack\n");
1246 case SERIAL_TIMEOUT
:
1250 break; /* Retransmit buffer */
1253 char junkbuf
[PBUFSIZ
];
1255 /* It's probably an old response, and we're out of sync. Just
1256 gobble up the packet and ignore it. */
1257 getpkt (junkbuf
, 0);
1258 continue; /* Now, go look for + */
1263 if (!started_error_output
)
1265 started_error_output
= 1;
1266 printf_unfiltered ("putpkt: Junk: ");
1268 putchar_unfiltered (ch
& 0177);
1272 break; /* Here to retransmit */
1276 /* This is wrong. If doing a long backtrace, the user should be
1277 able to get out next time we call QUIT, without anything as violent
1278 as interrupt_query. If we want to provide a way out of here
1279 without getting to the next QUIT, it should be based on hitting
1280 ^C twice as in remote_wait. */
1290 /* Come here after finding the start of the frame. Collect the rest into BUF,
1291 verifying the checksum, length, and handling run-length compression.
1292 Returns 0 on any error, 1 on success. */
1307 c
= readchar (remote_timeout
);
1311 case SERIAL_TIMEOUT
:
1313 puts_filtered ("Timeout in mid-packet, retrying\n");
1317 puts_filtered ("Saw new packet start in middle of old one\n");
1318 return 0; /* Start a new packet, count retries */
1321 unsigned char pktcsum
;
1325 pktcsum
= fromhex (readchar (remote_timeout
)) << 4;
1326 pktcsum
|= fromhex (readchar (remote_timeout
));
1328 if (csum
== pktcsum
)
1333 printf_filtered ("Bad checksum, sentsum=0x%x, csum=0x%x, buf=",
1335 puts_filtered (buf
);
1336 puts_filtered ("\n");
1340 case '*': /* Run length encoding */
1342 c
= readchar (remote_timeout
);
1344 c
= c
- ' ' + 3; /* Compute repeat count */
1347 if (c
> 0 && c
< 255 && bp
+ c
- 1 < buf
+ PBUFSIZ
- 1)
1349 memset (bp
, *(bp
- 1), c
);
1355 printf_filtered ("Repeat count %d too large for buffer: ", c
);
1356 puts_filtered (buf
);
1357 puts_filtered ("\n");
1361 if (bp
< buf
+ PBUFSIZ
- 1)
1369 puts_filtered ("Remote packet too long: ");
1370 puts_filtered (buf
);
1371 puts_filtered ("\n");
1378 /* Read a packet from the remote machine, with error checking,
1379 and store it in BUF. BUF is expected to be of size PBUFSIZ.
1380 If FOREVER, wait forever rather than timing out; this is used
1381 while the target is executing user code. */
1384 getpkt (buf
, forever
)
1394 strcpy (buf
,"timeout");
1398 #ifdef MAINTENANCE_CMDS
1399 timeout
= watchdog
> 0 ? watchdog
: -1;
1406 timeout
= remote_timeout
;
1410 for (tries
= 1; tries
<= MAX_TRIES
; tries
++)
1412 /* This can loop forever if the remote side sends us characters
1413 continuously, but if it pauses, we'll get a zero from readchar
1414 because of timeout. Then we'll count that as a retry. */
1416 /* Note that we will only wait forever prior to the start of a packet.
1417 After that, we expect characters to arrive at a brisk pace. They
1418 should show up within remote_timeout intervals. */
1422 c
= readchar (timeout
);
1424 if (c
== SERIAL_TIMEOUT
)
1426 #ifdef MAINTENANCE_CMDS
1427 if (forever
) /* Watchdog went off. Kill the target. */
1429 target_mourn_inferior ();
1430 error ("Watchdog has expired. Target detached.\n");
1434 puts_filtered ("Timed out.\n");
1440 /* We've found the start of a packet, now collect the data. */
1442 val
= read_frame (buf
);
1447 fprintf_unfiltered (gdb_stderr
, "Packet received: %s\n", buf
);
1448 SERIAL_WRITE (remote_desc
, "+", 1);
1452 /* Try the whole thing again. */
1454 SERIAL_WRITE (remote_desc
, "-", 1);
1457 /* We have tried hard enough, and just can't receive the packet. Give up. */
1459 printf_unfiltered ("Ignoring packet error, continuing...\n");
1460 SERIAL_WRITE (remote_desc
, "+", 1);
1466 /* For some mysterious reason, wait_for_inferior calls kill instead of
1467 mourn after it gets TARGET_WAITKIND_SIGNALLED. Work around it. */
1471 target_mourn_inferior ();
1475 /* Use catch_errors so the user can quit from gdb even when we aren't on
1476 speaking terms with the remote system. */
1477 catch_errors (putpkt
, "k", "", RETURN_MASK_ERROR
);
1479 /* Don't wait for it to die. I'm not really sure it matters whether
1480 we do or not. For the existing stubs, kill is a noop. */
1481 target_mourn_inferior ();
1487 unpush_target (&remote_ops
);
1488 generic_mourn_inferior ();
1491 #ifdef REMOTE_BREAKPOINT
1493 /* On some machines, e.g. 68k, we may use a different breakpoint instruction
1494 than other targets. */
1495 static unsigned char break_insn
[] = REMOTE_BREAKPOINT
;
1497 /* Check that it fits in BREAKPOINT_MAX bytes. */
1498 static unsigned char check_break_insn_size
[BREAKPOINT_MAX
] = REMOTE_BREAKPOINT
;
1500 #else /* No REMOTE_BREAKPOINT. */
1502 /* Same old breakpoint instruction. This code does nothing different
1503 than mem-break.c. */
1504 static unsigned char break_insn
[] = BREAKPOINT
;
1506 #endif /* No REMOTE_BREAKPOINT. */
1508 /* Insert a breakpoint on targets that don't have any better breakpoint
1509 support. We read the contents of the target location and stash it,
1510 then overwrite it with a breakpoint instruction. ADDR is the target
1511 location in the target machine. CONTENTS_CACHE is a pointer to
1512 memory allocated for saving the target contents. It is guaranteed
1513 by the caller to be long enough to save sizeof BREAKPOINT bytes (this
1514 is accomplished via BREAKPOINT_MAX). */
1517 remote_insert_breakpoint (addr
, contents_cache
)
1519 char *contents_cache
;
1523 val
= target_read_memory (addr
, contents_cache
, sizeof break_insn
);
1526 val
= target_write_memory (addr
, (char *)break_insn
, sizeof break_insn
);
1532 remote_remove_breakpoint (addr
, contents_cache
)
1534 char *contents_cache
;
1536 return target_write_memory (addr
, contents_cache
, sizeof break_insn
);
1539 /* Define the target subroutine names */
1541 struct target_ops remote_ops
= {
1542 "remote", /* to_shortname */
1543 "Remote serial target in gdb-specific protocol", /* to_longname */
1544 "Use a remote computer via a serial line, using a gdb-specific protocol.\n\
1545 Specify the serial device it is connected to (e.g. /dev/ttya).", /* to_doc */
1546 remote_open
, /* to_open */
1547 remote_close
, /* to_close */
1548 NULL
, /* to_attach */
1549 remote_detach
, /* to_detach */
1550 remote_resume
, /* to_resume */
1551 remote_wait
, /* to_wait */
1552 remote_fetch_registers
, /* to_fetch_registers */
1553 remote_store_registers
, /* to_store_registers */
1554 remote_prepare_to_store
, /* to_prepare_to_store */
1555 remote_xfer_memory
, /* to_xfer_memory */
1556 remote_files_info
, /* to_files_info */
1558 remote_insert_breakpoint
, /* to_insert_breakpoint */
1559 remote_remove_breakpoint
, /* to_remove_breakpoint */
1561 NULL
, /* to_terminal_init */
1562 NULL
, /* to_terminal_inferior */
1563 NULL
, /* to_terminal_ours_for_output */
1564 NULL
, /* to_terminal_ours */
1565 NULL
, /* to_terminal_info */
1566 remote_kill
, /* to_kill */
1567 generic_load
, /* to_load */
1568 NULL
, /* to_lookup_symbol */
1569 NULL
, /* to_create_inferior */
1570 remote_mourn
, /* to_mourn_inferior */
1572 0, /* to_notice_signals */
1574 process_stratum
, /* to_stratum */
1576 1, /* to_has_all_memory */
1577 1, /* to_has_memory */
1578 1, /* to_has_stack */
1579 1, /* to_has_registers */
1580 1, /* to_has_execution */
1581 NULL
, /* sections */
1582 NULL
, /* sections_end */
1583 OPS_MAGIC
/* to_magic */
1587 _initialize_remote ()
1589 add_target (&remote_ops
);