1 /* Remote utility routines for the remote server for GDB.
2 Copyright (C) 1986-2020 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 3 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, see <http://www.gnu.org/licenses/>. */
24 #include "gdbthread.h"
28 #include "gdbsupport/rsp-low.h"
29 #include "gdbsupport/netstuff.h"
30 #include "gdbsupport/filestuff.h"
31 #include "gdbsupport/gdb-sigmask.h"
34 #include <sys/ioctl.h>
40 #include <netinet/in.h>
43 #include <sys/socket.h>
48 #if HAVE_NETINET_TCP_H
49 #include <netinet/tcp.h>
52 #include <sys/ioctl.h>
60 #include "gdbsupport/gdb_sys_time.h"
63 #include <arpa/inet.h>
71 #ifndef HAVE_SOCKLEN_T
72 typedef int socklen_t
;
75 #ifndef IN_PROCESS_AGENT
77 /* Extra value for readchar_callback. */
79 /* The callback is currently not scheduled. */
83 /* Status of the readchar callback.
84 Either NOT_SCHEDULED or the callback id. */
85 static int readchar_callback
= NOT_SCHEDULED
;
87 static int readchar (void);
88 static void reset_readchar (void);
89 static void reschedule (void);
91 /* A cache entry for a successfully looked-up symbol. */
96 struct sym_cache
*next
;
99 static int remote_is_stdio
= 0;
101 static int remote_desc
= -1;
102 static int listen_desc
= -1;
105 # define read(fd, buf, len) recv (fd, (char *) buf, len, 0)
106 # define write(fd, buf, len) send (fd, (char *) buf, len, 0)
112 return remote_desc
!= -1;
115 /* Return true if the remote connection is over stdio. */
118 remote_connection_is_stdio (void)
120 return remote_is_stdio
;
124 enable_async_notification (int fd
)
126 #if defined(F_SETFL) && defined (FASYNC)
127 int save_fcntl_flags
;
129 save_fcntl_flags
= fcntl (fd
, F_GETFL
, 0);
130 fcntl (fd
, F_SETFL
, save_fcntl_flags
| FASYNC
);
131 #if defined (F_SETOWN)
132 fcntl (fd
, F_SETOWN
, getpid ());
138 handle_accept_event (int err
, gdb_client_data client_data
)
140 struct sockaddr_storage sockaddr
;
141 socklen_t len
= sizeof (sockaddr
);
144 debug_printf ("handling possible accept event\n");
146 remote_desc
= accept (listen_desc
, (struct sockaddr
*) &sockaddr
, &len
);
147 if (remote_desc
== -1)
148 perror_with_name ("Accept failed");
150 /* Enable TCP keep alive process. */
152 setsockopt (remote_desc
, SOL_SOCKET
, SO_KEEPALIVE
,
153 (char *) &tmp
, sizeof (tmp
));
155 /* Tell TCP not to delay small packets. This greatly speeds up
156 interactive response. */
158 setsockopt (remote_desc
, IPPROTO_TCP
, TCP_NODELAY
,
159 (char *) &tmp
, sizeof (tmp
));
162 signal (SIGPIPE
, SIG_IGN
); /* If we don't do this, then gdbserver simply
163 exits when the remote side dies. */
169 close (listen_desc
); /* No longer need this */
171 closesocket (listen_desc
); /* No longer need this */
175 /* Even if !RUN_ONCE no longer notice new connections. Still keep the
176 descriptor open for add_file_handler to wait for a new connection. */
177 delete_file_handler (listen_desc
);
179 /* Convert IP address to string. */
180 char orig_host
[GDB_NI_MAX_ADDR
], orig_port
[GDB_NI_MAX_PORT
];
182 int r
= getnameinfo ((struct sockaddr
*) &sockaddr
, len
,
183 orig_host
, sizeof (orig_host
),
184 orig_port
, sizeof (orig_port
),
185 NI_NUMERICHOST
| NI_NUMERICSERV
);
188 fprintf (stderr
, _("Could not obtain remote address: %s\n"),
191 fprintf (stderr
, _("Remote debugging from host %s, port %s\n"),
192 orig_host
, orig_port
);
194 enable_async_notification (remote_desc
);
196 /* Register the event loop handler. */
197 add_file_handler (remote_desc
, handle_serial_event
, NULL
);
199 /* We have a new GDB connection now. If we were disconnected
200 tracing, there's a window where the target could report a stop
201 event to the event loop, and since we have a connection now, we'd
202 try to send vStopped notifications to GDB. But, don't do that
203 until GDB as selected all-stop/non-stop, and has queried the
204 threads' status ('?'). */
208 /* Prepare for a later connection to a remote debugger.
209 NAME is the filename used for communication. */
212 remote_prepare (const char *name
)
214 client_state
&cs
= get_client_state ();
216 static int winsock_initialized
;
221 if (strcmp (name
, STDIO_CONNECTION_NAME
) == 0)
223 /* We need to record fact that we're using stdio sooner than the
224 call to remote_open so start_inferior knows the connection is
227 cs
.transport_is_reliable
= 1;
231 struct addrinfo hint
;
232 struct addrinfo
*ainfo
;
234 memset (&hint
, 0, sizeof (hint
));
235 /* Assume no prefix will be passed, therefore we should use
237 hint
.ai_family
= AF_UNSPEC
;
238 hint
.ai_socktype
= SOCK_STREAM
;
239 hint
.ai_protocol
= IPPROTO_TCP
;
241 parsed_connection_spec parsed
242 = parse_connection_spec_without_prefix (name
, &hint
);
244 if (parsed
.port_str
.empty ())
246 cs
.transport_is_reliable
= 0;
251 if (!winsock_initialized
)
255 WSAStartup (MAKEWORD (1, 0), &wsad
);
256 winsock_initialized
= 1;
260 int r
= getaddrinfo (parsed
.host_str
.c_str (), parsed
.port_str
.c_str (),
264 error (_("%s: cannot resolve name: %s"), name
, gai_strerror (r
));
266 scoped_free_addrinfo
freeaddrinfo (ainfo
);
268 struct addrinfo
*iter
;
270 for (iter
= ainfo
; iter
!= NULL
; iter
= iter
->ai_next
)
272 listen_desc
= gdb_socket_cloexec (iter
->ai_family
, iter
->ai_socktype
,
275 if (listen_desc
>= 0)
280 perror_with_name ("Can't open socket");
282 /* Allow rapid reuse of this port. */
284 setsockopt (listen_desc
, SOL_SOCKET
, SO_REUSEADDR
, (char *) &tmp
,
287 switch (iter
->ai_family
)
290 ((struct sockaddr_in
*) iter
->ai_addr
)->sin_addr
.s_addr
= INADDR_ANY
;
293 ((struct sockaddr_in6
*) iter
->ai_addr
)->sin6_addr
= in6addr_any
;
296 internal_error (__FILE__
, __LINE__
,
297 _("Invalid 'ai_family' %d\n"), iter
->ai_family
);
300 if (bind (listen_desc
, iter
->ai_addr
, iter
->ai_addrlen
) != 0)
301 perror_with_name ("Can't bind address");
303 if (listen (listen_desc
, 1) != 0)
304 perror_with_name ("Can't listen on socket");
306 cs
.transport_is_reliable
= 1;
309 /* Open a connection to a remote debugger.
310 NAME is the filename used for communication. */
313 remote_open (const char *name
)
315 const char *port_str
;
317 port_str
= strchr (name
, ':');
319 if (port_str
== NULL
)
320 error ("Only HOST:PORT is supported on this platform.");
323 if (strcmp (name
, STDIO_CONNECTION_NAME
) == 0)
325 fprintf (stderr
, "Remote debugging using stdio\n");
327 /* Use stdin as the handle of the connection.
328 We only select on reads, for example. */
329 remote_desc
= fileno (stdin
);
331 enable_async_notification (remote_desc
);
333 /* Register the event loop handler. */
334 add_file_handler (remote_desc
, handle_serial_event
, NULL
);
337 else if (port_str
== NULL
)
341 if (stat (name
, &statbuf
) == 0
342 && (S_ISCHR (statbuf
.st_mode
) || S_ISFIFO (statbuf
.st_mode
)))
343 remote_desc
= open (name
, O_RDWR
);
351 perror_with_name ("Could not open remote device");
355 struct termios termios
;
356 tcgetattr (remote_desc
, &termios
);
361 termios
.c_cflag
&= ~(CSIZE
| PARENB
);
362 termios
.c_cflag
|= CLOCAL
| CS8
;
363 termios
.c_cc
[VMIN
] = 1;
364 termios
.c_cc
[VTIME
] = 0;
366 tcsetattr (remote_desc
, TCSANOW
, &termios
);
370 fprintf (stderr
, "Remote debugging using %s\n", name
);
372 enable_async_notification (remote_desc
);
374 /* Register the event loop handler. */
375 add_file_handler (remote_desc
, handle_serial_event
, NULL
);
377 #endif /* USE_WIN32API */
380 char listen_port
[GDB_NI_MAX_PORT
];
381 struct sockaddr_storage sockaddr
;
382 socklen_t len
= sizeof (sockaddr
);
384 if (getsockname (listen_desc
, (struct sockaddr
*) &sockaddr
, &len
) < 0)
385 perror_with_name ("Can't determine port");
387 int r
= getnameinfo ((struct sockaddr
*) &sockaddr
, len
,
389 listen_port
, sizeof (listen_port
),
393 fprintf (stderr
, _("Can't obtain port where we are listening: %s"),
396 fprintf (stderr
, _("Listening on port %s\n"), listen_port
);
400 /* Register the event loop handler. */
401 add_file_handler (listen_desc
, handle_accept_event
, NULL
);
408 delete_file_handler (remote_desc
);
413 closesocket (remote_desc
);
415 if (! remote_connection_is_stdio ())
425 #ifndef IN_PROCESS_AGENT
428 decode_address (CORE_ADDR
*addrp
, const char *start
, int len
)
435 for (i
= 0; i
< len
; i
++)
439 addr
= addr
| (fromhex (ch
) & 0x0f);
445 decode_address_to_semicolon (CORE_ADDR
*addrp
, const char *start
)
450 while (*end
!= '\0' && *end
!= ';')
453 decode_address (addrp
, start
, end
- start
);
462 #ifndef IN_PROCESS_AGENT
464 /* Look for a sequence of characters which can be run-length encoded.
465 If there are any, update *CSUM and *P. Otherwise, output the
466 single character. Return the number of characters consumed. */
469 try_rle (char *buf
, int remaining
, unsigned char *csum
, char **p
)
473 /* Always output the character. */
477 /* Don't go past '~'. */
481 for (n
= 1; n
< remaining
; n
++)
482 if (buf
[n
] != buf
[0])
485 /* N is the index of the first character not the same as buf[0].
486 buf[0] is counted twice, so by decrementing N, we get the number
487 of characters the RLE sequence will replace. */
493 /* Skip the frame characters. The manual says to skip '+' and '-'
494 also, but there's no reason to. Unfortunately these two unusable
495 characters double the encoded length of a four byte zero
497 while (n
+ 29 == '$' || n
+ 29 == '#')
510 #ifndef IN_PROCESS_AGENT
512 /* Write a PTID to BUF. Returns BUF+CHARACTERS_WRITTEN. */
515 write_ptid (char *buf
, ptid_t ptid
)
517 client_state
&cs
= get_client_state ();
520 if (cs
.multi_process
)
524 buf
+= sprintf (buf
, "p-%x.", -pid
);
526 buf
+= sprintf (buf
, "p%x.", pid
);
530 buf
+= sprintf (buf
, "-%x", -tid
);
532 buf
+= sprintf (buf
, "%x", tid
);
538 hex_or_minus_one (const char *buf
, const char **obuf
)
542 if (startswith (buf
, "-1"))
548 buf
= unpack_varlen_hex (buf
, &ret
);
556 /* Extract a PTID from BUF. If non-null, OBUF is set to the to one
557 passed the last parsed char. Returns null_ptid on error. */
559 read_ptid (const char *buf
, const char **obuf
)
563 ULONGEST pid
= 0, tid
= 0;
567 /* Multi-process ptid. */
568 pp
= unpack_varlen_hex (p
+ 1, &pid
);
570 error ("invalid remote ptid: %s\n", p
);
574 tid
= hex_or_minus_one (p
, &pp
);
578 return ptid_t (pid
, tid
, 0);
581 /* No multi-process. Just a tid. */
582 tid
= hex_or_minus_one (p
, &pp
);
584 /* Since GDB is not sending a process id (multi-process extensions
585 are off), then there's only one process. Default to the first in
587 pid
= pid_of (get_first_process ());
591 return ptid_t (pid
, tid
, 0);
594 /* Write COUNT bytes in BUF to the client.
595 The result is the number of bytes written or -1 if error.
596 This may return less than COUNT. */
599 write_prim (const void *buf
, int count
)
601 if (remote_connection_is_stdio ())
602 return write (fileno (stdout
), buf
, count
);
604 return write (remote_desc
, buf
, count
);
607 /* Read COUNT bytes from the client and store in BUF.
608 The result is the number of bytes read or -1 if error.
609 This may return less than COUNT. */
612 read_prim (void *buf
, int count
)
614 if (remote_connection_is_stdio ())
615 return read (fileno (stdin
), buf
, count
);
617 return read (remote_desc
, buf
, count
);
620 /* Send a packet to the remote machine, with error checking.
621 The data of the packet is in BUF, and the length of the
622 packet is in CNT. Returns >= 0 on success, -1 otherwise. */
625 putpkt_binary_1 (char *buf
, int cnt
, int is_notif
)
627 client_state
&cs
= get_client_state ();
629 unsigned char csum
= 0;
634 buf2
= (char *) xmalloc (strlen ("$") + cnt
+ strlen ("#nn") + 1);
636 /* Copy the packet into buffer BUF2, encapsulating it
637 and giving it a checksum. */
645 for (i
= 0; i
< cnt
;)
646 i
+= try_rle (buf
+ i
, cnt
- i
, &csum
, &p
);
649 *p
++ = tohex ((csum
>> 4) & 0xf);
650 *p
++ = tohex (csum
& 0xf);
654 /* Send it over and over until we get a positive ack. */
658 if (write_prim (buf2
, p
- buf2
) != p
- buf2
)
660 perror ("putpkt(write)");
665 if (cs
.noack_mode
|| is_notif
)
667 /* Don't expect an ack then. */
671 debug_printf ("putpkt (\"%s\"); [notif]\n", buf2
);
673 debug_printf ("putpkt (\"%s\"); [noack mode]\n", buf2
);
681 debug_printf ("putpkt (\"%s\"); [looking for ack]\n", buf2
);
695 debug_printf ("[received '%c' (0x%x)]\n", cc
, cc
);
699 /* Check for an input interrupt while we're here. */
700 if (cc
== '\003' && current_thread
!= NULL
)
701 the_target
->request_interrupt ();
706 return 1; /* Success! */
710 putpkt_binary (char *buf
, int cnt
)
712 return putpkt_binary_1 (buf
, cnt
, 0);
715 /* Send a packet to the remote machine, with error checking. The data
716 of the packet is in BUF, and the packet should be a NUL-terminated
717 string. Returns >= 0 on success, -1 otherwise. */
722 return putpkt_binary (buf
, strlen (buf
));
726 putpkt_notif (char *buf
)
728 return putpkt_binary_1 (buf
, strlen (buf
), 1);
731 /* Come here when we get an input interrupt from the remote side. This
732 interrupt should only be active while we are waiting for the child to do
733 something. Thus this assumes readchar:bufcnt is 0.
734 About the only thing that should come through is a ^C, which
735 will cause us to request child interruption. */
738 input_interrupt (int unused
)
741 struct timeval immediate
= { 0, 0 };
743 /* Protect against spurious interrupts. This has been observed to
744 be a problem under NetBSD 1.4 and 1.5. */
747 FD_SET (remote_desc
, &readset
);
748 if (select (remote_desc
+ 1, &readset
, 0, 0, &immediate
) > 0)
753 cc
= read_prim (&c
, 1);
757 fprintf (stderr
, "client connection closed\n");
760 else if (cc
!= 1 || c
!= '\003')
762 fprintf (stderr
, "input_interrupt, count = %d c = %d ", cc
, c
);
764 fprintf (stderr
, "('%c')\n", c
);
766 fprintf (stderr
, "('\\x%02x')\n", c
& 0xff);
770 the_target
->request_interrupt ();
774 /* Check if the remote side sent us an interrupt request (^C). */
776 check_remote_input_interrupt_request (void)
778 /* This function may be called before establishing communications,
779 therefore we need to validate the remote descriptor. */
781 if (remote_desc
== -1)
787 /* Asynchronous I/O support. SIGIO must be unblocked when waiting,
788 in order to accept Control-C from the client, and must be blocked
789 when talking to the client. */
792 block_unblock_async_io (int block
)
797 sigemptyset (&sigio_set
);
798 sigaddset (&sigio_set
, SIGIO
);
799 gdb_sigmask (block
? SIG_BLOCK
: SIG_UNBLOCK
, &sigio_set
, NULL
);
803 /* Current state of asynchronous I/O. */
804 static int async_io_enabled
;
806 /* Enable asynchronous I/O. */
808 enable_async_io (void)
810 if (async_io_enabled
)
813 block_unblock_async_io (0);
815 async_io_enabled
= 1;
818 /* Disable asynchronous I/O. */
820 disable_async_io (void)
822 if (!async_io_enabled
)
825 block_unblock_async_io (1);
827 async_io_enabled
= 0;
831 initialize_async_io (void)
833 /* Make sure that async I/O starts blocked. */
834 async_io_enabled
= 1;
837 /* Install the signal handler. */
839 signal (SIGIO
, input_interrupt
);
843 /* Internal buffer used by readchar.
844 These are global to readchar because reschedule_remote needs to be
845 able to tell whether the buffer is empty. */
847 static unsigned char readchar_buf
[BUFSIZ
];
848 static int readchar_bufcnt
= 0;
849 static unsigned char *readchar_bufp
;
851 /* Returns next char from remote GDB. -1 if error. */
858 if (readchar_bufcnt
== 0)
860 readchar_bufcnt
= read_prim (readchar_buf
, sizeof (readchar_buf
));
862 if (readchar_bufcnt
<= 0)
864 if (readchar_bufcnt
== 0)
867 debug_printf ("readchar: Got EOF\n");
875 readchar_bufp
= readchar_buf
;
879 ch
= *readchar_bufp
++;
884 /* Reset the readchar state machine. */
887 reset_readchar (void)
890 if (readchar_callback
!= NOT_SCHEDULED
)
892 delete_timer (readchar_callback
);
893 readchar_callback
= NOT_SCHEDULED
;
897 /* Process remaining data in readchar_buf. */
900 process_remaining (void *context
)
902 /* This is a one-shot event. */
903 readchar_callback
= NOT_SCHEDULED
;
905 if (readchar_bufcnt
> 0)
906 handle_serial_event (0, NULL
);
909 /* If there is still data in the buffer, queue another event to process it,
910 we can't sleep in select yet. */
915 if (readchar_bufcnt
> 0 && readchar_callback
== NOT_SCHEDULED
)
916 readchar_callback
= create_timer (0, process_remaining
, NULL
);
919 /* Read a packet from the remote machine, with error checking,
920 and store it in BUF. Returns length of packet, or negative if error. */
925 client_state
&cs
= get_client_state ();
927 unsigned char csum
, c1
, c2
;
938 /* The '\003' may appear before or after each packet, so
939 check for an input interrupt. */
942 the_target
->request_interrupt ();
950 debug_printf ("[getpkt: discarding char '%c']\n", c
);
971 c1
= fromhex (readchar ());
972 c2
= fromhex (readchar ());
974 if (csum
== (c1
<< 4) + c2
)
980 "Bad checksum, sentsum=0x%x, csum=0x%x, "
981 "buf=%s [no-ack-mode, Bad medium?]\n",
982 (c1
<< 4) + c2
, csum
, buf
);
983 /* Not much we can do, GDB wasn't expecting an ack/nac. */
987 fprintf (stderr
, "Bad checksum, sentsum=0x%x, csum=0x%x, buf=%s\n",
988 (c1
<< 4) + c2
, csum
, buf
);
989 if (write_prim ("-", 1) != 1)
997 debug_printf ("getpkt (\"%s\"); [sending ack] \n", buf
);
1001 if (write_prim ("+", 1) != 1)
1006 debug_printf ("[sent ack]\n");
1014 debug_printf ("getpkt (\"%s\"); [no ack sent] \n", buf
);
1019 /* The readchar above may have already read a '\003' out of the socket
1020 and moved it to the local buffer. For example, when GDB sends
1021 vCont;c immediately followed by interrupt (see
1022 gdb.base/interrupt-noterm.exp). As soon as we see the vCont;c, we'll
1023 resume the inferior and wait. Since we've already moved the '\003'
1024 to the local buffer, SIGIO won't help. In that case, if we don't
1025 check for interrupt after the vCont;c packet, the interrupt character
1026 would stay in the buffer unattended until after the next (unrelated)
1028 while (readchar_bufcnt
> 0 && *readchar_bufp
== '\003')
1030 /* Consume the interrupt character in the buffer. */
1032 the_target
->request_interrupt ();
1039 write_ok (char *buf
)
1047 write_enn (char *buf
)
1049 /* Some day, we should define the meanings of the error codes... */
1058 #ifndef IN_PROCESS_AGENT
1061 outreg (struct regcache
*regcache
, int regno
, char *buf
)
1063 if ((regno
>> 12) != 0)
1064 *buf
++ = tohex ((regno
>> 12) & 0xf);
1065 if ((regno
>> 8) != 0)
1066 *buf
++ = tohex ((regno
>> 8) & 0xf);
1067 *buf
++ = tohex ((regno
>> 4) & 0xf);
1068 *buf
++ = tohex (regno
& 0xf);
1070 collect_register_as_string (regcache
, regno
, buf
);
1071 buf
+= 2 * register_size (regcache
->tdesc
, regno
);
1078 prepare_resume_reply (char *buf
, ptid_t ptid
,
1079 struct target_waitstatus
*status
)
1081 client_state
&cs
= get_client_state ();
1083 debug_printf ("Writing resume reply for %s:%d\n",
1084 target_pid_to_str (ptid
), status
->kind
);
1086 switch (status
->kind
)
1088 case TARGET_WAITKIND_STOPPED
:
1089 case TARGET_WAITKIND_FORKED
:
1090 case TARGET_WAITKIND_VFORKED
:
1091 case TARGET_WAITKIND_VFORK_DONE
:
1092 case TARGET_WAITKIND_EXECD
:
1093 case TARGET_WAITKIND_THREAD_CREATED
:
1094 case TARGET_WAITKIND_SYSCALL_ENTRY
:
1095 case TARGET_WAITKIND_SYSCALL_RETURN
:
1097 struct thread_info
*saved_thread
;
1099 struct regcache
*regcache
;
1101 if ((status
->kind
== TARGET_WAITKIND_FORKED
&& cs
.report_fork_events
)
1102 || (status
->kind
== TARGET_WAITKIND_VFORKED
1103 && cs
.report_vfork_events
))
1105 enum gdb_signal signal
= GDB_SIGNAL_TRAP
;
1106 const char *event
= (status
->kind
== TARGET_WAITKIND_FORKED
1107 ? "fork" : "vfork");
1109 sprintf (buf
, "T%02x%s:", signal
, event
);
1110 buf
+= strlen (buf
);
1111 buf
= write_ptid (buf
, status
->value
.related_pid
);
1114 else if (status
->kind
== TARGET_WAITKIND_VFORK_DONE
1115 && cs
.report_vfork_events
)
1117 enum gdb_signal signal
= GDB_SIGNAL_TRAP
;
1119 sprintf (buf
, "T%02xvforkdone:;", signal
);
1121 else if (status
->kind
== TARGET_WAITKIND_EXECD
&& cs
.report_exec_events
)
1123 enum gdb_signal signal
= GDB_SIGNAL_TRAP
;
1124 const char *event
= "exec";
1125 char hexified_pathname
[PATH_MAX
* 2];
1127 sprintf (buf
, "T%02x%s:", signal
, event
);
1128 buf
+= strlen (buf
);
1130 /* Encode pathname to hexified format. */
1131 bin2hex ((const gdb_byte
*) status
->value
.execd_pathname
,
1133 strlen (status
->value
.execd_pathname
));
1135 sprintf (buf
, "%s;", hexified_pathname
);
1136 xfree (status
->value
.execd_pathname
);
1137 status
->value
.execd_pathname
= NULL
;
1138 buf
+= strlen (buf
);
1140 else if (status
->kind
== TARGET_WAITKIND_THREAD_CREATED
1141 && cs
.report_thread_events
)
1143 enum gdb_signal signal
= GDB_SIGNAL_TRAP
;
1145 sprintf (buf
, "T%02xcreate:;", signal
);
1147 else if (status
->kind
== TARGET_WAITKIND_SYSCALL_ENTRY
1148 || status
->kind
== TARGET_WAITKIND_SYSCALL_RETURN
)
1150 enum gdb_signal signal
= GDB_SIGNAL_TRAP
;
1151 const char *event
= (status
->kind
== TARGET_WAITKIND_SYSCALL_ENTRY
1152 ? "syscall_entry" : "syscall_return");
1154 sprintf (buf
, "T%02x%s:%x;", signal
, event
,
1155 status
->value
.syscall_number
);
1158 sprintf (buf
, "T%02x", status
->value
.sig
);
1160 if (disable_packet_T
)
1162 /* This is a bit (OK, a lot) of a kludge, however, this isn't
1163 really a user feature, but exists only so GDB can use the
1164 gdbserver to test handling of the 'S' stop reply packet, so
1165 we would rather this code be as simple as possible.
1167 By this point we've started to build the 'T' stop packet,
1168 and it should look like 'Txx....' where 'x' is a hex digit.
1169 An 'S' stop packet always looks like 'Sxx', so all we do
1170 here is convert the buffer from a T packet to an S packet
1171 and the avoid adding any extra content by breaking out. */
1172 gdb_assert (*buf
== 'T');
1173 gdb_assert (isxdigit (*(buf
+ 1)));
1174 gdb_assert (isxdigit (*(buf
+ 2)));
1180 buf
+= strlen (buf
);
1182 saved_thread
= current_thread
;
1184 switch_to_thread (the_target
, ptid
);
1186 regp
= current_target_desc ()->expedite_regs
;
1188 regcache
= get_thread_regcache (current_thread
, 1);
1190 if (the_target
->stopped_by_watchpoint ())
1195 memcpy (buf
, "watch:", 6);
1198 addr
= the_target
->stopped_data_address ();
1200 /* Convert each byte of the address into two hexadecimal
1201 chars. Note that we take sizeof (void *) instead of
1202 sizeof (addr); this is to avoid sending a 64-bit
1203 address to a 32-bit GDB. */
1204 for (i
= sizeof (void *) * 2; i
> 0; i
--)
1205 *buf
++ = tohex ((addr
>> (i
- 1) * 4) & 0xf);
1208 else if (cs
.swbreak_feature
&& target_stopped_by_sw_breakpoint ())
1210 sprintf (buf
, "swbreak:;");
1211 buf
+= strlen (buf
);
1213 else if (cs
.hwbreak_feature
&& target_stopped_by_hw_breakpoint ())
1215 sprintf (buf
, "hwbreak:;");
1216 buf
+= strlen (buf
);
1221 buf
= outreg (regcache
, find_regno (regcache
->tdesc
, *regp
), buf
);
1226 /* Formerly, if the debugger had not used any thread features
1227 we would not burden it with a thread status response. This
1228 was for the benefit of GDB 4.13 and older. However, in
1229 recent GDB versions the check (``if (cont_thread != 0)'')
1230 does not have the desired effect because of sillyness in
1231 the way that the remote protocol handles specifying a
1232 thread. Since thread support relies on qSymbol support
1233 anyway, assume GDB can handle threads. */
1235 if (using_threads
&& !disable_packet_Tthread
)
1237 /* This if (1) ought to be unnecessary. But remote_wait
1238 in GDB will claim this event belongs to inferior_ptid
1239 if we do not specify a thread, and there's no way for
1240 gdbserver to know what inferior_ptid is. */
1241 if (1 || cs
.general_thread
!= ptid
)
1244 /* In non-stop, don't change the general thread behind
1247 cs
.general_thread
= ptid
;
1248 sprintf (buf
, "thread:");
1249 buf
+= strlen (buf
);
1250 buf
= write_ptid (buf
, ptid
);
1252 buf
+= strlen (buf
);
1254 core
= target_core_of_thread (ptid
);
1258 sprintf (buf
, "core:");
1259 buf
+= strlen (buf
);
1260 sprintf (buf
, "%x", core
);
1262 buf
+= strlen (buf
);
1269 strcpy (buf
, "library:;");
1270 buf
+= strlen (buf
);
1274 current_thread
= saved_thread
;
1277 case TARGET_WAITKIND_EXITED
:
1278 if (cs
.multi_process
)
1279 sprintf (buf
, "W%x;process:%x",
1280 status
->value
.integer
, ptid
.pid ());
1282 sprintf (buf
, "W%02x", status
->value
.integer
);
1284 case TARGET_WAITKIND_SIGNALLED
:
1285 if (cs
.multi_process
)
1286 sprintf (buf
, "X%x;process:%x",
1287 status
->value
.sig
, ptid
.pid ());
1289 sprintf (buf
, "X%02x", status
->value
.sig
);
1291 case TARGET_WAITKIND_THREAD_EXITED
:
1292 sprintf (buf
, "w%x;", status
->value
.integer
);
1293 buf
+= strlen (buf
);
1294 buf
= write_ptid (buf
, ptid
);
1296 case TARGET_WAITKIND_NO_RESUMED
:
1300 error ("unhandled waitkind");
1306 decode_m_packet (char *from
, CORE_ADDR
*mem_addr_ptr
, unsigned int *len_ptr
)
1310 *mem_addr_ptr
= *len_ptr
= 0;
1312 while ((ch
= from
[i
++]) != ',')
1314 *mem_addr_ptr
= *mem_addr_ptr
<< 4;
1315 *mem_addr_ptr
|= fromhex (ch
) & 0x0f;
1318 for (j
= 0; j
< 4; j
++)
1320 if ((ch
= from
[i
++]) == 0)
1322 *len_ptr
= *len_ptr
<< 4;
1323 *len_ptr
|= fromhex (ch
) & 0x0f;
1328 decode_M_packet (char *from
, CORE_ADDR
*mem_addr_ptr
, unsigned int *len_ptr
,
1329 unsigned char **to_p
)
1333 *mem_addr_ptr
= *len_ptr
= 0;
1335 while ((ch
= from
[i
++]) != ',')
1337 *mem_addr_ptr
= *mem_addr_ptr
<< 4;
1338 *mem_addr_ptr
|= fromhex (ch
) & 0x0f;
1341 while ((ch
= from
[i
++]) != ':')
1343 *len_ptr
= *len_ptr
<< 4;
1344 *len_ptr
|= fromhex (ch
) & 0x0f;
1348 *to_p
= (unsigned char *) xmalloc (*len_ptr
);
1350 hex2bin (&from
[i
++], *to_p
, *len_ptr
);
1354 decode_X_packet (char *from
, int packet_len
, CORE_ADDR
*mem_addr_ptr
,
1355 unsigned int *len_ptr
, unsigned char **to_p
)
1359 *mem_addr_ptr
= *len_ptr
= 0;
1361 while ((ch
= from
[i
++]) != ',')
1363 *mem_addr_ptr
= *mem_addr_ptr
<< 4;
1364 *mem_addr_ptr
|= fromhex (ch
) & 0x0f;
1367 while ((ch
= from
[i
++]) != ':')
1369 *len_ptr
= *len_ptr
<< 4;
1370 *len_ptr
|= fromhex (ch
) & 0x0f;
1374 *to_p
= (unsigned char *) xmalloc (*len_ptr
);
1376 if (remote_unescape_input ((const gdb_byte
*) &from
[i
], packet_len
- i
,
1377 *to_p
, *len_ptr
) != *len_ptr
)
1383 /* Decode a qXfer write request. */
1386 decode_xfer_write (char *buf
, int packet_len
, CORE_ADDR
*offset
,
1387 unsigned int *len
, unsigned char *data
)
1392 /* Extract the offset. */
1394 while ((ch
= *buf
++) != ':')
1396 *offset
= *offset
<< 4;
1397 *offset
|= fromhex (ch
) & 0x0f;
1400 /* Get encoded data. */
1401 packet_len
-= buf
- b
;
1402 *len
= remote_unescape_input ((const gdb_byte
*) buf
, packet_len
,
1407 /* Decode the parameters of a qSearch:memory packet. */
1410 decode_search_memory_packet (const char *buf
, int packet_len
,
1411 CORE_ADDR
*start_addrp
,
1412 CORE_ADDR
*search_space_lenp
,
1413 gdb_byte
*pattern
, unsigned int *pattern_lenp
)
1415 const char *p
= buf
;
1417 p
= decode_address_to_semicolon (start_addrp
, p
);
1418 p
= decode_address_to_semicolon (search_space_lenp
, p
);
1419 packet_len
-= p
- buf
;
1420 *pattern_lenp
= remote_unescape_input ((const gdb_byte
*) p
, packet_len
,
1421 pattern
, packet_len
);
1426 free_sym_cache (struct sym_cache
*sym
)
1436 clear_symbol_cache (struct sym_cache
**symcache_p
)
1438 struct sym_cache
*sym
, *next
;
1440 /* Check the cache first. */
1441 for (sym
= *symcache_p
; sym
; sym
= next
)
1444 free_sym_cache (sym
);
1450 /* Get the address of NAME, and return it in ADDRP if found. if
1451 MAY_ASK_GDB is false, assume symbol cache misses are failures.
1452 Returns 1 if the symbol is found, 0 if it is not, -1 on error. */
1455 look_up_one_symbol (const char *name
, CORE_ADDR
*addrp
, int may_ask_gdb
)
1457 client_state
&cs
= get_client_state ();
1460 struct sym_cache
*sym
;
1461 struct process_info
*proc
;
1463 proc
= current_process ();
1465 /* Check the cache first. */
1466 for (sym
= proc
->symbol_cache
; sym
; sym
= sym
->next
)
1467 if (strcmp (name
, sym
->name
) == 0)
1473 /* It might not be an appropriate time to look up a symbol,
1474 e.g. while we're trying to fetch registers. */
1478 /* Send the request. */
1479 strcpy (cs
.own_buf
, "qSymbol:");
1480 bin2hex ((const gdb_byte
*) name
, cs
.own_buf
+ strlen ("qSymbol:"),
1482 if (putpkt (cs
.own_buf
) < 0)
1485 /* FIXME: Eventually add buffer overflow checking (to getpkt?) */
1486 len
= getpkt (cs
.own_buf
);
1490 /* We ought to handle pretty much any packet at this point while we
1491 wait for the qSymbol "response". That requires re-entering the
1492 main loop. For now, this is an adequate approximation; allow
1493 GDB to read from memory and handle 'v' packets (for vFile transfers)
1494 while it figures out the address of the symbol. */
1497 if (cs
.own_buf
[0] == 'm')
1500 unsigned char *mem_buf
;
1501 unsigned int mem_len
;
1503 decode_m_packet (&cs
.own_buf
[1], &mem_addr
, &mem_len
);
1504 mem_buf
= (unsigned char *) xmalloc (mem_len
);
1505 if (read_inferior_memory (mem_addr
, mem_buf
, mem_len
) == 0)
1506 bin2hex (mem_buf
, cs
.own_buf
, mem_len
);
1508 write_enn (cs
.own_buf
);
1510 if (putpkt (cs
.own_buf
) < 0)
1513 else if (cs
.own_buf
[0] == 'v')
1516 handle_v_requests (cs
.own_buf
, len
, &new_len
);
1518 putpkt_binary (cs
.own_buf
, new_len
);
1520 putpkt (cs
.own_buf
);
1524 len
= getpkt (cs
.own_buf
);
1529 if (!startswith (cs
.own_buf
, "qSymbol:"))
1531 warning ("Malformed response to qSymbol, ignoring: %s", cs
.own_buf
);
1535 p
= cs
.own_buf
+ strlen ("qSymbol:");
1537 while (*q
&& *q
!= ':')
1540 /* Make sure we found a value for the symbol. */
1541 if (p
== q
|| *q
== '\0')
1544 decode_address (addrp
, p
, q
- p
);
1546 /* Save the symbol in our cache. */
1547 sym
= XNEW (struct sym_cache
);
1548 sym
->name
= xstrdup (name
);
1550 sym
->next
= proc
->symbol_cache
;
1551 proc
->symbol_cache
= sym
;
1556 /* Relocate an instruction to execute at a different address. OLDLOC
1557 is the address in the inferior memory where the instruction to
1558 relocate is currently at. On input, TO points to the destination
1559 where we want the instruction to be copied (and possibly adjusted)
1560 to. On output, it points to one past the end of the resulting
1561 instruction(s). The effect of executing the instruction at TO
1562 shall be the same as if executing it at OLDLOC. For example, call
1563 instructions that implicitly push the return address on the stack
1564 should be adjusted to return to the instruction after OLDLOC;
1565 relative branches, and other PC-relative instructions need the
1566 offset adjusted; etc. Returns 0 on success, -1 on failure. */
1569 relocate_instruction (CORE_ADDR
*to
, CORE_ADDR oldloc
)
1571 client_state
&cs
= get_client_state ();
1573 ULONGEST written
= 0;
1575 /* Send the request. */
1576 sprintf (cs
.own_buf
, "qRelocInsn:%s;%s", paddress (oldloc
),
1578 if (putpkt (cs
.own_buf
) < 0)
1581 /* FIXME: Eventually add buffer overflow checking (to getpkt?) */
1582 len
= getpkt (cs
.own_buf
);
1586 /* We ought to handle pretty much any packet at this point while we
1587 wait for the qRelocInsn "response". That requires re-entering
1588 the main loop. For now, this is an adequate approximation; allow
1589 GDB to access memory. */
1590 while (cs
.own_buf
[0] == 'm' || cs
.own_buf
[0] == 'M' || cs
.own_buf
[0] == 'X')
1593 unsigned char *mem_buf
= NULL
;
1594 unsigned int mem_len
;
1596 if (cs
.own_buf
[0] == 'm')
1598 decode_m_packet (&cs
.own_buf
[1], &mem_addr
, &mem_len
);
1599 mem_buf
= (unsigned char *) xmalloc (mem_len
);
1600 if (read_inferior_memory (mem_addr
, mem_buf
, mem_len
) == 0)
1601 bin2hex (mem_buf
, cs
.own_buf
, mem_len
);
1603 write_enn (cs
.own_buf
);
1605 else if (cs
.own_buf
[0] == 'X')
1607 if (decode_X_packet (&cs
.own_buf
[1], len
- 1, &mem_addr
,
1608 &mem_len
, &mem_buf
) < 0
1609 || target_write_memory (mem_addr
, mem_buf
, mem_len
) != 0)
1610 write_enn (cs
.own_buf
);
1612 write_ok (cs
.own_buf
);
1616 decode_M_packet (&cs
.own_buf
[1], &mem_addr
, &mem_len
, &mem_buf
);
1617 if (target_write_memory (mem_addr
, mem_buf
, mem_len
) == 0)
1618 write_ok (cs
.own_buf
);
1620 write_enn (cs
.own_buf
);
1623 if (putpkt (cs
.own_buf
) < 0)
1625 len
= getpkt (cs
.own_buf
);
1630 if (cs
.own_buf
[0] == 'E')
1632 warning ("An error occurred while relocating an instruction: %s",
1637 if (!startswith (cs
.own_buf
, "qRelocInsn:"))
1639 warning ("Malformed response to qRelocInsn, ignoring: %s",
1644 unpack_varlen_hex (cs
.own_buf
+ strlen ("qRelocInsn:"), &written
);
1651 monitor_output (const char *msg
)
1653 int len
= strlen (msg
);
1654 char *buf
= (char *) xmalloc (len
* 2 + 2);
1657 bin2hex ((const gdb_byte
*) msg
, buf
+ 1, len
);