/* Remote target communications for serial-line targets in custom GDB protocol
- Copyright (C) 1988-2020 Free Software Foundation, Inc.
+ Copyright (C) 1988-2022 Free Software Foundation, Inc.
This file is part of GDB.
#include <signal.h>
#include "serial.h"
-#include "gdbcore.h" /* for exec_bfd */
+#include "gdbcore.h"
#include "remote-fileio.h"
#include "gdb/fileio.h"
#include "gdbsupport/scoped_restore.h"
#include "gdbsupport/environ.h"
#include "gdbsupport/byte-vector.h"
+#include "gdbsupport/search.h"
#include <algorithm>
#include <unordered_map>
#include "async-event.h"
+#include "gdbsupport/selftest.h"
/* The remote target. */
Specify the serial device it is connected to\n\
(e.g. /dev/ttyS0, /dev/ttya, COM1, etc.).");
+/* See remote.h */
+
+bool remote_debug = false;
+
#define OPAQUETHREADBYTES 8
/* a 64 bit opaque identifier */
Otherwise zero, meaning to use the guessed size. */
long explicit_packet_size = 0;
- /* remote_wait is normally called when the target is running and
- waits for a stop reply packet. But sometimes we need to call it
- when the target is already stopped. We can send a "?" packet
- and have remote_wait read the response. Or, if we already have
- the response, we can stash it in BUF and tell remote_wait to
- skip calling getpkt. This flag is set when BUF contains a
- stop reply packet and the target is not waiting. */
- int cached_wait_status = 0;
-
/* True, if in no ack mode. That is, neither GDB nor the stub will
expect acks from each other. The connection is assumed to be
reliable. */
static const target_info remote_target_info = {
"remote",
- N_("Remote serial target in gdb-specific protocol"),
+ N_("Remote target using gdb-specific protocol"),
remote_doc
};
void detach (inferior *, int) override;
void disconnect (const char *, int) override;
- void commit_resume () override;
+ void commit_resumed () override;
void resume (ptid_t, int, enum gdb_signal) override;
ptid_t wait (ptid_t, struct target_waitstatus *, target_wait_flags) override;
+ bool has_pending_events () override;
void fetch_registers (struct regcache *, int) override;
void store_registers (struct regcache *, int) override;
void prepare_to_store (struct regcache *) override;
- void files_info () override;
-
int insert_breakpoint (struct gdbarch *, struct bp_target_info *) override;
int remove_breakpoint (struct gdbarch *, struct bp_target_info *,
const char *extra_thread_info (struct thread_info *) override;
- ptid_t get_ada_task_ptid (long lwp, long thread) override;
+ ptid_t get_ada_task_ptid (long lwp, ULONGEST thread) override;
thread_info *thread_handle_to_thread_info (const gdb_byte *thread_handle,
int handle_len,
bool use_agent (bool use) override;
bool can_use_agent () override;
- struct btrace_target_info *enable_btrace (ptid_t ptid,
- const struct btrace_config *conf) override;
+ struct btrace_target_info *
+ enable_btrace (thread_info *tp, const struct btrace_config *conf) override;
void disable_btrace (struct btrace_target_info *tinfo) override;
const struct btrace_config *btrace_conf (const struct btrace_target_info *) override;
bool augmented_libraries_svr4_read () override;
- bool follow_fork (bool, bool) override;
- void follow_exec (struct inferior *, const char *) override;
+ void follow_fork (inferior *, ptid_t, target_waitkind, bool, bool) override;
+ void follow_exec (inferior *, ptid_t, const char *) override;
int insert_fork_catchpoint (int) override;
int remove_fork_catchpoint (int) override;
int insert_vfork_catchpoint (int) override;
int remove_exec_catchpoint (int) override;
enum exec_direction_kind execution_direction () override;
+ bool supports_memory_tagging () override;
+
+ bool fetch_memtags (CORE_ADDR address, size_t len,
+ gdb::byte_vector &tags, int type) override;
+
+ bool store_memtags (CORE_ADDR address, size_t len,
+ const gdb::byte_vector &tags, int type) override;
+
public: /* Remote specific methods. */
void remote_download_command_source (int num, ULONGEST addr,
ULONGEST offset, int *remote_errno);
int remote_hostio_send_command (int command_bytes, int which_packet,
- int *remote_errno, char **attachment,
+ int *remote_errno, const char **attachment,
int *attachment_len);
int remote_hostio_set_filesystem (struct inferior *inf,
int *remote_errno);
int remote_resume_with_vcont (ptid_t ptid, int step,
gdb_signal siggnal);
- void add_current_inferior_and_thread (char *wait_status);
+ thread_info *add_current_inferior_and_thread (const char *wait_status);
ptid_t wait_ns (ptid_t ptid, struct target_waitstatus *status,
target_wait_flags options);
ptid_t process_stop_reply (struct stop_reply *stop_reply,
target_waitstatus *status);
- void remote_notice_new_inferior (ptid_t currthread, int executing);
+ ptid_t select_thread_for_ambiguous_stop_reply
+ (const struct target_waitstatus &status);
+ void remote_notice_new_inferior (ptid_t currthread, bool executing);
+
+ void print_one_stopped_thread (thread_info *thread);
void process_initial_stop_replies (int from_tty);
- thread_info *remote_add_thread (ptid_t ptid, bool running, bool executing);
+ thread_info *remote_add_thread (ptid_t ptid, bool running, bool executing,
+ bool silent_p);
void btrace_sync_conf (const btrace_config *conf);
void remote_btrace_maybe_reopen ();
void remove_new_fork_children (threads_listing_context *context);
- void kill_new_fork_children (int pid);
+ void kill_new_fork_children (inferior *inf);
void discard_pending_stop_replies (struct inferior *inf);
int stop_reply_queue_length ();
void check_pending_events_prevent_wildcard_vcont
- (int *may_global_wildcard_vcont);
+ (bool *may_global_wildcard_vcont);
void discard_pending_stop_replies_in_queue ();
struct stop_reply *remote_notif_remove_queued_reply (ptid_t ptid);
int try_open_exec);
ptid_t remote_current_thread (ptid_t oldpid);
- ptid_t get_current_thread (char *wait_status);
+ ptid_t get_current_thread (const char *wait_status);
void set_thread (ptid_t ptid, int gen);
void set_general_thread (ptid_t ptid);
char *write_ptid (char *buf, const char *endbuf, ptid_t ptid);
- int remote_unpack_thread_info_response (char *pkt, threadref *expectedref,
+ int remote_unpack_thread_info_response (const char *pkt, threadref *expectedref,
gdb_ext_thread_info *info);
int remote_get_threadinfo (threadref *threadid, int fieldset,
gdb_ext_thread_info *info);
- int parse_threadlist_response (char *pkt, int result_limit,
+ int parse_threadlist_response (const char *pkt, int result_limit,
threadref *original_echo,
threadref *resultlist,
int *doneflag);
bool vcont_r_supported ();
- void packet_command (const char *args, int from_tty);
+private:
-private: /* data fields */
+ bool start_remote_1 (int from_tty, int extended_p);
/* The remote state. Don't reference this directly. Use the
get_remote_state method instead. */
static const target_info extended_remote_target_info = {
"extended-remote",
- N_("Extended remote serial target in gdb-specific protocol"),
+ N_("Extended remote target using gdb-specific protocol"),
remote_doc
};
bool supports_disable_randomization () override;
};
+struct stop_reply : public notif_event
+{
+ ~stop_reply ();
+
+ /* The identifier of the thread about this event */
+ ptid_t ptid;
+
+ /* The remote state this event is associated with. When the remote
+ connection, represented by a remote_state object, is closed,
+ all the associated stop_reply events should be released. */
+ struct remote_state *rs;
+
+ struct target_waitstatus ws;
+
+ /* The architecture associated with the expedited registers. */
+ gdbarch *arch;
+
+ /* Expedited registers. This makes remote debugging a bit more
+ efficient for those targets that provide critical registers as
+ part of their normal status mechanism (as another roundtrip to
+ fetch them is avoided). */
+ std::vector<cached_reg_t> regcache;
+
+ enum target_stop_reason stop_reason;
+
+ CORE_ADDR watch_data_address;
+
+ int core;
+};
+
+/* See remote.h. */
+
+bool
+is_remote_target (process_stratum_target *target)
+{
+ remote_target *rt = dynamic_cast<remote_target *> (target);
+ return rt != nullptr;
+}
+
/* Per-program-space data key. */
static const struct program_space_key<char, gdb::xfree_deleter<char>>
remote_pspace_data;
remote exec-file commands. While the remote exec-file setting is
per-program-space, the set/show machinery uses this as the
location of the remote exec-file value. */
-static char *remote_exec_file_var;
+static std::string remote_exec_file_var;
/* The size to align memory write packets, when practical. The protocol
does not guarantee any alignment, and gdb will generate short
static CORE_ADDR remote_address_masked (CORE_ADDR);
-static void print_packet (const char *);
-
-static int stub_unpack_int (char *buff, int fieldlength);
+static int stub_unpack_int (const char *buff, int fieldlength);
struct packet_config;
-static void show_packet_config_cmd (struct packet_config *config);
-
static void show_remote_protocol_packet_cmd (struct ui_file *file,
int from_tty,
struct cmd_list_element *c,
static bool use_range_stepping = true;
+/* From the remote target's point of view, each thread is in one of these three
+ states. */
+enum class resume_state
+{
+ /* Not resumed - we haven't been asked to resume this thread. */
+ NOT_RESUMED,
+
+ /* We have been asked to resume this thread, but haven't sent a vCont action
+ for it yet. We'll need to consider it next time commit_resume is
+ called. */
+ RESUMED_PENDING_VCONT,
+
+ /* We have been asked to resume this thread, and we have sent a vCont action
+ for it. */
+ RESUMED,
+};
+
+/* Information about a thread's pending vCont-resume. Used when a thread is in
+ the remote_resume_state::RESUMED_PENDING_VCONT state. remote_target::resume
+ stores this information which is then picked up by
+ remote_target::commit_resume to know which is the proper action for this
+ thread to include in the vCont packet. */
+struct resumed_pending_vcont_info
+{
+ /* True if the last resume call for this thread was a step request, false
+ if a continue request. */
+ bool step;
+
+ /* The signal specified in the last resume call for this thread. */
+ gdb_signal sig;
+};
+
/* Private data that we'll store in (struct thread_info)->priv. */
struct remote_thread_info : public private_thread_info
{
to stop for a watchpoint. */
CORE_ADDR watch_data_address = 0;
- /* Fields used by the vCont action coalescing implemented in
- remote_resume / remote_commit_resume. remote_resume stores each
- thread's last resume request in these fields, so that a later
- remote_commit_resume knows which is the proper action for this
- thread to include in the vCont packet. */
+ /* Get the thread's resume state. */
+ enum resume_state get_resume_state () const
+ {
+ return m_resume_state;
+ }
- /* True if the last target_resume call for this thread was a step
- request, false if a continue request. */
- int last_resume_step = 0;
+ /* Put the thread in the NOT_RESUMED state. */
+ void set_not_resumed ()
+ {
+ m_resume_state = resume_state::NOT_RESUMED;
+ }
- /* The signal specified in the last target_resume call for this
- thread. */
- gdb_signal last_resume_sig = GDB_SIGNAL_0;
+ /* Put the thread in the RESUMED_PENDING_VCONT state. */
+ void set_resumed_pending_vcont (bool step, gdb_signal sig)
+ {
+ m_resume_state = resume_state::RESUMED_PENDING_VCONT;
+ m_resumed_pending_vcont_info.step = step;
+ m_resumed_pending_vcont_info.sig = sig;
+ }
+
+ /* Get the information this thread's pending vCont-resumption.
+
+ Must only be called if the thread is in the RESUMED_PENDING_VCONT resume
+ state. */
+ const struct resumed_pending_vcont_info &resumed_pending_vcont_info () const
+ {
+ gdb_assert (m_resume_state == resume_state::RESUMED_PENDING_VCONT);
+
+ return m_resumed_pending_vcont_info;
+ }
- /* Whether this thread was already vCont-resumed on the remote
- side. */
- int vcont_resumed = 0;
+ /* Put the thread in the VCONT_RESUMED state. */
+ void set_resumed ()
+ {
+ m_resume_state = resume_state::RESUMED;
+ }
+
+private:
+ /* Resume state for this thread. This is used to implement vCont action
+ coalescing (only when the target operates in non-stop mode).
+
+ remote_target::resume moves the thread to the RESUMED_PENDING_VCONT state,
+ which notes that this thread must be considered in the next commit_resume
+ call.
+
+ remote_target::commit_resume sends a vCont packet with actions for the
+ threads in the RESUMED_PENDING_VCONT state and moves them to the
+ VCONT_RESUMED state.
+
+ When reporting a stop to the core for a thread, that thread is moved back
+ to the NOT_RESUMED state. */
+ enum resume_state m_resume_state = resume_state::NOT_RESUMED;
+
+ /* Extra info used if the thread is in the RESUMED_PENDING_VCONT state. */
+ struct resumed_pending_vcont_info m_resumed_pending_vcont_info;
};
remote_state::remote_state ()
set_remote_exec_file (const char *ignored, int from_tty,
struct cmd_list_element *c)
{
- gdb_assert (remote_exec_file_var != NULL);
- set_pspace_remote_exec_file (current_program_space, remote_exec_file_var);
+ set_pspace_remote_exec_file (current_program_space,
+ remote_exec_file_var.c_str ());
}
/* The "set/show remote exec-file" show command hook. */
have an associated command always have this set to auto. */
enum auto_boolean detect;
+ /* The "show remote foo-packet" command created for this packet. */
+ cmd_list_element *show_cmd;
+
/* Does the target support this packet? */
enum packet_support support;
};
static enum packet_support packet_support (int packet);
static void
-show_packet_config_cmd (struct packet_config *config)
+show_packet_config_cmd (ui_file *file, struct packet_config *config)
{
const char *support = "internal-error";
switch (config->detect)
{
case AUTO_BOOLEAN_AUTO:
- printf_filtered (_("Support for the `%s' packet "
- "is auto-detected, currently %s.\n"),
- config->name, support);
+ fprintf_filtered (file,
+ _("Support for the `%s' packet "
+ "is auto-detected, currently %s.\n"),
+ config->name, support);
break;
case AUTO_BOOLEAN_TRUE:
case AUTO_BOOLEAN_FALSE:
- printf_filtered (_("Support for the `%s' packet is currently %s.\n"),
- config->name, support);
+ fprintf_filtered (file,
+ _("Support for the `%s' packet is currently %s.\n"),
+ config->name, support);
break;
}
}
add_packet_config_cmd (struct packet_config *config, const char *name,
const char *title, int legacy)
{
- char *set_doc;
- char *show_doc;
- char *cmd_name;
-
config->name = name;
config->title = title;
- set_doc = xstrprintf ("Set use of remote protocol `%s' (%s) packet.",
- name, title);
- show_doc = xstrprintf ("Show current use of remote "
- "protocol `%s' (%s) packet.",
- name, title);
+ gdb::unique_xmalloc_ptr<char> set_doc
+ = xstrprintf ("Set use of remote protocol `%s' (%s) packet.",
+ name, title);
+ gdb::unique_xmalloc_ptr<char> show_doc
+ = xstrprintf ("Show current use of remote protocol `%s' (%s) packet.",
+ name, title);
/* set/show TITLE-packet {auto,on,off} */
- cmd_name = xstrprintf ("%s-packet", title);
- add_setshow_auto_boolean_cmd (cmd_name, class_obscure,
- &config->detect, set_doc,
- show_doc, NULL, /* help_doc */
- NULL,
- show_remote_protocol_packet_cmd,
- &remote_set_cmdlist, &remote_show_cmdlist);
- /* The command code copies the documentation strings. */
- xfree (set_doc);
- xfree (show_doc);
+ gdb::unique_xmalloc_ptr<char> cmd_name = xstrprintf ("%s-packet", title);
+ set_show_commands cmds
+ = add_setshow_auto_boolean_cmd (cmd_name.release (), class_obscure,
+ &config->detect, set_doc.get (),
+ show_doc.get (), NULL, /* help_doc */
+ NULL,
+ show_remote_protocol_packet_cmd,
+ &remote_set_cmdlist, &remote_show_cmdlist);
+ config->show_cmd = cmds.show;
+
/* set/show remote NAME-packet {auto,on,off} -- legacy. */
if (legacy)
{
- char *legacy_name;
-
- legacy_name = xstrprintf ("%s-packet", name);
- add_alias_cmd (legacy_name, cmd_name, class_obscure, 0,
+ /* It's not clear who should take ownership of this string, so, for
+ now, make it static, and give copies to each of the add_alias_cmd
+ calls below. */
+ static gdb::unique_xmalloc_ptr<char> legacy_name
+ = xstrprintf ("%s-packet", name);
+ add_alias_cmd (legacy_name.get (), cmds.set, class_obscure, 0,
&remote_set_cmdlist);
- add_alias_cmd (legacy_name, cmd_name, class_obscure, 0,
+ add_alias_cmd (legacy_name.get (), cmds.show, class_obscure, 0,
&remote_show_cmdlist);
}
}
/* The stub recognized the packet request. */
if (config->support == PACKET_SUPPORT_UNKNOWN)
{
- if (remote_debug)
- fprintf_unfiltered (gdb_stdlog,
- "Packet %s (%s) is supported\n",
- config->name, config->title);
+ remote_debug_printf ("Packet %s (%s) is supported",
+ config->name, config->title);
config->support = PACKET_ENABLE;
}
break;
config->name, config->title);
}
- if (remote_debug)
- fprintf_unfiltered (gdb_stdlog,
- "Packet %s (%s) is NOT supported\n",
- config->name, config->title);
+ remote_debug_printf ("Packet %s (%s) is NOT supported",
+ config->name, config->title);
config->support = PACKET_DISABLE;
break;
}
/* Support TARGET_WAITKIND_NO_RESUMED. */
PACKET_no_resumed,
+ /* Support for memory tagging, allocation tag fetch/store
+ packets and the tag violation stop replies. */
+ PACKET_memory_tagging_feature,
+
PACKET_MAX
};
case AUTO_BOOLEAN_AUTO:
return config->support;
default:
- gdb_assert_not_reached (_("bad switch"));
+ gdb_assert_not_reached ("bad switch");
}
}
const char *value)
{
struct packet_config *packet;
+ gdb_assert (c->var.has_value ());
for (packet = remote_protocol_packets;
packet < &remote_protocol_packets[PACKET_MAX];
packet++)
{
- if (&packet->detect == c->var)
+ if (c == packet->show_cmd)
{
- show_packet_config_cmd (packet);
+ show_packet_config_cmd (file, packet);
return;
}
}
for (i = 0; i < NR_Z_PACKET_TYPES; i++)
{
- show_packet_config_cmd (&remote_protocol_packets[PACKET_Z0 + i]);
+ show_packet_config_cmd (file, &remote_protocol_packets[PACKET_Z0 + i]);
}
}
return packet_support (PACKET_exec_event_feature) == PACKET_ENABLE;
}
+/* Returns true if memory tagging is supported, false otherwise. */
+
+static bool
+remote_memory_tagging_p ()
+{
+ return packet_support (PACKET_memory_tagging_feature) == PACKET_ENABLE;
+}
+
/* Insert fork catchpoint target routine. If fork events are enabled
then return success, nothing more to do. */
inf = add_inferior_with_spaces ();
}
switch_to_inferior_no_thread (inf);
- push_target (this);
+ inf->push_target (this);
inferior_appeared (inf, pid);
}
ptid_t ptid);
/* Add thread PTID to GDB's thread list. Tag it as executing/running
- according to RUNNING. */
+ according to EXECUTING and RUNNING respectively. If SILENT_P (or the
+ remote_state::starting_up flag) is true then the new thread is added
+ silently, otherwise the new thread will be announced to the user. */
thread_info *
-remote_target::remote_add_thread (ptid_t ptid, bool running, bool executing)
+remote_target::remote_add_thread (ptid_t ptid, bool running, bool executing,
+ bool silent_p)
{
struct remote_state *rs = get_remote_state ();
struct thread_info *thread;
consider that a single-threaded target, mentioning a new thread
might be confusing to the user. Be silent then, preserving the
age old behavior. */
- if (rs->starting_up)
+ if (rs->starting_up || silent_p)
thread = add_thread_silent (this, ptid);
else
thread = add_thread (this, ptid);
- get_remote_thread_info (thread)->vcont_resumed = executing;
+ /* We start by assuming threads are resumed. That state then gets updated
+ when we process a matching stop reply. */
+ get_remote_thread_info (thread)->set_resumed ();
+
set_executing (this, ptid, executing);
set_running (this, ptid, running);
thread is (internally) executing or stopped. */
void
-remote_target::remote_notice_new_inferior (ptid_t currthread, int executing)
+remote_target::remote_notice_new_inferior (ptid_t currthread, bool executing)
{
/* In non-stop mode, we assume new found threads are (externally)
running until proven otherwise with a stop reply. In all-stop,
we can only get here if all threads are stopped. */
- int running = target_is_non_stop_p () ? 1 : 0;
+ bool running = target_is_non_stop_p ();
/* If this is a new thread, add it to GDB's thread list.
If we leave it up to WFI to do this, bad things will happen. */
{
/* We're seeing an event on a thread id we knew had exited.
This has to be a new thread reusing the old id. Add it. */
- remote_add_thread (currthread, running, executing);
+ remote_add_thread (currthread, running, executing, false);
return;
}
else
{
thread_info *thr
- = remote_add_thread (currthread, running, executing);
+ = remote_add_thread (currthread, running, executing, false);
switch_to_thread (thr);
}
return;
/* This is really a new thread. Add it. */
thread_info *new_thr
- = remote_add_thread (currthread, running, executing);
+ = remote_add_thread (currthread, running, executing, false);
/* If we found a new inferior, let the common code do whatever
it needs to with it (e.g., read shared libraries, insert
}
}
- if (remote_debug)
- {
- fprintf_unfiltered (gdb_stdlog,
- "remote_set_syscall_catchpoint "
- "pid %d needed %d any_count %d n_sysno %d\n",
- pid, needed, any_count, n_sysno);
- }
+ remote_debug_printf ("pid %d needed %d any_count %d n_sysno %d",
+ pid, needed, any_count, n_sysno);
std::string built_packet;
if (needed)
#define BUF_THREAD_ID_SIZE (OPAQUETHREADBYTES * 2)
-static char *unpack_nibble (char *buf, int *val);
+static const char *unpack_nibble (const char *buf, int *val);
-static char *unpack_byte (char *buf, int *value);
+static const char *unpack_byte (const char *buf, int *value);
static char *pack_int (char *buf, int value);
-static char *unpack_int (char *buf, int *value);
+static const char *unpack_int (const char *buf, int *value);
-static char *unpack_string (char *src, char *dest, int length);
+static const char *unpack_string (const char *src, char *dest, int length);
static char *pack_threadid (char *pkt, threadref *id);
-static char *unpack_threadid (char *inbuf, threadref *id);
+static const char *unpack_threadid (const char *inbuf, threadref *id);
void int_to_threadref (threadref *id, int value);
pp = unpack_varlen_hex (p + 1, &tid);
if (obuf)
*obuf = pp;
- return ptid_t (pid, tid, 0);
+ return ptid_t (pid, tid);
}
/* No multi-process. Just a tid. */
if (obuf)
*obuf = pp;
- return ptid_t (pid, tid, 0);
+ return ptid_t (pid, tid);
}
static int
}
static int
-stub_unpack_int (char *buff, int fieldlength)
+stub_unpack_int (const char *buff, int fieldlength)
{
int nibble;
int retval = 0;
return retval;
}
-static char *
-unpack_nibble (char *buf, int *val)
+static const char *
+unpack_nibble (const char *buf, int *val)
{
*val = fromhex (*buf++);
return buf;
}
-static char *
-unpack_byte (char *buf, int *value)
+static const char *
+unpack_byte (const char *buf, int *value)
{
*value = stub_unpack_int (buf, 2);
return buf + 2;
return buf;
}
-static char *
-unpack_int (char *buf, int *value)
+static const char *
+unpack_int (const char *buf, int *value)
{
*value = stub_unpack_int (buf, 8);
return buf + 8;
}
#endif /* 0 (unused) */
-static char *
-unpack_string (char *src, char *dest, int length)
+static const char *
+unpack_string (const char *src, char *dest, int length)
{
while (length--)
*dest++ = *src++;
}
-static char *
-unpack_threadid (char *inbuf, threadref *id)
+static const char *
+unpack_threadid (const char *inbuf, threadref *id)
{
char *altref;
- char *limit = inbuf + BUF_THREAD_ID_SIZE;
+ const char *limit = inbuf + BUF_THREAD_ID_SIZE;
int x, y;
altref = (char *) id;
the process. */
int
-remote_target::remote_unpack_thread_info_response (char *pkt,
+remote_target::remote_unpack_thread_info_response (const char *pkt,
threadref *expectedref,
gdb_ext_thread_info *info)
{
int mask, length;
int tag;
threadref ref;
- char *limit = pkt + rs->buf.size (); /* Plausible parsing limit. */
+ const char *limit = pkt + rs->buf.size (); /* Plausible parsing limit. */
int retval = 1;
/* info->threadid = 0; FIXME: implement zero_threadref. */
/* Encoding: 'q':8,'M':8,count:16,done:8,argthreadid:64,(threadid:64)* */
int
-remote_target::parse_threadlist_response (char *pkt, int result_limit,
+remote_target::parse_threadlist_response (const char *pkt, int result_limit,
threadref *original_echo,
threadref *resultlist,
int *doneflag)
{
struct remote_state *rs = get_remote_state ();
- char *limit;
int count, resultcount, done;
resultcount = 0;
/* Assume the 'q' and 'M chars have been stripped. */
- limit = pkt + (rs->buf.size () - BUF_THREAD_ID_SIZE);
+ const char *limit = pkt + (rs->buf.size () - BUF_THREAD_ID_SIZE);
/* done parse past here */
pkt = unpack_byte (pkt, &count); /* count field */
pkt = unpack_nibble (pkt, &done);
/* FIXME: This is a good reason to drop the packet. */
/* Possibly, there is a duplicate response. */
/* Possibilities :
- retransmit immediatly - race conditions
- retransmit after timeout - yes
- exit
- wait for packet, then exit
+ retransmit immediatly - race conditions
+ retransmit after timeout - yes
+ exit
+ wait for packet, then exit
*/
warning (_("HMM: threadlist did not echo arg thread, dropping it."));
return 0; /* I choose simply exiting. */
{
auto match_ptid = [&] (const thread_item &item)
{
- return item.ptid == ptid;
+ return item.ptid == ptid;
};
auto it = std::remove_if (this->items.begin (),
ptid_t result;
result = read_ptid (&rs->buf[2], &obuf);
- if (*obuf != '\0' && remote_debug)
- fprintf_unfiltered (gdb_stdlog,
- "warning: garbage in qC reply\n");
+ if (*obuf != '\0')
+ remote_debug_printf ("warning: garbage in qC reply");
return result;
}
executing until proven otherwise with a stop reply.
In all-stop, we can only get here if all threads are
stopped. */
- int executing = target_is_non_stop_p () ? 1 : 0;
+ bool executing = target_is_non_stop_p ();
remote_notice_new_inferior (item.ptid, executing);
/* Implement the to_get_ada_task_ptid function for the remote targets. */
ptid_t
-remote_target::get_ada_task_ptid (long lwp, long thread)
+remote_target::get_ada_task_ptid (long lwp, ULONGEST thread)
{
- return ptid_t (inferior_ptid.pid (), lwp, 0);
+ return ptid_t (inferior_ptid.pid (), lwp);
}
\f
int lose, num_segments = 0, do_sections, do_segments;
CORE_ADDR text_addr, data_addr, bss_addr, segments[2];
- if (symfile_objfile == NULL)
+ if (current_program_space->symfile_object_file == NULL)
return;
putpkt ("qOffsets");
else if (*ptr != '\0')
warning (_("Target reported unsupported offsets: %s"), buf);
- section_offsets offs = symfile_objfile->section_offsets;
+ objfile *objf = current_program_space->symfile_object_file;
+ section_offsets offs = objf->section_offsets;
- symfile_segment_data_up data
- = get_symfile_segment_data (symfile_objfile->obfd);
+ symfile_segment_data_up data = get_symfile_segment_data (objf->obfd);
do_segments = (data != NULL);
do_sections = num_segments == 0;
if (do_segments)
{
- int ret = symfile_map_offsets_to_segments (symfile_objfile->obfd,
+ int ret = symfile_map_offsets_to_segments (objf->obfd,
data.get (), offs,
num_segments, segments);
if (do_sections)
{
- offs[SECT_OFF_TEXT (symfile_objfile)] = text_addr;
+ offs[SECT_OFF_TEXT (objf)] = text_addr;
/* This is a temporary kludge to force data and bss to use the
same offsets because that's what nlmconv does now. The real
solution requires changes to the stub and remote.c that I
don't have time to do right now. */
- offs[SECT_OFF_DATA (symfile_objfile)] = data_addr;
- offs[SECT_OFF_BSS (symfile_objfile)] = data_addr;
+ offs[SECT_OFF_DATA (objf)] = data_addr;
+ offs[SECT_OFF_BSS (objf)] = data_addr;
}
- objfile_relocate (symfile_objfile, offs);
+ objfile_relocate (objf, offs);
}
/* Send interrupt_sequence to remote target. */
and extract the PTID. Returns NULL_PTID if not found. */
static ptid_t
-stop_reply_extract_thread (char *stop_reply)
+stop_reply_extract_thread (const char *stop_reply)
{
if (stop_reply[0] == 'T' && strlen (stop_reply) > 3)
{
method avoids a roundtrip. */
ptid_t
-remote_target::get_current_thread (char *wait_status)
+remote_target::get_current_thread (const char *wait_status)
{
ptid_t ptid = null_ptid;
whose response is a stop reply from which we can also try
extracting the thread. If the target doesn't support the explicit
qC query, we infer the current thread from that stop reply, passed
- in in WAIT_STATUS, which may be NULL. */
+ in in WAIT_STATUS, which may be NULL.
-void
-remote_target::add_current_inferior_and_thread (char *wait_status)
+ The function returns pointer to the main thread of the inferior. */
+
+thread_info *
+remote_target::add_current_inferior_and_thread (const char *wait_status)
{
struct remote_state *rs = get_remote_state ();
bool fake_pid_p = false;
yet. */
thread_info *tp = add_thread_silent (this, curr_ptid);
switch_to_thread_no_regs (tp);
+
+ return tp;
}
/* Print info about a thread that was found already stopped on
connection. */
-static void
-print_one_stopped_thread (struct thread_info *thread)
+void
+remote_target::print_one_stopped_thread (thread_info *thread)
{
- struct target_waitstatus *ws = &thread->suspend.waitstatus;
+ target_waitstatus ws;
+
+ /* If there is a pending waitstatus, use it. If there isn't it's because
+ the thread's stop was reported with TARGET_WAITKIND_STOPPED / GDB_SIGNAL_0
+ and process_initial_stop_replies decided it wasn't interesting to save
+ and report to the core. */
+ if (thread->has_pending_waitstatus ())
+ {
+ ws = thread->pending_waitstatus ();
+ thread->clear_pending_waitstatus ();
+ }
+ else
+ {
+ ws.set_stopped (GDB_SIGNAL_0);
+ }
switch_to_thread (thread);
- thread->suspend.stop_pc = get_frame_pc (get_current_frame ());
+ thread->set_stop_pc (get_frame_pc (get_current_frame ()));
set_current_sal_from_frame (get_current_frame ());
- thread->suspend.waitstatus_pending_p = 0;
+ /* For "info program". */
+ set_last_target_status (this, thread->ptid, ws);
- if (ws->kind == TARGET_WAITKIND_STOPPED)
+ if (ws.kind () == TARGET_WAITKIND_STOPPED)
{
- enum gdb_signal sig = ws->value.sig;
+ enum gdb_signal sig = ws.sig ();
if (signal_print_state (sig))
gdb::observers::signal_received.notify (sig);
struct thread_info *lowest_stopped = NULL;
struct thread_info *first = NULL;
+ /* This is only used when the target is non-stop. */
+ gdb_assert (target_is_non_stop_p ());
+
/* Consume the initial pending events. */
while (pending_stop_replies-- > 0)
{
struct target_waitstatus ws;
int ignore_event = 0;
- memset (&ws, 0, sizeof (ws));
event_ptid = target_wait (waiton_ptid, &ws, TARGET_WNOHANG);
if (remote_debug)
- print_target_wait_results (waiton_ptid, event_ptid, &ws);
+ print_target_wait_results (waiton_ptid, event_ptid, ws);
- switch (ws.kind)
+ switch (ws.kind ())
{
case TARGET_WAITKIND_IGNORE:
case TARGET_WAITKIND_NO_RESUMED:
case TARGET_WAITKIND_SIGNALLED:
case TARGET_WAITKIND_EXITED:
/* We shouldn't see these, but if we do, just ignore. */
- if (remote_debug)
- fprintf_unfiltered (gdb_stdlog, "remote: event ignored\n");
+ remote_debug_printf ("event ignored");
ignore_event = 1;
break;
- case TARGET_WAITKIND_EXECD:
- xfree (ws.value.execd_pathname);
- break;
default:
break;
}
thread_info *evthread = find_thread_ptid (this, event_ptid);
- if (ws.kind == TARGET_WAITKIND_STOPPED)
+ if (ws.kind () == TARGET_WAITKIND_STOPPED)
{
- enum gdb_signal sig = ws.value.sig;
+ enum gdb_signal sig = ws.sig ();
/* Stubs traditionally report SIGTRAP as initial signal,
instead of signal 0. Suppress it. */
if (sig == GDB_SIGNAL_TRAP)
sig = GDB_SIGNAL_0;
- evthread->suspend.stop_signal = sig;
- ws.value.sig = sig;
+ evthread->set_stop_signal (sig);
+ ws.set_stopped (sig);
}
- evthread->suspend.waitstatus = ws;
-
- if (ws.kind != TARGET_WAITKIND_STOPPED
- || ws.value.sig != GDB_SIGNAL_0)
- evthread->suspend.waitstatus_pending_p = 1;
+ if (ws.kind () != TARGET_WAITKIND_STOPPED
+ || ws.sig () != GDB_SIGNAL_0)
+ evthread->set_pending_waitstatus (ws);
set_executing (this, event_ptid, false);
set_running (this, event_ptid, false);
- get_remote_thread_info (evthread)->vcont_resumed = 0;
+ get_remote_thread_info (evthread)->set_not_resumed ();
}
/* "Notice" the new inferiors before anything related to
the inferiors. */
if (!non_stop)
{
- stop_all_threads ();
+ {
+ /* At this point, the remote target is not async. It needs to be for
+ the poll in stop_all_threads to consider events from it, so enable
+ it temporarily. */
+ gdb_assert (!this->is_async_p ());
+ SCOPE_EXIT { target_async (0); };
+ target_async (1);
+ stop_all_threads ();
+ }
/* If all threads of an inferior were already stopped, we
haven't setup the inferior yet. */
else if (thread->state != THREAD_STOPPED)
continue;
- if (selected == NULL
- && thread->suspend.waitstatus_pending_p)
+ if (selected == nullptr && thread->has_pending_waitstatus ())
selected = thread;
if (lowest_stopped == NULL
print_one_stopped_thread (thread);
}
-
- /* For "info program". */
- thread_info *thread = inferior_thread ();
- if (thread->state == THREAD_STOPPED)
- set_last_target_status (this, inferior_ptid, thread->suspend.waitstatus);
}
-/* Start the remote connection and sync state. */
+/* Mark a remote_target as marking (by setting the starting_up flag within
+ its remote_state) for the lifetime of this object. The reference count
+ on the remote target is temporarily incremented, to prevent the target
+ being deleted under our feet. */
-void
-remote_target::start_remote (int from_tty, int extended_p)
+struct scoped_mark_target_starting
{
+ /* Constructor, TARGET is the target to be marked as starting, its
+ reference count will be incremented. */
+ scoped_mark_target_starting (remote_target *target)
+ : m_remote_target (target)
+ {
+ m_remote_target->incref ();
+ remote_state *rs = m_remote_target->get_remote_state ();
+ rs->starting_up = true;
+ }
+
+ /* Destructor, mark the target being worked on as no longer starting, and
+ decrement the reference count. */
+ ~scoped_mark_target_starting ()
+ {
+ remote_state *rs = m_remote_target->get_remote_state ();
+ rs->starting_up = false;
+ decref_target (m_remote_target);
+ }
+
+private:
+
+ /* The target on which we are operating. */
+ remote_target *m_remote_target;
+};
+
+/* Helper for remote_target::start_remote, start the remote connection and
+ sync state. Return true if everything goes OK, otherwise, return false.
+ This function exists so that the scoped_restore created within it will
+ expire before we return to remote_target::start_remote. */
+
+bool
+remote_target::start_remote_1 (int from_tty, int extended_p)
+{
+ REMOTE_SCOPED_DEBUG_ENTER_EXIT;
+
struct remote_state *rs = get_remote_state ();
struct packet_config *noack_config;
- char *wait_status = NULL;
/* Signal other parts that we're going through the initial setup,
and so things may not be stable yet. E.g., we don't try to
Ctrl-C before we're connected and synced up can't interrupt the
target. Instead, it offers to drop the (potentially wedged)
connection. */
- rs->starting_up = 1;
+ scoped_mark_target_starting target_is_starting (this);
QUIT;
if (!target_is_non_stop_p ())
{
+ char *wait_status = NULL;
+
if (rs->buf[0] == 'W' || rs->buf[0] == 'X')
{
if (!extended_p)
error (_("The target is not running (try extended-remote?)"));
-
- /* We're connected, but not running. Drop out before we
- call start_remote. */
- rs->starting_up = 0;
- return;
+ return false;
}
else
{
/* Target has no concept of threads at all. GDB treats
non-threaded target as single-threaded; add a main
thread. */
- add_current_inferior_and_thread (wait_status);
+ thread_info *tp = add_current_inferior_and_thread (wait_status);
+ get_remote_thread_info (tp)->set_resumed ();
}
else
{
tell us which thread was current (no "thread"
register in T stop reply?). Just pick the first
thread in the thread list then. */
-
- if (remote_debug)
- fprintf_unfiltered (gdb_stdlog,
- "warning: couldn't determine remote "
- "current thread; picking first in list.\n");
+
+ remote_debug_printf ("warning: couldn't determine remote "
+ "current thread; picking first in list.");
for (thread_info *tp : all_non_exited_threads (this,
minus_one_ptid))
/* Use the previously fetched status. */
gdb_assert (wait_status != NULL);
- strcpy (rs->buf.data (), wait_status);
- rs->cached_wait_status = 1;
+ struct notif_event *reply
+ = remote_notif_parse (this, ¬if_client_stop, wait_status);
+ push_stop_reply ((struct stop_reply *) reply);
::start_remote (from_tty); /* Initialize gdb process mechanisms. */
}
{
if (!extended_p)
error (_("The target is not running (try extended-remote?)"));
-
- /* We're connected, but not running. Drop out before we
- call start_remote. */
- rs->starting_up = 0;
- return;
+ return false;
}
- /* In non-stop mode, any cached wait status will be stored in
- the stop reply queue. */
- gdb_assert (wait_status == NULL);
-
/* Report all signals during attach/startup. */
pass_signals ({});
/* If we connected to a live target, do some additional setup. */
if (target_has_execution ())
{
- if (symfile_objfile) /* No use without a symbol-file. */
+ /* No use without a symbol-file. */
+ if (current_program_space->symfile_object_file)
remote_check_symbols ();
}
previously; find out where things are at. */
remote_btrace_maybe_reopen ();
- /* The thread and inferior lists are now synchronized with the
- target, our symbols have been relocated, and we're merged the
- target's tracepoints with ours. We're done with basic start
- up. */
- rs->starting_up = 0;
+ return true;
+}
+
+/* Start the remote connection and sync state. */
- /* Maybe breakpoints are global and need to be inserted now. */
- if (breakpoints_should_be_inserted_now ())
+void
+remote_target::start_remote (int from_tty, int extended_p)
+{
+ if (start_remote_1 (from_tty, extended_p)
+ && breakpoints_should_be_inserted_now ())
insert_breakpoints ();
}
/* If this is a function address, return the start of code
instead of any data function descriptor. */
- sym_addr = gdbarch_convert_from_func_ptr_addr (target_gdbarch (),
- sym_addr,
- current_top_target ());
+ sym_addr = gdbarch_convert_from_func_ptr_addr
+ (target_gdbarch (), sym_addr, current_inferior ()->top_target ());
xsnprintf (msg.data (), get_remote_packet_size (), "qSymbol:%s:%s",
phex_nz (sym_addr, addr_size), &reply[8]);
{ "vContSupported", PACKET_DISABLE, remote_supported_packet, PACKET_vContSupported },
{ "QThreadEvents", PACKET_DISABLE, remote_supported_packet, PACKET_QThreadEvents },
{ "no-resumed", PACKET_DISABLE, remote_supported_packet, PACKET_no_resumed },
+ { "memory-tagging", PACKET_DISABLE, remote_supported_packet,
+ PACKET_memory_tagging_feature },
};
static char *remote_support_xml;
if (packet_set_cmd_state (PACKET_no_resumed) != AUTO_BOOLEAN_FALSE)
remote_query_supported_append (&q, "no-resumed+");
+ if (packet_set_cmd_state (PACKET_memory_tagging_feature)
+ != AUTO_BOOLEAN_FALSE)
+ remote_query_supported_append (&q, "memory-tagging+");
+
/* Keep this one last to work around a gdbserver <= 7.10 bug in
the qSupported:xmlRegisters=i386 handling. */
if (remote_support_xml != NULL
pop_all_targets_at_and_above (process_stratum);
generic_mourn_inferior ();
}
+
+ /* Don't rely on target_close doing this when the target is popped
+ from the last remote inferior above, because something may be
+ holding a reference to the target higher up on the stack, meaning
+ target_close won't be called yet. We lost the connection to the
+ target, so clear these now, otherwise we may later throw
+ TARGET_CLOSE_ERROR while trying to tell the remote target to
+ close the file. */
+ fileio_handles_invalidate_target (target);
}
static void
remote_fileio_reset ();
reopen_exec_file ();
- reread_symbols ();
+ reread_symbols (from_tty);
remote_target *remote
= (extended_p ? new extended_remote_target () : new remote_target ());
}
/* Switch to using the remote target now. */
- push_target (std::move (target_holder));
+ current_inferior ()->push_target (std::move (target_holder));
/* Register extra event sources in the event loop. */
rs->remote_async_inferior_event_token
- = create_async_event_handler (remote_async_inferior_event_handler, remote,
+ = create_async_event_handler (remote_async_inferior_event_handler, nullptr,
"remote");
rs->notif_state = remote_notif_state_allocate (remote);
/* Reset the target state; these things will be queried either by
remote_query_supported or as they are needed. */
reset_all_packet_configs_support ();
- rs->cached_wait_status = 0;
rs->explicit_packet_size = 0;
rs->noack_mode = 0;
rs->extended = extended_p;
rs->wait_forever_enabled_p = 1;
}
+/* Determine if WS represents a fork status. */
+
+static bool
+is_fork_status (target_waitkind kind)
+{
+ return (kind == TARGET_WAITKIND_FORKED
+ || kind == TARGET_WAITKIND_VFORKED);
+}
+
+/* Return THREAD's pending status if it is a pending fork parent, else
+ return nullptr. */
+
+static const target_waitstatus *
+thread_pending_fork_status (struct thread_info *thread)
+{
+ const target_waitstatus &ws
+ = (thread->has_pending_waitstatus ()
+ ? thread->pending_waitstatus ()
+ : thread->pending_follow);
+
+ if (!is_fork_status (ws.kind ()))
+ return nullptr;
+
+ return &ws;
+}
+
/* Detach the specified process. */
void
target_announce_detach (from_tty);
+ if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
+ {
+ /* If we're in breakpoints-always-inserted mode, or the inferior
+ is running, we have to remove breakpoints before detaching.
+ We don't do this in common code instead because not all
+ targets support removing breakpoints while the target is
+ running. The remote target / gdbserver does, though. */
+ remove_breakpoints_inf (current_inferior ());
+ }
+
/* Tell the remote target to detach. */
remote_detach_pid (pid);
if (from_tty && !rs->extended && number_of_live_inferiors (this) == 1)
puts_filtered (_("Ending remote debugging.\n"));
+ /* See if any thread of the inferior we are detaching has a pending fork
+ status. In that case, we must detach from the child resulting from
+ that fork. */
+ for (thread_info *thread : inf->non_exited_threads ())
+ {
+ const target_waitstatus *ws = thread_pending_fork_status (thread);
+
+ if (ws == nullptr)
+ continue;
+
+ remote_detach_pid (ws->child_ptid ().pid ());
+ }
+
+ /* Check also for any pending fork events in the stop reply queue. */
+ remote_notif_get_pending_events (¬if_client_stop);
+ for (stop_reply_up &reply : rs->stop_reply_queue)
+ {
+ if (reply->ptid.pid () != pid)
+ continue;
+
+ if (!is_fork_status (reply->ws.kind ()))
+ continue;
+
+ remote_detach_pid (reply->ws.child_ptid ().pid ());
+ }
+
thread_info *tp = find_thread_ptid (this, inferior_ptid);
/* Check to see if we are detaching a fork parent. Note that if we
are detaching a fork child, tp == NULL. */
is_fork_parent = (tp != NULL
- && tp->pending_follow.kind == TARGET_WAITKIND_FORKED);
+ && tp->pending_follow.kind () == TARGET_WAITKIND_FORKED);
/* If doing detach-on-fork, we don't mourn, because that will delete
breakpoints that should be available for the followed inferior. */
it is named remote_follow_fork in anticipation of using it for the
remote target as well. */
-bool
-remote_target::follow_fork (bool follow_child, bool detach_fork)
+void
+remote_target::follow_fork (inferior *child_inf, ptid_t child_ptid,
+ target_waitkind fork_kind, bool follow_child,
+ bool detach_fork)
{
+ process_stratum_target::follow_fork (child_inf, child_ptid,
+ fork_kind, follow_child, detach_fork);
+
struct remote_state *rs = get_remote_state ();
- enum target_waitkind kind = inferior_thread ()->pending_follow.kind;
- if ((kind == TARGET_WAITKIND_FORKED && remote_fork_event_p (rs))
- || (kind == TARGET_WAITKIND_VFORKED && remote_vfork_event_p (rs)))
+ if ((fork_kind == TARGET_WAITKIND_FORKED && remote_fork_event_p (rs))
+ || (fork_kind == TARGET_WAITKIND_VFORKED && remote_vfork_event_p (rs)))
{
/* When following the parent and detaching the child, we detach
the child here. For the case of following the child and
if (detach_fork && !follow_child)
{
/* Detach the fork child. */
- ptid_t child_ptid;
- pid_t child_pid;
-
- child_ptid = inferior_thread ()->pending_follow.value.related_pid;
- child_pid = child_ptid.pid ();
-
- remote_detach_pid (child_pid);
+ remote_detach_pid (child_ptid.pid ());
}
}
-
- return false;
}
/* Target follow-exec function for remote targets. Save EXECD_PATHNAME
- in the program space of the new inferior. On entry and at return the
- current inferior is the exec'ing inferior. INF is the new exec'd
- inferior, which may be the same as the exec'ing inferior unless
- follow-exec-mode is "new". */
+ in the program space of the new inferior. */
void
-remote_target::follow_exec (struct inferior *inf, const char *execd_pathname)
+remote_target::follow_exec (inferior *follow_inf, ptid_t ptid,
+ const char *execd_pathname)
{
+ process_stratum_target::follow_exec (follow_inf, ptid, execd_pathname);
+
/* We know that this is a target file name, so if it has the "target:"
prefix we strip it off before saving it in the program space. */
if (is_target_filename (execd_pathname))
execd_pathname += strlen (TARGET_SYSROOT_PREFIX);
- set_pspace_remote_exec_file (inf->pspace, execd_pathname);
+ set_pspace_remote_exec_file (follow_inf->pspace, execd_pathname);
}
/* Same as remote_detach, but don't send the "D" packet; just disconnect. */
if (packet_support (PACKET_vAttach) == PACKET_DISABLE)
error (_("This target does not support attaching to a process"));
- if (from_tty)
- {
- const char *exec_file = get_exec_file (0);
-
- if (exec_file)
- printf_unfiltered (_("Attaching to program: %s, %s\n"), exec_file,
- target_pid_to_str (ptid_t (pid)).c_str ());
- else
- printf_unfiltered (_("Attaching to %s\n"),
- target_pid_to_str (ptid_t (pid)).c_str ());
- }
+ target_announce_attach (from_tty, pid);
xsnprintf (rs->buf.data (), get_remote_packet_size (), "vAttach;%x", pid);
putpkt (rs->buf);
ptid. */
ptid_t curr_ptid = remote_current_thread (ptid_t (pid));
- /* Add the main thread to the thread list. */
- thread_info *thr = add_thread_silent (this, curr_ptid);
+ /* Add the main thread to the thread list. We add the thread
+ silently in this case (the final true parameter). */
+ thread_info *thr = remote_add_thread (curr_ptid, true, true, true);
switch_to_thread (thr);
-
- /* Don't consider the thread stopped until we've processed the
- saved stop reply. */
- set_executing (this, thr->ptid, true);
}
/* Next, if the target can specify a description, read it. We do
/* Use the previously fetched status. */
gdb_assert (wait_status != NULL);
- if (target_can_async_p ())
- {
- struct notif_event *reply
- = remote_notif_parse (this, ¬if_client_stop, wait_status);
-
- push_stop_reply ((struct stop_reply *) reply);
+ struct notif_event *reply
+ = remote_notif_parse (this, ¬if_client_stop, wait_status);
- target_async (1);
- }
- else
- {
- gdb_assert (wait_status != NULL);
- strcpy (rs->buf.data (), wait_status);
- rs->cached_wait_status = 1;
- }
+ push_stop_reply ((struct stop_reply *) reply);
}
else
- gdb_assert (wait_status == NULL);
+ {
+ gdb_assert (wait_status == NULL);
+
+ gdb_assert (target_can_async_p ());
+ }
}
/* Implementation of the to_post_attach method. */
binary is not using shared libraries, the vsyscall page is not
present (on Linux) and the binary itself hadn't changed since the
debugging process was started. */
- if (symfile_objfile != NULL)
+ if (current_program_space->symfile_object_file != NULL)
remote_check_symbols();
}
ptid_t nptid;
/* All (-1) threads of process. */
- nptid = ptid_t (ptid.pid (), -1, 0);
+ nptid = ptid_t (ptid.pid (), -1);
p += xsnprintf (p, endp - p, ":");
p = write_ptid (p, endp, nptid);
{
for (thread_info *thread : all_non_exited_threads (this, ptid))
if (inferior_ptid != thread->ptid
- && thread->suspend.stop_signal != GDB_SIGNAL_0)
+ && thread->stop_signal () != GDB_SIGNAL_0)
{
p = append_resumption (p, endp, thread->ptid,
- 0, thread->suspend.stop_signal);
- thread->suspend.stop_signal = GDB_SIGNAL_0;
+ 0, thread->stop_signal ());
+ thread->set_stop_signal (GDB_SIGNAL_0);
resume_clear_thread_private_info (thread);
}
individually. Resuming remote threads directly in target_resume
would thus result in sending one packet per thread. Instead, to
minimize roundtrip latency, here we just store the resume
- request; the actual remote resumption will be done in
- target_commit_resume / remote_commit_resume, where we'll be able
- to do vCont action coalescing. */
+ request (put the thread in RESUMED_PENDING_VCONT state); the actual remote
+ resumption will be done in remote_target::commit_resume, where we'll be
+ able to do vCont action coalescing. */
if (target_is_non_stop_p () && ::execution_direction != EXEC_REVERSE)
{
remote_thread_info *remote_thr;
else
remote_thr = get_remote_thread_info (this, ptid);
- remote_thr->last_resume_step = step;
- remote_thr->last_resume_sig = siggnal;
+ /* We don't expect the core to ask to resume an already resumed (from
+ its point of view) thread. */
+ gdb_assert (remote_thr->get_resume_state () == resume_state::NOT_RESUMED);
+
+ remote_thr->set_resumed_pending_vcont (step, siggnal);
return;
}
if (!remote_resume_with_vcont (ptid, step, siggnal))
remote_resume_with_hc (ptid, step, siggnal);
- /* We are about to start executing the inferior, let's register it
- with the event loop. NOTE: this is the one place where all the
- execution commands end up. We could alternatively do this in each
- of the execution commands in infcmd.c. */
- /* FIXME: ezannoni 1999-09-28: We may need to move this out of here
- into infcmd.c in order to allow inferior function calls to work
- NOT asynchronously. */
- if (target_can_async_p ())
- target_async (1);
+ /* Update resumed state tracked by the remote target. */
+ for (thread_info *tp : all_non_exited_threads (this, ptid))
+ get_remote_thread_info (tp)->set_resumed ();
/* We've just told the target to resume. The remote server will
wait for the inferior to stop, and then send a stop reply. In
rs->waiting_for_stop_reply = 1;
}
-static int is_pending_fork_parent_thread (struct thread_info *thread);
-
/* Private per-inferior info for target remote processes. */
struct remote_inferior : public private_inferior
/* to_commit_resume implementation. */
void
-remote_target::commit_resume ()
+remote_target::commit_resumed ()
{
- int any_process_wildcard;
- int may_global_wildcard_vcont;
-
/* If connected in all-stop mode, we'd send the remote resume
request directly from remote_resume. Likewise if
reverse-debugging, as there are no defined vCont actions for
(vCont;c). We can still send process-wide wildcards though. */
/* Start by assuming a global wildcard (vCont;c) is possible. */
- may_global_wildcard_vcont = 1;
+ bool may_global_wildcard_vcont = true;
/* And assume every process is individually wildcard-able too. */
for (inferior *inf : all_non_exited_inferiors (this))
disable process and global wildcard resumes appropriately. */
check_pending_events_prevent_wildcard_vcont (&may_global_wildcard_vcont);
+ bool any_pending_vcont_resume = false;
+
for (thread_info *tp : all_non_exited_threads (this))
{
+ remote_thread_info *priv = get_remote_thread_info (tp);
+
/* If a thread of a process is not meant to be resumed, then we
can't wildcard that process. */
- if (!tp->executing)
+ if (priv->get_resume_state () == resume_state::NOT_RESUMED)
{
get_remote_inferior (tp->inf)->may_wildcard_vcont = false;
/* And if we can't wildcard a process, we can't wildcard
everything either. */
- may_global_wildcard_vcont = 0;
+ may_global_wildcard_vcont = false;
continue;
}
+ if (priv->get_resume_state () == resume_state::RESUMED_PENDING_VCONT)
+ any_pending_vcont_resume = true;
+
/* If a thread is the parent of an unfollowed fork, then we
can't do a global wildcard, as that would resume the fork
child. */
- if (is_pending_fork_parent_thread (tp))
- may_global_wildcard_vcont = 0;
+ if (thread_pending_fork_status (tp) != nullptr)
+ may_global_wildcard_vcont = false;
}
+ /* We didn't have any resumed thread pending a vCont resume, so nothing to
+ do. */
+ if (!any_pending_vcont_resume)
+ return;
+
/* Now let's build the vCont packet(s). Actions must be appended
from narrower to wider scopes (thread -> process -> global). If
we end up with too many actions for a single packet vcont_builder
{
remote_thread_info *remote_thr = get_remote_thread_info (tp);
- if (!tp->executing || remote_thr->vcont_resumed)
+ /* If the thread was previously vCont-resumed, no need to send a specific
+ action for it. If we didn't receive a resume request for it, don't
+ send an action for it either. */
+ if (remote_thr->get_resume_state () != resume_state::RESUMED_PENDING_VCONT)
continue;
gdb_assert (!thread_is_in_step_over_chain (tp));
- if (!remote_thr->last_resume_step
- && remote_thr->last_resume_sig == GDB_SIGNAL_0
- && get_remote_inferior (tp->inf)->may_wildcard_vcont)
- {
- /* We'll send a wildcard resume instead. */
- remote_thr->vcont_resumed = 1;
- continue;
- }
+ /* We should never be commit-resuming a thread that has a stop reply.
+ Otherwise, we would end up reporting a stop event for a thread while
+ it is running on the remote target. */
+ remote_state *rs = get_remote_state ();
+ for (const auto &stop_reply : rs->stop_reply_queue)
+ gdb_assert (stop_reply->ptid != tp->ptid);
+
+ const resumed_pending_vcont_info &info
+ = remote_thr->resumed_pending_vcont_info ();
- vcont_builder.push_action (tp->ptid,
- remote_thr->last_resume_step,
- remote_thr->last_resume_sig);
- remote_thr->vcont_resumed = 1;
+ /* Check if we need to send a specific action for this thread. If not,
+ it will be included in a wildcard resume instead. */
+ if (info.step || info.sig != GDB_SIGNAL_0
+ || !get_remote_inferior (tp->inf)->may_wildcard_vcont)
+ vcont_builder.push_action (tp->ptid, info.step, info.sig);
+
+ remote_thr->set_resumed ();
}
/* Now check whether we can send any process-wide wildcard. This is
to avoid sending a global wildcard in the case nothing is
supposed to be resumed. */
- any_process_wildcard = 0;
+ bool any_process_wildcard = false;
for (inferior *inf : all_non_exited_inferiors (this))
{
if (get_remote_inferior (inf)->may_wildcard_vcont)
{
- any_process_wildcard = 1;
+ any_process_wildcard = true;
break;
}
}
vcont_builder.flush ();
}
+/* Implementation of target_has_pending_events. */
+
+bool
+remote_target::has_pending_events ()
+{
+ if (target_can_async_p ())
+ {
+ remote_state *rs = get_remote_state ();
+
+ if (async_event_handler_marked (rs->remote_async_inferior_event_token))
+ return true;
+
+ /* Note that BUFCNT can be negative, indicating sticky
+ error. */
+ if (rs->remote_desc->bufcnt != 0)
+ return true;
+ }
+ return false;
+}
+
\f
/* Non-stop version of target_stop. Uses `vCont;t' to stop a remote
char *p = rs->buf.data ();
char *endp = p + get_remote_packet_size ();
+ /* If any thread that needs to stop was resumed but pending a vCont
+ resume, generate a phony stop_reply. However, first check
+ whether the thread wasn't resumed with a signal. Generating a
+ phony stop in that case would result in losing the signal. */
+ bool needs_commit = false;
+ for (thread_info *tp : all_non_exited_threads (this, ptid))
+ {
+ remote_thread_info *remote_thr = get_remote_thread_info (tp);
+
+ if (remote_thr->get_resume_state ()
+ == resume_state::RESUMED_PENDING_VCONT)
+ {
+ const resumed_pending_vcont_info &info
+ = remote_thr->resumed_pending_vcont_info ();
+ if (info.sig != GDB_SIGNAL_0)
+ {
+ /* This signal must be forwarded to the inferior. We
+ could commit-resume just this thread, but its simpler
+ to just commit-resume everything. */
+ needs_commit = true;
+ break;
+ }
+ }
+ }
+
+ if (needs_commit)
+ commit_resumed ();
+ else
+ for (thread_info *tp : all_non_exited_threads (this, ptid))
+ {
+ remote_thread_info *remote_thr = get_remote_thread_info (tp);
+
+ if (remote_thr->get_resume_state ()
+ == resume_state::RESUMED_PENDING_VCONT)
+ {
+ remote_debug_printf ("Enqueueing phony stop reply for thread pending "
+ "vCont-resume (%d, %ld, %s)", tp->ptid.pid(),
+ tp->ptid.lwp (),
+ pulongest (tp->ptid.tid ()));
+
+ /* Check that the thread wasn't resumed with a signal.
+ Generating a phony stop would result in losing the
+ signal. */
+ const resumed_pending_vcont_info &info
+ = remote_thr->resumed_pending_vcont_info ();
+ gdb_assert (info.sig == GDB_SIGNAL_0);
+
+ stop_reply *sr = new stop_reply ();
+ sr->ptid = tp->ptid;
+ sr->rs = rs;
+ sr->ws.set_stopped (GDB_SIGNAL_0);
+ sr->arch = tp->inf->gdbarch;
+ sr->stop_reason = TARGET_STOPPED_BY_NO_REASON;
+ sr->watch_data_address = 0;
+ sr->core = 0;
+ this->push_stop_reply (sr);
+
+ /* Pretend that this thread was actually resumed on the
+ remote target, then stopped. If we leave it in the
+ RESUMED_PENDING_VCONT state and the commit_resumed
+ method is called while the stop reply is still in the
+ queue, we'll end up reporting a stop event to the core
+ for that thread while it is running on the remote
+ target... that would be bad. */
+ remote_thr->set_resumed ();
+ }
+ }
+
/* FIXME: This supports_vCont_probed check is a workaround until
packet_support is per-connection. */
if (packet_support (PACKET_vCont) == PACKET_SUPPORT_UNKNOWN
if (ptid.is_pid ())
/* All (-1) threads of process. */
- nptid = ptid_t (ptid.pid (), -1, 0);
+ nptid = ptid_t (ptid.pid (), -1);
else
{
/* Small optimization: if we already have a stop reply for
rs->ctrlc_pending_p = 1;
/* If the inferior is stopped already, but the core didn't know
- about it yet, just ignore the request. The cached wait status
+ about it yet, just ignore the request. The pending stop events
will be collected in remote_wait. */
- if (rs->cached_wait_status)
+ if (stop_reply_queue_length () > 0)
return;
/* Send interrupt_sequence to remote target. */
void
remote_target::stop (ptid_t ptid)
{
- if (remote_debug)
- fprintf_unfiltered (gdb_stdlog, "remote_stop called\n");
+ REMOTE_SCOPED_DEBUG_ENTER_EXIT;
if (target_is_non_stop_p ())
remote_stop_ns (ptid);
void
remote_target::interrupt ()
{
- if (remote_debug)
- fprintf_unfiltered (gdb_stdlog, "remote_interrupt called\n");
+ REMOTE_SCOPED_DEBUG_ENTER_EXIT;
if (target_is_non_stop_p ())
remote_interrupt_ns ();
void
remote_target::pass_ctrlc ()
{
- struct remote_state *rs = get_remote_state ();
+ REMOTE_SCOPED_DEBUG_ENTER_EXIT;
- if (remote_debug)
- fprintf_unfiltered (gdb_stdlog, "remote_pass_ctrlc called\n");
+ struct remote_state *rs = get_remote_state ();
/* If we're starting up, we're not fully synced yet. Quit
immediately. */
gdb_stdtarg->flush ();
}
-struct stop_reply : public notif_event
-{
- ~stop_reply ();
-
- /* The identifier of the thread about this event */
- ptid_t ptid;
-
- /* The remote state this event is associated with. When the remote
- connection, represented by a remote_state object, is closed,
- all the associated stop_reply events should be released. */
- struct remote_state *rs;
-
- struct target_waitstatus ws;
-
- /* The architecture associated with the expedited registers. */
- gdbarch *arch;
-
- /* Expedited registers. This makes remote debugging a bit more
- efficient for those targets that provide critical registers as
- part of their normal status mechanism (as another roundtrip to
- fetch them is avoided). */
- std::vector<cached_reg_t> regcache;
-
- enum target_stop_reason stop_reason;
-
- CORE_ADDR watch_data_address;
-
- int core;
-};
-
/* Return the length of the stop reply queue. */
int
/* acknowledge */
putpkt (remote, self->ack_command);
- if (stop_reply->ws.kind == TARGET_WAITKIND_IGNORE)
- {
- /* We got an unknown stop reply. */
- error (_("Unknown stop reply"));
- }
-
- remote->push_stop_reply (stop_reply);
+ /* Kind can be TARGET_WAITKIND_IGNORE if we have meanwhile discarded
+ the notification. It was left in the queue because we need to
+ acknowledge it and pull the rest of the notifications out. */
+ if (stop_reply->ws.kind () != TARGET_WAITKIND_IGNORE)
+ remote->push_stop_reply (stop_reply);
}
static int
REMOTE_NOTIF_STOP,
};
-/* Determine if THREAD_PTID is a pending fork parent thread. ARG contains
- the pid of the process that owns the threads we want to check, or
- -1 if we want to check all threads. */
-
-static int
-is_pending_fork_parent (struct target_waitstatus *ws, int event_pid,
- ptid_t thread_ptid)
-{
- if (ws->kind == TARGET_WAITKIND_FORKED
- || ws->kind == TARGET_WAITKIND_VFORKED)
- {
- if (event_pid == -1 || event_pid == thread_ptid.pid ())
- return 1;
- }
-
- return 0;
-}
-
-/* Return the thread's pending status used to determine whether the
- thread is a fork parent stopped at a fork event. */
-
-static struct target_waitstatus *
-thread_pending_fork_status (struct thread_info *thread)
-{
- if (thread->suspend.waitstatus_pending_p)
- return &thread->suspend.waitstatus;
- else
- return &thread->pending_follow;
-}
-
-/* Determine if THREAD is a pending fork parent thread. */
-
-static int
-is_pending_fork_parent_thread (struct thread_info *thread)
-{
- struct target_waitstatus *ws = thread_pending_fork_status (thread);
- int pid = -1;
-
- return is_pending_fork_parent (ws, pid, thread->ptid);
-}
-
/* If CONTEXT contains any fork child threads that have not been
reported yet, remove them from the CONTEXT list. If such a
thread exists it is because we are stopped at a fork catchpoint
void
remote_target::remove_new_fork_children (threads_listing_context *context)
{
- int pid = -1;
struct notif_client *notif = ¬if_client_stop;
/* For any threads stopped at a fork event, remove the corresponding
fork child threads from the CONTEXT list. */
for (thread_info *thread : all_non_exited_threads (this))
{
- struct target_waitstatus *ws = thread_pending_fork_status (thread);
+ const target_waitstatus *ws = thread_pending_fork_status (thread);
- if (is_pending_fork_parent (ws, pid, thread->ptid))
- context->remove_thread (ws->value.related_pid);
+ if (ws == nullptr)
+ continue;
+
+ context->remove_thread (ws->child_ptid ());
}
/* Check for any pending fork events (not reported or processed yet)
CONTEXT list as well. */
remote_notif_get_pending_events (notif);
for (auto &event : get_remote_state ()->stop_reply_queue)
- if (event->ws.kind == TARGET_WAITKIND_FORKED
- || event->ws.kind == TARGET_WAITKIND_VFORKED
- || event->ws.kind == TARGET_WAITKIND_THREAD_EXITED)
- context->remove_thread (event->ws.value.related_pid);
+ if (event->ws.kind () == TARGET_WAITKIND_FORKED
+ || event->ws.kind () == TARGET_WAITKIND_VFORKED
+ || event->ws.kind () == TARGET_WAITKIND_THREAD_EXITED)
+ context->remove_thread (event->ws.child_ptid ());
}
-/* Check whether any event pending in the vStopped queue would prevent
- a global or process wildcard vCont action. Clear
- *may_global_wildcard if we can't do a global wildcard (vCont;c),
- and clear the event inferior's may_wildcard_vcont flag if we can't
- do a process-wide wildcard resume (vCont;c:pPID.-1). */
+/* Check whether any event pending in the vStopped queue would prevent a
+ global or process wildcard vCont action. Set *may_global_wildcard to
+ false if we can't do a global wildcard (vCont;c), and clear the event
+ inferior's may_wildcard_vcont flag if we can't do a process-wide
+ wildcard resume (vCont;c:pPID.-1). */
void
remote_target::check_pending_events_prevent_wildcard_vcont
- (int *may_global_wildcard)
+ (bool *may_global_wildcard)
{
struct notif_client *notif = ¬if_client_stop;
remote_notif_get_pending_events (notif);
for (auto &event : get_remote_state ()->stop_reply_queue)
{
- if (event->ws.kind == TARGET_WAITKIND_NO_RESUMED
- || event->ws.kind == TARGET_WAITKIND_NO_HISTORY)
+ if (event->ws.kind () == TARGET_WAITKIND_NO_RESUMED
+ || event->ws.kind () == TARGET_WAITKIND_NO_HISTORY)
continue;
- if (event->ws.kind == TARGET_WAITKIND_FORKED
- || event->ws.kind == TARGET_WAITKIND_VFORKED)
- *may_global_wildcard = 0;
-
- struct inferior *inf = find_inferior_ptid (this, event->ptid);
+ if (event->ws.kind () == TARGET_WAITKIND_FORKED
+ || event->ws.kind () == TARGET_WAITKIND_VFORKED)
+ *may_global_wildcard = false;
/* This may be the first time we heard about this process.
Regardless, we must not do a global wildcard resume, otherwise
we'd resume this process too. */
- *may_global_wildcard = 0;
- if (inf != NULL)
- get_remote_inferior (inf)->may_wildcard_vcont = false;
+ *may_global_wildcard = false;
+ if (event->ptid != null_ptid)
+ {
+ inferior *inf = find_inferior_ptid (this, event->ptid);
+ if (inf != NULL)
+ get_remote_inferior (inf)->may_wildcard_vcont = false;
+ }
}
}
/* Discard the in-flight notification. */
if (reply != NULL && reply->ptid.pid () == inf->pid)
{
- delete reply;
- rns->pending_event[notif_client_stop.id] = NULL;
+ /* Leave the notification pending, since the server expects that
+ we acknowledge it with vStopped. But clear its contents, so
+ that later on when we acknowledge it, we also discard it. */
+ remote_debug_printf
+ ("discarding in-flight notification: ptid: %s, ws: %s\n",
+ reply->ptid.to_string().c_str(),
+ reply->ws.to_string ().c_str ());
+ reply->ws.set_ignore ();
}
/* Discard the stop replies we have already pulled with
{
return event->ptid.pid () == inf->pid;
});
+ for (auto it = iter; it != rs->stop_reply_queue.end (); ++it)
+ remote_debug_printf
+ ("discarding queued stop reply: ptid: %s, ws: %s\n",
+ reply->ptid.to_string().c_str(),
+ reply->ws.to_string ().c_str ());
rs->stop_reply_queue.erase (iter, rs->stop_reply_queue.end ());
}
if (notif_debug)
fprintf_unfiltered (gdb_stdlog,
"notif: discard queued event: 'Stop' in %s\n",
- target_pid_to_str (ptid).c_str ());
+ ptid.to_string ().c_str ());
return result;
}
remote_state *rs = get_remote_state ();
struct stop_reply *r = remote_notif_remove_queued_reply (ptid);
- if (!rs->stop_reply_queue.empty ())
+ if (!rs->stop_reply_queue.empty () && target_can_async_p ())
{
/* There's still at least an event left. */
mark_async_event_handler (rs->remote_async_inferior_event_token);
if (notif_debug)
fprintf_unfiltered (gdb_stdlog,
"notif: push 'Stop' %s to queue %d\n",
- target_pid_to_str (new_event->ptid).c_str (),
+ new_event->ptid.to_string ().c_str (),
int (rs->stop_reply_queue.size ()));
- mark_async_event_handler (rs->remote_async_inferior_event_token);
+ /* Mark the pending event queue only if async mode is currently enabled.
+ If async mode is not currently enabled, then, if it later becomes
+ enabled, and there are events in this queue, we will mark the event
+ token at that point, see remote_target::async. */
+ if (target_is_async_p ())
+ mark_async_event_handler (rs->remote_async_inferior_event_token);
}
/* Returns true if we have a stop reply for PTID. */
remote_state *rs = get_remote_state ();
for (auto &event : rs->stop_reply_queue)
if (ptid == event->ptid
- && event->ws.kind == TARGET_WAITKIND_STOPPED)
+ && event->ws.kind () == TARGET_WAITKIND_STOPPED)
return 1;
return 0;
}
event->ptid = null_ptid;
event->rs = get_remote_state ();
- event->ws.kind = TARGET_WAITKIND_IGNORE;
- event->ws.value.integer = 0;
+ event->ws.set_ignore ();
event->stop_reason = TARGET_STOPPED_BY_NO_REASON;
event->regcache.clear ();
event->core = -1;
{
ULONGEST sysno;
- event->ws.kind = TARGET_WAITKIND_SYSCALL_ENTRY;
p = unpack_varlen_hex (++p1, &sysno);
- event->ws.value.syscall_number = (int) sysno;
+ event->ws.set_syscall_entry ((int) sysno);
}
else if (strprefix (p, p1, "syscall_return"))
{
ULONGEST sysno;
- event->ws.kind = TARGET_WAITKIND_SYSCALL_RETURN;
p = unpack_varlen_hex (++p1, &sysno);
- event->ws.value.syscall_number = (int) sysno;
+ event->ws.set_syscall_return ((int) sysno);
}
else if (strprefix (p, p1, "watch")
|| strprefix (p, p1, "rwatch")
}
else if (strprefix (p, p1, "library"))
{
- event->ws.kind = TARGET_WAITKIND_LOADED;
+ event->ws.set_loaded ();
p = strchrnul (p1 + 1, ';');
}
else if (strprefix (p, p1, "replaylog"))
{
- event->ws.kind = TARGET_WAITKIND_NO_HISTORY;
+ event->ws.set_no_history ();
/* p1 will indicate "begin" or "end", but it makes
no difference for now, so ignore it. */
p = strchrnul (p1 + 1, ';');
event->core = c;
}
else if (strprefix (p, p1, "fork"))
- {
- event->ws.value.related_pid = read_ptid (++p1, &p);
- event->ws.kind = TARGET_WAITKIND_FORKED;
- }
+ event->ws.set_forked (read_ptid (++p1, &p));
else if (strprefix (p, p1, "vfork"))
- {
- event->ws.value.related_pid = read_ptid (++p1, &p);
- event->ws.kind = TARGET_WAITKIND_VFORKED;
- }
+ event->ws.set_vforked (read_ptid (++p1, &p));
else if (strprefix (p, p1, "vforkdone"))
{
- event->ws.kind = TARGET_WAITKIND_VFORK_DONE;
+ event->ws.set_vfork_done ();
p = strchrnul (p1 + 1, ';');
}
else if (strprefix (p, p1, "exec"))
/* Save the pathname for event reporting and for
the next run command. */
- gdb::unique_xmalloc_ptr<char[]> pathname
+ gdb::unique_xmalloc_ptr<char> pathname
((char *) xmalloc (pathlen + 1));
hex2bin (p1, (gdb_byte *) pathname.get (), pathlen);
- pathname[pathlen] = '\0';
+ pathname.get ()[pathlen] = '\0';
/* This is freed during event handling. */
- event->ws.value.execd_pathname = pathname.release ();
- event->ws.kind = TARGET_WAITKIND_EXECD;
+ event->ws.set_execd (std::move (pathname));
/* Skip the registers included in this packet, since
they may be for an architecture different from the
}
else if (strprefix (p, p1, "create"))
{
- event->ws.kind = TARGET_WAITKIND_THREAD_CREATED;
+ event->ws.set_thread_created ();
p = strchrnul (p1 + 1, ';');
}
else
++p;
}
- if (event->ws.kind != TARGET_WAITKIND_IGNORE)
+ if (event->ws.kind () != TARGET_WAITKIND_IGNORE)
break;
/* fall through */
{
int sig;
- event->ws.kind = TARGET_WAITKIND_STOPPED;
sig = (fromhex (buf[1]) << 4) + fromhex (buf[2]);
if (GDB_SIGNAL_FIRST <= sig && sig < GDB_SIGNAL_LAST)
- event->ws.value.sig = (enum gdb_signal) sig;
+ event->ws.set_stopped ((enum gdb_signal) sig);
else
- event->ws.value.sig = GDB_SIGNAL_UNKNOWN;
+ event->ws.set_stopped (GDB_SIGNAL_UNKNOWN);
}
break;
case 'w': /* Thread exited. */
{
ULONGEST value;
- event->ws.kind = TARGET_WAITKIND_THREAD_EXITED;
p = unpack_varlen_hex (&buf[1], &value);
- event->ws.value.integer = value;
+ event->ws.set_thread_exited (value);
if (*p != ';')
error (_("stop reply packet badly formatted: %s"), buf);
event->ptid = read_ptid (++p, NULL);
if (buf[0] == 'W')
{
/* The remote process exited. */
- event->ws.kind = TARGET_WAITKIND_EXITED;
- event->ws.value.integer = value;
+ event->ws.set_exited (value);
}
else
{
/* The remote process exited with a signal. */
- event->ws.kind = TARGET_WAITKIND_SIGNALLED;
if (GDB_SIGNAL_FIRST <= value && value < GDB_SIGNAL_LAST)
- event->ws.value.sig = (enum gdb_signal) value;
+ event->ws.set_signalled ((enum gdb_signal) value);
else
- event->ws.value.sig = GDB_SIGNAL_UNKNOWN;
+ event->ws.set_signalled (GDB_SIGNAL_UNKNOWN);
}
/* If no process is specified, return null_ptid, and let the
}
break;
case 'N':
- event->ws.kind = TARGET_WAITKIND_NO_RESUMED;
+ event->ws.set_no_resumed ();
event->ptid = minus_one_ptid;
break;
}
remote->remote_notif_get_pending_events (nc);
}
-/* Called when it is decided that STOP_REPLY holds the info of the
- event that is to be returned to the core. This function always
- destroys STOP_REPLY. */
+/* Called from process_stop_reply when the stop packet we are responding
+ to didn't include a process-id or thread-id. STATUS is the stop event
+ we are responding to.
+
+ It is the task of this function to select a suitable thread (or process)
+ and return its ptid, this is the thread (or process) we will assume the
+ stop event came from.
+
+ In some cases there isn't really any choice about which thread (or
+ process) is selected, a basic remote with a single process containing a
+ single thread might choose not to send any process-id or thread-id in
+ its stop packets, this function will select and return the one and only
+ thread.
+
+ However, if a target supports multiple threads (or processes) and still
+ doesn't include a thread-id (or process-id) in its stop packet then
+ first, this is a badly behaving target, and second, we're going to have
+ to select a thread (or process) at random and use that. This function
+ will print a warning to the user if it detects that there is the
+ possibility that GDB is guessing which thread (or process) to
+ report.
+
+ Note that this is called before GDB fetches the updated thread list from the
+ target. So it's possible for the stop reply to be ambiguous and for GDB to
+ not realize it. For example, if there's initially one thread, the target
+ spawns a second thread, and then sends a stop reply without an id that
+ concerns the first thread. GDB will assume the stop reply is about the
+ first thread - the only thread it knows about - without printing a warning.
+ Anyway, if the remote meant for the stop reply to be about the second thread,
+ then it would be really broken, because GDB doesn't know about that thread
+ yet. */
ptid_t
-remote_target::process_stop_reply (struct stop_reply *stop_reply,
- struct target_waitstatus *status)
+remote_target::select_thread_for_ambiguous_stop_reply
+ (const target_waitstatus &status)
{
- ptid_t ptid;
+ REMOTE_SCOPED_DEBUG_ENTER_EXIT;
- *status = stop_reply->ws;
- ptid = stop_reply->ptid;
+ /* Some stop events apply to all threads in an inferior, while others
+ only apply to a single thread. */
+ bool process_wide_stop
+ = (status.kind () == TARGET_WAITKIND_EXITED
+ || status.kind () == TARGET_WAITKIND_SIGNALLED);
- /* If no thread/process was reported by the stub then use the first
- non-exited thread in the current target. */
- if (ptid == null_ptid)
+ remote_debug_printf ("process_wide_stop = %d", process_wide_stop);
+
+ thread_info *first_resumed_thread = nullptr;
+ bool ambiguous = false;
+
+ /* Consider all non-exited threads of the target, find the first resumed
+ one. */
+ for (thread_info *thr : all_non_exited_threads (this))
{
- /* Some stop events apply to all threads in an inferior, while others
- only apply to a single thread. */
- bool is_stop_for_all_threads
- = (status->kind == TARGET_WAITKIND_EXITED
- || status->kind == TARGET_WAITKIND_SIGNALLED);
+ remote_thread_info *remote_thr = get_remote_thread_info (thr);
- for (thread_info *thr : all_non_exited_threads (this))
+ if (remote_thr->get_resume_state () != resume_state::RESUMED)
+ continue;
+
+ if (first_resumed_thread == nullptr)
+ first_resumed_thread = thr;
+ else if (!process_wide_stop
+ || first_resumed_thread->ptid.pid () != thr->ptid.pid ())
+ ambiguous = true;
+ }
+
+ gdb_assert (first_resumed_thread != nullptr);
+
+ remote_debug_printf ("first resumed thread is %s",
+ pid_to_str (first_resumed_thread->ptid).c_str ());
+ remote_debug_printf ("is this guess ambiguous? = %d", ambiguous);
+
+ /* Warn if the remote target is sending ambiguous stop replies. */
+ if (ambiguous)
+ {
+ static bool warned = false;
+
+ if (!warned)
{
- if (ptid != null_ptid
- && (!is_stop_for_all_threads
- || ptid.pid () != thr->ptid.pid ()))
- {
- static bool warned = false;
+ /* If you are seeing this warning then the remote target has
+ stopped without specifying a thread-id, but the target
+ does have multiple threads (or inferiors), and so GDB is
+ having to guess which thread stopped.
- if (!warned)
- {
- /* If you are seeing this warning then the remote target
- has stopped without specifying a thread-id, but the
- target does have multiple threads (or inferiors), and
- so GDB is having to guess which thread stopped.
-
- Examples of what might cause this are the target
- sending and 'S' stop packet, or a 'T' stop packet and
- not including a thread-id.
-
- Additionally, the target might send a 'W' or 'X
- packet without including a process-id, when the target
- has multiple running inferiors. */
- if (is_stop_for_all_threads)
- warning (_("multi-inferior target stopped without "
- "sending a process-id, using first "
- "non-exited inferior"));
- else
- warning (_("multi-threaded target stopped without "
- "sending a thread-id, using first "
- "non-exited thread"));
- warned = true;
- }
- break;
- }
+ Examples of what might cause this are the target sending
+ and 'S' stop packet, or a 'T' stop packet and not
+ including a thread-id.
- /* If this is a stop for all threads then don't use a particular
- threads ptid, instead create a new ptid where only the pid
- field is set. */
- if (is_stop_for_all_threads)
- ptid = ptid_t (thr->ptid.pid ());
+ Additionally, the target might send a 'W' or 'X packet
+ without including a process-id, when the target has
+ multiple running inferiors. */
+ if (process_wide_stop)
+ warning (_("multi-inferior target stopped without "
+ "sending a process-id, using first "
+ "non-exited inferior"));
else
- ptid = thr->ptid;
+ warning (_("multi-threaded target stopped without "
+ "sending a thread-id, using first "
+ "non-exited thread"));
+ warned = true;
}
- gdb_assert (ptid != null_ptid);
}
- if (status->kind != TARGET_WAITKIND_EXITED
- && status->kind != TARGET_WAITKIND_SIGNALLED
- && status->kind != TARGET_WAITKIND_NO_RESUMED)
+ /* If this is a stop for all threads then don't use a particular threads
+ ptid, instead create a new ptid where only the pid field is set. */
+ if (process_wide_stop)
+ return ptid_t (first_resumed_thread->ptid.pid ());
+ else
+ return first_resumed_thread->ptid;
+}
+
+/* Called when it is decided that STOP_REPLY holds the info of the
+ event that is to be returned to the core. This function always
+ destroys STOP_REPLY. */
+
+ptid_t
+remote_target::process_stop_reply (struct stop_reply *stop_reply,
+ struct target_waitstatus *status)
+{
+ *status = stop_reply->ws;
+ ptid_t ptid = stop_reply->ptid;
+
+ /* If no thread/process was reported by the stub then select a suitable
+ thread/process. */
+ if (ptid == null_ptid)
+ ptid = select_thread_for_ambiguous_stop_reply (*status);
+ gdb_assert (ptid != null_ptid);
+
+ if (status->kind () != TARGET_WAITKIND_EXITED
+ && status->kind () != TARGET_WAITKIND_SIGNALLED
+ && status->kind () != TARGET_WAITKIND_NO_RESUMED)
{
/* Expedited registers. */
if (!stop_reply->regcache.empty ())
stop_reply->regcache.clear ();
}
- remote_notice_new_inferior (ptid, 0);
+ remote_notice_new_inferior (ptid, false);
remote_thread_info *remote_thr = get_remote_thread_info (this, ptid);
remote_thr->core = stop_reply->core;
remote_thr->stop_reason = stop_reply->stop_reason;
remote_thr->watch_data_address = stop_reply->watch_data_address;
- remote_thr->vcont_resumed = 0;
+
+ if (target_is_non_stop_p ())
+ {
+ /* If the target works in non-stop mode, a stop-reply indicates that
+ only this thread stopped. */
+ remote_thr->set_not_resumed ();
+ }
+ else
+ {
+ /* If the target works in all-stop mode, a stop-reply indicates that
+ all the target's threads stopped. */
+ for (thread_info *tp : all_non_exited_threads (this))
+ get_remote_thread_info (tp)->set_not_resumed ();
+ }
}
delete stop_reply;
return to the event loop. */
if (options & TARGET_WNOHANG)
{
- status->kind = TARGET_WAITKIND_IGNORE;
+ status->set_ignore ();
return minus_one_ptid;
}
first_remote_resumed_thread (remote_target *target)
{
for (thread_info *tp : all_non_exited_threads (target, minus_one_ptid))
- if (tp->resumed)
+ if (tp->resumed ())
return tp->ptid;
return null_ptid;
}
again:
- status->kind = TARGET_WAITKIND_IGNORE;
- status->value.integer = 0;
+ status->set_ignore ();
stop_reply = queued_stop_reply (ptid);
if (stop_reply != NULL)
- return process_stop_reply (stop_reply, status);
-
- if (rs->cached_wait_status)
- /* Use the cached wait status, but only once. */
- rs->cached_wait_status = 0;
+ {
+ /* None of the paths that push a stop reply onto the queue should
+ have set the waiting_for_stop_reply flag. */
+ gdb_assert (!rs->waiting_for_stop_reply);
+ event_ptid = process_stop_reply (stop_reply, status);
+ }
else
{
- int ret;
- int is_notif;
int forever = ((options & TARGET_WNOHANG) == 0
&& rs->wait_forever_enabled_p);
if (!rs->waiting_for_stop_reply)
{
- status->kind = TARGET_WAITKIND_NO_RESUMED;
+ status->set_no_resumed ();
return minus_one_ptid;
}
_never_ wait for ever -> test on target_is_async_p().
However, before we do that we need to ensure that the caller
knows how to take the target into/out of async mode. */
- ret = getpkt_or_notif_sane (&rs->buf, forever, &is_notif);
+ int is_notif;
+ int ret = getpkt_or_notif_sane (&rs->buf, forever, &is_notif);
/* GDB gets a notification. Return to core as this event is
not interesting. */
if (ret == -1 && (options & TARGET_WNOHANG) != 0)
return minus_one_ptid;
- }
- buf = rs->buf.data ();
+ buf = rs->buf.data ();
- /* Assume that the target has acknowledged Ctrl-C unless we receive
- an 'F' or 'O' packet. */
- if (buf[0] != 'F' && buf[0] != 'O')
- rs->ctrlc_pending_p = 0;
+ /* Assume that the target has acknowledged Ctrl-C unless we receive
+ an 'F' or 'O' packet. */
+ if (buf[0] != 'F' && buf[0] != 'O')
+ rs->ctrlc_pending_p = 0;
- switch (buf[0])
- {
- case 'E': /* Error of some sort. */
- /* We're out of sync with the target now. Did it continue or
- not? Not is more likely, so report a stop. */
- rs->waiting_for_stop_reply = 0;
+ switch (buf[0])
+ {
+ case 'E': /* Error of some sort. */
+ /* We're out of sync with the target now. Did it continue or
+ not? Not is more likely, so report a stop. */
+ rs->waiting_for_stop_reply = 0;
- warning (_("Remote failure reply: %s"), buf);
- status->kind = TARGET_WAITKIND_STOPPED;
- status->value.sig = GDB_SIGNAL_0;
- break;
- case 'F': /* File-I/O request. */
- /* GDB may access the inferior memory while handling the File-I/O
- request, but we don't want GDB accessing memory while waiting
- for a stop reply. See the comments in putpkt_binary. Set
- waiting_for_stop_reply to 0 temporarily. */
- rs->waiting_for_stop_reply = 0;
- remote_fileio_request (this, buf, rs->ctrlc_pending_p);
- rs->ctrlc_pending_p = 0;
- /* GDB handled the File-I/O request, and the target is running
- again. Keep waiting for events. */
- rs->waiting_for_stop_reply = 1;
- break;
- case 'N': case 'T': case 'S': case 'X': case 'W':
- {
- /* There is a stop reply to handle. */
- rs->waiting_for_stop_reply = 0;
+ warning (_("Remote failure reply: %s"), buf);
+ status->set_stopped (GDB_SIGNAL_0);
+ break;
+ case 'F': /* File-I/O request. */
+ /* GDB may access the inferior memory while handling the File-I/O
+ request, but we don't want GDB accessing memory while waiting
+ for a stop reply. See the comments in putpkt_binary. Set
+ waiting_for_stop_reply to 0 temporarily. */
+ rs->waiting_for_stop_reply = 0;
+ remote_fileio_request (this, buf, rs->ctrlc_pending_p);
+ rs->ctrlc_pending_p = 0;
+ /* GDB handled the File-I/O request, and the target is running
+ again. Keep waiting for events. */
+ rs->waiting_for_stop_reply = 1;
+ break;
+ case 'N': case 'T': case 'S': case 'X': case 'W':
+ {
+ /* There is a stop reply to handle. */
+ rs->waiting_for_stop_reply = 0;
- stop_reply
- = (struct stop_reply *) remote_notif_parse (this,
- ¬if_client_stop,
- rs->buf.data ());
+ stop_reply
+ = (struct stop_reply *) remote_notif_parse (this,
+ ¬if_client_stop,
+ rs->buf.data ());
- event_ptid = process_stop_reply (stop_reply, status);
- break;
- }
- case 'O': /* Console output. */
- remote_console_output (buf + 1);
- break;
- case '\0':
- if (rs->last_sent_signal != GDB_SIGNAL_0)
- {
- /* Zero length reply means that we tried 'S' or 'C' and the
- remote system doesn't support it. */
- target_terminal::ours_for_output ();
- printf_filtered
- ("Can't send signals to this remote system. %s not sent.\n",
- gdb_signal_to_name (rs->last_sent_signal));
- rs->last_sent_signal = GDB_SIGNAL_0;
- target_terminal::inferior ();
-
- strcpy (buf, rs->last_sent_step ? "s" : "c");
- putpkt (buf);
+ event_ptid = process_stop_reply (stop_reply, status);
+ break;
+ }
+ case 'O': /* Console output. */
+ remote_console_output (buf + 1);
+ break;
+ case '\0':
+ if (rs->last_sent_signal != GDB_SIGNAL_0)
+ {
+ /* Zero length reply means that we tried 'S' or 'C' and the
+ remote system doesn't support it. */
+ target_terminal::ours_for_output ();
+ printf_filtered
+ ("Can't send signals to this remote system. %s not sent.\n",
+ gdb_signal_to_name (rs->last_sent_signal));
+ rs->last_sent_signal = GDB_SIGNAL_0;
+ target_terminal::inferior ();
+
+ strcpy (buf, rs->last_sent_step ? "s" : "c");
+ putpkt (buf);
+ break;
+ }
+ /* fallthrough */
+ default:
+ warning (_("Invalid remote reply: %s"), buf);
break;
}
- /* fallthrough */
- default:
- warning (_("Invalid remote reply: %s"), buf);
- break;
}
- if (status->kind == TARGET_WAITKIND_NO_RESUMED)
+ if (status->kind () == TARGET_WAITKIND_NO_RESUMED)
return minus_one_ptid;
- else if (status->kind == TARGET_WAITKIND_IGNORE)
+ else if (status->kind () == TARGET_WAITKIND_IGNORE)
{
/* Nothing interesting happened. If we're doing a non-blocking
poll, we're done. Otherwise, go back to waiting. */
else
goto again;
}
- else if (status->kind != TARGET_WAITKIND_EXITED
- && status->kind != TARGET_WAITKIND_SIGNALLED)
+ else if (status->kind () != TARGET_WAITKIND_EXITED
+ && status->kind () != TARGET_WAITKIND_SIGNALLED)
{
if (event_ptid != null_ptid)
record_currthread (rs, event_ptid);
remote_target::wait (ptid_t ptid, struct target_waitstatus *status,
target_wait_flags options)
{
+ REMOTE_SCOPED_DEBUG_ENTER_EXIT;
+
+ remote_state *rs = get_remote_state ();
+
+ /* Start by clearing the flag that asks for our wait method to be called,
+ we'll mark it again at the end if needed. If the target is not in
+ async mode then the async token should not be marked. */
+ if (target_is_async_p ())
+ clear_async_event_handler (rs->remote_async_inferior_event_token);
+ else
+ gdb_assert (!async_event_handler_marked
+ (rs->remote_async_inferior_event_token));
+
ptid_t event_ptid;
if (target_is_non_stop_p ())
if (target_is_async_p ())
{
- remote_state *rs = get_remote_state ();
-
- /* If there are are events left in the queue tell the event loop
- to return here. */
- if (!rs->stop_reply_queue.empty ())
+ /* If there are events left in the queue, or unacknowledged
+ notifications, then tell the event loop to call us again. */
+ if (!rs->stop_reply_queue.empty ()
+ || rs->notif_state->pending_event[notif_client_stop.id] != nullptr)
mark_async_event_handler (rs->remote_async_inferior_event_token);
}
getpkt (&rs->buf, 0);
if (packet_check_result (rs->buf) == PACKET_ERROR)
error (_("Could not read registers; remote failure reply '%s'"),
- rs->buf.data ());
+ rs->buf.data ());
/* We can get out of synch in various cases. If the first character
in the buffer is not a hex character, assume that has happened
&& (rs->buf[0] < 'a' || rs->buf[0] > 'f')
&& rs->buf[0] != 'x') /* New: unavailable register value. */
{
- if (remote_debug)
- fprintf_unfiltered (gdb_stdlog,
- "Bad register packet; fetching a new packet\n");
+ remote_debug_printf ("Bad register packet; fetching a new packet");
getpkt (&rs->buf, 0);
}
}
/* Looks valid enough, we can assume this is the correct length
- for a 'g' packet. It's important not to adjust
- rsa->sizeof_g_packet if we have truncated registers otherwise
- this "if" won't be run the next time the method is called
- with a packet of the same size and one of the internal errors
- below will trigger instead. */
+ for a 'g' packet. It's important not to adjust
+ rsa->sizeof_g_packet if we have truncated registers otherwise
+ this "if" won't be run the next time the method is called
+ with a packet of the same size and one of the internal errors
+ below will trigger instead. */
rsa->sizeof_g_packet = sizeof_g_packet;
}
&& address_size < (sizeof (ULONGEST) * 8))
{
/* Only create a mask when that mask can safely be constructed
- in a ULONGEST variable. */
+ in a ULONGEST variable. */
ULONGEST mask = 1;
mask = (mask << address_size) - 1;
if (rs->buf[0] == '\0')
{
- if (remote_debug)
- fprintf_unfiltered (gdb_stdlog,
- "binary downloading NOT "
- "supported by target\n");
+ remote_debug_printf ("binary downloading NOT supported by target");
remote_protocol_packets[PACKET_X].support = PACKET_DISABLE;
}
else
{
- if (remote_debug)
- fprintf_unfiltered (gdb_stdlog,
- "binary downloading supported by target\n");
+ remote_debug_printf ("binary downloading supported by target");
remote_protocol_packets[PACKET_X].support = PACKET_ENABLE;
}
break;
*p++ = ',';
/* Append the length and retain its location and size. It may need to be
- adjusted once the packet body has been created. */
+ adjusted once the packet body has been created. */
plen = p;
plenlen = hexnumstr (p, (ULONGEST) todo_units);
p += plenlen;
int unit_size,
ULONGEST *xfered_len)
{
- struct target_section *secp;
- struct target_section_table *table;
+ const struct target_section *secp;
secp = target_section_by_addr (this, memaddr);
if (secp != NULL
&& (bfd_section_flags (secp->the_bfd_section) & SEC_READONLY))
{
- struct target_section *p;
ULONGEST memend = memaddr + len;
- table = target_get_section_table (this);
-
- for (p = table->sections; p < table->sections_end; p++)
+ const target_section_table *table = target_get_section_table (this);
+ for (const target_section &p : *table)
{
- if (memaddr >= p->addr)
+ if (memaddr >= p.addr)
{
- if (memend <= p->endaddr)
+ if (memend <= p.endaddr)
{
/* Entire transfer is within this section. */
return remote_read_bytes_1 (memaddr, readbuf, len, unit_size,
xfered_len);
}
- else if (memaddr >= p->endaddr)
+ else if (memaddr >= p.endaddr)
{
/* This section ends before the transfer starts. */
continue;
else
{
/* This section overlaps the transfer. Just do half. */
- len = p->endaddr - memaddr;
+ len = p.endaddr - memaddr;
return remote_read_bytes_1 (memaddr, readbuf, len, unit_size,
xfered_len);
}
}
}
-void
-remote_target::files_info ()
-{
- puts_filtered ("Debugging a target over a serial line.\n");
-}
\f
/* Stuff for dealing with the packets which are part of this protocol.
See comment at top of file for details. */
string_file stb;
stb.putstrn (buf, n, '\\');
- return std::move (stb.string ());
-}
-
-/* Display a null-terminated packet on stdout, for debugging, using C
- string notation. */
-
-static void
-print_packet (const char *buf)
-{
- puts_filtered ("\"");
- fputstr_filtered (buf, '"', gdb_stdout);
- puts_filtered ("\"");
+ return stb.release ();
}
int
"and then try again."));
}
- /* We're sending out a new packet. Make sure we don't look at a
- stale cached response. */
- rs->cached_wait_status = 0;
-
/* Copy the packet into buffer BUF2, encapsulating it
and giving it a checksum. */
while (1)
{
- int started_error_output = 0;
-
if (remote_debug)
{
*p = '\0';
std::string str
= escape_buffer (buf2, std::min (len, max_chars));
- fprintf_unfiltered (gdb_stdlog, "Sending packet: %s", str.c_str ());
-
if (len > max_chars)
- fprintf_unfiltered (gdb_stdlog, "[%d bytes omitted]",
- len - max_chars);
-
- fprintf_unfiltered (gdb_stdlog, "...");
-
- gdb_flush (gdb_stdlog);
+ remote_debug_printf_nofunc
+ ("Sending packet: %s [%d bytes omitted]", str.c_str (),
+ len - max_chars);
+ else
+ remote_debug_printf_nofunc ("Sending packet: %s", str.c_str ());
}
remote_serial_write (buf2, p - buf2);
/* If this is a no acks version of the remote protocol, send the
packet and move on. */
if (rs->noack_mode)
- break;
+ break;
/* Read until either a timeout occurs (-2) or '+' is read.
Handle any notification that arrives in the mean time. */
{
ch = readchar (remote_timeout);
- if (remote_debug)
- {
- switch (ch)
- {
- case '+':
- case '-':
- case SERIAL_TIMEOUT:
- case '$':
- case '%':
- if (started_error_output)
- {
- putchar_unfiltered ('\n');
- started_error_output = 0;
- }
- }
- }
-
switch (ch)
{
case '+':
- if (remote_debug)
- fprintf_unfiltered (gdb_stdlog, "Ack\n");
+ remote_debug_printf_nofunc ("Received Ack");
return 1;
case '-':
- if (remote_debug)
- fprintf_unfiltered (gdb_stdlog, "Nak\n");
+ remote_debug_printf_nofunc ("Received Nak");
/* FALLTHROUGH */
case SERIAL_TIMEOUT:
tcount++;
break; /* Retransmit buffer. */
case '$':
{
- if (remote_debug)
- fprintf_unfiltered (gdb_stdlog,
- "Packet instead of Ack, ignoring it\n");
+ remote_debug_printf ("Packet instead of Ack, ignoring it");
/* It's probably an old response sent because an ACK
was lost. Gobble up the packet and ack it so it
doesn't get retransmitted when we resend this
val = read_frame (&rs->buf);
if (val >= 0)
{
- if (remote_debug)
- {
- std::string str = escape_buffer (rs->buf.data (), val);
+ remote_debug_printf_nofunc
+ (" Notification received: %s",
+ escape_buffer (rs->buf.data (), val).c_str ());
- fprintf_unfiltered (gdb_stdlog,
- " Notification received: %s\n",
- str.c_str ());
- }
handle_notification (rs->notif_state, rs->buf.data ());
/* We're in sync now, rewait for the ack. */
tcount = 0;
}
else
- {
- if (remote_debug)
- {
- if (!started_error_output)
- {
- started_error_output = 1;
- fprintf_unfiltered (gdb_stdlog, "putpkt: Junk: ");
- }
- fputc_unfiltered (ch & 0177, gdb_stdlog);
- fprintf_unfiltered (gdb_stdlog, "%s", rs->buf.data ());
- }
- }
+ remote_debug_printf_nofunc ("Junk: %c%s", ch & 0177,
+ rs->buf.data ());
continue;
}
/* fall-through */
default:
- if (remote_debug)
- {
- if (!started_error_output)
- {
- started_error_output = 1;
- fprintf_unfiltered (gdb_stdlog, "putpkt: Junk: ");
- }
- fputc_unfiltered (ch & 0177, gdb_stdlog);
- }
+ remote_debug_printf_nofunc ("Junk: %c%s", ch & 0177,
+ rs->buf.data ());
continue;
}
break; /* Here to retransmit. */
#if 0
/* This is wrong. If doing a long backtrace, the user should be
- able to get out next time we call QUIT, without anything as
- violent as interrupt_query. If we want to provide a way out of
- here without getting to the next QUIT, it should be based on
- hitting ^C twice as in remote_wait. */
+ able to get out next time we call QUIT, without anything as
+ violent as interrupt_query. If we want to provide a way out of
+ here without getting to the next QUIT, it should be based on
+ hitting ^C twice as in remote_wait. */
if (quit_flag)
{
quit_flag = 0;
switch (c)
{
case SERIAL_TIMEOUT:
- if (remote_debug)
- fputs_filtered ("Timeout in mid-packet, retrying\n", gdb_stdlog);
+ remote_debug_printf ("Timeout in mid-packet, retrying");
return -1;
+
case '$':
- if (remote_debug)
- fputs_filtered ("Saw new packet start in middle of old one\n",
- gdb_stdlog);
+ remote_debug_printf ("Saw new packet start in middle of old one");
return -1; /* Start a new packet, count retries. */
+
case '#':
{
unsigned char pktcsum;
if (check_0 == SERIAL_TIMEOUT || check_1 == SERIAL_TIMEOUT)
{
- if (remote_debug)
- fputs_filtered ("Timeout in checksum, retrying\n",
- gdb_stdlog);
+ remote_debug_printf ("Timeout in checksum, retrying");
return -1;
}
else if (check_0 < 0 || check_1 < 0)
{
- if (remote_debug)
- fputs_filtered ("Communication error in checksum\n",
- gdb_stdlog);
+ remote_debug_printf ("Communication error in checksum");
return -1;
}
pktcsum = (fromhex (check_0) << 4) | fromhex (check_1);
if (csum == pktcsum)
- return bc;
+ return bc;
- if (remote_debug)
- {
- std::string str = escape_buffer (buf, bc);
+ remote_debug_printf
+ ("Bad checksum, sentsum=0x%x, csum=0x%x, buf=%s",
+ pktcsum, csum, escape_buffer (buf, bc).c_str ());
- fprintf_unfiltered (gdb_stdlog,
- "Bad checksum, sentsum=0x%x, "
- "csum=0x%x, buf=%s\n",
- pktcsum, csum, str.c_str ());
- }
/* Number of characters in buffer ignoring trailing
- NULL. */
+ NULL. */
return -1;
}
case '*': /* Run length encoding. */
- {
+ {
int repeat;
- csum += c;
+ csum += c;
c = readchar (remote_timeout);
csum += c;
repeat = c - ' ' + 3; /* Compute repeat count. */
int timeout;
int val = -1;
- /* We're reading a new response. Make sure we don't look at a
- previously cached response. */
- rs->cached_wait_status = 0;
-
strcpy (buf->data (), "timeout");
if (forever)
_("Watchdog timeout has expired. "
"Target detached."));
}
- if (remote_debug)
- fputs_filtered ("Timed out.\n", gdb_stdlog);
+
+ remote_debug_printf ("Timed out.");
}
else
{
= escape_buffer (buf->data (),
std::min (val, max_chars));
- fprintf_unfiltered (gdb_stdlog, "Packet received: %s",
- str.c_str ());
-
if (val > max_chars)
- fprintf_unfiltered (gdb_stdlog, "[%d bytes omitted]",
- val - max_chars);
-
- fprintf_unfiltered (gdb_stdlog, "\n");
+ remote_debug_printf_nofunc
+ ("Packet received: %s [%d bytes omitted]", str.c_str (),
+ val - max_chars);
+ else
+ remote_debug_printf_nofunc ("Packet received: %s",
+ str.c_str ());
}
/* Skip the ack char if we're in no-ack mode. */
{
gdb_assert (c == '%');
- if (remote_debug)
- {
- std::string str = escape_buffer (buf->data (), val);
+ remote_debug_printf_nofunc
+ (" Notification received: %s",
+ escape_buffer (buf->data (), val).c_str ());
- fprintf_unfiltered (gdb_stdlog,
- " Notification received: %s\n",
- str.c_str ());
- }
if (is_notif != NULL)
*is_notif = 1;
return getpkt_or_notif_sane_1 (buf, forever, 1, is_notif);
}
-/* Kill any new fork children of process PID that haven't been
+/* Kill any new fork children of inferior INF that haven't been
processed by follow_fork. */
void
-remote_target::kill_new_fork_children (int pid)
+remote_target::kill_new_fork_children (inferior *inf)
{
remote_state *rs = get_remote_state ();
struct notif_client *notif = ¬if_client_stop;
- /* Kill the fork child threads of any threads in process PID
- that are stopped at a fork event. */
- for (thread_info *thread : all_non_exited_threads (this))
+ /* Kill the fork child threads of any threads in inferior INF that are stopped
+ at a fork event. */
+ for (thread_info *thread : inf->non_exited_threads ())
{
- struct target_waitstatus *ws = &thread->pending_follow;
+ const target_waitstatus *ws = thread_pending_fork_status (thread);
- if (is_pending_fork_parent (ws, pid, thread->ptid))
- {
- int child_pid = ws->value.related_pid.pid ();
- int res;
+ if (ws == nullptr)
+ continue;
- res = remote_vkill (child_pid);
- if (res != 0)
- error (_("Can't kill fork child process %d"), child_pid);
- }
+ int child_pid = ws->child_ptid ().pid ();
+ int res = remote_vkill (child_pid);
+
+ if (res != 0)
+ error (_("Can't kill fork child process %d"), child_pid);
}
/* Check for any pending fork events (not reported or processed yet)
- in process PID and kill those fork child threads as well. */
+ in inferior INF and kill those fork child threads as well. */
remote_notif_get_pending_events (notif);
for (auto &event : rs->stop_reply_queue)
- if (is_pending_fork_parent (&event->ws, pid, event->ptid))
- {
- int child_pid = event->ws.value.related_pid.pid ();
- int res;
+ {
+ if (event->ptid.pid () != inf->pid)
+ continue;
- res = remote_vkill (child_pid);
- if (res != 0)
- error (_("Can't kill fork child process %d"), child_pid);
- }
+ if (!is_fork_status (event->ws.kind ()))
+ continue;
+
+ int child_pid = event->ws.child_ptid ().pid ();
+ int res = remote_vkill (child_pid);
+
+ if (res != 0)
+ error (_("Can't kill fork child process %d"), child_pid);
+ }
}
\f
remote_target::kill ()
{
int res = -1;
- int pid = inferior_ptid.pid ();
+ inferior *inf = find_inferior_pid (this, inferior_ptid.pid ());
struct remote_state *rs = get_remote_state ();
+ gdb_assert (inf != nullptr);
+
if (packet_support (PACKET_vKill) != PACKET_DISABLE)
{
/* If we're stopped while forking and we haven't followed yet,
kill the child task. We need to do this before killing the
parent task because if this is a vfork then the parent will
be sleeping. */
- kill_new_fork_children (pid);
+ kill_new_fork_children (inf);
- res = remote_vkill (pid);
+ res = remote_vkill (inf->pid);
if (res == 0)
{
target_mourn_inferior (inferior_ptid);
error (_("Running \"%s\" on the remote target failed"),
remote_exec_file);
default:
- gdb_assert_not_reached (_("bad switch"));
+ gdb_assert_not_reached ("bad switch");
}
}
{
if (packet_support (PACKET_QSetWorkingDir) != PACKET_DISABLE)
{
- const char *inferior_cwd = get_inferior_cwd ();
+ const std::string &inferior_cwd = current_inferior ()->cwd ();
remote_state *rs = get_remote_state ();
- if (inferior_cwd != NULL)
+ if (!inferior_cwd.empty ())
{
- std::string hexpath = bin2hex ((const gdb_byte *) inferior_cwd,
- strlen (inferior_cwd));
+ std::string hexpath
+ = bin2hex ((const gdb_byte *) inferior_cwd.data (),
+ inferior_cwd.size ());
xsnprintf (rs->buf.data (), get_remote_packet_size (),
"QSetWorkingDir:%s", hexpath.c_str ());
{
case PACKET_ERROR:
if (rs->buf[1] == '.')
- {
- message = strchr (&rs->buf[2], '.');
- if (message)
- error (_("Remote failure reply: %s"), message + 1);
- }
+ {
+ message = strchr (&rs->buf[2], '.');
+ if (message)
+ error (_("Remote failure reply: %s"), message + 1);
+ }
return -1;
case PACKET_UNKNOWN:
return -1;
int res;
int read_only = 0;
- if (!exec_bfd)
+ if (!current_program_space->exec_bfd ())
error (_("command cannot be used without an exec file"));
if (args != NULL && strcmp (args, "-r") == 0)
args = NULL;
}
- for (s = exec_bfd->sections; s; s = s->next)
+ for (s = current_program_space->exec_bfd ()->sections; s; s = s->next)
{
if (!(s->flags & SEC_LOAD))
continue; /* Skip non-loadable section. */
lma = s->lma;
gdb::byte_vector sectdata (size);
- bfd_get_section_contents (exec_bfd, s, sectdata.data (), 0, size);
+ bfd_get_section_contents (current_program_space->exec_bfd (), s,
+ sectdata.data (), 0, size);
res = target_verify_memory (sectdata.data (), lma, size);
gdb_assert (rs->remote_desc);
return remote_read_qxfer
("osdata", annex, readbuf, offset, len, xfered_len,
- &remote_protocol_packets[PACKET_qXfer_osdata]);
+ &remote_protocol_packets[PACKET_qXfer_osdata]);
case TARGET_OBJECT_THREADS:
gdb_assert (annex == NULL);
case TARGET_OBJECT_BTRACE:
return remote_read_qxfer ("btrace", annex, readbuf, offset, len,
xfered_len,
- &remote_protocol_packets[PACKET_qXfer_btrace]);
+ &remote_protocol_packets[PACKET_qXfer_btrace]);
case TARGET_OBJECT_BTRACE_CONF:
return remote_read_qxfer ("btrace-conf", annex, readbuf, offset,
int found;
ULONGEST found_addr;
+ auto read_memory = [=] (CORE_ADDR addr, gdb_byte *result, size_t len)
+ {
+ return (target_read (this, TARGET_OBJECT_MEMORY, NULL, result, addr, len)
+ == len);
+ };
+
/* Don't go to the target if we don't have to. This is done before
checking packet_config_support to avoid the possibility that a
success for this edge case means the facility works in
{
/* Target doesn't provided special support, fall back and use the
standard support (copy memory and do the search here). */
- return simple_search_memory (this, start_addr, search_space_len,
+ return simple_search_memory (read_memory, start_addr, search_space_len,
pattern, pattern_len, found_addrp);
}
supported. If so, fall back to the simple way. */
if (packet_config_support (packet) == PACKET_DISABLE)
{
- return simple_search_memory (this, start_addr, search_space_len,
+ return simple_search_memory (read_memory, start_addr, search_space_len,
pattern, pattern_len, found_addrp);
}
return -1;
QUIT; /* Allow user to bail out with ^C. */
rs->buf[0] = '\0';
if (getpkt_sane (&rs->buf, 0) == -1)
- {
- /* Timeout. Continue to (try to) read responses.
- This is better than stopping with an error, assuming the stub
- is still executing the (long) monitor command.
- If needed, the user can interrupt gdb using C-c, obtaining
- an effect similar to stop on timeout. */
- continue;
- }
+ {
+ /* Timeout. Continue to (try to) read responses.
+ This is better than stopping with an error, assuming the stub
+ is still executing the (long) monitor command.
+ If needed, the user can interrupt gdb using C-c, obtaining
+ an effect similar to stop on timeout. */
+ continue;
+ }
buf = rs->buf.data ();
if (buf[0] == '\0')
error (_("Target does not support this command."));
{
std::vector<mem_region> result;
gdb::optional<gdb::char_vector> text
- = target_read_stralloc (current_top_target (), TARGET_OBJECT_MEMORY_MAP, NULL);
+ = target_read_stralloc (current_inferior ()->top_target (),
+ TARGET_OBJECT_MEMORY_MAP, NULL);
if (text)
result = parse_memory_map (text->data ());
return result;
}
-static void
-packet_command (const char *args, int from_tty)
+/* Set of callbacks used to implement the 'maint packet' command. */
+
+struct cli_packet_command_callbacks : public send_remote_packet_callbacks
{
- remote_target *remote = get_current_remote_target ();
+ /* Called before the packet is sent. BUF is the packet content before
+ the protocol specific prefix, suffix, and escaping is added. */
- if (remote == nullptr)
- error (_("command can only be used with remote target"));
+ void sending (gdb::array_view<const char> &buf) override
+ {
+ puts_filtered ("sending: ");
+ print_packet (buf);
+ puts_filtered ("\n");
+ }
- remote->packet_command (args, from_tty);
-}
+ /* Called with BUF, the reply from the remote target. */
+
+ void received (gdb::array_view<const char> &buf) override
+ {
+ puts_filtered ("received: \"");
+ print_packet (buf);
+ puts_filtered ("\"\n");
+ }
+
+private:
+
+ /* Print BUF o gdb_stdout. Any non-printable bytes in BUF are printed as
+ '\x??' with '??' replaced by the hexadecimal value of the byte. */
+
+ static void
+ print_packet (gdb::array_view<const char> &buf)
+ {
+ string_file stb;
+
+ for (int i = 0; i < buf.size (); ++i)
+ {
+ gdb_byte c = buf[i];
+ if (isprint (c))
+ fputc_unfiltered (c, &stb);
+ else
+ fprintf_unfiltered (&stb, "\\x%02x", (unsigned char) c);
+ }
+
+ puts_filtered (stb.string ().c_str ());
+ }
+};
+
+/* See remote.h. */
void
-remote_target::packet_command (const char *args, int from_tty)
+send_remote_packet (gdb::array_view<const char> &buf,
+ send_remote_packet_callbacks *callbacks)
{
- if (!args)
- error (_("remote-packet command requires packet text as argument"));
+ if (buf.size () == 0 || buf.data ()[0] == '\0')
+ error (_("a remote packet must not be empty"));
+
+ remote_target *remote = get_current_remote_target ();
+ if (remote == nullptr)
+ error (_("packets can only be sent to a remote target"));
- puts_filtered ("sending: ");
- print_packet (args);
- puts_filtered ("\n");
- putpkt (args);
+ callbacks->sending (buf);
- remote_state *rs = get_remote_state ();
+ remote->putpkt_binary (buf.data (), buf.size ());
+ remote_state *rs = remote->get_remote_state ();
+ int bytes = remote->getpkt_sane (&rs->buf, 0);
- getpkt (&rs->buf, 0);
- puts_filtered ("received: ");
- print_packet (rs->buf.data ());
- puts_filtered ("\n");
+ if (bytes < 0)
+ error (_("error while fetching packet from remote target"));
+
+ gdb::array_view<const char> view (&rs->buf[0], bytes);
+ callbacks->received (view);
+}
+
+/* Entry point for the 'maint packet' command. */
+
+static void
+cli_packet_command (const char *args, int from_tty)
+{
+ cli_packet_command_callbacks cb;
+ gdb::array_view<const char> view
+ = gdb::make_array_view (args, args == nullptr ? 0 : strlen (args));
+ send_remote_packet (view, &cb);
}
#if 0
-1 is returned, the other variables may not be initialized. */
static int
-remote_hostio_parse_result (char *buffer, int *retcode,
- int *remote_errno, char **attachment)
+remote_hostio_parse_result (const char *buffer, int *retcode,
+ int *remote_errno, const char **attachment)
{
char *p, *p2;
int
remote_target::remote_hostio_send_command (int command_bytes, int which_packet,
- int *remote_errno, char **attachment,
+ int *remote_errno, const char **attachment,
int *attachment_len)
{
struct remote_state *rs = get_remote_state ();
int ret, bytes_read;
- char *attachment_tmp;
+ const char *attachment_tmp;
if (packet_support (which_packet) == PACKET_DISABLE)
{
{
struct remote_state *rs = get_remote_state ();
char *p = rs->buf.data ();
- char *attachment;
+ const char *attachment;
int left = get_remote_packet_size ();
int ret, attachment_len;
int read_len;
{
cache->hit_count++;
- if (remote_debug)
- fprintf_unfiltered (gdb_stdlog, "readahead cache hit %s\n",
- pulongest (cache->hit_count));
+ remote_debug_printf ("readahead cache hit %s",
+ pulongest (cache->hit_count));
return ret;
}
cache->miss_count++;
- if (remote_debug)
- fprintf_unfiltered (gdb_stdlog, "readahead cache miss %s\n",
- pulongest (cache->miss_count));
+
+ remote_debug_printf ("readahead cache miss %s",
+ pulongest (cache->miss_count));
cache->fd = fd;
cache->offset = offset;
{
struct remote_state *rs = get_remote_state ();
char *p = rs->buf.data ();
- char *attachment;
+ const char *attachment;
int left = get_remote_packet_size ();
int len, attachment_len;
int read_len;
char *p = rs->buf.data ();
int left = get_remote_packet_size ();
int attachment_len, ret;
- char *attachment;
+ const char *attachment;
struct fio_stat fst;
int read_len;
this case we treat the remote filesystem as local if the
sysroot is exactly TARGET_SYSROOT_PREFIX and if the stub
does not support vFile:open. */
- if (strcmp (gdb_sysroot, TARGET_SYSROOT_PREFIX) == 0)
+ if (gdb_sysroot == TARGET_SYSROOT_PREFIX)
{
enum packet_support ps = packet_support (PACKET_vFile_open);
switch (errnum)
{
case FILEIO_EPERM:
- return EPERM;
+ return EPERM;
case FILEIO_ENOENT:
- return ENOENT;
+ return ENOENT;
case FILEIO_EINTR:
- return EINTR;
+ return EINTR;
case FILEIO_EIO:
- return EIO;
+ return EIO;
case FILEIO_EBADF:
- return EBADF;
+ return EBADF;
case FILEIO_EACCES:
- return EACCES;
+ return EACCES;
case FILEIO_EFAULT:
- return EFAULT;
+ return EFAULT;
case FILEIO_EBUSY:
- return EBUSY;
+ return EBUSY;
case FILEIO_EEXIST:
- return EEXIST;
+ return EEXIST;
case FILEIO_ENODEV:
- return ENODEV;
+ return ENODEV;
case FILEIO_ENOTDIR:
- return ENOTDIR;
+ return ENOTDIR;
case FILEIO_EISDIR:
- return EISDIR;
+ return EISDIR;
case FILEIO_EINVAL:
- return EINVAL;
+ return EINVAL;
case FILEIO_ENFILE:
- return ENFILE;
+ return ENFILE;
case FILEIO_EMFILE:
- return EMFILE;
+ return EMFILE;
case FILEIO_EFBIG:
- return EFBIG;
+ return EFBIG;
case FILEIO_ENOSPC:
- return ENOSPC;
+ return ENOSPC;
case FILEIO_ESPIPE:
- return ESPIPE;
+ return ESPIPE;
case FILEIO_EROFS:
- return EROFS;
+ return EROFS;
case FILEIO_ENOSYS:
- return ENOSYS;
+ return ENOSYS;
case FILEIO_ENAMETOOLONG:
- return ENAMETOOLONG;
+ return ENAMETOOLONG;
}
return -1;
}
"ignoring tp %d cond"), b->number);
}
- if (b->commands || *default_collect)
+ if (b->commands || !default_collect.empty ())
{
size_left = buf.size () - strlen (buf.data ());
error ("%s", err_msg);
encode_source_string (b->number, loc->address,
- "cond", b->cond_string,
+ "cond", b->cond_string.get (),
buf.data () + strlen (buf.data ()),
buf.size () - strlen (buf.data ()));
putpkt (buf.data ());
int anysecs = 0;
int offset = 0;
- if (!exec_bfd)
+ if (!current_program_space->exec_bfd ())
return; /* No information to give. */
struct remote_state *rs = get_remote_state ();
strcpy (rs->buf.data (), "QTro");
offset = strlen (rs->buf.data ());
- for (s = exec_bfd->sections; s; s = s->next)
+ for (s = current_program_space->exec_bfd ()->sections; s; s = s->next)
{
char tmp1[40], tmp2[40];
int sec_length;
{
struct remote_state *rs = get_remote_state ();
char *reply;
- struct bp_location *loc;
struct tracepoint *tp = (struct tracepoint *) bp;
size_t size = get_remote_packet_size ();
{
tp->hit_count = 0;
tp->traceframe_usage = 0;
- for (loc = tp->loc; loc; loc = loc->next)
+ for (bp_location *loc : tp->locations ())
{
/* If the tracepoint was never downloaded, don't go asking for
any status. */
if (*reply == '\0')
error (_("Target does not support this command."));
if (strcmp (reply, "OK") != 0)
- error (_("Bogus reply from target: %s"), reply);
+ error (_("Bogus reply from target: %s"), reply);
}
else if (val)
warning (_("Target does not support disconnected tracing."));
remote_target::traceframe_info ()
{
gdb::optional<gdb::char_vector> text
- = target_read_stralloc (current_top_target (), TARGET_OBJECT_TRACEFRAME_INFO,
+ = target_read_stralloc (current_inferior ()->top_target (),
+ TARGET_OBJECT_TRACEFRAME_INFO,
NULL);
if (text)
return parse_traceframe_info (text->data ());
if (val < 0)
{
*buf++ = '-';
- buf += hexnumstr (buf, (ULONGEST) -val);
+ buf += hexnumstr (buf, (ULONGEST) -val);
}
else
buf += hexnumstr (buf, (ULONGEST) val);
{
pos = buf;
pos += xsnprintf (pos, endbuf - pos, "%s=0x%x", packet->name,
- conf->bts.size);
+ conf->bts.size);
putpkt (buf);
getpkt (&rs->buf, 0);
{
pos = buf;
pos += xsnprintf (pos, endbuf - pos, "%s=0x%x", packet->name,
- conf->pt.size);
+ conf->pt.size);
putpkt (buf);
getpkt (&rs->buf, 0);
}
}
-/* Read the current thread's btrace configuration from the target and
- store it into CONF. */
+/* Read TP's btrace configuration from the target and store it into CONF. */
static void
-btrace_read_config (struct btrace_config *conf)
+btrace_read_config (thread_info *tp, struct btrace_config *conf)
{
+ /* target_read_stralloc relies on INFERIOR_PTID. */
+ scoped_restore_current_thread restore_thread;
+ switch_to_thread (tp);
+
gdb::optional<gdb::char_vector> xml
- = target_read_stralloc (current_top_target (), TARGET_OBJECT_BTRACE_CONF, "");
+ = target_read_stralloc (current_inferior ()->top_target (),
+ TARGET_OBJECT_BTRACE_CONF, "");
if (xml)
parse_xml_btrace_conf (conf, xml->data ());
}
if (packet_support (PACKET_qXfer_btrace_conf) != PACKET_ENABLE)
return;
- scoped_restore_current_thread restore_thread;
-
for (thread_info *tp : all_non_exited_threads (this))
{
- set_general_thread (tp->ptid);
-
memset (&rs->btrace_config, 0x00, sizeof (struct btrace_config));
- btrace_read_config (&rs->btrace_config);
+ btrace_read_config (tp, &rs->btrace_config);
if (rs->btrace_config.format == BTRACE_FORMAT_NONE)
continue;
/* Enable branch tracing. */
struct btrace_target_info *
-remote_target::enable_btrace (ptid_t ptid, const struct btrace_config *conf)
+remote_target::enable_btrace (thread_info *tp,
+ const struct btrace_config *conf)
{
struct btrace_target_info *tinfo = NULL;
struct packet_config *packet = NULL;
btrace_sync_conf (conf);
+ ptid_t ptid = tp->ptid;
set_general_thread (ptid);
buf += xsnprintf (buf, endbuf - buf, "%s", packet->name);
tracing itself is not impacted. */
try
{
- btrace_read_config (&tinfo->conf);
+ btrace_read_config (tp, &tinfo->conf);
}
catch (const gdb_exception_error &err)
{
}
gdb::optional<gdb::char_vector> xml
- = target_read_stralloc (current_top_target (), TARGET_OBJECT_BTRACE, annex);
+ = target_read_stralloc (current_inferior ()->top_target (),
+ TARGET_OBJECT_BTRACE, annex);
if (!xml)
return BTRACE_ERR_UNKNOWN;
xsnprintf (annex, annex_size, "%x", pid);
}
- filename = target_read_stralloc (current_top_target (),
+ filename = target_read_stralloc (current_inferior ()->top_target (),
TARGET_OBJECT_EXEC_FILE, annex);
return filename ? filename->data () : nullptr;
remote_thread_info *priv = get_remote_thread_info (tp);
if (tp->inf == inf && priv != NULL)
- {
+ {
if (handle_len != priv->thread_handle.size ())
error (_("Thread handle size mismatch: %d vs %zu (from remote)"),
- handle_len, priv->thread_handle.size ());
+ handle_len, priv->thread_handle.size ());
if (memcmp (thread_handle, priv->thread_handle.data (),
- handle_len) == 0)
+ handle_len) == 0)
return tp;
}
}
bool
remote_target::can_async_p ()
{
- struct remote_state *rs = get_remote_state ();
+ /* This flag should be checked in the common target.c code. */
+ gdb_assert (target_async_permitted);
- /* We don't go async if the user has explicitly prevented it with the
- "maint set target-async" command. */
- if (!target_async_permitted)
- return false;
-
- /* We're async whenever the serial device is. */
+ /* We're async whenever the serial device can. */
+ struct remote_state *rs = get_remote_state ();
return serial_can_async_p (rs->remote_desc);
}
bool
remote_target::is_async_p ()
{
- struct remote_state *rs = get_remote_state ();
-
- if (!target_async_permitted)
- /* We only enable async when the user specifically asks for it. */
- return false;
-
/* We're async whenever the serial device is. */
+ struct remote_state *rs = get_remote_state ();
return serial_is_async_p (rs->remote_desc);
}
remote_async_inferior_event_handler (gdb_client_data data)
{
inferior_event_handler (INF_REG_EVENT);
-
- remote_target *remote = (remote_target *) data;
- remote_state *rs = remote->get_remote_state ();
-
- /* inferior_event_handler may have consumed an event pending on the
- infrun side without calling target_wait on the REMOTE target, or
- may have pulled an event out of a different target. Keep trying
- for this remote target as long it still has either pending events
- or unacknowledged notifications. */
-
- if (rs->notif_state->pending_event[notif_client_stop.id] != NULL
- || !rs->stop_reply_queue.empty ())
- mark_async_event_handler (rs->remote_async_inferior_event_token);
}
int
{
remote_target *remote = get_current_remote_target ();
- if (remote != NULL) /* Have a remote connection. */
- remote->remote_check_symbols ();
+ /* First, check whether the current inferior's process target is a remote
+ target. */
+ if (remote == nullptr)
+ return;
+
+ /* When we are attaching or handling a fork child and the shared library
+ subsystem reads the list of loaded libraries, we receive new objfile
+ events in between each found library. The libraries are read in an
+ undefined order, so if we gave the remote side a chance to look up
+ symbols between each objfile, we might give it an inconsistent picture
+ of the inferior. It could appear that a library A appears loaded but
+ a library B does not, even though library A requires library B. That
+ would present a state that couldn't normally exist in the inferior.
+
+ So, skip these events, we'll give the remote a chance to look up symbols
+ once all the loaded libraries and their symbols are known to GDB. */
+ if (current_inferior ()->in_initial_library_scan)
+ return;
+
+ remote->remote_check_symbols ();
}
/* Pull all the tracepoints defined on the target and create local
}
}
+static void
+show_remote_debug (struct ui_file *file, int from_tty,
+ struct cmd_list_element *c, const char *value)
+{
+ fprintf_filtered (file, _("Debugging of remote protocol is %s.\n"),
+ value);
+}
+
+static void
+show_remote_timeout (struct ui_file *file, int from_tty,
+ struct cmd_list_element *c, const char *value)
+{
+ fprintf_filtered (file,
+ _("Timeout limit to wait for target to respond is %s.\n"),
+ value);
+}
+
+/* Implement the "supports_memory_tagging" target_ops method. */
+
+bool
+remote_target::supports_memory_tagging ()
+{
+ return remote_memory_tagging_p ();
+}
+
+/* Create the qMemTags packet given ADDRESS, LEN and TYPE. */
+
+static void
+create_fetch_memtags_request (gdb::char_vector &packet, CORE_ADDR address,
+ size_t len, int type)
+{
+ int addr_size = gdbarch_addr_bit (target_gdbarch ()) / 8;
+
+ std::string request = string_printf ("qMemTags:%s,%s:%s",
+ phex_nz (address, addr_size),
+ phex_nz (len, sizeof (len)),
+ phex_nz (type, sizeof (type)));
+
+ strcpy (packet.data (), request.c_str ());
+}
+
+/* Parse the qMemTags packet reply into TAGS.
+
+ Return true if successful, false otherwise. */
+
+static bool
+parse_fetch_memtags_reply (const gdb::char_vector &reply,
+ gdb::byte_vector &tags)
+{
+ if (reply.empty () || reply[0] == 'E' || reply[0] != 'm')
+ return false;
+
+ /* Copy the tag data. */
+ tags = hex2bin (reply.data () + 1);
+
+ return true;
+}
+
+/* Create the QMemTags packet given ADDRESS, LEN, TYPE and TAGS. */
+
+static void
+create_store_memtags_request (gdb::char_vector &packet, CORE_ADDR address,
+ size_t len, int type,
+ const gdb::byte_vector &tags)
+{
+ int addr_size = gdbarch_addr_bit (target_gdbarch ()) / 8;
+
+ /* Put together the main packet, address and length. */
+ std::string request = string_printf ("QMemTags:%s,%s:%s:",
+ phex_nz (address, addr_size),
+ phex_nz (len, sizeof (len)),
+ phex_nz (type, sizeof (type)));
+ request += bin2hex (tags.data (), tags.size ());
+
+ /* Check if we have exceeded the maximum packet size. */
+ if (packet.size () < request.length ())
+ error (_("Contents too big for packet QMemTags."));
+
+ strcpy (packet.data (), request.c_str ());
+}
+
+/* Implement the "fetch_memtags" target_ops method. */
+
+bool
+remote_target::fetch_memtags (CORE_ADDR address, size_t len,
+ gdb::byte_vector &tags, int type)
+{
+ /* Make sure the qMemTags packet is supported. */
+ if (!remote_memory_tagging_p ())
+ gdb_assert_not_reached ("remote fetch_memtags called with packet disabled");
+
+ struct remote_state *rs = get_remote_state ();
+
+ create_fetch_memtags_request (rs->buf, address, len, type);
+
+ putpkt (rs->buf);
+ getpkt (&rs->buf, 0);
+
+ return parse_fetch_memtags_reply (rs->buf, tags);
+}
+
+/* Implement the "store_memtags" target_ops method. */
+
+bool
+remote_target::store_memtags (CORE_ADDR address, size_t len,
+ const gdb::byte_vector &tags, int type)
+{
+ /* Make sure the QMemTags packet is supported. */
+ if (!remote_memory_tagging_p ())
+ gdb_assert_not_reached ("remote store_memtags called with packet disabled");
+
+ struct remote_state *rs = get_remote_state ();
+
+ create_store_memtags_request (rs->buf, address, len, type, tags);
+
+ putpkt (rs->buf);
+ getpkt (&rs->buf, 0);
+
+ /* Verify if the request was successful. */
+ return packet_check_result (rs->buf.data ()) == PACKET_OK;
+}
+
+/* Return true if remote target T is non-stop. */
+
+bool
+remote_target_is_non_stop_p (remote_target *t)
+{
+ scoped_restore_current_thread restore_thread;
+ switch_to_target_no_thread (t);
+
+ return target_is_non_stop_p ();
+}
+
+#if GDB_SELF_TEST
+
+namespace selftests {
+
+static void
+test_memory_tagging_functions ()
+{
+ remote_target remote;
+
+ struct packet_config *config
+ = &remote_protocol_packets[PACKET_memory_tagging_feature];
+
+ scoped_restore restore_memtag_support_
+ = make_scoped_restore (&config->support);
+
+ /* Test memory tagging packet support. */
+ config->support = PACKET_SUPPORT_UNKNOWN;
+ SELF_CHECK (remote.supports_memory_tagging () == false);
+ config->support = PACKET_DISABLE;
+ SELF_CHECK (remote.supports_memory_tagging () == false);
+ config->support = PACKET_ENABLE;
+ SELF_CHECK (remote.supports_memory_tagging () == true);
+
+ /* Setup testing. */
+ gdb::char_vector packet;
+ gdb::byte_vector tags, bv;
+ std::string expected, reply;
+ packet.resize (32000);
+
+ /* Test creating a qMemTags request. */
+
+ expected = "qMemTags:0,0:0";
+ create_fetch_memtags_request (packet, 0x0, 0x0, 0);
+ SELF_CHECK (strcmp (packet.data (), expected.c_str ()) == 0);
+
+ expected = "qMemTags:deadbeef,10:1";
+ create_fetch_memtags_request (packet, 0xdeadbeef, 16, 1);
+ SELF_CHECK (strcmp (packet.data (), expected.c_str ()) == 0);
+
+ /* Test parsing a qMemTags reply. */
+
+ /* Error reply, tags vector unmodified. */
+ reply = "E00";
+ strcpy (packet.data (), reply.c_str ());
+ tags.resize (0);
+ SELF_CHECK (parse_fetch_memtags_reply (packet, tags) == false);
+ SELF_CHECK (tags.size () == 0);
+
+ /* Valid reply, tags vector updated. */
+ tags.resize (0);
+ bv.resize (0);
+
+ for (int i = 0; i < 5; i++)
+ bv.push_back (i);
+
+ reply = "m" + bin2hex (bv.data (), bv.size ());
+ strcpy (packet.data (), reply.c_str ());
+
+ SELF_CHECK (parse_fetch_memtags_reply (packet, tags) == true);
+ SELF_CHECK (tags.size () == 5);
+
+ for (int i = 0; i < 5; i++)
+ SELF_CHECK (tags[i] == i);
+
+ /* Test creating a QMemTags request. */
+
+ /* Empty tag data. */
+ tags.resize (0);
+ expected = "QMemTags:0,0:0:";
+ create_store_memtags_request (packet, 0x0, 0x0, 0, tags);
+ SELF_CHECK (memcmp (packet.data (), expected.c_str (),
+ expected.length ()) == 0);
+
+ /* Non-empty tag data. */
+ tags.resize (0);
+ for (int i = 0; i < 5; i++)
+ tags.push_back (i);
+ expected = "QMemTags:deadbeef,ff:1:0001020304";
+ create_store_memtags_request (packet, 0xdeadbeef, 255, 1, tags);
+ SELF_CHECK (memcmp (packet.data (), expected.c_str (),
+ expected.length ()) == 0);
+}
+
+} // namespace selftests
+#endif /* GDB_SELF_TEST */
+
void _initialize_remote ();
void
_initialize_remote ()
{
- struct cmd_list_element *cmd;
- const char *cmd_name;
-
/* architecture specific data */
remote_g_packet_data_handle =
gdbarch_data_register_pre_init (remote_g_packet_data_init);
add_target (extended_remote_target_info, extended_remote_target::open);
/* Hook into new objfile notification. */
- gdb::observers::new_objfile.attach (remote_new_objfile);
+ gdb::observers::new_objfile.attach (remote_new_objfile, "remote");
#if 0
init_remote_threadtests ();
Remote protocol specific variables.\n\
Configure various remote-protocol specific variables such as\n\
the packets being used."),
- &remote_set_cmdlist, "set remote ",
+ &remote_set_cmdlist,
0 /* allow-unknown */, &setlist);
add_prefix_cmd ("remote", class_maintenance, show_remote_cmd, _("\
Remote protocol specific variables.\n\
Configure various remote-protocol specific variables such as\n\
the packets being used."),
- &remote_show_cmdlist, "show remote ",
+ &remote_show_cmdlist,
0 /* allow-unknown */, &showlist);
add_cmd ("compare-sections", class_obscure, compare_sections_command, _("\
To compare only read-only loaded sections, specify the -r option."),
&cmdlist);
- add_cmd ("packet", class_maintenance, packet_command, _("\
+ add_cmd ("packet", class_maintenance, cli_packet_command, _("\
Send an arbitrary packet to a remote target.\n\
maintenance packet TEXT\n\
If GDB is talking to an inferior via the GDB serial protocol, then\n\
terminating `#' character and checksum."),
&maintenancelist);
- add_setshow_boolean_cmd ("remotebreak", no_class, &remote_break, _("\
+ set_show_commands remotebreak_cmds
+ = add_setshow_boolean_cmd ("remotebreak", no_class, &remote_break, _("\
Set whether to send break if interrupted."), _("\
Show whether to send break if interrupted."), _("\
If set, a break, instead of a cntrl-c, is sent to the remote target."),
- set_remotebreak, show_remotebreak,
- &setlist, &showlist);
- cmd_name = "remotebreak";
- cmd = lookup_cmd (&cmd_name, setlist, "", NULL, -1, 1);
- deprecate_cmd (cmd, "set remote interrupt-sequence");
- cmd_name = "remotebreak"; /* needed because lookup_cmd updates the pointer */
- cmd = lookup_cmd (&cmd_name, showlist, "", NULL, -1, 1);
- deprecate_cmd (cmd, "show remote interrupt-sequence");
+ set_remotebreak, show_remotebreak,
+ &setlist, &showlist);
+ deprecate_cmd (remotebreak_cmds.set, "set remote interrupt-sequence");
+ deprecate_cmd (remotebreak_cmds.show, "show remote interrupt-sequence");
add_setshow_enum_cmd ("interrupt-sequence", class_support,
interrupt_sequence_modes, &interrupt_sequence_mode,
"qXfer:memory-map:read", "memory-map", 0);
add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_osdata],
- "qXfer:osdata:read", "osdata", 0);
+ "qXfer:osdata:read", "osdata", 0);
add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_threads],
"qXfer:threads:read", "threads", 0);
add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_siginfo_read],
- "qXfer:siginfo:read", "read-siginfo-object", 0);
+ "qXfer:siginfo:read", "read-siginfo-object", 0);
add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_siginfo_write],
- "qXfer:siginfo:write", "write-siginfo-object", 0);
+ "qXfer:siginfo:write", "write-siginfo-object", 0);
add_packet_config_cmd
(&remote_protocol_packets[PACKET_qXfer_traceframe_info],
"InstallInTrace", "install-in-trace", 0);
add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_statictrace_read],
- "qXfer:statictrace:read", "read-sdata-object", 0);
+ "qXfer:statictrace:read", "read-sdata-object", 0);
add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_fdpic],
"qXfer:fdpic:read", "read-fdpic-loadmap", 0);
"multiprocess-feature", "multiprocess-feature", 0);
add_packet_config_cmd (&remote_protocol_packets[PACKET_swbreak_feature],
- "swbreak-feature", "swbreak-feature", 0);
+ "swbreak-feature", "swbreak-feature", 0);
add_packet_config_cmd (&remote_protocol_packets[PACKET_hwbreak_feature],
- "hwbreak-feature", "hwbreak-feature", 0);
+ "hwbreak-feature", "hwbreak-feature", 0);
add_packet_config_cmd (&remote_protocol_packets[PACKET_fork_event_feature],
"fork-event-feature", "fork-event-feature", 0);
add_packet_config_cmd (&remote_protocol_packets[PACKET_no_resumed],
"N stop reply", "no-resumed-stop-reply", 0);
+ add_packet_config_cmd (&remote_protocol_packets[PACKET_memory_tagging_feature],
+ "memory-tagging-feature", "memory-tagging-feature", 0);
+
/* Assert that we've registered "set remote foo-packet" commands
for all packet configs. */
{
add_basic_prefix_cmd ("remote", class_files, _("\
Manipulate files on the remote system.\n\
Transfer files to and from the remote target system."),
- &remote_cmdlist, "remote ",
+ &remote_cmdlist,
0 /* allow-unknown */, &cmdlist);
add_cmd ("put", class_files, remote_put_command,
NULL, show_remote_packet_max_chars,
&setdebuglist, &showdebuglist);
+ add_setshow_boolean_cmd ("remote", no_class, &remote_debug,
+ _("Set debugging of remote protocol."),
+ _("Show debugging of remote protocol."),
+ _("\
+When enabled, each packet sent or received with the remote target\n\
+is displayed."),
+ NULL,
+ show_remote_debug,
+ &setdebuglist, &showdebuglist);
+
+ add_setshow_zuinteger_unlimited_cmd ("remotetimeout", no_class,
+ &remote_timeout, _("\
+Set timeout limit to wait for target to respond."), _("\
+Show timeout limit to wait for target to respond."), _("\
+This value is used to set the time limit for gdb to wait for a response\n\
+from the target."),
+ NULL,
+ show_remote_timeout,
+ &setlist, &showlist);
+
/* Eventually initialize fileio. See fileio.c */
initialize_remote_fileio (&remote_set_cmdlist, &remote_show_cmdlist);
+
+#if GDB_SELF_TEST
+ selftests::register_test ("remote_memory_tagging",
+ selftests::test_memory_tagging_functions);
+#endif
}
projects / binutils-gdb.git / blobdiff