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 ('?'). */
220 /* Prepare for a later connection to a remote debugger.
221 NAME is the filename used for communication. */
224 remote_prepare (const char *name
)
226 client_state
&cs
= get_client_state ();
228 static int winsock_initialized
;
233 if (strcmp (name
, STDIO_CONNECTION_NAME
) == 0)
235 /* We need to record fact that we're using stdio sooner than the
236 call to remote_open so start_inferior knows the connection is
239 cs
.transport_is_reliable
= 1;
243 struct addrinfo hint
;
244 struct addrinfo
*ainfo
;
246 memset (&hint
, 0, sizeof (hint
));
247 /* Assume no prefix will be passed, therefore we should use
249 hint
.ai_family
= AF_UNSPEC
;
250 hint
.ai_socktype
= SOCK_STREAM
;
251 hint
.ai_protocol
= IPPROTO_TCP
;
253 parsed_connection_spec parsed
254 = parse_connection_spec_without_prefix (name
, &hint
);
256 if (parsed
.port_str
.empty ())
258 cs
.transport_is_reliable
= 0;
263 if (!winsock_initialized
)
267 WSAStartup (MAKEWORD (1, 0), &wsad
);
268 winsock_initialized
= 1;
272 int r
= getaddrinfo (parsed
.host_str
.c_str (), parsed
.port_str
.c_str (),
276 error (_("%s: cannot resolve name: %s"), name
, gai_strerror (r
));
278 scoped_free_addrinfo
freeaddrinfo (ainfo
);
280 struct addrinfo
*iter
;
282 for (iter
= ainfo
; iter
!= NULL
; iter
= iter
->ai_next
)
284 listen_desc
= gdb_socket_cloexec (iter
->ai_family
, iter
->ai_socktype
,
287 if (listen_desc
>= 0)
292 perror_with_name ("Can't open socket");
294 /* Allow rapid reuse of this port. */
296 setsockopt (listen_desc
, SOL_SOCKET
, SO_REUSEADDR
, (char *) &tmp
,
299 switch (iter
->ai_family
)
302 ((struct sockaddr_in
*) iter
->ai_addr
)->sin_addr
.s_addr
= INADDR_ANY
;
305 ((struct sockaddr_in6
*) iter
->ai_addr
)->sin6_addr
= in6addr_any
;
308 internal_error (__FILE__
, __LINE__
,
309 _("Invalid 'ai_family' %d\n"), iter
->ai_family
);
312 if (bind (listen_desc
, iter
->ai_addr
, iter
->ai_addrlen
) != 0)
313 perror_with_name ("Can't bind address");
315 if (listen (listen_desc
, 1) != 0)
316 perror_with_name ("Can't listen on socket");
318 cs
.transport_is_reliable
= 1;
321 /* Open a connection to a remote debugger.
322 NAME is the filename used for communication. */
325 remote_open (const char *name
)
327 const char *port_str
;
329 port_str
= strchr (name
, ':');
331 if (port_str
== NULL
)
332 error ("Only HOST:PORT is supported on this platform.");
335 if (strcmp (name
, STDIO_CONNECTION_NAME
) == 0)
337 fprintf (stderr
, "Remote debugging using stdio\n");
339 /* Use stdin as the handle of the connection.
340 We only select on reads, for example. */
341 remote_desc
= fileno (stdin
);
343 enable_async_notification (remote_desc
);
345 /* Register the event loop handler. */
346 add_file_handler (remote_desc
, handle_serial_event
, NULL
);
349 else if (port_str
== NULL
)
353 if (stat (name
, &statbuf
) == 0
354 && (S_ISCHR (statbuf
.st_mode
) || S_ISFIFO (statbuf
.st_mode
)))
355 remote_desc
= open (name
, O_RDWR
);
363 perror_with_name ("Could not open remote device");
367 struct termios termios
;
368 tcgetattr (remote_desc
, &termios
);
373 termios
.c_cflag
&= ~(CSIZE
| PARENB
);
374 termios
.c_cflag
|= CLOCAL
| CS8
;
375 termios
.c_cc
[VMIN
] = 1;
376 termios
.c_cc
[VTIME
] = 0;
378 tcsetattr (remote_desc
, TCSANOW
, &termios
);
382 fprintf (stderr
, "Remote debugging using %s\n", name
);
384 enable_async_notification (remote_desc
);
386 /* Register the event loop handler. */
387 add_file_handler (remote_desc
, handle_serial_event
, NULL
);
389 #endif /* USE_WIN32API */
392 char listen_port
[GDB_NI_MAX_PORT
];
393 struct sockaddr_storage sockaddr
;
394 socklen_t len
= sizeof (sockaddr
);
396 if (getsockname (listen_desc
, (struct sockaddr
*) &sockaddr
, &len
) < 0)
397 perror_with_name ("Can't determine port");
399 int r
= getnameinfo ((struct sockaddr
*) &sockaddr
, len
,
401 listen_port
, sizeof (listen_port
),
405 fprintf (stderr
, _("Can't obtain port where we are listening: %s"),
408 fprintf (stderr
, _("Listening on port %s\n"), listen_port
);
412 /* Register the event loop handler. */
413 add_file_handler (listen_desc
, handle_accept_event
, NULL
);
420 delete_file_handler (remote_desc
);
425 closesocket (remote_desc
);
427 if (! remote_connection_is_stdio ())
430 remote_desc
= INVALID_DESCRIPTOR
;
437 #ifndef IN_PROCESS_AGENT
440 decode_address (CORE_ADDR
*addrp
, const char *start
, int len
)
447 for (i
= 0; i
< len
; i
++)
451 addr
= addr
| (fromhex (ch
) & 0x0f);
457 decode_address_to_semicolon (CORE_ADDR
*addrp
, const char *start
)
462 while (*end
!= '\0' && *end
!= ';')
465 decode_address (addrp
, start
, end
- start
);
474 #ifndef IN_PROCESS_AGENT
476 /* Look for a sequence of characters which can be run-length encoded.
477 If there are any, update *CSUM and *P. Otherwise, output the
478 single character. Return the number of characters consumed. */
481 try_rle (char *buf
, int remaining
, unsigned char *csum
, char **p
)
485 /* Always output the character. */
489 /* Don't go past '~'. */
493 for (n
= 1; n
< remaining
; n
++)
494 if (buf
[n
] != buf
[0])
497 /* N is the index of the first character not the same as buf[0].
498 buf[0] is counted twice, so by decrementing N, we get the number
499 of characters the RLE sequence will replace. */
505 /* Skip the frame characters. The manual says to skip '+' and '-'
506 also, but there's no reason to. Unfortunately these two unusable
507 characters double the encoded length of a four byte zero
509 while (n
+ 29 == '$' || n
+ 29 == '#')
522 #ifndef IN_PROCESS_AGENT
524 /* Write a PTID to BUF. Returns BUF+CHARACTERS_WRITTEN. */
527 write_ptid (char *buf
, ptid_t ptid
)
529 client_state
&cs
= get_client_state ();
532 if (cs
.multi_process
)
536 buf
+= sprintf (buf
, "p-%x.", -pid
);
538 buf
+= sprintf (buf
, "p%x.", pid
);
542 buf
+= sprintf (buf
, "-%x", -tid
);
544 buf
+= sprintf (buf
, "%x", tid
);
550 hex_or_minus_one (const char *buf
, const char **obuf
)
554 if (startswith (buf
, "-1"))
560 buf
= unpack_varlen_hex (buf
, &ret
);
568 /* Extract a PTID from BUF. If non-null, OBUF is set to the to one
569 passed the last parsed char. Returns null_ptid on error. */
571 read_ptid (const char *buf
, const char **obuf
)
575 ULONGEST pid
= 0, tid
= 0;
579 /* Multi-process ptid. */
580 pp
= unpack_varlen_hex (p
+ 1, &pid
);
582 error ("invalid remote ptid: %s\n", p
);
586 tid
= hex_or_minus_one (p
, &pp
);
590 return ptid_t (pid
, tid
, 0);
593 /* No multi-process. Just a tid. */
594 tid
= hex_or_minus_one (p
, &pp
);
596 /* Since GDB is not sending a process id (multi-process extensions
597 are off), then there's only one process. Default to the first in
599 pid
= pid_of (get_first_process ());
603 return ptid_t (pid
, tid
, 0);
606 /* Write COUNT bytes in BUF to the client.
607 The result is the number of bytes written or -1 if error.
608 This may return less than COUNT. */
611 write_prim (const void *buf
, int count
)
613 if (remote_connection_is_stdio ())
614 return write (fileno (stdout
), buf
, count
);
616 return write (remote_desc
, buf
, count
);
619 /* Read COUNT bytes from the client and store in BUF.
620 The result is the number of bytes read or -1 if error.
621 This may return less than COUNT. */
624 read_prim (void *buf
, int count
)
626 if (remote_connection_is_stdio ())
627 return read (fileno (stdin
), buf
, count
);
629 return read (remote_desc
, buf
, count
);
632 /* Send a packet to the remote machine, with error checking.
633 The data of the packet is in BUF, and the length of the
634 packet is in CNT. Returns >= 0 on success, -1 otherwise. */
637 putpkt_binary_1 (char *buf
, int cnt
, int is_notif
)
639 client_state
&cs
= get_client_state ();
641 unsigned char csum
= 0;
646 buf2
= (char *) xmalloc (strlen ("$") + cnt
+ strlen ("#nn") + 1);
648 /* Copy the packet into buffer BUF2, encapsulating it
649 and giving it a checksum. */
657 for (i
= 0; i
< cnt
;)
658 i
+= try_rle (buf
+ i
, cnt
- i
, &csum
, &p
);
661 *p
++ = tohex ((csum
>> 4) & 0xf);
662 *p
++ = tohex (csum
& 0xf);
666 /* Send it over and over until we get a positive ack. */
670 if (write_prim (buf2
, p
- buf2
) != p
- buf2
)
672 perror ("putpkt(write)");
677 if (cs
.noack_mode
|| is_notif
)
679 /* Don't expect an ack then. */
683 debug_printf ("putpkt (\"%s\"); [notif]\n", buf2
);
685 debug_printf ("putpkt (\"%s\"); [noack mode]\n", buf2
);
693 debug_printf ("putpkt (\"%s\"); [looking for ack]\n", buf2
);
707 debug_printf ("[received '%c' (0x%x)]\n", cc
, cc
);
711 /* Check for an input interrupt while we're here. */
712 if (cc
== '\003' && current_thread
!= NULL
)
713 (*the_target
->request_interrupt
) ();
718 return 1; /* Success! */
722 putpkt_binary (char *buf
, int cnt
)
724 return putpkt_binary_1 (buf
, cnt
, 0);
727 /* Send a packet to the remote machine, with error checking. The data
728 of the packet is in BUF, and the packet should be a NUL-terminated
729 string. Returns >= 0 on success, -1 otherwise. */
734 return putpkt_binary (buf
, strlen (buf
));
738 putpkt_notif (char *buf
)
740 return putpkt_binary_1 (buf
, strlen (buf
), 1);
743 /* Come here when we get an input interrupt from the remote side. This
744 interrupt should only be active while we are waiting for the child to do
745 something. Thus this assumes readchar:bufcnt is 0.
746 About the only thing that should come through is a ^C, which
747 will cause us to request child interruption. */
750 input_interrupt (int unused
)
753 struct timeval immediate
= { 0, 0 };
755 /* Protect against spurious interrupts. This has been observed to
756 be a problem under NetBSD 1.4 and 1.5. */
759 FD_SET (remote_desc
, &readset
);
760 if (select (remote_desc
+ 1, &readset
, 0, 0, &immediate
) > 0)
765 cc
= read_prim (&c
, 1);
769 fprintf (stderr
, "client connection closed\n");
772 else if (cc
!= 1 || c
!= '\003')
774 fprintf (stderr
, "input_interrupt, count = %d c = %d ", cc
, c
);
776 fprintf (stderr
, "('%c')\n", c
);
778 fprintf (stderr
, "('\\x%02x')\n", c
& 0xff);
782 (*the_target
->request_interrupt
) ();
786 /* Check if the remote side sent us an interrupt request (^C). */
788 check_remote_input_interrupt_request (void)
790 /* This function may be called before establishing communications,
791 therefore we need to validate the remote descriptor. */
793 if (remote_desc
== INVALID_DESCRIPTOR
)
799 /* Asynchronous I/O support. SIGIO must be unblocked when waiting,
800 in order to accept Control-C from the client, and must be blocked
801 when talking to the client. */
804 block_unblock_async_io (int block
)
809 sigemptyset (&sigio_set
);
810 sigaddset (&sigio_set
, SIGIO
);
811 gdb_sigmask (block
? SIG_BLOCK
: SIG_UNBLOCK
, &sigio_set
, NULL
);
817 nto_comctrl (int enable
)
819 struct sigevent event
;
823 event
.sigev_notify
= SIGEV_SIGNAL_THREAD
;
824 event
.sigev_signo
= SIGIO
;
825 event
.sigev_code
= 0;
826 event
.sigev_value
.sival_ptr
= NULL
;
827 event
.sigev_priority
= -1;
828 ionotify (remote_desc
, _NOTIFY_ACTION_POLLARM
, _NOTIFY_COND_INPUT
,
832 ionotify (remote_desc
, _NOTIFY_ACTION_POLL
, _NOTIFY_COND_INPUT
, NULL
);
837 /* Current state of asynchronous I/O. */
838 static int async_io_enabled
;
840 /* Enable asynchronous I/O. */
842 enable_async_io (void)
844 if (async_io_enabled
)
847 block_unblock_async_io (0);
849 async_io_enabled
= 1;
855 /* Disable asynchronous I/O. */
857 disable_async_io (void)
859 if (!async_io_enabled
)
862 block_unblock_async_io (1);
864 async_io_enabled
= 0;
872 initialize_async_io (void)
874 /* Make sure that async I/O starts blocked. */
875 async_io_enabled
= 1;
878 /* Install the signal handler. */
880 signal (SIGIO
, input_interrupt
);
884 /* Internal buffer used by readchar.
885 These are global to readchar because reschedule_remote needs to be
886 able to tell whether the buffer is empty. */
888 static unsigned char readchar_buf
[BUFSIZ
];
889 static int readchar_bufcnt
= 0;
890 static unsigned char *readchar_bufp
;
892 /* Returns next char from remote GDB. -1 if error. */
899 if (readchar_bufcnt
== 0)
901 readchar_bufcnt
= read_prim (readchar_buf
, sizeof (readchar_buf
));
903 if (readchar_bufcnt
<= 0)
905 if (readchar_bufcnt
== 0)
908 debug_printf ("readchar: Got EOF\n");
916 readchar_bufp
= readchar_buf
;
920 ch
= *readchar_bufp
++;
925 /* Reset the readchar state machine. */
928 reset_readchar (void)
931 if (readchar_callback
!= NOT_SCHEDULED
)
933 delete_callback_event (readchar_callback
);
934 readchar_callback
= NOT_SCHEDULED
;
938 /* Process remaining data in readchar_buf. */
941 process_remaining (void *context
)
945 /* This is a one-shot event. */
946 readchar_callback
= NOT_SCHEDULED
;
948 if (readchar_bufcnt
> 0)
949 res
= handle_serial_event (0, NULL
);
956 /* If there is still data in the buffer, queue another event to process it,
957 we can't sleep in select yet. */
962 if (readchar_bufcnt
> 0 && readchar_callback
== NOT_SCHEDULED
)
963 readchar_callback
= append_callback_event (process_remaining
, NULL
);
966 /* Read a packet from the remote machine, with error checking,
967 and store it in BUF. Returns length of packet, or negative if error. */
972 client_state
&cs
= get_client_state ();
974 unsigned char csum
, c1
, c2
;
985 /* The '\003' may appear before or after each packet, so
986 check for an input interrupt. */
989 (*the_target
->request_interrupt
) ();
997 debug_printf ("[getpkt: discarding char '%c']\n", c
);
1018 c1
= fromhex (readchar ());
1019 c2
= fromhex (readchar ());
1021 if (csum
== (c1
<< 4) + c2
)
1027 "Bad checksum, sentsum=0x%x, csum=0x%x, "
1028 "buf=%s [no-ack-mode, Bad medium?]\n",
1029 (c1
<< 4) + c2
, csum
, buf
);
1030 /* Not much we can do, GDB wasn't expecting an ack/nac. */
1034 fprintf (stderr
, "Bad checksum, sentsum=0x%x, csum=0x%x, buf=%s\n",
1035 (c1
<< 4) + c2
, csum
, buf
);
1036 if (write_prim ("-", 1) != 1)
1044 debug_printf ("getpkt (\"%s\"); [sending ack] \n", buf
);
1048 if (write_prim ("+", 1) != 1)
1053 debug_printf ("[sent ack]\n");
1061 debug_printf ("getpkt (\"%s\"); [no ack sent] \n", buf
);
1066 /* The readchar above may have already read a '\003' out of the socket
1067 and moved it to the local buffer. For example, when GDB sends
1068 vCont;c immediately followed by interrupt (see
1069 gdb.base/interrupt-noterm.exp). As soon as we see the vCont;c, we'll
1070 resume the inferior and wait. Since we've already moved the '\003'
1071 to the local buffer, SIGIO won't help. In that case, if we don't
1072 check for interrupt after the vCont;c packet, the interrupt character
1073 would stay in the buffer unattended until after the next (unrelated)
1075 while (readchar_bufcnt
> 0 && *readchar_bufp
== '\003')
1077 /* Consume the interrupt character in the buffer. */
1079 (*the_target
->request_interrupt
) ();
1086 write_ok (char *buf
)
1094 write_enn (char *buf
)
1096 /* Some day, we should define the meanings of the error codes... */
1105 #ifndef IN_PROCESS_AGENT
1108 outreg (struct regcache
*regcache
, int regno
, char *buf
)
1110 if ((regno
>> 12) != 0)
1111 *buf
++ = tohex ((regno
>> 12) & 0xf);
1112 if ((regno
>> 8) != 0)
1113 *buf
++ = tohex ((regno
>> 8) & 0xf);
1114 *buf
++ = tohex ((regno
>> 4) & 0xf);
1115 *buf
++ = tohex (regno
& 0xf);
1117 collect_register_as_string (regcache
, regno
, buf
);
1118 buf
+= 2 * register_size (regcache
->tdesc
, regno
);
1125 prepare_resume_reply (char *buf
, ptid_t ptid
,
1126 struct target_waitstatus
*status
)
1128 client_state
&cs
= get_client_state ();
1130 debug_printf ("Writing resume reply for %s:%d\n",
1131 target_pid_to_str (ptid
), status
->kind
);
1133 switch (status
->kind
)
1135 case TARGET_WAITKIND_STOPPED
:
1136 case TARGET_WAITKIND_FORKED
:
1137 case TARGET_WAITKIND_VFORKED
:
1138 case TARGET_WAITKIND_VFORK_DONE
:
1139 case TARGET_WAITKIND_EXECD
:
1140 case TARGET_WAITKIND_THREAD_CREATED
:
1141 case TARGET_WAITKIND_SYSCALL_ENTRY
:
1142 case TARGET_WAITKIND_SYSCALL_RETURN
:
1144 struct thread_info
*saved_thread
;
1146 struct regcache
*regcache
;
1148 if ((status
->kind
== TARGET_WAITKIND_FORKED
&& cs
.report_fork_events
)
1149 || (status
->kind
== TARGET_WAITKIND_VFORKED
1150 && cs
.report_vfork_events
))
1152 enum gdb_signal signal
= GDB_SIGNAL_TRAP
;
1153 const char *event
= (status
->kind
== TARGET_WAITKIND_FORKED
1154 ? "fork" : "vfork");
1156 sprintf (buf
, "T%02x%s:", signal
, event
);
1157 buf
+= strlen (buf
);
1158 buf
= write_ptid (buf
, status
->value
.related_pid
);
1161 else if (status
->kind
== TARGET_WAITKIND_VFORK_DONE
1162 && cs
.report_vfork_events
)
1164 enum gdb_signal signal
= GDB_SIGNAL_TRAP
;
1166 sprintf (buf
, "T%02xvforkdone:;", signal
);
1168 else if (status
->kind
== TARGET_WAITKIND_EXECD
&& cs
.report_exec_events
)
1170 enum gdb_signal signal
= GDB_SIGNAL_TRAP
;
1171 const char *event
= "exec";
1172 char hexified_pathname
[PATH_MAX
* 2];
1174 sprintf (buf
, "T%02x%s:", signal
, event
);
1175 buf
+= strlen (buf
);
1177 /* Encode pathname to hexified format. */
1178 bin2hex ((const gdb_byte
*) status
->value
.execd_pathname
,
1180 strlen (status
->value
.execd_pathname
));
1182 sprintf (buf
, "%s;", hexified_pathname
);
1183 xfree (status
->value
.execd_pathname
);
1184 status
->value
.execd_pathname
= NULL
;
1185 buf
+= strlen (buf
);
1187 else if (status
->kind
== TARGET_WAITKIND_THREAD_CREATED
1188 && cs
.report_thread_events
)
1190 enum gdb_signal signal
= GDB_SIGNAL_TRAP
;
1192 sprintf (buf
, "T%02xcreate:;", signal
);
1194 else if (status
->kind
== TARGET_WAITKIND_SYSCALL_ENTRY
1195 || status
->kind
== TARGET_WAITKIND_SYSCALL_RETURN
)
1197 enum gdb_signal signal
= GDB_SIGNAL_TRAP
;
1198 const char *event
= (status
->kind
== TARGET_WAITKIND_SYSCALL_ENTRY
1199 ? "syscall_entry" : "syscall_return");
1201 sprintf (buf
, "T%02x%s:%x;", signal
, event
,
1202 status
->value
.syscall_number
);
1205 sprintf (buf
, "T%02x", status
->value
.sig
);
1207 buf
+= strlen (buf
);
1209 saved_thread
= current_thread
;
1211 switch_to_thread (ptid
);
1213 regp
= current_target_desc ()->expedite_regs
;
1215 regcache
= get_thread_regcache (current_thread
, 1);
1217 if (the_target
->stopped_by_watchpoint
!= NULL
1218 && (*the_target
->stopped_by_watchpoint
) ())
1223 memcpy (buf
, "watch:", 6);
1226 addr
= (*the_target
->stopped_data_address
) ();
1228 /* Convert each byte of the address into two hexadecimal
1229 chars. Note that we take sizeof (void *) instead of
1230 sizeof (addr); this is to avoid sending a 64-bit
1231 address to a 32-bit GDB. */
1232 for (i
= sizeof (void *) * 2; i
> 0; i
--)
1233 *buf
++ = tohex ((addr
>> (i
- 1) * 4) & 0xf);
1236 else if (cs
.swbreak_feature
&& target_stopped_by_sw_breakpoint ())
1238 sprintf (buf
, "swbreak:;");
1239 buf
+= strlen (buf
);
1241 else if (cs
.hwbreak_feature
&& target_stopped_by_hw_breakpoint ())
1243 sprintf (buf
, "hwbreak:;");
1244 buf
+= strlen (buf
);
1249 buf
= outreg (regcache
, find_regno (regcache
->tdesc
, *regp
), buf
);
1254 /* Formerly, if the debugger had not used any thread features
1255 we would not burden it with a thread status response. This
1256 was for the benefit of GDB 4.13 and older. However, in
1257 recent GDB versions the check (``if (cont_thread != 0)'')
1258 does not have the desired effect because of sillyness in
1259 the way that the remote protocol handles specifying a
1260 thread. Since thread support relies on qSymbol support
1261 anyway, assume GDB can handle threads. */
1263 if (using_threads
&& !disable_packet_Tthread
)
1265 /* This if (1) ought to be unnecessary. But remote_wait
1266 in GDB will claim this event belongs to inferior_ptid
1267 if we do not specify a thread, and there's no way for
1268 gdbserver to know what inferior_ptid is. */
1269 if (1 || cs
.general_thread
!= ptid
)
1272 /* In non-stop, don't change the general thread behind
1275 cs
.general_thread
= ptid
;
1276 sprintf (buf
, "thread:");
1277 buf
+= strlen (buf
);
1278 buf
= write_ptid (buf
, ptid
);
1280 buf
+= strlen (buf
);
1282 core
= target_core_of_thread (ptid
);
1286 sprintf (buf
, "core:");
1287 buf
+= strlen (buf
);
1288 sprintf (buf
, "%x", core
);
1290 buf
+= strlen (buf
);
1297 strcpy (buf
, "library:;");
1298 buf
+= strlen (buf
);
1302 current_thread
= saved_thread
;
1305 case TARGET_WAITKIND_EXITED
:
1306 if (cs
.multi_process
)
1307 sprintf (buf
, "W%x;process:%x",
1308 status
->value
.integer
, ptid
.pid ());
1310 sprintf (buf
, "W%02x", status
->value
.integer
);
1312 case TARGET_WAITKIND_SIGNALLED
:
1313 if (cs
.multi_process
)
1314 sprintf (buf
, "X%x;process:%x",
1315 status
->value
.sig
, ptid
.pid ());
1317 sprintf (buf
, "X%02x", status
->value
.sig
);
1319 case TARGET_WAITKIND_THREAD_EXITED
:
1320 sprintf (buf
, "w%x;", status
->value
.integer
);
1321 buf
+= strlen (buf
);
1322 buf
= write_ptid (buf
, ptid
);
1324 case TARGET_WAITKIND_NO_RESUMED
:
1328 error ("unhandled waitkind");
1334 decode_m_packet (char *from
, CORE_ADDR
*mem_addr_ptr
, unsigned int *len_ptr
)
1338 *mem_addr_ptr
= *len_ptr
= 0;
1340 while ((ch
= from
[i
++]) != ',')
1342 *mem_addr_ptr
= *mem_addr_ptr
<< 4;
1343 *mem_addr_ptr
|= fromhex (ch
) & 0x0f;
1346 for (j
= 0; j
< 4; j
++)
1348 if ((ch
= from
[i
++]) == 0)
1350 *len_ptr
= *len_ptr
<< 4;
1351 *len_ptr
|= fromhex (ch
) & 0x0f;
1356 decode_M_packet (char *from
, CORE_ADDR
*mem_addr_ptr
, unsigned int *len_ptr
,
1357 unsigned char **to_p
)
1361 *mem_addr_ptr
= *len_ptr
= 0;
1363 while ((ch
= from
[i
++]) != ',')
1365 *mem_addr_ptr
= *mem_addr_ptr
<< 4;
1366 *mem_addr_ptr
|= fromhex (ch
) & 0x0f;
1369 while ((ch
= from
[i
++]) != ':')
1371 *len_ptr
= *len_ptr
<< 4;
1372 *len_ptr
|= fromhex (ch
) & 0x0f;
1376 *to_p
= (unsigned char *) xmalloc (*len_ptr
);
1378 hex2bin (&from
[i
++], *to_p
, *len_ptr
);
1382 decode_X_packet (char *from
, int packet_len
, CORE_ADDR
*mem_addr_ptr
,
1383 unsigned int *len_ptr
, unsigned char **to_p
)
1387 *mem_addr_ptr
= *len_ptr
= 0;
1389 while ((ch
= from
[i
++]) != ',')
1391 *mem_addr_ptr
= *mem_addr_ptr
<< 4;
1392 *mem_addr_ptr
|= fromhex (ch
) & 0x0f;
1395 while ((ch
= from
[i
++]) != ':')
1397 *len_ptr
= *len_ptr
<< 4;
1398 *len_ptr
|= fromhex (ch
) & 0x0f;
1402 *to_p
= (unsigned char *) xmalloc (*len_ptr
);
1404 if (remote_unescape_input ((const gdb_byte
*) &from
[i
], packet_len
- i
,
1405 *to_p
, *len_ptr
) != *len_ptr
)
1411 /* Decode a qXfer write request. */
1414 decode_xfer_write (char *buf
, int packet_len
, CORE_ADDR
*offset
,
1415 unsigned int *len
, unsigned char *data
)
1420 /* Extract the offset. */
1422 while ((ch
= *buf
++) != ':')
1424 *offset
= *offset
<< 4;
1425 *offset
|= fromhex (ch
) & 0x0f;
1428 /* Get encoded data. */
1429 packet_len
-= buf
- b
;
1430 *len
= remote_unescape_input ((const gdb_byte
*) buf
, packet_len
,
1435 /* Decode the parameters of a qSearch:memory packet. */
1438 decode_search_memory_packet (const char *buf
, int packet_len
,
1439 CORE_ADDR
*start_addrp
,
1440 CORE_ADDR
*search_space_lenp
,
1441 gdb_byte
*pattern
, unsigned int *pattern_lenp
)
1443 const char *p
= buf
;
1445 p
= decode_address_to_semicolon (start_addrp
, p
);
1446 p
= decode_address_to_semicolon (search_space_lenp
, p
);
1447 packet_len
-= p
- buf
;
1448 *pattern_lenp
= remote_unescape_input ((const gdb_byte
*) p
, packet_len
,
1449 pattern
, packet_len
);
1454 free_sym_cache (struct sym_cache
*sym
)
1464 clear_symbol_cache (struct sym_cache
**symcache_p
)
1466 struct sym_cache
*sym
, *next
;
1468 /* Check the cache first. */
1469 for (sym
= *symcache_p
; sym
; sym
= next
)
1472 free_sym_cache (sym
);
1478 /* Get the address of NAME, and return it in ADDRP if found. if
1479 MAY_ASK_GDB is false, assume symbol cache misses are failures.
1480 Returns 1 if the symbol is found, 0 if it is not, -1 on error. */
1483 look_up_one_symbol (const char *name
, CORE_ADDR
*addrp
, int may_ask_gdb
)
1485 client_state
&cs
= get_client_state ();
1488 struct sym_cache
*sym
;
1489 struct process_info
*proc
;
1491 proc
= current_process ();
1493 /* Check the cache first. */
1494 for (sym
= proc
->symbol_cache
; sym
; sym
= sym
->next
)
1495 if (strcmp (name
, sym
->name
) == 0)
1501 /* It might not be an appropriate time to look up a symbol,
1502 e.g. while we're trying to fetch registers. */
1506 /* Send the request. */
1507 strcpy (cs
.own_buf
, "qSymbol:");
1508 bin2hex ((const gdb_byte
*) name
, cs
.own_buf
+ strlen ("qSymbol:"),
1510 if (putpkt (cs
.own_buf
) < 0)
1513 /* FIXME: Eventually add buffer overflow checking (to getpkt?) */
1514 len
= getpkt (cs
.own_buf
);
1518 /* We ought to handle pretty much any packet at this point while we
1519 wait for the qSymbol "response". That requires re-entering the
1520 main loop. For now, this is an adequate approximation; allow
1521 GDB to read from memory and handle 'v' packets (for vFile transfers)
1522 while it figures out the address of the symbol. */
1525 if (cs
.own_buf
[0] == 'm')
1528 unsigned char *mem_buf
;
1529 unsigned int mem_len
;
1531 decode_m_packet (&cs
.own_buf
[1], &mem_addr
, &mem_len
);
1532 mem_buf
= (unsigned char *) xmalloc (mem_len
);
1533 if (read_inferior_memory (mem_addr
, mem_buf
, mem_len
) == 0)
1534 bin2hex (mem_buf
, cs
.own_buf
, mem_len
);
1536 write_enn (cs
.own_buf
);
1538 if (putpkt (cs
.own_buf
) < 0)
1541 else if (cs
.own_buf
[0] == 'v')
1544 handle_v_requests (cs
.own_buf
, len
, &new_len
);
1546 putpkt_binary (cs
.own_buf
, new_len
);
1548 putpkt (cs
.own_buf
);
1552 len
= getpkt (cs
.own_buf
);
1557 if (!startswith (cs
.own_buf
, "qSymbol:"))
1559 warning ("Malformed response to qSymbol, ignoring: %s", cs
.own_buf
);
1563 p
= cs
.own_buf
+ strlen ("qSymbol:");
1565 while (*q
&& *q
!= ':')
1568 /* Make sure we found a value for the symbol. */
1569 if (p
== q
|| *q
== '\0')
1572 decode_address (addrp
, p
, q
- p
);
1574 /* Save the symbol in our cache. */
1575 sym
= XNEW (struct sym_cache
);
1576 sym
->name
= xstrdup (name
);
1578 sym
->next
= proc
->symbol_cache
;
1579 proc
->symbol_cache
= sym
;
1584 /* Relocate an instruction to execute at a different address. OLDLOC
1585 is the address in the inferior memory where the instruction to
1586 relocate is currently at. On input, TO points to the destination
1587 where we want the instruction to be copied (and possibly adjusted)
1588 to. On output, it points to one past the end of the resulting
1589 instruction(s). The effect of executing the instruction at TO
1590 shall be the same as if executing it at OLDLOC. For example, call
1591 instructions that implicitly push the return address on the stack
1592 should be adjusted to return to the instruction after OLDLOC;
1593 relative branches, and other PC-relative instructions need the
1594 offset adjusted; etc. Returns 0 on success, -1 on failure. */
1597 relocate_instruction (CORE_ADDR
*to
, CORE_ADDR oldloc
)
1599 client_state
&cs
= get_client_state ();
1601 ULONGEST written
= 0;
1603 /* Send the request. */
1604 sprintf (cs
.own_buf
, "qRelocInsn:%s;%s", paddress (oldloc
),
1606 if (putpkt (cs
.own_buf
) < 0)
1609 /* FIXME: Eventually add buffer overflow checking (to getpkt?) */
1610 len
= getpkt (cs
.own_buf
);
1614 /* We ought to handle pretty much any packet at this point while we
1615 wait for the qRelocInsn "response". That requires re-entering
1616 the main loop. For now, this is an adequate approximation; allow
1617 GDB to access memory. */
1618 while (cs
.own_buf
[0] == 'm' || cs
.own_buf
[0] == 'M' || cs
.own_buf
[0] == 'X')
1621 unsigned char *mem_buf
= NULL
;
1622 unsigned int mem_len
;
1624 if (cs
.own_buf
[0] == 'm')
1626 decode_m_packet (&cs
.own_buf
[1], &mem_addr
, &mem_len
);
1627 mem_buf
= (unsigned char *) xmalloc (mem_len
);
1628 if (read_inferior_memory (mem_addr
, mem_buf
, mem_len
) == 0)
1629 bin2hex (mem_buf
, cs
.own_buf
, mem_len
);
1631 write_enn (cs
.own_buf
);
1633 else if (cs
.own_buf
[0] == 'X')
1635 if (decode_X_packet (&cs
.own_buf
[1], len
- 1, &mem_addr
,
1636 &mem_len
, &mem_buf
) < 0
1637 || target_write_memory (mem_addr
, mem_buf
, mem_len
) != 0)
1638 write_enn (cs
.own_buf
);
1640 write_ok (cs
.own_buf
);
1644 decode_M_packet (&cs
.own_buf
[1], &mem_addr
, &mem_len
, &mem_buf
);
1645 if (target_write_memory (mem_addr
, mem_buf
, mem_len
) == 0)
1646 write_ok (cs
.own_buf
);
1648 write_enn (cs
.own_buf
);
1651 if (putpkt (cs
.own_buf
) < 0)
1653 len
= getpkt (cs
.own_buf
);
1658 if (cs
.own_buf
[0] == 'E')
1660 warning ("An error occurred while relocating an instruction: %s",
1665 if (!startswith (cs
.own_buf
, "qRelocInsn:"))
1667 warning ("Malformed response to qRelocInsn, ignoring: %s",
1672 unpack_varlen_hex (cs
.own_buf
+ strlen ("qRelocInsn:"), &written
);
1679 monitor_output (const char *msg
)
1681 int len
= strlen (msg
);
1682 char *buf
= (char *) xmalloc (len
* 2 + 2);
1685 bin2hex ((const gdb_byte
*) msg
, buf
+ 1, len
);