1 /* Remote utility routines for the remote server for GDB.
2 Copyright (C) 1986-2020 Free Software Foundation, Inc.
4 This file is part of GDB.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program. If not, see <http://www.gnu.org/licenses/>. */
24 #include "gdbthread.h"
28 #include "gdbsupport/rsp-low.h"
29 #include "gdbsupport/netstuff.h"
30 #include "gdbsupport/filestuff.h"
31 #include "gdbsupport/gdb-sigmask.h"
34 #include <sys/ioctl.h>
40 #include <netinet/in.h>
43 #include <sys/socket.h>
48 #if HAVE_NETINET_TCP_H
49 #include <netinet/tcp.h>
52 #include <sys/ioctl.h>
60 #include "gdbsupport/gdb_sys_time.h"
63 #include <arpa/inet.h>
72 #include <sys/iomgr.h>
75 #ifndef HAVE_SOCKLEN_T
76 typedef int socklen_t
;
79 #ifndef IN_PROCESS_AGENT
82 # define INVALID_DESCRIPTOR INVALID_SOCKET
84 # define INVALID_DESCRIPTOR -1
87 /* Extra value for readchar_callback. */
89 /* The callback is currently not scheduled. */
93 /* Status of the readchar callback.
94 Either NOT_SCHEDULED or the callback id. */
95 static int readchar_callback
= NOT_SCHEDULED
;
97 static int readchar (void);
98 static void reset_readchar (void);
99 static void reschedule (void);
101 /* A cache entry for a successfully looked-up symbol. */
106 struct sym_cache
*next
;
109 static int remote_is_stdio
= 0;
111 static gdb_fildes_t remote_desc
= INVALID_DESCRIPTOR
;
112 static gdb_fildes_t listen_desc
= INVALID_DESCRIPTOR
;
115 # define read(fd, buf, len) recv (fd, (char *) buf, len, 0)
116 # define write(fd, buf, len) send (fd, (char *) buf, len, 0)
122 return remote_desc
!= INVALID_DESCRIPTOR
;
125 /* Return true if the remote connection is over stdio. */
128 remote_connection_is_stdio (void)
130 return remote_is_stdio
;
134 enable_async_notification (int fd
)
136 #if defined(F_SETFL) && defined (FASYNC)
137 int save_fcntl_flags
;
139 save_fcntl_flags
= fcntl (fd
, F_GETFL
, 0);
140 fcntl (fd
, F_SETFL
, save_fcntl_flags
| FASYNC
);
141 #if defined (F_SETOWN)
142 fcntl (fd
, F_SETOWN
, getpid ());
148 handle_accept_event (int err
, gdb_client_data client_data
)
150 struct sockaddr_storage sockaddr
;
151 socklen_t len
= sizeof (sockaddr
);
154 debug_printf ("handling possible accept event\n");
156 remote_desc
= accept (listen_desc
, (struct sockaddr
*) &sockaddr
, &len
);
157 if (remote_desc
== -1)
158 perror_with_name ("Accept failed");
160 /* Enable TCP keep alive process. */
162 setsockopt (remote_desc
, SOL_SOCKET
, SO_KEEPALIVE
,
163 (char *) &tmp
, sizeof (tmp
));
165 /* Tell TCP not to delay small packets. This greatly speeds up
166 interactive response. */
168 setsockopt (remote_desc
, IPPROTO_TCP
, TCP_NODELAY
,
169 (char *) &tmp
, sizeof (tmp
));
172 signal (SIGPIPE
, SIG_IGN
); /* If we don't do this, then gdbserver simply
173 exits when the remote side dies. */
179 close (listen_desc
); /* No longer need this */
181 closesocket (listen_desc
); /* No longer need this */
185 /* Even if !RUN_ONCE no longer notice new connections. Still keep the
186 descriptor open for add_file_handler to wait for a new connection. */
187 delete_file_handler (listen_desc
);
189 /* Convert IP address to string. */
190 char orig_host
[GDB_NI_MAX_ADDR
], orig_port
[GDB_NI_MAX_PORT
];
192 int r
= getnameinfo ((struct sockaddr
*) &sockaddr
, len
,
193 orig_host
, sizeof (orig_host
),
194 orig_port
, sizeof (orig_port
),
195 NI_NUMERICHOST
| NI_NUMERICSERV
);
198 fprintf (stderr
, _("Could not obtain remote address: %s\n"),
201 fprintf (stderr
, _("Remote debugging from host %s, port %s\n"),
202 orig_host
, orig_port
);
204 enable_async_notification (remote_desc
);
206 /* Register the event loop handler. */
207 add_file_handler (remote_desc
, handle_serial_event
, NULL
);
209 /* We have a new GDB connection now. If we were disconnected
210 tracing, there's a window where the target could report a stop
211 event to the event loop, and since we have a connection now, we'd
212 try to send vStopped notifications to GDB. But, don't do that
213 until GDB as selected all-stop/non-stop, and has queried the
214 threads' status ('?'). */
218 /* Prepare for a later connection to a remote debugger.
219 NAME is the filename used for communication. */
222 remote_prepare (const char *name
)
224 client_state
&cs
= get_client_state ();
226 static int winsock_initialized
;
231 if (strcmp (name
, STDIO_CONNECTION_NAME
) == 0)
233 /* We need to record fact that we're using stdio sooner than the
234 call to remote_open so start_inferior knows the connection is
237 cs
.transport_is_reliable
= 1;
241 struct addrinfo hint
;
242 struct addrinfo
*ainfo
;
244 memset (&hint
, 0, sizeof (hint
));
245 /* Assume no prefix will be passed, therefore we should use
247 hint
.ai_family
= AF_UNSPEC
;
248 hint
.ai_socktype
= SOCK_STREAM
;
249 hint
.ai_protocol
= IPPROTO_TCP
;
251 parsed_connection_spec parsed
252 = parse_connection_spec_without_prefix (name
, &hint
);
254 if (parsed
.port_str
.empty ())
256 cs
.transport_is_reliable
= 0;
261 if (!winsock_initialized
)
265 WSAStartup (MAKEWORD (1, 0), &wsad
);
266 winsock_initialized
= 1;
270 int r
= getaddrinfo (parsed
.host_str
.c_str (), parsed
.port_str
.c_str (),
274 error (_("%s: cannot resolve name: %s"), name
, gai_strerror (r
));
276 scoped_free_addrinfo
freeaddrinfo (ainfo
);
278 struct addrinfo
*iter
;
280 for (iter
= ainfo
; iter
!= NULL
; iter
= iter
->ai_next
)
282 listen_desc
= gdb_socket_cloexec (iter
->ai_family
, iter
->ai_socktype
,
285 if (listen_desc
>= 0)
290 perror_with_name ("Can't open socket");
292 /* Allow rapid reuse of this port. */
294 setsockopt (listen_desc
, SOL_SOCKET
, SO_REUSEADDR
, (char *) &tmp
,
297 switch (iter
->ai_family
)
300 ((struct sockaddr_in
*) iter
->ai_addr
)->sin_addr
.s_addr
= INADDR_ANY
;
303 ((struct sockaddr_in6
*) iter
->ai_addr
)->sin6_addr
= in6addr_any
;
306 internal_error (__FILE__
, __LINE__
,
307 _("Invalid 'ai_family' %d\n"), iter
->ai_family
);
310 if (bind (listen_desc
, iter
->ai_addr
, iter
->ai_addrlen
) != 0)
311 perror_with_name ("Can't bind address");
313 if (listen (listen_desc
, 1) != 0)
314 perror_with_name ("Can't listen on socket");
316 cs
.transport_is_reliable
= 1;
319 /* Open a connection to a remote debugger.
320 NAME is the filename used for communication. */
323 remote_open (const char *name
)
325 const char *port_str
;
327 port_str
= strchr (name
, ':');
329 if (port_str
== NULL
)
330 error ("Only HOST:PORT is supported on this platform.");
333 if (strcmp (name
, STDIO_CONNECTION_NAME
) == 0)
335 fprintf (stderr
, "Remote debugging using stdio\n");
337 /* Use stdin as the handle of the connection.
338 We only select on reads, for example. */
339 remote_desc
= fileno (stdin
);
341 enable_async_notification (remote_desc
);
343 /* Register the event loop handler. */
344 add_file_handler (remote_desc
, handle_serial_event
, NULL
);
347 else if (port_str
== NULL
)
351 if (stat (name
, &statbuf
) == 0
352 && (S_ISCHR (statbuf
.st_mode
) || S_ISFIFO (statbuf
.st_mode
)))
353 remote_desc
= open (name
, O_RDWR
);
361 perror_with_name ("Could not open remote device");
365 struct termios termios
;
366 tcgetattr (remote_desc
, &termios
);
371 termios
.c_cflag
&= ~(CSIZE
| PARENB
);
372 termios
.c_cflag
|= CLOCAL
| CS8
;
373 termios
.c_cc
[VMIN
] = 1;
374 termios
.c_cc
[VTIME
] = 0;
376 tcsetattr (remote_desc
, TCSANOW
, &termios
);
380 fprintf (stderr
, "Remote debugging using %s\n", name
);
382 enable_async_notification (remote_desc
);
384 /* Register the event loop handler. */
385 add_file_handler (remote_desc
, handle_serial_event
, NULL
);
387 #endif /* USE_WIN32API */
390 char listen_port
[GDB_NI_MAX_PORT
];
391 struct sockaddr_storage sockaddr
;
392 socklen_t len
= sizeof (sockaddr
);
394 if (getsockname (listen_desc
, (struct sockaddr
*) &sockaddr
, &len
) < 0)
395 perror_with_name ("Can't determine port");
397 int r
= getnameinfo ((struct sockaddr
*) &sockaddr
, len
,
399 listen_port
, sizeof (listen_port
),
403 fprintf (stderr
, _("Can't obtain port where we are listening: %s"),
406 fprintf (stderr
, _("Listening on port %s\n"), listen_port
);
410 /* Register the event loop handler. */
411 add_file_handler (listen_desc
, handle_accept_event
, NULL
);
418 delete_file_handler (remote_desc
);
423 closesocket (remote_desc
);
425 if (! remote_connection_is_stdio ())
428 remote_desc
= INVALID_DESCRIPTOR
;
435 #ifndef IN_PROCESS_AGENT
438 decode_address (CORE_ADDR
*addrp
, const char *start
, int len
)
445 for (i
= 0; i
< len
; i
++)
449 addr
= addr
| (fromhex (ch
) & 0x0f);
455 decode_address_to_semicolon (CORE_ADDR
*addrp
, const char *start
)
460 while (*end
!= '\0' && *end
!= ';')
463 decode_address (addrp
, start
, end
- start
);
472 #ifndef IN_PROCESS_AGENT
474 /* Look for a sequence of characters which can be run-length encoded.
475 If there are any, update *CSUM and *P. Otherwise, output the
476 single character. Return the number of characters consumed. */
479 try_rle (char *buf
, int remaining
, unsigned char *csum
, char **p
)
483 /* Always output the character. */
487 /* Don't go past '~'. */
491 for (n
= 1; n
< remaining
; n
++)
492 if (buf
[n
] != buf
[0])
495 /* N is the index of the first character not the same as buf[0].
496 buf[0] is counted twice, so by decrementing N, we get the number
497 of characters the RLE sequence will replace. */
503 /* Skip the frame characters. The manual says to skip '+' and '-'
504 also, but there's no reason to. Unfortunately these two unusable
505 characters double the encoded length of a four byte zero
507 while (n
+ 29 == '$' || n
+ 29 == '#')
520 #ifndef IN_PROCESS_AGENT
522 /* Write a PTID to BUF. Returns BUF+CHARACTERS_WRITTEN. */
525 write_ptid (char *buf
, ptid_t ptid
)
527 client_state
&cs
= get_client_state ();
530 if (cs
.multi_process
)
534 buf
+= sprintf (buf
, "p-%x.", -pid
);
536 buf
+= sprintf (buf
, "p%x.", pid
);
540 buf
+= sprintf (buf
, "-%x", -tid
);
542 buf
+= sprintf (buf
, "%x", tid
);
548 hex_or_minus_one (const char *buf
, const char **obuf
)
552 if (startswith (buf
, "-1"))
558 buf
= unpack_varlen_hex (buf
, &ret
);
566 /* Extract a PTID from BUF. If non-null, OBUF is set to the to one
567 passed the last parsed char. Returns null_ptid on error. */
569 read_ptid (const char *buf
, const char **obuf
)
573 ULONGEST pid
= 0, tid
= 0;
577 /* Multi-process ptid. */
578 pp
= unpack_varlen_hex (p
+ 1, &pid
);
580 error ("invalid remote ptid: %s\n", p
);
584 tid
= hex_or_minus_one (p
, &pp
);
588 return ptid_t (pid
, tid
, 0);
591 /* No multi-process. Just a tid. */
592 tid
= hex_or_minus_one (p
, &pp
);
594 /* Since GDB is not sending a process id (multi-process extensions
595 are off), then there's only one process. Default to the first in
597 pid
= pid_of (get_first_process ());
601 return ptid_t (pid
, tid
, 0);
604 /* Write COUNT bytes in BUF to the client.
605 The result is the number of bytes written or -1 if error.
606 This may return less than COUNT. */
609 write_prim (const void *buf
, int count
)
611 if (remote_connection_is_stdio ())
612 return write (fileno (stdout
), buf
, count
);
614 return write (remote_desc
, buf
, count
);
617 /* Read COUNT bytes from the client and store in BUF.
618 The result is the number of bytes read or -1 if error.
619 This may return less than COUNT. */
622 read_prim (void *buf
, int count
)
624 if (remote_connection_is_stdio ())
625 return read (fileno (stdin
), buf
, count
);
627 return read (remote_desc
, buf
, count
);
630 /* Send a packet to the remote machine, with error checking.
631 The data of the packet is in BUF, and the length of the
632 packet is in CNT. Returns >= 0 on success, -1 otherwise. */
635 putpkt_binary_1 (char *buf
, int cnt
, int is_notif
)
637 client_state
&cs
= get_client_state ();
639 unsigned char csum
= 0;
644 buf2
= (char *) xmalloc (strlen ("$") + cnt
+ strlen ("#nn") + 1);
646 /* Copy the packet into buffer BUF2, encapsulating it
647 and giving it a checksum. */
655 for (i
= 0; i
< cnt
;)
656 i
+= try_rle (buf
+ i
, cnt
- i
, &csum
, &p
);
659 *p
++ = tohex ((csum
>> 4) & 0xf);
660 *p
++ = tohex (csum
& 0xf);
664 /* Send it over and over until we get a positive ack. */
668 if (write_prim (buf2
, p
- buf2
) != p
- buf2
)
670 perror ("putpkt(write)");
675 if (cs
.noack_mode
|| is_notif
)
677 /* Don't expect an ack then. */
681 debug_printf ("putpkt (\"%s\"); [notif]\n", buf2
);
683 debug_printf ("putpkt (\"%s\"); [noack mode]\n", buf2
);
691 debug_printf ("putpkt (\"%s\"); [looking for ack]\n", buf2
);
705 debug_printf ("[received '%c' (0x%x)]\n", cc
, cc
);
709 /* Check for an input interrupt while we're here. */
710 if (cc
== '\003' && current_thread
!= NULL
)
711 the_target
->request_interrupt ();
716 return 1; /* Success! */
720 putpkt_binary (char *buf
, int cnt
)
722 return putpkt_binary_1 (buf
, cnt
, 0);
725 /* Send a packet to the remote machine, with error checking. The data
726 of the packet is in BUF, and the packet should be a NUL-terminated
727 string. Returns >= 0 on success, -1 otherwise. */
732 return putpkt_binary (buf
, strlen (buf
));
736 putpkt_notif (char *buf
)
738 return putpkt_binary_1 (buf
, strlen (buf
), 1);
741 /* Come here when we get an input interrupt from the remote side. This
742 interrupt should only be active while we are waiting for the child to do
743 something. Thus this assumes readchar:bufcnt is 0.
744 About the only thing that should come through is a ^C, which
745 will cause us to request child interruption. */
748 input_interrupt (int unused
)
751 struct timeval immediate
= { 0, 0 };
753 /* Protect against spurious interrupts. This has been observed to
754 be a problem under NetBSD 1.4 and 1.5. */
757 FD_SET (remote_desc
, &readset
);
758 if (select (remote_desc
+ 1, &readset
, 0, 0, &immediate
) > 0)
763 cc
= read_prim (&c
, 1);
767 fprintf (stderr
, "client connection closed\n");
770 else if (cc
!= 1 || c
!= '\003')
772 fprintf (stderr
, "input_interrupt, count = %d c = %d ", cc
, c
);
774 fprintf (stderr
, "('%c')\n", c
);
776 fprintf (stderr
, "('\\x%02x')\n", c
& 0xff);
780 the_target
->request_interrupt ();
784 /* Check if the remote side sent us an interrupt request (^C). */
786 check_remote_input_interrupt_request (void)
788 /* This function may be called before establishing communications,
789 therefore we need to validate the remote descriptor. */
791 if (remote_desc
== INVALID_DESCRIPTOR
)
797 /* Asynchronous I/O support. SIGIO must be unblocked when waiting,
798 in order to accept Control-C from the client, and must be blocked
799 when talking to the client. */
802 block_unblock_async_io (int block
)
807 sigemptyset (&sigio_set
);
808 sigaddset (&sigio_set
, SIGIO
);
809 gdb_sigmask (block
? SIG_BLOCK
: SIG_UNBLOCK
, &sigio_set
, NULL
);
815 nto_comctrl (int enable
)
817 struct sigevent event
;
821 event
.sigev_notify
= SIGEV_SIGNAL_THREAD
;
822 event
.sigev_signo
= SIGIO
;
823 event
.sigev_code
= 0;
824 event
.sigev_value
.sival_ptr
= NULL
;
825 event
.sigev_priority
= -1;
826 ionotify (remote_desc
, _NOTIFY_ACTION_POLLARM
, _NOTIFY_COND_INPUT
,
830 ionotify (remote_desc
, _NOTIFY_ACTION_POLL
, _NOTIFY_COND_INPUT
, NULL
);
835 /* Current state of asynchronous I/O. */
836 static int async_io_enabled
;
838 /* Enable asynchronous I/O. */
840 enable_async_io (void)
842 if (async_io_enabled
)
845 block_unblock_async_io (0);
847 async_io_enabled
= 1;
853 /* Disable asynchronous I/O. */
855 disable_async_io (void)
857 if (!async_io_enabled
)
860 block_unblock_async_io (1);
862 async_io_enabled
= 0;
870 initialize_async_io (void)
872 /* Make sure that async I/O starts blocked. */
873 async_io_enabled
= 1;
876 /* Install the signal handler. */
878 signal (SIGIO
, input_interrupt
);
882 /* Internal buffer used by readchar.
883 These are global to readchar because reschedule_remote needs to be
884 able to tell whether the buffer is empty. */
886 static unsigned char readchar_buf
[BUFSIZ
];
887 static int readchar_bufcnt
= 0;
888 static unsigned char *readchar_bufp
;
890 /* Returns next char from remote GDB. -1 if error. */
897 if (readchar_bufcnt
== 0)
899 readchar_bufcnt
= read_prim (readchar_buf
, sizeof (readchar_buf
));
901 if (readchar_bufcnt
<= 0)
903 if (readchar_bufcnt
== 0)
906 debug_printf ("readchar: Got EOF\n");
914 readchar_bufp
= readchar_buf
;
918 ch
= *readchar_bufp
++;
923 /* Reset the readchar state machine. */
926 reset_readchar (void)
929 if (readchar_callback
!= NOT_SCHEDULED
)
931 delete_timer (readchar_callback
);
932 readchar_callback
= NOT_SCHEDULED
;
936 /* Process remaining data in readchar_buf. */
939 process_remaining (void *context
)
941 /* This is a one-shot event. */
942 readchar_callback
= NOT_SCHEDULED
;
944 if (readchar_bufcnt
> 0)
945 handle_serial_event (0, NULL
);
948 /* If there is still data in the buffer, queue another event to process it,
949 we can't sleep in select yet. */
954 if (readchar_bufcnt
> 0 && readchar_callback
== NOT_SCHEDULED
)
955 readchar_callback
= create_timer (0, process_remaining
, NULL
);
958 /* Read a packet from the remote machine, with error checking,
959 and store it in BUF. Returns length of packet, or negative if error. */
964 client_state
&cs
= get_client_state ();
966 unsigned char csum
, c1
, c2
;
977 /* The '\003' may appear before or after each packet, so
978 check for an input interrupt. */
981 the_target
->request_interrupt ();
989 debug_printf ("[getpkt: discarding char '%c']\n", c
);
1010 c1
= fromhex (readchar ());
1011 c2
= fromhex (readchar ());
1013 if (csum
== (c1
<< 4) + c2
)
1019 "Bad checksum, sentsum=0x%x, csum=0x%x, "
1020 "buf=%s [no-ack-mode, Bad medium?]\n",
1021 (c1
<< 4) + c2
, csum
, buf
);
1022 /* Not much we can do, GDB wasn't expecting an ack/nac. */
1026 fprintf (stderr
, "Bad checksum, sentsum=0x%x, csum=0x%x, buf=%s\n",
1027 (c1
<< 4) + c2
, csum
, buf
);
1028 if (write_prim ("-", 1) != 1)
1036 debug_printf ("getpkt (\"%s\"); [sending ack] \n", buf
);
1040 if (write_prim ("+", 1) != 1)
1045 debug_printf ("[sent ack]\n");
1053 debug_printf ("getpkt (\"%s\"); [no ack sent] \n", buf
);
1058 /* The readchar above may have already read a '\003' out of the socket
1059 and moved it to the local buffer. For example, when GDB sends
1060 vCont;c immediately followed by interrupt (see
1061 gdb.base/interrupt-noterm.exp). As soon as we see the vCont;c, we'll
1062 resume the inferior and wait. Since we've already moved the '\003'
1063 to the local buffer, SIGIO won't help. In that case, if we don't
1064 check for interrupt after the vCont;c packet, the interrupt character
1065 would stay in the buffer unattended until after the next (unrelated)
1067 while (readchar_bufcnt
> 0 && *readchar_bufp
== '\003')
1069 /* Consume the interrupt character in the buffer. */
1071 the_target
->request_interrupt ();
1078 write_ok (char *buf
)
1086 write_enn (char *buf
)
1088 /* Some day, we should define the meanings of the error codes... */
1097 #ifndef IN_PROCESS_AGENT
1100 outreg (struct regcache
*regcache
, int regno
, char *buf
)
1102 if ((regno
>> 12) != 0)
1103 *buf
++ = tohex ((regno
>> 12) & 0xf);
1104 if ((regno
>> 8) != 0)
1105 *buf
++ = tohex ((regno
>> 8) & 0xf);
1106 *buf
++ = tohex ((regno
>> 4) & 0xf);
1107 *buf
++ = tohex (regno
& 0xf);
1109 collect_register_as_string (regcache
, regno
, buf
);
1110 buf
+= 2 * register_size (regcache
->tdesc
, regno
);
1117 prepare_resume_reply (char *buf
, ptid_t ptid
,
1118 struct target_waitstatus
*status
)
1120 client_state
&cs
= get_client_state ();
1122 debug_printf ("Writing resume reply for %s:%d\n",
1123 target_pid_to_str (ptid
), status
->kind
);
1125 switch (status
->kind
)
1127 case TARGET_WAITKIND_STOPPED
:
1128 case TARGET_WAITKIND_FORKED
:
1129 case TARGET_WAITKIND_VFORKED
:
1130 case TARGET_WAITKIND_VFORK_DONE
:
1131 case TARGET_WAITKIND_EXECD
:
1132 case TARGET_WAITKIND_THREAD_CREATED
:
1133 case TARGET_WAITKIND_SYSCALL_ENTRY
:
1134 case TARGET_WAITKIND_SYSCALL_RETURN
:
1136 struct thread_info
*saved_thread
;
1138 struct regcache
*regcache
;
1140 if ((status
->kind
== TARGET_WAITKIND_FORKED
&& cs
.report_fork_events
)
1141 || (status
->kind
== TARGET_WAITKIND_VFORKED
1142 && cs
.report_vfork_events
))
1144 enum gdb_signal signal
= GDB_SIGNAL_TRAP
;
1145 const char *event
= (status
->kind
== TARGET_WAITKIND_FORKED
1146 ? "fork" : "vfork");
1148 sprintf (buf
, "T%02x%s:", signal
, event
);
1149 buf
+= strlen (buf
);
1150 buf
= write_ptid (buf
, status
->value
.related_pid
);
1153 else if (status
->kind
== TARGET_WAITKIND_VFORK_DONE
1154 && cs
.report_vfork_events
)
1156 enum gdb_signal signal
= GDB_SIGNAL_TRAP
;
1158 sprintf (buf
, "T%02xvforkdone:;", signal
);
1160 else if (status
->kind
== TARGET_WAITKIND_EXECD
&& cs
.report_exec_events
)
1162 enum gdb_signal signal
= GDB_SIGNAL_TRAP
;
1163 const char *event
= "exec";
1164 char hexified_pathname
[PATH_MAX
* 2];
1166 sprintf (buf
, "T%02x%s:", signal
, event
);
1167 buf
+= strlen (buf
);
1169 /* Encode pathname to hexified format. */
1170 bin2hex ((const gdb_byte
*) status
->value
.execd_pathname
,
1172 strlen (status
->value
.execd_pathname
));
1174 sprintf (buf
, "%s;", hexified_pathname
);
1175 xfree (status
->value
.execd_pathname
);
1176 status
->value
.execd_pathname
= NULL
;
1177 buf
+= strlen (buf
);
1179 else if (status
->kind
== TARGET_WAITKIND_THREAD_CREATED
1180 && cs
.report_thread_events
)
1182 enum gdb_signal signal
= GDB_SIGNAL_TRAP
;
1184 sprintf (buf
, "T%02xcreate:;", signal
);
1186 else if (status
->kind
== TARGET_WAITKIND_SYSCALL_ENTRY
1187 || status
->kind
== TARGET_WAITKIND_SYSCALL_RETURN
)
1189 enum gdb_signal signal
= GDB_SIGNAL_TRAP
;
1190 const char *event
= (status
->kind
== TARGET_WAITKIND_SYSCALL_ENTRY
1191 ? "syscall_entry" : "syscall_return");
1193 sprintf (buf
, "T%02x%s:%x;", signal
, event
,
1194 status
->value
.syscall_number
);
1197 sprintf (buf
, "T%02x", status
->value
.sig
);
1199 if (disable_packet_T
)
1201 /* This is a bit (OK, a lot) of a kludge, however, this isn't
1202 really a user feature, but exists only so GDB can use the
1203 gdbserver to test handling of the 'S' stop reply packet, so
1204 we would rather this code be as simple as possible.
1206 By this point we've started to build the 'T' stop packet,
1207 and it should look like 'Txx....' where 'x' is a hex digit.
1208 An 'S' stop packet always looks like 'Sxx', so all we do
1209 here is convert the buffer from a T packet to an S packet
1210 and the avoid adding any extra content by breaking out. */
1211 gdb_assert (*buf
== 'T');
1212 gdb_assert (isxdigit (*(buf
+ 1)));
1213 gdb_assert (isxdigit (*(buf
+ 2)));
1219 buf
+= strlen (buf
);
1221 saved_thread
= current_thread
;
1223 switch_to_thread (the_target
, ptid
);
1225 regp
= current_target_desc ()->expedite_regs
;
1227 regcache
= get_thread_regcache (current_thread
, 1);
1229 if (the_target
->stopped_by_watchpoint ())
1234 memcpy (buf
, "watch:", 6);
1237 addr
= the_target
->stopped_data_address ();
1239 /* Convert each byte of the address into two hexadecimal
1240 chars. Note that we take sizeof (void *) instead of
1241 sizeof (addr); this is to avoid sending a 64-bit
1242 address to a 32-bit GDB. */
1243 for (i
= sizeof (void *) * 2; i
> 0; i
--)
1244 *buf
++ = tohex ((addr
>> (i
- 1) * 4) & 0xf);
1247 else if (cs
.swbreak_feature
&& target_stopped_by_sw_breakpoint ())
1249 sprintf (buf
, "swbreak:;");
1250 buf
+= strlen (buf
);
1252 else if (cs
.hwbreak_feature
&& target_stopped_by_hw_breakpoint ())
1254 sprintf (buf
, "hwbreak:;");
1255 buf
+= strlen (buf
);
1260 buf
= outreg (regcache
, find_regno (regcache
->tdesc
, *regp
), buf
);
1265 /* Formerly, if the debugger had not used any thread features
1266 we would not burden it with a thread status response. This
1267 was for the benefit of GDB 4.13 and older. However, in
1268 recent GDB versions the check (``if (cont_thread != 0)'')
1269 does not have the desired effect because of sillyness in
1270 the way that the remote protocol handles specifying a
1271 thread. Since thread support relies on qSymbol support
1272 anyway, assume GDB can handle threads. */
1274 if (using_threads
&& !disable_packet_Tthread
)
1276 /* This if (1) ought to be unnecessary. But remote_wait
1277 in GDB will claim this event belongs to inferior_ptid
1278 if we do not specify a thread, and there's no way for
1279 gdbserver to know what inferior_ptid is. */
1280 if (1 || cs
.general_thread
!= ptid
)
1283 /* In non-stop, don't change the general thread behind
1286 cs
.general_thread
= ptid
;
1287 sprintf (buf
, "thread:");
1288 buf
+= strlen (buf
);
1289 buf
= write_ptid (buf
, ptid
);
1291 buf
+= strlen (buf
);
1293 core
= target_core_of_thread (ptid
);
1297 sprintf (buf
, "core:");
1298 buf
+= strlen (buf
);
1299 sprintf (buf
, "%x", core
);
1301 buf
+= strlen (buf
);
1308 strcpy (buf
, "library:;");
1309 buf
+= strlen (buf
);
1313 current_thread
= saved_thread
;
1316 case TARGET_WAITKIND_EXITED
:
1317 if (cs
.multi_process
)
1318 sprintf (buf
, "W%x;process:%x",
1319 status
->value
.integer
, ptid
.pid ());
1321 sprintf (buf
, "W%02x", status
->value
.integer
);
1323 case TARGET_WAITKIND_SIGNALLED
:
1324 if (cs
.multi_process
)
1325 sprintf (buf
, "X%x;process:%x",
1326 status
->value
.sig
, ptid
.pid ());
1328 sprintf (buf
, "X%02x", status
->value
.sig
);
1330 case TARGET_WAITKIND_THREAD_EXITED
:
1331 sprintf (buf
, "w%x;", status
->value
.integer
);
1332 buf
+= strlen (buf
);
1333 buf
= write_ptid (buf
, ptid
);
1335 case TARGET_WAITKIND_NO_RESUMED
:
1339 error ("unhandled waitkind");
1345 decode_m_packet (char *from
, CORE_ADDR
*mem_addr_ptr
, unsigned int *len_ptr
)
1349 *mem_addr_ptr
= *len_ptr
= 0;
1351 while ((ch
= from
[i
++]) != ',')
1353 *mem_addr_ptr
= *mem_addr_ptr
<< 4;
1354 *mem_addr_ptr
|= fromhex (ch
) & 0x0f;
1357 for (j
= 0; j
< 4; j
++)
1359 if ((ch
= from
[i
++]) == 0)
1361 *len_ptr
= *len_ptr
<< 4;
1362 *len_ptr
|= fromhex (ch
) & 0x0f;
1367 decode_M_packet (char *from
, CORE_ADDR
*mem_addr_ptr
, unsigned int *len_ptr
,
1368 unsigned char **to_p
)
1372 *mem_addr_ptr
= *len_ptr
= 0;
1374 while ((ch
= from
[i
++]) != ',')
1376 *mem_addr_ptr
= *mem_addr_ptr
<< 4;
1377 *mem_addr_ptr
|= fromhex (ch
) & 0x0f;
1380 while ((ch
= from
[i
++]) != ':')
1382 *len_ptr
= *len_ptr
<< 4;
1383 *len_ptr
|= fromhex (ch
) & 0x0f;
1387 *to_p
= (unsigned char *) xmalloc (*len_ptr
);
1389 hex2bin (&from
[i
++], *to_p
, *len_ptr
);
1393 decode_X_packet (char *from
, int packet_len
, CORE_ADDR
*mem_addr_ptr
,
1394 unsigned int *len_ptr
, unsigned char **to_p
)
1398 *mem_addr_ptr
= *len_ptr
= 0;
1400 while ((ch
= from
[i
++]) != ',')
1402 *mem_addr_ptr
= *mem_addr_ptr
<< 4;
1403 *mem_addr_ptr
|= fromhex (ch
) & 0x0f;
1406 while ((ch
= from
[i
++]) != ':')
1408 *len_ptr
= *len_ptr
<< 4;
1409 *len_ptr
|= fromhex (ch
) & 0x0f;
1413 *to_p
= (unsigned char *) xmalloc (*len_ptr
);
1415 if (remote_unescape_input ((const gdb_byte
*) &from
[i
], packet_len
- i
,
1416 *to_p
, *len_ptr
) != *len_ptr
)
1422 /* Decode a qXfer write request. */
1425 decode_xfer_write (char *buf
, int packet_len
, CORE_ADDR
*offset
,
1426 unsigned int *len
, unsigned char *data
)
1431 /* Extract the offset. */
1433 while ((ch
= *buf
++) != ':')
1435 *offset
= *offset
<< 4;
1436 *offset
|= fromhex (ch
) & 0x0f;
1439 /* Get encoded data. */
1440 packet_len
-= buf
- b
;
1441 *len
= remote_unescape_input ((const gdb_byte
*) buf
, packet_len
,
1446 /* Decode the parameters of a qSearch:memory packet. */
1449 decode_search_memory_packet (const char *buf
, int packet_len
,
1450 CORE_ADDR
*start_addrp
,
1451 CORE_ADDR
*search_space_lenp
,
1452 gdb_byte
*pattern
, unsigned int *pattern_lenp
)
1454 const char *p
= buf
;
1456 p
= decode_address_to_semicolon (start_addrp
, p
);
1457 p
= decode_address_to_semicolon (search_space_lenp
, p
);
1458 packet_len
-= p
- buf
;
1459 *pattern_lenp
= remote_unescape_input ((const gdb_byte
*) p
, packet_len
,
1460 pattern
, packet_len
);
1465 free_sym_cache (struct sym_cache
*sym
)
1475 clear_symbol_cache (struct sym_cache
**symcache_p
)
1477 struct sym_cache
*sym
, *next
;
1479 /* Check the cache first. */
1480 for (sym
= *symcache_p
; sym
; sym
= next
)
1483 free_sym_cache (sym
);
1489 /* Get the address of NAME, and return it in ADDRP if found. if
1490 MAY_ASK_GDB is false, assume symbol cache misses are failures.
1491 Returns 1 if the symbol is found, 0 if it is not, -1 on error. */
1494 look_up_one_symbol (const char *name
, CORE_ADDR
*addrp
, int may_ask_gdb
)
1496 client_state
&cs
= get_client_state ();
1499 struct sym_cache
*sym
;
1500 struct process_info
*proc
;
1502 proc
= current_process ();
1504 /* Check the cache first. */
1505 for (sym
= proc
->symbol_cache
; sym
; sym
= sym
->next
)
1506 if (strcmp (name
, sym
->name
) == 0)
1512 /* It might not be an appropriate time to look up a symbol,
1513 e.g. while we're trying to fetch registers. */
1517 /* Send the request. */
1518 strcpy (cs
.own_buf
, "qSymbol:");
1519 bin2hex ((const gdb_byte
*) name
, cs
.own_buf
+ strlen ("qSymbol:"),
1521 if (putpkt (cs
.own_buf
) < 0)
1524 /* FIXME: Eventually add buffer overflow checking (to getpkt?) */
1525 len
= getpkt (cs
.own_buf
);
1529 /* We ought to handle pretty much any packet at this point while we
1530 wait for the qSymbol "response". That requires re-entering the
1531 main loop. For now, this is an adequate approximation; allow
1532 GDB to read from memory and handle 'v' packets (for vFile transfers)
1533 while it figures out the address of the symbol. */
1536 if (cs
.own_buf
[0] == 'm')
1539 unsigned char *mem_buf
;
1540 unsigned int mem_len
;
1542 decode_m_packet (&cs
.own_buf
[1], &mem_addr
, &mem_len
);
1543 mem_buf
= (unsigned char *) xmalloc (mem_len
);
1544 if (read_inferior_memory (mem_addr
, mem_buf
, mem_len
) == 0)
1545 bin2hex (mem_buf
, cs
.own_buf
, mem_len
);
1547 write_enn (cs
.own_buf
);
1549 if (putpkt (cs
.own_buf
) < 0)
1552 else if (cs
.own_buf
[0] == 'v')
1555 handle_v_requests (cs
.own_buf
, len
, &new_len
);
1557 putpkt_binary (cs
.own_buf
, new_len
);
1559 putpkt (cs
.own_buf
);
1563 len
= getpkt (cs
.own_buf
);
1568 if (!startswith (cs
.own_buf
, "qSymbol:"))
1570 warning ("Malformed response to qSymbol, ignoring: %s", cs
.own_buf
);
1574 p
= cs
.own_buf
+ strlen ("qSymbol:");
1576 while (*q
&& *q
!= ':')
1579 /* Make sure we found a value for the symbol. */
1580 if (p
== q
|| *q
== '\0')
1583 decode_address (addrp
, p
, q
- p
);
1585 /* Save the symbol in our cache. */
1586 sym
= XNEW (struct sym_cache
);
1587 sym
->name
= xstrdup (name
);
1589 sym
->next
= proc
->symbol_cache
;
1590 proc
->symbol_cache
= sym
;
1595 /* Relocate an instruction to execute at a different address. OLDLOC
1596 is the address in the inferior memory where the instruction to
1597 relocate is currently at. On input, TO points to the destination
1598 where we want the instruction to be copied (and possibly adjusted)
1599 to. On output, it points to one past the end of the resulting
1600 instruction(s). The effect of executing the instruction at TO
1601 shall be the same as if executing it at OLDLOC. For example, call
1602 instructions that implicitly push the return address on the stack
1603 should be adjusted to return to the instruction after OLDLOC;
1604 relative branches, and other PC-relative instructions need the
1605 offset adjusted; etc. Returns 0 on success, -1 on failure. */
1608 relocate_instruction (CORE_ADDR
*to
, CORE_ADDR oldloc
)
1610 client_state
&cs
= get_client_state ();
1612 ULONGEST written
= 0;
1614 /* Send the request. */
1615 sprintf (cs
.own_buf
, "qRelocInsn:%s;%s", paddress (oldloc
),
1617 if (putpkt (cs
.own_buf
) < 0)
1620 /* FIXME: Eventually add buffer overflow checking (to getpkt?) */
1621 len
= getpkt (cs
.own_buf
);
1625 /* We ought to handle pretty much any packet at this point while we
1626 wait for the qRelocInsn "response". That requires re-entering
1627 the main loop. For now, this is an adequate approximation; allow
1628 GDB to access memory. */
1629 while (cs
.own_buf
[0] == 'm' || cs
.own_buf
[0] == 'M' || cs
.own_buf
[0] == 'X')
1632 unsigned char *mem_buf
= NULL
;
1633 unsigned int mem_len
;
1635 if (cs
.own_buf
[0] == 'm')
1637 decode_m_packet (&cs
.own_buf
[1], &mem_addr
, &mem_len
);
1638 mem_buf
= (unsigned char *) xmalloc (mem_len
);
1639 if (read_inferior_memory (mem_addr
, mem_buf
, mem_len
) == 0)
1640 bin2hex (mem_buf
, cs
.own_buf
, mem_len
);
1642 write_enn (cs
.own_buf
);
1644 else if (cs
.own_buf
[0] == 'X')
1646 if (decode_X_packet (&cs
.own_buf
[1], len
- 1, &mem_addr
,
1647 &mem_len
, &mem_buf
) < 0
1648 || target_write_memory (mem_addr
, mem_buf
, mem_len
) != 0)
1649 write_enn (cs
.own_buf
);
1651 write_ok (cs
.own_buf
);
1655 decode_M_packet (&cs
.own_buf
[1], &mem_addr
, &mem_len
, &mem_buf
);
1656 if (target_write_memory (mem_addr
, mem_buf
, mem_len
) == 0)
1657 write_ok (cs
.own_buf
);
1659 write_enn (cs
.own_buf
);
1662 if (putpkt (cs
.own_buf
) < 0)
1664 len
= getpkt (cs
.own_buf
);
1669 if (cs
.own_buf
[0] == 'E')
1671 warning ("An error occurred while relocating an instruction: %s",
1676 if (!startswith (cs
.own_buf
, "qRelocInsn:"))
1678 warning ("Malformed response to qRelocInsn, ignoring: %s",
1683 unpack_varlen_hex (cs
.own_buf
+ strlen ("qRelocInsn:"), &written
);
1690 monitor_output (const char *msg
)
1692 int len
= strlen (msg
);
1693 char *buf
= (char *) xmalloc (len
* 2 + 2);
1696 bin2hex ((const gdb_byte
*) msg
, buf
+ 1, len
);