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
,
1085 struct target_waitstatus
*status
)
1087 client_state
&cs
= get_client_state ();
1089 debug_printf ("Writing resume reply for %s:%d\n",
1090 target_pid_to_str (ptid
), status
->kind ());
1092 switch (status
->kind ())
1094 case TARGET_WAITKIND_STOPPED
:
1095 case TARGET_WAITKIND_FORKED
:
1096 case TARGET_WAITKIND_VFORKED
:
1097 case TARGET_WAITKIND_VFORK_DONE
:
1098 case TARGET_WAITKIND_EXECD
:
1099 case TARGET_WAITKIND_THREAD_CREATED
:
1100 case TARGET_WAITKIND_SYSCALL_ENTRY
:
1101 case TARGET_WAITKIND_SYSCALL_RETURN
:
1103 struct thread_info
*saved_thread
;
1105 struct regcache
*regcache
;
1107 if ((status
->kind () == TARGET_WAITKIND_FORKED
&& cs
.report_fork_events
)
1108 || (status
->kind () == TARGET_WAITKIND_VFORKED
1109 && cs
.report_vfork_events
))
1111 enum gdb_signal signal
= GDB_SIGNAL_TRAP
;
1112 const char *event
= (status
->kind () == TARGET_WAITKIND_FORKED
1113 ? "fork" : "vfork");
1115 sprintf (buf
, "T%02x%s:", signal
, event
);
1116 buf
+= strlen (buf
);
1117 buf
= write_ptid (buf
, status
->child_ptid ());
1120 else if (status
->kind () == TARGET_WAITKIND_VFORK_DONE
1121 && cs
.report_vfork_events
)
1123 enum gdb_signal signal
= GDB_SIGNAL_TRAP
;
1125 sprintf (buf
, "T%02xvforkdone:;", signal
);
1127 else if (status
->kind () == TARGET_WAITKIND_EXECD
&& cs
.report_exec_events
)
1129 enum gdb_signal signal
= GDB_SIGNAL_TRAP
;
1130 const char *event
= "exec";
1131 char hexified_pathname
[PATH_MAX
* 2];
1133 sprintf (buf
, "T%02x%s:", signal
, event
);
1134 buf
+= strlen (buf
);
1136 /* Encode pathname to hexified format. */
1137 bin2hex ((const gdb_byte
*) status
->execd_pathname (),
1139 strlen (status
->execd_pathname ()));
1141 sprintf (buf
, "%s;", hexified_pathname
);
1142 buf
+= strlen (buf
);
1144 else if (status
->kind () == TARGET_WAITKIND_THREAD_CREATED
1145 && cs
.report_thread_events
)
1147 enum gdb_signal signal
= GDB_SIGNAL_TRAP
;
1149 sprintf (buf
, "T%02xcreate:;", signal
);
1151 else if (status
->kind () == TARGET_WAITKIND_SYSCALL_ENTRY
1152 || status
->kind () == TARGET_WAITKIND_SYSCALL_RETURN
)
1154 enum gdb_signal signal
= GDB_SIGNAL_TRAP
;
1155 const char *event
= (status
->kind () == TARGET_WAITKIND_SYSCALL_ENTRY
1156 ? "syscall_entry" : "syscall_return");
1158 sprintf (buf
, "T%02x%s:%x;", signal
, event
,
1159 status
->syscall_number ());
1162 sprintf (buf
, "T%02x", status
->sig ());
1164 if (disable_packet_T
)
1166 /* This is a bit (OK, a lot) of a kludge, however, this isn't
1167 really a user feature, but exists only so GDB can use the
1168 gdbserver to test handling of the 'S' stop reply packet, so
1169 we would rather this code be as simple as possible.
1171 By this point we've started to build the 'T' stop packet,
1172 and it should look like 'Txx....' where 'x' is a hex digit.
1173 An 'S' stop packet always looks like 'Sxx', so all we do
1174 here is convert the buffer from a T packet to an S packet
1175 and the avoid adding any extra content by breaking out. */
1176 gdb_assert (*buf
== 'T');
1177 gdb_assert (isxdigit (*(buf
+ 1)));
1178 gdb_assert (isxdigit (*(buf
+ 2)));
1184 buf
+= strlen (buf
);
1186 saved_thread
= current_thread
;
1188 switch_to_thread (the_target
, ptid
);
1190 regp
= current_target_desc ()->expedite_regs
;
1192 regcache
= get_thread_regcache (current_thread
, 1);
1194 if (the_target
->stopped_by_watchpoint ())
1199 memcpy (buf
, "watch:", 6);
1202 addr
= the_target
->stopped_data_address ();
1204 /* Convert each byte of the address into two hexadecimal
1205 chars. Note that we take sizeof (void *) instead of
1206 sizeof (addr); this is to avoid sending a 64-bit
1207 address to a 32-bit GDB. */
1208 for (i
= sizeof (void *) * 2; i
> 0; i
--)
1209 *buf
++ = tohex ((addr
>> (i
- 1) * 4) & 0xf);
1212 else if (cs
.swbreak_feature
&& target_stopped_by_sw_breakpoint ())
1214 sprintf (buf
, "swbreak:;");
1215 buf
+= strlen (buf
);
1217 else if (cs
.hwbreak_feature
&& target_stopped_by_hw_breakpoint ())
1219 sprintf (buf
, "hwbreak:;");
1220 buf
+= strlen (buf
);
1225 buf
= outreg (regcache
, find_regno (regcache
->tdesc
, *regp
), buf
);
1230 /* Formerly, if the debugger had not used any thread features
1231 we would not burden it with a thread status response. This
1232 was for the benefit of GDB 4.13 and older. However, in
1233 recent GDB versions the check (``if (cont_thread != 0)'')
1234 does not have the desired effect because of sillyness in
1235 the way that the remote protocol handles specifying a
1236 thread. Since thread support relies on qSymbol support
1237 anyway, assume GDB can handle threads. */
1239 if (using_threads
&& !disable_packet_Tthread
)
1241 /* This if (1) ought to be unnecessary. But remote_wait
1242 in GDB will claim this event belongs to inferior_ptid
1243 if we do not specify a thread, and there's no way for
1244 gdbserver to know what inferior_ptid is. */
1245 if (1 || cs
.general_thread
!= ptid
)
1248 /* In non-stop, don't change the general thread behind
1251 cs
.general_thread
= ptid
;
1252 sprintf (buf
, "thread:");
1253 buf
+= strlen (buf
);
1254 buf
= write_ptid (buf
, ptid
);
1256 buf
+= strlen (buf
);
1258 core
= target_core_of_thread (ptid
);
1262 sprintf (buf
, "core:");
1263 buf
+= strlen (buf
);
1264 sprintf (buf
, "%x", core
);
1266 buf
+= strlen (buf
);
1271 if (current_process ()->dlls_changed
)
1273 strcpy (buf
, "library:;");
1274 buf
+= strlen (buf
);
1275 current_process ()->dlls_changed
= false;
1278 current_thread
= saved_thread
;
1281 case TARGET_WAITKIND_EXITED
:
1282 if (cs
.multi_process
)
1283 sprintf (buf
, "W%x;process:%x",
1284 status
->exit_status (), ptid
.pid ());
1286 sprintf (buf
, "W%02x", status
->exit_status ());
1288 case TARGET_WAITKIND_SIGNALLED
:
1289 if (cs
.multi_process
)
1290 sprintf (buf
, "X%x;process:%x",
1291 status
->sig (), ptid
.pid ());
1293 sprintf (buf
, "X%02x", status
->sig ());
1295 case TARGET_WAITKIND_THREAD_EXITED
:
1296 sprintf (buf
, "w%x;", status
->exit_status ());
1297 buf
+= strlen (buf
);
1298 buf
= write_ptid (buf
, ptid
);
1300 case TARGET_WAITKIND_NO_RESUMED
:
1304 error ("unhandled waitkind");
1309 /* See remote-utils.h. */
1312 decode_m_packet_params (const char *from
, CORE_ADDR
*mem_addr_ptr
,
1313 unsigned int *len_ptr
, const char end_marker
)
1317 *mem_addr_ptr
= *len_ptr
= 0;
1319 while ((ch
= from
[i
++]) != ',')
1321 *mem_addr_ptr
= *mem_addr_ptr
<< 4;
1322 *mem_addr_ptr
|= fromhex (ch
) & 0x0f;
1325 while ((ch
= from
[i
++]) != end_marker
)
1327 *len_ptr
= *len_ptr
<< 4;
1328 *len_ptr
|= fromhex (ch
) & 0x0f;
1335 decode_m_packet (const char *from
, CORE_ADDR
*mem_addr_ptr
,
1336 unsigned int *len_ptr
)
1338 decode_m_packet_params (from
, mem_addr_ptr
, len_ptr
, '\0');
1342 decode_M_packet (const char *from
, CORE_ADDR
*mem_addr_ptr
,
1343 unsigned int *len_ptr
, unsigned char **to_p
)
1345 from
= decode_m_packet_params (from
, mem_addr_ptr
, len_ptr
, ':');
1348 *to_p
= (unsigned char *) xmalloc (*len_ptr
);
1350 hex2bin (from
, *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
);