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 if (disable_packet_T
)
1209 /* This is a bit (OK, a lot) of a kludge, however, this isn't
1210 really a user feature, but exists only so GDB can use the
1211 gdbserver to test handling of the 'S' stop reply packet, so
1212 we would rather this code be as simple as possible.
1214 By this point we've started to build the 'T' stop packet,
1215 and it should look like 'Txx....' where 'x' is a hex digit.
1216 An 'S' stop packet always looks like 'Sxx', so all we do
1217 here is convert the buffer from a T packet to an S packet
1218 and the avoid adding any extra content by breaking out. */
1219 gdb_assert (*buf
== 'T');
1220 gdb_assert (isxdigit (*(buf
+ 1)));
1221 gdb_assert (isxdigit (*(buf
+ 2)));
1227 buf
+= strlen (buf
);
1229 saved_thread
= current_thread
;
1231 switch_to_thread (the_target
, ptid
);
1233 regp
= current_target_desc ()->expedite_regs
;
1235 regcache
= get_thread_regcache (current_thread
, 1);
1237 if (the_target
->stopped_by_watchpoint ())
1242 memcpy (buf
, "watch:", 6);
1245 addr
= the_target
->stopped_data_address ();
1247 /* Convert each byte of the address into two hexadecimal
1248 chars. Note that we take sizeof (void *) instead of
1249 sizeof (addr); this is to avoid sending a 64-bit
1250 address to a 32-bit GDB. */
1251 for (i
= sizeof (void *) * 2; i
> 0; i
--)
1252 *buf
++ = tohex ((addr
>> (i
- 1) * 4) & 0xf);
1255 else if (cs
.swbreak_feature
&& target_stopped_by_sw_breakpoint ())
1257 sprintf (buf
, "swbreak:;");
1258 buf
+= strlen (buf
);
1260 else if (cs
.hwbreak_feature
&& target_stopped_by_hw_breakpoint ())
1262 sprintf (buf
, "hwbreak:;");
1263 buf
+= strlen (buf
);
1268 buf
= outreg (regcache
, find_regno (regcache
->tdesc
, *regp
), buf
);
1273 /* Formerly, if the debugger had not used any thread features
1274 we would not burden it with a thread status response. This
1275 was for the benefit of GDB 4.13 and older. However, in
1276 recent GDB versions the check (``if (cont_thread != 0)'')
1277 does not have the desired effect because of sillyness in
1278 the way that the remote protocol handles specifying a
1279 thread. Since thread support relies on qSymbol support
1280 anyway, assume GDB can handle threads. */
1282 if (using_threads
&& !disable_packet_Tthread
)
1284 /* This if (1) ought to be unnecessary. But remote_wait
1285 in GDB will claim this event belongs to inferior_ptid
1286 if we do not specify a thread, and there's no way for
1287 gdbserver to know what inferior_ptid is. */
1288 if (1 || cs
.general_thread
!= ptid
)
1291 /* In non-stop, don't change the general thread behind
1294 cs
.general_thread
= ptid
;
1295 sprintf (buf
, "thread:");
1296 buf
+= strlen (buf
);
1297 buf
= write_ptid (buf
, ptid
);
1299 buf
+= strlen (buf
);
1301 core
= target_core_of_thread (ptid
);
1305 sprintf (buf
, "core:");
1306 buf
+= strlen (buf
);
1307 sprintf (buf
, "%x", core
);
1309 buf
+= strlen (buf
);
1316 strcpy (buf
, "library:;");
1317 buf
+= strlen (buf
);
1321 current_thread
= saved_thread
;
1324 case TARGET_WAITKIND_EXITED
:
1325 if (cs
.multi_process
)
1326 sprintf (buf
, "W%x;process:%x",
1327 status
->value
.integer
, ptid
.pid ());
1329 sprintf (buf
, "W%02x", status
->value
.integer
);
1331 case TARGET_WAITKIND_SIGNALLED
:
1332 if (cs
.multi_process
)
1333 sprintf (buf
, "X%x;process:%x",
1334 status
->value
.sig
, ptid
.pid ());
1336 sprintf (buf
, "X%02x", status
->value
.sig
);
1338 case TARGET_WAITKIND_THREAD_EXITED
:
1339 sprintf (buf
, "w%x;", status
->value
.integer
);
1340 buf
+= strlen (buf
);
1341 buf
= write_ptid (buf
, ptid
);
1343 case TARGET_WAITKIND_NO_RESUMED
:
1347 error ("unhandled waitkind");
1353 decode_m_packet (char *from
, CORE_ADDR
*mem_addr_ptr
, unsigned int *len_ptr
)
1357 *mem_addr_ptr
= *len_ptr
= 0;
1359 while ((ch
= from
[i
++]) != ',')
1361 *mem_addr_ptr
= *mem_addr_ptr
<< 4;
1362 *mem_addr_ptr
|= fromhex (ch
) & 0x0f;
1365 for (j
= 0; j
< 4; j
++)
1367 if ((ch
= from
[i
++]) == 0)
1369 *len_ptr
= *len_ptr
<< 4;
1370 *len_ptr
|= fromhex (ch
) & 0x0f;
1375 decode_M_packet (char *from
, CORE_ADDR
*mem_addr_ptr
, unsigned int *len_ptr
,
1376 unsigned char **to_p
)
1380 *mem_addr_ptr
= *len_ptr
= 0;
1382 while ((ch
= from
[i
++]) != ',')
1384 *mem_addr_ptr
= *mem_addr_ptr
<< 4;
1385 *mem_addr_ptr
|= fromhex (ch
) & 0x0f;
1388 while ((ch
= from
[i
++]) != ':')
1390 *len_ptr
= *len_ptr
<< 4;
1391 *len_ptr
|= fromhex (ch
) & 0x0f;
1395 *to_p
= (unsigned char *) xmalloc (*len_ptr
);
1397 hex2bin (&from
[i
++], *to_p
, *len_ptr
);
1401 decode_X_packet (char *from
, int packet_len
, CORE_ADDR
*mem_addr_ptr
,
1402 unsigned int *len_ptr
, unsigned char **to_p
)
1406 *mem_addr_ptr
= *len_ptr
= 0;
1408 while ((ch
= from
[i
++]) != ',')
1410 *mem_addr_ptr
= *mem_addr_ptr
<< 4;
1411 *mem_addr_ptr
|= fromhex (ch
) & 0x0f;
1414 while ((ch
= from
[i
++]) != ':')
1416 *len_ptr
= *len_ptr
<< 4;
1417 *len_ptr
|= fromhex (ch
) & 0x0f;
1421 *to_p
= (unsigned char *) xmalloc (*len_ptr
);
1423 if (remote_unescape_input ((const gdb_byte
*) &from
[i
], packet_len
- i
,
1424 *to_p
, *len_ptr
) != *len_ptr
)
1430 /* Decode a qXfer write request. */
1433 decode_xfer_write (char *buf
, int packet_len
, CORE_ADDR
*offset
,
1434 unsigned int *len
, unsigned char *data
)
1439 /* Extract the offset. */
1441 while ((ch
= *buf
++) != ':')
1443 *offset
= *offset
<< 4;
1444 *offset
|= fromhex (ch
) & 0x0f;
1447 /* Get encoded data. */
1448 packet_len
-= buf
- b
;
1449 *len
= remote_unescape_input ((const gdb_byte
*) buf
, packet_len
,
1454 /* Decode the parameters of a qSearch:memory packet. */
1457 decode_search_memory_packet (const char *buf
, int packet_len
,
1458 CORE_ADDR
*start_addrp
,
1459 CORE_ADDR
*search_space_lenp
,
1460 gdb_byte
*pattern
, unsigned int *pattern_lenp
)
1462 const char *p
= buf
;
1464 p
= decode_address_to_semicolon (start_addrp
, p
);
1465 p
= decode_address_to_semicolon (search_space_lenp
, p
);
1466 packet_len
-= p
- buf
;
1467 *pattern_lenp
= remote_unescape_input ((const gdb_byte
*) p
, packet_len
,
1468 pattern
, packet_len
);
1473 free_sym_cache (struct sym_cache
*sym
)
1483 clear_symbol_cache (struct sym_cache
**symcache_p
)
1485 struct sym_cache
*sym
, *next
;
1487 /* Check the cache first. */
1488 for (sym
= *symcache_p
; sym
; sym
= next
)
1491 free_sym_cache (sym
);
1497 /* Get the address of NAME, and return it in ADDRP if found. if
1498 MAY_ASK_GDB is false, assume symbol cache misses are failures.
1499 Returns 1 if the symbol is found, 0 if it is not, -1 on error. */
1502 look_up_one_symbol (const char *name
, CORE_ADDR
*addrp
, int may_ask_gdb
)
1504 client_state
&cs
= get_client_state ();
1507 struct sym_cache
*sym
;
1508 struct process_info
*proc
;
1510 proc
= current_process ();
1512 /* Check the cache first. */
1513 for (sym
= proc
->symbol_cache
; sym
; sym
= sym
->next
)
1514 if (strcmp (name
, sym
->name
) == 0)
1520 /* It might not be an appropriate time to look up a symbol,
1521 e.g. while we're trying to fetch registers. */
1525 /* Send the request. */
1526 strcpy (cs
.own_buf
, "qSymbol:");
1527 bin2hex ((const gdb_byte
*) name
, cs
.own_buf
+ strlen ("qSymbol:"),
1529 if (putpkt (cs
.own_buf
) < 0)
1532 /* FIXME: Eventually add buffer overflow checking (to getpkt?) */
1533 len
= getpkt (cs
.own_buf
);
1537 /* We ought to handle pretty much any packet at this point while we
1538 wait for the qSymbol "response". That requires re-entering the
1539 main loop. For now, this is an adequate approximation; allow
1540 GDB to read from memory and handle 'v' packets (for vFile transfers)
1541 while it figures out the address of the symbol. */
1544 if (cs
.own_buf
[0] == 'm')
1547 unsigned char *mem_buf
;
1548 unsigned int mem_len
;
1550 decode_m_packet (&cs
.own_buf
[1], &mem_addr
, &mem_len
);
1551 mem_buf
= (unsigned char *) xmalloc (mem_len
);
1552 if (read_inferior_memory (mem_addr
, mem_buf
, mem_len
) == 0)
1553 bin2hex (mem_buf
, cs
.own_buf
, mem_len
);
1555 write_enn (cs
.own_buf
);
1557 if (putpkt (cs
.own_buf
) < 0)
1560 else if (cs
.own_buf
[0] == 'v')
1563 handle_v_requests (cs
.own_buf
, len
, &new_len
);
1565 putpkt_binary (cs
.own_buf
, new_len
);
1567 putpkt (cs
.own_buf
);
1571 len
= getpkt (cs
.own_buf
);
1576 if (!startswith (cs
.own_buf
, "qSymbol:"))
1578 warning ("Malformed response to qSymbol, ignoring: %s", cs
.own_buf
);
1582 p
= cs
.own_buf
+ strlen ("qSymbol:");
1584 while (*q
&& *q
!= ':')
1587 /* Make sure we found a value for the symbol. */
1588 if (p
== q
|| *q
== '\0')
1591 decode_address (addrp
, p
, q
- p
);
1593 /* Save the symbol in our cache. */
1594 sym
= XNEW (struct sym_cache
);
1595 sym
->name
= xstrdup (name
);
1597 sym
->next
= proc
->symbol_cache
;
1598 proc
->symbol_cache
= sym
;
1603 /* Relocate an instruction to execute at a different address. OLDLOC
1604 is the address in the inferior memory where the instruction to
1605 relocate is currently at. On input, TO points to the destination
1606 where we want the instruction to be copied (and possibly adjusted)
1607 to. On output, it points to one past the end of the resulting
1608 instruction(s). The effect of executing the instruction at TO
1609 shall be the same as if executing it at OLDLOC. For example, call
1610 instructions that implicitly push the return address on the stack
1611 should be adjusted to return to the instruction after OLDLOC;
1612 relative branches, and other PC-relative instructions need the
1613 offset adjusted; etc. Returns 0 on success, -1 on failure. */
1616 relocate_instruction (CORE_ADDR
*to
, CORE_ADDR oldloc
)
1618 client_state
&cs
= get_client_state ();
1620 ULONGEST written
= 0;
1622 /* Send the request. */
1623 sprintf (cs
.own_buf
, "qRelocInsn:%s;%s", paddress (oldloc
),
1625 if (putpkt (cs
.own_buf
) < 0)
1628 /* FIXME: Eventually add buffer overflow checking (to getpkt?) */
1629 len
= getpkt (cs
.own_buf
);
1633 /* We ought to handle pretty much any packet at this point while we
1634 wait for the qRelocInsn "response". That requires re-entering
1635 the main loop. For now, this is an adequate approximation; allow
1636 GDB to access memory. */
1637 while (cs
.own_buf
[0] == 'm' || cs
.own_buf
[0] == 'M' || cs
.own_buf
[0] == 'X')
1640 unsigned char *mem_buf
= NULL
;
1641 unsigned int mem_len
;
1643 if (cs
.own_buf
[0] == 'm')
1645 decode_m_packet (&cs
.own_buf
[1], &mem_addr
, &mem_len
);
1646 mem_buf
= (unsigned char *) xmalloc (mem_len
);
1647 if (read_inferior_memory (mem_addr
, mem_buf
, mem_len
) == 0)
1648 bin2hex (mem_buf
, cs
.own_buf
, mem_len
);
1650 write_enn (cs
.own_buf
);
1652 else if (cs
.own_buf
[0] == 'X')
1654 if (decode_X_packet (&cs
.own_buf
[1], len
- 1, &mem_addr
,
1655 &mem_len
, &mem_buf
) < 0
1656 || target_write_memory (mem_addr
, mem_buf
, mem_len
) != 0)
1657 write_enn (cs
.own_buf
);
1659 write_ok (cs
.own_buf
);
1663 decode_M_packet (&cs
.own_buf
[1], &mem_addr
, &mem_len
, &mem_buf
);
1664 if (target_write_memory (mem_addr
, mem_buf
, mem_len
) == 0)
1665 write_ok (cs
.own_buf
);
1667 write_enn (cs
.own_buf
);
1670 if (putpkt (cs
.own_buf
) < 0)
1672 len
= getpkt (cs
.own_buf
);
1677 if (cs
.own_buf
[0] == 'E')
1679 warning ("An error occurred while relocating an instruction: %s",
1684 if (!startswith (cs
.own_buf
, "qRelocInsn:"))
1686 warning ("Malformed response to qRelocInsn, ignoring: %s",
1691 unpack_varlen_hex (cs
.own_buf
+ strlen ("qRelocInsn:"), &written
);
1698 monitor_output (const char *msg
)
1700 int len
= strlen (msg
);
1701 char *buf
= (char *) xmalloc (len
* 2 + 2);
1704 bin2hex ((const gdb_byte
*) msg
, buf
+ 1, len
);