-# Copyright 1997, 1999, 2007-2012 Free Software Foundation, Inc.
+# Copyright 1997-2017 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
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
-if { [is_remote target] || ![isnative] } then {
- continue
-}
+# 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.
# Until "set follow-fork-mode" and "catch vfork" are implemented on
# other targets...
#
-if {![istarget "hppa*-hp-hpux*"] && ![istarget "*-linux*"]} then {
+if {![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"
+set compile_options debug
+
+if {[build_executable $testfile.exp $testfile $srcfile $compile_options] == -1} {
+ untested "failed to compile main testcase"
return -1
}
set testfile2 "vforked-prog"
set srcfile2 ${testfile2}.c
-if {[build_executable $testfile.exp $testfile2 $srcfile2 {debug}] == -1} {
- untested "failed to compile $testfile2"
+if {[build_executable $testfile.exp $testfile2 $srcfile2 $compile_options] == -1} {
+ untested "failed to compile secondary testcase"
return -1
}
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 srcfile
+
+ 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
+ }
+
+ set tbreak_line [gdb_get_line_number " VFORK " $srcfile]
+ gdb_test "tbreak ${tbreak_line}"
+ gdb_continue_to_breakpoint ".*"
+}
+
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
}
proc vfork_parent_follow_through_step {} {
+ with_test_prefix "vfork parent follow, through step" {
global gdb_prompt
- gdb_test_no_output "set follow-fork parent" \
- "set follow-fork parent, vfork through step"
+ setup_gdb
+
+ gdb_test_no_output "set follow-fork parent"
- set test "vfork parent follow, through step"
+ set test "step"
gdb_test_multiple "next" $test {
- -re "Detaching after fork from.*if \\(pid == 0\\).*$gdb_prompt " {
- pass "vfork parent follow, through step"
+ -re "Detaching after vfork from.*if \\(pid == 0\\).*$gdb_prompt " {
+ pass $test
}
}
# The child has been detached; allow time for any output it might
# 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
- gdb_test_no_output "set follow-fork parent" \
- "set follow-fork parent, vfork to bp"
+ 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 "vfork parent follow, to bp"
+ set test "continue to bp"
gdb_test_multiple "continue" $test {
- -re ".*Detaching after fork from child process.*Breakpoint.*${bp_location}.*$gdb_prompt " {
+ -re ".*Detaching after vfork from child process.*Breakpoint.*${bp_location}.*$gdb_prompt " {
pass $test
}
}
# any expected debugger output from a subsequent testpoint.
#
exec sleep 1
-}
+}}
-# Kill child and reload symbols.
-proc kill_child {} {
- global binfile
+proc vfork_child_follow_to_exit {} {
+ with_test_prefix "vfork child follow, to exit" {
global gdb_prompt
- set test "killing inferior"
- gdb_test_multiple "kill" $test {
- -re ".*Kill the program being debugged.*y or n. $" {
- gdb_test_no_output "y" ""
- set test2 "file $binfile"
- gdb_test_multiple "file $binfile" $test2 {
- -re ".*Load new symbol table from.*y or n. $" {
- send_gdb "y\n"
- gdb_test_multiple "" "loading symbols" {
- -re "Reading symbols from.*$gdb_prompt $" {
- }
- }
- }
- -re ".*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 ".*$gdb_prompt $" {
+ -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
- gdb_test_no_output \
- "set follow-fork child" \
- "set follow-fork child, vfork and exec to main bp"
+ setup_gdb
+
+ gdb_test_no_output "set follow-fork child"
set linenum [gdb_get_line_number "printf(\"Hello from vforked-prog" ${srcfile2}]
- set test "vfork and exec child follow, to main bp"
+ 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 " {
+ -re "Attaching after.* vfork to.*Detaching vfork parent.*xecuting new program.*Breakpoint.*vforked-prog.c:${linenum}.*$gdb_prompt " {
pass $test
}
}
# any gdb_expected debugger output from a subsequent testpoint.
#
exec sleep 1
-
- # Explicitly kill this child, or a subsequent rerun actually runs
- # the exec'd child, not the original program...
- kill_child
-}
+}}
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 follow-fork child, vfork and exec through step"
-
- set test "vfork and exec child follow, through step"
- 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"
- }
+ gdb_test_no_output "set follow-fork child"
+
+ set test "step over vfork"
+
+ # 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
# any expected debugger output from a subsequent testpoint.
#
exec sleep 1
+}}
- # Explicitly kill this child, or a subsequent rerun actually runs
- # the exec'd child, not the original program...
- kill_child
-}
-
-proc tcatch_vfork_then_parent_follow {} {
+proc continue_to_vfork {} {
global gdb_prompt
- global srcfile
-
- gdb_test_no_output \
- "set follow-fork parent" \
- "set follow-fork parent, tcatch vfork"
-
- gdb_test "tcatch vfork" \
- "Catchpoint .*(vfork).*" \
- "vfork parent follow, set tcatch vfork"
- # HP-UX 10.20 seems to stop you in "vfork", while more recent
- # HP-UXs stop you in "_vfork".
- set test "vfork parent follow, tcatch vfork"
+ # A vfork catchpoint may stop in either "vfork" or "_vfork".
+ set test "continue to vfork"
gdb_test_multiple "continue" $test {
- -re "0x\[0-9a-fA-F\]*.*(vfork|__kernel_v?syscall).*$gdb_prompt " {
+ -re "vfork \\(\\) at .*$gdb_prompt $" {
pass $test
}
- -re "vfork \\(\\) at.*$gdb_prompt " {
+ -re "0x\[0-9a-fA-F\]*.*(vfork|__kernel_v?syscall).*$gdb_prompt " {
pass $test
}
}
+}
+
+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).*"
+
+ continue_to_vfork
set linenum [gdb_get_line_number "pid = vfork ();"]
- set test "vfork parent follow, finish after tcatch 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
# any expected debugger output from a subsequent testpoint.
#
exec sleep 1
-}
+}}
-proc tcatch_vfork_then_child_follow {} {
+proc tcatch_vfork_then_child_follow_exec {} {
+ with_test_prefix "vfork child follow, finish after tcatch vfork" {
global gdb_prompt
global srcfile
global srcfile2
- gdb_test_no_output \
- "set follow-fork child" \
- "set follow-fork child, tcatch vfork"
+ setup_gdb
- gdb_test "tcatch vfork" \
- "Catchpoint .*(vfork).*" \
- "vfork child follow, set tcatch vfork"
+ gdb_test_no_output "set follow-fork child"
- # HP-UX 10.20 seems to stop you in "vfork", while more recent HP-UXs
- # stop you in "_vfork".
- set test "vfork child follow, tcatch 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
- }
- }
+ gdb_test "tcatch vfork" "Catchpoint .*(vfork).*"
+
+ continue_to_vfork
set linenum1 [gdb_get_line_number "pid = vfork ();"]
set linenum2 [gdb_get_line_number "printf(\"Hello from vforked-prog" ${srcfile2}]
- set test "vfork child follow, finish after tcatch vfork"
+ set test "finish"
gdb_test_multiple "finish" $test {
-re "Run till exit from.*vfork.*${srcfile}:${linenum1}.*$gdb_prompt " {
pass $test
# 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).*"
+
+ continue_to_vfork
+
+ 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 do_vfork_and_exec_tests {} {
+proc vfork_relations_in_info_inferiors { variant } {
+ with_test_prefix "vfork relations in info inferiors" {
global gdb_prompt
- # Check that vfork catchpoints are supported, as an indicator for whether
- # vfork-following is supported.
- if [runto_main] then { check_vfork_catchpoints }
+ 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 parent of inferior 2.*is vfork child of inferior 1" \
+ "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.
- if [runto_main] then { vfork_parent_follow_through_step }
+ 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.
- if [runto_main] then { vfork_parent_follow_to_bp }
+ 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.
#
- if [runto_main] then { vfork_and_exec_child_follow_to_main_bp }
+ 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
# recomputed in the exec'd child, the step through a vfork should
# land us in the "main" for the exec'd child, too.
#
- if [runto_main] then { vfork_and_exec_child_follow_through_step }
-
- # Try catching a vfork, and stepping out to the parent.
- #
- if [runto_main] then { tcatch_vfork_then_parent_follow }
+ vfork_and_exec_child_follow_through_step
# Try catching a vfork, and stepping out to the child.
#
- if [runto_main] then { tcatch_vfork_then_child_follow }
+ tcatch_vfork_then_child_follow_exec
# Test the ability to follow both child and parent of a vfork. Do
# this without catchpoints.
# 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"
}
-# Start with a fresh gdb
-clean_restart $testfile
+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
-# The "Detaching..." and "Attaching..." messages may be hidden by
-# default.
-gdb_test_no_output "set verbose"
+ # Try catching a vfork, and stepping out to the child.
+ #
+ tcatch_vfork_then_child_follow_exit
-# This is a test of gdb's ability to follow the parent or child
-# of a Unix vfork() system call. (The child will subsequently
-# call a variant of a Unix exec() system call.)
-#
-do_vfork_and_exec_tests
+ # 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