forked from Imagelibrary/binutils-gdb
f67c0c9171
This patch aims to turn 'set print inferior-events' always on, and do
some cleanup on the messages printed by GDB when various inferior
events happen (attach, detach, fork, kill, exit).
To make sure that the patch is correct, I've tested it with a handful
of combinations of 'set follow-fork-mode', 'set detach-on-fork' and
'set print inferior-events'. In the end, I decided to make my
hand-made test into an official testcase. More on that below.
Using the following program as an example:
#include <unistd.h>
int main ()
{
fork ();
return 0;
}
We see the following outputs from the patched GDB:
- With 'set print inferior-events on':
(gdb) r
Starting program: a.out
[Detaching after fork from child process 27749]
[Inferior 1 (process 27745) exited normally]
(gdb)
- With 'set print inferior-events off':
(gdb) r
Starting program: a.out
[Inferior 1 (process 27823) exited normally]
(gdb)
Comparing this against an unpatched GDB:
- With 'set print inferior-events off' and 'set follow-fork-mode
child':
(gdb) r
Starting program: a.out
[Inferior 2 (process 5993) exited normally]
(gdb)
Compare this against an unpatched GDB:
(unpatched-gdb) r
Starting program: a.out
[New process 5702]
[Inferior 2 (process 5702) exited normally]
(unpatched-gdb)
It is possible to notice that, in this scenario, the patched GDB
will lose the '[New process %d]' message.
- With 'set print inferior-events on', 'set follow-fork-mode child'
and 'set detach-on-fork on':
(gdb) r
Starting program: a.out
[Attaching after process 27905 fork to child process 27909]
[New inferior 2 (process 27909)]
[Detaching after fork from parent process 27905]
[Inferior 1 (process 27905) detached]
[Inferior 2 (process 27909) exited normally]
(gdb)
Compare this output with an unpatched GDB, using the same settings:
(unpatched-gdb) r
Starting program: a.out
[New inferior 28033]
[Inferior 28029 detached]
[New process 28033]
[Inferior 2 (process 28033) exited normally]
[Inferior 28033 exited]
(unpatched-gdb)
As can be seen above, I've also made a few modifications to messages
that are printed when 'set print inferior-events' is on. For example,
a few of the messages did not contain the '[' and ']' as
prefix/suffix, which led to a few inconsistencies like:
Attaching after process 22995 fork to child process 22999.
[New inferior 22999]
Detaching after fork from child process 22999.
[Inferior 22995 detached]
[Inferior 2 (process 22999) exited normally]
So I took the opportunity and included the square brackets where
applicable. I have also made the existing messages more uniform, by
always printing "Inferior %d (process %d)..." where applicable. This
makes it easier to identify the inferior number and the PID number
from the messages.
As suggested by Pedro, the "[Inferior %d exited]" message from
'exit_inferior' has been removed, because it got duplicated when
'inferior-events' is on. I'm also using the
'add_{thread,inferior}_silent' versions (instead of their verbose
counterparts) on some locations, also to avoid duplicated messages.
For example, a patched GDB with 'set print inferior-events on', 'set
detach-on-fork on' and 'set follow-fork-mode child', but using
'add_thread', would print:
(gdb) run
Starting program: a.out
[Attaching after process 25088 fork to child process 25092.]
[New inferior 25092] <--- duplicated
[Detaching after fork from child process 25092.]
[Inferior 25088 detached]
[New process 25092] <--- duplicated
[Inferior 2 (process 25092) exited normally]
But if we use 'add_thread_silent' (with the same configuration as
before):
(gdb) run
Starting program: a.out
[Attaching after process 31606 fork to child process 31610]
[New inferior 2 (process 31610)]
[Detaching after fork from parent process 31606]
[Inferior 1 (process 31606) detached]
[Inferior 2 (process 31610) exited normally]
As for the tests, the configuration options being exercised are:
- follow-fork-mode: child/parent
- detach-on-fork: on/off
- print inferior-events: on/off
It was also necessary to perform adjustments on several testcases,
because the expected messages changed considerably.
Built and regtested on BuildBot, without regressions.
gdb/ChangeLog:
2018-04-24 Jan Kratochvil <jan.kratochvil@redhat.com>
Sergio Durigan Junior <sergiodj@redhat.com>
Pedro Alves <palves@redhat.com>
* infcmd.c (kill_command): Print message when inferior has
been killed.
* inferior.c (print_inferior_events): Remove 'static'. Set as
'1'.
(add_inferior): Improve message printed when
'print_inferior_events' is on.
(exit_inferior): Remove message printed when
'print_inferior_events' is on.
(detach_inferior): Improve message printed when
'print_inferior_events' is on.
(initialize_inferiors): Use 'add_inferior_silent' to set
'current_inferior_'.
* inferior.h (print_inferior_events): Declare here as
'extern'.
* infrun.c (follow_fork_inferior): Print '[Attaching...]' or
'[Detaching...]' messages when 'print_inferior_events' is on.
Use 'add_thread_silent' instead of 'add_thread'. Add '[' and ']'
as prefix/suffix for messages. Remove periods. Fix erroneous
'Detaching after fork from child...', replace it by '... from
parent...'.
(handle_vfork_child_exec_or_exit): Add '[' and ']' as
prefix/suffix when printing 'Detaching...' messages. Print
them when 'print_inferior_events' is on.
* remote.c (remote_detach_1): Print message when detaching
from inferior and '!is_fork_parent'.
gdb/testsuite/ChangeLog:
2018-04-24 Jan Kratochvil <jan.kratochvil@redhat.com>
Sergio Durigan Junior <sergiodj@redhat.com>
Pedro Alves <palves@redhat.com>
* gdb.base/attach-non-pgrp-leader.exp: Adjust 'Detaching...'
regexps to expect for '[Inferior ... detached]' as well.
* gdb.base/attach.exp: Likewise.
* gdb.base/catch-syscall.exp (check_for_program_end): Adjust
"gdb_continue_to_end".
(test_catch_syscall_with_wrong_args): Likewise.
* gdb.base/foll-fork.exp: Adjust regexps to match '[' and
']'. Don't set 'verbose' on.
* gdb.base/foll-vfork.exp: Likewise.
* gdb.base/fork-print-inferior-events.c: New file.
* gdb.base/fork-print-inferior-events.exp: New file.
* gdb.base/hook-stop.exp: Adjust regexps to expect for new
'[Inferior ... has been killed]' message.
* gdb.base/kill-after-signal.exp: Likewise.
* gdb.base/solib-overlap.exp: Adjust regexps to expect for new
detach message.
* gdb.threads/kill.exp: Adjust regexps to expect for new kill
message.
* gdb.threads/clone-attach-detach.exp: Adjust 'Detaching...'
regexps to expect for '[Inferior ... detached]' as well.
* gdb.threads/process-dies-while-detaching.exp: Likewise.
407 lines
13 KiB
Plaintext
407 lines
13 KiB
Plaintext
# Copyright 1997-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/>.
|
|
|
|
# Until "set follow-fork-mode" and "catch fork" are implemented on
|
|
# other targets...
|
|
#
|
|
if { ![istarget "*-*-linux*"] && ![istarget "*-*-openbsd*"] } then {
|
|
continue
|
|
}
|
|
|
|
standard_testfile
|
|
|
|
if {[prepare_for_testing "failed to prepare" $testfile $srcfile debug]} {
|
|
return -1
|
|
}
|
|
|
|
proc check_fork_catchpoints {} {
|
|
global gdb_prompt
|
|
|
|
# Verify that the system supports "catch fork".
|
|
gdb_test "catch fork" "Catchpoint \[0-9\]* \\(fork\\)" "insert first fork catchpoint"
|
|
set has_fork_catchpoints 0
|
|
gdb_test_multiple "continue" "continue to first fork catchpoint" {
|
|
-re ".*Your system does not support this type\r\nof catchpoint.*$gdb_prompt $" {
|
|
unsupported "continue to first fork catchpoint"
|
|
}
|
|
-re ".*Catchpoint.*$gdb_prompt $" {
|
|
set has_fork_catchpoints 1
|
|
pass "continue to first fork catchpoint"
|
|
}
|
|
}
|
|
|
|
if {$has_fork_catchpoints == 0} {
|
|
unsupported "fork catchpoints"
|
|
return -code return
|
|
}
|
|
}
|
|
|
|
# Test follow-fork to ensure that the correct process is followed, that
|
|
# the followed process stops where it is expected to stop, that processes
|
|
# are detached (or not) as expected, and that the inferior list has the
|
|
# expected contents after following the fork. WHO is the argument to
|
|
# the 'set follow-fork-mode' command, DETACH is the argument to the
|
|
# 'set detach-on-fork' command, and CMD is the GDB command used to
|
|
# execute the program past the fork. If the value of WHO or DETACH is
|
|
# 'default', the corresponding GDB command is skipped for that test.
|
|
# The value of CMD must be either 'next 2' or 'continue'.
|
|
proc test_follow_fork { who detach cmd } {
|
|
global gdb_prompt
|
|
global srcfile
|
|
global testfile
|
|
|
|
with_test_prefix "follow $who, detach $detach, command \"$cmd\"" {
|
|
|
|
# Start a new debugger session each time so defaults are legitimate.
|
|
clean_restart $testfile
|
|
|
|
if ![runto_main] {
|
|
untested "could not run to main"
|
|
return -1
|
|
}
|
|
|
|
# The "Detaching..." and "Attaching..." messages may be hidden by
|
|
# default.
|
|
gdb_test_no_output "set verbose"
|
|
|
|
# Set follow-fork-mode if we aren't using the default.
|
|
if {$who == "default"} {
|
|
set who "parent"
|
|
} else {
|
|
gdb_test_no_output "set follow-fork $who"
|
|
}
|
|
|
|
gdb_test "show follow-fork" \
|
|
"Debugger response to a program call of fork or vfork is \"$who\"." \
|
|
"show follow-fork"
|
|
|
|
# Set detach-on-fork mode if we aren't using the default.
|
|
if {$detach == "default"} {
|
|
set detach "on"
|
|
} else {
|
|
gdb_test_no_output "set detach-on-fork $detach"
|
|
}
|
|
|
|
gdb_test "show detach-on-fork" \
|
|
"Whether gdb will detach.* fork is $detach." \
|
|
"show detach-on-fork"
|
|
|
|
# Set a breakpoint after the fork if we aren't single-stepping
|
|
# past the fork.
|
|
if {$cmd == "continue"} {
|
|
set bp_after_fork [gdb_get_line_number "set breakpoint here"]
|
|
gdb_test "break ${srcfile}:$bp_after_fork" \
|
|
"Breakpoint.*, line $bp_after_fork.*" \
|
|
"set breakpoint after fork"
|
|
}
|
|
|
|
# Set up the output we expect to see after we run.
|
|
set expected_re ""
|
|
if {$who == "child"} {
|
|
set expected_re "\\\[Attaching after.* fork to.*"
|
|
if {$detach == "on"} {
|
|
append expected_re "\\\[Detaching after fork from .*"
|
|
}
|
|
append expected_re "set breakpoint here.*"
|
|
} elseif {$who == "parent" && $detach == "on"} {
|
|
set expected_re "\\\[Detaching after fork from .*set breakpoint here.*"
|
|
} else {
|
|
set expected_re ".*set breakpoint here.*"
|
|
}
|
|
|
|
# Test running past and following the fork, using the parameters
|
|
# set above.
|
|
gdb_test $cmd $expected_re "$cmd past fork"
|
|
|
|
# Check that we have the inferiors arranged correctly after
|
|
# following the fork.
|
|
set resume_unfollowed 0
|
|
if {$who == "parent" && $detach == "on"} {
|
|
|
|
# Follow parent / detach child: the only inferior is the parent.
|
|
gdb_test "info inferiors" "\\* 1 .* process.*" \
|
|
"info inferiors"
|
|
|
|
} elseif {$who == "parent" && $detach == "off"} {
|
|
|
|
# Follow parent / keep child: two inferiors under debug, the
|
|
# parent is the current inferior.
|
|
gdb_test "info inferiors" "\\* 1 .*process.* 2 .*process.*" \
|
|
"info inferiors"
|
|
|
|
gdb_test "inferior 2" "Switching to inferior 2 .*"
|
|
set resume_unfollowed 1
|
|
|
|
} elseif {$who == "child" && $detach == "on"} {
|
|
|
|
# Follow child / detach parent: the child is under debug and is
|
|
# the current inferior. The parent is listed but is not under
|
|
# debug.
|
|
gdb_test "info inferiors" " 1 .*<null>.*\\* 2 .*process.*" \
|
|
"info inferiors"
|
|
|
|
} elseif {$who == "child" && $detach == "off"} {
|
|
|
|
# Follow child / keep parent: two inferiors under debug, the
|
|
# child is the current inferior.
|
|
gdb_test "info inferiors" " 1 .*process.*\\* 2 .*process.*" \
|
|
"info inferiors"
|
|
|
|
gdb_test "inferior 1" "Switching to inferior 1 .*"
|
|
set resume_unfollowed 1
|
|
}
|
|
|
|
if {$resume_unfollowed == 1} {
|
|
if {$cmd == "next 2"} {
|
|
|
|
gdb_continue_to_end "continue unfollowed inferior to end"
|
|
|
|
} elseif {$cmd == "continue"} {
|
|
|
|
gdb_continue_to_breakpoint \
|
|
"continue unfollowed inferior to bp" \
|
|
".* set breakpoint here.*"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
proc catch_fork_child_follow {} {
|
|
global gdb_prompt
|
|
global srcfile
|
|
|
|
set bp_after_fork [gdb_get_line_number "set breakpoint here"]
|
|
|
|
gdb_test "catch fork" "Catchpoint \[0-9\]* \\(fork\\)" \
|
|
"explicit child follow, set catch fork"
|
|
|
|
# Verify that the catchpoint is mentioned in an "info breakpoints",
|
|
# and further that the catchpoint mentions no process id.
|
|
#
|
|
set test_name "info shows catchpoint without pid"
|
|
gdb_test_multiple "info breakpoints" "$test_name" {
|
|
-re ".*catchpoint.*keep y.*fork\[\r\n\]+$gdb_prompt $" {
|
|
pass "$test_name"
|
|
}
|
|
}
|
|
|
|
gdb_test "continue" \
|
|
"Catchpoint \[0-9\]* \\(forked process \[0-9\]*\\),.*" \
|
|
"explicit child follow, catch fork"
|
|
|
|
# Verify that the catchpoint is mentioned in an "info breakpoints",
|
|
# and further that the catchpoint managed to capture a process id.
|
|
#
|
|
set test_name "info shows catchpoint without pid"
|
|
gdb_test_multiple "info breakpoints" "$test_name" {
|
|
-re ".*catchpoint.*keep y.*fork, process.*$gdb_prompt $" {
|
|
pass "$test_name"
|
|
}
|
|
}
|
|
|
|
gdb_test_no_output "set follow-fork child"
|
|
|
|
gdb_test "tbreak ${srcfile}:$bp_after_fork" \
|
|
"Temporary breakpoint.*, line $bp_after_fork.*" \
|
|
"set follow-fork child, tbreak"
|
|
|
|
set expected_re "\\\[Attaching after.* fork to.*\\\[Detaching after fork from"
|
|
append expected_re ".* at .*$bp_after_fork.*"
|
|
gdb_test "continue" $expected_re "set follow-fork child, hit tbreak"
|
|
|
|
# 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
|
|
|
|
gdb_test "delete breakpoints" \
|
|
"" \
|
|
"set follow-fork child, cleanup" \
|
|
"Delete all breakpoints. \\(y or n\\) $" \
|
|
"y"
|
|
}
|
|
|
|
proc catch_fork_unpatch_child {} {
|
|
global gdb_prompt
|
|
global srcfile
|
|
|
|
set bp_exit [gdb_get_line_number "at exit"]
|
|
|
|
gdb_test "break callee" "file .*$srcfile, line .*" \
|
|
"unpatch child, break at callee"
|
|
gdb_test "catch fork" "Catchpoint \[0-9\]* \\(fork\\)" \
|
|
"unpatch child, set catch fork"
|
|
|
|
gdb_test "continue" \
|
|
"Catchpoint \[0-9\]* \\(forked process \[0-9\]*\\),.*" \
|
|
"unpatch child, catch fork"
|
|
|
|
# Delete all breakpoints and catchpoints.
|
|
delete_breakpoints
|
|
|
|
# Force $srcfile as the current GDB source can be in glibc sourcetree.
|
|
gdb_test "break $srcfile:$bp_exit" \
|
|
"Breakpoint .*file .*$srcfile, line .*" \
|
|
"unpatch child, breakpoint at exit call"
|
|
|
|
gdb_test_no_output "set follow-fork child" \
|
|
"unpatch child, set follow-fork child"
|
|
|
|
set test "unpatch child, unpatched parent breakpoints from child"
|
|
gdb_test_multiple "continue" $test {
|
|
-re "at exit.*$gdb_prompt $" {
|
|
pass "$test"
|
|
}
|
|
-re "SIGTRAP.*$gdb_prompt $" {
|
|
fail "$test"
|
|
|
|
# Explicitly kill this child, so we can continue gracefully
|
|
# with further testing...
|
|
send_gdb "kill\n"
|
|
gdb_expect {
|
|
-re ".*Kill the program being debugged.*y or n. $" {
|
|
send_gdb "y\n"
|
|
gdb_expect -re "$gdb_prompt $" {}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
proc tcatch_fork_parent_follow {} {
|
|
global gdb_prompt
|
|
global srcfile
|
|
|
|
set bp_after_fork [gdb_get_line_number "set breakpoint here"]
|
|
|
|
gdb_test "catch fork" "Catchpoint \[0-9\]* \\(fork\\)" \
|
|
"explicit parent follow, set tcatch fork"
|
|
|
|
# ??rehrauer: I don't yet know how to get the id of the tcatch
|
|
# via this script, so that I can add a -do list to it. For now,
|
|
# do the follow stuff after the catch happens.
|
|
|
|
gdb_test "continue" \
|
|
"Catchpoint \[0-9\]* \\(forked process \[0-9\]*\\),.*" \
|
|
"explicit parent follow, tcatch fork"
|
|
|
|
gdb_test_no_output "set follow-fork parent"
|
|
|
|
gdb_test "tbreak ${srcfile}:$bp_after_fork" \
|
|
"Temporary breakpoint.*, line $bp_after_fork.*" \
|
|
"set follow-fork parent, tbreak"
|
|
|
|
gdb_test "continue" \
|
|
"\\\[Detaching after fork from.* at .*$bp_after_fork.*" \
|
|
"set follow-fork parent, hit tbreak"
|
|
|
|
# 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
|
|
|
|
gdb_test "delete breakpoints" \
|
|
"" \
|
|
"set follow-fork parent, cleanup" \
|
|
"Delete all breakpoints. \\(y or n\\) $" \
|
|
"y"
|
|
}
|
|
|
|
proc do_fork_tests {} {
|
|
global gdb_prompt
|
|
global testfile
|
|
|
|
# Verify that help is available for "set follow-fork-mode".
|
|
#
|
|
gdb_test "help set follow-fork-mode" \
|
|
"Set debugger response to a program call of fork or vfork..*
|
|
A fork or vfork creates a new process. follow-fork-mode can be:.*
|
|
.*parent - the original process is debugged after a fork.*
|
|
.*child - the new process is debugged after a fork.*
|
|
The unfollowed process will continue to run..*
|
|
By default, the debugger will follow the parent process..*" \
|
|
"help set follow-fork"
|
|
|
|
# Verify that we can set follow-fork-mode, using an abbreviation
|
|
# for both the flag and its value.
|
|
#
|
|
gdb_test_no_output "set follow-fork ch"
|
|
|
|
gdb_test "show follow-fork" \
|
|
"Debugger response to a program call of fork or vfork is \"child\".*" \
|
|
"set follow-fork, using abbreviations"
|
|
|
|
# Verify that we cannot set follow-fork-mode to nonsense.
|
|
#
|
|
gdb_test "set follow-fork chork" "Undefined item: \"chork\".*" \
|
|
"set follow-fork to nonsense is prohibited"
|
|
|
|
gdb_test_no_output "set follow-fork parent" "reset parent"
|
|
|
|
# Check that fork catchpoints are supported, as an indicator for whether
|
|
# fork-following is supported.
|
|
if [runto_main] then { check_fork_catchpoints }
|
|
|
|
# Test the basic follow-fork functionality using all combinations of
|
|
# values for follow-fork-mode and detach-on-fork, using either a
|
|
# breakpoint or single-step to execute past the fork.
|
|
#
|
|
# The first loop should be sufficient to test the defaults. There
|
|
# is no need to test using the defaults in other permutations (e.g.
|
|
# "default" "on", "parent" "default", etc.).
|
|
foreach cmd {"next 2" "continue"} {
|
|
test_follow_fork "default" "default" $cmd
|
|
}
|
|
|
|
# Now test all explicit permutations.
|
|
foreach who {"parent" "child"} {
|
|
foreach detach {"on" "off"} {
|
|
foreach cmd {"next 2" "continue"} {
|
|
test_follow_fork $who $detach $cmd
|
|
}
|
|
}
|
|
}
|
|
|
|
# Catchpoint tests.
|
|
|
|
# Restart to eliminate any effects of the follow-fork tests.
|
|
clean_restart $testfile
|
|
gdb_test_no_output "set verbose"
|
|
|
|
# Test the ability to catch a fork, specify that the child be
|
|
# followed, and continue. Make the catchpoint permanent.
|
|
#
|
|
if [runto_main] then { catch_fork_child_follow }
|
|
|
|
# Test that parent breakpoints are successfully detached from the
|
|
# child at fork time, even if the user removes them from the
|
|
# breakpoints list after stopping at a fork catchpoint.
|
|
if [runto_main] then { catch_fork_unpatch_child }
|
|
|
|
# Test the ability to catch a fork, specify via a -do clause that
|
|
# the parent be followed, and continue. Make the catchpoint temporary.
|
|
#
|
|
if [runto_main] then { tcatch_fork_parent_follow }
|
|
}
|
|
|
|
# This is a test of gdb's ability to follow the parent, child or both
|
|
# parent and child of a Unix fork() system call.
|
|
#
|
|
do_fork_tests
|
|
|
|
return 0
|