1 /* Main code for remote server for GDB.
2 Copyright (C) 1989-2017 Free Software Foundation, Inc.
4 This file is part of GDB.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program. If not, see <http://www.gnu.org/licenses/>. */
20 #include "gdbthread.h"
25 #include "signals-state-save-restore.h"
33 #include "btrace-common.h"
34 #include "filestuff.h"
35 #include "tracepoint.h"
39 #include "common-inferior.h"
40 #include "job-control.h"
43 #include "common/selftest.h"
45 #define require_running_or_return(BUF) \
46 if (!target_running ()) \
52 #define require_running_or_break(BUF) \
53 if (!target_running ()) \
59 /* The environment to pass to the inferior when creating it. */
61 static gdb_environ our_environ;
63 /* Start the inferior using a shell. */
65 /* We always try to start the inferior using a shell. */
67 int startup_with_shell = 1;
69 /* The thread set with an `Hc' packet. `Hc' is deprecated in favor of
70 `vCont'. Note the multi-process extensions made `vCont' a
71 requirement, so `Hc pPID.TID' is pretty much undefined. So
72 CONT_THREAD can be null_ptid for no `Hc' thread, minus_one_ptid for
73 resuming all threads of the process (again, `Hc' isn't used for
74 multi-process), or a specific thread ptid_t. */
77 /* The thread set with an `Hg' packet. */
78 ptid_t general_thread;
82 static int extended_protocol;
83 static int response_needed;
84 static int exit_requested;
86 /* --once: Exit after the first connection has closed. */
90 int report_fork_events;
91 int report_vfork_events;
92 int report_exec_events;
93 int report_thread_events;
95 /* Whether to report TARGET_WAITKING_NO_RESUMED events. */
96 static int report_no_resumed;
102 /* True if the "vContSupported" feature is active. In that case, GDB
103 wants us to report whether single step is supported in the reply to
105 static int vCont_supported;
107 /* Whether we should attempt to disable the operating system's address
108 space randomization feature before starting an inferior. */
109 int disable_randomization = 1;
111 static char *program_name = NULL;
112 static std::vector<char *> program_args;
113 static std::string wrapper_argv;
115 int pass_signals[GDB_SIGNAL_LAST];
116 int program_signals[GDB_SIGNAL_LAST];
117 int program_signals_p;
119 /* The PID of the originally created or attached inferior. Used to
120 send signals to the process when GDB sends us an asynchronous interrupt
121 (user hitting Control-C in the client), and to wait for the child to exit
122 when no longer debugging it. */
124 unsigned long signal_pid;
126 /* Set if you want to disable optional thread related packets support
127 in gdbserver, for the sake of testing GDB against stubs that don't
129 int disable_packet_vCont;
130 int disable_packet_Tthread;
131 int disable_packet_qC;
132 int disable_packet_qfThreadInfo;
134 /* Last status reported to GDB. */
135 struct target_waitstatus last_status;
139 static unsigned char *mem_buf;
141 /* A sub-class of 'struct notif_event' for stop, holding information
142 relative to a single stop reply. We keep a queue of these to
143 push to GDB in non-stop mode. */
147 struct notif_event base;
149 /* Thread or process that got the event. */
153 struct target_waitstatus status;
156 /* The current btrace configuration. This is gdbserver's mirror of GDB's
157 btrace configuration. */
158 static struct btrace_config current_btrace_conf;
160 DEFINE_QUEUE_P (notif_event_p);
162 /* Put a stop reply to the stop reply queue. */
165 queue_stop_reply (ptid_t ptid, struct target_waitstatus *status)
167 struct vstop_notif *new_notif = XNEW (struct vstop_notif);
169 new_notif->ptid = ptid;
170 new_notif->status = *status;
172 notif_event_enque (¬if_stop, (struct notif_event *) new_notif);
176 remove_all_on_match_ptid (QUEUE (notif_event_p) *q,
177 QUEUE_ITER (notif_event_p) *iter,
178 struct notif_event *event,
181 ptid_t filter_ptid = *(ptid_t *) data;
182 struct vstop_notif *vstop_event = (struct vstop_notif *) event;
184 if (ptid_match (vstop_event->ptid, filter_ptid))
186 if (q->free_func != NULL)
187 q->free_func (event);
189 QUEUE_remove_elem (notif_event_p, q, iter);
198 discard_queued_stop_replies (ptid_t ptid)
200 QUEUE_iterate (notif_event_p, notif_stop.queue,
201 remove_all_on_match_ptid, &ptid);
205 vstop_notif_reply (struct notif_event *event, char *own_buf)
207 struct vstop_notif *vstop = (struct vstop_notif *) event;
209 prepare_resume_reply (own_buf, vstop->ptid, &vstop->status);
212 /* QUEUE_iterate callback helper for in_queued_stop_replies. */
215 in_queued_stop_replies_ptid (QUEUE (notif_event_p) *q,
216 QUEUE_ITER (notif_event_p) *iter,
217 struct notif_event *event,
220 ptid_t filter_ptid = *(ptid_t *) data;
221 struct vstop_notif *vstop_event = (struct vstop_notif *) event;
223 if (ptid_match (vstop_event->ptid, filter_ptid))
226 /* Don't resume fork children that GDB does not know about yet. */
227 if ((vstop_event->status.kind == TARGET_WAITKIND_FORKED
228 || vstop_event->status.kind == TARGET_WAITKIND_VFORKED)
229 && ptid_match (vstop_event->status.value.related_pid, filter_ptid))
238 in_queued_stop_replies (ptid_t ptid)
240 return !QUEUE_iterate (notif_event_p, notif_stop.queue,
241 in_queued_stop_replies_ptid, &ptid);
244 struct notif_server notif_stop =
246 "vStopped", "Stop", NULL, vstop_notif_reply,
250 target_running (void)
252 return get_first_thread () != NULL;
255 /* See common/common-inferior.h. */
260 return !wrapper_argv.empty () ? wrapper_argv.c_str () : NULL;
263 /* See common/common-inferior.h. */
266 get_exec_file (int err)
268 if (err && program_name == NULL)
269 error (_("No executable file specified."));
283 attach_inferior (int pid)
285 /* myattach should return -1 if attaching is unsupported,
286 0 if it succeeded, and call error() otherwise. */
288 if (myattach (pid) != 0)
291 fprintf (stderr, "Attached; pid = %d\n", pid);
294 /* FIXME - It may be that we should get the SIGNAL_PID from the
295 attach function, so that it can be the main thread instead of
296 whichever we were told to attach to. */
301 last_ptid = mywait (pid_to_ptid (pid), &last_status, 0, 0);
303 /* GDB knows to ignore the first SIGSTOP after attaching to a running
304 process using the "attach" command, but this is different; it's
305 just using "target remote". Pretend it's just starting up. */
306 if (last_status.kind == TARGET_WAITKIND_STOPPED
307 && last_status.value.sig == GDB_SIGNAL_STOP)
308 last_status.value.sig = GDB_SIGNAL_TRAP;
310 current_thread->last_resume_kind = resume_stop;
311 current_thread->last_status = last_status;
317 extern int remote_debug;
319 /* Decode a qXfer read request. Return 0 if everything looks OK,
323 decode_xfer_read (char *buf, CORE_ADDR *ofs, unsigned int *len)
325 /* After the read marker and annex, qXfer looks like a
326 traditional 'm' packet. */
327 decode_m_packet (buf, ofs, len);
333 decode_xfer (char *buf, char **object, char **rw, char **annex, char **offset)
335 /* Extract and NUL-terminate the object. */
337 while (*buf && *buf != ':')
343 /* Extract and NUL-terminate the read/write action. */
345 while (*buf && *buf != ':')
351 /* Extract and NUL-terminate the annex. */
353 while (*buf && *buf != ':')
363 /* Write the response to a successful qXfer read. Returns the
364 length of the (binary) data stored in BUF, corresponding
365 to as much of DATA/LEN as we could fit. IS_MORE controls
366 the first character of the response. */
368 write_qxfer_response (char *buf, const gdb_byte *data, int len, int is_more)
377 return remote_escape_output (data, len, 1, (unsigned char *) buf + 1,
378 &out_len, PBUFSIZ - 2) + 1;
381 /* Handle btrace enabling in BTS format. */
384 handle_btrace_enable_bts (struct thread_info *thread)
386 if (thread->btrace != NULL)
387 return "E.Btrace already enabled.";
389 current_btrace_conf.format = BTRACE_FORMAT_BTS;
390 thread->btrace = target_enable_btrace (thread->entry.id,
391 ¤t_btrace_conf);
392 if (thread->btrace == NULL)
393 return "E.Could not enable btrace.";
398 /* Handle btrace enabling in Intel Processor Trace format. */
401 handle_btrace_enable_pt (struct thread_info *thread)
403 if (thread->btrace != NULL)
404 return "E.Btrace already enabled.";
406 current_btrace_conf.format = BTRACE_FORMAT_PT;
407 thread->btrace = target_enable_btrace (thread->entry.id,
408 ¤t_btrace_conf);
409 if (thread->btrace == NULL)
410 return "E.Could not enable btrace.";
415 /* Handle btrace disabling. */
418 handle_btrace_disable (struct thread_info *thread)
421 if (thread->btrace == NULL)
422 return "E.Branch tracing not enabled.";
424 if (target_disable_btrace (thread->btrace) != 0)
425 return "E.Could not disable branch tracing.";
427 thread->btrace = NULL;
431 /* Handle the "Qbtrace" packet. */
434 handle_btrace_general_set (char *own_buf)
436 struct thread_info *thread;
440 if (!startswith (own_buf, "Qbtrace:"))
443 op = own_buf + strlen ("Qbtrace:");
445 if (ptid_equal (general_thread, null_ptid)
446 || ptid_equal (general_thread, minus_one_ptid))
448 strcpy (own_buf, "E.Must select a single thread.");
452 thread = find_thread_ptid (general_thread);
455 strcpy (own_buf, "E.No such thread.");
461 if (strcmp (op, "bts") == 0)
462 err = handle_btrace_enable_bts (thread);
463 else if (strcmp (op, "pt") == 0)
464 err = handle_btrace_enable_pt (thread);
465 else if (strcmp (op, "off") == 0)
466 err = handle_btrace_disable (thread);
468 err = "E.Bad Qbtrace operation. Use bts, pt, or off.";
471 strcpy (own_buf, err);
478 /* Handle the "Qbtrace-conf" packet. */
481 handle_btrace_conf_general_set (char *own_buf)
483 struct thread_info *thread;
486 if (!startswith (own_buf, "Qbtrace-conf:"))
489 op = own_buf + strlen ("Qbtrace-conf:");
491 if (ptid_equal (general_thread, null_ptid)
492 || ptid_equal (general_thread, minus_one_ptid))
494 strcpy (own_buf, "E.Must select a single thread.");
498 thread = find_thread_ptid (general_thread);
501 strcpy (own_buf, "E.No such thread.");
505 if (startswith (op, "bts:size="))
511 size = strtoul (op + strlen ("bts:size="), &endp, 16);
512 if (endp == NULL || *endp != 0 || errno != 0 || size > UINT_MAX)
514 strcpy (own_buf, "E.Bad size value.");
518 current_btrace_conf.bts.size = (unsigned int) size;
520 else if (strncmp (op, "pt:size=", strlen ("pt:size=")) == 0)
526 size = strtoul (op + strlen ("pt:size="), &endp, 16);
527 if (endp == NULL || *endp != 0 || errno != 0 || size > UINT_MAX)
529 strcpy (own_buf, "E.Bad size value.");
533 current_btrace_conf.pt.size = (unsigned int) size;
537 strcpy (own_buf, "E.Bad Qbtrace configuration option.");
545 /* Handle all of the extended 'Q' packets. */
548 handle_general_set (char *own_buf)
550 if (startswith (own_buf, "QPassSignals:"))
552 int numsigs = (int) GDB_SIGNAL_LAST, i;
553 const char *p = own_buf + strlen ("QPassSignals:");
556 p = decode_address_to_semicolon (&cursig, p);
557 for (i = 0; i < numsigs; i++)
563 /* Keep looping, to clear the remaining signals. */
566 p = decode_address_to_semicolon (&cursig, p);
571 strcpy (own_buf, "OK");
575 if (startswith (own_buf, "QProgramSignals:"))
577 int numsigs = (int) GDB_SIGNAL_LAST, i;
578 const char *p = own_buf + strlen ("QProgramSignals:");
581 program_signals_p = 1;
583 p = decode_address_to_semicolon (&cursig, p);
584 for (i = 0; i < numsigs; i++)
588 program_signals[i] = 1;
590 /* Keep looping, to clear the remaining signals. */
593 p = decode_address_to_semicolon (&cursig, p);
596 program_signals[i] = 0;
598 strcpy (own_buf, "OK");
602 if (startswith (own_buf, "QCatchSyscalls:"))
604 const char *p = own_buf + sizeof ("QCatchSyscalls:") - 1;
607 struct process_info *process;
609 if (!target_running () || !target_supports_catch_syscall ())
615 if (strcmp (p, "0") == 0)
617 else if (p[0] == '1' && (p[1] == ';' || p[1] == '\0'))
621 fprintf (stderr, "Unknown catch-syscalls mode requested: %s\n",
627 process = current_process ();
628 VEC_truncate (int, process->syscalls_to_catch, 0);
638 p = decode_address_to_semicolon (&sysno, p);
639 VEC_safe_push (int, process->syscalls_to_catch, (int) sysno);
643 VEC_safe_push (int, process->syscalls_to_catch, ANY_SYSCALL);
650 if (strcmp (own_buf, "QEnvironmentReset") == 0)
652 our_environ = gdb_environ::from_host_environ ();
658 if (startswith (own_buf, "QEnvironmentHexEncoded:"))
660 const char *p = own_buf + sizeof ("QEnvironmentHexEncoded:") - 1;
661 /* The final form of the environment variable. FINAL_VAR will
662 hold the 'VAR=VALUE' format. */
663 std::string final_var = hex2str (p);
664 std::string var_name, var_value;
668 debug_printf (_("[QEnvironmentHexEncoded received '%s']\n"), p);
669 debug_printf (_("[Environment variable to be set: '%s']\n"),
674 size_t pos = final_var.find ('=');
675 if (pos == std::string::npos)
677 warning (_("Unexpected format for environment variable: '%s'"),
683 var_name = final_var.substr (0, pos);
684 var_value = final_var.substr (pos + 1, std::string::npos);
686 our_environ.set (var_name.c_str (), var_value.c_str ());
692 if (startswith (own_buf, "QEnvironmentUnset:"))
694 const char *p = own_buf + sizeof ("QEnvironmentUnset:") - 1;
695 std::string varname = hex2str (p);
699 debug_printf (_("[QEnvironmentUnset received '%s']\n"), p);
700 debug_printf (_("[Environment variable to be unset: '%s']\n"),
705 our_environ.unset (varname.c_str ());
711 if (strcmp (own_buf, "QStartNoAckMode") == 0)
715 debug_printf ("[noack mode enabled]\n");
724 if (startswith (own_buf, "QNonStop:"))
726 char *mode = own_buf + 9;
730 if (strcmp (mode, "0") == 0)
732 else if (strcmp (mode, "1") == 0)
736 /* We don't know what this mode is, so complain to
738 fprintf (stderr, "Unknown non-stop mode requested: %s\n",
744 req_str = req ? "non-stop" : "all-stop";
745 if (start_non_stop (req) != 0)
747 fprintf (stderr, "Setting %s mode failed\n", req_str);
755 debug_printf ("[%s mode enabled]\n", req_str);
761 if (startswith (own_buf, "QDisableRandomization:"))
763 char *packet = own_buf + strlen ("QDisableRandomization:");
766 unpack_varlen_hex (packet, &setting);
767 disable_randomization = setting;
771 debug_printf (disable_randomization
772 ? "[address space randomization disabled]\n"
773 : "[address space randomization enabled]\n");
780 if (target_supports_tracepoints ()
781 && handle_tracepoint_general_set (own_buf))
784 if (startswith (own_buf, "QAgent:"))
786 char *mode = own_buf + strlen ("QAgent:");
789 if (strcmp (mode, "0") == 0)
791 else if (strcmp (mode, "1") == 0)
795 /* We don't know what this value is, so complain to GDB. */
796 sprintf (own_buf, "E.Unknown QAgent value");
800 /* Update the flag. */
803 debug_printf ("[%s agent]\n", req ? "Enable" : "Disable");
808 if (handle_btrace_general_set (own_buf))
811 if (handle_btrace_conf_general_set (own_buf))
814 if (startswith (own_buf, "QThreadEvents:"))
816 char *mode = own_buf + strlen ("QThreadEvents:");
817 enum tribool req = TRIBOOL_UNKNOWN;
819 if (strcmp (mode, "0") == 0)
821 else if (strcmp (mode, "1") == 0)
825 char *mode_copy = xstrdup (mode);
827 /* We don't know what this mode is, so complain to GDB. */
828 sprintf (own_buf, "E.Unknown thread-events mode requested: %s\n",
834 report_thread_events = (req == TRIBOOL_TRUE);
838 const char *req_str = report_thread_events ? "enabled" : "disabled";
840 debug_printf ("[thread events are now %s]\n", req_str);
847 if (startswith (own_buf, "QStartupWithShell:"))
849 const char *value = own_buf + strlen ("QStartupWithShell:");
851 if (strcmp (value, "1") == 0)
852 startup_with_shell = true;
853 else if (strcmp (value, "0") == 0)
854 startup_with_shell = false;
858 fprintf (stderr, "Unknown value to startup-with-shell: %s\n",
865 debug_printf (_("[Inferior will %s started with shell]"),
866 startup_with_shell ? "be" : "not be");
872 if (startswith (own_buf, "QSetWorkingDir:"))
874 const char *p = own_buf + strlen ("QSetWorkingDir:");
878 std::string path = hex2str (p);
880 set_inferior_cwd (path.c_str ());
883 debug_printf (_("[Set the inferior's current directory to %s]\n"),
888 /* An empty argument means that we should clear out any
889 previously set cwd for the inferior. */
890 set_inferior_cwd (NULL);
894 [Unset the inferior's current directory; will use gdbserver's cwd]\n"));
901 /* Otherwise we didn't know what packet it was. Say we didn't
907 get_features_xml (const char *annex)
909 const struct target_desc *desc = current_target_desc ();
911 /* `desc->xmltarget' defines what to return when looking for the
912 "target.xml" file. Its contents can either be verbatim XML code
913 (prefixed with a '@') or else the name of the actual XML file to
914 be used in place of "target.xml".
916 This variable is set up from the auto-generated
917 init_registers_... routine for the current target. */
919 if (strcmp (annex, "target.xml") == 0)
921 const char *ret = tdesc_get_features_xml ((target_desc*) desc);
931 extern const char *const xml_builtin[][2];
934 /* Look for the annex. */
935 for (i = 0; xml_builtin[i][0] != NULL; i++)
936 if (strcmp (annex, xml_builtin[i][0]) == 0)
939 if (xml_builtin[i][0] != NULL)
940 return xml_builtin[i][1];
948 monitor_show_help (void)
950 monitor_output ("The following monitor commands are supported:\n");
951 monitor_output (" set debug <0|1>\n");
952 monitor_output (" Enable general debugging messages\n");
953 monitor_output (" set debug-hw-points <0|1>\n");
954 monitor_output (" Enable h/w breakpoint/watchpoint debugging messages\n");
955 monitor_output (" set remote-debug <0|1>\n");
956 monitor_output (" Enable remote protocol debugging messages\n");
957 monitor_output (" set debug-format option1[,option2,...]\n");
958 monitor_output (" Add additional information to debugging messages\n");
959 monitor_output (" Options: all, none");
960 monitor_output (", timestamp");
961 monitor_output ("\n");
962 monitor_output (" exit\n");
963 monitor_output (" Quit GDBserver\n");
966 /* Read trace frame or inferior memory. Returns the number of bytes
967 actually read, zero when no further transfer is possible, and -1 on
968 error. Return of a positive value smaller than LEN does not
969 indicate there's no more to be read, only the end of the transfer.
970 E.g., when GDB reads memory from a traceframe, a first request may
971 be served from a memory block that does not cover the whole request
972 length. A following request gets the rest served from either
973 another block (of the same traceframe) or from the read-only
977 gdb_read_memory (CORE_ADDR memaddr, unsigned char *myaddr, int len)
981 if (current_traceframe >= 0)
984 ULONGEST length = len;
986 if (traceframe_read_mem (current_traceframe,
987 memaddr, myaddr, len, &nbytes))
989 /* Data read from trace buffer, we're done. */
992 if (!in_readonly_region (memaddr, length))
994 /* Otherwise we have a valid readonly case, fall through. */
995 /* (assume no half-trace half-real blocks for now) */
998 res = prepare_to_access_memory ();
1001 if (set_desired_thread ())
1002 res = read_inferior_memory (memaddr, myaddr, len);
1005 done_accessing_memory ();
1007 return res == 0 ? len : -1;
1013 /* Write trace frame or inferior memory. Actually, writing to trace
1014 frames is forbidden. */
1017 gdb_write_memory (CORE_ADDR memaddr, const unsigned char *myaddr, int len)
1019 if (current_traceframe >= 0)
1025 ret = prepare_to_access_memory ();
1028 if (set_desired_thread ())
1029 ret = write_inferior_memory (memaddr, myaddr, len);
1032 done_accessing_memory ();
1038 /* Subroutine of handle_search_memory to simplify it. */
1041 handle_search_memory_1 (CORE_ADDR start_addr, CORE_ADDR search_space_len,
1042 gdb_byte *pattern, unsigned pattern_len,
1043 gdb_byte *search_buf,
1044 unsigned chunk_size, unsigned search_buf_size,
1045 CORE_ADDR *found_addrp)
1047 /* Prime the search buffer. */
1049 if (gdb_read_memory (start_addr, search_buf, search_buf_size)
1052 warning ("Unable to access %ld bytes of target "
1053 "memory at 0x%lx, halting search.",
1054 (long) search_buf_size, (long) start_addr);
1058 /* Perform the search.
1060 The loop is kept simple by allocating [N + pattern-length - 1] bytes.
1061 When we've scanned N bytes we copy the trailing bytes to the start and
1062 read in another N bytes. */
1064 while (search_space_len >= pattern_len)
1066 gdb_byte *found_ptr;
1067 unsigned nr_search_bytes = (search_space_len < search_buf_size
1071 found_ptr = (gdb_byte *) memmem (search_buf, nr_search_bytes, pattern,
1074 if (found_ptr != NULL)
1076 CORE_ADDR found_addr = start_addr + (found_ptr - search_buf);
1077 *found_addrp = found_addr;
1081 /* Not found in this chunk, skip to next chunk. */
1083 /* Don't let search_space_len wrap here, it's unsigned. */
1084 if (search_space_len >= chunk_size)
1085 search_space_len -= chunk_size;
1087 search_space_len = 0;
1089 if (search_space_len >= pattern_len)
1091 unsigned keep_len = search_buf_size - chunk_size;
1092 CORE_ADDR read_addr = start_addr + chunk_size + keep_len;
1095 /* Copy the trailing part of the previous iteration to the front
1096 of the buffer for the next iteration. */
1097 memcpy (search_buf, search_buf + chunk_size, keep_len);
1099 nr_to_read = (search_space_len - keep_len < chunk_size
1100 ? search_space_len - keep_len
1103 if (gdb_read_memory (read_addr, search_buf + keep_len,
1104 nr_to_read) != search_buf_size)
1106 warning ("Unable to access %ld bytes of target memory "
1107 "at 0x%lx, halting search.",
1108 (long) nr_to_read, (long) read_addr);
1112 start_addr += chunk_size;
1121 /* Handle qSearch:memory packets. */
1124 handle_search_memory (char *own_buf, int packet_len)
1126 CORE_ADDR start_addr;
1127 CORE_ADDR search_space_len;
1129 unsigned int pattern_len;
1130 /* NOTE: also defined in find.c testcase. */
1131 #define SEARCH_CHUNK_SIZE 16000
1132 const unsigned chunk_size = SEARCH_CHUNK_SIZE;
1133 /* Buffer to hold memory contents for searching. */
1134 gdb_byte *search_buf;
1135 unsigned search_buf_size;
1137 CORE_ADDR found_addr;
1138 int cmd_name_len = sizeof ("qSearch:memory:") - 1;
1140 pattern = (gdb_byte *) malloc (packet_len);
1141 if (pattern == NULL)
1143 error ("Unable to allocate memory to perform the search");
1144 strcpy (own_buf, "E00");
1147 if (decode_search_memory_packet (own_buf + cmd_name_len,
1148 packet_len - cmd_name_len,
1149 &start_addr, &search_space_len,
1150 pattern, &pattern_len) < 0)
1153 error ("Error in parsing qSearch:memory packet");
1154 strcpy (own_buf, "E00");
1158 search_buf_size = chunk_size + pattern_len - 1;
1160 /* No point in trying to allocate a buffer larger than the search space. */
1161 if (search_space_len < search_buf_size)
1162 search_buf_size = search_space_len;
1164 search_buf = (gdb_byte *) malloc (search_buf_size);
1165 if (search_buf == NULL)
1168 error ("Unable to allocate memory to perform the search");
1169 strcpy (own_buf, "E00");
1173 found = handle_search_memory_1 (start_addr, search_space_len,
1174 pattern, pattern_len,
1175 search_buf, chunk_size, search_buf_size,
1179 sprintf (own_buf, "1,%lx", (long) found_addr);
1180 else if (found == 0)
1181 strcpy (own_buf, "0");
1183 strcpy (own_buf, "E00");
1189 /* Handle the "D" packet. */
1192 handle_detach (char *own_buf)
1194 require_running_or_return (own_buf);
1201 pid = strtol (&own_buf[2], NULL, 16);
1204 pid = ptid_get_pid (current_ptid);
1206 if ((tracing && disconnected_tracing) || any_persistent_commands ())
1208 struct process_info *process = find_process_pid (pid);
1210 if (process == NULL)
1212 write_enn (own_buf);
1216 if (tracing && disconnected_tracing)
1218 "Disconnected tracing in effect, "
1219 "leaving gdbserver attached to the process\n");
1221 if (any_persistent_commands ())
1223 "Persistent commands are present, "
1224 "leaving gdbserver attached to the process\n");
1226 /* Make sure we're in non-stop/async mode, so we we can both
1227 wait for an async socket accept, and handle async target
1228 events simultaneously. There's also no point either in
1229 having the target stop all threads, when we're going to
1230 pass signals down without informing GDB. */
1234 debug_printf ("Forcing non-stop mode\n");
1240 process->gdb_detached = 1;
1242 /* Detaching implicitly resumes all threads. */
1243 target_continue_no_signal (minus_one_ptid);
1249 fprintf (stderr, "Detaching from process %d\n", pid);
1251 if (detach_inferior (pid) != 0)
1252 write_enn (own_buf);
1255 discard_queued_stop_replies (pid_to_ptid (pid));
1258 if (extended_protocol || target_running ())
1260 /* There is still at least one inferior remaining or
1261 we are in extended mode, so don't terminate gdbserver,
1262 and instead treat this like a normal program exit. */
1263 last_status.kind = TARGET_WAITKIND_EXITED;
1264 last_status.value.integer = 0;
1265 last_ptid = pid_to_ptid (pid);
1267 current_thread = NULL;
1274 /* If we are attached, then we can exit. Otherwise, we
1275 need to hang around doing nothing, until the child is
1277 join_inferior (pid);
1283 /* Parse options to --debug-format= and "monitor set debug-format".
1284 ARG is the text after "--debug-format=" or "monitor set debug-format".
1285 IS_MONITOR is non-zero if we're invoked via "monitor set debug-format".
1286 This triggers calls to monitor_output.
1287 The result is NULL if all options were parsed ok, otherwise an error
1288 message which the caller must free.
1290 N.B. These commands affect all debug format settings, they are not
1291 cumulative. If a format is not specified, it is turned off.
1292 However, we don't go to extra trouble with things like
1293 "monitor set debug-format all,none,timestamp".
1294 Instead we just parse them one at a time, in order.
1296 The syntax for "monitor set debug" we support here is not identical
1297 to gdb's "set debug foo on|off" because we also use this function to
1298 parse "--debug-format=foo,bar". */
1301 parse_debug_format_options (const char *arg, int is_monitor)
1303 VEC (char_ptr) *options;
1307 /* First turn all debug format options off. */
1308 debug_timestamp = 0;
1310 /* First remove leading spaces, for "monitor set debug-format". */
1311 while (isspace (*arg))
1314 options = delim_string_to_char_ptr_vec (arg, ',');
1316 for (ix = 0; VEC_iterate (char_ptr, options, ix, option); ++ix)
1318 if (strcmp (option, "all") == 0)
1320 debug_timestamp = 1;
1322 monitor_output ("All extra debug format options enabled.\n");
1324 else if (strcmp (option, "none") == 0)
1326 debug_timestamp = 0;
1328 monitor_output ("All extra debug format options disabled.\n");
1330 else if (strcmp (option, "timestamp") == 0)
1332 debug_timestamp = 1;
1334 monitor_output ("Timestamps will be added to debug output.\n");
1336 else if (*option == '\0')
1338 /* An empty option, e.g., "--debug-format=foo,,bar", is ignored. */
1343 char *msg = xstrprintf ("Unknown debug-format argument: \"%s\"\n",
1346 free_char_ptr_vec (options);
1351 free_char_ptr_vec (options);
1355 /* Handle monitor commands not handled by target-specific handlers. */
1358 handle_monitor_command (char *mon, char *own_buf)
1360 if (strcmp (mon, "set debug 1") == 0)
1363 monitor_output ("Debug output enabled.\n");
1365 else if (strcmp (mon, "set debug 0") == 0)
1368 monitor_output ("Debug output disabled.\n");
1370 else if (strcmp (mon, "set debug-hw-points 1") == 0)
1372 show_debug_regs = 1;
1373 monitor_output ("H/W point debugging output enabled.\n");
1375 else if (strcmp (mon, "set debug-hw-points 0") == 0)
1377 show_debug_regs = 0;
1378 monitor_output ("H/W point debugging output disabled.\n");
1380 else if (strcmp (mon, "set remote-debug 1") == 0)
1383 monitor_output ("Protocol debug output enabled.\n");
1385 else if (strcmp (mon, "set remote-debug 0") == 0)
1388 monitor_output ("Protocol debug output disabled.\n");
1390 else if (startswith (mon, "set debug-format "))
1393 = parse_debug_format_options (mon + sizeof ("set debug-format ") - 1,
1396 if (error_msg != NULL)
1398 monitor_output (error_msg);
1399 monitor_show_help ();
1400 write_enn (own_buf);
1404 else if (strcmp (mon, "help") == 0)
1405 monitor_show_help ();
1406 else if (strcmp (mon, "exit") == 0)
1410 monitor_output ("Unknown monitor command.\n\n");
1411 monitor_show_help ();
1412 write_enn (own_buf);
1416 /* Associates a callback with each supported qXfer'able object. */
1420 /* The object this handler handles. */
1423 /* Request that the target transfer up to LEN 8-bit bytes of the
1424 target's OBJECT. The OFFSET, for a seekable object, specifies
1425 the starting point. The ANNEX can be used to provide additional
1426 data-specific information to the target.
1428 Return the number of bytes actually transfered, zero when no
1429 further transfer is possible, -1 on error, -2 when the transfer
1430 is not supported, and -3 on a verbose error message that should
1431 be preserved. Return of a positive value smaller than LEN does
1432 not indicate the end of the object, only the end of the transfer.
1434 One, and only one, of readbuf or writebuf must be non-NULL. */
1435 int (*xfer) (const char *annex,
1436 gdb_byte *readbuf, const gdb_byte *writebuf,
1437 ULONGEST offset, LONGEST len);
1440 /* Handle qXfer:auxv:read. */
1443 handle_qxfer_auxv (const char *annex,
1444 gdb_byte *readbuf, const gdb_byte *writebuf,
1445 ULONGEST offset, LONGEST len)
1447 if (the_target->read_auxv == NULL || writebuf != NULL)
1450 if (annex[0] != '\0' || current_thread == NULL)
1453 return (*the_target->read_auxv) (offset, readbuf, len);
1456 /* Handle qXfer:exec-file:read. */
1459 handle_qxfer_exec_file (const char *annex,
1460 gdb_byte *readbuf, const gdb_byte *writebuf,
1461 ULONGEST offset, LONGEST len)
1467 if (the_target->pid_to_exec_file == NULL || writebuf != NULL)
1470 if (annex[0] == '\0')
1472 if (current_thread == NULL)
1475 pid = pid_of (current_thread);
1479 annex = unpack_varlen_hex (annex, &pid);
1480 if (annex[0] != '\0')
1487 file = (*the_target->pid_to_exec_file) (pid);
1491 total_len = strlen (file);
1493 if (offset > total_len)
1496 if (offset + len > total_len)
1497 len = total_len - offset;
1499 memcpy (readbuf, file + offset, len);
1503 /* Handle qXfer:features:read. */
1506 handle_qxfer_features (const char *annex,
1507 gdb_byte *readbuf, const gdb_byte *writebuf,
1508 ULONGEST offset, LONGEST len)
1510 const char *document;
1513 if (writebuf != NULL)
1516 if (!target_running ())
1519 /* Grab the correct annex. */
1520 document = get_features_xml (annex);
1521 if (document == NULL)
1524 total_len = strlen (document);
1526 if (offset > total_len)
1529 if (offset + len > total_len)
1530 len = total_len - offset;
1532 memcpy (readbuf, document + offset, len);
1536 /* Handle qXfer:libraries:read. */
1539 handle_qxfer_libraries (const char *annex,
1540 gdb_byte *readbuf, const gdb_byte *writebuf,
1541 ULONGEST offset, LONGEST len)
1543 if (writebuf != NULL)
1546 if (annex[0] != '\0' || current_thread == NULL)
1549 std::string document = "<library-list version=\"1.0\">\n";
1551 for (const dll_info &dll : all_dlls)
1552 document += string_printf
1553 (" <library name=\"%s\"><segment address=\"0x%lx\"/></library>\n",
1554 dll.name.c_str (), (long) dll.base_addr);
1556 document += "</library-list>\n";
1558 if (offset > document.length ())
1561 if (offset + len > document.length ())
1562 len = document.length () - offset;
1564 memcpy (readbuf, &document[offset], len);
1569 /* Handle qXfer:libraries-svr4:read. */
1572 handle_qxfer_libraries_svr4 (const char *annex,
1573 gdb_byte *readbuf, const gdb_byte *writebuf,
1574 ULONGEST offset, LONGEST len)
1576 if (writebuf != NULL)
1579 if (current_thread == NULL || the_target->qxfer_libraries_svr4 == NULL)
1582 return the_target->qxfer_libraries_svr4 (annex, readbuf, writebuf, offset, len);
1585 /* Handle qXfer:osadata:read. */
1588 handle_qxfer_osdata (const char *annex,
1589 gdb_byte *readbuf, const gdb_byte *writebuf,
1590 ULONGEST offset, LONGEST len)
1592 if (the_target->qxfer_osdata == NULL || writebuf != NULL)
1595 return (*the_target->qxfer_osdata) (annex, readbuf, NULL, offset, len);
1598 /* Handle qXfer:siginfo:read and qXfer:siginfo:write. */
1601 handle_qxfer_siginfo (const char *annex,
1602 gdb_byte *readbuf, const gdb_byte *writebuf,
1603 ULONGEST offset, LONGEST len)
1605 if (the_target->qxfer_siginfo == NULL)
1608 if (annex[0] != '\0' || current_thread == NULL)
1611 return (*the_target->qxfer_siginfo) (annex, readbuf, writebuf, offset, len);
1614 /* Handle qXfer:spu:read and qXfer:spu:write. */
1617 handle_qxfer_spu (const char *annex,
1618 gdb_byte *readbuf, const gdb_byte *writebuf,
1619 ULONGEST offset, LONGEST len)
1621 if (the_target->qxfer_spu == NULL)
1624 if (current_thread == NULL)
1627 return (*the_target->qxfer_spu) (annex, readbuf, writebuf, offset, len);
1630 /* Handle qXfer:statictrace:read. */
1633 handle_qxfer_statictrace (const char *annex,
1634 gdb_byte *readbuf, const gdb_byte *writebuf,
1635 ULONGEST offset, LONGEST len)
1639 if (writebuf != NULL)
1642 if (annex[0] != '\0' || current_thread == NULL || current_traceframe == -1)
1645 if (traceframe_read_sdata (current_traceframe, offset,
1646 readbuf, len, &nbytes))
1651 /* Helper for handle_qxfer_threads_proper.
1652 Emit the XML to describe the thread of INF. */
1655 handle_qxfer_threads_worker (struct inferior_list_entry *inf, void *arg)
1657 struct thread_info *thread = (struct thread_info *) inf;
1658 struct buffer *buffer = (struct buffer *) arg;
1659 ptid_t ptid = ptid_of (thread);
1661 int core = target_core_of_thread (ptid);
1663 const char *name = target_thread_name (ptid);
1666 bool handle_status = target_thread_handle (ptid, &handle, &handle_len);
1668 write_ptid (ptid_s, ptid);
1670 buffer_xml_printf (buffer, "<thread id=\"%s\"", ptid_s);
1674 sprintf (core_s, "%d", core);
1675 buffer_xml_printf (buffer, " core=\"%s\"", core_s);
1679 buffer_xml_printf (buffer, " name=\"%s\"", name);
1683 char *handle_s = (char *) alloca (handle_len * 2 + 1);
1684 bin2hex (handle, handle_s, handle_len);
1685 buffer_xml_printf (buffer, " handle=\"%s\"", handle_s);
1688 buffer_xml_printf (buffer, "/>\n");
1691 /* Helper for handle_qxfer_threads. */
1694 handle_qxfer_threads_proper (struct buffer *buffer)
1696 buffer_grow_str (buffer, "<threads>\n");
1698 for_each_inferior_with_data (&all_threads, handle_qxfer_threads_worker,
1701 buffer_grow_str0 (buffer, "</threads>\n");
1704 /* Handle qXfer:threads:read. */
1707 handle_qxfer_threads (const char *annex,
1708 gdb_byte *readbuf, const gdb_byte *writebuf,
1709 ULONGEST offset, LONGEST len)
1711 static char *result = 0;
1712 static unsigned int result_length = 0;
1714 if (writebuf != NULL)
1717 if (annex[0] != '\0')
1722 struct buffer buffer;
1723 /* When asked for data at offset 0, generate everything and store into
1724 'result'. Successive reads will be served off 'result'. */
1728 buffer_init (&buffer);
1730 handle_qxfer_threads_proper (&buffer);
1732 result = buffer_finish (&buffer);
1733 result_length = strlen (result);
1734 buffer_free (&buffer);
1737 if (offset >= result_length)
1739 /* We're out of data. */
1746 if (len > result_length - offset)
1747 len = result_length - offset;
1749 memcpy (readbuf, result + offset, len);
1754 /* Handle qXfer:traceframe-info:read. */
1757 handle_qxfer_traceframe_info (const char *annex,
1758 gdb_byte *readbuf, const gdb_byte *writebuf,
1759 ULONGEST offset, LONGEST len)
1761 static char *result = 0;
1762 static unsigned int result_length = 0;
1764 if (writebuf != NULL)
1767 if (!target_running () || annex[0] != '\0' || current_traceframe == -1)
1772 struct buffer buffer;
1774 /* When asked for data at offset 0, generate everything and
1775 store into 'result'. Successive reads will be served off
1779 buffer_init (&buffer);
1781 traceframe_read_info (current_traceframe, &buffer);
1783 result = buffer_finish (&buffer);
1784 result_length = strlen (result);
1785 buffer_free (&buffer);
1788 if (offset >= result_length)
1790 /* We're out of data. */
1797 if (len > result_length - offset)
1798 len = result_length - offset;
1800 memcpy (readbuf, result + offset, len);
1804 /* Handle qXfer:fdpic:read. */
1807 handle_qxfer_fdpic (const char *annex, gdb_byte *readbuf,
1808 const gdb_byte *writebuf, ULONGEST offset, LONGEST len)
1810 if (the_target->read_loadmap == NULL)
1813 if (current_thread == NULL)
1816 return (*the_target->read_loadmap) (annex, offset, readbuf, len);
1819 /* Handle qXfer:btrace:read. */
1822 handle_qxfer_btrace (const char *annex,
1823 gdb_byte *readbuf, const gdb_byte *writebuf,
1824 ULONGEST offset, LONGEST len)
1826 static struct buffer cache;
1827 struct thread_info *thread;
1828 enum btrace_read_type type;
1831 if (the_target->read_btrace == NULL || writebuf != NULL)
1834 if (ptid_equal (general_thread, null_ptid)
1835 || ptid_equal (general_thread, minus_one_ptid))
1837 strcpy (own_buf, "E.Must select a single thread.");
1841 thread = find_thread_ptid (general_thread);
1844 strcpy (own_buf, "E.No such thread.");
1848 if (thread->btrace == NULL)
1850 strcpy (own_buf, "E.Btrace not enabled.");
1854 if (strcmp (annex, "all") == 0)
1855 type = BTRACE_READ_ALL;
1856 else if (strcmp (annex, "new") == 0)
1857 type = BTRACE_READ_NEW;
1858 else if (strcmp (annex, "delta") == 0)
1859 type = BTRACE_READ_DELTA;
1862 strcpy (own_buf, "E.Bad annex.");
1868 buffer_free (&cache);
1870 result = target_read_btrace (thread->btrace, &cache, type);
1873 memcpy (own_buf, cache.buffer, cache.used_size);
1877 else if (offset > cache.used_size)
1879 buffer_free (&cache);
1883 if (len > cache.used_size - offset)
1884 len = cache.used_size - offset;
1886 memcpy (readbuf, cache.buffer + offset, len);
1891 /* Handle qXfer:btrace-conf:read. */
1894 handle_qxfer_btrace_conf (const char *annex,
1895 gdb_byte *readbuf, const gdb_byte *writebuf,
1896 ULONGEST offset, LONGEST len)
1898 static struct buffer cache;
1899 struct thread_info *thread;
1902 if (the_target->read_btrace_conf == NULL || writebuf != NULL)
1905 if (annex[0] != '\0')
1908 if (ptid_equal (general_thread, null_ptid)
1909 || ptid_equal (general_thread, minus_one_ptid))
1911 strcpy (own_buf, "E.Must select a single thread.");
1915 thread = find_thread_ptid (general_thread);
1918 strcpy (own_buf, "E.No such thread.");
1922 if (thread->btrace == NULL)
1924 strcpy (own_buf, "E.Btrace not enabled.");
1930 buffer_free (&cache);
1932 result = target_read_btrace_conf (thread->btrace, &cache);
1935 memcpy (own_buf, cache.buffer, cache.used_size);
1939 else if (offset > cache.used_size)
1941 buffer_free (&cache);
1945 if (len > cache.used_size - offset)
1946 len = cache.used_size - offset;
1948 memcpy (readbuf, cache.buffer + offset, len);
1953 static const struct qxfer qxfer_packets[] =
1955 { "auxv", handle_qxfer_auxv },
1956 { "btrace", handle_qxfer_btrace },
1957 { "btrace-conf", handle_qxfer_btrace_conf },
1958 { "exec-file", handle_qxfer_exec_file},
1959 { "fdpic", handle_qxfer_fdpic},
1960 { "features", handle_qxfer_features },
1961 { "libraries", handle_qxfer_libraries },
1962 { "libraries-svr4", handle_qxfer_libraries_svr4 },
1963 { "osdata", handle_qxfer_osdata },
1964 { "siginfo", handle_qxfer_siginfo },
1965 { "spu", handle_qxfer_spu },
1966 { "statictrace", handle_qxfer_statictrace },
1967 { "threads", handle_qxfer_threads },
1968 { "traceframe-info", handle_qxfer_traceframe_info },
1972 handle_qxfer (char *own_buf, int packet_len, int *new_packet_len_p)
1980 if (!startswith (own_buf, "qXfer:"))
1983 /* Grab the object, r/w and annex. */
1984 if (decode_xfer (own_buf + 6, &object, &rw, &annex, &offset) < 0)
1986 write_enn (own_buf);
1991 i < sizeof (qxfer_packets) / sizeof (qxfer_packets[0]);
1994 const struct qxfer *q = &qxfer_packets[i];
1996 if (strcmp (object, q->object) == 0)
1998 if (strcmp (rw, "read") == 0)
2000 unsigned char *data;
2005 /* Grab the offset and length. */
2006 if (decode_xfer_read (offset, &ofs, &len) < 0)
2008 write_enn (own_buf);
2012 /* Read one extra byte, as an indicator of whether there is
2014 if (len > PBUFSIZ - 2)
2016 data = (unsigned char *) malloc (len + 1);
2019 write_enn (own_buf);
2022 n = (*q->xfer) (annex, data, NULL, ofs, len + 1);
2030 /* Preserve error message. */
2033 write_enn (own_buf);
2035 *new_packet_len_p = write_qxfer_response (own_buf, data, len, 1);
2037 *new_packet_len_p = write_qxfer_response (own_buf, data, n, 0);
2042 else if (strcmp (rw, "write") == 0)
2047 unsigned char *data;
2049 strcpy (own_buf, "E00");
2050 data = (unsigned char *) malloc (packet_len - (offset - own_buf));
2053 write_enn (own_buf);
2056 if (decode_xfer_write (offset, packet_len - (offset - own_buf),
2057 &ofs, &len, data) < 0)
2060 write_enn (own_buf);
2064 n = (*q->xfer) (annex, NULL, data, ofs, len);
2072 /* Preserve error message. */
2075 write_enn (own_buf);
2077 sprintf (own_buf, "%x", n);
2090 /* Compute 32 bit CRC from inferior memory.
2092 On success, return 32 bit CRC.
2093 On failure, return (unsigned long long) -1. */
2095 static unsigned long long
2096 crc32 (CORE_ADDR base, int len, unsigned int crc)
2100 unsigned char byte = 0;
2102 /* Return failure if memory read fails. */
2103 if (read_inferior_memory (base, &byte, 1) != 0)
2104 return (unsigned long long) -1;
2106 crc = xcrc32 (&byte, 1, crc);
2109 return (unsigned long long) crc;
2112 /* Add supported btrace packets to BUF. */
2115 supported_btrace_packets (char *buf)
2117 int btrace_supported = 0;
2119 if (target_supports_btrace (BTRACE_FORMAT_BTS))
2121 strcat (buf, ";Qbtrace:bts+");
2122 strcat (buf, ";Qbtrace-conf:bts:size+");
2124 btrace_supported = 1;
2127 if (target_supports_btrace (BTRACE_FORMAT_PT))
2129 strcat (buf, ";Qbtrace:pt+");
2130 strcat (buf, ";Qbtrace-conf:pt:size+");
2132 btrace_supported = 1;
2135 if (!btrace_supported)
2138 strcat (buf, ";Qbtrace:off+");
2139 strcat (buf, ";qXfer:btrace:read+");
2140 strcat (buf, ";qXfer:btrace-conf:read+");
2143 /* Handle all of the extended 'q' packets. */
2146 handle_query (char *own_buf, int packet_len, int *new_packet_len_p)
2148 static struct inferior_list_entry *thread_ptr;
2150 /* Reply the current thread id. */
2151 if (strcmp ("qC", own_buf) == 0 && !disable_packet_qC)
2154 require_running_or_return (own_buf);
2156 if (general_thread != null_ptid && general_thread != minus_one_ptid)
2157 ptid = general_thread;
2160 thread_ptr = get_first_inferior (&all_threads);
2161 ptid = thread_ptr->id;
2164 sprintf (own_buf, "QC");
2166 write_ptid (own_buf, ptid);
2170 if (strcmp ("qSymbol::", own_buf) == 0)
2172 struct thread_info *save_thread = current_thread;
2174 /* For qSymbol, GDB only changes the current thread if the
2175 previous current thread was of a different process. So if
2176 the previous thread is gone, we need to pick another one of
2177 the same process. This can happen e.g., if we followed an
2178 exec in a non-leader thread. */
2179 if (current_thread == NULL)
2182 = find_any_thread_of_pid (ptid_get_pid (general_thread));
2184 /* Just in case, if we didn't find a thread, then bail out
2185 instead of crashing. */
2186 if (current_thread == NULL)
2188 write_enn (own_buf);
2189 current_thread = save_thread;
2194 /* GDB is suggesting new symbols have been loaded. This may
2195 mean a new shared library has been detected as loaded, so
2196 take the opportunity to check if breakpoints we think are
2197 inserted, still are. Note that it isn't guaranteed that
2198 we'll see this when a shared library is loaded, and nor will
2199 we see this for unloads (although breakpoints in unloaded
2200 libraries shouldn't trigger), as GDB may not find symbols for
2201 the library at all. We also re-validate breakpoints when we
2202 see a second GDB breakpoint for the same address, and or when
2203 we access breakpoint shadows. */
2204 validate_breakpoints ();
2206 if (target_supports_tracepoints ())
2207 tracepoint_look_up_symbols ();
2209 if (current_thread != NULL && the_target->look_up_symbols != NULL)
2210 (*the_target->look_up_symbols) ();
2212 current_thread = save_thread;
2214 strcpy (own_buf, "OK");
2218 if (!disable_packet_qfThreadInfo)
2220 if (strcmp ("qfThreadInfo", own_buf) == 0)
2222 require_running_or_return (own_buf);
2223 thread_ptr = get_first_inferior (&all_threads);
2226 write_ptid (own_buf, thread_ptr->id);
2227 thread_ptr = thread_ptr->next;
2231 if (strcmp ("qsThreadInfo", own_buf) == 0)
2233 require_running_or_return (own_buf);
2234 if (thread_ptr != NULL)
2237 write_ptid (own_buf, thread_ptr->id);
2238 thread_ptr = thread_ptr->next;
2243 sprintf (own_buf, "l");
2249 if (the_target->read_offsets != NULL
2250 && strcmp ("qOffsets", own_buf) == 0)
2252 CORE_ADDR text, data;
2254 require_running_or_return (own_buf);
2255 if (the_target->read_offsets (&text, &data))
2256 sprintf (own_buf, "Text=%lX;Data=%lX;Bss=%lX",
2257 (long)text, (long)data, (long)data);
2259 write_enn (own_buf);
2264 /* Protocol features query. */
2265 if (startswith (own_buf, "qSupported")
2266 && (own_buf[10] == ':' || own_buf[10] == '\0'))
2268 char *p = &own_buf[10];
2269 int gdb_supports_qRelocInsn = 0;
2271 /* Process each feature being provided by GDB. The first
2272 feature will follow a ':', and latter features will follow
2276 char **qsupported = NULL;
2281 /* Two passes, to avoid nested strtok calls in
2282 target_process_qsupported. */
2283 for (p = strtok (p + 1, ";");
2285 p = strtok (NULL, ";"))
2288 qsupported = XRESIZEVEC (char *, qsupported, count);
2289 qsupported[count - 1] = xstrdup (p);
2292 for (i = 0; i < count; i++)
2295 if (strcmp (p, "multiprocess+") == 0)
2297 /* GDB supports and wants multi-process support if
2299 if (target_supports_multi_process ())
2302 else if (strcmp (p, "qRelocInsn+") == 0)
2304 /* GDB supports relocate instruction requests. */
2305 gdb_supports_qRelocInsn = 1;
2307 else if (strcmp (p, "swbreak+") == 0)
2309 /* GDB wants us to report whether a trap is caused
2310 by a software breakpoint and for us to handle PC
2311 adjustment if necessary on this target. */
2312 if (target_supports_stopped_by_sw_breakpoint ())
2313 swbreak_feature = 1;
2315 else if (strcmp (p, "hwbreak+") == 0)
2317 /* GDB wants us to report whether a trap is caused
2318 by a hardware breakpoint. */
2319 if (target_supports_stopped_by_hw_breakpoint ())
2320 hwbreak_feature = 1;
2322 else if (strcmp (p, "fork-events+") == 0)
2324 /* GDB supports and wants fork events if possible. */
2325 if (target_supports_fork_events ())
2326 report_fork_events = 1;
2328 else if (strcmp (p, "vfork-events+") == 0)
2330 /* GDB supports and wants vfork events if possible. */
2331 if (target_supports_vfork_events ())
2332 report_vfork_events = 1;
2334 else if (strcmp (p, "exec-events+") == 0)
2336 /* GDB supports and wants exec events if possible. */
2337 if (target_supports_exec_events ())
2338 report_exec_events = 1;
2340 else if (strcmp (p, "vContSupported+") == 0)
2341 vCont_supported = 1;
2342 else if (strcmp (p, "QThreadEvents+") == 0)
2344 else if (strcmp (p, "no-resumed+") == 0)
2346 /* GDB supports and wants TARGET_WAITKIND_NO_RESUMED
2348 report_no_resumed = 1;
2352 /* Move the unknown features all together. */
2353 qsupported[i] = NULL;
2354 qsupported[unknown] = p;
2359 /* Give the target backend a chance to process the unknown
2361 target_process_qsupported (qsupported, unknown);
2363 for (i = 0; i < count; i++)
2364 free (qsupported[i]);
2369 "PacketSize=%x;QPassSignals+;QProgramSignals+;"
2370 "QStartupWithShell+;QEnvironmentHexEncoded+;"
2371 "QEnvironmentReset+;QEnvironmentUnset+;"
2375 if (target_supports_catch_syscall ())
2376 strcat (own_buf, ";QCatchSyscalls+");
2378 if (the_target->qxfer_libraries_svr4 != NULL)
2379 strcat (own_buf, ";qXfer:libraries-svr4:read+"
2380 ";augmented-libraries-svr4-read+");
2383 /* We do not have any hook to indicate whether the non-SVR4 target
2384 backend supports qXfer:libraries:read, so always report it. */
2385 strcat (own_buf, ";qXfer:libraries:read+");
2388 if (the_target->read_auxv != NULL)
2389 strcat (own_buf, ";qXfer:auxv:read+");
2391 if (the_target->qxfer_spu != NULL)
2392 strcat (own_buf, ";qXfer:spu:read+;qXfer:spu:write+");
2394 if (the_target->qxfer_siginfo != NULL)
2395 strcat (own_buf, ";qXfer:siginfo:read+;qXfer:siginfo:write+");
2397 if (the_target->read_loadmap != NULL)
2398 strcat (own_buf, ";qXfer:fdpic:read+");
2400 /* We always report qXfer:features:read, as targets may
2401 install XML files on a subsequent call to arch_setup.
2402 If we reported to GDB on startup that we don't support
2403 qXfer:feature:read at all, we will never be re-queried. */
2404 strcat (own_buf, ";qXfer:features:read+");
2406 if (transport_is_reliable)
2407 strcat (own_buf, ";QStartNoAckMode+");
2409 if (the_target->qxfer_osdata != NULL)
2410 strcat (own_buf, ";qXfer:osdata:read+");
2412 if (target_supports_multi_process ())
2413 strcat (own_buf, ";multiprocess+");
2415 if (target_supports_fork_events ())
2416 strcat (own_buf, ";fork-events+");
2418 if (target_supports_vfork_events ())
2419 strcat (own_buf, ";vfork-events+");
2421 if (target_supports_exec_events ())
2422 strcat (own_buf, ";exec-events+");
2424 if (target_supports_non_stop ())
2425 strcat (own_buf, ";QNonStop+");
2427 if (target_supports_disable_randomization ())
2428 strcat (own_buf, ";QDisableRandomization+");
2430 strcat (own_buf, ";qXfer:threads:read+");
2432 if (target_supports_tracepoints ())
2434 strcat (own_buf, ";ConditionalTracepoints+");
2435 strcat (own_buf, ";TraceStateVariables+");
2436 strcat (own_buf, ";TracepointSource+");
2437 strcat (own_buf, ";DisconnectedTracing+");
2438 if (gdb_supports_qRelocInsn && target_supports_fast_tracepoints ())
2439 strcat (own_buf, ";FastTracepoints+");
2440 strcat (own_buf, ";StaticTracepoints+");
2441 strcat (own_buf, ";InstallInTrace+");
2442 strcat (own_buf, ";qXfer:statictrace:read+");
2443 strcat (own_buf, ";qXfer:traceframe-info:read+");
2444 strcat (own_buf, ";EnableDisableTracepoints+");
2445 strcat (own_buf, ";QTBuffer:size+");
2446 strcat (own_buf, ";tracenz+");
2449 if (target_supports_hardware_single_step ()
2450 || target_supports_software_single_step () )
2452 strcat (own_buf, ";ConditionalBreakpoints+");
2454 strcat (own_buf, ";BreakpointCommands+");
2456 if (target_supports_agent ())
2457 strcat (own_buf, ";QAgent+");
2459 supported_btrace_packets (own_buf);
2461 if (target_supports_stopped_by_sw_breakpoint ())
2462 strcat (own_buf, ";swbreak+");
2464 if (target_supports_stopped_by_hw_breakpoint ())
2465 strcat (own_buf, ";hwbreak+");
2467 if (the_target->pid_to_exec_file != NULL)
2468 strcat (own_buf, ";qXfer:exec-file:read+");
2470 strcat (own_buf, ";vContSupported+");
2472 strcat (own_buf, ";QThreadEvents+");
2474 strcat (own_buf, ";no-resumed+");
2476 /* Reinitialize components as needed for the new connection. */
2477 hostio_handle_new_gdb_connection ();
2478 target_handle_new_gdb_connection ();
2483 /* Thread-local storage support. */
2484 if (the_target->get_tls_address != NULL
2485 && startswith (own_buf, "qGetTLSAddr:"))
2487 char *p = own_buf + 12;
2488 CORE_ADDR parts[2], address = 0;
2490 ptid_t ptid = null_ptid;
2492 require_running_or_return (own_buf);
2494 for (i = 0; i < 3; i++)
2502 p2 = strchr (p, ',');
2515 ptid = read_ptid (p, NULL);
2517 decode_address (&parts[i - 1], p, len);
2521 if (p != NULL || i < 3)
2525 struct thread_info *thread = find_thread_ptid (ptid);
2530 err = the_target->get_tls_address (thread, parts[0], parts[1],
2536 strcpy (own_buf, paddress(address));
2541 write_enn (own_buf);
2545 /* Otherwise, pretend we do not understand this packet. */
2548 /* Windows OS Thread Information Block address support. */
2549 if (the_target->get_tib_address != NULL
2550 && startswith (own_buf, "qGetTIBAddr:"))
2555 ptid_t ptid = read_ptid (own_buf + 12, &annex);
2557 n = (*the_target->get_tib_address) (ptid, &tlb);
2560 strcpy (own_buf, paddress(tlb));
2565 write_enn (own_buf);
2571 /* Handle "monitor" commands. */
2572 if (startswith (own_buf, "qRcmd,"))
2574 char *mon = (char *) malloc (PBUFSIZ);
2575 int len = strlen (own_buf + 6);
2579 write_enn (own_buf);
2584 || hex2bin (own_buf + 6, (gdb_byte *) mon, len / 2) != len / 2)
2586 write_enn (own_buf);
2590 mon[len / 2] = '\0';
2594 if (the_target->handle_monitor_command == NULL
2595 || (*the_target->handle_monitor_command) (mon) == 0)
2596 /* Default processing. */
2597 handle_monitor_command (mon, own_buf);
2603 if (startswith (own_buf, "qSearch:memory:"))
2605 require_running_or_return (own_buf);
2606 handle_search_memory (own_buf, packet_len);
2610 if (strcmp (own_buf, "qAttached") == 0
2611 || startswith (own_buf, "qAttached:"))
2613 struct process_info *process;
2615 if (own_buf[sizeof ("qAttached") - 1])
2617 int pid = strtoul (own_buf + sizeof ("qAttached:") - 1, NULL, 16);
2618 process = find_process_pid (pid);
2622 require_running_or_return (own_buf);
2623 process = current_process ();
2626 if (process == NULL)
2628 write_enn (own_buf);
2632 strcpy (own_buf, process->attached ? "1" : "0");
2636 if (startswith (own_buf, "qCRC:"))
2638 /* CRC check (compare-section). */
2642 unsigned long long crc;
2644 require_running_or_return (own_buf);
2645 comma = unpack_varlen_hex (own_buf + 5, &base);
2646 if (*comma++ != ',')
2648 write_enn (own_buf);
2651 len = strtoul (comma, NULL, 16);
2652 crc = crc32 (base, len, 0xffffffff);
2653 /* Check for memory failure. */
2654 if (crc == (unsigned long long) -1)
2656 write_enn (own_buf);
2659 sprintf (own_buf, "C%lx", (unsigned long) crc);
2663 if (handle_qxfer (own_buf, packet_len, new_packet_len_p))
2666 if (target_supports_tracepoints () && handle_tracepoint_query (own_buf))
2669 /* Otherwise we didn't know what packet it was. Say we didn't
2674 static void gdb_wants_all_threads_stopped (void);
2675 static void resume (struct thread_resume *actions, size_t n);
2677 /* The callback that is passed to visit_actioned_threads. */
2678 typedef int (visit_actioned_threads_callback_ftype)
2679 (const struct thread_resume *, struct thread_info *);
2681 /* Struct to pass data to visit_actioned_threads. */
2683 struct visit_actioned_threads_data
2685 const struct thread_resume *actions;
2687 visit_actioned_threads_callback_ftype *callback;
2690 /* Call CALLBACK for any thread to which ACTIONS applies to. Returns
2691 true if CALLBACK returns true. Returns false if no matching thread
2692 is found or CALLBACK results false.
2693 Note: This function is itself a callback for find_inferior. */
2696 visit_actioned_threads (struct inferior_list_entry *entry, void *datap)
2698 struct visit_actioned_threads_data *data
2699 = (struct visit_actioned_threads_data *) datap;
2700 const struct thread_resume *actions = data->actions;
2701 size_t num_actions = data->num_actions;
2702 visit_actioned_threads_callback_ftype *callback = data->callback;
2705 for (i = 0; i < num_actions; i++)
2707 const struct thread_resume *action = &actions[i];
2709 if (ptid_equal (action->thread, minus_one_ptid)
2710 || ptid_equal (action->thread, entry->id)
2711 || ((ptid_get_pid (action->thread)
2712 == ptid_get_pid (entry->id))
2713 && ptid_get_lwp (action->thread) == -1))
2715 struct thread_info *thread = (struct thread_info *) entry;
2717 if ((*callback) (action, thread))
2725 /* Callback for visit_actioned_threads. If the thread has a pending
2726 status to report, report it now. */
2729 handle_pending_status (const struct thread_resume *resumption,
2730 struct thread_info *thread)
2732 if (thread->status_pending_p)
2734 thread->status_pending_p = 0;
2736 last_status = thread->last_status;
2737 last_ptid = thread->entry.id;
2738 prepare_resume_reply (own_buf, last_ptid, &last_status);
2744 /* Parse vCont packets. */
2746 handle_v_cont (char *own_buf)
2750 struct thread_resume *resume_info;
2751 struct thread_resume default_action { null_ptid };
2753 /* Count the number of semicolons in the packet. There should be one
2754 for every action. */
2760 p = strchr (p, ';');
2763 resume_info = (struct thread_resume *) malloc (n * sizeof (resume_info[0]));
2764 if (resume_info == NULL)
2772 memset (&resume_info[i], 0, sizeof resume_info[i]);
2774 if (p[0] == 's' || p[0] == 'S')
2775 resume_info[i].kind = resume_step;
2776 else if (p[0] == 'r')
2777 resume_info[i].kind = resume_step;
2778 else if (p[0] == 'c' || p[0] == 'C')
2779 resume_info[i].kind = resume_continue;
2780 else if (p[0] == 't')
2781 resume_info[i].kind = resume_stop;
2785 if (p[0] == 'S' || p[0] == 'C')
2788 int sig = strtol (p + 1, &q, 16);
2793 if (!gdb_signal_to_host_p ((enum gdb_signal) sig))
2795 resume_info[i].sig = gdb_signal_to_host ((enum gdb_signal) sig);
2797 else if (p[0] == 'r')
2801 p = unpack_varlen_hex (p + 1, &addr);
2802 resume_info[i].step_range_start = addr;
2807 p = unpack_varlen_hex (p + 1, &addr);
2808 resume_info[i].step_range_end = addr;
2817 resume_info[i].thread = minus_one_ptid;
2818 default_action = resume_info[i];
2820 /* Note: we don't increment i here, we'll overwrite this entry
2821 the next time through. */
2823 else if (p[0] == ':')
2826 ptid_t ptid = read_ptid (p + 1, &q);
2831 if (p[0] != ';' && p[0] != 0)
2834 resume_info[i].thread = ptid;
2841 resume_info[i] = default_action;
2843 resume (resume_info, n);
2848 write_enn (own_buf);
2853 /* Resume target with ACTIONS, an array of NUM_ACTIONS elements. */
2856 resume (struct thread_resume *actions, size_t num_actions)
2860 /* Check if among the threads that GDB wants actioned, there's
2861 one with a pending status to report. If so, skip actually
2862 resuming/stopping and report the pending event
2864 struct visit_actioned_threads_data data;
2866 data.actions = actions;
2867 data.num_actions = num_actions;
2868 data.callback = handle_pending_status;
2869 if (find_inferior (&all_threads, visit_actioned_threads, &data) != NULL)
2875 (*the_target->resume) (actions, num_actions);
2881 last_ptid = mywait (minus_one_ptid, &last_status, 0, 1);
2883 if (last_status.kind == TARGET_WAITKIND_NO_RESUMED
2884 && !report_no_resumed)
2886 /* The client does not support this stop reply. At least
2888 sprintf (own_buf, "E.No unwaited-for children left.");
2889 disable_async_io ();
2893 if (last_status.kind != TARGET_WAITKIND_EXITED
2894 && last_status.kind != TARGET_WAITKIND_SIGNALLED
2895 && last_status.kind != TARGET_WAITKIND_NO_RESUMED)
2896 current_thread->last_status = last_status;
2898 /* From the client's perspective, all-stop mode always stops all
2899 threads implicitly (and the target backend has already done
2900 so by now). Tag all threads as "want-stopped", so we don't
2901 resume them implicitly without the client telling us to. */
2902 gdb_wants_all_threads_stopped ();
2903 prepare_resume_reply (own_buf, last_ptid, &last_status);
2904 disable_async_io ();
2906 if (last_status.kind == TARGET_WAITKIND_EXITED
2907 || last_status.kind == TARGET_WAITKIND_SIGNALLED)
2908 target_mourn_inferior (last_ptid);
2912 /* Attach to a new program. Return 1 if successful, 0 if failure. */
2914 handle_v_attach (char *own_buf)
2918 pid = strtol (own_buf + 8, NULL, 16);
2919 if (pid != 0 && attach_inferior (pid) == 0)
2921 /* Don't report shared library events after attaching, even if
2922 some libraries are preloaded. GDB will always poll the
2923 library list. Avoids the "stopped by shared library event"
2924 notice on the GDB side. */
2929 /* In non-stop, we don't send a resume reply. Stop events
2930 will follow up using the normal notification
2935 prepare_resume_reply (own_buf, last_ptid, &last_status);
2941 write_enn (own_buf);
2946 /* Run a new program. Return 1 if successful, 0 if failure. */
2948 handle_v_run (char *own_buf)
2951 std::vector<char *> new_argv;
2952 char *new_program_name = NULL;
2956 for (p = own_buf + strlen ("vRun;"); p && *p; p = strchr (p, ';'))
2962 for (i = 0, p = own_buf + strlen ("vRun;"); *p; p = next_p, ++i)
2964 next_p = strchr (p, ';');
2966 next_p = p + strlen (p);
2968 if (i == 0 && p == next_p)
2970 /* No program specified. */
2971 new_program_name = NULL;
2973 else if (p == next_p)
2975 /* Empty argument. */
2976 new_argv.push_back (xstrdup ("''"));
2980 size_t len = (next_p - p) / 2;
2981 /* ARG is the unquoted argument received via the RSP. */
2982 char *arg = (char *) xmalloc (len + 1);
2983 /* FULL_ARGS will contain the quoted version of ARG. */
2984 char *full_arg = (char *) xmalloc ((len + 1) * 2);
2985 /* These are pointers used to navigate the strings above. */
2986 char *tmp_arg = arg;
2987 char *tmp_full_arg = full_arg;
2990 hex2bin (p, (gdb_byte *) arg, len);
2993 while (*tmp_arg != '\0')
2999 *tmp_full_arg = '\'';
3005 /* Quote single quote. */
3006 *tmp_full_arg = '\\';
3014 *tmp_full_arg = *tmp_arg;
3020 *tmp_full_arg++ = '\'';
3022 /* Finish FULL_ARG and push it into the vector containing
3024 *tmp_full_arg = '\0';
3026 new_program_name = full_arg;
3028 new_argv.push_back (full_arg);
3034 new_argv.push_back (NULL);
3036 if (new_program_name == NULL)
3038 /* GDB didn't specify a program to run. Use the program from the
3039 last run with the new argument list. */
3040 if (program_name == NULL)
3042 write_enn (own_buf);
3043 free_vector_argv (new_argv);
3049 xfree (program_name);
3050 program_name = new_program_name;
3053 /* Free the old argv and install the new one. */
3054 free_vector_argv (program_args);
3055 program_args = new_argv;
3057 create_inferior (program_name, program_args);
3059 if (last_status.kind == TARGET_WAITKIND_STOPPED)
3061 prepare_resume_reply (own_buf, last_ptid, &last_status);
3063 /* In non-stop, sending a resume reply doesn't set the general
3064 thread, but GDB assumes a vRun sets it (this is so GDB can
3065 query which is the main thread of the new inferior. */
3067 general_thread = last_ptid;
3073 write_enn (own_buf);
3078 /* Kill process. Return 1 if successful, 0 if failure. */
3080 handle_v_kill (char *own_buf)
3083 char *p = &own_buf[6];
3085 pid = strtol (p, NULL, 16);
3088 if (pid != 0 && kill_inferior (pid) == 0)
3090 last_status.kind = TARGET_WAITKIND_SIGNALLED;
3091 last_status.value.sig = GDB_SIGNAL_KILL;
3092 last_ptid = pid_to_ptid (pid);
3093 discard_queued_stop_replies (last_ptid);
3099 write_enn (own_buf);
3104 /* Handle all of the extended 'v' packets. */
3106 handle_v_requests (char *own_buf, int packet_len, int *new_packet_len)
3108 if (!disable_packet_vCont)
3110 if (strcmp (own_buf, "vCtrlC") == 0)
3112 (*the_target->request_interrupt) ();
3117 if (startswith (own_buf, "vCont;"))
3119 handle_v_cont (own_buf);
3123 if (startswith (own_buf, "vCont?"))
3125 strcpy (own_buf, "vCont;c;C;t");
3127 if (target_supports_hardware_single_step ()
3128 || target_supports_software_single_step ()
3129 || !vCont_supported)
3131 /* If target supports single step either by hardware or by
3132 software, add actions s and S to the list of supported
3133 actions. On the other hand, if GDB doesn't request the
3134 supported vCont actions in qSupported packet, add s and
3135 S to the list too. */
3136 own_buf = own_buf + strlen (own_buf);
3137 strcpy (own_buf, ";s;S");
3140 if (target_supports_range_stepping ())
3142 own_buf = own_buf + strlen (own_buf);
3143 strcpy (own_buf, ";r");
3149 if (startswith (own_buf, "vFile:")
3150 && handle_vFile (own_buf, packet_len, new_packet_len))
3153 if (startswith (own_buf, "vAttach;"))
3155 if ((!extended_protocol || !multi_process) && target_running ())
3157 fprintf (stderr, "Already debugging a process\n");
3158 write_enn (own_buf);
3161 handle_v_attach (own_buf);
3165 if (startswith (own_buf, "vRun;"))
3167 if ((!extended_protocol || !multi_process) && target_running ())
3169 fprintf (stderr, "Already debugging a process\n");
3170 write_enn (own_buf);
3173 handle_v_run (own_buf);
3177 if (startswith (own_buf, "vKill;"))
3179 if (!target_running ())
3181 fprintf (stderr, "No process to kill\n");
3182 write_enn (own_buf);
3185 handle_v_kill (own_buf);
3189 if (handle_notif_ack (own_buf, packet_len))
3192 /* Otherwise we didn't know what packet it was. Say we didn't
3198 /* Resume thread and wait for another event. In non-stop mode,
3199 don't really wait here, but return immediatelly to the event
3202 myresume (char *own_buf, int step, int sig)
3204 struct thread_resume resume_info[2];
3206 int valid_cont_thread;
3208 valid_cont_thread = (!ptid_equal (cont_thread, null_ptid)
3209 && !ptid_equal (cont_thread, minus_one_ptid));
3211 if (step || sig || valid_cont_thread)
3213 resume_info[0].thread = current_ptid;
3215 resume_info[0].kind = resume_step;
3217 resume_info[0].kind = resume_continue;
3218 resume_info[0].sig = sig;
3222 if (!valid_cont_thread)
3224 resume_info[n].thread = minus_one_ptid;
3225 resume_info[n].kind = resume_continue;
3226 resume_info[n].sig = 0;
3230 resume (resume_info, n);
3233 /* Callback for for_each_inferior. Make a new stop reply for each
3237 queue_stop_reply_callback (struct inferior_list_entry *entry, void *arg)
3239 struct thread_info *thread = (struct thread_info *) entry;
3241 /* For now, assume targets that don't have this callback also don't
3242 manage the thread's last_status field. */
3243 if (the_target->thread_stopped == NULL)
3245 struct vstop_notif *new_notif = XNEW (struct vstop_notif);
3247 new_notif->ptid = entry->id;
3248 new_notif->status = thread->last_status;
3249 /* Pass the last stop reply back to GDB, but don't notify
3251 notif_event_enque (¬if_stop,
3252 (struct notif_event *) new_notif);
3256 if (thread_stopped (thread))
3260 std::string status_string
3261 = target_waitstatus_to_string (&thread->last_status);
3263 debug_printf ("Reporting thread %s as already stopped with %s\n",
3264 target_pid_to_str (entry->id),
3265 status_string.c_str ());
3268 gdb_assert (thread->last_status.kind != TARGET_WAITKIND_IGNORE);
3270 /* Pass the last stop reply back to GDB, but don't notify
3272 queue_stop_reply (entry->id, &thread->last_status);
3279 /* Set this inferior threads's state as "want-stopped". We won't
3280 resume this thread until the client gives us another action for
3284 gdb_wants_thread_stopped (struct inferior_list_entry *entry)
3286 struct thread_info *thread = (struct thread_info *) entry;
3288 thread->last_resume_kind = resume_stop;
3290 if (thread->last_status.kind == TARGET_WAITKIND_IGNORE)
3292 /* Most threads are stopped implicitly (all-stop); tag that with
3294 thread->last_status.kind = TARGET_WAITKIND_STOPPED;
3295 thread->last_status.value.sig = GDB_SIGNAL_0;
3299 /* Set all threads' states as "want-stopped". */
3302 gdb_wants_all_threads_stopped (void)
3304 for_each_inferior (&all_threads, gdb_wants_thread_stopped);
3307 /* Callback for for_each_inferior. Clear the thread's pending status
3311 clear_pending_status_callback (struct inferior_list_entry *entry)
3313 struct thread_info *thread = (struct thread_info *) entry;
3315 thread->status_pending_p = 0;
3318 /* Callback for for_each_inferior. If the thread is stopped with an
3319 interesting event, mark it as having a pending event. */
3322 set_pending_status_callback (struct inferior_list_entry *entry)
3324 struct thread_info *thread = (struct thread_info *) entry;
3326 if (thread->last_status.kind != TARGET_WAITKIND_STOPPED
3327 || (thread->last_status.value.sig != GDB_SIGNAL_0
3328 /* A breakpoint, watchpoint or finished step from a previous
3329 GDB run isn't considered interesting for a new GDB run.
3330 If we left those pending, the new GDB could consider them
3331 random SIGTRAPs. This leaves out real async traps. We'd
3332 have to peek into the (target-specific) siginfo to
3333 distinguish those. */
3334 && thread->last_status.value.sig != GDB_SIGNAL_TRAP))
3335 thread->status_pending_p = 1;
3338 /* Callback for find_inferior. Return true if ENTRY (a thread) has a
3339 pending status to report to GDB. */
3342 find_status_pending_thread_callback (struct inferior_list_entry *entry, void *data)
3344 struct thread_info *thread = (struct thread_info *) entry;
3346 return thread->status_pending_p;
3349 /* Status handler for the '?' packet. */
3352 handle_status (char *own_buf)
3354 /* GDB is connected, don't forward events to the target anymore. */
3355 for_each_process ([] (process_info *process) {
3356 process->gdb_detached = 0;
3359 /* In non-stop mode, we must send a stop reply for each stopped
3360 thread. In all-stop mode, just send one for the first stopped
3365 find_inferior (&all_threads, queue_stop_reply_callback, NULL);
3367 /* The first is sent immediatly. OK is sent if there is no
3368 stopped thread, which is the same handling of the vStopped
3369 packet (by design). */
3370 notif_write_event (¬if_stop, own_buf);
3374 struct inferior_list_entry *thread = NULL;
3377 stabilize_threads ();
3378 gdb_wants_all_threads_stopped ();
3380 /* We can only report one status, but we might be coming out of
3381 non-stop -- if more than one thread is stopped with
3382 interesting events, leave events for the threads we're not
3383 reporting now pending. They'll be reported the next time the
3384 threads are resumed. Start by marking all interesting events
3386 for_each_inferior (&all_threads, set_pending_status_callback);
3388 /* Prefer the last thread that reported an event to GDB (even if
3389 that was a GDB_SIGNAL_TRAP). */
3390 if (last_status.kind != TARGET_WAITKIND_IGNORE
3391 && last_status.kind != TARGET_WAITKIND_EXITED
3392 && last_status.kind != TARGET_WAITKIND_SIGNALLED)
3393 thread = find_inferior_id (&all_threads, last_ptid);
3395 /* If the last event thread is not found for some reason, look
3396 for some other thread that might have an event to report. */
3398 thread = find_inferior (&all_threads,
3399 find_status_pending_thread_callback, NULL);
3401 /* If we're still out of luck, simply pick the first thread in
3404 thread = get_first_inferior (&all_threads);
3408 struct thread_info *tp = (struct thread_info *) thread;
3410 /* We're reporting this event, so it's no longer
3412 tp->status_pending_p = 0;
3414 /* GDB assumes the current thread is the thread we're
3415 reporting the status for. */
3416 general_thread = thread->id;
3417 set_desired_thread ();
3419 gdb_assert (tp->last_status.kind != TARGET_WAITKIND_IGNORE);
3420 prepare_resume_reply (own_buf, tp->entry.id, &tp->last_status);
3423 strcpy (own_buf, "W00");
3428 gdbserver_version (void)
3430 printf ("GNU gdbserver %s%s\n"
3431 "Copyright (C) 2017 Free Software Foundation, Inc.\n"
3432 "gdbserver is free software, covered by the "
3433 "GNU General Public License.\n"
3434 "This gdbserver was configured as \"%s\"\n",
3435 PKGVERSION, version, host_name);
3439 gdbserver_usage (FILE *stream)
3441 fprintf (stream, "Usage:\tgdbserver [OPTIONS] COMM PROG [ARGS ...]\n"
3442 "\tgdbserver [OPTIONS] --attach COMM PID\n"
3443 "\tgdbserver [OPTIONS] --multi COMM\n"
3445 "COMM may either be a tty device (for serial debugging),\n"
3446 "HOST:PORT to listen for a TCP connection, or '-' or 'stdio' to use \n"
3447 "stdin/stdout of gdbserver.\n"
3448 "PROG is the executable program. ARGS are arguments passed to inferior.\n"
3449 "PID is the process ID to attach to, when --attach is specified.\n"
3451 "Operating modes:\n"
3453 " --attach Attach to running process PID.\n"
3454 " --multi Start server without a specific program, and\n"
3455 " only quit when explicitly commanded.\n"
3456 " --once Exit after the first connection has closed.\n"
3457 " --help Print this message and then exit.\n"
3458 " --version Display version information and exit.\n"
3462 " --wrapper WRAPPER -- Run WRAPPER to start new programs.\n"
3463 " --disable-randomization\n"
3464 " Run PROG with address space randomization disabled.\n"
3465 " --no-disable-randomization\n"
3466 " Don't disable address space randomization when\n"
3468 " --startup-with-shell\n"
3469 " Start PROG using a shell. I.e., execs a shell that\n"
3470 " then execs PROG. (default)\n"
3471 " --no-startup-with-shell\n"
3472 " Exec PROG directly instead of using a shell.\n"
3473 " Disables argument globbing and variable substitution\n"
3474 " on UNIX-like systems.\n"
3478 " --debug Enable general debugging output.\n"
3479 " --debug-format=opt1[,opt2,...]\n"
3480 " Specify extra content in debugging output.\n"
3485 " --remote-debug Enable remote protocol debugging output.\n"
3486 " --disable-packet=opt1[,opt2,...]\n"
3487 " Disable support for RSP packets or features.\n"
3489 " vCont, Tthread, qC, qfThreadInfo and \n"
3490 " threads (disable all threading packets).\n"
3492 "For more information, consult the GDB manual (available as on-line \n"
3493 "info or a printed manual).\n");
3494 if (REPORT_BUGS_TO[0] && stream == stdout)
3495 fprintf (stream, "Report bugs to \"%s\".\n", REPORT_BUGS_TO);
3499 gdbserver_show_disableable (FILE *stream)
3501 fprintf (stream, "Disableable packets:\n"
3502 " vCont \tAll vCont packets\n"
3503 " qC \tQuerying the current thread\n"
3504 " qfThreadInfo\tThread listing\n"
3505 " Tthread \tPassing the thread specifier in the "
3506 "T stop reply packet\n"
3507 " threads \tAll of the above\n");
3511 kill_inferior_callback (process_info *process)
3513 int pid = process->pid;
3515 kill_inferior (pid);
3516 discard_queued_stop_replies (pid_to_ptid (pid));
3519 /* Call this when exiting gdbserver with possible inferiors that need
3520 to be killed or detached from. */
3523 detach_or_kill_for_exit (void)
3525 /* First print a list of the inferiors we will be killing/detaching.
3526 This is to assist the user, for example, in case the inferior unexpectedly
3527 dies after we exit: did we screw up or did the inferior exit on its own?
3528 Having this info will save some head-scratching. */
3530 if (have_started_inferiors_p ())
3532 fprintf (stderr, "Killing process(es):");
3534 for_each_process ([] (process_info *process) {
3535 if (!process->attached)
3536 fprintf (stderr, " %d", process->pid);
3539 fprintf (stderr, "\n");
3541 if (have_attached_inferiors_p ())
3543 fprintf (stderr, "Detaching process(es):");
3545 for_each_process ([] (process_info *process) {
3546 if (process->attached)
3547 fprintf (stderr, " %d", process->pid);
3550 fprintf (stderr, "\n");
3553 /* Now we can kill or detach the inferiors. */
3554 for_each_process ([] (process_info *process) {
3555 int pid = process->pid;
3557 if (process->attached)
3558 detach_inferior (pid);
3560 kill_inferior (pid);
3562 discard_queued_stop_replies (pid_to_ptid (pid));
3566 /* Value that will be passed to exit(3) when gdbserver exits. */
3567 static int exit_code;
3569 /* Cleanup version of detach_or_kill_for_exit. */
3572 detach_or_kill_for_exit_cleanup (void *ignore)
3577 detach_or_kill_for_exit ();
3580 CATCH (exception, RETURN_MASK_ALL)
3583 fprintf (stderr, "Detach or kill failed: %s\n", exception.message);
3589 /* Main function. This is called by the real "main" function,
3590 wrapped in a TRY_CATCH that handles any uncaught exceptions. */
3592 static void ATTRIBUTE_NORETURN
3593 captured_main (int argc, char *argv[])
3598 const char *port = NULL;
3599 char **next_arg = &argv[1];
3600 volatile int multi_mode = 0;
3601 volatile int attach = 0;
3603 bool selftest = false;
3604 const char *selftest_filter = NULL;
3606 while (*next_arg != NULL && **next_arg == '-')
3608 if (strcmp (*next_arg, "--version") == 0)
3610 gdbserver_version ();
3613 else if (strcmp (*next_arg, "--help") == 0)
3615 gdbserver_usage (stdout);
3618 else if (strcmp (*next_arg, "--attach") == 0)
3620 else if (strcmp (*next_arg, "--multi") == 0)
3622 else if (strcmp (*next_arg, "--wrapper") == 0)
3629 while (*next_arg != NULL && strcmp (*next_arg, "--") != 0)
3631 wrapper_argv += *next_arg;
3632 wrapper_argv += ' ';
3636 if (!wrapper_argv.empty ())
3638 /* Erase the last whitespace. */
3639 wrapper_argv.erase (wrapper_argv.end () - 1);
3642 if (next_arg == tmp || *next_arg == NULL)
3644 gdbserver_usage (stderr);
3648 /* Consume the "--". */
3651 else if (strcmp (*next_arg, "--debug") == 0)
3653 else if (startswith (*next_arg, "--debug-format="))
3656 = parse_debug_format_options ((*next_arg)
3657 + sizeof ("--debug-format=") - 1, 0);
3659 if (error_msg != NULL)
3661 fprintf (stderr, "%s", error_msg);
3665 else if (strcmp (*next_arg, "--remote-debug") == 0)
3667 else if (strcmp (*next_arg, "--disable-packet") == 0)
3669 gdbserver_show_disableable (stdout);
3672 else if (startswith (*next_arg, "--disable-packet="))
3674 char *packets, *tok;
3676 packets = *next_arg += sizeof ("--disable-packet=") - 1;
3677 for (tok = strtok (packets, ",");
3679 tok = strtok (NULL, ","))
3681 if (strcmp ("vCont", tok) == 0)
3682 disable_packet_vCont = 1;
3683 else if (strcmp ("Tthread", tok) == 0)
3684 disable_packet_Tthread = 1;
3685 else if (strcmp ("qC", tok) == 0)
3686 disable_packet_qC = 1;
3687 else if (strcmp ("qfThreadInfo", tok) == 0)
3688 disable_packet_qfThreadInfo = 1;
3689 else if (strcmp ("threads", tok) == 0)
3691 disable_packet_vCont = 1;
3692 disable_packet_Tthread = 1;
3693 disable_packet_qC = 1;
3694 disable_packet_qfThreadInfo = 1;
3698 fprintf (stderr, "Don't know how to disable \"%s\".\n\n",
3700 gdbserver_show_disableable (stderr);
3705 else if (strcmp (*next_arg, "-") == 0)
3707 /* "-" specifies a stdio connection and is a form of port
3709 port = STDIO_CONNECTION_NAME;
3713 else if (strcmp (*next_arg, "--disable-randomization") == 0)
3714 disable_randomization = 1;
3715 else if (strcmp (*next_arg, "--no-disable-randomization") == 0)
3716 disable_randomization = 0;
3717 else if (strcmp (*next_arg, "--startup-with-shell") == 0)
3718 startup_with_shell = true;
3719 else if (strcmp (*next_arg, "--no-startup-with-shell") == 0)
3720 startup_with_shell = false;
3721 else if (strcmp (*next_arg, "--once") == 0)
3723 else if (strcmp (*next_arg, "--selftest") == 0)
3725 else if (startswith (*next_arg, "--selftest="))
3728 selftest_filter = *next_arg + strlen ("--selftest=");
3732 fprintf (stderr, "Unknown argument: %s\n", *next_arg);
3745 if ((port == NULL || (!attach && !multi_mode && *next_arg == NULL))
3748 gdbserver_usage (stderr);
3752 /* Remember stdio descriptors. LISTEN_DESC must not be listed, it will be
3753 opened by remote_prepare. */
3756 save_original_signals_state ();
3758 /* We need to know whether the remote connection is stdio before
3759 starting the inferior. Inferiors created in this scenario have
3760 stdin,stdout redirected. So do this here before we call
3763 remote_prepare (port);
3768 /* --attach used to come after PORT, so allow it there for
3770 if (*next_arg != NULL && strcmp (*next_arg, "--attach") == 0)
3777 && (*next_arg == NULL
3778 || (*next_arg)[0] == '\0'
3779 || (pid = strtoul (*next_arg, &arg_end, 0)) == 0
3781 || next_arg[1] != NULL))
3786 gdbserver_usage (stderr);
3790 /* Gather information about the environment. */
3791 our_environ = gdb_environ::from_host_environ ();
3793 initialize_async_io ();
3795 have_job_control ();
3796 initialize_event_loop ();
3797 if (target_supports_tracepoints ())
3798 initialize_tracepoint ();
3799 initialize_notif ();
3801 own_buf = (char *) xmalloc (PBUFSIZ + 1);
3802 mem_buf = (unsigned char *) xmalloc (PBUFSIZ);
3806 selftests::run_tests (selftest_filter);
3807 throw_quit ("Quit");
3810 if (pid == 0 && *next_arg != NULL)
3814 n = argc - (next_arg - argv);
3815 program_name = xstrdup (next_arg[0]);
3816 for (i = 1; i < n; i++)
3817 program_args.push_back (xstrdup (next_arg[i]));
3818 program_args.push_back (NULL);
3820 /* Wait till we are at first instruction in program. */
3821 create_inferior (program_name, program_args);
3823 /* We are now (hopefully) stopped at the first instruction of
3824 the target process. This assumes that the target process was
3825 successfully created. */
3829 if (attach_inferior (pid) == -1)
3830 error ("Attaching not supported on this target");
3832 /* Otherwise succeeded. */
3836 last_status.kind = TARGET_WAITKIND_EXITED;
3837 last_status.value.integer = 0;
3838 last_ptid = minus_one_ptid;
3840 make_cleanup (detach_or_kill_for_exit_cleanup, NULL);
3842 /* Don't report shared library events on the initial connection,
3843 even if some libraries are preloaded. Avoids the "stopped by
3844 shared library event" notice on gdb side. */
3847 if (last_status.kind == TARGET_WAITKIND_EXITED
3848 || last_status.kind == TARGET_WAITKIND_SIGNALLED)
3853 if (!was_running && !multi_mode)
3854 error ("No program to debug");
3861 report_fork_events = 0;
3862 report_vfork_events = 0;
3863 report_exec_events = 0;
3864 /* Be sure we're out of tfind mode. */
3865 current_traceframe = -1;
3866 cont_thread = null_ptid;
3867 swbreak_feature = 0;
3868 hwbreak_feature = 0;
3869 vCont_supported = 0;
3875 /* Wait for events. This will return when all event sources
3876 are removed from the event loop. */
3877 start_event_loop ();
3879 /* If an exit was requested (using the "monitor exit"
3880 command), terminate now. */
3882 throw_quit ("Quit");
3884 /* The only other way to get here is for getpkt to fail:
3886 - If --once was specified, we're done.
3888 - If not in extended-remote mode, and we're no longer
3889 debugging anything, simply exit: GDB has disconnected
3890 after processing the last process exit.
3892 - Otherwise, close the connection and reopen it at the
3894 if (run_once || (!extended_protocol && !target_running ()))
3895 throw_quit ("Quit");
3898 "Remote side has terminated connection. "
3899 "GDBserver will reopen the connection.\n");
3901 /* Get rid of any pending statuses. An eventual reconnection
3902 (by the same GDB instance or another) will refresh all its
3903 state from scratch. */
3904 discard_queued_stop_replies (minus_one_ptid);
3905 for_each_inferior (&all_threads,
3906 clear_pending_status_callback);
3910 if (disconnected_tracing)
3912 /* Try to enable non-stop/async mode, so we we can
3913 both wait for an async socket accept, and handle
3914 async target events simultaneously. There's also
3915 no point either in having the target always stop
3916 all threads, when we're going to pass signals
3917 down without informing GDB. */
3920 if (start_non_stop (1))
3923 /* Detaching implicitly resumes all threads;
3924 simply disconnecting does not. */
3930 "Disconnected tracing disabled; "
3931 "stopping trace run.\n");
3936 CATCH (exception, RETURN_MASK_ERROR)
3939 fprintf (stderr, "gdbserver: %s\n", exception.message);
3941 if (response_needed)
3943 write_enn (own_buf);
3948 throw_quit ("Quit");
3954 /* Main function. */
3957 main (int argc, char *argv[])
3962 captured_main (argc, argv);
3964 CATCH (exception, RETURN_MASK_ALL)
3966 if (exception.reason == RETURN_ERROR)
3969 fprintf (stderr, "%s\n", exception.message);
3970 fprintf (stderr, "Exiting\n");
3978 gdb_assert_not_reached ("captured_main should never return");
3981 /* Process options coming from Z packets for a breakpoint. PACKET is
3982 the packet buffer. *PACKET is updated to point to the first char
3983 after the last processed option. */
3986 process_point_options (struct gdb_breakpoint *bp, const char **packet)
3988 const char *dataptr = *packet;
3991 /* Check if data has the correct format. */
3992 if (*dataptr != ';')
3999 if (*dataptr == ';')
4002 if (*dataptr == 'X')
4004 /* Conditional expression. */
4006 debug_printf ("Found breakpoint condition.\n");
4007 if (!add_breakpoint_condition (bp, &dataptr))
4008 dataptr = strchrnul (dataptr, ';');
4010 else if (startswith (dataptr, "cmds:"))
4012 dataptr += strlen ("cmds:");
4014 debug_printf ("Found breakpoint commands %s.\n", dataptr);
4015 persist = (*dataptr == '1');
4017 if (add_breakpoint_commands (bp, &dataptr, persist))
4018 dataptr = strchrnul (dataptr, ';');
4022 fprintf (stderr, "Unknown token %c, ignoring.\n",
4024 /* Skip tokens until we find one that we recognize. */
4025 dataptr = strchrnul (dataptr, ';');
4031 /* Event loop callback that handles a serial event. The first byte in
4032 the serial buffer gets us here. We expect characters to arrive at
4033 a brisk pace, so we read the rest of the packet with a blocking
4037 process_serial_event (void)
4045 int new_packet_len = -1;
4047 disable_async_io ();
4049 response_needed = 0;
4050 packet_len = getpkt (own_buf);
4051 if (packet_len <= 0)
4054 /* Force an event loop break. */
4057 response_needed = 1;
4059 char ch = own_buf[0];
4063 handle_query (own_buf, packet_len, &new_packet_len);
4066 handle_general_set (own_buf);
4069 handle_detach (own_buf);
4072 extended_protocol = 1;
4076 handle_status (own_buf);
4079 if (own_buf[1] == 'c' || own_buf[1] == 'g' || own_buf[1] == 's')
4081 require_running_or_break (own_buf);
4083 ptid_t thread_id = read_ptid (&own_buf[2], NULL);
4085 if (thread_id == null_ptid || thread_id == minus_one_ptid)
4086 thread_id = null_ptid;
4087 else if (thread_id.is_pid ())
4089 /* The ptid represents a pid. */
4090 thread_info *thread = find_any_thread_of_pid (thread_id.pid ());
4094 write_enn (own_buf);
4098 thread_id = thread->entry.id;
4102 /* The ptid represents a lwp/tid. */
4103 if (find_thread_ptid (thread_id) == NULL)
4105 write_enn (own_buf);
4110 if (own_buf[1] == 'g')
4112 if (ptid_equal (thread_id, null_ptid))
4114 /* GDB is telling us to choose any thread. Check if
4115 the currently selected thread is still valid. If
4116 it is not, select the first available. */
4117 struct thread_info *thread =
4118 (struct thread_info *) find_inferior_id (&all_threads,
4121 thread = get_first_thread ();
4122 thread_id = thread->entry.id;
4125 general_thread = thread_id;
4126 set_desired_thread ();
4127 gdb_assert (current_thread != NULL);
4129 else if (own_buf[1] == 'c')
4130 cont_thread = thread_id;
4136 /* Silently ignore it so that gdb can extend the protocol
4137 without compatibility headaches. */
4142 require_running_or_break (own_buf);
4143 if (current_traceframe >= 0)
4145 struct regcache *regcache
4146 = new_register_cache (current_target_desc ());
4148 if (fetch_traceframe_registers (current_traceframe,
4150 registers_to_string (regcache, own_buf);
4152 write_enn (own_buf);
4153 free_register_cache (regcache);
4157 struct regcache *regcache;
4159 if (!set_desired_thread ())
4160 write_enn (own_buf);
4163 regcache = get_thread_regcache (current_thread, 1);
4164 registers_to_string (regcache, own_buf);
4169 require_running_or_break (own_buf);
4170 if (current_traceframe >= 0)
4171 write_enn (own_buf);
4174 struct regcache *regcache;
4176 if (!set_desired_thread ())
4177 write_enn (own_buf);
4180 regcache = get_thread_regcache (current_thread, 1);
4181 registers_from_string (regcache, &own_buf[1]);
4187 require_running_or_break (own_buf);
4188 decode_m_packet (&own_buf[1], &mem_addr, &len);
4189 res = gdb_read_memory (mem_addr, mem_buf, len);
4191 write_enn (own_buf);
4193 bin2hex (mem_buf, own_buf, res);
4196 require_running_or_break (own_buf);
4197 decode_M_packet (&own_buf[1], &mem_addr, &len, &mem_buf);
4198 if (gdb_write_memory (mem_addr, mem_buf, len) == 0)
4201 write_enn (own_buf);
4204 require_running_or_break (own_buf);
4205 if (decode_X_packet (&own_buf[1], packet_len - 1,
4206 &mem_addr, &len, &mem_buf) < 0
4207 || gdb_write_memory (mem_addr, mem_buf, len) != 0)
4208 write_enn (own_buf);
4213 require_running_or_break (own_buf);
4214 hex2bin (own_buf + 1, &sig, 1);
4215 if (gdb_signal_to_host_p ((enum gdb_signal) sig))
4216 signal = gdb_signal_to_host ((enum gdb_signal) sig);
4219 myresume (own_buf, 0, signal);
4222 require_running_or_break (own_buf);
4223 hex2bin (own_buf + 1, &sig, 1);
4224 if (gdb_signal_to_host_p ((enum gdb_signal) sig))
4225 signal = gdb_signal_to_host ((enum gdb_signal) sig);
4228 myresume (own_buf, 1, signal);
4231 require_running_or_break (own_buf);
4233 myresume (own_buf, 0, signal);
4236 require_running_or_break (own_buf);
4238 myresume (own_buf, 1, signal);
4240 case 'Z': /* insert_ ... */
4242 case 'z': /* remove_ ... */
4247 char type = own_buf[1];
4249 const int insert = ch == 'Z';
4250 const char *p = &own_buf[3];
4252 p = unpack_varlen_hex (p, &addr);
4253 kind = strtol (p + 1, &dataptr, 16);
4257 struct gdb_breakpoint *bp;
4259 bp = set_gdb_breakpoint (type, addr, kind, &res);
4264 /* GDB may have sent us a list of *point parameters to
4265 be evaluated on the target's side. Read such list
4266 here. If we already have a list of parameters, GDB
4267 is telling us to drop that list and use this one
4269 clear_breakpoint_conditions_and_commands (bp);
4270 const char *options = dataptr;
4271 process_point_options (bp, &options);
4275 res = delete_gdb_breakpoint (type, addr, kind);
4283 write_enn (own_buf);
4287 response_needed = 0;
4288 if (!target_running ())
4289 /* The packet we received doesn't make sense - but we can't
4290 reply to it, either. */
4293 fprintf (stderr, "Killing all inferiors\n");
4295 for_each_process (kill_inferior_callback);
4297 /* When using the extended protocol, we wait with no program
4298 running. The traditional protocol will exit instead. */
4299 if (extended_protocol)
4301 last_status.kind = TARGET_WAITKIND_EXITED;
4302 last_status.value.sig = GDB_SIGNAL_KILL;
4310 require_running_or_break (own_buf);
4312 ptid_t thread_id = read_ptid (&own_buf[1], NULL);
4313 if (find_thread_ptid (thread_id) == NULL)
4315 write_enn (own_buf);
4319 if (mythread_alive (thread_id))
4322 write_enn (own_buf);
4326 response_needed = 0;
4328 /* Restarting the inferior is only supported in the extended
4330 if (extended_protocol)
4332 if (target_running ())
4333 for_each_process (kill_inferior_callback);
4335 fprintf (stderr, "GDBserver restarting\n");
4337 /* Wait till we are at 1st instruction in prog. */
4338 if (program_name != NULL)
4340 create_inferior (program_name, program_args);
4342 if (last_status.kind == TARGET_WAITKIND_STOPPED)
4344 /* Stopped at the first instruction of the target
4346 general_thread = last_ptid;
4350 /* Something went wrong. */
4351 general_thread = null_ptid;
4356 last_status.kind = TARGET_WAITKIND_EXITED;
4357 last_status.value.sig = GDB_SIGNAL_KILL;
4363 /* It is a request we don't understand. Respond with an
4364 empty packet so that gdb knows that we don't support this
4370 /* Extended (long) request. */
4371 handle_v_requests (own_buf, packet_len, &new_packet_len);
4375 /* It is a request we don't understand. Respond with an empty
4376 packet so that gdb knows that we don't support this
4382 if (new_packet_len != -1)
4383 putpkt_binary (own_buf, new_packet_len);
4387 response_needed = 0;
4395 /* Event-loop callback for serial events. */
4398 handle_serial_event (int err, gdb_client_data client_data)
4401 debug_printf ("handling possible serial event\n");
4403 /* Really handle it. */
4404 if (process_serial_event () < 0)
4407 /* Be sure to not change the selected thread behind GDB's back.
4408 Important in the non-stop mode asynchronous protocol. */
4409 set_desired_thread ();
4414 /* Push a stop notification on the notification queue. */
4417 push_stop_notification (ptid_t ptid, struct target_waitstatus *status)
4419 struct vstop_notif *vstop_notif = XNEW (struct vstop_notif);
4421 vstop_notif->status = *status;
4422 vstop_notif->ptid = ptid;
4423 /* Push Stop notification. */
4424 notif_push (¬if_stop, (struct notif_event *) vstop_notif);
4427 /* Event-loop callback for target events. */
4430 handle_target_event (int err, gdb_client_data client_data)
4433 debug_printf ("handling possible target event\n");
4435 last_ptid = mywait (minus_one_ptid, &last_status,
4438 if (last_status.kind == TARGET_WAITKIND_NO_RESUMED)
4440 if (gdb_connected () && report_no_resumed)
4441 push_stop_notification (null_ptid, &last_status);
4443 else if (last_status.kind != TARGET_WAITKIND_IGNORE)
4445 int pid = ptid_get_pid (last_ptid);
4446 struct process_info *process = find_process_pid (pid);
4447 int forward_event = !gdb_connected () || process->gdb_detached;
4449 if (last_status.kind == TARGET_WAITKIND_EXITED
4450 || last_status.kind == TARGET_WAITKIND_SIGNALLED)
4452 mark_breakpoints_out (process);
4453 target_mourn_inferior (last_ptid);
4455 else if (last_status.kind == TARGET_WAITKIND_THREAD_EXITED)
4459 /* We're reporting this thread as stopped. Update its
4460 "want-stopped" state to what the client wants, until it
4461 gets a new resume action. */
4462 current_thread->last_resume_kind = resume_stop;
4463 current_thread->last_status = last_status;
4468 if (!target_running ())
4470 /* The last process exited. We're done. */
4474 if (last_status.kind == TARGET_WAITKIND_EXITED
4475 || last_status.kind == TARGET_WAITKIND_SIGNALLED
4476 || last_status.kind == TARGET_WAITKIND_THREAD_EXITED)
4480 /* A thread stopped with a signal, but gdb isn't
4481 connected to handle it. Pass it down to the
4482 inferior, as if it wasn't being traced. */
4483 enum gdb_signal signal;
4486 debug_printf ("GDB not connected; forwarding event %d for"
4488 (int) last_status.kind,
4489 target_pid_to_str (last_ptid));
4491 if (last_status.kind == TARGET_WAITKIND_STOPPED)
4492 signal = last_status.value.sig;
4494 signal = GDB_SIGNAL_0;
4495 target_continue (last_ptid, signal);
4499 push_stop_notification (last_ptid, &last_status);
4502 /* Be sure to not change the selected thread behind GDB's back.
4503 Important in the non-stop mode asynchronous protocol. */
4504 set_desired_thread ();
4517 } // namespace selftests
4518 #endif /* GDB_SELF_TEST */