1 /* Remote utility routines for the remote server for GDB.
2 Copyright (C) 1986-2016 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/>. */
22 #include "gdbthread.h"
28 #include <sys/ioctl.h>
34 #include <netinet/in.h>
37 #include <sys/socket.h>
42 #if HAVE_NETINET_TCP_H
43 #include <netinet/tcp.h>
46 #include <sys/ioctl.h>
54 #include "gdb_sys_time.h"
57 #include <arpa/inet.h>
66 #include <sys/iomgr.h>
69 #ifndef HAVE_SOCKLEN_T
70 typedef int socklen_t
;
73 #ifndef IN_PROCESS_AGENT
76 # define INVALID_DESCRIPTOR INVALID_SOCKET
78 # define INVALID_DESCRIPTOR -1
81 /* Extra value for readchar_callback. */
83 /* The callback is currently not scheduled. */
87 /* Status of the readchar callback.
88 Either NOT_SCHEDULED or the callback id. */
89 static int readchar_callback
= NOT_SCHEDULED
;
91 static int readchar (void);
92 static void reset_readchar (void);
93 static void reschedule (void);
95 /* A cache entry for a successfully looked-up symbol. */
100 struct sym_cache
*next
;
103 int remote_debug
= 0;
104 struct ui_file
*gdb_stdlog
;
106 static int remote_is_stdio
= 0;
108 static gdb_fildes_t remote_desc
= INVALID_DESCRIPTOR
;
109 static gdb_fildes_t listen_desc
= INVALID_DESCRIPTOR
;
111 /* FIXME headerize? */
112 extern int using_threads
;
113 extern int debug_threads
;
115 /* If true, then GDB has requested noack mode. */
117 /* If true, then we tell GDB to use noack mode by default. */
118 int transport_is_reliable
= 0;
121 # define read(fd, buf, len) recv (fd, (char *) buf, len, 0)
122 # define write(fd, buf, len) send (fd, (char *) buf, len, 0)
128 return remote_desc
!= INVALID_DESCRIPTOR
;
131 /* Return true if the remote connection is over stdio. */
134 remote_connection_is_stdio (void)
136 return remote_is_stdio
;
140 enable_async_notification (int fd
)
142 #if defined(F_SETFL) && defined (FASYNC)
143 int save_fcntl_flags
;
145 save_fcntl_flags
= fcntl (fd
, F_GETFL
, 0);
146 fcntl (fd
, F_SETFL
, save_fcntl_flags
| FASYNC
);
147 #if defined (F_SETOWN)
148 fcntl (fd
, F_SETOWN
, getpid ());
154 handle_accept_event (int err
, gdb_client_data client_data
)
156 struct sockaddr_in sockaddr
;
160 debug_printf ("handling possible accept event\n");
162 tmp
= sizeof (sockaddr
);
163 remote_desc
= accept (listen_desc
, (struct sockaddr
*) &sockaddr
, &tmp
);
164 if (remote_desc
== -1)
165 perror_with_name ("Accept failed");
167 /* Enable TCP keep alive process. */
169 setsockopt (remote_desc
, SOL_SOCKET
, SO_KEEPALIVE
,
170 (char *) &tmp
, sizeof (tmp
));
172 /* Tell TCP not to delay small packets. This greatly speeds up
173 interactive response. */
175 setsockopt (remote_desc
, IPPROTO_TCP
, TCP_NODELAY
,
176 (char *) &tmp
, sizeof (tmp
));
179 signal (SIGPIPE
, SIG_IGN
); /* If we don't do this, then gdbserver simply
180 exits when the remote side dies. */
186 close (listen_desc
); /* No longer need this */
188 closesocket (listen_desc
); /* No longer need this */
192 /* Even if !RUN_ONCE no longer notice new connections. Still keep the
193 descriptor open for add_file_handler to wait for a new connection. */
194 delete_file_handler (listen_desc
);
196 /* Convert IP address to string. */
197 fprintf (stderr
, "Remote debugging from host %s\n",
198 inet_ntoa (sockaddr
.sin_addr
));
200 enable_async_notification (remote_desc
);
202 /* Register the event loop handler. */
203 add_file_handler (remote_desc
, handle_serial_event
, NULL
);
205 /* We have a new GDB connection now. If we were disconnected
206 tracing, there's a window where the target could report a stop
207 event to the event loop, and since we have a connection now, we'd
208 try to send vStopped notifications to GDB. But, don't do that
209 until GDB as selected all-stop/non-stop, and has queried the
210 threads' status ('?'). */
216 /* Prepare for a later connection to a remote debugger.
217 NAME is the filename used for communication. */
220 remote_prepare (char *name
)
224 static int winsock_initialized
;
227 struct sockaddr_in sockaddr
;
232 if (strcmp (name
, STDIO_CONNECTION_NAME
) == 0)
234 /* We need to record fact that we're using stdio sooner than the
235 call to remote_open so start_inferior knows the connection is
238 transport_is_reliable
= 1;
242 port_str
= strchr (name
, ':');
243 if (port_str
== NULL
)
245 transport_is_reliable
= 0;
249 port
= strtoul (port_str
+ 1, &port_end
, 10);
250 if (port_str
[1] == '\0' || *port_end
!= '\0')
251 error ("Bad port argument: %s", name
);
254 if (!winsock_initialized
)
258 WSAStartup (MAKEWORD (1, 0), &wsad
);
259 winsock_initialized
= 1;
263 listen_desc
= socket (PF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
264 if (listen_desc
== -1)
265 perror_with_name ("Can't open socket");
267 /* Allow rapid reuse of this port. */
269 setsockopt (listen_desc
, SOL_SOCKET
, SO_REUSEADDR
, (char *) &tmp
,
272 sockaddr
.sin_family
= PF_INET
;
273 sockaddr
.sin_port
= htons (port
);
274 sockaddr
.sin_addr
.s_addr
= INADDR_ANY
;
276 if (bind (listen_desc
, (struct sockaddr
*) &sockaddr
, sizeof (sockaddr
))
277 || listen (listen_desc
, 1))
278 perror_with_name ("Can't bind address");
280 transport_is_reliable
= 1;
283 /* Open a connection to a remote debugger.
284 NAME is the filename used for communication. */
287 remote_open (char *name
)
291 port_str
= strchr (name
, ':');
293 if (port_str
== NULL
)
294 error ("Only <host>:<port> is supported on this platform.");
297 if (strcmp (name
, STDIO_CONNECTION_NAME
) == 0)
299 fprintf (stderr
, "Remote debugging using stdio\n");
301 /* Use stdin as the handle of the connection.
302 We only select on reads, for example. */
303 remote_desc
= fileno (stdin
);
305 enable_async_notification (remote_desc
);
307 /* Register the event loop handler. */
308 add_file_handler (remote_desc
, handle_serial_event
, NULL
);
311 else if (port_str
== NULL
)
315 if (stat (name
, &statbuf
) == 0
316 && (S_ISCHR (statbuf
.st_mode
) || S_ISFIFO (statbuf
.st_mode
)))
317 remote_desc
= open (name
, O_RDWR
);
325 perror_with_name ("Could not open remote device");
329 struct termios termios
;
330 tcgetattr (remote_desc
, &termios
);
335 termios
.c_cflag
&= ~(CSIZE
| PARENB
);
336 termios
.c_cflag
|= CLOCAL
| CS8
;
337 termios
.c_cc
[VMIN
] = 1;
338 termios
.c_cc
[VTIME
] = 0;
340 tcsetattr (remote_desc
, TCSANOW
, &termios
);
346 struct termio termio
;
347 ioctl (remote_desc
, TCGETA
, &termio
);
352 termio
.c_cflag
&= ~(CSIZE
| PARENB
);
353 termio
.c_cflag
|= CLOCAL
| CS8
;
354 termio
.c_cc
[VMIN
] = 1;
355 termio
.c_cc
[VTIME
] = 0;
357 ioctl (remote_desc
, TCSETA
, &termio
);
365 ioctl (remote_desc
, TIOCGETP
, &sg
);
367 ioctl (remote_desc
, TIOCSETP
, &sg
);
371 fprintf (stderr
, "Remote debugging using %s\n", name
);
373 enable_async_notification (remote_desc
);
375 /* Register the event loop handler. */
376 add_file_handler (remote_desc
, handle_serial_event
, NULL
);
378 #endif /* USE_WIN32API */
383 struct sockaddr_in sockaddr
;
385 len
= sizeof (sockaddr
);
386 if (getsockname (listen_desc
,
387 (struct sockaddr
*) &sockaddr
, &len
) < 0
388 || len
< sizeof (sockaddr
))
389 perror_with_name ("Can't determine port");
390 port
= ntohs (sockaddr
.sin_port
);
392 fprintf (stderr
, "Listening on port %d\n", port
);
395 /* Register the event loop handler. */
396 add_file_handler (listen_desc
, handle_accept_event
, NULL
);
403 delete_file_handler (remote_desc
);
406 closesocket (remote_desc
);
408 if (! remote_connection_is_stdio ())
411 remote_desc
= INVALID_DESCRIPTOR
;
418 #ifndef IN_PROCESS_AGENT
421 decode_address (CORE_ADDR
*addrp
, const char *start
, int len
)
428 for (i
= 0; i
< len
; i
++)
432 addr
= addr
| (fromhex (ch
) & 0x0f);
438 decode_address_to_semicolon (CORE_ADDR
*addrp
, const char *start
)
443 while (*end
!= '\0' && *end
!= ';')
446 decode_address (addrp
, start
, end
- start
);
455 #ifndef IN_PROCESS_AGENT
457 /* Look for a sequence of characters which can be run-length encoded.
458 If there are any, update *CSUM and *P. Otherwise, output the
459 single character. Return the number of characters consumed. */
462 try_rle (char *buf
, int remaining
, unsigned char *csum
, char **p
)
466 /* Always output the character. */
470 /* Don't go past '~'. */
474 for (n
= 1; n
< remaining
; n
++)
475 if (buf
[n
] != buf
[0])
478 /* N is the index of the first character not the same as buf[0].
479 buf[0] is counted twice, so by decrementing N, we get the number
480 of characters the RLE sequence will replace. */
486 /* Skip the frame characters. The manual says to skip '+' and '-'
487 also, but there's no reason to. Unfortunately these two unusable
488 characters double the encoded length of a four byte zero
490 while (n
+ 29 == '$' || n
+ 29 == '#')
503 #ifndef IN_PROCESS_AGENT
505 /* Write a PTID to BUF. Returns BUF+CHARACTERS_WRITTEN. */
508 write_ptid (char *buf
, ptid_t ptid
)
514 pid
= ptid_get_pid (ptid
);
516 buf
+= sprintf (buf
, "p-%x.", -pid
);
518 buf
+= sprintf (buf
, "p%x.", pid
);
520 tid
= ptid_get_lwp (ptid
);
522 buf
+= sprintf (buf
, "-%x", -tid
);
524 buf
+= sprintf (buf
, "%x", tid
);
530 hex_or_minus_one (char *buf
, char **obuf
)
534 if (startswith (buf
, "-1"))
540 buf
= unpack_varlen_hex (buf
, &ret
);
548 /* Extract a PTID from BUF. If non-null, OBUF is set to the to one
549 passed the last parsed char. Returns null_ptid on error. */
551 read_ptid (char *buf
, char **obuf
)
555 ULONGEST pid
= 0, tid
= 0;
559 /* Multi-process ptid. */
560 pp
= unpack_varlen_hex (p
+ 1, &pid
);
562 error ("invalid remote ptid: %s\n", p
);
566 tid
= hex_or_minus_one (p
, &pp
);
570 return ptid_build (pid
, tid
, 0);
573 /* No multi-process. Just a tid. */
574 tid
= hex_or_minus_one (p
, &pp
);
576 /* Since GDB is not sending a process id (multi-process extensions
577 are off), then there's only one process. Default to the first in
579 pid
= pid_of (get_first_process ());
583 return ptid_build (pid
, tid
, 0);
586 /* Write COUNT bytes in BUF to the client.
587 The result is the number of bytes written or -1 if error.
588 This may return less than COUNT. */
591 write_prim (const void *buf
, int count
)
593 if (remote_connection_is_stdio ())
594 return write (fileno (stdout
), buf
, count
);
596 return write (remote_desc
, buf
, count
);
599 /* Read COUNT bytes from the client and store in BUF.
600 The result is the number of bytes read or -1 if error.
601 This may return less than COUNT. */
604 read_prim (void *buf
, int count
)
606 if (remote_connection_is_stdio ())
607 return read (fileno (stdin
), buf
, count
);
609 return read (remote_desc
, buf
, count
);
612 /* Send a packet to the remote machine, with error checking.
613 The data of the packet is in BUF, and the length of the
614 packet is in CNT. Returns >= 0 on success, -1 otherwise. */
617 putpkt_binary_1 (char *buf
, int cnt
, int is_notif
)
620 unsigned char csum
= 0;
625 buf2
= (char *) xmalloc (strlen ("$") + cnt
+ strlen ("#nn") + 1);
627 /* Copy the packet into buffer BUF2, encapsulating it
628 and giving it a checksum. */
636 for (i
= 0; i
< cnt
;)
637 i
+= try_rle (buf
+ i
, cnt
- i
, &csum
, &p
);
640 *p
++ = tohex ((csum
>> 4) & 0xf);
641 *p
++ = tohex (csum
& 0xf);
645 /* Send it over and over until we get a positive ack. */
649 if (write_prim (buf2
, p
- buf2
) != p
- buf2
)
651 perror ("putpkt(write)");
656 if (noack_mode
|| is_notif
)
658 /* Don't expect an ack then. */
662 fprintf (stderr
, "putpkt (\"%s\"); [notif]\n", buf2
);
664 fprintf (stderr
, "putpkt (\"%s\"); [noack mode]\n", buf2
);
672 fprintf (stderr
, "putpkt (\"%s\"); [looking for ack]\n", buf2
);
686 fprintf (stderr
, "[received '%c' (0x%x)]\n", cc
, cc
);
690 /* Check for an input interrupt while we're here. */
691 if (cc
== '\003' && current_thread
!= NULL
)
692 (*the_target
->request_interrupt
) ();
697 return 1; /* Success! */
701 putpkt_binary (char *buf
, int cnt
)
703 return putpkt_binary_1 (buf
, cnt
, 0);
706 /* Send a packet to the remote machine, with error checking. The data
707 of the packet is in BUF, and the packet should be a NUL-terminated
708 string. Returns >= 0 on success, -1 otherwise. */
713 return putpkt_binary (buf
, strlen (buf
));
717 putpkt_notif (char *buf
)
719 return putpkt_binary_1 (buf
, strlen (buf
), 1);
722 /* Come here when we get an input interrupt from the remote side. This
723 interrupt should only be active while we are waiting for the child to do
724 something. Thus this assumes readchar:bufcnt is 0.
725 About the only thing that should come through is a ^C, which
726 will cause us to request child interruption. */
729 input_interrupt (int unused
)
732 struct timeval immediate
= { 0, 0 };
734 /* Protect against spurious interrupts. This has been observed to
735 be a problem under NetBSD 1.4 and 1.5. */
738 FD_SET (remote_desc
, &readset
);
739 if (select (remote_desc
+ 1, &readset
, 0, 0, &immediate
) > 0)
744 cc
= read_prim (&c
, 1);
748 fprintf (stderr
, "client connection closed\n");
751 else if (cc
!= 1 || c
!= '\003')
753 fprintf (stderr
, "input_interrupt, count = %d c = %d ", cc
, c
);
755 fprintf (stderr
, "('%c')\n", c
);
757 fprintf (stderr
, "('\\x%02x')\n", c
& 0xff);
761 (*the_target
->request_interrupt
) ();
765 /* Check if the remote side sent us an interrupt request (^C). */
767 check_remote_input_interrupt_request (void)
769 /* This function may be called before establishing communications,
770 therefore we need to validate the remote descriptor. */
772 if (remote_desc
== INVALID_DESCRIPTOR
)
778 /* Asynchronous I/O support. SIGIO must be enabled when waiting, in order to
779 accept Control-C from the client, and must be disabled when talking to
783 unblock_async_io (void)
788 sigemptyset (&sigio_set
);
789 sigaddset (&sigio_set
, SIGIO
);
790 sigprocmask (SIG_UNBLOCK
, &sigio_set
, NULL
);
796 nto_comctrl (int enable
)
798 struct sigevent event
;
802 event
.sigev_notify
= SIGEV_SIGNAL_THREAD
;
803 event
.sigev_signo
= SIGIO
;
804 event
.sigev_code
= 0;
805 event
.sigev_value
.sival_ptr
= NULL
;
806 event
.sigev_priority
= -1;
807 ionotify (remote_desc
, _NOTIFY_ACTION_POLLARM
, _NOTIFY_COND_INPUT
,
811 ionotify (remote_desc
, _NOTIFY_ACTION_POLL
, _NOTIFY_COND_INPUT
, NULL
);
816 /* Current state of asynchronous I/O. */
817 static int async_io_enabled
;
819 /* Enable asynchronous I/O. */
821 enable_async_io (void)
823 if (async_io_enabled
)
827 signal (SIGIO
, input_interrupt
);
829 async_io_enabled
= 1;
835 /* Disable asynchronous I/O. */
837 disable_async_io (void)
839 if (!async_io_enabled
)
843 signal (SIGIO
, SIG_IGN
);
845 async_io_enabled
= 0;
853 initialize_async_io (void)
855 /* Make sure that async I/O starts disabled. */
856 async_io_enabled
= 1;
859 /* Make sure the signal is unblocked. */
863 /* Internal buffer used by readchar.
864 These are global to readchar because reschedule_remote needs to be
865 able to tell whether the buffer is empty. */
867 static unsigned char readchar_buf
[BUFSIZ
];
868 static int readchar_bufcnt
= 0;
869 static unsigned char *readchar_bufp
;
871 /* Returns next char from remote GDB. -1 if error. */
878 if (readchar_bufcnt
== 0)
880 readchar_bufcnt
= read_prim (readchar_buf
, sizeof (readchar_buf
));
882 if (readchar_bufcnt
<= 0)
884 if (readchar_bufcnt
== 0)
887 fprintf (stderr
, "readchar: Got EOF\n");
895 readchar_bufp
= readchar_buf
;
899 ch
= *readchar_bufp
++;
904 /* Reset the readchar state machine. */
907 reset_readchar (void)
910 if (readchar_callback
!= NOT_SCHEDULED
)
912 delete_callback_event (readchar_callback
);
913 readchar_callback
= NOT_SCHEDULED
;
917 /* Process remaining data in readchar_buf. */
920 process_remaining (void *context
)
924 /* This is a one-shot event. */
925 readchar_callback
= NOT_SCHEDULED
;
927 if (readchar_bufcnt
> 0)
928 res
= handle_serial_event (0, NULL
);
935 /* If there is still data in the buffer, queue another event to process it,
936 we can't sleep in select yet. */
941 if (readchar_bufcnt
> 0 && readchar_callback
== NOT_SCHEDULED
)
942 readchar_callback
= append_callback_event (process_remaining
, NULL
);
945 /* Read a packet from the remote machine, with error checking,
946 and store it in BUF. Returns length of packet, or negative if error. */
952 unsigned char csum
, c1
, c2
;
963 /* The '\003' may appear before or after each packet, so
964 check for an input interrupt. */
967 (*the_target
->request_interrupt
) ();
975 fprintf (stderr
, "[getpkt: discarding char '%c']\n", c
);
996 c1
= fromhex (readchar ());
997 c2
= fromhex (readchar ());
999 if (csum
== (c1
<< 4) + c2
)
1005 "Bad checksum, sentsum=0x%x, csum=0x%x, "
1006 "buf=%s [no-ack-mode, Bad medium?]\n",
1007 (c1
<< 4) + c2
, csum
, buf
);
1008 /* Not much we can do, GDB wasn't expecting an ack/nac. */
1012 fprintf (stderr
, "Bad checksum, sentsum=0x%x, csum=0x%x, buf=%s\n",
1013 (c1
<< 4) + c2
, csum
, buf
);
1014 if (write_prim ("-", 1) != 1)
1022 fprintf (stderr
, "getpkt (\"%s\"); [sending ack] \n", buf
);
1026 if (write_prim ("+", 1) != 1)
1031 fprintf (stderr
, "[sent ack]\n");
1039 fprintf (stderr
, "getpkt (\"%s\"); [no ack sent] \n", buf
);
1044 /* The readchar above may have already read a '\003' out of the socket
1045 and moved it to the local buffer. For example, when GDB sends
1046 vCont;c immediately followed by interrupt (see
1047 gdb.base/interrupt-noterm.exp). As soon as we see the vCont;c, we'll
1048 resume the inferior and wait. Since we've already moved the '\003'
1049 to the local buffer, SIGIO won't help. In that case, if we don't
1050 check for interrupt after the vCont;c packet, the interrupt character
1051 would stay in the buffer unattended until after the next (unrelated)
1053 while (readchar_bufcnt
> 0 && *readchar_bufp
== '\003')
1055 /* Consume the interrupt character in the buffer. */
1057 (*the_target
->request_interrupt
) ();
1064 write_ok (char *buf
)
1072 write_enn (char *buf
)
1074 /* Some day, we should define the meanings of the error codes... */
1083 #ifndef IN_PROCESS_AGENT
1086 outreg (struct regcache
*regcache
, int regno
, char *buf
)
1088 if ((regno
>> 12) != 0)
1089 *buf
++ = tohex ((regno
>> 12) & 0xf);
1090 if ((regno
>> 8) != 0)
1091 *buf
++ = tohex ((regno
>> 8) & 0xf);
1092 *buf
++ = tohex ((regno
>> 4) & 0xf);
1093 *buf
++ = tohex (regno
& 0xf);
1095 collect_register_as_string (regcache
, regno
, buf
);
1096 buf
+= 2 * register_size (regcache
->tdesc
, regno
);
1103 prepare_resume_reply (char *buf
, ptid_t ptid
,
1104 struct target_waitstatus
*status
)
1107 debug_printf ("Writing resume reply for %s:%d\n",
1108 target_pid_to_str (ptid
), status
->kind
);
1110 switch (status
->kind
)
1112 case TARGET_WAITKIND_STOPPED
:
1113 case TARGET_WAITKIND_FORKED
:
1114 case TARGET_WAITKIND_VFORKED
:
1115 case TARGET_WAITKIND_VFORK_DONE
:
1116 case TARGET_WAITKIND_EXECD
:
1117 case TARGET_WAITKIND_THREAD_CREATED
:
1118 case TARGET_WAITKIND_SYSCALL_ENTRY
:
1119 case TARGET_WAITKIND_SYSCALL_RETURN
:
1121 struct thread_info
*saved_thread
;
1123 struct regcache
*regcache
;
1125 if ((status
->kind
== TARGET_WAITKIND_FORKED
&& report_fork_events
)
1126 || (status
->kind
== TARGET_WAITKIND_VFORKED
&& report_vfork_events
))
1128 enum gdb_signal signal
= GDB_SIGNAL_TRAP
;
1129 const char *event
= (status
->kind
== TARGET_WAITKIND_FORKED
1130 ? "fork" : "vfork");
1132 sprintf (buf
, "T%02x%s:", signal
, event
);
1133 buf
+= strlen (buf
);
1134 buf
= write_ptid (buf
, status
->value
.related_pid
);
1137 else if (status
->kind
== TARGET_WAITKIND_VFORK_DONE
&& report_vfork_events
)
1139 enum gdb_signal signal
= GDB_SIGNAL_TRAP
;
1141 sprintf (buf
, "T%02xvforkdone:;", signal
);
1143 else if (status
->kind
== TARGET_WAITKIND_EXECD
&& report_exec_events
)
1145 enum gdb_signal signal
= GDB_SIGNAL_TRAP
;
1146 const char *event
= "exec";
1147 char hexified_pathname
[PATH_MAX
* 2];
1149 sprintf (buf
, "T%02x%s:", signal
, event
);
1150 buf
+= strlen (buf
);
1152 /* Encode pathname to hexified format. */
1153 bin2hex ((const gdb_byte
*) status
->value
.execd_pathname
,
1155 strlen (status
->value
.execd_pathname
));
1157 sprintf (buf
, "%s;", hexified_pathname
);
1158 xfree (status
->value
.execd_pathname
);
1159 status
->value
.execd_pathname
= NULL
;
1160 buf
+= strlen (buf
);
1162 else if (status
->kind
== TARGET_WAITKIND_THREAD_CREATED
1163 && report_thread_events
)
1165 enum gdb_signal signal
= GDB_SIGNAL_TRAP
;
1167 sprintf (buf
, "T%02xcreate:;", signal
);
1169 else if (status
->kind
== TARGET_WAITKIND_SYSCALL_ENTRY
1170 || status
->kind
== TARGET_WAITKIND_SYSCALL_RETURN
)
1172 enum gdb_signal signal
= GDB_SIGNAL_TRAP
;
1173 const char *event
= (status
->kind
== TARGET_WAITKIND_SYSCALL_ENTRY
1174 ? "syscall_entry" : "syscall_return");
1176 sprintf (buf
, "T%02x%s:%x;", signal
, event
,
1177 status
->value
.syscall_number
);
1180 sprintf (buf
, "T%02x", status
->value
.sig
);
1182 buf
+= strlen (buf
);
1184 saved_thread
= current_thread
;
1186 current_thread
= find_thread_ptid (ptid
);
1188 regp
= current_target_desc ()->expedite_regs
;
1190 regcache
= get_thread_regcache (current_thread
, 1);
1192 if (the_target
->stopped_by_watchpoint
!= NULL
1193 && (*the_target
->stopped_by_watchpoint
) ())
1198 strncpy (buf
, "watch:", 6);
1201 addr
= (*the_target
->stopped_data_address
) ();
1203 /* Convert each byte of the address into two hexadecimal
1204 chars. Note that we take sizeof (void *) instead of
1205 sizeof (addr); this is to avoid sending a 64-bit
1206 address to a 32-bit GDB. */
1207 for (i
= sizeof (void *) * 2; i
> 0; i
--)
1208 *buf
++ = tohex ((addr
>> (i
- 1) * 4) & 0xf);
1211 else if (swbreak_feature
&& target_stopped_by_sw_breakpoint ())
1213 sprintf (buf
, "swbreak:;");
1214 buf
+= strlen (buf
);
1216 else if (hwbreak_feature
&& target_stopped_by_hw_breakpoint ())
1218 sprintf (buf
, "hwbreak:;");
1219 buf
+= strlen (buf
);
1224 buf
= outreg (regcache
, find_regno (regcache
->tdesc
, *regp
), buf
);
1229 /* Formerly, if the debugger had not used any thread features
1230 we would not burden it with a thread status response. This
1231 was for the benefit of GDB 4.13 and older. However, in
1232 recent GDB versions the check (``if (cont_thread != 0)'')
1233 does not have the desired effect because of sillyness in
1234 the way that the remote protocol handles specifying a
1235 thread. Since thread support relies on qSymbol support
1236 anyway, assume GDB can handle threads. */
1238 if (using_threads
&& !disable_packet_Tthread
)
1240 /* This if (1) ought to be unnecessary. But remote_wait
1241 in GDB will claim this event belongs to inferior_ptid
1242 if we do not specify a thread, and there's no way for
1243 gdbserver to know what inferior_ptid is. */
1244 if (1 || !ptid_equal (general_thread
, ptid
))
1247 /* In non-stop, don't change the general thread behind
1250 general_thread
= ptid
;
1251 sprintf (buf
, "thread:");
1252 buf
+= strlen (buf
);
1253 buf
= write_ptid (buf
, ptid
);
1255 buf
+= strlen (buf
);
1257 core
= target_core_of_thread (ptid
);
1261 sprintf (buf
, "core:");
1262 buf
+= strlen (buf
);
1263 sprintf (buf
, "%x", core
);
1265 buf
+= strlen (buf
);
1272 strcpy (buf
, "library:;");
1273 buf
+= strlen (buf
);
1277 current_thread
= saved_thread
;
1280 case TARGET_WAITKIND_EXITED
:
1282 sprintf (buf
, "W%x;process:%x",
1283 status
->value
.integer
, ptid_get_pid (ptid
));
1285 sprintf (buf
, "W%02x", status
->value
.integer
);
1287 case TARGET_WAITKIND_SIGNALLED
:
1289 sprintf (buf
, "X%x;process:%x",
1290 status
->value
.sig
, ptid_get_pid (ptid
));
1292 sprintf (buf
, "X%02x", status
->value
.sig
);
1294 case TARGET_WAITKIND_THREAD_EXITED
:
1295 sprintf (buf
, "w%x;", status
->value
.integer
);
1296 buf
+= strlen (buf
);
1297 buf
= write_ptid (buf
, ptid
);
1299 case TARGET_WAITKIND_NO_RESUMED
:
1303 error ("unhandled waitkind");
1309 decode_m_packet (char *from
, CORE_ADDR
*mem_addr_ptr
, unsigned int *len_ptr
)
1313 *mem_addr_ptr
= *len_ptr
= 0;
1315 while ((ch
= from
[i
++]) != ',')
1317 *mem_addr_ptr
= *mem_addr_ptr
<< 4;
1318 *mem_addr_ptr
|= fromhex (ch
) & 0x0f;
1321 for (j
= 0; j
< 4; j
++)
1323 if ((ch
= from
[i
++]) == 0)
1325 *len_ptr
= *len_ptr
<< 4;
1326 *len_ptr
|= fromhex (ch
) & 0x0f;
1331 decode_M_packet (char *from
, CORE_ADDR
*mem_addr_ptr
, unsigned int *len_ptr
,
1332 unsigned char **to_p
)
1336 *mem_addr_ptr
= *len_ptr
= 0;
1338 while ((ch
= from
[i
++]) != ',')
1340 *mem_addr_ptr
= *mem_addr_ptr
<< 4;
1341 *mem_addr_ptr
|= fromhex (ch
) & 0x0f;
1344 while ((ch
= from
[i
++]) != ':')
1346 *len_ptr
= *len_ptr
<< 4;
1347 *len_ptr
|= fromhex (ch
) & 0x0f;
1351 *to_p
= (unsigned char *) xmalloc (*len_ptr
);
1353 hex2bin (&from
[i
++], *to_p
, *len_ptr
);
1357 decode_X_packet (char *from
, int packet_len
, CORE_ADDR
*mem_addr_ptr
,
1358 unsigned int *len_ptr
, unsigned char **to_p
)
1362 *mem_addr_ptr
= *len_ptr
= 0;
1364 while ((ch
= from
[i
++]) != ',')
1366 *mem_addr_ptr
= *mem_addr_ptr
<< 4;
1367 *mem_addr_ptr
|= fromhex (ch
) & 0x0f;
1370 while ((ch
= from
[i
++]) != ':')
1372 *len_ptr
= *len_ptr
<< 4;
1373 *len_ptr
|= fromhex (ch
) & 0x0f;
1377 *to_p
= (unsigned char *) xmalloc (*len_ptr
);
1379 if (remote_unescape_input ((const gdb_byte
*) &from
[i
], packet_len
- i
,
1380 *to_p
, *len_ptr
) != *len_ptr
)
1386 /* Decode a qXfer write request. */
1389 decode_xfer_write (char *buf
, int packet_len
, CORE_ADDR
*offset
,
1390 unsigned int *len
, unsigned char *data
)
1395 /* Extract the offset. */
1397 while ((ch
= *buf
++) != ':')
1399 *offset
= *offset
<< 4;
1400 *offset
|= fromhex (ch
) & 0x0f;
1403 /* Get encoded data. */
1404 packet_len
-= buf
- b
;
1405 *len
= remote_unescape_input ((const gdb_byte
*) buf
, packet_len
,
1410 /* Decode the parameters of a qSearch:memory packet. */
1413 decode_search_memory_packet (const char *buf
, int packet_len
,
1414 CORE_ADDR
*start_addrp
,
1415 CORE_ADDR
*search_space_lenp
,
1416 gdb_byte
*pattern
, unsigned int *pattern_lenp
)
1418 const char *p
= buf
;
1420 p
= decode_address_to_semicolon (start_addrp
, p
);
1421 p
= decode_address_to_semicolon (search_space_lenp
, p
);
1422 packet_len
-= p
- buf
;
1423 *pattern_lenp
= remote_unescape_input ((const gdb_byte
*) p
, packet_len
,
1424 pattern
, packet_len
);
1429 free_sym_cache (struct sym_cache
*sym
)
1439 clear_symbol_cache (struct sym_cache
**symcache_p
)
1441 struct sym_cache
*sym
, *next
;
1443 /* Check the cache first. */
1444 for (sym
= *symcache_p
; sym
; sym
= next
)
1447 free_sym_cache (sym
);
1453 /* Get the address of NAME, and return it in ADDRP if found. if
1454 MAY_ASK_GDB is false, assume symbol cache misses are failures.
1455 Returns 1 if the symbol is found, 0 if it is not, -1 on error. */
1458 look_up_one_symbol (const char *name
, CORE_ADDR
*addrp
, int may_ask_gdb
)
1460 char own_buf
[266], *p
, *q
;
1462 struct sym_cache
*sym
;
1463 struct process_info
*proc
;
1465 proc
= current_process ();
1467 /* Check the cache first. */
1468 for (sym
= proc
->symbol_cache
; sym
; sym
= sym
->next
)
1469 if (strcmp (name
, sym
->name
) == 0)
1475 /* It might not be an appropriate time to look up a symbol,
1476 e.g. while we're trying to fetch registers. */
1480 /* Send the request. */
1481 strcpy (own_buf
, "qSymbol:");
1482 bin2hex ((const gdb_byte
*) name
, own_buf
+ strlen ("qSymbol:"),
1484 if (putpkt (own_buf
) < 0)
1487 /* FIXME: Eventually add buffer overflow checking (to getpkt?) */
1488 len
= getpkt (own_buf
);
1492 /* We ought to handle pretty much any packet at this point while we
1493 wait for the qSymbol "response". That requires re-entering the
1494 main loop. For now, this is an adequate approximation; allow
1495 GDB to read from memory while it figures out the address of the
1497 while (own_buf
[0] == 'm')
1500 unsigned char *mem_buf
;
1501 unsigned int mem_len
;
1503 decode_m_packet (&own_buf
[1], &mem_addr
, &mem_len
);
1504 mem_buf
= (unsigned char *) xmalloc (mem_len
);
1505 if (read_inferior_memory (mem_addr
, mem_buf
, mem_len
) == 0)
1506 bin2hex (mem_buf
, own_buf
, mem_len
);
1508 write_enn (own_buf
);
1510 if (putpkt (own_buf
) < 0)
1512 len
= getpkt (own_buf
);
1517 if (!startswith (own_buf
, "qSymbol:"))
1519 warning ("Malformed response to qSymbol, ignoring: %s\n", own_buf
);
1523 p
= own_buf
+ strlen ("qSymbol:");
1525 while (*q
&& *q
!= ':')
1528 /* Make sure we found a value for the symbol. */
1529 if (p
== q
|| *q
== '\0')
1532 decode_address (addrp
, p
, q
- p
);
1534 /* Save the symbol in our cache. */
1535 sym
= XNEW (struct sym_cache
);
1536 sym
->name
= xstrdup (name
);
1538 sym
->next
= proc
->symbol_cache
;
1539 proc
->symbol_cache
= sym
;
1544 /* Relocate an instruction to execute at a different address. OLDLOC
1545 is the address in the inferior memory where the instruction to
1546 relocate is currently at. On input, TO points to the destination
1547 where we want the instruction to be copied (and possibly adjusted)
1548 to. On output, it points to one past the end of the resulting
1549 instruction(s). The effect of executing the instruction at TO
1550 shall be the same as if executing it at OLDLOC. For example, call
1551 instructions that implicitly push the return address on the stack
1552 should be adjusted to return to the instruction after OLDLOC;
1553 relative branches, and other PC-relative instructions need the
1554 offset adjusted; etc. Returns 0 on success, -1 on failure. */
1557 relocate_instruction (CORE_ADDR
*to
, CORE_ADDR oldloc
)
1561 ULONGEST written
= 0;
1563 /* Send the request. */
1564 strcpy (own_buf
, "qRelocInsn:");
1565 sprintf (own_buf
, "qRelocInsn:%s;%s", paddress (oldloc
),
1567 if (putpkt (own_buf
) < 0)
1570 /* FIXME: Eventually add buffer overflow checking (to getpkt?) */
1571 len
= getpkt (own_buf
);
1575 /* We ought to handle pretty much any packet at this point while we
1576 wait for the qRelocInsn "response". That requires re-entering
1577 the main loop. For now, this is an adequate approximation; allow
1578 GDB to access memory. */
1579 while (own_buf
[0] == 'm' || own_buf
[0] == 'M' || own_buf
[0] == 'X')
1582 unsigned char *mem_buf
= NULL
;
1583 unsigned int mem_len
;
1585 if (own_buf
[0] == 'm')
1587 decode_m_packet (&own_buf
[1], &mem_addr
, &mem_len
);
1588 mem_buf
= (unsigned char *) xmalloc (mem_len
);
1589 if (read_inferior_memory (mem_addr
, mem_buf
, mem_len
) == 0)
1590 bin2hex (mem_buf
, own_buf
, mem_len
);
1592 write_enn (own_buf
);
1594 else if (own_buf
[0] == 'X')
1596 if (decode_X_packet (&own_buf
[1], len
- 1, &mem_addr
,
1597 &mem_len
, &mem_buf
) < 0
1598 || write_inferior_memory (mem_addr
, mem_buf
, mem_len
) != 0)
1599 write_enn (own_buf
);
1605 decode_M_packet (&own_buf
[1], &mem_addr
, &mem_len
, &mem_buf
);
1606 if (write_inferior_memory (mem_addr
, mem_buf
, mem_len
) == 0)
1609 write_enn (own_buf
);
1612 if (putpkt (own_buf
) < 0)
1614 len
= getpkt (own_buf
);
1619 if (own_buf
[0] == 'E')
1621 warning ("An error occurred while relocating an instruction: %s\n",
1626 if (!startswith (own_buf
, "qRelocInsn:"))
1628 warning ("Malformed response to qRelocInsn, ignoring: %s\n",
1633 unpack_varlen_hex (own_buf
+ strlen ("qRelocInsn:"), &written
);
1640 monitor_output (const char *msg
)
1642 int len
= strlen (msg
);
1643 char *buf
= (char *) xmalloc (len
* 2 + 2);
1646 bin2hex ((const gdb_byte
*) msg
, buf
+ 1, len
);