/* Main code for remote server for GDB.
- Copyright (C) 1989-2013 Free Software Foundation, Inc.
+ Copyright (C) 1989-2015 Free Software Foundation, Inc.
This file is part of GDB.
#include "agent.h"
#include "notif.h"
#include "tdesc.h"
+#include "rsp-low.h"
+#include <ctype.h>
#include <unistd.h>
#if HAVE_SIGNAL_H
#include <signal.h>
#endif
+#include "gdb_vecs.h"
#include "gdb_wait.h"
#include "btrace-common.h"
#include "filestuff.h"
#include "tracepoint.h"
+#include "dll.h"
+#include "hostio.h"
/* The thread set with an `Hc' packet. `Hc' is deprecated in favor of
`vCont'. Note the multi-process extensions made `vCont' a
requirement, so `Hc pPID.TID' is pretty much undefined. So
CONT_THREAD can be null_ptid for no `Hc' thread, minus_one_ptid for
resuming all threads of the process (again, `Hc' isn't used for
- multi-process), or a specific thread ptid_t.
-
- We also set this when handling a single-thread `vCont' resume, as
- some places in the backends check it to know when (and for which
- thread) single-thread scheduler-locking is in effect. */
+ multi-process), or a specific thread ptid_t. */
ptid_t cont_thread;
/* The thread set with an `Hg' packet. */
int server_waiting;
-static int extended_protocol;
+int extended_protocol;
static int response_needed;
static int exit_requested;
int run_once;
int multi_process;
+int report_fork_events;
+int report_vfork_events;
+int report_exec_events;
int non_stop;
+int swbreak_feature;
+int hwbreak_feature;
+
+/* True if the "vContSupported" feature is active. In that case, GDB
+ wants us to report whether single step is supported in the reply to
+ "vCont?" packet. */
+static int vCont_supported;
/* Whether we should attempt to disable the operating system's address
space randomization feature before starting an inferior. */
static char **program_argv, **wrapper_argv;
-/* Enable miscellaneous debugging output. The name is historical - it
- was originally used to debug LinuxThreads support. */
-int debug_threads;
-
-/* Enable debugging of h/w breakpoint/watchpoint support. */
-int debug_hw_points;
-
int pass_signals[GDB_SIGNAL_LAST];
int program_signals[GDB_SIGNAL_LAST];
int program_signals_p;
-jmp_buf toplevel;
-
/* The PID of the originally created or attached inferior. Used to
send signals to the process when GDB sends us an asynchronous interrupt
(user hitting Control-C in the client), and to wait for the child to exit
struct target_waitstatus status;
};
+/* The current btrace configuration. This is gdbserver's mirror of GDB's
+ btrace configuration. */
+static struct btrace_config current_btrace_conf;
+
DEFINE_QUEUE_P (notif_event_p);
/* Put a stop reply to the stop reply queue. */
static void
queue_stop_reply (ptid_t ptid, struct target_waitstatus *status)
{
- struct vstop_notif *new_notif = xmalloc (sizeof (*new_notif));
+ struct vstop_notif *new_notif = XNEW (struct vstop_notif);
new_notif->ptid = ptid;
new_notif->status = *status;
}
static int
-remove_all_on_match_pid (QUEUE (notif_event_p) *q,
- QUEUE_ITER (notif_event_p) *iter,
- struct notif_event *event,
- void *data)
+remove_all_on_match_ptid (QUEUE (notif_event_p) *q,
+ QUEUE_ITER (notif_event_p) *iter,
+ struct notif_event *event,
+ void *data)
{
- int *pid = data;
+ ptid_t filter_ptid = *(ptid_t *) data;
+ struct vstop_notif *vstop_event = (struct vstop_notif *) event;
- if (*pid == -1
- || ptid_get_pid (((struct vstop_notif *) event)->ptid) == *pid)
+ if (ptid_match (vstop_event->ptid, filter_ptid))
{
if (q->free_func != NULL)
q->free_func (event);
return 1;
}
-/* Get rid of the currently pending stop replies for PID. If PID is
- -1, then apply to all processes. */
+/* See server.h. */
-static void
-discard_queued_stop_replies (int pid)
+void
+discard_queued_stop_replies (ptid_t ptid)
{
QUEUE_iterate (notif_event_p, notif_stop.queue,
- remove_all_on_match_pid, &pid);
+ remove_all_on_match_ptid, &ptid);
}
static void
static int
target_running (void)
{
- return all_threads.head != NULL;
+ return get_first_thread () != NULL;
}
static int
count++;
for (i = 0; argv[i] != NULL; i++)
count++;
- new_argv = alloca (sizeof (char *) * count);
+ new_argv = XALLOCAVEC (char *, count);
count = 0;
for (i = 0; wrapper_argv[i] != NULL; i++)
new_argv[count++] = wrapper_argv[i];
{
int i;
for (i = 0; new_argv[i]; ++i)
- fprintf (stderr, "new_argv[%d] = \"%s\"\n", i, new_argv[i]);
- fflush (stderr);
+ debug_printf ("new_argv[%d] = \"%s\"\n", i, new_argv[i]);
+ debug_flush ();
}
#ifdef SIGTTOU
signal (SIGTTIN, SIG_DFL);
#endif
- /* Clear this so the backend doesn't get confused, thinking
- CONT_THREAD died, and it needs to resume all threads. */
- cont_thread = null_ptid;
-
signal_pid = create_inferior (new_argv[0], new_argv);
/* FIXME: we don't actually know at this point that the create
{
struct thread_resume resume_info;
+ memset (&resume_info, 0, sizeof (resume_info));
resume_info.thread = pid_to_ptid (signal_pid);
resume_info.kind = resume_continue;
resume_info.sig = 0;
last_ptid = mywait (pid_to_ptid (signal_pid), &last_status, 0, 0);
- if (last_status.kind != TARGET_WAITKIND_STOPPED)
- return signal_pid;
-
- do
+ if (last_status.kind == TARGET_WAITKIND_STOPPED)
{
- (*the_target->resume) (&resume_info, 1);
+ do
+ {
+ (*the_target->resume) (&resume_info, 1);
- last_ptid = mywait (pid_to_ptid (signal_pid), &last_status, 0, 0);
- if (last_status.kind != TARGET_WAITKIND_STOPPED)
- return signal_pid;
+ last_ptid = mywait (pid_to_ptid (signal_pid), &last_status, 0, 0);
+ if (last_status.kind != TARGET_WAITKIND_STOPPED)
+ break;
- current_inferior->last_resume_kind = resume_stop;
- current_inferior->last_status = last_status;
+ current_thread->last_resume_kind = resume_stop;
+ current_thread->last_status = last_status;
+ }
+ while (last_status.value.sig != GDB_SIGNAL_TRAP);
}
- while (last_status.value.sig != GDB_SIGNAL_TRAP);
-
+ target_arch_setup ();
return signal_pid;
}
(assuming success). */
last_ptid = mywait (pid_to_ptid (signal_pid), &last_status, 0, 0);
+ target_arch_setup ();
+
if (last_status.kind != TARGET_WAITKIND_EXITED
&& last_status.kind != TARGET_WAITKIND_SIGNALLED)
{
- current_inferior->last_resume_kind = resume_stop;
- current_inferior->last_status = last_status;
+ current_thread->last_resume_kind = resume_stop;
+ current_thread->last_status = last_status;
}
+ else
+ mourn_inferior (find_process_pid (ptid_get_pid (last_ptid)));
return signal_pid;
}
whichever we were told to attach to. */
signal_pid = pid;
- /* Clear this so the backend doesn't get confused, thinking
- CONT_THREAD died, and it needs to resume all threads. */
- cont_thread = null_ptid;
-
if (!non_stop)
{
last_ptid = mywait (pid_to_ptid (pid), &last_status, 0, 0);
&& last_status.value.sig == GDB_SIGNAL_STOP)
last_status.value.sig = GDB_SIGNAL_TRAP;
- current_inferior->last_resume_kind = resume_stop;
- current_inferior->last_status = last_status;
+ current_thread->last_resume_kind = resume_stop;
+ current_thread->last_status = last_status;
}
return 0;
else
buf[0] = 'l';
- return remote_escape_output (data, len, (unsigned char *) buf + 1, &out_len,
- PBUFSIZ - 2) + 1;
+ return remote_escape_output (data, len, 1, (unsigned char *) buf + 1,
+ &out_len, PBUFSIZ - 2) + 1;
+}
+
+/* Handle btrace enabling in BTS format. */
+
+static const char *
+handle_btrace_enable_bts (struct thread_info *thread)
+{
+ if (thread->btrace != NULL)
+ return "E.Btrace already enabled.";
+
+ current_btrace_conf.format = BTRACE_FORMAT_BTS;
+ thread->btrace = target_enable_btrace (thread->entry.id,
+ ¤t_btrace_conf);
+ if (thread->btrace == NULL)
+ return "E.Could not enable btrace.";
+
+ return NULL;
}
-/* Handle btrace enabling. */
+/* Handle btrace enabling in Intel(R) Processor Trace format. */
static const char *
-handle_btrace_enable (struct thread_info *thread)
+handle_btrace_enable_pt (struct thread_info *thread)
{
if (thread->btrace != NULL)
return "E.Btrace already enabled.";
- thread->btrace = target_enable_btrace (thread->entry.id);
+ current_btrace_conf.format = BTRACE_FORMAT_PT;
+ thread->btrace = target_enable_btrace (thread->entry.id,
+ ¤t_btrace_conf);
if (thread->btrace == NULL)
return "E.Could not enable btrace.";
const char *err;
char *op;
- if (strncmp ("Qbtrace:", own_buf, strlen ("Qbtrace:")) != 0)
+ if (!startswith (own_buf, "Qbtrace:"))
return 0;
op = own_buf + strlen ("Qbtrace:");
- if (!target_supports_btrace ())
- {
- strcpy (own_buf, "E.Target does not support branch tracing.");
- return -1;
- }
-
if (ptid_equal (general_thread, null_ptid)
|| ptid_equal (general_thread, minus_one_ptid))
{
err = NULL;
if (strcmp (op, "bts") == 0)
- err = handle_btrace_enable (thread);
+ err = handle_btrace_enable_bts (thread);
+ else if (strcmp (op, "pt") == 0)
+ err = handle_btrace_enable_pt (thread);
else if (strcmp (op, "off") == 0)
err = handle_btrace_disable (thread);
else
- err = "E.Bad Qbtrace operation. Use bts or off.";
+ err = "E.Bad Qbtrace operation. Use bts, pt, or off.";
if (err != 0)
strcpy (own_buf, err);
return 1;
}
+/* Handle the "Qbtrace-conf" packet. */
+
+static int
+handle_btrace_conf_general_set (char *own_buf)
+{
+ struct thread_info *thread;
+ char *op;
+
+ if (!startswith (own_buf, "Qbtrace-conf:"))
+ return 0;
+
+ op = own_buf + strlen ("Qbtrace-conf:");
+
+ if (ptid_equal (general_thread, null_ptid)
+ || ptid_equal (general_thread, minus_one_ptid))
+ {
+ strcpy (own_buf, "E.Must select a single thread.");
+ return -1;
+ }
+
+ thread = find_thread_ptid (general_thread);
+ if (thread == NULL)
+ {
+ strcpy (own_buf, "E.No such thread.");
+ return -1;
+ }
+
+ if (startswith (op, "bts:size="))
+ {
+ unsigned long size;
+ char *endp = NULL;
+
+ errno = 0;
+ size = strtoul (op + strlen ("bts:size="), &endp, 16);
+ if (endp == NULL || *endp != 0 || errno != 0 || size > UINT_MAX)
+ {
+ strcpy (own_buf, "E.Bad size value.");
+ return -1;
+ }
+
+ current_btrace_conf.bts.size = (unsigned int) size;
+ }
+ else if (strncmp (op, "pt:size=", strlen ("pt:size=")) == 0)
+ {
+ unsigned long size;
+ char *endp = NULL;
+
+ errno = 0;
+ size = strtoul (op + strlen ("pt:size="), &endp, 16);
+ if (endp == NULL || *endp != 0 || errno != 0 || size > UINT_MAX)
+ {
+ strcpy (own_buf, "E.Bad size value.");
+ return -1;
+ }
+
+ current_btrace_conf.pt.size = (unsigned int) size;
+ }
+ else
+ {
+ strcpy (own_buf, "E.Bad Qbtrace configuration option.");
+ return -1;
+ }
+
+ write_ok (own_buf);
+ return 1;
+}
+
/* Handle all of the extended 'Q' packets. */
static void
handle_general_set (char *own_buf)
{
- if (strncmp ("QPassSignals:", own_buf, strlen ("QPassSignals:")) == 0)
+ if (startswith (own_buf, "QPassSignals:"))
{
int numsigs = (int) GDB_SIGNAL_LAST, i;
const char *p = own_buf + strlen ("QPassSignals:");
return;
}
- if (strncmp ("QProgramSignals:", own_buf, strlen ("QProgramSignals:")) == 0)
+ if (startswith (own_buf, "QProgramSignals:"))
{
int numsigs = (int) GDB_SIGNAL_LAST, i;
const char *p = own_buf + strlen ("QProgramSignals:");
return;
}
- if (strncmp (own_buf, "QNonStop:", 9) == 0)
+ if (startswith (own_buf, "QNonStop:"))
{
char *mode = own_buf + 9;
int req = -1;
- char *req_str;
+ const char *req_str;
if (strcmp (mode, "0") == 0)
req = 0;
return;
}
- if (strncmp ("QDisableRandomization:", own_buf,
- strlen ("QDisableRandomization:")) == 0)
+ if (startswith (own_buf, "QDisableRandomization:"))
{
char *packet = own_buf + strlen ("QDisableRandomization:");
ULONGEST setting;
&& handle_tracepoint_general_set (own_buf))
return;
- if (strncmp ("QAgent:", own_buf, strlen ("QAgent:")) == 0)
+ if (startswith (own_buf, "QAgent:"))
{
char *mode = own_buf + strlen ("QAgent:");
int req = 0;
if (handle_btrace_general_set (own_buf))
return;
+ if (handle_btrace_conf_general_set (own_buf))
+ return;
+
/* Otherwise we didn't know what packet it was. Say we didn't
understand it. */
own_buf[0] = 0;
monitor_output (" Enable h/w breakpoint/watchpoint debugging messages\n");
monitor_output (" set remote-debug <0|1>\n");
monitor_output (" Enable remote protocol debugging messages\n");
+ monitor_output (" set debug-format option1[,option2,...]\n");
+ monitor_output (" Add additional information to debugging messages\n");
+ monitor_output (" Options: all, none");
+ monitor_output (", timestamp");
+ monitor_output ("\n");
monitor_output (" exit\n");
monitor_output (" Quit GDBserver\n");
}
res = prepare_to_access_memory ();
if (res == 0)
{
- res = read_inferior_memory (memaddr, myaddr, len);
+ if (set_desired_thread (1))
+ res = read_inferior_memory (memaddr, myaddr, len);
+ else
+ res = 1;
done_accessing_memory ();
return res == 0 ? len : -1;
ret = prepare_to_access_memory ();
if (ret == 0)
{
- ret = write_inferior_memory (memaddr, myaddr, len);
+ if (set_desired_thread (1))
+ ret = write_inferior_memory (memaddr, myaddr, len);
+ else
+ ret = EIO;
done_accessing_memory ();
}
return ret;
return; \
}
+/* Parse options to --debug-format= and "monitor set debug-format".
+ ARG is the text after "--debug-format=" or "monitor set debug-format".
+ IS_MONITOR is non-zero if we're invoked via "monitor set debug-format".
+ This triggers calls to monitor_output.
+ The result is NULL if all options were parsed ok, otherwise an error
+ message which the caller must free.
+
+ N.B. These commands affect all debug format settings, they are not
+ cumulative. If a format is not specified, it is turned off.
+ However, we don't go to extra trouble with things like
+ "monitor set debug-format all,none,timestamp".
+ Instead we just parse them one at a time, in order.
+
+ The syntax for "monitor set debug" we support here is not identical
+ to gdb's "set debug foo on|off" because we also use this function to
+ parse "--debug-format=foo,bar". */
+
+static char *
+parse_debug_format_options (const char *arg, int is_monitor)
+{
+ VEC (char_ptr) *options;
+ int ix;
+ char *option;
+
+ /* First turn all debug format options off. */
+ debug_timestamp = 0;
+
+ /* First remove leading spaces, for "monitor set debug-format". */
+ while (isspace (*arg))
+ ++arg;
+
+ options = delim_string_to_char_ptr_vec (arg, ',');
+
+ for (ix = 0; VEC_iterate (char_ptr, options, ix, option); ++ix)
+ {
+ if (strcmp (option, "all") == 0)
+ {
+ debug_timestamp = 1;
+ if (is_monitor)
+ monitor_output ("All extra debug format options enabled.\n");
+ }
+ else if (strcmp (option, "none") == 0)
+ {
+ debug_timestamp = 0;
+ if (is_monitor)
+ monitor_output ("All extra debug format options disabled.\n");
+ }
+ else if (strcmp (option, "timestamp") == 0)
+ {
+ debug_timestamp = 1;
+ if (is_monitor)
+ monitor_output ("Timestamps will be added to debug output.\n");
+ }
+ else if (*option == '\0')
+ {
+ /* An empty option, e.g., "--debug-format=foo,,bar", is ignored. */
+ continue;
+ }
+ else
+ {
+ char *msg = xstrprintf ("Unknown debug-format argument: \"%s\"\n",
+ option);
+
+ free_char_ptr_vec (options);
+ return msg;
+ }
+ }
+
+ free_char_ptr_vec (options);
+ return NULL;
+}
+
/* Handle monitor commands not handled by target-specific handlers. */
static void
}
else if (strcmp (mon, "set debug-hw-points 1") == 0)
{
- debug_hw_points = 1;
+ show_debug_regs = 1;
monitor_output ("H/W point debugging output enabled.\n");
}
else if (strcmp (mon, "set debug-hw-points 0") == 0)
{
- debug_hw_points = 0;
+ show_debug_regs = 0;
monitor_output ("H/W point debugging output disabled.\n");
}
else if (strcmp (mon, "set remote-debug 1") == 0)
remote_debug = 0;
monitor_output ("Protocol debug output disabled.\n");
}
+ else if (startswith (mon, "set debug-format "))
+ {
+ char *error_msg
+ = parse_debug_format_options (mon + sizeof ("set debug-format ") - 1,
+ 1);
+
+ if (error_msg != NULL)
+ {
+ monitor_output (error_msg);
+ monitor_show_help ();
+ write_enn (own_buf);
+ xfree (error_msg);
+ }
+ }
else if (strcmp (mon, "help") == 0)
monitor_show_help ();
else if (strcmp (mon, "exit") == 0)
if (the_target->read_auxv == NULL || writebuf != NULL)
return -2;
- if (annex[0] != '\0' || !target_running ())
+ if (annex[0] != '\0' || current_thread == NULL)
return -1;
return (*the_target->read_auxv) (offset, readbuf, len);
}
+/* Handle qXfer:exec-file:read. */
+
+static int
+handle_qxfer_exec_file (const char *const_annex,
+ gdb_byte *readbuf, const gdb_byte *writebuf,
+ ULONGEST offset, LONGEST len)
+{
+ char *file;
+ ULONGEST pid;
+ int total_len;
+
+ if (the_target->pid_to_exec_file == NULL || writebuf != NULL)
+ return -2;
+
+ if (const_annex[0] == '\0')
+ {
+ if (current_thread == NULL)
+ return -1;
+
+ pid = pid_of (current_thread);
+ }
+ else
+ {
+ char *annex = alloca (strlen (const_annex) + 1);
+
+ strcpy (annex, const_annex);
+ annex = unpack_varlen_hex (annex, &pid);
+
+ if (annex[0] != '\0')
+ return -1;
+ }
+
+ if (pid <= 0)
+ return -1;
+
+ file = (*the_target->pid_to_exec_file) (pid);
+ if (file == NULL)
+ return -1;
+
+ total_len = strlen (file);
+
+ if (offset > total_len)
+ return -1;
+
+ if (offset + len > total_len)
+ len = total_len - offset;
+
+ memcpy (readbuf, file + offset, len);
+ return len;
+}
+
/* Handle qXfer:features:read. */
static int
return len;
}
+/* Worker routine for handle_qxfer_libraries.
+ Add to the length pointed to by ARG a conservative estimate of the
+ length needed to transmit the file name of INF. */
+
+static void
+accumulate_file_name_length (struct inferior_list_entry *inf, void *arg)
+{
+ struct dll_info *dll = (struct dll_info *) inf;
+ unsigned int *total_len = arg;
+
+ /* Over-estimate the necessary memory. Assume that every character
+ in the library name must be escaped. */
+ *total_len += 128 + 6 * strlen (dll->name);
+}
+
+/* Worker routine for handle_qxfer_libraries.
+ Emit the XML to describe the library in INF. */
+
+static void
+emit_dll_description (struct inferior_list_entry *inf, void *arg)
+{
+ struct dll_info *dll = (struct dll_info *) inf;
+ char **p_ptr = arg;
+ char *p = *p_ptr;
+ char *name;
+
+ strcpy (p, " <library name=\"");
+ p = p + strlen (p);
+ name = xml_escape_text (dll->name);
+ strcpy (p, name);
+ free (name);
+ p = p + strlen (p);
+ strcpy (p, "\"><segment address=\"");
+ p = p + strlen (p);
+ sprintf (p, "0x%lx", (long) dll->base_addr);
+ p = p + strlen (p);
+ strcpy (p, "\"/></library>\n");
+ p = p + strlen (p);
+
+ *p_ptr = p;
+}
+
/* Handle qXfer:libraries:read. */
static int
{
unsigned int total_len;
char *document, *p;
- struct inferior_list_entry *dll_ptr;
if (writebuf != NULL)
return -2;
- if (annex[0] != '\0' || !target_running ())
+ if (annex[0] != '\0' || current_thread == NULL)
return -1;
- /* Over-estimate the necessary memory. Assume that every character
- in the library name must be escaped. */
total_len = 64;
- for (dll_ptr = all_dlls.head; dll_ptr != NULL; dll_ptr = dll_ptr->next)
- total_len += 128 + 6 * strlen (((struct dll_info *) dll_ptr)->name);
+ for_each_inferior_with_data (&all_dlls, accumulate_file_name_length,
+ &total_len);
document = malloc (total_len);
if (document == NULL)
return -1;
- strcpy (document, "<library-list>\n");
+ strcpy (document, "<library-list version=\"1.0\">\n");
p = document + strlen (document);
- for (dll_ptr = all_dlls.head; dll_ptr != NULL; dll_ptr = dll_ptr->next)
- {
- struct dll_info *dll = (struct dll_info *) dll_ptr;
- char *name;
-
- strcpy (p, " <library name=\"");
- p = p + strlen (p);
- name = xml_escape_text (dll->name);
- strcpy (p, name);
- free (name);
- p = p + strlen (p);
- strcpy (p, "\"><segment address=\"");
- p = p + strlen (p);
- sprintf (p, "0x%lx", (long) dll->base_addr);
- p = p + strlen (p);
- strcpy (p, "\"/></library>\n");
- p = p + strlen (p);
- }
+ for_each_inferior_with_data (&all_dlls, emit_dll_description, &p);
strcpy (p, "</library-list>\n");
if (writebuf != NULL)
return -2;
- if (!target_running () || the_target->qxfer_libraries_svr4 == NULL)
+ if (current_thread == NULL || the_target->qxfer_libraries_svr4 == NULL)
return -1;
return the_target->qxfer_libraries_svr4 (annex, readbuf, writebuf, offset, len);
if (the_target->qxfer_siginfo == NULL)
return -2;
- if (annex[0] != '\0' || !target_running ())
+ if (annex[0] != '\0' || current_thread == NULL)
return -1;
return (*the_target->qxfer_siginfo) (annex, readbuf, writebuf, offset, len);
if (the_target->qxfer_spu == NULL)
return -2;
- if (!target_running ())
+ if (current_thread == NULL)
return -1;
return (*the_target->qxfer_spu) (annex, readbuf, writebuf, offset, len);
if (writebuf != NULL)
return -2;
- if (annex[0] != '\0' || !target_running () || current_traceframe == -1)
+ if (annex[0] != '\0' || current_thread == NULL || current_traceframe == -1)
return -1;
if (traceframe_read_sdata (current_traceframe, offset,
return nbytes;
}
-/* Helper for handle_qxfer_threads. */
+/* Helper for handle_qxfer_threads_proper.
+ Emit the XML to describe the thread of INF. */
static void
-handle_qxfer_threads_proper (struct buffer *buffer)
+handle_qxfer_threads_worker (struct inferior_list_entry *inf, void *arg)
{
- struct inferior_list_entry *thread;
+ struct thread_info *thread = (struct thread_info *) inf;
+ struct buffer *buffer = arg;
+ ptid_t ptid = thread_to_gdb_id (thread);
+ char ptid_s[100];
+ int core = target_core_of_thread (ptid);
+ char core_s[21];
- buffer_grow_str (buffer, "<threads>\n");
+ write_ptid (ptid_s, ptid);
- for (thread = all_threads.head; thread; thread = thread->next)
+ if (core != -1)
+ {
+ sprintf (core_s, "%d", core);
+ buffer_xml_printf (buffer, "<thread id=\"%s\" core=\"%s\"/>\n",
+ ptid_s, core_s);
+ }
+ else
{
- ptid_t ptid = thread_to_gdb_id ((struct thread_info *)thread);
- char ptid_s[100];
- int core = target_core_of_thread (ptid);
- char core_s[21];
+ buffer_xml_printf (buffer, "<thread id=\"%s\"/>\n",
+ ptid_s);
+ }
+}
- write_ptid (ptid_s, ptid);
+/* Helper for handle_qxfer_threads. */
- if (core != -1)
- {
- sprintf (core_s, "%d", core);
- buffer_xml_printf (buffer, "<thread id=\"%s\" core=\"%s\"/>\n",
- ptid_s, core_s);
- }
- else
- {
- buffer_xml_printf (buffer, "<thread id=\"%s\"/>\n",
- ptid_s);
- }
- }
+static void
+handle_qxfer_threads_proper (struct buffer *buffer)
+{
+ buffer_grow_str (buffer, "<threads>\n");
+
+ for_each_inferior_with_data (&all_threads, handle_qxfer_threads_worker,
+ buffer);
buffer_grow_str0 (buffer, "</threads>\n");
}
if (writebuf != NULL)
return -2;
- if (!target_running () || annex[0] != '\0')
+ if (annex[0] != '\0')
return -1;
if (offset == 0)
if (the_target->read_loadmap == NULL)
return -2;
- if (!target_running ())
+ if (current_thread == NULL)
return -1;
return (*the_target->read_loadmap) (annex, offset, readbuf, len);
{
static struct buffer cache;
struct thread_info *thread;
- int type;
+ int type, result;
if (the_target->read_btrace == NULL || writebuf != NULL)
return -2;
- if (!target_running ())
- return -1;
-
if (ptid_equal (general_thread, null_ptid)
|| ptid_equal (general_thread, minus_one_ptid))
{
}
if (strcmp (annex, "all") == 0)
- type = btrace_read_all;
+ type = BTRACE_READ_ALL;
else if (strcmp (annex, "new") == 0)
- type = btrace_read_new;
+ type = BTRACE_READ_NEW;
+ else if (strcmp (annex, "delta") == 0)
+ type = BTRACE_READ_DELTA;
else
{
strcpy (own_buf, "E.Bad annex.");
{
buffer_free (&cache);
- target_read_btrace (thread->btrace, &cache, type);
+ result = target_read_btrace (thread->btrace, &cache, type);
+ if (result != 0)
+ {
+ memcpy (own_buf, cache.buffer, cache.used_size);
+ return -3;
+ }
+ }
+ else if (offset > cache.used_size)
+ {
+ buffer_free (&cache);
+ return -3;
+ }
+
+ if (len > cache.used_size - offset)
+ len = cache.used_size - offset;
+
+ memcpy (readbuf, cache.buffer + offset, len);
+
+ return len;
+}
+
+/* Handle qXfer:btrace-conf:read. */
+
+static int
+handle_qxfer_btrace_conf (const char *annex,
+ gdb_byte *readbuf, const gdb_byte *writebuf,
+ ULONGEST offset, LONGEST len)
+{
+ static struct buffer cache;
+ struct thread_info *thread;
+ int result;
+
+ if (the_target->read_btrace_conf == NULL || writebuf != NULL)
+ return -2;
+
+ if (annex[0] != '\0')
+ return -1;
+
+ if (ptid_equal (general_thread, null_ptid)
+ || ptid_equal (general_thread, minus_one_ptid))
+ {
+ strcpy (own_buf, "E.Must select a single thread.");
+ return -3;
+ }
+
+ thread = find_thread_ptid (general_thread);
+ if (thread == NULL)
+ {
+ strcpy (own_buf, "E.No such thread.");
+ return -3;
+ }
+
+ if (thread->btrace == NULL)
+ {
+ strcpy (own_buf, "E.Btrace not enabled.");
+ return -3;
+ }
+
+ if (offset == 0)
+ {
+ buffer_free (&cache);
+
+ result = target_read_btrace_conf (thread->btrace, &cache);
+ if (result != 0)
+ {
+ memcpy (own_buf, cache.buffer, cache.used_size);
+ return -3;
+ }
}
else if (offset > cache.used_size)
{
{
{ "auxv", handle_qxfer_auxv },
{ "btrace", handle_qxfer_btrace },
+ { "btrace-conf", handle_qxfer_btrace_conf },
+ { "exec-file", handle_qxfer_exec_file},
{ "fdpic", handle_qxfer_fdpic},
{ "features", handle_qxfer_features },
{ "libraries", handle_qxfer_libraries },
char *annex;
char *offset;
- if (strncmp (own_buf, "qXfer:", 6) != 0)
+ if (!startswith (own_buf, "qXfer:"))
return 0;
/* Grab the object, r/w and annex. */
return (unsigned long long) crc;
}
+/* Add supported btrace packets to BUF. */
+
+static void
+supported_btrace_packets (char *buf)
+{
+ int btrace_supported = 0;
+
+ if (target_supports_btrace (BTRACE_FORMAT_BTS))
+ {
+ strcat (buf, ";Qbtrace:bts+");
+ strcat (buf, ";Qbtrace-conf:bts:size+");
+
+ btrace_supported = 1;
+ }
+
+ if (target_supports_btrace (BTRACE_FORMAT_PT))
+ {
+ strcat (buf, ";Qbtrace:pt+");
+ strcat (buf, ";Qbtrace-conf:pt:size+");
+
+ btrace_supported = 1;
+ }
+
+ if (!btrace_supported)
+ return;
+
+ strcat (buf, ";Qbtrace:off+");
+ strcat (buf, ";qXfer:btrace:read+");
+ strcat (buf, ";qXfer:btrace-conf:read+");
+}
+
/* Handle all of the extended 'q' packets. */
void
gdb_id = general_thread;
else
{
- thread_ptr = all_threads.head;
+ thread_ptr = get_first_inferior (&all_threads);
gdb_id = thread_to_gdb_id ((struct thread_info *)thread_ptr);
}
if (target_supports_tracepoints ())
tracepoint_look_up_symbols ();
- if (target_running () && the_target->look_up_symbols != NULL)
+ if (current_thread != NULL && the_target->look_up_symbols != NULL)
(*the_target->look_up_symbols) ();
strcpy (own_buf, "OK");
ptid_t gdb_id;
require_running (own_buf);
- thread_ptr = all_threads.head;
+ thread_ptr = get_first_inferior (&all_threads);
*own_buf++ = 'm';
gdb_id = thread_to_gdb_id ((struct thread_info *)thread_ptr);
}
/* Protocol features query. */
- if (strncmp ("qSupported", own_buf, 10) == 0
+ if (startswith (own_buf, "qSupported")
&& (own_buf[10] == ':' || own_buf[10] == '\0'))
{
char *p = &own_buf[10];
/* GDB supports relocate instruction requests. */
gdb_supports_qRelocInsn = 1;
}
+ else if (strcmp (p, "swbreak+") == 0)
+ {
+ /* GDB wants us to report whether a trap is caused
+ by a software breakpoint and for us to handle PC
+ adjustment if necessary on this target. */
+ if (target_supports_stopped_by_sw_breakpoint ())
+ swbreak_feature = 1;
+ }
+ else if (strcmp (p, "hwbreak+") == 0)
+ {
+ /* GDB wants us to report whether a trap is caused
+ by a hardware breakpoint. */
+ if (target_supports_stopped_by_hw_breakpoint ())
+ hwbreak_feature = 1;
+ }
+ else if (strcmp (p, "fork-events+") == 0)
+ {
+ /* GDB supports and wants fork events if possible. */
+ if (target_supports_fork_events ())
+ report_fork_events = 1;
+ }
+ else if (strcmp (p, "vfork-events+") == 0)
+ {
+ /* GDB supports and wants vfork events if possible. */
+ if (target_supports_vfork_events ())
+ report_vfork_events = 1;
+ }
+ else if (strcmp (p, "exec-events+") == 0)
+ {
+ /* GDB supports and wants exec events if possible. */
+ if (target_supports_exec_events ())
+ report_exec_events = 1;
+ }
+ else if (strcmp (p, "vContSupported+") == 0)
+ vCont_supported = 1;
else
target_process_qsupported (p);
if (target_supports_multi_process ())
strcat (own_buf, ";multiprocess+");
+ if (target_supports_fork_events ())
+ strcat (own_buf, ";fork-events+");
+
+ if (target_supports_vfork_events ())
+ strcat (own_buf, ";vfork-events+");
+
+ if (target_supports_exec_events ())
+ strcat (own_buf, ";exec-events+");
+
if (target_supports_non_stop ())
strcat (own_buf, ";QNonStop+");
strcat (own_buf, ";tracenz+");
}
- /* Support target-side breakpoint conditions and commands. */
- strcat (own_buf, ";ConditionalBreakpoints+");
+ if (target_supports_hardware_single_step ())
+ {
+ /* Support target-side breakpoint conditions and commands.
+ GDBserver needs to step over the breakpoint if the condition
+ is false. GDBserver software single step is too simple, so
+ disable conditional breakpoints if the target doesn't have
+ hardware single step. */
+ strcat (own_buf, ";ConditionalBreakpoints+");
+ }
strcat (own_buf, ";BreakpointCommands+");
if (target_supports_agent ())
strcat (own_buf, ";QAgent+");
- if (target_supports_btrace ())
- {
- strcat (own_buf, ";Qbtrace:bts+");
- strcat (own_buf, ";Qbtrace:off+");
- strcat (own_buf, ";qXfer:btrace:read+");
- }
+ supported_btrace_packets (own_buf);
+
+ if (target_supports_stopped_by_sw_breakpoint ())
+ strcat (own_buf, ";swbreak+");
+
+ if (target_supports_stopped_by_hw_breakpoint ())
+ strcat (own_buf, ";hwbreak+");
+
+ if (the_target->pid_to_exec_file != NULL)
+ strcat (own_buf, ";qXfer:exec-file:read+");
+
+ strcat (own_buf, ";vContSupported+");
+
+ /* Reinitialize components as needed for the new connection. */
+ hostio_handle_new_gdb_connection ();
+ target_handle_new_gdb_connection ();
return;
}
/* Thread-local storage support. */
if (the_target->get_tls_address != NULL
- && strncmp ("qGetTLSAddr:", own_buf, 12) == 0)
+ && startswith (own_buf, "qGetTLSAddr:"))
{
char *p = own_buf + 12;
CORE_ADDR parts[2], address = 0;
/* Windows OS Thread Information Block address support. */
if (the_target->get_tib_address != NULL
- && strncmp ("qGetTIBAddr:", own_buf, 12) == 0)
+ && startswith (own_buf, "qGetTIBAddr:"))
{
char *annex;
int n;
}
/* Handle "monitor" commands. */
- if (strncmp ("qRcmd,", own_buf, 6) == 0)
+ if (startswith (own_buf, "qRcmd,"))
{
char *mon = malloc (PBUFSIZ);
int len = strlen (own_buf + 6);
return;
}
- if ((len % 2) != 0 || unhexify (mon, own_buf + 6, len / 2) != len / 2)
+ if ((len % 2) != 0
+ || hex2bin (own_buf + 6, (gdb_byte *) mon, len / 2) != len / 2)
{
write_enn (own_buf);
free (mon);
return;
}
- if (strncmp ("qSearch:memory:", own_buf,
- sizeof ("qSearch:memory:") - 1) == 0)
+ if (startswith (own_buf, "qSearch:memory:"))
{
require_running (own_buf);
handle_search_memory (own_buf, packet_len);
}
if (strcmp (own_buf, "qAttached") == 0
- || strncmp (own_buf, "qAttached:", sizeof ("qAttached:") - 1) == 0)
+ || startswith (own_buf, "qAttached:"))
{
struct process_info *process;
return;
}
- if (strncmp ("qCRC:", own_buf, 5) == 0)
+ if (startswith (own_buf, "qCRC:"))
{
/* CRC check (compare-section). */
char *comma;
}
static void gdb_wants_all_threads_stopped (void);
+static void resume (struct thread_resume *actions, size_t n);
+
+/* The callback that is passed to visit_actioned_threads. */
+typedef int (visit_actioned_threads_callback_ftype)
+ (const struct thread_resume *, struct thread_info *);
+
+/* Struct to pass data to visit_actioned_threads. */
+
+struct visit_actioned_threads_data
+{
+ const struct thread_resume *actions;
+ size_t num_actions;
+ visit_actioned_threads_callback_ftype *callback;
+};
+
+/* Call CALLBACK for any thread to which ACTIONS applies to. Returns
+ true if CALLBACK returns true. Returns false if no matching thread
+ is found or CALLBACK results false.
+ Note: This function is itself a callback for find_inferior. */
+
+static int
+visit_actioned_threads (struct inferior_list_entry *entry, void *datap)
+{
+ struct visit_actioned_threads_data *data = datap;
+ const struct thread_resume *actions = data->actions;
+ size_t num_actions = data->num_actions;
+ visit_actioned_threads_callback_ftype *callback = data->callback;
+ size_t i;
+
+ for (i = 0; i < num_actions; i++)
+ {
+ const struct thread_resume *action = &actions[i];
+
+ if (ptid_equal (action->thread, minus_one_ptid)
+ || ptid_equal (action->thread, entry->id)
+ || ((ptid_get_pid (action->thread)
+ == ptid_get_pid (entry->id))
+ && ptid_get_lwp (action->thread) == -1))
+ {
+ struct thread_info *thread = (struct thread_info *) entry;
+
+ if ((*callback) (action, thread))
+ return 1;
+ }
+ }
+
+ return 0;
+}
+
+/* Callback for visit_actioned_threads. If the thread has a pending
+ status to report, report it now. */
+
+static int
+handle_pending_status (const struct thread_resume *resumption,
+ struct thread_info *thread)
+{
+ if (thread->status_pending_p)
+ {
+ thread->status_pending_p = 0;
+
+ last_status = thread->last_status;
+ last_ptid = thread->entry.id;
+ prepare_resume_reply (own_buf, last_ptid, &last_status);
+ return 1;
+ }
+ return 0;
+}
/* Parse vCont packets. */
void
if (i < n)
resume_info[i] = default_action;
- /* `cont_thread' is still used in occasional places in the backend,
- to implement single-thread scheduler-locking. Doesn't make sense
- to set it if we see a stop request, or a wildcard action (one
- with '-1' (all threads), or 'pPID.-1' (all threads of PID)). */
- if (n == 1
- && !(ptid_equal (resume_info[0].thread, minus_one_ptid)
- || ptid_get_lwp (resume_info[0].thread) == -1)
- && resume_info[0].kind != resume_stop)
- cont_thread = resume_info[0].thread;
- else
- cont_thread = minus_one_ptid;
- set_desired_inferior (0);
+ resume (resume_info, n);
+ free (resume_info);
+ return;
- if (!non_stop)
- enable_async_io ();
+err:
+ write_enn (own_buf);
+ free (resume_info);
+ return;
+}
- (*the_target->resume) (resume_info, n);
+/* Resume target with ACTIONS, an array of NUM_ACTIONS elements. */
- free (resume_info);
+static void
+resume (struct thread_resume *actions, size_t num_actions)
+{
+ if (!non_stop)
+ {
+ /* Check if among the threads that GDB wants actioned, there's
+ one with a pending status to report. If so, skip actually
+ resuming/stopping and report the pending event
+ immediately. */
+ struct visit_actioned_threads_data data;
+
+ data.actions = actions;
+ data.num_actions = num_actions;
+ data.callback = handle_pending_status;
+ if (find_inferior (&all_threads, visit_actioned_threads, &data) != NULL)
+ return;
+
+ enable_async_io ();
+ }
+
+ (*the_target->resume) (actions, num_actions);
if (non_stop)
write_ok (own_buf);
{
last_ptid = mywait (minus_one_ptid, &last_status, 0, 1);
+ if (last_status.kind == TARGET_WAITKIND_NO_RESUMED)
+ {
+ /* No proper RSP support for this yet. At least return
+ error. */
+ sprintf (own_buf, "E.No unwaited-for children left.");
+ disable_async_io ();
+ return;
+ }
+
if (last_status.kind != TARGET_WAITKIND_EXITED
- && last_status.kind != TARGET_WAITKIND_SIGNALLED)
- current_inferior->last_status = last_status;
+ && last_status.kind != TARGET_WAITKIND_SIGNALLED
+ && last_status.kind != TARGET_WAITKIND_NO_RESUMED)
+ current_thread->last_status = last_status;
/* From the client's perspective, all-stop mode always stops all
threads implicitly (and the target backend has already done
|| last_status.kind == TARGET_WAITKIND_SIGNALLED)
mourn_inferior (find_process_pid (ptid_get_pid (last_ptid)));
}
- return;
-
-err:
- write_enn (own_buf);
- free (resume_info);
- return;
}
/* Attach to a new program. Return 1 if successful, 0 if failure. */
{
/* FIXME: Fail request if out of memory instead of dying. */
new_argv[i] = xmalloc (1 + (next_p - p) / 2);
- unhexify (new_argv[i], p, (next_p - p) / 2);
+ hex2bin (p, (gdb_byte *) new_argv[i], (next_p - p) / 2);
new_argv[i][(next_p - p) / 2] = '\0';
}
last_status.kind = TARGET_WAITKIND_SIGNALLED;
last_status.value.sig = GDB_SIGNAL_KILL;
last_ptid = pid_to_ptid (pid);
- discard_queued_stop_replies (pid);
+ discard_queued_stop_replies (last_ptid);
write_ok (own_buf);
return 1;
}
{
if (!disable_packet_vCont)
{
- if (strncmp (own_buf, "vCont;", 6) == 0)
+ if (startswith (own_buf, "vCont;"))
{
require_running (own_buf);
handle_v_cont (own_buf);
return;
}
- if (strncmp (own_buf, "vCont?", 6) == 0)
+ if (startswith (own_buf, "vCont?"))
{
- strcpy (own_buf, "vCont;c;C;s;S;t");
+ strcpy (own_buf, "vCont;c;C;t");
+
+ if (target_supports_hardware_single_step () || !vCont_supported)
+ {
+ /* If target supports hardware single step, add actions s
+ and S to the list of supported actions. On the other
+ hand, if GDB doesn't request the supported vCont actions
+ in qSupported packet, add s and S to the list too. */
+ own_buf = own_buf + strlen (own_buf);
+ strcpy (own_buf, ";s;S");
+ }
+
if (target_supports_range_stepping ())
{
own_buf = own_buf + strlen (own_buf);
}
}
- if (strncmp (own_buf, "vFile:", 6) == 0
+ if (startswith (own_buf, "vFile:")
&& handle_vFile (own_buf, packet_len, new_packet_len))
return;
- if (strncmp (own_buf, "vAttach;", 8) == 0)
+ if (startswith (own_buf, "vAttach;"))
{
if ((!extended_protocol || !multi_process) && target_running ())
{
return;
}
- if (strncmp (own_buf, "vRun;", 5) == 0)
+ if (startswith (own_buf, "vRun;"))
{
if ((!extended_protocol || !multi_process) && target_running ())
{
return;
}
- if (strncmp (own_buf, "vKill;", 6) == 0)
+ if (startswith (own_buf, "vKill;"))
{
if (!target_running ())
{
return;
}
-/* Resume inferior and wait for another event. In non-stop mode,
+/* Resume thread and wait for another event. In non-stop mode,
don't really wait here, but return immediatelly to the event
loop. */
static void
int n = 0;
int valid_cont_thread;
- set_desired_inferior (0);
-
valid_cont_thread = (!ptid_equal (cont_thread, null_ptid)
&& !ptid_equal (cont_thread, minus_one_ptid));
n++;
}
- if (!non_stop)
- enable_async_io ();
-
- (*the_target->resume) (resume_info, n);
-
- if (non_stop)
- write_ok (own_buf);
- else
- {
- last_ptid = mywait (minus_one_ptid, &last_status, 0, 1);
-
- if (last_status.kind != TARGET_WAITKIND_EXITED
- && last_status.kind != TARGET_WAITKIND_SIGNALLED)
- {
- current_inferior->last_resume_kind = resume_stop;
- current_inferior->last_status = last_status;
- }
-
- prepare_resume_reply (own_buf, last_ptid, &last_status);
- disable_async_io ();
-
- if (last_status.kind == TARGET_WAITKIND_EXITED
- || last_status.kind == TARGET_WAITKIND_SIGNALLED)
- mourn_inferior (find_process_pid (ptid_get_pid (last_ptid)));
- }
+ resume (resume_info, n);
}
/* Callback for for_each_inferior. Make a new stop reply for each
manage the thread's last_status field. */
if (the_target->thread_stopped == NULL)
{
- struct vstop_notif *new_notif = xmalloc (sizeof (*new_notif));
+ struct vstop_notif *new_notif = XNEW (struct vstop_notif);
new_notif->ptid = entry->id;
new_notif->status = thread->last_status;
char *status_string
= target_waitstatus_to_string (&thread->last_status);
- fprintf (stderr,
- "Reporting thread %s as already stopped with %s\n",
- target_pid_to_str (entry->id),
- status_string);
+ debug_printf ("Reporting thread %s as already stopped with %s\n",
+ target_pid_to_str (entry->id),
+ status_string);
xfree (status_string);
}
process->gdb_detached = 0;
}
+/* Callback for for_each_inferior. Clear the thread's pending status
+ flag. */
+
+static void
+clear_pending_status_callback (struct inferior_list_entry *entry)
+{
+ struct thread_info *thread = (struct thread_info *) entry;
+
+ thread->status_pending_p = 0;
+}
+
+/* Callback for for_each_inferior. If the thread is stopped with an
+ interesting event, mark it as having a pending event. */
+
+static void
+set_pending_status_callback (struct inferior_list_entry *entry)
+{
+ struct thread_info *thread = (struct thread_info *) entry;
+
+ if (thread->last_status.kind != TARGET_WAITKIND_STOPPED
+ || (thread->last_status.value.sig != GDB_SIGNAL_0
+ /* A breakpoint, watchpoint or finished step from a previous
+ GDB run isn't considered interesting for a new GDB run.
+ If we left those pending, the new GDB could consider them
+ random SIGTRAPs. This leaves out real async traps. We'd
+ have to peek into the (target-specific) siginfo to
+ distinguish those. */
+ && thread->last_status.value.sig != GDB_SIGNAL_TRAP))
+ thread->status_pending_p = 1;
+}
+
+/* Callback for find_inferior. Return true if ENTRY (a thread) has a
+ pending status to report to GDB. */
+
+static int
+find_status_pending_thread_callback (struct inferior_list_entry *entry, void *data)
+{
+ struct thread_info *thread = (struct thread_info *) entry;
+
+ return thread->status_pending_p;
+}
+
/* Status handler for the '?' packet. */
static void
if (non_stop)
{
- discard_queued_stop_replies (-1);
find_inferior (&all_threads, queue_stop_reply_callback, NULL);
/* The first is sent immediatly. OK is sent if there is no
}
else
{
+ struct inferior_list_entry *thread = NULL;
+
pause_all (0);
stabilize_threads ();
gdb_wants_all_threads_stopped ();
- if (all_threads.head)
+ /* We can only report one status, but we might be coming out of
+ non-stop -- if more than one thread is stopped with
+ interesting events, leave events for the threads we're not
+ reporting now pending. They'll be reported the next time the
+ threads are resumed. Start by marking all interesting events
+ as pending. */
+ for_each_inferior (&all_threads, set_pending_status_callback);
+
+ /* Prefer the last thread that reported an event to GDB (even if
+ that was a GDB_SIGNAL_TRAP). */
+ if (last_status.kind != TARGET_WAITKIND_IGNORE
+ && last_status.kind != TARGET_WAITKIND_EXITED
+ && last_status.kind != TARGET_WAITKIND_SIGNALLED)
+ thread = find_inferior_id (&all_threads, last_ptid);
+
+ /* If the last event thread is not found for some reason, look
+ for some other thread that might have an event to report. */
+ if (thread == NULL)
+ thread = find_inferior (&all_threads,
+ find_status_pending_thread_callback, NULL);
+
+ /* If we're still out of luck, simply pick the first thread in
+ the thread list. */
+ if (thread == NULL)
+ thread = get_first_inferior (&all_threads);
+
+ if (thread != NULL)
{
- struct target_waitstatus status;
+ struct thread_info *tp = (struct thread_info *) thread;
+
+ /* We're reporting this event, so it's no longer
+ pending. */
+ tp->status_pending_p = 0;
- status.kind = TARGET_WAITKIND_STOPPED;
- status.value.sig = GDB_SIGNAL_TRAP;
- prepare_resume_reply (own_buf,
- all_threads.head->id, &status);
+ /* GDB assumes the current thread is the thread we're
+ reporting the status for. */
+ general_thread = thread->id;
+ set_desired_thread (1);
+
+ gdb_assert (tp->last_status.kind != TARGET_WAITKIND_IGNORE);
+ prepare_resume_reply (own_buf, tp->entry.id, &tp->last_status);
}
else
strcpy (own_buf, "W00");
gdbserver_version (void)
{
printf ("GNU gdbserver %s%s\n"
- "Copyright (C) 2013 Free Software Foundation, Inc.\n"
+ "Copyright (C) 2015 Free Software Foundation, Inc.\n"
"gdbserver is free software, covered by the "
"GNU General Public License.\n"
"This gdbserver was configured as \"%s\"\n",
"\tgdbserver [OPTIONS] --attach COMM PID\n"
"\tgdbserver [OPTIONS] --multi COMM\n"
"\n"
- "COMM may either be a tty device (for serial debugging), or \n"
- "HOST:PORT to listen for a TCP connection.\n"
+ "COMM may either be a tty device (for serial debugging),\n"
+ "HOST:PORT to listen for a TCP connection, or '-' or 'stdio' to use \n"
+ "stdin/stdout of gdbserver.\n"
+ "PROG is the executable program. ARGS are arguments passed to inferior.\n"
+ "PID is the process ID to attach to, when --attach is specified.\n"
"\n"
- "Options:\n"
- " --debug Enable general debugging output.\n"
- " --remote-debug Enable remote protocol debugging output.\n"
+ "Operating modes:\n"
+ "\n"
+ " --attach Attach to running process PID.\n"
+ " --multi Start server without a specific program, and\n"
+ " only quit when explicitly commanded.\n"
+ " --once Exit after the first connection has closed.\n"
+ " --help Print this message and then exit.\n"
" --version Display version information and exit.\n"
+ "\n"
+ "Other options:\n"
+ "\n"
" --wrapper WRAPPER -- Run WRAPPER to start new programs.\n"
- " --once Exit after the first connection has "
- "closed.\n");
+ " --disable-randomization\n"
+ " Run PROG with address space randomization disabled.\n"
+ " --no-disable-randomization\n"
+ " Don't disable address space randomization when\n"
+ " starting PROG.\n"
+ "\n"
+ "Debug options:\n"
+ "\n"
+ " --debug Enable general debugging output.\n"
+ " --debug-format=opt1[,opt2,...]\n"
+ " Specify extra content in debugging output.\n"
+ " Options:\n"
+ " all\n"
+ " none\n"
+ " timestamp\n"
+ " --remote-debug Enable remote protocol debugging output.\n"
+ " --disable-packet=opt1[,opt2,...]\n"
+ " Disable support for RSP packets or features.\n"
+ " Options:\n"
+ " vCont, Tthread, qC, qfThreadInfo and \n"
+ " threads (disable all threading packets).\n"
+ "\n"
+ "For more information, consult the GDB manual (available as on-line \n"
+ "info or a printed manual).\n");
if (REPORT_BUGS_TO[0] && stream == stdout)
fprintf (stream, "Report bugs to \"%s\".\n", REPORT_BUGS_TO);
}
kill_inferior_callback (struct inferior_list_entry *entry)
{
struct process_info *process = (struct process_info *) entry;
- int pid = ptid_get_pid (process->head.id);
+ int pid = ptid_get_pid (process->entry.id);
kill_inferior (pid);
- discard_queued_stop_replies (pid);
+ discard_queued_stop_replies (pid_to_ptid (pid));
}
/* Callback for for_each_inferior to detach or kill the inferior,
detach_or_kill_inferior_callback (struct inferior_list_entry *entry)
{
struct process_info *process = (struct process_info *) entry;
- int pid = ptid_get_pid (process->head.id);
+ int pid = ptid_get_pid (process->entry.id);
if (process->attached)
detach_inferior (pid);
else
kill_inferior (pid);
- discard_queued_stop_replies (pid);
+ discard_queued_stop_replies (pid_to_ptid (pid));
}
/* for_each_inferior callback for detach_or_kill_for_exit to print
if (! process->attached)
{
- int pid = ptid_get_pid (process->head.id);
+ int pid = ptid_get_pid (process->entry.id);
fprintf (stderr, " %d", pid);
}
}
if (process->attached)
{
- int pid = ptid_get_pid (process->head.id);
+ int pid = ptid_get_pid (process->entry.id);
fprintf (stderr, " %d", pid);
}
}
for_each_inferior (&all_processes, detach_or_kill_inferior_callback);
}
-int
-main (int argc, char *argv[])
+/* Value that will be passed to exit(3) when gdbserver exits. */
+static int exit_code;
+
+/* Cleanup version of detach_or_kill_for_exit. */
+
+static void
+detach_or_kill_for_exit_cleanup (void *ignore)
+{
+
+ TRY
+ {
+ detach_or_kill_for_exit ();
+ }
+
+ CATCH (exception, RETURN_MASK_ALL)
+ {
+ fflush (stdout);
+ fprintf (stderr, "Detach or kill failed: %s\n", exception.message);
+ exit_code = 1;
+ }
+ END_CATCH
+}
+
+/* Main function. This is called by the real "main" function,
+ wrapped in a TRY_CATCH that handles any uncaught exceptions. */
+
+static void ATTRIBUTE_NORETURN
+captured_main (int argc, char *argv[])
{
int bad_attach;
int pid;
}
else if (strcmp (*next_arg, "--debug") == 0)
debug_threads = 1;
+ else if (startswith (*next_arg, "--debug-format="))
+ {
+ char *error_msg
+ = parse_debug_format_options ((*next_arg)
+ + sizeof ("--debug-format=") - 1, 0);
+
+ if (error_msg != NULL)
+ {
+ fprintf (stderr, "%s", error_msg);
+ exit (1);
+ }
+ }
else if (strcmp (*next_arg, "--remote-debug") == 0)
remote_debug = 1;
else if (strcmp (*next_arg, "--disable-packet") == 0)
gdbserver_show_disableable (stdout);
exit (0);
}
- else if (strncmp (*next_arg,
- "--disable-packet=",
- sizeof ("--disable-packet=") - 1) == 0)
+ else if (startswith (*next_arg, "--disable-packet="))
{
char *packets, *tok;
continue;
}
- if (setjmp (toplevel))
- {
- fprintf (stderr, "Exiting\n");
- exit (1);
- }
-
port = *next_arg;
next_arg++;
if (port == NULL || (!attach && !multi_mode && *next_arg == NULL))
initialize_event_loop ();
if (target_supports_tracepoints ())
initialize_tracepoint ();
+ initialize_notif ();
own_buf = xmalloc (PBUFSIZ + 1);
mem_buf = xmalloc (PBUFSIZ);
last_status.value.integer = 0;
last_ptid = minus_one_ptid;
}
-
- initialize_notif ();
+ make_cleanup (detach_or_kill_for_exit_cleanup, NULL);
/* Don't report shared library events on the initial connection,
even if some libraries are preloaded. Avoids the "stopped by
shared library event" notice on gdb side. */
dlls_changed = 0;
- if (setjmp (toplevel))
- {
- /* If something fails and longjmps while detaching or killing
- inferiors, we'd end up here again, stuck in an infinite loop
- trap. Be sure that if that happens, we exit immediately
- instead. */
- if (setjmp (toplevel) == 0)
- detach_or_kill_for_exit ();
- else
- fprintf (stderr, "Detach or kill failed. Exiting\n");
- exit (1);
- }
-
if (last_status.kind == TARGET_WAITKIND_EXITED
|| last_status.kind == TARGET_WAITKIND_SIGNALLED)
was_running = 0;
was_running = 1;
if (!was_running && !multi_mode)
- {
- fprintf (stderr, "No program to debug. GDBserver exiting.\n");
- exit (1);
- }
+ error ("No program to debug");
while (1)
{
+
noack_mode = 0;
multi_process = 0;
+ report_fork_events = 0;
+ report_vfork_events = 0;
+ report_exec_events = 0;
/* Be sure we're out of tfind mode. */
current_traceframe = -1;
+ cont_thread = null_ptid;
+ swbreak_feature = 0;
+ hwbreak_feature = 0;
+ vCont_supported = 0;
remote_open (port);
- if (setjmp (toplevel) != 0)
+ TRY
+ {
+ /* Wait for events. This will return when all event sources
+ are removed from the event loop. */
+ start_event_loop ();
+
+ /* If an exit was requested (using the "monitor exit"
+ command), terminate now. The only other way to get
+ here is for getpkt to fail; close the connection
+ and reopen it at the top of the loop. */
+
+ if (exit_requested || run_once)
+ throw_quit ("Quit");
+
+ fprintf (stderr,
+ "Remote side has terminated connection. "
+ "GDBserver will reopen the connection.\n");
+
+ /* Get rid of any pending statuses. An eventual reconnection
+ (by the same GDB instance or another) will refresh all its
+ state from scratch. */
+ discard_queued_stop_replies (minus_one_ptid);
+ for_each_inferior (&all_threads,
+ clear_pending_status_callback);
+
+ if (tracing)
+ {
+ if (disconnected_tracing)
+ {
+ /* Try to enable non-stop/async mode, so we we can
+ both wait for an async socket accept, and handle
+ async target events simultaneously. There's also
+ no point either in having the target always stop
+ all threads, when we're going to pass signals
+ down without informing GDB. */
+ if (!non_stop)
+ {
+ if (start_non_stop (1))
+ non_stop = 1;
+
+ /* Detaching implicitly resumes all threads;
+ simply disconnecting does not. */
+ }
+ }
+ else
+ {
+ fprintf (stderr,
+ "Disconnected tracing disabled; "
+ "stopping trace run.\n");
+ stop_tracing ();
+ }
+ }
+ }
+ CATCH (exception, RETURN_MASK_ERROR)
{
- /* An error occurred. */
+ fflush (stdout);
+ fprintf (stderr, "gdbserver: %s\n", exception.message);
+
if (response_needed)
{
write_enn (own_buf);
putpkt (own_buf);
}
+
+ if (run_once)
+ throw_quit ("Quit");
}
+ END_CATCH
+ }
+}
- /* Wait for events. This will return when all event sources are
- removed from the event loop. */
- start_event_loop ();
+/* Main function. */
- /* If an exit was requested (using the "monitor exit" command),
- terminate now. The only other way to get here is for
- getpkt to fail; close the connection and reopen it at the
- top of the loop. */
+int
+main (int argc, char *argv[])
+{
- if (exit_requested || run_once)
+ TRY
+ {
+ captured_main (argc, argv);
+ }
+ CATCH (exception, RETURN_MASK_ALL)
+ {
+ if (exception.reason == RETURN_ERROR)
{
- /* If something fails and longjmps while detaching or
- killing inferiors, we'd end up here again, stuck in an
- infinite loop trap. Be sure that if that happens, we
- exit immediately instead. */
- if (setjmp (toplevel) == 0)
- {
- detach_or_kill_for_exit ();
- exit (0);
- }
- else
- {
- fprintf (stderr, "Detach or kill failed. Exiting\n");
- exit (1);
- }
+ fflush (stdout);
+ fprintf (stderr, "%s\n", exception.message);
+ fprintf (stderr, "Exiting\n");
+ exit_code = 1;
}
- fprintf (stderr,
- "Remote side has terminated connection. "
- "GDBserver will reopen the connection.\n");
+ exit (exit_code);
+ }
+ END_CATCH
- if (tracing)
- {
- if (disconnected_tracing)
- {
- /* Try to enable non-stop/async mode, so we we can both
- wait for an async socket accept, and handle async
- target events simultaneously. There's also no point
- either in having the target always stop all threads,
- when we're going to pass signals down without
- informing GDB. */
- if (!non_stop)
- {
- if (start_non_stop (1))
- non_stop = 1;
+ gdb_assert_not_reached ("captured_main should never return");
+}
- /* Detaching implicitly resumes all threads; simply
- disconnecting does not. */
- }
- }
- else
- {
- fprintf (stderr,
- "Disconnected tracing disabled; stopping trace run.\n");
- stop_tracing ();
- }
- }
- }
+/* Skip PACKET until the next semi-colon (or end of string). */
+
+static void
+skip_to_semicolon (char **packet)
+{
+ while (**packet != '\0' && **packet != ';')
+ (*packet)++;
}
-/* Process options coming from Z packets for *point at address
- POINT_ADDR. PACKET is the packet buffer. *PACKET is updated
- to point to the first char after the last processed option. */
+/* Process options coming from Z packets for a breakpoint. PACKET is
+ the packet buffer. *PACKET is updated to point to the first char
+ after the last processed option. */
static void
-process_point_options (CORE_ADDR point_addr, char **packet)
+process_point_options (struct breakpoint *bp, char **packet)
{
char *dataptr = *packet;
int persist;
{
/* Conditional expression. */
if (debug_threads)
- fprintf (stderr, "Found breakpoint condition.\n");
- add_breakpoint_condition (point_addr, &dataptr);
+ debug_printf ("Found breakpoint condition.\n");
+ if (!add_breakpoint_condition (bp, &dataptr))
+ skip_to_semicolon (&dataptr);
}
- else if (strncmp (dataptr, "cmds:", strlen ("cmds:")) == 0)
+ else if (startswith (dataptr, "cmds:"))
{
dataptr += strlen ("cmds:");
if (debug_threads)
- fprintf (stderr, "Found breakpoint commands %s.\n", dataptr);
+ debug_printf ("Found breakpoint commands %s.\n", dataptr);
persist = (*dataptr == '1');
dataptr += 2;
- add_breakpoint_commands (point_addr, &dataptr, persist);
+ if (add_breakpoint_commands (bp, &dataptr, persist))
+ skip_to_semicolon (&dataptr);
}
else
{
fprintf (stderr, "Unknown token %c, ignoring.\n",
*dataptr);
/* Skip tokens until we find one that we recognize. */
- while (*dataptr && *dataptr != ';')
- dataptr++;
+ skip_to_semicolon (&dataptr);
}
}
*packet = dataptr;
if (!non_stop)
{
if (debug_threads)
- fprintf (stderr, "Forcing non-stop mode\n");
+ debug_printf ("Forcing non-stop mode\n");
non_stop = 1;
start_non_stop (1);
write_enn (own_buf);
else
{
- discard_queued_stop_replies (pid);
+ discard_queued_stop_replies (pid_to_ptid (pid));
write_ok (own_buf);
if (extended_protocol)
last_status.value.integer = 0;
last_ptid = pid_to_ptid (pid);
- current_inferior = NULL;
+ current_thread = NULL;
}
else
{
break;
}
- thread_id = ((struct inferior_list_entry *)thread)->id;
+ thread_id = thread->entry.id;
}
else
{
(struct thread_info *) find_inferior_id (&all_threads,
general_thread);
if (thread == NULL)
- thread_id = all_threads.head->id;
+ thread = get_first_thread ();
+ thread_id = thread->entry.id;
}
general_thread = thread_id;
- set_desired_inferior (1);
+ set_desired_thread (1);
+ gdb_assert (current_thread != NULL);
}
else if (own_buf[1] == 'c')
cont_thread = thread_id;
{
struct regcache *regcache;
- set_desired_inferior (1);
- regcache = get_thread_regcache (current_inferior, 1);
- registers_to_string (regcache, own_buf);
+ if (!set_desired_thread (1))
+ write_enn (own_buf);
+ else
+ {
+ regcache = get_thread_regcache (current_thread, 1);
+ registers_to_string (regcache, own_buf);
+ }
}
break;
case 'G':
{
struct regcache *regcache;
- set_desired_inferior (1);
- regcache = get_thread_regcache (current_inferior, 1);
- registers_from_string (regcache, &own_buf[1]);
- write_ok (own_buf);
+ if (!set_desired_thread (1))
+ write_enn (own_buf);
+ else
+ {
+ regcache = get_thread_regcache (current_thread, 1);
+ registers_from_string (regcache, &own_buf[1]);
+ write_ok (own_buf);
+ }
}
break;
case 'm':
if (res < 0)
write_enn (own_buf);
else
- convert_int_to_ascii (mem_buf, own_buf, res);
+ bin2hex (mem_buf, own_buf, res);
break;
case 'M':
require_running (own_buf);
break;
case 'C':
require_running (own_buf);
- convert_ascii_to_int (own_buf + 1, &sig, 1);
+ hex2bin (own_buf + 1, &sig, 1);
if (gdb_signal_to_host_p (sig))
signal = gdb_signal_to_host (sig);
else
break;
case 'S':
require_running (own_buf);
- convert_ascii_to_int (own_buf + 1, &sig, 1);
+ hex2bin (own_buf + 1, &sig, 1);
if (gdb_signal_to_host_p (sig))
signal = gdb_signal_to_host (sig);
else
p = unpack_varlen_hex (p, &addr);
len = strtol (p + 1, &dataptr, 16);
- /* Default to unrecognized/unsupported. */
- res = 1;
- switch (type)
+ if (insert)
{
- case '0': /* software-breakpoint */
- case '1': /* hardware-breakpoint */
- case '2': /* write watchpoint */
- case '3': /* read watchpoint */
- case '4': /* access watchpoint */
- require_running (own_buf);
- if (insert && the_target->insert_point != NULL)
+ struct breakpoint *bp;
+
+ bp = set_gdb_breakpoint (type, addr, len, &res);
+ if (bp != NULL)
{
- /* Insert the breakpoint. If it is already inserted, nothing
- will take place. */
- res = (*the_target->insert_point) (type, addr, len);
-
- /* GDB may have sent us a list of *point parameters to be
- evaluated on the target's side. Read such list here. If we
- already have a list of parameters, GDB is telling us to drop
- that list and use this one instead. */
- if (!res && (type == '0' || type == '1'))
- {
- /* Remove previous conditions. */
- clear_gdb_breakpoint_conditions (addr);
- process_point_options (addr, &dataptr);
- }
+ res = 0;
+
+ /* GDB may have sent us a list of *point parameters to
+ be evaluated on the target's side. Read such list
+ here. If we already have a list of parameters, GDB
+ is telling us to drop that list and use this one
+ instead. */
+ clear_breakpoint_conditions_and_commands (bp);
+ process_point_options (bp, &dataptr);
}
- else if (!insert && the_target->remove_point != NULL)
- res = (*the_target->remove_point) (type, addr, len);
- break;
- default:
- break;
}
+ else
+ res = delete_gdb_breakpoint (type, addr, len);
if (res == 0)
write_ok (own_buf);
/* Wait till we are at 1st instruction in prog. */
if (program_argv != NULL)
- start_inferior (program_argv);
+ {
+ start_inferior (program_argv);
+ if (last_status.kind == TARGET_WAITKIND_STOPPED)
+ {
+ /* Stopped at the first instruction of the target
+ process. */
+ general_thread = last_ptid;
+ }
+ else
+ {
+ /* Something went wrong. */
+ general_thread = null_ptid;
+ }
+ }
else
{
last_status.kind = TARGET_WAITKIND_EXITED;
the whole vStopped list (until it gets an OK). */
if (QUEUE_is_empty (notif_event_p, notif_stop.queue))
{
- fprintf (stderr, "GDBserver exiting\n");
+ /* Be transparent when GDB is connected through stdio -- no
+ need to spam GDB's console. */
+ if (!remote_connection_is_stdio ())
+ fprintf (stderr, "GDBserver exiting\n");
remote_close ();
exit (0);
}
handle_serial_event (int err, gdb_client_data client_data)
{
if (debug_threads)
- fprintf (stderr, "handling possible serial event\n");
+ debug_printf ("handling possible serial event\n");
/* Really handle it. */
if (process_serial_event () < 0)
return -1;
- /* Be sure to not change the selected inferior behind GDB's back.
+ /* Be sure to not change the selected thread behind GDB's back.
Important in the non-stop mode asynchronous protocol. */
- set_desired_inferior (1);
+ set_desired_thread (1);
return 0;
}
handle_target_event (int err, gdb_client_data client_data)
{
if (debug_threads)
- fprintf (stderr, "handling possible target event\n");
+ debug_printf ("handling possible target event\n");
last_ptid = mywait (minus_one_ptid, &last_status,
TARGET_WNOHANG, 1);
- if (last_status.kind != TARGET_WAITKIND_IGNORE)
+ if (last_status.kind == TARGET_WAITKIND_NO_RESUMED)
+ {
+ /* No RSP support for this yet. */
+ }
+ else if (last_status.kind != TARGET_WAITKIND_IGNORE)
{
int pid = ptid_get_pid (last_ptid);
struct process_info *process = find_process_pid (pid);
/* We're reporting this thread as stopped. Update its
"want-stopped" state to what the client wants, until it
gets a new resume action. */
- current_inferior->last_resume_kind = resume_stop;
- current_inferior->last_status = last_status;
+ current_thread->last_resume_kind = resume_stop;
+ current_thread->last_status = last_status;
}
if (forward_event)
struct thread_resume resume_info;
if (debug_threads)
- fprintf (stderr,
- "GDB not connected; forwarding event %d for [%s]\n",
- (int) last_status.kind,
- target_pid_to_str (last_ptid));
+ debug_printf ("GDB not connected; forwarding event %d for"
+ " [%s]\n",
+ (int) last_status.kind,
+ target_pid_to_str (last_ptid));
resume_info.thread = last_ptid;
resume_info.kind = resume_continue;
(*the_target->resume) (&resume_info, 1);
}
else if (debug_threads)
- fprintf (stderr, "GDB not connected; ignoring event %d for [%s]\n",
- (int) last_status.kind,
- target_pid_to_str (last_ptid));
+ debug_printf ("GDB not connected; ignoring event %d for [%s]\n",
+ (int) last_status.kind,
+ target_pid_to_str (last_ptid));
}
else
{
- struct vstop_notif *vstop_notif
- = xmalloc (sizeof (struct vstop_notif));
+ struct vstop_notif *vstop_notif = XNEW (struct vstop_notif);
vstop_notif->status = last_status;
vstop_notif->ptid = last_ptid;
}
}
- /* Be sure to not change the selected inferior behind GDB's back.
+ /* Be sure to not change the selected thread behind GDB's back.
Important in the non-stop mode asynchronous protocol. */
- set_desired_inferior (1);
+ set_desired_thread (1);
return 0;
}
projects / deliverable / binutils-gdb.git / blobdiff