diff options
| -rw-r--r-- | gdb/testsuite/ChangeLog | 5 | ||||
| -rw-r--r-- | gdb/testsuite/gdb.threads/detach-step-over.c | 112 | ||||
| -rw-r--r-- | gdb/testsuite/gdb.threads/detach-step-over.exp | 290 |
3 files changed, 407 insertions, 0 deletions
diff --git a/gdb/testsuite/ChangeLog b/gdb/testsuite/ChangeLog index 75fcf3e..62c06d0 100644 --- a/gdb/testsuite/ChangeLog +++ b/gdb/testsuite/ChangeLog @@ -1,5 +1,10 @@ 2021-02-03 Pedro Alves <pedro@palves.net> + * gdb.threads/detach-step-over.c: New file. + * gdb.threads/detach-step-over.exp: New file. + +2021-02-03 Pedro Alves <pedro@palves.net> + * gdb.threads/attach-non-stop.c: New file. * gdb.threads/attach-non-stop.exp: New file. diff --git a/gdb/testsuite/gdb.threads/detach-step-over.c b/gdb/testsuite/gdb.threads/detach-step-over.c new file mode 100644 index 0000000..13db9f6 --- /dev/null +++ b/gdb/testsuite/gdb.threads/detach-step-over.c @@ -0,0 +1,112 @@ +/* This testcase is part of GDB, the GNU debugger. + + Copyright 2021 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/>. */ + +#define _GNU_SOURCE +#include <assert.h> +#include <pthread.h> +#include <stdlib.h> +#include <stdio.h> +#include <unistd.h> +#include <string.h> +#include <signal.h> + +/* Number of threads we'll create. */ +int n_threads = 10; + +int mypid; + +static void +setup_done (void) +{ +} + +/* Entry point for threads. Loops forever. */ + +void * +thread_func (void *arg) +{ + /* Avoid setting the breakpoint at an instruction that wouldn't + require a fixup phase, like a branch/jump. In such a case, even + if GDB manages to detach the inferior with an incomplete + displaced step, GDB inferior may still not crash. A breakpoint + at a line that increments a variable is good bet that we end up + setting a breakpoint at an instruction that will require a fixup + phase to move the PC from the scratch pad to the instruction + after the breakpoint. */ + volatile unsigned counter = 0; + + while (1) + { + counter++; /* Set breakpoint here. */ + counter++; + counter++; + } + + return NULL; +} + +/* Allow for as much timeout as DejaGnu wants, plus a bit of + slack. */ +#define SECONDS (TIMEOUT + 20) + +/* We'll exit after this many seconds. */ +unsigned int seconds_left = SECONDS; + +/* GDB sets this whenever it's about to start a new detach/attach + sequence. We react by resetting the seconds-left counter. */ +volatile int again = 0; + +int +main (int argc, char **argv) +{ + int i; + + signal (SIGUSR1, SIG_IGN); + + mypid = getpid (); + setup_done (); + + if (argc > 1) + n_threads = atoi (argv[1]); + + /* Spawn the test threads. */ + for (i = 0; i < n_threads; ++i) + { + pthread_t child; + int rc; + + rc = pthread_create (&child, NULL, thread_func, NULL); + assert (rc == 0); + } + + /* Exit after a while if GDB is gone/crashes. But wait long enough + for one attach/detach sequence done by the .exp file. */ + while (--seconds_left > 0) + { + sleep (1); + + if (again) + { + /* GDB should be reattaching soon. Restart the timer. */ + again = 0; + seconds_left = SECONDS; + } + } + + printf ("timeout, exiting\n"); + return 0; +} diff --git a/gdb/testsuite/gdb.threads/detach-step-over.exp b/gdb/testsuite/gdb.threads/detach-step-over.exp new file mode 100644 index 0000000..8c58aeb --- /dev/null +++ b/gdb/testsuite/gdb.threads/detach-step-over.exp @@ -0,0 +1,290 @@ +# Copyright 2021 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 detaching from a process that is running and has threads +# constantly hitting a breakpoint and stepping over it, in all +# combinations of: +# +# - maint target non-stop off/on +# - set non-stop on/off +# - displaced stepping on/off +# +# This stresses the edge cases of detaching while a displaced step or +# an in-line step over are in progress. +# +# A fail mode is that the inferior process dies after being detached. +# This can happen because e.g.: +# +# - GDB leaves a breakpoint installed behind, or +# +# - GDB leaves a thread running in the displaced step scratch buffer. +# With no debugger around to run the finish step, the thread runs +# off of the scratch buffer, with undefined results. +# +# To exercise this, the testcase reattaches to the process shortly +# after detaching, ensuring the process is still alive and well. +# +# In addition, since GDB may pause threads of all processes for +# stepping over a breakpoint, it needs to re-resume all threads if it +# detaches from the process that was just stepping over the +# breakpoint. To ensure that, the testcase actually runs a second +# process at the same time as the one that is used to test detaching. +# After the first process is detached, the testcase sends a SIGUSR1 to +# the second process. If threads failed to be resumed, then the +# SIGUSR1 is never reported to the user, resulting in timeout. The +# threads of this second process will also be constantly stepping over +# a breakpoint, which has helped with exposing further corner case +# bugs. + +if {![can_spawn_for_attach]} { + return 0 +} + +standard_testfile + +set bp_lineno [gdb_get_line_number "Set breakpoint here"] + +# The test proper. See description above. +proc test {condition_eval target_non_stop non_stop displaced} { + global binfile srcfile + global gdb_prompt + global decimal + global bp_lineno + global GDBFLAGS + + # Number of threads started by the program. + set n_threads 10 + + save_vars { GDBFLAGS } { + append GDBFLAGS " -ex \"maint set target-non-stop $target_non_stop\"" + append GDBFLAGS " -ex \"set non-stop $non_stop\"" + append GDBFLAGS " -ex \"set displaced $displaced\"" + append GDBFLAGS " -ex \"set schedule-multiple on\"" + clean_restart $binfile + } + + set test_spawn_id [spawn_wait_for_attach $binfile] + set testpid [spawn_id_get_pid $test_spawn_id] + + set any "\[^\r\n\]*" + + gdb_test "add-inferior" "Added inferior 2.*" + gdb_test "inferior 2" "Switching to .*" + + gdb_load $binfile + if ![runto setup_done] then { + fail "can't run to setup_done" + kill_wait_spawned_process $test_spawn_id + return + } + + gdb_test_no_output "set breakpoint condition-evaluation $condition_eval" + + # Get the PID of the test process. + set pid_inf2 "" + gdb_test_multiple "p mypid" "get pid of inferior 2" { + -re " = ($decimal)\r\n$gdb_prompt $" { + set pid_inf2 $expect_out(1,string) + pass $gdb_test_name + } + } + + set attempts 3 + for {set attempt 1} { $attempt <= $attempts } { incr attempt } { + with_test_prefix "iter $attempt" { + gdb_test "inferior 1" "Switching to .*" + + set attached 0 + set eperm 0 + set test "attach" + gdb_test_multiple "attach $testpid" $test { + -re "new threads in iteration" { + # Seen when "set debug libthread_db" is on. + exp_continue + } + -re "is a zombie - the process has already terminated.*$gdb_prompt " { + fail $gdb_test_name + } + -re "Unable to attach: .*$gdb_prompt " { + fail $gdb_test_name + } + -re "Attaching to program.*process $testpid.*$gdb_prompt " { + pass $test + set attached 1 + } + } + + if {!$attached} { + kill_wait_spawned_process $test_spawn_id + return + } + + if {$non_stop} { + # In non-stop, we will see one stop per thread after + # the prompt. + set stops 0 + set tid_re "$::decimal\.$::decimal" + set test "seen all stops" + for {set thread 1} { $thread <= $n_threads } { incr thread } { + if {[gdb_test_multiple "" $test { + -re "Thread ${tid_re} ${any} stopped" { + incr stops + } + }] != 0} { + break + } + } + + # If we haven't seen all stops, then the + # gdb_test_multiple in the loop above will have + # already issued a FAIL. + if {$stops != $n_threads} { + kill_wait_spawned_process $test_spawn_id + return + } + pass $test + } + + # Set threads stepping over a breakpoint continuously. + gdb_test "break $srcfile:$bp_lineno if 0" "Breakpoint.*" \ + "break LOC if 0" + + if {$attempt < $attempts} { + # Kick the time out timer for another round. + gdb_test "print again = 1" " = 1" "reset timer in the inferior" + # Show the time we had left in the logs, in case + # something goes wrong. + gdb_test "print seconds_left" " = .*" + } + + if {$non_stop} { + set cont_cmd "continue -a &" + } else { + set cont_cmd "continue &" + } + + set cont_cmd_re [string_to_regexp $cont_cmd] + gdb_test_multiple $cont_cmd "" { + -re "^$cont_cmd_re\r\nContinuing\.\r\n$gdb_prompt " { + pass $gdb_test_name + } + } + + # Wait a bit, to give time for the threads to hit the + # breakpoint. + sleep 1 + + set running_count 0 + set interrupted 0 + gdb_test_multiple "info threads" "all threads running" { + -re "\\(running\\)" { + incr running_count + exp_continue + } + -re "Cannot execute this command while the target is running.*$gdb_prompt $" { + # Testing against a remote server that doesn't do + # non-stop mode. Explicitly interrupt. This + # doesn't test the same code paths in GDB, but + # it's still something. + set interrupted 1 + gdb_test_multiple "interrupt" "" { + -re "$gdb_prompt " { + gdb_test_multiple "" $gdb_test_name { + -re "received signal SIGINT, Interrupt" { + pass $gdb_test_name + } + } + } + } + } + -re "$gdb_prompt $" { + gdb_assert {$running_count == ($n_threads + 1) * 2} $gdb_test_name + } + } + + gdb_test "detach" "Detaching from.*" + + if {!$interrupted} { + # Now test whether inferior 2's thread were really left + # running. Currently an inline step-over stops all + # threads of all processes. If detach aborts such a step + # over, then threads of other inferiors should be + # re-resumed. Test for that by sending a signal to + # inferior 2. + remote_exec target "kill -SIGUSR1 ${pid_inf2}" + + gdb_test_multiple "" "stop with SIGUSR1" { + -re "received signal SIGUSR1" { + pass $gdb_test_name + } + } + } + + delete_breakpoints + } + } + kill_wait_spawned_process $test_spawn_id +} + +# The test program exits after a while, in case GDB crashes. Make it +# wait at least as long as we may wait before declaring a time out +# failure. +set options { "additional_flags=-DTIMEOUT=$timeout" debug pthreads } + +if {[prepare_for_testing "failed to prepare" $testfile $srcfile $options] == -1} { + return -1 +} + +if ![runto_main] { + return -1 +} + +# Probe support for "set breakpoint condition-evaluation target". +# This setting influences who steps over the breakpoint, the (remote) +# target (e.g. gdbserver) or gdb, thus exposing issues on either the +# target or gdb. +set supports_condition_eval_target 1 +set cmd "set breakpoint condition-evaluation target" +gdb_test_multiple $cmd "probe condition-evaluation target support" { + -re "warning: Target does not support breakpoint condition evaluation.\r\nUsing host evaluation mode instead.\r\n$gdb_prompt $" { + # Target doesn't support breakpoint condition evaluation on + # its side. + set supports_condition_eval_target 0 + pass $gdb_test_name + } + -re "^$cmd\r\n$gdb_prompt $" { + pass $gdb_test_name + } +} + +foreach_with_prefix breakpoint-condition-evaluation {"host" "target"} { + if {!$supports_condition_eval_target && ${breakpoint-condition-evaluation} == "target"} { + continue + } + + foreach_with_prefix target-non-stop {"off" "on"} { + foreach_with_prefix non-stop {"off" "on"} { + if {${non-stop} && !${target-non-stop}} { + # "set non-stop" overrides "maint set + # target-non-stop", no use testing this combination. + continue + } + + foreach_with_prefix displaced {"off" "auto"} { + test ${breakpoint-condition-evaluation} ${target-non-stop} ${non-stop} ${displaced} + } + } + } +} |