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
;
119 # define read(fd, buf, len) recv (fd, (char *) buf, len, 0)
120 # define write(fd, buf, len) send (fd, (char *) buf, len, 0)
126 return remote_desc
!= INVALID_DESCRIPTOR
;
129 /* Return true if the remote connection is over stdio. */
132 remote_connection_is_stdio (void)
134 return remote_is_stdio
;
138 enable_async_notification (int fd
)
140 #if defined(F_SETFL) && defined (FASYNC)
141 int save_fcntl_flags
;
143 save_fcntl_flags
= fcntl (fd
, F_GETFL
, 0);
144 fcntl (fd
, F_SETFL
, save_fcntl_flags
| FASYNC
);
145 #if defined (F_SETOWN)
146 fcntl (fd
, F_SETOWN
, getpid ());
152 handle_accept_event (int err
, gdb_client_data client_data
)
154 struct sockaddr_in sockaddr
;
158 debug_printf ("handling possible accept event\n");
160 tmp
= sizeof (sockaddr
);
161 remote_desc
= accept (listen_desc
, (struct sockaddr
*) &sockaddr
, &tmp
);
162 if (remote_desc
== -1)
163 perror_with_name ("Accept failed");
165 /* Enable TCP keep alive process. */
167 setsockopt (remote_desc
, SOL_SOCKET
, SO_KEEPALIVE
,
168 (char *) &tmp
, sizeof (tmp
));
170 /* Tell TCP not to delay small packets. This greatly speeds up
171 interactive response. */
173 setsockopt (remote_desc
, IPPROTO_TCP
, TCP_NODELAY
,
174 (char *) &tmp
, sizeof (tmp
));
177 signal (SIGPIPE
, SIG_IGN
); /* If we don't do this, then gdbserver simply
178 exits when the remote side dies. */
184 close (listen_desc
); /* No longer need this */
186 closesocket (listen_desc
); /* No longer need this */
190 /* Even if !RUN_ONCE no longer notice new connections. Still keep the
191 descriptor open for add_file_handler to wait for a new connection. */
192 delete_file_handler (listen_desc
);
194 /* Convert IP address to string. */
195 fprintf (stderr
, "Remote debugging from host %s\n",
196 inet_ntoa (sockaddr
.sin_addr
));
198 enable_async_notification (remote_desc
);
200 /* Register the event loop handler. */
201 add_file_handler (remote_desc
, handle_serial_event
, NULL
);
203 /* We have a new GDB connection now. If we were disconnected
204 tracing, there's a window where the target could report a stop
205 event to the event loop, and since we have a connection now, we'd
206 try to send vStopped notifications to GDB. But, don't do that
207 until GDB as selected all-stop/non-stop, and has queried the
208 threads' status ('?'). */
214 /* Prepare for a later connection to a remote debugger.
215 NAME is the filename used for communication. */
218 remote_prepare (const char *name
)
220 client_state
&cs
= get_client_state ();
221 const char *port_str
;
223 static int winsock_initialized
;
226 struct sockaddr_in sockaddr
;
231 if (strcmp (name
, STDIO_CONNECTION_NAME
) == 0)
233 /* We need to record fact that we're using stdio sooner than the
234 call to remote_open so start_inferior knows the connection is
237 cs
.transport_is_reliable
= 1;
241 port_str
= strchr (name
, ':');
242 if (port_str
== NULL
)
244 cs
.transport_is_reliable
= 0;
248 port
= strtoul (port_str
+ 1, &port_end
, 10);
249 if (port_str
[1] == '\0' || *port_end
!= '\0')
250 error ("Bad port argument: %s", name
);
253 if (!winsock_initialized
)
257 WSAStartup (MAKEWORD (1, 0), &wsad
);
258 winsock_initialized
= 1;
262 listen_desc
= socket (PF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
263 if (listen_desc
== -1)
264 perror_with_name ("Can't open socket");
266 /* Allow rapid reuse of this port. */
268 setsockopt (listen_desc
, SOL_SOCKET
, SO_REUSEADDR
, (char *) &tmp
,
271 sockaddr
.sin_family
= PF_INET
;
272 sockaddr
.sin_port
= htons (port
);
273 sockaddr
.sin_addr
.s_addr
= INADDR_ANY
;
275 if (bind (listen_desc
, (struct sockaddr
*) &sockaddr
, sizeof (sockaddr
))
276 || listen (listen_desc
, 1))
277 perror_with_name ("Can't bind address");
279 cs
.transport_is_reliable
= 1;
282 /* Open a connection to a remote debugger.
283 NAME is the filename used for communication. */
286 remote_open (const char *name
)
288 const char *port_str
;
290 port_str
= strchr (name
, ':');
292 if (port_str
== NULL
)
293 error ("Only <host>:<port> is supported on this platform.");
296 if (strcmp (name
, STDIO_CONNECTION_NAME
) == 0)
298 fprintf (stderr
, "Remote debugging using stdio\n");
300 /* Use stdin as the handle of the connection.
301 We only select on reads, for example. */
302 remote_desc
= fileno (stdin
);
304 enable_async_notification (remote_desc
);
306 /* Register the event loop handler. */
307 add_file_handler (remote_desc
, handle_serial_event
, NULL
);
310 else if (port_str
== NULL
)
314 if (stat (name
, &statbuf
) == 0
315 && (S_ISCHR (statbuf
.st_mode
) || S_ISFIFO (statbuf
.st_mode
)))
316 remote_desc
= open (name
, O_RDWR
);
324 perror_with_name ("Could not open remote device");
328 struct termios termios
;
329 tcgetattr (remote_desc
, &termios
);
334 termios
.c_cflag
&= ~(CSIZE
| PARENB
);
335 termios
.c_cflag
|= CLOCAL
| CS8
;
336 termios
.c_cc
[VMIN
] = 1;
337 termios
.c_cc
[VTIME
] = 0;
339 tcsetattr (remote_desc
, TCSANOW
, &termios
);
343 fprintf (stderr
, "Remote debugging using %s\n", name
);
345 enable_async_notification (remote_desc
);
347 /* Register the event loop handler. */
348 add_file_handler (remote_desc
, handle_serial_event
, NULL
);
350 #endif /* USE_WIN32API */
355 struct sockaddr_in sockaddr
;
357 len
= sizeof (sockaddr
);
358 if (getsockname (listen_desc
,
359 (struct sockaddr
*) &sockaddr
, &len
) < 0
360 || len
< sizeof (sockaddr
))
361 perror_with_name ("Can't determine port");
362 port
= ntohs (sockaddr
.sin_port
);
364 fprintf (stderr
, "Listening on port %d\n", port
);
367 /* Register the event loop handler. */
368 add_file_handler (listen_desc
, handle_accept_event
, NULL
);
375 delete_file_handler (remote_desc
);
380 closesocket (remote_desc
);
382 if (! remote_connection_is_stdio ())
385 remote_desc
= INVALID_DESCRIPTOR
;
392 #ifndef IN_PROCESS_AGENT
395 decode_address (CORE_ADDR
*addrp
, const char *start
, int len
)
402 for (i
= 0; i
< len
; i
++)
406 addr
= addr
| (fromhex (ch
) & 0x0f);
412 decode_address_to_semicolon (CORE_ADDR
*addrp
, const char *start
)
417 while (*end
!= '\0' && *end
!= ';')
420 decode_address (addrp
, start
, end
- start
);
429 #ifndef IN_PROCESS_AGENT
431 /* Look for a sequence of characters which can be run-length encoded.
432 If there are any, update *CSUM and *P. Otherwise, output the
433 single character. Return the number of characters consumed. */
436 try_rle (char *buf
, int remaining
, unsigned char *csum
, char **p
)
440 /* Always output the character. */
444 /* Don't go past '~'. */
448 for (n
= 1; n
< remaining
; n
++)
449 if (buf
[n
] != buf
[0])
452 /* N is the index of the first character not the same as buf[0].
453 buf[0] is counted twice, so by decrementing N, we get the number
454 of characters the RLE sequence will replace. */
460 /* Skip the frame characters. The manual says to skip '+' and '-'
461 also, but there's no reason to. Unfortunately these two unusable
462 characters double the encoded length of a four byte zero
464 while (n
+ 29 == '$' || n
+ 29 == '#')
477 #ifndef IN_PROCESS_AGENT
479 /* Write a PTID to BUF. Returns BUF+CHARACTERS_WRITTEN. */
482 write_ptid (char *buf
, ptid_t ptid
)
484 client_state
&cs
= get_client_state ();
487 if (cs
.multi_process
)
491 buf
+= sprintf (buf
, "p-%x.", -pid
);
493 buf
+= sprintf (buf
, "p%x.", pid
);
497 buf
+= sprintf (buf
, "-%x", -tid
);
499 buf
+= sprintf (buf
, "%x", tid
);
505 hex_or_minus_one (const char *buf
, const char **obuf
)
509 if (startswith (buf
, "-1"))
515 buf
= unpack_varlen_hex (buf
, &ret
);
523 /* Extract a PTID from BUF. If non-null, OBUF is set to the to one
524 passed the last parsed char. Returns null_ptid on error. */
526 read_ptid (const char *buf
, const char **obuf
)
530 ULONGEST pid
= 0, tid
= 0;
534 /* Multi-process ptid. */
535 pp
= unpack_varlen_hex (p
+ 1, &pid
);
537 error ("invalid remote ptid: %s\n", p
);
541 tid
= hex_or_minus_one (p
, &pp
);
545 return ptid_t (pid
, tid
, 0);
548 /* No multi-process. Just a tid. */
549 tid
= hex_or_minus_one (p
, &pp
);
551 /* Since GDB is not sending a process id (multi-process extensions
552 are off), then there's only one process. Default to the first in
554 pid
= pid_of (get_first_process ());
558 return ptid_t (pid
, tid
, 0);
561 /* Write COUNT bytes in BUF to the client.
562 The result is the number of bytes written or -1 if error.
563 This may return less than COUNT. */
566 write_prim (const void *buf
, int count
)
568 if (remote_connection_is_stdio ())
569 return write (fileno (stdout
), buf
, count
);
571 return write (remote_desc
, buf
, count
);
574 /* Read COUNT bytes from the client and store in BUF.
575 The result is the number of bytes read or -1 if error.
576 This may return less than COUNT. */
579 read_prim (void *buf
, int count
)
581 if (remote_connection_is_stdio ())
582 return read (fileno (stdin
), buf
, count
);
584 return read (remote_desc
, buf
, count
);
587 /* Send a packet to the remote machine, with error checking.
588 The data of the packet is in BUF, and the length of the
589 packet is in CNT. Returns >= 0 on success, -1 otherwise. */
592 putpkt_binary_1 (char *buf
, int cnt
, int is_notif
)
594 client_state
&cs
= get_client_state ();
596 unsigned char csum
= 0;
601 buf2
= (char *) xmalloc (strlen ("$") + cnt
+ strlen ("#nn") + 1);
603 /* Copy the packet into buffer BUF2, encapsulating it
604 and giving it a checksum. */
612 for (i
= 0; i
< cnt
;)
613 i
+= try_rle (buf
+ i
, cnt
- i
, &csum
, &p
);
616 *p
++ = tohex ((csum
>> 4) & 0xf);
617 *p
++ = tohex (csum
& 0xf);
621 /* Send it over and over until we get a positive ack. */
625 if (write_prim (buf2
, p
- buf2
) != p
- buf2
)
627 perror ("putpkt(write)");
632 if (cs
.noack_mode
|| is_notif
)
634 /* Don't expect an ack then. */
638 debug_printf ("putpkt (\"%s\"); [notif]\n", buf2
);
640 debug_printf ("putpkt (\"%s\"); [noack mode]\n", buf2
);
648 debug_printf ("putpkt (\"%s\"); [looking for ack]\n", buf2
);
662 debug_printf ("[received '%c' (0x%x)]\n", cc
, cc
);
666 /* Check for an input interrupt while we're here. */
667 if (cc
== '\003' && current_thread
!= NULL
)
668 (*the_target
->request_interrupt
) ();
673 return 1; /* Success! */
677 putpkt_binary (char *buf
, int cnt
)
679 return putpkt_binary_1 (buf
, cnt
, 0);
682 /* Send a packet to the remote machine, with error checking. The data
683 of the packet is in BUF, and the packet should be a NUL-terminated
684 string. Returns >= 0 on success, -1 otherwise. */
689 return putpkt_binary (buf
, strlen (buf
));
693 putpkt_notif (char *buf
)
695 return putpkt_binary_1 (buf
, strlen (buf
), 1);
698 /* Come here when we get an input interrupt from the remote side. This
699 interrupt should only be active while we are waiting for the child to do
700 something. Thus this assumes readchar:bufcnt is 0.
701 About the only thing that should come through is a ^C, which
702 will cause us to request child interruption. */
705 input_interrupt (int unused
)
708 struct timeval immediate
= { 0, 0 };
710 /* Protect against spurious interrupts. This has been observed to
711 be a problem under NetBSD 1.4 and 1.5. */
714 FD_SET (remote_desc
, &readset
);
715 if (select (remote_desc
+ 1, &readset
, 0, 0, &immediate
) > 0)
720 cc
= read_prim (&c
, 1);
724 fprintf (stderr
, "client connection closed\n");
727 else if (cc
!= 1 || c
!= '\003')
729 fprintf (stderr
, "input_interrupt, count = %d c = %d ", cc
, c
);
731 fprintf (stderr
, "('%c')\n", c
);
733 fprintf (stderr
, "('\\x%02x')\n", c
& 0xff);
737 (*the_target
->request_interrupt
) ();
741 /* Check if the remote side sent us an interrupt request (^C). */
743 check_remote_input_interrupt_request (void)
745 /* This function may be called before establishing communications,
746 therefore we need to validate the remote descriptor. */
748 if (remote_desc
== INVALID_DESCRIPTOR
)
754 /* Asynchronous I/O support. SIGIO must be unblocked when waiting,
755 in order to accept Control-C from the client, and must be blocked
756 when talking to the client. */
759 block_unblock_async_io (int block
)
764 sigemptyset (&sigio_set
);
765 sigaddset (&sigio_set
, SIGIO
);
766 sigprocmask (block
? SIG_BLOCK
: SIG_UNBLOCK
, &sigio_set
, NULL
);
772 nto_comctrl (int enable
)
774 struct sigevent event
;
778 event
.sigev_notify
= SIGEV_SIGNAL_THREAD
;
779 event
.sigev_signo
= SIGIO
;
780 event
.sigev_code
= 0;
781 event
.sigev_value
.sival_ptr
= NULL
;
782 event
.sigev_priority
= -1;
783 ionotify (remote_desc
, _NOTIFY_ACTION_POLLARM
, _NOTIFY_COND_INPUT
,
787 ionotify (remote_desc
, _NOTIFY_ACTION_POLL
, _NOTIFY_COND_INPUT
, NULL
);
792 /* Current state of asynchronous I/O. */
793 static int async_io_enabled
;
795 /* Enable asynchronous I/O. */
797 enable_async_io (void)
799 if (async_io_enabled
)
802 block_unblock_async_io (0);
804 async_io_enabled
= 1;
810 /* Disable asynchronous I/O. */
812 disable_async_io (void)
814 if (!async_io_enabled
)
817 block_unblock_async_io (1);
819 async_io_enabled
= 0;
827 initialize_async_io (void)
829 /* Make sure that async I/O starts blocked. */
830 async_io_enabled
= 1;
833 /* Install the signal handler. */
835 signal (SIGIO
, input_interrupt
);
839 /* Internal buffer used by readchar.
840 These are global to readchar because reschedule_remote needs to be
841 able to tell whether the buffer is empty. */
843 static unsigned char readchar_buf
[BUFSIZ
];
844 static int readchar_bufcnt
= 0;
845 static unsigned char *readchar_bufp
;
847 /* Returns next char from remote GDB. -1 if error. */
852 client_state
&cs
= get_client_state ();
855 if (readchar_bufcnt
== 0)
857 readchar_bufcnt
= read_prim (readchar_buf
, sizeof (readchar_buf
));
859 if (readchar_bufcnt
<= 0)
861 if (readchar_bufcnt
== 0)
864 debug_printf ("readchar: Got EOF\n");
872 readchar_bufp
= readchar_buf
;
876 ch
= *readchar_bufp
++;
881 /* Reset the readchar state machine. */
884 reset_readchar (void)
887 if (readchar_callback
!= NOT_SCHEDULED
)
889 delete_callback_event (readchar_callback
);
890 readchar_callback
= NOT_SCHEDULED
;
894 /* Process remaining data in readchar_buf. */
897 process_remaining (void *context
)
901 /* This is a one-shot event. */
902 readchar_callback
= NOT_SCHEDULED
;
904 if (readchar_bufcnt
> 0)
905 res
= handle_serial_event (0, NULL
);
912 /* If there is still data in the buffer, queue another event to process it,
913 we can't sleep in select yet. */
918 if (readchar_bufcnt
> 0 && readchar_callback
== NOT_SCHEDULED
)
919 readchar_callback
= append_callback_event (process_remaining
, NULL
);
922 /* Read a packet from the remote machine, with error checking,
923 and store it in BUF. Returns length of packet, or negative if error. */
928 client_state
&cs
= get_client_state ();
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
)
1084 client_state
&cs
= get_client_state ();
1086 debug_printf ("Writing resume reply for %s:%d\n",
1087 target_pid_to_str (ptid
), status
->kind
);
1089 switch (status
->kind
)
1091 case TARGET_WAITKIND_STOPPED
:
1092 case TARGET_WAITKIND_FORKED
:
1093 case TARGET_WAITKIND_VFORKED
:
1094 case TARGET_WAITKIND_VFORK_DONE
:
1095 case TARGET_WAITKIND_EXECD
:
1096 case TARGET_WAITKIND_THREAD_CREATED
:
1097 case TARGET_WAITKIND_SYSCALL_ENTRY
:
1098 case TARGET_WAITKIND_SYSCALL_RETURN
:
1100 struct thread_info
*saved_thread
;
1102 struct regcache
*regcache
;
1104 if ((status
->kind
== TARGET_WAITKIND_FORKED
&& cs
.report_fork_events
)
1105 || (status
->kind
== TARGET_WAITKIND_VFORKED
1106 && cs
.report_vfork_events
))
1108 enum gdb_signal signal
= GDB_SIGNAL_TRAP
;
1109 const char *event
= (status
->kind
== TARGET_WAITKIND_FORKED
1110 ? "fork" : "vfork");
1112 sprintf (buf
, "T%02x%s:", signal
, event
);
1113 buf
+= strlen (buf
);
1114 buf
= write_ptid (buf
, status
->value
.related_pid
);
1117 else if (status
->kind
== TARGET_WAITKIND_VFORK_DONE
1118 && cs
.report_vfork_events
)
1120 enum gdb_signal signal
= GDB_SIGNAL_TRAP
;
1122 sprintf (buf
, "T%02xvforkdone:;", signal
);
1124 else if (status
->kind
== TARGET_WAITKIND_EXECD
&& cs
.report_exec_events
)
1126 enum gdb_signal signal
= GDB_SIGNAL_TRAP
;
1127 const char *event
= "exec";
1128 char hexified_pathname
[PATH_MAX
* 2];
1130 sprintf (buf
, "T%02x%s:", signal
, event
);
1131 buf
+= strlen (buf
);
1133 /* Encode pathname to hexified format. */
1134 bin2hex ((const gdb_byte
*) status
->value
.execd_pathname
,
1136 strlen (status
->value
.execd_pathname
));
1138 sprintf (buf
, "%s;", hexified_pathname
);
1139 xfree (status
->value
.execd_pathname
);
1140 status
->value
.execd_pathname
= NULL
;
1141 buf
+= strlen (buf
);
1143 else if (status
->kind
== TARGET_WAITKIND_THREAD_CREATED
1144 && cs
.report_thread_events
)
1146 enum gdb_signal signal
= GDB_SIGNAL_TRAP
;
1148 sprintf (buf
, "T%02xcreate:;", signal
);
1150 else if (status
->kind
== TARGET_WAITKIND_SYSCALL_ENTRY
1151 || status
->kind
== TARGET_WAITKIND_SYSCALL_RETURN
)
1153 enum gdb_signal signal
= GDB_SIGNAL_TRAP
;
1154 const char *event
= (status
->kind
== TARGET_WAITKIND_SYSCALL_ENTRY
1155 ? "syscall_entry" : "syscall_return");
1157 sprintf (buf
, "T%02x%s:%x;", signal
, event
,
1158 status
->value
.syscall_number
);
1161 sprintf (buf
, "T%02x", status
->value
.sig
);
1163 buf
+= strlen (buf
);
1165 saved_thread
= current_thread
;
1167 switch_to_thread (ptid
);
1169 regp
= current_target_desc ()->expedite_regs
;
1171 regcache
= get_thread_regcache (current_thread
, 1);
1173 if (the_target
->stopped_by_watchpoint
!= NULL
1174 && (*the_target
->stopped_by_watchpoint
) ())
1179 memcpy (buf
, "watch:", 6);
1182 addr
= (*the_target
->stopped_data_address
) ();
1184 /* Convert each byte of the address into two hexadecimal
1185 chars. Note that we take sizeof (void *) instead of
1186 sizeof (addr); this is to avoid sending a 64-bit
1187 address to a 32-bit GDB. */
1188 for (i
= sizeof (void *) * 2; i
> 0; i
--)
1189 *buf
++ = tohex ((addr
>> (i
- 1) * 4) & 0xf);
1192 else if (cs
.swbreak_feature
&& target_stopped_by_sw_breakpoint ())
1194 sprintf (buf
, "swbreak:;");
1195 buf
+= strlen (buf
);
1197 else if (cs
.hwbreak_feature
&& target_stopped_by_hw_breakpoint ())
1199 sprintf (buf
, "hwbreak:;");
1200 buf
+= strlen (buf
);
1205 buf
= outreg (regcache
, find_regno (regcache
->tdesc
, *regp
), buf
);
1210 /* Formerly, if the debugger had not used any thread features
1211 we would not burden it with a thread status response. This
1212 was for the benefit of GDB 4.13 and older. However, in
1213 recent GDB versions the check (``if (cont_thread != 0)'')
1214 does not have the desired effect because of sillyness in
1215 the way that the remote protocol handles specifying a
1216 thread. Since thread support relies on qSymbol support
1217 anyway, assume GDB can handle threads. */
1219 if (using_threads
&& !disable_packet_Tthread
)
1221 /* This if (1) ought to be unnecessary. But remote_wait
1222 in GDB will claim this event belongs to inferior_ptid
1223 if we do not specify a thread, and there's no way for
1224 gdbserver to know what inferior_ptid is. */
1225 if (1 || cs
.general_thread
!= ptid
)
1228 /* In non-stop, don't change the general thread behind
1231 cs
.general_thread
= ptid
;
1232 sprintf (buf
, "thread:");
1233 buf
+= strlen (buf
);
1234 buf
= write_ptid (buf
, ptid
);
1236 buf
+= strlen (buf
);
1238 core
= target_core_of_thread (ptid
);
1242 sprintf (buf
, "core:");
1243 buf
+= strlen (buf
);
1244 sprintf (buf
, "%x", core
);
1246 buf
+= strlen (buf
);
1253 strcpy (buf
, "library:;");
1254 buf
+= strlen (buf
);
1258 current_thread
= saved_thread
;
1261 case TARGET_WAITKIND_EXITED
:
1262 if (cs
.multi_process
)
1263 sprintf (buf
, "W%x;process:%x",
1264 status
->value
.integer
, ptid
.pid ());
1266 sprintf (buf
, "W%02x", status
->value
.integer
);
1268 case TARGET_WAITKIND_SIGNALLED
:
1269 if (cs
.multi_process
)
1270 sprintf (buf
, "X%x;process:%x",
1271 status
->value
.sig
, ptid
.pid ());
1273 sprintf (buf
, "X%02x", status
->value
.sig
);
1275 case TARGET_WAITKIND_THREAD_EXITED
:
1276 sprintf (buf
, "w%x;", status
->value
.integer
);
1277 buf
+= strlen (buf
);
1278 buf
= write_ptid (buf
, ptid
);
1280 case TARGET_WAITKIND_NO_RESUMED
:
1284 error ("unhandled waitkind");
1290 decode_m_packet (char *from
, CORE_ADDR
*mem_addr_ptr
, unsigned int *len_ptr
)
1294 *mem_addr_ptr
= *len_ptr
= 0;
1296 while ((ch
= from
[i
++]) != ',')
1298 *mem_addr_ptr
= *mem_addr_ptr
<< 4;
1299 *mem_addr_ptr
|= fromhex (ch
) & 0x0f;
1302 for (j
= 0; j
< 4; j
++)
1304 if ((ch
= from
[i
++]) == 0)
1306 *len_ptr
= *len_ptr
<< 4;
1307 *len_ptr
|= fromhex (ch
) & 0x0f;
1312 decode_M_packet (char *from
, CORE_ADDR
*mem_addr_ptr
, unsigned int *len_ptr
,
1313 unsigned char **to_p
)
1317 *mem_addr_ptr
= *len_ptr
= 0;
1319 while ((ch
= from
[i
++]) != ',')
1321 *mem_addr_ptr
= *mem_addr_ptr
<< 4;
1322 *mem_addr_ptr
|= fromhex (ch
) & 0x0f;
1325 while ((ch
= from
[i
++]) != ':')
1327 *len_ptr
= *len_ptr
<< 4;
1328 *len_ptr
|= fromhex (ch
) & 0x0f;
1332 *to_p
= (unsigned char *) xmalloc (*len_ptr
);
1334 hex2bin (&from
[i
++], *to_p
, *len_ptr
);
1338 decode_X_packet (char *from
, int packet_len
, CORE_ADDR
*mem_addr_ptr
,
1339 unsigned int *len_ptr
, unsigned char **to_p
)
1343 *mem_addr_ptr
= *len_ptr
= 0;
1345 while ((ch
= from
[i
++]) != ',')
1347 *mem_addr_ptr
= *mem_addr_ptr
<< 4;
1348 *mem_addr_ptr
|= fromhex (ch
) & 0x0f;
1351 while ((ch
= from
[i
++]) != ':')
1353 *len_ptr
= *len_ptr
<< 4;
1354 *len_ptr
|= fromhex (ch
) & 0x0f;
1358 *to_p
= (unsigned char *) xmalloc (*len_ptr
);
1360 if (remote_unescape_input ((const gdb_byte
*) &from
[i
], packet_len
- i
,
1361 *to_p
, *len_ptr
) != *len_ptr
)
1367 /* Decode a qXfer write request. */
1370 decode_xfer_write (char *buf
, int packet_len
, CORE_ADDR
*offset
,
1371 unsigned int *len
, unsigned char *data
)
1376 /* Extract the offset. */
1378 while ((ch
= *buf
++) != ':')
1380 *offset
= *offset
<< 4;
1381 *offset
|= fromhex (ch
) & 0x0f;
1384 /* Get encoded data. */
1385 packet_len
-= buf
- b
;
1386 *len
= remote_unescape_input ((const gdb_byte
*) buf
, packet_len
,
1391 /* Decode the parameters of a qSearch:memory packet. */
1394 decode_search_memory_packet (const char *buf
, int packet_len
,
1395 CORE_ADDR
*start_addrp
,
1396 CORE_ADDR
*search_space_lenp
,
1397 gdb_byte
*pattern
, unsigned int *pattern_lenp
)
1399 const char *p
= buf
;
1401 p
= decode_address_to_semicolon (start_addrp
, p
);
1402 p
= decode_address_to_semicolon (search_space_lenp
, p
);
1403 packet_len
-= p
- buf
;
1404 *pattern_lenp
= remote_unescape_input ((const gdb_byte
*) p
, packet_len
,
1405 pattern
, packet_len
);
1410 free_sym_cache (struct sym_cache
*sym
)
1420 clear_symbol_cache (struct sym_cache
**symcache_p
)
1422 struct sym_cache
*sym
, *next
;
1424 /* Check the cache first. */
1425 for (sym
= *symcache_p
; sym
; sym
= next
)
1428 free_sym_cache (sym
);
1434 /* Get the address of NAME, and return it in ADDRP if found. if
1435 MAY_ASK_GDB is false, assume symbol cache misses are failures.
1436 Returns 1 if the symbol is found, 0 if it is not, -1 on error. */
1439 look_up_one_symbol (const char *name
, CORE_ADDR
*addrp
, int may_ask_gdb
)
1441 client_state
&cs
= get_client_state ();
1444 struct sym_cache
*sym
;
1445 struct process_info
*proc
;
1447 proc
= current_process ();
1449 /* Check the cache first. */
1450 for (sym
= proc
->symbol_cache
; sym
; sym
= sym
->next
)
1451 if (strcmp (name
, sym
->name
) == 0)
1457 /* It might not be an appropriate time to look up a symbol,
1458 e.g. while we're trying to fetch registers. */
1462 /* Send the request. */
1463 strcpy (cs
.own_buf
, "qSymbol:");
1464 bin2hex ((const gdb_byte
*) name
, cs
.own_buf
+ strlen ("qSymbol:"),
1466 if (putpkt (cs
.own_buf
) < 0)
1469 /* FIXME: Eventually add buffer overflow checking (to getpkt?) */
1470 len
= getpkt (cs
.own_buf
);
1474 /* We ought to handle pretty much any packet at this point while we
1475 wait for the qSymbol "response". That requires re-entering the
1476 main loop. For now, this is an adequate approximation; allow
1477 GDB to read from memory and handle 'v' packets (for vFile transfers)
1478 while it figures out the address of the symbol. */
1481 if (cs
.own_buf
[0] == 'm')
1484 unsigned char *mem_buf
;
1485 unsigned int mem_len
;
1487 decode_m_packet (&cs
.own_buf
[1], &mem_addr
, &mem_len
);
1488 mem_buf
= (unsigned char *) xmalloc (mem_len
);
1489 if (read_inferior_memory (mem_addr
, mem_buf
, mem_len
) == 0)
1490 bin2hex (mem_buf
, cs
.own_buf
, mem_len
);
1492 write_enn (cs
.own_buf
);
1494 if (putpkt (cs
.own_buf
) < 0)
1497 else if (cs
.own_buf
[0] == 'v')
1500 handle_v_requests (cs
.own_buf
, len
, &new_len
);
1502 putpkt_binary (cs
.own_buf
, new_len
);
1504 putpkt (cs
.own_buf
);
1508 len
= getpkt (cs
.own_buf
);
1513 if (!startswith (cs
.own_buf
, "qSymbol:"))
1515 warning ("Malformed response to qSymbol, ignoring: %s\n", cs
.own_buf
);
1519 p
= cs
.own_buf
+ strlen ("qSymbol:");
1521 while (*q
&& *q
!= ':')
1524 /* Make sure we found a value for the symbol. */
1525 if (p
== q
|| *q
== '\0')
1528 decode_address (addrp
, p
, q
- p
);
1530 /* Save the symbol in our cache. */
1531 sym
= XNEW (struct sym_cache
);
1532 sym
->name
= xstrdup (name
);
1534 sym
->next
= proc
->symbol_cache
;
1535 proc
->symbol_cache
= sym
;
1540 /* Relocate an instruction to execute at a different address. OLDLOC
1541 is the address in the inferior memory where the instruction to
1542 relocate is currently at. On input, TO points to the destination
1543 where we want the instruction to be copied (and possibly adjusted)
1544 to. On output, it points to one past the end of the resulting
1545 instruction(s). The effect of executing the instruction at TO
1546 shall be the same as if executing it at OLDLOC. For example, call
1547 instructions that implicitly push the return address on the stack
1548 should be adjusted to return to the instruction after OLDLOC;
1549 relative branches, and other PC-relative instructions need the
1550 offset adjusted; etc. Returns 0 on success, -1 on failure. */
1553 relocate_instruction (CORE_ADDR
*to
, CORE_ADDR oldloc
)
1555 client_state
&cs
= get_client_state ();
1557 ULONGEST written
= 0;
1559 /* Send the request. */
1560 sprintf (cs
.own_buf
, "qRelocInsn:%s;%s", paddress (oldloc
),
1562 if (putpkt (cs
.own_buf
) < 0)
1565 /* FIXME: Eventually add buffer overflow checking (to getpkt?) */
1566 len
= getpkt (cs
.own_buf
);
1570 /* We ought to handle pretty much any packet at this point while we
1571 wait for the qRelocInsn "response". That requires re-entering
1572 the main loop. For now, this is an adequate approximation; allow
1573 GDB to access memory. */
1574 while (cs
.own_buf
[0] == 'm' || cs
.own_buf
[0] == 'M' || cs
.own_buf
[0] == 'X')
1577 unsigned char *mem_buf
= NULL
;
1578 unsigned int mem_len
;
1580 if (cs
.own_buf
[0] == 'm')
1582 decode_m_packet (&cs
.own_buf
[1], &mem_addr
, &mem_len
);
1583 mem_buf
= (unsigned char *) xmalloc (mem_len
);
1584 if (read_inferior_memory (mem_addr
, mem_buf
, mem_len
) == 0)
1585 bin2hex (mem_buf
, cs
.own_buf
, mem_len
);
1587 write_enn (cs
.own_buf
);
1589 else if (cs
.own_buf
[0] == 'X')
1591 if (decode_X_packet (&cs
.own_buf
[1], len
- 1, &mem_addr
,
1592 &mem_len
, &mem_buf
) < 0
1593 || write_inferior_memory (mem_addr
, mem_buf
, mem_len
) != 0)
1594 write_enn (cs
.own_buf
);
1596 write_ok (cs
.own_buf
);
1600 decode_M_packet (&cs
.own_buf
[1], &mem_addr
, &mem_len
, &mem_buf
);
1601 if (write_inferior_memory (mem_addr
, mem_buf
, mem_len
) == 0)
1602 write_ok (cs
.own_buf
);
1604 write_enn (cs
.own_buf
);
1607 if (putpkt (cs
.own_buf
) < 0)
1609 len
= getpkt (cs
.own_buf
);
1614 if (cs
.own_buf
[0] == 'E')
1616 warning ("An error occurred while relocating an instruction: %s\n",
1621 if (!startswith (cs
.own_buf
, "qRelocInsn:"))
1623 warning ("Malformed response to qRelocInsn, ignoring: %s\n",
1628 unpack_varlen_hex (cs
.own_buf
+ strlen ("qRelocInsn:"), &written
);
1635 monitor_output (const char *msg
)
1637 int len
= strlen (msg
);
1638 char *buf
= (char *) xmalloc (len
* 2 + 2);
1641 bin2hex ((const gdb_byte
*) msg
, buf
+ 1, len
);