1 /* Remote utility routines for the remote server for GDB.
2 Copyright (C) 1986-2019 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 "gdbsupport/rsp-low.h"
29 #include "gdbsupport/netstuff.h"
30 #include "gdbsupport/filestuff.h"
33 #include <sys/ioctl.h>
39 #include <netinet/in.h>
42 #include <sys/socket.h>
47 #if HAVE_NETINET_TCP_H
48 #include <netinet/tcp.h>
51 #include <sys/ioctl.h>
59 #include "gdbsupport/gdb_sys_time.h"
62 #include <arpa/inet.h>
71 #include <sys/iomgr.h>
74 #ifndef HAVE_SOCKLEN_T
75 typedef int socklen_t
;
78 #ifndef IN_PROCESS_AGENT
81 # define INVALID_DESCRIPTOR INVALID_SOCKET
83 # define INVALID_DESCRIPTOR -1
86 /* Extra value for readchar_callback. */
88 /* The callback is currently not scheduled. */
92 /* Status of the readchar callback.
93 Either NOT_SCHEDULED or the callback id. */
94 static int readchar_callback
= NOT_SCHEDULED
;
96 static int readchar (void);
97 static void reset_readchar (void);
98 static void reschedule (void);
100 /* A cache entry for a successfully looked-up symbol. */
105 struct sym_cache
*next
;
108 static int remote_is_stdio
= 0;
110 static gdb_fildes_t remote_desc
= INVALID_DESCRIPTOR
;
111 static gdb_fildes_t listen_desc
= INVALID_DESCRIPTOR
;
114 # define read(fd, buf, len) recv (fd, (char *) buf, len, 0)
115 # define write(fd, buf, len) send (fd, (char *) buf, len, 0)
121 return remote_desc
!= INVALID_DESCRIPTOR
;
124 /* Return true if the remote connection is over stdio. */
127 remote_connection_is_stdio (void)
129 return remote_is_stdio
;
133 enable_async_notification (int fd
)
135 #if defined(F_SETFL) && defined (FASYNC)
136 int save_fcntl_flags
;
138 save_fcntl_flags
= fcntl (fd
, F_GETFL
, 0);
139 fcntl (fd
, F_SETFL
, save_fcntl_flags
| FASYNC
);
140 #if defined (F_SETOWN)
141 fcntl (fd
, F_SETOWN
, getpid ());
147 handle_accept_event (int err
, gdb_client_data client_data
)
149 struct sockaddr_storage sockaddr
;
150 socklen_t len
= sizeof (sockaddr
);
153 debug_printf ("handling possible accept event\n");
155 remote_desc
= accept (listen_desc
, (struct sockaddr
*) &sockaddr
, &len
);
156 if (remote_desc
== -1)
157 perror_with_name ("Accept failed");
159 /* Enable TCP keep alive process. */
161 setsockopt (remote_desc
, SOL_SOCKET
, SO_KEEPALIVE
,
162 (char *) &tmp
, sizeof (tmp
));
164 /* Tell TCP not to delay small packets. This greatly speeds up
165 interactive response. */
167 setsockopt (remote_desc
, IPPROTO_TCP
, TCP_NODELAY
,
168 (char *) &tmp
, sizeof (tmp
));
171 signal (SIGPIPE
, SIG_IGN
); /* If we don't do this, then gdbserver simply
172 exits when the remote side dies. */
178 close (listen_desc
); /* No longer need this */
180 closesocket (listen_desc
); /* No longer need this */
184 /* Even if !RUN_ONCE no longer notice new connections. Still keep the
185 descriptor open for add_file_handler to wait for a new connection. */
186 delete_file_handler (listen_desc
);
188 /* Convert IP address to string. */
189 char orig_host
[GDB_NI_MAX_ADDR
], orig_port
[GDB_NI_MAX_PORT
];
191 int r
= getnameinfo ((struct sockaddr
*) &sockaddr
, len
,
192 orig_host
, sizeof (orig_host
),
193 orig_port
, sizeof (orig_port
),
194 NI_NUMERICHOST
| NI_NUMERICSERV
);
197 fprintf (stderr
, _("Could not obtain remote address: %s\n"),
200 fprintf (stderr
, _("Remote debugging from host %s, port %s\n"),
201 orig_host
, orig_port
);
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 client_state
&cs
= get_client_state ();
227 static int winsock_initialized
;
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 cs
.transport_is_reliable
= 1;
242 struct addrinfo hint
;
243 struct addrinfo
*ainfo
;
245 memset (&hint
, 0, sizeof (hint
));
246 /* Assume no prefix will be passed, therefore we should use
248 hint
.ai_family
= AF_UNSPEC
;
249 hint
.ai_socktype
= SOCK_STREAM
;
250 hint
.ai_protocol
= IPPROTO_TCP
;
252 parsed_connection_spec parsed
253 = parse_connection_spec_without_prefix (name
, &hint
);
255 if (parsed
.port_str
.empty ())
257 cs
.transport_is_reliable
= 0;
262 if (!winsock_initialized
)
266 WSAStartup (MAKEWORD (1, 0), &wsad
);
267 winsock_initialized
= 1;
271 int r
= getaddrinfo (parsed
.host_str
.c_str (), parsed
.port_str
.c_str (),
275 error (_("%s: cannot resolve name: %s"), name
, gai_strerror (r
));
277 scoped_free_addrinfo
freeaddrinfo (ainfo
);
279 struct addrinfo
*iter
;
281 for (iter
= ainfo
; iter
!= NULL
; iter
= iter
->ai_next
)
283 listen_desc
= gdb_socket_cloexec (iter
->ai_family
, iter
->ai_socktype
,
286 if (listen_desc
>= 0)
291 perror_with_name ("Can't open socket");
293 /* Allow rapid reuse of this port. */
295 setsockopt (listen_desc
, SOL_SOCKET
, SO_REUSEADDR
, (char *) &tmp
,
298 switch (iter
->ai_family
)
301 ((struct sockaddr_in
*) iter
->ai_addr
)->sin_addr
.s_addr
= INADDR_ANY
;
304 ((struct sockaddr_in6
*) iter
->ai_addr
)->sin6_addr
= in6addr_any
;
307 internal_error (__FILE__
, __LINE__
,
308 _("Invalid 'ai_family' %d\n"), iter
->ai_family
);
311 if (bind (listen_desc
, iter
->ai_addr
, iter
->ai_addrlen
) != 0)
312 perror_with_name ("Can't bind address");
314 if (listen (listen_desc
, 1) != 0)
315 perror_with_name ("Can't listen on socket");
317 cs
.transport_is_reliable
= 1;
320 /* Open a connection to a remote debugger.
321 NAME is the filename used for communication. */
324 remote_open (const char *name
)
326 const char *port_str
;
328 port_str
= strchr (name
, ':');
330 if (port_str
== NULL
)
331 error ("Only HOST:PORT is supported on this platform.");
334 if (strcmp (name
, STDIO_CONNECTION_NAME
) == 0)
336 fprintf (stderr
, "Remote debugging using stdio\n");
338 /* Use stdin as the handle of the connection.
339 We only select on reads, for example. */
340 remote_desc
= fileno (stdin
);
342 enable_async_notification (remote_desc
);
344 /* Register the event loop handler. */
345 add_file_handler (remote_desc
, handle_serial_event
, NULL
);
348 else if (port_str
== NULL
)
352 if (stat (name
, &statbuf
) == 0
353 && (S_ISCHR (statbuf
.st_mode
) || S_ISFIFO (statbuf
.st_mode
)))
354 remote_desc
= open (name
, O_RDWR
);
362 perror_with_name ("Could not open remote device");
366 struct termios termios
;
367 tcgetattr (remote_desc
, &termios
);
372 termios
.c_cflag
&= ~(CSIZE
| PARENB
);
373 termios
.c_cflag
|= CLOCAL
| CS8
;
374 termios
.c_cc
[VMIN
] = 1;
375 termios
.c_cc
[VTIME
] = 0;
377 tcsetattr (remote_desc
, TCSANOW
, &termios
);
381 fprintf (stderr
, "Remote debugging using %s\n", name
);
383 enable_async_notification (remote_desc
);
385 /* Register the event loop handler. */
386 add_file_handler (remote_desc
, handle_serial_event
, NULL
);
388 #endif /* USE_WIN32API */
391 char listen_port
[GDB_NI_MAX_PORT
];
392 struct sockaddr_storage sockaddr
;
393 socklen_t len
= sizeof (sockaddr
);
395 if (getsockname (listen_desc
, (struct sockaddr
*) &sockaddr
, &len
) < 0)
396 perror_with_name ("Can't determine port");
398 int r
= getnameinfo ((struct sockaddr
*) &sockaddr
, len
,
400 listen_port
, sizeof (listen_port
),
404 fprintf (stderr
, _("Can't obtain port where we are listening: %s"),
407 fprintf (stderr
, _("Listening on port %s\n"), listen_port
);
411 /* Register the event loop handler. */
412 add_file_handler (listen_desc
, handle_accept_event
, NULL
);
419 delete_file_handler (remote_desc
);
424 closesocket (remote_desc
);
426 if (! remote_connection_is_stdio ())
429 remote_desc
= INVALID_DESCRIPTOR
;
436 #ifndef IN_PROCESS_AGENT
439 decode_address (CORE_ADDR
*addrp
, const char *start
, int len
)
446 for (i
= 0; i
< len
; i
++)
450 addr
= addr
| (fromhex (ch
) & 0x0f);
456 decode_address_to_semicolon (CORE_ADDR
*addrp
, const char *start
)
461 while (*end
!= '\0' && *end
!= ';')
464 decode_address (addrp
, start
, end
- start
);
473 #ifndef IN_PROCESS_AGENT
475 /* Look for a sequence of characters which can be run-length encoded.
476 If there are any, update *CSUM and *P. Otherwise, output the
477 single character. Return the number of characters consumed. */
480 try_rle (char *buf
, int remaining
, unsigned char *csum
, char **p
)
484 /* Always output the character. */
488 /* Don't go past '~'. */
492 for (n
= 1; n
< remaining
; n
++)
493 if (buf
[n
] != buf
[0])
496 /* N is the index of the first character not the same as buf[0].
497 buf[0] is counted twice, so by decrementing N, we get the number
498 of characters the RLE sequence will replace. */
504 /* Skip the frame characters. The manual says to skip '+' and '-'
505 also, but there's no reason to. Unfortunately these two unusable
506 characters double the encoded length of a four byte zero
508 while (n
+ 29 == '$' || n
+ 29 == '#')
521 #ifndef IN_PROCESS_AGENT
523 /* Write a PTID to BUF. Returns BUF+CHARACTERS_WRITTEN. */
526 write_ptid (char *buf
, ptid_t ptid
)
528 client_state
&cs
= get_client_state ();
531 if (cs
.multi_process
)
535 buf
+= sprintf (buf
, "p-%x.", -pid
);
537 buf
+= sprintf (buf
, "p%x.", pid
);
541 buf
+= sprintf (buf
, "-%x", -tid
);
543 buf
+= sprintf (buf
, "%x", tid
);
549 hex_or_minus_one (const char *buf
, const char **obuf
)
553 if (startswith (buf
, "-1"))
559 buf
= unpack_varlen_hex (buf
, &ret
);
567 /* Extract a PTID from BUF. If non-null, OBUF is set to the to one
568 passed the last parsed char. Returns null_ptid on error. */
570 read_ptid (const char *buf
, const char **obuf
)
574 ULONGEST pid
= 0, tid
= 0;
578 /* Multi-process ptid. */
579 pp
= unpack_varlen_hex (p
+ 1, &pid
);
581 error ("invalid remote ptid: %s\n", p
);
585 tid
= hex_or_minus_one (p
, &pp
);
589 return ptid_t (pid
, tid
, 0);
592 /* No multi-process. Just a tid. */
593 tid
= hex_or_minus_one (p
, &pp
);
595 /* Since GDB is not sending a process id (multi-process extensions
596 are off), then there's only one process. Default to the first in
598 pid
= pid_of (get_first_process ());
602 return ptid_t (pid
, tid
, 0);
605 /* Write COUNT bytes in BUF to the client.
606 The result is the number of bytes written or -1 if error.
607 This may return less than COUNT. */
610 write_prim (const void *buf
, int count
)
612 if (remote_connection_is_stdio ())
613 return write (fileno (stdout
), buf
, count
);
615 return write (remote_desc
, buf
, count
);
618 /* Read COUNT bytes from the client and store in BUF.
619 The result is the number of bytes read or -1 if error.
620 This may return less than COUNT. */
623 read_prim (void *buf
, int count
)
625 if (remote_connection_is_stdio ())
626 return read (fileno (stdin
), buf
, count
);
628 return read (remote_desc
, buf
, count
);
631 /* Send a packet to the remote machine, with error checking.
632 The data of the packet is in BUF, and the length of the
633 packet is in CNT. Returns >= 0 on success, -1 otherwise. */
636 putpkt_binary_1 (char *buf
, int cnt
, int is_notif
)
638 client_state
&cs
= get_client_state ();
640 unsigned char csum
= 0;
645 buf2
= (char *) xmalloc (strlen ("$") + cnt
+ strlen ("#nn") + 1);
647 /* Copy the packet into buffer BUF2, encapsulating it
648 and giving it a checksum. */
656 for (i
= 0; i
< cnt
;)
657 i
+= try_rle (buf
+ i
, cnt
- i
, &csum
, &p
);
660 *p
++ = tohex ((csum
>> 4) & 0xf);
661 *p
++ = tohex (csum
& 0xf);
665 /* Send it over and over until we get a positive ack. */
669 if (write_prim (buf2
, p
- buf2
) != p
- buf2
)
671 perror ("putpkt(write)");
676 if (cs
.noack_mode
|| is_notif
)
678 /* Don't expect an ack then. */
682 debug_printf ("putpkt (\"%s\"); [notif]\n", buf2
);
684 debug_printf ("putpkt (\"%s\"); [noack mode]\n", buf2
);
692 debug_printf ("putpkt (\"%s\"); [looking for ack]\n", buf2
);
706 debug_printf ("[received '%c' (0x%x)]\n", cc
, cc
);
710 /* Check for an input interrupt while we're here. */
711 if (cc
== '\003' && current_thread
!= NULL
)
712 (*the_target
->request_interrupt
) ();
717 return 1; /* Success! */
721 putpkt_binary (char *buf
, int cnt
)
723 return putpkt_binary_1 (buf
, cnt
, 0);
726 /* Send a packet to the remote machine, with error checking. The data
727 of the packet is in BUF, and the packet should be a NUL-terminated
728 string. Returns >= 0 on success, -1 otherwise. */
733 return putpkt_binary (buf
, strlen (buf
));
737 putpkt_notif (char *buf
)
739 return putpkt_binary_1 (buf
, strlen (buf
), 1);
742 /* Come here when we get an input interrupt from the remote side. This
743 interrupt should only be active while we are waiting for the child to do
744 something. Thus this assumes readchar:bufcnt is 0.
745 About the only thing that should come through is a ^C, which
746 will cause us to request child interruption. */
749 input_interrupt (int unused
)
752 struct timeval immediate
= { 0, 0 };
754 /* Protect against spurious interrupts. This has been observed to
755 be a problem under NetBSD 1.4 and 1.5. */
758 FD_SET (remote_desc
, &readset
);
759 if (select (remote_desc
+ 1, &readset
, 0, 0, &immediate
) > 0)
764 cc
= read_prim (&c
, 1);
768 fprintf (stderr
, "client connection closed\n");
771 else if (cc
!= 1 || c
!= '\003')
773 fprintf (stderr
, "input_interrupt, count = %d c = %d ", cc
, c
);
775 fprintf (stderr
, "('%c')\n", c
);
777 fprintf (stderr
, "('\\x%02x')\n", c
& 0xff);
781 (*the_target
->request_interrupt
) ();
785 /* Check if the remote side sent us an interrupt request (^C). */
787 check_remote_input_interrupt_request (void)
789 /* This function may be called before establishing communications,
790 therefore we need to validate the remote descriptor. */
792 if (remote_desc
== INVALID_DESCRIPTOR
)
798 /* Asynchronous I/O support. SIGIO must be unblocked when waiting,
799 in order to accept Control-C from the client, and must be blocked
800 when talking to the client. */
803 block_unblock_async_io (int block
)
808 sigemptyset (&sigio_set
);
809 sigaddset (&sigio_set
, SIGIO
);
810 sigprocmask (block
? SIG_BLOCK
: SIG_UNBLOCK
, &sigio_set
, NULL
);
816 nto_comctrl (int enable
)
818 struct sigevent event
;
822 event
.sigev_notify
= SIGEV_SIGNAL_THREAD
;
823 event
.sigev_signo
= SIGIO
;
824 event
.sigev_code
= 0;
825 event
.sigev_value
.sival_ptr
= NULL
;
826 event
.sigev_priority
= -1;
827 ionotify (remote_desc
, _NOTIFY_ACTION_POLLARM
, _NOTIFY_COND_INPUT
,
831 ionotify (remote_desc
, _NOTIFY_ACTION_POLL
, _NOTIFY_COND_INPUT
, NULL
);
836 /* Current state of asynchronous I/O. */
837 static int async_io_enabled
;
839 /* Enable asynchronous I/O. */
841 enable_async_io (void)
843 if (async_io_enabled
)
846 block_unblock_async_io (0);
848 async_io_enabled
= 1;
854 /* Disable asynchronous I/O. */
856 disable_async_io (void)
858 if (!async_io_enabled
)
861 block_unblock_async_io (1);
863 async_io_enabled
= 0;
871 initialize_async_io (void)
873 /* Make sure that async I/O starts blocked. */
874 async_io_enabled
= 1;
877 /* Install the signal handler. */
879 signal (SIGIO
, input_interrupt
);
883 /* Internal buffer used by readchar.
884 These are global to readchar because reschedule_remote needs to be
885 able to tell whether the buffer is empty. */
887 static unsigned char readchar_buf
[BUFSIZ
];
888 static int readchar_bufcnt
= 0;
889 static unsigned char *readchar_bufp
;
891 /* Returns next char from remote GDB. -1 if error. */
898 if (readchar_bufcnt
== 0)
900 readchar_bufcnt
= read_prim (readchar_buf
, sizeof (readchar_buf
));
902 if (readchar_bufcnt
<= 0)
904 if (readchar_bufcnt
== 0)
907 debug_printf ("readchar: Got EOF\n");
915 readchar_bufp
= readchar_buf
;
919 ch
= *readchar_bufp
++;
924 /* Reset the readchar state machine. */
927 reset_readchar (void)
930 if (readchar_callback
!= NOT_SCHEDULED
)
932 delete_callback_event (readchar_callback
);
933 readchar_callback
= NOT_SCHEDULED
;
937 /* Process remaining data in readchar_buf. */
940 process_remaining (void *context
)
944 /* This is a one-shot event. */
945 readchar_callback
= NOT_SCHEDULED
;
947 if (readchar_bufcnt
> 0)
948 res
= handle_serial_event (0, NULL
);
955 /* If there is still data in the buffer, queue another event to process it,
956 we can't sleep in select yet. */
961 if (readchar_bufcnt
> 0 && readchar_callback
== NOT_SCHEDULED
)
962 readchar_callback
= append_callback_event (process_remaining
, NULL
);
965 /* Read a packet from the remote machine, with error checking,
966 and store it in BUF. Returns length of packet, or negative if error. */
971 client_state
&cs
= get_client_state ();
973 unsigned char csum
, c1
, c2
;
984 /* The '\003' may appear before or after each packet, so
985 check for an input interrupt. */
988 (*the_target
->request_interrupt
) ();
996 debug_printf ("[getpkt: discarding char '%c']\n", c
);
1017 c1
= fromhex (readchar ());
1018 c2
= fromhex (readchar ());
1020 if (csum
== (c1
<< 4) + c2
)
1026 "Bad checksum, sentsum=0x%x, csum=0x%x, "
1027 "buf=%s [no-ack-mode, Bad medium?]\n",
1028 (c1
<< 4) + c2
, csum
, buf
);
1029 /* Not much we can do, GDB wasn't expecting an ack/nac. */
1033 fprintf (stderr
, "Bad checksum, sentsum=0x%x, csum=0x%x, buf=%s\n",
1034 (c1
<< 4) + c2
, csum
, buf
);
1035 if (write_prim ("-", 1) != 1)
1043 debug_printf ("getpkt (\"%s\"); [sending ack] \n", buf
);
1047 if (write_prim ("+", 1) != 1)
1052 debug_printf ("[sent ack]\n");
1060 debug_printf ("getpkt (\"%s\"); [no ack sent] \n", buf
);
1065 /* The readchar above may have already read a '\003' out of the socket
1066 and moved it to the local buffer. For example, when GDB sends
1067 vCont;c immediately followed by interrupt (see
1068 gdb.base/interrupt-noterm.exp). As soon as we see the vCont;c, we'll
1069 resume the inferior and wait. Since we've already moved the '\003'
1070 to the local buffer, SIGIO won't help. In that case, if we don't
1071 check for interrupt after the vCont;c packet, the interrupt character
1072 would stay in the buffer unattended until after the next (unrelated)
1074 while (readchar_bufcnt
> 0 && *readchar_bufp
== '\003')
1076 /* Consume the interrupt character in the buffer. */
1078 (*the_target
->request_interrupt
) ();
1085 write_ok (char *buf
)
1093 write_enn (char *buf
)
1095 /* Some day, we should define the meanings of the error codes... */
1104 #ifndef IN_PROCESS_AGENT
1107 outreg (struct regcache
*regcache
, int regno
, char *buf
)
1109 if ((regno
>> 12) != 0)
1110 *buf
++ = tohex ((regno
>> 12) & 0xf);
1111 if ((regno
>> 8) != 0)
1112 *buf
++ = tohex ((regno
>> 8) & 0xf);
1113 *buf
++ = tohex ((regno
>> 4) & 0xf);
1114 *buf
++ = tohex (regno
& 0xf);
1116 collect_register_as_string (regcache
, regno
, buf
);
1117 buf
+= 2 * register_size (regcache
->tdesc
, regno
);
1124 prepare_resume_reply (char *buf
, ptid_t ptid
,
1125 struct target_waitstatus
*status
)
1127 client_state
&cs
= get_client_state ();
1129 debug_printf ("Writing resume reply for %s:%d\n",
1130 target_pid_to_str (ptid
), status
->kind
);
1132 switch (status
->kind
)
1134 case TARGET_WAITKIND_STOPPED
:
1135 case TARGET_WAITKIND_FORKED
:
1136 case TARGET_WAITKIND_VFORKED
:
1137 case TARGET_WAITKIND_VFORK_DONE
:
1138 case TARGET_WAITKIND_EXECD
:
1139 case TARGET_WAITKIND_THREAD_CREATED
:
1140 case TARGET_WAITKIND_SYSCALL_ENTRY
:
1141 case TARGET_WAITKIND_SYSCALL_RETURN
:
1143 struct thread_info
*saved_thread
;
1145 struct regcache
*regcache
;
1147 if ((status
->kind
== TARGET_WAITKIND_FORKED
&& cs
.report_fork_events
)
1148 || (status
->kind
== TARGET_WAITKIND_VFORKED
1149 && cs
.report_vfork_events
))
1151 enum gdb_signal signal
= GDB_SIGNAL_TRAP
;
1152 const char *event
= (status
->kind
== TARGET_WAITKIND_FORKED
1153 ? "fork" : "vfork");
1155 sprintf (buf
, "T%02x%s:", signal
, event
);
1156 buf
+= strlen (buf
);
1157 buf
= write_ptid (buf
, status
->value
.related_pid
);
1160 else if (status
->kind
== TARGET_WAITKIND_VFORK_DONE
1161 && cs
.report_vfork_events
)
1163 enum gdb_signal signal
= GDB_SIGNAL_TRAP
;
1165 sprintf (buf
, "T%02xvforkdone:;", signal
);
1167 else if (status
->kind
== TARGET_WAITKIND_EXECD
&& cs
.report_exec_events
)
1169 enum gdb_signal signal
= GDB_SIGNAL_TRAP
;
1170 const char *event
= "exec";
1171 char hexified_pathname
[PATH_MAX
* 2];
1173 sprintf (buf
, "T%02x%s:", signal
, event
);
1174 buf
+= strlen (buf
);
1176 /* Encode pathname to hexified format. */
1177 bin2hex ((const gdb_byte
*) status
->value
.execd_pathname
,
1179 strlen (status
->value
.execd_pathname
));
1181 sprintf (buf
, "%s;", hexified_pathname
);
1182 xfree (status
->value
.execd_pathname
);
1183 status
->value
.execd_pathname
= NULL
;
1184 buf
+= strlen (buf
);
1186 else if (status
->kind
== TARGET_WAITKIND_THREAD_CREATED
1187 && cs
.report_thread_events
)
1189 enum gdb_signal signal
= GDB_SIGNAL_TRAP
;
1191 sprintf (buf
, "T%02xcreate:;", signal
);
1193 else if (status
->kind
== TARGET_WAITKIND_SYSCALL_ENTRY
1194 || status
->kind
== TARGET_WAITKIND_SYSCALL_RETURN
)
1196 enum gdb_signal signal
= GDB_SIGNAL_TRAP
;
1197 const char *event
= (status
->kind
== TARGET_WAITKIND_SYSCALL_ENTRY
1198 ? "syscall_entry" : "syscall_return");
1200 sprintf (buf
, "T%02x%s:%x;", signal
, event
,
1201 status
->value
.syscall_number
);
1204 sprintf (buf
, "T%02x", status
->value
.sig
);
1206 buf
+= strlen (buf
);
1208 saved_thread
= current_thread
;
1210 switch_to_thread (ptid
);
1212 regp
= current_target_desc ()->expedite_regs
;
1214 regcache
= get_thread_regcache (current_thread
, 1);
1216 if (the_target
->stopped_by_watchpoint
!= NULL
1217 && (*the_target
->stopped_by_watchpoint
) ())
1222 memcpy (buf
, "watch:", 6);
1225 addr
= (*the_target
->stopped_data_address
) ();
1227 /* Convert each byte of the address into two hexadecimal
1228 chars. Note that we take sizeof (void *) instead of
1229 sizeof (addr); this is to avoid sending a 64-bit
1230 address to a 32-bit GDB. */
1231 for (i
= sizeof (void *) * 2; i
> 0; i
--)
1232 *buf
++ = tohex ((addr
>> (i
- 1) * 4) & 0xf);
1235 else if (cs
.swbreak_feature
&& target_stopped_by_sw_breakpoint ())
1237 sprintf (buf
, "swbreak:;");
1238 buf
+= strlen (buf
);
1240 else if (cs
.hwbreak_feature
&& target_stopped_by_hw_breakpoint ())
1242 sprintf (buf
, "hwbreak:;");
1243 buf
+= strlen (buf
);
1248 buf
= outreg (regcache
, find_regno (regcache
->tdesc
, *regp
), buf
);
1253 /* Formerly, if the debugger had not used any thread features
1254 we would not burden it with a thread status response. This
1255 was for the benefit of GDB 4.13 and older. However, in
1256 recent GDB versions the check (``if (cont_thread != 0)'')
1257 does not have the desired effect because of sillyness in
1258 the way that the remote protocol handles specifying a
1259 thread. Since thread support relies on qSymbol support
1260 anyway, assume GDB can handle threads. */
1262 if (using_threads
&& !disable_packet_Tthread
)
1264 /* This if (1) ought to be unnecessary. But remote_wait
1265 in GDB will claim this event belongs to inferior_ptid
1266 if we do not specify a thread, and there's no way for
1267 gdbserver to know what inferior_ptid is. */
1268 if (1 || cs
.general_thread
!= ptid
)
1271 /* In non-stop, don't change the general thread behind
1274 cs
.general_thread
= ptid
;
1275 sprintf (buf
, "thread:");
1276 buf
+= strlen (buf
);
1277 buf
= write_ptid (buf
, ptid
);
1279 buf
+= strlen (buf
);
1281 core
= target_core_of_thread (ptid
);
1285 sprintf (buf
, "core:");
1286 buf
+= strlen (buf
);
1287 sprintf (buf
, "%x", core
);
1289 buf
+= strlen (buf
);
1296 strcpy (buf
, "library:;");
1297 buf
+= strlen (buf
);
1301 current_thread
= saved_thread
;
1304 case TARGET_WAITKIND_EXITED
:
1305 if (cs
.multi_process
)
1306 sprintf (buf
, "W%x;process:%x",
1307 status
->value
.integer
, ptid
.pid ());
1309 sprintf (buf
, "W%02x", status
->value
.integer
);
1311 case TARGET_WAITKIND_SIGNALLED
:
1312 if (cs
.multi_process
)
1313 sprintf (buf
, "X%x;process:%x",
1314 status
->value
.sig
, ptid
.pid ());
1316 sprintf (buf
, "X%02x", status
->value
.sig
);
1318 case TARGET_WAITKIND_THREAD_EXITED
:
1319 sprintf (buf
, "w%x;", status
->value
.integer
);
1320 buf
+= strlen (buf
);
1321 buf
= write_ptid (buf
, ptid
);
1323 case TARGET_WAITKIND_NO_RESUMED
:
1327 error ("unhandled waitkind");
1333 decode_m_packet (char *from
, CORE_ADDR
*mem_addr_ptr
, unsigned int *len_ptr
)
1337 *mem_addr_ptr
= *len_ptr
= 0;
1339 while ((ch
= from
[i
++]) != ',')
1341 *mem_addr_ptr
= *mem_addr_ptr
<< 4;
1342 *mem_addr_ptr
|= fromhex (ch
) & 0x0f;
1345 for (j
= 0; j
< 4; j
++)
1347 if ((ch
= from
[i
++]) == 0)
1349 *len_ptr
= *len_ptr
<< 4;
1350 *len_ptr
|= fromhex (ch
) & 0x0f;
1355 decode_M_packet (char *from
, CORE_ADDR
*mem_addr_ptr
, unsigned int *len_ptr
,
1356 unsigned char **to_p
)
1360 *mem_addr_ptr
= *len_ptr
= 0;
1362 while ((ch
= from
[i
++]) != ',')
1364 *mem_addr_ptr
= *mem_addr_ptr
<< 4;
1365 *mem_addr_ptr
|= fromhex (ch
) & 0x0f;
1368 while ((ch
= from
[i
++]) != ':')
1370 *len_ptr
= *len_ptr
<< 4;
1371 *len_ptr
|= fromhex (ch
) & 0x0f;
1375 *to_p
= (unsigned char *) xmalloc (*len_ptr
);
1377 hex2bin (&from
[i
++], *to_p
, *len_ptr
);
1381 decode_X_packet (char *from
, int packet_len
, CORE_ADDR
*mem_addr_ptr
,
1382 unsigned int *len_ptr
, unsigned char **to_p
)
1386 *mem_addr_ptr
= *len_ptr
= 0;
1388 while ((ch
= from
[i
++]) != ',')
1390 *mem_addr_ptr
= *mem_addr_ptr
<< 4;
1391 *mem_addr_ptr
|= fromhex (ch
) & 0x0f;
1394 while ((ch
= from
[i
++]) != ':')
1396 *len_ptr
= *len_ptr
<< 4;
1397 *len_ptr
|= fromhex (ch
) & 0x0f;
1401 *to_p
= (unsigned char *) xmalloc (*len_ptr
);
1403 if (remote_unescape_input ((const gdb_byte
*) &from
[i
], packet_len
- i
,
1404 *to_p
, *len_ptr
) != *len_ptr
)
1410 /* Decode a qXfer write request. */
1413 decode_xfer_write (char *buf
, int packet_len
, CORE_ADDR
*offset
,
1414 unsigned int *len
, unsigned char *data
)
1419 /* Extract the offset. */
1421 while ((ch
= *buf
++) != ':')
1423 *offset
= *offset
<< 4;
1424 *offset
|= fromhex (ch
) & 0x0f;
1427 /* Get encoded data. */
1428 packet_len
-= buf
- b
;
1429 *len
= remote_unescape_input ((const gdb_byte
*) buf
, packet_len
,
1434 /* Decode the parameters of a qSearch:memory packet. */
1437 decode_search_memory_packet (const char *buf
, int packet_len
,
1438 CORE_ADDR
*start_addrp
,
1439 CORE_ADDR
*search_space_lenp
,
1440 gdb_byte
*pattern
, unsigned int *pattern_lenp
)
1442 const char *p
= buf
;
1444 p
= decode_address_to_semicolon (start_addrp
, p
);
1445 p
= decode_address_to_semicolon (search_space_lenp
, p
);
1446 packet_len
-= p
- buf
;
1447 *pattern_lenp
= remote_unescape_input ((const gdb_byte
*) p
, packet_len
,
1448 pattern
, packet_len
);
1453 free_sym_cache (struct sym_cache
*sym
)
1463 clear_symbol_cache (struct sym_cache
**symcache_p
)
1465 struct sym_cache
*sym
, *next
;
1467 /* Check the cache first. */
1468 for (sym
= *symcache_p
; sym
; sym
= next
)
1471 free_sym_cache (sym
);
1477 /* Get the address of NAME, and return it in ADDRP if found. if
1478 MAY_ASK_GDB is false, assume symbol cache misses are failures.
1479 Returns 1 if the symbol is found, 0 if it is not, -1 on error. */
1482 look_up_one_symbol (const char *name
, CORE_ADDR
*addrp
, int may_ask_gdb
)
1484 client_state
&cs
= get_client_state ();
1487 struct sym_cache
*sym
;
1488 struct process_info
*proc
;
1490 proc
= current_process ();
1492 /* Check the cache first. */
1493 for (sym
= proc
->symbol_cache
; sym
; sym
= sym
->next
)
1494 if (strcmp (name
, sym
->name
) == 0)
1500 /* It might not be an appropriate time to look up a symbol,
1501 e.g. while we're trying to fetch registers. */
1505 /* Send the request. */
1506 strcpy (cs
.own_buf
, "qSymbol:");
1507 bin2hex ((const gdb_byte
*) name
, cs
.own_buf
+ strlen ("qSymbol:"),
1509 if (putpkt (cs
.own_buf
) < 0)
1512 /* FIXME: Eventually add buffer overflow checking (to getpkt?) */
1513 len
= getpkt (cs
.own_buf
);
1517 /* We ought to handle pretty much any packet at this point while we
1518 wait for the qSymbol "response". That requires re-entering the
1519 main loop. For now, this is an adequate approximation; allow
1520 GDB to read from memory and handle 'v' packets (for vFile transfers)
1521 while it figures out the address of the symbol. */
1524 if (cs
.own_buf
[0] == 'm')
1527 unsigned char *mem_buf
;
1528 unsigned int mem_len
;
1530 decode_m_packet (&cs
.own_buf
[1], &mem_addr
, &mem_len
);
1531 mem_buf
= (unsigned char *) xmalloc (mem_len
);
1532 if (read_inferior_memory (mem_addr
, mem_buf
, mem_len
) == 0)
1533 bin2hex (mem_buf
, cs
.own_buf
, mem_len
);
1535 write_enn (cs
.own_buf
);
1537 if (putpkt (cs
.own_buf
) < 0)
1540 else if (cs
.own_buf
[0] == 'v')
1543 handle_v_requests (cs
.own_buf
, len
, &new_len
);
1545 putpkt_binary (cs
.own_buf
, new_len
);
1547 putpkt (cs
.own_buf
);
1551 len
= getpkt (cs
.own_buf
);
1556 if (!startswith (cs
.own_buf
, "qSymbol:"))
1558 warning ("Malformed response to qSymbol, ignoring: %s", cs
.own_buf
);
1562 p
= cs
.own_buf
+ strlen ("qSymbol:");
1564 while (*q
&& *q
!= ':')
1567 /* Make sure we found a value for the symbol. */
1568 if (p
== q
|| *q
== '\0')
1571 decode_address (addrp
, p
, q
- p
);
1573 /* Save the symbol in our cache. */
1574 sym
= XNEW (struct sym_cache
);
1575 sym
->name
= xstrdup (name
);
1577 sym
->next
= proc
->symbol_cache
;
1578 proc
->symbol_cache
= sym
;
1583 /* Relocate an instruction to execute at a different address. OLDLOC
1584 is the address in the inferior memory where the instruction to
1585 relocate is currently at. On input, TO points to the destination
1586 where we want the instruction to be copied (and possibly adjusted)
1587 to. On output, it points to one past the end of the resulting
1588 instruction(s). The effect of executing the instruction at TO
1589 shall be the same as if executing it at OLDLOC. For example, call
1590 instructions that implicitly push the return address on the stack
1591 should be adjusted to return to the instruction after OLDLOC;
1592 relative branches, and other PC-relative instructions need the
1593 offset adjusted; etc. Returns 0 on success, -1 on failure. */
1596 relocate_instruction (CORE_ADDR
*to
, CORE_ADDR oldloc
)
1598 client_state
&cs
= get_client_state ();
1600 ULONGEST written
= 0;
1602 /* Send the request. */
1603 sprintf (cs
.own_buf
, "qRelocInsn:%s;%s", paddress (oldloc
),
1605 if (putpkt (cs
.own_buf
) < 0)
1608 /* FIXME: Eventually add buffer overflow checking (to getpkt?) */
1609 len
= getpkt (cs
.own_buf
);
1613 /* We ought to handle pretty much any packet at this point while we
1614 wait for the qRelocInsn "response". That requires re-entering
1615 the main loop. For now, this is an adequate approximation; allow
1616 GDB to access memory. */
1617 while (cs
.own_buf
[0] == 'm' || cs
.own_buf
[0] == 'M' || cs
.own_buf
[0] == 'X')
1620 unsigned char *mem_buf
= NULL
;
1621 unsigned int mem_len
;
1623 if (cs
.own_buf
[0] == 'm')
1625 decode_m_packet (&cs
.own_buf
[1], &mem_addr
, &mem_len
);
1626 mem_buf
= (unsigned char *) xmalloc (mem_len
);
1627 if (read_inferior_memory (mem_addr
, mem_buf
, mem_len
) == 0)
1628 bin2hex (mem_buf
, cs
.own_buf
, mem_len
);
1630 write_enn (cs
.own_buf
);
1632 else if (cs
.own_buf
[0] == 'X')
1634 if (decode_X_packet (&cs
.own_buf
[1], len
- 1, &mem_addr
,
1635 &mem_len
, &mem_buf
) < 0
1636 || target_write_memory (mem_addr
, mem_buf
, mem_len
) != 0)
1637 write_enn (cs
.own_buf
);
1639 write_ok (cs
.own_buf
);
1643 decode_M_packet (&cs
.own_buf
[1], &mem_addr
, &mem_len
, &mem_buf
);
1644 if (target_write_memory (mem_addr
, mem_buf
, mem_len
) == 0)
1645 write_ok (cs
.own_buf
);
1647 write_enn (cs
.own_buf
);
1650 if (putpkt (cs
.own_buf
) < 0)
1652 len
= getpkt (cs
.own_buf
);
1657 if (cs
.own_buf
[0] == 'E')
1659 warning ("An error occurred while relocating an instruction: %s",
1664 if (!startswith (cs
.own_buf
, "qRelocInsn:"))
1666 warning ("Malformed response to qRelocInsn, ignoring: %s",
1671 unpack_varlen_hex (cs
.own_buf
+ strlen ("qRelocInsn:"), &written
);
1678 monitor_output (const char *msg
)
1680 int len
= strlen (msg
);
1681 char *buf
= (char *) xmalloc (len
* 2 + 2);
1684 bin2hex ((const gdb_byte
*) msg
, buf
+ 1, len
);