1 /* Remote utility routines for the remote server for GDB.
2 Copyright (C) 1986-2018 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
);
384 closesocket (remote_desc
);
386 if (! remote_connection_is_stdio ())
389 remote_desc
= INVALID_DESCRIPTOR
;
396 #ifndef IN_PROCESS_AGENT
399 decode_address (CORE_ADDR
*addrp
, const char *start
, int len
)
406 for (i
= 0; i
< len
; i
++)
410 addr
= addr
| (fromhex (ch
) & 0x0f);
416 decode_address_to_semicolon (CORE_ADDR
*addrp
, const char *start
)
421 while (*end
!= '\0' && *end
!= ';')
424 decode_address (addrp
, start
, end
- start
);
433 #ifndef IN_PROCESS_AGENT
435 /* Look for a sequence of characters which can be run-length encoded.
436 If there are any, update *CSUM and *P. Otherwise, output the
437 single character. Return the number of characters consumed. */
440 try_rle (char *buf
, int remaining
, unsigned char *csum
, char **p
)
444 /* Always output the character. */
448 /* Don't go past '~'. */
452 for (n
= 1; n
< remaining
; n
++)
453 if (buf
[n
] != buf
[0])
456 /* N is the index of the first character not the same as buf[0].
457 buf[0] is counted twice, so by decrementing N, we get the number
458 of characters the RLE sequence will replace. */
464 /* Skip the frame characters. The manual says to skip '+' and '-'
465 also, but there's no reason to. Unfortunately these two unusable
466 characters double the encoded length of a four byte zero
468 while (n
+ 29 == '$' || n
+ 29 == '#')
481 #ifndef IN_PROCESS_AGENT
483 /* Write a PTID to BUF. Returns BUF+CHARACTERS_WRITTEN. */
486 write_ptid (char *buf
, ptid_t ptid
)
492 pid
= ptid_get_pid (ptid
);
494 buf
+= sprintf (buf
, "p-%x.", -pid
);
496 buf
+= sprintf (buf
, "p%x.", pid
);
498 tid
= ptid_get_lwp (ptid
);
500 buf
+= sprintf (buf
, "-%x", -tid
);
502 buf
+= sprintf (buf
, "%x", tid
);
508 hex_or_minus_one (const char *buf
, const char **obuf
)
512 if (startswith (buf
, "-1"))
518 buf
= unpack_varlen_hex (buf
, &ret
);
526 /* Extract a PTID from BUF. If non-null, OBUF is set to the to one
527 passed the last parsed char. Returns null_ptid on error. */
529 read_ptid (const char *buf
, const char **obuf
)
533 ULONGEST pid
= 0, tid
= 0;
537 /* Multi-process ptid. */
538 pp
= unpack_varlen_hex (p
+ 1, &pid
);
540 error ("invalid remote ptid: %s\n", p
);
544 tid
= hex_or_minus_one (p
, &pp
);
548 return ptid_build (pid
, tid
, 0);
551 /* No multi-process. Just a tid. */
552 tid
= hex_or_minus_one (p
, &pp
);
554 /* Since GDB is not sending a process id (multi-process extensions
555 are off), then there's only one process. Default to the first in
557 pid
= pid_of (get_first_process ());
561 return ptid_build (pid
, tid
, 0);
564 /* Write COUNT bytes in BUF to the client.
565 The result is the number of bytes written or -1 if error.
566 This may return less than COUNT. */
569 write_prim (const void *buf
, int count
)
571 if (remote_connection_is_stdio ())
572 return write (fileno (stdout
), buf
, count
);
574 return write (remote_desc
, buf
, count
);
577 /* Read COUNT bytes from the client and store in BUF.
578 The result is the number of bytes read or -1 if error.
579 This may return less than COUNT. */
582 read_prim (void *buf
, int count
)
584 if (remote_connection_is_stdio ())
585 return read (fileno (stdin
), buf
, count
);
587 return read (remote_desc
, buf
, count
);
590 /* Send a packet to the remote machine, with error checking.
591 The data of the packet is in BUF, and the length of the
592 packet is in CNT. Returns >= 0 on success, -1 otherwise. */
595 putpkt_binary_1 (char *buf
, int cnt
, int is_notif
)
598 unsigned char csum
= 0;
603 buf2
= (char *) xmalloc (strlen ("$") + cnt
+ strlen ("#nn") + 1);
605 /* Copy the packet into buffer BUF2, encapsulating it
606 and giving it a checksum. */
614 for (i
= 0; i
< cnt
;)
615 i
+= try_rle (buf
+ i
, cnt
- i
, &csum
, &p
);
618 *p
++ = tohex ((csum
>> 4) & 0xf);
619 *p
++ = tohex (csum
& 0xf);
623 /* Send it over and over until we get a positive ack. */
627 if (write_prim (buf2
, p
- buf2
) != p
- buf2
)
629 perror ("putpkt(write)");
634 if (noack_mode
|| is_notif
)
636 /* Don't expect an ack then. */
640 debug_printf ("putpkt (\"%s\"); [notif]\n", buf2
);
642 debug_printf ("putpkt (\"%s\"); [noack mode]\n", buf2
);
650 debug_printf ("putpkt (\"%s\"); [looking for ack]\n", buf2
);
664 debug_printf ("[received '%c' (0x%x)]\n", cc
, cc
);
668 /* Check for an input interrupt while we're here. */
669 if (cc
== '\003' && current_thread
!= NULL
)
670 (*the_target
->request_interrupt
) ();
675 return 1; /* Success! */
679 putpkt_binary (char *buf
, int cnt
)
681 return putpkt_binary_1 (buf
, cnt
, 0);
684 /* Send a packet to the remote machine, with error checking. The data
685 of the packet is in BUF, and the packet should be a NUL-terminated
686 string. Returns >= 0 on success, -1 otherwise. */
691 return putpkt_binary (buf
, strlen (buf
));
695 putpkt_notif (char *buf
)
697 return putpkt_binary_1 (buf
, strlen (buf
), 1);
700 /* Come here when we get an input interrupt from the remote side. This
701 interrupt should only be active while we are waiting for the child to do
702 something. Thus this assumes readchar:bufcnt is 0.
703 About the only thing that should come through is a ^C, which
704 will cause us to request child interruption. */
707 input_interrupt (int unused
)
710 struct timeval immediate
= { 0, 0 };
712 /* Protect against spurious interrupts. This has been observed to
713 be a problem under NetBSD 1.4 and 1.5. */
716 FD_SET (remote_desc
, &readset
);
717 if (select (remote_desc
+ 1, &readset
, 0, 0, &immediate
) > 0)
722 cc
= read_prim (&c
, 1);
726 fprintf (stderr
, "client connection closed\n");
729 else if (cc
!= 1 || c
!= '\003')
731 fprintf (stderr
, "input_interrupt, count = %d c = %d ", cc
, c
);
733 fprintf (stderr
, "('%c')\n", c
);
735 fprintf (stderr
, "('\\x%02x')\n", c
& 0xff);
739 (*the_target
->request_interrupt
) ();
743 /* Check if the remote side sent us an interrupt request (^C). */
745 check_remote_input_interrupt_request (void)
747 /* This function may be called before establishing communications,
748 therefore we need to validate the remote descriptor. */
750 if (remote_desc
== INVALID_DESCRIPTOR
)
756 /* Asynchronous I/O support. SIGIO must be unblocked when waiting,
757 in order to accept Control-C from the client, and must be blocked
758 when talking to the client. */
761 block_unblock_async_io (int block
)
766 sigemptyset (&sigio_set
);
767 sigaddset (&sigio_set
, SIGIO
);
768 sigprocmask (block
? SIG_BLOCK
: SIG_UNBLOCK
, &sigio_set
, NULL
);
774 nto_comctrl (int enable
)
776 struct sigevent event
;
780 event
.sigev_notify
= SIGEV_SIGNAL_THREAD
;
781 event
.sigev_signo
= SIGIO
;
782 event
.sigev_code
= 0;
783 event
.sigev_value
.sival_ptr
= NULL
;
784 event
.sigev_priority
= -1;
785 ionotify (remote_desc
, _NOTIFY_ACTION_POLLARM
, _NOTIFY_COND_INPUT
,
789 ionotify (remote_desc
, _NOTIFY_ACTION_POLL
, _NOTIFY_COND_INPUT
, NULL
);
794 /* Current state of asynchronous I/O. */
795 static int async_io_enabled
;
797 /* Enable asynchronous I/O. */
799 enable_async_io (void)
801 if (async_io_enabled
)
804 block_unblock_async_io (0);
806 async_io_enabled
= 1;
812 /* Disable asynchronous I/O. */
814 disable_async_io (void)
816 if (!async_io_enabled
)
819 block_unblock_async_io (1);
821 async_io_enabled
= 0;
829 initialize_async_io (void)
831 /* Make sure that async I/O starts blocked. */
832 async_io_enabled
= 1;
835 /* Install the signal handler. */
837 signal (SIGIO
, input_interrupt
);
841 /* Internal buffer used by readchar.
842 These are global to readchar because reschedule_remote needs to be
843 able to tell whether the buffer is empty. */
845 static unsigned char readchar_buf
[BUFSIZ
];
846 static int readchar_bufcnt
= 0;
847 static unsigned char *readchar_bufp
;
849 /* Returns next char from remote GDB. -1 if error. */
856 if (readchar_bufcnt
== 0)
858 readchar_bufcnt
= read_prim (readchar_buf
, sizeof (readchar_buf
));
860 if (readchar_bufcnt
<= 0)
862 if (readchar_bufcnt
== 0)
865 debug_printf ("readchar: Got EOF\n");
873 readchar_bufp
= readchar_buf
;
877 ch
= *readchar_bufp
++;
882 /* Reset the readchar state machine. */
885 reset_readchar (void)
888 if (readchar_callback
!= NOT_SCHEDULED
)
890 delete_callback_event (readchar_callback
);
891 readchar_callback
= NOT_SCHEDULED
;
895 /* Process remaining data in readchar_buf. */
898 process_remaining (void *context
)
902 /* This is a one-shot event. */
903 readchar_callback
= NOT_SCHEDULED
;
905 if (readchar_bufcnt
> 0)
906 res
= handle_serial_event (0, NULL
);
913 /* If there is still data in the buffer, queue another event to process it,
914 we can't sleep in select yet. */
919 if (readchar_bufcnt
> 0 && readchar_callback
== NOT_SCHEDULED
)
920 readchar_callback
= append_callback_event (process_remaining
, NULL
);
923 /* Read a packet from the remote machine, with error checking,
924 and store it in BUF. Returns length of packet, or negative if error. */
930 unsigned char csum
, c1
, c2
;
941 /* The '\003' may appear before or after each packet, so
942 check for an input interrupt. */
945 (*the_target
->request_interrupt
) ();
953 debug_printf ("[getpkt: discarding char '%c']\n", c
);
974 c1
= fromhex (readchar ());
975 c2
= fromhex (readchar ());
977 if (csum
== (c1
<< 4) + c2
)
983 "Bad checksum, sentsum=0x%x, csum=0x%x, "
984 "buf=%s [no-ack-mode, Bad medium?]\n",
985 (c1
<< 4) + c2
, csum
, buf
);
986 /* Not much we can do, GDB wasn't expecting an ack/nac. */
990 fprintf (stderr
, "Bad checksum, sentsum=0x%x, csum=0x%x, buf=%s\n",
991 (c1
<< 4) + c2
, csum
, buf
);
992 if (write_prim ("-", 1) != 1)
1000 debug_printf ("getpkt (\"%s\"); [sending ack] \n", buf
);
1004 if (write_prim ("+", 1) != 1)
1009 debug_printf ("[sent ack]\n");
1017 debug_printf ("getpkt (\"%s\"); [no ack sent] \n", buf
);
1022 /* The readchar above may have already read a '\003' out of the socket
1023 and moved it to the local buffer. For example, when GDB sends
1024 vCont;c immediately followed by interrupt (see
1025 gdb.base/interrupt-noterm.exp). As soon as we see the vCont;c, we'll
1026 resume the inferior and wait. Since we've already moved the '\003'
1027 to the local buffer, SIGIO won't help. In that case, if we don't
1028 check for interrupt after the vCont;c packet, the interrupt character
1029 would stay in the buffer unattended until after the next (unrelated)
1031 while (readchar_bufcnt
> 0 && *readchar_bufp
== '\003')
1033 /* Consume the interrupt character in the buffer. */
1035 (*the_target
->request_interrupt
) ();
1042 write_ok (char *buf
)
1050 write_enn (char *buf
)
1052 /* Some day, we should define the meanings of the error codes... */
1061 #ifndef IN_PROCESS_AGENT
1064 outreg (struct regcache
*regcache
, int regno
, char *buf
)
1066 if ((regno
>> 12) != 0)
1067 *buf
++ = tohex ((regno
>> 12) & 0xf);
1068 if ((regno
>> 8) != 0)
1069 *buf
++ = tohex ((regno
>> 8) & 0xf);
1070 *buf
++ = tohex ((regno
>> 4) & 0xf);
1071 *buf
++ = tohex (regno
& 0xf);
1073 collect_register_as_string (regcache
, regno
, buf
);
1074 buf
+= 2 * register_size (regcache
->tdesc
, regno
);
1081 prepare_resume_reply (char *buf
, ptid_t ptid
,
1082 struct target_waitstatus
*status
)
1085 debug_printf ("Writing resume reply for %s:%d\n",
1086 target_pid_to_str (ptid
), status
->kind
);
1088 switch (status
->kind
)
1090 case TARGET_WAITKIND_STOPPED
:
1091 case TARGET_WAITKIND_FORKED
:
1092 case TARGET_WAITKIND_VFORKED
:
1093 case TARGET_WAITKIND_VFORK_DONE
:
1094 case TARGET_WAITKIND_EXECD
:
1095 case TARGET_WAITKIND_THREAD_CREATED
:
1096 case TARGET_WAITKIND_SYSCALL_ENTRY
:
1097 case TARGET_WAITKIND_SYSCALL_RETURN
:
1099 struct thread_info
*saved_thread
;
1101 struct regcache
*regcache
;
1103 if ((status
->kind
== TARGET_WAITKIND_FORKED
&& report_fork_events
)
1104 || (status
->kind
== TARGET_WAITKIND_VFORKED
&& report_vfork_events
))
1106 enum gdb_signal signal
= GDB_SIGNAL_TRAP
;
1107 const char *event
= (status
->kind
== TARGET_WAITKIND_FORKED
1108 ? "fork" : "vfork");
1110 sprintf (buf
, "T%02x%s:", signal
, event
);
1111 buf
+= strlen (buf
);
1112 buf
= write_ptid (buf
, status
->value
.related_pid
);
1115 else if (status
->kind
== TARGET_WAITKIND_VFORK_DONE
&& report_vfork_events
)
1117 enum gdb_signal signal
= GDB_SIGNAL_TRAP
;
1119 sprintf (buf
, "T%02xvforkdone:;", signal
);
1121 else if (status
->kind
== TARGET_WAITKIND_EXECD
&& report_exec_events
)
1123 enum gdb_signal signal
= GDB_SIGNAL_TRAP
;
1124 const char *event
= "exec";
1125 char hexified_pathname
[PATH_MAX
* 2];
1127 sprintf (buf
, "T%02x%s:", signal
, event
);
1128 buf
+= strlen (buf
);
1130 /* Encode pathname to hexified format. */
1131 bin2hex ((const gdb_byte
*) status
->value
.execd_pathname
,
1133 strlen (status
->value
.execd_pathname
));
1135 sprintf (buf
, "%s;", hexified_pathname
);
1136 xfree (status
->value
.execd_pathname
);
1137 status
->value
.execd_pathname
= NULL
;
1138 buf
+= strlen (buf
);
1140 else if (status
->kind
== TARGET_WAITKIND_THREAD_CREATED
1141 && report_thread_events
)
1143 enum gdb_signal signal
= GDB_SIGNAL_TRAP
;
1145 sprintf (buf
, "T%02xcreate:;", signal
);
1147 else if (status
->kind
== TARGET_WAITKIND_SYSCALL_ENTRY
1148 || status
->kind
== TARGET_WAITKIND_SYSCALL_RETURN
)
1150 enum gdb_signal signal
= GDB_SIGNAL_TRAP
;
1151 const char *event
= (status
->kind
== TARGET_WAITKIND_SYSCALL_ENTRY
1152 ? "syscall_entry" : "syscall_return");
1154 sprintf (buf
, "T%02x%s:%x;", signal
, event
,
1155 status
->value
.syscall_number
);
1158 sprintf (buf
, "T%02x", status
->value
.sig
);
1160 buf
+= strlen (buf
);
1162 saved_thread
= current_thread
;
1164 switch_to_thread (ptid
);
1166 regp
= current_target_desc ()->expedite_regs
;
1168 regcache
= get_thread_regcache (current_thread
, 1);
1170 if (the_target
->stopped_by_watchpoint
!= NULL
1171 && (*the_target
->stopped_by_watchpoint
) ())
1176 memcpy (buf
, "watch:", 6);
1179 addr
= (*the_target
->stopped_data_address
) ();
1181 /* Convert each byte of the address into two hexadecimal
1182 chars. Note that we take sizeof (void *) instead of
1183 sizeof (addr); this is to avoid sending a 64-bit
1184 address to a 32-bit GDB. */
1185 for (i
= sizeof (void *) * 2; i
> 0; i
--)
1186 *buf
++ = tohex ((addr
>> (i
- 1) * 4) & 0xf);
1189 else if (swbreak_feature
&& target_stopped_by_sw_breakpoint ())
1191 sprintf (buf
, "swbreak:;");
1192 buf
+= strlen (buf
);
1194 else if (hwbreak_feature
&& target_stopped_by_hw_breakpoint ())
1196 sprintf (buf
, "hwbreak:;");
1197 buf
+= strlen (buf
);
1202 buf
= outreg (regcache
, find_regno (regcache
->tdesc
, *regp
), buf
);
1207 /* Formerly, if the debugger had not used any thread features
1208 we would not burden it with a thread status response. This
1209 was for the benefit of GDB 4.13 and older. However, in
1210 recent GDB versions the check (``if (cont_thread != 0)'')
1211 does not have the desired effect because of sillyness in
1212 the way that the remote protocol handles specifying a
1213 thread. Since thread support relies on qSymbol support
1214 anyway, assume GDB can handle threads. */
1216 if (using_threads
&& !disable_packet_Tthread
)
1218 /* This if (1) ought to be unnecessary. But remote_wait
1219 in GDB will claim this event belongs to inferior_ptid
1220 if we do not specify a thread, and there's no way for
1221 gdbserver to know what inferior_ptid is. */
1222 if (1 || !ptid_equal (general_thread
, ptid
))
1225 /* In non-stop, don't change the general thread behind
1228 general_thread
= ptid
;
1229 sprintf (buf
, "thread:");
1230 buf
+= strlen (buf
);
1231 buf
= write_ptid (buf
, ptid
);
1233 buf
+= strlen (buf
);
1235 core
= target_core_of_thread (ptid
);
1239 sprintf (buf
, "core:");
1240 buf
+= strlen (buf
);
1241 sprintf (buf
, "%x", core
);
1243 buf
+= strlen (buf
);
1250 strcpy (buf
, "library:;");
1251 buf
+= strlen (buf
);
1255 current_thread
= saved_thread
;
1258 case TARGET_WAITKIND_EXITED
:
1260 sprintf (buf
, "W%x;process:%x",
1261 status
->value
.integer
, ptid_get_pid (ptid
));
1263 sprintf (buf
, "W%02x", status
->value
.integer
);
1265 case TARGET_WAITKIND_SIGNALLED
:
1267 sprintf (buf
, "X%x;process:%x",
1268 status
->value
.sig
, ptid_get_pid (ptid
));
1270 sprintf (buf
, "X%02x", status
->value
.sig
);
1272 case TARGET_WAITKIND_THREAD_EXITED
:
1273 sprintf (buf
, "w%x;", status
->value
.integer
);
1274 buf
+= strlen (buf
);
1275 buf
= write_ptid (buf
, ptid
);
1277 case TARGET_WAITKIND_NO_RESUMED
:
1281 error ("unhandled waitkind");
1287 decode_m_packet (char *from
, CORE_ADDR
*mem_addr_ptr
, unsigned int *len_ptr
)
1291 *mem_addr_ptr
= *len_ptr
= 0;
1293 while ((ch
= from
[i
++]) != ',')
1295 *mem_addr_ptr
= *mem_addr_ptr
<< 4;
1296 *mem_addr_ptr
|= fromhex (ch
) & 0x0f;
1299 for (j
= 0; j
< 4; j
++)
1301 if ((ch
= from
[i
++]) == 0)
1303 *len_ptr
= *len_ptr
<< 4;
1304 *len_ptr
|= fromhex (ch
) & 0x0f;
1309 decode_M_packet (char *from
, CORE_ADDR
*mem_addr_ptr
, unsigned int *len_ptr
,
1310 unsigned char **to_p
)
1314 *mem_addr_ptr
= *len_ptr
= 0;
1316 while ((ch
= from
[i
++]) != ',')
1318 *mem_addr_ptr
= *mem_addr_ptr
<< 4;
1319 *mem_addr_ptr
|= fromhex (ch
) & 0x0f;
1322 while ((ch
= from
[i
++]) != ':')
1324 *len_ptr
= *len_ptr
<< 4;
1325 *len_ptr
|= fromhex (ch
) & 0x0f;
1329 *to_p
= (unsigned char *) xmalloc (*len_ptr
);
1331 hex2bin (&from
[i
++], *to_p
, *len_ptr
);
1335 decode_X_packet (char *from
, int packet_len
, CORE_ADDR
*mem_addr_ptr
,
1336 unsigned int *len_ptr
, unsigned char **to_p
)
1340 *mem_addr_ptr
= *len_ptr
= 0;
1342 while ((ch
= from
[i
++]) != ',')
1344 *mem_addr_ptr
= *mem_addr_ptr
<< 4;
1345 *mem_addr_ptr
|= fromhex (ch
) & 0x0f;
1348 while ((ch
= from
[i
++]) != ':')
1350 *len_ptr
= *len_ptr
<< 4;
1351 *len_ptr
|= fromhex (ch
) & 0x0f;
1355 *to_p
= (unsigned char *) xmalloc (*len_ptr
);
1357 if (remote_unescape_input ((const gdb_byte
*) &from
[i
], packet_len
- i
,
1358 *to_p
, *len_ptr
) != *len_ptr
)
1364 /* Decode a qXfer write request. */
1367 decode_xfer_write (char *buf
, int packet_len
, CORE_ADDR
*offset
,
1368 unsigned int *len
, unsigned char *data
)
1373 /* Extract the offset. */
1375 while ((ch
= *buf
++) != ':')
1377 *offset
= *offset
<< 4;
1378 *offset
|= fromhex (ch
) & 0x0f;
1381 /* Get encoded data. */
1382 packet_len
-= buf
- b
;
1383 *len
= remote_unescape_input ((const gdb_byte
*) buf
, packet_len
,
1388 /* Decode the parameters of a qSearch:memory packet. */
1391 decode_search_memory_packet (const char *buf
, int packet_len
,
1392 CORE_ADDR
*start_addrp
,
1393 CORE_ADDR
*search_space_lenp
,
1394 gdb_byte
*pattern
, unsigned int *pattern_lenp
)
1396 const char *p
= buf
;
1398 p
= decode_address_to_semicolon (start_addrp
, p
);
1399 p
= decode_address_to_semicolon (search_space_lenp
, p
);
1400 packet_len
-= p
- buf
;
1401 *pattern_lenp
= remote_unescape_input ((const gdb_byte
*) p
, packet_len
,
1402 pattern
, packet_len
);
1407 free_sym_cache (struct sym_cache
*sym
)
1417 clear_symbol_cache (struct sym_cache
**symcache_p
)
1419 struct sym_cache
*sym
, *next
;
1421 /* Check the cache first. */
1422 for (sym
= *symcache_p
; sym
; sym
= next
)
1425 free_sym_cache (sym
);
1431 /* Get the address of NAME, and return it in ADDRP if found. if
1432 MAY_ASK_GDB is false, assume symbol cache misses are failures.
1433 Returns 1 if the symbol is found, 0 if it is not, -1 on error. */
1436 look_up_one_symbol (const char *name
, CORE_ADDR
*addrp
, int may_ask_gdb
)
1440 struct sym_cache
*sym
;
1441 struct process_info
*proc
;
1443 proc
= current_process ();
1445 /* Check the cache first. */
1446 for (sym
= proc
->symbol_cache
; sym
; sym
= sym
->next
)
1447 if (strcmp (name
, sym
->name
) == 0)
1453 /* It might not be an appropriate time to look up a symbol,
1454 e.g. while we're trying to fetch registers. */
1458 /* Send the request. */
1459 strcpy (own_buf
, "qSymbol:");
1460 bin2hex ((const gdb_byte
*) name
, own_buf
+ strlen ("qSymbol:"),
1462 if (putpkt (own_buf
) < 0)
1465 /* FIXME: Eventually add buffer overflow checking (to getpkt?) */
1466 len
= getpkt (own_buf
);
1470 /* We ought to handle pretty much any packet at this point while we
1471 wait for the qSymbol "response". That requires re-entering the
1472 main loop. For now, this is an adequate approximation; allow
1473 GDB to read from memory and handle 'v' packets (for vFile transfers)
1474 while it figures out the address of the symbol. */
1477 if (own_buf
[0] == 'm')
1480 unsigned char *mem_buf
;
1481 unsigned int mem_len
;
1483 decode_m_packet (&own_buf
[1], &mem_addr
, &mem_len
);
1484 mem_buf
= (unsigned char *) xmalloc (mem_len
);
1485 if (read_inferior_memory (mem_addr
, mem_buf
, mem_len
) == 0)
1486 bin2hex (mem_buf
, own_buf
, mem_len
);
1488 write_enn (own_buf
);
1490 if (putpkt (own_buf
) < 0)
1493 else if (own_buf
[0] == 'v')
1496 handle_v_requests (own_buf
, len
, &new_len
);
1498 putpkt_binary (own_buf
, new_len
);
1504 len
= getpkt (own_buf
);
1509 if (!startswith (own_buf
, "qSymbol:"))
1511 warning ("Malformed response to qSymbol, ignoring: %s\n", own_buf
);
1515 p
= own_buf
+ strlen ("qSymbol:");
1517 while (*q
&& *q
!= ':')
1520 /* Make sure we found a value for the symbol. */
1521 if (p
== q
|| *q
== '\0')
1524 decode_address (addrp
, p
, q
- p
);
1526 /* Save the symbol in our cache. */
1527 sym
= XNEW (struct sym_cache
);
1528 sym
->name
= xstrdup (name
);
1530 sym
->next
= proc
->symbol_cache
;
1531 proc
->symbol_cache
= sym
;
1536 /* Relocate an instruction to execute at a different address. OLDLOC
1537 is the address in the inferior memory where the instruction to
1538 relocate is currently at. On input, TO points to the destination
1539 where we want the instruction to be copied (and possibly adjusted)
1540 to. On output, it points to one past the end of the resulting
1541 instruction(s). The effect of executing the instruction at TO
1542 shall be the same as if executing it at OLDLOC. For example, call
1543 instructions that implicitly push the return address on the stack
1544 should be adjusted to return to the instruction after OLDLOC;
1545 relative branches, and other PC-relative instructions need the
1546 offset adjusted; etc. Returns 0 on success, -1 on failure. */
1549 relocate_instruction (CORE_ADDR
*to
, CORE_ADDR oldloc
)
1552 ULONGEST written
= 0;
1554 /* Send the request. */
1555 sprintf (own_buf
, "qRelocInsn:%s;%s", paddress (oldloc
),
1557 if (putpkt (own_buf
) < 0)
1560 /* FIXME: Eventually add buffer overflow checking (to getpkt?) */
1561 len
= getpkt (own_buf
);
1565 /* We ought to handle pretty much any packet at this point while we
1566 wait for the qRelocInsn "response". That requires re-entering
1567 the main loop. For now, this is an adequate approximation; allow
1568 GDB to access memory. */
1569 while (own_buf
[0] == 'm' || own_buf
[0] == 'M' || own_buf
[0] == 'X')
1572 unsigned char *mem_buf
= NULL
;
1573 unsigned int mem_len
;
1575 if (own_buf
[0] == 'm')
1577 decode_m_packet (&own_buf
[1], &mem_addr
, &mem_len
);
1578 mem_buf
= (unsigned char *) xmalloc (mem_len
);
1579 if (read_inferior_memory (mem_addr
, mem_buf
, mem_len
) == 0)
1580 bin2hex (mem_buf
, own_buf
, mem_len
);
1582 write_enn (own_buf
);
1584 else if (own_buf
[0] == 'X')
1586 if (decode_X_packet (&own_buf
[1], len
- 1, &mem_addr
,
1587 &mem_len
, &mem_buf
) < 0
1588 || write_inferior_memory (mem_addr
, mem_buf
, mem_len
) != 0)
1589 write_enn (own_buf
);
1595 decode_M_packet (&own_buf
[1], &mem_addr
, &mem_len
, &mem_buf
);
1596 if (write_inferior_memory (mem_addr
, mem_buf
, mem_len
) == 0)
1599 write_enn (own_buf
);
1602 if (putpkt (own_buf
) < 0)
1604 len
= getpkt (own_buf
);
1609 if (own_buf
[0] == 'E')
1611 warning ("An error occurred while relocating an instruction: %s\n",
1616 if (!startswith (own_buf
, "qRelocInsn:"))
1618 warning ("Malformed response to qRelocInsn, ignoring: %s\n",
1623 unpack_varlen_hex (own_buf
+ strlen ("qRelocInsn:"), &written
);
1630 monitor_output (const char *msg
)
1632 int len
= strlen (msg
);
1633 char *buf
= (char *) xmalloc (len
* 2 + 2);
1636 bin2hex ((const gdb_byte
*) msg
, buf
+ 1, len
);