[pushed] Re: [PATCH/7.10 2/2] gdbserver: Fix non-stop / fork / step-over issues

Pedro Alves
2015-08-06T09:44:41Z

On 08/05/2015 04:10 PM, Pedro Alves wrote:
> On 08/05/2015 12:41 PM, Yao Qi wrote:
>> Pedro Alves <palves@redhat.com> writes:
>>
>>> I've now extended the test to run in a few different modes, along
>>> a couple different axis. One axis is with/without conditional
>>> breakpoints on the target enabled. That exposes the same fails you
>>> saw on arm, on x86 gdbserver as well. And then the other axis is
>>> with/without joining _all_ threads before exiting. If we gracefully
>>> terminate the breakpoint thread (new mode), then the test should be
>>> passing everywhere, because what fails is gdb's handling of the inferior
>>> disappearing while a thread is stopped (and being inspected).
>>> Therefore that new mode is not kfailed.
>>>
>>> For testing convenience, I've pushed this along with the previous patch
>>> to the users/palves/gdbserver-fork-issues branch on sourceware.org.
>>> Let me know if this works for you.
>>
>> Thanks, Pedro. There are no fails on arm-linux with GDBserver. Some
>> comments on your patch below,
>
> Thanks Yao, that's great.
>
> Thinking about this some more made me want to split both the patch
> and test in two. The process-exits-while-handling-breakpoints issues
> happen independently of the fork issues, so I'll make the fork test always
> join all threads before exiting. Splitting will result in two
> cleaner and more directed tests. As per your testing, the fork test
> will not need any kfail.

I've done that now. I'll send the
process-exits-while-handling-breakpoints test and patch separately.

>> @@ -3089,8 +3142,25 @@ linux_wait_1 (ptid_t ptid,
>> info_p = &info;
>> else
>> info_p = NULL;
>> - linux_resume_one_lwp (event_child, event_child->stepping,
>> - WSTOPSIG (w), info_p);
>> +
>> + if (step_over_finished)
>> + {
>> + /* We cancelled this thread's step-over above. We still
>> + need to unsuspend all other LWPs, and set then back
>
> s/set then/set them/?

Fixed.

>> @@ -3111,8 +3181,15 @@ linux_wait_1 (ptid_t ptid,
>> || (current_thread->last_resume_kind == resume_step
>> && !in_step_range)
>> || event_child->stop_reason == TARGET_STOPPED_BY_WATCHPOINT
>> - || (!step_over_finished && !in_step_range
>> - && !bp_explains_trap && !trace_event)
>> + || (!in_step_range
>> + && !bp_explains_trap
>> + && !trace_event
>> + /* A step-over was finished just now? */
>> + && !step_over_finished
>> + /* A step-over had been finished previously,
>> + and the single-step was left pending? */
>> + && !(current_thread->last_resume_kind == resume_continue
>> + && event_child->stop_reason == TARGET_STOPPED_BY_SINGLE_STEP))
>> || (gdb_breakpoint_here (event_child->stop_pc)
>
> I don't fully understand this, what is a case that "step-over had been
> finished previously, but the single-step was left pending"?
>
>> (linux_wait_1): If passing a signal to the inferior after
>> finishing a step-over, unsuspend and re-resume all lwps. If we
>> see a single-step event but the thread should be continuing, don't
>> pass the trap to gdb.
>
> however, the explanations in ChangeLog look more reasonable.

Indeed. I've moved the comment above to where the rest of the
explanations are and clarified it. I also renamed the test,
and cleaned it up a little bit.

Below's what I pushed to master. I'll push it to 7.10 too in a bit.

Thanks!

---
From 863d01bde2725d009c45ab7e9ba1dbf3f5b923f8 Mon Sep 17 00:00:00 2001
From: Pedro Alves <palves@redhat.com>
Date: Thu, 6 Aug 2015 10:30:18 +0100
Subject: [PATCH 3/3] gdbserver: Fix non-stop / fork / step-over issues

Ref: https://sourceware.org/ml/gdb-patches/2015-07/msg00868.html

This adds a test that has a multithreaded program have several threads
continuously fork, while another thread continuously steps over a
breakpoint.

This exposes several intertwined issues, which this patch addresses:

- When we're stopping and suspending threads, some thread may fork,
and we missed setting its suspend count to 1, like we do when a new
clone/thread is detected. When we next unsuspend threads, the fork
child's suspend count goes below 0, which is bogus and fails an
assertion.

- If a step-over is cancelled because a signal arrives, but then gdb
is not interested in the signal, we pass the signal straight back
to the inferior. However, we miss that we need to re-increment the
suspend counts of all other threads that had been paused for the
step-over. As a result, other threads indefinitely end up stuck
stopped.

- If a detach request comes in just while gdbserver is handling a
step-over (in the test at hand, this is GDB detaching the fork
child), gdbserver internal errors in stabilize_thread's helpers,
which assert that all thread's suspend counts are 0 (otherwise we
wouldn't be able to move threads out of the jump pads). The
suspend counts aren't 0 while a step-over is in progress, because
all threads but the one stepping past the breakpoint must remain
paused until the step-over finishes and the breakpoint can be
reinserted.

- Occasionally, we see "BAD - reinserting but not stepping." being
output (from within linux_resume_one_lwp_throw). That was because
GDB pokes memory while gdbserver is busy with a step-over, and that
suspends threads, and then re-resumes them with proceed_one_lwp,
which missed another reason to tell linux_resume_one_lwp that the
thread should be set back to stepping.

- In a couple places, we were resuming threads that are meant to be
suspended. E.g., when a vCont;c/s request for thread B comes in
just while gdbserver is stepping thread A past a breakpoint. The
resume for thread B must be deferred until the step-over finishes.

- The test runs with both "set detach-on-fork" on and off. When off,
it exercises the case of GDB detaching the fork child explicitly.
When on, it exercises the case of gdb resuming the child
explicitly. In the "off" case, gdb seems to exponentially become
slower as new inferiors are created. This is _very_ noticeable as
with only 100 inferiors gdb is crawling already, which makes the
test take quite a bit to run. For that reason, I've disabled the
"off" variant for now.

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

* target/waitstatus.h (enum target_stop_reason)
<TARGET_STOPPED_BY_SINGLE_STEP>: New value.

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

* linux-low.c (handle_extended_wait): Set the fork child's suspend
count if stopping and suspending threads.
(check_stopped_by_breakpoint): If stopped by trace, set the LWP's
stop reason to TARGET_STOPPED_BY_SINGLE_STEP.
(linux_detach): Complete an ongoing step-over.
(lwp_suspended_inc, lwp_suspended_decr): New functions. Use
throughout.
(resume_stopped_resumed_lwps): Don't resume a suspended thread.
(linux_wait_1): If passing a signal to the inferior after
finishing a step-over, unsuspend and re-resume all lwps. If we
see a single-step event but the thread should be continuing, don't
pass the trap to gdb.
(stuck_in_jump_pad_callback, move_out_of_jump_pad_callback): Use
internal_error instead of gdb_assert.
(enqueue_pending_signal): New function.
(check_ptrace_stopped_lwp_gone): Add debug output.
(start_step_over): Use internal_error instead of gdb_assert.
(complete_ongoing_step_over): New function.
(linux_resume_one_thread): Don't resume a suspended thread.
(proceed_one_lwp): If the LWP is stepping over a breakpoint, reset
it stepping.

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

* gdb.threads/forking-threads-plus-breakpoint.exp: New file.
* gdb.threads/forking-threads-plus-breakpoint.c: New file.
---
gdb/ChangeLog | 5 +
gdb/gdbserver/ChangeLog | 24 +++
gdb/testsuite/ChangeLog | 5 +
gdb/gdbserver/linux-low.c | 221 ++++++++++++++++++---
gdb/target/waitstatus.h | 5 +-
.../gdb.threads/forking-threads-plus-breakpoint.c | 139 +++++++++++++
.../forking-threads-plus-breakpoint.exp | 117 +++++++++++
7 files changed, 486 insertions(+), 30 deletions(-)
create mode 100644 gdb/testsuite/gdb.threads/forking-threads-plus-breakpoint.c
create mode 100644 gdb/testsuite/gdb.threads/forking-threads-plus-breakpoint.exp

diff --git a/gdb/ChangeLog b/gdb/ChangeLog
index 7ea7a02..65a540c 100644
--- a/gdb/ChangeLog
+++ b/gdb/ChangeLog
@@ -1,3 +1,8 @@
+2015-08-06 Pedro Alves <palves@redhat.com>
+
+ * target/waitstatus.h (enum target_stop_reason)
+ <TARGET_STOPPED_BY_SINGLE_STEP>: New value.
+
2015-08-05 Pedro Alves <palves@redhat.com>
Joel Brobecker <brobecker@adacore.com>

diff --git a/gdb/gdbserver/ChangeLog b/gdb/gdbserver/ChangeLog
index 77b4330..5588fb0 100644
--- a/gdb/gdbserver/ChangeLog
+++ b/gdb/gdbserver/ChangeLog
@@ -1,5 +1,29 @@
2015-08-06 Pedro Alves <palves@redhat.com>

+ * linux-low.c (handle_extended_wait): Set the fork child's suspend
+ count if stopping and suspending threads.
+ (check_stopped_by_breakpoint): If stopped by trace, set the LWP's
+ stop reason to TARGET_STOPPED_BY_SINGLE_STEP.
+ (linux_detach): Complete an ongoing step-over.
+ (lwp_suspended_inc, lwp_suspended_decr): New functions. Use
+ throughout.
+ (resume_stopped_resumed_lwps): Don't resume a suspended thread.
+ (linux_wait_1): If passing a signal to the inferior after
+ finishing a step-over, unsuspend and re-resume all lwps. If we
+ see a single-step event but the thread should be continuing, don't
+ pass the trap to gdb.
+ (stuck_in_jump_pad_callback, move_out_of_jump_pad_callback): Use
+ internal_error instead of gdb_assert.
+ (enqueue_pending_signal): New function.
+ (check_ptrace_stopped_lwp_gone): Add debug output.
+ (start_step_over): Use internal_error instead of gdb_assert.
+ (complete_ongoing_step_over): New function.
+ (linux_resume_one_thread): Don't resume a suspended thread.
+ (proceed_one_lwp): If the LWP is stepping over a breakpoint, reset
+ it stepping.
+
+2015-08-06 Pedro Alves <palves@redhat.com>
+
* linux-low.c (add_lwp): Set waitstatus to TARGET_WAITKIND_IGNORE.
(linux_thread_alive): Use lwp_is_marked_dead.
(extended_event_reported): Delete.
diff --git a/gdb/testsuite/ChangeLog b/gdb/testsuite/ChangeLog
index 59d0be7..ad63b02 100644
--- a/gdb/testsuite/ChangeLog
+++ b/gdb/testsuite/ChangeLog
@@ -1,3 +1,8 @@
+2015-08-06 Pedro Alves <palves@redhat.com>
+
+ * gdb.threads/forking-threads-plus-breakpoint.exp: New file.
+ * gdb.threads/forking-threads-plus-breakpoint.c: New file.
+
2015-08-05 Pedro Alves <palves@redhat.com>

* gdb.threads/next-while-other-thread-longjmps.c: New file.
diff --git a/gdb/gdbserver/linux-low.c b/gdb/gdbserver/linux-low.c
index 6a7182a..98fffc9 100644
--- a/gdb/gdbserver/linux-low.c
+++ b/gdb/gdbserver/linux-low.c
@@ -271,6 +271,8 @@ static int lwp_is_marked_dead (struct lwp_info *lwp);
static void proceed_all_lwps (void);
static int finish_step_over (struct lwp_info *lwp);
static int kill_lwp (unsigned long lwpid, int signo);
+static void enqueue_pending_signal (struct lwp_info *lwp, int signal, siginfo_t *info);
+static void complete_ongoing_step_over (void);

/* When the event-loop is doing a step-over, this points at the thread
being stepped. */
@@ -489,6 +491,15 @@ handle_extended_wait (struct lwp_info *event_lwp, int wstat)
child_thr->last_resume_kind = resume_stop;
child_thr->last_status.kind = TARGET_WAITKIND_STOPPED;

+ /* If we're suspending all threads, leave this one suspended
+ too. */
+ if (stopping_threads == STOPPING_AND_SUSPENDING_THREADS)
+ {
+ if (debug_threads)
+ debug_printf ("HEW: leaving child suspended\n");
+ child_lwp->suspended = 1;
+ }
+
parent_proc = get_thread_process (event_thr);
child_proc->attached = parent_proc->attached;
clone_all_breakpoints (&child_proc->breakpoints,
@@ -688,6 +699,8 @@ check_stopped_by_breakpoint (struct lwp_info *lwp)
debug_printf ("CSBB: %s stopped by trace\n",
target_pid_to_str (ptid_of (thr)));
}
+
+ lwp->stop_reason = TARGET_STOPPED_BY_SINGLE_STEP;
}
}
}
@@ -1318,6 +1331,11 @@ linux_detach (int pid)
if (process == NULL)
return -1;

+ /* As there's a step over already in progress, let it finish first,
+ otherwise nesting a stabilize_threads operation on top gets real
+ messy. */
+ complete_ongoing_step_over ();
+
/* Stop all threads before detaching. First, ptrace requires that
the thread is stopped to sucessfully detach. Second, thread_db
may need to uninstall thread event breakpoints from memory, which
@@ -1686,6 +1704,39 @@ not_stopped_callback (struct inferior_list_entry *entry, void *arg)
return 0;
}

+/* Increment LWP's suspend count. */
+
+static void
+lwp_suspended_inc (struct lwp_info *lwp)
+{
+ lwp->suspended++;
+
+ if (debug_threads && lwp->suspended > 4)
+ {
+ struct thread_info *thread = get_lwp_thread (lwp);
+
+ debug_printf ("LWP %ld has a suspiciously high suspend count,"
+ " suspended=%d\n", lwpid_of (thread), lwp->suspended);
+ }
+}
+
+/* Decrement LWP's suspend count. */
+
+static void
+lwp_suspended_decr (struct lwp_info *lwp)
+{
+ lwp->suspended--;
+
+ if (lwp->suspended < 0)
+ {
+ struct thread_info *thread = get_lwp_thread (lwp);
+
+ internal_error (__FILE__, __LINE__,
+ "unsuspend LWP %ld, suspended=%d\n", lwpid_of (thread),
+ lwp->suspended);
+ }
+}
+
/* This function should only be called if the LWP got a SIGTRAP.

Handle any tracepoint steps or hits. Return true if a tracepoint
@@ -1703,7 +1754,7 @@ handle_tracepoints (struct lwp_info *lwp)
uninsert tracepoints. To do this, we temporarily pause all
threads, unpatch away, and then unpause threads. We need to make
sure the unpausing doesn't resume LWP too. */
- lwp->suspended++;
+ lwp_suspended_inc (lwp);

/* And we need to be sure that any all-threads-stopping doesn't try
to move threads out of the jump pads, as it could deadlock the
@@ -1719,7 +1770,7 @@ handle_tracepoints (struct lwp_info *lwp)
actions. */
tpoint_related_event |= tracepoint_was_hit (tinfo, lwp->stop_pc);

- lwp->suspended--;
+ lwp_suspended_decr (lwp);

gdb_assert (lwp->suspended == 0);
gdb_assert (!stabilizing_threads || lwp->collecting_fast_tracepoint);
@@ -2179,10 +2230,13 @@ linux_low_filter_event (int lwpid, int wstat)

/* Note that TRAP_HWBKPT can indicate either a hardware breakpoint
or hardware watchpoint. Check which is which if we got
- TARGET_STOPPED_BY_HW_BREAKPOINT. */
+ TARGET_STOPPED_BY_HW_BREAKPOINT. Likewise, we may have single
+ stepped an instruction that triggered a watchpoint. In that
+ case, on some architectures (such as x86), instead of
+ TRAP_HWBKPT, si_code indicates TRAP_TRACE, and we need to check
+ the debug registers separately. */
if (WIFSTOPPED (wstat) && WSTOPSIG (wstat) == SIGTRAP
- && (child->stop_reason == TARGET_STOPPED_BY_NO_REASON
- || child->stop_reason == TARGET_STOPPED_BY_HW_BREAKPOINT))
+ && child->stop_reason != TARGET_STOPPED_BY_SW_BREAKPOINT)
check_stopped_by_watchpoint (child);

if (!have_stop_pc)
@@ -2241,6 +2295,7 @@ resume_stopped_resumed_lwps (struct inferior_list_entry *entry)
struct lwp_info *lp = get_thread_lwp (thread);

if (lp->stopped
+ && !lp->suspended
&& !lp->status_pending_p
&& thread->last_resume_kind != resume_stop
&& thread->last_status.kind == TARGET_WAITKIND_IGNORE)
@@ -2611,9 +2666,7 @@ unsuspend_one_lwp (struct inferior_list_entry *entry, void *except)
if (lwp == except)
return 0;

- lwp->suspended--;
-
- gdb_assert (lwp->suspended >= 0);
+ lwp_suspended_decr (lwp);
return 0;
}

@@ -2706,7 +2759,7 @@ linux_stabilize_threads (void)
lwp = get_thread_lwp (current_thread);

/* Lock it. */
- lwp->suspended++;
+ lwp_suspended_inc (lwp);

if (ourstatus.value.sig != GDB_SIGNAL_0
|| current_thread->last_resume_kind == resume_stop)
@@ -3092,8 +3145,25 @@ linux_wait_1 (ptid_t ptid,
info_p = &info;
else
info_p = NULL;
- linux_resume_one_lwp (event_child, event_child->stepping,
- WSTOPSIG (w), info_p);
+
+ if (step_over_finished)
+ {
+ /* We cancelled this thread's step-over above. We still
+ need to unsuspend all other LWPs, and set them back
+ running again while the signal handler runs. */
+ unsuspend_all_lwps (event_child);
+
+ /* Enqueue the pending signal info so that proceed_all_lwps
+ doesn't lose it. */
+ enqueue_pending_signal (event_child, WSTOPSIG (w), info_p);
+
+ proceed_all_lwps ();
+ }
+ else
+ {
+ linux_resume_one_lwp (event_child, event_child->stepping,
+ WSTOPSIG (w), info_p);
+ }
return ignore_event (ourstatus);
}

@@ -3109,13 +3179,21 @@ linux_wait_1 (ptid_t ptid,
do, we're be able to handle GDB breakpoints on top of internal
breakpoints, by handling the internal breakpoint and still
reporting the event to GDB. If we don't, we're out of luck, GDB
- won't see the breakpoint hit. */
+ won't see the breakpoint hit. If we see a single-step event but
+ the thread should be continuing, don't pass the trap to gdb.
+ That indicates that we had previously finished a single-step but
+ left the single-step pending -- see
+ complete_ongoing_step_over. */
report_to_gdb = (!maybe_internal_trap
|| (current_thread->last_resume_kind == resume_step
&& !in_step_range)
|| event_child->stop_reason == TARGET_STOPPED_BY_WATCHPOINT
- || (!step_over_finished && !in_step_range
- && !bp_explains_trap && !trace_event)
+ || (!in_step_range
+ && !bp_explains_trap
+ && !trace_event
+ && !step_over_finished
+ && !(current_thread->last_resume_kind == resume_continue
+ && event_child->stop_reason == TARGET_STOPPED_BY_SINGLE_STEP))
|| (gdb_breakpoint_here (event_child->stop_pc)
&& gdb_condition_true_at_breakpoint (event_child->stop_pc)
&& gdb_no_commands_at_breakpoint (event_child->stop_pc))
@@ -3463,7 +3541,7 @@ suspend_and_send_sigstop_callback (struct inferior_list_entry *entry,
if (lwp == except)
return 0;

- lwp->suspended++;
+ lwp_suspended_inc (lwp);

return send_sigstop_callback (entry, except);
}
@@ -3565,7 +3643,12 @@ stuck_in_jump_pad_callback (struct inferior_list_entry *entry, void *data)
struct thread_info *thread = (struct thread_info *) entry;
struct lwp_info *lwp = get_thread_lwp (thread);

- gdb_assert (lwp->suspended == 0);
+ if (lwp->suspended != 0)
+ {
+ internal_error (__FILE__, __LINE__,
+ "LWP %ld is suspended, suspended=%d\n",
+ lwpid_of (thread), lwp->suspended);
+ }
gdb_assert (lwp->stopped);

/* Allow debugging the jump pad, gdb_collect, etc.. */
@@ -3584,7 +3667,12 @@ move_out_of_jump_pad_callback (struct inferior_list_entry *entry)
struct lwp_info *lwp = get_thread_lwp (thread);
int *wstat;

- gdb_assert (lwp->suspended == 0);
+ if (lwp->suspended != 0)
+ {
+ internal_error (__FILE__, __LINE__,
+ "LWP %ld is suspended, suspended=%d\n",
+ lwpid_of (thread), lwp->suspended);
+ }
gdb_assert (lwp->stopped);

wstat = lwp->status_pending_p ? &lwp->status_pending : NULL;
@@ -3613,7 +3701,7 @@ move_out_of_jump_pad_callback (struct inferior_list_entry *entry)
linux_resume_one_lwp (lwp, 0, 0, NULL);
}
else
- lwp->suspended++;
+ lwp_suspended_inc (lwp);
}

static int
@@ -3668,6 +3756,24 @@ stop_all_lwps (int suspend, struct lwp_info *except)
}
}

+/* Enqueue one signal in the chain of signals which need to be
+ delivered to this process on next resume. */
+
+static void
+enqueue_pending_signal (struct lwp_info *lwp, int signal, siginfo_t *info)
+{
+ struct pending_signals *p_sig;
+
+ p_sig = xmalloc (sizeof (*p_sig));
+ p_sig->prev = lwp->pending_signals;
+ p_sig->signal = signal;
+ if (info == NULL)
+ memset (&p_sig->info, 0, sizeof (siginfo_t));
+ else
+ memcpy (&p_sig->info, info, sizeof (siginfo_t));
+ lwp->pending_signals = p_sig;
+}
+
/* Resume execution of LWP. If STEP is nonzero, single-step it. If
SIGNAL is nonzero, give it that signal. */

@@ -4201,7 +4307,13 @@ start_step_over (struct lwp_info *lwp)
lwpid_of (thread));

stop_all_lwps (1, lwp);
- gdb_assert (lwp->suspended == 0);
+
+ if (lwp->suspended != 0)
+ {
+ internal_error (__FILE__, __LINE__,
+ "LWP %ld suspended=%d\n", lwpid_of (thread),
+ lwp->suspended);
+ }

if (debug_threads)
debug_printf ("Done stopping all threads for step-over.\n");
@@ -4273,6 +4385,39 @@ finish_step_over (struct lwp_info *lwp)
return 0;
}

+/* If there's a step over in progress, wait until all threads stop
+ (that is, until the stepping thread finishes its step), and
+ unsuspend all lwps. The stepping thread ends with its status
+ pending, which is processed later when we get back to processing
+ events. */
+
+static void
+complete_ongoing_step_over (void)
+{
+ if (!ptid_equal (step_over_bkpt, null_ptid))
+ {
+ struct lwp_info *lwp;
+ int wstat;
+ int ret;
+
+ if (debug_threads)
+ debug_printf ("detach: step over in progress, finish it first\n");
+
+ /* Passing NULL_PTID as filter indicates we want all events to
+ be left pending. Eventually this returns when there are no
+ unwaited-for children left. */
+ ret = linux_wait_for_event_filtered (minus_one_ptid, null_ptid,
+ &wstat, __WALL);
+ gdb_assert (ret == -1);
+
+ lwp = find_lwp_pid (step_over_bkpt);
+ if (lwp != NULL)
+ finish_step_over (lwp);
+ step_over_bkpt = null_ptid;
+ unsuspend_all_lwps (lwp);
+ }
+}
+
/* This function is called once per thread. We check the thread's resume
request, which will tell us whether to resume, step, or leave the thread
stopped; and what signal, if any, it should be sent.
@@ -4347,13 +4492,16 @@ linux_resume_one_thread (struct inferior_list_entry *entry, void *arg)
}

/* If this thread which is about to be resumed has a pending status,
- then don't resume any threads - we can just report the pending
- status. Make sure to queue any signals that would otherwise be
- sent. In all-stop mode, we do this decision based on if *any*
- thread has a pending status. If there's a thread that needs the
- step-over-breakpoint dance, then don't resume any other thread
- but that particular one. */
- leave_pending = (lwp->status_pending_p || leave_all_stopped);
+ then don't resume it - we can just report the pending status.
+ Likewise if it is suspended, because e.g., another thread is
+ stepping past a breakpoint. Make sure to queue any signals that
+ would otherwise be sent. In all-stop mode, we do this decision
+ based on if *any* thread has a pending status. If there's a
+ thread that needs the step-over-breakpoint dance, then don't
+ resume any other thread but that particular one. */
+ leave_pending = (lwp->suspended
+ || lwp->status_pending_p
+ || leave_all_stopped);

if (!leave_pending)
{
@@ -4536,7 +4684,23 @@ proceed_one_lwp (struct inferior_list_entry *entry, void *except)
send_sigstop (lwp);
}

- step = thread->last_resume_kind == resume_step;
+ if (thread->last_resume_kind == resume_step)
+ {
+ if (debug_threads)
+ debug_printf (" stepping LWP %ld, client wants it stepping\n",
+ lwpid_of (thread));
+ step = 1;
+ }
+ else if (lwp->bp_reinsert != 0)
+ {
+ if (debug_threads)
+ debug_printf (" stepping LWP %ld, reinsert set\n",
+ lwpid_of (thread));
+ step = 1;
+ }
+ else
+ step = 0;
+
linux_resume_one_lwp (lwp, step, 0, NULL);
return 0;
}
@@ -4550,8 +4714,7 @@ unsuspend_and_proceed_one_lwp (struct inferior_list_entry *entry, void *except)
if (lwp == except)
return 0;

- lwp->suspended--;
- gdb_assert (lwp->suspended >= 0);
+ lwp_suspended_decr (lwp);

return proceed_one_lwp (entry, except);
}
diff --git a/gdb/target/waitstatus.h b/gdb/target/waitstatus.h
index d4ef3b8..ffaddc1 100644
--- a/gdb/target/waitstatus.h
+++ b/gdb/target/waitstatus.h
@@ -131,7 +131,10 @@ enum target_stop_reason
TARGET_STOPPED_BY_HW_BREAKPOINT,

/* Stopped by a watchpoint. */
- TARGET_STOPPED_BY_WATCHPOINT
+ TARGET_STOPPED_BY_WATCHPOINT,
+
+ /* Stopped by a single step finishing. */
+ TARGET_STOPPED_BY_SINGLE_STEP
};

/* Prototypes */
diff --git a/gdb/testsuite/gdb.threads/forking-threads-plus-breakpoint.c b/gdb/testsuite/gdb.threads/forking-threads-plus-breakpoint.c
new file mode 100644
index 0000000..a6ff0fd
--- /dev/null
+++ b/gdb/testsuite/gdb.threads/forking-threads-plus-breakpoint.c
@@ -0,0 +1,139 @@
+/* This testcase is part of GDB, the GNU debugger.
+
+ Copyright 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/>. */
+
+#include <assert.h>
+#include <pthread.h>
+#include <unistd.h>
+#include <stdio.h>
+#include <sys/types.h>
+#include <sys/wait.h>
+#include <stdlib.h>
+
+/* Number of threads. Each thread continuously spawns a fork and wait
+ for it. If we have another thread continuously start a step over,
+ gdbserver should end up finding new forks while suspending
+ threads. */
+#define NTHREADS 10
+
+pthread_t threads[NTHREADS];
+
+pthread_barrier_t barrier;
+
+#define NFORKS 10
+
+/* Used to create a conditional breakpoint that always fails. */
+volatile int zero;
+
+static void *
+thread_forks (void *arg)
+{
+ int i;
+
+ pthread_barrier_wait (&barrier);
+
+ for (i = 0; i < NFORKS; i++)
+ {
+ pid_t pid;
+
+ pid = fork ();
+
+ if (pid > 0)
+ {
+ int status;
+
+ /* Parent. */
+ pid = waitpid (pid, &status, 0);
+ if (pid == -1)
+ {
+ perror ("wait");
+ exit (1);
+ }
+
+ if (!WIFEXITED (status))
+ {
+ printf ("Unexpected wait status 0x%x from child %d\n",
+ status, pid);
+ }
+ }
+ else if (pid == 0)
+ {
+ /* Child. */
+ exit (0);
+ }
+ else
+ {
+ perror ("fork");
+ exit (1);
+ }
+ }
+}
+
+/* Set this to tell the thread_breakpoint thread to exit. */
+volatile int break_out;
+
+static void *
+thread_breakpoint (void *arg)
+{
+ pthread_barrier_wait (&barrier);
+
+ while (!break_out)
+ {
+ usleep (1); /* set break here */
+ }
+
+ return NULL;
+}
+
+pthread_barrier_t barrier;
+
+int
+main (void)
+{
+ int i;
+ int ret;
+ pthread_t bp_thread;
+
+ /* Don't run forever. */
+ alarm (180);
+
+ pthread_barrier_init (&barrier, NULL, NTHREADS + 1);
+
+ /* Start the threads that constantly fork. */
+ for (i = 0; i < NTHREADS; i++)
+ {
+ ret = pthread_create (&threads[i], NULL, thread_forks, NULL);
+ assert (ret == 0);
+ }
+
+ /* Start the thread that constantly hit a conditional breakpoint
+ that needs to be stepped over. */
+ ret = pthread_create (&bp_thread, NULL, thread_breakpoint, NULL);
+ assert (ret == 0);
+
+ /* Wait for forking to stop. */
+ for (i = 0; i < NTHREADS; i++)
+ {
+ ret = pthread_join (threads[i], NULL);
+ assert (ret == 0);
+ }
+
+ break_out = 1;
+ pthread_join (bp_thread, NULL);
+ assert (ret == 0);
+
+ return 0;
+}
diff --git a/gdb/testsuite/gdb.threads/forking-threads-plus-breakpoint.exp b/gdb/testsuite/gdb.threads/forking-threads-plus-breakpoint.exp
new file mode 100644
index 0000000..448b734
--- /dev/null
+++ b/gdb/testsuite/gdb.threads/forking-threads-plus-breakpoint.exp
@@ -0,0 +1,117 @@
+# 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/>.
+
+# This test verifies that several threads forking while another thread
+# is constantly stepping over a breakpoint is properly handled.
+
+standard_testfile
+
+set linenum [gdb_get_line_number "set break here"]
+
+if {[build_executable "failed to prepare" $testfile $srcfile {debug pthreads}] == -1} {
+ return -1
+}
+
+# The test proper. If COND_BP_TARGET is true, then test with
+# conditional breakpoints evaluated on the target side, if possible.
+# DETACH_ON_FORK is used as value for the "set detach-on-fork"
+# setting. If "on", this exercises GDB explicitly continuing the fork
+# child until exit. If "off", this exercises GDB detaching the fork
+# child.
+proc do_test { cond_bp_target detach_on_fork } {
+ global GDBFLAGS
+ global srcfile testfile binfile
+ global decimal gdb_prompt
+ global linenum
+ global is_remote_target
+
+ set saved_gdbflags $GDBFLAGS
+ set GDBFLAGS [concat $GDBFLAGS " -ex \"set non-stop on\""]
+ clean_restart $binfile
+ set GDBFLAGS $saved_gdbflags
+
+ if ![runto_main] then {
+ fail "Can't run to main"
+ return 0
+ }
+
+ gdb_test_no_output "set detach-on-fork $detach_on_fork"
+
+ gdb_test "break $linenum if zero == 1" \
+ "Breakpoint .*" \
+ "set breakpoint that evals false"
+
+ set test "continue &"
+ gdb_test_multiple $test $test {
+ -re "$gdb_prompt " {
+ pass $test
+ }
+ }
+
+ set fork_count 0
+ set ok 0
+
+ set test "inferior 1 exited"
+ gdb_test_multiple "" $test {
+ -re "Inferior 1 \(\[^\r\n\]+\) exited normally" {
+ set ok 1
+ pass $test
+ }
+ -re "Inferior $decimal \(\[^\r\n\]+\) exited normally" {
+ incr fork_count
+ if {$fork_count <= 100} {
+ exp_continue
+ } else {
+ fail "$test (too many forks)"
+ }
+ }
+ }
+
+ if {!$ok} {
+ # No use testing further.
+ return
+ }
+
+ gdb_test "info threads" "No threads\." \
+ "no threads left"
+
+ gdb_test "info inferiors" \
+ "Num\[ \t\]+Description\[ \t\]+Executable\[ \t\]+\r\n\\* 1 \[^\r\n\]+" \
+ "only inferior 1 left"
+}
+
+# Wrapper for foreach that calls with_test_prefix on each iteration,
+# including the iterator's current value in the prefix.
+
+proc foreach_with_prefix {var list body} {
+ upvar 1 $var myvar
+ foreach myvar $list {
+ with_test_prefix "$var=$myvar" {
+ uplevel 1 $body
+ }
+ }
+}
+
+foreach_with_prefix cond_bp_target {1 0} {
+ foreach_with_prefix detach_on_fork {"on" "off"} {
+ do_test $cond_bp_target $detach_on_fork
+
+ # Disable "off" for now. The test does pass with
+ # detach-on-fork off (at the time of writing), but gdb seems
+ # to slow down quadratically as inferiors are created, and
+ # then the test takes annoyingly long to complete...
+ break
+ }
+}
--
1.9.3