1 /* Remote utility routines for the remote server for GDB.
2 Copyright (C) 1986-2024 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 /* gnulib wraps these as macros, undo them. */
109 # define read(fd, buf, len) recv (fd, (char *) buf, len, 0)
110 # define write(fd, buf, len) send (fd, (char *) buf, len, 0)
116 return remote_desc
!= -1;
119 /* Return true if the remote connection is over stdio. */
122 remote_connection_is_stdio (void)
124 return remote_is_stdio
;
128 enable_async_notification (int fd
)
130 #if defined(F_SETFL) && defined (FASYNC)
131 int save_fcntl_flags
;
133 save_fcntl_flags
= fcntl (fd
, F_GETFL
, 0);
134 fcntl (fd
, F_SETFL
, save_fcntl_flags
| FASYNC
);
135 #if defined (F_SETOWN)
136 fcntl (fd
, F_SETOWN
, getpid ());
142 handle_accept_event (int err
, gdb_client_data client_data
)
144 struct sockaddr_storage sockaddr
;
145 socklen_t len
= sizeof (sockaddr
);
147 threads_debug_printf ("handling possible accept event");
149 remote_desc
= accept (listen_desc
, (struct sockaddr
*) &sockaddr
, &len
);
150 if (remote_desc
== -1)
151 perror_with_name ("Accept failed");
153 /* Enable TCP keep alive process. */
155 setsockopt (remote_desc
, SOL_SOCKET
, SO_KEEPALIVE
,
156 (char *) &tmp
, sizeof (tmp
));
158 /* Tell TCP not to delay small packets. This greatly speeds up
159 interactive response. */
161 setsockopt (remote_desc
, IPPROTO_TCP
, TCP_NODELAY
,
162 (char *) &tmp
, sizeof (tmp
));
165 signal (SIGPIPE
, SIG_IGN
); /* If we don't do this, then gdbserver simply
166 exits when the remote side dies. */
172 close (listen_desc
); /* No longer need this */
174 closesocket (listen_desc
); /* No longer need this */
178 /* Even if !RUN_ONCE no longer notice new connections. Still keep the
179 descriptor open for add_file_handler to wait for a new connection. */
180 delete_file_handler (listen_desc
);
182 /* Convert IP address to string. */
183 char orig_host
[GDB_NI_MAX_ADDR
], orig_port
[GDB_NI_MAX_PORT
];
185 int r
= getnameinfo ((struct sockaddr
*) &sockaddr
, len
,
186 orig_host
, sizeof (orig_host
),
187 orig_port
, sizeof (orig_port
),
188 NI_NUMERICHOST
| NI_NUMERICSERV
);
191 fprintf (stderr
, _("Could not obtain remote address: %s\n"),
194 fprintf (stderr
, _("Remote debugging from host %s, port %s\n"),
195 orig_host
, orig_port
);
197 enable_async_notification (remote_desc
);
199 /* Register the event loop handler. */
200 add_file_handler (remote_desc
, handle_serial_event
, NULL
, "remote-net");
202 /* We have a new GDB connection now. If we were disconnected
203 tracing, there's a window where the target could report a stop
204 event to the event loop, and since we have a connection now, we'd
205 try to send vStopped notifications to GDB. But, don't do that
206 until GDB as selected all-stop/non-stop, and has queried the
207 threads' status ('?'). */
211 /* Prepare for a later connection to a remote debugger.
212 NAME is the filename used for communication. */
215 remote_prepare (const char *name
)
217 client_state
&cs
= get_client_state ();
219 static int winsock_initialized
;
224 if (strcmp (name
, STDIO_CONNECTION_NAME
) == 0)
226 /* We need to record fact that we're using stdio sooner than the
227 call to remote_open so start_inferior knows the connection is
230 cs
.transport_is_reliable
= 1;
234 struct addrinfo hint
;
235 struct addrinfo
*ainfo
;
237 memset (&hint
, 0, sizeof (hint
));
238 /* Assume no prefix will be passed, therefore we should use
240 hint
.ai_family
= AF_UNSPEC
;
241 hint
.ai_socktype
= SOCK_STREAM
;
242 hint
.ai_protocol
= IPPROTO_TCP
;
244 parsed_connection_spec parsed
245 = parse_connection_spec_without_prefix (name
, &hint
);
247 if (parsed
.port_str
.empty ())
249 cs
.transport_is_reliable
= 0;
254 if (!winsock_initialized
)
258 WSAStartup (MAKEWORD (1, 0), &wsad
);
259 winsock_initialized
= 1;
263 int r
= getaddrinfo (parsed
.host_str
.c_str (), parsed
.port_str
.c_str (),
267 error (_("%s: cannot resolve name: %s"), name
, gai_strerror (r
));
269 scoped_free_addrinfo
freeaddrinfo (ainfo
);
271 struct addrinfo
*iter
;
273 for (iter
= ainfo
; iter
!= NULL
; iter
= iter
->ai_next
)
275 listen_desc
= gdb_socket_cloexec (iter
->ai_family
, iter
->ai_socktype
,
278 if (listen_desc
>= 0)
283 perror_with_name ("Can't open socket");
285 /* Allow rapid reuse of this port. */
287 setsockopt (listen_desc
, SOL_SOCKET
, SO_REUSEADDR
, (char *) &tmp
,
290 switch (iter
->ai_family
)
293 ((struct sockaddr_in
*) iter
->ai_addr
)->sin_addr
.s_addr
= INADDR_ANY
;
296 ((struct sockaddr_in6
*) iter
->ai_addr
)->sin6_addr
= in6addr_any
;
299 internal_error (_("Invalid 'ai_family' %d\n"), iter
->ai_family
);
302 if (bind (listen_desc
, iter
->ai_addr
, iter
->ai_addrlen
) != 0)
303 perror_with_name ("Can't bind address");
305 if (listen (listen_desc
, 1) != 0)
306 perror_with_name ("Can't listen on socket");
308 cs
.transport_is_reliable
= 1;
311 /* Open a connection to a remote debugger.
312 NAME is the filename used for communication. */
315 remote_open (const char *name
)
317 const char *port_str
;
319 port_str
= strchr (name
, ':');
321 if (port_str
== NULL
)
322 error ("Only HOST:PORT is supported on this platform.");
325 if (strcmp (name
, STDIO_CONNECTION_NAME
) == 0)
327 fprintf (stderr
, "Remote debugging using stdio\n");
329 /* Use stdin as the handle of the connection.
330 We only select on reads, for example. */
331 remote_desc
= fileno (stdin
);
333 enable_async_notification (remote_desc
);
335 /* Register the event loop handler. */
336 add_file_handler (remote_desc
, handle_serial_event
, NULL
, "remote-stdio");
339 else if (port_str
== NULL
)
343 if (stat (name
, &statbuf
) == 0
344 && (S_ISCHR (statbuf
.st_mode
) || S_ISFIFO (statbuf
.st_mode
)))
345 remote_desc
= open (name
, O_RDWR
);
353 perror_with_name ("Could not open remote device");
357 struct termios termios
;
358 tcgetattr (remote_desc
, &termios
);
363 termios
.c_cflag
&= ~(CSIZE
| PARENB
);
364 termios
.c_cflag
|= CLOCAL
| CS8
;
365 termios
.c_cc
[VMIN
] = 1;
366 termios
.c_cc
[VTIME
] = 0;
368 tcsetattr (remote_desc
, TCSANOW
, &termios
);
372 fprintf (stderr
, "Remote debugging using %s\n", name
);
374 enable_async_notification (remote_desc
);
376 /* Register the event loop handler. */
377 add_file_handler (remote_desc
, handle_serial_event
, NULL
,
380 #endif /* USE_WIN32API */
383 char listen_port
[GDB_NI_MAX_PORT
];
384 struct sockaddr_storage sockaddr
;
385 socklen_t len
= sizeof (sockaddr
);
387 if (getsockname (listen_desc
, (struct sockaddr
*) &sockaddr
, &len
) < 0)
388 perror_with_name ("Can't determine port");
390 int r
= getnameinfo ((struct sockaddr
*) &sockaddr
, len
,
392 listen_port
, sizeof (listen_port
),
396 fprintf (stderr
, _("Can't obtain port where we are listening: %s"),
399 fprintf (stderr
, _("Listening on port %s\n"), listen_port
);
403 /* Register the event loop handler. */
404 add_file_handler (listen_desc
, handle_accept_event
, NULL
,
412 delete_file_handler (remote_desc
);
417 closesocket (remote_desc
);
419 if (! remote_connection_is_stdio ())
429 #ifndef IN_PROCESS_AGENT
432 decode_address (CORE_ADDR
*addrp
, const char *start
, int len
)
439 for (i
= 0; i
< len
; i
++)
443 addr
= addr
| (fromhex (ch
) & 0x0f);
449 decode_address_to_semicolon (CORE_ADDR
*addrp
, const char *start
)
454 while (*end
!= '\0' && *end
!= ';')
457 decode_address (addrp
, start
, end
- start
);
466 #ifndef IN_PROCESS_AGENT
468 /* Look for a sequence of characters which can be run-length encoded.
469 If there are any, update *CSUM and *P. Otherwise, output the
470 single character. Return the number of characters consumed. */
473 try_rle (char *buf
, int remaining
, unsigned char *csum
, char **p
)
477 /* Always output the character. */
481 /* Don't go past '~'. */
485 for (n
= 1; n
< remaining
; n
++)
486 if (buf
[n
] != buf
[0])
489 /* N is the index of the first character not the same as buf[0].
490 buf[0] is counted twice, so by decrementing N, we get the number
491 of characters the RLE sequence will replace. */
497 /* Skip the frame characters. The manual says to skip '+' and '-'
498 also, but there's no reason to. Unfortunately these two unusable
499 characters double the encoded length of a four byte zero
501 while (n
+ 29 == '$' || n
+ 29 == '#')
514 #ifndef IN_PROCESS_AGENT
516 /* Write a PTID to BUF. Returns BUF+CHARACTERS_WRITTEN. */
519 write_ptid (char *buf
, ptid_t ptid
)
521 client_state
&cs
= get_client_state ();
524 if (cs
.multi_process
)
528 buf
+= sprintf (buf
, "p-%x.", -pid
);
530 buf
+= sprintf (buf
, "p%x.", pid
);
534 buf
+= sprintf (buf
, "-%x", -tid
);
536 buf
+= sprintf (buf
, "%x", tid
);
542 hex_or_minus_one (const char *buf
, const char **obuf
)
546 if (startswith (buf
, "-1"))
552 buf
= unpack_varlen_hex (buf
, &ret
);
560 /* Extract a PTID from BUF. If non-null, OBUF is set to the to one
561 passed the last parsed char. Returns null_ptid on error. */
563 read_ptid (const char *buf
, const char **obuf
)
567 ULONGEST pid
= 0, tid
= 0;
571 /* Multi-process ptid. */
572 pp
= unpack_varlen_hex (p
+ 1, &pid
);
574 error ("invalid remote ptid: %s\n", p
);
578 tid
= hex_or_minus_one (p
, &pp
);
582 return ptid_t (pid
, tid
);
585 /* No multi-process. Just a tid. */
586 tid
= hex_or_minus_one (p
, &pp
);
588 /* Since GDB is not sending a process id (multi-process extensions
589 are off), then there's only one process. Default to the first in
591 pid
= pid_of (get_first_process ());
595 return ptid_t (pid
, tid
);
598 /* Write COUNT bytes in BUF to the client.
599 The result is the number of bytes written or -1 if error.
600 This may return less than COUNT. */
603 write_prim (const void *buf
, int count
)
605 if (remote_connection_is_stdio ())
606 return write (fileno (stdout
), buf
, count
);
608 return write (remote_desc
, buf
, count
);
611 /* Read COUNT bytes from the client and store in BUF.
612 The result is the number of bytes read or -1 if error.
613 This may return less than COUNT. */
616 read_prim (void *buf
, int count
)
618 if (remote_connection_is_stdio ())
619 return read (fileno (stdin
), buf
, count
);
621 return read (remote_desc
, buf
, count
);
624 /* Send a packet to the remote machine, with error checking.
625 The data of the packet is in BUF, and the length of the
626 packet is in CNT. Returns >= 0 on success, -1 otherwise. */
629 putpkt_binary_1 (char *buf
, int cnt
, int is_notif
)
631 client_state
&cs
= get_client_state ();
633 unsigned char csum
= 0;
638 buf2
= (char *) xmalloc (strlen ("$") + cnt
+ strlen ("#nn") + 1);
640 /* Copy the packet into buffer BUF2, encapsulating it
641 and giving it a checksum. */
649 for (i
= 0; i
< cnt
;)
650 i
+= try_rle (buf
+ i
, cnt
- i
, &csum
, &p
);
653 *p
++ = tohex ((csum
>> 4) & 0xf);
654 *p
++ = tohex (csum
& 0xf);
658 /* Send it over and over until we get a positive ack. */
662 if (write_prim (buf2
, p
- buf2
) != p
- buf2
)
664 perror ("putpkt(write)");
669 if (cs
.noack_mode
|| is_notif
)
671 /* Don't expect an ack then. */
673 remote_debug_printf ("putpkt (\"%s\"); [notif]", buf2
);
675 remote_debug_printf ("putpkt (\"%s\"); [noack mode]", buf2
);
680 remote_debug_printf ("putpkt (\"%s\"); [looking for ack]", buf2
);
690 remote_debug_printf ("[received '%c' (0x%x)]", cc
, cc
);
692 /* Check for an input interrupt while we're here. */
693 if (cc
== '\003' && current_thread
!= NULL
)
694 the_target
->request_interrupt ();
699 return 1; /* Success! */
703 putpkt_binary (char *buf
, int cnt
)
705 return putpkt_binary_1 (buf
, cnt
, 0);
708 /* Send a packet to the remote machine, with error checking. The data
709 of the packet is in BUF, and the packet should be a NUL-terminated
710 string. Returns >= 0 on success, -1 otherwise. */
715 return putpkt_binary (buf
, strlen (buf
));
719 putpkt_notif (char *buf
)
721 return putpkt_binary_1 (buf
, strlen (buf
), 1);
724 /* Come here when we get an input interrupt from the remote side. This
725 interrupt should only be active while we are waiting for the child to do
726 something. Thus this assumes readchar:bufcnt is 0.
727 About the only thing that should come through is a ^C, which
728 will cause us to request child interruption. */
731 input_interrupt (int unused
)
734 struct timeval immediate
= { 0, 0 };
736 /* Protect against spurious interrupts. This has been observed to
737 be a problem under NetBSD 1.4 and 1.5. */
740 FD_SET (remote_desc
, &readset
);
741 if (select (remote_desc
+ 1, &readset
, 0, 0, &immediate
) > 0)
746 cc
= read_prim (&c
, 1);
750 fprintf (stderr
, "client connection closed\n");
753 else if (cc
!= 1 || c
!= '\003')
755 fprintf (stderr
, "input_interrupt, count = %d c = %d ", cc
, c
);
757 fprintf (stderr
, "('%c')\n", c
);
759 fprintf (stderr
, "('\\x%02x')\n", c
& 0xff);
763 the_target
->request_interrupt ();
767 /* Check if the remote side sent us an interrupt request (^C). */
769 check_remote_input_interrupt_request (void)
771 /* This function may be called before establishing communications,
772 therefore we need to validate the remote descriptor. */
774 if (remote_desc
== -1)
780 /* Asynchronous I/O support. SIGIO must be unblocked when waiting,
781 in order to accept Control-C from the client, and must be blocked
782 when talking to the client. */
785 block_unblock_async_io (int block
)
790 sigemptyset (&sigio_set
);
791 sigaddset (&sigio_set
, SIGIO
);
792 gdb_sigmask (block
? SIG_BLOCK
: SIG_UNBLOCK
, &sigio_set
, NULL
);
796 /* Current state of asynchronous I/O. */
797 static int async_io_enabled
;
799 /* Enable asynchronous I/O. */
801 enable_async_io (void)
803 if (async_io_enabled
)
806 block_unblock_async_io (0);
808 async_io_enabled
= 1;
811 /* Disable asynchronous I/O. */
813 disable_async_io (void)
815 if (!async_io_enabled
)
818 block_unblock_async_io (1);
820 async_io_enabled
= 0;
824 initialize_async_io (void)
826 /* Make sure that async I/O starts blocked. */
827 async_io_enabled
= 1;
830 /* Install the signal handler. */
832 signal (SIGIO
, input_interrupt
);
836 /* Internal buffer used by readchar.
837 These are global to readchar because reschedule_remote needs to be
838 able to tell whether the buffer is empty. */
840 static unsigned char readchar_buf
[BUFSIZ
];
841 static int readchar_bufcnt
= 0;
842 static unsigned char *readchar_bufp
;
844 /* Returns next char from remote GDB. -1 if error. */
851 if (readchar_bufcnt
== 0)
853 readchar_bufcnt
= read_prim (readchar_buf
, sizeof (readchar_buf
));
855 if (readchar_bufcnt
<= 0)
857 if (readchar_bufcnt
== 0)
859 remote_debug_printf ("readchar: Got EOF");
867 readchar_bufp
= readchar_buf
;
871 ch
= *readchar_bufp
++;
876 /* Reset the readchar state machine. */
879 reset_readchar (void)
882 if (readchar_callback
!= NOT_SCHEDULED
)
884 delete_timer (readchar_callback
);
885 readchar_callback
= NOT_SCHEDULED
;
889 /* Process remaining data in readchar_buf. */
892 process_remaining (void *context
)
894 /* This is a one-shot event. */
895 readchar_callback
= NOT_SCHEDULED
;
897 if (readchar_bufcnt
> 0)
898 handle_serial_event (0, NULL
);
901 /* If there is still data in the buffer, queue another event to process it,
902 we can't sleep in select yet. */
907 if (readchar_bufcnt
> 0 && readchar_callback
== NOT_SCHEDULED
)
908 readchar_callback
= create_timer (0, process_remaining
, NULL
);
911 /* Read a packet from the remote machine, with error checking,
912 and store it in BUF. Returns length of packet, or negative if error. */
917 client_state
&cs
= get_client_state ();
919 unsigned char csum
, c1
, c2
;
930 /* The '\003' may appear before or after each packet, so
931 check for an input interrupt. */
934 the_target
->request_interrupt ();
941 remote_debug_printf ("[getpkt: discarding char '%c']", c
);
960 c1
= fromhex (readchar ());
961 c2
= fromhex (readchar ());
963 if (csum
== (c1
<< 4) + c2
)
969 "Bad checksum, sentsum=0x%x, csum=0x%x, "
970 "buf=%s [no-ack-mode, Bad medium?]\n",
971 (c1
<< 4) + c2
, csum
, buf
);
972 /* Not much we can do, GDB wasn't expecting an ack/nac. */
976 fprintf (stderr
, "Bad checksum, sentsum=0x%x, csum=0x%x, buf=%s\n",
977 (c1
<< 4) + c2
, csum
, buf
);
978 if (write_prim ("-", 1) != 1)
984 remote_debug_printf ("getpkt (\"%s\"); [sending ack]", buf
);
986 if (write_prim ("+", 1) != 1)
989 remote_debug_printf ("[sent ack]");
992 remote_debug_printf ("getpkt (\"%s\"); [no ack sent]", buf
);
994 /* The readchar above may have already read a '\003' out of the socket
995 and moved it to the local buffer. For example, when GDB sends
996 vCont;c immediately followed by interrupt (see
997 gdb.base/interrupt-noterm.exp). As soon as we see the vCont;c, we'll
998 resume the inferior and wait. Since we've already moved the '\003'
999 to the local buffer, SIGIO won't help. In that case, if we don't
1000 check for interrupt after the vCont;c packet, the interrupt character
1001 would stay in the buffer unattended until after the next (unrelated)
1003 while (readchar_bufcnt
> 0 && *readchar_bufp
== '\003')
1005 /* Consume the interrupt character in the buffer. */
1007 the_target
->request_interrupt ();
1014 write_ok (char *buf
)
1022 write_enn (char *buf
)
1024 /* Some day, we should define the meanings of the error codes... */
1033 #ifndef IN_PROCESS_AGENT
1036 outreg (struct regcache
*regcache
, int regno
, char *buf
)
1038 if ((regno
>> 12) != 0)
1039 *buf
++ = tohex ((regno
>> 12) & 0xf);
1040 if ((regno
>> 8) != 0)
1041 *buf
++ = tohex ((regno
>> 8) & 0xf);
1042 *buf
++ = tohex ((regno
>> 4) & 0xf);
1043 *buf
++ = tohex (regno
& 0xf);
1045 collect_register_as_string (regcache
, regno
, buf
);
1046 buf
+= 2 * register_size (regcache
->tdesc
, regno
);
1053 prepare_resume_reply (char *buf
, ptid_t ptid
, const target_waitstatus
&status
)
1055 client_state
&cs
= get_client_state ();
1056 threads_debug_printf ("Writing resume reply for %s: %s",
1057 target_pid_to_str (ptid
).c_str (),
1058 status
.to_string ().c_str ());
1060 switch (status
.kind ())
1062 case TARGET_WAITKIND_STOPPED
:
1063 case TARGET_WAITKIND_FORKED
:
1064 case TARGET_WAITKIND_VFORKED
:
1065 case TARGET_WAITKIND_VFORK_DONE
:
1066 case TARGET_WAITKIND_THREAD_CLONED
:
1067 case TARGET_WAITKIND_EXECD
:
1068 case TARGET_WAITKIND_THREAD_CREATED
:
1069 case TARGET_WAITKIND_SYSCALL_ENTRY
:
1070 case TARGET_WAITKIND_SYSCALL_RETURN
:
1072 struct regcache
*regcache
;
1073 char *buf_start
= buf
;
1075 if ((status
.kind () == TARGET_WAITKIND_FORKED
1076 && cs
.report_fork_events
)
1077 || (status
.kind () == TARGET_WAITKIND_VFORKED
1078 && cs
.report_vfork_events
)
1079 || status
.kind () == TARGET_WAITKIND_THREAD_CLONED
)
1081 enum gdb_signal signal
= GDB_SIGNAL_TRAP
;
1083 auto kind_remote_str
= [] (target_waitkind kind
)
1087 case TARGET_WAITKIND_FORKED
:
1089 case TARGET_WAITKIND_VFORKED
:
1091 case TARGET_WAITKIND_THREAD_CLONED
:
1094 gdb_assert_not_reached ("unhandled kind");
1098 const char *event
= kind_remote_str (status
.kind ());
1100 sprintf (buf
, "T%02x%s:", signal
, event
);
1101 buf
+= strlen (buf
);
1102 buf
= write_ptid (buf
, status
.child_ptid ());
1105 else if (status
.kind () == TARGET_WAITKIND_VFORK_DONE
1106 && cs
.report_vfork_events
)
1108 enum gdb_signal signal
= GDB_SIGNAL_TRAP
;
1110 sprintf (buf
, "T%02xvforkdone:;", signal
);
1112 else if (status
.kind () == TARGET_WAITKIND_EXECD
&& cs
.report_exec_events
)
1114 enum gdb_signal signal
= GDB_SIGNAL_TRAP
;
1115 const char *event
= "exec";
1116 char hexified_pathname
[PATH_MAX
* 2];
1118 sprintf (buf
, "T%02x%s:", signal
, event
);
1119 buf
+= strlen (buf
);
1121 /* Encode pathname to hexified format. */
1122 bin2hex ((const gdb_byte
*) status
.execd_pathname (),
1124 strlen (status
.execd_pathname ()));
1126 sprintf (buf
, "%s;", hexified_pathname
);
1127 buf
+= strlen (buf
);
1129 else if (status
.kind () == TARGET_WAITKIND_THREAD_CREATED
1130 && cs
.report_thread_events
)
1132 enum gdb_signal signal
= GDB_SIGNAL_TRAP
;
1134 sprintf (buf
, "T%02xcreate:;", signal
);
1136 else if (status
.kind () == TARGET_WAITKIND_SYSCALL_ENTRY
1137 || status
.kind () == TARGET_WAITKIND_SYSCALL_RETURN
)
1139 enum gdb_signal signal
= GDB_SIGNAL_TRAP
;
1140 const char *event
= (status
.kind () == TARGET_WAITKIND_SYSCALL_ENTRY
1141 ? "syscall_entry" : "syscall_return");
1143 sprintf (buf
, "T%02x%s:%x;", signal
, event
,
1144 status
.syscall_number ());
1147 sprintf (buf
, "T%02x", status
.sig ());
1149 if (disable_packet_T
)
1151 /* This is a bit (OK, a lot) of a kludge, however, this isn't
1152 really a user feature, but exists only so GDB can use the
1153 gdbserver to test handling of the 'S' stop reply packet, so
1154 we would rather this code be as simple as possible.
1156 By this point we've started to build the 'T' stop packet,
1157 and it should look like 'Txx....' where 'x' is a hex digit.
1158 An 'S' stop packet always looks like 'Sxx', so all we do
1159 here is convert the buffer from a T packet to an S packet
1160 and the avoid adding any extra content by breaking out. */
1161 gdb_assert (buf_start
[0] == 'T');
1162 gdb_assert (isxdigit (buf_start
[1]));
1163 gdb_assert (isxdigit (buf_start
[2]));
1165 buf_start
[3] = '\0';
1169 buf
+= strlen (buf
);
1171 scoped_restore_current_thread restore_thread
;
1173 switch_to_thread (the_target
, ptid
);
1175 regcache
= get_thread_regcache (current_thread
, 1);
1177 if (the_target
->stopped_by_watchpoint ())
1182 memcpy (buf
, "watch:", 6);
1185 addr
= the_target
->stopped_data_address ();
1187 /* Convert each byte of the address into two hexadecimal
1188 chars. Note that we take sizeof (void *) instead of
1189 sizeof (addr); this is to avoid sending a 64-bit
1190 address to a 32-bit GDB. */
1191 for (i
= sizeof (void *) * 2; i
> 0; i
--)
1192 *buf
++ = tohex ((addr
>> (i
- 1) * 4) & 0xf);
1195 else if (cs
.swbreak_feature
&& target_stopped_by_sw_breakpoint ())
1197 sprintf (buf
, "swbreak:;");
1198 buf
+= strlen (buf
);
1200 else if (cs
.hwbreak_feature
&& target_stopped_by_hw_breakpoint ())
1202 sprintf (buf
, "hwbreak:;");
1203 buf
+= strlen (buf
);
1206 /* Handle the expedited registers. */
1207 for (const std::string
&expedited_reg
:
1208 current_target_desc ()->expedite_regs
)
1209 buf
= outreg (regcache
, find_regno (regcache
->tdesc
,
1210 expedited_reg
.c_str ()), buf
);
1213 /* Formerly, if the debugger had not used any thread features
1214 we would not burden it with a thread status response. This
1215 was for the benefit of GDB 4.13 and older. However, in
1216 recent GDB versions the check (``if (cont_thread != 0)'')
1217 does not have the desired effect because of silliness in
1218 the way that the remote protocol handles specifying a
1219 thread. Since thread support relies on qSymbol support
1220 anyway, assume GDB can handle threads. */
1222 if (using_threads
&& !disable_packet_Tthread
)
1224 /* This if (1) ought to be unnecessary. But remote_wait
1225 in GDB will claim this event belongs to inferior_ptid
1226 if we do not specify a thread, and there's no way for
1227 gdbserver to know what inferior_ptid is. */
1228 if (1 || cs
.general_thread
!= ptid
)
1231 /* In non-stop, don't change the general thread behind
1234 cs
.general_thread
= ptid
;
1235 sprintf (buf
, "thread:");
1236 buf
+= strlen (buf
);
1237 buf
= write_ptid (buf
, ptid
);
1239 buf
+= strlen (buf
);
1241 core
= target_core_of_thread (ptid
);
1245 sprintf (buf
, "core:");
1246 buf
+= strlen (buf
);
1247 sprintf (buf
, "%x", core
);
1249 buf
+= strlen (buf
);
1254 if (current_process ()->dlls_changed
)
1256 strcpy (buf
, "library:;");
1257 buf
+= strlen (buf
);
1258 current_process ()->dlls_changed
= false;
1262 case TARGET_WAITKIND_EXITED
:
1263 if (cs
.multi_process
)
1264 sprintf (buf
, "W%x;process:%x",
1265 status
.exit_status (), ptid
.pid ());
1267 sprintf (buf
, "W%02x", status
.exit_status ());
1269 case TARGET_WAITKIND_SIGNALLED
:
1270 if (cs
.multi_process
)
1271 sprintf (buf
, "X%x;process:%x",
1272 status
.sig (), ptid
.pid ());
1274 sprintf (buf
, "X%02x", status
.sig ());
1276 case TARGET_WAITKIND_THREAD_EXITED
:
1277 sprintf (buf
, "w%x;", status
.exit_status ());
1278 buf
+= strlen (buf
);
1279 buf
= write_ptid (buf
, ptid
);
1281 case TARGET_WAITKIND_NO_RESUMED
:
1285 error ("unhandled waitkind");
1290 /* See remote-utils.h. */
1293 decode_m_packet_params (const char *from
, CORE_ADDR
*mem_addr_ptr
,
1294 unsigned int *len_ptr
, const char end_marker
)
1298 *mem_addr_ptr
= *len_ptr
= 0;
1300 while ((ch
= from
[i
++]) != ',')
1302 *mem_addr_ptr
= *mem_addr_ptr
<< 4;
1303 *mem_addr_ptr
|= fromhex (ch
) & 0x0f;
1306 while ((ch
= from
[i
++]) != end_marker
)
1308 *len_ptr
= *len_ptr
<< 4;
1309 *len_ptr
|= fromhex (ch
) & 0x0f;
1316 decode_m_packet (const char *from
, CORE_ADDR
*mem_addr_ptr
,
1317 unsigned int *len_ptr
)
1319 decode_m_packet_params (from
, mem_addr_ptr
, len_ptr
, '\0');
1323 decode_M_packet (const char *from
, CORE_ADDR
*mem_addr_ptr
,
1324 unsigned int *len_ptr
, unsigned char **to_p
)
1326 from
= decode_m_packet_params (from
, mem_addr_ptr
, len_ptr
, ':');
1329 *to_p
= (unsigned char *) xmalloc (*len_ptr
);
1331 hex2bin (from
, *to_p
, *len_ptr
);
1335 decode_X_packet (char *from
, int packet_len
, CORE_ADDR
*mem_addr_ptr
,
1336 unsigned int *len_ptr
, unsigned char **to_p
)
1340 *mem_addr_ptr
= *len_ptr
= 0;
1342 while ((ch
= from
[i
++]) != ',')
1344 *mem_addr_ptr
= *mem_addr_ptr
<< 4;
1345 *mem_addr_ptr
|= fromhex (ch
) & 0x0f;
1348 while ((ch
= from
[i
++]) != ':')
1350 *len_ptr
= *len_ptr
<< 4;
1351 *len_ptr
|= fromhex (ch
) & 0x0f;
1355 *to_p
= (unsigned char *) xmalloc (*len_ptr
);
1357 if (remote_unescape_input ((const gdb_byte
*) &from
[i
], packet_len
- i
,
1358 *to_p
, *len_ptr
) != *len_ptr
)
1364 /* Decode a qXfer write request. */
1367 decode_xfer_write (char *buf
, int packet_len
, CORE_ADDR
*offset
,
1368 unsigned int *len
, unsigned char *data
)
1373 /* Extract the offset. */
1375 while ((ch
= *buf
++) != ':')
1377 *offset
= *offset
<< 4;
1378 *offset
|= fromhex (ch
) & 0x0f;
1381 /* Get encoded data. */
1382 packet_len
-= buf
- b
;
1383 *len
= remote_unescape_input ((const gdb_byte
*) buf
, packet_len
,
1388 /* Decode the parameters of a qSearch:memory packet. */
1391 decode_search_memory_packet (const char *buf
, int packet_len
,
1392 CORE_ADDR
*start_addrp
,
1393 CORE_ADDR
*search_space_lenp
,
1394 gdb_byte
*pattern
, unsigned int *pattern_lenp
)
1396 const char *p
= buf
;
1398 p
= decode_address_to_semicolon (start_addrp
, p
);
1399 p
= decode_address_to_semicolon (search_space_lenp
, p
);
1400 packet_len
-= p
- buf
;
1401 *pattern_lenp
= remote_unescape_input ((const gdb_byte
*) p
, packet_len
,
1402 pattern
, packet_len
);
1407 free_sym_cache (struct sym_cache
*sym
)
1417 clear_symbol_cache (struct sym_cache
**symcache_p
)
1419 struct sym_cache
*sym
, *next
;
1421 /* Check the cache first. */
1422 for (sym
= *symcache_p
; sym
; sym
= next
)
1425 free_sym_cache (sym
);
1431 /* Get the address of NAME, and return it in ADDRP if found. if
1432 MAY_ASK_GDB is false, assume symbol cache misses are failures.
1433 Returns 1 if the symbol is found, 0 if it is not, -1 on error. */
1436 look_up_one_symbol (const char *name
, CORE_ADDR
*addrp
, int may_ask_gdb
)
1438 client_state
&cs
= get_client_state ();
1441 struct sym_cache
*sym
;
1442 struct process_info
*proc
;
1444 proc
= current_process ();
1446 /* Check the cache first. */
1447 for (sym
= proc
->symbol_cache
; sym
; sym
= sym
->next
)
1448 if (strcmp (name
, sym
->name
) == 0)
1454 /* It might not be an appropriate time to look up a symbol,
1455 e.g. while we're trying to fetch registers. */
1459 /* Send the request. */
1460 strcpy (cs
.own_buf
, "qSymbol:");
1461 bin2hex ((const gdb_byte
*) name
, cs
.own_buf
+ strlen ("qSymbol:"),
1463 if (putpkt (cs
.own_buf
) < 0)
1466 /* FIXME: Eventually add buffer overflow checking (to getpkt?) */
1467 len
= getpkt (cs
.own_buf
);
1471 /* We ought to handle pretty much any packet at this point while we
1472 wait for the qSymbol "response". That requires re-entering the
1473 main loop. For now, this is an adequate approximation; allow
1474 GDB to read from memory and handle 'v' packets (for vFile transfers)
1475 while it figures out the address of the symbol. */
1478 if (cs
.own_buf
[0] == 'm')
1481 unsigned char *mem_buf
;
1482 unsigned int mem_len
;
1484 decode_m_packet (&cs
.own_buf
[1], &mem_addr
, &mem_len
);
1485 mem_buf
= (unsigned char *) xmalloc (mem_len
);
1486 if (read_inferior_memory (mem_addr
, mem_buf
, mem_len
) == 0)
1487 bin2hex (mem_buf
, cs
.own_buf
, mem_len
);
1489 write_enn (cs
.own_buf
);
1491 if (putpkt (cs
.own_buf
) < 0)
1494 else if (cs
.own_buf
[0] == 'v')
1497 handle_v_requests (cs
.own_buf
, len
, &new_len
);
1499 putpkt_binary (cs
.own_buf
, new_len
);
1501 putpkt (cs
.own_buf
);
1505 len
= getpkt (cs
.own_buf
);
1510 if (!startswith (cs
.own_buf
, "qSymbol:"))
1512 warning ("Malformed response to qSymbol, ignoring: %s", cs
.own_buf
);
1516 p
= cs
.own_buf
+ strlen ("qSymbol:");
1518 while (*q
&& *q
!= ':')
1521 /* Make sure we found a value for the symbol. */
1522 if (p
== q
|| *q
== '\0')
1525 decode_address (addrp
, p
, q
- p
);
1527 /* Save the symbol in our cache. */
1528 sym
= XNEW (struct sym_cache
);
1529 sym
->name
= xstrdup (name
);
1531 sym
->next
= proc
->symbol_cache
;
1532 proc
->symbol_cache
= sym
;
1537 /* Relocate an instruction to execute at a different address. OLDLOC
1538 is the address in the inferior memory where the instruction to
1539 relocate is currently at. On input, TO points to the destination
1540 where we want the instruction to be copied (and possibly adjusted)
1541 to. On output, it points to one past the end of the resulting
1542 instruction(s). The effect of executing the instruction at TO
1543 shall be the same as if executing it at OLDLOC. For example, call
1544 instructions that implicitly push the return address on the stack
1545 should be adjusted to return to the instruction after OLDLOC;
1546 relative branches, and other PC-relative instructions need the
1547 offset adjusted; etc. Returns 0 on success, -1 on failure. */
1550 relocate_instruction (CORE_ADDR
*to
, CORE_ADDR oldloc
)
1552 client_state
&cs
= get_client_state ();
1554 ULONGEST written
= 0;
1556 /* Send the request. */
1557 sprintf (cs
.own_buf
, "qRelocInsn:%s;%s", paddress (oldloc
),
1559 if (putpkt (cs
.own_buf
) < 0)
1562 /* FIXME: Eventually add buffer overflow checking (to getpkt?) */
1563 len
= getpkt (cs
.own_buf
);
1567 /* We ought to handle pretty much any packet at this point while we
1568 wait for the qRelocInsn "response". That requires re-entering
1569 the main loop. For now, this is an adequate approximation; allow
1570 GDB to access memory. */
1571 while (cs
.own_buf
[0] == 'm' || cs
.own_buf
[0] == 'M' || cs
.own_buf
[0] == 'X')
1574 unsigned char *mem_buf
= NULL
;
1575 unsigned int mem_len
;
1577 if (cs
.own_buf
[0] == 'm')
1579 decode_m_packet (&cs
.own_buf
[1], &mem_addr
, &mem_len
);
1580 mem_buf
= (unsigned char *) xmalloc (mem_len
);
1581 if (read_inferior_memory (mem_addr
, mem_buf
, mem_len
) == 0)
1582 bin2hex (mem_buf
, cs
.own_buf
, mem_len
);
1584 write_enn (cs
.own_buf
);
1586 else if (cs
.own_buf
[0] == 'X')
1588 if (decode_X_packet (&cs
.own_buf
[1], len
- 1, &mem_addr
,
1589 &mem_len
, &mem_buf
) < 0
1590 || target_write_memory (mem_addr
, mem_buf
, mem_len
) != 0)
1591 write_enn (cs
.own_buf
);
1593 write_ok (cs
.own_buf
);
1597 decode_M_packet (&cs
.own_buf
[1], &mem_addr
, &mem_len
, &mem_buf
);
1598 if (target_write_memory (mem_addr
, mem_buf
, mem_len
) == 0)
1599 write_ok (cs
.own_buf
);
1601 write_enn (cs
.own_buf
);
1604 if (putpkt (cs
.own_buf
) < 0)
1606 len
= getpkt (cs
.own_buf
);
1611 if (cs
.own_buf
[0] == 'E')
1613 warning ("An error occurred while relocating an instruction: %s",
1618 if (!startswith (cs
.own_buf
, "qRelocInsn:"))
1620 warning ("Malformed response to qRelocInsn, ignoring: %s",
1625 unpack_varlen_hex (cs
.own_buf
+ strlen ("qRelocInsn:"), &written
);
1632 monitor_output (const char *msg
)
1634 int len
= strlen (msg
);
1635 char *buf
= (char *) xmalloc (len
* 2 + 2);
1638 bin2hex ((const gdb_byte
*) msg
, buf
+ 1, len
);