1 /* Remote utility routines for the remote server for GDB.
2 Copyright (C) 1986-2019 Free Software Foundation, Inc.
4 This file is part of GDB.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program. If not, see <http://www.gnu.org/licenses/>. */
24 #include "gdbthread.h"
27 #include "common/rsp-low.h"
28 #include "common/netstuff.h"
29 #include "common/filestuff.h"
32 #include <sys/ioctl.h>
38 #include <netinet/in.h>
41 #include <sys/socket.h>
46 #if HAVE_NETINET_TCP_H
47 #include <netinet/tcp.h>
50 #include <sys/ioctl.h>
58 #include "common/gdb_sys_time.h"
61 #include <arpa/inet.h>
66 #if _WIN32_WINNT < 0x0501
68 # define _WIN32_WINNT 0x0501
74 #include <sys/iomgr.h>
77 #ifndef HAVE_SOCKLEN_T
78 typedef int socklen_t
;
81 #ifndef IN_PROCESS_AGENT
84 # define INVALID_DESCRIPTOR INVALID_SOCKET
86 # define INVALID_DESCRIPTOR -1
89 /* Extra value for readchar_callback. */
91 /* The callback is currently not scheduled. */
95 /* Status of the readchar callback.
96 Either NOT_SCHEDULED or the callback id. */
97 static int readchar_callback
= NOT_SCHEDULED
;
99 static int readchar (void);
100 static void reset_readchar (void);
101 static void reschedule (void);
103 /* A cache entry for a successfully looked-up symbol. */
108 struct sym_cache
*next
;
111 int remote_debug
= 0;
112 struct ui_file
*gdb_stdlog
;
114 static int remote_is_stdio
= 0;
116 static gdb_fildes_t remote_desc
= INVALID_DESCRIPTOR
;
117 static gdb_fildes_t listen_desc
= INVALID_DESCRIPTOR
;
119 /* FIXME headerize? */
120 extern int using_threads
;
121 extern int debug_threads
;
124 # define read(fd, buf, len) recv (fd, (char *) buf, len, 0)
125 # define write(fd, buf, len) send (fd, (char *) buf, len, 0)
131 return remote_desc
!= INVALID_DESCRIPTOR
;
134 /* Return true if the remote connection is over stdio. */
137 remote_connection_is_stdio (void)
139 return remote_is_stdio
;
143 enable_async_notification (int fd
)
145 #if defined(F_SETFL) && defined (FASYNC)
146 int save_fcntl_flags
;
148 save_fcntl_flags
= fcntl (fd
, F_GETFL
, 0);
149 fcntl (fd
, F_SETFL
, save_fcntl_flags
| FASYNC
);
150 #if defined (F_SETOWN)
151 fcntl (fd
, F_SETOWN
, getpid ());
157 handle_accept_event (int err
, gdb_client_data client_data
)
159 struct sockaddr_storage sockaddr
;
160 socklen_t len
= sizeof (sockaddr
);
163 debug_printf ("handling possible accept event\n");
165 remote_desc
= accept (listen_desc
, (struct sockaddr
*) &sockaddr
, &len
);
166 if (remote_desc
== -1)
167 perror_with_name ("Accept failed");
169 /* Enable TCP keep alive process. */
171 setsockopt (remote_desc
, SOL_SOCKET
, SO_KEEPALIVE
,
172 (char *) &tmp
, sizeof (tmp
));
174 /* Tell TCP not to delay small packets. This greatly speeds up
175 interactive response. */
177 setsockopt (remote_desc
, IPPROTO_TCP
, TCP_NODELAY
,
178 (char *) &tmp
, sizeof (tmp
));
181 signal (SIGPIPE
, SIG_IGN
); /* If we don't do this, then gdbserver simply
182 exits when the remote side dies. */
188 close (listen_desc
); /* No longer need this */
190 closesocket (listen_desc
); /* No longer need this */
194 /* Even if !RUN_ONCE no longer notice new connections. Still keep the
195 descriptor open for add_file_handler to wait for a new connection. */
196 delete_file_handler (listen_desc
);
198 /* Convert IP address to string. */
199 char orig_host
[GDB_NI_MAX_ADDR
], orig_port
[GDB_NI_MAX_PORT
];
201 int r
= getnameinfo ((struct sockaddr
*) &sockaddr
, len
,
202 orig_host
, sizeof (orig_host
),
203 orig_port
, sizeof (orig_port
),
204 NI_NUMERICHOST
| NI_NUMERICSERV
);
207 fprintf (stderr
, _("Could not obtain remote address: %s\n"),
210 fprintf (stderr
, _("Remote debugging from host %s, port %s\n"),
211 orig_host
, orig_port
);
213 enable_async_notification (remote_desc
);
215 /* Register the event loop handler. */
216 add_file_handler (remote_desc
, handle_serial_event
, NULL
);
218 /* We have a new GDB connection now. If we were disconnected
219 tracing, there's a window where the target could report a stop
220 event to the event loop, and since we have a connection now, we'd
221 try to send vStopped notifications to GDB. But, don't do that
222 until GDB as selected all-stop/non-stop, and has queried the
223 threads' status ('?'). */
229 /* Prepare for a later connection to a remote debugger.
230 NAME is the filename used for communication. */
233 remote_prepare (const char *name
)
235 client_state
&cs
= get_client_state ();
237 static int winsock_initialized
;
242 if (strcmp (name
, STDIO_CONNECTION_NAME
) == 0)
244 /* We need to record fact that we're using stdio sooner than the
245 call to remote_open so start_inferior knows the connection is
248 cs
.transport_is_reliable
= 1;
252 struct addrinfo hint
;
253 struct addrinfo
*ainfo
;
255 memset (&hint
, 0, sizeof (hint
));
256 /* Assume no prefix will be passed, therefore we should use
258 hint
.ai_family
= AF_UNSPEC
;
259 hint
.ai_socktype
= SOCK_STREAM
;
260 hint
.ai_protocol
= IPPROTO_TCP
;
262 parsed_connection_spec parsed
263 = parse_connection_spec_without_prefix (name
, &hint
);
265 if (parsed
.port_str
.empty ())
267 cs
.transport_is_reliable
= 0;
272 if (!winsock_initialized
)
276 WSAStartup (MAKEWORD (1, 0), &wsad
);
277 winsock_initialized
= 1;
281 int r
= getaddrinfo (parsed
.host_str
.c_str (), parsed
.port_str
.c_str (),
285 error (_("%s: cannot resolve name: %s"), name
, gai_strerror (r
));
287 scoped_free_addrinfo
freeaddrinfo (ainfo
);
289 struct addrinfo
*iter
;
291 for (iter
= ainfo
; iter
!= NULL
; iter
= iter
->ai_next
)
293 listen_desc
= gdb_socket_cloexec (iter
->ai_family
, iter
->ai_socktype
,
296 if (listen_desc
>= 0)
301 perror_with_name ("Can't open socket");
303 /* Allow rapid reuse of this port. */
305 setsockopt (listen_desc
, SOL_SOCKET
, SO_REUSEADDR
, (char *) &tmp
,
308 switch (iter
->ai_family
)
311 ((struct sockaddr_in
*) iter
->ai_addr
)->sin_addr
.s_addr
= INADDR_ANY
;
314 ((struct sockaddr_in6
*) iter
->ai_addr
)->sin6_addr
= in6addr_any
;
317 internal_error (__FILE__
, __LINE__
,
318 _("Invalid 'ai_family' %d\n"), iter
->ai_family
);
321 if (bind (listen_desc
, iter
->ai_addr
, iter
->ai_addrlen
) != 0)
322 perror_with_name ("Can't bind address");
324 if (listen (listen_desc
, 1) != 0)
325 perror_with_name ("Can't listen on socket");
327 cs
.transport_is_reliable
= 1;
330 /* Open a connection to a remote debugger.
331 NAME is the filename used for communication. */
334 remote_open (const char *name
)
336 const char *port_str
;
338 port_str
= strchr (name
, ':');
340 if (port_str
== NULL
)
341 error ("Only HOST:PORT is supported on this platform.");
344 if (strcmp (name
, STDIO_CONNECTION_NAME
) == 0)
346 fprintf (stderr
, "Remote debugging using stdio\n");
348 /* Use stdin as the handle of the connection.
349 We only select on reads, for example. */
350 remote_desc
= fileno (stdin
);
352 enable_async_notification (remote_desc
);
354 /* Register the event loop handler. */
355 add_file_handler (remote_desc
, handle_serial_event
, NULL
);
358 else if (port_str
== NULL
)
362 if (stat (name
, &statbuf
) == 0
363 && (S_ISCHR (statbuf
.st_mode
) || S_ISFIFO (statbuf
.st_mode
)))
364 remote_desc
= open (name
, O_RDWR
);
372 perror_with_name ("Could not open remote device");
376 struct termios termios
;
377 tcgetattr (remote_desc
, &termios
);
382 termios
.c_cflag
&= ~(CSIZE
| PARENB
);
383 termios
.c_cflag
|= CLOCAL
| CS8
;
384 termios
.c_cc
[VMIN
] = 1;
385 termios
.c_cc
[VTIME
] = 0;
387 tcsetattr (remote_desc
, TCSANOW
, &termios
);
391 fprintf (stderr
, "Remote debugging using %s\n", name
);
393 enable_async_notification (remote_desc
);
395 /* Register the event loop handler. */
396 add_file_handler (remote_desc
, handle_serial_event
, NULL
);
398 #endif /* USE_WIN32API */
401 char listen_port
[GDB_NI_MAX_PORT
];
402 struct sockaddr_storage sockaddr
;
403 socklen_t len
= sizeof (sockaddr
);
405 if (getsockname (listen_desc
, (struct sockaddr
*) &sockaddr
, &len
) < 0)
406 perror_with_name ("Can't determine port");
408 int r
= getnameinfo ((struct sockaddr
*) &sockaddr
, len
,
410 listen_port
, sizeof (listen_port
),
414 fprintf (stderr
, _("Can't obtain port where we are listening: %s"),
417 fprintf (stderr
, _("Listening on port %s\n"), listen_port
);
421 /* Register the event loop handler. */
422 add_file_handler (listen_desc
, handle_accept_event
, NULL
);
429 delete_file_handler (remote_desc
);
434 closesocket (remote_desc
);
436 if (! remote_connection_is_stdio ())
439 remote_desc
= INVALID_DESCRIPTOR
;
446 #ifndef IN_PROCESS_AGENT
449 decode_address (CORE_ADDR
*addrp
, const char *start
, int len
)
456 for (i
= 0; i
< len
; i
++)
460 addr
= addr
| (fromhex (ch
) & 0x0f);
466 decode_address_to_semicolon (CORE_ADDR
*addrp
, const char *start
)
471 while (*end
!= '\0' && *end
!= ';')
474 decode_address (addrp
, start
, end
- start
);
483 #ifndef IN_PROCESS_AGENT
485 /* Look for a sequence of characters which can be run-length encoded.
486 If there are any, update *CSUM and *P. Otherwise, output the
487 single character. Return the number of characters consumed. */
490 try_rle (char *buf
, int remaining
, unsigned char *csum
, char **p
)
494 /* Always output the character. */
498 /* Don't go past '~'. */
502 for (n
= 1; n
< remaining
; n
++)
503 if (buf
[n
] != buf
[0])
506 /* N is the index of the first character not the same as buf[0].
507 buf[0] is counted twice, so by decrementing N, we get the number
508 of characters the RLE sequence will replace. */
514 /* Skip the frame characters. The manual says to skip '+' and '-'
515 also, but there's no reason to. Unfortunately these two unusable
516 characters double the encoded length of a four byte zero
518 while (n
+ 29 == '$' || n
+ 29 == '#')
531 #ifndef IN_PROCESS_AGENT
533 /* Write a PTID to BUF. Returns BUF+CHARACTERS_WRITTEN. */
536 write_ptid (char *buf
, ptid_t ptid
)
538 client_state
&cs
= get_client_state ();
541 if (cs
.multi_process
)
545 buf
+= sprintf (buf
, "p-%x.", -pid
);
547 buf
+= sprintf (buf
, "p%x.", pid
);
551 buf
+= sprintf (buf
, "-%x", -tid
);
553 buf
+= sprintf (buf
, "%x", tid
);
559 hex_or_minus_one (const char *buf
, const char **obuf
)
563 if (startswith (buf
, "-1"))
569 buf
= unpack_varlen_hex (buf
, &ret
);
577 /* Extract a PTID from BUF. If non-null, OBUF is set to the to one
578 passed the last parsed char. Returns null_ptid on error. */
580 read_ptid (const char *buf
, const char **obuf
)
584 ULONGEST pid
= 0, tid
= 0;
588 /* Multi-process ptid. */
589 pp
= unpack_varlen_hex (p
+ 1, &pid
);
591 error ("invalid remote ptid: %s\n", p
);
595 tid
= hex_or_minus_one (p
, &pp
);
599 return ptid_t (pid
, tid
, 0);
602 /* No multi-process. Just a tid. */
603 tid
= hex_or_minus_one (p
, &pp
);
605 /* Since GDB is not sending a process id (multi-process extensions
606 are off), then there's only one process. Default to the first in
608 pid
= pid_of (get_first_process ());
612 return ptid_t (pid
, tid
, 0);
615 /* Write COUNT bytes in BUF to the client.
616 The result is the number of bytes written or -1 if error.
617 This may return less than COUNT. */
620 write_prim (const void *buf
, int count
)
622 if (remote_connection_is_stdio ())
623 return write (fileno (stdout
), buf
, count
);
625 return write (remote_desc
, buf
, count
);
628 /* Read COUNT bytes from the client and store in BUF.
629 The result is the number of bytes read or -1 if error.
630 This may return less than COUNT. */
633 read_prim (void *buf
, int count
)
635 if (remote_connection_is_stdio ())
636 return read (fileno (stdin
), buf
, count
);
638 return read (remote_desc
, buf
, count
);
641 /* Send a packet to the remote machine, with error checking.
642 The data of the packet is in BUF, and the length of the
643 packet is in CNT. Returns >= 0 on success, -1 otherwise. */
646 putpkt_binary_1 (char *buf
, int cnt
, int is_notif
)
648 client_state
&cs
= get_client_state ();
650 unsigned char csum
= 0;
655 buf2
= (char *) xmalloc (strlen ("$") + cnt
+ strlen ("#nn") + 1);
657 /* Copy the packet into buffer BUF2, encapsulating it
658 and giving it a checksum. */
666 for (i
= 0; i
< cnt
;)
667 i
+= try_rle (buf
+ i
, cnt
- i
, &csum
, &p
);
670 *p
++ = tohex ((csum
>> 4) & 0xf);
671 *p
++ = tohex (csum
& 0xf);
675 /* Send it over and over until we get a positive ack. */
679 if (write_prim (buf2
, p
- buf2
) != p
- buf2
)
681 perror ("putpkt(write)");
686 if (cs
.noack_mode
|| is_notif
)
688 /* Don't expect an ack then. */
692 debug_printf ("putpkt (\"%s\"); [notif]\n", buf2
);
694 debug_printf ("putpkt (\"%s\"); [noack mode]\n", buf2
);
702 debug_printf ("putpkt (\"%s\"); [looking for ack]\n", buf2
);
716 debug_printf ("[received '%c' (0x%x)]\n", cc
, cc
);
720 /* Check for an input interrupt while we're here. */
721 if (cc
== '\003' && current_thread
!= NULL
)
722 (*the_target
->request_interrupt
) ();
727 return 1; /* Success! */
731 putpkt_binary (char *buf
, int cnt
)
733 return putpkt_binary_1 (buf
, cnt
, 0);
736 /* Send a packet to the remote machine, with error checking. The data
737 of the packet is in BUF, and the packet should be a NUL-terminated
738 string. Returns >= 0 on success, -1 otherwise. */
743 return putpkt_binary (buf
, strlen (buf
));
747 putpkt_notif (char *buf
)
749 return putpkt_binary_1 (buf
, strlen (buf
), 1);
752 /* Come here when we get an input interrupt from the remote side. This
753 interrupt should only be active while we are waiting for the child to do
754 something. Thus this assumes readchar:bufcnt is 0.
755 About the only thing that should come through is a ^C, which
756 will cause us to request child interruption. */
759 input_interrupt (int unused
)
762 struct timeval immediate
= { 0, 0 };
764 /* Protect against spurious interrupts. This has been observed to
765 be a problem under NetBSD 1.4 and 1.5. */
768 FD_SET (remote_desc
, &readset
);
769 if (select (remote_desc
+ 1, &readset
, 0, 0, &immediate
) > 0)
774 cc
= read_prim (&c
, 1);
778 fprintf (stderr
, "client connection closed\n");
781 else if (cc
!= 1 || c
!= '\003')
783 fprintf (stderr
, "input_interrupt, count = %d c = %d ", cc
, c
);
785 fprintf (stderr
, "('%c')\n", c
);
787 fprintf (stderr
, "('\\x%02x')\n", c
& 0xff);
791 (*the_target
->request_interrupt
) ();
795 /* Check if the remote side sent us an interrupt request (^C). */
797 check_remote_input_interrupt_request (void)
799 /* This function may be called before establishing communications,
800 therefore we need to validate the remote descriptor. */
802 if (remote_desc
== INVALID_DESCRIPTOR
)
808 /* Asynchronous I/O support. SIGIO must be unblocked when waiting,
809 in order to accept Control-C from the client, and must be blocked
810 when talking to the client. */
813 block_unblock_async_io (int block
)
818 sigemptyset (&sigio_set
);
819 sigaddset (&sigio_set
, SIGIO
);
820 sigprocmask (block
? SIG_BLOCK
: SIG_UNBLOCK
, &sigio_set
, NULL
);
826 nto_comctrl (int enable
)
828 struct sigevent event
;
832 event
.sigev_notify
= SIGEV_SIGNAL_THREAD
;
833 event
.sigev_signo
= SIGIO
;
834 event
.sigev_code
= 0;
835 event
.sigev_value
.sival_ptr
= NULL
;
836 event
.sigev_priority
= -1;
837 ionotify (remote_desc
, _NOTIFY_ACTION_POLLARM
, _NOTIFY_COND_INPUT
,
841 ionotify (remote_desc
, _NOTIFY_ACTION_POLL
, _NOTIFY_COND_INPUT
, NULL
);
846 /* Current state of asynchronous I/O. */
847 static int async_io_enabled
;
849 /* Enable asynchronous I/O. */
851 enable_async_io (void)
853 if (async_io_enabled
)
856 block_unblock_async_io (0);
858 async_io_enabled
= 1;
864 /* Disable asynchronous I/O. */
866 disable_async_io (void)
868 if (!async_io_enabled
)
871 block_unblock_async_io (1);
873 async_io_enabled
= 0;
881 initialize_async_io (void)
883 /* Make sure that async I/O starts blocked. */
884 async_io_enabled
= 1;
887 /* Install the signal handler. */
889 signal (SIGIO
, input_interrupt
);
893 /* Internal buffer used by readchar.
894 These are global to readchar because reschedule_remote needs to be
895 able to tell whether the buffer is empty. */
897 static unsigned char readchar_buf
[BUFSIZ
];
898 static int readchar_bufcnt
= 0;
899 static unsigned char *readchar_bufp
;
901 /* Returns next char from remote GDB. -1 if error. */
908 if (readchar_bufcnt
== 0)
910 readchar_bufcnt
= read_prim (readchar_buf
, sizeof (readchar_buf
));
912 if (readchar_bufcnt
<= 0)
914 if (readchar_bufcnt
== 0)
917 debug_printf ("readchar: Got EOF\n");
925 readchar_bufp
= readchar_buf
;
929 ch
= *readchar_bufp
++;
934 /* Reset the readchar state machine. */
937 reset_readchar (void)
940 if (readchar_callback
!= NOT_SCHEDULED
)
942 delete_callback_event (readchar_callback
);
943 readchar_callback
= NOT_SCHEDULED
;
947 /* Process remaining data in readchar_buf. */
950 process_remaining (void *context
)
954 /* This is a one-shot event. */
955 readchar_callback
= NOT_SCHEDULED
;
957 if (readchar_bufcnt
> 0)
958 res
= handle_serial_event (0, NULL
);
965 /* If there is still data in the buffer, queue another event to process it,
966 we can't sleep in select yet. */
971 if (readchar_bufcnt
> 0 && readchar_callback
== NOT_SCHEDULED
)
972 readchar_callback
= append_callback_event (process_remaining
, NULL
);
975 /* Read a packet from the remote machine, with error checking,
976 and store it in BUF. Returns length of packet, or negative if error. */
981 client_state
&cs
= get_client_state ();
983 unsigned char csum
, c1
, c2
;
994 /* The '\003' may appear before or after each packet, so
995 check for an input interrupt. */
998 (*the_target
->request_interrupt
) ();
1006 debug_printf ("[getpkt: discarding char '%c']\n", c
);
1027 c1
= fromhex (readchar ());
1028 c2
= fromhex (readchar ());
1030 if (csum
== (c1
<< 4) + c2
)
1036 "Bad checksum, sentsum=0x%x, csum=0x%x, "
1037 "buf=%s [no-ack-mode, Bad medium?]\n",
1038 (c1
<< 4) + c2
, csum
, buf
);
1039 /* Not much we can do, GDB wasn't expecting an ack/nac. */
1043 fprintf (stderr
, "Bad checksum, sentsum=0x%x, csum=0x%x, buf=%s\n",
1044 (c1
<< 4) + c2
, csum
, buf
);
1045 if (write_prim ("-", 1) != 1)
1053 debug_printf ("getpkt (\"%s\"); [sending ack] \n", buf
);
1057 if (write_prim ("+", 1) != 1)
1062 debug_printf ("[sent ack]\n");
1070 debug_printf ("getpkt (\"%s\"); [no ack sent] \n", buf
);
1075 /* The readchar above may have already read a '\003' out of the socket
1076 and moved it to the local buffer. For example, when GDB sends
1077 vCont;c immediately followed by interrupt (see
1078 gdb.base/interrupt-noterm.exp). As soon as we see the vCont;c, we'll
1079 resume the inferior and wait. Since we've already moved the '\003'
1080 to the local buffer, SIGIO won't help. In that case, if we don't
1081 check for interrupt after the vCont;c packet, the interrupt character
1082 would stay in the buffer unattended until after the next (unrelated)
1084 while (readchar_bufcnt
> 0 && *readchar_bufp
== '\003')
1086 /* Consume the interrupt character in the buffer. */
1088 (*the_target
->request_interrupt
) ();
1095 write_ok (char *buf
)
1103 write_enn (char *buf
)
1105 /* Some day, we should define the meanings of the error codes... */
1114 #ifndef IN_PROCESS_AGENT
1117 outreg (struct regcache
*regcache
, int regno
, char *buf
)
1119 if ((regno
>> 12) != 0)
1120 *buf
++ = tohex ((regno
>> 12) & 0xf);
1121 if ((regno
>> 8) != 0)
1122 *buf
++ = tohex ((regno
>> 8) & 0xf);
1123 *buf
++ = tohex ((regno
>> 4) & 0xf);
1124 *buf
++ = tohex (regno
& 0xf);
1126 collect_register_as_string (regcache
, regno
, buf
);
1127 buf
+= 2 * register_size (regcache
->tdesc
, regno
);
1134 prepare_resume_reply (char *buf
, ptid_t ptid
,
1135 struct target_waitstatus
*status
)
1137 client_state
&cs
= get_client_state ();
1139 debug_printf ("Writing resume reply for %s:%d\n",
1140 target_pid_to_str (ptid
), status
->kind
);
1142 switch (status
->kind
)
1144 case TARGET_WAITKIND_STOPPED
:
1145 case TARGET_WAITKIND_FORKED
:
1146 case TARGET_WAITKIND_VFORKED
:
1147 case TARGET_WAITKIND_VFORK_DONE
:
1148 case TARGET_WAITKIND_EXECD
:
1149 case TARGET_WAITKIND_THREAD_CREATED
:
1150 case TARGET_WAITKIND_SYSCALL_ENTRY
:
1151 case TARGET_WAITKIND_SYSCALL_RETURN
:
1153 struct thread_info
*saved_thread
;
1155 struct regcache
*regcache
;
1157 if ((status
->kind
== TARGET_WAITKIND_FORKED
&& cs
.report_fork_events
)
1158 || (status
->kind
== TARGET_WAITKIND_VFORKED
1159 && cs
.report_vfork_events
))
1161 enum gdb_signal signal
= GDB_SIGNAL_TRAP
;
1162 const char *event
= (status
->kind
== TARGET_WAITKIND_FORKED
1163 ? "fork" : "vfork");
1165 sprintf (buf
, "T%02x%s:", signal
, event
);
1166 buf
+= strlen (buf
);
1167 buf
= write_ptid (buf
, status
->value
.related_pid
);
1170 else if (status
->kind
== TARGET_WAITKIND_VFORK_DONE
1171 && cs
.report_vfork_events
)
1173 enum gdb_signal signal
= GDB_SIGNAL_TRAP
;
1175 sprintf (buf
, "T%02xvforkdone:;", signal
);
1177 else if (status
->kind
== TARGET_WAITKIND_EXECD
&& cs
.report_exec_events
)
1179 enum gdb_signal signal
= GDB_SIGNAL_TRAP
;
1180 const char *event
= "exec";
1181 char hexified_pathname
[PATH_MAX
* 2];
1183 sprintf (buf
, "T%02x%s:", signal
, event
);
1184 buf
+= strlen (buf
);
1186 /* Encode pathname to hexified format. */
1187 bin2hex ((const gdb_byte
*) status
->value
.execd_pathname
,
1189 strlen (status
->value
.execd_pathname
));
1191 sprintf (buf
, "%s;", hexified_pathname
);
1192 xfree (status
->value
.execd_pathname
);
1193 status
->value
.execd_pathname
= NULL
;
1194 buf
+= strlen (buf
);
1196 else if (status
->kind
== TARGET_WAITKIND_THREAD_CREATED
1197 && cs
.report_thread_events
)
1199 enum gdb_signal signal
= GDB_SIGNAL_TRAP
;
1201 sprintf (buf
, "T%02xcreate:;", signal
);
1203 else if (status
->kind
== TARGET_WAITKIND_SYSCALL_ENTRY
1204 || status
->kind
== TARGET_WAITKIND_SYSCALL_RETURN
)
1206 enum gdb_signal signal
= GDB_SIGNAL_TRAP
;
1207 const char *event
= (status
->kind
== TARGET_WAITKIND_SYSCALL_ENTRY
1208 ? "syscall_entry" : "syscall_return");
1210 sprintf (buf
, "T%02x%s:%x;", signal
, event
,
1211 status
->value
.syscall_number
);
1214 sprintf (buf
, "T%02x", status
->value
.sig
);
1216 buf
+= strlen (buf
);
1218 saved_thread
= current_thread
;
1220 switch_to_thread (ptid
);
1222 regp
= current_target_desc ()->expedite_regs
;
1224 regcache
= get_thread_regcache (current_thread
, 1);
1226 if (the_target
->stopped_by_watchpoint
!= NULL
1227 && (*the_target
->stopped_by_watchpoint
) ())
1232 memcpy (buf
, "watch:", 6);
1235 addr
= (*the_target
->stopped_data_address
) ();
1237 /* Convert each byte of the address into two hexadecimal
1238 chars. Note that we take sizeof (void *) instead of
1239 sizeof (addr); this is to avoid sending a 64-bit
1240 address to a 32-bit GDB. */
1241 for (i
= sizeof (void *) * 2; i
> 0; i
--)
1242 *buf
++ = tohex ((addr
>> (i
- 1) * 4) & 0xf);
1245 else if (cs
.swbreak_feature
&& target_stopped_by_sw_breakpoint ())
1247 sprintf (buf
, "swbreak:;");
1248 buf
+= strlen (buf
);
1250 else if (cs
.hwbreak_feature
&& target_stopped_by_hw_breakpoint ())
1252 sprintf (buf
, "hwbreak:;");
1253 buf
+= strlen (buf
);
1258 buf
= outreg (regcache
, find_regno (regcache
->tdesc
, *regp
), buf
);
1263 /* Formerly, if the debugger had not used any thread features
1264 we would not burden it with a thread status response. This
1265 was for the benefit of GDB 4.13 and older. However, in
1266 recent GDB versions the check (``if (cont_thread != 0)'')
1267 does not have the desired effect because of sillyness in
1268 the way that the remote protocol handles specifying a
1269 thread. Since thread support relies on qSymbol support
1270 anyway, assume GDB can handle threads. */
1272 if (using_threads
&& !disable_packet_Tthread
)
1274 /* This if (1) ought to be unnecessary. But remote_wait
1275 in GDB will claim this event belongs to inferior_ptid
1276 if we do not specify a thread, and there's no way for
1277 gdbserver to know what inferior_ptid is. */
1278 if (1 || cs
.general_thread
!= ptid
)
1281 /* In non-stop, don't change the general thread behind
1284 cs
.general_thread
= ptid
;
1285 sprintf (buf
, "thread:");
1286 buf
+= strlen (buf
);
1287 buf
= write_ptid (buf
, ptid
);
1289 buf
+= strlen (buf
);
1291 core
= target_core_of_thread (ptid
);
1295 sprintf (buf
, "core:");
1296 buf
+= strlen (buf
);
1297 sprintf (buf
, "%x", core
);
1299 buf
+= strlen (buf
);
1306 strcpy (buf
, "library:;");
1307 buf
+= strlen (buf
);
1311 current_thread
= saved_thread
;
1314 case TARGET_WAITKIND_EXITED
:
1315 if (cs
.multi_process
)
1316 sprintf (buf
, "W%x;process:%x",
1317 status
->value
.integer
, ptid
.pid ());
1319 sprintf (buf
, "W%02x", status
->value
.integer
);
1321 case TARGET_WAITKIND_SIGNALLED
:
1322 if (cs
.multi_process
)
1323 sprintf (buf
, "X%x;process:%x",
1324 status
->value
.sig
, ptid
.pid ());
1326 sprintf (buf
, "X%02x", status
->value
.sig
);
1328 case TARGET_WAITKIND_THREAD_EXITED
:
1329 sprintf (buf
, "w%x;", status
->value
.integer
);
1330 buf
+= strlen (buf
);
1331 buf
= write_ptid (buf
, ptid
);
1333 case TARGET_WAITKIND_NO_RESUMED
:
1337 error ("unhandled waitkind");
1343 decode_m_packet (char *from
, CORE_ADDR
*mem_addr_ptr
, unsigned int *len_ptr
)
1347 *mem_addr_ptr
= *len_ptr
= 0;
1349 while ((ch
= from
[i
++]) != ',')
1351 *mem_addr_ptr
= *mem_addr_ptr
<< 4;
1352 *mem_addr_ptr
|= fromhex (ch
) & 0x0f;
1355 for (j
= 0; j
< 4; j
++)
1357 if ((ch
= from
[i
++]) == 0)
1359 *len_ptr
= *len_ptr
<< 4;
1360 *len_ptr
|= fromhex (ch
) & 0x0f;
1365 decode_M_packet (char *from
, CORE_ADDR
*mem_addr_ptr
, unsigned int *len_ptr
,
1366 unsigned char **to_p
)
1370 *mem_addr_ptr
= *len_ptr
= 0;
1372 while ((ch
= from
[i
++]) != ',')
1374 *mem_addr_ptr
= *mem_addr_ptr
<< 4;
1375 *mem_addr_ptr
|= fromhex (ch
) & 0x0f;
1378 while ((ch
= from
[i
++]) != ':')
1380 *len_ptr
= *len_ptr
<< 4;
1381 *len_ptr
|= fromhex (ch
) & 0x0f;
1385 *to_p
= (unsigned char *) xmalloc (*len_ptr
);
1387 hex2bin (&from
[i
++], *to_p
, *len_ptr
);
1391 decode_X_packet (char *from
, int packet_len
, CORE_ADDR
*mem_addr_ptr
,
1392 unsigned int *len_ptr
, unsigned char **to_p
)
1396 *mem_addr_ptr
= *len_ptr
= 0;
1398 while ((ch
= from
[i
++]) != ',')
1400 *mem_addr_ptr
= *mem_addr_ptr
<< 4;
1401 *mem_addr_ptr
|= fromhex (ch
) & 0x0f;
1404 while ((ch
= from
[i
++]) != ':')
1406 *len_ptr
= *len_ptr
<< 4;
1407 *len_ptr
|= fromhex (ch
) & 0x0f;
1411 *to_p
= (unsigned char *) xmalloc (*len_ptr
);
1413 if (remote_unescape_input ((const gdb_byte
*) &from
[i
], packet_len
- i
,
1414 *to_p
, *len_ptr
) != *len_ptr
)
1420 /* Decode a qXfer write request. */
1423 decode_xfer_write (char *buf
, int packet_len
, CORE_ADDR
*offset
,
1424 unsigned int *len
, unsigned char *data
)
1429 /* Extract the offset. */
1431 while ((ch
= *buf
++) != ':')
1433 *offset
= *offset
<< 4;
1434 *offset
|= fromhex (ch
) & 0x0f;
1437 /* Get encoded data. */
1438 packet_len
-= buf
- b
;
1439 *len
= remote_unescape_input ((const gdb_byte
*) buf
, packet_len
,
1444 /* Decode the parameters of a qSearch:memory packet. */
1447 decode_search_memory_packet (const char *buf
, int packet_len
,
1448 CORE_ADDR
*start_addrp
,
1449 CORE_ADDR
*search_space_lenp
,
1450 gdb_byte
*pattern
, unsigned int *pattern_lenp
)
1452 const char *p
= buf
;
1454 p
= decode_address_to_semicolon (start_addrp
, p
);
1455 p
= decode_address_to_semicolon (search_space_lenp
, p
);
1456 packet_len
-= p
- buf
;
1457 *pattern_lenp
= remote_unescape_input ((const gdb_byte
*) p
, packet_len
,
1458 pattern
, packet_len
);
1463 free_sym_cache (struct sym_cache
*sym
)
1473 clear_symbol_cache (struct sym_cache
**symcache_p
)
1475 struct sym_cache
*sym
, *next
;
1477 /* Check the cache first. */
1478 for (sym
= *symcache_p
; sym
; sym
= next
)
1481 free_sym_cache (sym
);
1487 /* Get the address of NAME, and return it in ADDRP if found. if
1488 MAY_ASK_GDB is false, assume symbol cache misses are failures.
1489 Returns 1 if the symbol is found, 0 if it is not, -1 on error. */
1492 look_up_one_symbol (const char *name
, CORE_ADDR
*addrp
, int may_ask_gdb
)
1494 client_state
&cs
= get_client_state ();
1497 struct sym_cache
*sym
;
1498 struct process_info
*proc
;
1500 proc
= current_process ();
1502 /* Check the cache first. */
1503 for (sym
= proc
->symbol_cache
; sym
; sym
= sym
->next
)
1504 if (strcmp (name
, sym
->name
) == 0)
1510 /* It might not be an appropriate time to look up a symbol,
1511 e.g. while we're trying to fetch registers. */
1515 /* Send the request. */
1516 strcpy (cs
.own_buf
, "qSymbol:");
1517 bin2hex ((const gdb_byte
*) name
, cs
.own_buf
+ strlen ("qSymbol:"),
1519 if (putpkt (cs
.own_buf
) < 0)
1522 /* FIXME: Eventually add buffer overflow checking (to getpkt?) */
1523 len
= getpkt (cs
.own_buf
);
1527 /* We ought to handle pretty much any packet at this point while we
1528 wait for the qSymbol "response". That requires re-entering the
1529 main loop. For now, this is an adequate approximation; allow
1530 GDB to read from memory and handle 'v' packets (for vFile transfers)
1531 while it figures out the address of the symbol. */
1534 if (cs
.own_buf
[0] == 'm')
1537 unsigned char *mem_buf
;
1538 unsigned int mem_len
;
1540 decode_m_packet (&cs
.own_buf
[1], &mem_addr
, &mem_len
);
1541 mem_buf
= (unsigned char *) xmalloc (mem_len
);
1542 if (read_inferior_memory (mem_addr
, mem_buf
, mem_len
) == 0)
1543 bin2hex (mem_buf
, cs
.own_buf
, mem_len
);
1545 write_enn (cs
.own_buf
);
1547 if (putpkt (cs
.own_buf
) < 0)
1550 else if (cs
.own_buf
[0] == 'v')
1553 handle_v_requests (cs
.own_buf
, len
, &new_len
);
1555 putpkt_binary (cs
.own_buf
, new_len
);
1557 putpkt (cs
.own_buf
);
1561 len
= getpkt (cs
.own_buf
);
1566 if (!startswith (cs
.own_buf
, "qSymbol:"))
1568 warning ("Malformed response to qSymbol, ignoring: %s\n", cs
.own_buf
);
1572 p
= cs
.own_buf
+ strlen ("qSymbol:");
1574 while (*q
&& *q
!= ':')
1577 /* Make sure we found a value for the symbol. */
1578 if (p
== q
|| *q
== '\0')
1581 decode_address (addrp
, p
, q
- p
);
1583 /* Save the symbol in our cache. */
1584 sym
= XNEW (struct sym_cache
);
1585 sym
->name
= xstrdup (name
);
1587 sym
->next
= proc
->symbol_cache
;
1588 proc
->symbol_cache
= sym
;
1593 /* Relocate an instruction to execute at a different address. OLDLOC
1594 is the address in the inferior memory where the instruction to
1595 relocate is currently at. On input, TO points to the destination
1596 where we want the instruction to be copied (and possibly adjusted)
1597 to. On output, it points to one past the end of the resulting
1598 instruction(s). The effect of executing the instruction at TO
1599 shall be the same as if executing it at OLDLOC. For example, call
1600 instructions that implicitly push the return address on the stack
1601 should be adjusted to return to the instruction after OLDLOC;
1602 relative branches, and other PC-relative instructions need the
1603 offset adjusted; etc. Returns 0 on success, -1 on failure. */
1606 relocate_instruction (CORE_ADDR
*to
, CORE_ADDR oldloc
)
1608 client_state
&cs
= get_client_state ();
1610 ULONGEST written
= 0;
1612 /* Send the request. */
1613 sprintf (cs
.own_buf
, "qRelocInsn:%s;%s", paddress (oldloc
),
1615 if (putpkt (cs
.own_buf
) < 0)
1618 /* FIXME: Eventually add buffer overflow checking (to getpkt?) */
1619 len
= getpkt (cs
.own_buf
);
1623 /* We ought to handle pretty much any packet at this point while we
1624 wait for the qRelocInsn "response". That requires re-entering
1625 the main loop. For now, this is an adequate approximation; allow
1626 GDB to access memory. */
1627 while (cs
.own_buf
[0] == 'm' || cs
.own_buf
[0] == 'M' || cs
.own_buf
[0] == 'X')
1630 unsigned char *mem_buf
= NULL
;
1631 unsigned int mem_len
;
1633 if (cs
.own_buf
[0] == 'm')
1635 decode_m_packet (&cs
.own_buf
[1], &mem_addr
, &mem_len
);
1636 mem_buf
= (unsigned char *) xmalloc (mem_len
);
1637 if (read_inferior_memory (mem_addr
, mem_buf
, mem_len
) == 0)
1638 bin2hex (mem_buf
, cs
.own_buf
, mem_len
);
1640 write_enn (cs
.own_buf
);
1642 else if (cs
.own_buf
[0] == 'X')
1644 if (decode_X_packet (&cs
.own_buf
[1], len
- 1, &mem_addr
,
1645 &mem_len
, &mem_buf
) < 0
1646 || write_inferior_memory (mem_addr
, mem_buf
, mem_len
) != 0)
1647 write_enn (cs
.own_buf
);
1649 write_ok (cs
.own_buf
);
1653 decode_M_packet (&cs
.own_buf
[1], &mem_addr
, &mem_len
, &mem_buf
);
1654 if (write_inferior_memory (mem_addr
, mem_buf
, mem_len
) == 0)
1655 write_ok (cs
.own_buf
);
1657 write_enn (cs
.own_buf
);
1660 if (putpkt (cs
.own_buf
) < 0)
1662 len
= getpkt (cs
.own_buf
);
1667 if (cs
.own_buf
[0] == 'E')
1669 warning ("An error occurred while relocating an instruction: %s\n",
1674 if (!startswith (cs
.own_buf
, "qRelocInsn:"))
1676 warning ("Malformed response to qRelocInsn, ignoring: %s\n",
1681 unpack_varlen_hex (cs
.own_buf
+ strlen ("qRelocInsn:"), &written
);
1688 monitor_output (const char *msg
)
1690 int len
= strlen (msg
);
1691 char *buf
= (char *) xmalloc (len
* 2 + 2);
1694 bin2hex ((const gdb_byte
*) msg
, buf
+ 1, len
);