1 /* Main code for remote server for GDB.
2 Copyright (C) 1989, 1993, 1994, 1995, 1997, 1998, 1999, 2000, 2002, 2003,
3 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011
4 Free Software Foundation, Inc.
6 This file is part of GDB.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program. If not, see <http://www.gnu.org/licenses/>. */
34 ptid_t general_thread;
38 static int extended_protocol;
39 static int response_needed;
40 static int exit_requested;
42 /* --once: Exit after the first connection has closed. */
48 /* Whether we should attempt to disable the operating system's address
49 space randomization feature before starting an inferior. */
50 int disable_randomization = 1;
52 static char **program_argv, **wrapper_argv;
54 /* Enable miscellaneous debugging output. The name is historical - it
55 was originally used to debug LinuxThreads support. */
58 /* Enable debugging of h/w breakpoint/watchpoint support. */
61 int pass_signals[TARGET_SIGNAL_LAST];
65 const char *gdbserver_xmltarget;
67 /* The PID of the originally created or attached inferior. Used to
68 send signals to the process when GDB sends us an asynchronous interrupt
69 (user hitting Control-C in the client), and to wait for the child to exit
70 when no longer debugging it. */
72 unsigned long signal_pid;
75 /* A file descriptor for the controlling terminal. */
78 /* TERMINAL_FD's original foreground group. */
79 pid_t old_foreground_pgrp;
81 /* Hand back terminal ownership to the original foreground group. */
84 restore_old_foreground_pgrp (void)
86 tcsetpgrp (terminal_fd, old_foreground_pgrp);
90 /* Set if you want to disable optional thread related packets support
91 in gdbserver, for the sake of testing GDB against stubs that don't
93 int disable_packet_vCont;
94 int disable_packet_Tthread;
95 int disable_packet_qC;
96 int disable_packet_qfThreadInfo;
98 /* Last status reported to GDB. */
99 static struct target_waitstatus last_status;
100 static ptid_t last_ptid;
102 static char *own_buf;
103 static unsigned char *mem_buf;
105 /* Structure holding information relative to a single stop reply. We
106 keep a queue of these (really a singly-linked list) to push to GDB
110 /* Pointer to next in list. */
111 struct vstop_notif *next;
113 /* Thread or process that got the event. */
117 struct target_waitstatus status;
120 /* The pending stop replies list head. */
121 static struct vstop_notif *notif_queue = NULL;
123 /* Put a stop reply to the stop reply queue. */
126 queue_stop_reply (ptid_t ptid, struct target_waitstatus *status)
128 struct vstop_notif *new_notif;
130 new_notif = xmalloc (sizeof (*new_notif));
131 new_notif->next = NULL;
132 new_notif->ptid = ptid;
133 new_notif->status = *status;
137 struct vstop_notif *tail;
138 for (tail = notif_queue;
142 tail->next = new_notif;
145 notif_queue = new_notif;
150 struct vstop_notif *n;
152 for (n = notif_queue; n; n = n->next)
155 fprintf (stderr, "pending stop replies: %d\n", i);
159 /* Place an event in the stop reply queue, and push a notification if
160 we aren't sending one yet. */
163 push_event (ptid_t ptid, struct target_waitstatus *status)
165 gdb_assert (status->kind != TARGET_WAITKIND_IGNORE);
167 queue_stop_reply (ptid, status);
169 /* If this is the first stop reply in the queue, then inform GDB
170 about it, by sending a Stop notification. */
171 if (notif_queue->next == NULL)
176 prepare_resume_reply (p,
177 notif_queue->ptid, ¬if_queue->status);
178 putpkt_notif (own_buf);
182 /* Get rid of the currently pending stop replies for PID. If PID is
183 -1, then apply to all processes. */
186 discard_queued_stop_replies (int pid)
188 struct vstop_notif *prev = NULL, *reply, *next;
190 for (reply = notif_queue; reply; reply = next)
195 || ptid_get_pid (reply->ptid) == pid)
197 if (reply == notif_queue)
200 prev->next = reply->next;
209 /* If there are more stop replies to push, push one now. */
212 send_next_stop_reply (char *own_buf)
215 prepare_resume_reply (own_buf,
217 ¬if_queue->status);
223 target_running (void)
225 return all_threads.head != NULL;
229 start_inferior (char **argv)
231 char **new_argv = argv;
233 if (wrapper_argv != NULL)
237 for (i = 0; wrapper_argv[i] != NULL; i++)
239 for (i = 0; argv[i] != NULL; i++)
241 new_argv = alloca (sizeof (char *) * count);
243 for (i = 0; wrapper_argv[i] != NULL; i++)
244 new_argv[count++] = wrapper_argv[i];
245 for (i = 0; argv[i] != NULL; i++)
246 new_argv[count++] = argv[i];
247 new_argv[count] = NULL;
253 for (i = 0; new_argv[i]; ++i)
254 fprintf (stderr, "new_argv[%d] = \"%s\"\n", i, new_argv[i]);
259 signal (SIGTTOU, SIG_DFL);
260 signal (SIGTTIN, SIG_DFL);
263 signal_pid = create_inferior (new_argv[0], new_argv);
265 /* FIXME: we don't actually know at this point that the create
266 actually succeeded. We won't know that until we wait. */
267 fprintf (stderr, "Process %s created; pid = %ld\n", argv[0],
272 signal (SIGTTOU, SIG_IGN);
273 signal (SIGTTIN, SIG_IGN);
274 terminal_fd = fileno (stderr);
275 old_foreground_pgrp = tcgetpgrp (terminal_fd);
276 tcsetpgrp (terminal_fd, signal_pid);
277 atexit (restore_old_foreground_pgrp);
280 if (wrapper_argv != NULL)
282 struct thread_resume resume_info;
284 resume_info.thread = pid_to_ptid (signal_pid);
285 resume_info.kind = resume_continue;
288 mywait (pid_to_ptid (signal_pid), &last_status, 0, 0);
290 if (last_status.kind != TARGET_WAITKIND_STOPPED)
295 (*the_target->resume) (&resume_info, 1);
297 mywait (pid_to_ptid (signal_pid), &last_status, 0, 0);
298 if (last_status.kind != TARGET_WAITKIND_STOPPED)
301 current_inferior->last_resume_kind = resume_stop;
302 current_inferior->last_status = last_status;
304 while (last_status.value.sig != TARGET_SIGNAL_TRAP);
306 current_inferior->last_resume_kind = resume_stop;
307 current_inferior->last_status = last_status;
311 /* Wait till we are at 1st instruction in program, return new pid
312 (assuming success). */
313 last_ptid = mywait (pid_to_ptid (signal_pid), &last_status, 0, 0);
315 if (last_status.kind != TARGET_WAITKIND_EXITED
316 && last_status.kind != TARGET_WAITKIND_SIGNALLED)
318 current_inferior->last_resume_kind = resume_stop;
319 current_inferior->last_status = last_status;
326 attach_inferior (int pid)
328 /* myattach should return -1 if attaching is unsupported,
329 0 if it succeeded, and call error() otherwise. */
331 if (myattach (pid) != 0)
334 fprintf (stderr, "Attached; pid = %d\n", pid);
337 /* FIXME - It may be that we should get the SIGNAL_PID from the
338 attach function, so that it can be the main thread instead of
339 whichever we were told to attach to. */
344 last_ptid = mywait (pid_to_ptid (pid), &last_status, 0, 0);
346 /* GDB knows to ignore the first SIGSTOP after attaching to a running
347 process using the "attach" command, but this is different; it's
348 just using "target remote". Pretend it's just starting up. */
349 if (last_status.kind == TARGET_WAITKIND_STOPPED
350 && last_status.value.sig == TARGET_SIGNAL_STOP)
351 last_status.value.sig = TARGET_SIGNAL_TRAP;
353 current_inferior->last_resume_kind = resume_stop;
354 current_inferior->last_status = last_status;
360 extern int remote_debug;
362 /* Decode a qXfer read request. Return 0 if everything looks OK,
366 decode_xfer_read (char *buf, CORE_ADDR *ofs, unsigned int *len)
368 /* After the read marker and annex, qXfer looks like a
369 traditional 'm' packet. */
370 decode_m_packet (buf, ofs, len);
376 decode_xfer (char *buf, char **object, char **rw, char **annex, char **offset)
378 /* Extract and NUL-terminate the object. */
380 while (*buf && *buf != ':')
386 /* Extract and NUL-terminate the read/write action. */
388 while (*buf && *buf != ':')
394 /* Extract and NUL-terminate the annex. */
396 while (*buf && *buf != ':')
406 /* Write the response to a successful qXfer read. Returns the
407 length of the (binary) data stored in BUF, corresponding
408 to as much of DATA/LEN as we could fit. IS_MORE controls
409 the first character of the response. */
411 write_qxfer_response (char *buf, const void *data, int len, int is_more)
420 return remote_escape_output (data, len, (unsigned char *) buf + 1, &out_len,
424 /* Handle all of the extended 'Q' packets. */
427 handle_general_set (char *own_buf)
429 if (strncmp ("QPassSignals:", own_buf, strlen ("QPassSignals:")) == 0)
431 int numsigs = (int) TARGET_SIGNAL_LAST, i;
432 const char *p = own_buf + strlen ("QPassSignals:");
435 p = decode_address_to_semicolon (&cursig, p);
436 for (i = 0; i < numsigs; i++)
442 /* Keep looping, to clear the remaining signals. */
445 p = decode_address_to_semicolon (&cursig, p);
450 strcpy (own_buf, "OK");
454 if (strcmp (own_buf, "QStartNoAckMode") == 0)
458 fprintf (stderr, "[noack mode enabled]\n");
467 if (strncmp (own_buf, "QNonStop:", 9) == 0)
469 char *mode = own_buf + 9;
473 if (strcmp (mode, "0") == 0)
475 else if (strcmp (mode, "1") == 0)
479 /* We don't know what this mode is, so complain to
481 fprintf (stderr, "Unknown non-stop mode requested: %s\n",
487 req_str = req ? "non-stop" : "all-stop";
488 if (start_non_stop (req) != 0)
490 fprintf (stderr, "Setting %s mode failed\n", req_str);
498 fprintf (stderr, "[%s mode enabled]\n", req_str);
504 if (strncmp ("QDisableRandomization:", own_buf,
505 strlen ("QDisableRandomization:")) == 0)
507 char *packet = own_buf + strlen ("QDisableRandomization:");
510 unpack_varlen_hex (packet, &setting);
511 disable_randomization = setting;
515 if (disable_randomization)
516 fprintf (stderr, "[address space randomization disabled]\n");
518 fprintf (stderr, "[address space randomization enabled]\n");
525 if (target_supports_tracepoints ()
526 && handle_tracepoint_general_set (own_buf))
529 /* Otherwise we didn't know what packet it was. Say we didn't
535 get_features_xml (const char *annex)
537 /* gdbserver_xmltarget defines what to return when looking
538 for the "target.xml" file. Its contents can either be
539 verbatim XML code (prefixed with a '@') or else the name
540 of the actual XML file to be used in place of "target.xml".
542 This variable is set up from the auto-generated
543 init_registers_... routine for the current target. */
545 if (gdbserver_xmltarget
546 && strcmp (annex, "target.xml") == 0)
548 if (*gdbserver_xmltarget == '@')
549 return gdbserver_xmltarget + 1;
551 annex = gdbserver_xmltarget;
556 extern const char *const xml_builtin[][2];
559 /* Look for the annex. */
560 for (i = 0; xml_builtin[i][0] != NULL; i++)
561 if (strcmp (annex, xml_builtin[i][0]) == 0)
564 if (xml_builtin[i][0] != NULL)
565 return xml_builtin[i][1];
573 monitor_show_help (void)
575 monitor_output ("The following monitor commands are supported:\n");
576 monitor_output (" set debug <0|1>\n");
577 monitor_output (" Enable general debugging messages\n");
578 monitor_output (" set debug-hw-points <0|1>\n");
579 monitor_output (" Enable h/w breakpoint/watchpoint debugging messages\n");
580 monitor_output (" set remote-debug <0|1>\n");
581 monitor_output (" Enable remote protocol debugging messages\n");
582 monitor_output (" exit\n");
583 monitor_output (" Quit GDBserver\n");
586 /* Read trace frame or inferior memory. Returns the number of bytes
587 actually read, zero when no further transfer is possible, and -1 on
588 error. Return of a positive value smaller than LEN does not
589 indicate there's no more to be read, only the end of the transfer.
590 E.g., when GDB reads memory from a traceframe, a first request may
591 be served from a memory block that does not cover the whole request
592 length. A following request gets the rest served from either
593 another block (of the same traceframe) or from the read-only
597 gdb_read_memory (CORE_ADDR memaddr, unsigned char *myaddr, int len)
601 if (current_traceframe >= 0)
604 ULONGEST length = len;
606 if (traceframe_read_mem (current_traceframe,
607 memaddr, myaddr, len, &nbytes))
609 /* Data read from trace buffer, we're done. */
612 if (!in_readonly_region (memaddr, length))
614 /* Otherwise we have a valid readonly case, fall through. */
615 /* (assume no half-trace half-real blocks for now) */
618 res = prepare_to_access_memory ();
621 res = read_inferior_memory (memaddr, myaddr, len);
622 done_accessing_memory ();
624 return res == 0 ? len : -1;
630 /* Write trace frame or inferior memory. Actually, writing to trace
631 frames is forbidden. */
634 gdb_write_memory (CORE_ADDR memaddr, const unsigned char *myaddr, int len)
636 if (current_traceframe >= 0)
642 ret = prepare_to_access_memory ();
645 ret = write_inferior_memory (memaddr, myaddr, len);
646 done_accessing_memory ();
652 /* Subroutine of handle_search_memory to simplify it. */
655 handle_search_memory_1 (CORE_ADDR start_addr, CORE_ADDR search_space_len,
656 gdb_byte *pattern, unsigned pattern_len,
657 gdb_byte *search_buf,
658 unsigned chunk_size, unsigned search_buf_size,
659 CORE_ADDR *found_addrp)
661 /* Prime the search buffer. */
663 if (gdb_read_memory (start_addr, search_buf, search_buf_size)
666 warning ("Unable to access target memory at 0x%lx, halting search.",
671 /* Perform the search.
673 The loop is kept simple by allocating [N + pattern-length - 1] bytes.
674 When we've scanned N bytes we copy the trailing bytes to the start and
675 read in another N bytes. */
677 while (search_space_len >= pattern_len)
680 unsigned nr_search_bytes = (search_space_len < search_buf_size
684 found_ptr = memmem (search_buf, nr_search_bytes, pattern, pattern_len);
686 if (found_ptr != NULL)
688 CORE_ADDR found_addr = start_addr + (found_ptr - search_buf);
689 *found_addrp = found_addr;
693 /* Not found in this chunk, skip to next chunk. */
695 /* Don't let search_space_len wrap here, it's unsigned. */
696 if (search_space_len >= chunk_size)
697 search_space_len -= chunk_size;
699 search_space_len = 0;
701 if (search_space_len >= pattern_len)
703 unsigned keep_len = search_buf_size - chunk_size;
704 CORE_ADDR read_addr = start_addr + chunk_size + keep_len;
707 /* Copy the trailing part of the previous iteration to the front
708 of the buffer for the next iteration. */
709 memcpy (search_buf, search_buf + chunk_size, keep_len);
711 nr_to_read = (search_space_len - keep_len < chunk_size
712 ? search_space_len - keep_len
715 if (gdb_read_memory (read_addr, search_buf + keep_len,
716 nr_to_read) != search_buf_size)
718 warning ("Unable to access target memory "
719 "at 0x%lx, halting search.",
724 start_addr += chunk_size;
733 /* Handle qSearch:memory packets. */
736 handle_search_memory (char *own_buf, int packet_len)
738 CORE_ADDR start_addr;
739 CORE_ADDR search_space_len;
741 unsigned int pattern_len;
742 /* NOTE: also defined in find.c testcase. */
743 #define SEARCH_CHUNK_SIZE 16000
744 const unsigned chunk_size = SEARCH_CHUNK_SIZE;
745 /* Buffer to hold memory contents for searching. */
746 gdb_byte *search_buf;
747 unsigned search_buf_size;
749 CORE_ADDR found_addr;
750 int cmd_name_len = sizeof ("qSearch:memory:") - 1;
752 pattern = malloc (packet_len);
755 error ("Unable to allocate memory to perform the search");
756 strcpy (own_buf, "E00");
759 if (decode_search_memory_packet (own_buf + cmd_name_len,
760 packet_len - cmd_name_len,
761 &start_addr, &search_space_len,
762 pattern, &pattern_len) < 0)
765 error ("Error in parsing qSearch:memory packet");
766 strcpy (own_buf, "E00");
770 search_buf_size = chunk_size + pattern_len - 1;
772 /* No point in trying to allocate a buffer larger than the search space. */
773 if (search_space_len < search_buf_size)
774 search_buf_size = search_space_len;
776 search_buf = malloc (search_buf_size);
777 if (search_buf == NULL)
780 error ("Unable to allocate memory to perform the search");
781 strcpy (own_buf, "E00");
785 found = handle_search_memory_1 (start_addr, search_space_len,
786 pattern, pattern_len,
787 search_buf, chunk_size, search_buf_size,
791 sprintf (own_buf, "1,%lx", (long) found_addr);
793 strcpy (own_buf, "0");
795 strcpy (own_buf, "E00");
801 #define require_running(BUF) \
802 if (!target_running ()) \
808 /* Handle monitor commands not handled by target-specific handlers. */
811 handle_monitor_command (char *mon)
813 if (strcmp (mon, "set debug 1") == 0)
816 monitor_output ("Debug output enabled.\n");
818 else if (strcmp (mon, "set debug 0") == 0)
821 monitor_output ("Debug output disabled.\n");
823 else if (strcmp (mon, "set debug-hw-points 1") == 0)
826 monitor_output ("H/W point debugging output enabled.\n");
828 else if (strcmp (mon, "set debug-hw-points 0") == 0)
831 monitor_output ("H/W point debugging output disabled.\n");
833 else if (strcmp (mon, "set remote-debug 1") == 0)
836 monitor_output ("Protocol debug output enabled.\n");
838 else if (strcmp (mon, "set remote-debug 0") == 0)
841 monitor_output ("Protocol debug output disabled.\n");
843 else if (strcmp (mon, "help") == 0)
844 monitor_show_help ();
845 else if (strcmp (mon, "exit") == 0)
849 monitor_output ("Unknown monitor command.\n\n");
850 monitor_show_help ();
855 /* Associates a callback with each supported qXfer'able object. */
859 /* The object this handler handles. */
862 /* Request that the target transfer up to LEN 8-bit bytes of the
863 target's OBJECT. The OFFSET, for a seekable object, specifies
864 the starting point. The ANNEX can be used to provide additional
865 data-specific information to the target.
867 Return the number of bytes actually transfered, zero when no
868 further transfer is possible, -1 on error, and -2 when the
869 transfer is not supported. Return of a positive value smaller
870 than LEN does not indicate the end of the object, only the end of
873 One, and only one, of readbuf or writebuf must be non-NULL. */
874 int (*xfer) (const char *annex,
875 gdb_byte *readbuf, const gdb_byte *writebuf,
876 ULONGEST offset, LONGEST len);
879 /* Handle qXfer:auxv:read. */
882 handle_qxfer_auxv (const char *annex,
883 gdb_byte *readbuf, const gdb_byte *writebuf,
884 ULONGEST offset, LONGEST len)
886 if (the_target->read_auxv == NULL || writebuf != NULL)
889 if (annex[0] != '\0' || !target_running ())
892 return (*the_target->read_auxv) (offset, readbuf, len);
895 /* Handle qXfer:features:read. */
898 handle_qxfer_features (const char *annex,
899 gdb_byte *readbuf, const gdb_byte *writebuf,
900 ULONGEST offset, LONGEST len)
902 const char *document;
905 if (writebuf != NULL)
908 if (!target_running ())
911 /* Grab the correct annex. */
912 document = get_features_xml (annex);
913 if (document == NULL)
916 total_len = strlen (document);
918 if (offset > total_len)
921 if (offset + len > total_len)
922 len = total_len - offset;
924 memcpy (readbuf, document + offset, len);
928 /* Handle qXfer:libraries:read. */
931 handle_qxfer_libraries (const char *annex,
932 gdb_byte *readbuf, const gdb_byte *writebuf,
933 ULONGEST offset, LONGEST len)
935 unsigned int total_len;
937 struct inferior_list_entry *dll_ptr;
939 if (writebuf != NULL)
942 if (annex[0] != '\0' || !target_running ())
945 /* Over-estimate the necessary memory. Assume that every character
946 in the library name must be escaped. */
948 for (dll_ptr = all_dlls.head; dll_ptr != NULL; dll_ptr = dll_ptr->next)
949 total_len += 128 + 6 * strlen (((struct dll_info *) dll_ptr)->name);
951 document = malloc (total_len);
952 if (document == NULL)
955 strcpy (document, "<library-list>\n");
956 p = document + strlen (document);
958 for (dll_ptr = all_dlls.head; dll_ptr != NULL; dll_ptr = dll_ptr->next)
960 struct dll_info *dll = (struct dll_info *) dll_ptr;
963 strcpy (p, " <library name=\"");
965 name = xml_escape_text (dll->name);
969 strcpy (p, "\"><segment address=\"");
971 sprintf (p, "0x%lx", (long) dll->base_addr);
973 strcpy (p, "\"/></library>\n");
977 strcpy (p, "</library-list>\n");
979 total_len = strlen (document);
981 if (offset > total_len)
987 if (offset + len > total_len)
988 len = total_len - offset;
990 memcpy (readbuf, document + offset, len);
995 /* Handle qXfer:osadata:read. */
998 handle_qxfer_osdata (const char *annex,
999 gdb_byte *readbuf, const gdb_byte *writebuf,
1000 ULONGEST offset, LONGEST len)
1002 if (the_target->qxfer_osdata == NULL || writebuf != NULL)
1005 return (*the_target->qxfer_osdata) (annex, readbuf, NULL, offset, len);
1008 /* Handle qXfer:siginfo:read and qXfer:siginfo:write. */
1011 handle_qxfer_siginfo (const char *annex,
1012 gdb_byte *readbuf, const gdb_byte *writebuf,
1013 ULONGEST offset, LONGEST len)
1015 if (the_target->qxfer_siginfo == NULL)
1018 if (annex[0] != '\0' || !target_running ())
1021 return (*the_target->qxfer_siginfo) (annex, readbuf, writebuf, offset, len);
1024 /* Handle qXfer:spu:read and qXfer:spu:write. */
1027 handle_qxfer_spu (const char *annex,
1028 gdb_byte *readbuf, const gdb_byte *writebuf,
1029 ULONGEST offset, LONGEST len)
1031 if (the_target->qxfer_spu == NULL)
1034 if (!target_running ())
1037 return (*the_target->qxfer_spu) (annex, readbuf, writebuf, offset, len);
1040 /* Handle qXfer:statictrace:read. */
1043 handle_qxfer_statictrace (const char *annex,
1044 gdb_byte *readbuf, const gdb_byte *writebuf,
1045 ULONGEST offset, LONGEST len)
1049 if (writebuf != NULL)
1052 if (annex[0] != '\0' || !target_running () || current_traceframe == -1)
1055 if (traceframe_read_sdata (current_traceframe, offset,
1056 readbuf, len, &nbytes))
1061 /* Helper for handle_qxfer_threads. */
1064 handle_qxfer_threads_proper (struct buffer *buffer)
1066 struct inferior_list_entry *thread;
1068 buffer_grow_str (buffer, "<threads>\n");
1070 for (thread = all_threads.head; thread; thread = thread->next)
1072 ptid_t ptid = thread_to_gdb_id ((struct thread_info *)thread);
1077 write_ptid (ptid_s, ptid);
1079 if (the_target->core_of_thread)
1080 core = (*the_target->core_of_thread) (ptid);
1084 sprintf (core_s, "%d", core);
1085 buffer_xml_printf (buffer, "<thread id=\"%s\" core=\"%s\"/>\n",
1090 buffer_xml_printf (buffer, "<thread id=\"%s\"/>\n",
1095 buffer_grow_str0 (buffer, "</threads>\n");
1098 /* Handle qXfer:threads:read. */
1101 handle_qxfer_threads (const char *annex,
1102 gdb_byte *readbuf, const gdb_byte *writebuf,
1103 ULONGEST offset, LONGEST len)
1105 static char *result = 0;
1106 static unsigned int result_length = 0;
1108 if (writebuf != NULL)
1111 if (!target_running () || annex[0] != '\0')
1116 struct buffer buffer;
1117 /* When asked for data at offset 0, generate everything and store into
1118 'result'. Successive reads will be served off 'result'. */
1122 buffer_init (&buffer);
1124 handle_qxfer_threads_proper (&buffer);
1126 result = buffer_finish (&buffer);
1127 result_length = strlen (result);
1128 buffer_free (&buffer);
1131 if (offset >= result_length)
1133 /* We're out of data. */
1140 if (len > result_length - offset)
1141 len = result_length - offset;
1143 memcpy (readbuf, result + offset, len);
1148 /* Handle qXfer:traceframe-info:read. */
1151 handle_qxfer_traceframe_info (const char *annex,
1152 gdb_byte *readbuf, const gdb_byte *writebuf,
1153 ULONGEST offset, LONGEST len)
1155 static char *result = 0;
1156 static unsigned int result_length = 0;
1158 if (writebuf != NULL)
1161 if (!target_running () || annex[0] != '\0' || current_traceframe == -1)
1166 struct buffer buffer;
1168 /* When asked for data at offset 0, generate everything and
1169 store into 'result'. Successive reads will be served off
1173 buffer_init (&buffer);
1175 traceframe_read_info (current_traceframe, &buffer);
1177 result = buffer_finish (&buffer);
1178 result_length = strlen (result);
1179 buffer_free (&buffer);
1182 if (offset >= result_length)
1184 /* We're out of data. */
1191 if (len > result_length - offset)
1192 len = result_length - offset;
1194 memcpy (readbuf, result + offset, len);
1198 /* Handle qXfer:fdpic:read. */
1201 handle_qxfer_fdpic (const char *annex, gdb_byte *readbuf,
1202 const gdb_byte *writebuf, ULONGEST offset, LONGEST len)
1204 if (the_target->read_loadmap == NULL)
1207 if (!target_running ())
1210 return (*the_target->read_loadmap) (annex, offset, readbuf, len);
1213 static const struct qxfer qxfer_packets[] =
1215 { "auxv", handle_qxfer_auxv },
1216 { "fdpic", handle_qxfer_fdpic},
1217 { "features", handle_qxfer_features },
1218 { "libraries", handle_qxfer_libraries },
1219 { "osdata", handle_qxfer_osdata },
1220 { "siginfo", handle_qxfer_siginfo },
1221 { "spu", handle_qxfer_spu },
1222 { "statictrace", handle_qxfer_statictrace },
1223 { "threads", handle_qxfer_threads },
1224 { "traceframe-info", handle_qxfer_traceframe_info },
1228 handle_qxfer (char *own_buf, int packet_len, int *new_packet_len_p)
1236 if (strncmp (own_buf, "qXfer:", 6) != 0)
1239 /* Grab the object, r/w and annex. */
1240 if (decode_xfer (own_buf + 6, &object, &rw, &annex, &offset) < 0)
1242 write_enn (own_buf);
1247 i < sizeof (qxfer_packets) / sizeof (qxfer_packets[0]);
1250 const struct qxfer *q = &qxfer_packets[i];
1252 if (strcmp (object, q->object) == 0)
1254 if (strcmp (rw, "read") == 0)
1256 unsigned char *data;
1261 /* Grab the offset and length. */
1262 if (decode_xfer_read (offset, &ofs, &len) < 0)
1264 write_enn (own_buf);
1268 /* Read one extra byte, as an indicator of whether there is
1270 if (len > PBUFSIZ - 2)
1272 data = malloc (len + 1);
1275 write_enn (own_buf);
1278 n = (*q->xfer) (annex, data, NULL, ofs, len + 1);
1285 write_enn (own_buf);
1287 *new_packet_len_p = write_qxfer_response (own_buf, data, len, 1);
1289 *new_packet_len_p = write_qxfer_response (own_buf, data, n, 0);
1294 else if (strcmp (rw, "write") == 0)
1299 unsigned char *data;
1301 strcpy (own_buf, "E00");
1302 data = malloc (packet_len - (offset - own_buf));
1305 write_enn (own_buf);
1308 if (decode_xfer_write (offset, packet_len - (offset - own_buf),
1309 &ofs, &len, data) < 0)
1312 write_enn (own_buf);
1316 n = (*q->xfer) (annex, NULL, data, ofs, len);
1323 write_enn (own_buf);
1325 sprintf (own_buf, "%x", n);
1338 /* Table used by the crc32 function to calcuate the checksum. */
1340 static unsigned int crc32_table[256] =
1343 /* Compute 32 bit CRC from inferior memory.
1345 On success, return 32 bit CRC.
1346 On failure, return (unsigned long long) -1. */
1348 static unsigned long long
1349 crc32 (CORE_ADDR base, int len, unsigned int crc)
1351 if (!crc32_table[1])
1353 /* Initialize the CRC table and the decoding table. */
1357 for (i = 0; i < 256; i++)
1359 for (c = i << 24, j = 8; j > 0; --j)
1360 c = c & 0x80000000 ? (c << 1) ^ 0x04c11db7 : (c << 1);
1367 unsigned char byte = 0;
1369 /* Return failure if memory read fails. */
1370 if (read_inferior_memory (base, &byte, 1) != 0)
1371 return (unsigned long long) -1;
1373 crc = (crc << 8) ^ crc32_table[((crc >> 24) ^ byte) & 255];
1376 return (unsigned long long) crc;
1379 /* Handle all of the extended 'q' packets. */
1382 handle_query (char *own_buf, int packet_len, int *new_packet_len_p)
1384 static struct inferior_list_entry *thread_ptr;
1386 /* Reply the current thread id. */
1387 if (strcmp ("qC", own_buf) == 0 && !disable_packet_qC)
1390 require_running (own_buf);
1392 if (!ptid_equal (general_thread, null_ptid)
1393 && !ptid_equal (general_thread, minus_one_ptid))
1394 gdb_id = general_thread;
1397 thread_ptr = all_threads.head;
1398 gdb_id = thread_to_gdb_id ((struct thread_info *)thread_ptr);
1401 sprintf (own_buf, "QC");
1403 write_ptid (own_buf, gdb_id);
1407 if (strcmp ("qSymbol::", own_buf) == 0)
1409 /* GDB is suggesting new symbols have been loaded. This may
1410 mean a new shared library has been detected as loaded, so
1411 take the opportunity to check if breakpoints we think are
1412 inserted, still are. Note that it isn't guaranteed that
1413 we'll see this when a shared library is loaded, and nor will
1414 we see this for unloads (although breakpoints in unloaded
1415 libraries shouldn't trigger), as GDB may not find symbols for
1416 the library at all. We also re-validate breakpoints when we
1417 see a second GDB breakpoint for the same address, and or when
1418 we access breakpoint shadows. */
1419 validate_breakpoints ();
1421 if (target_supports_tracepoints ())
1422 tracepoint_look_up_symbols ();
1424 if (target_running () && the_target->look_up_symbols != NULL)
1425 (*the_target->look_up_symbols) ();
1427 strcpy (own_buf, "OK");
1431 if (!disable_packet_qfThreadInfo)
1433 if (strcmp ("qfThreadInfo", own_buf) == 0)
1437 require_running (own_buf);
1438 thread_ptr = all_threads.head;
1441 gdb_id = thread_to_gdb_id ((struct thread_info *)thread_ptr);
1442 write_ptid (own_buf, gdb_id);
1443 thread_ptr = thread_ptr->next;
1447 if (strcmp ("qsThreadInfo", own_buf) == 0)
1451 require_running (own_buf);
1452 if (thread_ptr != NULL)
1455 gdb_id = thread_to_gdb_id ((struct thread_info *)thread_ptr);
1456 write_ptid (own_buf, gdb_id);
1457 thread_ptr = thread_ptr->next;
1462 sprintf (own_buf, "l");
1468 if (the_target->read_offsets != NULL
1469 && strcmp ("qOffsets", own_buf) == 0)
1471 CORE_ADDR text, data;
1473 require_running (own_buf);
1474 if (the_target->read_offsets (&text, &data))
1475 sprintf (own_buf, "Text=%lX;Data=%lX;Bss=%lX",
1476 (long)text, (long)data, (long)data);
1478 write_enn (own_buf);
1483 /* Protocol features query. */
1484 if (strncmp ("qSupported", own_buf, 10) == 0
1485 && (own_buf[10] == ':' || own_buf[10] == '\0'))
1487 char *p = &own_buf[10];
1488 int gdb_supports_qRelocInsn = 0;
1490 /* Start processing qSupported packet. */
1491 target_process_qsupported (NULL);
1493 /* Process each feature being provided by GDB. The first
1494 feature will follow a ':', and latter features will follow
1498 char **qsupported = NULL;
1502 /* Two passes, to avoid nested strtok calls in
1503 target_process_qsupported. */
1504 for (p = strtok (p + 1, ";");
1506 p = strtok (NULL, ";"))
1509 qsupported = xrealloc (qsupported, count * sizeof (char *));
1510 qsupported[count - 1] = xstrdup (p);
1513 for (i = 0; i < count; i++)
1516 if (strcmp (p, "multiprocess+") == 0)
1518 /* GDB supports and wants multi-process support if
1520 if (target_supports_multi_process ())
1523 else if (strcmp (p, "qRelocInsn+") == 0)
1525 /* GDB supports relocate instruction requests. */
1526 gdb_supports_qRelocInsn = 1;
1529 target_process_qsupported (p);
1537 sprintf (own_buf, "PacketSize=%x;QPassSignals+", PBUFSIZ - 1);
1539 /* We do not have any hook to indicate whether the target backend
1540 supports qXfer:libraries:read, so always report it. */
1541 strcat (own_buf, ";qXfer:libraries:read+");
1543 if (the_target->read_auxv != NULL)
1544 strcat (own_buf, ";qXfer:auxv:read+");
1546 if (the_target->qxfer_spu != NULL)
1547 strcat (own_buf, ";qXfer:spu:read+;qXfer:spu:write+");
1549 if (the_target->qxfer_siginfo != NULL)
1550 strcat (own_buf, ";qXfer:siginfo:read+;qXfer:siginfo:write+");
1552 if (the_target->read_loadmap != NULL)
1553 strcat (own_buf, ";qXfer:fdpic:read+");
1555 /* We always report qXfer:features:read, as targets may
1556 install XML files on a subsequent call to arch_setup.
1557 If we reported to GDB on startup that we don't support
1558 qXfer:feature:read at all, we will never be re-queried. */
1559 strcat (own_buf, ";qXfer:features:read+");
1561 if (transport_is_reliable)
1562 strcat (own_buf, ";QStartNoAckMode+");
1564 if (the_target->qxfer_osdata != NULL)
1565 strcat (own_buf, ";qXfer:osdata:read+");
1567 if (target_supports_multi_process ())
1568 strcat (own_buf, ";multiprocess+");
1570 if (target_supports_non_stop ())
1571 strcat (own_buf, ";QNonStop+");
1573 if (target_supports_disable_randomization ())
1574 strcat (own_buf, ";QDisableRandomization+");
1576 strcat (own_buf, ";qXfer:threads:read+");
1578 if (target_supports_tracepoints ())
1580 strcat (own_buf, ";ConditionalTracepoints+");
1581 strcat (own_buf, ";TraceStateVariables+");
1582 strcat (own_buf, ";TracepointSource+");
1583 strcat (own_buf, ";DisconnectedTracing+");
1584 if (gdb_supports_qRelocInsn && target_supports_fast_tracepoints ())
1585 strcat (own_buf, ";FastTracepoints+");
1586 strcat (own_buf, ";StaticTracepoints+");
1587 strcat (own_buf, ";InstallInTrace+");
1588 strcat (own_buf, ";qXfer:statictrace:read+");
1589 strcat (own_buf, ";qXfer:traceframe-info:read+");
1590 strcat (own_buf, ";EnableDisableTracepoints+");
1591 strcat (own_buf, ";tracenz+");
1597 /* Thread-local storage support. */
1598 if (the_target->get_tls_address != NULL
1599 && strncmp ("qGetTLSAddr:", own_buf, 12) == 0)
1601 char *p = own_buf + 12;
1602 CORE_ADDR parts[2], address = 0;
1604 ptid_t ptid = null_ptid;
1606 require_running (own_buf);
1608 for (i = 0; i < 3; i++)
1616 p2 = strchr (p, ',');
1629 ptid = read_ptid (p, NULL);
1631 decode_address (&parts[i - 1], p, len);
1635 if (p != NULL || i < 3)
1639 struct thread_info *thread = find_thread_ptid (ptid);
1644 err = the_target->get_tls_address (thread, parts[0], parts[1],
1650 strcpy (own_buf, paddress(address));
1655 write_enn (own_buf);
1659 /* Otherwise, pretend we do not understand this packet. */
1662 /* Windows OS Thread Information Block address support. */
1663 if (the_target->get_tib_address != NULL
1664 && strncmp ("qGetTIBAddr:", own_buf, 12) == 0)
1669 ptid_t ptid = read_ptid (own_buf + 12, &annex);
1671 n = (*the_target->get_tib_address) (ptid, &tlb);
1674 strcpy (own_buf, paddress(tlb));
1679 write_enn (own_buf);
1685 /* Handle "monitor" commands. */
1686 if (strncmp ("qRcmd,", own_buf, 6) == 0)
1688 char *mon = malloc (PBUFSIZ);
1689 int len = strlen (own_buf + 6);
1693 write_enn (own_buf);
1697 if ((len % 2) != 0 || unhexify (mon, own_buf + 6, len / 2) != len / 2)
1699 write_enn (own_buf);
1703 mon[len / 2] = '\0';
1707 if (the_target->handle_monitor_command == NULL
1708 || (*the_target->handle_monitor_command) (mon) == 0)
1709 /* Default processing. */
1710 handle_monitor_command (mon);
1716 if (strncmp ("qSearch:memory:", own_buf,
1717 sizeof ("qSearch:memory:") - 1) == 0)
1719 require_running (own_buf);
1720 handle_search_memory (own_buf, packet_len);
1724 if (strcmp (own_buf, "qAttached") == 0
1725 || strncmp (own_buf, "qAttached:", sizeof ("qAttached:") - 1) == 0)
1727 struct process_info *process;
1729 if (own_buf[sizeof ("qAttached") - 1])
1731 int pid = strtoul (own_buf + sizeof ("qAttached:") - 1, NULL, 16);
1732 process = (struct process_info *)
1733 find_inferior_id (&all_processes, pid_to_ptid (pid));
1737 require_running (own_buf);
1738 process = current_process ();
1741 if (process == NULL)
1743 write_enn (own_buf);
1747 strcpy (own_buf, process->attached ? "1" : "0");
1751 if (strncmp ("qCRC:", own_buf, 5) == 0)
1753 /* CRC check (compare-section). */
1757 unsigned long long crc;
1759 require_running (own_buf);
1760 base = strtoul (own_buf + 5, &comma, 16);
1761 if (*comma++ != ',')
1763 write_enn (own_buf);
1766 len = strtoul (comma, NULL, 16);
1767 crc = crc32 (base, len, 0xffffffff);
1768 /* Check for memory failure. */
1769 if (crc == (unsigned long long) -1)
1771 write_enn (own_buf);
1774 sprintf (own_buf, "C%lx", (unsigned long) crc);
1778 if (handle_qxfer (own_buf, packet_len, new_packet_len_p))
1781 if (target_supports_tracepoints () && handle_tracepoint_query (own_buf))
1784 /* Otherwise we didn't know what packet it was. Say we didn't
1789 static void gdb_wants_all_threads_stopped (void);
1791 /* Parse vCont packets. */
1793 handle_v_cont (char *own_buf)
1797 struct thread_resume *resume_info;
1798 struct thread_resume default_action = {{0}};
1800 /* Count the number of semicolons in the packet. There should be one
1801 for every action. */
1807 p = strchr (p, ';');
1810 resume_info = malloc (n * sizeof (resume_info[0]));
1811 if (resume_info == NULL)
1819 if (p[0] == 's' || p[0] == 'S')
1820 resume_info[i].kind = resume_step;
1821 else if (p[0] == 'c' || p[0] == 'C')
1822 resume_info[i].kind = resume_continue;
1823 else if (p[0] == 't')
1824 resume_info[i].kind = resume_stop;
1828 if (p[0] == 'S' || p[0] == 'C')
1831 sig = strtol (p + 1, &q, 16);
1836 if (!target_signal_to_host_p (sig))
1838 resume_info[i].sig = target_signal_to_host (sig);
1842 resume_info[i].sig = 0;
1848 resume_info[i].thread = minus_one_ptid;
1849 default_action = resume_info[i];
1851 /* Note: we don't increment i here, we'll overwrite this entry
1852 the next time through. */
1854 else if (p[0] == ':')
1856 ptid_t ptid = read_ptid (p + 1, &q);
1861 if (p[0] != ';' && p[0] != 0)
1864 resume_info[i].thread = ptid;
1871 resume_info[i] = default_action;
1873 /* Still used in occasional places in the backend. */
1875 && !ptid_equal (resume_info[0].thread, minus_one_ptid)
1876 && resume_info[0].kind != resume_stop)
1877 cont_thread = resume_info[0].thread;
1879 cont_thread = minus_one_ptid;
1880 set_desired_inferior (0);
1885 (*the_target->resume) (resume_info, n);
1893 last_ptid = mywait (minus_one_ptid, &last_status, 0, 1);
1895 if (last_status.kind != TARGET_WAITKIND_EXITED
1896 && last_status.kind != TARGET_WAITKIND_SIGNALLED)
1897 current_inferior->last_status = last_status;
1899 /* From the client's perspective, all-stop mode always stops all
1900 threads implicitly (and the target backend has already done
1901 so by now). Tag all threads as "want-stopped", so we don't
1902 resume them implicitly without the client telling us to. */
1903 gdb_wants_all_threads_stopped ();
1904 prepare_resume_reply (own_buf, last_ptid, &last_status);
1905 disable_async_io ();
1907 if (last_status.kind == TARGET_WAITKIND_EXITED
1908 || last_status.kind == TARGET_WAITKIND_SIGNALLED)
1909 mourn_inferior (find_process_pid (ptid_get_pid (last_ptid)));
1914 write_enn (own_buf);
1919 /* Attach to a new program. Return 1 if successful, 0 if failure. */
1921 handle_v_attach (char *own_buf)
1925 pid = strtol (own_buf + 8, NULL, 16);
1926 if (pid != 0 && attach_inferior (pid) == 0)
1928 /* Don't report shared library events after attaching, even if
1929 some libraries are preloaded. GDB will always poll the
1930 library list. Avoids the "stopped by shared library event"
1931 notice on the GDB side. */
1936 /* In non-stop, we don't send a resume reply. Stop events
1937 will follow up using the normal notification
1942 prepare_resume_reply (own_buf, last_ptid, &last_status);
1948 write_enn (own_buf);
1953 /* Run a new program. Return 1 if successful, 0 if failure. */
1955 handle_v_run (char *own_buf)
1957 char *p, *next_p, **new_argv;
1961 for (p = own_buf + strlen ("vRun;"); p && *p; p = strchr (p, ';'))
1967 new_argv = calloc (new_argc + 2, sizeof (char *));
1968 if (new_argv == NULL)
1970 write_enn (own_buf);
1975 for (p = own_buf + strlen ("vRun;"); *p; p = next_p)
1977 next_p = strchr (p, ';');
1979 next_p = p + strlen (p);
1981 if (i == 0 && p == next_p)
1985 /* FIXME: Fail request if out of memory instead of dying. */
1986 new_argv[i] = xmalloc (1 + (next_p - p) / 2);
1987 unhexify (new_argv[i], p, (next_p - p) / 2);
1988 new_argv[i][(next_p - p) / 2] = '\0';
1997 if (new_argv[0] == NULL)
1999 /* GDB didn't specify a program to run. Use the program from the
2000 last run with the new argument list. */
2002 if (program_argv == NULL)
2004 write_enn (own_buf);
2005 freeargv (new_argv);
2009 new_argv[0] = strdup (program_argv[0]);
2010 if (new_argv[0] == NULL)
2012 write_enn (own_buf);
2013 freeargv (new_argv);
2018 /* Free the old argv and install the new one. */
2019 freeargv (program_argv);
2020 program_argv = new_argv;
2022 start_inferior (program_argv);
2023 if (last_status.kind == TARGET_WAITKIND_STOPPED)
2025 prepare_resume_reply (own_buf, last_ptid, &last_status);
2027 /* In non-stop, sending a resume reply doesn't set the general
2028 thread, but GDB assumes a vRun sets it (this is so GDB can
2029 query which is the main thread of the new inferior. */
2031 general_thread = last_ptid;
2037 write_enn (own_buf);
2042 /* Kill process. Return 1 if successful, 0 if failure. */
2044 handle_v_kill (char *own_buf)
2047 char *p = &own_buf[6];
2049 pid = strtol (p, NULL, 16);
2052 if (pid != 0 && kill_inferior (pid) == 0)
2054 last_status.kind = TARGET_WAITKIND_SIGNALLED;
2055 last_status.value.sig = TARGET_SIGNAL_KILL;
2056 last_ptid = pid_to_ptid (pid);
2057 discard_queued_stop_replies (pid);
2063 write_enn (own_buf);
2068 /* Handle a 'vStopped' packet. */
2070 handle_v_stopped (char *own_buf)
2072 /* If we're waiting for GDB to acknowledge a pending stop reply,
2073 consider that done. */
2076 struct vstop_notif *head;
2079 fprintf (stderr, "vStopped: acking %s\n",
2080 target_pid_to_str (notif_queue->ptid));
2083 notif_queue = notif_queue->next;
2087 /* Push another stop reply, or if there are no more left, an OK. */
2088 send_next_stop_reply (own_buf);
2091 /* Handle all of the extended 'v' packets. */
2093 handle_v_requests (char *own_buf, int packet_len, int *new_packet_len)
2095 if (!disable_packet_vCont)
2097 if (strncmp (own_buf, "vCont;", 6) == 0)
2099 require_running (own_buf);
2100 handle_v_cont (own_buf);
2104 if (strncmp (own_buf, "vCont?", 6) == 0)
2106 strcpy (own_buf, "vCont;c;C;s;S;t");
2111 if (strncmp (own_buf, "vFile:", 6) == 0
2112 && handle_vFile (own_buf, packet_len, new_packet_len))
2115 if (strncmp (own_buf, "vAttach;", 8) == 0)
2117 if (!multi_process && target_running ())
2119 fprintf (stderr, "Already debugging a process\n");
2120 write_enn (own_buf);
2123 handle_v_attach (own_buf);
2127 if (strncmp (own_buf, "vRun;", 5) == 0)
2129 if (!multi_process && target_running ())
2131 fprintf (stderr, "Already debugging a process\n");
2132 write_enn (own_buf);
2135 handle_v_run (own_buf);
2139 if (strncmp (own_buf, "vKill;", 6) == 0)
2141 if (!target_running ())
2143 fprintf (stderr, "No process to kill\n");
2144 write_enn (own_buf);
2147 handle_v_kill (own_buf);
2151 if (strncmp (own_buf, "vStopped", 8) == 0)
2153 handle_v_stopped (own_buf);
2157 /* Otherwise we didn't know what packet it was. Say we didn't
2163 /* Resume inferior and wait for another event. In non-stop mode,
2164 don't really wait here, but return immediatelly to the event
2167 myresume (char *own_buf, int step, int sig)
2169 struct thread_resume resume_info[2];
2171 int valid_cont_thread;
2173 set_desired_inferior (0);
2175 valid_cont_thread = (!ptid_equal (cont_thread, null_ptid)
2176 && !ptid_equal (cont_thread, minus_one_ptid));
2178 if (step || sig || valid_cont_thread)
2180 resume_info[0].thread
2181 = ((struct inferior_list_entry *) current_inferior)->id;
2183 resume_info[0].kind = resume_step;
2185 resume_info[0].kind = resume_continue;
2186 resume_info[0].sig = sig;
2190 if (!valid_cont_thread)
2192 resume_info[n].thread = minus_one_ptid;
2193 resume_info[n].kind = resume_continue;
2194 resume_info[n].sig = 0;
2201 (*the_target->resume) (resume_info, n);
2207 last_ptid = mywait (minus_one_ptid, &last_status, 0, 1);
2209 if (last_status.kind != TARGET_WAITKIND_EXITED
2210 && last_status.kind != TARGET_WAITKIND_SIGNALLED)
2212 current_inferior->last_resume_kind = resume_stop;
2213 current_inferior->last_status = last_status;
2216 prepare_resume_reply (own_buf, last_ptid, &last_status);
2217 disable_async_io ();
2219 if (last_status.kind == TARGET_WAITKIND_EXITED
2220 || last_status.kind == TARGET_WAITKIND_SIGNALLED)
2221 mourn_inferior (find_process_pid (ptid_get_pid (last_ptid)));
2225 /* Callback for for_each_inferior. Make a new stop reply for each
2229 queue_stop_reply_callback (struct inferior_list_entry *entry, void *arg)
2231 struct thread_info *thread = (struct thread_info *) entry;
2233 /* For now, assume targets that don't have this callback also don't
2234 manage the thread's last_status field. */
2235 if (the_target->thread_stopped == NULL)
2237 /* Pass the last stop reply back to GDB, but don't notify
2239 queue_stop_reply (entry->id, &thread->last_status);
2243 if (thread_stopped (thread))
2247 "Reporting thread %s as already stopped with %s\n",
2248 target_pid_to_str (entry->id),
2249 target_waitstatus_to_string (&thread->last_status));
2251 gdb_assert (thread->last_status.kind != TARGET_WAITKIND_IGNORE);
2253 /* Pass the last stop reply back to GDB, but don't notify
2255 queue_stop_reply (entry->id, &thread->last_status);
2262 /* Set this inferior threads's state as "want-stopped". We won't
2263 resume this thread until the client gives us another action for
2267 gdb_wants_thread_stopped (struct inferior_list_entry *entry)
2269 struct thread_info *thread = (struct thread_info *) entry;
2271 thread->last_resume_kind = resume_stop;
2273 if (thread->last_status.kind == TARGET_WAITKIND_IGNORE)
2275 /* Most threads are stopped implicitly (all-stop); tag that with
2277 thread->last_status.kind = TARGET_WAITKIND_STOPPED;
2278 thread->last_status.value.sig = TARGET_SIGNAL_0;
2282 /* Set all threads' states as "want-stopped". */
2285 gdb_wants_all_threads_stopped (void)
2287 for_each_inferior (&all_threads, gdb_wants_thread_stopped);
2290 /* Clear the gdb_detached flag of every process. */
2293 gdb_reattached_process (struct inferior_list_entry *entry)
2295 struct process_info *process = (struct process_info *) entry;
2297 process->gdb_detached = 0;
2300 /* Status handler for the '?' packet. */
2303 handle_status (char *own_buf)
2305 /* GDB is connected, don't forward events to the target anymore. */
2306 for_each_inferior (&all_processes, gdb_reattached_process);
2308 /* In non-stop mode, we must send a stop reply for each stopped
2309 thread. In all-stop mode, just send one for the first stopped
2314 discard_queued_stop_replies (-1);
2315 find_inferior (&all_threads, queue_stop_reply_callback, NULL);
2317 /* The first is sent immediatly. OK is sent if there is no
2318 stopped thread, which is the same handling of the vStopped
2319 packet (by design). */
2320 send_next_stop_reply (own_buf);
2325 stabilize_threads ();
2326 gdb_wants_all_threads_stopped ();
2328 if (all_threads.head)
2330 struct target_waitstatus status;
2332 status.kind = TARGET_WAITKIND_STOPPED;
2333 status.value.sig = TARGET_SIGNAL_TRAP;
2334 prepare_resume_reply (own_buf,
2335 all_threads.head->id, &status);
2338 strcpy (own_buf, "W00");
2343 gdbserver_version (void)
2345 printf ("GNU gdbserver %s%s\n"
2346 "Copyright (C) 2011 Free Software Foundation, Inc.\n"
2347 "gdbserver is free software, covered by the "
2348 "GNU General Public License.\n"
2349 "This gdbserver was configured as \"%s\"\n",
2350 PKGVERSION, version, host_name);
2354 gdbserver_usage (FILE *stream)
2356 fprintf (stream, "Usage:\tgdbserver [OPTIONS] COMM PROG [ARGS ...]\n"
2357 "\tgdbserver [OPTIONS] --attach COMM PID\n"
2358 "\tgdbserver [OPTIONS] --multi COMM\n"
2360 "COMM may either be a tty device (for serial debugging), or \n"
2361 "HOST:PORT to listen for a TCP connection.\n"
2364 " --debug Enable general debugging output.\n"
2365 " --remote-debug Enable remote protocol debugging output.\n"
2366 " --version Display version information and exit.\n"
2367 " --wrapper WRAPPER -- Run WRAPPER to start new programs.\n"
2368 " --once Exit after the first connection has "
2370 if (REPORT_BUGS_TO[0] && stream == stdout)
2371 fprintf (stream, "Report bugs to \"%s\".\n", REPORT_BUGS_TO);
2375 gdbserver_show_disableable (FILE *stream)
2377 fprintf (stream, "Disableable packets:\n"
2378 " vCont \tAll vCont packets\n"
2379 " qC \tQuerying the current thread\n"
2380 " qfThreadInfo\tThread listing\n"
2381 " Tthread \tPassing the thread specifier in the "
2382 "T stop reply packet\n"
2383 " threads \tAll of the above\n");
2387 #undef require_running
2388 #define require_running(BUF) \
2389 if (!target_running ()) \
2396 first_thread_of (struct inferior_list_entry *entry, void *args)
2398 int pid = * (int *) args;
2400 if (ptid_get_pid (entry->id) == pid)
2407 kill_inferior_callback (struct inferior_list_entry *entry)
2409 struct process_info *process = (struct process_info *) entry;
2410 int pid = ptid_get_pid (process->head.id);
2412 kill_inferior (pid);
2413 discard_queued_stop_replies (pid);
2416 /* Callback for for_each_inferior to detach or kill the inferior,
2417 depending on whether we attached to it or not.
2418 We inform the user whether we're detaching or killing the process
2419 as this is only called when gdbserver is about to exit. */
2422 detach_or_kill_inferior_callback (struct inferior_list_entry *entry)
2424 struct process_info *process = (struct process_info *) entry;
2425 int pid = ptid_get_pid (process->head.id);
2427 if (process->attached)
2428 detach_inferior (pid);
2430 kill_inferior (pid);
2432 discard_queued_stop_replies (pid);
2435 /* for_each_inferior callback for detach_or_kill_for_exit to print
2436 the pids of started inferiors. */
2439 print_started_pid (struct inferior_list_entry *entry)
2441 struct process_info *process = (struct process_info *) entry;
2443 if (! process->attached)
2445 int pid = ptid_get_pid (process->head.id);
2446 fprintf (stderr, " %d", pid);
2450 /* for_each_inferior callback for detach_or_kill_for_exit to print
2451 the pids of attached inferiors. */
2454 print_attached_pid (struct inferior_list_entry *entry)
2456 struct process_info *process = (struct process_info *) entry;
2458 if (process->attached)
2460 int pid = ptid_get_pid (process->head.id);
2461 fprintf (stderr, " %d", pid);
2465 /* Call this when exiting gdbserver with possible inferiors that need
2466 to be killed or detached from. */
2469 detach_or_kill_for_exit (void)
2471 /* First print a list of the inferiors we will be killing/detaching.
2472 This is to assist the user, for example, in case the inferior unexpectedly
2473 dies after we exit: did we screw up or did the inferior exit on its own?
2474 Having this info will save some head-scratching. */
2476 if (have_started_inferiors_p ())
2478 fprintf (stderr, "Killing process(es):");
2479 for_each_inferior (&all_processes, print_started_pid);
2480 fprintf (stderr, "\n");
2482 if (have_attached_inferiors_p ())
2484 fprintf (stderr, "Detaching process(es):");
2485 for_each_inferior (&all_processes, print_attached_pid);
2486 fprintf (stderr, "\n");
2489 /* Now we can kill or detach the inferiors. */
2491 for_each_inferior (&all_processes, detach_or_kill_inferior_callback);
2495 main (int argc, char *argv[])
2499 char *arg_end, *port;
2500 char **next_arg = &argv[1];
2505 while (*next_arg != NULL && **next_arg == '-')
2507 if (strcmp (*next_arg, "--version") == 0)
2509 gdbserver_version ();
2512 else if (strcmp (*next_arg, "--help") == 0)
2514 gdbserver_usage (stdout);
2517 else if (strcmp (*next_arg, "--attach") == 0)
2519 else if (strcmp (*next_arg, "--multi") == 0)
2521 else if (strcmp (*next_arg, "--wrapper") == 0)
2525 wrapper_argv = next_arg;
2526 while (*next_arg != NULL && strcmp (*next_arg, "--") != 0)
2529 if (next_arg == wrapper_argv || *next_arg == NULL)
2531 gdbserver_usage (stderr);
2535 /* Consume the "--". */
2538 else if (strcmp (*next_arg, "--debug") == 0)
2540 else if (strcmp (*next_arg, "--remote-debug") == 0)
2542 else if (strcmp (*next_arg, "--disable-packet") == 0)
2544 gdbserver_show_disableable (stdout);
2547 else if (strncmp (*next_arg,
2548 "--disable-packet=",
2549 sizeof ("--disable-packet=") - 1) == 0)
2551 char *packets, *tok;
2553 packets = *next_arg += sizeof ("--disable-packet=") - 1;
2554 for (tok = strtok (packets, ",");
2556 tok = strtok (NULL, ","))
2558 if (strcmp ("vCont", tok) == 0)
2559 disable_packet_vCont = 1;
2560 else if (strcmp ("Tthread", tok) == 0)
2561 disable_packet_Tthread = 1;
2562 else if (strcmp ("qC", tok) == 0)
2563 disable_packet_qC = 1;
2564 else if (strcmp ("qfThreadInfo", tok) == 0)
2565 disable_packet_qfThreadInfo = 1;
2566 else if (strcmp ("threads", tok) == 0)
2568 disable_packet_vCont = 1;
2569 disable_packet_Tthread = 1;
2570 disable_packet_qC = 1;
2571 disable_packet_qfThreadInfo = 1;
2575 fprintf (stderr, "Don't know how to disable \"%s\".\n\n",
2577 gdbserver_show_disableable (stderr);
2582 else if (strcmp (*next_arg, "--disable-randomization") == 0)
2583 disable_randomization = 1;
2584 else if (strcmp (*next_arg, "--no-disable-randomization") == 0)
2585 disable_randomization = 0;
2586 else if (strcmp (*next_arg, "--once") == 0)
2590 fprintf (stderr, "Unknown argument: %s\n", *next_arg);
2598 if (setjmp (toplevel))
2600 fprintf (stderr, "Exiting\n");
2606 if (port == NULL || (!attach && !multi_mode && *next_arg == NULL))
2608 gdbserver_usage (stderr);
2615 /* --attach used to come after PORT, so allow it there for
2617 if (*next_arg != NULL && strcmp (*next_arg, "--attach") == 0)
2624 && (*next_arg == NULL
2625 || (*next_arg)[0] == '\0'
2626 || (pid = strtoul (*next_arg, &arg_end, 0)) == 0
2628 || next_arg[1] != NULL))
2633 gdbserver_usage (stderr);
2637 initialize_async_io ();
2639 if (target_supports_tracepoints ())
2640 initialize_tracepoint ();
2642 own_buf = xmalloc (PBUFSIZ + 1);
2643 mem_buf = xmalloc (PBUFSIZ);
2645 if (pid == 0 && *next_arg != NULL)
2649 n = argc - (next_arg - argv);
2650 program_argv = xmalloc (sizeof (char *) * (n + 1));
2651 for (i = 0; i < n; i++)
2652 program_argv[i] = xstrdup (next_arg[i]);
2653 program_argv[i] = NULL;
2655 /* Wait till we are at first instruction in program. */
2656 start_inferior (program_argv);
2658 /* We are now (hopefully) stopped at the first instruction of
2659 the target process. This assumes that the target process was
2660 successfully created. */
2664 if (attach_inferior (pid) == -1)
2665 error ("Attaching not supported on this target");
2667 /* Otherwise succeeded. */
2671 last_status.kind = TARGET_WAITKIND_EXITED;
2672 last_status.value.integer = 0;
2673 last_ptid = minus_one_ptid;
2676 /* Don't report shared library events on the initial connection,
2677 even if some libraries are preloaded. Avoids the "stopped by
2678 shared library event" notice on gdb side. */
2681 if (setjmp (toplevel))
2683 detach_or_kill_for_exit ();
2687 if (last_status.kind == TARGET_WAITKIND_EXITED
2688 || last_status.kind == TARGET_WAITKIND_SIGNALLED)
2693 if (!was_running && !multi_mode)
2695 fprintf (stderr, "No program to debug. GDBserver exiting.\n");
2699 remote_prepare (port);
2705 /* Be sure we're out of tfind mode. */
2706 current_traceframe = -1;
2710 if (setjmp (toplevel) != 0)
2712 /* An error occurred. */
2713 if (response_needed)
2715 write_enn (own_buf);
2720 /* Wait for events. This will return when all event sources are
2721 removed from the event loop. */
2722 start_event_loop ();
2724 /* If an exit was requested (using the "monitor exit" command),
2725 terminate now. The only other way to get here is for
2726 getpkt to fail; close the connection and reopen it at the
2729 if (exit_requested || run_once)
2731 detach_or_kill_for_exit ();
2736 "Remote side has terminated connection. "
2737 "GDBserver will reopen the connection.\n");
2741 if (disconnected_tracing)
2743 /* Try to enable non-stop/async mode, so we we can both
2744 wait for an async socket accept, and handle async
2745 target events simultaneously. There's also no point
2746 either in having the target always stop all threads,
2747 when we're going to pass signals down without
2751 if (start_non_stop (1))
2754 /* Detaching implicitly resumes all threads; simply
2755 disconnecting does not. */
2761 "Disconnected tracing disabled; stopping trace run.\n");
2768 /* Event loop callback that handles a serial event. The first byte in
2769 the serial buffer gets us here. We expect characters to arrive at
2770 a brisk pace, so we read the rest of the packet with a blocking
2774 process_serial_event (void)
2785 int new_packet_len = -1;
2787 /* Used to decide when gdbserver should exit in
2788 multi-mode/remote. */
2789 static int have_ran = 0;
2792 have_ran = target_running ();
2794 disable_async_io ();
2796 response_needed = 0;
2797 packet_len = getpkt (own_buf);
2798 if (packet_len <= 0)
2801 /* Force an event loop break. */
2804 response_needed = 1;
2811 handle_query (own_buf, packet_len, &new_packet_len);
2814 handle_general_set (own_buf);
2817 require_running (own_buf);
2822 pid = strtol (&own_buf[i], NULL, 16);
2826 ptid_get_pid (((struct inferior_list_entry *) current_inferior)->id);
2828 if (tracing && disconnected_tracing)
2830 struct thread_resume resume_info;
2831 struct process_info *process = find_process_pid (pid);
2833 if (process == NULL)
2835 write_enn (own_buf);
2840 "Disconnected tracing in effect, "
2841 "leaving gdbserver attached to the process\n");
2843 /* Make sure we're in non-stop/async mode, so we we can both
2844 wait for an async socket accept, and handle async target
2845 events simultaneously. There's also no point either in
2846 having the target stop all threads, when we're going to
2847 pass signals down without informing GDB. */
2851 fprintf (stderr, "Forcing non-stop mode\n");
2857 process->gdb_detached = 1;
2859 /* Detaching implicitly resumes all threads. */
2860 resume_info.thread = minus_one_ptid;
2861 resume_info.kind = resume_continue;
2862 resume_info.sig = 0;
2863 (*the_target->resume) (&resume_info, 1);
2866 break; /* from switch/case */
2869 fprintf (stderr, "Detaching from process %d\n", pid);
2871 if (detach_inferior (pid) != 0)
2872 write_enn (own_buf);
2875 discard_queued_stop_replies (pid);
2878 if (extended_protocol)
2880 /* Treat this like a normal program exit. */
2881 last_status.kind = TARGET_WAITKIND_EXITED;
2882 last_status.value.integer = 0;
2883 last_ptid = pid_to_ptid (pid);
2885 current_inferior = NULL;
2892 /* If we are attached, then we can exit. Otherwise, we
2893 need to hang around doing nothing, until the child is
2895 join_inferior (pid);
2901 extended_protocol = 1;
2905 handle_status (own_buf);
2908 if (own_buf[1] == 'c' || own_buf[1] == 'g' || own_buf[1] == 's')
2910 ptid_t gdb_id, thread_id;
2913 require_running (own_buf);
2915 gdb_id = read_ptid (&own_buf[2], NULL);
2917 pid = ptid_get_pid (gdb_id);
2919 if (ptid_equal (gdb_id, null_ptid)
2920 || ptid_equal (gdb_id, minus_one_ptid))
2921 thread_id = null_ptid;
2923 && ptid_equal (pid_to_ptid (pid),
2926 struct thread_info *thread =
2927 (struct thread_info *) find_inferior (&all_threads,
2932 write_enn (own_buf);
2936 thread_id = ((struct inferior_list_entry *)thread)->id;
2940 thread_id = gdb_id_to_thread_id (gdb_id);
2941 if (ptid_equal (thread_id, null_ptid))
2943 write_enn (own_buf);
2948 if (own_buf[1] == 'g')
2950 if (ptid_equal (thread_id, null_ptid))
2952 /* GDB is telling us to choose any thread. Check if
2953 the currently selected thread is still valid. If
2954 it is not, select the first available. */
2955 struct thread_info *thread =
2956 (struct thread_info *) find_inferior_id (&all_threads,
2959 thread_id = all_threads.head->id;
2962 general_thread = thread_id;
2963 set_desired_inferior (1);
2965 else if (own_buf[1] == 'c')
2966 cont_thread = thread_id;
2972 /* Silently ignore it so that gdb can extend the protocol
2973 without compatibility headaches. */
2978 require_running (own_buf);
2979 if (current_traceframe >= 0)
2981 struct regcache *regcache = new_register_cache ();
2983 if (fetch_traceframe_registers (current_traceframe,
2985 registers_to_string (regcache, own_buf);
2987 write_enn (own_buf);
2988 free_register_cache (regcache);
2992 struct regcache *regcache;
2994 set_desired_inferior (1);
2995 regcache = get_thread_regcache (current_inferior, 1);
2996 registers_to_string (regcache, own_buf);
3000 require_running (own_buf);
3001 if (current_traceframe >= 0)
3002 write_enn (own_buf);
3005 struct regcache *regcache;
3007 set_desired_inferior (1);
3008 regcache = get_thread_regcache (current_inferior, 1);
3009 registers_from_string (regcache, &own_buf[1]);
3014 require_running (own_buf);
3015 decode_m_packet (&own_buf[1], &mem_addr, &len);
3016 res = gdb_read_memory (mem_addr, mem_buf, len);
3018 write_enn (own_buf);
3020 convert_int_to_ascii (mem_buf, own_buf, res);
3023 require_running (own_buf);
3024 decode_M_packet (&own_buf[1], &mem_addr, &len, &mem_buf);
3025 if (gdb_write_memory (mem_addr, mem_buf, len) == 0)
3028 write_enn (own_buf);
3031 require_running (own_buf);
3032 if (decode_X_packet (&own_buf[1], packet_len - 1,
3033 &mem_addr, &len, &mem_buf) < 0
3034 || gdb_write_memory (mem_addr, mem_buf, len) != 0)
3035 write_enn (own_buf);
3040 require_running (own_buf);
3041 convert_ascii_to_int (own_buf + 1, &sig, 1);
3042 if (target_signal_to_host_p (sig))
3043 signal = target_signal_to_host (sig);
3046 myresume (own_buf, 0, signal);
3049 require_running (own_buf);
3050 convert_ascii_to_int (own_buf + 1, &sig, 1);
3051 if (target_signal_to_host_p (sig))
3052 signal = target_signal_to_host (sig);
3055 myresume (own_buf, 1, signal);
3058 require_running (own_buf);
3060 myresume (own_buf, 0, signal);
3063 require_running (own_buf);
3065 myresume (own_buf, 1, signal);
3067 case 'Z': /* insert_ ... */
3069 case 'z': /* remove_ ... */
3073 CORE_ADDR addr = strtoul (&own_buf[3], &lenptr, 16);
3074 int len = strtol (lenptr + 1, &dataptr, 16);
3075 char type = own_buf[1];
3077 const int insert = ch == 'Z';
3079 /* Default to unrecognized/unsupported. */
3083 case '0': /* software-breakpoint */
3084 case '1': /* hardware-breakpoint */
3085 case '2': /* write watchpoint */
3086 case '3': /* read watchpoint */
3087 case '4': /* access watchpoint */
3088 require_running (own_buf);
3089 if (insert && the_target->insert_point != NULL)
3090 res = (*the_target->insert_point) (type, addr, len);
3091 else if (!insert && the_target->remove_point != NULL)
3092 res = (*the_target->remove_point) (type, addr, len);
3104 write_enn (own_buf);
3108 response_needed = 0;
3109 if (!target_running ())
3110 /* The packet we received doesn't make sense - but we can't
3111 reply to it, either. */
3114 fprintf (stderr, "Killing all inferiors\n");
3115 for_each_inferior (&all_processes, kill_inferior_callback);
3117 /* When using the extended protocol, we wait with no program
3118 running. The traditional protocol will exit instead. */
3119 if (extended_protocol)
3121 last_status.kind = TARGET_WAITKIND_EXITED;
3122 last_status.value.sig = TARGET_SIGNAL_KILL;
3130 ptid_t gdb_id, thread_id;
3132 require_running (own_buf);
3134 gdb_id = read_ptid (&own_buf[1], NULL);
3135 thread_id = gdb_id_to_thread_id (gdb_id);
3136 if (ptid_equal (thread_id, null_ptid))
3138 write_enn (own_buf);
3142 if (mythread_alive (thread_id))
3145 write_enn (own_buf);
3149 response_needed = 0;
3151 /* Restarting the inferior is only supported in the extended
3153 if (extended_protocol)
3155 if (target_running ())
3156 for_each_inferior (&all_processes,
3157 kill_inferior_callback);
3158 fprintf (stderr, "GDBserver restarting\n");
3160 /* Wait till we are at 1st instruction in prog. */
3161 if (program_argv != NULL)
3162 start_inferior (program_argv);
3165 last_status.kind = TARGET_WAITKIND_EXITED;
3166 last_status.value.sig = TARGET_SIGNAL_KILL;
3172 /* It is a request we don't understand. Respond with an
3173 empty packet so that gdb knows that we don't support this
3179 /* Extended (long) request. */
3180 handle_v_requests (own_buf, packet_len, &new_packet_len);
3184 /* It is a request we don't understand. Respond with an empty
3185 packet so that gdb knows that we don't support this
3191 if (new_packet_len != -1)
3192 putpkt_binary (own_buf, new_packet_len);
3196 response_needed = 0;
3198 if (!extended_protocol && have_ran && !target_running ())
3200 /* In non-stop, defer exiting until GDB had a chance to query
3201 the whole vStopped list (until it gets an OK). */
3204 fprintf (stderr, "GDBserver exiting\n");
3216 /* Event-loop callback for serial events. */
3219 handle_serial_event (int err, gdb_client_data client_data)
3222 fprintf (stderr, "handling possible serial event\n");
3224 /* Really handle it. */
3225 if (process_serial_event () < 0)
3228 /* Be sure to not change the selected inferior behind GDB's back.
3229 Important in the non-stop mode asynchronous protocol. */
3230 set_desired_inferior (1);
3235 /* Event-loop callback for target events. */
3238 handle_target_event (int err, gdb_client_data client_data)
3241 fprintf (stderr, "handling possible target event\n");
3243 last_ptid = mywait (minus_one_ptid, &last_status,
3246 if (last_status.kind != TARGET_WAITKIND_IGNORE)
3248 int pid = ptid_get_pid (last_ptid);
3249 struct process_info *process = find_process_pid (pid);
3250 int forward_event = !gdb_connected () || process->gdb_detached;
3252 if (last_status.kind == TARGET_WAITKIND_EXITED
3253 || last_status.kind == TARGET_WAITKIND_SIGNALLED)
3255 mark_breakpoints_out (process);
3256 mourn_inferior (process);
3260 /* We're reporting this thread as stopped. Update its
3261 "want-stopped" state to what the client wants, until it
3262 gets a new resume action. */
3263 current_inferior->last_resume_kind = resume_stop;
3264 current_inferior->last_status = last_status;
3269 if (!target_running ())
3271 /* The last process exited. We're done. */
3275 if (last_status.kind == TARGET_WAITKIND_STOPPED)
3277 /* A thread stopped with a signal, but gdb isn't
3278 connected to handle it. Pass it down to the
3279 inferior, as if it wasn't being traced. */
3280 struct thread_resume resume_info;
3284 "GDB not connected; forwarding event %d for [%s]\n",
3285 (int) last_status.kind,
3286 target_pid_to_str (last_ptid));
3288 resume_info.thread = last_ptid;
3289 resume_info.kind = resume_continue;
3290 resume_info.sig = target_signal_to_host (last_status.value.sig);
3291 (*the_target->resume) (&resume_info, 1);
3293 else if (debug_threads)
3294 fprintf (stderr, "GDB not connected; ignoring event %d for [%s]\n",
3295 (int) last_status.kind,
3296 target_pid_to_str (last_ptid));
3300 /* Something interesting. Tell GDB about it. */
3301 push_event (last_ptid, &last_status);
3305 /* Be sure to not change the selected inferior behind GDB's back.
3306 Important in the non-stop mode asynchronous protocol. */
3307 set_desired_inferior (1);