| # Copyright 1999-2018 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/>. | |
| # Please email any bugs, comments, and/or additions to this file to: | |
| # bug-gdb@gnu.org | |
| #### Dining Philosophers, on LinuxThreads - Jim Blandy <jimb@cygnus.com> | |
| #### | |
| #### At the moment, GDB's support for LinuxThreads is pretty | |
| #### idiosyncratic --- GDB's output doesn't look much like the output | |
| #### it produces for other thread implementations, messages appear at | |
| #### different times, etc. So these tests are specific to LinuxThreads. | |
| #### | |
| #### However, if all goes well, Linux will soon have a libthread_db | |
| #### interface, and GDB will manage it the same way it does other | |
| #### libthread_db-based systems. Then, we can adjust this file to | |
| #### work with any such system. | |
| ### Other things we ought to test: | |
| ### stepping a thread while others are running | |
| ### killing and restarting | |
| ### quitting gracefully | |
| # This only works with Linux configurations. | |
| if ![istarget *-*-linux-gnu*] then { | |
| return | |
| } | |
| standard_testfile | |
| if {[gdb_compile_pthreads "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable {debug}] != ""} { | |
| return -1 | |
| } | |
| clean_restart ${binfile} | |
| gdb_test_no_output "set print sevenbit-strings" | |
| runto_main | |
| # There should be no threads initially. | |
| gdb_test "info threads" ".*" "info threads 1" | |
| # Try stepping over the thread creation function. | |
| gdb_breakpoint [gdb_get_line_number "linuxthreads.exp: create philosopher"] | |
| set expect_manager -1 | |
| for {set i 0} {$i < 5} {incr i} { | |
| gdb_continue_to_breakpoint "about to create philosopher: $i" | |
| set threads_before {} | |
| gdb_test_multiple "info threads" "info threads before: $i" { | |
| -re "info threads\r\n" { | |
| exp_continue | |
| } | |
| -re "^ *Id.*Frame *\[\r\n\]+" { | |
| exp_continue | |
| } | |
| -re "^. +(\[0-9\]+ *Thread \[-0-9a-fx.\]+) \[^\n\]*\n" { | |
| verbose -log "found thread $expect_out(1,string)" 2 | |
| lappend threads_before $expect_out(1,string) | |
| exp_continue | |
| } | |
| -re "^\[^\n\]*\n" { | |
| verbose -log "skipping line" 2 | |
| exp_continue -continue_timer | |
| } | |
| -re "^$gdb_prompt $" { | |
| } | |
| } | |
| set threads_created 0 | |
| gdb_test_multiple "next" "create philosopher: $i" { | |
| -re "^next\r\n" { | |
| exp_continue | |
| } | |
| -re "^ *\[_!\] \[0-9\]* \[_!\]\r\n" { | |
| # Ignore program output. | |
| exp_continue -continue_timer | |
| } | |
| -re "^\\\[New \[^\]\n\]+\\\]\[^\n\]+\n" { | |
| incr threads_created | |
| exp_continue | |
| } | |
| -re "^189\[^\n\]+\n" { | |
| exp_continue | |
| } | |
| -re "^$gdb_prompt $" { | |
| } | |
| -re " received signal.*(Unknown signal|SIGUSR|Real-time event).*$gdb_prompt $" { | |
| # It would be nice if we could catch the message that GDB prints | |
| # when it first notices that the thread library doesn't support | |
| # debugging, or if we could explicitly ask GDB somehow. | |
| unsupported "this GDB does not support threads on this system." | |
| return -1 | |
| } | |
| -re "$gdb_prompt $" { | |
| } | |
| } | |
| if { $threads_created == 1 } { | |
| if { $expect_manager < 0 } { | |
| set expect_manager 0 | |
| } | |
| pass "create philosopher: $i" | |
| } elseif { !$i && $threads_created == 2 } { | |
| # Two threads are created the first time in LinuxThreads, | |
| # where the second is the manager thread. In NPTL, there is none. | |
| set expect_manager 1 | |
| pass "create philosopher: $i" | |
| } else { | |
| fail "create philosopher: $i" | |
| } | |
| set threads_after {} | |
| gdb_test_multiple "info threads" "info threads after: $i" { | |
| -re "info threads\r\n" { | |
| exp_continue | |
| } | |
| -re "^ *Id.*Frame *\[\r\n\]+" { | |
| exp_continue | |
| } | |
| -re "^. +(\[0-9\]+ *Thread \[-0-9a-fx.\]+) \[^\n\]*\n" { | |
| set name $expect_out(1,string) | |
| for {set j 0} {$j != [llength $threads_before] } {incr j} { | |
| if {$name == [lindex $threads_before $j]} { | |
| set threads_before [lreplace $threads_before $j $j] | |
| set name "" | |
| break | |
| } | |
| } | |
| if { $name != "" } { | |
| lappend threads_after $name | |
| } | |
| exp_continue | |
| } | |
| -re "^\[^\n\]*\n" { | |
| verbose -log "skipping line" 2 | |
| exp_continue -continue_timer | |
| } | |
| -re "^$gdb_prompt $" { | |
| if { [llength $threads_before] != 0 } { | |
| fail "info threads after: $i" | |
| } elseif { !$i && [llength $threads_after] == 2 } { | |
| set expect_manager 1 | |
| pass "info threads after: $i" | |
| } elseif { [llength $threads_after] == 1 } { | |
| if { $expect_manager < 0 } { | |
| set expect_manager 0 | |
| } | |
| pass "info threads after: $i" | |
| } else { | |
| fail "info threads after: $i" | |
| } | |
| } | |
| } | |
| } | |
| set nthreads 6 | |
| # Run until there are some threads. | |
| gdb_breakpoint [gdb_get_line_number "linuxthreads.exp: info threads 2"] | |
| gdb_continue_to_breakpoint "main thread's sleep" | |
| set info_threads_ptn ".*" | |
| for {set i 1} {$i < $nthreads} {incr i} { | |
| append info_threads_ptn "$i *Thread .*" | |
| } | |
| append info_threads_ptn "\[\r\n\]+$gdb_prompt $" | |
| set info_threads_manager_ptn "[expr $nthreads + 1] *Thread .*$info_threads_ptn" | |
| gdb_test_multiple "info threads" "info threads 2" { | |
| -re "$info_threads_manager_ptn" { | |
| # We did see a manager thread. Check that against what we expected. | |
| switch -exact -- $expect_manager { | |
| -1 { | |
| # We weren't sure whether to expect a manager thread. | |
| pass "info threads 2" | |
| } | |
| 1 { | |
| # We were expecting a manager thread. | |
| pass "info threads 2" | |
| } | |
| 0 { | |
| # We were not expecting to see the manager thread. | |
| fail "info threads 2" | |
| } | |
| } | |
| set expect_manager 1 | |
| incr nthreads | |
| } | |
| -re "$info_threads_ptn" { | |
| # We did not see a manager thread. Check that against what we | |
| # expected. | |
| switch -exact -- $expect_manager { | |
| -1 { | |
| # We weren't sure whether to expect a manager thread. | |
| # Don't expect it from here on out. | |
| pass "info threads 2" | |
| } | |
| 1 { | |
| # We were expecting a manager thread, but we didn't see one. | |
| fail "info threads 2" | |
| } | |
| 0 { | |
| # We were not expecting to see the manager thread. | |
| pass "info threads 2" | |
| } | |
| } | |
| set expect_manager 0 | |
| } | |
| } | |
| # Try setting a thread-specific breakpoint. | |
| gdb_breakpoint "print_philosopher thread 5" | |
| gdb_continue_to_breakpoint "thread 5's print" | |
| # When there is no debugging info available for the thread library, | |
| # the backtrace entry for philosopher's caller looks like: | |
| # #2 0x4001c548 in pthread_create () from /lib/libpthread.so.0 | |
| # If you do have debug info, the output obviously depends more on the | |
| # exact library in use; under NPTL, you get: | |
| # #2 0x0012b7fc in start_thread (arg=0x21) at pthread_create.c:264 | |
| gdb_test "where" "print_philosopher.*philosopher.* \(from .*libpthread\|at pthread_create\|in pthread_create\).*" \ | |
| "first thread-specific breakpoint hit" | |
| # Make sure it's catching the right thread. Try hitting the | |
| # breakpoint ten times, and make sure we don't get anyone else. | |
| set only_five 1 | |
| for {set i 0} {$only_five > 0 && $i < 10} {incr i} { | |
| gdb_continue_to_breakpoint "thread 5's print, pass: $i" | |
| gdb_test_multiple "info threads" "" { | |
| -re "\[*\] 5 *Thread .* +print_philosopher .*\r\n$gdb_prompt $" { | |
| # Okay this time. | |
| } | |
| -re ".*$gdb_prompt $" { | |
| set only_five 0 | |
| } | |
| timeout { | |
| set only_five -1 | |
| } | |
| } | |
| } | |
| set name "thread-specific breakpoint is thread-specific" | |
| if {$only_five == 1} { pass $name } | |
| if {$only_five == 0} { fail $name } | |
| if {$only_five == -1} { fail "$name (timeout)" } | |
| ### Select a particular thread. | |
| proc select_thread {thread} { | |
| global gdb_prompt | |
| gdb_test "thread $thread" \ | |
| "\\\[Switching to thread .*\\\].*" \ | |
| "selected thread: $thread" | |
| } | |
| ### Select THREAD, check for a plausible backtrace, and make sure | |
| ### we're actually selecting a different philosopher each time. | |
| ### Return true if the thread had a stack which was not only | |
| ### acceptable, but interesting. SEEN should be an array in which | |
| ### SEEN(N) exists iff we have found philosopher number N before. | |
| set main_seen 0 | |
| set manager_seen 0 | |
| proc check_philosopher_stack {thread seen_name} { | |
| global gdb_prompt | |
| upvar $seen_name seen | |
| global main_seen | |
| global expect_manager manager_seen | |
| set name "philosopher is distinct: $thread" | |
| set interesting 0 | |
| select_thread $thread | |
| gdb_test_multiple "where" "$name" { | |
| -re ".* in philosopher \\(data=(0x\[0-9a-f\]+).*\r\n$gdb_prompt $" { | |
| set data $expect_out(1,string) | |
| if {[info exists seen($data)]} { | |
| fail $name | |
| } else { | |
| pass $name | |
| set seen($data) yep | |
| } | |
| set interesting 1 | |
| } | |
| -re ".* in __pthread_manager \\(.*$gdb_prompt $" { | |
| if {$manager_seen == 1} { | |
| fail "manager thread is distinct: $thread" | |
| } else { | |
| set manager_seen 1 | |
| pass "manager thread is distinct: $thread" | |
| } | |
| set interesting 1 | |
| } | |
| -re "pthread_start_thread.*\r\n$gdb_prompt $" { | |
| ## Maybe the thread hasn't started yet. | |
| pass $name | |
| } | |
| -re ".* in main \\(.*$gdb_prompt $" { | |
| if {$main_seen == 1} { | |
| fail "main is distinct: $thread" | |
| } else { | |
| set main_seen 1 | |
| pass "main is distinct: $thread" | |
| } | |
| set interesting 1 | |
| } | |
| -re " in \\?\\?.*\r\n$gdb_prompt $" { | |
| ## Sometimes we can't get a backtrace. I'm going to call | |
| ## this a pass, since we do verify that at least one | |
| ## thread was interesting, so we can get more consistent | |
| ## test suite totals. But in my heart, I think it should | |
| ## be an xfail. | |
| pass $name | |
| } | |
| } | |
| return $interesting | |
| } | |
| set any_interesting 0 | |
| catch {unset seen} | |
| array set seen {} | |
| for {set i 1} {$i <= $nthreads} {incr i} { | |
| if [check_philosopher_stack $i seen] { | |
| set any_interesting 1 | |
| } | |
| } | |
| unset seen | |
| if {$any_interesting} { | |
| pass "found an interesting thread" | |
| } else { | |
| fail "found an interesting thread" | |
| } | |
| if {$manager_seen == $expect_manager} { | |
| pass "manager thread found (not found) when expected" | |
| } else { | |
| fail "manager thread found (not found) when expected" | |
| } |