[06/16,v2] Extended-remote Linux follow fork

  This is a small update to this patch so that it will work on targets
where hardware single step is not supported.  I had noted previously
that I had not tested inheritance of hardware watchpoints across a
fork.  I have now completed that testing, which exposed a couple of
problems, one of which is fixed by this update.  The only change from
the previous version of this patch is to initialize the variable
'status' in linux-low.c:linux_follow_fork.

Thanks,
--Don

On 8/20/2014 5:29 PM, Don Breazeal wrote:
> This patch implements basic support for follow-fork and detach-on-fork on
> extended-remote Linux targets.  Only 'fork' is supported in this patch;
> 'vfork' support is added n a subsequent patch.  Sufficient extended-remote
> functionality has been implemented here to pass gdb.base/foll-fork.exp with
> the catchpoint tests commented out.
> 
> The implementation follows the same general structure as for the native
> implementation as much as possible.
> 
> This implementation included:
>  * enabling fork events in linux-low.c in initialize_low and
>    linux_enable_extended_features
>  
>    - this adds the ptrace option to trace fork events to the new functions
>      from patch 4 that set up ptrace options.
> 
>  * handling fork events in gdbserver/linux-low.c:handle_extended_wait
>  
>    - when a fork event occurs in gdbserver, we must do the full creation
>      of the new process, thread, lwp, and breakpoint lists.  This is
>      required whether or not the new child is destined to be
>      detached-on-fork, because GDB will make target calls that require all
>      the structures.  In particular we need the breakpoint lists in order
>      to remove the breakpoints from a detaching child.  If we are not
>      detaching the child we will need all these structures anyway.
> 
>    - as part of this event handling we store the target_waitstatus in a new
>      member of the parent thread_info structure, 'pending_follow'.  This
>      mimics a similar mechanism used in the native implementation.  Here is
>      it used in several ways:
>      - in remote_detach_1 to distinguish between a process that is being
>        detached-on-fork vs. just detached.  In the fork case we don't want
>        to mourn the process because we want to keep the inferior around in
>        case the user decides to run the inferior again.
>      - to record the child pid for the expected follow_fork request.
>      - to find the parent in follow_fork (and later, elsewhere).
> 
>    - we also store the waitstatus in a new lwp_info member, 'waitstatus',
>      which is used in controlling the reporting of the event in
>      linux_wait_1.  We cannot re-use pending_follow for this because we
>      need to mark this one with 'ignored' status as part of the
>      linux_wait_1 procedure to stop event processing, and we need to keep
>      pending_follow intact for use later on.  We will also need this later
>      on for exec event handling, where pending_follow makes no sense.
> 
>    - handle_extended_wait is given a return value, denoting whether the
>      handled event should be reported to GDB.  Previously it had only
>      handled clone events, which were never reported.
> 
>  * using a new predicate to control handling of the fork event (and 
>    eventually all extended events) in linux_wait_1.  The predicate,
>    extended_event_reported, checks a target_waitstatus.kind for an
>    extended ptrace event.
> 
>  * implementing a new RSP 'T' Stop Reply Packet stop reason: "fork", in
>    gdbserver/remote-utils.c and remote.c.
> 
>  * implementing new target and RSP support for target_follow_fork with
>    target extended-remote.  (The RSP components were actually defined in
>    patch 4, but they see their first use here).
> 
>    - extended_remote target routine extended_remote_follow_fork
> 
>    - RSP packet vFollowFork
> 
>    - in gdbserver struct target_ops, add functions linux_supports_follow_fork
>      and linux_follow_fork.  The linux_follow_fork routine mimics the
>      implementation of linux-nat.c:linux_child_follow_fork, but the data
>      structures in use prevented turning this into a common function for now.
> 
> Tested on x64 Ubuntu Lucid, native, remote, extended-remote.
> 
> Thanks
> --Don
> 
> gdb/
> 2014-08-20  Don Breazeal  <donb@codesourcery.com>
> 
> 	* remote.c (remote_detach_1): Add target_ops argument, handle
> 	detach-on-fork.
> 	(remote_detach, extended_remote_detach): Call remote_detach_1
> 	with target_ops argument.
> 	(remote_parse_stop_reply): Handle new RSP stop reason "fork" in
> 	'T' stop reply packet.
> 	(extended_remote_follow_fork): Implement follow-fork support.
> 	(remote_pid_to_str): Print process.
> 	(_initialize_remote): Call add_packet_config_cmd for new RSP packet.
> 
> gdb/gdbserver/
> 2014-08-20  Don Breazeal  <donb@codesourcery.com>
> 
> 	* gdbthread.h (struct thread_info) <pending_follow>: New member.
> 	* linux-low.c (handle_extended_wait): Change function type from
> 	void to int, handle PTRACE_EVENT_FORK, call internal_error.
> 	(is_parent_callback): New function.
> 	(linux_follow_fork): New function.
> 	(linux_low_filter_event): Handle return value from
> 	handle_extended_wait.
> 	(extended_event_reported): New function.
> 	(linux_write_memory): Add pid to debug print.
> 	(linux_target_ops) <follow_fork>: Initialize new member.
> 	(initialize_low): Add PTRACE_O_TRACEFORK option.
> 	* linux-low.h (struct lwp_info) <waitstatus>: New member.
> 	* lynx-low.c (lynx_target_ops) <follow_fork>: Initialize new member.
> 	* nto-low.c (nto_target_ops) <follow_fork>: Initialize new member.
> 	* remote-utils.c (prepare_resume_reply): New RSP stop reason "fork"
> 	for 'T' stop reply.
> 	* server.c (handle_v_follow_fork): New function.
> 	(handle_v_requests): Handle vFollowFork packet, call
> 	handle_v_follow_fork.
> 	* spu-low.c (spu_target_ops) <follow_fork>: Initialize new member.
> 	* target.h (struct target_ops) <follow_fork>: New member.
> 	(target_follow_fork): Define macro.
> 	* win32-low.c (win32_target_ops) <follow_fork>: Initialize new member.
> 

---
 gdb/gdbserver/gdbthread.h    |    5 +
 gdb/gdbserver/linux-low.c    |  207
+++++++++++++++++++++++++++++++++++++++---
 gdb/gdbserver/linux-low.h    |    5 +
 gdb/gdbserver/lynx-low.c     |    1 +
 gdb/gdbserver/nto-low.c      |    1 +
 gdb/gdbserver/remote-utils.c |   14 +++-
 gdb/gdbserver/server.c       |   41 ++++++++
 gdb/gdbserver/spu-low.c      |    1 +
 gdb/gdbserver/target.h       |   13 +++
 gdb/gdbserver/win32-low.c    |    1 +
 gdb/remote.c                 |   80 ++++++++++++----
 11 files changed, 334 insertions(+), 35 deletions(-)

     PACKET_qXfer_siginfo_read },
@@ -4333,10 +4336,12 @@ remote_open_1 (const char *name, int from_tty,
    die when it hits one.  */

 static void
-remote_detach_1 (const char *args, int from_tty, int extended)
+remote_detach_1 (struct target_ops *ops, const char *args,
+		 int from_tty, int extended)
 {
   int pid = ptid_get_pid (inferior_ptid);
   struct remote_state *rs = get_remote_state ();
+  struct thread_info *tp = first_thread_of_process (pid);

   if (args)
     error (_("Argument given to \"detach\" when remotely debugging."));
@@ -4373,19 +4378,28 @@ remote_detach_1 (const char *args, int from_tty,
int extended)
   if (from_tty && !extended)
     puts_filtered (_("Ending remote debugging.\n"));

-  target_mourn_inferior ();
+  /* If doing detach-on-fork, we don't mourn, because that will delete
+     breakpoints that should be available for the child.  */
+  if (tp->pending_follow.kind != TARGET_WAITKIND_FORKED)
+    target_mourn_inferior ();
+  else
+    {
+      inferior_ptid = null_ptid;
+      detach_inferior (pid);
+      inf_child_maybe_unpush_target (ops);
+    }
 }

 static void
 remote_detach (struct target_ops *ops, const char *args, int from_tty)
 {
-  remote_detach_1 (args, from_tty, 0);
+  remote_detach_1 (ops, args, from_tty, 0);
 }

 static void
 extended_remote_detach (struct target_ops *ops, const char *args, int
from_tty)
 {
-  remote_detach_1 (args, from_tty, 1);
+  remote_detach_1 (ops, args, from_tty, 1);
 }

 /* Same as remote_detach, but don't send the "D" packet; just
disconnect.  */
@@ -5481,7 +5495,8 @@ remote_parse_stop_reply (char *buf, struct
stop_reply *event)
 	     as a register number.  */

 	  if (strncmp (p, "awatch", strlen("awatch")) != 0
-	      && strncmp (p, "core", strlen ("core") != 0))
+	      && strncmp (p, "core", strlen ("core") != 0)
+	      && strncmp (p, "fork", strlen ("fork") != 0))
 	    {
 	      /* Read the ``P'' register number.  */
 	      pnum = strtol (p, &p_temp, 16);
@@ -5533,6 +5548,11 @@ Packet: '%s'\n"),
 		  p = unpack_varlen_hex (++p1, &c);
 		  event->core = c;
 		}
+	      else if (strncmp (p, "fork", p1 - p) == 0)
+		{
+		  event->ws.value.related_pid = read_ptid (++p1, &p);
+		  event->ws.kind = TARGET_WAITKIND_FORKED;
+		}
 	      else
 		{
 		  /* Silently skip unknown optional info.  */
@@ -7820,6 +7840,32 @@ extended_remote_kill (struct target_ops *ops)
   target_mourn_inferior ();
 }

+/* Target routine for follow-fork.  */
+
+static int
+extended_remote_follow_fork (struct target_ops *ops, int follow_child,
+			     int detach_fork)
+{
+  struct remote_state *rs = get_remote_state ();
+
+  if (extended_remote_feature_supported (FORK_EVENT))
+    {
+      char *p = rs->buf;
+      char *endbuf = rs->buf + get_remote_packet_size ();
+
+      xsnprintf (rs->buf, get_remote_packet_size (), "vFollowFork;%d;%d",
+		 follow_child, detach_fork);
+
+      putpkt (rs->buf);
+      getpkt (&rs->buf, &rs->buf_size, 0);
+
+      if (rs->buf[0] == 'E')
+	return 1;
+    }
+
+  return 0;
+}
+
 static void
 remote_mourn (struct target_ops *ops)
 {
@@ -7836,20 +7882,6 @@ remote_mourn_1 (struct target_ops *target)
   generic_mourn_inferior ();
 }

-/* Target follow-fork function for extended-remote targets.  */
-
-static int
-extended_remote_follow_fork (struct target_ops *target, int follow_child,
-			     int detach_fork)
-{
-  if (extended_remote_feature_supported (FORK_EVENT))
-    {
-      /* FIXME: Implement follow-fork here.  */
-      return -1;
-    }
-  return 0;
-}
-
 static void
 extended_remote_mourn_1 (struct target_ops *target)
 {
@@ -9356,8 +9388,11 @@ remote_pid_to_str (struct target_ops *ops, ptid_t
ptid)
       if (ptid_equal (magic_null_ptid, ptid))
 	xsnprintf (buf, sizeof buf, "Thread <main>");
       else if (rs->extended && remote_multi_process_p (rs))
-	xsnprintf (buf, sizeof buf, "Thread %d.%ld",
-		   ptid_get_pid (ptid), ptid_get_lwp (ptid));
+	if (ptid_get_lwp (ptid) == 0)
+	  return normal_pid_to_str (ptid);
+	else
+	  xsnprintf (buf, sizeof buf, "Thread %d.%ld",
+		     ptid_get_pid (ptid), ptid_get_lwp (ptid));
       else
 	xsnprintf (buf, sizeof buf, "Thread %ld",
 		   ptid_get_lwp (ptid));
@@ -12184,6 +12219,9 @@ Show the maximum size of the address (in bits)
in a memory packet."), NULL,
   add_packet_config_cmd (&remote_protocol_packets[PACKET_vKill],
 			 "vKill", "kill", 0);

+  add_packet_config_cmd (&remote_protocol_packets[PACKET_vFollowFork],
+			 "vFollowFork", "follow-fork", 0);
+
   add_packet_config_cmd (&remote_protocol_packets[PACKET_qAttached],
 			 "qAttached", "query-attached", 0);
  

[06/16,v2] Extended-remote Linux follow fork

Commit Message

Patch