1 /* Remote utility routines for the remote server for GDB.
2 Copyright (C) 1986-2019 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"
27 #include "gdbsupport/rsp-low.h"
28 #include "gdbsupport/netstuff.h"
29 #include "gdbsupport/filestuff.h"
32 #include <sys/ioctl.h>
38 #include <netinet/in.h>
41 #include <sys/socket.h>
46 #if HAVE_NETINET_TCP_H
47 #include <netinet/tcp.h>
50 #include <sys/ioctl.h>
58 #include "gdbsupport/gdb_sys_time.h"
61 #include <arpa/inet.h>
70 #include <sys/iomgr.h>
73 #ifndef HAVE_SOCKLEN_T
74 typedef int socklen_t
;
77 #ifndef IN_PROCESS_AGENT
80 # define INVALID_DESCRIPTOR INVALID_SOCKET
82 # define INVALID_DESCRIPTOR -1
85 /* Extra value for readchar_callback. */
87 /* The callback is currently not scheduled. */
91 /* Status of the readchar callback.
92 Either NOT_SCHEDULED or the callback id. */
93 static int readchar_callback
= NOT_SCHEDULED
;
95 static int readchar (void);
96 static void reset_readchar (void);
97 static void reschedule (void);
99 /* A cache entry for a successfully looked-up symbol. */
104 struct sym_cache
*next
;
107 static int remote_is_stdio
= 0;
109 static gdb_fildes_t remote_desc
= INVALID_DESCRIPTOR
;
110 static gdb_fildes_t listen_desc
= INVALID_DESCRIPTOR
;
112 /* FIXME headerize? */
113 extern int using_threads
;
114 extern int debug_threads
;
117 # define read(fd, buf, len) recv (fd, (char *) buf, len, 0)
118 # define write(fd, buf, len) send (fd, (char *) buf, len, 0)
124 return remote_desc
!= INVALID_DESCRIPTOR
;
127 /* Return true if the remote connection is over stdio. */
130 remote_connection_is_stdio (void)
132 return remote_is_stdio
;
136 enable_async_notification (int fd
)
138 #if defined(F_SETFL) && defined (FASYNC)
139 int save_fcntl_flags
;
141 save_fcntl_flags
= fcntl (fd
, F_GETFL
, 0);
142 fcntl (fd
, F_SETFL
, save_fcntl_flags
| FASYNC
);
143 #if defined (F_SETOWN)
144 fcntl (fd
, F_SETOWN
, getpid ());
150 handle_accept_event (int err
, gdb_client_data client_data
)
152 struct sockaddr_storage sockaddr
;
153 socklen_t len
= sizeof (sockaddr
);
156 debug_printf ("handling possible accept event\n");
158 remote_desc
= accept (listen_desc
, (struct sockaddr
*) &sockaddr
, &len
);
159 if (remote_desc
== -1)
160 perror_with_name ("Accept failed");
162 /* Enable TCP keep alive process. */
164 setsockopt (remote_desc
, SOL_SOCKET
, SO_KEEPALIVE
,
165 (char *) &tmp
, sizeof (tmp
));
167 /* Tell TCP not to delay small packets. This greatly speeds up
168 interactive response. */
170 setsockopt (remote_desc
, IPPROTO_TCP
, TCP_NODELAY
,
171 (char *) &tmp
, sizeof (tmp
));
174 signal (SIGPIPE
, SIG_IGN
); /* If we don't do this, then gdbserver simply
175 exits when the remote side dies. */
181 close (listen_desc
); /* No longer need this */
183 closesocket (listen_desc
); /* No longer need this */
187 /* Even if !RUN_ONCE no longer notice new connections. Still keep the
188 descriptor open for add_file_handler to wait for a new connection. */
189 delete_file_handler (listen_desc
);
191 /* Convert IP address to string. */
192 char orig_host
[GDB_NI_MAX_ADDR
], orig_port
[GDB_NI_MAX_PORT
];
194 int r
= getnameinfo ((struct sockaddr
*) &sockaddr
, len
,
195 orig_host
, sizeof (orig_host
),
196 orig_port
, sizeof (orig_port
),
197 NI_NUMERICHOST
| NI_NUMERICSERV
);
200 fprintf (stderr
, _("Could not obtain remote address: %s\n"),
203 fprintf (stderr
, _("Remote debugging from host %s, port %s\n"),
204 orig_host
, orig_port
);
206 enable_async_notification (remote_desc
);
208 /* Register the event loop handler. */
209 add_file_handler (remote_desc
, handle_serial_event
, NULL
);
211 /* We have a new GDB connection now. If we were disconnected
212 tracing, there's a window where the target could report a stop
213 event to the event loop, and since we have a connection now, we'd
214 try to send vStopped notifications to GDB. But, don't do that
215 until GDB as selected all-stop/non-stop, and has queried the
216 threads' status ('?'). */
222 /* Prepare for a later connection to a remote debugger.
223 NAME is the filename used for communication. */
226 remote_prepare (const char *name
)
228 client_state
&cs
= get_client_state ();
230 static int winsock_initialized
;
235 if (strcmp (name
, STDIO_CONNECTION_NAME
) == 0)
237 /* We need to record fact that we're using stdio sooner than the
238 call to remote_open so start_inferior knows the connection is
241 cs
.transport_is_reliable
= 1;
245 struct addrinfo hint
;
246 struct addrinfo
*ainfo
;
248 memset (&hint
, 0, sizeof (hint
));
249 /* Assume no prefix will be passed, therefore we should use
251 hint
.ai_family
= AF_UNSPEC
;
252 hint
.ai_socktype
= SOCK_STREAM
;
253 hint
.ai_protocol
= IPPROTO_TCP
;
255 parsed_connection_spec parsed
256 = parse_connection_spec_without_prefix (name
, &hint
);
258 if (parsed
.port_str
.empty ())
260 cs
.transport_is_reliable
= 0;
265 if (!winsock_initialized
)
269 WSAStartup (MAKEWORD (1, 0), &wsad
);
270 winsock_initialized
= 1;
274 int r
= getaddrinfo (parsed
.host_str
.c_str (), parsed
.port_str
.c_str (),
278 error (_("%s: cannot resolve name: %s"), name
, gai_strerror (r
));
280 scoped_free_addrinfo
freeaddrinfo (ainfo
);
282 struct addrinfo
*iter
;
284 for (iter
= ainfo
; iter
!= NULL
; iter
= iter
->ai_next
)
286 listen_desc
= gdb_socket_cloexec (iter
->ai_family
, iter
->ai_socktype
,
289 if (listen_desc
>= 0)
294 perror_with_name ("Can't open socket");
296 /* Allow rapid reuse of this port. */
298 setsockopt (listen_desc
, SOL_SOCKET
, SO_REUSEADDR
, (char *) &tmp
,
301 switch (iter
->ai_family
)
304 ((struct sockaddr_in
*) iter
->ai_addr
)->sin_addr
.s_addr
= INADDR_ANY
;
307 ((struct sockaddr_in6
*) iter
->ai_addr
)->sin6_addr
= in6addr_any
;
310 internal_error (__FILE__
, __LINE__
,
311 _("Invalid 'ai_family' %d\n"), iter
->ai_family
);
314 if (bind (listen_desc
, iter
->ai_addr
, iter
->ai_addrlen
) != 0)
315 perror_with_name ("Can't bind address");
317 if (listen (listen_desc
, 1) != 0)
318 perror_with_name ("Can't listen on socket");
320 cs
.transport_is_reliable
= 1;
323 /* Open a connection to a remote debugger.
324 NAME is the filename used for communication. */
327 remote_open (const char *name
)
329 const char *port_str
;
331 port_str
= strchr (name
, ':');
333 if (port_str
== NULL
)
334 error ("Only HOST:PORT is supported on this platform.");
337 if (strcmp (name
, STDIO_CONNECTION_NAME
) == 0)
339 fprintf (stderr
, "Remote debugging using stdio\n");
341 /* Use stdin as the handle of the connection.
342 We only select on reads, for example. */
343 remote_desc
= fileno (stdin
);
345 enable_async_notification (remote_desc
);
347 /* Register the event loop handler. */
348 add_file_handler (remote_desc
, handle_serial_event
, NULL
);
351 else if (port_str
== NULL
)
355 if (stat (name
, &statbuf
) == 0
356 && (S_ISCHR (statbuf
.st_mode
) || S_ISFIFO (statbuf
.st_mode
)))
357 remote_desc
= open (name
, O_RDWR
);
365 perror_with_name ("Could not open remote device");
369 struct termios termios
;
370 tcgetattr (remote_desc
, &termios
);
375 termios
.c_cflag
&= ~(CSIZE
| PARENB
);
376 termios
.c_cflag
|= CLOCAL
| CS8
;
377 termios
.c_cc
[VMIN
] = 1;
378 termios
.c_cc
[VTIME
] = 0;
380 tcsetattr (remote_desc
, TCSANOW
, &termios
);
384 fprintf (stderr
, "Remote debugging using %s\n", name
);
386 enable_async_notification (remote_desc
);
388 /* Register the event loop handler. */
389 add_file_handler (remote_desc
, handle_serial_event
, NULL
);
391 #endif /* USE_WIN32API */
394 char listen_port
[GDB_NI_MAX_PORT
];
395 struct sockaddr_storage sockaddr
;
396 socklen_t len
= sizeof (sockaddr
);
398 if (getsockname (listen_desc
, (struct sockaddr
*) &sockaddr
, &len
) < 0)
399 perror_with_name ("Can't determine port");
401 int r
= getnameinfo ((struct sockaddr
*) &sockaddr
, len
,
403 listen_port
, sizeof (listen_port
),
407 fprintf (stderr
, _("Can't obtain port where we are listening: %s"),
410 fprintf (stderr
, _("Listening on port %s\n"), listen_port
);
414 /* Register the event loop handler. */
415 add_file_handler (listen_desc
, handle_accept_event
, NULL
);
422 delete_file_handler (remote_desc
);
427 closesocket (remote_desc
);
429 if (! remote_connection_is_stdio ())
432 remote_desc
= INVALID_DESCRIPTOR
;
439 #ifndef IN_PROCESS_AGENT
442 decode_address (CORE_ADDR
*addrp
, const char *start
, int len
)
449 for (i
= 0; i
< len
; i
++)
453 addr
= addr
| (fromhex (ch
) & 0x0f);
459 decode_address_to_semicolon (CORE_ADDR
*addrp
, const char *start
)
464 while (*end
!= '\0' && *end
!= ';')
467 decode_address (addrp
, start
, end
- start
);
476 #ifndef IN_PROCESS_AGENT
478 /* Look for a sequence of characters which can be run-length encoded.
479 If there are any, update *CSUM and *P. Otherwise, output the
480 single character. Return the number of characters consumed. */
483 try_rle (char *buf
, int remaining
, unsigned char *csum
, char **p
)
487 /* Always output the character. */
491 /* Don't go past '~'. */
495 for (n
= 1; n
< remaining
; n
++)
496 if (buf
[n
] != buf
[0])
499 /* N is the index of the first character not the same as buf[0].
500 buf[0] is counted twice, so by decrementing N, we get the number
501 of characters the RLE sequence will replace. */
507 /* Skip the frame characters. The manual says to skip '+' and '-'
508 also, but there's no reason to. Unfortunately these two unusable
509 characters double the encoded length of a four byte zero
511 while (n
+ 29 == '$' || n
+ 29 == '#')
524 #ifndef IN_PROCESS_AGENT
526 /* Write a PTID to BUF. Returns BUF+CHARACTERS_WRITTEN. */
529 write_ptid (char *buf
, ptid_t ptid
)
531 client_state
&cs
= get_client_state ();
534 if (cs
.multi_process
)
538 buf
+= sprintf (buf
, "p-%x.", -pid
);
540 buf
+= sprintf (buf
, "p%x.", pid
);
544 buf
+= sprintf (buf
, "-%x", -tid
);
546 buf
+= sprintf (buf
, "%x", tid
);
552 hex_or_minus_one (const char *buf
, const char **obuf
)
556 if (startswith (buf
, "-1"))
562 buf
= unpack_varlen_hex (buf
, &ret
);
570 /* Extract a PTID from BUF. If non-null, OBUF is set to the to one
571 passed the last parsed char. Returns null_ptid on error. */
573 read_ptid (const char *buf
, const char **obuf
)
577 ULONGEST pid
= 0, tid
= 0;
581 /* Multi-process ptid. */
582 pp
= unpack_varlen_hex (p
+ 1, &pid
);
584 error ("invalid remote ptid: %s\n", p
);
588 tid
= hex_or_minus_one (p
, &pp
);
592 return ptid_t (pid
, tid
, 0);
595 /* No multi-process. Just a tid. */
596 tid
= hex_or_minus_one (p
, &pp
);
598 /* Since GDB is not sending a process id (multi-process extensions
599 are off), then there's only one process. Default to the first in
601 pid
= pid_of (get_first_process ());
605 return ptid_t (pid
, tid
, 0);
608 /* Write COUNT bytes in BUF to the client.
609 The result is the number of bytes written or -1 if error.
610 This may return less than COUNT. */
613 write_prim (const void *buf
, int count
)
615 if (remote_connection_is_stdio ())
616 return write (fileno (stdout
), buf
, count
);
618 return write (remote_desc
, buf
, count
);
621 /* Read COUNT bytes from the client and store in BUF.
622 The result is the number of bytes read or -1 if error.
623 This may return less than COUNT. */
626 read_prim (void *buf
, int count
)
628 if (remote_connection_is_stdio ())
629 return read (fileno (stdin
), buf
, count
);
631 return read (remote_desc
, buf
, count
);
634 /* Send a packet to the remote machine, with error checking.
635 The data of the packet is in BUF, and the length of the
636 packet is in CNT. Returns >= 0 on success, -1 otherwise. */
639 putpkt_binary_1 (char *buf
, int cnt
, int is_notif
)
641 client_state
&cs
= get_client_state ();
643 unsigned char csum
= 0;
648 buf2
= (char *) xmalloc (strlen ("$") + cnt
+ strlen ("#nn") + 1);
650 /* Copy the packet into buffer BUF2, encapsulating it
651 and giving it a checksum. */
659 for (i
= 0; i
< cnt
;)
660 i
+= try_rle (buf
+ i
, cnt
- i
, &csum
, &p
);
663 *p
++ = tohex ((csum
>> 4) & 0xf);
664 *p
++ = tohex (csum
& 0xf);
668 /* Send it over and over until we get a positive ack. */
672 if (write_prim (buf2
, p
- buf2
) != p
- buf2
)
674 perror ("putpkt(write)");
679 if (cs
.noack_mode
|| is_notif
)
681 /* Don't expect an ack then. */
685 debug_printf ("putpkt (\"%s\"); [notif]\n", buf2
);
687 debug_printf ("putpkt (\"%s\"); [noack mode]\n", buf2
);
695 debug_printf ("putpkt (\"%s\"); [looking for ack]\n", buf2
);
709 debug_printf ("[received '%c' (0x%x)]\n", cc
, cc
);
713 /* Check for an input interrupt while we're here. */
714 if (cc
== '\003' && current_thread
!= NULL
)
715 (*the_target
->request_interrupt
) ();
720 return 1; /* Success! */
724 putpkt_binary (char *buf
, int cnt
)
726 return putpkt_binary_1 (buf
, cnt
, 0);
729 /* Send a packet to the remote machine, with error checking. The data
730 of the packet is in BUF, and the packet should be a NUL-terminated
731 string. Returns >= 0 on success, -1 otherwise. */
736 return putpkt_binary (buf
, strlen (buf
));
740 putpkt_notif (char *buf
)
742 return putpkt_binary_1 (buf
, strlen (buf
), 1);
745 /* Come here when we get an input interrupt from the remote side. This
746 interrupt should only be active while we are waiting for the child to do
747 something. Thus this assumes readchar:bufcnt is 0.
748 About the only thing that should come through is a ^C, which
749 will cause us to request child interruption. */
752 input_interrupt (int unused
)
755 struct timeval immediate
= { 0, 0 };
757 /* Protect against spurious interrupts. This has been observed to
758 be a problem under NetBSD 1.4 and 1.5. */
761 FD_SET (remote_desc
, &readset
);
762 if (select (remote_desc
+ 1, &readset
, 0, 0, &immediate
) > 0)
767 cc
= read_prim (&c
, 1);
771 fprintf (stderr
, "client connection closed\n");
774 else if (cc
!= 1 || c
!= '\003')
776 fprintf (stderr
, "input_interrupt, count = %d c = %d ", cc
, c
);
778 fprintf (stderr
, "('%c')\n", c
);
780 fprintf (stderr
, "('\\x%02x')\n", c
& 0xff);
784 (*the_target
->request_interrupt
) ();
788 /* Check if the remote side sent us an interrupt request (^C). */
790 check_remote_input_interrupt_request (void)
792 /* This function may be called before establishing communications,
793 therefore we need to validate the remote descriptor. */
795 if (remote_desc
== INVALID_DESCRIPTOR
)
801 /* Asynchronous I/O support. SIGIO must be unblocked when waiting,
802 in order to accept Control-C from the client, and must be blocked
803 when talking to the client. */
806 block_unblock_async_io (int block
)
811 sigemptyset (&sigio_set
);
812 sigaddset (&sigio_set
, SIGIO
);
813 sigprocmask (block
? SIG_BLOCK
: SIG_UNBLOCK
, &sigio_set
, NULL
);
819 nto_comctrl (int enable
)
821 struct sigevent event
;
825 event
.sigev_notify
= SIGEV_SIGNAL_THREAD
;
826 event
.sigev_signo
= SIGIO
;
827 event
.sigev_code
= 0;
828 event
.sigev_value
.sival_ptr
= NULL
;
829 event
.sigev_priority
= -1;
830 ionotify (remote_desc
, _NOTIFY_ACTION_POLLARM
, _NOTIFY_COND_INPUT
,
834 ionotify (remote_desc
, _NOTIFY_ACTION_POLL
, _NOTIFY_COND_INPUT
, NULL
);
839 /* Current state of asynchronous I/O. */
840 static int async_io_enabled
;
842 /* Enable asynchronous I/O. */
844 enable_async_io (void)
846 if (async_io_enabled
)
849 block_unblock_async_io (0);
851 async_io_enabled
= 1;
857 /* Disable asynchronous I/O. */
859 disable_async_io (void)
861 if (!async_io_enabled
)
864 block_unblock_async_io (1);
866 async_io_enabled
= 0;
874 initialize_async_io (void)
876 /* Make sure that async I/O starts blocked. */
877 async_io_enabled
= 1;
880 /* Install the signal handler. */
882 signal (SIGIO
, input_interrupt
);
886 /* Internal buffer used by readchar.
887 These are global to readchar because reschedule_remote needs to be
888 able to tell whether the buffer is empty. */
890 static unsigned char readchar_buf
[BUFSIZ
];
891 static int readchar_bufcnt
= 0;
892 static unsigned char *readchar_bufp
;
894 /* Returns next char from remote GDB. -1 if error. */
901 if (readchar_bufcnt
== 0)
903 readchar_bufcnt
= read_prim (readchar_buf
, sizeof (readchar_buf
));
905 if (readchar_bufcnt
<= 0)
907 if (readchar_bufcnt
== 0)
910 debug_printf ("readchar: Got EOF\n");
918 readchar_bufp
= readchar_buf
;
922 ch
= *readchar_bufp
++;
927 /* Reset the readchar state machine. */
930 reset_readchar (void)
933 if (readchar_callback
!= NOT_SCHEDULED
)
935 delete_callback_event (readchar_callback
);
936 readchar_callback
= NOT_SCHEDULED
;
940 /* Process remaining data in readchar_buf. */
943 process_remaining (void *context
)
947 /* This is a one-shot event. */
948 readchar_callback
= NOT_SCHEDULED
;
950 if (readchar_bufcnt
> 0)
951 res
= handle_serial_event (0, NULL
);
958 /* If there is still data in the buffer, queue another event to process it,
959 we can't sleep in select yet. */
964 if (readchar_bufcnt
> 0 && readchar_callback
== NOT_SCHEDULED
)
965 readchar_callback
= append_callback_event (process_remaining
, NULL
);
968 /* Read a packet from the remote machine, with error checking,
969 and store it in BUF. Returns length of packet, or negative if error. */
974 client_state
&cs
= get_client_state ();
976 unsigned char csum
, c1
, c2
;
987 /* The '\003' may appear before or after each packet, so
988 check for an input interrupt. */
991 (*the_target
->request_interrupt
) ();
999 debug_printf ("[getpkt: discarding char '%c']\n", c
);
1020 c1
= fromhex (readchar ());
1021 c2
= fromhex (readchar ());
1023 if (csum
== (c1
<< 4) + c2
)
1029 "Bad checksum, sentsum=0x%x, csum=0x%x, "
1030 "buf=%s [no-ack-mode, Bad medium?]\n",
1031 (c1
<< 4) + c2
, csum
, buf
);
1032 /* Not much we can do, GDB wasn't expecting an ack/nac. */
1036 fprintf (stderr
, "Bad checksum, sentsum=0x%x, csum=0x%x, buf=%s\n",
1037 (c1
<< 4) + c2
, csum
, buf
);
1038 if (write_prim ("-", 1) != 1)
1046 debug_printf ("getpkt (\"%s\"); [sending ack] \n", buf
);
1050 if (write_prim ("+", 1) != 1)
1055 debug_printf ("[sent ack]\n");
1063 debug_printf ("getpkt (\"%s\"); [no ack sent] \n", buf
);
1068 /* The readchar above may have already read a '\003' out of the socket
1069 and moved it to the local buffer. For example, when GDB sends
1070 vCont;c immediately followed by interrupt (see
1071 gdb.base/interrupt-noterm.exp). As soon as we see the vCont;c, we'll
1072 resume the inferior and wait. Since we've already moved the '\003'
1073 to the local buffer, SIGIO won't help. In that case, if we don't
1074 check for interrupt after the vCont;c packet, the interrupt character
1075 would stay in the buffer unattended until after the next (unrelated)
1077 while (readchar_bufcnt
> 0 && *readchar_bufp
== '\003')
1079 /* Consume the interrupt character in the buffer. */
1081 (*the_target
->request_interrupt
) ();
1088 write_ok (char *buf
)
1096 write_enn (char *buf
)
1098 /* Some day, we should define the meanings of the error codes... */
1107 #ifndef IN_PROCESS_AGENT
1110 outreg (struct regcache
*regcache
, int regno
, char *buf
)
1112 if ((regno
>> 12) != 0)
1113 *buf
++ = tohex ((regno
>> 12) & 0xf);
1114 if ((regno
>> 8) != 0)
1115 *buf
++ = tohex ((regno
>> 8) & 0xf);
1116 *buf
++ = tohex ((regno
>> 4) & 0xf);
1117 *buf
++ = tohex (regno
& 0xf);
1119 collect_register_as_string (regcache
, regno
, buf
);
1120 buf
+= 2 * register_size (regcache
->tdesc
, regno
);
1127 prepare_resume_reply (char *buf
, ptid_t ptid
,
1128 struct target_waitstatus
*status
)
1130 client_state
&cs
= get_client_state ();
1132 debug_printf ("Writing resume reply for %s:%d\n",
1133 target_pid_to_str (ptid
), status
->kind
);
1135 switch (status
->kind
)
1137 case TARGET_WAITKIND_STOPPED
:
1138 case TARGET_WAITKIND_FORKED
:
1139 case TARGET_WAITKIND_VFORKED
:
1140 case TARGET_WAITKIND_VFORK_DONE
:
1141 case TARGET_WAITKIND_EXECD
:
1142 case TARGET_WAITKIND_THREAD_CREATED
:
1143 case TARGET_WAITKIND_SYSCALL_ENTRY
:
1144 case TARGET_WAITKIND_SYSCALL_RETURN
:
1146 struct thread_info
*saved_thread
;
1148 struct regcache
*regcache
;
1150 if ((status
->kind
== TARGET_WAITKIND_FORKED
&& cs
.report_fork_events
)
1151 || (status
->kind
== TARGET_WAITKIND_VFORKED
1152 && cs
.report_vfork_events
))
1154 enum gdb_signal signal
= GDB_SIGNAL_TRAP
;
1155 const char *event
= (status
->kind
== TARGET_WAITKIND_FORKED
1156 ? "fork" : "vfork");
1158 sprintf (buf
, "T%02x%s:", signal
, event
);
1159 buf
+= strlen (buf
);
1160 buf
= write_ptid (buf
, status
->value
.related_pid
);
1163 else if (status
->kind
== TARGET_WAITKIND_VFORK_DONE
1164 && cs
.report_vfork_events
)
1166 enum gdb_signal signal
= GDB_SIGNAL_TRAP
;
1168 sprintf (buf
, "T%02xvforkdone:;", signal
);
1170 else if (status
->kind
== TARGET_WAITKIND_EXECD
&& cs
.report_exec_events
)
1172 enum gdb_signal signal
= GDB_SIGNAL_TRAP
;
1173 const char *event
= "exec";
1174 char hexified_pathname
[PATH_MAX
* 2];
1176 sprintf (buf
, "T%02x%s:", signal
, event
);
1177 buf
+= strlen (buf
);
1179 /* Encode pathname to hexified format. */
1180 bin2hex ((const gdb_byte
*) status
->value
.execd_pathname
,
1182 strlen (status
->value
.execd_pathname
));
1184 sprintf (buf
, "%s;", hexified_pathname
);
1185 xfree (status
->value
.execd_pathname
);
1186 status
->value
.execd_pathname
= NULL
;
1187 buf
+= strlen (buf
);
1189 else if (status
->kind
== TARGET_WAITKIND_THREAD_CREATED
1190 && cs
.report_thread_events
)
1192 enum gdb_signal signal
= GDB_SIGNAL_TRAP
;
1194 sprintf (buf
, "T%02xcreate:;", signal
);
1196 else if (status
->kind
== TARGET_WAITKIND_SYSCALL_ENTRY
1197 || status
->kind
== TARGET_WAITKIND_SYSCALL_RETURN
)
1199 enum gdb_signal signal
= GDB_SIGNAL_TRAP
;
1200 const char *event
= (status
->kind
== TARGET_WAITKIND_SYSCALL_ENTRY
1201 ? "syscall_entry" : "syscall_return");
1203 sprintf (buf
, "T%02x%s:%x;", signal
, event
,
1204 status
->value
.syscall_number
);
1207 sprintf (buf
, "T%02x", status
->value
.sig
);
1209 buf
+= strlen (buf
);
1211 saved_thread
= current_thread
;
1213 switch_to_thread (ptid
);
1215 regp
= current_target_desc ()->expedite_regs
;
1217 regcache
= get_thread_regcache (current_thread
, 1);
1219 if (the_target
->stopped_by_watchpoint
!= NULL
1220 && (*the_target
->stopped_by_watchpoint
) ())
1225 memcpy (buf
, "watch:", 6);
1228 addr
= (*the_target
->stopped_data_address
) ();
1230 /* Convert each byte of the address into two hexadecimal
1231 chars. Note that we take sizeof (void *) instead of
1232 sizeof (addr); this is to avoid sending a 64-bit
1233 address to a 32-bit GDB. */
1234 for (i
= sizeof (void *) * 2; i
> 0; i
--)
1235 *buf
++ = tohex ((addr
>> (i
- 1) * 4) & 0xf);
1238 else if (cs
.swbreak_feature
&& target_stopped_by_sw_breakpoint ())
1240 sprintf (buf
, "swbreak:;");
1241 buf
+= strlen (buf
);
1243 else if (cs
.hwbreak_feature
&& target_stopped_by_hw_breakpoint ())
1245 sprintf (buf
, "hwbreak:;");
1246 buf
+= strlen (buf
);
1251 buf
= outreg (regcache
, find_regno (regcache
->tdesc
, *regp
), buf
);
1256 /* Formerly, if the debugger had not used any thread features
1257 we would not burden it with a thread status response. This
1258 was for the benefit of GDB 4.13 and older. However, in
1259 recent GDB versions the check (``if (cont_thread != 0)'')
1260 does not have the desired effect because of sillyness in
1261 the way that the remote protocol handles specifying a
1262 thread. Since thread support relies on qSymbol support
1263 anyway, assume GDB can handle threads. */
1265 if (using_threads
&& !disable_packet_Tthread
)
1267 /* This if (1) ought to be unnecessary. But remote_wait
1268 in GDB will claim this event belongs to inferior_ptid
1269 if we do not specify a thread, and there's no way for
1270 gdbserver to know what inferior_ptid is. */
1271 if (1 || cs
.general_thread
!= ptid
)
1274 /* In non-stop, don't change the general thread behind
1277 cs
.general_thread
= ptid
;
1278 sprintf (buf
, "thread:");
1279 buf
+= strlen (buf
);
1280 buf
= write_ptid (buf
, ptid
);
1282 buf
+= strlen (buf
);
1284 core
= target_core_of_thread (ptid
);
1288 sprintf (buf
, "core:");
1289 buf
+= strlen (buf
);
1290 sprintf (buf
, "%x", core
);
1292 buf
+= strlen (buf
);
1299 strcpy (buf
, "library:;");
1300 buf
+= strlen (buf
);
1304 current_thread
= saved_thread
;
1307 case TARGET_WAITKIND_EXITED
:
1308 if (cs
.multi_process
)
1309 sprintf (buf
, "W%x;process:%x",
1310 status
->value
.integer
, ptid
.pid ());
1312 sprintf (buf
, "W%02x", status
->value
.integer
);
1314 case TARGET_WAITKIND_SIGNALLED
:
1315 if (cs
.multi_process
)
1316 sprintf (buf
, "X%x;process:%x",
1317 status
->value
.sig
, ptid
.pid ());
1319 sprintf (buf
, "X%02x", status
->value
.sig
);
1321 case TARGET_WAITKIND_THREAD_EXITED
:
1322 sprintf (buf
, "w%x;", status
->value
.integer
);
1323 buf
+= strlen (buf
);
1324 buf
= write_ptid (buf
, ptid
);
1326 case TARGET_WAITKIND_NO_RESUMED
:
1330 error ("unhandled waitkind");
1336 decode_m_packet (char *from
, CORE_ADDR
*mem_addr_ptr
, unsigned int *len_ptr
)
1340 *mem_addr_ptr
= *len_ptr
= 0;
1342 while ((ch
= from
[i
++]) != ',')
1344 *mem_addr_ptr
= *mem_addr_ptr
<< 4;
1345 *mem_addr_ptr
|= fromhex (ch
) & 0x0f;
1348 for (j
= 0; j
< 4; j
++)
1350 if ((ch
= from
[i
++]) == 0)
1352 *len_ptr
= *len_ptr
<< 4;
1353 *len_ptr
|= fromhex (ch
) & 0x0f;
1358 decode_M_packet (char *from
, CORE_ADDR
*mem_addr_ptr
, unsigned int *len_ptr
,
1359 unsigned char **to_p
)
1363 *mem_addr_ptr
= *len_ptr
= 0;
1365 while ((ch
= from
[i
++]) != ',')
1367 *mem_addr_ptr
= *mem_addr_ptr
<< 4;
1368 *mem_addr_ptr
|= fromhex (ch
) & 0x0f;
1371 while ((ch
= from
[i
++]) != ':')
1373 *len_ptr
= *len_ptr
<< 4;
1374 *len_ptr
|= fromhex (ch
) & 0x0f;
1378 *to_p
= (unsigned char *) xmalloc (*len_ptr
);
1380 hex2bin (&from
[i
++], *to_p
, *len_ptr
);
1384 decode_X_packet (char *from
, int packet_len
, CORE_ADDR
*mem_addr_ptr
,
1385 unsigned int *len_ptr
, unsigned char **to_p
)
1389 *mem_addr_ptr
= *len_ptr
= 0;
1391 while ((ch
= from
[i
++]) != ',')
1393 *mem_addr_ptr
= *mem_addr_ptr
<< 4;
1394 *mem_addr_ptr
|= fromhex (ch
) & 0x0f;
1397 while ((ch
= from
[i
++]) != ':')
1399 *len_ptr
= *len_ptr
<< 4;
1400 *len_ptr
|= fromhex (ch
) & 0x0f;
1404 *to_p
= (unsigned char *) xmalloc (*len_ptr
);
1406 if (remote_unescape_input ((const gdb_byte
*) &from
[i
], packet_len
- i
,
1407 *to_p
, *len_ptr
) != *len_ptr
)
1413 /* Decode a qXfer write request. */
1416 decode_xfer_write (char *buf
, int packet_len
, CORE_ADDR
*offset
,
1417 unsigned int *len
, unsigned char *data
)
1422 /* Extract the offset. */
1424 while ((ch
= *buf
++) != ':')
1426 *offset
= *offset
<< 4;
1427 *offset
|= fromhex (ch
) & 0x0f;
1430 /* Get encoded data. */
1431 packet_len
-= buf
- b
;
1432 *len
= remote_unescape_input ((const gdb_byte
*) buf
, packet_len
,
1437 /* Decode the parameters of a qSearch:memory packet. */
1440 decode_search_memory_packet (const char *buf
, int packet_len
,
1441 CORE_ADDR
*start_addrp
,
1442 CORE_ADDR
*search_space_lenp
,
1443 gdb_byte
*pattern
, unsigned int *pattern_lenp
)
1445 const char *p
= buf
;
1447 p
= decode_address_to_semicolon (start_addrp
, p
);
1448 p
= decode_address_to_semicolon (search_space_lenp
, p
);
1449 packet_len
-= p
- buf
;
1450 *pattern_lenp
= remote_unescape_input ((const gdb_byte
*) p
, packet_len
,
1451 pattern
, packet_len
);
1456 free_sym_cache (struct sym_cache
*sym
)
1466 clear_symbol_cache (struct sym_cache
**symcache_p
)
1468 struct sym_cache
*sym
, *next
;
1470 /* Check the cache first. */
1471 for (sym
= *symcache_p
; sym
; sym
= next
)
1474 free_sym_cache (sym
);
1480 /* Get the address of NAME, and return it in ADDRP if found. if
1481 MAY_ASK_GDB is false, assume symbol cache misses are failures.
1482 Returns 1 if the symbol is found, 0 if it is not, -1 on error. */
1485 look_up_one_symbol (const char *name
, CORE_ADDR
*addrp
, int may_ask_gdb
)
1487 client_state
&cs
= get_client_state ();
1490 struct sym_cache
*sym
;
1491 struct process_info
*proc
;
1493 proc
= current_process ();
1495 /* Check the cache first. */
1496 for (sym
= proc
->symbol_cache
; sym
; sym
= sym
->next
)
1497 if (strcmp (name
, sym
->name
) == 0)
1503 /* It might not be an appropriate time to look up a symbol,
1504 e.g. while we're trying to fetch registers. */
1508 /* Send the request. */
1509 strcpy (cs
.own_buf
, "qSymbol:");
1510 bin2hex ((const gdb_byte
*) name
, cs
.own_buf
+ strlen ("qSymbol:"),
1512 if (putpkt (cs
.own_buf
) < 0)
1515 /* FIXME: Eventually add buffer overflow checking (to getpkt?) */
1516 len
= getpkt (cs
.own_buf
);
1520 /* We ought to handle pretty much any packet at this point while we
1521 wait for the qSymbol "response". That requires re-entering the
1522 main loop. For now, this is an adequate approximation; allow
1523 GDB to read from memory and handle 'v' packets (for vFile transfers)
1524 while it figures out the address of the symbol. */
1527 if (cs
.own_buf
[0] == 'm')
1530 unsigned char *mem_buf
;
1531 unsigned int mem_len
;
1533 decode_m_packet (&cs
.own_buf
[1], &mem_addr
, &mem_len
);
1534 mem_buf
= (unsigned char *) xmalloc (mem_len
);
1535 if (read_inferior_memory (mem_addr
, mem_buf
, mem_len
) == 0)
1536 bin2hex (mem_buf
, cs
.own_buf
, mem_len
);
1538 write_enn (cs
.own_buf
);
1540 if (putpkt (cs
.own_buf
) < 0)
1543 else if (cs
.own_buf
[0] == 'v')
1546 handle_v_requests (cs
.own_buf
, len
, &new_len
);
1548 putpkt_binary (cs
.own_buf
, new_len
);
1550 putpkt (cs
.own_buf
);
1554 len
= getpkt (cs
.own_buf
);
1559 if (!startswith (cs
.own_buf
, "qSymbol:"))
1561 warning ("Malformed response to qSymbol, ignoring: %s", cs
.own_buf
);
1565 p
= cs
.own_buf
+ strlen ("qSymbol:");
1567 while (*q
&& *q
!= ':')
1570 /* Make sure we found a value for the symbol. */
1571 if (p
== q
|| *q
== '\0')
1574 decode_address (addrp
, p
, q
- p
);
1576 /* Save the symbol in our cache. */
1577 sym
= XNEW (struct sym_cache
);
1578 sym
->name
= xstrdup (name
);
1580 sym
->next
= proc
->symbol_cache
;
1581 proc
->symbol_cache
= sym
;
1586 /* Relocate an instruction to execute at a different address. OLDLOC
1587 is the address in the inferior memory where the instruction to
1588 relocate is currently at. On input, TO points to the destination
1589 where we want the instruction to be copied (and possibly adjusted)
1590 to. On output, it points to one past the end of the resulting
1591 instruction(s). The effect of executing the instruction at TO
1592 shall be the same as if executing it at OLDLOC. For example, call
1593 instructions that implicitly push the return address on the stack
1594 should be adjusted to return to the instruction after OLDLOC;
1595 relative branches, and other PC-relative instructions need the
1596 offset adjusted; etc. Returns 0 on success, -1 on failure. */
1599 relocate_instruction (CORE_ADDR
*to
, CORE_ADDR oldloc
)
1601 client_state
&cs
= get_client_state ();
1603 ULONGEST written
= 0;
1605 /* Send the request. */
1606 sprintf (cs
.own_buf
, "qRelocInsn:%s;%s", paddress (oldloc
),
1608 if (putpkt (cs
.own_buf
) < 0)
1611 /* FIXME: Eventually add buffer overflow checking (to getpkt?) */
1612 len
= getpkt (cs
.own_buf
);
1616 /* We ought to handle pretty much any packet at this point while we
1617 wait for the qRelocInsn "response". That requires re-entering
1618 the main loop. For now, this is an adequate approximation; allow
1619 GDB to access memory. */
1620 while (cs
.own_buf
[0] == 'm' || cs
.own_buf
[0] == 'M' || cs
.own_buf
[0] == 'X')
1623 unsigned char *mem_buf
= NULL
;
1624 unsigned int mem_len
;
1626 if (cs
.own_buf
[0] == 'm')
1628 decode_m_packet (&cs
.own_buf
[1], &mem_addr
, &mem_len
);
1629 mem_buf
= (unsigned char *) xmalloc (mem_len
);
1630 if (read_inferior_memory (mem_addr
, mem_buf
, mem_len
) == 0)
1631 bin2hex (mem_buf
, cs
.own_buf
, mem_len
);
1633 write_enn (cs
.own_buf
);
1635 else if (cs
.own_buf
[0] == 'X')
1637 if (decode_X_packet (&cs
.own_buf
[1], len
- 1, &mem_addr
,
1638 &mem_len
, &mem_buf
) < 0
1639 || write_inferior_memory (mem_addr
, mem_buf
, mem_len
) != 0)
1640 write_enn (cs
.own_buf
);
1642 write_ok (cs
.own_buf
);
1646 decode_M_packet (&cs
.own_buf
[1], &mem_addr
, &mem_len
, &mem_buf
);
1647 if (write_inferior_memory (mem_addr
, mem_buf
, mem_len
) == 0)
1648 write_ok (cs
.own_buf
);
1650 write_enn (cs
.own_buf
);
1653 if (putpkt (cs
.own_buf
) < 0)
1655 len
= getpkt (cs
.own_buf
);
1660 if (cs
.own_buf
[0] == 'E')
1662 warning ("An error occurred while relocating an instruction: %s",
1667 if (!startswith (cs
.own_buf
, "qRelocInsn:"))
1669 warning ("Malformed response to qRelocInsn, ignoring: %s",
1674 unpack_varlen_hex (cs
.own_buf
+ strlen ("qRelocInsn:"), &written
);
1681 monitor_output (const char *msg
)
1683 int len
= strlen (msg
);
1684 char *buf
= (char *) xmalloc (len
* 2 + 2);
1687 bin2hex ((const gdb_byte
*) msg
, buf
+ 1, len
);