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"
28 #include "gdbthread.h"
30 #include "filestuff.h"
33 #include <sys/ioctl.h>
39 #include <netinet/in.h>
42 #include <sys/socket.h>
47 #if HAVE_NETINET_TCP_H
48 #include <netinet/tcp.h>
51 #include <sys/ioctl.h>
59 #include "gdb_sys_time.h"
62 #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 int remote_debug
= 0;
110 struct ui_file
*gdb_stdlog
;
112 static int remote_is_stdio
= 0;
114 static gdb_fildes_t remote_desc
= INVALID_DESCRIPTOR
;
115 static gdb_fildes_t listen_desc
= INVALID_DESCRIPTOR
;
117 /* FIXME headerize? */
118 extern int using_threads
;
119 extern int debug_threads
;
122 # define read(fd, buf, len) recv (fd, (char *) buf, len, 0)
123 # define write(fd, buf, len) send (fd, (char *) buf, len, 0)
129 return remote_desc
!= INVALID_DESCRIPTOR
;
132 /* Return true if the remote connection is over stdio. */
135 remote_connection_is_stdio (void)
137 return remote_is_stdio
;
141 enable_async_notification (int fd
)
143 #if defined(F_SETFL) && defined (FASYNC)
144 int save_fcntl_flags
;
146 save_fcntl_flags
= fcntl (fd
, F_GETFL
, 0);
147 fcntl (fd
, F_SETFL
, save_fcntl_flags
| FASYNC
);
148 #if defined (F_SETOWN)
149 fcntl (fd
, F_SETOWN
, getpid ());
155 handle_accept_event (int err
, gdb_client_data client_data
)
157 struct sockaddr_storage sockaddr
;
158 socklen_t len
= sizeof (sockaddr
);
161 debug_printf ("handling possible accept event\n");
163 remote_desc
= accept (listen_desc
, (struct sockaddr
*) &sockaddr
, &len
);
164 if (remote_desc
== -1)
165 perror_with_name ("Accept failed");
167 /* Enable TCP keep alive process. */
169 setsockopt (remote_desc
, SOL_SOCKET
, SO_KEEPALIVE
,
170 (char *) &tmp
, sizeof (tmp
));
172 /* Tell TCP not to delay small packets. This greatly speeds up
173 interactive response. */
175 setsockopt (remote_desc
, IPPROTO_TCP
, TCP_NODELAY
,
176 (char *) &tmp
, sizeof (tmp
));
179 signal (SIGPIPE
, SIG_IGN
); /* If we don't do this, then gdbserver simply
180 exits when the remote side dies. */
186 close (listen_desc
); /* No longer need this */
188 closesocket (listen_desc
); /* No longer need this */
192 /* Even if !RUN_ONCE no longer notice new connections. Still keep the
193 descriptor open for add_file_handler to wait for a new connection. */
194 delete_file_handler (listen_desc
);
196 /* Convert IP address to string. */
197 char orig_host
[GDB_NI_MAX_ADDR
], orig_port
[GDB_NI_MAX_PORT
];
199 int r
= getnameinfo ((struct sockaddr
*) &sockaddr
, len
,
200 orig_host
, sizeof (orig_host
),
201 orig_port
, sizeof (orig_port
),
202 NI_NUMERICHOST
| NI_NUMERICSERV
);
205 fprintf (stderr
, _("Could not obtain remote address: %s\n"),
208 fprintf (stderr
, _("Remote debugging from host %s, port %s\n"),
209 orig_host
, orig_port
);
211 enable_async_notification (remote_desc
);
213 /* Register the event loop handler. */
214 add_file_handler (remote_desc
, handle_serial_event
, NULL
);
216 /* We have a new GDB connection now. If we were disconnected
217 tracing, there's a window where the target could report a stop
218 event to the event loop, and since we have a connection now, we'd
219 try to send vStopped notifications to GDB. But, don't do that
220 until GDB as selected all-stop/non-stop, and has queried the
221 threads' status ('?'). */
227 /* Prepare for a later connection to a remote debugger.
228 NAME is the filename used for communication. */
231 remote_prepare (const char *name
)
233 client_state
&cs
= get_client_state ();
235 static int winsock_initialized
;
240 if (strcmp (name
, STDIO_CONNECTION_NAME
) == 0)
242 /* We need to record fact that we're using stdio sooner than the
243 call to remote_open so start_inferior knows the connection is
246 cs
.transport_is_reliable
= 1;
250 struct addrinfo hint
;
251 struct addrinfo
*ainfo
;
253 memset (&hint
, 0, sizeof (hint
));
254 /* Assume no prefix will be passed, therefore we should use
256 hint
.ai_family
= AF_UNSPEC
;
257 hint
.ai_socktype
= SOCK_STREAM
;
258 hint
.ai_protocol
= IPPROTO_TCP
;
260 parsed_connection_spec parsed
261 = parse_connection_spec_without_prefix (name
, &hint
);
263 if (parsed
.port_str
.empty ())
265 cs
.transport_is_reliable
= 0;
270 if (!winsock_initialized
)
274 WSAStartup (MAKEWORD (1, 0), &wsad
);
275 winsock_initialized
= 1;
279 int r
= getaddrinfo (parsed
.host_str
.c_str (), parsed
.port_str
.c_str (),
283 error (_("%s: cannot resolve name: %s"), name
, gai_strerror (r
));
285 scoped_free_addrinfo
freeaddrinfo (ainfo
);
287 struct addrinfo
*iter
;
289 for (iter
= ainfo
; iter
!= NULL
; iter
= iter
->ai_next
)
291 listen_desc
= gdb_socket_cloexec (iter
->ai_family
, iter
->ai_socktype
,
294 if (listen_desc
>= 0)
299 perror_with_name ("Can't open socket");
301 /* Allow rapid reuse of this port. */
303 setsockopt (listen_desc
, SOL_SOCKET
, SO_REUSEADDR
, (char *) &tmp
,
306 switch (iter
->ai_family
)
309 ((struct sockaddr_in
*) iter
->ai_addr
)->sin_addr
.s_addr
= INADDR_ANY
;
312 ((struct sockaddr_in6
*) iter
->ai_addr
)->sin6_addr
= in6addr_any
;
315 internal_error (__FILE__
, __LINE__
,
316 _("Invalid 'ai_family' %d\n"), iter
->ai_family
);
319 if (bind (listen_desc
, iter
->ai_addr
, iter
->ai_addrlen
) != 0)
320 perror_with_name ("Can't bind address");
322 if (listen (listen_desc
, 1) != 0)
323 perror_with_name ("Can't listen on socket");
325 cs
.transport_is_reliable
= 1;
328 /* Open a connection to a remote debugger.
329 NAME is the filename used for communication. */
332 remote_open (const char *name
)
334 const char *port_str
;
336 port_str
= strchr (name
, ':');
338 if (port_str
== NULL
)
339 error ("Only HOST:PORT is supported on this platform.");
342 if (strcmp (name
, STDIO_CONNECTION_NAME
) == 0)
344 fprintf (stderr
, "Remote debugging using stdio\n");
346 /* Use stdin as the handle of the connection.
347 We only select on reads, for example. */
348 remote_desc
= fileno (stdin
);
350 enable_async_notification (remote_desc
);
352 /* Register the event loop handler. */
353 add_file_handler (remote_desc
, handle_serial_event
, NULL
);
356 else if (port_str
== NULL
)
360 if (stat (name
, &statbuf
) == 0
361 && (S_ISCHR (statbuf
.st_mode
) || S_ISFIFO (statbuf
.st_mode
)))
362 remote_desc
= open (name
, O_RDWR
);
370 perror_with_name ("Could not open remote device");
374 struct termios termios
;
375 tcgetattr (remote_desc
, &termios
);
380 termios
.c_cflag
&= ~(CSIZE
| PARENB
);
381 termios
.c_cflag
|= CLOCAL
| CS8
;
382 termios
.c_cc
[VMIN
] = 1;
383 termios
.c_cc
[VTIME
] = 0;
385 tcsetattr (remote_desc
, TCSANOW
, &termios
);
389 fprintf (stderr
, "Remote debugging using %s\n", name
);
391 enable_async_notification (remote_desc
);
393 /* Register the event loop handler. */
394 add_file_handler (remote_desc
, handle_serial_event
, NULL
);
396 #endif /* USE_WIN32API */
399 char listen_port
[GDB_NI_MAX_PORT
];
400 struct sockaddr_storage sockaddr
;
401 socklen_t len
= sizeof (sockaddr
);
403 if (getsockname (listen_desc
, (struct sockaddr
*) &sockaddr
, &len
) < 0)
404 perror_with_name ("Can't determine port");
406 int r
= getnameinfo ((struct sockaddr
*) &sockaddr
, len
,
408 listen_port
, sizeof (listen_port
),
412 fprintf (stderr
, _("Can't obtain port where we are listening: %s"),
415 fprintf (stderr
, _("Listening on port %s\n"), listen_port
);
419 /* Register the event loop handler. */
420 add_file_handler (listen_desc
, handle_accept_event
, NULL
);
427 delete_file_handler (remote_desc
);
432 closesocket (remote_desc
);
434 if (! remote_connection_is_stdio ())
437 remote_desc
= INVALID_DESCRIPTOR
;
444 #ifndef IN_PROCESS_AGENT
447 decode_address (CORE_ADDR
*addrp
, const char *start
, int len
)
454 for (i
= 0; i
< len
; i
++)
458 addr
= addr
| (fromhex (ch
) & 0x0f);
464 decode_address_to_semicolon (CORE_ADDR
*addrp
, const char *start
)
469 while (*end
!= '\0' && *end
!= ';')
472 decode_address (addrp
, start
, end
- start
);
481 #ifndef IN_PROCESS_AGENT
483 /* Look for a sequence of characters which can be run-length encoded.
484 If there are any, update *CSUM and *P. Otherwise, output the
485 single character. Return the number of characters consumed. */
488 try_rle (char *buf
, int remaining
, unsigned char *csum
, char **p
)
492 /* Always output the character. */
496 /* Don't go past '~'. */
500 for (n
= 1; n
< remaining
; n
++)
501 if (buf
[n
] != buf
[0])
504 /* N is the index of the first character not the same as buf[0].
505 buf[0] is counted twice, so by decrementing N, we get the number
506 of characters the RLE sequence will replace. */
512 /* Skip the frame characters. The manual says to skip '+' and '-'
513 also, but there's no reason to. Unfortunately these two unusable
514 characters double the encoded length of a four byte zero
516 while (n
+ 29 == '$' || n
+ 29 == '#')
529 #ifndef IN_PROCESS_AGENT
531 /* Write a PTID to BUF. Returns BUF+CHARACTERS_WRITTEN. */
534 write_ptid (char *buf
, ptid_t ptid
)
536 client_state
&cs
= get_client_state ();
539 if (cs
.multi_process
)
543 buf
+= sprintf (buf
, "p-%x.", -pid
);
545 buf
+= sprintf (buf
, "p%x.", pid
);
549 buf
+= sprintf (buf
, "-%x", -tid
);
551 buf
+= sprintf (buf
, "%x", tid
);
557 hex_or_minus_one (const char *buf
, const char **obuf
)
561 if (startswith (buf
, "-1"))
567 buf
= unpack_varlen_hex (buf
, &ret
);
575 /* Extract a PTID from BUF. If non-null, OBUF is set to the to one
576 passed the last parsed char. Returns null_ptid on error. */
578 read_ptid (const char *buf
, const char **obuf
)
582 ULONGEST pid
= 0, tid
= 0;
586 /* Multi-process ptid. */
587 pp
= unpack_varlen_hex (p
+ 1, &pid
);
589 error ("invalid remote ptid: %s\n", p
);
593 tid
= hex_or_minus_one (p
, &pp
);
597 return ptid_t (pid
, tid
, 0);
600 /* No multi-process. Just a tid. */
601 tid
= hex_or_minus_one (p
, &pp
);
603 /* Since GDB is not sending a process id (multi-process extensions
604 are off), then there's only one process. Default to the first in
606 pid
= pid_of (get_first_process ());
610 return ptid_t (pid
, tid
, 0);
613 /* Write COUNT bytes in BUF to the client.
614 The result is the number of bytes written or -1 if error.
615 This may return less than COUNT. */
618 write_prim (const void *buf
, int count
)
620 if (remote_connection_is_stdio ())
621 return write (fileno (stdout
), buf
, count
);
623 return write (remote_desc
, buf
, count
);
626 /* Read COUNT bytes from the client and store in BUF.
627 The result is the number of bytes read or -1 if error.
628 This may return less than COUNT. */
631 read_prim (void *buf
, int count
)
633 if (remote_connection_is_stdio ())
634 return read (fileno (stdin
), buf
, count
);
636 return read (remote_desc
, buf
, count
);
639 /* Send a packet to the remote machine, with error checking.
640 The data of the packet is in BUF, and the length of the
641 packet is in CNT. Returns >= 0 on success, -1 otherwise. */
644 putpkt_binary_1 (char *buf
, int cnt
, int is_notif
)
646 client_state
&cs
= get_client_state ();
648 unsigned char csum
= 0;
653 buf2
= (char *) xmalloc (strlen ("$") + cnt
+ strlen ("#nn") + 1);
655 /* Copy the packet into buffer BUF2, encapsulating it
656 and giving it a checksum. */
664 for (i
= 0; i
< cnt
;)
665 i
+= try_rle (buf
+ i
, cnt
- i
, &csum
, &p
);
668 *p
++ = tohex ((csum
>> 4) & 0xf);
669 *p
++ = tohex (csum
& 0xf);
673 /* Send it over and over until we get a positive ack. */
677 if (write_prim (buf2
, p
- buf2
) != p
- buf2
)
679 perror ("putpkt(write)");
684 if (cs
.noack_mode
|| is_notif
)
686 /* Don't expect an ack then. */
690 debug_printf ("putpkt (\"%s\"); [notif]\n", buf2
);
692 debug_printf ("putpkt (\"%s\"); [noack mode]\n", buf2
);
700 debug_printf ("putpkt (\"%s\"); [looking for ack]\n", buf2
);
714 debug_printf ("[received '%c' (0x%x)]\n", cc
, cc
);
718 /* Check for an input interrupt while we're here. */
719 if (cc
== '\003' && current_thread
!= NULL
)
720 (*the_target
->request_interrupt
) ();
725 return 1; /* Success! */
729 putpkt_binary (char *buf
, int cnt
)
731 return putpkt_binary_1 (buf
, cnt
, 0);
734 /* Send a packet to the remote machine, with error checking. The data
735 of the packet is in BUF, and the packet should be a NUL-terminated
736 string. Returns >= 0 on success, -1 otherwise. */
741 return putpkt_binary (buf
, strlen (buf
));
745 putpkt_notif (char *buf
)
747 return putpkt_binary_1 (buf
, strlen (buf
), 1);
750 /* Come here when we get an input interrupt from the remote side. This
751 interrupt should only be active while we are waiting for the child to do
752 something. Thus this assumes readchar:bufcnt is 0.
753 About the only thing that should come through is a ^C, which
754 will cause us to request child interruption. */
757 input_interrupt (int unused
)
760 struct timeval immediate
= { 0, 0 };
762 /* Protect against spurious interrupts. This has been observed to
763 be a problem under NetBSD 1.4 and 1.5. */
766 FD_SET (remote_desc
, &readset
);
767 if (select (remote_desc
+ 1, &readset
, 0, 0, &immediate
) > 0)
772 cc
= read_prim (&c
, 1);
776 fprintf (stderr
, "client connection closed\n");
779 else if (cc
!= 1 || c
!= '\003')
781 fprintf (stderr
, "input_interrupt, count = %d c = %d ", cc
, c
);
783 fprintf (stderr
, "('%c')\n", c
);
785 fprintf (stderr
, "('\\x%02x')\n", c
& 0xff);
789 (*the_target
->request_interrupt
) ();
793 /* Check if the remote side sent us an interrupt request (^C). */
795 check_remote_input_interrupt_request (void)
797 /* This function may be called before establishing communications,
798 therefore we need to validate the remote descriptor. */
800 if (remote_desc
== INVALID_DESCRIPTOR
)
806 /* Asynchronous I/O support. SIGIO must be unblocked when waiting,
807 in order to accept Control-C from the client, and must be blocked
808 when talking to the client. */
811 block_unblock_async_io (int block
)
816 sigemptyset (&sigio_set
);
817 sigaddset (&sigio_set
, SIGIO
);
818 sigprocmask (block
? SIG_BLOCK
: SIG_UNBLOCK
, &sigio_set
, NULL
);
824 nto_comctrl (int enable
)
826 struct sigevent event
;
830 event
.sigev_notify
= SIGEV_SIGNAL_THREAD
;
831 event
.sigev_signo
= SIGIO
;
832 event
.sigev_code
= 0;
833 event
.sigev_value
.sival_ptr
= NULL
;
834 event
.sigev_priority
= -1;
835 ionotify (remote_desc
, _NOTIFY_ACTION_POLLARM
, _NOTIFY_COND_INPUT
,
839 ionotify (remote_desc
, _NOTIFY_ACTION_POLL
, _NOTIFY_COND_INPUT
, NULL
);
844 /* Current state of asynchronous I/O. */
845 static int async_io_enabled
;
847 /* Enable asynchronous I/O. */
849 enable_async_io (void)
851 if (async_io_enabled
)
854 block_unblock_async_io (0);
856 async_io_enabled
= 1;
862 /* Disable asynchronous I/O. */
864 disable_async_io (void)
866 if (!async_io_enabled
)
869 block_unblock_async_io (1);
871 async_io_enabled
= 0;
879 initialize_async_io (void)
881 /* Make sure that async I/O starts blocked. */
882 async_io_enabled
= 1;
885 /* Install the signal handler. */
887 signal (SIGIO
, input_interrupt
);
891 /* Internal buffer used by readchar.
892 These are global to readchar because reschedule_remote needs to be
893 able to tell whether the buffer is empty. */
895 static unsigned char readchar_buf
[BUFSIZ
];
896 static int readchar_bufcnt
= 0;
897 static unsigned char *readchar_bufp
;
899 /* Returns next char from remote GDB. -1 if error. */
906 if (readchar_bufcnt
== 0)
908 readchar_bufcnt
= read_prim (readchar_buf
, sizeof (readchar_buf
));
910 if (readchar_bufcnt
<= 0)
912 if (readchar_bufcnt
== 0)
915 debug_printf ("readchar: Got EOF\n");
923 readchar_bufp
= readchar_buf
;
927 ch
= *readchar_bufp
++;
932 /* Reset the readchar state machine. */
935 reset_readchar (void)
938 if (readchar_callback
!= NOT_SCHEDULED
)
940 delete_callback_event (readchar_callback
);
941 readchar_callback
= NOT_SCHEDULED
;
945 /* Process remaining data in readchar_buf. */
948 process_remaining (void *context
)
952 /* This is a one-shot event. */
953 readchar_callback
= NOT_SCHEDULED
;
955 if (readchar_bufcnt
> 0)
956 res
= handle_serial_event (0, NULL
);
963 /* If there is still data in the buffer, queue another event to process it,
964 we can't sleep in select yet. */
969 if (readchar_bufcnt
> 0 && readchar_callback
== NOT_SCHEDULED
)
970 readchar_callback
= append_callback_event (process_remaining
, NULL
);
973 /* Read a packet from the remote machine, with error checking,
974 and store it in BUF. Returns length of packet, or negative if error. */
979 client_state
&cs
= get_client_state ();
981 unsigned char csum
, c1
, c2
;
992 /* The '\003' may appear before or after each packet, so
993 check for an input interrupt. */
996 (*the_target
->request_interrupt
) ();
1004 debug_printf ("[getpkt: discarding char '%c']\n", c
);
1025 c1
= fromhex (readchar ());
1026 c2
= fromhex (readchar ());
1028 if (csum
== (c1
<< 4) + c2
)
1034 "Bad checksum, sentsum=0x%x, csum=0x%x, "
1035 "buf=%s [no-ack-mode, Bad medium?]\n",
1036 (c1
<< 4) + c2
, csum
, buf
);
1037 /* Not much we can do, GDB wasn't expecting an ack/nac. */
1041 fprintf (stderr
, "Bad checksum, sentsum=0x%x, csum=0x%x, buf=%s\n",
1042 (c1
<< 4) + c2
, csum
, buf
);
1043 if (write_prim ("-", 1) != 1)
1051 debug_printf ("getpkt (\"%s\"); [sending ack] \n", buf
);
1055 if (write_prim ("+", 1) != 1)
1060 debug_printf ("[sent ack]\n");
1068 debug_printf ("getpkt (\"%s\"); [no ack sent] \n", buf
);
1073 /* The readchar above may have already read a '\003' out of the socket
1074 and moved it to the local buffer. For example, when GDB sends
1075 vCont;c immediately followed by interrupt (see
1076 gdb.base/interrupt-noterm.exp). As soon as we see the vCont;c, we'll
1077 resume the inferior and wait. Since we've already moved the '\003'
1078 to the local buffer, SIGIO won't help. In that case, if we don't
1079 check for interrupt after the vCont;c packet, the interrupt character
1080 would stay in the buffer unattended until after the next (unrelated)
1082 while (readchar_bufcnt
> 0 && *readchar_bufp
== '\003')
1084 /* Consume the interrupt character in the buffer. */
1086 (*the_target
->request_interrupt
) ();
1093 write_ok (char *buf
)
1101 write_enn (char *buf
)
1103 /* Some day, we should define the meanings of the error codes... */
1112 #ifndef IN_PROCESS_AGENT
1115 outreg (struct regcache
*regcache
, int regno
, char *buf
)
1117 if ((regno
>> 12) != 0)
1118 *buf
++ = tohex ((regno
>> 12) & 0xf);
1119 if ((regno
>> 8) != 0)
1120 *buf
++ = tohex ((regno
>> 8) & 0xf);
1121 *buf
++ = tohex ((regno
>> 4) & 0xf);
1122 *buf
++ = tohex (regno
& 0xf);
1124 collect_register_as_string (regcache
, regno
, buf
);
1125 buf
+= 2 * register_size (regcache
->tdesc
, regno
);
1132 prepare_resume_reply (char *buf
, ptid_t ptid
,
1133 struct target_waitstatus
*status
)
1135 client_state
&cs
= get_client_state ();
1137 debug_printf ("Writing resume reply for %s:%d\n",
1138 target_pid_to_str (ptid
), status
->kind
);
1140 switch (status
->kind
)
1142 case TARGET_WAITKIND_STOPPED
:
1143 case TARGET_WAITKIND_FORKED
:
1144 case TARGET_WAITKIND_VFORKED
:
1145 case TARGET_WAITKIND_VFORK_DONE
:
1146 case TARGET_WAITKIND_EXECD
:
1147 case TARGET_WAITKIND_THREAD_CREATED
:
1148 case TARGET_WAITKIND_SYSCALL_ENTRY
:
1149 case TARGET_WAITKIND_SYSCALL_RETURN
:
1151 struct thread_info
*saved_thread
;
1153 struct regcache
*regcache
;
1155 if ((status
->kind
== TARGET_WAITKIND_FORKED
&& cs
.report_fork_events
)
1156 || (status
->kind
== TARGET_WAITKIND_VFORKED
1157 && cs
.report_vfork_events
))
1159 enum gdb_signal signal
= GDB_SIGNAL_TRAP
;
1160 const char *event
= (status
->kind
== TARGET_WAITKIND_FORKED
1161 ? "fork" : "vfork");
1163 sprintf (buf
, "T%02x%s:", signal
, event
);
1164 buf
+= strlen (buf
);
1165 buf
= write_ptid (buf
, status
->value
.related_pid
);
1168 else if (status
->kind
== TARGET_WAITKIND_VFORK_DONE
1169 && cs
.report_vfork_events
)
1171 enum gdb_signal signal
= GDB_SIGNAL_TRAP
;
1173 sprintf (buf
, "T%02xvforkdone:;", signal
);
1175 else if (status
->kind
== TARGET_WAITKIND_EXECD
&& cs
.report_exec_events
)
1177 enum gdb_signal signal
= GDB_SIGNAL_TRAP
;
1178 const char *event
= "exec";
1179 char hexified_pathname
[PATH_MAX
* 2];
1181 sprintf (buf
, "T%02x%s:", signal
, event
);
1182 buf
+= strlen (buf
);
1184 /* Encode pathname to hexified format. */
1185 bin2hex ((const gdb_byte
*) status
->value
.execd_pathname
,
1187 strlen (status
->value
.execd_pathname
));
1189 sprintf (buf
, "%s;", hexified_pathname
);
1190 xfree (status
->value
.execd_pathname
);
1191 status
->value
.execd_pathname
= NULL
;
1192 buf
+= strlen (buf
);
1194 else if (status
->kind
== TARGET_WAITKIND_THREAD_CREATED
1195 && cs
.report_thread_events
)
1197 enum gdb_signal signal
= GDB_SIGNAL_TRAP
;
1199 sprintf (buf
, "T%02xcreate:;", signal
);
1201 else if (status
->kind
== TARGET_WAITKIND_SYSCALL_ENTRY
1202 || status
->kind
== TARGET_WAITKIND_SYSCALL_RETURN
)
1204 enum gdb_signal signal
= GDB_SIGNAL_TRAP
;
1205 const char *event
= (status
->kind
== TARGET_WAITKIND_SYSCALL_ENTRY
1206 ? "syscall_entry" : "syscall_return");
1208 sprintf (buf
, "T%02x%s:%x;", signal
, event
,
1209 status
->value
.syscall_number
);
1212 sprintf (buf
, "T%02x", status
->value
.sig
);
1214 buf
+= strlen (buf
);
1216 saved_thread
= current_thread
;
1218 switch_to_thread (ptid
);
1220 regp
= current_target_desc ()->expedite_regs
;
1222 regcache
= get_thread_regcache (current_thread
, 1);
1224 if (the_target
->stopped_by_watchpoint
!= NULL
1225 && (*the_target
->stopped_by_watchpoint
) ())
1230 memcpy (buf
, "watch:", 6);
1233 addr
= (*the_target
->stopped_data_address
) ();
1235 /* Convert each byte of the address into two hexadecimal
1236 chars. Note that we take sizeof (void *) instead of
1237 sizeof (addr); this is to avoid sending a 64-bit
1238 address to a 32-bit GDB. */
1239 for (i
= sizeof (void *) * 2; i
> 0; i
--)
1240 *buf
++ = tohex ((addr
>> (i
- 1) * 4) & 0xf);
1243 else if (cs
.swbreak_feature
&& target_stopped_by_sw_breakpoint ())
1245 sprintf (buf
, "swbreak:;");
1246 buf
+= strlen (buf
);
1248 else if (cs
.hwbreak_feature
&& target_stopped_by_hw_breakpoint ())
1250 sprintf (buf
, "hwbreak:;");
1251 buf
+= strlen (buf
);
1256 buf
= outreg (regcache
, find_regno (regcache
->tdesc
, *regp
), buf
);
1261 /* Formerly, if the debugger had not used any thread features
1262 we would not burden it with a thread status response. This
1263 was for the benefit of GDB 4.13 and older. However, in
1264 recent GDB versions the check (``if (cont_thread != 0)'')
1265 does not have the desired effect because of sillyness in
1266 the way that the remote protocol handles specifying a
1267 thread. Since thread support relies on qSymbol support
1268 anyway, assume GDB can handle threads. */
1270 if (using_threads
&& !disable_packet_Tthread
)
1272 /* This if (1) ought to be unnecessary. But remote_wait
1273 in GDB will claim this event belongs to inferior_ptid
1274 if we do not specify a thread, and there's no way for
1275 gdbserver to know what inferior_ptid is. */
1276 if (1 || cs
.general_thread
!= ptid
)
1279 /* In non-stop, don't change the general thread behind
1282 cs
.general_thread
= ptid
;
1283 sprintf (buf
, "thread:");
1284 buf
+= strlen (buf
);
1285 buf
= write_ptid (buf
, ptid
);
1287 buf
+= strlen (buf
);
1289 core
= target_core_of_thread (ptid
);
1293 sprintf (buf
, "core:");
1294 buf
+= strlen (buf
);
1295 sprintf (buf
, "%x", core
);
1297 buf
+= strlen (buf
);
1304 strcpy (buf
, "library:;");
1305 buf
+= strlen (buf
);
1309 current_thread
= saved_thread
;
1312 case TARGET_WAITKIND_EXITED
:
1313 if (cs
.multi_process
)
1314 sprintf (buf
, "W%x;process:%x",
1315 status
->value
.integer
, ptid
.pid ());
1317 sprintf (buf
, "W%02x", status
->value
.integer
);
1319 case TARGET_WAITKIND_SIGNALLED
:
1320 if (cs
.multi_process
)
1321 sprintf (buf
, "X%x;process:%x",
1322 status
->value
.sig
, ptid
.pid ());
1324 sprintf (buf
, "X%02x", status
->value
.sig
);
1326 case TARGET_WAITKIND_THREAD_EXITED
:
1327 sprintf (buf
, "w%x;", status
->value
.integer
);
1328 buf
+= strlen (buf
);
1329 buf
= write_ptid (buf
, ptid
);
1331 case TARGET_WAITKIND_NO_RESUMED
:
1335 error ("unhandled waitkind");
1341 decode_m_packet (char *from
, CORE_ADDR
*mem_addr_ptr
, unsigned int *len_ptr
)
1345 *mem_addr_ptr
= *len_ptr
= 0;
1347 while ((ch
= from
[i
++]) != ',')
1349 *mem_addr_ptr
= *mem_addr_ptr
<< 4;
1350 *mem_addr_ptr
|= fromhex (ch
) & 0x0f;
1353 for (j
= 0; j
< 4; j
++)
1355 if ((ch
= from
[i
++]) == 0)
1357 *len_ptr
= *len_ptr
<< 4;
1358 *len_ptr
|= fromhex (ch
) & 0x0f;
1363 decode_M_packet (char *from
, CORE_ADDR
*mem_addr_ptr
, unsigned int *len_ptr
,
1364 unsigned char **to_p
)
1368 *mem_addr_ptr
= *len_ptr
= 0;
1370 while ((ch
= from
[i
++]) != ',')
1372 *mem_addr_ptr
= *mem_addr_ptr
<< 4;
1373 *mem_addr_ptr
|= fromhex (ch
) & 0x0f;
1376 while ((ch
= from
[i
++]) != ':')
1378 *len_ptr
= *len_ptr
<< 4;
1379 *len_ptr
|= fromhex (ch
) & 0x0f;
1383 *to_p
= (unsigned char *) xmalloc (*len_ptr
);
1385 hex2bin (&from
[i
++], *to_p
, *len_ptr
);
1389 decode_X_packet (char *from
, int packet_len
, CORE_ADDR
*mem_addr_ptr
,
1390 unsigned int *len_ptr
, unsigned char **to_p
)
1394 *mem_addr_ptr
= *len_ptr
= 0;
1396 while ((ch
= from
[i
++]) != ',')
1398 *mem_addr_ptr
= *mem_addr_ptr
<< 4;
1399 *mem_addr_ptr
|= fromhex (ch
) & 0x0f;
1402 while ((ch
= from
[i
++]) != ':')
1404 *len_ptr
= *len_ptr
<< 4;
1405 *len_ptr
|= fromhex (ch
) & 0x0f;
1409 *to_p
= (unsigned char *) xmalloc (*len_ptr
);
1411 if (remote_unescape_input ((const gdb_byte
*) &from
[i
], packet_len
- i
,
1412 *to_p
, *len_ptr
) != *len_ptr
)
1418 /* Decode a qXfer write request. */
1421 decode_xfer_write (char *buf
, int packet_len
, CORE_ADDR
*offset
,
1422 unsigned int *len
, unsigned char *data
)
1427 /* Extract the offset. */
1429 while ((ch
= *buf
++) != ':')
1431 *offset
= *offset
<< 4;
1432 *offset
|= fromhex (ch
) & 0x0f;
1435 /* Get encoded data. */
1436 packet_len
-= buf
- b
;
1437 *len
= remote_unescape_input ((const gdb_byte
*) buf
, packet_len
,
1442 /* Decode the parameters of a qSearch:memory packet. */
1445 decode_search_memory_packet (const char *buf
, int packet_len
,
1446 CORE_ADDR
*start_addrp
,
1447 CORE_ADDR
*search_space_lenp
,
1448 gdb_byte
*pattern
, unsigned int *pattern_lenp
)
1450 const char *p
= buf
;
1452 p
= decode_address_to_semicolon (start_addrp
, p
);
1453 p
= decode_address_to_semicolon (search_space_lenp
, p
);
1454 packet_len
-= p
- buf
;
1455 *pattern_lenp
= remote_unescape_input ((const gdb_byte
*) p
, packet_len
,
1456 pattern
, packet_len
);
1461 free_sym_cache (struct sym_cache
*sym
)
1471 clear_symbol_cache (struct sym_cache
**symcache_p
)
1473 struct sym_cache
*sym
, *next
;
1475 /* Check the cache first. */
1476 for (sym
= *symcache_p
; sym
; sym
= next
)
1479 free_sym_cache (sym
);
1485 /* Get the address of NAME, and return it in ADDRP if found. if
1486 MAY_ASK_GDB is false, assume symbol cache misses are failures.
1487 Returns 1 if the symbol is found, 0 if it is not, -1 on error. */
1490 look_up_one_symbol (const char *name
, CORE_ADDR
*addrp
, int may_ask_gdb
)
1492 client_state
&cs
= get_client_state ();
1495 struct sym_cache
*sym
;
1496 struct process_info
*proc
;
1498 proc
= current_process ();
1500 /* Check the cache first. */
1501 for (sym
= proc
->symbol_cache
; sym
; sym
= sym
->next
)
1502 if (strcmp (name
, sym
->name
) == 0)
1508 /* It might not be an appropriate time to look up a symbol,
1509 e.g. while we're trying to fetch registers. */
1513 /* Send the request. */
1514 strcpy (cs
.own_buf
, "qSymbol:");
1515 bin2hex ((const gdb_byte
*) name
, cs
.own_buf
+ strlen ("qSymbol:"),
1517 if (putpkt (cs
.own_buf
) < 0)
1520 /* FIXME: Eventually add buffer overflow checking (to getpkt?) */
1521 len
= getpkt (cs
.own_buf
);
1525 /* We ought to handle pretty much any packet at this point while we
1526 wait for the qSymbol "response". That requires re-entering the
1527 main loop. For now, this is an adequate approximation; allow
1528 GDB to read from memory and handle 'v' packets (for vFile transfers)
1529 while it figures out the address of the symbol. */
1532 if (cs
.own_buf
[0] == 'm')
1535 unsigned char *mem_buf
;
1536 unsigned int mem_len
;
1538 decode_m_packet (&cs
.own_buf
[1], &mem_addr
, &mem_len
);
1539 mem_buf
= (unsigned char *) xmalloc (mem_len
);
1540 if (read_inferior_memory (mem_addr
, mem_buf
, mem_len
) == 0)
1541 bin2hex (mem_buf
, cs
.own_buf
, mem_len
);
1543 write_enn (cs
.own_buf
);
1545 if (putpkt (cs
.own_buf
) < 0)
1548 else if (cs
.own_buf
[0] == 'v')
1551 handle_v_requests (cs
.own_buf
, len
, &new_len
);
1553 putpkt_binary (cs
.own_buf
, new_len
);
1555 putpkt (cs
.own_buf
);
1559 len
= getpkt (cs
.own_buf
);
1564 if (!startswith (cs
.own_buf
, "qSymbol:"))
1566 warning ("Malformed response to qSymbol, ignoring: %s\n", cs
.own_buf
);
1570 p
= cs
.own_buf
+ strlen ("qSymbol:");
1572 while (*q
&& *q
!= ':')
1575 /* Make sure we found a value for the symbol. */
1576 if (p
== q
|| *q
== '\0')
1579 decode_address (addrp
, p
, q
- p
);
1581 /* Save the symbol in our cache. */
1582 sym
= XNEW (struct sym_cache
);
1583 sym
->name
= xstrdup (name
);
1585 sym
->next
= proc
->symbol_cache
;
1586 proc
->symbol_cache
= sym
;
1591 /* Relocate an instruction to execute at a different address. OLDLOC
1592 is the address in the inferior memory where the instruction to
1593 relocate is currently at. On input, TO points to the destination
1594 where we want the instruction to be copied (and possibly adjusted)
1595 to. On output, it points to one past the end of the resulting
1596 instruction(s). The effect of executing the instruction at TO
1597 shall be the same as if executing it at OLDLOC. For example, call
1598 instructions that implicitly push the return address on the stack
1599 should be adjusted to return to the instruction after OLDLOC;
1600 relative branches, and other PC-relative instructions need the
1601 offset adjusted; etc. Returns 0 on success, -1 on failure. */
1604 relocate_instruction (CORE_ADDR
*to
, CORE_ADDR oldloc
)
1606 client_state
&cs
= get_client_state ();
1608 ULONGEST written
= 0;
1610 /* Send the request. */
1611 sprintf (cs
.own_buf
, "qRelocInsn:%s;%s", paddress (oldloc
),
1613 if (putpkt (cs
.own_buf
) < 0)
1616 /* FIXME: Eventually add buffer overflow checking (to getpkt?) */
1617 len
= getpkt (cs
.own_buf
);
1621 /* We ought to handle pretty much any packet at this point while we
1622 wait for the qRelocInsn "response". That requires re-entering
1623 the main loop. For now, this is an adequate approximation; allow
1624 GDB to access memory. */
1625 while (cs
.own_buf
[0] == 'm' || cs
.own_buf
[0] == 'M' || cs
.own_buf
[0] == 'X')
1628 unsigned char *mem_buf
= NULL
;
1629 unsigned int mem_len
;
1631 if (cs
.own_buf
[0] == 'm')
1633 decode_m_packet (&cs
.own_buf
[1], &mem_addr
, &mem_len
);
1634 mem_buf
= (unsigned char *) xmalloc (mem_len
);
1635 if (read_inferior_memory (mem_addr
, mem_buf
, mem_len
) == 0)
1636 bin2hex (mem_buf
, cs
.own_buf
, mem_len
);
1638 write_enn (cs
.own_buf
);
1640 else if (cs
.own_buf
[0] == 'X')
1642 if (decode_X_packet (&cs
.own_buf
[1], len
- 1, &mem_addr
,
1643 &mem_len
, &mem_buf
) < 0
1644 || write_inferior_memory (mem_addr
, mem_buf
, mem_len
) != 0)
1645 write_enn (cs
.own_buf
);
1647 write_ok (cs
.own_buf
);
1651 decode_M_packet (&cs
.own_buf
[1], &mem_addr
, &mem_len
, &mem_buf
);
1652 if (write_inferior_memory (mem_addr
, mem_buf
, mem_len
) == 0)
1653 write_ok (cs
.own_buf
);
1655 write_enn (cs
.own_buf
);
1658 if (putpkt (cs
.own_buf
) < 0)
1660 len
= getpkt (cs
.own_buf
);
1665 if (cs
.own_buf
[0] == 'E')
1667 warning ("An error occurred while relocating an instruction: %s\n",
1672 if (!startswith (cs
.own_buf
, "qRelocInsn:"))
1674 warning ("Malformed response to qRelocInsn, ignoring: %s\n",
1679 unpack_varlen_hex (cs
.own_buf
+ strlen ("qRelocInsn:"), &written
);
1686 monitor_output (const char *msg
)
1688 int len
= strlen (msg
);
1689 char *buf
= (char *) xmalloc (len
* 2 + 2);
1692 bin2hex ((const gdb_byte
*) msg
, buf
+ 1, len
);