GDBserver

remote-utils.c
Go to the documentation of this file.
1 /* Remote utility routines for the remote server for GDB.
2 Copyright (C) 1986-2018 Free Software Foundation, Inc.
3
4 This file is part of GDB.
5
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.
10
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.
15
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/>. */
18
19 #include "server.h"
20 #if HAVE_TERMIOS_H
21 #include <termios.h>
22 #endif
23 #include "target.h"
24 #include "gdbthread.h"
25 #include "tdesc.h"
26 #include "dll.h"
27 #include "rsp-low.h"
28 #include "gdbthread.h"
29 #include <ctype.h>
30 #if HAVE_SYS_IOCTL_H
31 #include <sys/ioctl.h>
32 #endif
33 #if HAVE_SYS_FILE_H
34 #include <sys/file.h>
35 #endif
36 #if HAVE_NETINET_IN_H
37 #include <netinet/in.h>
38 #endif
39 #if HAVE_SYS_SOCKET_H
40 #include <sys/socket.h>
41 #endif
42 #if HAVE_NETDB_H
43 #include <netdb.h>
44 #endif
45 #if HAVE_NETINET_TCP_H
46 #include <netinet/tcp.h>
47 #endif
48 #if HAVE_SYS_IOCTL_H
49 #include <sys/ioctl.h>
50 #endif
51 #if HAVE_SIGNAL_H
52 #include <signal.h>
53 #endif
54 #if HAVE_FCNTL_H
55 #include <fcntl.h>
56 #endif
57 #include "gdb_sys_time.h"
58 #include <unistd.h>
59 #if HAVE_ARPA_INET_H
60 #include <arpa/inet.h>
61 #endif
62 #include <sys/stat.h>
63
64 #if USE_WIN32API
65 #include <winsock2.h>
66 #endif
67
68 #if __QNX__
69 #include <sys/iomgr.h>
70 #endif /* __QNX__ */
71
72 #ifndef HAVE_SOCKLEN_T
73 typedef int socklen_t;
74 #endif
75
76 #ifndef IN_PROCESS_AGENT
77
78 #if USE_WIN32API
79 # define INVALID_DESCRIPTOR INVALID_SOCKET
80 #else
81 # define INVALID_DESCRIPTOR -1
82 #endif
83
84 /* Extra value for readchar_callback. */
85 enum {
86 /* The callback is currently not scheduled. */
87 NOT_SCHEDULED = -1
88 };
89
90 /* Status of the readchar callback.
91 Either NOT_SCHEDULED or the callback id. */
92 static int readchar_callback = NOT_SCHEDULED;
93
94 static int readchar (void);
95 static void reset_readchar (void);
96 static void reschedule (void);
97
98 /* A cache entry for a successfully looked-up symbol. */
99 struct sym_cache
100 {
101 char *name;
102 CORE_ADDR addr;
103 struct sym_cache *next;
104 };
105
106 int remote_debug = 0;
107 struct ui_file *gdb_stdlog;
108
109 static int remote_is_stdio = 0;
110
111 static gdb_fildes_t remote_desc = INVALID_DESCRIPTOR;
112 static gdb_fildes_t listen_desc = INVALID_DESCRIPTOR;
113
114 /* FIXME headerize? */
115 extern int using_threads;
116 extern int debug_threads;
117
118 /* If true, then GDB has requested noack mode. */
119 int noack_mode = 0;
120 /* If true, then we tell GDB to use noack mode by default. */
121 int transport_is_reliable = 0;
122
123 #ifdef USE_WIN32API
124 # define read(fd, buf, len) recv (fd, (char *) buf, len, 0)
125 # define write(fd, buf, len) send (fd, (char *) buf, len, 0)
126 #endif
127
128 int
129 gdb_connected (void)
130 {
131 return remote_desc != INVALID_DESCRIPTOR;
132 }
133
134 /* Return true if the remote connection is over stdio. */
135
136 int
137 remote_connection_is_stdio (void)
138 {
139 return remote_is_stdio;
140 }
141
142 static void
143 enable_async_notification (int fd)
144 {
145 #if defined(F_SETFL) && defined (FASYNC)
146 int save_fcntl_flags;
147
148 save_fcntl_flags = fcntl (fd, F_GETFL, 0);
149 fcntl (fd, F_SETFL, save_fcntl_flags | FASYNC);
150 #if defined (F_SETOWN)
151 fcntl (fd, F_SETOWN, getpid ());
152 #endif
153 #endif
154 }
155
156 static int
157 handle_accept_event (int err, gdb_client_data client_data)
158 {
159 struct sockaddr_in sockaddr;
160 socklen_t tmp;
161
162 if (debug_threads)
163 debug_printf ("handling possible accept event\n");
164
165 tmp = sizeof (sockaddr);
166 remote_desc = accept (listen_desc, (struct sockaddr *) &sockaddr, &tmp);
167 if (remote_desc == -1)
168 perror_with_name ("Accept failed");
169
170 /* Enable TCP keep alive process. */
171 tmp = 1;
172 setsockopt (remote_desc, SOL_SOCKET, SO_KEEPALIVE,
173 (char *) &tmp, sizeof (tmp));
174
175 /* Tell TCP not to delay small packets. This greatly speeds up
176 interactive response. */
177 tmp = 1;
178 setsockopt (remote_desc, IPPROTO_TCP, TCP_NODELAY,
179 (char *) &tmp, sizeof (tmp));
180
181 #ifndef USE_WIN32API
182 signal (SIGPIPE, SIG_IGN); /* If we don't do this, then gdbserver simply
183 exits when the remote side dies. */
184 #endif
185
186 if (run_once)
187 {
188 #ifndef USE_WIN32API
189 close (listen_desc); /* No longer need this */
190 #else
191 closesocket (listen_desc); /* No longer need this */
192 #endif
193 }
194
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);
198
199 /* Convert IP address to string. */
200 fprintf (stderr, "Remote debugging from host %s\n",
201 inet_ntoa (sockaddr.sin_addr));
202
203 enable_async_notification (remote_desc);
204
205 /* Register the event loop handler. */
206 add_file_handler (remote_desc, handle_serial_event, NULL);
207
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 ('?'). */
214 target_async (0);
215
216 return 0;
217 }
218
219 /* Prepare for a later connection to a remote debugger.
220 NAME is the filename used for communication. */
221
222 void
223 remote_prepare (const char *name)
224 {
225 const char *port_str;
226 #ifdef USE_WIN32API
227 static int winsock_initialized;
228 #endif
229 int port;
230 struct sockaddr_in sockaddr;
231 socklen_t tmp;
232 char *port_end;
233
234 remote_is_stdio = 0;
235 if (strcmp (name, STDIO_CONNECTION_NAME) == 0)
236 {
237 /* We need to record fact that we're using stdio sooner than the
238 call to remote_open so start_inferior knows the connection is
239 via stdio. */
240 remote_is_stdio = 1;
241 transport_is_reliable = 1;
242 return;
243 }
244
245 port_str = strchr (name, ':');
246 if (port_str == NULL)
247 {
248 transport_is_reliable = 0;
249 return;
250 }
251
252 port = strtoul (port_str + 1, &port_end, 10);
253 if (port_str[1] == '\0' || *port_end != '\0')
254 error ("Bad port argument: %s", name);
255
256 #ifdef USE_WIN32API
257 if (!winsock_initialized)
258 {
259 WSADATA wsad;
260
261 WSAStartup (MAKEWORD (1, 0), &wsad);
262 winsock_initialized = 1;
263 }
264 #endif
265
266 listen_desc = socket (PF_INET, SOCK_STREAM, IPPROTO_TCP);
267 if (listen_desc == -1)
268 perror_with_name ("Can't open socket");
269
270 /* Allow rapid reuse of this port. */
271 tmp = 1;
272 setsockopt (listen_desc, SOL_SOCKET, SO_REUSEADDR, (char *) &tmp,
273 sizeof (tmp));
274
275 sockaddr.sin_family = PF_INET;
276 sockaddr.sin_port = htons (port);
277 sockaddr.sin_addr.s_addr = INADDR_ANY;
278
279 if (bind (listen_desc, (struct sockaddr *) &sockaddr, sizeof (sockaddr))
280 || listen (listen_desc, 1))
281 perror_with_name ("Can't bind address");
282
283 transport_is_reliable = 1;
284 }
285
286 /* Open a connection to a remote debugger.
287 NAME is the filename used for communication. */
288
289 void
290 remote_open (const char *name)
291 {
292 const char *port_str;
293
294 port_str = strchr (name, ':');
295 #ifdef USE_WIN32API
296 if (port_str == NULL)
297 error ("Only <host>:<port> is supported on this platform.");
298 #endif
299
300 if (strcmp (name, STDIO_CONNECTION_NAME) == 0)
301 {
302 fprintf (stderr, "Remote debugging using stdio\n");
303
304 /* Use stdin as the handle of the connection.
305 We only select on reads, for example. */
306 remote_desc = fileno (stdin);
307
308 enable_async_notification (remote_desc);
309
310 /* Register the event loop handler. */
311 add_file_handler (remote_desc, handle_serial_event, NULL);
312 }
313 #ifndef USE_WIN32API
314 else if (port_str == NULL)
315 {
316 struct stat statbuf;
317
318 if (stat (name, &statbuf) == 0
319 && (S_ISCHR (statbuf.st_mode) || S_ISFIFO (statbuf.st_mode)))
320 remote_desc = open (name, O_RDWR);
321 else
322 {
323 errno = EINVAL;
324 remote_desc = -1;
325 }
326
327 if (remote_desc < 0)
328 perror_with_name ("Could not open remote device");
329
330 #if HAVE_TERMIOS_H
331 {
332 struct termios termios;
333 tcgetattr (remote_desc, &termios);
334
335 termios.c_iflag = 0;
336 termios.c_oflag = 0;
337 termios.c_lflag = 0;
338 termios.c_cflag &= ~(CSIZE | PARENB);
339 termios.c_cflag |= CLOCAL | CS8;
340 termios.c_cc[VMIN] = 1;
341 termios.c_cc[VTIME] = 0;
342
343 tcsetattr (remote_desc, TCSANOW, &termios);
344 }
345 #endif
346
347 fprintf (stderr, "Remote debugging using %s\n", name);
348
349 enable_async_notification (remote_desc);
350
351 /* Register the event loop handler. */
352 add_file_handler (remote_desc, handle_serial_event, NULL);
353 }
354 #endif /* USE_WIN32API */
355 else
356 {
357 int port;
358 socklen_t len;
359 struct sockaddr_in sockaddr;
360
361 len = sizeof (sockaddr);
362 if (getsockname (listen_desc,
363 (struct sockaddr *) &sockaddr, &len) < 0
364 || len < sizeof (sockaddr))
365 perror_with_name ("Can't determine port");
366 port = ntohs (sockaddr.sin_port);
367
368 fprintf (stderr, "Listening on port %d\n", port);
369 fflush (stderr);
370
371 /* Register the event loop handler. */
372 add_file_handler (listen_desc, handle_accept_event, NULL);
373 }
374 }
375
376 void
377 remote_close (void)
378 {
379 delete_file_handler (remote_desc);
380
381 disable_async_io ();
382
383 #ifdef USE_WIN32API
384 closesocket (remote_desc);
385 #else
386 if (! remote_connection_is_stdio ())
387 close (remote_desc);
388 #endif
389 remote_desc = INVALID_DESCRIPTOR;
390
391 reset_readchar ();
392 }
393
394 #endif
395
396 #ifndef IN_PROCESS_AGENT
397
398 void
399 decode_address (CORE_ADDR *addrp, const char *start, int len)
400 {
401 CORE_ADDR addr;
402 char ch;
403 int i;
404
405 addr = 0;
406 for (i = 0; i < len; i++)
407 {
408 ch = start[i];
409 addr = addr << 4;
410 addr = addr | (fromhex (ch) & 0x0f);
411 }
412 *addrp = addr;
413 }
414
415 const char *
416 decode_address_to_semicolon (CORE_ADDR *addrp, const char *start)
417 {
418 const char *end;
419
420 end = start;
421 while (*end != '\0' && *end != ';')
422 end++;
423
424 decode_address (addrp, start, end - start);
425
426 if (*end == ';')
427 end++;
428 return end;
429 }
430
431 #endif
432
433 #ifndef IN_PROCESS_AGENT
434
435 /* Look for a sequence of characters which can be run-length encoded.
436 If there are any, update *CSUM and *P. Otherwise, output the
437 single character. Return the number of characters consumed. */
438
439 static int
440 try_rle (char *buf, int remaining, unsigned char *csum, char **p)
441 {
442 int n;
443
444 /* Always output the character. */
445 *csum += buf[0];
446 *(*p)++ = buf[0];
447
448 /* Don't go past '~'. */
449 if (remaining > 97)
450 remaining = 97;
451
452 for (n = 1; n < remaining; n++)
453 if (buf[n] != buf[0])
454 break;
455
456 /* N is the index of the first character not the same as buf[0].
457 buf[0] is counted twice, so by decrementing N, we get the number
458 of characters the RLE sequence will replace. */
459 n--;
460
461 if (n < 3)
462 return 1;
463
464 /* Skip the frame characters. The manual says to skip '+' and '-'
465 also, but there's no reason to. Unfortunately these two unusable
466 characters double the encoded length of a four byte zero
467 value. */
468 while (n + 29 == '$' || n + 29 == '#')
469 n--;
470
471 *csum += '*';
472 *(*p)++ = '*';
473 *csum += n + 29;
474 *(*p)++ = n + 29;
475
476 return n + 1;
477 }
478
479 #endif
480
481 #ifndef IN_PROCESS_AGENT
482
483 /* Write a PTID to BUF. Returns BUF+CHARACTERS_WRITTEN. */
484
485 char *
486 write_ptid (char *buf, ptid_t ptid)
487 {
488 int pid, tid;
489
490 if (multi_process)
491 {
492 pid = ptid_get_pid (ptid);
493 if (pid < 0)
494 buf += sprintf (buf, "p-%x.", -pid);
495 else
496 buf += sprintf (buf, "p%x.", pid);
497 }
498 tid = ptid_get_lwp (ptid);
499 if (tid < 0)
500 buf += sprintf (buf, "-%x", -tid);
501 else
502 buf += sprintf (buf, "%x", tid);
503
504 return buf;
505 }
506
507 static ULONGEST
508 hex_or_minus_one (const char *buf, const char **obuf)
509 {
510 ULONGEST ret;
511
512 if (startswith (buf, "-1"))
513 {
514 ret = (ULONGEST) -1;
515 buf += 2;
516 }
517 else
518 buf = unpack_varlen_hex (buf, &ret);
519
520 if (obuf)
521 *obuf = buf;
522
523 return ret;
524 }
525
526 /* Extract a PTID from BUF. If non-null, OBUF is set to the to one
527 passed the last parsed char. Returns null_ptid on error. */
528 ptid_t
529 read_ptid (const char *buf, const char **obuf)
530 {
531 const char *p = buf;
532 const char *pp;
533 ULONGEST pid = 0, tid = 0;
534
535 if (*p == 'p')
536 {
537 /* Multi-process ptid. */
538 pp = unpack_varlen_hex (p + 1, &pid);
539 if (*pp != '.')
540 error ("invalid remote ptid: %s\n", p);
541
542 p = pp + 1;
543
544 tid = hex_or_minus_one (p, &pp);
545
546 if (obuf)
547 *obuf = pp;
548 return ptid_build (pid, tid, 0);
549 }
550
551 /* No multi-process. Just a tid. */
552 tid = hex_or_minus_one (p, &pp);
553
554 /* Since GDB is not sending a process id (multi-process extensions
555 are off), then there's only one process. Default to the first in
556 the list. */
557 pid = pid_of (get_first_process ());
558
559 if (obuf)
560 *obuf = pp;
561 return ptid_build (pid, tid, 0);
562 }
563
564 /* Write COUNT bytes in BUF to the client.
565 The result is the number of bytes written or -1 if error.
566 This may return less than COUNT. */
567
568 static int
569 write_prim (const void *buf, int count)
570 {
571 if (remote_connection_is_stdio ())
572 return write (fileno (stdout), buf, count);
573 else
574 return write (remote_desc, buf, count);
575 }
576
577 /* Read COUNT bytes from the client and store in BUF.
578 The result is the number of bytes read or -1 if error.
579 This may return less than COUNT. */
580
581 static int
582 read_prim (void *buf, int count)
583 {
584 if (remote_connection_is_stdio ())
585 return read (fileno (stdin), buf, count);
586 else
587 return read (remote_desc, buf, count);
588 }
589
590 /* Send a packet to the remote machine, with error checking.
591 The data of the packet is in BUF, and the length of the
592 packet is in CNT. Returns >= 0 on success, -1 otherwise. */
593
594 static int
595 putpkt_binary_1 (char *buf, int cnt, int is_notif)
596 {
597 int i;
598 unsigned char csum = 0;
599 char *buf2;
600 char *p;
601 int cc;
602
603 buf2 = (char *) xmalloc (strlen ("$") + cnt + strlen ("#nn") + 1);
604
605 /* Copy the packet into buffer BUF2, encapsulating it
606 and giving it a checksum. */
607
608 p = buf2;
609 if (is_notif)
610 *p++ = '%';
611 else
612 *p++ = '$';
613
614 for (i = 0; i < cnt;)
615 i += try_rle (buf + i, cnt - i, &csum, &p);
616
617 *p++ = '#';
618 *p++ = tohex ((csum >> 4) & 0xf);
619 *p++ = tohex (csum & 0xf);
620
621 *p = '\0';
622
623 /* Send it over and over until we get a positive ack. */
624
625 do
626 {
627 if (write_prim (buf2, p - buf2) != p - buf2)
628 {
629 perror ("putpkt(write)");
630 free (buf2);
631 return -1;
632 }
633
634 if (noack_mode || is_notif)
635 {
636 /* Don't expect an ack then. */
637 if (remote_debug)
638 {
639 if (is_notif)
640 debug_printf ("putpkt (\"%s\"); [notif]\n", buf2);
641 else
642 debug_printf ("putpkt (\"%s\"); [noack mode]\n", buf2);
643 debug_flush ();
644 }
645 break;
646 }
647
648 if (remote_debug)
649 {
650 debug_printf ("putpkt (\"%s\"); [looking for ack]\n", buf2);
651 debug_flush ();
652 }
653
654 cc = readchar ();
655
656 if (cc < 0)
657 {
658 free (buf2);
659 return -1;
660 }
661
662 if (remote_debug)
663 {
664 debug_printf ("[received '%c' (0x%x)]\n", cc, cc);
665 debug_flush ();
666 }
667
668 /* Check for an input interrupt while we're here. */
669 if (cc == '\003' && current_thread != NULL)
670 (*the_target->request_interrupt) ();
671 }
672 while (cc != '+');
673
674 free (buf2);
675 return 1; /* Success! */
676 }
677
678 int
679 putpkt_binary (char *buf, int cnt)
680 {
681 return putpkt_binary_1 (buf, cnt, 0);
682 }
683
684 /* Send a packet to the remote machine, with error checking. The data
685 of the packet is in BUF, and the packet should be a NUL-terminated
686 string. Returns >= 0 on success, -1 otherwise. */
687
688 int
689 putpkt (char *buf)
690 {
691 return putpkt_binary (buf, strlen (buf));
692 }
693
694 int
695 putpkt_notif (char *buf)
696 {
697 return putpkt_binary_1 (buf, strlen (buf), 1);
698 }
699
700 /* Come here when we get an input interrupt from the remote side. This
701 interrupt should only be active while we are waiting for the child to do
702 something. Thus this assumes readchar:bufcnt is 0.
703 About the only thing that should come through is a ^C, which
704 will cause us to request child interruption. */
705
706 static void
707 input_interrupt (int unused)
708 {
709 fd_set readset;
710 struct timeval immediate = { 0, 0 };
711
712 /* Protect against spurious interrupts. This has been observed to
713 be a problem under NetBSD 1.4 and 1.5. */
714
715 FD_ZERO (&readset);
716 FD_SET (remote_desc, &readset);
717 if (select (remote_desc + 1, &readset, 0, 0, &immediate) > 0)
718 {
719 int cc;
720 char c = 0;
721
722 cc = read_prim (&c, 1);
723
724 if (cc == 0)
725 {
726 fprintf (stderr, "client connection closed\n");
727 return;
728 }
729 else if (cc != 1 || c != '\003')
730 {
731 fprintf (stderr, "input_interrupt, count = %d c = %d ", cc, c);
732 if (isprint (c))
733 fprintf (stderr, "('%c')\n", c);
734 else
735 fprintf (stderr, "('\\x%02x')\n", c & 0xff);
736 return;
737 }
738
739 (*the_target->request_interrupt) ();
740 }
741 }
742
743 /* Check if the remote side sent us an interrupt request (^C). */
744 void
745 check_remote_input_interrupt_request (void)
746 {
747 /* This function may be called before establishing communications,
748 therefore we need to validate the remote descriptor. */
749
750 if (remote_desc == INVALID_DESCRIPTOR)
751 return;
752
753 input_interrupt (0);
754 }
755
756 /* Asynchronous I/O support. SIGIO must be unblocked when waiting,
757 in order to accept Control-C from the client, and must be blocked
758 when talking to the client. */
759
760 static void
761 block_unblock_async_io (int block)
762 {
763 #ifndef USE_WIN32API
764 sigset_t sigio_set;
765
766 sigemptyset (&sigio_set);
767 sigaddset (&sigio_set, SIGIO);
768 sigprocmask (block ? SIG_BLOCK : SIG_UNBLOCK, &sigio_set, NULL);
769 #endif
770 }
771
772 #ifdef __QNX__
773 static void
774 nto_comctrl (int enable)
775 {
776 struct sigevent event;
777
778 if (enable)
779 {
780 event.sigev_notify = SIGEV_SIGNAL_THREAD;
781 event.sigev_signo = SIGIO;
782 event.sigev_code = 0;
783 event.sigev_value.sival_ptr = NULL;
784 event.sigev_priority = -1;
785 ionotify (remote_desc, _NOTIFY_ACTION_POLLARM, _NOTIFY_COND_INPUT,
786 &event);
787 }
788 else
789 ionotify (remote_desc, _NOTIFY_ACTION_POLL, _NOTIFY_COND_INPUT, NULL);
790 }
791 #endif /* __QNX__ */
792
793
794 /* Current state of asynchronous I/O. */
795 static int async_io_enabled;
796
797 /* Enable asynchronous I/O. */
798 void
799 enable_async_io (void)
800 {
801 if (async_io_enabled)
802 return;
803
804 block_unblock_async_io (0);
805
806 async_io_enabled = 1;
807 #ifdef __QNX__
808 nto_comctrl (1);
809 #endif /* __QNX__ */
810 }
811
812 /* Disable asynchronous I/O. */
813 void
814 disable_async_io (void)
815 {
816 if (!async_io_enabled)
817 return;
818
819 block_unblock_async_io (1);
820
821 async_io_enabled = 0;
822 #ifdef __QNX__
823 nto_comctrl (0);
824 #endif /* __QNX__ */
825
826 }
827
828 void
829 initialize_async_io (void)
830 {
831 /* Make sure that async I/O starts blocked. */
832 async_io_enabled = 1;
833 disable_async_io ();
834
835 /* Install the signal handler. */
836 #ifndef USE_WIN32API
837 signal (SIGIO, input_interrupt);
838 #endif
839 }
840
841 /* Internal buffer used by readchar.
842 These are global to readchar because reschedule_remote needs to be
843 able to tell whether the buffer is empty. */
844
845 static unsigned char readchar_buf[BUFSIZ];
846 static int readchar_bufcnt = 0;
847 static unsigned char *readchar_bufp;
848
849 /* Returns next char from remote GDB. -1 if error. */
850
851 static int
852 readchar (void)
853 {
854 int ch;
855
856 if (readchar_bufcnt == 0)
857 {
858 readchar_bufcnt = read_prim (readchar_buf, sizeof (readchar_buf));
859
860 if (readchar_bufcnt <= 0)
861 {
862 if (readchar_bufcnt == 0)
863 {
864 if (remote_debug)
865 debug_printf ("readchar: Got EOF\n");
866 }
867 else
868 perror ("readchar");
869
870 return -1;
871 }
872
873 readchar_bufp = readchar_buf;
874 }
875
876 readchar_bufcnt--;
877 ch = *readchar_bufp++;
878 reschedule ();
879 return ch;
880 }
881
882 /* Reset the readchar state machine. */
883
884 static void
885 reset_readchar (void)
886 {
887 readchar_bufcnt = 0;
888 if (readchar_callback != NOT_SCHEDULED)
889 {
890 delete_callback_event (readchar_callback);
891 readchar_callback = NOT_SCHEDULED;
892 }
893 }
894
895 /* Process remaining data in readchar_buf. */
896
897 static int
898 process_remaining (void *context)
899 {
900 int res;
901
902 /* This is a one-shot event. */
903 readchar_callback = NOT_SCHEDULED;
904
905 if (readchar_bufcnt > 0)
906 res = handle_serial_event (0, NULL);
907 else
908 res = 0;
909
910 return res;
911 }
912
913 /* If there is still data in the buffer, queue another event to process it,
914 we can't sleep in select yet. */
915
916 static void
917 reschedule (void)
918 {
919 if (readchar_bufcnt > 0 && readchar_callback == NOT_SCHEDULED)
920 readchar_callback = append_callback_event (process_remaining, NULL);
921 }
922
923 /* Read a packet from the remote machine, with error checking,
924 and store it in BUF. Returns length of packet, or negative if error. */
925
926 int
927 getpkt (char *buf)
928 {
929 char *bp;
930 unsigned char csum, c1, c2;
931 int c;
932
933 while (1)
934 {
935 csum = 0;
936
937 while (1)
938 {
939 c = readchar ();
940
941 /* The '\003' may appear before or after each packet, so
942 check for an input interrupt. */
943 if (c == '\003')
944 {
945 (*the_target->request_interrupt) ();
946 continue;
947 }
948
949 if (c == '$')
950 break;
951 if (remote_debug)
952 {
953 debug_printf ("[getpkt: discarding char '%c']\n", c);
954 debug_flush ();
955 }
956
957 if (c < 0)
958 return -1;
959 }
960
961 bp = buf;
962 while (1)
963 {
964 c = readchar ();
965 if (c < 0)
966 return -1;
967 if (c == '#')
968 break;
969 *bp++ = c;
970 csum += c;
971 }
972 *bp = 0;
973
974 c1 = fromhex (readchar ());
975 c2 = fromhex (readchar ());
976
977 if (csum == (c1 << 4) + c2)
978 break;
979
980 if (noack_mode)
981 {
982 fprintf (stderr,
983 "Bad checksum, sentsum=0x%x, csum=0x%x, "
984 "buf=%s [no-ack-mode, Bad medium?]\n",
985 (c1 << 4) + c2, csum, buf);
986 /* Not much we can do, GDB wasn't expecting an ack/nac. */
987 break;
988 }
989
990 fprintf (stderr, "Bad checksum, sentsum=0x%x, csum=0x%x, buf=%s\n",
991 (c1 << 4) + c2, csum, buf);
992 if (write_prim ("-", 1) != 1)
993 return -1;
994 }
995
996 if (!noack_mode)
997 {
998 if (remote_debug)
999 {
1000 debug_printf ("getpkt (\"%s\"); [sending ack] \n", buf);
1001 debug_flush ();
1002 }
1003
1004 if (write_prim ("+", 1) != 1)
1005 return -1;
1006
1007 if (remote_debug)
1008 {
1009 debug_printf ("[sent ack]\n");
1010 debug_flush ();
1011 }
1012 }
1013 else
1014 {
1015 if (remote_debug)
1016 {
1017 debug_printf ("getpkt (\"%s\"); [no ack sent] \n", buf);
1018 debug_flush ();
1019 }
1020 }
1021
1022 /* The readchar above may have already read a '\003' out of the socket
1023 and moved it to the local buffer. For example, when GDB sends
1024 vCont;c immediately followed by interrupt (see
1025 gdb.base/interrupt-noterm.exp). As soon as we see the vCont;c, we'll
1026 resume the inferior and wait. Since we've already moved the '\003'
1027 to the local buffer, SIGIO won't help. In that case, if we don't
1028 check for interrupt after the vCont;c packet, the interrupt character
1029 would stay in the buffer unattended until after the next (unrelated)
1030 stop. */
1031 while (readchar_bufcnt > 0 && *readchar_bufp == '\003')
1032 {
1033 /* Consume the interrupt character in the buffer. */
1034 readchar ();
1035 (*the_target->request_interrupt) ();
1036 }
1037
1038 return bp - buf;
1039 }
1040
1041 void
1042 write_ok (char *buf)
1043 {
1044 buf[0] = 'O';
1045 buf[1] = 'K';
1046 buf[2] = '\0';
1047 }
1048
1049 void
1050 write_enn (char *buf)
1051 {
1052 /* Some day, we should define the meanings of the error codes... */
1053 buf[0] = 'E';
1054 buf[1] = '0';
1055 buf[2] = '1';
1056 buf[3] = '\0';
1057 }
1058
1059 #endif
1060
1061 #ifndef IN_PROCESS_AGENT
1062
1063 static char *
1064 outreg (struct regcache *regcache, int regno, char *buf)
1065 {
1066 if ((regno >> 12) != 0)
1067 *buf++ = tohex ((regno >> 12) & 0xf);
1068 if ((regno >> 8) != 0)
1069 *buf++ = tohex ((regno >> 8) & 0xf);
1070 *buf++ = tohex ((regno >> 4) & 0xf);
1071 *buf++ = tohex (regno & 0xf);
1072 *buf++ = ':';
1073 collect_register_as_string (regcache, regno, buf);
1074 buf += 2 * register_size (regcache->tdesc, regno);
1075 *buf++ = ';';
1076
1077 return buf;
1078 }
1079
1080 void
1081 prepare_resume_reply (char *buf, ptid_t ptid,
1082 struct target_waitstatus *status)
1083 {
1084 if (debug_threads)
1085 debug_printf ("Writing resume reply for %s:%d\n",
1086 target_pid_to_str (ptid), status->kind);
1087
1088 switch (status->kind)
1089 {
1090 case TARGET_WAITKIND_STOPPED:
1091 case TARGET_WAITKIND_FORKED:
1092 case TARGET_WAITKIND_VFORKED:
1093 case TARGET_WAITKIND_VFORK_DONE:
1094 case TARGET_WAITKIND_EXECD:
1095 case TARGET_WAITKIND_THREAD_CREATED:
1096 case TARGET_WAITKIND_SYSCALL_ENTRY:
1097 case TARGET_WAITKIND_SYSCALL_RETURN:
1098 {
1099 struct thread_info *saved_thread;
1100 const char **regp;
1101 struct regcache *regcache;
1102
1103 if ((status->kind == TARGET_WAITKIND_FORKED && report_fork_events)
1104 || (status->kind == TARGET_WAITKIND_VFORKED && report_vfork_events))
1105 {
1106 enum gdb_signal signal = GDB_SIGNAL_TRAP;
1107 const char *event = (status->kind == TARGET_WAITKIND_FORKED
1108 ? "fork" : "vfork");
1109
1110 sprintf (buf, "T%02x%s:", signal, event);
1111 buf += strlen (buf);
1112 buf = write_ptid (buf, status->value.related_pid);
1113 strcat (buf, ";");
1114 }
1115 else if (status->kind == TARGET_WAITKIND_VFORK_DONE && report_vfork_events)
1116 {
1117 enum gdb_signal signal = GDB_SIGNAL_TRAP;
1118
1119 sprintf (buf, "T%02xvforkdone:;", signal);
1120 }
1121 else if (status->kind == TARGET_WAITKIND_EXECD && report_exec_events)
1122 {
1123 enum gdb_signal signal = GDB_SIGNAL_TRAP;
1124 const char *event = "exec";
1125 char hexified_pathname[PATH_MAX * 2];
1126
1127 sprintf (buf, "T%02x%s:", signal, event);
1128 buf += strlen (buf);
1129
1130 /* Encode pathname to hexified format. */
1131 bin2hex ((const gdb_byte *) status->value.execd_pathname,
1132 hexified_pathname,
1133 strlen (status->value.execd_pathname));
1134
1135 sprintf (buf, "%s;", hexified_pathname);
1136 xfree (status->value.execd_pathname);
1137 status->value.execd_pathname = NULL;
1138 buf += strlen (buf);
1139 }
1140 else if (status->kind == TARGET_WAITKIND_THREAD_CREATED
1141 && report_thread_events)
1142 {
1143 enum gdb_signal signal = GDB_SIGNAL_TRAP;
1144
1145 sprintf (buf, "T%02xcreate:;", signal);
1146 }
1147 else if (status->kind == TARGET_WAITKIND_SYSCALL_ENTRY
1148 || status->kind == TARGET_WAITKIND_SYSCALL_RETURN)
1149 {
1150 enum gdb_signal signal = GDB_SIGNAL_TRAP;
1151 const char *event = (status->kind == TARGET_WAITKIND_SYSCALL_ENTRY
1152 ? "syscall_entry" : "syscall_return");
1153
1154 sprintf (buf, "T%02x%s:%x;", signal, event,
1155 status->value.syscall_number);
1156 }
1157 else
1158 sprintf (buf, "T%02x", status->value.sig);
1159
1160 buf += strlen (buf);
1161
1162 saved_thread = current_thread;
1163
1164 switch_to_thread (ptid);
1165
1166 regp = current_target_desc ()->expedite_regs;
1167
1168 regcache = get_thread_regcache (current_thread, 1);
1169
1170 if (the_target->stopped_by_watchpoint != NULL
1171 && (*the_target->stopped_by_watchpoint) ())
1172 {
1173 CORE_ADDR addr;
1174 int i;
1175
1176 memcpy (buf, "watch:", 6);
1177 buf += 6;
1178
1179 addr = (*the_target->stopped_data_address) ();
1180
1181 /* Convert each byte of the address into two hexadecimal
1182 chars. Note that we take sizeof (void *) instead of
1183 sizeof (addr); this is to avoid sending a 64-bit
1184 address to a 32-bit GDB. */
1185 for (i = sizeof (void *) * 2; i > 0; i--)
1186 *buf++ = tohex ((addr >> (i - 1) * 4) & 0xf);
1187 *buf++ = ';';
1188 }
1189 else if (swbreak_feature && target_stopped_by_sw_breakpoint ())
1190 {
1191 sprintf (buf, "swbreak:;");
1192 buf += strlen (buf);
1193 }
1194 else if (hwbreak_feature && target_stopped_by_hw_breakpoint ())
1195 {
1196 sprintf (buf, "hwbreak:;");
1197 buf += strlen (buf);
1198 }
1199
1200 while (*regp)
1201 {
1202 buf = outreg (regcache, find_regno (regcache->tdesc, *regp), buf);
1203 regp ++;
1204 }
1205 *buf = '\0';
1206
1207 /* Formerly, if the debugger had not used any thread features
1208 we would not burden it with a thread status response. This
1209 was for the benefit of GDB 4.13 and older. However, in
1210 recent GDB versions the check (``if (cont_thread != 0)'')
1211 does not have the desired effect because of sillyness in
1212 the way that the remote protocol handles specifying a
1213 thread. Since thread support relies on qSymbol support
1214 anyway, assume GDB can handle threads. */
1215
1216 if (using_threads && !disable_packet_Tthread)
1217 {
1218 /* This if (1) ought to be unnecessary. But remote_wait
1219 in GDB will claim this event belongs to inferior_ptid
1220 if we do not specify a thread, and there's no way for
1221 gdbserver to know what inferior_ptid is. */
1222 if (1 || !ptid_equal (general_thread, ptid))
1223 {
1224 int core = -1;
1225 /* In non-stop, don't change the general thread behind
1226 GDB's back. */
1227 if (!non_stop)
1228 general_thread = ptid;
1229 sprintf (buf, "thread:");
1230 buf += strlen (buf);
1231 buf = write_ptid (buf, ptid);
1232 strcat (buf, ";");
1233 buf += strlen (buf);
1234
1235 core = target_core_of_thread (ptid);
1236
1237 if (core != -1)
1238 {
1239 sprintf (buf, "core:");
1240 buf += strlen (buf);
1241 sprintf (buf, "%x", core);
1242 strcat (buf, ";");
1243 buf += strlen (buf);
1244 }
1245 }
1246 }
1247
1248 if (dlls_changed)
1249 {
1250 strcpy (buf, "library:;");
1251 buf += strlen (buf);
1252 dlls_changed = 0;
1253 }
1254
1255 current_thread = saved_thread;
1256 }
1257 break;
1258 case TARGET_WAITKIND_EXITED:
1259 if (multi_process)
1260 sprintf (buf, "W%x;process:%x",
1261 status->value.integer, ptid_get_pid (ptid));
1262 else
1263 sprintf (buf, "W%02x", status->value.integer);
1264 break;
1265 case TARGET_WAITKIND_SIGNALLED:
1266 if (multi_process)
1267 sprintf (buf, "X%x;process:%x",
1268 status->value.sig, ptid_get_pid (ptid));
1269 else
1270 sprintf (buf, "X%02x", status->value.sig);
1271 break;
1272 case TARGET_WAITKIND_THREAD_EXITED:
1273 sprintf (buf, "w%x;", status->value.integer);
1274 buf += strlen (buf);
1275 buf = write_ptid (buf, ptid);
1276 break;
1277 case TARGET_WAITKIND_NO_RESUMED:
1278 sprintf (buf, "N");
1279 break;
1280 default:
1281 error ("unhandled waitkind");
1282 break;
1283 }
1284 }
1285
1286 void
1287 decode_m_packet (char *from, CORE_ADDR *mem_addr_ptr, unsigned int *len_ptr)
1288 {
1289 int i = 0, j = 0;
1290 char ch;
1291 *mem_addr_ptr = *len_ptr = 0;
1292
1293 while ((ch = from[i++]) != ',')
1294 {
1295 *mem_addr_ptr = *mem_addr_ptr << 4;
1296 *mem_addr_ptr |= fromhex (ch) & 0x0f;
1297 }
1298
1299 for (j = 0; j < 4; j++)
1300 {
1301 if ((ch = from[i++]) == 0)
1302 break;
1303 *len_ptr = *len_ptr << 4;
1304 *len_ptr |= fromhex (ch) & 0x0f;
1305 }
1306 }
1307
1308 void
1309 decode_M_packet (char *from, CORE_ADDR *mem_addr_ptr, unsigned int *len_ptr,
1310 unsigned char **to_p)
1311 {
1312 int i = 0;
1313 char ch;
1314 *mem_addr_ptr = *len_ptr = 0;
1315
1316 while ((ch = from[i++]) != ',')
1317 {
1318 *mem_addr_ptr = *mem_addr_ptr << 4;
1319 *mem_addr_ptr |= fromhex (ch) & 0x0f;
1320 }
1321
1322 while ((ch = from[i++]) != ':')
1323 {
1324 *len_ptr = *len_ptr << 4;
1325 *len_ptr |= fromhex (ch) & 0x0f;
1326 }
1327
1328 if (*to_p == NULL)
1329 *to_p = (unsigned char *) xmalloc (*len_ptr);
1330
1331 hex2bin (&from[i++], *to_p, *len_ptr);
1332 }
1333
1334 int
1335 decode_X_packet (char *from, int packet_len, CORE_ADDR *mem_addr_ptr,
1336 unsigned int *len_ptr, unsigned char **to_p)
1337 {
1338 int i = 0;
1339 char ch;
1340 *mem_addr_ptr = *len_ptr = 0;
1341
1342 while ((ch = from[i++]) != ',')
1343 {
1344 *mem_addr_ptr = *mem_addr_ptr << 4;
1345 *mem_addr_ptr |= fromhex (ch) & 0x0f;
1346 }
1347
1348 while ((ch = from[i++]) != ':')
1349 {
1350 *len_ptr = *len_ptr << 4;
1351 *len_ptr |= fromhex (ch) & 0x0f;
1352 }
1353
1354 if (*to_p == NULL)
1355 *to_p = (unsigned char *) xmalloc (*len_ptr);
1356
1357 if (remote_unescape_input ((const gdb_byte *) &from[i], packet_len - i,
1358 *to_p, *len_ptr) != *len_ptr)
1359 return -1;
1360
1361 return 0;
1362 }
1363
1364 /* Decode a qXfer write request. */
1365
1366 int
1367 decode_xfer_write (char *buf, int packet_len, CORE_ADDR *offset,
1368 unsigned int *len, unsigned char *data)
1369 {
1370 char ch;
1371 char *b = buf;
1372
1373 /* Extract the offset. */
1374 *offset = 0;
1375 while ((ch = *buf++) != ':')
1376 {
1377 *offset = *offset << 4;
1378 *offset |= fromhex (ch) & 0x0f;
1379 }
1380
1381 /* Get encoded data. */
1382 packet_len -= buf - b;
1383 *len = remote_unescape_input ((const gdb_byte *) buf, packet_len,
1384 data, packet_len);
1385 return 0;
1386 }
1387
1388 /* Decode the parameters of a qSearch:memory packet. */
1389
1390 int
1391 decode_search_memory_packet (const char *buf, int packet_len,
1392 CORE_ADDR *start_addrp,
1393 CORE_ADDR *search_space_lenp,
1394 gdb_byte *pattern, unsigned int *pattern_lenp)
1395 {
1396 const char *p = buf;
1397
1398 p = decode_address_to_semicolon (start_addrp, p);
1399 p = decode_address_to_semicolon (search_space_lenp, p);
1400 packet_len -= p - buf;
1401 *pattern_lenp = remote_unescape_input ((const gdb_byte *) p, packet_len,
1402 pattern, packet_len);
1403 return 0;
1404 }
1405
1406 static void
1407 free_sym_cache (struct sym_cache *sym)
1408 {
1409 if (sym != NULL)
1410 {
1411 free (sym->name);
1412 free (sym);
1413 }
1414 }
1415
1416 void
1417 clear_symbol_cache (struct sym_cache **symcache_p)
1418 {
1419 struct sym_cache *sym, *next;
1420
1421 /* Check the cache first. */
1422 for (sym = *symcache_p; sym; sym = next)
1423 {
1424 next = sym->next;
1425 free_sym_cache (sym);
1426 }
1427
1428 *symcache_p = NULL;
1429 }
1430
1431 /* Get the address of NAME, and return it in ADDRP if found. if
1432 MAY_ASK_GDB is false, assume symbol cache misses are failures.
1433 Returns 1 if the symbol is found, 0 if it is not, -1 on error. */
1434
1435 int
1436 look_up_one_symbol (const char *name, CORE_ADDR *addrp, int may_ask_gdb)
1437 {
1438 char *p, *q;
1439 int len;
1440 struct sym_cache *sym;
1441 struct process_info *proc;
1442
1443 proc = current_process ();
1444
1445 /* Check the cache first. */
1446 for (sym = proc->symbol_cache; sym; sym = sym->next)
1447 if (strcmp (name, sym->name) == 0)
1448 {
1449 *addrp = sym->addr;
1450 return 1;
1451 }
1452
1453 /* It might not be an appropriate time to look up a symbol,
1454 e.g. while we're trying to fetch registers. */
1455 if (!may_ask_gdb)
1456 return 0;
1457
1458 /* Send the request. */
1459 strcpy (own_buf, "qSymbol:");
1460 bin2hex ((const gdb_byte *) name, own_buf + strlen ("qSymbol:"),
1461 strlen (name));
1462 if (putpkt (own_buf) < 0)
1463 return -1;
1464
1465 /* FIXME: Eventually add buffer overflow checking (to getpkt?) */
1466 len = getpkt (own_buf);
1467 if (len < 0)
1468 return -1;
1469
1470 /* We ought to handle pretty much any packet at this point while we
1471 wait for the qSymbol "response". That requires re-entering the
1472 main loop. For now, this is an adequate approximation; allow
1473 GDB to read from memory and handle 'v' packets (for vFile transfers)
1474 while it figures out the address of the symbol. */
1475 while (1)
1476 {
1477 if (own_buf[0] == 'm')
1478 {
1479 CORE_ADDR mem_addr;
1480 unsigned char *mem_buf;
1481 unsigned int mem_len;
1482
1483 decode_m_packet (&own_buf[1], &mem_addr, &mem_len);
1484 mem_buf = (unsigned char *) xmalloc (mem_len);
1485 if (read_inferior_memory (mem_addr, mem_buf, mem_len) == 0)
1486 bin2hex (mem_buf, own_buf, mem_len);
1487 else
1488 write_enn (own_buf);
1489 free (mem_buf);
1490 if (putpkt (own_buf) < 0)
1491 return -1;
1492 }
1493 else if (own_buf[0] == 'v')
1494 {
1495 int new_len = -1;
1496 handle_v_requests (own_buf, len, &new_len);
1497 if (new_len != -1)
1498 putpkt_binary (own_buf, new_len);
1499 else
1500 putpkt (own_buf);
1501 }
1502 else
1503 break;
1504 len = getpkt (own_buf);
1505 if (len < 0)
1506 return -1;
1507 }
1508
1509 if (!startswith (own_buf, "qSymbol:"))
1510 {
1511 warning ("Malformed response to qSymbol, ignoring: %s\n", own_buf);
1512 return -1;
1513 }
1514
1515 p = own_buf + strlen ("qSymbol:");
1516 q = p;
1517 while (*q && *q != ':')
1518 q++;
1519
1520 /* Make sure we found a value for the symbol. */
1521 if (p == q || *q == '\0')
1522 return 0;
1523
1524 decode_address (addrp, p, q - p);
1525
1526 /* Save the symbol in our cache. */
1527 sym = XNEW (struct sym_cache);
1528 sym->name = xstrdup (name);
1529 sym->addr = *addrp;
1530 sym->next = proc->symbol_cache;
1531 proc->symbol_cache = sym;
1532
1533 return 1;
1534 }
1535
1536 /* Relocate an instruction to execute at a different address. OLDLOC
1537 is the address in the inferior memory where the instruction to
1538 relocate is currently at. On input, TO points to the destination
1539 where we want the instruction to be copied (and possibly adjusted)
1540 to. On output, it points to one past the end of the resulting
1541 instruction(s). The effect of executing the instruction at TO
1542 shall be the same as if executing it at OLDLOC. For example, call
1543 instructions that implicitly push the return address on the stack
1544 should be adjusted to return to the instruction after OLDLOC;
1545 relative branches, and other PC-relative instructions need the
1546 offset adjusted; etc. Returns 0 on success, -1 on failure. */
1547
1548 int
1549 relocate_instruction (CORE_ADDR *to, CORE_ADDR oldloc)
1550 {
1551 int len;
1552 ULONGEST written = 0;
1553
1554 /* Send the request. */
1555 sprintf (own_buf, "qRelocInsn:%s;%s", paddress (oldloc),
1556 paddress (*to));
1557 if (putpkt (own_buf) < 0)
1558 return -1;
1559
1560 /* FIXME: Eventually add buffer overflow checking (to getpkt?) */
1561 len = getpkt (own_buf);
1562 if (len < 0)
1563 return -1;
1564
1565 /* We ought to handle pretty much any packet at this point while we
1566 wait for the qRelocInsn "response". That requires re-entering
1567 the main loop. For now, this is an adequate approximation; allow
1568 GDB to access memory. */
1569 while (own_buf[0] == 'm' || own_buf[0] == 'M' || own_buf[0] == 'X')
1570 {
1571 CORE_ADDR mem_addr;
1572 unsigned char *mem_buf = NULL;
1573 unsigned int mem_len;
1574
1575 if (own_buf[0] == 'm')
1576 {
1577 decode_m_packet (&own_buf[1], &mem_addr, &mem_len);
1578 mem_buf = (unsigned char *) xmalloc (mem_len);
1579 if (read_inferior_memory (mem_addr, mem_buf, mem_len) == 0)
1580 bin2hex (mem_buf, own_buf, mem_len);
1581 else
1582 write_enn (own_buf);
1583 }
1584 else if (own_buf[0] == 'X')
1585 {
1586 if (decode_X_packet (&own_buf[1], len - 1, &mem_addr,
1587 &mem_len, &mem_buf) < 0
1588 || write_inferior_memory (mem_addr, mem_buf, mem_len) != 0)
1589 write_enn (own_buf);
1590 else
1591 write_ok (own_buf);
1592 }
1593 else
1594 {
1595 decode_M_packet (&own_buf[1], &mem_addr, &mem_len, &mem_buf);
1596 if (write_inferior_memory (mem_addr, mem_buf, mem_len) == 0)
1597 write_ok (own_buf);
1598 else
1599 write_enn (own_buf);
1600 }
1601 free (mem_buf);
1602 if (putpkt (own_buf) < 0)
1603 return -1;
1604 len = getpkt (own_buf);
1605 if (len < 0)
1606 return -1;
1607 }
1608
1609 if (own_buf[0] == 'E')
1610 {
1611 warning ("An error occurred while relocating an instruction: %s\n",
1612 own_buf);
1613 return -1;
1614 }
1615
1616 if (!startswith (own_buf, "qRelocInsn:"))
1617 {
1618 warning ("Malformed response to qRelocInsn, ignoring: %s\n",
1619 own_buf);
1620 return -1;
1621 }
1622
1623 unpack_varlen_hex (own_buf + strlen ("qRelocInsn:"), &written);
1624
1625 *to += written;
1626 return 0;
1627 }
1628
1629 void
1630 monitor_output (const char *msg)
1631 {
1632 int len = strlen (msg);
1633 char *buf = (char *) xmalloc (len * 2 + 2);
1634
1635 buf[0] = 'O';
1636 bin2hex ((const gdb_byte *) msg, buf + 1, len);
1637
1638 putpkt (buf);
1639 free (buf);
1640 }
1641
1642 #endif
regcache::tdesc
const struct target_desc * tdesc
Definition: regcache.h:34
putpkt_binary_1
static int putpkt_binary_1(char *buf, int cnt, int is_notif)
Definition: remote-utils.c:595
delete_callback_event
void delete_callback_event(int id)
Definition: event-loop.c:218
remote_prepare
void remote_prepare(const char *name)
Definition: remote-utils.c:223
handle_serial_event
int handle_serial_event(int err, gdb_client_data client_data)
Definition: server.c:4365
current_thread
struct thread_info * current_thread
Definition: inferiors.c:28
monitor_output
void monitor_output(const char *msg)
Definition: remote-utils.c:1630
remote_is_stdio
static int remote_is_stdio
Definition: remote-utils.c:109
xfree
static void xfree(T *ptr)
Definition: common-utils.h:54
remote_unescape_input
int remote_unescape_input(const gdb_byte *buffer, int len, gdb_byte *out_buf, int out_maxlen)
Definition: rsp-low.c:269
target_core_of_thread
#define target_core_of_thread(ptid)
Definition: target.h:693
target_ops::stopped_by_watchpoint
int(* stopped_by_watchpoint)(void)
Definition: target.h:236
debug_flush
void debug_flush(void)
Definition: debug.c:66
clear_symbol_cache
void clear_symbol_cache(struct sym_cache **symcache_p)
Definition: remote-utils.c:1417
CORE_ADDR
bfd_vma CORE_ADDR
Definition: common-types.h:41
using_threads
int using_threads
Definition: linux-low.c:255
putpkt_binary
int putpkt_binary(char *buf, int cnt)
Definition: remote-utils.c:679
read_ptid
ptid_t read_ptid(const char *buf, const char **obuf)
Definition: remote-utils.c:529
ptid_get_pid
int ptid_get_pid(const ptid_t &ptid)
Definition: ptid.c:47
target_desc::expedite_regs
const char ** expedite_regs
Definition: tdesc.h:45
decode_xfer_write
int decode_xfer_write(char *buf, int packet_len, CORE_ADDR *offset, unsigned int *len, unsigned char *data)
Definition: remote-utils.c:1367
block_unblock_async_io
static void block_unblock_async_io(int block)
Definition: remote-utils.c:761
sym_cache::addr
CORE_ADDR addr
Definition: remote-utils.c:102
socklen_t
int socklen_t
Definition: remote-utils.c:73
reschedule
static void reschedule(void)
Definition: remote-utils.c:917
prepare_resume_reply
void prepare_resume_reply(char *buf, ptid_t ptid, struct target_waitstatus *status)
Definition: remote-utils.c:1081
warning
void warning(const char *fmt,...)
Definition: errors.c:26
target_stopped_by_hw_breakpoint
#define target_stopped_by_hw_breakpoint()
Definition: target.h:662
gdb_stdlog
struct ui_file * gdb_stdlog
Definition: remote-utils.c:107
enable_async_notification
static void enable_async_notification(int fd)
Definition: remote-utils.c:143
bin2hex
int bin2hex(const gdb_byte *bin, char *hex, int count)
Definition: rsp-low.c:173
enable_async_io
void enable_async_io(void)
Definition: remote-utils.c:799
process_info
Definition: inferiors.h:34
report_thread_events
int report_thread_events
Definition: server.c:93
reset_readchar
static void reset_readchar(void)
Definition: remote-utils.c:885
putpkt
int putpkt(char *buf)
Definition: remote-utils.c:689
S_ISCHR
#define S_ISCHR(m)
Definition: stat.h:458
initialize_async_io
void initialize_async_io(void)
Definition: remote-utils.c:829
paddress
char * paddress(CORE_ADDR addr)
Definition: utils.c:124
name
const char * name
Definition: tracepoint.c:180
handle_v_requests
void handle_v_requests(char *own_buf, int packet_len, int *new_packet_len)
Definition: server.c:3093
sym_cache
Definition: remote-utils.c:99
tohex
int tohex(int nib)
Definition: rsp-low.c:41
write_prim
static int write_prim(const void *buf, int count)
Definition: remote-utils.c:569
fcntl.h
write_ptid
char * write_ptid(char *buf, ptid_t ptid)
Definition: remote-utils.c:486
remote_open
void remote_open(const char *name)
Definition: remote-utils.c:290
get_first_process
process_info * get_first_process(void)
Definition: inferiors.c:174
non_stop
int non_stop
Definition: server.c:98
multi_process
int multi_process
Definition: server.c:89
pid_of
static int pid_of(const thread_info *thread)
Definition: gdbthread.h:214
the_target
struct target_ops * the_target
Definition: target.c:24
regcache
Definition: regcache.h:31
perror
void perror(const char *)
Definition: wincecompat.c:24
run_once
int run_once
Definition: server.c:87
disable_async_io
void disable_async_io(void)
Definition: remote-utils.c:814
read_prim
static int read_prim(void *buf, int count)
Definition: remote-utils.c:582
xstrdup
char * xstrdup(const char *s)
Definition: utils.c:44
XNEW
#define XNEW(T)
Definition: poison.h:109
ptid_build
ptid_t ptid_build(int pid, long lwp, long tid)
Definition: ptid.c:31
S_ISFIFO
#define S_ISFIFO(m)
Definition: stat.h:478
general_thread
ptid_t general_thread
Definition: server.c:78
stat.h
STDIO_CONNECTION_NAME
#define STDIO_CONNECTION_NAME
Definition: remote-utils.h:28
rsp-low.h
thread_info
Definition: gdbthread.h:30
decode_address
void decode_address(CORE_ADDR *addrp, const char *start, int len)
Definition: remote-utils.c:399
async_io_enabled
static int async_io_enabled
Definition: remote-utils.c:795
target_stopped_by_sw_breakpoint
#define target_stopped_by_sw_breakpoint()
Definition: target.h:650
process_remaining
static int process_remaining(void *context)
Definition: remote-utils.c:898
outreg
static char * outreg(struct regcache *regcache, int regno, char *buf)
Definition: remote-utils.c:1064
remote_connection_is_stdio
int remote_connection_is_stdio(void)
Definition: remote-utils.c:137
delete_file_handler
void delete_file_handler(gdb_fildes_t fd)
Definition: event-loop.c:334
collect_register_as_string
void collect_register_as_string(struct regcache *regcache, int n, char *buf)
Definition: regcache.c:434
decode_address_to_semicolon
const char * decode_address_to_semicolon(CORE_ADDR *addrp, const char *start)
Definition: remote-utils.c:416
target_ops::request_interrupt
void(* request_interrupt)(void)
Definition: target.h:189
report_fork_events
int report_fork_events
Definition: server.c:90
gdb_sys_time.h
ptid_t
Definition: ptid.h:35
offset
int offset
Definition: tracepoint.c:181
readchar
static int readchar(void)
Definition: remote-utils.c:852
read_inferior_memory
int read_inferior_memory(CORE_ADDR memaddr, unsigned char *myaddr, int len)
Definition: target.c:120
remote_desc
static gdb_fildes_t remote_desc
Definition: remote-utils.c:111
noack_mode
int noack_mode
Definition: remote-utils.c:119
dlls_changed
int dlls_changed
Definition: dll.c:27
unistd.h
signal.h
gdbthread.h
write_ok
void write_ok(char *buf)
Definition: remote-utils.c:1042
readchar_callback
static int readchar_callback
Definition: remote-utils.c:92
register_size
int register_size(const struct target_desc *tdesc, int n)
Definition: regcache.c:293
decode_m_packet
void decode_m_packet(char *from, CORE_ADDR *mem_addr_ptr, unsigned int *len_ptr)
Definition: remote-utils.c:1287
look_up_one_symbol
int look_up_one_symbol(const char *name, CORE_ADDR *addrp, int may_ask_gdb)
Definition: remote-utils.c:1436
free
void free(T *ptr)=delete
disable_packet_Tthread
int disable_packet_Tthread
Definition: server.c:130
server.h
report_exec_events
int report_exec_events
Definition: server.c:92
decode_search_memory_packet
int decode_search_memory_packet(const char *buf, int packet_len, CORE_ADDR *start_addrp, CORE_ADDR *search_space_lenp, gdb_byte *pattern, unsigned int *pattern_lenp)
Definition: remote-utils.c:1391
startswith
static int startswith(const char *string, const char *pattern)
Definition: common-utils.h:107
INVALID_DESCRIPTOR
#define INVALID_DESCRIPTOR
Definition: remote-utils.c:81
mem_buf
static unsigned char * mem_buf
Definition: server.c:139
current_process
struct process_info * current_process(void)
Definition: inferiors.c:210
fromhex
int fromhex(int a)
Definition: rsp-low.c:26
putpkt_notif
int putpkt_notif(char *buf)
Definition: remote-utils.c:695
report_vfork_events
int report_vfork_events
Definition: server.c:91
ptid_get_lwp
long ptid_get_lwp(const ptid_t &ptid)
Definition: ptid.c:55
gdb_client_data
void * gdb_client_data
Definition: event-loop.h:22
append_callback_event
int append_callback_event(callback_handler_func *proc, gdb_client_data data)
Definition: event-loop.c:198
sym_cache::next
struct sym_cache * next
Definition: remote-utils.c:103
errno
#define errno
Definition: wincecompat.h:24
hwbreak_feature
int hwbreak_feature
Definition: server.c:100
write_inferior_memory
int write_inferior_memory(CORE_ADDR memaddr, const unsigned char *myaddr, int len)
Definition: target.c:145
switch_to_thread
void switch_to_thread(ptid_t ptid)
Definition: inferiors.c:231
add_file_handler
void add_file_handler(gdb_fildes_t fd, handler_func *proc, gdb_client_data client_data)
Definition: event-loop.c:324
listen_desc
static gdb_fildes_t listen_desc
Definition: remote-utils.c:112
process_info::symbol_cache
struct sym_cache * symbol_cache
Definition: inferiors.h:52
decode_M_packet
void decode_M_packet(char *from, CORE_ADDR *mem_addr_ptr, unsigned int *len_ptr, unsigned char **to_p)
Definition: remote-utils.c:1309
gdb_byte
bfd_byte gdb_byte
Definition: common-types.h:38
free_sym_cache
static void free_sym_cache(struct sym_cache *sym)
Definition: remote-utils.c:1407
NOT_SCHEDULED
Definition: remote-utils.c:87
find_regno
int find_regno(const struct target_desc *tdesc, const char *name)
Definition: regcache.c:243
current_target_desc
const struct target_desc * current_target_desc(void)
Definition: tdesc.c:61
readchar_buf
static unsigned char readchar_buf[BUFSIZ]
Definition: remote-utils.c:845
readchar_bufp
static unsigned char * readchar_bufp
Definition: remote-utils.c:847
target_async
#define target_async(enable)
Definition: target.h:541
try_rle
static int try_rle(char *buf, int remaining, unsigned char *csum, char **p)
Definition: remote-utils.c:440
target_pid_to_str
const char * target_pid_to_str(ptid_t ptid)
Definition: target.c:308
own_buf
char * own_buf
Definition: server.c:138
sym_cache::name
char * name
Definition: remote-utils.c:101
get_thread_regcache
struct regcache * get_thread_regcache(struct thread_info *thread, int fetch)
Definition: regcache.c:27
target.h
perror_with_name
void perror_with_name(const char *string)
Definition: utils.c:57
ptid_equal
int ptid_equal(const ptid_t &ptid1, const ptid_t &ptid2)
Definition: ptid.c:71
ULONGEST
unsigned long long ULONGEST
Definition: common-types.h:53
xmalloc
PTR xmalloc(size_t size)
Definition: common-utils.c:35
handle_accept_event
static int handle_accept_event(int err, gdb_client_data client_data)
Definition: remote-utils.c:157
gdb_fildes_t
int gdb_fildes_t
Definition: server.h:113
hex2bin
int hex2bin(const char *hex, gdb_byte *bin, int count)
Definition: rsp-low.c:115
gdb_connected
int gdb_connected(void)
Definition: remote-utils.c:129
unpack_varlen_hex
const char * unpack_varlen_hex(const char *buff, ULONGEST *result)
Definition: rsp-low.c:96
debug_printf
void debug_printf(const char *fmt,...)
Definition: common-debug.c:30
remote_close
void remote_close(void)
Definition: remote-utils.c:377
transport_is_reliable
int transport_is_reliable
Definition: remote-utils.c:121
remote_debug
int remote_debug
Definition: remote-utils.c:106
fcntl
#define fcntl
Definition: fcntl.h:436
dll.h
input_interrupt
static void input_interrupt(int unused)
Definition: remote-utils.c:707
check_remote_input_interrupt_request
void check_remote_input_interrupt_request(void)
Definition: remote-utils.c:745
target_ops::stopped_data_address
CORE_ADDR(* stopped_data_address)(void)
Definition: target.h:241
decode_X_packet
int decode_X_packet(char *from, int packet_len, CORE_ADDR *mem_addr_ptr, unsigned int *len_ptr, unsigned char **to_p)
Definition: remote-utils.c:1335
readchar_bufcnt
static int readchar_bufcnt
Definition: remote-utils.c:846
error
void error(const char *fmt,...)
Definition: errors.c:38
getpkt
int getpkt(char *buf)
Definition: remote-utils.c:927
hex_or_minus_one
static ULONGEST hex_or_minus_one(const char *buf, const char **obuf)
Definition: remote-utils.c:508
relocate_instruction
int relocate_instruction(CORE_ADDR *to, CORE_ADDR oldloc)
Definition: remote-utils.c:1549
tdesc.h
write_enn
void write_enn(char *buf)
Definition: remote-utils.c:1050
debug_threads
int debug_threads
Definition: debug.c:24
swbreak_feature
int swbreak_feature
Definition: server.c:99