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

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