gdb: follow-fork: push target and add thread in target_follow_fork
authorSimon Marchi <simon.marchi@polymtl.ca>
Fri, 28 May 2021 21:28:35 +0000 (17:28 -0400)
committerSimon Marchi <simon.marchi@polymtl.ca>
Wed, 4 Aug 2021 00:26:49 +0000 (20:26 -0400)
In the context of ROCm-gdb [1], the ROCm target sits on top of the
linux-nat target.  when a process forks, it needs to carry over some
data from the forking inferior to the fork child inferior.  Ideally, the
ROCm target would implement the follow_fork target_ops method, but there
are some small problems.  This patch fixes these, which helps the ROCm
target, but also makes things more consistent and a bit nicer in
general, I believe.

The main problem is: when follow-fork-mode is "parent",
target_follow_fork is called with the parent as the current inferior.
When it's "child", target_follow_fork is called with the child as the
current inferior.  This means that target_follow_fork is sometimes
called on the parent's target stack and sometimes on the child's target
stack.

The parent's target stack may contain targets above the process target,
such as the ROCm target.  So if follow-fork-child is "parent", the ROCm
target would get notified of the fork and do whatever is needed.  But
the child's target stack, at that moment, only contains the exec and
process target copied over from the parent.  The child's target stack is
set up by follow_fork_inferior, before calling target_follow_fork.  In
that case, the ROCm target wouldn't get notified of the fork.

For consistency, I think it would be good to always call
target_follow_fork on the parent inferior's target stack.  I think it
makes sense as a way to indicate "this inferior has called fork, do
whatever is needed".  The desired outcome of the fork (whether an
inferior is created for the child, do we need to detach from the child)
can be indicated by passed parameter.

I therefore propose these changes:

 - make follow_fork_inferior always call target_follow_fork with the
   parent as the current inferior.  That lets all targets present on the
   parent's target stack do some fork-related handling and push
   themselves on the fork child's target stack if needed.

   For this purpose, pass the child inferior down to target_follow_fork
   and follow_fork implementations.  This is nullptr if no inferior is
   created for the child, because we want to detach from it.

 - as a result, in follow_fork_inferior, detach from the parent inferior
   (if needed) only after the target_follow_fork call.  This is needed
   because we want to call target_follow_fork before the parent's
   target stack is torn down.

 - hand over to the targets in the parent's target stack (including the
   process target) the responsibility to push themselves, if needed, to
   the child's target stack.  Also hand over the responsibility to the
   process target, at the same time, to create the child's initial
   thread (just like we do for follow_exec).

 - pass the child inferior to exec_on_vfork, so we don't need to swap
   the current inferior between parent and child.  Nothing in
   exec_on_vfork depends on the current inferior, after this change.

   Although this could perhaps be replaced with just having the exec
   target implement follow_fork and push itself in the child's target
   stack, like the process target does... We would just need to make
   sure the process target calls beneath()->follow_fork(...).  I'm not
   sure about this one.

gdb/ChangeLog:

* target.h (struct target_ops) <follow_fork>: Add inferior*
parameter.
(target_follow_fork): Likewise.
* target.c (default_follow_fork): Likewise.
(target_follow_fork): Likewise.
* fbsd-nat.h (class fbsd_nat_target) <follow_fork>: Likewise.
(fbsd_nat_target::follow_fork): Likewise, and call
inf_ptrace_target::follow_fork.
* linux-nat.h (class linux_nat_target) <follow_fork>: Likewise.
* linux-nat.c (linux_nat_target::follow_fork): Likewise, and
call inf_ptrace_target::follow_fork.
* obsd-nat.h (obsd_nat_target) <follow_fork>: Likewise.
* obsd-nat.c (obsd_nat_target::follow_fork): Likewise, and call
inf_ptrace_target::follow_fork.
* remote.c (class remote_target) <follow_fork>: Likewise.
(remote_target::follow_fork): Likewise, and call
process_stratum_target::follow_fork.
* process-stratum-target.h (class process_stratum_target)
<follow_fork>: New.
* process-stratum-target.c
(process_stratum_target::follow_fork): New.
* target-delegates.c: Re-generate.

[1] https://github.com/ROCm-Developer-Tools/ROCgdb

Change-Id: I460bd0af850f0485e8aed4b24c6d8262a4c69929

15 files changed:
gdb/exec.c
gdb/exec.h
gdb/fbsd-nat.c
gdb/fbsd-nat.h
gdb/infrun.c
gdb/linux-nat.c
gdb/linux-nat.h
gdb/obsd-nat.c
gdb/obsd-nat.h
gdb/process-stratum-target.c
gdb/process-stratum-target.h
gdb/remote.c
gdb/target-delegates.c
gdb/target.c
gdb/target.h

index a28336be8ef165cd10191c5b28f60015ab5b8600..6f936c9403f02f113791f28c00644456f32a6fff 100644 (file)
@@ -678,10 +678,10 @@ program_space::remove_target_sections (void *owner)
 /* 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
index 1119953dc8fb79ac01a448065b5ff8cc9291fb47..c237f831d23464e2fa64f32271c99c671d1823e4 100644 (file)
@@ -34,12 +34,11 @@ struct objfile;
 
 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
index 0ae1195791cb6e45b42b39136a423bc5f0ca9297..4b2d01f1c4434d049fe035688893ce2ade917add 100644 (file)
@@ -1471,9 +1471,13 @@ fbsd_nat_target::create_inferior (const char *exec_file,
    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 ();
index 3fb502ca8d089e8c01550e03e657907ccfa150e0..34d7e6d25ba195db542fa4b71b2cc9354e3f9302 100644 (file)
@@ -85,7 +85,7 @@ public:
 #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;
index 815ebf45c1fd4bfbbf3f2e88b7bb501bc5dd1799..6c42c48d87cb6810eddc4afbbfb3690714b83f35 100644 (file)
@@ -428,7 +428,8 @@ holding the child stopped.  Try \"set detach-on-fork\" or \
       return true;
     }
 
-  thread_info *child_thr = nullptr;
+  inferior *parent_inf = current_inferior ();
+  inferior *child_inf = nullptr;
 
   if (!follow_child)
     {
@@ -462,25 +463,15 @@ holding the child stopped.  Try \"set detach-on-fork\" or \
        }
       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.  */
@@ -489,7 +480,7 @@ holding the child stopped.  Try \"set detach-on-fork\" or \
              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
@@ -498,32 +489,18 @@ holding the child stopped.  Try \"set detach-on-fork\" or \
              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
@@ -538,8 +515,6 @@ holding the child stopped.  Try \"set detach-on-fork\" or \
   else
     {
       /* Follow the child.  */
-      struct inferior *parent_inf, *child_inf;
-      struct program_space *parent_pspace;
 
       if (print_inferior_events)
        {
@@ -559,71 +534,12 @@ holding the child stopped.  Try \"set detach-on-fork\" or \
 
       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
@@ -633,7 +549,7 @@ holding the child stopped.  Try \"set detach-on-fork\" or \
          child_inf->pspace = parent_pspace;
          child_inf->aspace = child_inf->pspace->aspace;
 
-         exec_on_vfork ();
+         exec_on_vfork (child_inf);
        }
       else
        {
@@ -641,22 +557,84 @@ holding the child stopped.  Try \"set detach-on-fork\" or \
          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);
     }
 
index e4d0206eaac86490f3fdaed0041d92ce7c336984..211e447dc6f4c7eda207bc876ab25b597185f6cf 100644 (file)
@@ -444,19 +444,20 @@ struct lwp_deleter
 
 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 ();
 
@@ -589,7 +590,7 @@ linux_nat_target::follow_fork (ptid_t child_ptid, target_waitkind fork_kind,
     {
       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;
     }
index ee36c56519b2cf2a0a11ce9e4e99a41c88600c3f..83bd6d4a67866d9970235772b544803ab6e827db 100644 (file)
@@ -133,7 +133,7 @@ public:
 
   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;
index 044da080c163c1ad289dfff09ead335fdd5fc2eb..890ec5ed67013971e2eb38a289b01d4e9818e291 100644 (file)
@@ -152,13 +152,16 @@ obsd_nat_target::post_startup_inferior (ptid_t pid)
   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
index 43a793e0a317e725f6767e32ac2c7f0b72955876..1f74b9984c59ac0c5ff1fa4ef579954df22ee587 100644 (file)
@@ -29,7 +29,7 @@ class obsd_nat_target : public inf_ptrace_target
   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;
 
index 7aeda79e04c39a9cb1a4654b0ecec9500fb94c84..4c726419b99a7fac6fcc00ca5cf8ba4d7b7a767b 100644 (file)
@@ -85,6 +85,8 @@ process_stratum_target::has_execution (inferior *inf)
   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)
@@ -107,6 +109,21 @@ process_stratum_target::follow_exec (inferior *follow_inf, ptid_t ptid,
 
 /* 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)
index ed6907c2bd1f29aa7c6685248919608545cadc21..f0b6ea5996e8b77f88fec44a98663ce1e7de1547 100644 (file)
@@ -73,6 +73,15 @@ public:
   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
index 552481fc551b624355caab9f4ba81f1953d6de8e..b6da6b086a2c441653dafa8943eeca3552595b96 100644 (file)
@@ -682,7 +682,7 @@ public:
 
   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;
@@ -5920,9 +5920,13 @@ extended_remote_target::detach (inferior *inf, int from_tty)
    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))
index fa4cc5bb2dfca4cec140470c74f6e1475c1df1ed..3fd2854955febca1c9f7f1cf4503edafa195e664 100644 (file)
@@ -56,7 +56,7 @@ struct dummy_target : public target_ops
   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;
@@ -231,7 +231,7 @@ struct debug_target : public target_ops
   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;
@@ -1519,30 +1519,32 @@ debug_target::remove_vfork_catchpoint (int arg0)
 }
 
 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);
 }
 
index fe909c2fd39a9f12638730fa16680eaf2658a169..ae2d659583e2a10a68eccc763ffa3d25b430d425 100644 (file)
@@ -2701,9 +2701,9 @@ target_program_signals (gdb::array_view<const unsigned char> program_signals)
 }
 
 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__,
@@ -2713,12 +2713,24 @@ default_follow_fork (struct target_ops *self, ptid_t child_ptid,
 /* 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.  */
index 5ba73f4a5d91dcd204a01e3742236e9236937ed3..57afebef8765996740cba0de02a0cf1e88f67521 100644 (file)
@@ -636,7 +636,7 @@ struct target_ops
       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);
@@ -1719,8 +1719,9 @@ extern int target_remove_vfork_catchpoint (int pid);
    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.