230 lines
7.5 KiB
Plaintext
230 lines
7.5 KiB
Plaintext
# Copyright 2015-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/>.
|
|
|
|
standard_testfile
|
|
|
|
# This test is Linux-only.
|
|
if ![istarget *-*-linux*] then {
|
|
untested "coredump-filter.exp"
|
|
return -1
|
|
}
|
|
|
|
if { [prepare_for_testing "failed to prepare" $testfile $srcfile debug] } {
|
|
return -1
|
|
}
|
|
|
|
if { ![runto_main] } {
|
|
untested "could not run to main"
|
|
return -1
|
|
}
|
|
|
|
gdb_breakpoint [gdb_get_line_number "break-here"]
|
|
gdb_continue_to_breakpoint "break-here" ".* break-here .*"
|
|
|
|
proc do_save_core { filter_flag core dump_excluded } {
|
|
verbose -log "writing $filter_flag to /proc/<inferior pid>/coredump_filter"
|
|
|
|
gdb_test "p set_coredump_filter ($filter_flag)" " = 0"
|
|
|
|
# Enable dumping of excluded mappings (i.e. VM_DONTDUMP).
|
|
if { $dump_excluded == 1 } {
|
|
gdb_test_no_output "set dump-excluded-mappings on"
|
|
}
|
|
|
|
# Generate a corefile.
|
|
gdb_gcore_cmd "$core" "save corefile"
|
|
|
|
# Restore original status.
|
|
if { $dump_excluded == 1 } {
|
|
gdb_test_no_output "set dump-excluded-mappings off"
|
|
}
|
|
}
|
|
|
|
proc do_load_and_test_core { core var working_var working_value dump_excluded } {
|
|
global hex decimal coredump_var_addr
|
|
|
|
set core_loaded [gdb_core_cmd "$core" "load core"]
|
|
if { $core_loaded == -1 } {
|
|
fail "loading $core"
|
|
return
|
|
}
|
|
|
|
# Access the memory the addresses point to.
|
|
if { $dump_excluded == 0 } {
|
|
gdb_test "print/x *(char *) $coredump_var_addr($var)" "\(\\\$$decimal = <error: \)?Cannot access memory at address $hex\(>\)?" \
|
|
"printing $var when core is loaded (should not work)"
|
|
gdb_test "print/x *(char *) $coredump_var_addr($working_var)" " = $working_value.*" \
|
|
"print/x *$working_var ( = $working_value)"
|
|
} else {
|
|
# Check if VM_DONTDUMP mappings are present in the core file.
|
|
gdb_test "print/x *(char *) $coredump_var_addr($var)" " = $working_value.*" \
|
|
"print/x *$var ( = $working_value)"
|
|
}
|
|
}
|
|
|
|
# We do not do file-backed mappings in the test program, but it is
|
|
# important to test this anyway. One way of performing the test is to
|
|
# load GDB with a corefile but without a binary, and then ask for the
|
|
# disassemble of a function (i.e., the binary's .text section). GDB
|
|
# should fail in this case. However, it must succeed if the binary is
|
|
# provided along with the corefile. This is what we test here.
|
|
|
|
proc test_disasm { core address should_fail } {
|
|
global testfile hex
|
|
|
|
# Restart GDB without loading the binary.
|
|
with_test_prefix "no binary" {
|
|
gdb_exit
|
|
gdb_start
|
|
|
|
set core_loaded [gdb_core_cmd "$core" "load core"]
|
|
if { $core_loaded == -1 } {
|
|
fail "loading $core"
|
|
return
|
|
}
|
|
|
|
if { $should_fail == 1 } {
|
|
gdb_test "x/i \$pc" "=> $hex:\tCannot access memory at address $hex" \
|
|
"disassemble function with corefile and without a binary"
|
|
} else {
|
|
gdb_test "x/i \$pc" "=> $hex:\t\[^C\].*" \
|
|
"disassemble function with corefile and without a binary"
|
|
}
|
|
}
|
|
|
|
with_test_prefix "with binary" {
|
|
clean_restart $testfile
|
|
|
|
set core_loaded [gdb_core_cmd "$core" "load core"]
|
|
if { $core_loaded == -1 } {
|
|
fail "loading $core"
|
|
return
|
|
}
|
|
|
|
gdb_test "disassemble $address" "Dump of assembler code for function.*" \
|
|
"disassemble function with corefile and with a binary"
|
|
}
|
|
}
|
|
|
|
set non_private_anon_core [standard_output_file non-private-anon.gcore]
|
|
set non_shared_anon_core [standard_output_file non-shared-anon.gcore]
|
|
# A corefile without {private,shared} {anonymous,file-backed} pages
|
|
set non_private_shared_anon_file_core [standard_output_file non-private-shared-anon-file.gcore]
|
|
set dont_dump_core [standard_output_file dont-dump.gcore]
|
|
set dump_excluded_core [standard_output_file dump-excluded.gcore]
|
|
|
|
# We will generate a few corefiles.
|
|
#
|
|
# This list is composed by sub-lists, and their elements are (in
|
|
# order):
|
|
#
|
|
# - name of the test
|
|
# - hexadecimal value to be put in the /proc/PID/coredump_filter file
|
|
# - name of the variable that contains the name of the corefile to be
|
|
# generated (including the initial $).
|
|
# - name of the variable in the C source code that points to the
|
|
# memory mapping that will NOT be present in the corefile.
|
|
# - name of a variable in the C source code that points to a memory
|
|
# mapping that WILL be present in the corefile
|
|
# - corresponding value expected for the above variable
|
|
# - whether to include mappings marked as VM_DONTDUMP in the
|
|
# corefile (1) or not (0).
|
|
#
|
|
# This list refers to the corefiles generated by MAP_ANONYMOUS in the
|
|
# test program.
|
|
|
|
set all_anon_corefiles { { "non-Private-Anonymous" "0x7e" \
|
|
$non_private_anon_core \
|
|
"private_anon" \
|
|
"shared_anon" "0x22" "0" }
|
|
{ "non-Shared-Anonymous" "0x7d" \
|
|
$non_shared_anon_core "shared_anon" \
|
|
"private_anon" "0x11" "0" }
|
|
{ "DoNotDump" "0x33" \
|
|
$dont_dump_core "dont_dump" \
|
|
"shared_anon" "0x22" "0" }
|
|
{ "DoNotDump-DumpExcluded" "0x33" \
|
|
$dump_excluded_core "dont_dump" \
|
|
"shared_anon" "0x55" "1" } }
|
|
|
|
# If corefile loading is not supported, we do not even try to run the
|
|
# tests.
|
|
set core_supported [gdb_gcore_cmd "$non_private_anon_core" "save a corefile"]
|
|
if { !$core_supported } {
|
|
untested "corefile generation is not supported"
|
|
return -1
|
|
}
|
|
|
|
gdb_test_multiple "info inferiors" "getting inferior pid" {
|
|
-re "process $decimal.*\r\n$gdb_prompt $" {
|
|
}
|
|
-re "Remote target.*$gdb_prompt $" {
|
|
# If the target does not provide PID information (like usermode QEMU),
|
|
# just bail out as the rest of the test may rely on it, giving spurious
|
|
# failures.
|
|
return -1
|
|
}
|
|
}
|
|
|
|
# Get the main function's address.
|
|
set main_addr ""
|
|
gdb_test_multiple "print/x &main" "getting main's address" {
|
|
-re "$decimal = \($hex\)\r\n$gdb_prompt $" {
|
|
set main_addr $expect_out(1,string)
|
|
}
|
|
}
|
|
|
|
# Obtain the address of each variable that will be checked on each
|
|
# case.
|
|
unset -nocomplain coredump_var_addr
|
|
foreach item $all_anon_corefiles {
|
|
foreach name [list [lindex $item 3] [lindex $item 4]] {
|
|
set test "print/x $name"
|
|
gdb_test_multiple $test $test {
|
|
-re " = \($hex\)\r\n$gdb_prompt $" {
|
|
set coredump_var_addr($name) $expect_out(1,string)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
# Generate corefiles for the "anon" case.
|
|
foreach item $all_anon_corefiles {
|
|
with_test_prefix "saving corefile for [lindex $item 0]" {
|
|
do_save_core [lindex $item 1] [subst [lindex $item 2]] [lindex $item 6]
|
|
}
|
|
}
|
|
|
|
with_test_prefix "saving corefile for non-Private-Shared-Anon-File" {
|
|
do_save_core "0x60" $non_private_shared_anon_file_core "0"
|
|
}
|
|
|
|
clean_restart $testfile
|
|
|
|
foreach item $all_anon_corefiles {
|
|
with_test_prefix "loading and testing corefile for [lindex $item 0]" {
|
|
do_load_and_test_core [subst [lindex $item 2]] [lindex $item 3] \
|
|
[lindex $item 4] [lindex $item 5] [lindex $item 6]
|
|
}
|
|
|
|
with_test_prefix "disassembling function main for [lindex $item 0]" {
|
|
test_disasm [subst [lindex $item 2]] $main_addr 0
|
|
}
|
|
}
|
|
|
|
with_test_prefix "loading and testing corefile for non-Private-Shared-Anon-File" {
|
|
test_disasm $non_private_shared_anon_file_core $main_addr 1
|
|
}
|