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;
39 static int extended_protocol;
40 static int response_needed;
41 static int exit_requested;
46 static char **program_argv, **wrapper_argv;
48 /* Enable miscellaneous debugging output. The name is historical - it
49 was originally used to debug LinuxThreads support. */
52 /* Enable debugging of h/w breakpoint/watchpoint support. */
55 int pass_signals[TARGET_SIGNAL_LAST];
59 const char *gdbserver_xmltarget;
61 /* The PID of the originally created or attached inferior. Used to
62 send signals to the process when GDB sends us an asynchronous interrupt
63 (user hitting Control-C in the client), and to wait for the child to exit
64 when no longer debugging it. */
66 unsigned long signal_pid;
69 /* A file descriptor for the controlling terminal. */
72 /* TERMINAL_FD's original foreground group. */
73 pid_t old_foreground_pgrp;
75 /* Hand back terminal ownership to the original foreground group. */
78 restore_old_foreground_pgrp (void)
80 tcsetpgrp (terminal_fd, old_foreground_pgrp);
84 /* Set if you want to disable optional thread related packets support
85 in gdbserver, for the sake of testing GDB against stubs that don't
87 int disable_packet_vCont;
88 int disable_packet_Tthread;
89 int disable_packet_qC;
90 int disable_packet_qfThreadInfo;
92 /* Last status reported to GDB. */
93 static struct target_waitstatus last_status;
94 static ptid_t last_ptid;
97 static unsigned char *mem_buf;
99 /* Structure holding information relative to a single stop reply. We
100 keep a queue of these (really a singly-linked list) to push to GDB
104 /* Pointer to next in list. */
105 struct vstop_notif *next;
107 /* Thread or process that got the event. */
111 struct target_waitstatus status;
114 /* The pending stop replies list head. */
115 static struct vstop_notif *notif_queue = NULL;
117 /* Put a stop reply to the stop reply queue. */
120 queue_stop_reply (ptid_t ptid, struct target_waitstatus *status)
122 struct vstop_notif *new_notif;
124 new_notif = malloc (sizeof (*new_notif));
125 new_notif->next = NULL;
126 new_notif->ptid = ptid;
127 new_notif->status = *status;
131 struct vstop_notif *tail;
132 for (tail = notif_queue;
136 tail->next = new_notif;
139 notif_queue = new_notif;
144 struct vstop_notif *n;
146 for (n = notif_queue; n; n = n->next)
149 fprintf (stderr, "pending stop replies: %d\n", i);
153 /* Place an event in the stop reply queue, and push a notification if
154 we aren't sending one yet. */
157 push_event (ptid_t ptid, struct target_waitstatus *status)
159 gdb_assert (status->kind != TARGET_WAITKIND_IGNORE);
161 queue_stop_reply (ptid, status);
163 /* If this is the first stop reply in the queue, then inform GDB
164 about it, by sending a Stop notification. */
165 if (notif_queue->next == NULL)
170 prepare_resume_reply (p,
171 notif_queue->ptid, ¬if_queue->status);
172 putpkt_notif (own_buf);
176 /* Get rid of the currently pending stop replies for PID. If PID is
177 -1, then apply to all processes. */
180 discard_queued_stop_replies (int pid)
182 struct vstop_notif *prev = NULL, *reply, *next;
184 for (reply = notif_queue; reply; reply = next)
189 || ptid_get_pid (reply->ptid) == pid)
191 if (reply == notif_queue)
194 prev->next = reply->next;
203 /* If there are more stop replies to push, push one now. */
206 send_next_stop_reply (char *own_buf)
209 prepare_resume_reply (own_buf,
211 ¬if_queue->status);
217 target_running (void)
219 return all_threads.head != NULL;
223 start_inferior (char **argv)
225 char **new_argv = argv;
227 if (wrapper_argv != NULL)
231 for (i = 0; wrapper_argv[i] != NULL; i++)
233 for (i = 0; argv[i] != NULL; i++)
235 new_argv = alloca (sizeof (char *) * count);
237 for (i = 0; wrapper_argv[i] != NULL; i++)
238 new_argv[count++] = wrapper_argv[i];
239 for (i = 0; argv[i] != NULL; i++)
240 new_argv[count++] = argv[i];
241 new_argv[count] = NULL;
247 for (i = 0; new_argv[i]; ++i)
248 fprintf (stderr, "new_argv[%d] = \"%s\"\n", i, new_argv[i]);
253 signal (SIGTTOU, SIG_DFL);
254 signal (SIGTTIN, SIG_DFL);
257 signal_pid = create_inferior (new_argv[0], new_argv);
259 /* FIXME: we don't actually know at this point that the create
260 actually succeeded. We won't know that until we wait. */
261 fprintf (stderr, "Process %s created; pid = %ld\n", argv[0],
266 signal (SIGTTOU, SIG_IGN);
267 signal (SIGTTIN, SIG_IGN);
268 terminal_fd = fileno (stderr);
269 old_foreground_pgrp = tcgetpgrp (terminal_fd);
270 tcsetpgrp (terminal_fd, signal_pid);
271 atexit (restore_old_foreground_pgrp);
274 if (wrapper_argv != NULL)
276 struct thread_resume resume_info;
278 resume_info.thread = pid_to_ptid (signal_pid);
279 resume_info.kind = resume_continue;
282 mywait (pid_to_ptid (signal_pid), &last_status, 0, 0);
284 if (last_status.kind != TARGET_WAITKIND_STOPPED)
289 (*the_target->resume) (&resume_info, 1);
291 mywait (pid_to_ptid (signal_pid), &last_status, 0, 0);
292 if (last_status.kind != TARGET_WAITKIND_STOPPED)
295 current_inferior->last_resume_kind = resume_stop;
296 current_inferior->last_status = last_status;
298 while (last_status.value.sig != TARGET_SIGNAL_TRAP);
300 current_inferior->last_resume_kind = resume_stop;
301 current_inferior->last_status = last_status;
305 /* Wait till we are at 1st instruction in program, return new pid
306 (assuming success). */
307 last_ptid = mywait (pid_to_ptid (signal_pid), &last_status, 0, 0);
309 if (last_status.kind != TARGET_WAITKIND_EXITED
310 && last_status.kind != TARGET_WAITKIND_SIGNALLED)
312 current_inferior->last_resume_kind = resume_stop;
313 current_inferior->last_status = last_status;
320 attach_inferior (int pid)
322 /* myattach should return -1 if attaching is unsupported,
323 0 if it succeeded, and call error() otherwise. */
325 if (myattach (pid) != 0)
328 fprintf (stderr, "Attached; pid = %d\n", pid);
331 /* FIXME - It may be that we should get the SIGNAL_PID from the
332 attach function, so that it can be the main thread instead of
333 whichever we were told to attach to. */
338 last_ptid = mywait (pid_to_ptid (pid), &last_status, 0, 0);
340 /* GDB knows to ignore the first SIGSTOP after attaching to a running
341 process using the "attach" command, but this is different; it's
342 just using "target remote". Pretend it's just starting up. */
343 if (last_status.kind == TARGET_WAITKIND_STOPPED
344 && last_status.value.sig == TARGET_SIGNAL_STOP)
345 last_status.value.sig = TARGET_SIGNAL_TRAP;
347 current_inferior->last_resume_kind = resume_stop;
348 current_inferior->last_status = last_status;
354 extern int remote_debug;
356 /* Decode a qXfer read request. Return 0 if everything looks OK,
360 decode_xfer_read (char *buf, char **annex, CORE_ADDR *ofs, unsigned int *len)
362 /* Extract and NUL-terminate the annex. */
364 while (*buf && *buf != ':')
370 /* After the read marker and annex, qXfer looks like a
371 traditional 'm' packet. */
372 decode_m_packet (buf, ofs, len);
377 /* Write the response to a successful qXfer read. Returns the
378 length of the (binary) data stored in BUF, corresponding
379 to as much of DATA/LEN as we could fit. IS_MORE controls
380 the first character of the response. */
382 write_qxfer_response (char *buf, const void *data, int len, int is_more)
391 return remote_escape_output (data, len, (unsigned char *) buf + 1, &out_len,
395 /* Handle all of the extended 'Q' packets. */
398 handle_general_set (char *own_buf)
400 if (strncmp ("QPassSignals:", own_buf, strlen ("QPassSignals:")) == 0)
402 int numsigs = (int) TARGET_SIGNAL_LAST, i;
403 const char *p = own_buf + strlen ("QPassSignals:");
406 p = decode_address_to_semicolon (&cursig, p);
407 for (i = 0; i < numsigs; i++)
413 /* Keep looping, to clear the remaining signals. */
416 p = decode_address_to_semicolon (&cursig, p);
421 strcpy (own_buf, "OK");
425 if (strcmp (own_buf, "QStartNoAckMode") == 0)
429 fprintf (stderr, "[noack mode enabled]\n");
438 if (strncmp (own_buf, "QNonStop:", 9) == 0)
440 char *mode = own_buf + 9;
444 if (strcmp (mode, "0") == 0)
446 else if (strcmp (mode, "1") == 0)
450 /* We don't know what this mode is, so complain to
452 fprintf (stderr, "Unknown non-stop mode requested: %s\n",
458 req_str = req ? "non-stop" : "all-stop";
459 if (start_non_stop (req) != 0)
461 fprintf (stderr, "Setting %s mode failed\n", req_str);
469 fprintf (stderr, "[%s mode enabled]\n", req_str);
475 if (target_supports_tracepoints ()
476 && handle_tracepoint_general_set (own_buf))
479 /* Otherwise we didn't know what packet it was. Say we didn't
485 get_features_xml (const char *annex)
487 /* gdbserver_xmltarget defines what to return when looking
488 for the "target.xml" file. Its contents can either be
489 verbatim XML code (prefixed with a '@') or else the name
490 of the actual XML file to be used in place of "target.xml".
492 This variable is set up from the auto-generated
493 init_registers_... routine for the current target. */
495 if (gdbserver_xmltarget
496 && strcmp (annex, "target.xml") == 0)
498 if (*gdbserver_xmltarget == '@')
499 return gdbserver_xmltarget + 1;
501 annex = gdbserver_xmltarget;
506 extern const char *const xml_builtin[][2];
509 /* Look for the annex. */
510 for (i = 0; xml_builtin[i][0] != NULL; i++)
511 if (strcmp (annex, xml_builtin[i][0]) == 0)
514 if (xml_builtin[i][0] != NULL)
515 return xml_builtin[i][1];
523 monitor_show_help (void)
525 monitor_output ("The following monitor commands are supported:\n");
526 monitor_output (" set debug <0|1>\n");
527 monitor_output (" Enable general debugging messages\n");
528 monitor_output (" set debug-hw-points <0|1>\n");
529 monitor_output (" Enable h/w breakpoint/watchpoint debugging messages\n");
530 monitor_output (" set remote-debug <0|1>\n");
531 monitor_output (" Enable remote protocol debugging messages\n");
532 monitor_output (" exit\n");
533 monitor_output (" Quit GDBserver\n");
536 /* Read trace frame or inferior memory. */
539 gdb_read_memory (CORE_ADDR memaddr, unsigned char *myaddr, int len)
543 if (current_traceframe >= 0)
546 ULONGEST length = len;
548 if (traceframe_read_mem (current_traceframe,
549 memaddr, myaddr, len, &nbytes))
551 /* Data read from trace buffer, we're done. */
552 if (nbytes == length)
554 if (!in_readonly_region (memaddr, length))
556 /* Otherwise we have a valid readonly case, fall through. */
557 /* (assume no half-trace half-real blocks for now) */
560 ret = prepare_to_access_memory ();
563 ret = read_inferior_memory (memaddr, myaddr, len);
564 done_accessing_memory ();
570 /* Write trace frame or inferior memory. Actually, writing to trace
571 frames is forbidden. */
574 gdb_write_memory (CORE_ADDR memaddr, const unsigned char *myaddr, int len)
576 if (current_traceframe >= 0)
582 ret = prepare_to_access_memory ();
585 ret = write_inferior_memory (memaddr, myaddr, len);
586 done_accessing_memory ();
592 /* Subroutine of handle_search_memory to simplify it. */
595 handle_search_memory_1 (CORE_ADDR start_addr, CORE_ADDR search_space_len,
596 gdb_byte *pattern, unsigned pattern_len,
597 gdb_byte *search_buf,
598 unsigned chunk_size, unsigned search_buf_size,
599 CORE_ADDR *found_addrp)
601 /* Prime the search buffer. */
603 if (gdb_read_memory (start_addr, search_buf, search_buf_size) != 0)
605 warning ("Unable to access target memory at 0x%lx, halting search.",
610 /* Perform the search.
612 The loop is kept simple by allocating [N + pattern-length - 1] bytes.
613 When we've scanned N bytes we copy the trailing bytes to the start and
614 read in another N bytes. */
616 while (search_space_len >= pattern_len)
619 unsigned nr_search_bytes = (search_space_len < search_buf_size
623 found_ptr = memmem (search_buf, nr_search_bytes, pattern, pattern_len);
625 if (found_ptr != NULL)
627 CORE_ADDR found_addr = start_addr + (found_ptr - search_buf);
628 *found_addrp = found_addr;
632 /* Not found in this chunk, skip to next chunk. */
634 /* Don't let search_space_len wrap here, it's unsigned. */
635 if (search_space_len >= chunk_size)
636 search_space_len -= chunk_size;
638 search_space_len = 0;
640 if (search_space_len >= pattern_len)
642 unsigned keep_len = search_buf_size - chunk_size;
643 CORE_ADDR read_addr = start_addr + chunk_size + keep_len;
646 /* Copy the trailing part of the previous iteration to the front
647 of the buffer for the next iteration. */
648 memcpy (search_buf, search_buf + chunk_size, keep_len);
650 nr_to_read = (search_space_len - keep_len < chunk_size
651 ? search_space_len - keep_len
654 if (gdb_read_memory (read_addr, search_buf + keep_len,
657 warning ("Unable to access target memory "
658 "at 0x%lx, halting search.",
663 start_addr += chunk_size;
672 /* Handle qSearch:memory packets. */
675 handle_search_memory (char *own_buf, int packet_len)
677 CORE_ADDR start_addr;
678 CORE_ADDR search_space_len;
680 unsigned int pattern_len;
681 /* NOTE: also defined in find.c testcase. */
682 #define SEARCH_CHUNK_SIZE 16000
683 const unsigned chunk_size = SEARCH_CHUNK_SIZE;
684 /* Buffer to hold memory contents for searching. */
685 gdb_byte *search_buf;
686 unsigned search_buf_size;
688 CORE_ADDR found_addr;
689 int cmd_name_len = sizeof ("qSearch:memory:") - 1;
691 pattern = malloc (packet_len);
694 error ("Unable to allocate memory to perform the search");
695 strcpy (own_buf, "E00");
698 if (decode_search_memory_packet (own_buf + cmd_name_len,
699 packet_len - cmd_name_len,
700 &start_addr, &search_space_len,
701 pattern, &pattern_len) < 0)
704 error ("Error in parsing qSearch:memory packet");
705 strcpy (own_buf, "E00");
709 search_buf_size = chunk_size + pattern_len - 1;
711 /* No point in trying to allocate a buffer larger than the search space. */
712 if (search_space_len < search_buf_size)
713 search_buf_size = search_space_len;
715 search_buf = malloc (search_buf_size);
716 if (search_buf == NULL)
719 error ("Unable to allocate memory to perform the search");
720 strcpy (own_buf, "E00");
724 found = handle_search_memory_1 (start_addr, search_space_len,
725 pattern, pattern_len,
726 search_buf, chunk_size, search_buf_size,
730 sprintf (own_buf, "1,%lx", (long) found_addr);
732 strcpy (own_buf, "0");
734 strcpy (own_buf, "E00");
740 #define require_running(BUF) \
741 if (!target_running ()) \
747 /* Handle monitor commands not handled by target-specific handlers. */
750 handle_monitor_command (char *mon)
752 if (strcmp (mon, "set debug 1") == 0)
755 monitor_output ("Debug output enabled.\n");
757 else if (strcmp (mon, "set debug 0") == 0)
760 monitor_output ("Debug output disabled.\n");
762 else if (strcmp (mon, "set debug-hw-points 1") == 0)
765 monitor_output ("H/W point debugging output enabled.\n");
767 else if (strcmp (mon, "set debug-hw-points 0") == 0)
770 monitor_output ("H/W point debugging output disabled.\n");
772 else if (strcmp (mon, "set remote-debug 1") == 0)
775 monitor_output ("Protocol debug output enabled.\n");
777 else if (strcmp (mon, "set remote-debug 0") == 0)
780 monitor_output ("Protocol debug output disabled.\n");
782 else if (strcmp (mon, "help") == 0)
783 monitor_show_help ();
784 else if (strcmp (mon, "exit") == 0)
788 monitor_output ("Unknown monitor command.\n\n");
789 monitor_show_help ();
795 handle_threads_qxfer_proper (struct buffer *buffer)
797 struct inferior_list_entry *thread;
799 buffer_grow_str (buffer, "<threads>\n");
801 for (thread = all_threads.head; thread; thread = thread->next)
803 ptid_t ptid = thread_to_gdb_id ((struct thread_info *)thread);
808 write_ptid (ptid_s, ptid);
810 if (the_target->core_of_thread)
811 core = (*the_target->core_of_thread) (ptid);
815 sprintf (core_s, "%d", core);
816 buffer_xml_printf (buffer, "<thread id=\"%s\" core=\"%s\"/>\n",
821 buffer_xml_printf (buffer, "<thread id=\"%s\"/>\n",
826 buffer_grow_str0 (buffer, "</threads>\n");
830 handle_threads_qxfer (const char *annex,
831 unsigned char *readbuf,
832 CORE_ADDR offset, int length)
834 static char *result = 0;
835 static unsigned int result_length = 0;
837 if (annex && strcmp (annex, "") != 0)
842 struct buffer buffer;
843 /* When asked for data at offset 0, generate everything and store into
844 'result'. Successive reads will be served off 'result'. */
848 buffer_init (&buffer);
850 handle_threads_qxfer_proper (&buffer);
852 result = buffer_finish (&buffer);
853 result_length = strlen (result);
854 buffer_free (&buffer);
857 if (offset >= result_length)
859 /* We're out of data. */
866 if (length > result_length - offset)
867 length = result_length - offset;
869 memcpy (readbuf, result + offset, length);
875 /* Table used by the crc32 function to calcuate the checksum. */
877 static unsigned int crc32_table[256] =
880 /* Compute 32 bit CRC from inferior memory.
882 On success, return 32 bit CRC.
883 On failure, return (unsigned long long) -1. */
885 static unsigned long long
886 crc32 (CORE_ADDR base, int len, unsigned int crc)
890 /* Initialize the CRC table and the decoding table. */
894 for (i = 0; i < 256; i++)
896 for (c = i << 24, j = 8; j > 0; --j)
897 c = c & 0x80000000 ? (c << 1) ^ 0x04c11db7 : (c << 1);
904 unsigned char byte = 0;
906 /* Return failure if memory read fails. */
907 if (read_inferior_memory (base, &byte, 1) != 0)
908 return (unsigned long long) -1;
910 crc = (crc << 8) ^ crc32_table[((crc >> 24) ^ byte) & 255];
913 return (unsigned long long) crc;
916 /* Handle all of the extended 'q' packets. */
918 handle_query (char *own_buf, int packet_len, int *new_packet_len_p)
920 static struct inferior_list_entry *thread_ptr;
922 /* Reply the current thread id. */
923 if (strcmp ("qC", own_buf) == 0 && !disable_packet_qC)
926 require_running (own_buf);
928 if (!ptid_equal (general_thread, null_ptid)
929 && !ptid_equal (general_thread, minus_one_ptid))
930 gdb_id = general_thread;
933 thread_ptr = all_threads.head;
934 gdb_id = thread_to_gdb_id ((struct thread_info *)thread_ptr);
937 sprintf (own_buf, "QC");
939 own_buf = write_ptid (own_buf, gdb_id);
943 if (strcmp ("qSymbol::", own_buf) == 0)
945 /* GDB is suggesting new symbols have been loaded. This may
946 mean a new shared library has been detected as loaded, so
947 take the opportunity to check if breakpoints we think are
948 inserted, still are. Note that it isn't guaranteed that
949 we'll see this when a shared library is loaded, and nor will
950 we see this for unloads (although breakpoints in unloaded
951 libraries shouldn't trigger), as GDB may not find symbols for
952 the library at all. We also re-validate breakpoints when we
953 see a second GDB breakpoint for the same address, and or when
954 we access breakpoint shadows. */
955 validate_breakpoints ();
957 if (target_supports_tracepoints ())
958 tracepoint_look_up_symbols ();
960 if (target_running () && the_target->look_up_symbols != NULL)
961 (*the_target->look_up_symbols) ();
963 strcpy (own_buf, "OK");
967 if (!disable_packet_qfThreadInfo)
969 if (strcmp ("qfThreadInfo", own_buf) == 0)
973 require_running (own_buf);
974 thread_ptr = all_threads.head;
977 gdb_id = thread_to_gdb_id ((struct thread_info *)thread_ptr);
978 write_ptid (own_buf, gdb_id);
979 thread_ptr = thread_ptr->next;
983 if (strcmp ("qsThreadInfo", own_buf) == 0)
987 require_running (own_buf);
988 if (thread_ptr != NULL)
991 gdb_id = thread_to_gdb_id ((struct thread_info *)thread_ptr);
992 write_ptid (own_buf, gdb_id);
993 thread_ptr = thread_ptr->next;
998 sprintf (own_buf, "l");
1004 if (the_target->read_offsets != NULL
1005 && strcmp ("qOffsets", own_buf) == 0)
1007 CORE_ADDR text, data;
1009 require_running (own_buf);
1010 if (the_target->read_offsets (&text, &data))
1011 sprintf (own_buf, "Text=%lX;Data=%lX;Bss=%lX",
1012 (long)text, (long)data, (long)data);
1014 write_enn (own_buf);
1019 if (the_target->qxfer_spu != NULL
1020 && strncmp ("qXfer:spu:read:", own_buf, 15) == 0)
1026 unsigned char *spu_buf;
1028 require_running (own_buf);
1029 strcpy (own_buf, "E00");
1030 if (decode_xfer_read (own_buf + 15, &annex, &ofs, &len) < 0)
1032 if (len > PBUFSIZ - 2)
1034 spu_buf = malloc (len + 1);
1038 n = (*the_target->qxfer_spu) (annex, spu_buf, NULL, ofs, len + 1);
1040 write_enn (own_buf);
1042 *new_packet_len_p = write_qxfer_response (own_buf, spu_buf, len, 1);
1044 *new_packet_len_p = write_qxfer_response (own_buf, spu_buf, n, 0);
1050 if (the_target->qxfer_spu != NULL
1051 && strncmp ("qXfer:spu:write:", own_buf, 16) == 0)
1057 unsigned char *spu_buf;
1059 require_running (own_buf);
1060 strcpy (own_buf, "E00");
1061 spu_buf = malloc (packet_len - 15);
1064 if (decode_xfer_write (own_buf + 16, packet_len - 16, &annex,
1065 &ofs, &len, spu_buf) < 0)
1071 n = (*the_target->qxfer_spu)
1072 (annex, NULL, (unsigned const char *)spu_buf, ofs, len);
1074 write_enn (own_buf);
1076 sprintf (own_buf, "%x", n);
1082 if (the_target->read_auxv != NULL
1083 && strncmp ("qXfer:auxv:read:", own_buf, 16) == 0)
1085 unsigned char *data;
1091 require_running (own_buf);
1093 /* Reject any annex; grab the offset and length. */
1094 if (decode_xfer_read (own_buf + 16, &annex, &ofs, &len) < 0
1095 || annex[0] != '\0')
1097 strcpy (own_buf, "E00");
1101 /* Read one extra byte, as an indicator of whether there is
1103 if (len > PBUFSIZ - 2)
1105 data = malloc (len + 1);
1108 write_enn (own_buf);
1111 n = (*the_target->read_auxv) (ofs, data, len + 1);
1113 write_enn (own_buf);
1115 *new_packet_len_p = write_qxfer_response (own_buf, data, len, 1);
1117 *new_packet_len_p = write_qxfer_response (own_buf, data, n, 0);
1124 if (strncmp ("qXfer:features:read:", own_buf, 20) == 0)
1127 unsigned int len, total_len;
1128 const char *document;
1131 require_running (own_buf);
1133 /* Grab the annex, offset, and length. */
1134 if (decode_xfer_read (own_buf + 20, &annex, &ofs, &len) < 0)
1136 strcpy (own_buf, "E00");
1140 /* Now grab the correct annex. */
1141 document = get_features_xml (annex);
1142 if (document == NULL)
1144 strcpy (own_buf, "E00");
1148 total_len = strlen (document);
1149 if (len > PBUFSIZ - 2)
1152 if (ofs > total_len)
1153 write_enn (own_buf);
1154 else if (len < total_len - ofs)
1155 *new_packet_len_p = write_qxfer_response (own_buf, document + ofs,
1158 *new_packet_len_p = write_qxfer_response (own_buf, document + ofs,
1159 total_len - ofs, 0);
1164 if (strncmp ("qXfer:libraries:read:", own_buf, 21) == 0)
1167 unsigned int len, total_len;
1169 struct inferior_list_entry *dll_ptr;
1172 require_running (own_buf);
1174 /* Reject any annex; grab the offset and length. */
1175 if (decode_xfer_read (own_buf + 21, &annex, &ofs, &len) < 0
1176 || annex[0] != '\0')
1178 strcpy (own_buf, "E00");
1182 /* Over-estimate the necessary memory. Assume that every character
1183 in the library name must be escaped. */
1185 for (dll_ptr = all_dlls.head; dll_ptr != NULL; dll_ptr = dll_ptr->next)
1186 total_len += 128 + 6 * strlen (((struct dll_info *) dll_ptr)->name);
1188 document = malloc (total_len);
1189 if (document == NULL)
1191 write_enn (own_buf);
1194 strcpy (document, "<library-list>\n");
1195 p = document + strlen (document);
1197 for (dll_ptr = all_dlls.head; dll_ptr != NULL; dll_ptr = dll_ptr->next)
1199 struct dll_info *dll = (struct dll_info *) dll_ptr;
1202 strcpy (p, " <library name=\"");
1204 name = xml_escape_text (dll->name);
1208 strcpy (p, "\"><segment address=\"");
1210 sprintf (p, "0x%lx", (long) dll->base_addr);
1212 strcpy (p, "\"/></library>\n");
1216 strcpy (p, "</library-list>\n");
1218 total_len = strlen (document);
1219 if (len > PBUFSIZ - 2)
1222 if (ofs > total_len)
1223 write_enn (own_buf);
1224 else if (len < total_len - ofs)
1225 *new_packet_len_p = write_qxfer_response (own_buf, document + ofs,
1228 *new_packet_len_p = write_qxfer_response (own_buf, document + ofs,
1229 total_len - ofs, 0);
1235 if (the_target->qxfer_osdata != NULL
1236 && strncmp ("qXfer:osdata:read:", own_buf, 18) == 0)
1242 unsigned char *workbuf;
1244 strcpy (own_buf, "E00");
1245 if (decode_xfer_read (own_buf + 18, &annex, &ofs, &len) < 0)
1247 if (len > PBUFSIZ - 2)
1249 workbuf = malloc (len + 1);
1253 n = (*the_target->qxfer_osdata) (annex, workbuf, NULL, ofs, len + 1);
1255 write_enn (own_buf);
1257 *new_packet_len_p = write_qxfer_response (own_buf, workbuf, len, 1);
1259 *new_packet_len_p = write_qxfer_response (own_buf, workbuf, n, 0);
1265 if (the_target->qxfer_siginfo != NULL
1266 && strncmp ("qXfer:siginfo:read:", own_buf, 19) == 0)
1268 unsigned char *data;
1274 require_running (own_buf);
1276 /* Reject any annex; grab the offset and length. */
1277 if (decode_xfer_read (own_buf + 19, &annex, &ofs, &len) < 0
1278 || annex[0] != '\0')
1280 strcpy (own_buf, "E00");
1284 /* Read one extra byte, as an indicator of whether there is
1286 if (len > PBUFSIZ - 2)
1288 data = malloc (len + 1);
1291 n = (*the_target->qxfer_siginfo) (annex, data, NULL, ofs, len + 1);
1293 write_enn (own_buf);
1295 *new_packet_len_p = write_qxfer_response (own_buf, data, len, 1);
1297 *new_packet_len_p = write_qxfer_response (own_buf, data, n, 0);
1303 if (the_target->qxfer_siginfo != NULL
1304 && strncmp ("qXfer:siginfo:write:", own_buf, 20) == 0)
1310 unsigned char *data;
1312 require_running (own_buf);
1314 strcpy (own_buf, "E00");
1315 data = malloc (packet_len - 19);
1318 if (decode_xfer_write (own_buf + 20, packet_len - 20, &annex,
1319 &ofs, &len, data) < 0)
1325 n = (*the_target->qxfer_siginfo)
1326 (annex, NULL, (unsigned const char *)data, ofs, len);
1328 write_enn (own_buf);
1330 sprintf (own_buf, "%x", n);
1336 if (strncmp ("qXfer:threads:read:", own_buf, 19) == 0)
1338 unsigned char *data;
1344 require_running (own_buf);
1346 /* Reject any annex; grab the offset and length. */
1347 if (decode_xfer_read (own_buf + 19, &annex, &ofs, &len) < 0
1348 || annex[0] != '\0')
1350 strcpy (own_buf, "E00");
1354 /* Read one extra byte, as an indicator of whether there is
1356 if (len > PBUFSIZ - 2)
1358 data = malloc (len + 1);
1361 n = handle_threads_qxfer (annex, data, ofs, len + 1);
1363 write_enn (own_buf);
1365 *new_packet_len_p = write_qxfer_response (own_buf, data, len, 1);
1367 *new_packet_len_p = write_qxfer_response (own_buf, data, n, 0);
1373 if (strncmp ("qXfer:statictrace:read:", own_buf,
1374 sizeof ("qXfer:statictrace:read:") -1) == 0)
1376 unsigned char *data;
1382 require_running (own_buf);
1384 if (current_traceframe == -1)
1386 write_enn (own_buf);
1390 /* Reject any annex; grab the offset and length. */
1391 if (decode_xfer_read (own_buf + sizeof ("qXfer:statictrace:read:") -1,
1392 &annex, &ofs, &len) < 0
1393 || annex[0] != '\0')
1395 strcpy (own_buf, "E00");
1399 /* Read one extra byte, as an indicator of whether there is
1401 if (len > PBUFSIZ - 2)
1403 data = malloc (len + 1);
1407 if (traceframe_read_sdata (current_traceframe, ofs,
1408 data, len + 1, &nbytes))
1409 write_enn (own_buf);
1410 else if (nbytes > len)
1411 *new_packet_len_p = write_qxfer_response (own_buf, data, len, 1);
1413 *new_packet_len_p = write_qxfer_response (own_buf, data, nbytes, 0);
1419 /* Protocol features query. */
1420 if (strncmp ("qSupported", own_buf, 10) == 0
1421 && (own_buf[10] == ':' || own_buf[10] == '\0'))
1423 char *p = &own_buf[10];
1424 int gdb_supports_qRelocInsn = 0;
1426 /* Start processing qSupported packet. */
1427 target_process_qsupported (NULL);
1429 /* Process each feature being provided by GDB. The first
1430 feature will follow a ':', and latter features will follow
1434 char **qsupported = NULL;
1438 /* Two passes, to avoid nested strtok calls in
1439 target_process_qsupported. */
1440 for (p = strtok (p + 1, ";");
1442 p = strtok (NULL, ";"))
1445 qsupported = xrealloc (qsupported, count * sizeof (char *));
1446 qsupported[count - 1] = xstrdup (p);
1449 for (i = 0; i < count; i++)
1452 if (strcmp (p, "multiprocess+") == 0)
1454 /* GDB supports and wants multi-process support if
1456 if (target_supports_multi_process ())
1459 else if (strcmp (p, "qRelocInsn+") == 0)
1461 /* GDB supports relocate instruction requests. */
1462 gdb_supports_qRelocInsn = 1;
1465 target_process_qsupported (p);
1473 sprintf (own_buf, "PacketSize=%x;QPassSignals+", PBUFSIZ - 1);
1475 /* We do not have any hook to indicate whether the target backend
1476 supports qXfer:libraries:read, so always report it. */
1477 strcat (own_buf, ";qXfer:libraries:read+");
1479 if (the_target->read_auxv != NULL)
1480 strcat (own_buf, ";qXfer:auxv:read+");
1482 if (the_target->qxfer_spu != NULL)
1483 strcat (own_buf, ";qXfer:spu:read+;qXfer:spu:write+");
1485 if (the_target->qxfer_siginfo != NULL)
1486 strcat (own_buf, ";qXfer:siginfo:read+;qXfer:siginfo:write+");
1488 /* We always report qXfer:features:read, as targets may
1489 install XML files on a subsequent call to arch_setup.
1490 If we reported to GDB on startup that we don't support
1491 qXfer:feature:read at all, we will never be re-queried. */
1492 strcat (own_buf, ";qXfer:features:read+");
1494 if (transport_is_reliable)
1495 strcat (own_buf, ";QStartNoAckMode+");
1497 if (the_target->qxfer_osdata != NULL)
1498 strcat (own_buf, ";qXfer:osdata:read+");
1500 if (target_supports_multi_process ())
1501 strcat (own_buf, ";multiprocess+");
1503 if (target_supports_non_stop ())
1504 strcat (own_buf, ";QNonStop+");
1506 strcat (own_buf, ";qXfer:threads:read+");
1508 if (target_supports_tracepoints ())
1510 strcat (own_buf, ";ConditionalTracepoints+");
1511 strcat (own_buf, ";TraceStateVariables+");
1512 strcat (own_buf, ";TracepointSource+");
1513 strcat (own_buf, ";DisconnectedTracing+");
1514 if (gdb_supports_qRelocInsn && target_supports_fast_tracepoints ())
1515 strcat (own_buf, ";FastTracepoints+");
1516 strcat (own_buf, ";StaticTracepoints+");
1517 strcat (own_buf, ";qXfer:statictrace:read+");
1523 /* Thread-local storage support. */
1524 if (the_target->get_tls_address != NULL
1525 && strncmp ("qGetTLSAddr:", own_buf, 12) == 0)
1527 char *p = own_buf + 12;
1528 CORE_ADDR parts[2], address = 0;
1530 ptid_t ptid = null_ptid;
1532 require_running (own_buf);
1534 for (i = 0; i < 3; i++)
1542 p2 = strchr (p, ',');
1555 ptid = read_ptid (p, NULL);
1557 decode_address (&parts[i - 1], p, len);
1561 if (p != NULL || i < 3)
1565 struct thread_info *thread = find_thread_ptid (ptid);
1570 err = the_target->get_tls_address (thread, parts[0], parts[1],
1576 strcpy (own_buf, paddress(address));
1581 write_enn (own_buf);
1585 /* Otherwise, pretend we do not understand this packet. */
1588 /* Windows OS Thread Information Block address support. */
1589 if (the_target->get_tib_address != NULL
1590 && strncmp ("qGetTIBAddr:", own_buf, 12) == 0)
1595 ptid_t ptid = read_ptid (own_buf + 12, &annex);
1597 n = (*the_target->get_tib_address) (ptid, &tlb);
1600 strcpy (own_buf, paddress(tlb));
1605 write_enn (own_buf);
1611 /* Handle "monitor" commands. */
1612 if (strncmp ("qRcmd,", own_buf, 6) == 0)
1614 char *mon = malloc (PBUFSIZ);
1615 int len = strlen (own_buf + 6);
1619 write_enn (own_buf);
1623 if ((len % 2) != 0 || unhexify (mon, own_buf + 6, len / 2) != len / 2)
1625 write_enn (own_buf);
1629 mon[len / 2] = '\0';
1633 if (the_target->handle_monitor_command == NULL
1634 || (*the_target->handle_monitor_command) (mon) == 0)
1635 /* Default processing. */
1636 handle_monitor_command (mon);
1642 if (strncmp ("qSearch:memory:", own_buf,
1643 sizeof ("qSearch:memory:") - 1) == 0)
1645 require_running (own_buf);
1646 handle_search_memory (own_buf, packet_len);
1650 if (strcmp (own_buf, "qAttached") == 0
1651 || strncmp (own_buf, "qAttached:", sizeof ("qAttached:") - 1) == 0)
1653 struct process_info *process;
1655 if (own_buf[sizeof ("qAttached") - 1])
1657 int pid = strtoul (own_buf + sizeof ("qAttached:") - 1, NULL, 16);
1658 process = (struct process_info *)
1659 find_inferior_id (&all_processes, pid_to_ptid (pid));
1663 require_running (own_buf);
1664 process = current_process ();
1667 if (process == NULL)
1669 write_enn (own_buf);
1673 strcpy (own_buf, process->attached ? "1" : "0");
1677 if (strncmp ("qCRC:", own_buf, 5) == 0)
1679 /* CRC check (compare-section). */
1683 unsigned long long crc;
1685 require_running (own_buf);
1686 base = strtoul (own_buf + 5, &comma, 16);
1687 if (*comma++ != ',')
1689 write_enn (own_buf);
1692 len = strtoul (comma, NULL, 16);
1693 crc = crc32 (base, len, 0xffffffff);
1694 /* Check for memory failure. */
1695 if (crc == (unsigned long long) -1)
1697 write_enn (own_buf);
1700 sprintf (own_buf, "C%lx", (unsigned long) crc);
1704 if (target_supports_tracepoints () && handle_tracepoint_query (own_buf))
1707 /* Otherwise we didn't know what packet it was. Say we didn't
1712 static void gdb_wants_all_threads_stopped (void);
1714 /* Parse vCont packets. */
1716 handle_v_cont (char *own_buf)
1720 struct thread_resume *resume_info;
1721 struct thread_resume default_action = {{0}};
1723 /* Count the number of semicolons in the packet. There should be one
1724 for every action. */
1730 p = strchr (p, ';');
1733 resume_info = malloc (n * sizeof (resume_info[0]));
1734 if (resume_info == NULL)
1742 if (p[0] == 's' || p[0] == 'S')
1743 resume_info[i].kind = resume_step;
1744 else if (p[0] == 'c' || p[0] == 'C')
1745 resume_info[i].kind = resume_continue;
1746 else if (p[0] == 't')
1747 resume_info[i].kind = resume_stop;
1751 if (p[0] == 'S' || p[0] == 'C')
1754 sig = strtol (p + 1, &q, 16);
1759 if (!target_signal_to_host_p (sig))
1761 resume_info[i].sig = target_signal_to_host (sig);
1765 resume_info[i].sig = 0;
1771 resume_info[i].thread = minus_one_ptid;
1772 default_action = resume_info[i];
1774 /* Note: we don't increment i here, we'll overwrite this entry
1775 the next time through. */
1777 else if (p[0] == ':')
1779 ptid_t ptid = read_ptid (p + 1, &q);
1784 if (p[0] != ';' && p[0] != 0)
1787 resume_info[i].thread = ptid;
1794 resume_info[i] = default_action;
1796 /* Still used in occasional places in the backend. */
1798 && !ptid_equal (resume_info[0].thread, minus_one_ptid)
1799 && resume_info[0].kind != resume_stop)
1800 cont_thread = resume_info[0].thread;
1802 cont_thread = minus_one_ptid;
1803 set_desired_inferior (0);
1808 (*the_target->resume) (resume_info, n);
1816 last_ptid = mywait (minus_one_ptid, &last_status, 0, 1);
1818 if (last_status.kind != TARGET_WAITKIND_EXITED
1819 && last_status.kind != TARGET_WAITKIND_SIGNALLED)
1820 current_inferior->last_status = last_status;
1822 /* From the client's perspective, all-stop mode always stops all
1823 threads implicitly (and the target backend has already done
1824 so by now). Tag all threads as "want-stopped", so we don't
1825 resume them implicitly without the client telling us to. */
1826 gdb_wants_all_threads_stopped ();
1827 prepare_resume_reply (own_buf, last_ptid, &last_status);
1828 disable_async_io ();
1830 if (last_status.kind == TARGET_WAITKIND_EXITED
1831 || last_status.kind == TARGET_WAITKIND_SIGNALLED)
1832 mourn_inferior (find_process_pid (ptid_get_pid (last_ptid)));
1837 write_enn (own_buf);
1842 /* Attach to a new program. Return 1 if successful, 0 if failure. */
1844 handle_v_attach (char *own_buf)
1848 pid = strtol (own_buf + 8, NULL, 16);
1849 if (pid != 0 && attach_inferior (pid) == 0)
1851 /* Don't report shared library events after attaching, even if
1852 some libraries are preloaded. GDB will always poll the
1853 library list. Avoids the "stopped by shared library event"
1854 notice on the GDB side. */
1859 /* In non-stop, we don't send a resume reply. Stop events
1860 will follow up using the normal notification
1865 prepare_resume_reply (own_buf, last_ptid, &last_status);
1871 write_enn (own_buf);
1876 /* Run a new program. Return 1 if successful, 0 if failure. */
1878 handle_v_run (char *own_buf)
1880 char *p, *next_p, **new_argv;
1884 for (p = own_buf + strlen ("vRun;"); p && *p; p = strchr (p, ';'))
1890 new_argv = calloc (new_argc + 2, sizeof (char *));
1891 if (new_argv == NULL)
1893 write_enn (own_buf);
1898 for (p = own_buf + strlen ("vRun;"); *p; p = next_p)
1900 next_p = strchr (p, ';');
1902 next_p = p + strlen (p);
1904 if (i == 0 && p == next_p)
1908 /* FIXME: Fail request if out of memory instead of dying. */
1909 new_argv[i] = xmalloc (1 + (next_p - p) / 2);
1910 unhexify (new_argv[i], p, (next_p - p) / 2);
1911 new_argv[i][(next_p - p) / 2] = '\0';
1920 if (new_argv[0] == NULL)
1922 /* GDB didn't specify a program to run. Use the program from the
1923 last run with the new argument list. */
1925 if (program_argv == NULL)
1927 /* FIXME: new_argv memory leak */
1928 write_enn (own_buf);
1932 new_argv[0] = strdup (program_argv[0]);
1933 if (new_argv[0] == NULL)
1935 /* FIXME: new_argv memory leak */
1936 write_enn (own_buf);
1941 /* Free the old argv and install the new one. */
1942 freeargv (program_argv);
1943 program_argv = new_argv;
1945 start_inferior (program_argv);
1946 if (last_status.kind == TARGET_WAITKIND_STOPPED)
1948 prepare_resume_reply (own_buf, last_ptid, &last_status);
1950 /* In non-stop, sending a resume reply doesn't set the general
1951 thread, but GDB assumes a vRun sets it (this is so GDB can
1952 query which is the main thread of the new inferior. */
1954 general_thread = last_ptid;
1960 write_enn (own_buf);
1965 /* Kill process. Return 1 if successful, 0 if failure. */
1967 handle_v_kill (char *own_buf)
1970 char *p = &own_buf[6];
1972 pid = strtol (p, NULL, 16);
1975 if (pid != 0 && kill_inferior (pid) == 0)
1977 last_status.kind = TARGET_WAITKIND_SIGNALLED;
1978 last_status.value.sig = TARGET_SIGNAL_KILL;
1979 last_ptid = pid_to_ptid (pid);
1980 discard_queued_stop_replies (pid);
1986 write_enn (own_buf);
1991 /* Handle a 'vStopped' packet. */
1993 handle_v_stopped (char *own_buf)
1995 /* If we're waiting for GDB to acknowledge a pending stop reply,
1996 consider that done. */
1999 struct vstop_notif *head;
2002 fprintf (stderr, "vStopped: acking %s\n",
2003 target_pid_to_str (notif_queue->ptid));
2006 notif_queue = notif_queue->next;
2010 /* Push another stop reply, or if there are no more left, an OK. */
2011 send_next_stop_reply (own_buf);
2014 /* Handle all of the extended 'v' packets. */
2016 handle_v_requests (char *own_buf, int packet_len, int *new_packet_len)
2018 if (!disable_packet_vCont)
2020 if (strncmp (own_buf, "vCont;", 6) == 0)
2022 require_running (own_buf);
2023 handle_v_cont (own_buf);
2027 if (strncmp (own_buf, "vCont?", 6) == 0)
2029 strcpy (own_buf, "vCont;c;C;s;S;t");
2034 if (strncmp (own_buf, "vFile:", 6) == 0
2035 && handle_vFile (own_buf, packet_len, new_packet_len))
2038 if (strncmp (own_buf, "vAttach;", 8) == 0)
2040 if (!multi_process && target_running ())
2042 fprintf (stderr, "Already debugging a process\n");
2043 write_enn (own_buf);
2046 handle_v_attach (own_buf);
2050 if (strncmp (own_buf, "vRun;", 5) == 0)
2052 if (!multi_process && target_running ())
2054 fprintf (stderr, "Already debugging a process\n");
2055 write_enn (own_buf);
2058 handle_v_run (own_buf);
2062 if (strncmp (own_buf, "vKill;", 6) == 0)
2064 if (!target_running ())
2066 fprintf (stderr, "No process to kill\n");
2067 write_enn (own_buf);
2070 handle_v_kill (own_buf);
2074 if (strncmp (own_buf, "vStopped", 8) == 0)
2076 handle_v_stopped (own_buf);
2080 /* Otherwise we didn't know what packet it was. Say we didn't
2086 /* Resume inferior and wait for another event. In non-stop mode,
2087 don't really wait here, but return immediatelly to the event
2090 myresume (char *own_buf, int step, int sig)
2092 struct thread_resume resume_info[2];
2094 int valid_cont_thread;
2096 set_desired_inferior (0);
2098 valid_cont_thread = (!ptid_equal (cont_thread, null_ptid)
2099 && !ptid_equal (cont_thread, minus_one_ptid));
2101 if (step || sig || valid_cont_thread)
2103 resume_info[0].thread
2104 = ((struct inferior_list_entry *) current_inferior)->id;
2106 resume_info[0].kind = resume_step;
2108 resume_info[0].kind = resume_continue;
2109 resume_info[0].sig = sig;
2113 if (!valid_cont_thread)
2115 resume_info[n].thread = minus_one_ptid;
2116 resume_info[n].kind = resume_continue;
2117 resume_info[n].sig = 0;
2124 (*the_target->resume) (resume_info, n);
2130 last_ptid = mywait (minus_one_ptid, &last_status, 0, 1);
2132 if (last_status.kind != TARGET_WAITKIND_EXITED
2133 && last_status.kind != TARGET_WAITKIND_SIGNALLED)
2135 current_inferior->last_resume_kind = resume_stop;
2136 current_inferior->last_status = last_status;
2139 prepare_resume_reply (own_buf, last_ptid, &last_status);
2140 disable_async_io ();
2142 if (last_status.kind == TARGET_WAITKIND_EXITED
2143 || last_status.kind == TARGET_WAITKIND_SIGNALLED)
2144 mourn_inferior (find_process_pid (ptid_get_pid (last_ptid)));
2148 /* Callback for for_each_inferior. Make a new stop reply for each
2152 queue_stop_reply_callback (struct inferior_list_entry *entry, void *arg)
2154 struct thread_info *thread = (struct thread_info *) entry;
2156 /* For now, assume targets that don't have this callback also don't
2157 manage the thread's last_status field. */
2158 if (the_target->thread_stopped == NULL)
2160 /* Pass the last stop reply back to GDB, but don't notify
2162 queue_stop_reply (entry->id, &thread->last_status);
2166 if (thread_stopped (thread))
2170 "Reporting thread %s as already stopped with %s\n",
2171 target_pid_to_str (entry->id),
2172 target_waitstatus_to_string (&thread->last_status));
2174 gdb_assert (thread->last_status.kind != TARGET_WAITKIND_IGNORE);
2176 /* Pass the last stop reply back to GDB, but don't notify
2178 queue_stop_reply (entry->id, &thread->last_status);
2185 /* Set this inferior threads's state as "want-stopped". We won't
2186 resume this thread until the client gives us another action for
2190 gdb_wants_thread_stopped (struct inferior_list_entry *entry)
2192 struct thread_info *thread = (struct thread_info *) entry;
2194 thread->last_resume_kind = resume_stop;
2196 if (thread->last_status.kind == TARGET_WAITKIND_IGNORE)
2198 /* Most threads are stopped implicitly (all-stop); tag that with
2200 thread->last_status.kind = TARGET_WAITKIND_STOPPED;
2201 thread->last_status.value.sig = TARGET_SIGNAL_0;
2205 /* Set all threads' states as "want-stopped". */
2208 gdb_wants_all_threads_stopped (void)
2210 for_each_inferior (&all_threads, gdb_wants_thread_stopped);
2213 /* Clear the gdb_detached flag of every process. */
2216 gdb_reattached_process (struct inferior_list_entry *entry)
2218 struct process_info *process = (struct process_info *) entry;
2220 process->gdb_detached = 0;
2223 /* Status handler for the '?' packet. */
2226 handle_status (char *own_buf)
2228 /* GDB is connected, don't forward events to the target anymore. */
2229 for_each_inferior (&all_processes, gdb_reattached_process);
2231 /* In non-stop mode, we must send a stop reply for each stopped
2232 thread. In all-stop mode, just send one for the first stopped
2237 discard_queued_stop_replies (-1);
2238 find_inferior (&all_threads, queue_stop_reply_callback, NULL);
2240 /* The first is sent immediatly. OK is sent if there is no
2241 stopped thread, which is the same handling of the vStopped
2242 packet (by design). */
2243 send_next_stop_reply (own_buf);
2248 stabilize_threads ();
2249 gdb_wants_all_threads_stopped ();
2251 if (all_threads.head)
2253 struct target_waitstatus status;
2255 status.kind = TARGET_WAITKIND_STOPPED;
2256 status.value.sig = TARGET_SIGNAL_TRAP;
2257 prepare_resume_reply (own_buf,
2258 all_threads.head->id, &status);
2261 strcpy (own_buf, "W00");
2266 gdbserver_version (void)
2268 printf ("GNU gdbserver %s%s\n"
2269 "Copyright (C) 2011 Free Software Foundation, Inc.\n"
2270 "gdbserver is free software, covered by the "
2271 "GNU General Public License.\n"
2272 "This gdbserver was configured as \"%s\"\n",
2273 PKGVERSION, version, host_name);
2277 gdbserver_usage (FILE *stream)
2279 fprintf (stream, "Usage:\tgdbserver [OPTIONS] COMM PROG [ARGS ...]\n"
2280 "\tgdbserver [OPTIONS] --attach COMM PID\n"
2281 "\tgdbserver [OPTIONS] --multi COMM\n"
2283 "COMM may either be a tty device (for serial debugging), or \n"
2284 "HOST:PORT to listen for a TCP connection.\n"
2287 " --debug Enable general debugging output.\n"
2288 " --remote-debug Enable remote protocol debugging output.\n"
2289 " --version Display version information and exit.\n"
2290 " --wrapper WRAPPER -- Run WRAPPER to start new programs.\n");
2291 if (REPORT_BUGS_TO[0] && stream == stdout)
2292 fprintf (stream, "Report bugs to \"%s\".\n", REPORT_BUGS_TO);
2296 gdbserver_show_disableable (FILE *stream)
2298 fprintf (stream, "Disableable packets:\n"
2299 " vCont \tAll vCont packets\n"
2300 " qC \tQuerying the current thread\n"
2301 " qfThreadInfo\tThread listing\n"
2302 " Tthread \tPassing the thread specifier in the "
2303 "T stop reply packet\n"
2304 " threads \tAll of the above\n");
2308 #undef require_running
2309 #define require_running(BUF) \
2310 if (!target_running ()) \
2317 first_thread_of (struct inferior_list_entry *entry, void *args)
2319 int pid = * (int *) args;
2321 if (ptid_get_pid (entry->id) == pid)
2328 kill_inferior_callback (struct inferior_list_entry *entry)
2330 struct process_info *process = (struct process_info *) entry;
2331 int pid = ptid_get_pid (process->head.id);
2333 kill_inferior (pid);
2334 discard_queued_stop_replies (pid);
2337 /* Callback for for_each_inferior to detach or kill the inferior,
2338 depending on whether we attached to it or not.
2339 We inform the user whether we're detaching or killing the process
2340 as this is only called when gdbserver is about to exit. */
2343 detach_or_kill_inferior_callback (struct inferior_list_entry *entry)
2345 struct process_info *process = (struct process_info *) entry;
2346 int pid = ptid_get_pid (process->head.id);
2348 if (process->attached)
2349 detach_inferior (pid);
2351 kill_inferior (pid);
2353 discard_queued_stop_replies (pid);
2356 /* for_each_inferior callback for detach_or_kill_for_exit to print
2357 the pids of started inferiors. */
2360 print_started_pid (struct inferior_list_entry *entry)
2362 struct process_info *process = (struct process_info *) entry;
2364 if (! process->attached)
2366 int pid = ptid_get_pid (process->head.id);
2367 fprintf (stderr, " %d", pid);
2371 /* for_each_inferior callback for detach_or_kill_for_exit to print
2372 the pids of attached inferiors. */
2375 print_attached_pid (struct inferior_list_entry *entry)
2377 struct process_info *process = (struct process_info *) entry;
2379 if (process->attached)
2381 int pid = ptid_get_pid (process->head.id);
2382 fprintf (stderr, " %d", pid);
2386 /* Call this when exiting gdbserver with possible inferiors that need
2387 to be killed or detached from. */
2390 detach_or_kill_for_exit (void)
2392 /* First print a list of the inferiors we will be killing/detaching.
2393 This is to assist the user, for example, in case the inferior unexpectedly
2394 dies after we exit: did we screw up or did the inferior exit on its own?
2395 Having this info will save some head-scratching. */
2397 if (have_started_inferiors_p ())
2399 fprintf (stderr, "Killing process(es):");
2400 for_each_inferior (&all_processes, print_started_pid);
2401 fprintf (stderr, "\n");
2403 if (have_attached_inferiors_p ())
2405 fprintf (stderr, "Detaching process(es):");
2406 for_each_inferior (&all_processes, print_attached_pid);
2407 fprintf (stderr, "\n");
2410 /* Now we can kill or detach the inferiors. */
2412 for_each_inferior (&all_processes, detach_or_kill_inferior_callback);
2416 join_inferiors_callback (struct inferior_list_entry *entry)
2418 struct process_info *process = (struct process_info *) entry;
2420 /* If we are attached, then we can exit. Otherwise, we need to hang
2421 around doing nothing, until the child is gone. */
2422 if (!process->attached)
2423 join_inferior (ptid_get_pid (process->head.id));
2427 main (int argc, char *argv[])
2431 char *arg_end, *port;
2432 char **next_arg = &argv[1];
2437 while (*next_arg != NULL && **next_arg == '-')
2439 if (strcmp (*next_arg, "--version") == 0)
2441 gdbserver_version ();
2444 else if (strcmp (*next_arg, "--help") == 0)
2446 gdbserver_usage (stdout);
2449 else if (strcmp (*next_arg, "--attach") == 0)
2451 else if (strcmp (*next_arg, "--multi") == 0)
2453 else if (strcmp (*next_arg, "--wrapper") == 0)
2457 wrapper_argv = next_arg;
2458 while (*next_arg != NULL && strcmp (*next_arg, "--") != 0)
2461 if (next_arg == wrapper_argv || *next_arg == NULL)
2463 gdbserver_usage (stderr);
2467 /* Consume the "--". */
2470 else if (strcmp (*next_arg, "--debug") == 0)
2472 else if (strcmp (*next_arg, "--remote-debug") == 0)
2474 else if (strcmp (*next_arg, "--disable-packet") == 0)
2476 gdbserver_show_disableable (stdout);
2479 else if (strncmp (*next_arg,
2480 "--disable-packet=",
2481 sizeof ("--disable-packet=") - 1) == 0)
2483 char *packets, *tok;
2485 packets = *next_arg += sizeof ("--disable-packet=") - 1;
2486 for (tok = strtok (packets, ",");
2488 tok = strtok (NULL, ","))
2490 if (strcmp ("vCont", tok) == 0)
2491 disable_packet_vCont = 1;
2492 else if (strcmp ("Tthread", tok) == 0)
2493 disable_packet_Tthread = 1;
2494 else if (strcmp ("qC", tok) == 0)
2495 disable_packet_qC = 1;
2496 else if (strcmp ("qfThreadInfo", tok) == 0)
2497 disable_packet_qfThreadInfo = 1;
2498 else if (strcmp ("threads", tok) == 0)
2500 disable_packet_vCont = 1;
2501 disable_packet_Tthread = 1;
2502 disable_packet_qC = 1;
2503 disable_packet_qfThreadInfo = 1;
2507 fprintf (stderr, "Don't know how to disable \"%s\".\n\n",
2509 gdbserver_show_disableable (stderr);
2516 fprintf (stderr, "Unknown argument: %s\n", *next_arg);
2524 if (setjmp (toplevel))
2526 fprintf (stderr, "Exiting\n");
2532 if (port == NULL || (!attach && !multi_mode && *next_arg == NULL))
2534 gdbserver_usage (stderr);
2541 /* --attach used to come after PORT, so allow it there for
2543 if (*next_arg != NULL && strcmp (*next_arg, "--attach") == 0)
2550 && (*next_arg == NULL
2551 || (*next_arg)[0] == '\0'
2552 || (pid = strtoul (*next_arg, &arg_end, 0)) == 0
2554 || next_arg[1] != NULL))
2559 gdbserver_usage (stderr);
2563 initialize_inferiors ();
2564 initialize_async_io ();
2566 if (target_supports_tracepoints ())
2567 initialize_tracepoint ();
2569 own_buf = xmalloc (PBUFSIZ + 1);
2570 mem_buf = xmalloc (PBUFSIZ);
2572 if (pid == 0 && *next_arg != NULL)
2576 n = argc - (next_arg - argv);
2577 program_argv = xmalloc (sizeof (char *) * (n + 1));
2578 for (i = 0; i < n; i++)
2579 program_argv[i] = xstrdup (next_arg[i]);
2580 program_argv[i] = NULL;
2582 /* Wait till we are at first instruction in program. */
2583 start_inferior (program_argv);
2585 /* We are now (hopefully) stopped at the first instruction of
2586 the target process. This assumes that the target process was
2587 successfully created. */
2591 if (attach_inferior (pid) == -1)
2592 error ("Attaching not supported on this target");
2594 /* Otherwise succeeded. */
2598 last_status.kind = TARGET_WAITKIND_EXITED;
2599 last_status.value.integer = 0;
2600 last_ptid = minus_one_ptid;
2603 /* Don't report shared library events on the initial connection,
2604 even if some libraries are preloaded. Avoids the "stopped by
2605 shared library event" notice on gdb side. */
2608 if (setjmp (toplevel))
2610 detach_or_kill_for_exit ();
2614 if (last_status.kind == TARGET_WAITKIND_EXITED
2615 || last_status.kind == TARGET_WAITKIND_SIGNALLED)
2620 if (!was_running && !multi_mode)
2622 fprintf (stderr, "No program to debug. GDBserver exiting.\n");
2630 /* Be sure we're out of tfind mode. */
2631 current_traceframe = -1;
2635 if (setjmp (toplevel) != 0)
2637 /* An error occurred. */
2638 if (response_needed)
2640 write_enn (own_buf);
2645 /* Wait for events. This will return when all event sources are
2646 removed from the event loop. */
2647 start_event_loop ();
2649 /* If an exit was requested (using the "monitor exit" command),
2650 terminate now. The only other way to get here is for
2651 getpkt to fail; close the connection and reopen it at the
2656 detach_or_kill_for_exit ();
2661 "Remote side has terminated connection. "
2662 "GDBserver will reopen the connection.\n");
2666 if (disconnected_tracing)
2668 /* Try to enable non-stop/async mode, so we we can both
2669 wait for an async socket accept, and handle async
2670 target events simultaneously. There's also no point
2671 either in having the target always stop all threads,
2672 when we're going to pass signals down without
2676 if (start_non_stop (1))
2679 /* Detaching implicitly resumes all threads; simply
2680 disconnecting does not. */
2686 "Disconnected tracing disabled; stopping trace run.\n");
2693 /* Event loop callback that handles a serial event. The first byte in
2694 the serial buffer gets us here. We expect characters to arrive at
2695 a brisk pace, so we read the rest of the packet with a blocking
2699 process_serial_event (void)
2709 int new_packet_len = -1;
2711 /* Used to decide when gdbserver should exit in
2712 multi-mode/remote. */
2713 static int have_ran = 0;
2716 have_ran = target_running ();
2718 disable_async_io ();
2720 response_needed = 0;
2721 packet_len = getpkt (own_buf);
2722 if (packet_len <= 0)
2725 /* Force an event loop break. */
2728 response_needed = 1;
2735 handle_query (own_buf, packet_len, &new_packet_len);
2738 handle_general_set (own_buf);
2741 require_running (own_buf);
2746 pid = strtol (&own_buf[i], NULL, 16);
2750 ptid_get_pid (((struct inferior_list_entry *) current_inferior)->id);
2752 if (tracing && disconnected_tracing)
2754 struct thread_resume resume_info;
2755 struct process_info *process = find_process_pid (pid);
2757 if (process == NULL)
2759 write_enn (own_buf);
2764 "Disconnected tracing in effect, "
2765 "leaving gdbserver attached to the process\n");
2767 /* Make sure we're in non-stop/async mode, so we we can both
2768 wait for an async socket accept, and handle async target
2769 events simultaneously. There's also no point either in
2770 having the target stop all threads, when we're going to
2771 pass signals down without informing GDB. */
2775 fprintf (stderr, "Forcing non-stop mode\n");
2781 process->gdb_detached = 1;
2783 /* Detaching implicitly resumes all threads. */
2784 resume_info.thread = minus_one_ptid;
2785 resume_info.kind = resume_continue;
2786 resume_info.sig = 0;
2787 (*the_target->resume) (&resume_info, 1);
2790 break; /* from switch/case */
2793 fprintf (stderr, "Detaching from process %d\n", pid);
2795 if (detach_inferior (pid) != 0)
2796 write_enn (own_buf);
2799 discard_queued_stop_replies (pid);
2802 if (extended_protocol)
2804 /* Treat this like a normal program exit. */
2805 last_status.kind = TARGET_WAITKIND_EXITED;
2806 last_status.value.integer = 0;
2807 last_ptid = pid_to_ptid (pid);
2809 current_inferior = NULL;
2816 /* If we are attached, then we can exit. Otherwise, we
2817 need to hang around doing nothing, until the child is
2819 for_each_inferior (&all_processes,
2820 join_inferiors_callback);
2826 extended_protocol = 1;
2830 handle_status (own_buf);
2833 if (own_buf[1] == 'c' || own_buf[1] == 'g' || own_buf[1] == 's')
2835 ptid_t gdb_id, thread_id;
2838 require_running (own_buf);
2840 gdb_id = read_ptid (&own_buf[2], NULL);
2842 pid = ptid_get_pid (gdb_id);
2844 if (ptid_equal (gdb_id, null_ptid)
2845 || ptid_equal (gdb_id, minus_one_ptid))
2846 thread_id = null_ptid;
2848 && ptid_equal (pid_to_ptid (pid),
2851 struct thread_info *thread =
2852 (struct thread_info *) find_inferior (&all_threads,
2857 write_enn (own_buf);
2861 thread_id = ((struct inferior_list_entry *)thread)->id;
2865 thread_id = gdb_id_to_thread_id (gdb_id);
2866 if (ptid_equal (thread_id, null_ptid))
2868 write_enn (own_buf);
2873 if (own_buf[1] == 'g')
2875 if (ptid_equal (thread_id, null_ptid))
2877 /* GDB is telling us to choose any thread. Check if
2878 the currently selected thread is still valid. If
2879 it is not, select the first available. */
2880 struct thread_info *thread =
2881 (struct thread_info *) find_inferior_id (&all_threads,
2884 thread_id = all_threads.head->id;
2887 general_thread = thread_id;
2888 set_desired_inferior (1);
2890 else if (own_buf[1] == 'c')
2891 cont_thread = thread_id;
2892 else if (own_buf[1] == 's')
2893 step_thread = thread_id;
2899 /* Silently ignore it so that gdb can extend the protocol
2900 without compatibility headaches. */
2905 require_running (own_buf);
2906 if (current_traceframe >= 0)
2908 struct regcache *regcache = new_register_cache ();
2910 if (fetch_traceframe_registers (current_traceframe,
2912 registers_to_string (regcache, own_buf);
2914 write_enn (own_buf);
2915 free_register_cache (regcache);
2919 struct regcache *regcache;
2921 set_desired_inferior (1);
2922 regcache = get_thread_regcache (current_inferior, 1);
2923 registers_to_string (regcache, own_buf);
2927 require_running (own_buf);
2928 if (current_traceframe >= 0)
2929 write_enn (own_buf);
2932 struct regcache *regcache;
2934 set_desired_inferior (1);
2935 regcache = get_thread_regcache (current_inferior, 1);
2936 registers_from_string (regcache, &own_buf[1]);
2941 require_running (own_buf);
2942 decode_m_packet (&own_buf[1], &mem_addr, &len);
2943 if (gdb_read_memory (mem_addr, mem_buf, len) == 0)
2944 convert_int_to_ascii (mem_buf, own_buf, len);
2946 write_enn (own_buf);
2949 require_running (own_buf);
2950 decode_M_packet (&own_buf[1], &mem_addr, &len, &mem_buf);
2951 if (gdb_write_memory (mem_addr, mem_buf, len) == 0)
2954 write_enn (own_buf);
2957 require_running (own_buf);
2958 if (decode_X_packet (&own_buf[1], packet_len - 1,
2959 &mem_addr, &len, &mem_buf) < 0
2960 || gdb_write_memory (mem_addr, mem_buf, len) != 0)
2961 write_enn (own_buf);
2966 require_running (own_buf);
2967 convert_ascii_to_int (own_buf + 1, &sig, 1);
2968 if (target_signal_to_host_p (sig))
2969 signal = target_signal_to_host (sig);
2972 myresume (own_buf, 0, signal);
2975 require_running (own_buf);
2976 convert_ascii_to_int (own_buf + 1, &sig, 1);
2977 if (target_signal_to_host_p (sig))
2978 signal = target_signal_to_host (sig);
2981 myresume (own_buf, 1, signal);
2984 require_running (own_buf);
2986 myresume (own_buf, 0, signal);
2989 require_running (own_buf);
2991 myresume (own_buf, 1, signal);
2993 case 'Z': /* insert_ ... */
2995 case 'z': /* remove_ ... */
2999 CORE_ADDR addr = strtoul (&own_buf[3], &lenptr, 16);
3000 int len = strtol (lenptr + 1, &dataptr, 16);
3001 char type = own_buf[1];
3003 const int insert = ch == 'Z';
3005 /* Default to unrecognized/unsupported. */
3009 case '0': /* software-breakpoint */
3010 case '1': /* hardware-breakpoint */
3011 case '2': /* write watchpoint */
3012 case '3': /* read watchpoint */
3013 case '4': /* access watchpoint */
3014 require_running (own_buf);
3015 if (insert && the_target->insert_point != NULL)
3016 res = (*the_target->insert_point) (type, addr, len);
3017 else if (!insert && the_target->remove_point != NULL)
3018 res = (*the_target->remove_point) (type, addr, len);
3030 write_enn (own_buf);
3034 response_needed = 0;
3035 if (!target_running ())
3036 /* The packet we received doesn't make sense - but we can't
3037 reply to it, either. */
3040 fprintf (stderr, "Killing all inferiors\n");
3041 for_each_inferior (&all_processes, kill_inferior_callback);
3043 /* When using the extended protocol, we wait with no program
3044 running. The traditional protocol will exit instead. */
3045 if (extended_protocol)
3047 last_status.kind = TARGET_WAITKIND_EXITED;
3048 last_status.value.sig = TARGET_SIGNAL_KILL;
3056 ptid_t gdb_id, thread_id;
3058 require_running (own_buf);
3060 gdb_id = read_ptid (&own_buf[1], NULL);
3061 thread_id = gdb_id_to_thread_id (gdb_id);
3062 if (ptid_equal (thread_id, null_ptid))
3064 write_enn (own_buf);
3068 if (mythread_alive (thread_id))
3071 write_enn (own_buf);
3075 response_needed = 0;
3077 /* Restarting the inferior is only supported in the extended
3079 if (extended_protocol)
3081 if (target_running ())
3082 for_each_inferior (&all_processes,
3083 kill_inferior_callback);
3084 fprintf (stderr, "GDBserver restarting\n");
3086 /* Wait till we are at 1st instruction in prog. */
3087 if (program_argv != NULL)
3088 start_inferior (program_argv);
3091 last_status.kind = TARGET_WAITKIND_EXITED;
3092 last_status.value.sig = TARGET_SIGNAL_KILL;
3098 /* It is a request we don't understand. Respond with an
3099 empty packet so that gdb knows that we don't support this
3105 /* Extended (long) request. */
3106 handle_v_requests (own_buf, packet_len, &new_packet_len);
3110 /* It is a request we don't understand. Respond with an empty
3111 packet so that gdb knows that we don't support this
3117 if (new_packet_len != -1)
3118 putpkt_binary (own_buf, new_packet_len);
3122 response_needed = 0;
3124 if (!extended_protocol && have_ran && !target_running ())
3126 /* In non-stop, defer exiting until GDB had a chance to query
3127 the whole vStopped list (until it gets an OK). */
3130 fprintf (stderr, "GDBserver exiting\n");
3142 /* Event-loop callback for serial events. */
3145 handle_serial_event (int err, gdb_client_data client_data)
3148 fprintf (stderr, "handling possible serial event\n");
3150 /* Really handle it. */
3151 if (process_serial_event () < 0)
3154 /* Be sure to not change the selected inferior behind GDB's back.
3155 Important in the non-stop mode asynchronous protocol. */
3156 set_desired_inferior (1);
3161 /* Event-loop callback for target events. */
3164 handle_target_event (int err, gdb_client_data client_data)
3167 fprintf (stderr, "handling possible target event\n");
3169 last_ptid = mywait (minus_one_ptid, &last_status,
3172 if (last_status.kind != TARGET_WAITKIND_IGNORE)
3174 int pid = ptid_get_pid (last_ptid);
3175 struct process_info *process = find_process_pid (pid);
3176 int forward_event = !gdb_connected () || process->gdb_detached;
3178 if (last_status.kind == TARGET_WAITKIND_EXITED
3179 || last_status.kind == TARGET_WAITKIND_SIGNALLED)
3181 mark_breakpoints_out (process);
3182 mourn_inferior (process);
3186 /* We're reporting this thread as stopped. Update its
3187 "want-stopped" state to what the client wants, until it
3188 gets a new resume action. */
3189 current_inferior->last_resume_kind = resume_stop;
3190 current_inferior->last_status = last_status;
3195 if (!target_running ())
3197 /* The last process exited. We're done. */
3201 if (last_status.kind == TARGET_WAITKIND_STOPPED)
3203 /* A thread stopped with a signal, but gdb isn't
3204 connected to handle it. Pass it down to the
3205 inferior, as if it wasn't being traced. */
3206 struct thread_resume resume_info;
3210 "GDB not connected; forwarding event %d for [%s]\n",
3211 (int) last_status.kind,
3212 target_pid_to_str (last_ptid));
3214 resume_info.thread = last_ptid;
3215 resume_info.kind = resume_continue;
3216 resume_info.sig = target_signal_to_host (last_status.value.sig);
3217 (*the_target->resume) (&resume_info, 1);
3219 else if (debug_threads)
3220 fprintf (stderr, "GDB not connected; ignoring event %d for [%s]\n",
3221 (int) last_status.kind,
3222 target_pid_to_str (last_ptid));
3226 /* Something interesting. Tell GDB about it. */
3227 push_event (last_ptid, &last_status);
3231 /* Be sure to not change the selected inferior behind GDB's back.
3232 Important in the non-stop mode asynchronous protocol. */
3233 set_desired_inferior (1);