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/>. */
20 #include "gdb_termios.h"
22 #include "gdbthread.h"
26 #include "gdbthread.h"
29 #include <sys/ioctl.h>
35 #include <netinet/in.h>
38 #include <sys/socket.h>
43 #if HAVE_NETINET_TCP_H
44 #include <netinet/tcp.h>
47 #include <sys/ioctl.h>
55 #include "gdb_sys_time.h"
58 #include <arpa/inet.h>
67 #include <sys/iomgr.h>
70 #ifndef HAVE_SOCKLEN_T
71 typedef int socklen_t
;
74 #ifndef IN_PROCESS_AGENT
77 # define INVALID_DESCRIPTOR INVALID_SOCKET
79 # define INVALID_DESCRIPTOR -1
82 /* Extra value for readchar_callback. */
84 /* The callback is currently not scheduled. */
88 /* Status of the readchar callback.
89 Either NOT_SCHEDULED or the callback id. */
90 static int readchar_callback
= NOT_SCHEDULED
;
92 static int readchar (void);
93 static void reset_readchar (void);
94 static void reschedule (void);
96 /* A cache entry for a successfully looked-up symbol. */
101 struct sym_cache
*next
;
104 int remote_debug
= 0;
105 struct ui_file
*gdb_stdlog
;
107 static int remote_is_stdio
= 0;
109 static gdb_fildes_t remote_desc
= INVALID_DESCRIPTOR
;
110 static gdb_fildes_t listen_desc
= INVALID_DESCRIPTOR
;
112 /* FIXME headerize? */
113 extern int using_threads
;
114 extern int debug_threads
;
116 /* If true, then GDB has requested noack mode. */
118 /* If true, then we tell GDB to use noack mode by default. */
119 int transport_is_reliable
= 0;
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_in sockaddr
;
161 debug_printf ("handling possible accept event\n");
163 tmp
= sizeof (sockaddr
);
164 remote_desc
= accept (listen_desc
, (struct sockaddr
*) &sockaddr
, &tmp
);
165 if (remote_desc
== -1)
166 perror_with_name ("Accept failed");
168 /* Enable TCP keep alive process. */
170 setsockopt (remote_desc
, SOL_SOCKET
, SO_KEEPALIVE
,
171 (char *) &tmp
, sizeof (tmp
));
173 /* Tell TCP not to delay small packets. This greatly speeds up
174 interactive response. */
176 setsockopt (remote_desc
, IPPROTO_TCP
, TCP_NODELAY
,
177 (char *) &tmp
, sizeof (tmp
));
180 signal (SIGPIPE
, SIG_IGN
); /* If we don't do this, then gdbserver simply
181 exits when the remote side dies. */
187 close (listen_desc
); /* No longer need this */
189 closesocket (listen_desc
); /* No longer need this */
193 /* Even if !RUN_ONCE no longer notice new connections. Still keep the
194 descriptor open for add_file_handler to wait for a new connection. */
195 delete_file_handler (listen_desc
);
197 /* Convert IP address to string. */
198 fprintf (stderr
, "Remote debugging from host %s\n",
199 inet_ntoa (sockaddr
.sin_addr
));
201 enable_async_notification (remote_desc
);
203 /* Register the event loop handler. */
204 add_file_handler (remote_desc
, handle_serial_event
, NULL
);
206 /* We have a new GDB connection now. If we were disconnected
207 tracing, there's a window where the target could report a stop
208 event to the event loop, and since we have a connection now, we'd
209 try to send vStopped notifications to GDB. But, don't do that
210 until GDB as selected all-stop/non-stop, and has queried the
211 threads' status ('?'). */
217 /* Prepare for a later connection to a remote debugger.
218 NAME is the filename used for communication. */
221 remote_prepare (const char *name
)
223 const char *port_str
;
225 static int winsock_initialized
;
228 struct sockaddr_in sockaddr
;
233 if (strcmp (name
, STDIO_CONNECTION_NAME
) == 0)
235 /* We need to record fact that we're using stdio sooner than the
236 call to remote_open so start_inferior knows the connection is
239 transport_is_reliable
= 1;
243 port_str
= strchr (name
, ':');
244 if (port_str
== NULL
)
246 transport_is_reliable
= 0;
250 port
= strtoul (port_str
+ 1, &port_end
, 10);
251 if (port_str
[1] == '\0' || *port_end
!= '\0')
252 error ("Bad port argument: %s", name
);
255 if (!winsock_initialized
)
259 WSAStartup (MAKEWORD (1, 0), &wsad
);
260 winsock_initialized
= 1;
264 listen_desc
= socket (PF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
265 if (listen_desc
== -1)
266 perror_with_name ("Can't open socket");
268 /* Allow rapid reuse of this port. */
270 setsockopt (listen_desc
, SOL_SOCKET
, SO_REUSEADDR
, (char *) &tmp
,
273 sockaddr
.sin_family
= PF_INET
;
274 sockaddr
.sin_port
= htons (port
);
275 sockaddr
.sin_addr
.s_addr
= INADDR_ANY
;
277 if (bind (listen_desc
, (struct sockaddr
*) &sockaddr
, sizeof (sockaddr
))
278 || listen (listen_desc
, 1))
279 perror_with_name ("Can't bind address");
281 transport_is_reliable
= 1;
284 /* Open a connection to a remote debugger.
285 NAME is the filename used for communication. */
288 remote_open (const char *name
)
290 const char *port_str
;
292 port_str
= strchr (name
, ':');
294 if (port_str
== NULL
)
295 error ("Only <host>:<port> is supported on this platform.");
298 if (strcmp (name
, STDIO_CONNECTION_NAME
) == 0)
300 fprintf (stderr
, "Remote debugging using stdio\n");
302 /* Use stdin as the handle of the connection.
303 We only select on reads, for example. */
304 remote_desc
= fileno (stdin
);
306 enable_async_notification (remote_desc
);
308 /* Register the event loop handler. */
309 add_file_handler (remote_desc
, handle_serial_event
, NULL
);
312 else if (port_str
== NULL
)
316 if (stat (name
, &statbuf
) == 0
317 && (S_ISCHR (statbuf
.st_mode
) || S_ISFIFO (statbuf
.st_mode
)))
318 remote_desc
= open (name
, O_RDWR
);
326 perror_with_name ("Could not open remote device");
330 struct termios termios
;
331 tcgetattr (remote_desc
, &termios
);
336 termios
.c_cflag
&= ~(CSIZE
| PARENB
);
337 termios
.c_cflag
|= CLOCAL
| CS8
;
338 termios
.c_cc
[VMIN
] = 1;
339 termios
.c_cc
[VTIME
] = 0;
341 tcsetattr (remote_desc
, TCSANOW
, &termios
);
347 struct termio termio
;
348 ioctl (remote_desc
, TCGETA
, &termio
);
353 termio
.c_cflag
&= ~(CSIZE
| PARENB
);
354 termio
.c_cflag
|= CLOCAL
| CS8
;
355 termio
.c_cc
[VMIN
] = 1;
356 termio
.c_cc
[VTIME
] = 0;
358 ioctl (remote_desc
, TCSETA
, &termio
);
366 ioctl (remote_desc
, TIOCGETP
, &sg
);
368 ioctl (remote_desc
, TIOCSETP
, &sg
);
372 fprintf (stderr
, "Remote debugging using %s\n", name
);
374 enable_async_notification (remote_desc
);
376 /* Register the event loop handler. */
377 add_file_handler (remote_desc
, handle_serial_event
, NULL
);
379 #endif /* USE_WIN32API */
384 struct sockaddr_in sockaddr
;
386 len
= sizeof (sockaddr
);
387 if (getsockname (listen_desc
,
388 (struct sockaddr
*) &sockaddr
, &len
) < 0
389 || len
< sizeof (sockaddr
))
390 perror_with_name ("Can't determine port");
391 port
= ntohs (sockaddr
.sin_port
);
393 fprintf (stderr
, "Listening on port %d\n", port
);
396 /* Register the event loop handler. */
397 add_file_handler (listen_desc
, handle_accept_event
, NULL
);
404 delete_file_handler (remote_desc
);
407 /* Remove SIGIO handler. */
408 signal (SIGIO
, SIG_IGN
);
412 closesocket (remote_desc
);
414 if (! remote_connection_is_stdio ())
417 remote_desc
= INVALID_DESCRIPTOR
;
424 #ifndef IN_PROCESS_AGENT
427 decode_address (CORE_ADDR
*addrp
, const char *start
, int len
)
434 for (i
= 0; i
< len
; i
++)
438 addr
= addr
| (fromhex (ch
) & 0x0f);
444 decode_address_to_semicolon (CORE_ADDR
*addrp
, const char *start
)
449 while (*end
!= '\0' && *end
!= ';')
452 decode_address (addrp
, start
, end
- start
);
461 #ifndef IN_PROCESS_AGENT
463 /* Look for a sequence of characters which can be run-length encoded.
464 If there are any, update *CSUM and *P. Otherwise, output the
465 single character. Return the number of characters consumed. */
468 try_rle (char *buf
, int remaining
, unsigned char *csum
, char **p
)
472 /* Always output the character. */
476 /* Don't go past '~'. */
480 for (n
= 1; n
< remaining
; n
++)
481 if (buf
[n
] != buf
[0])
484 /* N is the index of the first character not the same as buf[0].
485 buf[0] is counted twice, so by decrementing N, we get the number
486 of characters the RLE sequence will replace. */
492 /* Skip the frame characters. The manual says to skip '+' and '-'
493 also, but there's no reason to. Unfortunately these two unusable
494 characters double the encoded length of a four byte zero
496 while (n
+ 29 == '$' || n
+ 29 == '#')
509 #ifndef IN_PROCESS_AGENT
511 /* Write a PTID to BUF. Returns BUF+CHARACTERS_WRITTEN. */
514 write_ptid (char *buf
, ptid_t ptid
)
520 pid
= ptid_get_pid (ptid
);
522 buf
+= sprintf (buf
, "p-%x.", -pid
);
524 buf
+= sprintf (buf
, "p%x.", pid
);
526 tid
= ptid_get_lwp (ptid
);
528 buf
+= sprintf (buf
, "-%x", -tid
);
530 buf
+= sprintf (buf
, "%x", tid
);
536 hex_or_minus_one (const char *buf
, const char **obuf
)
540 if (startswith (buf
, "-1"))
546 buf
= unpack_varlen_hex (buf
, &ret
);
554 /* Extract a PTID from BUF. If non-null, OBUF is set to the to one
555 passed the last parsed char. Returns null_ptid on error. */
557 read_ptid (const char *buf
, const char **obuf
)
561 ULONGEST pid
= 0, tid
= 0;
565 /* Multi-process ptid. */
566 pp
= unpack_varlen_hex (p
+ 1, &pid
);
568 error ("invalid remote ptid: %s\n", p
);
572 tid
= hex_or_minus_one (p
, &pp
);
576 return ptid_build (pid
, tid
, 0);
579 /* No multi-process. Just a tid. */
580 tid
= hex_or_minus_one (p
, &pp
);
582 /* Since GDB is not sending a process id (multi-process extensions
583 are off), then there's only one process. Default to the first in
585 pid
= pid_of (get_first_process ());
589 return ptid_build (pid
, tid
, 0);
592 /* Write COUNT bytes in BUF to the client.
593 The result is the number of bytes written or -1 if error.
594 This may return less than COUNT. */
597 write_prim (const void *buf
, int count
)
599 if (remote_connection_is_stdio ())
600 return write (fileno (stdout
), buf
, count
);
602 return write (remote_desc
, buf
, count
);
605 /* Read COUNT bytes from the client and store in BUF.
606 The result is the number of bytes read or -1 if error.
607 This may return less than COUNT. */
610 read_prim (void *buf
, int count
)
612 if (remote_connection_is_stdio ())
613 return read (fileno (stdin
), buf
, count
);
615 return read (remote_desc
, buf
, count
);
618 /* Send a packet to the remote machine, with error checking.
619 The data of the packet is in BUF, and the length of the
620 packet is in CNT. Returns >= 0 on success, -1 otherwise. */
623 putpkt_binary_1 (char *buf
, int cnt
, int is_notif
)
626 unsigned char csum
= 0;
631 buf2
= (char *) xmalloc (strlen ("$") + cnt
+ strlen ("#nn") + 1);
633 /* Copy the packet into buffer BUF2, encapsulating it
634 and giving it a checksum. */
642 for (i
= 0; i
< cnt
;)
643 i
+= try_rle (buf
+ i
, cnt
- i
, &csum
, &p
);
646 *p
++ = tohex ((csum
>> 4) & 0xf);
647 *p
++ = tohex (csum
& 0xf);
651 /* Send it over and over until we get a positive ack. */
655 if (write_prim (buf2
, p
- buf2
) != p
- buf2
)
657 perror ("putpkt(write)");
662 if (noack_mode
|| is_notif
)
664 /* Don't expect an ack then. */
668 debug_printf ("putpkt (\"%s\"); [notif]\n", buf2
);
670 debug_printf ("putpkt (\"%s\"); [noack mode]\n", buf2
);
678 debug_printf ("putpkt (\"%s\"); [looking for ack]\n", buf2
);
692 debug_printf ("[received '%c' (0x%x)]\n", cc
, cc
);
696 /* Check for an input interrupt while we're here. */
697 if (cc
== '\003' && current_thread
!= NULL
)
698 (*the_target
->request_interrupt
) ();
703 return 1; /* Success! */
707 putpkt_binary (char *buf
, int cnt
)
709 return putpkt_binary_1 (buf
, cnt
, 0);
712 /* Send a packet to the remote machine, with error checking. The data
713 of the packet is in BUF, and the packet should be a NUL-terminated
714 string. Returns >= 0 on success, -1 otherwise. */
719 return putpkt_binary (buf
, strlen (buf
));
723 putpkt_notif (char *buf
)
725 return putpkt_binary_1 (buf
, strlen (buf
), 1);
728 /* Come here when we get an input interrupt from the remote side. This
729 interrupt should only be active while we are waiting for the child to do
730 something. Thus this assumes readchar:bufcnt is 0.
731 About the only thing that should come through is a ^C, which
732 will cause us to request child interruption. */
735 input_interrupt (int unused
)
738 struct timeval immediate
= { 0, 0 };
740 /* Protect against spurious interrupts. This has been observed to
741 be a problem under NetBSD 1.4 and 1.5. */
744 FD_SET (remote_desc
, &readset
);
745 if (select (remote_desc
+ 1, &readset
, 0, 0, &immediate
) > 0)
750 cc
= read_prim (&c
, 1);
754 fprintf (stderr
, "client connection closed\n");
757 else if (cc
!= 1 || c
!= '\003')
759 fprintf (stderr
, "input_interrupt, count = %d c = %d ", cc
, c
);
761 fprintf (stderr
, "('%c')\n", c
);
763 fprintf (stderr
, "('\\x%02x')\n", c
& 0xff);
767 (*the_target
->request_interrupt
) ();
771 /* Check if the remote side sent us an interrupt request (^C). */
773 check_remote_input_interrupt_request (void)
775 /* This function may be called before establishing communications,
776 therefore we need to validate the remote descriptor. */
778 if (remote_desc
== INVALID_DESCRIPTOR
)
784 /* Asynchronous I/O support. SIGIO must be unblocked when waiting,
785 in order to accept Control-C from the client, and must be blocked
786 when talking to the client. */
789 block_unblock_async_io (int block
)
794 sigemptyset (&sigio_set
);
795 sigaddset (&sigio_set
, SIGIO
);
796 sigprocmask (block
? SIG_BLOCK
: SIG_UNBLOCK
, &sigio_set
, NULL
);
802 nto_comctrl (int enable
)
804 struct sigevent event
;
808 event
.sigev_notify
= SIGEV_SIGNAL_THREAD
;
809 event
.sigev_signo
= SIGIO
;
810 event
.sigev_code
= 0;
811 event
.sigev_value
.sival_ptr
= NULL
;
812 event
.sigev_priority
= -1;
813 ionotify (remote_desc
, _NOTIFY_ACTION_POLLARM
, _NOTIFY_COND_INPUT
,
817 ionotify (remote_desc
, _NOTIFY_ACTION_POLL
, _NOTIFY_COND_INPUT
, NULL
);
822 /* Current state of asynchronous I/O. */
823 static int async_io_enabled
;
825 /* Enable asynchronous I/O. */
827 enable_async_io (void)
829 if (async_io_enabled
)
832 block_unblock_async_io (0);
834 async_io_enabled
= 1;
840 /* Disable asynchronous I/O. */
842 disable_async_io (void)
844 if (!async_io_enabled
)
847 block_unblock_async_io (1);
849 async_io_enabled
= 0;
857 initialize_async_io (void)
859 /* Make sure that async I/O starts blocked. */
860 async_io_enabled
= 1;
863 /* Install the signal handler. */
865 signal (SIGIO
, input_interrupt
);
869 /* Internal buffer used by readchar.
870 These are global to readchar because reschedule_remote needs to be
871 able to tell whether the buffer is empty. */
873 static unsigned char readchar_buf
[BUFSIZ
];
874 static int readchar_bufcnt
= 0;
875 static unsigned char *readchar_bufp
;
877 /* Returns next char from remote GDB. -1 if error. */
884 if (readchar_bufcnt
== 0)
886 readchar_bufcnt
= read_prim (readchar_buf
, sizeof (readchar_buf
));
888 if (readchar_bufcnt
<= 0)
890 if (readchar_bufcnt
== 0)
893 debug_printf ("readchar: Got EOF\n");
901 readchar_bufp
= readchar_buf
;
905 ch
= *readchar_bufp
++;
910 /* Reset the readchar state machine. */
913 reset_readchar (void)
916 if (readchar_callback
!= NOT_SCHEDULED
)
918 delete_callback_event (readchar_callback
);
919 readchar_callback
= NOT_SCHEDULED
;
923 /* Process remaining data in readchar_buf. */
926 process_remaining (void *context
)
930 /* This is a one-shot event. */
931 readchar_callback
= NOT_SCHEDULED
;
933 if (readchar_bufcnt
> 0)
934 res
= handle_serial_event (0, NULL
);
941 /* If there is still data in the buffer, queue another event to process it,
942 we can't sleep in select yet. */
947 if (readchar_bufcnt
> 0 && readchar_callback
== NOT_SCHEDULED
)
948 readchar_callback
= append_callback_event (process_remaining
, NULL
);
951 /* Read a packet from the remote machine, with error checking,
952 and store it in BUF. Returns length of packet, or negative if error. */
958 unsigned char csum
, c1
, c2
;
969 /* The '\003' may appear before or after each packet, so
970 check for an input interrupt. */
973 (*the_target
->request_interrupt
) ();
981 debug_printf ("[getpkt: discarding char '%c']\n", c
);
1002 c1
= fromhex (readchar ());
1003 c2
= fromhex (readchar ());
1005 if (csum
== (c1
<< 4) + c2
)
1011 "Bad checksum, sentsum=0x%x, csum=0x%x, "
1012 "buf=%s [no-ack-mode, Bad medium?]\n",
1013 (c1
<< 4) + c2
, csum
, buf
);
1014 /* Not much we can do, GDB wasn't expecting an ack/nac. */
1018 fprintf (stderr
, "Bad checksum, sentsum=0x%x, csum=0x%x, buf=%s\n",
1019 (c1
<< 4) + c2
, csum
, buf
);
1020 if (write_prim ("-", 1) != 1)
1028 debug_printf ("getpkt (\"%s\"); [sending ack] \n", buf
);
1032 if (write_prim ("+", 1) != 1)
1037 debug_printf ("[sent ack]\n");
1045 debug_printf ("getpkt (\"%s\"); [no ack sent] \n", buf
);
1050 /* The readchar above may have already read a '\003' out of the socket
1051 and moved it to the local buffer. For example, when GDB sends
1052 vCont;c immediately followed by interrupt (see
1053 gdb.base/interrupt-noterm.exp). As soon as we see the vCont;c, we'll
1054 resume the inferior and wait. Since we've already moved the '\003'
1055 to the local buffer, SIGIO won't help. In that case, if we don't
1056 check for interrupt after the vCont;c packet, the interrupt character
1057 would stay in the buffer unattended until after the next (unrelated)
1059 while (readchar_bufcnt
> 0 && *readchar_bufp
== '\003')
1061 /* Consume the interrupt character in the buffer. */
1063 (*the_target
->request_interrupt
) ();
1070 write_ok (char *buf
)
1078 write_enn (char *buf
)
1080 /* Some day, we should define the meanings of the error codes... */
1089 #ifndef IN_PROCESS_AGENT
1092 outreg (struct regcache
*regcache
, int regno
, char *buf
)
1094 if ((regno
>> 12) != 0)
1095 *buf
++ = tohex ((regno
>> 12) & 0xf);
1096 if ((regno
>> 8) != 0)
1097 *buf
++ = tohex ((regno
>> 8) & 0xf);
1098 *buf
++ = tohex ((regno
>> 4) & 0xf);
1099 *buf
++ = tohex (regno
& 0xf);
1101 collect_register_as_string (regcache
, regno
, buf
);
1102 buf
+= 2 * register_size (regcache
->tdesc
, regno
);
1109 prepare_resume_reply (char *buf
, ptid_t ptid
,
1110 struct target_waitstatus
*status
)
1113 debug_printf ("Writing resume reply for %s:%d\n",
1114 target_pid_to_str (ptid
), status
->kind
);
1116 switch (status
->kind
)
1118 case TARGET_WAITKIND_STOPPED
:
1119 case TARGET_WAITKIND_FORKED
:
1120 case TARGET_WAITKIND_VFORKED
:
1121 case TARGET_WAITKIND_VFORK_DONE
:
1122 case TARGET_WAITKIND_EXECD
:
1123 case TARGET_WAITKIND_THREAD_CREATED
:
1124 case TARGET_WAITKIND_SYSCALL_ENTRY
:
1125 case TARGET_WAITKIND_SYSCALL_RETURN
:
1127 struct thread_info
*saved_thread
;
1129 struct regcache
*regcache
;
1131 if ((status
->kind
== TARGET_WAITKIND_FORKED
&& report_fork_events
)
1132 || (status
->kind
== TARGET_WAITKIND_VFORKED
&& report_vfork_events
))
1134 enum gdb_signal signal
= GDB_SIGNAL_TRAP
;
1135 const char *event
= (status
->kind
== TARGET_WAITKIND_FORKED
1136 ? "fork" : "vfork");
1138 sprintf (buf
, "T%02x%s:", signal
, event
);
1139 buf
+= strlen (buf
);
1140 buf
= write_ptid (buf
, status
->value
.related_pid
);
1143 else if (status
->kind
== TARGET_WAITKIND_VFORK_DONE
&& report_vfork_events
)
1145 enum gdb_signal signal
= GDB_SIGNAL_TRAP
;
1147 sprintf (buf
, "T%02xvforkdone:;", signal
);
1149 else if (status
->kind
== TARGET_WAITKIND_EXECD
&& report_exec_events
)
1151 enum gdb_signal signal
= GDB_SIGNAL_TRAP
;
1152 const char *event
= "exec";
1153 char hexified_pathname
[PATH_MAX
* 2];
1155 sprintf (buf
, "T%02x%s:", signal
, event
);
1156 buf
+= strlen (buf
);
1158 /* Encode pathname to hexified format. */
1159 bin2hex ((const gdb_byte
*) status
->value
.execd_pathname
,
1161 strlen (status
->value
.execd_pathname
));
1163 sprintf (buf
, "%s;", hexified_pathname
);
1164 xfree (status
->value
.execd_pathname
);
1165 status
->value
.execd_pathname
= NULL
;
1166 buf
+= strlen (buf
);
1168 else if (status
->kind
== TARGET_WAITKIND_THREAD_CREATED
1169 && report_thread_events
)
1171 enum gdb_signal signal
= GDB_SIGNAL_TRAP
;
1173 sprintf (buf
, "T%02xcreate:;", signal
);
1175 else if (status
->kind
== TARGET_WAITKIND_SYSCALL_ENTRY
1176 || status
->kind
== TARGET_WAITKIND_SYSCALL_RETURN
)
1178 enum gdb_signal signal
= GDB_SIGNAL_TRAP
;
1179 const char *event
= (status
->kind
== TARGET_WAITKIND_SYSCALL_ENTRY
1180 ? "syscall_entry" : "syscall_return");
1182 sprintf (buf
, "T%02x%s:%x;", signal
, event
,
1183 status
->value
.syscall_number
);
1186 sprintf (buf
, "T%02x", status
->value
.sig
);
1188 buf
+= strlen (buf
);
1190 saved_thread
= current_thread
;
1192 switch_to_thread (ptid
);
1194 regp
= current_target_desc ()->expedite_regs
;
1196 regcache
= get_thread_regcache (current_thread
, 1);
1198 if (the_target
->stopped_by_watchpoint
!= NULL
1199 && (*the_target
->stopped_by_watchpoint
) ())
1204 strncpy (buf
, "watch:", 6);
1207 addr
= (*the_target
->stopped_data_address
) ();
1209 /* Convert each byte of the address into two hexadecimal
1210 chars. Note that we take sizeof (void *) instead of
1211 sizeof (addr); this is to avoid sending a 64-bit
1212 address to a 32-bit GDB. */
1213 for (i
= sizeof (void *) * 2; i
> 0; i
--)
1214 *buf
++ = tohex ((addr
>> (i
- 1) * 4) & 0xf);
1217 else if (swbreak_feature
&& target_stopped_by_sw_breakpoint ())
1219 sprintf (buf
, "swbreak:;");
1220 buf
+= strlen (buf
);
1222 else if (hwbreak_feature
&& target_stopped_by_hw_breakpoint ())
1224 sprintf (buf
, "hwbreak:;");
1225 buf
+= strlen (buf
);
1230 buf
= outreg (regcache
, find_regno (regcache
->tdesc
, *regp
), buf
);
1235 /* Formerly, if the debugger had not used any thread features
1236 we would not burden it with a thread status response. This
1237 was for the benefit of GDB 4.13 and older. However, in
1238 recent GDB versions the check (``if (cont_thread != 0)'')
1239 does not have the desired effect because of sillyness in
1240 the way that the remote protocol handles specifying a
1241 thread. Since thread support relies on qSymbol support
1242 anyway, assume GDB can handle threads. */
1244 if (using_threads
&& !disable_packet_Tthread
)
1246 /* This if (1) ought to be unnecessary. But remote_wait
1247 in GDB will claim this event belongs to inferior_ptid
1248 if we do not specify a thread, and there's no way for
1249 gdbserver to know what inferior_ptid is. */
1250 if (1 || !ptid_equal (general_thread
, ptid
))
1253 /* In non-stop, don't change the general thread behind
1256 general_thread
= ptid
;
1257 sprintf (buf
, "thread:");
1258 buf
+= strlen (buf
);
1259 buf
= write_ptid (buf
, ptid
);
1261 buf
+= strlen (buf
);
1263 core
= target_core_of_thread (ptid
);
1267 sprintf (buf
, "core:");
1268 buf
+= strlen (buf
);
1269 sprintf (buf
, "%x", core
);
1271 buf
+= strlen (buf
);
1278 strcpy (buf
, "library:;");
1279 buf
+= strlen (buf
);
1283 current_thread
= saved_thread
;
1286 case TARGET_WAITKIND_EXITED
:
1288 sprintf (buf
, "W%x;process:%x",
1289 status
->value
.integer
, ptid_get_pid (ptid
));
1291 sprintf (buf
, "W%02x", status
->value
.integer
);
1293 case TARGET_WAITKIND_SIGNALLED
:
1295 sprintf (buf
, "X%x;process:%x",
1296 status
->value
.sig
, ptid_get_pid (ptid
));
1298 sprintf (buf
, "X%02x", status
->value
.sig
);
1300 case TARGET_WAITKIND_THREAD_EXITED
:
1301 sprintf (buf
, "w%x;", status
->value
.integer
);
1302 buf
+= strlen (buf
);
1303 buf
= write_ptid (buf
, ptid
);
1305 case TARGET_WAITKIND_NO_RESUMED
:
1309 error ("unhandled waitkind");
1315 decode_m_packet (char *from
, CORE_ADDR
*mem_addr_ptr
, unsigned int *len_ptr
)
1319 *mem_addr_ptr
= *len_ptr
= 0;
1321 while ((ch
= from
[i
++]) != ',')
1323 *mem_addr_ptr
= *mem_addr_ptr
<< 4;
1324 *mem_addr_ptr
|= fromhex (ch
) & 0x0f;
1327 for (j
= 0; j
< 4; j
++)
1329 if ((ch
= from
[i
++]) == 0)
1331 *len_ptr
= *len_ptr
<< 4;
1332 *len_ptr
|= fromhex (ch
) & 0x0f;
1337 decode_M_packet (char *from
, CORE_ADDR
*mem_addr_ptr
, unsigned int *len_ptr
,
1338 unsigned char **to_p
)
1342 *mem_addr_ptr
= *len_ptr
= 0;
1344 while ((ch
= from
[i
++]) != ',')
1346 *mem_addr_ptr
= *mem_addr_ptr
<< 4;
1347 *mem_addr_ptr
|= fromhex (ch
) & 0x0f;
1350 while ((ch
= from
[i
++]) != ':')
1352 *len_ptr
= *len_ptr
<< 4;
1353 *len_ptr
|= fromhex (ch
) & 0x0f;
1357 *to_p
= (unsigned char *) xmalloc (*len_ptr
);
1359 hex2bin (&from
[i
++], *to_p
, *len_ptr
);
1363 decode_X_packet (char *from
, int packet_len
, CORE_ADDR
*mem_addr_ptr
,
1364 unsigned int *len_ptr
, 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 if (remote_unescape_input ((const gdb_byte
*) &from
[i
], packet_len
- i
,
1386 *to_p
, *len_ptr
) != *len_ptr
)
1392 /* Decode a qXfer write request. */
1395 decode_xfer_write (char *buf
, int packet_len
, CORE_ADDR
*offset
,
1396 unsigned int *len
, unsigned char *data
)
1401 /* Extract the offset. */
1403 while ((ch
= *buf
++) != ':')
1405 *offset
= *offset
<< 4;
1406 *offset
|= fromhex (ch
) & 0x0f;
1409 /* Get encoded data. */
1410 packet_len
-= buf
- b
;
1411 *len
= remote_unescape_input ((const gdb_byte
*) buf
, packet_len
,
1416 /* Decode the parameters of a qSearch:memory packet. */
1419 decode_search_memory_packet (const char *buf
, int packet_len
,
1420 CORE_ADDR
*start_addrp
,
1421 CORE_ADDR
*search_space_lenp
,
1422 gdb_byte
*pattern
, unsigned int *pattern_lenp
)
1424 const char *p
= buf
;
1426 p
= decode_address_to_semicolon (start_addrp
, p
);
1427 p
= decode_address_to_semicolon (search_space_lenp
, p
);
1428 packet_len
-= p
- buf
;
1429 *pattern_lenp
= remote_unescape_input ((const gdb_byte
*) p
, packet_len
,
1430 pattern
, packet_len
);
1435 free_sym_cache (struct sym_cache
*sym
)
1445 clear_symbol_cache (struct sym_cache
**symcache_p
)
1447 struct sym_cache
*sym
, *next
;
1449 /* Check the cache first. */
1450 for (sym
= *symcache_p
; sym
; sym
= next
)
1453 free_sym_cache (sym
);
1459 /* Get the address of NAME, and return it in ADDRP if found. if
1460 MAY_ASK_GDB is false, assume symbol cache misses are failures.
1461 Returns 1 if the symbol is found, 0 if it is not, -1 on error. */
1464 look_up_one_symbol (const char *name
, CORE_ADDR
*addrp
, int may_ask_gdb
)
1468 struct sym_cache
*sym
;
1469 struct process_info
*proc
;
1471 proc
= current_process ();
1473 /* Check the cache first. */
1474 for (sym
= proc
->symbol_cache
; sym
; sym
= sym
->next
)
1475 if (strcmp (name
, sym
->name
) == 0)
1481 /* It might not be an appropriate time to look up a symbol,
1482 e.g. while we're trying to fetch registers. */
1486 /* Send the request. */
1487 strcpy (own_buf
, "qSymbol:");
1488 bin2hex ((const gdb_byte
*) name
, own_buf
+ strlen ("qSymbol:"),
1490 if (putpkt (own_buf
) < 0)
1493 /* FIXME: Eventually add buffer overflow checking (to getpkt?) */
1494 len
= getpkt (own_buf
);
1498 /* We ought to handle pretty much any packet at this point while we
1499 wait for the qSymbol "response". That requires re-entering the
1500 main loop. For now, this is an adequate approximation; allow
1501 GDB to read from memory and handle 'v' packets (for vFile transfers)
1502 while it figures out the address of the symbol. */
1505 if (own_buf
[0] == 'm')
1508 unsigned char *mem_buf
;
1509 unsigned int mem_len
;
1511 decode_m_packet (&own_buf
[1], &mem_addr
, &mem_len
);
1512 mem_buf
= (unsigned char *) xmalloc (mem_len
);
1513 if (read_inferior_memory (mem_addr
, mem_buf
, mem_len
) == 0)
1514 bin2hex (mem_buf
, own_buf
, mem_len
);
1516 write_enn (own_buf
);
1518 if (putpkt (own_buf
) < 0)
1521 else if (own_buf
[0] == 'v')
1524 handle_v_requests (own_buf
, len
, &new_len
);
1526 putpkt_binary (own_buf
, new_len
);
1532 len
= getpkt (own_buf
);
1537 if (!startswith (own_buf
, "qSymbol:"))
1539 warning ("Malformed response to qSymbol, ignoring: %s\n", own_buf
);
1543 p
= own_buf
+ strlen ("qSymbol:");
1545 while (*q
&& *q
!= ':')
1548 /* Make sure we found a value for the symbol. */
1549 if (p
== q
|| *q
== '\0')
1552 decode_address (addrp
, p
, q
- p
);
1554 /* Save the symbol in our cache. */
1555 sym
= XNEW (struct sym_cache
);
1556 sym
->name
= xstrdup (name
);
1558 sym
->next
= proc
->symbol_cache
;
1559 proc
->symbol_cache
= sym
;
1564 /* Relocate an instruction to execute at a different address. OLDLOC
1565 is the address in the inferior memory where the instruction to
1566 relocate is currently at. On input, TO points to the destination
1567 where we want the instruction to be copied (and possibly adjusted)
1568 to. On output, it points to one past the end of the resulting
1569 instruction(s). The effect of executing the instruction at TO
1570 shall be the same as if executing it at OLDLOC. For example, call
1571 instructions that implicitly push the return address on the stack
1572 should be adjusted to return to the instruction after OLDLOC;
1573 relative branches, and other PC-relative instructions need the
1574 offset adjusted; etc. Returns 0 on success, -1 on failure. */
1577 relocate_instruction (CORE_ADDR
*to
, CORE_ADDR oldloc
)
1580 ULONGEST written
= 0;
1582 /* Send the request. */
1583 sprintf (own_buf
, "qRelocInsn:%s;%s", paddress (oldloc
),
1585 if (putpkt (own_buf
) < 0)
1588 /* FIXME: Eventually add buffer overflow checking (to getpkt?) */
1589 len
= getpkt (own_buf
);
1593 /* We ought to handle pretty much any packet at this point while we
1594 wait for the qRelocInsn "response". That requires re-entering
1595 the main loop. For now, this is an adequate approximation; allow
1596 GDB to access memory. */
1597 while (own_buf
[0] == 'm' || own_buf
[0] == 'M' || own_buf
[0] == 'X')
1600 unsigned char *mem_buf
= NULL
;
1601 unsigned int mem_len
;
1603 if (own_buf
[0] == 'm')
1605 decode_m_packet (&own_buf
[1], &mem_addr
, &mem_len
);
1606 mem_buf
= (unsigned char *) xmalloc (mem_len
);
1607 if (read_inferior_memory (mem_addr
, mem_buf
, mem_len
) == 0)
1608 bin2hex (mem_buf
, own_buf
, mem_len
);
1610 write_enn (own_buf
);
1612 else if (own_buf
[0] == 'X')
1614 if (decode_X_packet (&own_buf
[1], len
- 1, &mem_addr
,
1615 &mem_len
, &mem_buf
) < 0
1616 || write_inferior_memory (mem_addr
, mem_buf
, mem_len
) != 0)
1617 write_enn (own_buf
);
1623 decode_M_packet (&own_buf
[1], &mem_addr
, &mem_len
, &mem_buf
);
1624 if (write_inferior_memory (mem_addr
, mem_buf
, mem_len
) == 0)
1627 write_enn (own_buf
);
1630 if (putpkt (own_buf
) < 0)
1632 len
= getpkt (own_buf
);
1637 if (own_buf
[0] == 'E')
1639 warning ("An error occurred while relocating an instruction: %s\n",
1644 if (!startswith (own_buf
, "qRelocInsn:"))
1646 warning ("Malformed response to qRelocInsn, ignoring: %s\n",
1651 unpack_varlen_hex (own_buf
+ strlen ("qRelocInsn:"), &written
);
1658 monitor_output (const char *msg
)
1660 int len
= strlen (msg
);
1661 char *buf
= (char *) xmalloc (len
* 2 + 2);
1664 bin2hex ((const gdb_byte
*) msg
, buf
+ 1, len
);