1 /* Remote utility routines for the remote server for GDB.
2 Copyright (C) 1986-2017 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/>. */
20 #include "gdb_termios.h"
22 #include "gdbthread.h"
28 #include <sys/ioctl.h>
34 #include <netinet/in.h>
37 #include <sys/socket.h>
42 #if HAVE_NETINET_TCP_H
43 #include <netinet/tcp.h>
46 #include <sys/ioctl.h>
54 #include "gdb_sys_time.h"
57 #include <arpa/inet.h>
66 #include <sys/iomgr.h>
69 #ifndef HAVE_SOCKLEN_T
70 typedef int socklen_t;
73 #ifndef IN_PROCESS_AGENT
76 # define INVALID_DESCRIPTOR INVALID_SOCKET
78 # define INVALID_DESCRIPTOR -1
81 /* Extra value for readchar_callback. */
83 /* The callback is currently not scheduled. */
87 /* Status of the readchar callback.
88 Either NOT_SCHEDULED or the callback id. */
89 static int readchar_callback = NOT_SCHEDULED;
91 static int readchar (void);
92 static void reset_readchar (void);
93 static void reschedule (void);
95 /* A cache entry for a successfully looked-up symbol. */
100 struct sym_cache *next;
103 int remote_debug = 0;
104 struct ui_file *gdb_stdlog;
106 static int remote_is_stdio = 0;
108 static gdb_fildes_t remote_desc = INVALID_DESCRIPTOR;
109 static gdb_fildes_t listen_desc = INVALID_DESCRIPTOR;
111 /* FIXME headerize? */
112 extern int using_threads;
113 extern int debug_threads;
115 /* If true, then GDB has requested noack mode. */
117 /* If true, then we tell GDB to use noack mode by default. */
118 int transport_is_reliable = 0;
121 # define read(fd, buf, len) recv (fd, (char *) buf, len, 0)
122 # define write(fd, buf, len) send (fd, (char *) buf, len, 0)
128 return remote_desc != INVALID_DESCRIPTOR;
131 /* Return true if the remote connection is over stdio. */
134 remote_connection_is_stdio (void)
136 return remote_is_stdio;
140 enable_async_notification (int fd)
142 #if defined(F_SETFL) && defined (FASYNC)
143 int save_fcntl_flags;
145 save_fcntl_flags = fcntl (fd, F_GETFL, 0);
146 fcntl (fd, F_SETFL, save_fcntl_flags | FASYNC);
147 #if defined (F_SETOWN)
148 fcntl (fd, F_SETOWN, getpid ());
154 handle_accept_event (int err, gdb_client_data client_data)
156 struct sockaddr_in sockaddr;
160 debug_printf ("handling possible accept event\n");
162 tmp = sizeof (sockaddr);
163 remote_desc = accept (listen_desc, (struct sockaddr *) &sockaddr, &tmp);
164 if (remote_desc == -1)
165 perror_with_name ("Accept failed");
167 /* Enable TCP keep alive process. */
169 setsockopt (remote_desc, SOL_SOCKET, SO_KEEPALIVE,
170 (char *) &tmp, sizeof (tmp));
172 /* Tell TCP not to delay small packets. This greatly speeds up
173 interactive response. */
175 setsockopt (remote_desc, IPPROTO_TCP, TCP_NODELAY,
176 (char *) &tmp, sizeof (tmp));
179 signal (SIGPIPE, SIG_IGN); /* If we don't do this, then gdbserver simply
180 exits when the remote side dies. */
186 close (listen_desc); /* No longer need this */
188 closesocket (listen_desc); /* No longer need this */
192 /* Even if !RUN_ONCE no longer notice new connections. Still keep the
193 descriptor open for add_file_handler to wait for a new connection. */
194 delete_file_handler (listen_desc);
196 /* Convert IP address to string. */
197 fprintf (stderr, "Remote debugging from host %s\n",
198 inet_ntoa (sockaddr.sin_addr));
200 enable_async_notification (remote_desc);
202 /* Register the event loop handler. */
203 add_file_handler (remote_desc, handle_serial_event, NULL);
205 /* We have a new GDB connection now. If we were disconnected
206 tracing, there's a window where the target could report a stop
207 event to the event loop, and since we have a connection now, we'd
208 try to send vStopped notifications to GDB. But, don't do that
209 until GDB as selected all-stop/non-stop, and has queried the
210 threads' status ('?'). */
216 /* Prepare for a later connection to a remote debugger.
217 NAME is the filename used for communication. */
220 remote_prepare (const char *name)
222 const char *port_str;
224 static int winsock_initialized;
227 struct sockaddr_in sockaddr;
232 if (strcmp (name, STDIO_CONNECTION_NAME) == 0)
234 /* We need to record fact that we're using stdio sooner than the
235 call to remote_open so start_inferior knows the connection is
238 transport_is_reliable = 1;
242 port_str = strchr (name, ':');
243 if (port_str == NULL)
245 transport_is_reliable = 0;
249 port = strtoul (port_str + 1, &port_end, 10);
250 if (port_str[1] == '\0' || *port_end != '\0')
251 error ("Bad port argument: %s", name);
254 if (!winsock_initialized)
258 WSAStartup (MAKEWORD (1, 0), &wsad);
259 winsock_initialized = 1;
263 listen_desc = socket (PF_INET, SOCK_STREAM, IPPROTO_TCP);
264 if (listen_desc == -1)
265 perror_with_name ("Can't open socket");
267 /* Allow rapid reuse of this port. */
269 setsockopt (listen_desc, SOL_SOCKET, SO_REUSEADDR, (char *) &tmp,
272 sockaddr.sin_family = PF_INET;
273 sockaddr.sin_port = htons (port);
274 sockaddr.sin_addr.s_addr = INADDR_ANY;
276 if (bind (listen_desc, (struct sockaddr *) &sockaddr, sizeof (sockaddr))
277 || listen (listen_desc, 1))
278 perror_with_name ("Can't bind address");
280 transport_is_reliable = 1;
283 /* Open a connection to a remote debugger.
284 NAME is the filename used for communication. */
287 remote_open (const char *name)
289 const char *port_str;
291 port_str = strchr (name, ':');
293 if (port_str == NULL)
294 error ("Only <host>:<port> is supported on this platform.");
297 if (strcmp (name, STDIO_CONNECTION_NAME) == 0)
299 fprintf (stderr, "Remote debugging using stdio\n");
301 /* Use stdin as the handle of the connection.
302 We only select on reads, for example. */
303 remote_desc = fileno (stdin);
305 enable_async_notification (remote_desc);
307 /* Register the event loop handler. */
308 add_file_handler (remote_desc, handle_serial_event, NULL);
311 else if (port_str == NULL)
315 if (stat (name, &statbuf) == 0
316 && (S_ISCHR (statbuf.st_mode) || S_ISFIFO (statbuf.st_mode)))
317 remote_desc = open (name, O_RDWR);
325 perror_with_name ("Could not open remote device");
329 struct termios termios;
330 tcgetattr (remote_desc, &termios);
335 termios.c_cflag &= ~(CSIZE | PARENB);
336 termios.c_cflag |= CLOCAL | CS8;
337 termios.c_cc[VMIN] = 1;
338 termios.c_cc[VTIME] = 0;
340 tcsetattr (remote_desc, TCSANOW, &termios);
346 struct termio termio;
347 ioctl (remote_desc, TCGETA, &termio);
352 termio.c_cflag &= ~(CSIZE | PARENB);
353 termio.c_cflag |= CLOCAL | CS8;
354 termio.c_cc[VMIN] = 1;
355 termio.c_cc[VTIME] = 0;
357 ioctl (remote_desc, TCSETA, &termio);
365 ioctl (remote_desc, TIOCGETP, &sg);
367 ioctl (remote_desc, TIOCSETP, &sg);
371 fprintf (stderr, "Remote debugging using %s\n", name);
373 enable_async_notification (remote_desc);
375 /* Register the event loop handler. */
376 add_file_handler (remote_desc, handle_serial_event, NULL);
378 #endif /* USE_WIN32API */
383 struct sockaddr_in sockaddr;
385 len = sizeof (sockaddr);
386 if (getsockname (listen_desc,
387 (struct sockaddr *) &sockaddr, &len) < 0
388 || len < sizeof (sockaddr))
389 perror_with_name ("Can't determine port");
390 port = ntohs (sockaddr.sin_port);
392 fprintf (stderr, "Listening on port %d\n", port);
395 /* Register the event loop handler. */
396 add_file_handler (listen_desc, handle_accept_event, NULL);
403 delete_file_handler (remote_desc);
406 /* Remove SIGIO handler. */
407 signal (SIGIO, SIG_IGN);
411 closesocket (remote_desc);
413 if (! remote_connection_is_stdio ())
416 remote_desc = INVALID_DESCRIPTOR;
423 #ifndef IN_PROCESS_AGENT
426 decode_address (CORE_ADDR *addrp, const char *start, int len)
433 for (i = 0; i < len; i++)
437 addr = addr | (fromhex (ch) & 0x0f);
443 decode_address_to_semicolon (CORE_ADDR *addrp, const char *start)
448 while (*end != '\0' && *end != ';')
451 decode_address (addrp, start, end - start);
460 #ifndef IN_PROCESS_AGENT
462 /* Look for a sequence of characters which can be run-length encoded.
463 If there are any, update *CSUM and *P. Otherwise, output the
464 single character. Return the number of characters consumed. */
467 try_rle (char *buf, int remaining, unsigned char *csum, char **p)
471 /* Always output the character. */
475 /* Don't go past '~'. */
479 for (n = 1; n < remaining; n++)
480 if (buf[n] != buf[0])
483 /* N is the index of the first character not the same as buf[0].
484 buf[0] is counted twice, so by decrementing N, we get the number
485 of characters the RLE sequence will replace. */
491 /* Skip the frame characters. The manual says to skip '+' and '-'
492 also, but there's no reason to. Unfortunately these two unusable
493 characters double the encoded length of a four byte zero
495 while (n + 29 == '$' || n + 29 == '#')
508 #ifndef IN_PROCESS_AGENT
510 /* Write a PTID to BUF. Returns BUF+CHARACTERS_WRITTEN. */
513 write_ptid (char *buf, ptid_t ptid)
519 pid = ptid_get_pid (ptid);
521 buf += sprintf (buf, "p-%x.", -pid);
523 buf += sprintf (buf, "p%x.", pid);
525 tid = ptid_get_lwp (ptid);
527 buf += sprintf (buf, "-%x", -tid);
529 buf += sprintf (buf, "%x", tid);
535 hex_or_minus_one (char *buf, char **obuf)
539 if (startswith (buf, "-1"))
545 buf = unpack_varlen_hex (buf, &ret);
553 /* Extract a PTID from BUF. If non-null, OBUF is set to the to one
554 passed the last parsed char. Returns null_ptid on error. */
556 read_ptid (char *buf, char **obuf)
560 ULONGEST pid = 0, tid = 0;
564 /* Multi-process ptid. */
565 pp = unpack_varlen_hex (p + 1, &pid);
567 error ("invalid remote ptid: %s\n", p);
571 tid = hex_or_minus_one (p, &pp);
575 return ptid_build (pid, tid, 0);
578 /* No multi-process. Just a tid. */
579 tid = hex_or_minus_one (p, &pp);
581 /* Since GDB is not sending a process id (multi-process extensions
582 are off), then there's only one process. Default to the first in
584 pid = pid_of (get_first_process ());
588 return ptid_build (pid, tid, 0);
591 /* Write COUNT bytes in BUF to the client.
592 The result is the number of bytes written or -1 if error.
593 This may return less than COUNT. */
596 write_prim (const void *buf, int count)
598 if (remote_connection_is_stdio ())
599 return write (fileno (stdout), buf, count);
601 return write (remote_desc, buf, count);
604 /* Read COUNT bytes from the client and store in BUF.
605 The result is the number of bytes read or -1 if error.
606 This may return less than COUNT. */
609 read_prim (void *buf, int count)
611 if (remote_connection_is_stdio ())
612 return read (fileno (stdin), buf, count);
614 return read (remote_desc, buf, count);
617 /* Send a packet to the remote machine, with error checking.
618 The data of the packet is in BUF, and the length of the
619 packet is in CNT. Returns >= 0 on success, -1 otherwise. */
622 putpkt_binary_1 (char *buf, int cnt, int is_notif)
625 unsigned char csum = 0;
630 buf2 = (char *) xmalloc (strlen ("$") + cnt + strlen ("#nn") + 1);
632 /* Copy the packet into buffer BUF2, encapsulating it
633 and giving it a checksum. */
641 for (i = 0; i < cnt;)
642 i += try_rle (buf + i, cnt - i, &csum, &p);
645 *p++ = tohex ((csum >> 4) & 0xf);
646 *p++ = tohex (csum & 0xf);
650 /* Send it over and over until we get a positive ack. */
654 if (write_prim (buf2, p - buf2) != p - buf2)
656 perror ("putpkt(write)");
661 if (noack_mode || is_notif)
663 /* Don't expect an ack then. */
667 debug_printf ("putpkt (\"%s\"); [notif]\n", buf2);
669 debug_printf ("putpkt (\"%s\"); [noack mode]\n", buf2);
677 debug_printf ("putpkt (\"%s\"); [looking for ack]\n", buf2);
691 debug_printf ("[received '%c' (0x%x)]\n", cc, cc);
695 /* Check for an input interrupt while we're here. */
696 if (cc == '\003' && current_thread != NULL)
697 (*the_target->request_interrupt) ();
702 return 1; /* Success! */
706 putpkt_binary (char *buf, int cnt)
708 return putpkt_binary_1 (buf, cnt, 0);
711 /* Send a packet to the remote machine, with error checking. The data
712 of the packet is in BUF, and the packet should be a NUL-terminated
713 string. Returns >= 0 on success, -1 otherwise. */
718 return putpkt_binary (buf, strlen (buf));
722 putpkt_notif (char *buf)
724 return putpkt_binary_1 (buf, strlen (buf), 1);
727 /* Come here when we get an input interrupt from the remote side. This
728 interrupt should only be active while we are waiting for the child to do
729 something. Thus this assumes readchar:bufcnt is 0.
730 About the only thing that should come through is a ^C, which
731 will cause us to request child interruption. */
734 input_interrupt (int unused)
737 struct timeval immediate = { 0, 0 };
739 /* Protect against spurious interrupts. This has been observed to
740 be a problem under NetBSD 1.4 and 1.5. */
743 FD_SET (remote_desc, &readset);
744 if (select (remote_desc + 1, &readset, 0, 0, &immediate) > 0)
749 cc = read_prim (&c, 1);
753 fprintf (stderr, "client connection closed\n");
756 else if (cc != 1 || c != '\003')
758 fprintf (stderr, "input_interrupt, count = %d c = %d ", cc, c);
760 fprintf (stderr, "('%c')\n", c);
762 fprintf (stderr, "('\\x%02x')\n", c & 0xff);
766 (*the_target->request_interrupt) ();
770 /* Check if the remote side sent us an interrupt request (^C). */
772 check_remote_input_interrupt_request (void)
774 /* This function may be called before establishing communications,
775 therefore we need to validate the remote descriptor. */
777 if (remote_desc == INVALID_DESCRIPTOR)
783 /* Asynchronous I/O support. SIGIO must be unblocked when waiting,
784 in order to accept Control-C from the client, and must be blocked
785 when talking to the client. */
788 block_unblock_async_io (int block)
793 sigemptyset (&sigio_set);
794 sigaddset (&sigio_set, SIGIO);
795 sigprocmask (block ? SIG_BLOCK : SIG_UNBLOCK, &sigio_set, NULL);
801 nto_comctrl (int enable)
803 struct sigevent event;
807 event.sigev_notify = SIGEV_SIGNAL_THREAD;
808 event.sigev_signo = SIGIO;
809 event.sigev_code = 0;
810 event.sigev_value.sival_ptr = NULL;
811 event.sigev_priority = -1;
812 ionotify (remote_desc, _NOTIFY_ACTION_POLLARM, _NOTIFY_COND_INPUT,
816 ionotify (remote_desc, _NOTIFY_ACTION_POLL, _NOTIFY_COND_INPUT, NULL);
821 /* Current state of asynchronous I/O. */
822 static int async_io_enabled;
824 /* Enable asynchronous I/O. */
826 enable_async_io (void)
828 if (async_io_enabled)
831 block_unblock_async_io (0);
833 async_io_enabled = 1;
839 /* Disable asynchronous I/O. */
841 disable_async_io (void)
843 if (!async_io_enabled)
846 block_unblock_async_io (1);
848 async_io_enabled = 0;
856 initialize_async_io (void)
858 /* Make sure that async I/O starts blocked. */
859 async_io_enabled = 1;
862 /* Install the signal handler. */
864 signal (SIGIO, input_interrupt);
868 /* Internal buffer used by readchar.
869 These are global to readchar because reschedule_remote needs to be
870 able to tell whether the buffer is empty. */
872 static unsigned char readchar_buf[BUFSIZ];
873 static int readchar_bufcnt = 0;
874 static unsigned char *readchar_bufp;
876 /* Returns next char from remote GDB. -1 if error. */
883 if (readchar_bufcnt == 0)
885 readchar_bufcnt = read_prim (readchar_buf, sizeof (readchar_buf));
887 if (readchar_bufcnt <= 0)
889 if (readchar_bufcnt == 0)
892 debug_printf ("readchar: Got EOF\n");
900 readchar_bufp = readchar_buf;
904 ch = *readchar_bufp++;
909 /* Reset the readchar state machine. */
912 reset_readchar (void)
915 if (readchar_callback != NOT_SCHEDULED)
917 delete_callback_event (readchar_callback);
918 readchar_callback = NOT_SCHEDULED;
922 /* Process remaining data in readchar_buf. */
925 process_remaining (void *context)
929 /* This is a one-shot event. */
930 readchar_callback = NOT_SCHEDULED;
932 if (readchar_bufcnt > 0)
933 res = handle_serial_event (0, NULL);
940 /* If there is still data in the buffer, queue another event to process it,
941 we can't sleep in select yet. */
946 if (readchar_bufcnt > 0 && readchar_callback == NOT_SCHEDULED)
947 readchar_callback = append_callback_event (process_remaining, NULL);
950 /* Read a packet from the remote machine, with error checking,
951 and store it in BUF. Returns length of packet, or negative if error. */
957 unsigned char csum, c1, c2;
968 /* The '\003' may appear before or after each packet, so
969 check for an input interrupt. */
972 (*the_target->request_interrupt) ();
980 debug_printf ("[getpkt: discarding char '%c']\n", c);
1001 c1 = fromhex (readchar ());
1002 c2 = fromhex (readchar ());
1004 if (csum == (c1 << 4) + c2)
1010 "Bad checksum, sentsum=0x%x, csum=0x%x, "
1011 "buf=%s [no-ack-mode, Bad medium?]\n",
1012 (c1 << 4) + c2, csum, buf);
1013 /* Not much we can do, GDB wasn't expecting an ack/nac. */
1017 fprintf (stderr, "Bad checksum, sentsum=0x%x, csum=0x%x, buf=%s\n",
1018 (c1 << 4) + c2, csum, buf);
1019 if (write_prim ("-", 1) != 1)
1027 debug_printf ("getpkt (\"%s\"); [sending ack] \n", buf);
1031 if (write_prim ("+", 1) != 1)
1036 debug_printf ("[sent ack]\n");
1044 debug_printf ("getpkt (\"%s\"); [no ack sent] \n", buf);
1049 /* The readchar above may have already read a '\003' out of the socket
1050 and moved it to the local buffer. For example, when GDB sends
1051 vCont;c immediately followed by interrupt (see
1052 gdb.base/interrupt-noterm.exp). As soon as we see the vCont;c, we'll
1053 resume the inferior and wait. Since we've already moved the '\003'
1054 to the local buffer, SIGIO won't help. In that case, if we don't
1055 check for interrupt after the vCont;c packet, the interrupt character
1056 would stay in the buffer unattended until after the next (unrelated)
1058 while (readchar_bufcnt > 0 && *readchar_bufp == '\003')
1060 /* Consume the interrupt character in the buffer. */
1062 (*the_target->request_interrupt) ();
1069 write_ok (char *buf)
1077 write_enn (char *buf)
1079 /* Some day, we should define the meanings of the error codes... */
1088 #ifndef IN_PROCESS_AGENT
1091 outreg (struct regcache *regcache, int regno, char *buf)
1093 if ((regno >> 12) != 0)
1094 *buf++ = tohex ((regno >> 12) & 0xf);
1095 if ((regno >> 8) != 0)
1096 *buf++ = tohex ((regno >> 8) & 0xf);
1097 *buf++ = tohex ((regno >> 4) & 0xf);
1098 *buf++ = tohex (regno & 0xf);
1100 collect_register_as_string (regcache, regno, buf);
1101 buf += 2 * register_size (regcache->tdesc, regno);
1108 prepare_resume_reply (char *buf, ptid_t ptid,
1109 struct target_waitstatus *status)
1112 debug_printf ("Writing resume reply for %s:%d\n",
1113 target_pid_to_str (ptid), status->kind);
1115 switch (status->kind)
1117 case TARGET_WAITKIND_STOPPED:
1118 case TARGET_WAITKIND_FORKED:
1119 case TARGET_WAITKIND_VFORKED:
1120 case TARGET_WAITKIND_VFORK_DONE:
1121 case TARGET_WAITKIND_EXECD:
1122 case TARGET_WAITKIND_THREAD_CREATED:
1123 case TARGET_WAITKIND_SYSCALL_ENTRY:
1124 case TARGET_WAITKIND_SYSCALL_RETURN:
1126 struct thread_info *saved_thread;
1128 struct regcache *regcache;
1130 if ((status->kind == TARGET_WAITKIND_FORKED && report_fork_events)
1131 || (status->kind == TARGET_WAITKIND_VFORKED && report_vfork_events))
1133 enum gdb_signal signal = GDB_SIGNAL_TRAP;
1134 const char *event = (status->kind == TARGET_WAITKIND_FORKED
1135 ? "fork" : "vfork");
1137 sprintf (buf, "T%02x%s:", signal, event);
1138 buf += strlen (buf);
1139 buf = write_ptid (buf, status->value.related_pid);
1142 else if (status->kind == TARGET_WAITKIND_VFORK_DONE && report_vfork_events)
1144 enum gdb_signal signal = GDB_SIGNAL_TRAP;
1146 sprintf (buf, "T%02xvforkdone:;", signal);
1148 else if (status->kind == TARGET_WAITKIND_EXECD && report_exec_events)
1150 enum gdb_signal signal = GDB_SIGNAL_TRAP;
1151 const char *event = "exec";
1152 char hexified_pathname[PATH_MAX * 2];
1154 sprintf (buf, "T%02x%s:", signal, event);
1155 buf += strlen (buf);
1157 /* Encode pathname to hexified format. */
1158 bin2hex ((const gdb_byte *) status->value.execd_pathname,
1160 strlen (status->value.execd_pathname));
1162 sprintf (buf, "%s;", hexified_pathname);
1163 xfree (status->value.execd_pathname);
1164 status->value.execd_pathname = NULL;
1165 buf += strlen (buf);
1167 else if (status->kind == TARGET_WAITKIND_THREAD_CREATED
1168 && report_thread_events)
1170 enum gdb_signal signal = GDB_SIGNAL_TRAP;
1172 sprintf (buf, "T%02xcreate:;", signal);
1174 else if (status->kind == TARGET_WAITKIND_SYSCALL_ENTRY
1175 || status->kind == TARGET_WAITKIND_SYSCALL_RETURN)
1177 enum gdb_signal signal = GDB_SIGNAL_TRAP;
1178 const char *event = (status->kind == TARGET_WAITKIND_SYSCALL_ENTRY
1179 ? "syscall_entry" : "syscall_return");
1181 sprintf (buf, "T%02x%s:%x;", signal, event,
1182 status->value.syscall_number);
1185 sprintf (buf, "T%02x", status->value.sig);
1187 buf += strlen (buf);
1189 saved_thread = current_thread;
1191 current_thread = find_thread_ptid (ptid);
1193 regp = current_target_desc ()->expedite_regs;
1195 regcache = get_thread_regcache (current_thread, 1);
1197 if (the_target->stopped_by_watchpoint != NULL
1198 && (*the_target->stopped_by_watchpoint) ())
1203 strncpy (buf, "watch:", 6);
1206 addr = (*the_target->stopped_data_address) ();
1208 /* Convert each byte of the address into two hexadecimal
1209 chars. Note that we take sizeof (void *) instead of
1210 sizeof (addr); this is to avoid sending a 64-bit
1211 address to a 32-bit GDB. */
1212 for (i = sizeof (void *) * 2; i > 0; i--)
1213 *buf++ = tohex ((addr >> (i - 1) * 4) & 0xf);
1216 else if (swbreak_feature && target_stopped_by_sw_breakpoint ())
1218 sprintf (buf, "swbreak:;");
1219 buf += strlen (buf);
1221 else if (hwbreak_feature && target_stopped_by_hw_breakpoint ())
1223 sprintf (buf, "hwbreak:;");
1224 buf += strlen (buf);
1229 buf = outreg (regcache, find_regno (regcache->tdesc, *regp), buf);
1234 /* Formerly, if the debugger had not used any thread features
1235 we would not burden it with a thread status response. This
1236 was for the benefit of GDB 4.13 and older. However, in
1237 recent GDB versions the check (``if (cont_thread != 0)'')
1238 does not have the desired effect because of sillyness in
1239 the way that the remote protocol handles specifying a
1240 thread. Since thread support relies on qSymbol support
1241 anyway, assume GDB can handle threads. */
1243 if (using_threads && !disable_packet_Tthread)
1245 /* This if (1) ought to be unnecessary. But remote_wait
1246 in GDB will claim this event belongs to inferior_ptid
1247 if we do not specify a thread, and there's no way for
1248 gdbserver to know what inferior_ptid is. */
1249 if (1 || !ptid_equal (general_thread, ptid))
1252 /* In non-stop, don't change the general thread behind
1255 general_thread = ptid;
1256 sprintf (buf, "thread:");
1257 buf += strlen (buf);
1258 buf = write_ptid (buf, ptid);
1260 buf += strlen (buf);
1262 core = target_core_of_thread (ptid);
1266 sprintf (buf, "core:");
1267 buf += strlen (buf);
1268 sprintf (buf, "%x", core);
1270 buf += strlen (buf);
1277 strcpy (buf, "library:;");
1278 buf += strlen (buf);
1282 current_thread = saved_thread;
1285 case TARGET_WAITKIND_EXITED:
1287 sprintf (buf, "W%x;process:%x",
1288 status->value.integer, ptid_get_pid (ptid));
1290 sprintf (buf, "W%02x", status->value.integer);
1292 case TARGET_WAITKIND_SIGNALLED:
1294 sprintf (buf, "X%x;process:%x",
1295 status->value.sig, ptid_get_pid (ptid));
1297 sprintf (buf, "X%02x", status->value.sig);
1299 case TARGET_WAITKIND_THREAD_EXITED:
1300 sprintf (buf, "w%x;", status->value.integer);
1301 buf += strlen (buf);
1302 buf = write_ptid (buf, ptid);
1304 case TARGET_WAITKIND_NO_RESUMED:
1308 error ("unhandled waitkind");
1314 decode_m_packet (char *from, CORE_ADDR *mem_addr_ptr, unsigned int *len_ptr)
1318 *mem_addr_ptr = *len_ptr = 0;
1320 while ((ch = from[i++]) != ',')
1322 *mem_addr_ptr = *mem_addr_ptr << 4;
1323 *mem_addr_ptr |= fromhex (ch) & 0x0f;
1326 for (j = 0; j < 4; j++)
1328 if ((ch = from[i++]) == 0)
1330 *len_ptr = *len_ptr << 4;
1331 *len_ptr |= fromhex (ch) & 0x0f;
1336 decode_M_packet (char *from, CORE_ADDR *mem_addr_ptr, unsigned int *len_ptr,
1337 unsigned char **to_p)
1341 *mem_addr_ptr = *len_ptr = 0;
1343 while ((ch = from[i++]) != ',')
1345 *mem_addr_ptr = *mem_addr_ptr << 4;
1346 *mem_addr_ptr |= fromhex (ch) & 0x0f;
1349 while ((ch = from[i++]) != ':')
1351 *len_ptr = *len_ptr << 4;
1352 *len_ptr |= fromhex (ch) & 0x0f;
1356 *to_p = (unsigned char *) xmalloc (*len_ptr);
1358 hex2bin (&from[i++], *to_p, *len_ptr);
1362 decode_X_packet (char *from, int packet_len, CORE_ADDR *mem_addr_ptr,
1363 unsigned int *len_ptr, unsigned char **to_p)
1367 *mem_addr_ptr = *len_ptr = 0;
1369 while ((ch = from[i++]) != ',')
1371 *mem_addr_ptr = *mem_addr_ptr << 4;
1372 *mem_addr_ptr |= fromhex (ch) & 0x0f;
1375 while ((ch = from[i++]) != ':')
1377 *len_ptr = *len_ptr << 4;
1378 *len_ptr |= fromhex (ch) & 0x0f;
1382 *to_p = (unsigned char *) xmalloc (*len_ptr);
1384 if (remote_unescape_input ((const gdb_byte *) &from[i], packet_len - i,
1385 *to_p, *len_ptr) != *len_ptr)
1391 /* Decode a qXfer write request. */
1394 decode_xfer_write (char *buf, int packet_len, CORE_ADDR *offset,
1395 unsigned int *len, unsigned char *data)
1400 /* Extract the offset. */
1402 while ((ch = *buf++) != ':')
1404 *offset = *offset << 4;
1405 *offset |= fromhex (ch) & 0x0f;
1408 /* Get encoded data. */
1409 packet_len -= buf - b;
1410 *len = remote_unescape_input ((const gdb_byte *) buf, packet_len,
1415 /* Decode the parameters of a qSearch:memory packet. */
1418 decode_search_memory_packet (const char *buf, int packet_len,
1419 CORE_ADDR *start_addrp,
1420 CORE_ADDR *search_space_lenp,
1421 gdb_byte *pattern, unsigned int *pattern_lenp)
1423 const char *p = buf;
1425 p = decode_address_to_semicolon (start_addrp, p);
1426 p = decode_address_to_semicolon (search_space_lenp, p);
1427 packet_len -= p - buf;
1428 *pattern_lenp = remote_unescape_input ((const gdb_byte *) p, packet_len,
1429 pattern, packet_len);
1434 free_sym_cache (struct sym_cache *sym)
1444 clear_symbol_cache (struct sym_cache **symcache_p)
1446 struct sym_cache *sym, *next;
1448 /* Check the cache first. */
1449 for (sym = *symcache_p; sym; sym = next)
1452 free_sym_cache (sym);
1458 /* Get the address of NAME, and return it in ADDRP if found. if
1459 MAY_ASK_GDB is false, assume symbol cache misses are failures.
1460 Returns 1 if the symbol is found, 0 if it is not, -1 on error. */
1463 look_up_one_symbol (const char *name, CORE_ADDR *addrp, int may_ask_gdb)
1467 struct sym_cache *sym;
1468 struct process_info *proc;
1470 proc = current_process ();
1472 /* Check the cache first. */
1473 for (sym = proc->symbol_cache; sym; sym = sym->next)
1474 if (strcmp (name, sym->name) == 0)
1480 /* It might not be an appropriate time to look up a symbol,
1481 e.g. while we're trying to fetch registers. */
1485 /* Send the request. */
1486 strcpy (own_buf, "qSymbol:");
1487 bin2hex ((const gdb_byte *) name, own_buf + strlen ("qSymbol:"),
1489 if (putpkt (own_buf) < 0)
1492 /* FIXME: Eventually add buffer overflow checking (to getpkt?) */
1493 len = getpkt (own_buf);
1497 /* We ought to handle pretty much any packet at this point while we
1498 wait for the qSymbol "response". That requires re-entering the
1499 main loop. For now, this is an adequate approximation; allow
1500 GDB to read from memory and handle 'v' packets (for vFile transfers)
1501 while it figures out the address of the symbol. */
1504 if (own_buf[0] == 'm')
1507 unsigned char *mem_buf;
1508 unsigned int mem_len;
1510 decode_m_packet (&own_buf[1], &mem_addr, &mem_len);
1511 mem_buf = (unsigned char *) xmalloc (mem_len);
1512 if (read_inferior_memory (mem_addr, mem_buf, mem_len) == 0)
1513 bin2hex (mem_buf, own_buf, mem_len);
1515 write_enn (own_buf);
1517 if (putpkt (own_buf) < 0)
1520 else if (own_buf[0] == 'v')
1523 handle_v_requests (own_buf, len, &new_len);
1525 putpkt_binary (own_buf, new_len);
1531 len = getpkt (own_buf);
1536 if (!startswith (own_buf, "qSymbol:"))
1538 warning ("Malformed response to qSymbol, ignoring: %s\n", own_buf);
1542 p = own_buf + strlen ("qSymbol:");
1544 while (*q && *q != ':')
1547 /* Make sure we found a value for the symbol. */
1548 if (p == q || *q == '\0')
1551 decode_address (addrp, p, q - p);
1553 /* Save the symbol in our cache. */
1554 sym = XNEW (struct sym_cache);
1555 sym->name = xstrdup (name);
1557 sym->next = proc->symbol_cache;
1558 proc->symbol_cache = sym;
1563 /* Relocate an instruction to execute at a different address. OLDLOC
1564 is the address in the inferior memory where the instruction to
1565 relocate is currently at. On input, TO points to the destination
1566 where we want the instruction to be copied (and possibly adjusted)
1567 to. On output, it points to one past the end of the resulting
1568 instruction(s). The effect of executing the instruction at TO
1569 shall be the same as if executing it at OLDLOC. For example, call
1570 instructions that implicitly push the return address on the stack
1571 should be adjusted to return to the instruction after OLDLOC;
1572 relative branches, and other PC-relative instructions need the
1573 offset adjusted; etc. Returns 0 on success, -1 on failure. */
1576 relocate_instruction (CORE_ADDR *to, CORE_ADDR oldloc)
1579 ULONGEST written = 0;
1581 /* Send the request. */
1582 sprintf (own_buf, "qRelocInsn:%s;%s", paddress (oldloc),
1584 if (putpkt (own_buf) < 0)
1587 /* FIXME: Eventually add buffer overflow checking (to getpkt?) */
1588 len = getpkt (own_buf);
1592 /* We ought to handle pretty much any packet at this point while we
1593 wait for the qRelocInsn "response". That requires re-entering
1594 the main loop. For now, this is an adequate approximation; allow
1595 GDB to access memory. */
1596 while (own_buf[0] == 'm' || own_buf[0] == 'M' || own_buf[0] == 'X')
1599 unsigned char *mem_buf = NULL;
1600 unsigned int mem_len;
1602 if (own_buf[0] == 'm')
1604 decode_m_packet (&own_buf[1], &mem_addr, &mem_len);
1605 mem_buf = (unsigned char *) xmalloc (mem_len);
1606 if (read_inferior_memory (mem_addr, mem_buf, mem_len) == 0)
1607 bin2hex (mem_buf, own_buf, mem_len);
1609 write_enn (own_buf);
1611 else if (own_buf[0] == 'X')
1613 if (decode_X_packet (&own_buf[1], len - 1, &mem_addr,
1614 &mem_len, &mem_buf) < 0
1615 || write_inferior_memory (mem_addr, mem_buf, mem_len) != 0)
1616 write_enn (own_buf);
1622 decode_M_packet (&own_buf[1], &mem_addr, &mem_len, &mem_buf);
1623 if (write_inferior_memory (mem_addr, mem_buf, mem_len) == 0)
1626 write_enn (own_buf);
1629 if (putpkt (own_buf) < 0)
1631 len = getpkt (own_buf);
1636 if (own_buf[0] == 'E')
1638 warning ("An error occurred while relocating an instruction: %s\n",
1643 if (!startswith (own_buf, "qRelocInsn:"))
1645 warning ("Malformed response to qRelocInsn, ignoring: %s\n",
1650 unpack_varlen_hex (own_buf + strlen ("qRelocInsn:"), &written);
1657 monitor_output (const char *msg)
1659 int len = strlen (msg);
1660 char *buf = (char *) xmalloc (len * 2 + 2);
1663 bin2hex ((const gdb_byte *) msg, buf + 1, len);