base/SOURCES/gdb-rhbz1184724-gdb-internal-error-num-lwps.patch

From 6681535d2cecea1f67255c140f11b217518a2f4e Mon Sep 17 00:00:00 2001
From: Pedro Alves <palves@redhat.com>
Date: Wed, 17 Jun 2015 20:41:05 +0100
Subject: [PATCH] Fix BZ1184724 - gdb output a internal-error: Assertion
 `num_lwps (GET_PID (inferior_ptid)) == 1'

The real issue with this bug is in the ptrace error:

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  (gdb) c
  Continuing.
  netcfStateCleanup () at interface/interface_backend_netcf.c:116
  116	}
  ptrace: No such process.
  ^^^^^^^^^^^^^^^^^^^^^^^^
  (gdb) quit
	  Inferior 1 [process 11205] will be detached.
  Quit anyway? (y or n) y
  [Thread 0x7fefdf322880 (LWP 11205) exited]

  ../../gdb/linux-nat.c:1869: internal-error: linux_nat_detach: Assertion `num_lwps (GET_PID (inferior_ptid)) == 1' failed.
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

The assertion is just a consequence.

So the main fix is to backport the GDB [1] bits of upstream 23f238d3
(Fix race exposed by gdb.threads/killed.exp).  That makes
linux_resume_one_lwp detect when the LWP being resumed disappears.
However, we need to backport also part of 8a99810d (linux-nat.c: clean
up pending status checking and resuming LWPs), which is what
introduced the centralized linux_resume_one_lwp in the first place,
and also one bit from 8817a6f2 (PR gdb/15713 - errors from
i386_linux_resume lead to lock-up), which makes linux_nat_resume not
clear the leader LWP's lwp->stopped flag too early, otherwise we'd hit
the new assertion in check_ptrace_stopped_lwp_gone.

The test is new (not a backport), and without the fix triggers the
"detach" assertion shown above.

[1] - The equivalent GDBserver bits are harder to backport, as they
rely on GDB exceptions, which GDBserver 7.6.1 doesn't support yet.
Fortunately, GDBserver already handles ESRCH from within its
linux_resume_one_lwp, so doesn't trigger this particular bug and
passes the test.

gdb/ChangeLog:
2015-06-17  Pedro Alves  <palves@redhat.com>

	* common/linux-procfs.c (linux_proc_pid_is_trace_stopped): New
	function.
	* common/linux-procfs.h (linux_proc_pid_is_trace_stopped): New
	declaration.
	* linux-nat.c (linux_resume_one_lwp_throw, check_ptrace_stopped_lwp_gone)
	(linux_resume_one_lwp): New functions.
	(resume_lwp): Use linux_resume_one_lwp.
	(linux_nat_resume_callback): Skip if LWP is the same as the passed
	in data pointer.
	(linux_nat_resume): Don't clear the selected LWP's stopped flag
	before resuming the sibling LWPs.  Instead pass LWP to
	linux_nat_resume_callback.  Use linux_resume_one_lwp.
	(linux_handle_extended_wait, linux_nat_filter_event)
	(linux_nat_wait_1): Use linux_resume_one_lwp.
	(resume_stopped_resumed_lwps): Try register reads in TRY/CATCH and
	swallows errors if the LWP is gone.  Use
	linux_resume_one_lwp_throw instead of linux_resume_one_lwp.

gdb/testsuite/ChangeLog:
2015-06-17  Pedro Alves  <palves@redhat.com>

	* gdb.threads/thread-kills-process.c: New file.
	* gdb.threads/thread-kills-process.exp: New file.
---
 gdb/ChangeLog                                      |  13 ++
 gdb/common/linux-procfs.c                          |   6 +
 gdb/common/linux-procfs.h                          |   2 +
 gdb/linux-nat.c                                    | 200 +++++++++++++--------
 gdb/testsuite/gdb.threads/thread-kills-process.c   |  62 +++++++
 gdb/testsuite/gdb.threads/thread-kills-process.exp |  70 ++++++++
 6 files changed, 277 insertions(+), 76 deletions(-)
 create mode 100644 gdb/testsuite/gdb.threads/thread-kills-process.c
 create mode 100644 gdb/testsuite/gdb.threads/thread-kills-process.exp

Index: gdb-7.6.1/gdb/common/linux-procfs.c
===================================================================
--- gdb-7.6.1.orig/gdb/common/linux-procfs.c
+++ gdb-7.6.1/gdb/common/linux-procfs.c
@@ -111,6 +111,12 @@ linux_proc_pid_is_stopped (pid_t pid)
   return linux_proc_pid_has_state (pid, "T (stopped)");
 }
 
+int
+linux_proc_pid_is_trace_stopped (pid_t pid)
+{
+  return linux_proc_pid_has_state (pid, "T (tracing stop)");
+}
+
 /* See linux-procfs.h declaration.  */
 
 int
Index: gdb-7.6.1/gdb/common/linux-procfs.h
===================================================================
--- gdb-7.6.1.orig/gdb/common/linux-procfs.h
+++ gdb-7.6.1/gdb/common/linux-procfs.h
@@ -36,6 +36,8 @@ extern pid_t linux_proc_get_tracerpid (p
 
 extern int linux_proc_pid_is_stopped (pid_t pid);
 
+extern int linux_proc_pid_is_trace_stopped (pid_t pid);
+
 /* Return non-zero if PID is a zombie.  */
 
 extern int linux_proc_pid_is_zombie (pid_t pid);
Index: gdb-7.6.1/gdb/linux-nat.c
===================================================================
--- gdb-7.6.1.orig/gdb/linux-nat.c
+++ gdb-7.6.1/gdb/linux-nat.c
@@ -1928,6 +1928,85 @@ linux_nat_detach (struct target_ops *ops
     linux_ops->to_detach (ops, args, from_tty);
 }
 
+/* Resume execution of the inferior process.  If STEP is nonzero,
+   single-step it.  If SIGNAL is nonzero, give it that signal.  */
+
+static void
+linux_resume_one_lwp_throw (struct lwp_info *lp, int step,
+			    enum gdb_signal signo)
+{
+  ptid_t ptid;
+
+  lp->step = step;
+
+  if (linux_nat_prepare_to_resume != NULL)
+    linux_nat_prepare_to_resume (lp);
+
+  ptid = pid_to_ptid (GET_LWP (lp->ptid));
+  linux_ops->to_resume (linux_ops, ptid, step, signo);
+
+  /* Successfully resumed.  Clear state that no longer makes sense,
+     and mark the LWP as running.  Must not do this before resuming
+     otherwise if that fails other code will be confused.  E.g., we'd
+     later try to stop the LWP and hang forever waiting for a stop
+     status.  Note that we must not throw after this is cleared,
+     otherwise handle_zombie_lwp_error would get confused.  */
+  lp->stopped = 0;
+  lp->stopped_by_watchpoint = 0;
+  registers_changed_ptid (lp->ptid);
+}
+
+/* Called when we try to resume a stopped LWP and that errors out.  If
+   the LWP is no longer in ptrace-stopped state (meaning it's zombie,
+   or about to become), discard the error, clear any pending status
+   the LWP may have, and return true (we'll collect the exit status
+   soon enough).  Otherwise, return false.  */
+
+static int
+check_ptrace_stopped_lwp_gone (struct lwp_info *lp)
+{
+  /* If we get an error after resuming the LWP successfully, we'd
+     confuse !T state for the LWP being gone.  */
+  gdb_assert (lp->stopped);
+
+  /* We can't just check whether the LWP is in 'Z (Zombie)' state,
+     because even if ptrace failed with ESRCH, the tracee may be "not
+     yet fully dead", but already refusing ptrace requests.  In that
+     case the tracee has 'R (Running)' state for a little bit
+     (observed in Linux 3.18).  See also the note on ESRCH in the
+     ptrace(2) man page.  Instead, check whether the LWP has any state
+     other than ptrace-stopped.  */
+
+  /* Don't assume anything if /proc/PID/status can't be read.  */
+  if (linux_proc_pid_is_trace_stopped (ptid_get_lwp (lp->ptid)) == 0)
+    {
+      lp->status = 0;
+      lp->waitstatus.kind = TARGET_WAITKIND_IGNORE;
+      lp->stopped_by_watchpoint = 0;
+      return 1;
+    }
+  return 0;
+}
+
+/* Like linux_resume_one_lwp_throw, but no error is thrown if the LWP
+   disappears while we try to resume it.  */
+
+static void
+linux_resume_one_lwp (struct lwp_info *lp, int step, enum gdb_signal signo)
+{
+  volatile struct gdb_exception ex;
+
+  TRY_CATCH (ex, RETURN_MASK_ERROR)
+    {
+      linux_resume_one_lwp_throw (lp, step, signo);
+    }
+  if (ex.reason < 0)
+    {
+      if (!check_ptrace_stopped_lwp_gone (lp))
+	throw_exception (ex);
+    }
+}
+
 /* Resume LP.  */
 
 static void
@@ -1956,14 +2035,7 @@ resume_lwp (struct lwp_info *lp, int ste
 				 : "0"),
 				step ? "step" : "resume");
 
-	  if (linux_nat_prepare_to_resume != NULL)
-	    linux_nat_prepare_to_resume (lp);
-	  linux_ops->to_resume (linux_ops,
-				pid_to_ptid (GET_LWP (lp->ptid)),
-				step, signo);
-	  lp->stopped = 0;
-	  lp->step = step;
-	  lp->stopped_by_watchpoint = 0;
+	  linux_resume_one_lwp (lp, step, signo);
 	}
       else
 	{
@@ -1982,13 +2054,17 @@ resume_lwp (struct lwp_info *lp, int ste
     }
 }
 
-/* Resume LWP, with the last stop signal, if it is in pass state.  */
+/* Callback for iterate_over_lwps.  If LWP is EXCEPT, do nothing.
+   Resume LWP with the last stop signal, if it is in pass state.  */
 
 static int
-linux_nat_resume_callback (struct lwp_info *lp, void *data)
+linux_nat_resume_callback (struct lwp_info *lp, void *except)
 {
   enum gdb_signal signo = GDB_SIGNAL_0;
 
+  if (lp == except)
+    return 0;
+
   if (lp->stopped)
     {
       struct thread_info *thread;
@@ -2108,20 +2184,10 @@ linux_nat_resume (struct target_ops *ops
       return;
     }
 
-  /* Mark LWP as not stopped to prevent it from being continued by
-     linux_nat_resume_callback.  */
-  lp->stopped = 0;
-
   if (resume_many)
-    iterate_over_lwps (ptid, linux_nat_resume_callback, NULL);
+    iterate_over_lwps (ptid, linux_nat_resume_callback, lp);
 
-  /* Convert to something the lower layer understands.  */
-  ptid = pid_to_ptid (GET_LWP (lp->ptid));
-
-  if (linux_nat_prepare_to_resume != NULL)
-    linux_nat_prepare_to_resume (lp);
-  linux_ops->to_resume (linux_ops, ptid, step, signo);
-  lp->stopped_by_watchpoint = 0;
+  linux_resume_one_lwp (lp, step, signo);
 
   if (debug_linux_nat)
     fprintf_unfiltered (gdb_stdlog,
@@ -2287,11 +2353,7 @@ linux_handle_syscall_trap (struct lwp_in
 
   /* Note that gdbarch_get_syscall_number may access registers, hence
      fill a regcache.  */
-  registers_changed ();
-  if (linux_nat_prepare_to_resume != NULL)
-    linux_nat_prepare_to_resume (lp);
-  linux_ops->to_resume (linux_ops, pid_to_ptid (GET_LWP (lp->ptid)),
-			lp->step, GDB_SIGNAL_0);
+  linux_resume_one_lwp (lp, lp->step, GDB_SIGNAL_0);
   return 1;
 }
 
@@ -2486,22 +2548,15 @@ linux_handle_extended_wait (struct lwp_i
 		    fprintf_unfiltered (gdb_stdlog,
 					"LHEW: resuming new LWP %ld\n",
 					GET_LWP (new_lp->ptid));
-		  if (linux_nat_prepare_to_resume != NULL)
-		    linux_nat_prepare_to_resume (new_lp);
-		  linux_ops->to_resume (linux_ops, pid_to_ptid (new_pid),
-					0, GDB_SIGNAL_0);
-		  new_lp->stopped = 0;
+
+		  linux_resume_one_lwp (new_lp, 0, GDB_SIGNAL_0);
 		}
 	    }
 
 	  if (debug_linux_nat)
 	    fprintf_unfiltered (gdb_stdlog,
 				"LHEW: resuming parent LWP %d\n", pid);
-	  if (linux_nat_prepare_to_resume != NULL)
-	    linux_nat_prepare_to_resume (lp);
-	  linux_ops->to_resume (linux_ops, pid_to_ptid (GET_LWP (lp->ptid)),
-				0, GDB_SIGNAL_0);
-
+	  linux_resume_one_lwp (lp, 0, GDB_SIGNAL_0);
 	  return 1;
 	}
 
@@ -3382,12 +3437,7 @@ linux_nat_filter_event (int lwpid, int s
 	{
 	  /* This is a delayed SIGSTOP.  */
 
-	  registers_changed ();
-
-	  if (linux_nat_prepare_to_resume != NULL)
-	    linux_nat_prepare_to_resume (lp);
-	  linux_ops->to_resume (linux_ops, pid_to_ptid (GET_LWP (lp->ptid)),
-			    lp->step, GDB_SIGNAL_0);
+	  linux_resume_one_lwp (lp, lp->step, GDB_SIGNAL_0);
 	  if (debug_linux_nat)
 	    fprintf_unfiltered (gdb_stdlog,
 				"LLW: %s %s, 0, 0 (discard SIGSTOP)\n",
@@ -3395,7 +3445,6 @@ linux_nat_filter_event (int lwpid, int s
 				"PTRACE_SINGLESTEP" : "PTRACE_CONT",
 				target_pid_to_str (lp->ptid));
 
-	  lp->stopped = 0;
 	  gdb_assert (lp->resumed);
 
 	  /* Discard the event.  */
@@ -3416,11 +3465,7 @@ linux_nat_filter_event (int lwpid, int s
       /* This is a delayed SIGINT.  */
       lp->ignore_sigint = 0;
 
-      registers_changed ();
-      if (linux_nat_prepare_to_resume != NULL)
-	linux_nat_prepare_to_resume (lp);
-      linux_ops->to_resume (linux_ops, pid_to_ptid (GET_LWP (lp->ptid)),
-			    lp->step, GDB_SIGNAL_0);
+      linux_resume_one_lwp (lp, lp->step, GDB_SIGNAL_0);
       if (debug_linux_nat)
 	fprintf_unfiltered (gdb_stdlog,
 			    "LLW: %s %s, 0, 0 (discard SIGINT)\n",
@@ -3428,7 +3473,6 @@ linux_nat_filter_event (int lwpid, int s
 			    "PTRACE_SINGLESTEP" : "PTRACE_CONT",
 			    target_pid_to_str (lp->ptid));
 
-      lp->stopped = 0;
       gdb_assert (lp->resumed);
 
       /* Discard the event.  */
@@ -3796,11 +3840,7 @@ retry:
 	     other threads to run.  On the other hand, not resuming
 	     newly attached threads may cause an unwanted delay in
 	     getting them running.  */
-	  registers_changed ();
-	  if (linux_nat_prepare_to_resume != NULL)
-	    linux_nat_prepare_to_resume (lp);
-	  linux_ops->to_resume (linux_ops, pid_to_ptid (GET_LWP (lp->ptid)),
-				lp->step, signo);
+	  linux_resume_one_lwp (lp, lp->step, signo);
 	  if (debug_linux_nat)
 	    fprintf_unfiltered (gdb_stdlog,
 				"LLW: %s %s, %s (preempt 'handle')\n",
@@ -3810,7 +3850,6 @@ retry:
 				(signo != GDB_SIGNAL_0
 				 ? strsignal (gdb_signal_to_host (signo))
 				 : "0"));
-	  lp->stopped = 0;
 	  goto retry;
 	}
 
@@ -3935,32 +3974,41 @@ resume_stopped_resumed_lwps (struct lwp_
     {
       struct regcache *regcache = get_thread_regcache (lp->ptid);
       struct gdbarch *gdbarch = get_regcache_arch (regcache);
-      CORE_ADDR pc = regcache_read_pc (regcache);
+      volatile struct gdb_exception ex;
 
       gdb_assert (is_executing (lp->ptid));
 
-      /* Don't bother if there's a breakpoint at PC that we'd hit
-	 immediately, and we're not waiting for this LWP.  */
-      if (!ptid_match (lp->ptid, *wait_ptid_p))
+      TRY_CATCH (ex, RETURN_MASK_ERROR)
 	{
-	  if (breakpoint_inserted_here_p (get_regcache_aspace (regcache), pc))
-	    return 0;
-	}
+	  CORE_ADDR pc = regcache_read_pc (regcache);
+	  int leave_stopped = 0;
 
-      if (debug_linux_nat)
-	fprintf_unfiltered (gdb_stdlog,
-			    "RSRL: resuming stopped-resumed LWP %s at %s: step=%d\n",
-			    target_pid_to_str (lp->ptid),
-			    paddress (gdbarch, pc),
-			    lp->step);
+	  /* Don't bother if there's a breakpoint at PC that we'd hit
+	     immediately, and we're not waiting for this LWP.  */
+	  if (!ptid_match (lp->ptid, *wait_ptid_p))
+	    {
+	      if (breakpoint_inserted_here_p (get_regcache_aspace (regcache), pc))
+		leave_stopped = 1;
+	    }
 
-      registers_changed ();
-      if (linux_nat_prepare_to_resume != NULL)
-	linux_nat_prepare_to_resume (lp);
-      linux_ops->to_resume (linux_ops, pid_to_ptid (GET_LWP (lp->ptid)),
-			    lp->step, GDB_SIGNAL_0);
-      lp->stopped = 0;
-      lp->stopped_by_watchpoint = 0;
+	  if (!leave_stopped)
+	    {
+	      if (debug_linux_nat)
+		fprintf_unfiltered (gdb_stdlog,
+				    "RSRL: resuming stopped-resumed LWP %s at "
+				    "%s: step=%d\n",
+				    target_pid_to_str (lp->ptid),
+				    paddress (gdbarch, pc),
+				    lp->step);
+
+	      linux_resume_one_lwp_throw (lp, lp->step, GDB_SIGNAL_0);
+	    }
+	}
+      if (ex.reason < 0)
+	{
+	  if (!check_ptrace_stopped_lwp_gone (lp))
+	    throw_exception (ex);
+	}
     }
 
   return 0;
Index: gdb-7.6.1/gdb/testsuite/gdb.threads/thread-kills-process.c
===================================================================
--- /dev/null
+++ gdb-7.6.1/gdb/testsuite/gdb.threads/thread-kills-process.c
@@ -0,0 +1,62 @@
+/* Copyright 2015 Free Software Foundation, Inc.
+
+   This file is part of GDB.
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 3 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
+
+#include <pthread.h>
+#include <unistd.h>
+
+volatile int call_exit;
+static pthread_barrier_t barrier;
+#define NUMTHREADS 256
+
+void *
+thread_function (void *arg)
+{
+  pthread_barrier_wait (&barrier);
+
+  while (!call_exit)
+    usleep (1);
+
+  _exit (0);
+  return NULL;
+}
+
+void
+all_threads_started (void)
+{
+  call_exit = 1;
+}
+
+int
+main (int argc, char **argv)
+{
+  pthread_t threads[NUMTHREADS];
+  int i;
+
+  pthread_barrier_init (&barrier, NULL, NUMTHREADS + 1);
+
+  for (i = 0; i < NUMTHREADS; ++i)
+    pthread_create (&threads[i], NULL, thread_function, NULL);
+
+  pthread_barrier_wait (&barrier);
+
+  all_threads_started ();
+
+  for (i = 0; i < NUMTHREADS; ++i)
+    pthread_join (threads[i], NULL);
+
+  return 0;
+}
Index: gdb-7.6.1/gdb/testsuite/gdb.threads/thread-kills-process.exp
===================================================================
--- /dev/null
+++ gdb-7.6.1/gdb/testsuite/gdb.threads/thread-kills-process.exp
@@ -0,0 +1,70 @@
+# Copyright (C) 2015 Free Software Foundation, Inc.
+
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+standard_testfile
+
+if {[gdb_compile_pthreads "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable {debug}] != "" } {
+    return -1
+}
+
+clean_restart ${binfile}
+if {![runto_main]} {
+    fail "Couldn't run to main"
+    return
+}
+
+gdb_breakpoint "all_threads_started"
+
+gdb_continue_to_breakpoint "all_threads_started"
+
+# Update the thread list, otherwise when testing against GDBserver,
+# GDB won't know about thread 2.  (Only necessary with GDB < 7.9.)
+gdb_test "info threads" ".*"
+
+# Select any thread but the leader.
+gdb_test "thread 2" ".*" "switch to non-leader thread"
+
+# Delete breakpoints so that GDB doesn't switch back the to leader to
+# step over its breakpoint.
+delete_breakpoints
+
+# Let threads exit the process on next resume.
+gdb_test "p call_exit = 0" " = 0"
+
+# While GDB is busy resuming all threads one by one, one of the
+# threads should manage to exit the process.  GDB should handle that
+# gracefully instead of erroring out.
+#
+# gdb_continue_to_end doesn't work with GDBserver until the
+# introduction of the "exit_is_reliable" board variable
+# (b477a5e649150) in GDB 7.7.
+#gdb_continue_to_end "" continue 1
+gdb_test "continue" "$inferior_exited_re normally.*"
+
+# On the buggy GDB where the "continue" above would error out, a
+# subsequent "detach" (e.g., the user tries to quit GDB, and quit
+# offers to detach) would hit this assertion:
+#
+#   linux-nat.c:1869: internal-error: linux_nat_detach: Assertion `num_lwps (GET_PID (inferior_ptid)) == 1' failed.
+
+# That was a consequence of the original bug, but let's make sure that
+# even when "continue" is handled properly, detach doesn't stumble on
+# anything stale.
+gdb_test "detach" "The program is not being run\\." \
+    "detach after exit"
+
+# Likewise "continue".
+gdb_test "continue" "The program is not being run\\." \
+    "continue after exit"