Make sure we don't resume the stepped thread by accident.
Say: <stopped at a breakpoint in thread 2> (gdb) thread 3 (gdb) step The above triggers the prepare_to_proceed/deferred_step_ptid process, which switches back to thread 2, to step over its breakpoint before getting back to thread 3 and "step" it. If while stepping over the breakpoint in thread 2, a signal arrives, and it is set to pass/nostop, we'll set a step-resume breakpoint at the supposed signal-handler resume address, and call keep_going. The problem is that we were supposedly stepping thread 3, and that keep_going delivers a signal to thread 2, and due to scheduler-locking off, resumes everything else, _including_ thread 3, the thread we want stepping. This means that we lose control of thread 3 until the next event, when we stop everything. The end result for the user, is that GDB lost control of the "step". Here's the current infrun debug output of the above, with the testcase in the patch below: infrun: clear_proceed_status_thread (Thread 0x2aaaab8f5700 (LWP 11663)) infrun: clear_proceed_status_thread (Thread 0x2aaaab6f4700 (LWP 11662)) infrun: clear_proceed_status_thread (Thread 0x2aaaab4f2b20 (LWP 11659)) infrun: proceed (addr=0xffffffffffffffff, signal=144, step=1) infrun: prepare_to_proceed (step=1), switched to [Thread 0x2aaaab6f4700 (LWP 11662)] infrun: resume (step=1, signal=0), trap_expected=1, current thread [Thread 0x2aaaab6f4700 (LWP 11662)] at 0x40098f infrun: wait_for_inferior () infrun: target_wait (-1, status) = infrun: 11659 [Thread 0x2aaaab6f4700 (LWP 11662)], infrun: status->kind = stopped, signal = SIGUSR1 infrun: infwait_normal_state infrun: TARGET_WAITKIND_STOPPED infrun: stop_pc = 0x40098f infrun: random signal 30 Program received signal SIGUSR1, User defined signal 1. infrun: signal arrived while stepping over breakpoint infrun: inserting step-resume breakpoint at 0x40098f infrun: resume (step=0, signal=30), trap_expected=0, current thread [Thread 0x2aaaab6f4700 (LWP 11662)] at 0x40098f ^^^ this is a wildcard resume. infrun: prepare_to_wait infrun: target_wait (-1, status) = infrun: 11659 [Thread 0x2aaaab6f4700 (LWP 11662)], infrun: status->kind = stopped, signal = SIGTRAP infrun: infwait_normal_state infrun: TARGET_WAITKIND_STOPPED infrun: stop_pc = 0x40098f infrun: BPSTAT_WHAT_STEP_RESUME infrun: resume (step=1, signal=0), trap_expected=1, current thread [Thread 0x2aaaab6f4700 (LWP 11662)] at 0x40098f ^^^ step-resume hit, meaning the handler returned, so we go back to stepping thread 3. infrun: prepare_to_wait infrun: target_wait (-1, status) = infrun: 11659 [Thread 0x2aaaab6f4700 (LWP 11662)], infrun: status->kind = stopped, signal = SIGTRAP infrun: infwait_normal_state infrun: TARGET_WAITKIND_STOPPED infrun: stop_pc = 0x40088b infrun: switching back to stepped thread infrun: Switching context from Thread 0x2aaaab6f4700 (LWP 11662) to Thread 0x2aaaab8f5700 (LWP 11663) infrun: resume (step=1, signal=0), trap_expected=0, current thread [Thread 0x2aaaab8f5700 (LWP 11663)] at 0x400938 infrun: prepare_to_wait infrun: target_wait (-1, status) = infrun: 11659 [Thread 0x2aaaab8f5700 (LWP 11663)], infrun: status->kind = stopped, signal = SIGTRAP infrun: infwait_normal_state infrun: TARGET_WAITKIND_STOPPED infrun: stop_pc = 0x40093a infrun: keep going infrun: resume (step=1, signal=0), trap_expected=0, current thread [Thread 0x2aaaab8f5700 (LWP 11663)] at 0x40093a infrun: prepare_to_wait infrun: target_wait (-1, status) = infrun: 11659 [Thread 0x2aaaab8f5700 (LWP 11663)], infrun: status->kind = stopped, signal = SIGTRAP infrun: infwait_normal_state infrun: TARGET_WAITKIND_STOPPED infrun: stop_pc = 0x40091e infrun: stepped to a different line infrun: stop_stepping [Switching to Thread 0x2aaaab8f5700 (LWP 11663)] 69 (*myp) ++; /* set breakpoint child_two here */ ^^^ we stopped at the wrong line. We still stepped a bit because the test is running in a loop, and when we got back to stepping thread 3, it happened to be in the stepping range. (The loop increments a counter, and the test makes sure it increments exactly once. Without the fix, the counter increments a bunch, since the user-stepped thread runs free without GDB noticing.) The fix is to switch to the stepping thread before continuing for the step-resume breakpoint. gdb/ 2014-02-07 Pedro Alves <palves@redhat.com> * infrun.c (handle_signal_stop) <signal arrives while stepping over a breakpoint>: Switch back to the stepping thread. gdb/testsuite/ 2014-02-07 Pedro Alves <pedro@codesourcery.com> Pedro Alves <palves@redhat.com> * gdb.threads/step-after-sr-lock.c: New file. * gdb.threads/step-after-sr-lock.exp: New file.
This commit is contained in:
Pedro Alves
parent
b5ee5a50d4
commit
d137e6dc79
@ -1,3 +1,8 @@
|
||||
2014-02-07 Pedro Alves <palves@redhat.com>
|
||||
|
||||
* infrun.c (handle_signal_stop) <signal arrives while stepping
|
||||
over a breakpoint>: Switch back to the stepping thread.
|
||||
|
||||
2014-02-07 Yao Qi <yao@codesourcery.com>
|
||||
|
||||
* target.c (target_xfer_partial): Return zero if LEN is zero.
|
||||
|
||||
@ -4384,7 +4384,11 @@ handle_signal_stop (struct execution_control_state *ecs)
|
||||
ecs->event_thread->step_after_step_resume_breakpoint = 1;
|
||||
/* Reset trap_expected to ensure breakpoints are re-inserted. */
|
||||
ecs->event_thread->control.trap_expected = 0;
|
||||
keep_going (ecs);
|
||||
|
||||
/* If we were nexting/stepping some other thread, switch to
|
||||
it, so that we don't continue it, losing control. */
|
||||
if (!switch_back_to_stepped_thread (ecs))
|
||||
keep_going (ecs);
|
||||
return;
|
||||
}
|
||||
|
||||
|
||||
@ -1,3 +1,9 @@
|
||||
2014-02-07 Pedro Alves <pedro@codesourcery.com>
|
||||
Pedro Alves <palves@redhat.com>
|
||||
|
||||
* gdb.threads/step-after-sr-lock.c: New file.
|
||||
* gdb.threads/step-after-sr-lock.exp: New file.
|
||||
|
||||
2014-02-07 Pedro Alves <palves@redhat.com>
|
||||
|
||||
* gdb.threads/stepi-random-signal.exp: Set SIGCHLD to print.
|
||||
|
||||
145
gdb/testsuite/gdb.threads/step-after-sr-lock.c
Normal file
145
gdb/testsuite/gdb.threads/step-after-sr-lock.c
Normal file
@ -0,0 +1,145 @@
|
||||
/* This testcase is part of GDB, the GNU debugger.
|
||||
|
||||
Copyright 2009-2014 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 <pthread.h>
|
||||
#include <unistd.h>
|
||||
#include <stdlib.h>
|
||||
#include <signal.h>
|
||||
|
||||
unsigned int args[2];
|
||||
|
||||
pid_t pid;
|
||||
pthread_barrier_t barrier;
|
||||
pthread_t child_thread_2, child_thread_3;
|
||||
|
||||
void
|
||||
handler (int signo)
|
||||
{
|
||||
/* so that thread 3 is sure to run, in case the bug is present. */
|
||||
usleep (10);
|
||||
}
|
||||
|
||||
void
|
||||
callme (void)
|
||||
{
|
||||
}
|
||||
|
||||
void
|
||||
block_signals (void)
|
||||
{
|
||||
sigset_t mask;
|
||||
|
||||
sigfillset (&mask);
|
||||
sigprocmask (SIG_BLOCK, &mask, NULL);
|
||||
}
|
||||
|
||||
void
|
||||
unblock_signals (void)
|
||||
{
|
||||
sigset_t mask;
|
||||
|
||||
sigfillset (&mask);
|
||||
sigprocmask (SIG_UNBLOCK, &mask, NULL);
|
||||
}
|
||||
|
||||
void *
|
||||
child_function_3 (void *arg)
|
||||
{
|
||||
int my_number = (long) arg;
|
||||
volatile int *myp = (int *) &args[my_number];
|
||||
|
||||
pthread_barrier_wait (&barrier);
|
||||
|
||||
while (*myp > 0)
|
||||
{
|
||||
(*myp) ++; /* set breakpoint child_two here */
|
||||
callme ();
|
||||
}
|
||||
|
||||
pthread_exit (NULL);
|
||||
}
|
||||
|
||||
void *
|
||||
child_function_2 (void *arg)
|
||||
{
|
||||
int my_number = (long) arg;
|
||||
volatile int *myp = (int *) &args[my_number];
|
||||
|
||||
unblock_signals ();
|
||||
|
||||
pthread_barrier_wait (&barrier);
|
||||
|
||||
while (*myp > 0)
|
||||
{
|
||||
(*myp) ++;
|
||||
callme (); /* set breakpoint child_one here */
|
||||
}
|
||||
|
||||
*myp = 1;
|
||||
while (*myp > 0)
|
||||
{
|
||||
(*myp) ++;
|
||||
callme ();
|
||||
}
|
||||
|
||||
pthread_exit (NULL);
|
||||
}
|
||||
|
||||
|
||||
int
|
||||
main ()
|
||||
{
|
||||
int res;
|
||||
long i;
|
||||
|
||||
/* Block signals in all threads but one, so that we're sure which
|
||||
thread gets the signal we send from the command line. */
|
||||
block_signals ();
|
||||
|
||||
signal (SIGUSR1, handler);
|
||||
|
||||
/* Call these early so that PLTs for these are resolved soon,
|
||||
instead of in the threads. RTLD_NOW should work as well. */
|
||||
usleep (0);
|
||||
pthread_barrier_init (&barrier, NULL, 1);
|
||||
pthread_barrier_wait (&barrier);
|
||||
|
||||
pthread_barrier_init (&barrier, NULL, 2);
|
||||
|
||||
/* The test uses this global to know where to send the signal
|
||||
to. */
|
||||
pid = getpid ();
|
||||
|
||||
i = 0;
|
||||
args[i] = 1;
|
||||
res = pthread_create (&child_thread_2,
|
||||
NULL, child_function_2, (void *) i);
|
||||
pthread_barrier_wait (&barrier);
|
||||
callme (); /* set wait-thread-2 breakpoint here */
|
||||
|
||||
i = 1;
|
||||
args[i] = 1;
|
||||
res = pthread_create (&child_thread_3,
|
||||
NULL, child_function_3, (void *) i);
|
||||
pthread_barrier_wait (&barrier);
|
||||
callme (); /* set wait-thread-3 breakpoint here */
|
||||
|
||||
pthread_join (child_thread_2, NULL);
|
||||
pthread_join (child_thread_3, NULL);
|
||||
|
||||
exit(EXIT_SUCCESS);
|
||||
}
|
||||
120
gdb/testsuite/gdb.threads/step-after-sr-lock.exp
Normal file
120
gdb/testsuite/gdb.threads/step-after-sr-lock.exp
Normal file
@ -0,0 +1,120 @@
|
||||
# Copyright (C) 2011-2014 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/>.
|
||||
|
||||
# Test that GDB doesn't inadvertently resume the stepped thread when a
|
||||
# signal arrives while stepping over the breakpoint that last caused a
|
||||
# stop, when the thread that hit that breakpoint is not the stepped
|
||||
# thread.
|
||||
|
||||
standard_testfile
|
||||
set executable ${testfile}
|
||||
|
||||
if [target_info exists gdb,nosignals] {
|
||||
verbose "Skipping ${testfile}.exp because of nosignals."
|
||||
return -1
|
||||
}
|
||||
|
||||
# Test uses host "kill".
|
||||
if { [is_remote target] } {
|
||||
return -1
|
||||
}
|
||||
|
||||
if {[gdb_compile_pthreads "${srcdir}/${subdir}/${srcfile}" "${binfile}" \
|
||||
executable [list debug "incdir=${objdir}"]] != "" } {
|
||||
return -1
|
||||
}
|
||||
|
||||
proc get_value {var test} {
|
||||
global expect_out
|
||||
global gdb_prompt
|
||||
global decimal
|
||||
|
||||
set value -1
|
||||
gdb_test_multiple "print $var" "$test" {
|
||||
-re ".*= ($decimal).*\r\n$gdb_prompt $" {
|
||||
set value $expect_out(1,string)
|
||||
pass "$test"
|
||||
}
|
||||
}
|
||||
return ${value}
|
||||
}
|
||||
|
||||
# Start with a fresh gdb.
|
||||
|
||||
clean_restart $executable
|
||||
|
||||
if ![runto_main] {
|
||||
return -1
|
||||
}
|
||||
|
||||
gdb_breakpoint [gdb_get_line_number "set wait-thread-2 breakpoint here"]
|
||||
gdb_continue_to_breakpoint "run to wait-thread-2 breakpoint"
|
||||
gdb_test "info threads" "" "info threads with thread 2"
|
||||
|
||||
gdb_breakpoint [gdb_get_line_number "set wait-thread-3 breakpoint here"]
|
||||
gdb_continue_to_breakpoint "run to breakpoint"
|
||||
gdb_test "info threads" "" "info threads with thread 3"
|
||||
|
||||
set testpid [get_value "pid" "get pid of inferior"]
|
||||
|
||||
gdb_test "set scheduler-locking on"
|
||||
|
||||
gdb_breakpoint [gdb_get_line_number "set breakpoint child_two here"]
|
||||
gdb_breakpoint [gdb_get_line_number "set breakpoint child_one here"]
|
||||
|
||||
gdb_test "thread 3" "" "switch to thread 3 to run to its breakpoint"
|
||||
gdb_continue_to_breakpoint "run to breakpoint in thread 3"
|
||||
|
||||
gdb_test "thread 2" "" "switch to thread 2 to run to its breakpoint"
|
||||
gdb_continue_to_breakpoint "run to breakpoint in thread 2"
|
||||
|
||||
delete_breakpoints
|
||||
|
||||
gdb_test "b *\$pc" "" "set breakpoint to be stepped over"
|
||||
# Make sure the first loop breaks without hitting the breakpoint
|
||||
# again.
|
||||
gdb_test "p *myp = 0" " = 0" "force loop break in thread 2"
|
||||
|
||||
# We want "print" to make sure the target reports the signal to the
|
||||
# core.
|
||||
gdb_test "handle SIGUSR1 print nostop pass" "" ""
|
||||
|
||||
# Queue a signal in thread 2.
|
||||
remote_exec host "kill -SIGUSR1 ${testpid}"
|
||||
|
||||
gdb_test "thread 3" "" "switch to thread 3 for stepping"
|
||||
set my_number [get_value "my_number" "get my_number"]
|
||||
set cnt_before [get_value "args\[$my_number\]" "get count before step"]
|
||||
gdb_test "set scheduler-locking off"
|
||||
|
||||
# Make sure we're exercising the paths we want to.
|
||||
gdb_test "set debug infrun 1"
|
||||
|
||||
gdb_test \
|
||||
"step" \
|
||||
".*prepare_to_proceed \\(step=1\\), switched to.*signal arrived while stepping over breakpoint.*switching back to stepped thread.*stepped to a different line.*callme.*" \
|
||||
"step"
|
||||
|
||||
set cnt_after [get_value "args\[$my_number\]" "get count after step"]
|
||||
|
||||
# Test that GDB doesn't inadvertently resume the stepped thread when a
|
||||
# signal arrives while stepping over a breakpoint in another thread.
|
||||
|
||||
set test "stepped thread under control"
|
||||
if { $cnt_before + 1 == $cnt_after } {
|
||||
pass $test
|
||||
} else {
|
||||
fail $test
|
||||
}
|
||||
Loading…
Reference in New Issue
Block a user