1 /* Remote utility routines for the remote server for GDB.
2 Copyright (C) 1986-2021 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
);
148 debug_printf ("handling possible accept event\n");
150 remote_desc
= accept (listen_desc
, (struct sockaddr
*) &sockaddr
, &len
);
151 if (remote_desc
== -1)
152 perror_with_name ("Accept failed");
154 /* Enable TCP keep alive process. */
156 setsockopt (remote_desc
, SOL_SOCKET
, SO_KEEPALIVE
,
157 (char *) &tmp
, sizeof (tmp
));
159 /* Tell TCP not to delay small packets. This greatly speeds up
160 interactive response. */
162 setsockopt (remote_desc
, IPPROTO_TCP
, TCP_NODELAY
,
163 (char *) &tmp
, sizeof (tmp
));
166 signal (SIGPIPE
, SIG_IGN
); /* If we don't do this, then gdbserver simply
167 exits when the remote side dies. */
173 close (listen_desc
); /* No longer need this */
175 closesocket (listen_desc
); /* No longer need this */
179 /* Even if !RUN_ONCE no longer notice new connections. Still keep the
180 descriptor open for add_file_handler to wait for a new connection. */
181 delete_file_handler (listen_desc
);
183 /* Convert IP address to string. */
184 char orig_host
[GDB_NI_MAX_ADDR
], orig_port
[GDB_NI_MAX_PORT
];
186 int r
= getnameinfo ((struct sockaddr
*) &sockaddr
, len
,
187 orig_host
, sizeof (orig_host
),
188 orig_port
, sizeof (orig_port
),
189 NI_NUMERICHOST
| NI_NUMERICSERV
);
192 fprintf (stderr
, _("Could not obtain remote address: %s\n"),
195 fprintf (stderr
, _("Remote debugging from host %s, port %s\n"),
196 orig_host
, orig_port
);
198 enable_async_notification (remote_desc
);
200 /* Register the event loop handler. */
201 add_file_handler (remote_desc
, handle_serial_event
, NULL
, "remote-net");
203 /* We have a new GDB connection now. If we were disconnected
204 tracing, there's a window where the target could report a stop
205 event to the event loop, and since we have a connection now, we'd
206 try to send vStopped notifications to GDB. But, don't do that
207 until GDB as selected all-stop/non-stop, and has queried the
208 threads' status ('?'). */
212 /* Prepare for a later connection to a remote debugger.
213 NAME is the filename used for communication. */
216 remote_prepare (const char *name
)
218 client_state
&cs
= get_client_state ();
220 static int winsock_initialized
;
225 if (strcmp (name
, STDIO_CONNECTION_NAME
) == 0)
227 /* We need to record fact that we're using stdio sooner than the
228 call to remote_open so start_inferior knows the connection is
231 cs
.transport_is_reliable
= 1;
235 struct addrinfo hint
;
236 struct addrinfo
*ainfo
;
238 memset (&hint
, 0, sizeof (hint
));
239 /* Assume no prefix will be passed, therefore we should use
241 hint
.ai_family
= AF_UNSPEC
;
242 hint
.ai_socktype
= SOCK_STREAM
;
243 hint
.ai_protocol
= IPPROTO_TCP
;
245 parsed_connection_spec parsed
246 = parse_connection_spec_without_prefix (name
, &hint
);
248 if (parsed
.port_str
.empty ())
250 cs
.transport_is_reliable
= 0;
255 if (!winsock_initialized
)
259 WSAStartup (MAKEWORD (1, 0), &wsad
);
260 winsock_initialized
= 1;
264 int r
= getaddrinfo (parsed
.host_str
.c_str (), parsed
.port_str
.c_str (),
268 error (_("%s: cannot resolve name: %s"), name
, gai_strerror (r
));
270 scoped_free_addrinfo
freeaddrinfo (ainfo
);
272 struct addrinfo
*iter
;
274 for (iter
= ainfo
; iter
!= NULL
; iter
= iter
->ai_next
)
276 listen_desc
= gdb_socket_cloexec (iter
->ai_family
, iter
->ai_socktype
,
279 if (listen_desc
>= 0)
284 perror_with_name ("Can't open socket");
286 /* Allow rapid reuse of this port. */
288 setsockopt (listen_desc
, SOL_SOCKET
, SO_REUSEADDR
, (char *) &tmp
,
291 switch (iter
->ai_family
)
294 ((struct sockaddr_in
*) iter
->ai_addr
)->sin_addr
.s_addr
= INADDR_ANY
;
297 ((struct sockaddr_in6
*) iter
->ai_addr
)->sin6_addr
= in6addr_any
;
300 internal_error (__FILE__
, __LINE__
,
301 _("Invalid 'ai_family' %d\n"), iter
->ai_family
);
304 if (bind (listen_desc
, iter
->ai_addr
, iter
->ai_addrlen
) != 0)
305 perror_with_name ("Can't bind address");
307 if (listen (listen_desc
, 1) != 0)
308 perror_with_name ("Can't listen on socket");
310 cs
.transport_is_reliable
= 1;
313 /* Open a connection to a remote debugger.
314 NAME is the filename used for communication. */
317 remote_open (const char *name
)
319 const char *port_str
;
321 port_str
= strchr (name
, ':');
323 if (port_str
== NULL
)
324 error ("Only HOST:PORT is supported on this platform.");
327 if (strcmp (name
, STDIO_CONNECTION_NAME
) == 0)
329 fprintf (stderr
, "Remote debugging using stdio\n");
331 /* Use stdin as the handle of the connection.
332 We only select on reads, for example. */
333 remote_desc
= fileno (stdin
);
335 enable_async_notification (remote_desc
);
337 /* Register the event loop handler. */
338 add_file_handler (remote_desc
, handle_serial_event
, NULL
, "remote-stdio");
341 else if (port_str
== NULL
)
345 if (stat (name
, &statbuf
) == 0
346 && (S_ISCHR (statbuf
.st_mode
) || S_ISFIFO (statbuf
.st_mode
)))
347 remote_desc
= open (name
, O_RDWR
);
355 perror_with_name ("Could not open remote device");
359 struct termios termios
;
360 tcgetattr (remote_desc
, &termios
);
365 termios
.c_cflag
&= ~(CSIZE
| PARENB
);
366 termios
.c_cflag
|= CLOCAL
| CS8
;
367 termios
.c_cc
[VMIN
] = 1;
368 termios
.c_cc
[VTIME
] = 0;
370 tcsetattr (remote_desc
, TCSANOW
, &termios
);
374 fprintf (stderr
, "Remote debugging using %s\n", name
);
376 enable_async_notification (remote_desc
);
378 /* Register the event loop handler. */
379 add_file_handler (remote_desc
, handle_serial_event
, NULL
,
382 #endif /* USE_WIN32API */
385 char listen_port
[GDB_NI_MAX_PORT
];
386 struct sockaddr_storage sockaddr
;
387 socklen_t len
= sizeof (sockaddr
);
389 if (getsockname (listen_desc
, (struct sockaddr
*) &sockaddr
, &len
) < 0)
390 perror_with_name ("Can't determine port");
392 int r
= getnameinfo ((struct sockaddr
*) &sockaddr
, len
,
394 listen_port
, sizeof (listen_port
),
398 fprintf (stderr
, _("Can't obtain port where we are listening: %s"),
401 fprintf (stderr
, _("Listening on port %s\n"), listen_port
);
405 /* Register the event loop handler. */
406 add_file_handler (listen_desc
, handle_accept_event
, NULL
,
414 delete_file_handler (remote_desc
);
419 closesocket (remote_desc
);
421 if (! remote_connection_is_stdio ())
431 #ifndef IN_PROCESS_AGENT
434 decode_address (CORE_ADDR
*addrp
, const char *start
, int len
)
441 for (i
= 0; i
< len
; i
++)
445 addr
= addr
| (fromhex (ch
) & 0x0f);
451 decode_address_to_semicolon (CORE_ADDR
*addrp
, const char *start
)
456 while (*end
!= '\0' && *end
!= ';')
459 decode_address (addrp
, start
, end
- start
);
468 #ifndef IN_PROCESS_AGENT
470 /* Look for a sequence of characters which can be run-length encoded.
471 If there are any, update *CSUM and *P. Otherwise, output the
472 single character. Return the number of characters consumed. */
475 try_rle (char *buf
, int remaining
, unsigned char *csum
, char **p
)
479 /* Always output the character. */
483 /* Don't go past '~'. */
487 for (n
= 1; n
< remaining
; n
++)
488 if (buf
[n
] != buf
[0])
491 /* N is the index of the first character not the same as buf[0].
492 buf[0] is counted twice, so by decrementing N, we get the number
493 of characters the RLE sequence will replace. */
499 /* Skip the frame characters. The manual says to skip '+' and '-'
500 also, but there's no reason to. Unfortunately these two unusable
501 characters double the encoded length of a four byte zero
503 while (n
+ 29 == '$' || n
+ 29 == '#')
516 #ifndef IN_PROCESS_AGENT
518 /* Write a PTID to BUF. Returns BUF+CHARACTERS_WRITTEN. */
521 write_ptid (char *buf
, ptid_t ptid
)
523 client_state
&cs
= get_client_state ();
526 if (cs
.multi_process
)
530 buf
+= sprintf (buf
, "p-%x.", -pid
);
532 buf
+= sprintf (buf
, "p%x.", pid
);
536 buf
+= sprintf (buf
, "-%x", -tid
);
538 buf
+= sprintf (buf
, "%x", tid
);
544 hex_or_minus_one (const char *buf
, const char **obuf
)
548 if (startswith (buf
, "-1"))
554 buf
= unpack_varlen_hex (buf
, &ret
);
562 /* Extract a PTID from BUF. If non-null, OBUF is set to the to one
563 passed the last parsed char. Returns null_ptid on error. */
565 read_ptid (const char *buf
, const char **obuf
)
569 ULONGEST pid
= 0, tid
= 0;
573 /* Multi-process ptid. */
574 pp
= unpack_varlen_hex (p
+ 1, &pid
);
576 error ("invalid remote ptid: %s\n", p
);
580 tid
= hex_or_minus_one (p
, &pp
);
584 return ptid_t (pid
, tid
);
587 /* No multi-process. Just a tid. */
588 tid
= hex_or_minus_one (p
, &pp
);
590 /* Since GDB is not sending a process id (multi-process extensions
591 are off), then there's only one process. Default to the first in
593 pid
= pid_of (get_first_process ());
597 return ptid_t (pid
, tid
);
600 /* Write COUNT bytes in BUF to the client.
601 The result is the number of bytes written or -1 if error.
602 This may return less than COUNT. */
605 write_prim (const void *buf
, int count
)
607 if (remote_connection_is_stdio ())
608 return write (fileno (stdout
), buf
, count
);
610 return write (remote_desc
, buf
, count
);
613 /* Read COUNT bytes from the client and store in BUF.
614 The result is the number of bytes read or -1 if error.
615 This may return less than COUNT. */
618 read_prim (void *buf
, int count
)
620 if (remote_connection_is_stdio ())
621 return read (fileno (stdin
), buf
, count
);
623 return read (remote_desc
, buf
, count
);
626 /* Send a packet to the remote machine, with error checking.
627 The data of the packet is in BUF, and the length of the
628 packet is in CNT. Returns >= 0 on success, -1 otherwise. */
631 putpkt_binary_1 (char *buf
, int cnt
, int is_notif
)
633 client_state
&cs
= get_client_state ();
635 unsigned char csum
= 0;
640 buf2
= (char *) xmalloc (strlen ("$") + cnt
+ strlen ("#nn") + 1);
642 /* Copy the packet into buffer BUF2, encapsulating it
643 and giving it a checksum. */
651 for (i
= 0; i
< cnt
;)
652 i
+= try_rle (buf
+ i
, cnt
- i
, &csum
, &p
);
655 *p
++ = tohex ((csum
>> 4) & 0xf);
656 *p
++ = tohex (csum
& 0xf);
660 /* Send it over and over until we get a positive ack. */
664 if (write_prim (buf2
, p
- buf2
) != p
- buf2
)
666 perror ("putpkt(write)");
671 if (cs
.noack_mode
|| is_notif
)
673 /* Don't expect an ack then. */
677 debug_printf ("putpkt (\"%s\"); [notif]\n", buf2
);
679 debug_printf ("putpkt (\"%s\"); [noack mode]\n", buf2
);
687 debug_printf ("putpkt (\"%s\"); [looking for ack]\n", buf2
);
701 debug_printf ("[received '%c' (0x%x)]\n", cc
, cc
);
705 /* Check for an input interrupt while we're here. */
706 if (cc
== '\003' && current_thread
!= NULL
)
707 the_target
->request_interrupt ();
712 return 1; /* Success! */
716 putpkt_binary (char *buf
, int cnt
)
718 return putpkt_binary_1 (buf
, cnt
, 0);
721 /* Send a packet to the remote machine, with error checking. The data
722 of the packet is in BUF, and the packet should be a NUL-terminated
723 string. Returns >= 0 on success, -1 otherwise. */
728 return putpkt_binary (buf
, strlen (buf
));
732 putpkt_notif (char *buf
)
734 return putpkt_binary_1 (buf
, strlen (buf
), 1);
737 /* Come here when we get an input interrupt from the remote side. This
738 interrupt should only be active while we are waiting for the child to do
739 something. Thus this assumes readchar:bufcnt is 0.
740 About the only thing that should come through is a ^C, which
741 will cause us to request child interruption. */
744 input_interrupt (int unused
)
747 struct timeval immediate
= { 0, 0 };
749 /* Protect against spurious interrupts. This has been observed to
750 be a problem under NetBSD 1.4 and 1.5. */
753 FD_SET (remote_desc
, &readset
);
754 if (select (remote_desc
+ 1, &readset
, 0, 0, &immediate
) > 0)
759 cc
= read_prim (&c
, 1);
763 fprintf (stderr
, "client connection closed\n");
766 else if (cc
!= 1 || c
!= '\003')
768 fprintf (stderr
, "input_interrupt, count = %d c = %d ", cc
, c
);
770 fprintf (stderr
, "('%c')\n", c
);
772 fprintf (stderr
, "('\\x%02x')\n", c
& 0xff);
776 the_target
->request_interrupt ();
780 /* Check if the remote side sent us an interrupt request (^C). */
782 check_remote_input_interrupt_request (void)
784 /* This function may be called before establishing communications,
785 therefore we need to validate the remote descriptor. */
787 if (remote_desc
== -1)
793 /* Asynchronous I/O support. SIGIO must be unblocked when waiting,
794 in order to accept Control-C from the client, and must be blocked
795 when talking to the client. */
798 block_unblock_async_io (int block
)
803 sigemptyset (&sigio_set
);
804 sigaddset (&sigio_set
, SIGIO
);
805 gdb_sigmask (block
? SIG_BLOCK
: SIG_UNBLOCK
, &sigio_set
, NULL
);
809 /* Current state of asynchronous I/O. */
810 static int async_io_enabled
;
812 /* Enable asynchronous I/O. */
814 enable_async_io (void)
816 if (async_io_enabled
)
819 block_unblock_async_io (0);
821 async_io_enabled
= 1;
824 /* Disable asynchronous I/O. */
826 disable_async_io (void)
828 if (!async_io_enabled
)
831 block_unblock_async_io (1);
833 async_io_enabled
= 0;
837 initialize_async_io (void)
839 /* Make sure that async I/O starts blocked. */
840 async_io_enabled
= 1;
843 /* Install the signal handler. */
845 signal (SIGIO
, input_interrupt
);
849 /* Internal buffer used by readchar.
850 These are global to readchar because reschedule_remote needs to be
851 able to tell whether the buffer is empty. */
853 static unsigned char readchar_buf
[BUFSIZ
];
854 static int readchar_bufcnt
= 0;
855 static unsigned char *readchar_bufp
;
857 /* Returns next char from remote GDB. -1 if error. */
864 if (readchar_bufcnt
== 0)
866 readchar_bufcnt
= read_prim (readchar_buf
, sizeof (readchar_buf
));
868 if (readchar_bufcnt
<= 0)
870 if (readchar_bufcnt
== 0)
873 debug_printf ("readchar: Got EOF\n");
881 readchar_bufp
= readchar_buf
;
885 ch
= *readchar_bufp
++;
890 /* Reset the readchar state machine. */
893 reset_readchar (void)
896 if (readchar_callback
!= NOT_SCHEDULED
)
898 delete_timer (readchar_callback
);
899 readchar_callback
= NOT_SCHEDULED
;
903 /* Process remaining data in readchar_buf. */
906 process_remaining (void *context
)
908 /* This is a one-shot event. */
909 readchar_callback
= NOT_SCHEDULED
;
911 if (readchar_bufcnt
> 0)
912 handle_serial_event (0, NULL
);
915 /* If there is still data in the buffer, queue another event to process it,
916 we can't sleep in select yet. */
921 if (readchar_bufcnt
> 0 && readchar_callback
== NOT_SCHEDULED
)
922 readchar_callback
= create_timer (0, process_remaining
, NULL
);
925 /* Read a packet from the remote machine, with error checking,
926 and store it in BUF. Returns length of packet, or negative if error. */
931 client_state
&cs
= get_client_state ();
933 unsigned char csum
, c1
, c2
;
944 /* The '\003' may appear before or after each packet, so
945 check for an input interrupt. */
948 the_target
->request_interrupt ();
956 debug_printf ("[getpkt: discarding char '%c']\n", c
);
977 c1
= fromhex (readchar ());
978 c2
= fromhex (readchar ());
980 if (csum
== (c1
<< 4) + c2
)
986 "Bad checksum, sentsum=0x%x, csum=0x%x, "
987 "buf=%s [no-ack-mode, Bad medium?]\n",
988 (c1
<< 4) + c2
, csum
, buf
);
989 /* Not much we can do, GDB wasn't expecting an ack/nac. */
993 fprintf (stderr
, "Bad checksum, sentsum=0x%x, csum=0x%x, buf=%s\n",
994 (c1
<< 4) + c2
, csum
, buf
);
995 if (write_prim ("-", 1) != 1)
1003 debug_printf ("getpkt (\"%s\"); [sending ack] \n", buf
);
1007 if (write_prim ("+", 1) != 1)
1012 debug_printf ("[sent ack]\n");
1020 debug_printf ("getpkt (\"%s\"); [no ack sent] \n", buf
);
1025 /* The readchar above may have already read a '\003' out of the socket
1026 and moved it to the local buffer. For example, when GDB sends
1027 vCont;c immediately followed by interrupt (see
1028 gdb.base/interrupt-noterm.exp). As soon as we see the vCont;c, we'll
1029 resume the inferior and wait. Since we've already moved the '\003'
1030 to the local buffer, SIGIO won't help. In that case, if we don't
1031 check for interrupt after the vCont;c packet, the interrupt character
1032 would stay in the buffer unattended until after the next (unrelated)
1034 while (readchar_bufcnt
> 0 && *readchar_bufp
== '\003')
1036 /* Consume the interrupt character in the buffer. */
1038 the_target
->request_interrupt ();
1045 write_ok (char *buf
)
1053 write_enn (char *buf
)
1055 /* Some day, we should define the meanings of the error codes... */
1064 #ifndef IN_PROCESS_AGENT
1067 outreg (struct regcache
*regcache
, int regno
, char *buf
)
1069 if ((regno
>> 12) != 0)
1070 *buf
++ = tohex ((regno
>> 12) & 0xf);
1071 if ((regno
>> 8) != 0)
1072 *buf
++ = tohex ((regno
>> 8) & 0xf);
1073 *buf
++ = tohex ((regno
>> 4) & 0xf);
1074 *buf
++ = tohex (regno
& 0xf);
1076 collect_register_as_string (regcache
, regno
, buf
);
1077 buf
+= 2 * register_size (regcache
->tdesc
, regno
);
1084 prepare_resume_reply (char *buf
, ptid_t ptid
, const target_waitstatus
&status
)
1086 client_state
&cs
= get_client_state ();
1088 debug_printf ("Writing resume reply for %s:%d\n",
1089 target_pid_to_str (ptid
).c_str (), status
.kind ());
1091 switch (status
.kind ())
1093 case TARGET_WAITKIND_STOPPED
:
1094 case TARGET_WAITKIND_FORKED
:
1095 case TARGET_WAITKIND_VFORKED
:
1096 case TARGET_WAITKIND_VFORK_DONE
:
1097 case TARGET_WAITKIND_EXECD
:
1098 case TARGET_WAITKIND_THREAD_CREATED
:
1099 case TARGET_WAITKIND_SYSCALL_ENTRY
:
1100 case TARGET_WAITKIND_SYSCALL_RETURN
:
1102 struct thread_info
*saved_thread
;
1104 struct regcache
*regcache
;
1106 if ((status
.kind () == TARGET_WAITKIND_FORKED
&& cs
.report_fork_events
)
1107 || (status
.kind () == TARGET_WAITKIND_VFORKED
1108 && cs
.report_vfork_events
))
1110 enum gdb_signal signal
= GDB_SIGNAL_TRAP
;
1111 const char *event
= (status
.kind () == TARGET_WAITKIND_FORKED
1112 ? "fork" : "vfork");
1114 sprintf (buf
, "T%02x%s:", signal
, event
);
1115 buf
+= strlen (buf
);
1116 buf
= write_ptid (buf
, status
.child_ptid ());
1119 else if (status
.kind () == TARGET_WAITKIND_VFORK_DONE
1120 && cs
.report_vfork_events
)
1122 enum gdb_signal signal
= GDB_SIGNAL_TRAP
;
1124 sprintf (buf
, "T%02xvforkdone:;", signal
);
1126 else if (status
.kind () == TARGET_WAITKIND_EXECD
&& cs
.report_exec_events
)
1128 enum gdb_signal signal
= GDB_SIGNAL_TRAP
;
1129 const char *event
= "exec";
1130 char hexified_pathname
[PATH_MAX
* 2];
1132 sprintf (buf
, "T%02x%s:", signal
, event
);
1133 buf
+= strlen (buf
);
1135 /* Encode pathname to hexified format. */
1136 bin2hex ((const gdb_byte
*) status
.execd_pathname (),
1138 strlen (status
.execd_pathname ()));
1140 sprintf (buf
, "%s;", hexified_pathname
);
1141 buf
+= strlen (buf
);
1143 else if (status
.kind () == TARGET_WAITKIND_THREAD_CREATED
1144 && cs
.report_thread_events
)
1146 enum gdb_signal signal
= GDB_SIGNAL_TRAP
;
1148 sprintf (buf
, "T%02xcreate:;", signal
);
1150 else if (status
.kind () == TARGET_WAITKIND_SYSCALL_ENTRY
1151 || status
.kind () == TARGET_WAITKIND_SYSCALL_RETURN
)
1153 enum gdb_signal signal
= GDB_SIGNAL_TRAP
;
1154 const char *event
= (status
.kind () == TARGET_WAITKIND_SYSCALL_ENTRY
1155 ? "syscall_entry" : "syscall_return");
1157 sprintf (buf
, "T%02x%s:%x;", signal
, event
,
1158 status
.syscall_number ());
1161 sprintf (buf
, "T%02x", status
.sig ());
1163 if (disable_packet_T
)
1165 /* This is a bit (OK, a lot) of a kludge, however, this isn't
1166 really a user feature, but exists only so GDB can use the
1167 gdbserver to test handling of the 'S' stop reply packet, so
1168 we would rather this code be as simple as possible.
1170 By this point we've started to build the 'T' stop packet,
1171 and it should look like 'Txx....' where 'x' is a hex digit.
1172 An 'S' stop packet always looks like 'Sxx', so all we do
1173 here is convert the buffer from a T packet to an S packet
1174 and the avoid adding any extra content by breaking out. */
1175 gdb_assert (*buf
== 'T');
1176 gdb_assert (isxdigit (*(buf
+ 1)));
1177 gdb_assert (isxdigit (*(buf
+ 2)));
1183 buf
+= strlen (buf
);
1185 saved_thread
= current_thread
;
1187 switch_to_thread (the_target
, ptid
);
1189 regp
= current_target_desc ()->expedite_regs
;
1191 regcache
= get_thread_regcache (current_thread
, 1);
1193 if (the_target
->stopped_by_watchpoint ())
1198 memcpy (buf
, "watch:", 6);
1201 addr
= the_target
->stopped_data_address ();
1203 /* Convert each byte of the address into two hexadecimal
1204 chars. Note that we take sizeof (void *) instead of
1205 sizeof (addr); this is to avoid sending a 64-bit
1206 address to a 32-bit GDB. */
1207 for (i
= sizeof (void *) * 2; i
> 0; i
--)
1208 *buf
++ = tohex ((addr
>> (i
- 1) * 4) & 0xf);
1211 else if (cs
.swbreak_feature
&& target_stopped_by_sw_breakpoint ())
1213 sprintf (buf
, "swbreak:;");
1214 buf
+= strlen (buf
);
1216 else if (cs
.hwbreak_feature
&& target_stopped_by_hw_breakpoint ())
1218 sprintf (buf
, "hwbreak:;");
1219 buf
+= strlen (buf
);
1224 buf
= outreg (regcache
, find_regno (regcache
->tdesc
, *regp
), buf
);
1229 /* Formerly, if the debugger had not used any thread features
1230 we would not burden it with a thread status response. This
1231 was for the benefit of GDB 4.13 and older. However, in
1232 recent GDB versions the check (``if (cont_thread != 0)'')
1233 does not have the desired effect because of sillyness in
1234 the way that the remote protocol handles specifying a
1235 thread. Since thread support relies on qSymbol support
1236 anyway, assume GDB can handle threads. */
1238 if (using_threads
&& !disable_packet_Tthread
)
1240 /* This if (1) ought to be unnecessary. But remote_wait
1241 in GDB will claim this event belongs to inferior_ptid
1242 if we do not specify a thread, and there's no way for
1243 gdbserver to know what inferior_ptid is. */
1244 if (1 || cs
.general_thread
!= ptid
)
1247 /* In non-stop, don't change the general thread behind
1250 cs
.general_thread
= ptid
;
1251 sprintf (buf
, "thread:");
1252 buf
+= strlen (buf
);
1253 buf
= write_ptid (buf
, ptid
);
1255 buf
+= strlen (buf
);
1257 core
= target_core_of_thread (ptid
);
1261 sprintf (buf
, "core:");
1262 buf
+= strlen (buf
);
1263 sprintf (buf
, "%x", core
);
1265 buf
+= strlen (buf
);
1270 if (current_process ()->dlls_changed
)
1272 strcpy (buf
, "library:;");
1273 buf
+= strlen (buf
);
1274 current_process ()->dlls_changed
= false;
1277 current_thread
= saved_thread
;
1280 case TARGET_WAITKIND_EXITED
:
1281 if (cs
.multi_process
)
1282 sprintf (buf
, "W%x;process:%x",
1283 status
.exit_status (), ptid
.pid ());
1285 sprintf (buf
, "W%02x", status
.exit_status ());
1287 case TARGET_WAITKIND_SIGNALLED
:
1288 if (cs
.multi_process
)
1289 sprintf (buf
, "X%x;process:%x",
1290 status
.sig (), ptid
.pid ());
1292 sprintf (buf
, "X%02x", status
.sig ());
1294 case TARGET_WAITKIND_THREAD_EXITED
:
1295 sprintf (buf
, "w%x;", status
.exit_status ());
1296 buf
+= strlen (buf
);
1297 buf
= write_ptid (buf
, ptid
);
1299 case TARGET_WAITKIND_NO_RESUMED
:
1303 error ("unhandled waitkind");
1308 /* See remote-utils.h. */
1311 decode_m_packet_params (const char *from
, CORE_ADDR
*mem_addr_ptr
,
1312 unsigned int *len_ptr
, const char end_marker
)
1316 *mem_addr_ptr
= *len_ptr
= 0;
1318 while ((ch
= from
[i
++]) != ',')
1320 *mem_addr_ptr
= *mem_addr_ptr
<< 4;
1321 *mem_addr_ptr
|= fromhex (ch
) & 0x0f;
1324 while ((ch
= from
[i
++]) != end_marker
)
1326 *len_ptr
= *len_ptr
<< 4;
1327 *len_ptr
|= fromhex (ch
) & 0x0f;
1334 decode_m_packet (const char *from
, CORE_ADDR
*mem_addr_ptr
,
1335 unsigned int *len_ptr
)
1337 decode_m_packet_params (from
, mem_addr_ptr
, len_ptr
, '\0');
1341 decode_M_packet (const char *from
, CORE_ADDR
*mem_addr_ptr
,
1342 unsigned int *len_ptr
, unsigned char **to_p
)
1344 from
= decode_m_packet_params (from
, mem_addr_ptr
, len_ptr
, ':');
1347 *to_p
= (unsigned char *) xmalloc (*len_ptr
);
1349 hex2bin (from
, *to_p
, *len_ptr
);
1353 decode_X_packet (char *from
, int packet_len
, CORE_ADDR
*mem_addr_ptr
,
1354 unsigned int *len_ptr
, unsigned char **to_p
)
1358 *mem_addr_ptr
= *len_ptr
= 0;
1360 while ((ch
= from
[i
++]) != ',')
1362 *mem_addr_ptr
= *mem_addr_ptr
<< 4;
1363 *mem_addr_ptr
|= fromhex (ch
) & 0x0f;
1366 while ((ch
= from
[i
++]) != ':')
1368 *len_ptr
= *len_ptr
<< 4;
1369 *len_ptr
|= fromhex (ch
) & 0x0f;
1373 *to_p
= (unsigned char *) xmalloc (*len_ptr
);
1375 if (remote_unescape_input ((const gdb_byte
*) &from
[i
], packet_len
- i
,
1376 *to_p
, *len_ptr
) != *len_ptr
)
1382 /* Decode a qXfer write request. */
1385 decode_xfer_write (char *buf
, int packet_len
, CORE_ADDR
*offset
,
1386 unsigned int *len
, unsigned char *data
)
1391 /* Extract the offset. */
1393 while ((ch
= *buf
++) != ':')
1395 *offset
= *offset
<< 4;
1396 *offset
|= fromhex (ch
) & 0x0f;
1399 /* Get encoded data. */
1400 packet_len
-= buf
- b
;
1401 *len
= remote_unescape_input ((const gdb_byte
*) buf
, packet_len
,
1406 /* Decode the parameters of a qSearch:memory packet. */
1409 decode_search_memory_packet (const char *buf
, int packet_len
,
1410 CORE_ADDR
*start_addrp
,
1411 CORE_ADDR
*search_space_lenp
,
1412 gdb_byte
*pattern
, unsigned int *pattern_lenp
)
1414 const char *p
= buf
;
1416 p
= decode_address_to_semicolon (start_addrp
, p
);
1417 p
= decode_address_to_semicolon (search_space_lenp
, p
);
1418 packet_len
-= p
- buf
;
1419 *pattern_lenp
= remote_unescape_input ((const gdb_byte
*) p
, packet_len
,
1420 pattern
, packet_len
);
1425 free_sym_cache (struct sym_cache
*sym
)
1435 clear_symbol_cache (struct sym_cache
**symcache_p
)
1437 struct sym_cache
*sym
, *next
;
1439 /* Check the cache first. */
1440 for (sym
= *symcache_p
; sym
; sym
= next
)
1443 free_sym_cache (sym
);
1449 /* Get the address of NAME, and return it in ADDRP if found. if
1450 MAY_ASK_GDB is false, assume symbol cache misses are failures.
1451 Returns 1 if the symbol is found, 0 if it is not, -1 on error. */
1454 look_up_one_symbol (const char *name
, CORE_ADDR
*addrp
, int may_ask_gdb
)
1456 client_state
&cs
= get_client_state ();
1459 struct sym_cache
*sym
;
1460 struct process_info
*proc
;
1462 proc
= current_process ();
1464 /* Check the cache first. */
1465 for (sym
= proc
->symbol_cache
; sym
; sym
= sym
->next
)
1466 if (strcmp (name
, sym
->name
) == 0)
1472 /* It might not be an appropriate time to look up a symbol,
1473 e.g. while we're trying to fetch registers. */
1477 /* Send the request. */
1478 strcpy (cs
.own_buf
, "qSymbol:");
1479 bin2hex ((const gdb_byte
*) name
, cs
.own_buf
+ strlen ("qSymbol:"),
1481 if (putpkt (cs
.own_buf
) < 0)
1484 /* FIXME: Eventually add buffer overflow checking (to getpkt?) */
1485 len
= getpkt (cs
.own_buf
);
1489 /* We ought to handle pretty much any packet at this point while we
1490 wait for the qSymbol "response". That requires re-entering the
1491 main loop. For now, this is an adequate approximation; allow
1492 GDB to read from memory and handle 'v' packets (for vFile transfers)
1493 while it figures out the address of the symbol. */
1496 if (cs
.own_buf
[0] == 'm')
1499 unsigned char *mem_buf
;
1500 unsigned int mem_len
;
1502 decode_m_packet (&cs
.own_buf
[1], &mem_addr
, &mem_len
);
1503 mem_buf
= (unsigned char *) xmalloc (mem_len
);
1504 if (read_inferior_memory (mem_addr
, mem_buf
, mem_len
) == 0)
1505 bin2hex (mem_buf
, cs
.own_buf
, mem_len
);
1507 write_enn (cs
.own_buf
);
1509 if (putpkt (cs
.own_buf
) < 0)
1512 else if (cs
.own_buf
[0] == 'v')
1515 handle_v_requests (cs
.own_buf
, len
, &new_len
);
1517 putpkt_binary (cs
.own_buf
, new_len
);
1519 putpkt (cs
.own_buf
);
1523 len
= getpkt (cs
.own_buf
);
1528 if (!startswith (cs
.own_buf
, "qSymbol:"))
1530 warning ("Malformed response to qSymbol, ignoring: %s", cs
.own_buf
);
1534 p
= cs
.own_buf
+ strlen ("qSymbol:");
1536 while (*q
&& *q
!= ':')
1539 /* Make sure we found a value for the symbol. */
1540 if (p
== q
|| *q
== '\0')
1543 decode_address (addrp
, p
, q
- p
);
1545 /* Save the symbol in our cache. */
1546 sym
= XNEW (struct sym_cache
);
1547 sym
->name
= xstrdup (name
);
1549 sym
->next
= proc
->symbol_cache
;
1550 proc
->symbol_cache
= sym
;
1555 /* Relocate an instruction to execute at a different address. OLDLOC
1556 is the address in the inferior memory where the instruction to
1557 relocate is currently at. On input, TO points to the destination
1558 where we want the instruction to be copied (and possibly adjusted)
1559 to. On output, it points to one past the end of the resulting
1560 instruction(s). The effect of executing the instruction at TO
1561 shall be the same as if executing it at OLDLOC. For example, call
1562 instructions that implicitly push the return address on the stack
1563 should be adjusted to return to the instruction after OLDLOC;
1564 relative branches, and other PC-relative instructions need the
1565 offset adjusted; etc. Returns 0 on success, -1 on failure. */
1568 relocate_instruction (CORE_ADDR
*to
, CORE_ADDR oldloc
)
1570 client_state
&cs
= get_client_state ();
1572 ULONGEST written
= 0;
1574 /* Send the request. */
1575 sprintf (cs
.own_buf
, "qRelocInsn:%s;%s", paddress (oldloc
),
1577 if (putpkt (cs
.own_buf
) < 0)
1580 /* FIXME: Eventually add buffer overflow checking (to getpkt?) */
1581 len
= getpkt (cs
.own_buf
);
1585 /* We ought to handle pretty much any packet at this point while we
1586 wait for the qRelocInsn "response". That requires re-entering
1587 the main loop. For now, this is an adequate approximation; allow
1588 GDB to access memory. */
1589 while (cs
.own_buf
[0] == 'm' || cs
.own_buf
[0] == 'M' || cs
.own_buf
[0] == 'X')
1592 unsigned char *mem_buf
= NULL
;
1593 unsigned int mem_len
;
1595 if (cs
.own_buf
[0] == 'm')
1597 decode_m_packet (&cs
.own_buf
[1], &mem_addr
, &mem_len
);
1598 mem_buf
= (unsigned char *) xmalloc (mem_len
);
1599 if (read_inferior_memory (mem_addr
, mem_buf
, mem_len
) == 0)
1600 bin2hex (mem_buf
, cs
.own_buf
, mem_len
);
1602 write_enn (cs
.own_buf
);
1604 else if (cs
.own_buf
[0] == 'X')
1606 if (decode_X_packet (&cs
.own_buf
[1], len
- 1, &mem_addr
,
1607 &mem_len
, &mem_buf
) < 0
1608 || target_write_memory (mem_addr
, mem_buf
, mem_len
) != 0)
1609 write_enn (cs
.own_buf
);
1611 write_ok (cs
.own_buf
);
1615 decode_M_packet (&cs
.own_buf
[1], &mem_addr
, &mem_len
, &mem_buf
);
1616 if (target_write_memory (mem_addr
, mem_buf
, mem_len
) == 0)
1617 write_ok (cs
.own_buf
);
1619 write_enn (cs
.own_buf
);
1622 if (putpkt (cs
.own_buf
) < 0)
1624 len
= getpkt (cs
.own_buf
);
1629 if (cs
.own_buf
[0] == 'E')
1631 warning ("An error occurred while relocating an instruction: %s",
1636 if (!startswith (cs
.own_buf
, "qRelocInsn:"))
1638 warning ("Malformed response to qRelocInsn, ignoring: %s",
1643 unpack_varlen_hex (cs
.own_buf
+ strlen ("qRelocInsn:"), &written
);
1650 monitor_output (const char *msg
)
1652 int len
= strlen (msg
);
1653 char *buf
= (char *) xmalloc (len
* 2 + 2);
1656 bin2hex ((const gdb_byte
*) msg
, buf
+ 1, len
);