09635af7cd
As it happens we have a board that fails a gdb.base/gcore-relro.exp test case reproducibly and moreover the case appears to trigger a kernel bug making the it less than usable. Specifically the board remains responsive to some extent, however processes do not appear to be able to successfully complete termination anymore and perhaps more importantly further gdbserver processes can be started, but they never reach the stage of listening on the RSP socket. This change handles timeouts in gdbserver start properly, by throwing a TCL error exception when gdbserver does not report listening on the RSP socket in time. This is then caught at the outer level and reported, and 2 rather than 1 is returned so that the caller may tell the failure to start gdbserver and other issues apart and act accordingly (or do nothing). I thought letting the exception unwind further on might be a good idea for any test harnesses out there to break outright where a gdbserver start error is silently ignored right now, however I figured out the calls to gdbserver-support.exp are buried down too deep in the GDB test suite for such a change to be made easily. I think returning a distinct return value is good enough (the API says "non-zero", so 2 is as good as 1) and we can always make the error harder in a later step if required. With config/gdbserver.exp being used this change remains transparent to the target board, the return value is passed up by gdb_reload and the error exception unwinds through gdbserver_gdb_load and is caught and handled by mi_gdb_target_load. A call to perror is still made, reporting the timeout, and in the case of mi_gdb_target_load the procedure returns a value denoting unsuccessful completion. An unsuccessful completion of gdb_reload is already handled elsewhere. An alternative gdbserver board configuration can interpret the return value in its gdb_reload implementation and catch the error in gdbserver_gdb_load in an attempt to recover a target board that has gone astray, for example by rebooting the board somehow. This has proved effective with our failing board, that now completes the remaining test cases with no further hiccups. * lib/gdbserver-support.exp (gdbserver_start): Throw an error exception on timeout. (gdbserver_run): Catch any `gdbserver_spawn' error exceptions. (gdbserver_start_extended): Catch any `gdbserver_start' error exceptions. (gdbserver_start_multi, mi_gdbserver_start_multi): Likewise. * lib/mi-support.exp (mi_gdb_target_load): Catch any `gdbserver_gdb_load' error exceptions.
438 lines
12 KiB
Text
438 lines
12 KiB
Text
# Copyright 2000-2014 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/>.
|
||
|
||
# This file is based on config/gdbserver.exp, which was written by
|
||
# Michael Snyder (msnyder@redhat.com).
|
||
|
||
#
|
||
# To be addressed or set in your baseboard config file:
|
||
#
|
||
# set_board_info gdb_protocol "remote"
|
||
# Unles you have a gdbserver that uses a different protocol...
|
||
# After GDB starts you should check global $gdbserver_protocol instead as
|
||
# the testfile may force a specific different target protocol itself.
|
||
#
|
||
# set_board_info gdb_server_prog
|
||
# This will be the path to the gdbserver program you want to test.
|
||
# Defaults to "gdbserver".
|
||
#
|
||
# set_board_info sockethost
|
||
# The name of the host computer whose socket is being used.
|
||
# Defaults to "localhost". Note: old gdbserver requires
|
||
# that you define this, but libremote/gdbserver does not.
|
||
#
|
||
# set_board_info gdb,socketport
|
||
# Port id to use for socket connection. If not set explicitly,
|
||
# it will start at "2345" and increment for each use.
|
||
# After GDB starts you should check global $gdbserver_gdbport for the
|
||
# real port used. It is not useful if $gdbserver_reconnect_p was not set.
|
||
#
|
||
|
||
#
|
||
# gdb_target_cmd
|
||
# Send gdb the "target" command
|
||
#
|
||
proc gdb_target_cmd { targetname serialport } {
|
||
global gdb_prompt
|
||
|
||
set serialport_re [string_to_regexp $serialport]
|
||
for {set i 1} {$i <= 3} {incr i} {
|
||
send_gdb "target $targetname $serialport\n"
|
||
gdb_expect 60 {
|
||
-re "A program is being debugged already.*ill it.*y or n. $" {
|
||
send_gdb "y\n"
|
||
exp_continue
|
||
}
|
||
-re "unknown host.*$gdb_prompt" {
|
||
verbose "Couldn't look up $serialport"
|
||
}
|
||
-re "Couldn't establish connection to remote.*$gdb_prompt $" {
|
||
verbose "Connection failed"
|
||
}
|
||
-re "Remote MIPS debugging.*$gdb_prompt" {
|
||
verbose "Set target to $targetname"
|
||
return 0
|
||
}
|
||
-re "Remote debugging using .*$serialport_re.*$gdb_prompt $" {
|
||
verbose "Set target to $targetname"
|
||
return 0
|
||
}
|
||
-re "Remote debugging using stdio.*$gdb_prompt $" {
|
||
verbose "Set target to $targetname"
|
||
return 0
|
||
}
|
||
-re "Remote target $targetname connected to.*$gdb_prompt $" {
|
||
verbose "Set target to $targetname"
|
||
return 0
|
||
}
|
||
-re "Connected to.*$gdb_prompt $" {
|
||
verbose "Set target to $targetname"
|
||
return 0
|
||
}
|
||
-re "Ending remote.*$gdb_prompt $" { }
|
||
-re "Connection refused.*$gdb_prompt $" {
|
||
verbose "Connection refused by remote target. Pausing, and trying again."
|
||
sleep 30
|
||
continue
|
||
}
|
||
-re "Timeout reading from remote system.*$gdb_prompt $" {
|
||
verbose "Got timeout error from gdb."
|
||
}
|
||
-notransfer -re "Remote debugging using .*\r\n> $" {
|
||
# We got an unexpected prompt while creating the target.
|
||
# Leave it there for the test to diagnose.
|
||
return 1
|
||
}
|
||
timeout {
|
||
send_gdb ""
|
||
break
|
||
}
|
||
}
|
||
}
|
||
return 1
|
||
}
|
||
|
||
|
||
global portnum
|
||
set portnum "2345"
|
||
|
||
# Locate the gdbserver binary. Returns "" if gdbserver could not be found.
|
||
|
||
proc find_gdbserver { } {
|
||
global GDB
|
||
global GDBSERVER
|
||
|
||
if [info exists GDBSERVER] {
|
||
return ${GDBSERVER}
|
||
}
|
||
|
||
if [target_info exists gdb_server_prog] {
|
||
return [target_info gdb_server_prog]
|
||
}
|
||
|
||
set gdbserver "${GDB}server"
|
||
if { [file isdirectory $gdbserver] } {
|
||
append gdbserver "/gdbserver"
|
||
}
|
||
|
||
if { [file executable $gdbserver] } {
|
||
return $gdbserver
|
||
}
|
||
|
||
return ""
|
||
}
|
||
|
||
# Return non-zero if we should skip gdbserver-specific tests.
|
||
|
||
proc skip_gdbserver_tests { } {
|
||
if { [find_gdbserver] == "" } {
|
||
return 1
|
||
}
|
||
|
||
return 0
|
||
}
|
||
|
||
# Download the currently loaded program to the target if necessary.
|
||
# Return the target system filename.
|
||
# NOTE: This was named "gdbserver_download", but that collides with the
|
||
# dejagnu "download" API function when using load_generic_config "gdbserver".
|
||
|
||
proc gdbserver_download_current_prog { } {
|
||
global gdbserver_host_exec
|
||
global gdbserver_host_mtime
|
||
global gdbserver_server_exec
|
||
global last_loaded_file
|
||
|
||
set host_exec $last_loaded_file
|
||
|
||
# If we already downloaded a file to the target, see if we can reuse it.
|
||
set reuse 0
|
||
if { [info exists gdbserver_server_exec] } {
|
||
set reuse 1
|
||
|
||
# If the file has changed, we can not.
|
||
if { $host_exec != $gdbserver_host_exec } {
|
||
set reuse 0
|
||
}
|
||
|
||
# If the mtime has changed, we can not.
|
||
if { [file mtime $host_exec] != $gdbserver_host_mtime } {
|
||
set reuse 0
|
||
}
|
||
}
|
||
|
||
if { $reuse == 0 } {
|
||
set gdbserver_host_exec $host_exec
|
||
set gdbserver_host_mtime [file mtime $host_exec]
|
||
if [is_remote target] {
|
||
set gdbserver_server_exec [gdb_download $host_exec]
|
||
} else {
|
||
set gdbserver_server_exec $host_exec
|
||
}
|
||
}
|
||
|
||
return $gdbserver_server_exec
|
||
}
|
||
|
||
# Default routine to compute the argument to "target remote".
|
||
|
||
proc gdbserver_default_get_remote_address { host port } {
|
||
# Historically HOST included the trailing ":".
|
||
# To avoid breaking any board files out there we leave things alone.
|
||
return "$host$port"
|
||
}
|
||
|
||
# Default routine to compute the "comm" argument for gdbserver.
|
||
|
||
proc gdbserver_default_get_comm_port { port } {
|
||
return ":$port"
|
||
}
|
||
|
||
# Start a gdbserver process with initial OPTIONS and trailing ARGUMENTS.
|
||
# The port will be filled in between them automatically.
|
||
#
|
||
# Returns the target protocol and socket to connect to.
|
||
|
||
proc gdbserver_start { options arguments } {
|
||
global portnum
|
||
|
||
# Port id -- either specified in baseboard file, or managed here.
|
||
if [target_info exists gdb,socketport] {
|
||
set portnum [target_info gdb,socketport]
|
||
} else {
|
||
# Bump the port number to avoid conflicts with hung ports.
|
||
incr portnum
|
||
}
|
||
|
||
# Extract the local and remote host ids from the target board struct.
|
||
if [target_info exists sockethost] {
|
||
set debughost [target_info sockethost]
|
||
} else {
|
||
set debughost "localhost:"
|
||
}
|
||
|
||
# Some boards use a different value for the port that is passed to
|
||
# gdbserver and the port that is passed to the "target remote" command.
|
||
# One example is the stdio gdbserver support.
|
||
if [target_info exists gdb,get_remote_address] {
|
||
set get_remote_address [target_info gdb,get_remote_address]
|
||
} else {
|
||
set get_remote_address gdbserver_default_get_remote_address
|
||
}
|
||
if [target_info exists gdbserver,get_comm_port] {
|
||
set get_comm_port [target_info gdbserver,get_comm_port]
|
||
} else {
|
||
set get_comm_port gdbserver_default_get_comm_port
|
||
}
|
||
|
||
# Extract the protocol
|
||
if [target_info exists gdb_protocol] {
|
||
set protocol [target_info gdb_protocol]
|
||
} else {
|
||
set protocol "remote"
|
||
}
|
||
|
||
set gdbserver [find_gdbserver]
|
||
|
||
# Loop till we find a free port.
|
||
while 1 {
|
||
# Fire off the debug agent.
|
||
set gdbserver_command "$gdbserver"
|
||
|
||
# If gdbserver_reconnect will be called $gdbserver_reconnect_p must be
|
||
# set to true already during gdbserver_start.
|
||
global gdbserver_reconnect_p
|
||
if {![info exists gdbserver_reconnect_p] || !$gdbserver_reconnect_p} {
|
||
# GDB client could accidentally connect to a stale server.
|
||
# append gdbserver_command " --debug --once"
|
||
append gdbserver_command " --once"
|
||
}
|
||
|
||
if { $options != "" } {
|
||
append gdbserver_command " $options"
|
||
}
|
||
if { $portnum != "" } {
|
||
append gdbserver_command " [$get_comm_port $portnum]"
|
||
}
|
||
if { $arguments != "" } {
|
||
append gdbserver_command " $arguments"
|
||
}
|
||
|
||
set server_spawn_id [remote_spawn target $gdbserver_command]
|
||
|
||
# Wait for the server to open its TCP socket, so that GDB can connect.
|
||
expect {
|
||
-i $server_spawn_id
|
||
-timeout 120
|
||
-notransfer
|
||
-re "Listening on" { }
|
||
-re "Can't bind address: Address already in use\\.\r\n" {
|
||
verbose -log "Port $portnum is already in use."
|
||
if ![target_info exists gdb,socketport] {
|
||
# Bump the port number to avoid the conflict.
|
||
wait -i $expect_out(spawn_id)
|
||
incr portnum
|
||
continue
|
||
}
|
||
}
|
||
timeout {
|
||
error "Timeout waiting for gdbserver response."
|
||
}
|
||
}
|
||
break
|
||
}
|
||
|
||
# We can't just call close, because if gdbserver is local then that means
|
||
# that it will get a SIGHUP. Doing it this way could also allow us to
|
||
# get at the inferior's input or output if necessary, and means that we
|
||
# don't need to redirect output.
|
||
expect_background {
|
||
-i $server_spawn_id
|
||
full_buffer { }
|
||
eof {
|
||
# The spawn ID is already closed now (but not yet waited for).
|
||
wait -i $expect_out(spawn_id)
|
||
}
|
||
}
|
||
|
||
return [list $protocol [$get_remote_address $debughost $portnum]]
|
||
}
|
||
|
||
# Start a gdbserver process running SERVER_EXEC, and connect GDB
|
||
# to it. CHILD_ARGS are passed to the inferior.
|
||
#
|
||
# Returns the target protocol and socket to connect to.
|
||
|
||
proc gdbserver_spawn { child_args } {
|
||
set target_exec [gdbserver_download_current_prog]
|
||
|
||
# Fire off the debug agent. This flavour of gdbserver takes as
|
||
# arguments the port information, the name of the executable file to
|
||
# be debugged, and any arguments.
|
||
set arguments "$target_exec"
|
||
if { $child_args != "" } {
|
||
append arguments " $child_args"
|
||
}
|
||
return [gdbserver_start "" $arguments]
|
||
}
|
||
|
||
# Start a gdbserver process running HOST_EXEC and pass CHILD_ARGS
|
||
# to it. Return 0 on success, or non-zero on failure: 2 if gdbserver
|
||
# failed to start or 1 if we couldn't connect to it.
|
||
|
||
proc gdbserver_run { child_args } {
|
||
global gdbserver_protocol
|
||
global gdbserver_gdbport
|
||
|
||
# Kill anything running before we try to start gdbserver, in case
|
||
# we are sharing a serial connection.
|
||
global gdb_prompt
|
||
send_gdb "kill\n"
|
||
gdb_expect 120 {
|
||
-re "Kill the program being debugged. .y or n. $" {
|
||
send_gdb "y\n"
|
||
verbose "\t\tKilling previous program being debugged"
|
||
exp_continue
|
||
}
|
||
-re "$gdb_prompt $" {
|
||
# OK.
|
||
}
|
||
}
|
||
|
||
if { [catch { gdbserver_spawn $child_args } res] == 1 } {
|
||
perror $res
|
||
return 2
|
||
}
|
||
set gdbserver_protocol [lindex $res 0]
|
||
set gdbserver_gdbport [lindex $res 1]
|
||
|
||
return [gdb_target_cmd $gdbserver_protocol $gdbserver_gdbport]
|
||
}
|
||
|
||
# Reconnect to the previous gdbserver session.
|
||
|
||
proc gdbserver_reconnect { } {
|
||
global gdbserver_protocol
|
||
global gdbserver_gdbport
|
||
|
||
global gdbserver_reconnect_p
|
||
if {![info exists gdbserver_reconnect_p] || !$gdbserver_reconnect_p} {
|
||
error "gdbserver_reconnect_p is not set before gdbserver_reconnect"
|
||
return 0
|
||
}
|
||
|
||
return [gdb_target_cmd $gdbserver_protocol $gdbserver_gdbport]
|
||
}
|
||
|
||
# Start and connect to a gdbserver in extended mode. Note this frobs
|
||
# $gdbserver_protocol, so should be used only from a board that
|
||
# usually connects in target remote mode.
|
||
proc gdbserver_start_extended { } {
|
||
global gdbserver_protocol
|
||
global gdbserver_gdbport
|
||
global use_gdb_stub
|
||
|
||
if { [catch { gdbserver_start "--multi" "" } res] == 1 } {
|
||
perror $res
|
||
return 2
|
||
}
|
||
set gdbserver_protocol [lindex $res 0]
|
||
if { [string first "extended-" $gdbserver_protocol] != 0} {
|
||
set gdbserver_protocol "extended-$gdbserver_protocol"
|
||
}
|
||
set gdbserver_gdbport [lindex $res 1]
|
||
|
||
# Even if the board file is testing with target remote, our caller
|
||
# wants to test against gdbserver in extended-remote mode. Make sure to
|
||
# disable stub-like techniques.
|
||
set use_gdb_stub 0
|
||
|
||
return [gdb_target_cmd $gdbserver_protocol $gdbserver_gdbport]
|
||
}
|
||
|
||
# Start and connect to a gdbserver in extended/multi mode. Unlike
|
||
# gdbserver_start_extended, this does not frob $gdbserver_protocol.
|
||
|
||
proc gdbserver_start_multi { } {
|
||
global gdbserver_protocol
|
||
global gdbserver_gdbport
|
||
|
||
if { [catch { gdbserver_start "--multi" "" } res] == 1 } {
|
||
perror $res
|
||
return 2
|
||
}
|
||
set gdbserver_protocol [lindex $res 0]
|
||
set gdbserver_gdbport [lindex $res 1]
|
||
|
||
return [gdb_target_cmd $gdbserver_protocol $gdbserver_gdbport]
|
||
}
|
||
|
||
# Start a gdbserver process in multi/extended mode, and have GDB
|
||
# connect to it (MI version). Return 0 on success, or non-zero on
|
||
# failure.
|
||
|
||
proc mi_gdbserver_start_multi { } {
|
||
global gdbserver_protocol
|
||
global gdbserver_gdbport
|
||
|
||
if { [catch { gdbserver_start "--multi" "" } res] == 1 } {
|
||
perror $res
|
||
return 2
|
||
}
|
||
set gdbserver_protocol [lindex $res 0]
|
||
set gdbserver_gdbport [lindex $res 1]
|
||
|
||
return [mi_gdb_target_cmd $gdbserver_protocol $gdbserver_gdbport]
|
||
}
|