gdb/testsuite/gdb.base/catch-syscall.exp

   1 #   Copyright 1997-2014 Free Software Foundation, Inc.
   2
   3 # This program is free software; you can redistribute it and/or modify
   4 # it under the terms of the GNU General Public License as published by
   5 # the Free Software Foundation; either version 3 of the License, or
   6 # (at your option) any later version.
   7 #
   8 # This program is distributed in the hope that it will be useful,
   9 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  10 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11 # GNU General Public License for more details.
  12 #
  13 # You should have received a copy of the GNU General Public License
  14 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
  15
  16
  17 # This program tests the 'catch syscall' functionality.
  18 #
  19 # It was written by Sergio Durigan Junior <sergiodj@linux.vnet.ibm.com>
  20 # on September/2008.
  21
  22 if { [is_remote target] || ![isnative] } then {
  23     continue
  24 }
  25
  26 # Until "catch syscall" is implemented on other targets...
  27 if { ![istarget "hppa*-hp-hpux*"] && ![istarget "*-linux*"] } {
  28     continue
  29 }
  30
  31 # This shall be updated whenever 'catch syscall' is implemented
  32 # on some architecture.
  33 #if { ![istarget "i\[34567\]86-*-linux*"]
  34 if { ![istarget "x86_64-*-linux*"] && ![istarget "i\[34567\]86-*-linux*"]
  35      && ![istarget "powerpc-*-linux*"] && ![istarget "powerpc64-*-linux*"]
  36      && ![istarget "sparc-*-linux*"] && ![istarget "sparc64-*-linux*"]
  37      && ![istarget "mips*-linux*"] && ![istarget "arm*-linux*"]
  38      && ![istarget "s390*-linux*"] } {
  39      continue
  40 }
  41
  42 standard_testfile
  43
  44 if  { [prepare_for_testing ${testfile}.exp $testfile ${testfile}.c] } {
  45      untested catch-syscall.exp
  46      return -1
  47 }
  48
  49 # All (but the last) syscalls from the example code
  50 # They are ordered according to the file, so do not change this.
  51 set all_syscalls { "close" "chroot" "pipe" "write" "read" }
  52 set all_syscalls_numbers { }
  53
  54 # The last syscall (exit()) does not return, so
  55 # we cannot expect the catchpoint to be triggered
  56 # twice.  It is a special case.
  57 set last_syscall "exit_group"
  58 set last_syscall_number { }
  59
  60 # Internal procedure used to check if, after issuing a 'catch syscall'
  61 # command (without arguments), the 'info breakpoints' command displays
  62 # that '"any syscall"' is to be caught.
  63 proc check_info_bp_any_syscall {} {
  64     # Verifying that the catchpoint appears in the 'info breakpoints'
  65     # command, but with "<any syscall>".
  66     set thistest "catch syscall appears in 'info breakpoints'"
  67     gdb_test "info breakpoints" ".*catchpoint.*keep y.*syscall \"<any syscall>\".*" $thistest
  68 }
  69
  70 # Internal procedure used to check if, after issuing a 'catch syscall X'
  71 # command (with arguments), the 'info breakpoints' command displays
  72 # that the syscall 'X' is to be caught.
  73 proc check_info_bp_specific_syscall { syscall } {
  74     set thistest "syscall(s) $syscall appears in 'info breakpoints'"
  75     gdb_test "info breakpoints" ".*catchpoint.*keep y.*syscall(\[(\]s\[)\])? (.)?${syscall}(.)?.*" $thistest
  76 }
  77
  78 # Internal procedure used to check if, after issuing a 'catch syscall X'
  79 # command (with many arguments), the 'info breakpoints' command displays
  80 # that the syscalls 'X' are to be caught.
  81 proc check_info_bp_many_syscalls { syscalls } {
  82     set filter_str ""
  83
  84     foreach name $syscalls {
  85       set filter_str "${filter_str}${name}, "
  86     }
  87
  88     set filter_str [ string trimright $filter_str ", " ]
  89
  90     set thistest "syscalls $filter_str appears in 'info breakpoints'"
  91     gdb_test "info breakpoints" ".*catchpoint.*keep y.*syscalls (.)?${filter_str}(.)?.*" $thistest
  92 }
  93
  94 # This procedure checks if there was a call to a syscall.
  95 proc check_call_to_syscall { syscall } {
  96     global decimal
  97
  98     set thistest "program has called $syscall"
  99     gdb_test "continue" "Catchpoint $decimal \\(call to syscall .?${syscall}.?\\).*" $thistest
 100 }
 101
 102 # This procedure checks if the syscall returned.
 103 proc check_return_from_syscall { syscall } {
 104     global decimal
 105
 106     set thistest "syscall $syscall has returned"
 107     gdb_test "continue" "Catchpoint $decimal \\(returned from syscall ${syscall}\\).*" $thistest
 108 }
 109
 110 # Internal procedure that performs two 'continue' commands and checks if
 111 # a syscall call AND return occur.
 112 proc check_continue { syscall } {
 113     # Testing if the 'continue' stops at the
 114     # specified syscall_name.  If it does, then it should
 115     # first print that the infeior has called the syscall,
 116     # and after print that the syscall has returned.
 117
 118     # Testing if the inferiorr has called the syscall.
 119     check_call_to_syscall $syscall
 120     # And now, that the syscall has returned.
 121     check_return_from_syscall $syscall
 122 }
 123
 124 # Inserts a syscall catchpoint with an argument.
 125 proc insert_catch_syscall_with_arg { syscall } {
 126     global decimal
 127
 128     # Trying to set the catchpoint
 129     set thistest "catch syscall with arguments ($syscall)"
 130     gdb_test "catch syscall $syscall" "Catchpoint $decimal \\(syscall \'?${syscall}\'?( \[${decimal}\])?\\)" $thistest
 131
 132     check_info_bp_specific_syscall $syscall
 133 }
 134
 135 # Inserts a syscall catchpoint with many arguments.
 136 proc insert_catch_syscall_with_many_args { syscalls numbers } {
 137     global decimal
 138
 139     set catch [ join $syscalls " " ]
 140     set filter_str ""
 141
 142     foreach name $syscalls number $numbers {
 143       set filter_str "${filter_str}'${name}' \\\[${number}\\\] "
 144     }
 145
 146     set filter_str [ string trimright $filter_str " " ]
 147
 148     # Trying to set the catchpoint
 149     set thistest "catch syscall with arguments ($filter_str)"
 150     gdb_test "catch syscall $catch" "Catchpoint $decimal \\(syscalls ${filter_str}\\).*" $thistest
 151
 152     check_info_bp_many_syscalls $syscalls
 153 }
 154
 155 proc check_for_program_end {} {
 156     # Deleting the catchpoints
 157     delete_breakpoints
 158
 159     gdb_continue_to_end
 160 }
 161
 162 proc test_catch_syscall_without_args {} {
 163     global all_syscalls last_syscall decimal
 164
 165     with_test_prefix "without arguments" {
 166         # Trying to set the syscall.
 167         gdb_test "catch syscall" "Catchpoint $decimal \\(any syscall\\)"
 168
 169         check_info_bp_any_syscall
 170
 171         # We have to check every syscall.
 172         foreach name $all_syscalls {
 173             check_continue $name
 174         }
 175
 176         # At last but not least, we check if the inferior has called
 177         # the last (exit) syscall.
 178         check_call_to_syscall $last_syscall
 179
 180         # Now let's see if the inferior correctly finishes.
 181         check_for_program_end
 182     }
 183 }
 184
 185 proc test_catch_syscall_with_args {} {
 186     with_test_prefix "with arguments" {
 187         set syscall_name "close"
 188         insert_catch_syscall_with_arg $syscall_name
 189
 190         # Can we continue until we catch the syscall?
 191         check_continue $syscall_name
 192
 193         # Now let's see if the inferior correctly finishes.
 194         check_for_program_end
 195     }
 196 }
 197
 198 proc test_catch_syscall_with_many_args {} {
 199     with_test_prefix "with many arguments" {
 200         global all_syscalls all_syscalls_numbers
 201
 202         insert_catch_syscall_with_many_args $all_syscalls $all_syscalls_numbers
 203
 204         # Can we continue until we catch the syscalls?
 205         foreach name $all_syscalls {
 206             check_continue $name
 207         }
 208
 209         # Now let's see if the inferior correctly finishes.
 210         check_for_program_end
 211     }
 212 }
 213
 214 proc test_catch_syscall_with_wrong_args {} {
 215     with_test_prefix "wrong args" {
 216         # mlock is not called from the source
 217         set syscall_name "mlock"
 218         insert_catch_syscall_with_arg $syscall_name
 219
 220         # Now, we must verify if the program stops with a continue.
 221         # If it doesn't, everything is right (since we don't have
 222         # a syscall named "mlock" in it).  Otherwise, this is a failure.
 223         set thistest "catch syscall with unused syscall ($syscall_name)"
 224         gdb_continue_to_end $thistest
 225     }
 226 }
 227
 228 proc test_catch_syscall_restarting_inferior {} {
 229     with_test_prefix "restarting inferior" {
 230         set syscall_name "chroot"
 231
 232         with_test_prefix "entry" {
 233             insert_catch_syscall_with_arg $syscall_name
 234
 235             # Let's first reach the entry of the syscall.
 236             check_call_to_syscall $syscall_name
 237         }
 238
 239         with_test_prefix "entry/return" {
 240             # Now, restart the program.
 241             rerun_to_main
 242
 243             # And check for entry/return.
 244             check_continue $syscall_name
 245
 246             # Can we finish?
 247             check_for_program_end
 248         }
 249     }
 250 }
 251
 252 proc test_catch_syscall_fail_nodatadir {} {
 253     with_test_prefix "fail no datadir" {
 254         # Sanitizing.
 255         delete_breakpoints
 256
 257         # Make sure GDB doesn't load the syscalls xml from the system
 258         # data directory.
 259         gdb_test "set data-directory /the/path/to/nowhere" \
 260             "Warning: /the/path/to/nowhere: .*"
 261
 262         # Testing to see if we receive a warning when calling "catch
 263         # syscall" without XML support (without datadir).
 264         set thistest "catch syscall displays a warning when there is no XML support"
 265         gdb_test "catch syscall" \
 266             "warning: Could not load the syscall XML file.*warning: GDB will not be able to display syscall names nor to verify if.*any provided syscall numbers are valid.*Catchpoint .*(syscall).*" \
 267             $thistest
 268
 269         # Since the catchpoint was set, we must check if it's present
 270         # in "info breakpoints" output.
 271         check_info_bp_any_syscall
 272
 273         # Sanitizing.
 274         delete_breakpoints
 275     }
 276 }
 277
 278 proc do_syscall_tests {} {
 279     # NOTE: We don't have to point gdb at the correct data-directory.
 280     # For the build tree that is handled by INTERNAL_GDBFLAGS.
 281
 282     # Verify that the 'catch syscall' help is available
 283     set thistest "help catch syscall"
 284     gdb_test "help catch syscall" "Catch system calls.*" $thistest
 285
 286     # Try to set a catchpoint to a nonsense syscall
 287     set thistest "catch syscall to a nonsense syscall is prohibited"
 288     gdb_test "catch syscall nonsense_syscall" "Unknown syscall name .*" $thistest
 289
 290     # Regression test for syscall completer bug.
 291     gdb_test "complete catch syscall close chroo" \
 292         "catch syscall close chroot" \
 293         "complete catch syscall with multiple words"
 294
 295     # Testing the 'catch syscall' command without arguments.
 296     # This test should catch any syscalls.
 297     if [runto_main] then { test_catch_syscall_without_args }
 298
 299     # Testing the 'catch syscall' command with arguments.
 300     # This test should only catch the specified syscall.
 301     if [runto_main] then { test_catch_syscall_with_args }
 302
 303     # Testing the 'catch syscall' command with many arguments.
 304     # This test should catch $all_syscalls.
 305     if [runto_main] then { test_catch_syscall_with_many_args }
 306
 307     # Testing the 'catch syscall' command with WRONG arguments.
 308     # This test should not trigger any catchpoints.
 309     if [runto_main] then { test_catch_syscall_with_wrong_args }
 310
 311     # Testing the 'catch' syscall command during a restart of
 312     # the inferior.
 313     if [runto_main] then { test_catch_syscall_restarting_inferior }
 314 }
 315
 316 proc test_catch_syscall_without_args_noxml {} {
 317     with_test_prefix "without args noxml" {
 318         # We will need the syscall names even not using it because we
 319         # need to know know many syscalls are in the example file.
 320         global all_syscalls last_syscall_number all_syscalls_numbers
 321
 322         delete_breakpoints
 323
 324         gdb_test "catch syscall" "Catchpoint .*(syscall).*"
 325
 326         # Now, we should be able to set a catchpoint, and GDB shall
 327         # not display the warning anymore.
 328         foreach name $all_syscalls number $all_syscalls_numbers {
 329             with_test_prefix "$name" {
 330                 check_continue $number
 331             }
 332         }
 333
 334         # At last but not least, we check if the inferior has called
 335         # the last (exit) syscall.
 336         check_call_to_syscall $last_syscall_number
 337
 338         delete_breakpoints
 339     }
 340 }
 341
 342 proc test_catch_syscall_with_args_noxml {} {
 343     with_test_prefix "with args noxml" {
 344         global all_syscalls_numbers
 345
 346         delete_breakpoints
 347
 348         # Inserting all syscalls numbers to be caught
 349         foreach syscall_number $all_syscalls_numbers {
 350             insert_catch_syscall_with_arg $syscall_number
 351         }
 352
 353         # Checking that all syscalls are caught.
 354         foreach syscall_number $all_syscalls_numbers {
 355             check_continue $syscall_number
 356         }
 357
 358         delete_breakpoints
 359     }
 360 }
 361
 362 proc test_catch_syscall_with_wrong_args_noxml {} {
 363     with_test_prefix "with wrong args noxml" {
 364         delete_breakpoints
 365
 366         # Even without XML support, GDB should not accept unknown
 367         # syscall names for the catchpoint.
 368         gdb_test "catch syscall nonsense_syscall" \
 369             "Unknown syscall name .nonsense_syscall.*"
 370
 371         delete_breakpoints
 372     }
 373 }
 374
 375 proc do_syscall_tests_without_xml {} {
 376     # Make sure GDB doesn't load the syscalls xml from the system data
 377     # directory.
 378     gdb_test "set data-directory /the/path/to/nowhere" \
 379         "Warning: /the/path/to/nowhere: .*"
 380
 381     # Let's test if we can catch syscalls without XML support.
 382     # We should succeed, but GDB is not supposed to print syscall names.
 383     if [runto_main] then { test_catch_syscall_without_args_noxml }
 384
 385     # The only valid argument "catch syscall" should accept is the
 386     # syscall number, and not the name (since it can't translate a
 387     # name to a number).
 388     if [runto_main] then { test_catch_syscall_with_args_noxml }
 389
 390     # Now, we'll try to provide a syscall name (valid or not) to the command,
 391     # and expect it to fail.
 392     if [runto_main] then { test_catch_syscall_with_wrong_args_noxml }
 393 }
 394
 395 # This procedure fills the vector "all_syscalls_numbers" with the proper
 396 # numbers for the used syscalls according to the architecture.
 397 proc fill_all_syscalls_numbers {} {
 398     global all_syscalls_numbers last_syscall_number all_syscalls
 399
 400     foreach syscall $all_syscalls {
 401         lappend all_syscalls_numbers [get_integer_valueof "${syscall}_syscall" -1]
 402     }
 403
 404     set last_syscall_number [get_integer_valueof "exit_group_syscall" -1]
 405 }
 406
 407 # Fill all the syscalls numbers before starting anything.
 408 fill_all_syscalls_numbers
 409
 410 # Execute the tests, using XML support
 411 if { ![gdb_skip_xml_test] } {
 412   clean_restart $binfile
 413   do_syscall_tests
 414
 415   # Now, we have to see if GDB displays a warning when we
 416   # don't set the data-directory but try to use catch syscall
 417   # anyway.  For that, we must restart GDB first.
 418   clean_restart $binfile
 419   test_catch_syscall_fail_nodatadir
 420 }
 421
 422 # Restart gdb
 423 clean_restart $binfile
 424
 425 # Execute the tests, without XML support.  In this case, GDB will
 426 # only display syscall numbers, and not syscall names.
 427 do_syscall_tests_without_xml