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
, 0);
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
, 0);
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
->value
.related_pid
);
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
->value
.execd_pathname
,
1139 strlen (status
->value
.execd_pathname
));
1141 sprintf (buf
, "%s;", hexified_pathname
);
1142 xfree (status
->value
.execd_pathname
);
1143 status
->value
.execd_pathname
= NULL
;
1144 buf
+= strlen (buf
);
1146 else if (status
->kind
== TARGET_WAITKIND_THREAD_CREATED
1147 && cs
.report_thread_events
)
1149 enum gdb_signal signal
= GDB_SIGNAL_TRAP
;
1151 sprintf (buf
, "T%02xcreate:;", signal
);
1153 else if (status
->kind
== TARGET_WAITKIND_SYSCALL_ENTRY
1154 || status
->kind
== TARGET_WAITKIND_SYSCALL_RETURN
)
1156 enum gdb_signal signal
= GDB_SIGNAL_TRAP
;
1157 const char *event
= (status
->kind
== TARGET_WAITKIND_SYSCALL_ENTRY
1158 ? "syscall_entry" : "syscall_return");
1160 sprintf (buf
, "T%02x%s:%x;", signal
, event
,
1161 status
->value
.syscall_number
);
1164 sprintf (buf
, "T%02x", status
->value
.sig
);
1166 if (disable_packet_T
)
1168 /* This is a bit (OK, a lot) of a kludge, however, this isn't
1169 really a user feature, but exists only so GDB can use the
1170 gdbserver to test handling of the 'S' stop reply packet, so
1171 we would rather this code be as simple as possible.
1173 By this point we've started to build the 'T' stop packet,
1174 and it should look like 'Txx....' where 'x' is a hex digit.
1175 An 'S' stop packet always looks like 'Sxx', so all we do
1176 here is convert the buffer from a T packet to an S packet
1177 and the avoid adding any extra content by breaking out. */
1178 gdb_assert (*buf
== 'T');
1179 gdb_assert (isxdigit (*(buf
+ 1)));
1180 gdb_assert (isxdigit (*(buf
+ 2)));
1186 buf
+= strlen (buf
);
1188 saved_thread
= current_thread
;
1190 switch_to_thread (the_target
, ptid
);
1192 regp
= current_target_desc ()->expedite_regs
;
1194 regcache
= get_thread_regcache (current_thread
, 1);
1196 if (the_target
->stopped_by_watchpoint ())
1201 memcpy (buf
, "watch:", 6);
1204 addr
= the_target
->stopped_data_address ();
1206 /* Convert each byte of the address into two hexadecimal
1207 chars. Note that we take sizeof (void *) instead of
1208 sizeof (addr); this is to avoid sending a 64-bit
1209 address to a 32-bit GDB. */
1210 for (i
= sizeof (void *) * 2; i
> 0; i
--)
1211 *buf
++ = tohex ((addr
>> (i
- 1) * 4) & 0xf);
1214 else if (cs
.swbreak_feature
&& target_stopped_by_sw_breakpoint ())
1216 sprintf (buf
, "swbreak:;");
1217 buf
+= strlen (buf
);
1219 else if (cs
.hwbreak_feature
&& target_stopped_by_hw_breakpoint ())
1221 sprintf (buf
, "hwbreak:;");
1222 buf
+= strlen (buf
);
1227 buf
= outreg (regcache
, find_regno (regcache
->tdesc
, *regp
), buf
);
1232 /* Formerly, if the debugger had not used any thread features
1233 we would not burden it with a thread status response. This
1234 was for the benefit of GDB 4.13 and older. However, in
1235 recent GDB versions the check (``if (cont_thread != 0)'')
1236 does not have the desired effect because of sillyness in
1237 the way that the remote protocol handles specifying a
1238 thread. Since thread support relies on qSymbol support
1239 anyway, assume GDB can handle threads. */
1241 if (using_threads
&& !disable_packet_Tthread
)
1243 /* This if (1) ought to be unnecessary. But remote_wait
1244 in GDB will claim this event belongs to inferior_ptid
1245 if we do not specify a thread, and there's no way for
1246 gdbserver to know what inferior_ptid is. */
1247 if (1 || cs
.general_thread
!= ptid
)
1250 /* In non-stop, don't change the general thread behind
1253 cs
.general_thread
= ptid
;
1254 sprintf (buf
, "thread:");
1255 buf
+= strlen (buf
);
1256 buf
= write_ptid (buf
, ptid
);
1258 buf
+= strlen (buf
);
1260 core
= target_core_of_thread (ptid
);
1264 sprintf (buf
, "core:");
1265 buf
+= strlen (buf
);
1266 sprintf (buf
, "%x", core
);
1268 buf
+= strlen (buf
);
1273 if (current_process ()->dlls_changed
)
1275 strcpy (buf
, "library:;");
1276 buf
+= strlen (buf
);
1277 current_process ()->dlls_changed
= false;
1280 current_thread
= saved_thread
;
1283 case TARGET_WAITKIND_EXITED
:
1284 if (cs
.multi_process
)
1285 sprintf (buf
, "W%x;process:%x",
1286 status
->value
.integer
, ptid
.pid ());
1288 sprintf (buf
, "W%02x", status
->value
.integer
);
1290 case TARGET_WAITKIND_SIGNALLED
:
1291 if (cs
.multi_process
)
1292 sprintf (buf
, "X%x;process:%x",
1293 status
->value
.sig
, ptid
.pid ());
1295 sprintf (buf
, "X%02x", status
->value
.sig
);
1297 case TARGET_WAITKIND_THREAD_EXITED
:
1298 sprintf (buf
, "w%x;", status
->value
.integer
);
1299 buf
+= strlen (buf
);
1300 buf
= write_ptid (buf
, ptid
);
1302 case TARGET_WAITKIND_NO_RESUMED
:
1306 error ("unhandled waitkind");
1312 decode_m_packet (char *from
, CORE_ADDR
*mem_addr_ptr
, unsigned int *len_ptr
)
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 for (j
= 0; j
< 4; j
++)
1326 if ((ch
= from
[i
++]) == 0)
1328 *len_ptr
= *len_ptr
<< 4;
1329 *len_ptr
|= fromhex (ch
) & 0x0f;
1334 decode_M_packet (char *from
, CORE_ADDR
*mem_addr_ptr
, unsigned int *len_ptr
,
1335 unsigned char **to_p
)
1339 *mem_addr_ptr
= *len_ptr
= 0;
1341 while ((ch
= from
[i
++]) != ',')
1343 *mem_addr_ptr
= *mem_addr_ptr
<< 4;
1344 *mem_addr_ptr
|= fromhex (ch
) & 0x0f;
1347 while ((ch
= from
[i
++]) != ':')
1349 *len_ptr
= *len_ptr
<< 4;
1350 *len_ptr
|= fromhex (ch
) & 0x0f;
1354 *to_p
= (unsigned char *) xmalloc (*len_ptr
);
1356 hex2bin (&from
[i
++], *to_p
, *len_ptr
);
1360 decode_X_packet (char *from
, int packet_len
, CORE_ADDR
*mem_addr_ptr
,
1361 unsigned int *len_ptr
, unsigned char **to_p
)
1365 *mem_addr_ptr
= *len_ptr
= 0;
1367 while ((ch
= from
[i
++]) != ',')
1369 *mem_addr_ptr
= *mem_addr_ptr
<< 4;
1370 *mem_addr_ptr
|= fromhex (ch
) & 0x0f;
1373 while ((ch
= from
[i
++]) != ':')
1375 *len_ptr
= *len_ptr
<< 4;
1376 *len_ptr
|= fromhex (ch
) & 0x0f;
1380 *to_p
= (unsigned char *) xmalloc (*len_ptr
);
1382 if (remote_unescape_input ((const gdb_byte
*) &from
[i
], packet_len
- i
,
1383 *to_p
, *len_ptr
) != *len_ptr
)
1389 /* Decode a qXfer write request. */
1392 decode_xfer_write (char *buf
, int packet_len
, CORE_ADDR
*offset
,
1393 unsigned int *len
, unsigned char *data
)
1398 /* Extract the offset. */
1400 while ((ch
= *buf
++) != ':')
1402 *offset
= *offset
<< 4;
1403 *offset
|= fromhex (ch
) & 0x0f;
1406 /* Get encoded data. */
1407 packet_len
-= buf
- b
;
1408 *len
= remote_unescape_input ((const gdb_byte
*) buf
, packet_len
,
1413 /* Decode the parameters of a qSearch:memory packet. */
1416 decode_search_memory_packet (const char *buf
, int packet_len
,
1417 CORE_ADDR
*start_addrp
,
1418 CORE_ADDR
*search_space_lenp
,
1419 gdb_byte
*pattern
, unsigned int *pattern_lenp
)
1421 const char *p
= buf
;
1423 p
= decode_address_to_semicolon (start_addrp
, p
);
1424 p
= decode_address_to_semicolon (search_space_lenp
, p
);
1425 packet_len
-= p
- buf
;
1426 *pattern_lenp
= remote_unescape_input ((const gdb_byte
*) p
, packet_len
,
1427 pattern
, packet_len
);
1432 free_sym_cache (struct sym_cache
*sym
)
1442 clear_symbol_cache (struct sym_cache
**symcache_p
)
1444 struct sym_cache
*sym
, *next
;
1446 /* Check the cache first. */
1447 for (sym
= *symcache_p
; sym
; sym
= next
)
1450 free_sym_cache (sym
);
1456 /* Get the address of NAME, and return it in ADDRP if found. if
1457 MAY_ASK_GDB is false, assume symbol cache misses are failures.
1458 Returns 1 if the symbol is found, 0 if it is not, -1 on error. */
1461 look_up_one_symbol (const char *name
, CORE_ADDR
*addrp
, int may_ask_gdb
)
1463 client_state
&cs
= get_client_state ();
1466 struct sym_cache
*sym
;
1467 struct process_info
*proc
;
1469 proc
= current_process ();
1471 /* Check the cache first. */
1472 for (sym
= proc
->symbol_cache
; sym
; sym
= sym
->next
)
1473 if (strcmp (name
, sym
->name
) == 0)
1479 /* It might not be an appropriate time to look up a symbol,
1480 e.g. while we're trying to fetch registers. */
1484 /* Send the request. */
1485 strcpy (cs
.own_buf
, "qSymbol:");
1486 bin2hex ((const gdb_byte
*) name
, cs
.own_buf
+ strlen ("qSymbol:"),
1488 if (putpkt (cs
.own_buf
) < 0)
1491 /* FIXME: Eventually add buffer overflow checking (to getpkt?) */
1492 len
= getpkt (cs
.own_buf
);
1496 /* We ought to handle pretty much any packet at this point while we
1497 wait for the qSymbol "response". That requires re-entering the
1498 main loop. For now, this is an adequate approximation; allow
1499 GDB to read from memory and handle 'v' packets (for vFile transfers)
1500 while it figures out the address of the symbol. */
1503 if (cs
.own_buf
[0] == 'm')
1506 unsigned char *mem_buf
;
1507 unsigned int mem_len
;
1509 decode_m_packet (&cs
.own_buf
[1], &mem_addr
, &mem_len
);
1510 mem_buf
= (unsigned char *) xmalloc (mem_len
);
1511 if (read_inferior_memory (mem_addr
, mem_buf
, mem_len
) == 0)
1512 bin2hex (mem_buf
, cs
.own_buf
, mem_len
);
1514 write_enn (cs
.own_buf
);
1516 if (putpkt (cs
.own_buf
) < 0)
1519 else if (cs
.own_buf
[0] == 'v')
1522 handle_v_requests (cs
.own_buf
, len
, &new_len
);
1524 putpkt_binary (cs
.own_buf
, new_len
);
1526 putpkt (cs
.own_buf
);
1530 len
= getpkt (cs
.own_buf
);
1535 if (!startswith (cs
.own_buf
, "qSymbol:"))
1537 warning ("Malformed response to qSymbol, ignoring: %s", cs
.own_buf
);
1541 p
= cs
.own_buf
+ strlen ("qSymbol:");
1543 while (*q
&& *q
!= ':')
1546 /* Make sure we found a value for the symbol. */
1547 if (p
== q
|| *q
== '\0')
1550 decode_address (addrp
, p
, q
- p
);
1552 /* Save the symbol in our cache. */
1553 sym
= XNEW (struct sym_cache
);
1554 sym
->name
= xstrdup (name
);
1556 sym
->next
= proc
->symbol_cache
;
1557 proc
->symbol_cache
= sym
;
1562 /* Relocate an instruction to execute at a different address. OLDLOC
1563 is the address in the inferior memory where the instruction to
1564 relocate is currently at. On input, TO points to the destination
1565 where we want the instruction to be copied (and possibly adjusted)
1566 to. On output, it points to one past the end of the resulting
1567 instruction(s). The effect of executing the instruction at TO
1568 shall be the same as if executing it at OLDLOC. For example, call
1569 instructions that implicitly push the return address on the stack
1570 should be adjusted to return to the instruction after OLDLOC;
1571 relative branches, and other PC-relative instructions need the
1572 offset adjusted; etc. Returns 0 on success, -1 on failure. */
1575 relocate_instruction (CORE_ADDR
*to
, CORE_ADDR oldloc
)
1577 client_state
&cs
= get_client_state ();
1579 ULONGEST written
= 0;
1581 /* Send the request. */
1582 sprintf (cs
.own_buf
, "qRelocInsn:%s;%s", paddress (oldloc
),
1584 if (putpkt (cs
.own_buf
) < 0)
1587 /* FIXME: Eventually add buffer overflow checking (to getpkt?) */
1588 len
= getpkt (cs
.own_buf
);
1592 /* We ought to handle pretty much any packet at this point while we
1593 wait for the qRelocInsn "response". That requires re-entering
1594 the main loop. For now, this is an adequate approximation; allow
1595 GDB to access memory. */
1596 while (cs
.own_buf
[0] == 'm' || cs
.own_buf
[0] == 'M' || cs
.own_buf
[0] == 'X')
1599 unsigned char *mem_buf
= NULL
;
1600 unsigned int mem_len
;
1602 if (cs
.own_buf
[0] == 'm')
1604 decode_m_packet (&cs
.own_buf
[1], &mem_addr
, &mem_len
);
1605 mem_buf
= (unsigned char *) xmalloc (mem_len
);
1606 if (read_inferior_memory (mem_addr
, mem_buf
, mem_len
) == 0)
1607 bin2hex (mem_buf
, cs
.own_buf
, mem_len
);
1609 write_enn (cs
.own_buf
);
1611 else if (cs
.own_buf
[0] == 'X')
1613 if (decode_X_packet (&cs
.own_buf
[1], len
- 1, &mem_addr
,
1614 &mem_len
, &mem_buf
) < 0
1615 || target_write_memory (mem_addr
, mem_buf
, mem_len
) != 0)
1616 write_enn (cs
.own_buf
);
1618 write_ok (cs
.own_buf
);
1622 decode_M_packet (&cs
.own_buf
[1], &mem_addr
, &mem_len
, &mem_buf
);
1623 if (target_write_memory (mem_addr
, mem_buf
, mem_len
) == 0)
1624 write_ok (cs
.own_buf
);
1626 write_enn (cs
.own_buf
);
1629 if (putpkt (cs
.own_buf
) < 0)
1631 len
= getpkt (cs
.own_buf
);
1636 if (cs
.own_buf
[0] == 'E')
1638 warning ("An error occurred while relocating an instruction: %s",
1643 if (!startswith (cs
.own_buf
, "qRelocInsn:"))
1645 warning ("Malformed response to qRelocInsn, ignoring: %s",
1650 unpack_varlen_hex (cs
.own_buf
+ strlen ("qRelocInsn:"), &written
);
1657 monitor_output (const char *msg
)
1659 int len
= strlen (msg
);
1660 char *buf
= (char *) xmalloc (len
* 2 + 2);
1663 bin2hex ((const gdb_byte
*) msg
, buf
+ 1, len
);