| # Copyright 1997-2013 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/>. |
| |
| # Various tests of gdb's ability to follow the parent or child of a |
| # Unix vfork system call. A vfork parent is blocked until the child |
| # either execs or exits --- since those events take somewhat different |
| # code paths in GDB, both variants are exercised. |
| |
| if { [is_remote target] || ![isnative] } then { |
| continue |
| } |
| |
| # Until "set follow-fork-mode" and "catch vfork" are implemented on |
| # other targets... |
| # |
| if {![istarget "hppa*-hp-hpux*"] && ![istarget "*-linux*"]} then { |
| continue |
| } |
| |
| # Test to see if we are on an HP-UX 10.20 and if so, |
| # do not run these tests as catching vfork is disabled for |
| # 10.20. |
| |
| if [istarget "hppa*-hp-hpux10.20"] then { |
| return 0 |
| } |
| |
| # NOTE drow/2002-12-06: I don't know what the referenced kernel problem |
| # is, but it appears to be fixed in recent HP/UX versions. |
| |
| ##if [istarget "hppa2.0w-hp-hpux*"] { |
| ## warning "Don't run gdb.base/foll-vfork.exp until JAGaa43495 kernel problem is fixed." |
| ## return 0 |
| ##} |
| |
| standard_testfile |
| |
| if {[build_executable $testfile.exp $testfile $srcfile {debug}] == -1} { |
| untested "failed to compile $testfile" |
| return -1 |
| } |
| |
| set testfile2 "vforked-prog" |
| set srcfile2 ${testfile2}.c |
| |
| if {[build_executable $testfile.exp $testfile2 $srcfile2 {debug}] == -1} { |
| untested "failed to compile $testfile2" |
| return -1 |
| } |
| |
| # A few of these tests require a little more time than the standard |
| # timeout allows. |
| set oldtimeout $timeout |
| set timeout [expr "$timeout + 10"] |
| |
| # Start with a fresh GDB, with verbosity enabled, and run to main. On |
| # error, behave as "return", so we don't try to continue testing with |
| # a borked session. |
| proc setup_gdb {} { |
| global testfile |
| |
| clean_restart $testfile |
| |
| # The "Detaching..." and "Attaching..." messages may be hidden by |
| # default. |
| gdb_test_no_output "set verbose" |
| |
| if ![runto_main] { |
| return -code return |
| } |
| } |
| |
| proc check_vfork_catchpoints {} { |
| global gdb_prompt |
| global has_vfork_catchpoints |
| |
| setup_gdb |
| |
| # Verify that the system supports "catch vfork". |
| gdb_test "catch vfork" "Catchpoint \[0-9\]* \\(vfork\\)" "insert first vfork catchpoint" |
| set has_vfork_catchpoints 0 |
| gdb_test_multiple "continue" "continue to first vfork catchpoint" { |
| -re ".*Your system does not support this type\r\nof catchpoint.*$gdb_prompt $" { |
| unsupported "continue to first vfork catchpoint" |
| } |
| -re ".*Catchpoint.*$gdb_prompt $" { |
| set has_vfork_catchpoints 1 |
| pass "continue to first vfork catchpoint" |
| } |
| } |
| |
| if {$has_vfork_catchpoints == 0} { |
| unsupported "vfork catchpoints" |
| return -code return |
| } |
| } |
| |
| proc vfork_parent_follow_through_step {} { |
| with_test_prefix "vfork parent follow, through step" { |
| global gdb_prompt |
| |
| setup_gdb |
| |
| gdb_test_no_output "set follow-fork parent" |
| |
| set test "step" |
| gdb_test_multiple "next" $test { |
| -re "Detaching after fork from.*if \\(pid == 0\\).*$gdb_prompt " { |
| pass $test |
| } |
| } |
| # The child has been detached; allow time for any output it might |
| # generate to arrive, so that output doesn't get confused with |
| # any gdb_expected debugger output from a subsequent testpoint. |
| # |
| exec sleep 1 |
| }} |
| |
| proc vfork_parent_follow_to_bp {} { |
| with_test_prefix "vfork parent follow, to bp" { |
| global gdb_prompt |
| global srcfile |
| |
| setup_gdb |
| |
| gdb_test_no_output "set follow-fork parent" |
| |
| set bp_location [gdb_get_line_number "printf (\"I'm the proud parent of child"] |
| gdb_test "break ${srcfile}:${bp_location}" ".*" "break, vfork to bp" |
| |
| set test "continue to bp" |
| gdb_test_multiple "continue" $test { |
| -re ".*Detaching after fork from child process.*Breakpoint.*${bp_location}.*$gdb_prompt " { |
| pass $test |
| } |
| } |
| # The child has been detached; allow time for any output it might |
| # generate to arrive, so that output doesn't get confused with |
| # any expected debugger output from a subsequent testpoint. |
| # |
| exec sleep 1 |
| }} |
| |
| proc vfork_child_follow_to_exit {} { |
| with_test_prefix "vfork child follow, to exit" { |
| global gdb_prompt |
| |
| setup_gdb |
| |
| gdb_test_no_output "set follow-fork child" |
| |
| set test "continue to child exit" |
| gdb_test_multiple "continue" $test { |
| -re "Couldn't get registers.*$gdb_prompt " { |
| # PR gdb/14766 |
| fail "$test" |
| } |
| -re "Attaching after.* vfork to.*Detaching vfork parent .* after child exit.*$gdb_prompt " { |
| pass $test |
| } |
| } |
| # The parent has been detached; allow time for any output it might |
| # generate to arrive, so that output doesn't get confused with |
| # any gdb_expected debugger output from a subsequent testpoint. |
| # |
| exec sleep 1 |
| }} |
| |
| proc vfork_and_exec_child_follow_to_main_bp {} { |
| with_test_prefix "vfork and exec child follow, to main bp" { |
| global gdb_prompt |
| global srcfile2 |
| |
| setup_gdb |
| |
| gdb_test_no_output "set follow-fork child" |
| |
| set linenum [gdb_get_line_number "printf(\"Hello from vforked-prog" ${srcfile2}] |
| |
| set test "continue to bp" |
| gdb_test_multiple "continue" $test { |
| -re "Attaching after.* vfork to.*xecuting new program.*Breakpoint.*vforked-prog.c:${linenum}.*$gdb_prompt " { |
| pass $test |
| } |
| } |
| # The parent has been detached; allow time for any output it might |
| # generate to arrive, so that output doesn't get confused with |
| # any gdb_expected debugger output from a subsequent testpoint. |
| # |
| exec sleep 1 |
| }} |
| |
| proc vfork_and_exec_child_follow_through_step {} { |
| with_test_prefix "vfork and exec child follow, through step" { |
| global gdb_prompt |
| global srcfile2 |
| |
| if { [istarget "hppa*-*-hpux*"] && ![istarget "hppa*-*-hpux11.*"] } { |
| # This test cannot be performed prior to HP-UX 10.30, because |
| # ptrace-based debugging of a vforking program basically doesn't |
| # allow the child to do things like hit a breakpoint between a |
| # vfork and exec. This means that saying "set follow-fork |
| # child; next" at a vfork() call won't work, because the |
| # implementation of "next" sets a "step resume" breakpoint at |
| # the return from the vfork(), which the child will hit on its |
| # way to exec'ing. |
| # |
| verbose "vfork child-following next test ignored for pre-HP/UX-10.30 targets." |
| return 0 |
| } |
| |
| setup_gdb |
| |
| gdb_test_no_output "set follow-fork child" |
| |
| set test "step over vfork" |
| if { [istarget "hppa*-*-hpux*"]} { |
| # Since the child cannot be debugged until after it has exec'd, |
| # and since there's a bp on "main" in the parent, and since the |
| # bp's for the parent are recomputed in the exec'd child, the |
| # step through a vfork should land us in the "main" for the |
| # exec'd child, too. |
| # |
| set linenum [gdb_get_line_number "printf(\"Hello from vforked-prog" ${srcfile2}] |
| gdb_test_multiple "next" $test { |
| -re "Attaching after fork to.*Executing new program.*Breakpoint.*vforked-prog.c:${linenum}.*$gdb_prompt " { |
| pass "$test" |
| } |
| } |
| } else { |
| # The ideal support is to be able to debug the child even |
| # before it execs. Thus, "next" lands on the next line after |
| # the vfork. |
| gdb_test_multiple "next" $test { |
| -re "Attaching after .* vfork to child.*if \\(pid == 0\\).*$gdb_prompt " { |
| pass "$test" |
| } |
| } |
| } |
| # The parent has been detached; allow time for any output it might |
| # generate to arrive, so that output doesn't get confused with |
| # any expected debugger output from a subsequent testpoint. |
| # |
| exec sleep 1 |
| }} |
| |
| proc tcatch_vfork_then_parent_follow {} { |
| with_test_prefix "vfork parent follow, finish after tcatch vfork" { |
| global gdb_prompt |
| global srcfile |
| |
| setup_gdb |
| |
| gdb_test_no_output "set follow-fork parent" |
| |
| gdb_test "tcatch vfork" "Catchpoint .*(vfork).*" |
| |
| # HP-UX 10.20 seems to stop you in "vfork", while more recent |
| # HP-UXs stop you in "_vfork". |
| set test "continue to vfork" |
| gdb_test_multiple "continue" $test { |
| -re "0x\[0-9a-fA-F\]*.*(vfork|__kernel_v?syscall).*$gdb_prompt " { |
| pass $test |
| } |
| -re "vfork \\(\\) at.*$gdb_prompt " { |
| pass $test |
| } |
| } |
| |
| set linenum [gdb_get_line_number "pid = vfork ();"] |
| set test "finish" |
| gdb_test_multiple "finish" $test { |
| -re "Run till exit from.*vfork.*0x\[0-9a-fA-F\]* in main .* at .*${srcfile}:${linenum}.*$gdb_prompt " { |
| pass $test |
| } |
| -re "Run till exit from.*__kernel_v?syscall.*0x\[0-9a-fA-F\]* in vfork .*$gdb_prompt " { |
| send_gdb "finish\n" |
| exp_continue |
| } |
| } |
| # The child has been detached; allow time for any output it might |
| # generate to arrive, so that output doesn't get confused with |
| # any expected debugger output from a subsequent testpoint. |
| # |
| exec sleep 1 |
| }} |
| |
| proc tcatch_vfork_then_child_follow_exec {} { |
| with_test_prefix "vfork child follow, finish after tcatch vfork" { |
| global gdb_prompt |
| global srcfile |
| global srcfile2 |
| |
| setup_gdb |
| |
| gdb_test_no_output "set follow-fork child" |
| |
| gdb_test "tcatch vfork" "Catchpoint .*(vfork).*" |
| |
| # HP-UX 10.20 seems to stop you in "vfork", while more recent HP-UXs |
| # stop you in "_vfork". |
| set test "continue to vfork" |
| gdb_test_multiple "continue" $test { |
| -re "vfork \\(\\) at .*$gdb_prompt $" { |
| pass $test |
| } |
| -re "0x\[0-9a-fA-F\]*.*(vfork|__kernel_v?syscall).*$gdb_prompt " { |
| pass $test |
| } |
| } |
| |
| set linenum1 [gdb_get_line_number "pid = vfork ();"] |
| set linenum2 [gdb_get_line_number "printf(\"Hello from vforked-prog" ${srcfile2}] |
| |
| set test "finish" |
| gdb_test_multiple "finish" $test { |
| -re "Run till exit from.*vfork.*${srcfile}:${linenum1}.*$gdb_prompt " { |
| pass $test |
| } |
| -re "Run till exit from.*__kernel_v?syscall.*0x\[0-9a-fA-F\]* in vfork .*$gdb_prompt " { |
| send_gdb "finish\n" |
| exp_continue |
| } |
| -re "Run till exit from.*vfork.*${srcfile2}:${linenum2}.*$gdb_prompt " { |
| pass "$test (followed exec)" |
| } |
| } |
| # The parent has been detached; allow time for any output it might |
| # generate to arrive, so that output doesn't get confused with |
| # any expected debugger output from a subsequent testpoint. |
| # |
| exec sleep 1 |
| }} |
| |
| proc tcatch_vfork_then_child_follow_exit {} { |
| with_test_prefix "vfork child follow, finish after tcatch vfork" { |
| global gdb_prompt |
| global srcfile |
| |
| setup_gdb |
| |
| gdb_test_no_output "set follow-fork child" |
| |
| gdb_test "tcatch vfork" "Catchpoint .*(vfork).*" |
| |
| # HP-UX 10.20 seems to stop you in "vfork", while more recent HP-UXs |
| # stop you in "_vfork". |
| set test "continue to vfork" |
| gdb_test_multiple "continue" $test { |
| -re "vfork \\(\\) at .*$gdb_prompt $" { |
| pass $test |
| } |
| -re "0x\[0-9a-fA-F\]*.*(vfork|__kernel_v?syscall).*$gdb_prompt " { |
| pass $test |
| } |
| } |
| |
| set test "finish" |
| gdb_test_multiple "finish" $test { |
| -re "Run till exit from.*vfork.*exited normally.*$gdb_prompt " { |
| setup_kfail "gdb/14762" *-*-* |
| fail $test |
| } |
| -re "Run till exit from.*vfork.*pid = vfork \\(\\).*$gdb_prompt " { |
| pass $test |
| } |
| -re "Run till exit from.*__kernel_v?syscall.*0x\[0-9a-fA-F\]* in vfork .*$gdb_prompt " { |
| send_gdb "finish\n" |
| exp_continue |
| } |
| } |
| # The parent has been detached; allow time for any output it might |
| # generate to arrive, so that output doesn't get confused with |
| # any expected debugger output from a subsequent testpoint. |
| # |
| exec sleep 1 |
| }} |
| |
| proc vfork_relations_in_info_inferiors { variant } { |
| with_test_prefix "vfork relations in info inferiors" { |
| global gdb_prompt |
| |
| setup_gdb |
| |
| gdb_test_no_output "set follow-fork child" |
| |
| set test "step over vfork" |
| gdb_test_multiple "next" $test { |
| -re "Attaching after .* vfork to child.*if \\(pid == 0\\).*$gdb_prompt " { |
| pass "$test" |
| } |
| } |
| |
| gdb_test "info inferiors" \ |
| ".*is vfork child of inferior 1.*is vfork parent of inferior 2" \ |
| "info inferiors shows vfork parent/child relation" |
| |
| if { $variant == "exec" } { |
| global srcfile2 |
| |
| set linenum [gdb_get_line_number "printf(\"Hello from vforked-prog" ${srcfile2}] |
| set test "continue to bp" |
| gdb_test_multiple "continue" $test { |
| -re ".*xecuting new program.*Breakpoint.*vforked-prog.c:${linenum}.*$gdb_prompt " { |
| pass $test |
| } |
| } |
| } else { |
| set test "continue to child exit" |
| gdb_test_multiple "continue" $test { |
| -re "exited normally.*$gdb_prompt " { |
| pass $test |
| } |
| } |
| } |
| |
| set test "vfork relation no longer appears in info inferiors" |
| gdb_test_multiple "info inferiors" $test { |
| -re "is vfork child of inferior 1.*$gdb_prompt $" { |
| fail $test |
| } |
| -re "is vfork parent of inferior 2.*$gdb_prompt $" { |
| fail $test |
| } |
| -re "$gdb_prompt $" { |
| pass $test |
| } |
| } |
| }} |
| |
| proc do_vfork_and_follow_parent_tests {} { |
| global gdb_prompt |
| |
| # Try following the parent process by stepping through a call to |
| # vfork. Do this without catchpoints. |
| vfork_parent_follow_through_step |
| |
| # Try following the parent process by setting a breakpoint on the |
| # other side of a vfork, and running to that point. Do this |
| # without catchpoints. |
| vfork_parent_follow_to_bp |
| |
| # Try catching a vfork, and stepping out to the parent. |
| # |
| tcatch_vfork_then_parent_follow |
| } |
| |
| proc do_vfork_and_follow_child_tests_exec {} { |
| # Try following the child process by just continuing through the |
| # vfork, and letting the parent's breakpoint on "main" be auto- |
| # magically reset in the child. |
| # |
| vfork_and_exec_child_follow_to_main_bp |
| |
| # Try following the child process by stepping through a call to |
| # vfork. The child also executes an exec. Since the child cannot |
| # be debugged until after it has exec'd, and since there's a bp on |
| # "main" in the parent, and since the bp's for the parent are |
| # recomputed in the exec'd child, the step through a vfork should |
| # land us in the "main" for the exec'd child, too. |
| # |
| vfork_and_exec_child_follow_through_step |
| |
| # Try catching a vfork, and stepping out to the child. |
| # |
| tcatch_vfork_then_child_follow_exec |
| |
| # Test the ability to follow both child and parent of a vfork. Do |
| # this without catchpoints. |
| # ??rehrauer: NYI. Will add testpoints here when implemented. |
| # |
| |
| # Test the ability to have the debugger ask the user at vfork-time |
| # whether to follow the parent, child or both. Do this without |
| # catchpoints. |
| # ??rehrauer: NYI. Will add testpoints here when implemented. |
| # |
| |
| # Step over a vfork in the child, do "info inferiors" and check the |
| # parent/child relation is displayed. Run the child over the exec, |
| # and confirm the relation is no longer displayed in "info |
| # inferiors". |
| # |
| vfork_relations_in_info_inferiors "exec" |
| } |
| |
| proc do_vfork_and_follow_child_tests_exit {} { |
| # Try following the child process by just continuing through the |
| # vfork, and letting the child exit. |
| # |
| vfork_child_follow_to_exit |
| |
| # Try catching a vfork, and stepping out to the child. |
| # |
| tcatch_vfork_then_child_follow_exit |
| |
| # Step over a vfork in the child, do "info inferiors" and check the |
| # parent/child relation is displayed. Run the child to completion, |
| # and confirm the relation is no longer displayed in "info |
| # inferiors". |
| # |
| vfork_relations_in_info_inferiors "exit" |
| } |
| |
| with_test_prefix "check vfork support" { |
| # Check that vfork catchpoints are supported, as an indicator for |
| # whether vfork-following is supported. |
| check_vfork_catchpoints |
| } |
| |
| # Follow parent and follow child vfork tests with a child that execs. |
| with_test_prefix "exec" { |
| # These are tests of gdb's ability to follow the parent of a Unix |
| # vfork system call. The child will subsequently call a variant |
| # of the Unix exec system call. |
| do_vfork_and_follow_parent_tests |
| |
| # These are tests of gdb's ability to follow the child of a Unix |
| # vfork system call. The child will subsequently call a variant |
| # of a Unix exec system call. |
| # |
| do_vfork_and_follow_child_tests_exec |
| } |
| |
| # Switch to test the case of the child exiting. We can't use |
| # standard_testfile here because we don't want to overwrite the binary |
| # of the previous tests. |
| set testfile "foll-vfork-exit" |
| set srcfile ${testfile}.c |
| set binfile [standard_output_file ${testfile}] |
| |
| if {[build_executable $testfile.exp $testfile $srcfile] == -1} { |
| untested "failed to build $testfile" |
| return |
| } |
| |
| # Follow parent and follow child vfork tests with a child that exits. |
| with_test_prefix "exit" { |
| # These are tests of gdb's ability to follow the parent of a Unix |
| # vfork system call. The child will subsequently exit. |
| do_vfork_and_follow_parent_tests |
| |
| # These are tests of gdb's ability to follow the child of a Unix |
| # vfork system call. The child will subsequently exit. |
| # |
| do_vfork_and_follow_child_tests_exit |
| } |
| |
| set timeout $oldtimeout |
| return 0 |