/* See exec.h. */
void
-exec_on_vfork ()
+exec_on_vfork (inferior *vfork_child)
{
- if (!current_program_space->target_sections ().empty ())
- current_inferior ()->push_target (&exec_ops);
+ if (!vfork_child->pspace->target_sections ().empty ())
+ vfork_child->push_target (&exec_ops);
}
\f
extern target_section_table build_section_table (struct bfd *);
-/* The current inferior is a child vforked and its program space is
- shared with its parent. This pushes the exec target on the
- current/child inferior's target stack if there are sections in the
- program space's section table. */
+/* VFORK_CHILD is a child vforked and its program space is shared with its
+ parent. This pushes the exec target on that inferior's target stack if
+ there are sections in the program space's section table. */
-extern void exec_on_vfork ();
+extern void exec_on_vfork (inferior *vfork_child);
/* Read from mappable read-only sections of BFD executable files.
Return TARGET_XFER_OK, if read is successful. Return
the ptid of the followed inferior. */
void
-fbsd_nat_target::follow_fork (ptid_t child_ptid, target_waitkind fork_kind,
- bool follow_child, bool detach_fork)
+fbsd_nat_target::follow_fork (inferior *child_inf, ptid_t child_ptid,
+ target_waitkind fork_kind, bool follow_child,
+ bool detach_fork)
{
+ inf_ptrace_target::follow_fork (child_inf, child_ptid, fork_kind,
+ follow_child, detach_fork);
+
if (!follow_child && detach_fork)
{
pid_t child_pid = child_ptid.pid ();
#endif
#ifdef TDP_RFPPWAIT
- void follow_fork (ptid_t, target_waitkind, bool, bool) override;
+ void follow_fork (inferior *, ptid_t, target_waitkind, bool, bool) override;
int insert_fork_catchpoint (int) override;
int remove_fork_catchpoint (int) override;
return true;
}
- thread_info *child_thr = nullptr;
+ inferior *parent_inf = current_inferior ();
+ inferior *child_inf = nullptr;
if (!follow_child)
{
}
else
{
- struct inferior *parent_inf, *child_inf;
-
/* Add process to GDB's tables. */
child_inf = add_inferior (child_ptid.pid ());
- parent_inf = current_inferior ();
child_inf->attach_flag = parent_inf->attach_flag;
copy_terminal_info (child_inf, parent_inf);
child_inf->gdbarch = parent_inf->gdbarch;
copy_inferior_target_desc_info (child_inf, parent_inf);
- scoped_restore_current_pspace_and_thread restore_pspace_thread;
-
- set_current_inferior (child_inf);
- switch_to_no_thread ();
child_inf->symfile_flags = SYMFILE_NO_READ;
- child_inf->push_target (parent_inf->process_target ());
- child_thr = add_thread_silent (child_inf->process_target (),
- child_ptid);
/* If this is a vfork child, then the address-space is
shared with the parent. */
child_inf->pspace = parent_inf->pspace;
child_inf->aspace = parent_inf->aspace;
- exec_on_vfork ();
+ exec_on_vfork (child_inf);
/* The parent will be frozen until the child is done
with the shared region. Keep track of the
child_inf->pending_detach = 0;
parent_inf->vfork_child = child_inf;
parent_inf->pending_detach = 0;
-
- /* Now that the inferiors and program spaces are all
- wired up, we can switch to the child thread (which
- switches inferior and program space too). */
- switch_to_thread (child_thr);
}
else
{
child_inf->aspace = new_address_space ();
child_inf->pspace = new program_space (child_inf->aspace);
child_inf->removable = 1;
- set_current_program_space (child_inf->pspace);
clone_program_space (child_inf->pspace, parent_inf->pspace);
-
- /* solib_create_inferior_hook relies on the current
- thread. */
- switch_to_thread (child_thr);
}
}
if (has_vforked)
{
- struct inferior *parent_inf;
-
- parent_inf = current_inferior ();
-
/* If we detached from the child, then we have to be careful
to not insert breakpoints in the parent until the child
is done with the shared memory region. However, if we're
else
{
/* Follow the child. */
- struct inferior *parent_inf, *child_inf;
- struct program_space *parent_pspace;
if (print_inferior_events)
{
child_inf = add_inferior (child_ptid.pid ());
- parent_inf = current_inferior ();
child_inf->attach_flag = parent_inf->attach_flag;
copy_terminal_info (child_inf, parent_inf);
child_inf->gdbarch = parent_inf->gdbarch;
copy_inferior_target_desc_info (child_inf, parent_inf);
- parent_pspace = parent_inf->pspace;
-
- process_stratum_target *target = parent_inf->process_target ();
-
- {
- /* Hold a strong reference to the target while (maybe)
- detaching the parent. Otherwise detaching could close the
- target. */
- auto target_ref = target_ops_ref::new_reference (target);
-
- /* If we're vforking, we want to hold on to the parent until
- the child exits or execs. At child exec or exit time we
- can remove the old breakpoints from the parent and detach
- or resume debugging it. Otherwise, detach the parent now;
- we'll want to reuse it's program/address spaces, but we
- can't set them to the child before removing breakpoints
- from the parent, otherwise, the breakpoints module could
- decide to remove breakpoints from the wrong process (since
- they'd be assigned to the same address space). */
-
- if (has_vforked)
- {
- gdb_assert (child_inf->vfork_parent == NULL);
- gdb_assert (parent_inf->vfork_child == NULL);
- child_inf->vfork_parent = parent_inf;
- child_inf->pending_detach = 0;
- parent_inf->vfork_child = child_inf;
- parent_inf->pending_detach = detach_fork;
- parent_inf->waiting_for_vfork_done = 0;
- }
- else if (detach_fork)
- {
- if (print_inferior_events)
- {
- /* Ensure that we have a process ptid. */
- ptid_t process_ptid = ptid_t (parent_ptid.pid ());
-
- target_terminal::ours_for_output ();
- fprintf_filtered (gdb_stdlog,
- _("[Detaching after fork from "
- "parent %s]\n"),
- target_pid_to_str (process_ptid).c_str ());
- }
-
- target_detach (parent_inf, 0);
- parent_inf = NULL;
- }
-
- /* Note that the detach above makes PARENT_INF dangling. */
-
- /* Add the child thread to the appropriate lists, and switch
- to this new thread, before cloning the program space, and
- informing the solib layer about this new process. */
-
- set_current_inferior (child_inf);
- child_inf->push_target (target);
- }
-
- child_thr = add_thread_silent (target, child_ptid);
+ program_space *parent_pspace = parent_inf->pspace;
/* If this is a vfork child, then the address-space is shared
with the parent. If we detached from the parent, then we can
child_inf->pspace = parent_pspace;
child_inf->aspace = child_inf->pspace->aspace;
- exec_on_vfork ();
+ exec_on_vfork (child_inf);
}
else
{
child_inf->pspace = new program_space (child_inf->aspace);
child_inf->removable = 1;
child_inf->symfile_flags = SYMFILE_NO_READ;
- set_current_program_space (child_inf->pspace);
clone_program_space (child_inf->pspace, parent_pspace);
}
-
- switch_to_thread (child_thr);
}
- target_follow_fork (child_ptid, fork_kind, follow_child, detach_fork);
+ gdb_assert (current_inferior () == parent_inf);
+
+ /* If we are setting up an inferior for the child, target_follow_fork is
+ responsible for pushing the appropriate targets on the new inferior's
+ target stack and adding the initial thread (with ptid CHILD_PTID).
+
+ If we are not setting up an inferior for the child (because following
+ the parent and detach_fork is true), it is responsible for detaching
+ from CHILD_PTID. */
+ target_follow_fork (child_inf, child_ptid, fork_kind, follow_child,
+ detach_fork);
+
+ /* target_follow_fork must leave the parent as the current inferior. If we
+ want to follow the child, we make it the current one below. */
+ gdb_assert (current_inferior () == parent_inf);
+
+ /* If there is a child inferior, target_follow_fork must have created a thread
+ for it. */
+ if (child_inf != nullptr)
+ gdb_assert (!child_inf->thread_list.empty ());
+
+ /* Detach the parent if needed. */
+ if (follow_child)
+ {
+ /* If we're vforking, we want to hold on to the parent until
+ the child exits or execs. At child exec or exit time we
+ can remove the old breakpoints from the parent and detach
+ or resume debugging it. Otherwise, detach the parent now;
+ we'll want to reuse it's program/address spaces, but we
+ can't set them to the child before removing breakpoints
+ from the parent, otherwise, the breakpoints module could
+ decide to remove breakpoints from the wrong process (since
+ they'd be assigned to the same address space). */
+
+ if (has_vforked)
+ {
+ gdb_assert (child_inf->vfork_parent == NULL);
+ gdb_assert (parent_inf->vfork_child == NULL);
+ child_inf->vfork_parent = parent_inf;
+ child_inf->pending_detach = 0;
+ parent_inf->vfork_child = child_inf;
+ parent_inf->pending_detach = detach_fork;
+ parent_inf->waiting_for_vfork_done = 0;
+ }
+ else if (detach_fork)
+ {
+ if (print_inferior_events)
+ {
+ /* Ensure that we have a process ptid. */
+ ptid_t process_ptid = ptid_t (parent_ptid.pid ());
+
+ target_terminal::ours_for_output ();
+ fprintf_filtered (gdb_stdlog,
+ _("[Detaching after fork from "
+ "parent %s]\n"),
+ target_pid_to_str (process_ptid).c_str ());
+ }
+
+ target_detach (parent_inf, 0);
+ }
+ }
/* If we ended up creating a new inferior, call post_create_inferior to inform
the various subcomponents. */
- if (child_thr != nullptr)
+ if (child_inf != nullptr)
{
- scoped_restore_current_thread restore;
- switch_to_thread (child_thr);
+ /* If FOLLOW_CHILD, we leave CHILD_INF as the current inferior
+ (do not restore the parent as the current inferior). */
+ gdb::optional<scoped_restore_current_thread> maybe_restore;
+
+ if (!follow_child)
+ maybe_restore.emplace ();
+ switch_to_thread (*child_inf->threads ().begin ());
post_create_inferior (0);
}
typedef std::unique_ptr<struct lwp_info, lwp_deleter> lwp_info_up;
-/* Target hook for follow_fork. On entry inferior_ptid must be the
- ptid of the followed inferior. At return, inferior_ptid will be
- unchanged. */
+/* Target hook for follow_fork. */
void
-linux_nat_target::follow_fork (ptid_t child_ptid, target_waitkind fork_kind,
- bool follow_child, bool detach_fork)
+linux_nat_target::follow_fork (inferior *child_inf, ptid_t child_ptid,
+ target_waitkind fork_kind, bool follow_child,
+ bool detach_fork)
{
+ inf_ptrace_target::follow_fork (child_inf, child_ptid, fork_kind,
+ follow_child, detach_fork);
+
if (!follow_child)
{
bool has_vforked = fork_kind == TARGET_WAITKIND_VFORKED;
ptid_t parent_ptid = inferior_ptid;
- child_ptid = inferior_thread ()->pending_follow.value.related_pid;
int parent_pid = parent_ptid.lwp ();
int child_pid = child_ptid.lwp ();
{
struct lwp_info *child_lp;
- child_lp = add_lwp (inferior_ptid);
+ child_lp = add_lwp (child_ptid);
child_lp->stopped = 1;
child_lp->last_resume_kind = resume_stop;
}
void post_attach (int) override;
- void follow_fork (ptid_t, target_waitkind, bool, bool) override;
+ void follow_fork (inferior *, ptid_t, target_waitkind, bool, bool) override;
std::vector<static_tracepoint_marker>
static_tracepoint_markers_by_strid (const char *id) override;
obsd_enable_proc_events (pid.pid ());
}
-/* Target hook for follow_fork. On entry and at return inferior_ptid is
- the ptid of the followed inferior. */
+/* Target hook for follow_fork. */
void
-obsd_nat_target::follow_fork (ptid_t child_ptid, target_waitkind fork_kind,
+obsd_nat_target::follow_fork (inferior *child_inf, ptid_t child_ptid,
+ target_waitkind fork_kind,
bool follow_child, bool detach_fork)
{
+ inf_ptrace_target::follow_fork (child_inf, child_ptid, fork_kind,
+ follow_child, detach_fork);
+
if (!follow_child && detach_fork)
{
/* Breakpoints have already been detached from the child by
void update_thread_list () override;
ptid_t wait (ptid_t, struct target_waitstatus *, target_wait_flags) override;
- void follow_fork (ptid_t, target_waitkind, bool, bool) override;
+ void follow_fork (inferior *inf, ptid_t, target_waitkind, bool, bool) override;
int insert_fork_catchpoint (int) override;
return inf->pid != 0;
}
+/* See process-stratum-target.h. */
+
void
process_stratum_target::follow_exec (inferior *follow_inf, ptid_t ptid,
const char *execd_pathname)
/* See process-stratum-target.h. */
+void
+process_stratum_target::follow_fork (inferior *child_inf, ptid_t child_ptid,
+ target_waitkind fork_kind,
+ bool follow_child,
+ bool detach_on_fork)
+{
+ if (child_inf != nullptr)
+ {
+ child_inf->push_target (this);
+ add_thread_silent (this, child_ptid);
+ }
+}
+
+/* See process-stratum-target.h. */
+
void
process_stratum_target::maybe_add_resumed_with_pending_wait_status
(thread_info *thread)
void follow_exec (inferior *follow_inf, ptid_t ptid,
const char *execd_pathname) override;
+ /* Default implementation of follow_fork.
+
+ If a child inferior was created by infrun while following the fork
+ (CHILD_INF is non-nullptr), push this target on CHILD_INF's target stack
+ and add an initial thread with ptid CHILD_PTID. */
+ void follow_fork (inferior *child_inf, ptid_t child_ptid,
+ target_waitkind fork_kind, bool follow_child,
+ bool detach_on_fork) override;
+
/* True if any thread is, or may be executing. We need to track
this separately because until we fully sync the thread list, we
won't know whether the target is fully stopped, even if we see
const struct btrace_config *btrace_conf (const struct btrace_target_info *) override;
bool augmented_libraries_svr4_read () override;
- void follow_fork (ptid_t, target_waitkind, bool, bool) 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;
remote target as well. */
void
-remote_target::follow_fork (ptid_t child_ptid, target_waitkind fork_kind,
- bool follow_child, bool detach_fork)
+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 ();
if ((fork_kind == TARGET_WAITKIND_FORKED && remote_fork_event_p (rs))
int remove_fork_catchpoint (int arg0) override;
int insert_vfork_catchpoint (int arg0) override;
int remove_vfork_catchpoint (int arg0) override;
- void follow_fork (ptid_t arg0, target_waitkind arg1, bool arg2, bool arg3) override;
+ void follow_fork (inferior *arg0, ptid_t arg1, target_waitkind arg2, bool arg3, bool arg4) override;
int insert_exec_catchpoint (int arg0) override;
int remove_exec_catchpoint (int arg0) override;
void follow_exec (inferior *arg0, ptid_t arg1, const char *arg2) override;
int remove_fork_catchpoint (int arg0) override;
int insert_vfork_catchpoint (int arg0) override;
int remove_vfork_catchpoint (int arg0) override;
- void follow_fork (ptid_t arg0, target_waitkind arg1, bool arg2, bool arg3) override;
+ void follow_fork (inferior *arg0, ptid_t arg1, target_waitkind arg2, bool arg3, bool arg4) override;
int insert_exec_catchpoint (int arg0) override;
int remove_exec_catchpoint (int arg0) override;
void follow_exec (inferior *arg0, ptid_t arg1, const char *arg2) override;
}
void
-target_ops::follow_fork (ptid_t arg0, target_waitkind arg1, bool arg2, bool arg3)
+target_ops::follow_fork (inferior *arg0, ptid_t arg1, target_waitkind arg2, bool arg3, bool arg4)
{
- this->beneath ()->follow_fork (arg0, arg1, arg2, arg3);
+ this->beneath ()->follow_fork (arg0, arg1, arg2, arg3, arg4);
}
void
-dummy_target::follow_fork (ptid_t arg0, target_waitkind arg1, bool arg2, bool arg3)
+dummy_target::follow_fork (inferior *arg0, ptid_t arg1, target_waitkind arg2, bool arg3, bool arg4)
{
- default_follow_fork (this, arg0, arg1, arg2, arg3);
+ default_follow_fork (this, arg0, arg1, arg2, arg3, arg4);
}
void
-debug_target::follow_fork (ptid_t arg0, target_waitkind arg1, bool arg2, bool arg3)
+debug_target::follow_fork (inferior *arg0, ptid_t arg1, target_waitkind arg2, bool arg3, bool arg4)
{
fprintf_unfiltered (gdb_stdlog, "-> %s->follow_fork (...)\n", this->beneath ()->shortname ());
- this->beneath ()->follow_fork (arg0, arg1, arg2, arg3);
+ this->beneath ()->follow_fork (arg0, arg1, arg2, arg3, arg4);
fprintf_unfiltered (gdb_stdlog, "<- %s->follow_fork (", this->beneath ()->shortname ());
- target_debug_print_ptid_t (arg0);
+ target_debug_print_inferior_p (arg0);
fputs_unfiltered (", ", gdb_stdlog);
- target_debug_print_target_waitkind (arg1);
+ target_debug_print_ptid_t (arg1);
fputs_unfiltered (", ", gdb_stdlog);
- target_debug_print_bool (arg2);
+ target_debug_print_target_waitkind (arg2);
fputs_unfiltered (", ", gdb_stdlog);
target_debug_print_bool (arg3);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_bool (arg4);
fputs_unfiltered (")\n", gdb_stdlog);
}
}
static void
-default_follow_fork (struct target_ops *self, ptid_t child_ptid,
- target_waitkind fork_kind, bool follow_child,
- bool detach_fork)
+default_follow_fork (struct target_ops *self, inferior *child_inf,
+ ptid_t child_ptid, target_waitkind fork_kind,
+ bool follow_child, bool detach_fork)
{
/* Some target returned a fork event, but did not know how to follow it. */
internal_error (__FILE__, __LINE__,
/* See target.h. */
void
-target_follow_fork (ptid_t child_ptid, target_waitkind fork_kind,
- bool follow_child, bool detach_fork)
+target_follow_fork (inferior *child_inf, ptid_t child_ptid,
+ target_waitkind fork_kind, bool follow_child,
+ bool detach_fork)
{
target_ops *target = current_inferior ()->top_target ();
- return target->follow_fork (child_ptid, fork_kind, follow_child, detach_fork);
+ /* Check consistency between CHILD_INF, CHILD_PTID, FOLLOW_CHILD and
+ DETACH_FORK. */
+ if (child_inf != nullptr)
+ {
+ gdb_assert (follow_child || !detach_fork);
+ gdb_assert (child_inf->pid == child_ptid.pid ());
+ }
+ else
+ gdb_assert (!follow_child && detach_fork);
+
+ return target->follow_fork (child_inf, child_ptid, fork_kind, follow_child,
+ detach_fork);
}
/* See target.h. */
TARGET_DEFAULT_RETURN (1);
virtual int remove_vfork_catchpoint (int)
TARGET_DEFAULT_RETURN (1);
- virtual void follow_fork (ptid_t, target_waitkind, bool, bool)
+ virtual void follow_fork (inferior *, ptid_t, target_waitkind, bool, bool)
TARGET_DEFAULT_FUNC (default_follow_fork);
virtual int insert_exec_catchpoint (int)
TARGET_DEFAULT_RETURN (1);
bookkeeping and fiddling necessary to continue debugging either the parent,
the child or both. */
-void target_follow_fork (ptid_t child_ptid, target_waitkind fork_kind,
- bool follow_child, bool detach_fork);
+void target_follow_fork (inferior *inf, ptid_t child_ptid,
+ target_waitkind fork_kind, bool follow_child,
+ bool detach_fork);
/* Handle the target-specific bookkeeping required when the inferior makes an
exec call.
projects / binutils-gdb.git / commitdiff