1 /* Remote utility routines for the remote server for GDB.
2 Copyright (C) 1986-2017 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"
31 #include <sys/ioctl.h>
37 #include <netinet/in.h>
40 #include <sys/socket.h>
45 #if HAVE_NETINET_TCP_H
46 #include <netinet/tcp.h>
49 #include <sys/ioctl.h>
57 #include "gdb_sys_time.h"
60 #include <arpa/inet.h>
69 #include <sys/iomgr.h>
72 #ifndef HAVE_SOCKLEN_T
73 typedef int socklen_t
;
76 #ifndef IN_PROCESS_AGENT
79 # define INVALID_DESCRIPTOR INVALID_SOCKET
81 # define INVALID_DESCRIPTOR -1
84 /* Extra value for readchar_callback. */
86 /* The callback is currently not scheduled. */
90 /* Status of the readchar callback.
91 Either NOT_SCHEDULED or the callback id. */
92 static int readchar_callback
= NOT_SCHEDULED
;
94 static int readchar (void);
95 static void reset_readchar (void);
96 static void reschedule (void);
98 /* A cache entry for a successfully looked-up symbol. */
103 struct sym_cache
*next
;
106 int remote_debug
= 0;
107 struct ui_file
*gdb_stdlog
;
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
;
114 /* FIXME headerize? */
115 extern int using_threads
;
116 extern int debug_threads
;
118 /* If true, then GDB has requested noack mode. */
120 /* If true, then we tell GDB to use noack mode by default. */
121 int transport_is_reliable
= 0;
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_in sockaddr
;
163 debug_printf ("handling possible accept event\n");
165 tmp
= sizeof (sockaddr
);
166 remote_desc
= accept (listen_desc
, (struct sockaddr
*) &sockaddr
, &tmp
);
167 if (remote_desc
== -1)
168 perror_with_name ("Accept failed");
170 /* Enable TCP keep alive process. */
172 setsockopt (remote_desc
, SOL_SOCKET
, SO_KEEPALIVE
,
173 (char *) &tmp
, sizeof (tmp
));
175 /* Tell TCP not to delay small packets. This greatly speeds up
176 interactive response. */
178 setsockopt (remote_desc
, IPPROTO_TCP
, TCP_NODELAY
,
179 (char *) &tmp
, sizeof (tmp
));
182 signal (SIGPIPE
, SIG_IGN
); /* If we don't do this, then gdbserver simply
183 exits when the remote side dies. */
189 close (listen_desc
); /* No longer need this */
191 closesocket (listen_desc
); /* No longer need this */
195 /* Even if !RUN_ONCE no longer notice new connections. Still keep the
196 descriptor open for add_file_handler to wait for a new connection. */
197 delete_file_handler (listen_desc
);
199 /* Convert IP address to string. */
200 fprintf (stderr
, "Remote debugging from host %s\n",
201 inet_ntoa (sockaddr
.sin_addr
));
203 enable_async_notification (remote_desc
);
205 /* Register the event loop handler. */
206 add_file_handler (remote_desc
, handle_serial_event
, NULL
);
208 /* We have a new GDB connection now. If we were disconnected
209 tracing, there's a window where the target could report a stop
210 event to the event loop, and since we have a connection now, we'd
211 try to send vStopped notifications to GDB. But, don't do that
212 until GDB as selected all-stop/non-stop, and has queried the
213 threads' status ('?'). */
219 /* Prepare for a later connection to a remote debugger.
220 NAME is the filename used for communication. */
223 remote_prepare (const char *name
)
225 const char *port_str
;
227 static int winsock_initialized
;
230 struct sockaddr_in sockaddr
;
235 if (strcmp (name
, STDIO_CONNECTION_NAME
) == 0)
237 /* We need to record fact that we're using stdio sooner than the
238 call to remote_open so start_inferior knows the connection is
241 transport_is_reliable
= 1;
245 port_str
= strchr (name
, ':');
246 if (port_str
== NULL
)
248 transport_is_reliable
= 0;
252 port
= strtoul (port_str
+ 1, &port_end
, 10);
253 if (port_str
[1] == '\0' || *port_end
!= '\0')
254 error ("Bad port argument: %s", name
);
257 if (!winsock_initialized
)
261 WSAStartup (MAKEWORD (1, 0), &wsad
);
262 winsock_initialized
= 1;
266 listen_desc
= socket (PF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
267 if (listen_desc
== -1)
268 perror_with_name ("Can't open socket");
270 /* Allow rapid reuse of this port. */
272 setsockopt (listen_desc
, SOL_SOCKET
, SO_REUSEADDR
, (char *) &tmp
,
275 sockaddr
.sin_family
= PF_INET
;
276 sockaddr
.sin_port
= htons (port
);
277 sockaddr
.sin_addr
.s_addr
= INADDR_ANY
;
279 if (bind (listen_desc
, (struct sockaddr
*) &sockaddr
, sizeof (sockaddr
))
280 || listen (listen_desc
, 1))
281 perror_with_name ("Can't bind address");
283 transport_is_reliable
= 1;
286 /* Open a connection to a remote debugger.
287 NAME is the filename used for communication. */
290 remote_open (const char *name
)
292 const char *port_str
;
294 port_str
= strchr (name
, ':');
296 if (port_str
== NULL
)
297 error ("Only <host>:<port> is supported on this platform.");
300 if (strcmp (name
, STDIO_CONNECTION_NAME
) == 0)
302 fprintf (stderr
, "Remote debugging using stdio\n");
304 /* Use stdin as the handle of the connection.
305 We only select on reads, for example. */
306 remote_desc
= fileno (stdin
);
308 enable_async_notification (remote_desc
);
310 /* Register the event loop handler. */
311 add_file_handler (remote_desc
, handle_serial_event
, NULL
);
314 else if (port_str
== NULL
)
318 if (stat (name
, &statbuf
) == 0
319 && (S_ISCHR (statbuf
.st_mode
) || S_ISFIFO (statbuf
.st_mode
)))
320 remote_desc
= open (name
, O_RDWR
);
328 perror_with_name ("Could not open remote device");
332 struct termios termios
;
333 tcgetattr (remote_desc
, &termios
);
338 termios
.c_cflag
&= ~(CSIZE
| PARENB
);
339 termios
.c_cflag
|= CLOCAL
| CS8
;
340 termios
.c_cc
[VMIN
] = 1;
341 termios
.c_cc
[VTIME
] = 0;
343 tcsetattr (remote_desc
, TCSANOW
, &termios
);
347 fprintf (stderr
, "Remote debugging using %s\n", name
);
349 enable_async_notification (remote_desc
);
351 /* Register the event loop handler. */
352 add_file_handler (remote_desc
, handle_serial_event
, NULL
);
354 #endif /* USE_WIN32API */
359 struct sockaddr_in sockaddr
;
361 len
= sizeof (sockaddr
);
362 if (getsockname (listen_desc
,
363 (struct sockaddr
*) &sockaddr
, &len
) < 0
364 || len
< sizeof (sockaddr
))
365 perror_with_name ("Can't determine port");
366 port
= ntohs (sockaddr
.sin_port
);
368 fprintf (stderr
, "Listening on port %d\n", port
);
371 /* Register the event loop handler. */
372 add_file_handler (listen_desc
, handle_accept_event
, NULL
);
379 delete_file_handler (remote_desc
);
382 /* Remove SIGIO handler. */
383 signal (SIGIO
, SIG_IGN
);
387 closesocket (remote_desc
);
389 if (! remote_connection_is_stdio ())
392 remote_desc
= INVALID_DESCRIPTOR
;
399 #ifndef IN_PROCESS_AGENT
402 decode_address (CORE_ADDR
*addrp
, const char *start
, int len
)
409 for (i
= 0; i
< len
; i
++)
413 addr
= addr
| (fromhex (ch
) & 0x0f);
419 decode_address_to_semicolon (CORE_ADDR
*addrp
, const char *start
)
424 while (*end
!= '\0' && *end
!= ';')
427 decode_address (addrp
, start
, end
- start
);
436 #ifndef IN_PROCESS_AGENT
438 /* Look for a sequence of characters which can be run-length encoded.
439 If there are any, update *CSUM and *P. Otherwise, output the
440 single character. Return the number of characters consumed. */
443 try_rle (char *buf
, int remaining
, unsigned char *csum
, char **p
)
447 /* Always output the character. */
451 /* Don't go past '~'. */
455 for (n
= 1; n
< remaining
; n
++)
456 if (buf
[n
] != buf
[0])
459 /* N is the index of the first character not the same as buf[0].
460 buf[0] is counted twice, so by decrementing N, we get the number
461 of characters the RLE sequence will replace. */
467 /* Skip the frame characters. The manual says to skip '+' and '-'
468 also, but there's no reason to. Unfortunately these two unusable
469 characters double the encoded length of a four byte zero
471 while (n
+ 29 == '$' || n
+ 29 == '#')
484 #ifndef IN_PROCESS_AGENT
486 /* Write a PTID to BUF. Returns BUF+CHARACTERS_WRITTEN. */
489 write_ptid (char *buf
, ptid_t ptid
)
495 pid
= ptid_get_pid (ptid
);
497 buf
+= sprintf (buf
, "p-%x.", -pid
);
499 buf
+= sprintf (buf
, "p%x.", pid
);
501 tid
= ptid_get_lwp (ptid
);
503 buf
+= sprintf (buf
, "-%x", -tid
);
505 buf
+= sprintf (buf
, "%x", tid
);
511 hex_or_minus_one (const char *buf
, const char **obuf
)
515 if (startswith (buf
, "-1"))
521 buf
= unpack_varlen_hex (buf
, &ret
);
529 /* Extract a PTID from BUF. If non-null, OBUF is set to the to one
530 passed the last parsed char. Returns null_ptid on error. */
532 read_ptid (const char *buf
, const char **obuf
)
536 ULONGEST pid
= 0, tid
= 0;
540 /* Multi-process ptid. */
541 pp
= unpack_varlen_hex (p
+ 1, &pid
);
543 error ("invalid remote ptid: %s\n", p
);
547 tid
= hex_or_minus_one (p
, &pp
);
551 return ptid_build (pid
, tid
, 0);
554 /* No multi-process. Just a tid. */
555 tid
= hex_or_minus_one (p
, &pp
);
557 /* Since GDB is not sending a process id (multi-process extensions
558 are off), then there's only one process. Default to the first in
560 pid
= pid_of (get_first_process ());
564 return ptid_build (pid
, tid
, 0);
567 /* Write COUNT bytes in BUF to the client.
568 The result is the number of bytes written or -1 if error.
569 This may return less than COUNT. */
572 write_prim (const void *buf
, int count
)
574 if (remote_connection_is_stdio ())
575 return write (fileno (stdout
), buf
, count
);
577 return write (remote_desc
, buf
, count
);
580 /* Read COUNT bytes from the client and store in BUF.
581 The result is the number of bytes read or -1 if error.
582 This may return less than COUNT. */
585 read_prim (void *buf
, int count
)
587 if (remote_connection_is_stdio ())
588 return read (fileno (stdin
), buf
, count
);
590 return read (remote_desc
, buf
, count
);
593 /* Send a packet to the remote machine, with error checking.
594 The data of the packet is in BUF, and the length of the
595 packet is in CNT. Returns >= 0 on success, -1 otherwise. */
598 putpkt_binary_1 (char *buf
, int cnt
, int is_notif
)
601 unsigned char csum
= 0;
606 buf2
= (char *) xmalloc (strlen ("$") + cnt
+ strlen ("#nn") + 1);
608 /* Copy the packet into buffer BUF2, encapsulating it
609 and giving it a checksum. */
617 for (i
= 0; i
< cnt
;)
618 i
+= try_rle (buf
+ i
, cnt
- i
, &csum
, &p
);
621 *p
++ = tohex ((csum
>> 4) & 0xf);
622 *p
++ = tohex (csum
& 0xf);
626 /* Send it over and over until we get a positive ack. */
630 if (write_prim (buf2
, p
- buf2
) != p
- buf2
)
632 perror ("putpkt(write)");
637 if (noack_mode
|| is_notif
)
639 /* Don't expect an ack then. */
643 debug_printf ("putpkt (\"%s\"); [notif]\n", buf2
);
645 debug_printf ("putpkt (\"%s\"); [noack mode]\n", buf2
);
653 debug_printf ("putpkt (\"%s\"); [looking for ack]\n", buf2
);
667 debug_printf ("[received '%c' (0x%x)]\n", cc
, cc
);
671 /* Check for an input interrupt while we're here. */
672 if (cc
== '\003' && current_thread
!= NULL
)
673 (*the_target
->request_interrupt
) ();
678 return 1; /* Success! */
682 putpkt_binary (char *buf
, int cnt
)
684 return putpkt_binary_1 (buf
, cnt
, 0);
687 /* Send a packet to the remote machine, with error checking. The data
688 of the packet is in BUF, and the packet should be a NUL-terminated
689 string. Returns >= 0 on success, -1 otherwise. */
694 return putpkt_binary (buf
, strlen (buf
));
698 putpkt_notif (char *buf
)
700 return putpkt_binary_1 (buf
, strlen (buf
), 1);
703 /* Come here when we get an input interrupt from the remote side. This
704 interrupt should only be active while we are waiting for the child to do
705 something. Thus this assumes readchar:bufcnt is 0.
706 About the only thing that should come through is a ^C, which
707 will cause us to request child interruption. */
710 input_interrupt (int unused
)
713 struct timeval immediate
= { 0, 0 };
715 /* Protect against spurious interrupts. This has been observed to
716 be a problem under NetBSD 1.4 and 1.5. */
719 FD_SET (remote_desc
, &readset
);
720 if (select (remote_desc
+ 1, &readset
, 0, 0, &immediate
) > 0)
725 cc
= read_prim (&c
, 1);
729 fprintf (stderr
, "client connection closed\n");
732 else if (cc
!= 1 || c
!= '\003')
734 fprintf (stderr
, "input_interrupt, count = %d c = %d ", cc
, c
);
736 fprintf (stderr
, "('%c')\n", c
);
738 fprintf (stderr
, "('\\x%02x')\n", c
& 0xff);
742 (*the_target
->request_interrupt
) ();
746 /* Check if the remote side sent us an interrupt request (^C). */
748 check_remote_input_interrupt_request (void)
750 /* This function may be called before establishing communications,
751 therefore we need to validate the remote descriptor. */
753 if (remote_desc
== INVALID_DESCRIPTOR
)
759 /* Asynchronous I/O support. SIGIO must be unblocked when waiting,
760 in order to accept Control-C from the client, and must be blocked
761 when talking to the client. */
764 block_unblock_async_io (int block
)
769 sigemptyset (&sigio_set
);
770 sigaddset (&sigio_set
, SIGIO
);
771 sigprocmask (block
? SIG_BLOCK
: SIG_UNBLOCK
, &sigio_set
, NULL
);
777 nto_comctrl (int enable
)
779 struct sigevent event
;
783 event
.sigev_notify
= SIGEV_SIGNAL_THREAD
;
784 event
.sigev_signo
= SIGIO
;
785 event
.sigev_code
= 0;
786 event
.sigev_value
.sival_ptr
= NULL
;
787 event
.sigev_priority
= -1;
788 ionotify (remote_desc
, _NOTIFY_ACTION_POLLARM
, _NOTIFY_COND_INPUT
,
792 ionotify (remote_desc
, _NOTIFY_ACTION_POLL
, _NOTIFY_COND_INPUT
, NULL
);
797 /* Current state of asynchronous I/O. */
798 static int async_io_enabled
;
800 /* Enable asynchronous I/O. */
802 enable_async_io (void)
804 if (async_io_enabled
)
807 block_unblock_async_io (0);
809 async_io_enabled
= 1;
815 /* Disable asynchronous I/O. */
817 disable_async_io (void)
819 if (!async_io_enabled
)
822 block_unblock_async_io (1);
824 async_io_enabled
= 0;
832 initialize_async_io (void)
834 /* Make sure that async I/O starts blocked. */
835 async_io_enabled
= 1;
838 /* Install the signal handler. */
840 signal (SIGIO
, input_interrupt
);
844 /* Internal buffer used by readchar.
845 These are global to readchar because reschedule_remote needs to be
846 able to tell whether the buffer is empty. */
848 static unsigned char readchar_buf
[BUFSIZ
];
849 static int readchar_bufcnt
= 0;
850 static unsigned char *readchar_bufp
;
852 /* Returns next char from remote GDB. -1 if error. */
859 if (readchar_bufcnt
== 0)
861 readchar_bufcnt
= read_prim (readchar_buf
, sizeof (readchar_buf
));
863 if (readchar_bufcnt
<= 0)
865 if (readchar_bufcnt
== 0)
868 debug_printf ("readchar: Got EOF\n");
876 readchar_bufp
= readchar_buf
;
880 ch
= *readchar_bufp
++;
885 /* Reset the readchar state machine. */
888 reset_readchar (void)
891 if (readchar_callback
!= NOT_SCHEDULED
)
893 delete_callback_event (readchar_callback
);
894 readchar_callback
= NOT_SCHEDULED
;
898 /* Process remaining data in readchar_buf. */
901 process_remaining (void *context
)
905 /* This is a one-shot event. */
906 readchar_callback
= NOT_SCHEDULED
;
908 if (readchar_bufcnt
> 0)
909 res
= handle_serial_event (0, NULL
);
916 /* If there is still data in the buffer, queue another event to process it,
917 we can't sleep in select yet. */
922 if (readchar_bufcnt
> 0 && readchar_callback
== NOT_SCHEDULED
)
923 readchar_callback
= append_callback_event (process_remaining
, NULL
);
926 /* Read a packet from the remote machine, with error checking,
927 and store it in BUF. Returns length of packet, or negative if error. */
933 unsigned char csum
, c1
, c2
;
944 /* The '\003' may appear before or after each packet, so
945 check for an input interrupt. */
948 (*the_target
->request_interrupt
) ();
956 debug_printf ("[getpkt: discarding char '%c']\n", c
);
977 c1
= fromhex (readchar ());
978 c2
= fromhex (readchar ());
980 if (csum
== (c1
<< 4) + c2
)
986 "Bad checksum, sentsum=0x%x, csum=0x%x, "
987 "buf=%s [no-ack-mode, Bad medium?]\n",
988 (c1
<< 4) + c2
, csum
, buf
);
989 /* Not much we can do, GDB wasn't expecting an ack/nac. */
993 fprintf (stderr
, "Bad checksum, sentsum=0x%x, csum=0x%x, buf=%s\n",
994 (c1
<< 4) + c2
, csum
, buf
);
995 if (write_prim ("-", 1) != 1)
1003 debug_printf ("getpkt (\"%s\"); [sending ack] \n", buf
);
1007 if (write_prim ("+", 1) != 1)
1012 debug_printf ("[sent ack]\n");
1020 debug_printf ("getpkt (\"%s\"); [no ack sent] \n", buf
);
1025 /* The readchar above may have already read a '\003' out of the socket
1026 and moved it to the local buffer. For example, when GDB sends
1027 vCont;c immediately followed by interrupt (see
1028 gdb.base/interrupt-noterm.exp). As soon as we see the vCont;c, we'll
1029 resume the inferior and wait. Since we've already moved the '\003'
1030 to the local buffer, SIGIO won't help. In that case, if we don't
1031 check for interrupt after the vCont;c packet, the interrupt character
1032 would stay in the buffer unattended until after the next (unrelated)
1034 while (readchar_bufcnt
> 0 && *readchar_bufp
== '\003')
1036 /* Consume the interrupt character in the buffer. */
1038 (*the_target
->request_interrupt
) ();
1045 write_ok (char *buf
)
1053 write_enn (char *buf
)
1055 /* Some day, we should define the meanings of the error codes... */
1064 #ifndef IN_PROCESS_AGENT
1067 outreg (struct regcache
*regcache
, int regno
, char *buf
)
1069 if ((regno
>> 12) != 0)
1070 *buf
++ = tohex ((regno
>> 12) & 0xf);
1071 if ((regno
>> 8) != 0)
1072 *buf
++ = tohex ((regno
>> 8) & 0xf);
1073 *buf
++ = tohex ((regno
>> 4) & 0xf);
1074 *buf
++ = tohex (regno
& 0xf);
1076 collect_register_as_string (regcache
, regno
, buf
);
1077 buf
+= 2 * register_size (regcache
->tdesc
, regno
);
1084 prepare_resume_reply (char *buf
, ptid_t ptid
,
1085 struct target_waitstatus
*status
)
1088 debug_printf ("Writing resume reply for %s:%d\n",
1089 target_pid_to_str (ptid
), status
->kind
);
1091 switch (status
->kind
)
1093 case TARGET_WAITKIND_STOPPED
:
1094 case TARGET_WAITKIND_FORKED
:
1095 case TARGET_WAITKIND_VFORKED
:
1096 case TARGET_WAITKIND_VFORK_DONE
:
1097 case TARGET_WAITKIND_EXECD
:
1098 case TARGET_WAITKIND_THREAD_CREATED
:
1099 case TARGET_WAITKIND_SYSCALL_ENTRY
:
1100 case TARGET_WAITKIND_SYSCALL_RETURN
:
1102 struct thread_info
*saved_thread
;
1104 struct regcache
*regcache
;
1106 if ((status
->kind
== TARGET_WAITKIND_FORKED
&& report_fork_events
)
1107 || (status
->kind
== TARGET_WAITKIND_VFORKED
&& report_vfork_events
))
1109 enum gdb_signal signal
= GDB_SIGNAL_TRAP
;
1110 const char *event
= (status
->kind
== TARGET_WAITKIND_FORKED
1111 ? "fork" : "vfork");
1113 sprintf (buf
, "T%02x%s:", signal
, event
);
1114 buf
+= strlen (buf
);
1115 buf
= write_ptid (buf
, status
->value
.related_pid
);
1118 else if (status
->kind
== TARGET_WAITKIND_VFORK_DONE
&& report_vfork_events
)
1120 enum gdb_signal signal
= GDB_SIGNAL_TRAP
;
1122 sprintf (buf
, "T%02xvforkdone:;", signal
);
1124 else if (status
->kind
== TARGET_WAITKIND_EXECD
&& report_exec_events
)
1126 enum gdb_signal signal
= GDB_SIGNAL_TRAP
;
1127 const char *event
= "exec";
1128 char hexified_pathname
[PATH_MAX
* 2];
1130 sprintf (buf
, "T%02x%s:", signal
, event
);
1131 buf
+= strlen (buf
);
1133 /* Encode pathname to hexified format. */
1134 bin2hex ((const gdb_byte
*) status
->value
.execd_pathname
,
1136 strlen (status
->value
.execd_pathname
));
1138 sprintf (buf
, "%s;", hexified_pathname
);
1139 xfree (status
->value
.execd_pathname
);
1140 status
->value
.execd_pathname
= NULL
;
1141 buf
+= strlen (buf
);
1143 else if (status
->kind
== TARGET_WAITKIND_THREAD_CREATED
1144 && report_thread_events
)
1146 enum gdb_signal signal
= GDB_SIGNAL_TRAP
;
1148 sprintf (buf
, "T%02xcreate:;", signal
);
1150 else if (status
->kind
== TARGET_WAITKIND_SYSCALL_ENTRY
1151 || status
->kind
== TARGET_WAITKIND_SYSCALL_RETURN
)
1153 enum gdb_signal signal
= GDB_SIGNAL_TRAP
;
1154 const char *event
= (status
->kind
== TARGET_WAITKIND_SYSCALL_ENTRY
1155 ? "syscall_entry" : "syscall_return");
1157 sprintf (buf
, "T%02x%s:%x;", signal
, event
,
1158 status
->value
.syscall_number
);
1161 sprintf (buf
, "T%02x", status
->value
.sig
);
1163 buf
+= strlen (buf
);
1165 saved_thread
= current_thread
;
1167 switch_to_thread (ptid
);
1169 regp
= current_target_desc ()->expedite_regs
;
1171 regcache
= get_thread_regcache (current_thread
, 1);
1173 if (the_target
->stopped_by_watchpoint
!= NULL
1174 && (*the_target
->stopped_by_watchpoint
) ())
1179 strncpy (buf
, "watch:", 6);
1182 addr
= (*the_target
->stopped_data_address
) ();
1184 /* Convert each byte of the address into two hexadecimal
1185 chars. Note that we take sizeof (void *) instead of
1186 sizeof (addr); this is to avoid sending a 64-bit
1187 address to a 32-bit GDB. */
1188 for (i
= sizeof (void *) * 2; i
> 0; i
--)
1189 *buf
++ = tohex ((addr
>> (i
- 1) * 4) & 0xf);
1192 else if (swbreak_feature
&& target_stopped_by_sw_breakpoint ())
1194 sprintf (buf
, "swbreak:;");
1195 buf
+= strlen (buf
);
1197 else if (hwbreak_feature
&& target_stopped_by_hw_breakpoint ())
1199 sprintf (buf
, "hwbreak:;");
1200 buf
+= strlen (buf
);
1205 buf
= outreg (regcache
, find_regno (regcache
->tdesc
, *regp
), buf
);
1210 /* Formerly, if the debugger had not used any thread features
1211 we would not burden it with a thread status response. This
1212 was for the benefit of GDB 4.13 and older. However, in
1213 recent GDB versions the check (``if (cont_thread != 0)'')
1214 does not have the desired effect because of sillyness in
1215 the way that the remote protocol handles specifying a
1216 thread. Since thread support relies on qSymbol support
1217 anyway, assume GDB can handle threads. */
1219 if (using_threads
&& !disable_packet_Tthread
)
1221 /* This if (1) ought to be unnecessary. But remote_wait
1222 in GDB will claim this event belongs to inferior_ptid
1223 if we do not specify a thread, and there's no way for
1224 gdbserver to know what inferior_ptid is. */
1225 if (1 || !ptid_equal (general_thread
, ptid
))
1228 /* In non-stop, don't change the general thread behind
1231 general_thread
= ptid
;
1232 sprintf (buf
, "thread:");
1233 buf
+= strlen (buf
);
1234 buf
= write_ptid (buf
, ptid
);
1236 buf
+= strlen (buf
);
1238 core
= target_core_of_thread (ptid
);
1242 sprintf (buf
, "core:");
1243 buf
+= strlen (buf
);
1244 sprintf (buf
, "%x", core
);
1246 buf
+= strlen (buf
);
1253 strcpy (buf
, "library:;");
1254 buf
+= strlen (buf
);
1258 current_thread
= saved_thread
;
1261 case TARGET_WAITKIND_EXITED
:
1263 sprintf (buf
, "W%x;process:%x",
1264 status
->value
.integer
, ptid_get_pid (ptid
));
1266 sprintf (buf
, "W%02x", status
->value
.integer
);
1268 case TARGET_WAITKIND_SIGNALLED
:
1270 sprintf (buf
, "X%x;process:%x",
1271 status
->value
.sig
, ptid_get_pid (ptid
));
1273 sprintf (buf
, "X%02x", status
->value
.sig
);
1275 case TARGET_WAITKIND_THREAD_EXITED
:
1276 sprintf (buf
, "w%x;", status
->value
.integer
);
1277 buf
+= strlen (buf
);
1278 buf
= write_ptid (buf
, ptid
);
1280 case TARGET_WAITKIND_NO_RESUMED
:
1284 error ("unhandled waitkind");
1290 decode_m_packet (char *from
, CORE_ADDR
*mem_addr_ptr
, unsigned int *len_ptr
)
1294 *mem_addr_ptr
= *len_ptr
= 0;
1296 while ((ch
= from
[i
++]) != ',')
1298 *mem_addr_ptr
= *mem_addr_ptr
<< 4;
1299 *mem_addr_ptr
|= fromhex (ch
) & 0x0f;
1302 for (j
= 0; j
< 4; j
++)
1304 if ((ch
= from
[i
++]) == 0)
1306 *len_ptr
= *len_ptr
<< 4;
1307 *len_ptr
|= fromhex (ch
) & 0x0f;
1312 decode_M_packet (char *from
, CORE_ADDR
*mem_addr_ptr
, unsigned int *len_ptr
,
1313 unsigned char **to_p
)
1317 *mem_addr_ptr
= *len_ptr
= 0;
1319 while ((ch
= from
[i
++]) != ',')
1321 *mem_addr_ptr
= *mem_addr_ptr
<< 4;
1322 *mem_addr_ptr
|= fromhex (ch
) & 0x0f;
1325 while ((ch
= from
[i
++]) != ':')
1327 *len_ptr
= *len_ptr
<< 4;
1328 *len_ptr
|= fromhex (ch
) & 0x0f;
1332 *to_p
= (unsigned char *) xmalloc (*len_ptr
);
1334 hex2bin (&from
[i
++], *to_p
, *len_ptr
);
1338 decode_X_packet (char *from
, int packet_len
, CORE_ADDR
*mem_addr_ptr
,
1339 unsigned int *len_ptr
, unsigned char **to_p
)
1343 *mem_addr_ptr
= *len_ptr
= 0;
1345 while ((ch
= from
[i
++]) != ',')
1347 *mem_addr_ptr
= *mem_addr_ptr
<< 4;
1348 *mem_addr_ptr
|= fromhex (ch
) & 0x0f;
1351 while ((ch
= from
[i
++]) != ':')
1353 *len_ptr
= *len_ptr
<< 4;
1354 *len_ptr
|= fromhex (ch
) & 0x0f;
1358 *to_p
= (unsigned char *) xmalloc (*len_ptr
);
1360 if (remote_unescape_input ((const gdb_byte
*) &from
[i
], packet_len
- i
,
1361 *to_p
, *len_ptr
) != *len_ptr
)
1367 /* Decode a qXfer write request. */
1370 decode_xfer_write (char *buf
, int packet_len
, CORE_ADDR
*offset
,
1371 unsigned int *len
, unsigned char *data
)
1376 /* Extract the offset. */
1378 while ((ch
= *buf
++) != ':')
1380 *offset
= *offset
<< 4;
1381 *offset
|= fromhex (ch
) & 0x0f;
1384 /* Get encoded data. */
1385 packet_len
-= buf
- b
;
1386 *len
= remote_unescape_input ((const gdb_byte
*) buf
, packet_len
,
1391 /* Decode the parameters of a qSearch:memory packet. */
1394 decode_search_memory_packet (const char *buf
, int packet_len
,
1395 CORE_ADDR
*start_addrp
,
1396 CORE_ADDR
*search_space_lenp
,
1397 gdb_byte
*pattern
, unsigned int *pattern_lenp
)
1399 const char *p
= buf
;
1401 p
= decode_address_to_semicolon (start_addrp
, p
);
1402 p
= decode_address_to_semicolon (search_space_lenp
, p
);
1403 packet_len
-= p
- buf
;
1404 *pattern_lenp
= remote_unescape_input ((const gdb_byte
*) p
, packet_len
,
1405 pattern
, packet_len
);
1410 free_sym_cache (struct sym_cache
*sym
)
1420 clear_symbol_cache (struct sym_cache
**symcache_p
)
1422 struct sym_cache
*sym
, *next
;
1424 /* Check the cache first. */
1425 for (sym
= *symcache_p
; sym
; sym
= next
)
1428 free_sym_cache (sym
);
1434 /* Get the address of NAME, and return it in ADDRP if found. if
1435 MAY_ASK_GDB is false, assume symbol cache misses are failures.
1436 Returns 1 if the symbol is found, 0 if it is not, -1 on error. */
1439 look_up_one_symbol (const char *name
, CORE_ADDR
*addrp
, int may_ask_gdb
)
1443 struct sym_cache
*sym
;
1444 struct process_info
*proc
;
1446 proc
= current_process ();
1448 /* Check the cache first. */
1449 for (sym
= proc
->symbol_cache
; sym
; sym
= sym
->next
)
1450 if (strcmp (name
, sym
->name
) == 0)
1456 /* It might not be an appropriate time to look up a symbol,
1457 e.g. while we're trying to fetch registers. */
1461 /* Send the request. */
1462 strcpy (own_buf
, "qSymbol:");
1463 bin2hex ((const gdb_byte
*) name
, own_buf
+ strlen ("qSymbol:"),
1465 if (putpkt (own_buf
) < 0)
1468 /* FIXME: Eventually add buffer overflow checking (to getpkt?) */
1469 len
= getpkt (own_buf
);
1473 /* We ought to handle pretty much any packet at this point while we
1474 wait for the qSymbol "response". That requires re-entering the
1475 main loop. For now, this is an adequate approximation; allow
1476 GDB to read from memory and handle 'v' packets (for vFile transfers)
1477 while it figures out the address of the symbol. */
1480 if (own_buf
[0] == 'm')
1483 unsigned char *mem_buf
;
1484 unsigned int mem_len
;
1486 decode_m_packet (&own_buf
[1], &mem_addr
, &mem_len
);
1487 mem_buf
= (unsigned char *) xmalloc (mem_len
);
1488 if (read_inferior_memory (mem_addr
, mem_buf
, mem_len
) == 0)
1489 bin2hex (mem_buf
, own_buf
, mem_len
);
1491 write_enn (own_buf
);
1493 if (putpkt (own_buf
) < 0)
1496 else if (own_buf
[0] == 'v')
1499 handle_v_requests (own_buf
, len
, &new_len
);
1501 putpkt_binary (own_buf
, new_len
);
1507 len
= getpkt (own_buf
);
1512 if (!startswith (own_buf
, "qSymbol:"))
1514 warning ("Malformed response to qSymbol, ignoring: %s\n", own_buf
);
1518 p
= own_buf
+ strlen ("qSymbol:");
1520 while (*q
&& *q
!= ':')
1523 /* Make sure we found a value for the symbol. */
1524 if (p
== q
|| *q
== '\0')
1527 decode_address (addrp
, p
, q
- p
);
1529 /* Save the symbol in our cache. */
1530 sym
= XNEW (struct sym_cache
);
1531 sym
->name
= xstrdup (name
);
1533 sym
->next
= proc
->symbol_cache
;
1534 proc
->symbol_cache
= sym
;
1539 /* Relocate an instruction to execute at a different address. OLDLOC
1540 is the address in the inferior memory where the instruction to
1541 relocate is currently at. On input, TO points to the destination
1542 where we want the instruction to be copied (and possibly adjusted)
1543 to. On output, it points to one past the end of the resulting
1544 instruction(s). The effect of executing the instruction at TO
1545 shall be the same as if executing it at OLDLOC. For example, call
1546 instructions that implicitly push the return address on the stack
1547 should be adjusted to return to the instruction after OLDLOC;
1548 relative branches, and other PC-relative instructions need the
1549 offset adjusted; etc. Returns 0 on success, -1 on failure. */
1552 relocate_instruction (CORE_ADDR
*to
, CORE_ADDR oldloc
)
1555 ULONGEST written
= 0;
1557 /* Send the request. */
1558 sprintf (own_buf
, "qRelocInsn:%s;%s", paddress (oldloc
),
1560 if (putpkt (own_buf
) < 0)
1563 /* FIXME: Eventually add buffer overflow checking (to getpkt?) */
1564 len
= getpkt (own_buf
);
1568 /* We ought to handle pretty much any packet at this point while we
1569 wait for the qRelocInsn "response". That requires re-entering
1570 the main loop. For now, this is an adequate approximation; allow
1571 GDB to access memory. */
1572 while (own_buf
[0] == 'm' || own_buf
[0] == 'M' || own_buf
[0] == 'X')
1575 unsigned char *mem_buf
= NULL
;
1576 unsigned int mem_len
;
1578 if (own_buf
[0] == 'm')
1580 decode_m_packet (&own_buf
[1], &mem_addr
, &mem_len
);
1581 mem_buf
= (unsigned char *) xmalloc (mem_len
);
1582 if (read_inferior_memory (mem_addr
, mem_buf
, mem_len
) == 0)
1583 bin2hex (mem_buf
, own_buf
, mem_len
);
1585 write_enn (own_buf
);
1587 else if (own_buf
[0] == 'X')
1589 if (decode_X_packet (&own_buf
[1], len
- 1, &mem_addr
,
1590 &mem_len
, &mem_buf
) < 0
1591 || write_inferior_memory (mem_addr
, mem_buf
, mem_len
) != 0)
1592 write_enn (own_buf
);
1598 decode_M_packet (&own_buf
[1], &mem_addr
, &mem_len
, &mem_buf
);
1599 if (write_inferior_memory (mem_addr
, mem_buf
, mem_len
) == 0)
1602 write_enn (own_buf
);
1605 if (putpkt (own_buf
) < 0)
1607 len
= getpkt (own_buf
);
1612 if (own_buf
[0] == 'E')
1614 warning ("An error occurred while relocating an instruction: %s\n",
1619 if (!startswith (own_buf
, "qRelocInsn:"))
1621 warning ("Malformed response to qRelocInsn, ignoring: %s\n",
1626 unpack_varlen_hex (own_buf
+ strlen ("qRelocInsn:"), &written
);
1633 monitor_output (const char *msg
)
1635 int len
= strlen (msg
);
1636 char *buf
= (char *) xmalloc (len
* 2 + 2);
1639 bin2hex ((const gdb_byte
*) msg
, buf
+ 1, len
);