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"
30 #include "filestuff.h"
33 #include <sys/ioctl.h>
39 #include <netinet/in.h>
45 #include <sys/socket.h>
50 #if HAVE_NETINET_TCP_H
51 #include <netinet/tcp.h>
54 #include <sys/ioctl.h>
62 #include "gdb_sys_time.h"
65 #include <arpa/inet.h>
75 #include <sys/iomgr.h>
78 #ifndef HAVE_SOCKLEN_T
79 typedef int socklen_t
;
82 #ifndef IN_PROCESS_AGENT
85 # define INVALID_DESCRIPTOR INVALID_SOCKET
87 # define INVALID_DESCRIPTOR -1
90 /* Extra value for readchar_callback. */
92 /* The callback is currently not scheduled. */
96 /* Status of the readchar callback.
97 Either NOT_SCHEDULED or the callback id. */
98 static int readchar_callback
= NOT_SCHEDULED
;
100 static int readchar (void);
101 static void reset_readchar (void);
102 static void reschedule (void);
104 /* A cache entry for a successfully looked-up symbol. */
109 struct sym_cache
*next
;
112 int remote_debug
= 0;
113 struct ui_file
*gdb_stdlog
;
115 static int remote_is_stdio
= 0;
117 static gdb_fildes_t remote_desc
= INVALID_DESCRIPTOR
;
118 static gdb_fildes_t listen_desc
= INVALID_DESCRIPTOR
;
120 /* FIXME headerize? */
121 extern int using_threads
;
122 extern int debug_threads
;
125 # define read(fd, buf, len) recv (fd, (char *) buf, len, 0)
126 # define write(fd, buf, len) send (fd, (char *) buf, len, 0)
132 return remote_desc
!= INVALID_DESCRIPTOR
;
135 /* Return true if the remote connection is over stdio. */
138 remote_connection_is_stdio (void)
140 return remote_is_stdio
;
144 enable_async_notification (int fd
)
146 #if defined(F_SETFL) && defined (FASYNC)
147 int save_fcntl_flags
;
149 save_fcntl_flags
= fcntl (fd
, F_GETFL
, 0);
150 fcntl (fd
, F_SETFL
, save_fcntl_flags
| FASYNC
);
151 #if defined (F_SETOWN)
152 fcntl (fd
, F_SETOWN
, getpid ());
158 handle_accept_event (int err
, gdb_client_data client_data
)
160 struct sockaddr_storage sockaddr
;
161 socklen_t len
= sizeof (sockaddr
);
164 debug_printf ("handling possible accept event\n");
166 remote_desc
= accept (listen_desc
, (struct sockaddr
*) &sockaddr
, &len
);
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
);
200 if (sockaddr
.ss_family
== AF_UNIX
)
202 struct sockaddr_un su
;
203 socklen_t socklen
= sizeof (su
);
205 if (getsockname (listen_desc
, (struct sockaddr
*) &su
, &socklen
) != 0)
206 perror (_("Could not obtain remote address"));
208 fprintf (stderr
, _("Remote debugging on local socket bound to %s\n"),
214 /* Convert IP address to string. */
215 char orig_host
[GDB_NI_MAX_ADDR
], orig_port
[GDB_NI_MAX_PORT
];
217 int r
= getnameinfo ((struct sockaddr
*) &sockaddr
, len
,
218 orig_host
, sizeof (orig_host
),
219 orig_port
, sizeof (orig_port
),
220 NI_NUMERICHOST
| NI_NUMERICSERV
);
223 fprintf (stderr
, _("Could not obtain remote address: %s\n"),
226 fprintf (stderr
, _("Remote debugging from host %s, port %s\n"),
227 orig_host
, orig_port
);
230 enable_async_notification (remote_desc
);
232 /* Register the event loop handler. */
233 add_file_handler (remote_desc
, handle_serial_event
, NULL
);
235 /* We have a new GDB connection now. If we were disconnected
236 tracing, there's a window where the target could report a stop
237 event to the event loop, and since we have a connection now, we'd
238 try to send vStopped notifications to GDB. But, don't do that
239 until GDB as selected all-stop/non-stop, and has queried the
240 threads' status ('?'). */
246 /* Prepare for a later connection to a remote debugger.
247 NAME is the filename used for communication. */
250 remote_prepare (const char *name
)
252 client_state
&cs
= get_client_state ();
254 static int winsock_initialized
;
259 if (strcmp (name
, STDIO_CONNECTION_NAME
) == 0)
261 /* We need to record fact that we're using stdio sooner than the
262 call to remote_open so start_inferior knows the connection is
265 cs
.transport_is_reliable
= 1;
269 struct addrinfo hint
;
270 struct addrinfo
*ainfo
;
272 struct sockaddr
*addr
;
275 memset (&hint
, 0, sizeof (hint
));
276 /* Assume no prefix will be passed, therefore we should use
278 hint
.ai_family
= AF_UNSPEC
;
279 hint
.ai_socktype
= SOCK_STREAM
;
280 hint
.ai_protocol
= IPPROTO_TCP
;
282 parsed_connection_spec parsed
283 = parse_connection_spec (name
, &hint
);
285 if (parsed
.port_str
.empty ())
287 cs
.transport_is_reliable
= 0;
292 if (!winsock_initialized
)
296 WSAStartup (MAKEWORD (1, 0), &wsad
);
297 winsock_initialized
= 1;
302 struct sockaddr_un unix_addr
;
304 #ifndef UNIX_PATH_MAX
305 #define UNIX_PATH_MAX sizeof (((struct sockaddr_un *) NULL)->sun_path)
308 if (hint
.ai_family
== AF_LOCAL
)
310 const char *sock_name
= parsed
.port_str
.c_str ();
311 if (parsed
.port_str
.length () > UNIX_PATH_MAX
- 1)
314 (_("%s is too long. Socket names may be no longer than %s bytes."),
315 sock_name
, pulongest (UNIX_PATH_MAX
- 1));
318 listen_desc
= socket (AF_UNIX
, SOCK_STREAM
, 0);
320 perror_with_name ("Can't open socket");
322 memset (&unix_addr
, 0, sizeof (unix_addr
));
323 unix_addr
.sun_family
= AF_UNIX
;
324 strncpy (unix_addr
.sun_path
, sock_name
, UNIX_PATH_MAX
- 1);
327 int stat_result
= stat (sock_name
, &statbuf
);
330 && S_ISSOCK (statbuf
.st_mode
))
333 addr
= (struct sockaddr
*) &unix_addr
;
334 addrlen
= sizeof (unix_addr
);
339 struct addrinfo
*iter
;
341 int r
= getaddrinfo (parsed
.host_str
.c_str (),
342 parsed
.port_str
.c_str (),
346 error (_("%s: cannot resolve name: %s"), name
, gai_strerror (r
));
348 scoped_free_addrinfo
freeaddrinfo (ainfo
);
350 for (iter
= ainfo
; iter
!= NULL
; iter
= iter
->ai_next
)
352 listen_desc
= gdb_socket_cloexec (iter
->ai_family
, iter
->ai_socktype
,
355 if (listen_desc
>= 0)
360 perror_with_name ("Can't open socket");
362 /* Allow rapid reuse of this port. */
364 setsockopt (listen_desc
, SOL_SOCKET
, SO_REUSEADDR
, (char *) &tmp
,
367 if (iter
->ai_socktype
== SOCK_DGRAM
)
368 error (_("Only stream orientated protocols are currently supported."));
370 switch (iter
->ai_family
)
373 ((struct sockaddr_in
*) iter
->ai_addr
)->sin_addr
.s_addr
= INADDR_ANY
;
376 ((struct sockaddr_in6
*) iter
->ai_addr
)->sin6_addr
= in6addr_any
;
379 internal_error (__FILE__
, __LINE__
,
380 _("Invalid 'ai_family' %d\n"), iter
->ai_family
);
382 addr
= iter
->ai_addr
;
383 addrlen
= iter
->ai_addrlen
;
386 if (bind (listen_desc
, addr
, addrlen
) != 0)
387 perror_with_name ("Can't bind address");
389 if (listen (listen_desc
, 1) != 0)
390 perror_with_name ("Can't listen on socket");
392 cs
.transport_is_reliable
= 1;
395 /* Open a connection to a remote debugger.
396 NAME is the filename used for communication. */
399 remote_open (const char *name
)
401 const char *port_str
;
403 port_str
= strchr (name
, ':');
405 if (port_str
== NULL
)
406 error ("Only HOST:PORT is supported on this platform.");
409 if (strcmp (name
, STDIO_CONNECTION_NAME
) == 0)
411 fprintf (stderr
, "Remote debugging using stdio\n");
413 /* Use stdin as the handle of the connection.
414 We only select on reads, for example. */
415 remote_desc
= fileno (stdin
);
417 enable_async_notification (remote_desc
);
419 /* Register the event loop handler. */
420 add_file_handler (remote_desc
, handle_serial_event
, NULL
);
423 else if (port_str
== NULL
)
427 if (stat (name
, &statbuf
) == 0
428 && (S_ISCHR (statbuf
.st_mode
) || S_ISFIFO (statbuf
.st_mode
)))
429 remote_desc
= open (name
, O_RDWR
);
437 perror_with_name ("Could not open remote device");
441 struct termios termios
;
442 tcgetattr (remote_desc
, &termios
);
447 termios
.c_cflag
&= ~(CSIZE
| PARENB
);
448 termios
.c_cflag
|= CLOCAL
| CS8
;
449 termios
.c_cc
[VMIN
] = 1;
450 termios
.c_cc
[VTIME
] = 0;
452 tcsetattr (remote_desc
, TCSANOW
, &termios
);
456 fprintf (stderr
, "Remote debugging using %s\n", name
);
458 enable_async_notification (remote_desc
);
460 /* Register the event loop handler. */
461 add_file_handler (remote_desc
, handle_serial_event
, NULL
);
463 #endif /* USE_WIN32API */
466 char listen_port
[GDB_NI_MAX_PORT
];
467 struct sockaddr_storage sockaddr
;
468 socklen_t len
= sizeof (sockaddr
);
470 if (getsockname (listen_desc
, (struct sockaddr
*) &sockaddr
, &len
) < 0)
471 perror_with_name ("Can't determine port");
473 int r
= getnameinfo ((struct sockaddr
*) &sockaddr
, len
,
475 listen_port
, sizeof (listen_port
),
479 fprintf (stderr
, _("Can't obtain port where we are listening: %s"),
482 fprintf (stderr
, _("Listening on port %s\n"), listen_port
);
486 /* Register the event loop handler. */
487 add_file_handler (listen_desc
, handle_accept_event
, NULL
);
494 delete_file_handler (remote_desc
);
499 closesocket (remote_desc
);
501 if (! remote_connection_is_stdio ())
504 remote_desc
= INVALID_DESCRIPTOR
;
511 #ifndef IN_PROCESS_AGENT
514 decode_address (CORE_ADDR
*addrp
, const char *start
, int len
)
521 for (i
= 0; i
< len
; i
++)
525 addr
= addr
| (fromhex (ch
) & 0x0f);
531 decode_address_to_semicolon (CORE_ADDR
*addrp
, const char *start
)
536 while (*end
!= '\0' && *end
!= ';')
539 decode_address (addrp
, start
, end
- start
);
548 #ifndef IN_PROCESS_AGENT
550 /* Look for a sequence of characters which can be run-length encoded.
551 If there are any, update *CSUM and *P. Otherwise, output the
552 single character. Return the number of characters consumed. */
555 try_rle (char *buf
, int remaining
, unsigned char *csum
, char **p
)
559 /* Always output the character. */
563 /* Don't go past '~'. */
567 for (n
= 1; n
< remaining
; n
++)
568 if (buf
[n
] != buf
[0])
571 /* N is the index of the first character not the same as buf[0].
572 buf[0] is counted twice, so by decrementing N, we get the number
573 of characters the RLE sequence will replace. */
579 /* Skip the frame characters. The manual says to skip '+' and '-'
580 also, but there's no reason to. Unfortunately these two unusable
581 characters double the encoded length of a four byte zero
583 while (n
+ 29 == '$' || n
+ 29 == '#')
596 #ifndef IN_PROCESS_AGENT
598 /* Write a PTID to BUF. Returns BUF+CHARACTERS_WRITTEN. */
601 write_ptid (char *buf
, ptid_t ptid
)
603 client_state
&cs
= get_client_state ();
606 if (cs
.multi_process
)
610 buf
+= sprintf (buf
, "p-%x.", -pid
);
612 buf
+= sprintf (buf
, "p%x.", pid
);
616 buf
+= sprintf (buf
, "-%x", -tid
);
618 buf
+= sprintf (buf
, "%x", tid
);
624 hex_or_minus_one (const char *buf
, const char **obuf
)
628 if (startswith (buf
, "-1"))
634 buf
= unpack_varlen_hex (buf
, &ret
);
642 /* Extract a PTID from BUF. If non-null, OBUF is set to the to one
643 passed the last parsed char. Returns null_ptid on error. */
645 read_ptid (const char *buf
, const char **obuf
)
649 ULONGEST pid
= 0, tid
= 0;
653 /* Multi-process ptid. */
654 pp
= unpack_varlen_hex (p
+ 1, &pid
);
656 error ("invalid remote ptid: %s\n", p
);
660 tid
= hex_or_minus_one (p
, &pp
);
664 return ptid_t (pid
, tid
, 0);
667 /* No multi-process. Just a tid. */
668 tid
= hex_or_minus_one (p
, &pp
);
670 /* Since GDB is not sending a process id (multi-process extensions
671 are off), then there's only one process. Default to the first in
673 pid
= pid_of (get_first_process ());
677 return ptid_t (pid
, tid
, 0);
680 /* Write COUNT bytes in BUF to the client.
681 The result is the number of bytes written or -1 if error.
682 This may return less than COUNT. */
685 write_prim (const void *buf
, int count
)
687 if (remote_connection_is_stdio ())
688 return write (fileno (stdout
), buf
, count
);
690 return write (remote_desc
, buf
, count
);
693 /* Read COUNT bytes from the client and store in BUF.
694 The result is the number of bytes read or -1 if error.
695 This may return less than COUNT. */
698 read_prim (void *buf
, int count
)
700 if (remote_connection_is_stdio ())
701 return read (fileno (stdin
), buf
, count
);
703 return read (remote_desc
, buf
, count
);
706 /* Send a packet to the remote machine, with error checking.
707 The data of the packet is in BUF, and the length of the
708 packet is in CNT. Returns >= 0 on success, -1 otherwise. */
711 putpkt_binary_1 (char *buf
, int cnt
, int is_notif
)
713 client_state
&cs
= get_client_state ();
715 unsigned char csum
= 0;
720 buf2
= (char *) xmalloc (strlen ("$") + cnt
+ strlen ("#nn") + 1);
722 /* Copy the packet into buffer BUF2, encapsulating it
723 and giving it a checksum. */
731 for (i
= 0; i
< cnt
;)
732 i
+= try_rle (buf
+ i
, cnt
- i
, &csum
, &p
);
735 *p
++ = tohex ((csum
>> 4) & 0xf);
736 *p
++ = tohex (csum
& 0xf);
740 /* Send it over and over until we get a positive ack. */
744 if (write_prim (buf2
, p
- buf2
) != p
- buf2
)
746 perror ("putpkt(write)");
751 if (cs
.noack_mode
|| is_notif
)
753 /* Don't expect an ack then. */
757 debug_printf ("putpkt (\"%s\"); [notif]\n", buf2
);
759 debug_printf ("putpkt (\"%s\"); [noack mode]\n", buf2
);
767 debug_printf ("putpkt (\"%s\"); [looking for ack]\n", buf2
);
781 debug_printf ("[received '%c' (0x%x)]\n", cc
, cc
);
785 /* Check for an input interrupt while we're here. */
786 if (cc
== '\003' && current_thread
!= NULL
)
787 (*the_target
->request_interrupt
) ();
792 return 1; /* Success! */
796 putpkt_binary (char *buf
, int cnt
)
798 return putpkt_binary_1 (buf
, cnt
, 0);
801 /* Send a packet to the remote machine, with error checking. The data
802 of the packet is in BUF, and the packet should be a NUL-terminated
803 string. Returns >= 0 on success, -1 otherwise. */
808 return putpkt_binary (buf
, strlen (buf
));
812 putpkt_notif (char *buf
)
814 return putpkt_binary_1 (buf
, strlen (buf
), 1);
817 /* Come here when we get an input interrupt from the remote side. This
818 interrupt should only be active while we are waiting for the child to do
819 something. Thus this assumes readchar:bufcnt is 0.
820 About the only thing that should come through is a ^C, which
821 will cause us to request child interruption. */
824 input_interrupt (int unused
)
827 struct timeval immediate
= { 0, 0 };
829 /* Protect against spurious interrupts. This has been observed to
830 be a problem under NetBSD 1.4 and 1.5. */
833 FD_SET (remote_desc
, &readset
);
834 if (select (remote_desc
+ 1, &readset
, 0, 0, &immediate
) > 0)
839 cc
= read_prim (&c
, 1);
843 fprintf (stderr
, "client connection closed\n");
846 else if (cc
!= 1 || c
!= '\003')
848 fprintf (stderr
, "input_interrupt, count = %d c = %d ", cc
, c
);
850 fprintf (stderr
, "('%c')\n", c
);
852 fprintf (stderr
, "('\\x%02x')\n", c
& 0xff);
856 (*the_target
->request_interrupt
) ();
860 /* Check if the remote side sent us an interrupt request (^C). */
862 check_remote_input_interrupt_request (void)
864 /* This function may be called before establishing communications,
865 therefore we need to validate the remote descriptor. */
867 if (remote_desc
== INVALID_DESCRIPTOR
)
873 /* Asynchronous I/O support. SIGIO must be unblocked when waiting,
874 in order to accept Control-C from the client, and must be blocked
875 when talking to the client. */
878 block_unblock_async_io (int block
)
883 sigemptyset (&sigio_set
);
884 sigaddset (&sigio_set
, SIGIO
);
885 sigprocmask (block
? SIG_BLOCK
: SIG_UNBLOCK
, &sigio_set
, NULL
);
891 nto_comctrl (int enable
)
893 struct sigevent event
;
897 event
.sigev_notify
= SIGEV_SIGNAL_THREAD
;
898 event
.sigev_signo
= SIGIO
;
899 event
.sigev_code
= 0;
900 event
.sigev_value
.sival_ptr
= NULL
;
901 event
.sigev_priority
= -1;
902 ionotify (remote_desc
, _NOTIFY_ACTION_POLLARM
, _NOTIFY_COND_INPUT
,
906 ionotify (remote_desc
, _NOTIFY_ACTION_POLL
, _NOTIFY_COND_INPUT
, NULL
);
911 /* Current state of asynchronous I/O. */
912 static int async_io_enabled
;
914 /* Enable asynchronous I/O. */
916 enable_async_io (void)
918 if (async_io_enabled
)
921 block_unblock_async_io (0);
923 async_io_enabled
= 1;
929 /* Disable asynchronous I/O. */
931 disable_async_io (void)
933 if (!async_io_enabled
)
936 block_unblock_async_io (1);
938 async_io_enabled
= 0;
946 initialize_async_io (void)
948 /* Make sure that async I/O starts blocked. */
949 async_io_enabled
= 1;
952 /* Install the signal handler. */
954 signal (SIGIO
, input_interrupt
);
958 /* Internal buffer used by readchar.
959 These are global to readchar because reschedule_remote needs to be
960 able to tell whether the buffer is empty. */
962 static unsigned char readchar_buf
[BUFSIZ
];
963 static int readchar_bufcnt
= 0;
964 static unsigned char *readchar_bufp
;
966 /* Returns next char from remote GDB. -1 if error. */
973 if (readchar_bufcnt
== 0)
975 readchar_bufcnt
= read_prim (readchar_buf
, sizeof (readchar_buf
));
977 if (readchar_bufcnt
<= 0)
979 if (readchar_bufcnt
== 0)
982 debug_printf ("readchar: Got EOF\n");
990 readchar_bufp
= readchar_buf
;
994 ch
= *readchar_bufp
++;
999 /* Reset the readchar state machine. */
1002 reset_readchar (void)
1004 readchar_bufcnt
= 0;
1005 if (readchar_callback
!= NOT_SCHEDULED
)
1007 delete_callback_event (readchar_callback
);
1008 readchar_callback
= NOT_SCHEDULED
;
1012 /* Process remaining data in readchar_buf. */
1015 process_remaining (void *context
)
1019 /* This is a one-shot event. */
1020 readchar_callback
= NOT_SCHEDULED
;
1022 if (readchar_bufcnt
> 0)
1023 res
= handle_serial_event (0, NULL
);
1030 /* If there is still data in the buffer, queue another event to process it,
1031 we can't sleep in select yet. */
1036 if (readchar_bufcnt
> 0 && readchar_callback
== NOT_SCHEDULED
)
1037 readchar_callback
= append_callback_event (process_remaining
, NULL
);
1040 /* Read a packet from the remote machine, with error checking,
1041 and store it in BUF. Returns length of packet, or negative if error. */
1046 client_state
&cs
= get_client_state ();
1048 unsigned char csum
, c1
, c2
;
1059 /* The '\003' may appear before or after each packet, so
1060 check for an input interrupt. */
1063 (*the_target
->request_interrupt
) ();
1071 debug_printf ("[getpkt: discarding char '%c']\n", c
);
1092 c1
= fromhex (readchar ());
1093 c2
= fromhex (readchar ());
1095 if (csum
== (c1
<< 4) + c2
)
1101 "Bad checksum, sentsum=0x%x, csum=0x%x, "
1102 "buf=%s [no-ack-mode, Bad medium?]\n",
1103 (c1
<< 4) + c2
, csum
, buf
);
1104 /* Not much we can do, GDB wasn't expecting an ack/nac. */
1108 fprintf (stderr
, "Bad checksum, sentsum=0x%x, csum=0x%x, buf=%s\n",
1109 (c1
<< 4) + c2
, csum
, buf
);
1110 if (write_prim ("-", 1) != 1)
1118 debug_printf ("getpkt (\"%s\"); [sending ack] \n", buf
);
1122 if (write_prim ("+", 1) != 1)
1127 debug_printf ("[sent ack]\n");
1135 debug_printf ("getpkt (\"%s\"); [no ack sent] \n", buf
);
1140 /* The readchar above may have already read a '\003' out of the socket
1141 and moved it to the local buffer. For example, when GDB sends
1142 vCont;c immediately followed by interrupt (see
1143 gdb.base/interrupt-noterm.exp). As soon as we see the vCont;c, we'll
1144 resume the inferior and wait. Since we've already moved the '\003'
1145 to the local buffer, SIGIO won't help. In that case, if we don't
1146 check for interrupt after the vCont;c packet, the interrupt character
1147 would stay in the buffer unattended until after the next (unrelated)
1149 while (readchar_bufcnt
> 0 && *readchar_bufp
== '\003')
1151 /* Consume the interrupt character in the buffer. */
1153 (*the_target
->request_interrupt
) ();
1160 write_ok (char *buf
)
1168 write_enn (char *buf
)
1170 /* Some day, we should define the meanings of the error codes... */
1179 #ifndef IN_PROCESS_AGENT
1182 outreg (struct regcache
*regcache
, int regno
, char *buf
)
1184 if ((regno
>> 12) != 0)
1185 *buf
++ = tohex ((regno
>> 12) & 0xf);
1186 if ((regno
>> 8) != 0)
1187 *buf
++ = tohex ((regno
>> 8) & 0xf);
1188 *buf
++ = tohex ((regno
>> 4) & 0xf);
1189 *buf
++ = tohex (regno
& 0xf);
1191 collect_register_as_string (regcache
, regno
, buf
);
1192 buf
+= 2 * register_size (regcache
->tdesc
, regno
);
1199 prepare_resume_reply (char *buf
, ptid_t ptid
,
1200 struct target_waitstatus
*status
)
1202 client_state
&cs
= get_client_state ();
1204 debug_printf ("Writing resume reply for %s:%d\n",
1205 target_pid_to_str (ptid
), status
->kind
);
1207 switch (status
->kind
)
1209 case TARGET_WAITKIND_STOPPED
:
1210 case TARGET_WAITKIND_FORKED
:
1211 case TARGET_WAITKIND_VFORKED
:
1212 case TARGET_WAITKIND_VFORK_DONE
:
1213 case TARGET_WAITKIND_EXECD
:
1214 case TARGET_WAITKIND_THREAD_CREATED
:
1215 case TARGET_WAITKIND_SYSCALL_ENTRY
:
1216 case TARGET_WAITKIND_SYSCALL_RETURN
:
1218 struct thread_info
*saved_thread
;
1220 struct regcache
*regcache
;
1222 if ((status
->kind
== TARGET_WAITKIND_FORKED
&& cs
.report_fork_events
)
1223 || (status
->kind
== TARGET_WAITKIND_VFORKED
1224 && cs
.report_vfork_events
))
1226 enum gdb_signal signal
= GDB_SIGNAL_TRAP
;
1227 const char *event
= (status
->kind
== TARGET_WAITKIND_FORKED
1228 ? "fork" : "vfork");
1230 sprintf (buf
, "T%02x%s:", signal
, event
);
1231 buf
+= strlen (buf
);
1232 buf
= write_ptid (buf
, status
->value
.related_pid
);
1235 else if (status
->kind
== TARGET_WAITKIND_VFORK_DONE
1236 && cs
.report_vfork_events
)
1238 enum gdb_signal signal
= GDB_SIGNAL_TRAP
;
1240 sprintf (buf
, "T%02xvforkdone:;", signal
);
1242 else if (status
->kind
== TARGET_WAITKIND_EXECD
&& cs
.report_exec_events
)
1244 enum gdb_signal signal
= GDB_SIGNAL_TRAP
;
1245 const char *event
= "exec";
1246 char hexified_pathname
[PATH_MAX
* 2];
1248 sprintf (buf
, "T%02x%s:", signal
, event
);
1249 buf
+= strlen (buf
);
1251 /* Encode pathname to hexified format. */
1252 bin2hex ((const gdb_byte
*) status
->value
.execd_pathname
,
1254 strlen (status
->value
.execd_pathname
));
1256 sprintf (buf
, "%s;", hexified_pathname
);
1257 xfree (status
->value
.execd_pathname
);
1258 status
->value
.execd_pathname
= NULL
;
1259 buf
+= strlen (buf
);
1261 else if (status
->kind
== TARGET_WAITKIND_THREAD_CREATED
1262 && cs
.report_thread_events
)
1264 enum gdb_signal signal
= GDB_SIGNAL_TRAP
;
1266 sprintf (buf
, "T%02xcreate:;", signal
);
1268 else if (status
->kind
== TARGET_WAITKIND_SYSCALL_ENTRY
1269 || status
->kind
== TARGET_WAITKIND_SYSCALL_RETURN
)
1271 enum gdb_signal signal
= GDB_SIGNAL_TRAP
;
1272 const char *event
= (status
->kind
== TARGET_WAITKIND_SYSCALL_ENTRY
1273 ? "syscall_entry" : "syscall_return");
1275 sprintf (buf
, "T%02x%s:%x;", signal
, event
,
1276 status
->value
.syscall_number
);
1279 sprintf (buf
, "T%02x", status
->value
.sig
);
1281 buf
+= strlen (buf
);
1283 saved_thread
= current_thread
;
1285 switch_to_thread (ptid
);
1287 regp
= current_target_desc ()->expedite_regs
;
1289 regcache
= get_thread_regcache (current_thread
, 1);
1291 if (the_target
->stopped_by_watchpoint
!= NULL
1292 && (*the_target
->stopped_by_watchpoint
) ())
1297 memcpy (buf
, "watch:", 6);
1300 addr
= (*the_target
->stopped_data_address
) ();
1302 /* Convert each byte of the address into two hexadecimal
1303 chars. Note that we take sizeof (void *) instead of
1304 sizeof (addr); this is to avoid sending a 64-bit
1305 address to a 32-bit GDB. */
1306 for (i
= sizeof (void *) * 2; i
> 0; i
--)
1307 *buf
++ = tohex ((addr
>> (i
- 1) * 4) & 0xf);
1310 else if (cs
.swbreak_feature
&& target_stopped_by_sw_breakpoint ())
1312 sprintf (buf
, "swbreak:;");
1313 buf
+= strlen (buf
);
1315 else if (cs
.hwbreak_feature
&& target_stopped_by_hw_breakpoint ())
1317 sprintf (buf
, "hwbreak:;");
1318 buf
+= strlen (buf
);
1323 buf
= outreg (regcache
, find_regno (regcache
->tdesc
, *regp
), buf
);
1328 /* Formerly, if the debugger had not used any thread features
1329 we would not burden it with a thread status response. This
1330 was for the benefit of GDB 4.13 and older. However, in
1331 recent GDB versions the check (``if (cont_thread != 0)'')
1332 does not have the desired effect because of sillyness in
1333 the way that the remote protocol handles specifying a
1334 thread. Since thread support relies on qSymbol support
1335 anyway, assume GDB can handle threads. */
1337 if (using_threads
&& !disable_packet_Tthread
)
1339 /* This if (1) ought to be unnecessary. But remote_wait
1340 in GDB will claim this event belongs to inferior_ptid
1341 if we do not specify a thread, and there's no way for
1342 gdbserver to know what inferior_ptid is. */
1343 if (1 || cs
.general_thread
!= ptid
)
1346 /* In non-stop, don't change the general thread behind
1349 cs
.general_thread
= ptid
;
1350 sprintf (buf
, "thread:");
1351 buf
+= strlen (buf
);
1352 buf
= write_ptid (buf
, ptid
);
1354 buf
+= strlen (buf
);
1356 core
= target_core_of_thread (ptid
);
1360 sprintf (buf
, "core:");
1361 buf
+= strlen (buf
);
1362 sprintf (buf
, "%x", core
);
1364 buf
+= strlen (buf
);
1371 strcpy (buf
, "library:;");
1372 buf
+= strlen (buf
);
1376 current_thread
= saved_thread
;
1379 case TARGET_WAITKIND_EXITED
:
1380 if (cs
.multi_process
)
1381 sprintf (buf
, "W%x;process:%x",
1382 status
->value
.integer
, ptid
.pid ());
1384 sprintf (buf
, "W%02x", status
->value
.integer
);
1386 case TARGET_WAITKIND_SIGNALLED
:
1387 if (cs
.multi_process
)
1388 sprintf (buf
, "X%x;process:%x",
1389 status
->value
.sig
, ptid
.pid ());
1391 sprintf (buf
, "X%02x", status
->value
.sig
);
1393 case TARGET_WAITKIND_THREAD_EXITED
:
1394 sprintf (buf
, "w%x;", status
->value
.integer
);
1395 buf
+= strlen (buf
);
1396 buf
= write_ptid (buf
, ptid
);
1398 case TARGET_WAITKIND_NO_RESUMED
:
1402 error ("unhandled waitkind");
1408 decode_m_packet (char *from
, CORE_ADDR
*mem_addr_ptr
, unsigned int *len_ptr
)
1412 *mem_addr_ptr
= *len_ptr
= 0;
1414 while ((ch
= from
[i
++]) != ',')
1416 *mem_addr_ptr
= *mem_addr_ptr
<< 4;
1417 *mem_addr_ptr
|= fromhex (ch
) & 0x0f;
1420 for (j
= 0; j
< 4; j
++)
1422 if ((ch
= from
[i
++]) == 0)
1424 *len_ptr
= *len_ptr
<< 4;
1425 *len_ptr
|= fromhex (ch
) & 0x0f;
1430 decode_M_packet (char *from
, CORE_ADDR
*mem_addr_ptr
, unsigned int *len_ptr
,
1431 unsigned char **to_p
)
1435 *mem_addr_ptr
= *len_ptr
= 0;
1437 while ((ch
= from
[i
++]) != ',')
1439 *mem_addr_ptr
= *mem_addr_ptr
<< 4;
1440 *mem_addr_ptr
|= fromhex (ch
) & 0x0f;
1443 while ((ch
= from
[i
++]) != ':')
1445 *len_ptr
= *len_ptr
<< 4;
1446 *len_ptr
|= fromhex (ch
) & 0x0f;
1450 *to_p
= (unsigned char *) xmalloc (*len_ptr
);
1452 hex2bin (&from
[i
++], *to_p
, *len_ptr
);
1456 decode_X_packet (char *from
, int packet_len
, CORE_ADDR
*mem_addr_ptr
,
1457 unsigned int *len_ptr
, unsigned char **to_p
)
1461 *mem_addr_ptr
= *len_ptr
= 0;
1463 while ((ch
= from
[i
++]) != ',')
1465 *mem_addr_ptr
= *mem_addr_ptr
<< 4;
1466 *mem_addr_ptr
|= fromhex (ch
) & 0x0f;
1469 while ((ch
= from
[i
++]) != ':')
1471 *len_ptr
= *len_ptr
<< 4;
1472 *len_ptr
|= fromhex (ch
) & 0x0f;
1476 *to_p
= (unsigned char *) xmalloc (*len_ptr
);
1478 if (remote_unescape_input ((const gdb_byte
*) &from
[i
], packet_len
- i
,
1479 *to_p
, *len_ptr
) != *len_ptr
)
1485 /* Decode a qXfer write request. */
1488 decode_xfer_write (char *buf
, int packet_len
, CORE_ADDR
*offset
,
1489 unsigned int *len
, unsigned char *data
)
1494 /* Extract the offset. */
1496 while ((ch
= *buf
++) != ':')
1498 *offset
= *offset
<< 4;
1499 *offset
|= fromhex (ch
) & 0x0f;
1502 /* Get encoded data. */
1503 packet_len
-= buf
- b
;
1504 *len
= remote_unescape_input ((const gdb_byte
*) buf
, packet_len
,
1509 /* Decode the parameters of a qSearch:memory packet. */
1512 decode_search_memory_packet (const char *buf
, int packet_len
,
1513 CORE_ADDR
*start_addrp
,
1514 CORE_ADDR
*search_space_lenp
,
1515 gdb_byte
*pattern
, unsigned int *pattern_lenp
)
1517 const char *p
= buf
;
1519 p
= decode_address_to_semicolon (start_addrp
, p
);
1520 p
= decode_address_to_semicolon (search_space_lenp
, p
);
1521 packet_len
-= p
- buf
;
1522 *pattern_lenp
= remote_unescape_input ((const gdb_byte
*) p
, packet_len
,
1523 pattern
, packet_len
);
1528 free_sym_cache (struct sym_cache
*sym
)
1538 clear_symbol_cache (struct sym_cache
**symcache_p
)
1540 struct sym_cache
*sym
, *next
;
1542 /* Check the cache first. */
1543 for (sym
= *symcache_p
; sym
; sym
= next
)
1546 free_sym_cache (sym
);
1552 /* Get the address of NAME, and return it in ADDRP if found. if
1553 MAY_ASK_GDB is false, assume symbol cache misses are failures.
1554 Returns 1 if the symbol is found, 0 if it is not, -1 on error. */
1557 look_up_one_symbol (const char *name
, CORE_ADDR
*addrp
, int may_ask_gdb
)
1559 client_state
&cs
= get_client_state ();
1562 struct sym_cache
*sym
;
1563 struct process_info
*proc
;
1565 proc
= current_process ();
1567 /* Check the cache first. */
1568 for (sym
= proc
->symbol_cache
; sym
; sym
= sym
->next
)
1569 if (strcmp (name
, sym
->name
) == 0)
1575 /* It might not be an appropriate time to look up a symbol,
1576 e.g. while we're trying to fetch registers. */
1580 /* Send the request. */
1581 strcpy (cs
.own_buf
, "qSymbol:");
1582 bin2hex ((const gdb_byte
*) name
, cs
.own_buf
+ strlen ("qSymbol:"),
1584 if (putpkt (cs
.own_buf
) < 0)
1587 /* FIXME: Eventually add buffer overflow checking (to getpkt?) */
1588 len
= getpkt (cs
.own_buf
);
1592 /* We ought to handle pretty much any packet at this point while we
1593 wait for the qSymbol "response". That requires re-entering the
1594 main loop. For now, this is an adequate approximation; allow
1595 GDB to read from memory and handle 'v' packets (for vFile transfers)
1596 while it figures out the address of the symbol. */
1599 if (cs
.own_buf
[0] == 'm')
1602 unsigned char *mem_buf
;
1603 unsigned int mem_len
;
1605 decode_m_packet (&cs
.own_buf
[1], &mem_addr
, &mem_len
);
1606 mem_buf
= (unsigned char *) xmalloc (mem_len
);
1607 if (read_inferior_memory (mem_addr
, mem_buf
, mem_len
) == 0)
1608 bin2hex (mem_buf
, cs
.own_buf
, mem_len
);
1610 write_enn (cs
.own_buf
);
1612 if (putpkt (cs
.own_buf
) < 0)
1615 else if (cs
.own_buf
[0] == 'v')
1618 handle_v_requests (cs
.own_buf
, len
, &new_len
);
1620 putpkt_binary (cs
.own_buf
, new_len
);
1622 putpkt (cs
.own_buf
);
1626 len
= getpkt (cs
.own_buf
);
1631 if (!startswith (cs
.own_buf
, "qSymbol:"))
1633 warning ("Malformed response to qSymbol, ignoring: %s\n", cs
.own_buf
);
1637 p
= cs
.own_buf
+ strlen ("qSymbol:");
1639 while (*q
&& *q
!= ':')
1642 /* Make sure we found a value for the symbol. */
1643 if (p
== q
|| *q
== '\0')
1646 decode_address (addrp
, p
, q
- p
);
1648 /* Save the symbol in our cache. */
1649 sym
= XNEW (struct sym_cache
);
1650 sym
->name
= xstrdup (name
);
1652 sym
->next
= proc
->symbol_cache
;
1653 proc
->symbol_cache
= sym
;
1658 /* Relocate an instruction to execute at a different address. OLDLOC
1659 is the address in the inferior memory where the instruction to
1660 relocate is currently at. On input, TO points to the destination
1661 where we want the instruction to be copied (and possibly adjusted)
1662 to. On output, it points to one past the end of the resulting
1663 instruction(s). The effect of executing the instruction at TO
1664 shall be the same as if executing it at OLDLOC. For example, call
1665 instructions that implicitly push the return address on the stack
1666 should be adjusted to return to the instruction after OLDLOC;
1667 relative branches, and other PC-relative instructions need the
1668 offset adjusted; etc. Returns 0 on success, -1 on failure. */
1671 relocate_instruction (CORE_ADDR
*to
, CORE_ADDR oldloc
)
1673 client_state
&cs
= get_client_state ();
1675 ULONGEST written
= 0;
1677 /* Send the request. */
1678 sprintf (cs
.own_buf
, "qRelocInsn:%s;%s", paddress (oldloc
),
1680 if (putpkt (cs
.own_buf
) < 0)
1683 /* FIXME: Eventually add buffer overflow checking (to getpkt?) */
1684 len
= getpkt (cs
.own_buf
);
1688 /* We ought to handle pretty much any packet at this point while we
1689 wait for the qRelocInsn "response". That requires re-entering
1690 the main loop. For now, this is an adequate approximation; allow
1691 GDB to access memory. */
1692 while (cs
.own_buf
[0] == 'm' || cs
.own_buf
[0] == 'M' || cs
.own_buf
[0] == 'X')
1695 unsigned char *mem_buf
= NULL
;
1696 unsigned int mem_len
;
1698 if (cs
.own_buf
[0] == 'm')
1700 decode_m_packet (&cs
.own_buf
[1], &mem_addr
, &mem_len
);
1701 mem_buf
= (unsigned char *) xmalloc (mem_len
);
1702 if (read_inferior_memory (mem_addr
, mem_buf
, mem_len
) == 0)
1703 bin2hex (mem_buf
, cs
.own_buf
, mem_len
);
1705 write_enn (cs
.own_buf
);
1707 else if (cs
.own_buf
[0] == 'X')
1709 if (decode_X_packet (&cs
.own_buf
[1], len
- 1, &mem_addr
,
1710 &mem_len
, &mem_buf
) < 0
1711 || write_inferior_memory (mem_addr
, mem_buf
, mem_len
) != 0)
1712 write_enn (cs
.own_buf
);
1714 write_ok (cs
.own_buf
);
1718 decode_M_packet (&cs
.own_buf
[1], &mem_addr
, &mem_len
, &mem_buf
);
1719 if (write_inferior_memory (mem_addr
, mem_buf
, mem_len
) == 0)
1720 write_ok (cs
.own_buf
);
1722 write_enn (cs
.own_buf
);
1725 if (putpkt (cs
.own_buf
) < 0)
1727 len
= getpkt (cs
.own_buf
);
1732 if (cs
.own_buf
[0] == 'E')
1734 warning ("An error occurred while relocating an instruction: %s\n",
1739 if (!startswith (cs
.own_buf
, "qRelocInsn:"))
1741 warning ("Malformed response to qRelocInsn, ignoring: %s\n",
1746 unpack_varlen_hex (cs
.own_buf
+ strlen ("qRelocInsn:"), &written
);
1753 monitor_output (const char *msg
)
1755 int len
= strlen (msg
);
1756 char *buf
= (char *) xmalloc (len
* 2 + 2);
1759 bin2hex ((const gdb_byte
*) msg
, buf
+ 1, len
);