gdb/gdb-6.7-bz233852-attach-signalled-fix.patch

2008-01-09  Jan Kratochvil  <jan.kratochvil@redhat.com>

	Support attaching to stopped processes/threads and/or with pending
	signals.  This ChangeLog entry is OBSOLETE:
	* linux-nat.c (STRINGIFY, STRINGIFY_ARG): New macros.
	(kill_lwp): New declaration.
	(linux_ptrace_post_attach, pid_is_stopped): New function.
	(linux_child_follow_fork): New comment about WAS_STOPPED.
	(lin_lwp_attach_lwp): Variable PID removed.  Part replaced by a call to
	LINUX_PTRACE_POST_ATTACH.
	(linux_nat_attach): Likewise.
	(linux_nat_detach): Optionally stop the detached process.
	(linux_nat_resume): Clear WAS_STOPPED if appropriate.
	* NEWS: Document the new behaviour.

2007-06-30  Jan Kratochvil  <jan.kratochvil@redhat.com>

	* gdb.texinfo (Attach): Document the ATTACH and DETACH commands for
	stopped processes.  Document the messages on the seen pending signals.

2008-02-24  Jan Kratochvil  <jan.kratochvil@redhat.com>

	Port to GDB-6.8pre.

Index: gdb-6.8cvs20080219/gdb/NEWS
===================================================================
--- gdb-6.8cvs20080219.orig/gdb/NEWS	2008-02-24 19:35:37.000000000 +0100
+++ gdb-6.8cvs20080219/gdb/NEWS	2008-02-24 19:36:26.000000000 +0100
@@ -412,6 +412,9 @@ Renesas M32C/M16C		m32c-elf
 
 Morpho Technologies ms1		ms1-elf
 
+* On GNU/Linux, stopped processes may get attached to now.  Signals being
+delivered at the time of the attach command no longer get lost.
+
 * New commands
 
 init-if-undefined		Initialize a convenience variable, but
Index: gdb-6.8cvs20080219/gdb/linux-nat.c
===================================================================
--- gdb-6.8cvs20080219.orig/gdb/linux-nat.c	2008-02-24 19:36:26.000000000 +0100
+++ gdb-6.8cvs20080219/gdb/linux-nat.c	2008-02-24 19:45:01.000000000 +0100
@@ -89,6 +89,15 @@
 #define PTRACE_GETSIGINFO    0x4202
 #endif
 
+#define STRINGIFY_ARG(x) #x
+#define STRINGIFY(x) STRINGIFY_ARG (x)
+
+static int linux_ptrace_post_attach (ptid_t ptid, int *cloned_return);
+static int kill_lwp (int lwpid, int signo);
+
+/* PID of the inferior stopped by SIGSTOP before attaching (or zero).  */
+static pid_t pid_was_stopped;
+
 /* The single-threaded native GNU/Linux target_ops.  We save a pointer for
    the use of the multi-threaded target.  */
 static struct target_ops *linux_ops;
@@ -539,6 +548,11 @@ linux_child_follow_fork (struct target_o
 	}
       else
 	{
+	  /* We should check PID_WAS_STOPPED and detach it stopped accordingly.
+	     In this point of code it cannot be 1 as we would not get FORK
+	     executed without CONTINUE first which resets PID_WAS_STOPPED.
+	     We would have to first TARGET_STOP and WAITPID it as with running
+	     inferior PTRACE_DETACH, SIGSTOP will ignore the signal.  */
 	  target_detach (NULL, 0);
 	}
 
@@ -942,9 +956,8 @@ lin_lwp_attach_lwp (ptid_t ptid)
      to happen.  */
   if (GET_LWP (ptid) != GET_PID (ptid) && lp == NULL)
     {
-      pid_t pid;
       int status;
-      int cloned = 0;
+      int cloned;
 
       if (ptrace (PTRACE_ATTACH, GET_LWP (ptid), 0, 0) < 0)
 	{
@@ -958,37 +971,20 @@ lin_lwp_attach_lwp (ptid_t ptid)
 	  return -1;
 	}
 
-      if (debug_linux_nat)
-	fprintf_unfiltered (gdb_stdlog,
-			    "LLAL: PTRACE_ATTACH %s, 0, 0 (OK)\n",
-			    target_pid_to_str (ptid));
-
-      pid = my_waitpid (GET_LWP (ptid), &status, 0);
-      if (pid == -1 && errno == ECHILD)
-	{
-	  /* Try again with __WCLONE to check cloned processes.  */
-	  pid = my_waitpid (GET_LWP (ptid), &status, __WCLONE);
-	  cloned = 1;
+      status = linux_ptrace_post_attach (ptid, &cloned);
+      if (status != 0)
+        {
+	  error (_("Thread %s exited: %s"), target_pid_to_str (ptid),
+		 status_to_str (status));
 	}
 
-      gdb_assert (pid == GET_LWP (ptid)
-		  && WIFSTOPPED (status) && WSTOPSIG (status));
-
-      if (lp == NULL)
-	lp = add_lwp (ptid);
+      /* ADD_LWP with TID only already after the WAITPID.  */
+      lp = add_lwp (ptid);
       lp->cloned = cloned;
 
-      target_post_attach (pid);
+      target_post_attach (GET_LWP (ptid));
 
       lp->stopped = 1;
-
-      if (debug_linux_nat)
-	{
-	  fprintf_unfiltered (gdb_stdlog,
-			      "LLAL: waitpid %s received %s\n",
-			      target_pid_to_str (ptid),
-			      status_to_str (status));
-	}
     }
   else
     {
@@ -998,44 +994,202 @@ lin_lwp_attach_lwp (ptid_t ptid)
          threads.  Note that this won't have already been done since
          the main thread will have, we assume, been stopped by an
          attach from a different layer.  */
-      if (lp == NULL)
-	lp = add_lwp (ptid);
       lp->stopped = 1;
     }
 
   return 0;
 }
 
+/* Detect `T (stopped)' in `/proc/PID/status'.
+   Other states including `T (tracing stop)' are reported as false.  */
+
+static int
+pid_is_stopped (pid_t pid)
+{
+  FILE *status_file;
+  char buf[100];
+  int retval = 0;
+
+  snprintf (buf, sizeof (buf), "/proc/%d/status", (int) pid);
+  status_file = fopen (buf, "r");
+  if (status_file != NULL)
+    {
+      int have_state = 0;
+
+      while (fgets (buf, sizeof (buf), status_file))
+	{
+	  if (strncmp (buf, "State:", 6) == 0)
+	    {
+	      have_state = 1;
+	      break;
+	    }
+	}
+      if (have_state && strstr (buf, "T (stopped)") != NULL)
+	retval = 1;
+      fclose (status_file);
+    }
+  return retval;
+}
+
+/* Handle the processing after PTRACE_ATTACH, the first WAITPID -> SIGSTOP.
+   Returns STATUS if the thread has exited, 0 otherwise.
+   Sets PID_WAS_STOPPED if the process was originally stopped.
+   Sets LP->CLONED if the given LWP is not the thread leader.
+
+   Scenario for a standard unstopped inferior:
+    * `S (sleeping)' or `R (running)' or similiar states.
+    * PTRACE_ATTACH is called.
+    * `S (sleeping)' (or similiar) for some while.
+    * `T (tracing stop)'.
+    * WAITPID succeeds here returning SIGSTOP (signalled by PTRACE_ATTACH).
+
+   Scenario for a formerly stopped inferior:
+    * `T (stopped)'.
+    * PTRACE_ATTACH is called.
+    * `T (stopped)' would stay indefinitely
+      Note since this moment the `TracerPid' field gets filled
+      (by PTRACE_ATTACH), it is no longer just the common `T (stopped)' state.
+       * If no one did WAITPID since sending SIGSTOP our WAITPID would return
+         SIGSTOP.  The state still would not turn to `T (tracing stop)'.
+       * Usually its original parent (before PTRACE_ATTACH was applied) already
+         did WAITPID.  The original parent already received our SIGSTOP
+         sinalled by our PTRACE_ATTACH.
+         In this case our own WAITPID would hang.  Therefore...
+    * ... we do artificial: tkill (SIGCONT);
+      `PTRACE_CONT, SIGSTOP' does not work in 100% cases as sometimes SIGSTOP
+      gets remembered by kernel during the first PTRACE_CONT later and we get
+      spurious SIGSTOP event.  Expecting the signal may get delivered to
+      a different task of the thread group.
+      `kill_lwp (SIGSTOP)' has no effect in this moment (it is already stopped).
+    * WAITPID returns the artifical SIGCONT.
+      (The possibly pending SIGSTOP gets vanished by specifically SIGCONT.)
+    * State turns `T (tracing stop)'.
+   In this moment everything is almost fine but we need a workaround as final
+   `PTRACE_DETACH, SIGSTOP' would leave the process unstopped otherwise:
+    * tkill (SIGSTOP);
+    * `PTRACE_CONT, 0'
+    * WAITPID returns the artifical SIGSTOP.
+
+   With the pending (unwaited for) SIGSTOP the artifical signal effects are:
+   kill (SIGSTOP)
+   PTRACE_ATTACH
+    /-tkill (SIGCONT), WAITPID: SIGCONT, WAITPID: hang !
+   //-tkill (SIGCONT), WAITPID: SIGCONT, PTRACE_CONT (SIG_0), WAITPID: wait (OK)
+   \\-tkill (SIGALRM), WAITPID: SIGSTOP, WAITPID: hang !
+    \-tkill (SIGALRM), WAITPID: SIGSTOP, PTRACE_CONT (SIG_0), WAITPID: SIGALRM !
+   Therefore we signal artifical SIGCONT and stop waiting after its reception.
+
+   For the detection whether the process was formerly stopped we need to
+   read `/proc/PID/status'.  `PTRACE_CONT, SIGSTOP' returns ESRCH
+   for `S (sleeping)' and succeeds for `T (stopped)' but it unfortunately
+   succeeds even for `T (tracing stop)'.  Depending on PTRACE_CONT, SIGSTOP
+   success value for formerly stopped processes would mean a race condition
+   as we would get false stopped processes detection if we get too slow.
+
+   `waitid (..., WSTOPPED)' hangs the same way as WAITPID.
+
+   Signals get queued for WAITPID.  PTRACE_ATTACH (or TKILL) enqueues SIGSTOP
+   there but WAITPID may return an already pending signal.
+   Redeliver it by PTRACE_CONT, SIGxxx as otherwise it would get lost.
+   Similiar processing is being done in this file by WAIT_LWP.  */
+
+static int
+linux_ptrace_post_attach (ptid_t ptid, int *cloned_return)
+{
+  unsigned long sig;
+  int this_thread_was_stopped;
+  int cloned = 0;
+
+  if (debug_linux_nat)
+    fprintf_unfiltered (gdb_stdlog,
+			"LLAL: PTRACE_ATTACH %s, 0, 0 (OK)\n",
+			target_pid_to_str (ptid));
+
+  /* This code should not be run for the threads being attached after the first
+     thread (process) as we would get later spurious SIGCONT otherwise.  */
+
+  this_thread_was_stopped = pid_is_stopped (GET_LWP (ptid));
+  if (this_thread_was_stopped)
+    {
+      pid_was_stopped = GET_PID (ptid);
+      if (kill_lwp (GET_LWP (ptid), SIGCONT) != 0)
+	perror_with_name (("kill_lwp (SIGCONT)"));
+    }
+
+  for (;;)
+    {
+      pid_t pid;
+      int status;
+
+      pid = my_waitpid (GET_LWP (ptid), &status, 0);
+      if (pid == -1 && errno == ECHILD)
+	{
+	  /* Try again with __WCLONE to check cloned processes.  */
+	  pid = my_waitpid (GET_LWP (ptid), &status, __WCLONE);
+	  cloned = 1;
+	}
+
+      gdb_assert (pid == GET_LWP (ptid));
+
+      if (debug_linux_nat)
+	{
+	  fprintf_unfiltered (gdb_stdlog,
+			      "LLAL: waitpid %s received %s\n",
+			      target_pid_to_str (ptid),
+			      status_to_str (status));
+	}
+
+      /* Check if the thread has exited.  */
+      if (WIFEXITED (status) || WIFSIGNALED (status))
+	return status;
+      gdb_assert (WIFSTOPPED (status));
+      sig = WSTOPSIG (status);
+      gdb_assert (sig != 0);
+      if (sig == SIGSTOP)
+	break;
+
+      /* As the second signal for stopped processes we send SIGSTOP.  */
+      if (this_thread_was_stopped && sig == SIGCONT)
+	sig = SIGSTOP;
+
+      printf_unfiltered (_("Redelivering pending %s.\n"),
+		 target_signal_to_string (target_signal_from_host (sig)));
+      if (sig == SIGSTOP)
+	{
+	  if (kill_lwp (GET_LWP (ptid), sig) != 0)
+	    perror_with_name (("kill_lwp"));
+	  /* We now must resume the inferior to get SIGSTOP delivered.  */
+	  sig = 0;
+	}
+      if (ptrace (PTRACE_CONT, GET_LWP (ptid), NULL, (void *) sig) != 0)
+	perror_with_name (("ptrace"));
+    }
+  *cloned_return = cloned;
+  return 0;
+}
+
 static void
 linux_nat_attach (char *args, int from_tty)
 {
   struct lwp_info *lp;
-  pid_t pid;
   int status;
-  int cloned = 0;
+  int cloned;
 
   /* FIXME: We should probably accept a list of process id's, and
      attach all of them.  */
   linux_ops->to_attach (args, from_tty);
 
-  /* Make sure the initial process is stopped.  The user-level threads
-     layer might want to poke around in the inferior, and that won't
-     work if things haven't stabilized yet.  */
-  pid = my_waitpid (GET_PID (inferior_ptid), &status, 0);
-  if (pid == -1 && errno == ECHILD)
-    {
-      warning (_("%s is a cloned process"), target_pid_to_str (inferior_ptid));
-
-      /* Try again with __WCLONE to check cloned processes.  */
-      pid = my_waitpid (GET_PID (inferior_ptid), &status, __WCLONE);
-      cloned = 1;
-    }
-
-  gdb_assert (pid == GET_PID (inferior_ptid)
-	      && WIFSTOPPED (status) && WSTOPSIG (status) == SIGSTOP);
-
   /* Add the initial process as the first LWP to the list.  */
   inferior_ptid = BUILD_LWP (GET_PID (inferior_ptid), GET_PID (inferior_ptid));
+
+  status = linux_ptrace_post_attach (inferior_ptid, &cloned);
+  if (status != 0)
+    error (_("Program %s exited: %s\n"), target_pid_to_str (inferior_ptid),
+	   status_to_str (status));
+  if (cloned)
+    warning (_("%s is a cloned process"), target_pid_to_str (inferior_ptid));
+
+  /* ADD_LWP with TID only already after the WAITPID.  */
   lp = add_lwp (inferior_ptid);
   lp->cloned = cloned;
 
@@ -1046,8 +1200,8 @@ linux_nat_attach (char *args, int from_t
   lp->resumed = 1;
   if (debug_linux_nat)
     {
-      fprintf_unfiltered (gdb_stdlog,
-			  "LLA: waitpid %ld, faking SIGSTOP\n", (long) pid);
+      fprintf_unfiltered (gdb_stdlog, "LLA: waitpid %d, faking SIGSTOP\n",
+			  GET_PID (inferior_ptid));
     }
 }
 
@@ -1092,6 +1246,9 @@ detach_callback (struct lwp_info *lp, vo
      overall process id just yet.  */
   if (GET_LWP (lp->ptid) != GET_PID (lp->ptid))
     {
+      /* None of these threads should be stopped for PID_WAS_STOPPED.  Only the
+         last thread (process) will be stopped by LINUX_NAT_DETACH.  */
+
       errno = 0;
       if (ptrace (PTRACE_DETACH, GET_LWP (lp->ptid), 0,
 		  WSTOPSIG (lp->status)) < 0)
@@ -1120,6 +1277,9 @@ linux_nat_detach (char *args, int from_t
 
   trap_ptid = null_ptid;
 
+  if (pid_was_stopped == GET_PID (lwp_list->ptid))
+    args = STRINGIFY (SIGSTOP);
+
   /* Destroy LWP info; it's no longer valid.  */
   init_lwp_list ();
 
@@ -1255,6 +1415,14 @@ linux_nat_resume (ptid_t ptid, int step_
      resume_callback.  */
   lp->stopped = 0;
 
+  /* At this point, we are going to resume the inferior and if we
+     have attached to a stopped process, we no longer should leave
+     it as stopped if the user detaches.  PTID variable has PID set to LWP
+     while we need to check the real PID here.  */
+
+  if (!step && lp && pid_was_stopped == GET_PID (lp->ptid))
+    pid_was_stopped = 0;
+
   if (resume_all)
     iterate_over_lwps (resume_callback, NULL);
 
Index: gdb-6.8cvs20080219/gdb/doc/gdb.texinfo
===================================================================
--- gdb-6.8cvs20080219.orig/gdb/doc/gdb.texinfo	2008-02-24 19:36:24.000000000 +0100
+++ gdb-6.8cvs20080219/gdb/doc/gdb.texinfo	2008-02-24 19:36:26.000000000 +0100
@@ -2176,16 +2176,29 @@ can step and continue; you can modify st
 process continue running, you may use the @code{continue} command after
 attaching @value{GDBN} to the process.
 
+For a process already being stopped before the @code{attach} command executed
+you get the informational message below.  Other signals may be occasionally
+shown if they were being delivered right the time the @code{attach} command
+executed.  Such process is left still stopped after the @code{detach} command
+as long as you have not used the @code{continue} command (or similiar one)
+during your debugging session.
+
+@smallexample
+Attaching to program: /bin/sleep, process 16289
+Redelivering pending Stopped (signal).
+@end smallexample
+
 @table @code
 @kindex detach
 @item detach
 When you have finished debugging the attached process, you can use the
-@code{detach} command to release it from @value{GDBN} control.  Detaching
-the process continues its execution.  After the @code{detach} command,
-that process and @value{GDBN} become completely independent once more, and you
-are ready to @code{attach} another process or start one with @code{run}.
-@code{detach} does not repeat if you press @key{RET} again after
-executing the command.
+@code{detach} command to release it from @value{GDBN} control.  Detaching the
+process continues its execution unless it was already stopped before the
+attachment and a @code{continue} type command has not been executed.  After the
+@code{detach} command, that process and @value{GDBN} become completely
+independent once more, and you are ready to @code{attach} another process or
+start one with @code{run}.  @code{detach} does not repeat if you press
+@key{RET} again after executing the command.
 @end table
 
 If you exit @value{GDBN} while you have an attached process, you detach