diff --git a/gdb/ChangeLog b/gdb/ChangeLog index c9a6de9d5ad..69fbac83620 100644 --- a/gdb/ChangeLog +++ b/gdb/ChangeLog @@ -1,3 +1,8 @@ +2008-09-22 Pedro Alves + + * linux-nat.c (linux_nat_wait): Only use set_ignore_sigint in + all-stop mode. + 2008-09-19 Andrew Stubbs * MAINTAINERS: Update my email address. diff --git a/gdb/linux-nat.c b/gdb/linux-nat.c index 42e19b5969e..bbf8fb75fd3 100644 --- a/gdb/linux-nat.c +++ b/gdb/linux-nat.c @@ -2946,18 +2946,24 @@ retry: goto retry; } - if (signo == TARGET_SIGNAL_INT && signal_pass_state (signo) == 0) + if (!non_stop) { - /* If ^C/BREAK is typed at the tty/console, SIGINT gets - forwarded to the entire process group, that is, all LWPs - will receive it - unless they're using CLONE_THREAD to - share signals. Since we only want to report it once, we - mark it as ignored for all LWPs except this one. */ - iterate_over_lwps (set_ignore_sigint, NULL); - lp->ignore_sigint = 0; + /* Only do the below in all-stop, as we currently use SIGINT + to implement target_stop (see linux_nat_stop) in + non-stop. */ + if (signo == TARGET_SIGNAL_INT && signal_pass_state (signo) == 0) + { + /* If ^C/BREAK is typed at the tty/console, SIGINT gets + forwarded to the entire process group, that is, all LWPs + will receive it - unless they're using CLONE_THREAD to + share signals. Since we only want to report it once, we + mark it as ignored for all LWPs except this one. */ + iterate_over_lwps (set_ignore_sigint, NULL); + lp->ignore_sigint = 0; + } + else + maybe_clear_ignore_sigint (lp); } - else - maybe_clear_ignore_sigint (lp); } /* This LWP is stopped now. */ diff --git a/gdb/testsuite/ChangeLog b/gdb/testsuite/ChangeLog index 392519de1fa..d2478c17a91 100644 --- a/gdb/testsuite/ChangeLog +++ b/gdb/testsuite/ChangeLog @@ -1,3 +1,14 @@ +2008-09-22 Pedro Alves + + * lib/mi-support.exp (mi_expect_interrupt): New. + (mi_reverse_list, mi_check_thread_states): New, moved and renamed + from gdb.mi/mi-nonstop.exp. + * gdb.mi/mi-nsintrall.exp, gdb.mi/nsintrall.c: New. + * gdb.mi/mi-nonstop.exp (myreverse, check_thread_states): Moved to + lib/mi-support.exp. + Use mi_check_thread_states throughout. Avoid ".*" and do not + require an anchor after -exec-run. + 2008-09-13 Daniel Jacobowitz * gdb.mi/mi-nonstop.exp: Do not check thread state while a diff --git a/gdb/testsuite/gdb.mi/mi-nonstop.exp b/gdb/testsuite/gdb.mi/mi-nonstop.exp index 0bcfe41d325..0e6e130a4f6 100644 --- a/gdb/testsuite/gdb.mi/mi-nonstop.exp +++ b/gdb/testsuite/gdb.mi/mi-nonstop.exp @@ -26,29 +26,6 @@ if {[mi_gdb_start]} { continue } -proc myreverse { list } { - if { [llength $list] <= 1 } { - return $list - } - set tail [lrange $list 1 [llength $list]] - set rtail [myreverse $tail] - lappend rtail [lindex $list 0] - return $rtail -} - -proc check_thread_states { xstates test } { - global expect_out - set states [myreverse $xstates] - set pattern "\\^done,threads=\\\[" - foreach s $states { - set pattern "${pattern}(.*)state=\"$s\"" - } - set pattern "$pattern\\\}\\\].*" - - verbose -log "expecting: $pattern" - mi_gdb_test "-thread-info" $pattern $test -} - # # Start here # @@ -81,18 +58,24 @@ mi_gdb_test "-gdb-set target-async 1" ".*" detect_async mi_gdb_test "200-break-insert -t main" ".*" + +set created "=thread-created,id=\"$decimal\"\r\n" +set running "\\*running,thread-id=\"$decimal\"\r\n" + +set notifs "($created)*($running)*" + # Note: presently, we skip this test on non-native targets, # so 'run' is OK. As soon as we start to run this on remote # target, the logic from mi_run_cmd will have to be refactored. send_gdb "-exec-run\n" gdb_expect { - -re ".*\\^running.*$mi_gdb_prompt$" { + -re "\\^running\r\n$notifs$mi_gdb_prompt" { } -re "\\^error,msg=\"The target does not support running in non-stop mode.\"" { verbose -log "Non-stop mode not supported, skipping all tests" return } - -re ".*\r\n$mi_gdb_prompt$" { + -re "\r\n$mi_gdb_prompt" { perror "Cannot start target (unknown output after running)" return -1 } @@ -109,7 +92,7 @@ mi_send_resuming_command "exec-continue" "resume 1" mi_expect_stop "breakpoint-hit" "break_at_me" ".*" "non-stop.c" ".*" {"" "disp=\"keep\""} "w0,i0 stop" mi_expect_stop "breakpoint-hit" "break_at_me" ".*" "non-stop.c" ".*" {"" "disp=\"keep\""} "w1,i0 stop" -check_thread_states {"running" "stopped" "stopped"} "thread state, stop 1" +mi_check_thread_states {"running" "stopped" "stopped"} "thread state, stop 1" mi_gdb_test "-thread-select 2" "\\^done.*" "select thread 2" mi_create_varobj I_W0 "i" "create varobj in first thread" @@ -117,14 +100,14 @@ mi_gdb_test "-thread-select 3" "\\^done.*" "select thread 3" mi_create_varobj I_W1 "i" "create varobj in second thread" mi_send_resuming_command "exec-continue --thread 2" "resume 1" -check_thread_states {"running" "running" "stopped"} "thread state, resume 1" +mi_check_thread_states {"running" "running" "stopped"} "thread state, resume 1" mi_expect_stop "breakpoint-hit" "break_at_me" ".*" "non-stop.c" ".*" {"" "disp=\"keep\""} "w0,i1 stop" -check_thread_states {"running" "stopped" "stopped"} "thread state, stop 2" +mi_check_thread_states {"running" "stopped" "stopped"} "thread state, stop 2" mi_send_resuming_command "exec-continue --thread 3" "resume 2" -check_thread_states {"running" "stopped" "running"} "thread state, resume 2" +mi_check_thread_states {"running" "stopped" "running"} "thread state, resume 2" mi_expect_stop "breakpoint-hit" "break_at_me" ".*" "non-stop.c" ".*" {"" "disp=\"keep\""} "w1,i1 stop" -check_thread_states {"running" "stopped" "stopped"} "thread state, stop 3" +mi_check_thread_states {"running" "stopped" "stopped"} "thread state, stop 3" mi_varobj_update * {I_W1 I_W0} "update varobj, 1" mi_check_varobj_value I_W0 1 "check varobj, w0, 1" @@ -143,7 +126,7 @@ gdb_expect { # thread might not be stopped immediately when we return from the target. # So, wait a bit sleep 1 -check_thread_states {"stopped" "stopped" "stopped"} "thread state, stop 4" +mi_check_thread_states {"stopped" "stopped" "stopped"} "thread state, stop 4" send_gdb "-exec-continue --all\n" gdb_expect { @@ -168,7 +151,7 @@ mi_send_resuming_command "exec-continue --thread 3" "resume 3" sleep 2 mi_expect_stop "breakpoint-hit" "break_at_me" ".*" "non-stop.c" ".*" {"" "disp=\"keep\""} "w0,i3 stop" -check_thread_states {"running" "running" "stopped"} "thread state, stop on cond breakpoint" +mi_check_thread_states {"running" "running" "stopped"} "thread state, stop on cond breakpoint" # Check that when we update all varobj, we don't get no error about varobj # bound to running thread. diff --git a/gdb/testsuite/gdb.mi/mi-nsintrall.exp b/gdb/testsuite/gdb.mi/mi-nsintrall.exp new file mode 100644 index 00000000000..7d2acc0d884 --- /dev/null +++ b/gdb/testsuite/gdb.mi/mi-nsintrall.exp @@ -0,0 +1,149 @@ +# Copyright 2008 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 . + +# This only works with native configurations +if {![isnative]} { + return +} + +load_lib mi-support.exp +set MIFLAGS "-i=mi" + +gdb_exit +if {[mi_gdb_start]} { + continue +} + +# +# Start here +# +set testfile "nsintrall" +set srcfile "$testfile.c" +set binfile "$objdir/$subdir/mi-$testfile" + +set options [list debug incdir=$objdir] +if {[gdb_compile_pthreads "$srcdir/$subdir/$srcfile" $binfile executable $options] != "" } { + return -1 +} + +mi_gdb_reinitialize_dir $srcdir/$subdir +mi_gdb_load $binfile + +set supported 0 +send_gdb "-gdb-show non-stop\n" +gdb_expect { + -re ".*\\^done,value=\"off\",supported=\"(\[^\"\]+)\"\r\n$mi_gdb_prompt$" { + if { $expect_out(1,string) == "1" } { + set supported 1 + } + } + -re ".$mi_gdb_prompt$" { + } +} + +mi_gdb_test "-gdb-set non-stop 1" ".*" +mi_gdb_test "-gdb-set target-async 1" ".*" +detect_async + +mi_gdb_test "200-break-insert -t main" ".*" + +set created "=thread-created,id=\"$decimal\"\r\n" +set running "\\*running,thread-id=\"$decimal\"\r\n" + +set notifs "($created)*($running)*" + +# Note: presently, we skip this test on non-native targets, +# so 'run' is OK. As soon as we start to run this on remote +# target, the logic from mi_run_cmd will have to be refactored. +send_gdb "-exec-run\n" +gdb_expect { + -re "\\^running\r\n$notifs$mi_gdb_prompt" { + } + -re "\\^error,msg=\"The target does not support running in non-stop mode.\"" { + verbose -log "Non-stop mode not supported, skipping all tests" + return + } + -re "\r\n$mi_gdb_prompt" { + perror "Cannot start target (unknown output after running)" + return -1 + } + timeout { + perror "Cannot start target (timeout)" + return -1 + } +} +mi_expect_stop "breakpoint-hit" main ".*" ".*" "\[0-9\]+" \ + { "" "disp=\"del\"" } "run to main" + +mi_create_breakpoint thread_function 2 keep thread_function .* .* .* \ + "breakpoint at thread_function" + +mi_send_resuming_command "exec-continue --all" "resume all" +for {set i 0} {$i < 6} {incr i} { + mi_expect_stop "breakpoint-hit" "thread_function" "\[^\n\]*" "$srcfile" \ + "\[0-9\]*" {"" "disp=\"keep\""} "stop $i" +} + +mi_check_thread_states \ + {"stopped" "stopped" "stopped" "stopped" "stopped" "stopped"} \ + "thread state, all stopped" + +# now that we know about all the threads, we can get rid of the breakpoints +mi_delete_breakpoints + +set running_re "" +for {set i 6} {$i > 0} {incr i -1} { + set running_re "$running_re\\*running,thread-id=\"$i\"\r\n" +} + +send_gdb "-exec-continue --all\n" +gdb_expect { + -re ".*$running_re$mi_gdb_prompt" { + pass "resume all, no breakpoint" + } + timeout { + fail "resume all, no breakpoint (timeout)" + } +} +mi_check_thread_states \ + {"running" "running" "running" "running" "running" "running"} \ + "thread state, resume all" + +mi_gdb_test "200-exec-interrupt --all" "200\\^done" "interrupt all threads" + +for {set i 0} {$i < 6} {incr i} { + mi_expect_interrupt "interrupt $i" +} +mi_check_thread_states \ + {"stopped" "stopped" "stopped" "stopped" "stopped" "stopped"} \ + "thread state, all interrupted" + +# resume all threads, and check that no thread is spuriously left interrupted +send_gdb "-exec-continue --all\n" +gdb_expect { + -re ".*$running_re$mi_gdb_prompt" { + pass "resume all after interrupting" + } + timeout { + fail "resume all after interrupting (timeout)" + } +} + +sleep 1 +mi_check_thread_states \ + {"running" "running" "running" "running" "running" "running"} \ + "thread state, resume all after interrupting" + +mi_gdb_exit diff --git a/gdb/testsuite/gdb.mi/nsintrall.c b/gdb/testsuite/gdb.mi/nsintrall.c new file mode 100644 index 00000000000..187a2cb21b4 --- /dev/null +++ b/gdb/testsuite/gdb.mi/nsintrall.c @@ -0,0 +1,64 @@ +/* This testcase is part of GDB, the GNU debugger. + + Copyright 2002, 2003, 2004, 2007, 2008 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 . */ + +#include +#include +#include +#include + +void *thread_function(void *arg); /* Pointer to function executed by each thread */ + +#define NUM 5 + +unsigned int args[NUM+1]; + +int main() { + int res; + pthread_t threads[NUM]; + void *thread_result; + long i; + + for (i = 1; i <= NUM; i++) + { + args[i] = 1; + res = pthread_create(&threads[i], + NULL, + thread_function, + (void *) i); + } + + /* last thread start. */ + args[0] = 1; + thread_function ((void *) 0); + + exit(EXIT_SUCCESS); +} + +void *thread_function(void *arg) { + int my_number = (long) arg; + int *myp = (int *) &args[my_number]; + + /* Don't run forever. Run just short of it :) */ + while (*myp > 0) + { + /* main loop. */ + (*myp) ++; + usleep (1); + } + + pthread_exit(NULL); +} diff --git a/gdb/testsuite/lib/mi-support.exp b/gdb/testsuite/lib/mi-support.exp index 0d8c8a65c83..71c0f5946ae 100644 --- a/gdb/testsuite/lib/mi-support.exp +++ b/gdb/testsuite/lib/mi-support.exp @@ -1037,6 +1037,42 @@ proc mi_expect_stop { reason func args file line extra test } { } } +# Wait for MI *stopped notification related to an interrupt request to +# appear. +proc mi_expect_interrupt { test } { + global mi_gdb_prompt + global decimal + global async + + if {$async} { + set prompt_re "" + } else { + set prompt_re "$mi_gdb_prompt$" + } + + set r "reason=\"signal-received\",signal-name=\"SIGINT\",signal-meaning=\"Interrupt\"" + + set any "\[^\n\]*" + + # A signal can land anywhere, just ignore the location + verbose -log "mi_expect_interrupt: expecting: \\*stopped,${r},thread-id=\"$decimal\",stopped-threads=$any\r\n$prompt_re" + gdb_expect { + -re "\\*stopped,${r},thread-id=\"$decimal\",stopped-threads=$any\r\n$prompt_re" { + pass "$test" + return 0; + } + -re ".*\r\n$mi_gdb_prompt$" { + verbose -log "got $expect_out(buffer)" + fail "$test (unknown output after running)" + return -1 + } + timeout { + fail "$test (timeout)" + return -1 + } + } +} + # cmd should not include the number or newline (i.e. "exec-step 3", not # "220-exec-step 3\n" @@ -1704,3 +1740,25 @@ proc mi_load_shlibs { args } { mi_gdb_test "set solib-search-path [file dirname [lindex $args 0]]" "\^done" "" } +proc mi_reverse_list { list } { + if { [llength $list] <= 1 } { + return $list + } + set tail [lrange $list 1 [llength $list]] + set rtail [mi_reverse_list $tail] + lappend rtail [lindex $list 0] + return $rtail +} + +proc mi_check_thread_states { xstates test } { + global expect_out + set states [mi_reverse_list $xstates] + set pattern "\\^done,threads=\\\[" + foreach s $states { + set pattern "${pattern}(.*)state=\"$s\"" + } + set pattern "$pattern\\\}\\\].*" + + verbose -log "expecting: $pattern" + mi_gdb_test "-thread-info" $pattern $test +}