tests/utils/utils.sh

   1 # Copyright (C) 2012 David Goulet <dgoulet@efficios.com>
   2 #
   3 # SPDX-License-Identifier: LGPL-2.1-only
   4 #
   5
   6 SESSIOND_BIN="lttng-sessiond"
   7 SESSIOND_MATCH=".*lttng-sess.*"
   8 RUNAS_BIN="lttng-runas"
   9 RUNAS_MATCH=".*lttng-runas.*"
  10 CONSUMERD_BIN="lttng-consumerd"
  11 CONSUMERD_MATCH=".*lttng-consumerd.*"
  12 RELAYD_BIN="lttng-relayd"
  13 RELAYD_MATCH=".*lttng-relayd.*"
  14 LTTNG_BIN="lttng"
  15 BABELTRACE_BIN="babeltrace"
  16 OUTPUT_DEST=/dev/null
  17 ERROR_OUTPUT_DEST=/dev/null
  18
  19 # To match 20201127-175802
  20 date_time_pattern="[0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9]-[0-9][0-9][0-9][0-9][0-9][0-9]"
  21 # The size of a long on this system
  22 system_long_bit_size=$(getconf LONG_BIT)
  23
  24 # Minimal kernel version supported for session daemon tests
  25 KERNEL_MAJOR_VERSION=2
  26 KERNEL_MINOR_VERSION=6
  27 KERNEL_PATCHLEVEL_VERSION=27
  28
  29 # We set the default UST register timeout and network and app socket timeout to
  30 # "wait forever", so that basic tests don't have to worry about hitting
  31 # timeouts on busy systems. Specialized tests should test those corner-cases.
  32 export LTTNG_UST_REGISTER_TIMEOUT=-1
  33 export LTTNG_NETWORK_SOCKET_TIMEOUT=-1
  34 export LTTNG_APP_SOCKET_TIMEOUT=-1
  35
  36 # We set the default lttng-sessiond path to /bin/true to prevent the spawning
  37 # of a daemonized sessiond. This is necessary since 'lttng create' will spawn
  38 # its own sessiond if none is running. It also ensures that 'lttng create'
  39 # fails when no sessiond is running.
  40 export LTTNG_SESSIOND_PATH="/bin/true"
  41
  42 source $TESTDIR/utils/tap/tap.sh
  43
  44 if [ -z ${LTTNG_TEST_TEARDOWN_TIMEOUT+x} ]; then
  45         LTTNG_TEST_TEARDOWN_TIMEOUT=60
  46 fi
  47
  48 function full_cleanup ()
  49 {
  50         # Try to kill daemons gracefully
  51         stop_lttng_relayd_notap SIGTERM $LTTNG_TEST_TEARDOWN_TIMEOUT
  52         stop_lttng_sessiond_notap SIGTERM $LTTNG_TEST_TEARDOWN_TIMEOUT
  53
  54         # If daemons are still present, forcibly kill them
  55         stop_lttng_relayd_notap SIGKILL $LTTNG_TEST_TEARDOWN_TIMEOUT
  56         stop_lttng_sessiond_notap SIGKILL $LTTNG_TEST_TEARDOWN_TIMEOUT
  57         stop_lttng_consumerd_notap SIGKILL $LTTNG_TEST_TEARDOWN_TIMEOUT
  58
  59         # Disable trap for SIGTERM since the following kill to the
  60         # pidgroup will be SIGTERM. Otherwise it loops.
  61         # The '-' before the pid number ($$) indicates 'kill' to signal the
  62         # whole process group.
  63         trap - SIGTERM && kill -- -$$
  64         exit 1
  65 }
  66
  67 function null_pipes ()
  68 {
  69         exec 0>/dev/null
  70         exec 1>/dev/null
  71         exec 2>/dev/null
  72 }
  73
  74 trap full_cleanup SIGINT SIGTERM
  75
  76 # perl prove closes its child pipes before giving it a chance to run its
  77 # signal trap handlers. Redirect pipes to /dev/null if SIGPIPE is caught
  78 # to allow those trap handlers to proceed.
  79
  80 trap null_pipes SIGPIPE
  81
  82 function print_ok ()
  83 {
  84         # Check if we are a terminal
  85         if [ -t 1 ]; then
  86                 echo -e "\e[1;32mOK\e[0m"
  87         else
  88                 echo -e "OK"
  89         fi
  90 }
  91
  92 function print_fail ()
  93 {
  94         # Check if we are a terminal
  95         if [ -t 1 ]; then
  96                 echo -e "\e[1;31mFAIL\e[0m"
  97         else
  98                 echo -e "FAIL"
  99         fi
 100 }
 101
 102 function print_test_banner ()
 103 {
 104         local desc="$1"
 105         diag "$desc"
 106 }
 107
 108 function validate_kernel_version ()
 109 {
 110         local kern_version=($(uname -r | awk -F. '{ printf("%d.%d.%d\n",$1,$2,$3); }' | tr '.' '\n'))
 111         if [ ${kern_version[0]} -gt $KERNEL_MAJOR_VERSION ]; then
 112                 return 0
 113         fi
 114         if [ ${kern_version[1]} -gt $KERNEL_MINOR_VERSION ]; then
 115                 return 0
 116         fi
 117         if [ ${kern_version[2]} -ge $KERNEL_PATCHLEVEL_VERSION ]; then
 118                 return 0
 119         fi
 120         return 1
 121 }
 122
 123 # Generate a random string
 124 #  $1 = number of characters; defaults to 16
 125 #  $2 = include special characters; 1 = yes, 0 = no; defaults to yes
 126 function randstring()
 127 {
 128         [ "$2" == "0" ] && CHAR="[:alnum:]" || CHAR="[:graph:]"
 129         cat /dev/urandom 2>/dev/null | tr -cd "$CHAR" 2>/dev/null | head -c ${1:-16} 2>/dev/null
 130         echo
 131 }
 132
 133 # Return the number of _configured_ CPUs.
 134 function conf_proc_count()
 135 {
 136         getconf _NPROCESSORS_CONF
 137         if [ $? -ne 0 ]; then
 138                 diag "Failed to get the number of configured CPUs"
 139         fi
 140         echo
 141 }
 142
 143 # Check if base lttng-modules are present.
 144 # Bail out on failure
 145 function validate_lttng_modules_present ()
 146 {
 147         # Check for loadable modules.
 148         modprobe -n lttng-tracer 2>/dev/null
 149         if [ $? -eq 0 ]; then
 150                 return 0
 151         fi
 152
 153         # Check for builtin modules.
 154         ls /proc/lttng > /dev/null 2>&1
 155         if [ $? -eq 0 ]; then
 156                 return 0
 157         fi
 158
 159         BAIL_OUT "LTTng modules not detected."
 160 }
 161
 162 # Run the lttng binary.
 163 #
 164 # The first two arguments are stdout and stderr redirect paths, respectively.
 165 # The rest of the arguments are forwarded to the lttng binary
 166 function _run_lttng_cmd
 167 {
 168         local stdout_dest="$1"
 169         local stderr_dest="$2"
 170         shift 2
 171
 172         diag "$TESTDIR/../src/bin/lttng/$LTTNG_BIN $*"
 173         $TESTDIR/../src/bin/lttng/$LTTNG_BIN "$@" 1> "$stdout_dest" 2> "$stderr_dest"
 174 }
 175
 176 function enable_kernel_lttng_event
 177 {
 178         local withtap="$1"
 179         local expected_to_fail="$2"
 180         local sess_name="$3"
 181         local event_name="$4"
 182         local channel_name="$5"
 183
 184         if [ -z "$event_name" ]; then
 185                 # Enable all event if no event name specified
 186                 event_name="-a"
 187         fi
 188
 189         if [ -z "$channel_name" ]; then
 190                 # default channel if none specified
 191                 chan=""
 192         else
 193                 chan="-c $channel_name"
 194         fi
 195
 196         $TESTDIR/../src/bin/lttng/$LTTNG_BIN enable-event "$event_name" $chan -s $sess_name -k 1> $OUTPUT_DEST 2> $ERROR_OUTPUT_DEST
 197         ret=$?
 198         if [[ $expected_to_fail -eq "1" ]]; then
 199                 test $ret -ne "0"
 200                 ret=$?
 201                 if [ $withtap -eq "1" ]; then
 202                         ok $ret "Enable kernel event $event_name for session $session_name on channel $channel_name failed as expected"
 203                 fi
 204         else
 205                 if [ $withtap -eq "1" ]; then
 206                         ok $ret "Enable kernel event $event_name for session $sess_name"
 207                 fi
 208         fi
 209 }
 210
 211 function enable_kernel_lttng_event_ok ()
 212 {
 213         enable_kernel_lttng_event 1 0 "$@"
 214 }
 215
 216 function enable_kernel_lttng_event_fail ()
 217 {
 218         enable_kernel_lttng_event 1 1 "$@"
 219 }
 220
 221 function enable_kernel_lttng_event_notap ()
 222 {
 223         enable_kernel_lttng_event 0 0 "$@"
 224 }
 225
 226 # Old interface
 227 function lttng_enable_kernel_event
 228 {
 229         enable_kernel_lttng_event_ok "$@"
 230 }
 231
 232 function lttng_enable_kernel_syscall()
 233 {
 234         local expected_to_fail=$1
 235         local sess_name=$2
 236         local syscall_name=$3
 237         local channel_name=$4
 238
 239         if [ -z $syscall_name ]; then
 240                 # Enable all event if no syscall name specified
 241                 syscall_name="-a"
 242         fi
 243
 244         if [ -z $channel_name ]; then
 245                 # default channel if none specified
 246                 chan=""
 247         else
 248                 chan="-c $channel_name"
 249         fi
 250
 251         $TESTDIR/../src/bin/lttng/$LTTNG_BIN enable-event --syscall "$syscall_name" $chan -s $sess_name -k 1> $OUTPUT_DEST 2> $ERROR_OUTPUT_DEST
 252         ret=$?
 253         if [[ $expected_to_fail -eq "1" ]]; then
 254                 test $ret -ne "0"
 255                 ok $? "Enable kernel syscall $syscall_name for session $sess_name on channel $channel_name fail as expected"
 256         else
 257                 ok $ret "Enable kernel syscall $syscall_name for session $sess_name on channel $channel_name"
 258         fi
 259 }
 260
 261 function lttng_enable_kernel_syscall_ok()
 262 {
 263         lttng_enable_kernel_syscall 0 "$@"
 264 }
 265
 266 function lttng_enable_kernel_syscall_fail()
 267 {
 268         lttng_enable_kernel_syscall 1 "$@"
 269 }
 270
 271 function lttng_disable_kernel_syscall()
 272 {
 273         local expected_to_fail=$1
 274         local sess_name=$2
 275         local syscall_name=$3
 276         local channel_name=$4
 277
 278         if [ -z $syscall_name ]; then
 279                 # Enable all event if no syscall name specified
 280                 syscall_name="-a"
 281         fi
 282
 283         if [ -z $channel_name ]; then
 284                 # default channel if none specified
 285                 chan=""
 286         else
 287                 chan="-c $channel_name"
 288         fi
 289
 290         $TESTDIR/../src/bin/lttng/$LTTNG_BIN disable-event --syscall "$syscall_name" $chan -s $sess_name -k 1> $OUTPUT_DEST 2> $ERROR_OUTPUT_DEST
 291
 292         ret=$?
 293         if [[ $expected_to_fail -eq "1" ]]; then
 294                 test $ret -ne "0"
 295                 ok $? "Disable kernel syscall $syscall_name for session $sess_name on channel $channel_name failed as expected"
 296         else
 297                 ok $ret "Disable kernel syscall $syscall_name for session $sess_name on channel $channel_name"
 298         fi
 299 }
 300
 301 function lttng_disable_kernel_syscall_ok()
 302 {
 303         lttng_disable_kernel_syscall 0 "$@"
 304 }
 305
 306 function lttng_disable_kernel_syscall_fail()
 307 {
 308         lttng_disable_kernel_syscall 1 "$@"
 309 }
 310
 311 function lttng_enable_kernel_userspace_probe_event ()
 312 {
 313         local expected_to_fail="$1"
 314         local sess_name="$2"
 315         local target="$3"
 316         local event_name="$4"
 317
 318         "$TESTDIR/../src/bin/lttng/$LTTNG_BIN" enable-event --kernel --userspace-probe="$target" "$event_name" -s "$sess_name" > "$OUTPUT_DEST" 2> "$ERROR_OUTPUT_DEST"
 319         ret=$?
 320         if [[ $expected_to_fail -eq "1" ]]; then
 321                 test $ret -ne "0"
 322                 ok $? "Enable kernel userspace probe event for session $sess_name failed as expected"
 323         else
 324                 ok $ret "Enable kernel userspace probe event for session $sess_name"
 325         fi
 326 }
 327
 328 function lttng_enable_kernel_userspace_probe_event_fail ()
 329 {
 330         lttng_enable_kernel_userspace_probe_event 1 "$@"
 331 }
 332
 333 function lttng_enable_kernel_userspace_probe_event_ok ()
 334 {
 335         lttng_enable_kernel_userspace_probe_event 0 "$@"
 336 }
 337
 338 function disable_kernel_lttng_userspace_probe_event_ok ()
 339 {
 340         local sess_name="$1"
 341         local event_name="$2"
 342
 343         "$TESTDIR/../src/bin/lttng/$LTTNG_BIN" disable-event --kernel "$event_name" -s "$sess_name" > "$OUTPUT_DEST" 2> "$ERROR_OUTPUT_DEST"
 344         ok $? "Disable kernel event $target for session $sess_name"
 345 }
 346 function lttng_enable_kernel_channel()
 347 {
 348         local withtap=$1
 349         local expected_to_fail=$2
 350         local sess_name=$3
 351         local channel_name=$4
 352         local opts="${@:5}"
 353
 354         $TESTDIR/../src/bin/lttng/$LTTNG_BIN enable-channel -k $channel_name -s $sess_name $opts 1> $OUTPUT_DEST 2> $ERROR_OUTPUT_DEST
 355         ret=$?
 356         if [[ $expected_to_fail -eq "1" ]]; then
 357                 test "$ret" -ne "0"
 358                 ret=$?
 359                 if [ $withtap -eq "1" ]; then
 360                         ok $ret "Enable channel $channel_name for session $sess_name failed as expected"
 361                 fi
 362         else
 363                 if [ $withtap -eq "1" ]; then
 364                         ok $ret "Enable channel $channel_name for session $sess_name"
 365                 fi
 366         fi
 367 }
 368
 369 function lttng_enable_kernel_channel_ok()
 370 {
 371         lttng_enable_kernel_channel 1 0 "$@"
 372 }
 373
 374 function lttng_enable_kernel_channel_fail()
 375 {
 376         lttng_enable_kernel_channel 1 1 "$@"
 377 }
 378
 379 function lttng_enable_kernel_channel_notap()
 380 {
 381         lttng_enable_kernel_channel 0 0 "$@"
 382 }
 383
 384 function enable_kernel_lttng_channel_ok()
 385 {
 386         lttng_enable_kernel_channel 1 0 "$@"
 387 }
 388
 389 function lttng_disable_kernel_channel()
 390 {
 391         local expected_to_fail=$1
 392         local sess_name=$2
 393         local channel_name=$3
 394
 395         $TESTDIR/../src/bin/lttng/$LTTNG_BIN disable-channel -k $channel_name -s $sess_name 1> $OUTPUT_DEST 2> $ERROR_OUTPUT_DEST
 396         ret=$?
 397         if [[ $expected_to_fail -eq "1" ]]; then
 398                 test "$ret" -ne "0"
 399                 ok $? "Disable channel $channel_name for session $sess_name failed as expected"
 400         else
 401                 ok $ret "Disable channel $channel_name for session $sess_name"
 402         fi
 403 }
 404
 405 function lttng_disable_kernel_channel_ok()
 406 {
 407         lttng_disable_kernel_channel 0 "$@"
 408 }
 409
 410 function lttng_disable_kernel_channel_fail()
 411 {
 412         lttng_disable_kernel_channel 1 "$@"
 413 }
 414
 415 function start_lttng_relayd_opt()
 416 {
 417         local withtap=$1
 418         local process_mode=$2
 419         local opt=$3
 420
 421         DIR=$(readlink -f "$TESTDIR")
 422
 423         if [ -z $(pgrep $RELAYD_MATCH) ]; then
 424                 # shellcheck disable=SC2086
 425                 $DIR/../src/bin/lttng-relayd/$RELAYD_BIN $process_mode $opt 1> $OUTPUT_DEST 2> $ERROR_OUTPUT_DEST
 426                 #$DIR/../src/bin/lttng-relayd/$RELAYD_BIN $opt -vvv >>/tmp/relayd.log 2>&1 &
 427                 if [ $? -eq 1 ]; then
 428                         if [ $withtap -eq "1" ]; then
 429                                 fail "Start lttng-relayd (process mode: $process_mode opt: $opt)"
 430                         fi
 431                         return 1
 432                 else
 433                         if [ $withtap -eq "1" ]; then
 434                                 pass "Start lttng-relayd (process mode: $process_mode opt: $opt)"
 435                         fi
 436                 fi
 437         else
 438                 pass "Start lttng-relayd (opt: $opt)"
 439         fi
 440 }
 441
 442 function start_lttng_relayd()
 443 {
 444         start_lttng_relayd_opt 1 "-b" "$@"
 445 }
 446
 447 function start_lttng_relayd_notap()
 448 {
 449         start_lttng_relayd_opt 0 "-b" "$@"
 450 }
 451
 452 function stop_lttng_relayd_opt()
 453 {
 454         local withtap=$1
 455         local signal=$2
 456
 457         if [ -z "$signal" ]; then
 458                 signal="SIGTERM"
 459         fi
 460
 461         local timeout_s=$3
 462         local dtimeleft_s=
 463
 464         # Multiply time by 2 to simplify integer arithmetic
 465         if [ -n "$timeout_s" ]; then
 466                 dtimeleft_s=$((timeout_s * 2))
 467         fi
 468
 469         local retval=0
 470         local pids=
 471
 472         pids=$(pgrep "$RELAYD_MATCH")
 473         if [ -z "$pids" ]; then
 474                 if [ "$withtap" -eq "1" ]; then
 475                         pass "No relay daemon to kill"
 476                 fi
 477                 return 0
 478         fi
 479
 480         diag "Killing (signal $signal) lttng-relayd (pid: $pids)"
 481
 482         # shellcheck disable=SC2086
 483         if ! kill -s $signal $pids 1> $OUTPUT_DEST 2> $ERROR_OUTPUT_DEST; then
 484                 retval=1
 485                 if [ "$withtap" -eq "1" ]; then
 486                         fail "Kill relay daemon"
 487                 fi
 488         else
 489                 out=1
 490                 while [ -n "$out" ]; do
 491                         out=$(pgrep "$RELAYD_MATCH")
 492                         if [ -n "$dtimeleft_s" ]; then
 493                                 if [ $dtimeleft_s -lt 0 ]; then
 494                                         out=
 495                                         retval=1
 496                                 fi
 497                                 dtimeleft_s=$((dtimeleft_s - 1))
 498                         fi
 499                         sleep 0.5
 500                 done
 501                 if [ "$withtap" -eq "1" ]; then
 502                         if [ "$retval" -eq "0" ]; then
 503                                 pass "Wait after kill relay daemon"
 504                         else
 505                                 fail "Wait after kill relay daemon"
 506                         fi
 507                 fi
 508         fi
 509         return $retval
 510 }
 511
 512 function stop_lttng_relayd()
 513 {
 514         stop_lttng_relayd_opt 1 "$@"
 515 }
 516
 517 function stop_lttng_relayd_notap()
 518 {
 519         stop_lttng_relayd_opt 0 "$@"
 520 }
 521
 522 #First arg: show tap output
 523 #Second argument: load path for automatic loading
 524 function start_lttng_sessiond_opt()
 525 {
 526         local withtap=$1
 527         local load_path=$2
 528
 529         local env_vars=""
 530         local consumerd=""
 531
 532         local long_bit_value=
 533         long_bit_value=$(getconf LONG_BIT)
 534
 535         if [ -n "$TEST_NO_SESSIOND" ] && [ "$TEST_NO_SESSIOND" == "1" ]; then
 536                 # Env variable requested no session daemon
 537                 return
 538         fi
 539
 540         DIR=$(readlink -f "$TESTDIR")
 541
 542         # Get long_bit value for 32/64 consumerd
 543         case "$long_bit_value" in
 544                 32)
 545                         consumerd="--consumerd32-path=$DIR/../src/bin/lttng-consumerd/lttng-consumerd"
 546                         ;;
 547                 64)
 548                         consumerd="--consumerd64-path=$DIR/../src/bin/lttng-consumerd/lttng-consumerd"
 549                         ;;
 550                 *)
 551                         return
 552                         ;;
 553         esac
 554
 555         # Check for env. variable. Allow the use of LD_PRELOAD etc.
 556         if [[ "x${LTTNG_SESSIOND_ENV_VARS}" != "x" ]]; then
 557                 env_vars="${LTTNG_SESSIOND_ENV_VARS} "
 558         fi
 559         env_vars="${env_vars}$DIR/../src/bin/lttng-sessiond/$SESSIOND_BIN"
 560
 561         if ! validate_kernel_version; then
 562             fail "Start session daemon"
 563             BAIL_OUT "*** Kernel too old for session daemon tests ***"
 564         fi
 565
 566         : "${LTTNG_SESSION_CONFIG_XSD_PATH="${DIR}/../src/common/config/"}"
 567         export LTTNG_SESSION_CONFIG_XSD_PATH
 568
 569         if [ -z "$(pgrep "${SESSIOND_MATCH}")" ]; then
 570                 # Have a load path ?
 571                 if [ -n "$load_path" ]; then
 572                         # shellcheck disable=SC2086
 573                         env $env_vars --load "$load_path" --background "$consumerd"
 574                 else
 575                         # shellcheck disable=SC2086
 576                         env $env_vars --background "$consumerd"
 577                 fi
 578                 #$DIR/../src/bin/lttng-sessiond/$SESSIOND_BIN --background --consumerd32-path="$DIR/../src/bin/lttng-consumerd/lttng-consumerd" --consumerd64-path="$DIR/../src/bin/lttng-consumerd/lttng-consumerd" --verbose-consumer >>/tmp/sessiond.log 2>&1
 579                 status=$?
 580                 if [ "$withtap" -eq "1" ]; then
 581                         ok $status "Start session daemon"
 582                 fi
 583         fi
 584 }
 585
 586 function start_lttng_sessiond()
 587 {
 588         start_lttng_sessiond_opt 1 "$@"
 589 }
 590
 591 function start_lttng_sessiond_notap()
 592 {
 593         start_lttng_sessiond_opt 0 "$@"
 594 }
 595
 596 function stop_lttng_sessiond_opt()
 597 {
 598         local withtap=$1
 599         local signal=$2
 600
 601         if [ -z "$signal" ]; then
 602                 signal=SIGTERM
 603         fi
 604
 605         local timeout_s=$3
 606         local dtimeleft_s=
 607
 608         # Multiply time by 2 to simplify integer arithmetic
 609         if [ -n "$timeout_s" ]; then
 610                 dtimeleft_s=$((timeout_s * 2))
 611         fi
 612
 613         if [ -n "$TEST_NO_SESSIOND" ] && [ "$TEST_NO_SESSIOND" == "1" ]; then
 614                 # Env variable requested no session daemon
 615                 return 0
 616         fi
 617
 618         local retval=0
 619
 620         local runas_pids=
 621         runas_pids=$(pgrep "$RUNAS_MATCH")
 622
 623         local pids=
 624         pids=$(pgrep "$SESSIOND_MATCH")
 625
 626         if [ -n "$runas_pids" ]; then
 627                 pids="$pids $runas_pids"
 628         fi
 629
 630         if [ -z "$pids" ]; then
 631                 if [ "$withtap" -eq "1" ]; then
 632                         pass "No session daemon to kill"
 633                 fi
 634                 return 0
 635         fi
 636
 637         diag "Killing (signal $signal) $SESSIOND_BIN and lt-$SESSIOND_BIN pids: $(echo "$pids" | tr '\n' ' ')"
 638
 639         # shellcheck disable=SC2086
 640         if ! kill -s $signal $pids 1> $OUTPUT_DEST 2> $ERROR_OUTPUT_DEST; then
 641                 retval=1
 642                 if [ "$withtap" -eq "1" ]; then
 643                         fail "Kill sessions daemon"
 644                 fi
 645         else
 646                 out=1
 647                 while [ -n "$out" ]; do
 648                         out=$(pgrep "${SESSIOND_MATCH}")
 649                         if [ -n "$dtimeleft_s" ]; then
 650                                 if [ $dtimeleft_s -lt 0 ]; then
 651                                         out=
 652                                         retval=1
 653                                 fi
 654                                 dtimeleft_s=$((dtimeleft_s - 1))
 655                         fi
 656                         sleep 0.5
 657                 done
 658                 out=1
 659                 while [ -n "$out" ]; do
 660                         out=$(pgrep "$CONSUMERD_MATCH")
 661                         if [ -n "$dtimeleft_s" ]; then
 662                                 if [ $dtimeleft_s -lt 0 ]; then
 663                                         out=
 664                                         retval=1
 665                                 fi
 666                                 dtimeleft_s=$((dtimeleft_s - 1))
 667                         fi
 668                         sleep 0.5
 669                 done
 670
 671                 if [ "$withtap" -eq "1" ]; then
 672                         if [ "$retval" -eq "0" ]; then
 673                                 pass "Wait after kill session daemon"
 674                         else
 675                                 fail "Wait after kill session daemon"
 676                         fi
 677                 fi
 678         fi
 679         if [ "$signal" = "SIGKILL" ]; then
 680                 if [ "$(id -u)" -eq "0" ]; then
 681                         local modules=
 682                         modules="$(lsmod | grep ^lttng | awk '{print $1}')"
 683
 684                         if [ -n "$modules" ]; then
 685                                 diag "Unloading all LTTng modules"
 686                                 modprobe --remove "$modules"
 687                         fi
 688                 fi
 689         fi
 690
 691         return $retval
 692 }
 693
 694 function stop_lttng_sessiond()
 695 {
 696         stop_lttng_sessiond_opt 1 "$@"
 697 }
 698
 699 function stop_lttng_sessiond_notap()
 700 {
 701         stop_lttng_sessiond_opt 0 "$@"
 702 }
 703
 704 function sigstop_lttng_sessiond_opt()
 705 {
 706         local withtap=$1
 707         local signal=SIGSTOP
 708
 709         if [ -n "$TEST_NO_SESSIOND" ] && [ "$TEST_NO_SESSIOND" == "1" ]; then
 710                 # Env variable requested no session daemon
 711                 return
 712         fi
 713
 714         PID_SESSIOND="$(pgrep "${SESSIOND_MATCH}") $(pgrep "$RUNAS_MATCH")"
 715
 716         if [ "$withtap" -eq "1" ]; then
 717                 diag "Sending SIGSTOP to lt-$SESSIOND_BIN and $SESSIOND_BIN pids: $(echo "$PID_SESSIOND" | tr '\n' ' ')"
 718         fi
 719
 720         # shellcheck disable=SC2086
 721         if ! kill -s $signal $PID_SESSIOND 1> $OUTPUT_DEST 2> $ERROR_OUTPUT_DEST; then
 722                 if [ "$withtap" -eq "1" ]; then
 723                         fail "Sending SIGSTOP to session daemon"
 724                 fi
 725         else
 726                 out=1
 727                 while [ $out -ne 0 ]; do
 728                         pid="$(pgrep "$SESSIOND_MATCH")"
 729
 730                         # Wait until state becomes stopped for session
 731                         # daemon(s).
 732                         out=0
 733                         for sessiond_pid in $pid; do
 734                                 state="$(ps -p "$sessiond_pid" -o state= )"
 735                                 if [[ -n "$state" && "$state" != "T" ]]; then
 736                                         out=1
 737                                 fi
 738                         done
 739                         sleep 0.5
 740                 done
 741                 if [ "$withtap" -eq "1" ]; then
 742                         pass "Sending SIGSTOP to session daemon"
 743                 fi
 744         fi
 745 }
 746
 747 function sigstop_lttng_sessiond()
 748 {
 749         sigstop_lttng_sessiond_opt 1 "$@"
 750 }
 751
 752 function sigstop_lttng_sessiond_notap()
 753 {
 754         sigstop_lttng_sessiond_opt 0 "$@"
 755 }
 756
 757 function stop_lttng_consumerd_opt()
 758 {
 759         local withtap=$1
 760         local signal=$2
 761
 762         if [ -z "$signal" ]; then
 763                 signal=SIGTERM
 764         fi
 765
 766         local timeout_s=$3
 767         local dtimeleft_s=
 768
 769         # Multiply time by 2 to simplify integer arithmetic
 770         if [ -n "$timeout_s" ]; then
 771                 dtimeleft_s=$((timeout_s * 2))
 772         fi
 773
 774         local retval=0
 775
 776         PID_CONSUMERD="$(pgrep "$CONSUMERD_MATCH")"
 777
 778         if [ -z "$PID_CONSUMERD" ]; then
 779                 if [ "$withtap" -eq "1" ]; then
 780                         pass "No consumer daemon to kill"
 781                 fi
 782                 return 0
 783         fi
 784
 785         diag "Killing (signal $signal) $CONSUMERD_BIN pids: $(echo "$PID_CONSUMERD" | tr '\n' ' ')"
 786
 787         # shellcheck disable=SC2086
 788         if ! kill -s $signal $PID_CONSUMERD 1> $OUTPUT_DEST 2> $ERROR_OUTPUT_DEST; then
 789                 retval=1
 790                 if [ "$withtap" -eq "1" ]; then
 791                         fail "Kill consumer daemon"
 792                 fi
 793         else
 794                 out=1
 795                 while [ $out -ne 0 ]; do
 796                         pid="$(pgrep "$CONSUMERD_MATCH")"
 797
 798                         # If consumerds are still present check their status.
 799                         # A zombie status qualifies the consumerd as *killed*
 800                         out=0
 801                         for consumer_pid in $pid; do
 802                                 state="$(ps -p "$consumer_pid" -o state= )"
 803                                 if [[ -n "$state" && "$state" != "Z" ]]; then
 804                                         out=1
 805                                 fi
 806                         done
 807                         if [ -n "$dtimeleft_s" ]; then
 808                                 if [ $dtimeleft_s -lt 0 ]; then
 809                                         out=0
 810                                         retval=1
 811                                 fi
 812                                 dtimeleft_s=$((dtimeleft_s - 1))
 813                         fi
 814                         sleep 0.5
 815                 done
 816                 if [ "$withtap" -eq "1" ]; then
 817                         if [ "$retval" -eq "0" ]; then
 818                                 pass "Wait after kill consumer daemon"
 819                         else
 820                                 fail "Wait after kill consumer daemon"
 821                         fi
 822                 fi
 823         fi
 824
 825         return $retval
 826 }
 827
 828 function stop_lttng_consumerd()
 829 {
 830         stop_lttng_consumerd_opt 1 "$@"
 831 }
 832
 833 function stop_lttng_consumerd_notap()
 834 {
 835         stop_lttng_consumerd_opt 0 "$@"
 836 }
 837
 838 function sigstop_lttng_consumerd_opt()
 839 {
 840         local withtap=$1
 841         local signal=SIGSTOP
 842
 843         PID_CONSUMERD="$(pgrep "$CONSUMERD_MATCH")"
 844
 845         diag "Sending SIGSTOP to $CONSUMERD_BIN pids: $(echo "$PID_CONSUMERD" | tr '\n' ' ')"
 846
 847         # shellcheck disable=SC2086
 848         kill -s $signal $PID_CONSUMERD 1> $OUTPUT_DEST 2> $ERROR_OUTPUT_DEST
 849         retval=$?
 850
 851         if [ $retval -eq 1 ]; then
 852                 if [ "$withtap" -eq "1" ]; then
 853                         fail "Sending SIGSTOP to consumer daemon"
 854                 fi
 855                 return 1
 856         else
 857                 out=1
 858                 while [ $out -ne 0 ]; do
 859                         pid="$(pgrep "$CONSUMERD_MATCH")"
 860
 861                         # Wait until state becomes stopped for all
 862                         # consumers.
 863                         out=0
 864                         for consumer_pid in $pid; do
 865                                 state="$(ps -p "$consumer_pid" -o state= )"
 866                                 if [[ -n "$state" && "$state" != "T" ]]; then
 867                                         out=1
 868                                 fi
 869                         done
 870                         sleep 0.5
 871                 done
 872                 if [ "$withtap" -eq "1" ]; then
 873                         pass "Sending SIGSTOP to consumer daemon"
 874                 fi
 875         fi
 876         return $retval
 877 }
 878
 879 function sigstop_lttng_consumerd()
 880 {
 881         sigstop_lttng_consumerd_opt 1 "$@"
 882 }
 883
 884 function sigstop_lttng_consumerd_notap()
 885 {
 886         sigstop_lttng_consumerd_opt 0 "$@"
 887 }
 888
 889 function list_lttng_with_opts ()
 890 {
 891         local opts=$1
 892         $TESTDIR/../src/bin/lttng/$LTTNG_BIN list $opts 1> $OUTPUT_DEST 2> $ERROR_OUTPUT_DEST
 893         ok $? "Lttng-tool list command with option $opts"
 894 }
 895
 896 function create_lttng_session_no_output ()
 897 {
 898         local sess_name=$1
 899         local opts="${@:2}"
 900
 901         $TESTDIR/../src/bin/lttng/$LTTNG_BIN create $sess_name --no-output $opts 1> $OUTPUT_DEST 2> $ERROR_OUTPUT_DEST
 902         ok $? "Create session $sess_name in no-output mode"
 903 }
 904
 905 function create_lttng_session_uri () {
 906         local sess_name=$1
 907         local uri=$2
 908         local opts="${@:3}"
 909
 910         $TESTDIR/../src/bin/lttng/$LTTNG_BIN create $sess_name -U $uri $opts 1> $OUTPUT_DEST 2> $ERROR_OUTPUT_DEST
 911         ok $? "Create session $sess_name with uri:$uri and opts: $opts"
 912 }
 913
 914 function create_lttng_session ()
 915 {
 916         local withtap=$1
 917         local expected_to_fail=$2
 918         local sess_name=$3
 919         local trace_path=$4
 920         local opt=$5
 921
 922         if [ -z "$trace_path" ]; then
 923                 # Use lttng-sessiond default output.
 924                 trace_path=""
 925         else
 926                 trace_path="-o $trace_path"
 927         fi
 928
 929         $TESTDIR/../src/bin/lttng/$LTTNG_BIN create "$sess_name" $trace_path $opt 1> $OUTPUT_DEST 2> $ERROR_OUTPUT_DEST
 930         ret=$?
 931         if [ $expected_to_fail -eq "1" ]; then
 932                 test "$ret" -ne "0"
 933                 ret=$?
 934                 if [ $withtap -eq "1" ]; then
 935                         ok $ret "Create session $sess_name in $trace_path failed as expected"
 936                 fi
 937         else
 938                 if [ $withtap -eq "1" ]; then
 939                         ok $ret "Create session $sess_name in $trace_path"
 940                 fi
 941         fi
 942         return $ret
 943 }
 944
 945 function create_lttng_session_ok ()
 946 {
 947         create_lttng_session 1 0 "$@"
 948 }
 949
 950 function create_lttng_session_fail ()
 951 {
 952         create_lttng_session 1 1 "$@"
 953 }
 954
 955 function create_lttng_session_notap ()
 956 {
 957         create_lttng_session 0 0 "$@"
 958 }
 959
 960
 961 function enable_ust_lttng_channel ()
 962 {
 963         local withtap=$1
 964         local expected_to_fail=$2
 965         local sess_name=$3
 966         local channel_name=$4
 967         local opts="${@:5}"
 968
 969         $TESTDIR/../src/bin/lttng/$LTTNG_BIN enable-channel -u $channel_name -s $sess_name $opts 1> $OUTPUT_DEST 2> $ERROR_OUTPUT_DEST
 970         ret=$?
 971         if [[ $expected_to_fail -eq "1" ]]; then
 972                 test "$ret" -ne "0"
 973                 ret=$?
 974                 if [ $withtap -eq "1" ]; then
 975                         ok $ret "Enable channel $channel_name for session $sess_name failed as expected"
 976                 fi
 977         else
 978                 if [ $withtap -eq "1" ]; then
 979                         ok $ret "Enable channel $channel_name for session $sess_name"
 980                 fi
 981         fi
 982         return $ret
 983 }
 984
 985 function enable_ust_lttng_channel_ok ()
 986 {
 987         enable_ust_lttng_channel 1 0 "$@"
 988 }
 989
 990 function enable_ust_lttng_channel_fail ()
 991 {
 992         enable_ust_lttng_channel 1 1 "$@"
 993 }
 994
 995 function enable_ust_lttng_channel_notap ()
 996 {
 997         enable_ust_lttng_channel 0 0 "$@"
 998 }
 999
1000 function disable_ust_lttng_channel()
1001 {
1002         local sess_name=$1
1003         local channel_name=$2
1004
1005         $TESTDIR/../src/bin/lttng/$LTTNG_BIN disable-channel -u $channel_name -s $sess_name 1> $OUTPUT_DEST 2> $ERROR_OUTPUT_DEST
1006         ok $? "Disable channel $channel_name for session $sess_name"
1007 }
1008
1009 function enable_lttng_mmap_overwrite_kernel_channel()
1010 {
1011         local sess_name=$1
1012         local channel_name=$2
1013
1014         $TESTDIR/../src/bin/lttng/$LTTNG_BIN enable-channel -s $sess_name $channel_name -k --output mmap --overwrite 1> $OUTPUT_DEST 2> $ERROR_OUTPUT_DEST
1015         ok $? "Enable channel $channel_name for session $sess_name"
1016 }
1017
1018 function enable_lttng_mmap_discard_small_kernel_channel()
1019 {
1020         local sess_name=$1
1021         local channel_name=$2
1022
1023         $TESTDIR/../src/bin/lttng/$LTTNG_BIN enable-channel -s $sess_name $channel_name -k --output mmap --discard --subbuf-size=$(getconf PAGE_SIZE) --num-subbuf=2 1> $OUTPUT_DEST 2> $ERROR_OUTPUT_DEST
1024         ok $? "Enable small discard channel $channel_name for session $sess_name"
1025 }
1026
1027 function enable_lttng_mmap_overwrite_small_kernel_channel()
1028 {
1029         local sess_name=$1
1030         local channel_name=$2
1031
1032         $TESTDIR/../src/bin/lttng/$LTTNG_BIN enable-channel -s $sess_name $channel_name -k --output mmap --overwrite --subbuf-size=$(getconf PAGE_SIZE) --num-subbuf=2 1> $OUTPUT_DEST 2> $ERROR_OUTPUT_DEST
1033         ok $? "Enable small discard channel $channel_name for session $sess_name"
1034 }
1035
1036 function enable_lttng_mmap_overwrite_ust_channel()
1037 {
1038         local sess_name=$1
1039         local channel_name=$2
1040
1041         $TESTDIR/../src/bin/lttng/$LTTNG_BIN enable-channel -s $sess_name $channel_name -u --output mmap --overwrite 1> $OUTPUT_DEST 2> $ERROR_OUTPUT_DEST
1042         ok $? "Enable channel $channel_name for session $sess_name"
1043 }
1044
1045 function enable_ust_lttng_event ()
1046 {
1047         local withtap=$1
1048         local expected_to_fail=$2
1049         local sess_name=$3
1050         local event_name="$4"
1051         local channel_name=$5
1052
1053         if [ -z $channel_name ]; then
1054                 # default channel if none specified
1055                 chan=""
1056         else
1057                 chan="-c $channel_name"
1058         fi
1059
1060         $TESTDIR/../src/bin/lttng/$LTTNG_BIN enable-event "$event_name" $chan -s $sess_name -u 1> $OUTPUT_DEST 2> $ERROR_OUTPUT_DEST
1061         ret=$?
1062         if [[ $expected_to_fail -eq "1" ]]; then
1063                 test $ret -ne "0"
1064                 ret=$?
1065                 if [[ $withtap -eq "1" ]]; then
1066                         ok $ret "Enable ust event $event_name for session $session_name failed as expected"
1067                 fi
1068         else
1069                 if [[ $withtap -eq "1" ]]; then
1070                         ok $ret "Enable ust event $event_name for session $sess_name"
1071                 fi
1072         fi
1073         return $ret
1074 }
1075
1076 function enable_ust_lttng_event_ok ()
1077 {
1078         enable_ust_lttng_event 1 0 "$@"
1079 }
1080
1081 function enable_ust_lttng_event_fail ()
1082 {
1083         enable_ust_lttng_event 1 1 "$@"
1084 }
1085
1086 function enable_ust_lttng_event_notap ()
1087 {
1088         enable_ust_lttng_event 0 0 "$@"
1089 }
1090
1091 function enable_jul_lttng_event()
1092 {
1093         sess_name=$1
1094         event_name="$2"
1095         channel_name=$3
1096
1097         if [ -z $channel_name ]; then
1098                 # default channel if none specified
1099                 chan=""
1100         else
1101                 chan="-c $channel_name"
1102         fi
1103
1104         $TESTDIR/../src/bin/lttng/$LTTNG_BIN enable-event "$event_name" $chan -s $sess_name -j 1> $OUTPUT_DEST 2> $ERROR_OUTPUT_DEST
1105         ok $? "Enable JUL event $event_name for session $sess_name"
1106 }
1107
1108 function enable_jul_lttng_event_loglevel()
1109 {
1110         local sess_name=$1
1111         local event_name="$2"
1112         local loglevel=$3
1113         local channel_name=$4
1114
1115         if [ -z $channel_name ]; then
1116                 # default channel if none specified
1117                 chan=""
1118         else
1119                 chan="-c $channel_name"
1120         fi
1121
1122         $TESTDIR/../src/bin/lttng/$LTTNG_BIN enable-event --loglevel $loglevel "$event_name" $chan -s $sess_name -j 1> $OUTPUT_DEST 2> $ERROR_OUTPUT_DEST
1123         ok $? "Enable JUL event $event_name for session $sess_name with loglevel $loglevel"
1124 }
1125
1126 function enable_log4j_lttng_event()
1127 {
1128         local sess_name=$1
1129         local event_name=$2
1130         local channel_name=$3
1131
1132         local chan_opt=()
1133
1134         # default channel if none specified
1135         if [ -n "$channel_name" ]; then
1136                 chan_opt=("-c" "$channel_name")
1137         fi
1138
1139         _run_lttng_cmd "$OUTPUT_DEST" "$ERROR_OUTPUT_DEST" \
1140                 enable-event "$event_name" "${chan_opt[@]}" -s "$sess_name" --log4j
1141         ok $? "Enable LOG4J event '$event_name' for session '$sess_name'"
1142 }
1143
1144 function enable_log4j_lttng_event_filter()
1145 {
1146         local sess_name=$1
1147         local event_name=$2
1148         local filter=$3
1149
1150         _run_lttng_cmd "$OUTPUT_DEST" "$ERROR_OUTPUT_DEST" \
1151                 enable-event "$event_name" -s "$sess_name" --log4j --filter "$filter"
1152         ok $? "Enable LOG4J event '$event_name' with filter '$filter' for session '$sess_name'"
1153 }
1154
1155 function enable_log4j_lttng_event_filter_loglevel_only()
1156 {
1157         local sess_name=$1
1158         local event_name=$2
1159         local filter=$3
1160         local loglevel=$4
1161
1162         _run_lttng_cmd "$OUTPUT_DEST" "$ERROR_OUTPUT_DEST" \
1163                 enable-event --loglevel-only "$loglevel" "$event_name" -s "$sess_name" -l --filter "$filter"
1164         ok $? "Enable LOG4J event '$event_name' with filter '$filter' and loglevel-only '$loglevel' for session '$sess_name'"
1165 }
1166
1167 function enable_log4j_lttng_event_loglevel()
1168 {
1169         local sess_name=$1
1170         local event_name=$2
1171         local loglevel=$3
1172         local channel_name=$4
1173
1174
1175         # default channel if none specified
1176         if [ -n "$channel_name" ]; then
1177                 chan_opt=("-c" "$channel_name")
1178         fi
1179
1180         _run_lttng_cmd "$OUTPUT_DEST" "$ERROR_OUTPUT_DEST" \
1181                 enable-event --loglevel "$loglevel" "$event_name" "${chan_opt[@]}" -s "$sess_name" --log4j
1182         ok $? "Enable LOG4J event '$event_name' for session '$sess_name' with loglevel '$loglevel'"
1183 }
1184
1185 function enable_log4j_lttng_event_loglevel_only()
1186 {
1187         local sess_name=$1
1188         local event_name=$2
1189         local loglevel=$3
1190         local channel_name=$4
1191
1192         local chan_opt=()
1193
1194         # default channel if none specified
1195         if [ -n "$channel_name" ]; then
1196                 chan_opt=("-c" "$channel_name")
1197         fi
1198
1199         _run_lttng_cmd "$OUTPUT_DEST" "$ERROR_OUTPUT_DEST" \
1200                 enable-event --loglevel-only "$loglevel" "$event_name" "${chan_opt[@]}" -s "$sess_name" --log4j
1201         ok $? "Enable LOG4J event '$event_name' for session '$sess_name' with loglevel-only '$loglevel'"
1202 }
1203
1204 function enable_python_lttng_event()
1205 {
1206         sess_name=$1
1207         event_name="$2"
1208         channel_name=$3
1209
1210         if [ -z $channel_name ]; then
1211                 # default channel if none specified
1212                 chan=""
1213         else
1214                 chan="-c $channel_name"
1215         fi
1216
1217         $TESTDIR/../src/bin/lttng/$LTTNG_BIN enable-event "$event_name" $chan -s $sess_name -p 1> $OUTPUT_DEST 2> $ERROR_OUTPUT_DEST
1218         ok $? "Enable Python event $event_name for session $sess_name"
1219 }
1220
1221 function enable_python_lttng_event_loglevel()
1222 {
1223         local sess_name=$1
1224         local event_name="$2"
1225         local loglevel=$3
1226         local channel_name=$4
1227
1228         if [ -z $channel_name ]; then
1229                 # default channel if none specified
1230                 chan=""
1231         else
1232                 chan="-c $channel_name"
1233         fi
1234
1235         $TESTDIR/../src/bin/lttng/$LTTNG_BIN enable-event --loglevel $loglevel "$event_name" $chan -s $sess_name -p 1> $OUTPUT_DEST 2> $ERROR_OUTPUT_DEST
1236         ok $? "Enable Python event $event_name for session $sess_name with loglevel $loglevel"
1237 }
1238
1239 function enable_ust_lttng_event_filter()
1240 {
1241         local sess_name="$1"
1242         local event_name="$2"
1243         local filter="$3"
1244         local channel_name=$4
1245
1246         if [ -z $channel_name ]; then
1247                 # default channel if none specified
1248                 chan=""
1249         else
1250                 chan="-c $channel_name"
1251         fi
1252
1253         $TESTDIR/../src/bin/lttng/$LTTNG_BIN enable-event $chan "$event_name" -s $sess_name -u --filter "$filter" 1> $OUTPUT_DEST 2> $ERROR_OUTPUT_DEST
1254         ok $? "Enable event $event_name with filtering for session $sess_name"
1255 }
1256
1257 function enable_ust_lttng_event_loglevel()
1258 {
1259         local sess_name="$1"
1260         local event_name="$2"
1261         local loglevel="$3"
1262
1263         $TESTDIR/../src/bin/lttng/$LTTNG_BIN enable-event "$event_name" -s $sess_name -u --loglevel $loglevel 1> $OUTPUT_DEST 2> $ERROR_OUTPUT_DEST
1264         ok $? "Enable event $event_name with loglevel $loglevel"
1265 }
1266
1267 function enable_ust_lttng_event_loglevel_only()
1268 {
1269         local sess_name="$1"
1270         local event_name="$2"
1271         local loglevel="$3"
1272
1273         $TESTDIR/../src/bin/lttng/$LTTNG_BIN enable-event "$event_name" -s $sess_name -u --loglevel-only $loglevel 1> $OUTPUT_DEST 2> $ERROR_OUTPUT_DEST
1274         ok $? "Enable event $event_name with loglevel-only $loglevel"
1275 }
1276
1277 function disable_ust_lttng_event ()
1278 {
1279         local sess_name="$1"
1280         local event_name="$2"
1281         local channel_name="$3"
1282
1283         if [ -z $channel_name ]; then
1284                 # default channel if none specified
1285                 chan=""
1286         else
1287                 chan="-c $channel_name"
1288         fi
1289
1290         $TESTDIR/../src/bin/lttng/$LTTNG_BIN disable-event "$event_name" -s $sess_name $chan -u 1> $OUTPUT_DEST 2> $ERROR_OUTPUT_DEST
1291         ok $? "Disable event $event_name for session $sess_name"
1292 }
1293
1294 function disable_jul_lttng_event ()
1295 {
1296         local sess_name="$1"
1297         local event_name="$2"
1298
1299         $TESTDIR/../src/bin/lttng/$LTTNG_BIN disable-event "$event_name" -s $sess_name -j >/dev/null 2>&1
1300         ok $? "Disable JUL event $event_name for session $sess_name"
1301 }
1302
1303 function disable_log4j_lttng_event ()
1304 {
1305         local sess_name="$1"
1306         local event_name="$2"
1307
1308         _run_lttng_cmd "$OUTPUT_DEST" "$ERROR_OUTPUT_DEST" \
1309                 disable-event "$event_name" -s "$sess_name" --log4j
1310         ok $? "Disable LOG4J event '$event_name' for session '$sess_name'"
1311 }
1312
1313 function disable_python_lttng_event ()
1314 {
1315         local sess_name="$1"
1316         local event_name="$2"
1317
1318         $TESTDIR/../src/bin/lttng/$LTTNG_BIN disable-event "$event_name" -s $sess_name -p 1> $OUTPUT_DEST 2> $ERROR_OUTPUT_DEST
1319         ok $? "Disable Python event $event_name for session $sess_name"
1320 }
1321
1322 function start_lttng_tracing_opt ()
1323 {
1324         local withtap=$1
1325         local expected_to_fail=$2
1326         local sess_name=$3
1327
1328         $TESTDIR/../src/bin/lttng/$LTTNG_BIN start $sess_name 1> $OUTPUT_DEST 2> $ERROR_OUTPUT_DEST
1329         ret=$?
1330         if [[ $expected_to_fail -eq "1" ]]; then
1331                 test "$ret" -ne "0"
1332                 ret=$?
1333                 if [ $withtap -eq "1" ]; then
1334                         ok $? "Start tracing for session $sess_name failed as expected"
1335                 fi
1336         else
1337                 if [ $withtap -eq "1" ]; then
1338                         ok $ret "Start tracing for session $sess_name"
1339                 fi
1340         fi
1341 }
1342
1343 function start_lttng_tracing_ok ()
1344 {
1345         start_lttng_tracing_opt 1 0 "$@"
1346 }
1347
1348 function start_lttng_tracing_fail ()
1349 {
1350         start_lttng_tracing_opt 1 1 "$@"
1351 }
1352
1353 function start_lttng_tracing_notap ()
1354 {
1355         start_lttng_tracing_opt 0 1 "$@"
1356 }
1357
1358 function stop_lttng_tracing_opt ()
1359 {
1360         local withtap=$1
1361         local expected_to_fail=$2
1362         local sess_name=$3
1363
1364         $TESTDIR/../src/bin/lttng/$LTTNG_BIN stop $sess_name 1> $OUTPUT_DEST 2> $ERROR_OUTPUT_DEST
1365         ret=$?
1366         if [[ $expected_to_fail -eq "1" ]]; then
1367                 test "$ret" -ne "0"
1368                 ret=$?
1369                 if [ $withtap -eq "1" ]; then
1370                         ok $? "Stop lttng tracing for session $sess_name failed as expected"
1371                 fi
1372         else
1373                 if [ $withtap -eq "1" ]; then
1374                         ok $ret "Stop lttng tracing for session $sess_name"
1375                 fi
1376         fi
1377 }
1378
1379 function stop_lttng_tracing_ok ()
1380 {
1381         stop_lttng_tracing_opt 1 0 "$@"
1382 }
1383
1384 function stop_lttng_tracing_fail ()
1385 {
1386         stop_lttng_tracing_opt 1 1 "$@"
1387 }
1388
1389 function stop_lttng_tracing_notap ()
1390 {
1391         stop_lttng_tracing_opt 0 0 "$@"
1392 }
1393
1394 function destroy_lttng_session ()
1395 {
1396         local withtap=$1
1397         local expected_to_fail=$2
1398         local sess_name=$3
1399
1400         $TESTDIR/../src/bin/lttng/$LTTNG_BIN destroy $sess_name 1> $OUTPUT_DEST 2> $ERROR_OUTPUT_DEST
1401         ret=$?
1402         if [[ $expected_to_fail -eq "1" ]]; then
1403                 test "$ret" -ne "0"
1404                 ret=$?
1405                 if [ $withtap -eq "1" ]; then
1406                         ok $ret "Destroy session $sess_name failed as expected"
1407                 fi
1408         else
1409                 if [ $withtap -eq "1" ]; then
1410                         ok $ret "Destroy session $sess_name"
1411                 fi
1412         fi
1413 }
1414
1415 function destroy_lttng_session_ok ()
1416 {
1417         destroy_lttng_session 1 0 "$@"
1418
1419 }
1420
1421 function destroy_lttng_session_fail ()
1422 {
1423         destroy_lttng_session 1 1 "$@"
1424 }
1425
1426 function destroy_lttng_session_notap ()
1427 {
1428         destroy_lttng_session 0 0 "$@"
1429 }
1430
1431 function destroy_lttng_sessions ()
1432 {
1433         $TESTDIR/../src/bin/lttng/$LTTNG_BIN destroy --all 1> $OUTPUT_DEST 2> $ERROR_OUTPUT_DEST
1434         ok $? "Destroy all lttng sessions"
1435 }
1436
1437 function lttng_snapshot_add_output ()
1438 {
1439         local expected_to_fail=$1
1440         local sess_name=$2
1441         local trace_path=$3
1442         local opts=$4
1443
1444         $TESTDIR/../src/bin/lttng/$LTTNG_BIN snapshot add-output -s $sess_name $trace_path $opts 1> $OUTPUT_DEST 2> $ERROR_OUTPUT_DEST
1445         ret=$?
1446         if [[ $expected_to_fail -eq 1 ]]; then
1447                 test "$ret" -ne "0"
1448                 ok $? "Added snapshot output $trace_path failed as expected"
1449         else
1450                 ok $ret "Added snapshot output $trace_path"
1451         fi
1452 }
1453
1454 function lttng_snapshot_add_output_ok ()
1455 {
1456         lttng_snapshot_add_output 0 "$@"
1457 }
1458
1459 function lttng_snapshot_add_output_fail ()
1460 {
1461         lttng_snapshot_add_output 1 "$@"
1462 }
1463
1464 function lttng_snapshot_del_output ()
1465 {
1466         local expected_to_fail=$1
1467         local sess_name=$2
1468         local id=$3
1469
1470         $TESTDIR/../src/bin/lttng/$LTTNG_BIN snapshot del-output -s $sess_name $id 1> $OUTPUT_DEST 2> $ERROR_OUTPUT_DEST
1471         ret=$?
1472         if [[ $expected_to_fail -eq "1" ]]; then
1473                 test "$ret" -ne "0"
1474                 ok $? "Deleted snapshot output id $id failed as expected"
1475         else
1476                 ok $ret "Deleted snapshot output id $id"
1477         fi
1478 }
1479
1480 function lttng_snapshot_del_output_ok ()
1481 {
1482         lttng_snapshot_del_output 0 "$@"
1483 }
1484
1485 function lttng_snapshot_del_output_fail ()
1486 {
1487         lttng_snapshot_del_output 1 "$@"
1488 }
1489
1490 function lttng_snapshot_record ()
1491 {
1492         local sess_name=$1
1493         local trace_path=$2
1494
1495         $TESTDIR/../src/bin/lttng/$LTTNG_BIN snapshot record -s "$sess_name" "$trace_path" 1> $OUTPUT_DEST 2> $ERROR_OUTPUT_DEST
1496         ok $? "Snapshot recorded"
1497 }
1498
1499 function lttng_snapshot_list ()
1500 {
1501         local sess_name=$1
1502         $TESTDIR/../src/bin/lttng/$LTTNG_BIN snapshot list-output -s $sess_name 1> $OUTPUT_DEST 2> $ERROR_OUTPUT_DEST
1503         ok $? "Snapshot list"
1504 }
1505
1506 function lttng_save()
1507 {
1508         local sess_name=$1
1509         local opts=$2
1510
1511         $TESTDIR/../src/bin/lttng/$LTTNG_BIN save $sess_name $opts 1> $OUTPUT_DEST 2> $ERROR_OUTPUT_DEST
1512         ok $? "Session saved"
1513 }
1514
1515 function lttng_load()
1516 {
1517         local expected_to_fail=$1
1518         local opts=$2
1519
1520         $TESTDIR/../src/bin/lttng/$LTTNG_BIN load $opts 1> $OUTPUT_DEST 2> $ERROR_OUTPUT_DEST
1521         ret=$?
1522         if [[ $expected_to_fail -eq "1" ]]; then
1523                 test $ret -ne "0"
1524                 ok $? "Load command failed as expected with opts: $opts"
1525         else
1526                 ok $ret "Load command with opts: $opts"
1527         fi
1528 }
1529
1530 function lttng_load_ok()
1531 {
1532         lttng_load 0 "$@"
1533 }
1534
1535 function lttng_load_fail()
1536 {
1537         lttng_load 1 "$@"
1538 }
1539
1540 function lttng_track()
1541 {
1542         local expected_to_fail="$1"
1543         shift 1
1544         local opts="$@"
1545         $TESTDIR/../src/bin/lttng/$LTTNG_BIN track $opts >$OUTPUT_DEST
1546         ret=$?
1547         if [[ $expected_to_fail -eq "1" ]]; then
1548                 test $ret -ne "0"
1549                 ok $? "Track command failed as expected with opts: $opts"
1550         else
1551                 ok $ret "Track command with opts: $opts"
1552         fi
1553 }
1554
1555 function lttng_track_ok()
1556 {
1557         lttng_track 0 "$@"
1558 }
1559
1560 function lttng_track_fail()
1561 {
1562         lttng_track 1 "$@"
1563 }
1564
1565 function lttng_untrack()
1566 {
1567         local expected_to_fail="$1"
1568         shift 1
1569         local opts="$@"
1570         $TESTDIR/../src/bin/lttng/$LTTNG_BIN untrack $opts >$OUTPUT_DEST
1571         ret=$?
1572         if [[ $expected_to_fail -eq "1" ]]; then
1573                 test $ret -ne "0"
1574                 ok $? "Untrack command failed as expected with opts: $opts"
1575         else
1576                 ok $ret "Untrack command with opts: $opts"
1577         fi
1578 }
1579
1580 function lttng_untrack_ok()
1581 {
1582         lttng_untrack 0 "$@"
1583 }
1584
1585 function lttng_untrack_fail()
1586 {
1587         lttng_untrack 1 "$@"
1588 }
1589
1590 function lttng_track_pid_ok()
1591 {
1592         PID=$1
1593         "$TESTDIR/../src/bin/lttng/$LTTNG_BIN" track --kernel --pid=$PID 1> $OUTPUT_DEST 2> $ERROR_OUTPUT_DEST
1594         ok $? "Lttng track pid on the kernel domain"
1595 }
1596
1597 function lttng_untrack_kernel_all_ok()
1598 {
1599         "$TESTDIR/../src/bin/lttng/$LTTNG_BIN" untrack --kernel --pid --all 1> $OUTPUT_DEST 2> $ERROR_OUTPUT_DEST
1600         ok $? "Lttng untrack all pid on the kernel domain"
1601 }
1602
1603 function lttng_track_ust_ok()
1604 {
1605         lttng_track_ok -u "$@"
1606 }
1607
1608 function lttng_track_ust_fail()
1609 {
1610         lttng_track_fail -u "$@"
1611 }
1612
1613 function lttng_track_kernel_ok()
1614 {
1615         lttng_track_ok -k "$@"
1616 }
1617
1618 function lttng_track_kernel_fail()
1619 {
1620         lttng_track_fail -k "$@"
1621 }
1622
1623 function lttng_untrack_ust_ok()
1624 {
1625         lttng_untrack_ok -u "$@"
1626 }
1627
1628 function lttng_untrack_ust_fail()
1629 {
1630         lttng_untrack_fail -u "$@"
1631 }
1632
1633 function lttng_untrack_kernel_ok()
1634 {
1635         lttng_untrack_ok -k "$@"
1636 }
1637
1638 function lttng_untrack_kernel_fail()
1639 {
1640         lttng_untrack_fail -k "$@"
1641 }
1642
1643 function lttng_add_context_list()
1644 {
1645         $TESTDIR/../src/bin/lttng/$LTTNG_BIN add-context --list 1> $OUTPUT_DEST 2> $ERROR_OUTPUT_DEST
1646         ret=$?
1647         ok $ret "Context listing"
1648 }
1649
1650 function add_context_lttng()
1651 {
1652         local expected_to_fail="$1"
1653         local domain="$2"
1654         local session_name="$3"
1655         local channel_name="$4"
1656         local type="$5"
1657
1658         $TESTDIR/../src/bin/lttng/$LTTNG_BIN add-context -s $session_name -c $channel_name -t $type $domain  1> $OUTPUT_DEST 2> $ERROR_OUTPUT_DEST
1659         ret=$?
1660         if [[ $expected_to_fail -eq "1" ]]; then
1661                 test $ret -ne "0"
1662                 ok $? "Add context command failed as expected for type: $type"
1663         else
1664                 ok $ret "Add context command for type: $type"
1665         fi
1666 }
1667
1668 function add_context_ust_ok()
1669 {
1670         add_context_lttng 0 -u "$@"
1671 }
1672
1673 function add_context_ust_fail()
1674 {
1675         add_context_lttng 1 -u "$@"
1676 }
1677
1678 function add_context_kernel_ok()
1679 {
1680         add_context_lttng 0 -k "$@"
1681 }
1682
1683 function add_context_kernel_fail()
1684 {
1685         add_context_lttng 1 -k "$@"
1686 }
1687
1688 function wait_live_trace_ready ()
1689 {
1690         local url=$1
1691         local zero_client_match=0
1692
1693         diag "Waiting for live trace at url: $url"
1694         while [ $zero_client_match -eq 0 ]; do
1695                 zero_client_match=$($BABELTRACE_BIN -i lttng-live $url | grep "0 client(s) connected" | wc -l)
1696                 sleep 0.5
1697         done
1698         pass "Waiting for live trace at url: $url"
1699 }
1700
1701 function wait_live_viewer_connect ()
1702 {
1703         local url=$1
1704         local one_client_match=0
1705
1706         diag "Waiting for live viewers on url: $url"
1707         while [ $one_client_match -eq 0 ]; do
1708                 one_client_match=$($BABELTRACE_BIN -i lttng-live $url | grep "1 client(s) connected" | wc -l)
1709                 sleep 0.5
1710         done
1711         pass "Waiting for live viewers on url: $url"
1712 }
1713
1714 function bail_out_if_no_babeltrace()
1715 {
1716         which "$BABELTRACE_BIN" >/dev/null
1717         if [ $? -ne 0 ]; then
1718                 LTTNG_BAIL_OUT "\"$BABELTRACE_BIN\" binary not found. Skipping tests"
1719         fi
1720 }
1721
1722 function validate_metadata_event ()
1723 {
1724         local event_name=$1
1725         local nr_event_id=$2
1726         local trace_path=$3
1727
1728         local metadata_file=$(find $trace_path | grep metadata)
1729         local metadata_path=$(dirname $metadata_file)
1730
1731         which $BABELTRACE_BIN >/dev/null
1732         skip $? -ne 0 "Babeltrace binary not found. Skipping trace matches"
1733
1734         local count=$($BABELTRACE_BIN --output-format=ctf-metadata $metadata_path | grep $event_name | wc -l)
1735
1736         if [ "$count" -ne "$nr_event_id" ]; then
1737                 fail "Metadata match with the metadata of $count event(s) named $event_name"
1738                 diag "$count matching event id found in metadata"
1739         else
1740                 pass "Metadata match with the metadata of $count event(s) named $event_name"
1741         fi
1742
1743 }
1744
1745 function trace_matches ()
1746 {
1747         local event_name=$1
1748         local nr_iter=$2
1749         local trace_path=$3
1750
1751         which $BABELTRACE_BIN >/dev/null
1752         skip $? -ne 0 "Babeltrace binary not found. Skipping trace matches"
1753
1754         local count=$($BABELTRACE_BIN $trace_path | grep $event_name | wc -l)
1755
1756         if [ "$count" -ne "$nr_iter" ]; then
1757                 fail "Trace match"
1758                 diag "$count matching events found in trace"
1759         else
1760                 pass "Trace match"
1761         fi
1762 }
1763
1764 function trace_match_only()
1765 {
1766         local event_name=$1
1767         local nr_iter=$2
1768         local trace_path=$3
1769
1770         which $BABELTRACE_BIN >/dev/null
1771         skip $? -ne 0 "Babeltrace binary not found. Skipping trace matches"
1772
1773         local count=$($BABELTRACE_BIN $trace_path | grep $event_name | wc -l)
1774         local total=$($BABELTRACE_BIN $trace_path | wc -l)
1775
1776         if [ "$nr_iter" -eq "$count" ] && [ "$total" -eq "$nr_iter" ]; then
1777                 pass "Trace match with $total event $event_name"
1778         else
1779                 fail "Trace match"
1780                 diag "$total event(s) found, expecting $nr_iter of event $event_name and only found $count"
1781         fi
1782 }
1783
1784 function validate_trace
1785 {
1786         local event_name=$1
1787         local trace_path=$2
1788
1789         which $BABELTRACE_BIN >/dev/null
1790         if [ $? -ne 0 ]; then
1791             skip 0 "Babeltrace binary not found. Skipping trace validation"
1792         fi
1793
1794         OLDIFS=$IFS
1795         IFS=","
1796         for i in $event_name; do
1797                 traced=$($BABELTRACE_BIN $trace_path 2>/dev/null | grep $i | wc -l)
1798                 if [ "$traced" -ne 0 ]; then
1799                         pass "Validate trace for event $i, $traced events"
1800                 else
1801                         fail "Validate trace for event $i"
1802                         diag "Found $traced occurences of $i"
1803                 fi
1804         done
1805         ret=$?
1806         IFS=$OLDIFS
1807         return $ret
1808 }
1809
1810 function validate_trace_count
1811 {
1812         local event_name=$1
1813         local trace_path=$2
1814         local expected_count=$3
1815
1816         which $BABELTRACE_BIN >/dev/null
1817         if [ $? -ne 0 ]; then
1818             skip 0 "Babeltrace binary not found. Skipping trace validation"
1819         fi
1820
1821         cnt=0
1822         OLDIFS=$IFS
1823         IFS=","
1824         for i in $event_name; do
1825                 traced=$($BABELTRACE_BIN $trace_path 2>/dev/null | grep $i | wc -l)
1826                 if [ "$traced" -ne 0 ]; then
1827                         pass "Validate trace for event $i, $traced events"
1828                 else
1829                         fail "Validate trace for event $i"
1830                         diag "Found $traced occurences of $i"
1831                 fi
1832                 cnt=$(($cnt + $traced))
1833         done
1834         IFS=$OLDIFS
1835         test $cnt -eq $expected_count
1836         ok $? "Read a total of $cnt events, expected $expected_count"
1837 }
1838
1839 function validate_trace_count_range_incl_min_excl_max
1840 {
1841         local event_name=$1
1842         local trace_path=$2
1843         local expected_min=$3
1844         local expected_max=$4
1845
1846         which $BABELTRACE_BIN >/dev/null
1847         if [ $? -ne 0 ]; then
1848             skip 0 "Babeltrace binary not found. Skipping trace validation"
1849         fi
1850
1851         cnt=0
1852         OLDIFS=$IFS
1853         IFS=","
1854         for i in $event_name; do
1855                 traced=$($BABELTRACE_BIN $trace_path 2>/dev/null | grep $i | wc -l)
1856                 if [ "$traced" -ge $expected_min ]; then
1857                         pass "Validate trace for event $i, $traced events"
1858                 else
1859                         fail "Validate trace for event $i"
1860                         diag "Found $traced occurences of $i"
1861                 fi
1862                 cnt=$(($cnt + $traced))
1863         done
1864         IFS=$OLDIFS
1865         test $cnt -lt $expected_max
1866         ok $? "Read a total of $cnt events, expected between [$expected_min, $expected_max["
1867 }
1868
1869 function trace_first_line
1870 {
1871         local trace_path=$1
1872
1873         which $BABELTRACE_BIN >/dev/null
1874         if [ $? -ne 0 ]; then
1875             skip 0 "Babeltrace binary not found. Skipping trace validation"
1876         fi
1877
1878         $BABELTRACE_BIN $trace_path 2>/dev/null | head -n 1
1879 }
1880
1881 function validate_trace_exp()
1882 {
1883         local event_exp=$1
1884         local trace_path=$2
1885
1886         which $BABELTRACE_BIN >/dev/null
1887         skip $? -ne 0 "Babeltrace binary not found. Skipping trace validation"
1888
1889         traced=$($BABELTRACE_BIN $trace_path 2>/dev/null | grep --extended-regexp ${event_exp} | wc -l)
1890         if [ "$traced" -ne 0 ]; then
1891                 pass "Validate trace for expression '${event_exp}', $traced events"
1892         else
1893                 fail "Validate trace for expression '${event_exp}'"
1894                 diag "Found $traced occurences of '${event_exp}'"
1895         fi
1896         ret=$?
1897         return $ret
1898 }
1899
1900 function validate_trace_only_exp()
1901 {
1902         local event_exp=$1
1903         local trace_path=$2
1904
1905         which $BABELTRACE_BIN >/dev/null
1906         skip $? -ne 0 "Babeltrace binary not found. Skipping trace matches"
1907
1908         local count=$($BABELTRACE_BIN $trace_path | grep --extended-regexp ${event_exp} | wc -l)
1909         local total=$($BABELTRACE_BIN $trace_path | wc -l)
1910
1911         if [ "$count" -ne 0 ] && [ "$total" -eq "$count" ]; then
1912                 pass "Trace match with $total for expression '${event_exp}'"
1913         else
1914                 fail "Trace match"
1915                 diag "$total syscall event(s) found, only syscalls matching expression '${event_exp}' ($count occurrences) are expected"
1916         fi
1917         ret=$?
1918         return $ret
1919 }
1920
1921 function validate_trace_empty()
1922 {
1923         local trace_path=$1
1924
1925         which $BABELTRACE_BIN >/dev/null
1926         if [ $? -ne 0 ]; then
1927             skip 0 "Babeltrace binary not found. Skipping trace validation"
1928         fi
1929
1930         events=$($BABELTRACE_BIN $trace_path 2>/dev/null)
1931         ret=$?
1932         if [ $ret -ne 0 ]; then
1933                 fail "Failed to parse trace"
1934                 return $ret
1935         fi
1936
1937         traced=$(echo -n "$events" | wc -l)
1938         if [ "$traced" -eq 0 ]; then
1939                 pass "Validate empty trace"
1940         else
1941                 fail "Validate empty trace"
1942                 diag "Found $traced events in trace"
1943         fi
1944         ret=$?
1945         return $ret
1946 }
1947
1948 function validate_directory_empty ()
1949 {
1950         local trace_path="$1"
1951
1952         # Do not double quote `$trace_path` below as we want wildcards to be
1953         # expanded.
1954         files="$(ls -A $trace_path)"
1955         ret=$?
1956         if [ $ret -ne 0 ]; then
1957                 fail "Failed to list content of directory \"$trace_path\""
1958                 return $ret
1959         fi
1960
1961         nb_files="$(echo -n "$files" | wc -l)"
1962         ok $nb_files "Directory \"$trace_path\" is empty"
1963 }
1964
1965 function validate_trace_session_ust_empty()
1966 {
1967         validate_directory_empty "$1"/ust
1968 }
1969
1970 function validate_trace_session_kernel_empty()
1971 {
1972         validate_trace_empty "$1"/kernel
1973 }
1974
1975 function regenerate_metadata ()
1976 {
1977         local expected_to_fail=$1
1978         local sess_name=$2
1979
1980         $TESTDIR/../src/bin/lttng/$LTTNG_BIN regenerate metadata -s $sess_name 1> $OUTPUT_DEST 2> $ERROR_OUTPUT_DEST
1981         ret=$?
1982         if [[ $expected_to_fail -eq "1" ]]; then
1983                 test "$ret" -ne "0"
1984                 ok $? "Expected fail on regenerate metadata $sess_name"
1985         else
1986                 ok $ret "Metadata regenerate $sess_name"
1987         fi
1988 }
1989
1990 function regenerate_metadata_ok ()
1991 {
1992         regenerate_metadata 0 "$@"
1993 }
1994
1995 function regenerate_metadata_fail ()
1996 {
1997         regenerate_metadata 1 "$@"
1998 }
1999
2000 function regenerate_statedump ()
2001 {
2002         local expected_to_fail=$1
2003         local sess_name=$2
2004
2005         $TESTDIR/../src/bin/lttng/$LTTNG_BIN regenerate statedump -s $sess_name 1> $OUTPUT_DEST 2> $ERROR_OUTPUT_DEST
2006         ret=$?
2007         if [[ $expected_to_fail -eq "1" ]]; then
2008                 test "$ret" -ne "0"
2009                 ok $? "Expected fail on regenerate statedump $sess_name"
2010         else
2011                 ok $ret "Statedump regenerate $sess_name"
2012         fi
2013 }
2014
2015 function regenerate_statedump_ok ()
2016 {
2017         regenerate_statedump 0 "$@"
2018 }
2019
2020 function regenerate_statedump_fail ()
2021 {
2022         regenerate_statedump 1 "$@"
2023 }
2024
2025 function rotate_session ()
2026 {
2027         local expected_to_fail=$1
2028         local sess_name=$2
2029
2030         $TESTDIR/../src/bin/lttng/$LTTNG_BIN rotate $sess_name 1> $OUTPUT_DEST 2> $ERROR_OUTPUT_DEST
2031         ret=$?
2032         if [[ $expected_to_fail -eq "1" ]]; then
2033                 test "$ret" -ne "0"
2034                 ok $? "Expected fail on rotate session $sess_name"
2035         else
2036                 ok $ret "Rotate session $sess_name"
2037         fi
2038 }
2039
2040 function rotate_session_ok ()
2041 {
2042         rotate_session 0 "$@"
2043 }
2044
2045 function rotate_session_fail ()
2046 {
2047         rotate_session 1 "$@"
2048 }
2049
2050 function destructive_tests_enabled ()
2051 {
2052         if [ "$LTTNG_ENABLE_DESTRUCTIVE_TESTS" = "will-break-my-system" ]; then
2053                 return 0
2054         else
2055                 return 1
2056         fi
2057 }
2058
2059 function lttng_enable_rotation_timer ()
2060 {
2061         local expected_to_fail=$1
2062         local sess_name=$2
2063         local period=$3
2064
2065         $TESTDIR/../src/bin/lttng/$LTTNG_BIN enable-rotation -s $sess_name --timer $period 1> $OUTPUT_DEST 2> $ERROR_OUTPUT_DEST
2066         ret=$?
2067         if [[ $expected_to_fail -eq "1" ]]; then
2068                 test "$ret" -ne "0"
2069                 ok $? "Expected fail when setting periodic rotation ($period) of session $sess_name"
2070         else
2071                 ok $ret "Set periodic rotation ($period) of session $sess_name"
2072         fi
2073 }
2074
2075 function lttng_enable_rotation_timer_ok ()
2076 {
2077         lttng_enable_rotation_timer 0 $@
2078 }
2079
2080 function lttng_enable_rotation_timer_fail ()
2081 {
2082         lttng_enable_rotation_timer 1 $@
2083 }
2084
2085 function lttng_enable_rotation_size ()
2086 {
2087         local expected_to_fail=$1
2088         local sess_name=$2
2089         local size=$3
2090
2091         $TESTDIR/../src/bin/lttng/$LTTNG_BIN enable-rotation -s $sess_name --size $size 1> $OUTPUT_DEST 2> $ERROR_OUTPUT_DEST
2092         ret=$?
2093         if [[ $expected_to_fail -eq "1" ]]; then
2094                 test "$ret" -ne "0"
2095                 ok $? "Expected fail on rotate session $sess_name"
2096         else
2097                 ok $ret "Rotate session $sess_name"
2098         fi
2099 }
2100
2101 function lttng_enable_rotation_size_ok ()
2102 {
2103         lttng_enable_rotation_size 0 $@
2104 }
2105
2106 function lttng_enable_rotation_size_fail ()
2107 {
2108         lttng_enable_rotation_size 1 $@
2109 }
2110
2111 function lttng_clear_session ()
2112 {
2113         local expected_to_fail=$1
2114         local sess_name=$2
2115
2116         $TESTDIR/../src/bin/lttng/$LTTNG_BIN clear $sess_name 1> $OUTPUT_DEST 2> $ERROR_OUTPUT_DEST
2117         ret=$?
2118         if [[ $expected_to_fail -eq "1" ]]; then
2119                 test "$ret" -ne "0"
2120                 ok $? "Expected fail on clear session $sess_name"
2121         else
2122                 ok $ret "Clear session $sess_name"
2123         fi
2124 }
2125
2126 function lttng_clear_session_ok ()
2127 {
2128         lttng_clear_session 0 $@
2129 }
2130
2131 function lttng_clear_session_fail ()
2132 {
2133         lttng_clear_session 1 $@
2134 }
2135
2136 function lttng_clear_all ()
2137 {
2138         $TESTDIR/../src/bin/lttng/$LTTNG_BIN clear --all 1> $OUTPUT_DEST 2> $ERROR_OUTPUT_DEST
2139         ok $? "Clear all lttng sessions"
2140 }
2141
2142 function validate_path_pattern ()
2143 {
2144         local message=$1
2145         local pattern=$2
2146         # Base path is only used in error case and is used to list the content
2147         # of the base path.
2148         local base_path=$3
2149
2150
2151         [ -f $pattern ]
2152         ret=$?
2153         ok $ret "$message"
2154
2155         if [ "$ret" -ne "0" ]; then
2156                 diag "Path pattern expected: $pattern"
2157                 # List the tracepath for more info. We use find as a recursive
2158                 # directory lister.
2159                 diag "The base path content:"
2160                 find "$base_path" -print
2161         fi
2162 }
2163
2164 function validate_trace_path_ust_uid ()
2165 {
2166         local trace_path=$1
2167         local session_name=$2
2168         local uid=$UID
2169         local pattern="$trace_path/$session_name-$date_time_pattern/ust/uid/$uid/${system_long_bit_size}-bit/metadata"
2170
2171         validate_path_pattern "UST per-uid trace path is valid" "$pattern" "$trace_path"
2172 }
2173
2174 function validate_trace_path_ust_uid_network ()
2175 {
2176         local trace_path=$1
2177         local session_name=$2
2178         local base_path=$3
2179         local uid=$UID
2180         local hostname=$HOSTNAME
2181         local pattern
2182         local ret
2183
2184         # If the session was given a network base path (e.g
2185         # 127.0.0.1/my/custom/path on creation, there is no session name
2186         # component to the path on the relayd side. Caller can simply not pass a
2187         # session name for this scenario.
2188         if [ -n "$session_name" ]; then
2189                 session_name="$session_name-$date_time_pattern"
2190                 if [ -n "$base_path" ]; then
2191                         fail "Session name and base path are mutually exclusive"
2192                         return
2193                 fi
2194         fi
2195
2196         pattern="$trace_path/$hostname/$base_path/$session_name/ust/uid/$uid/${system_long_bit_size}-bit/metadata"
2197
2198         validate_path_pattern "UST per-uid network trace path is valid" "$pattern" "$trace_path"
2199 }
2200
2201 function validate_trace_path_ust_uid_snapshot_network ()
2202 {
2203         local trace_path=$1
2204         local session_name=$2
2205         local snapshot_name=$3
2206         local snapshot_number=$4
2207         local base_path=$5
2208         local hostname=$HOSTNAME
2209         local uid=$UID
2210         local pattern
2211         local ret
2212
2213         # If the session/output was given a network base path (e.g
2214         # 127.0.0.1/my/custom/path on creation, there is no session name
2215         # component to the path on the relayd side. Caller can simply not pass a
2216         # session name for this scenario.
2217         if [ -n "$session_name" ]; then
2218                 session_name="$session_name-$date_time_pattern"
2219                 if [ -n "$base_path" ]; then
2220                         fail "Session name and base path are mutually exclusive"
2221                         return
2222                 fi
2223         fi
2224
2225         pattern="$trace_path/$hostname/$base_path/$session_name/$snapshot_name-$date_time_pattern-$snapshot_number/ust/uid/$uid/${system_long_bit_size}-bit/metadata"
2226
2227         validate_path_pattern "UST per-uid network snapshot trace path is valid" "$pattern" "$trace_path"
2228 }
2229
2230 function validate_trace_path_ust_uid_snapshot ()
2231 {
2232         local trace_path=$1
2233         local session_name=$2
2234         local snapshot_name=$3
2235         local snapshot_number=$4
2236         local base_path=$5
2237         local uid=$UID
2238         local pattern
2239         local ret
2240
2241         # If the session/output was given a network base path (e.g
2242         # 127.0.0.1/my/custom/path) on creation, there is no session name
2243         # component to the path on the relayd side. Caller can simply not pass a
2244         # session name for this scenario.
2245         if [ -n "$session_name" ]; then
2246                 session_name="$session_name-$date_time_pattern"
2247                 if [ -n "$base_path" ]; then
2248                         fail "Session name and base path are mutually exclusive"
2249                         return
2250                 fi
2251         fi
2252
2253         pattern="$trace_path/$base_path/$session_name/$snapshot_name-$date_time_pattern-$snapshot_number/ust/uid/$uid/${system_long_bit_size}-bit/metadata"
2254
2255         validate_path_pattern "UST per-uid snapshot trace path is valid" "$pattern" "$trace_path"
2256 }
2257
2258 function validate_trace_path_ust_pid ()
2259 {
2260         local trace_path=$1
2261         local session_name=$2
2262         local app_string=$3
2263         local pid=$4
2264         local pattern
2265         local ret
2266
2267         # If the session was given a trace path on creation, there is no session
2268         # name component to the path. Caller can simply not pass a session name
2269         # for this scenario.
2270         if [ -n "$session_name" ]; then
2271                 session_name="$session_name-$date_time_pattern"
2272         fi
2273
2274         pattern="$trace_path/$session_name/ust/pid/$pid/$app_string-*-$date_time_pattern/metadata"
2275
2276         validate_path_pattern "UST per-pid trace path is valid" "$pattern" "$trace_path"
2277 }
2278
2279 function validate_trace_path_kernel ()
2280 {
2281         local trace_path=$1
2282         local session_name=$2
2283         local pattern
2284
2285         # If the session was given a trace path on creation, there is no session
2286         # name component to the path. Caller can simply not pass a session name
2287         # for this scenario.
2288         if [ -n "$session_name" ]; then
2289                 session_name="$session_name-$date_time_pattern"
2290         fi
2291
2292         pattern="$trace_path/$session_name/kernel/metadata"
2293
2294         validate_path_pattern "Kernel trace path is valid" "$pattern" "$trace_path"
2295 }
2296
2297 function validate_trace_path_kernel_network ()
2298 {
2299         local trace_path=$1
2300         local session_name=$2
2301         local hostname=$HOSTNAME
2302         local pattern="$trace_path/$hostname/$session_name-$date_time_pattern/kernel/metadata"
2303
2304         validate_path_pattern "Kernel network trace path is valid" "$pattern" "$trace_path"
2305 }
2306
2307 function validate_trace_path_kernel_snapshot ()
2308 {
2309         local trace_path=$1
2310         local session_name=$2
2311         local snapshot_name=$3
2312         local snapshot_number=$4
2313         local base_path=$5
2314         local pattern
2315         local ret
2316
2317         # If the session/output was given a network base path (e.g
2318         # 127.0.0.1/my/custom/path on creation, there is no session name
2319         # component to the path on the relayd side. Caller can simply not pass a
2320         # session name for this scenario.
2321         if [ -n "$session_name" ]; then
2322                 session_name="$session_name-$date_time_pattern"
2323                 if [ -n "$base_path" ]; then
2324                         fail "Session name and base path are mutually exclusive"
2325                         return
2326                 fi
2327         fi
2328
2329         pattern="$trace_path/$base_path/$session_name/$snapshot_name-$date_time_pattern-$snapshot_number/kernel/metadata"
2330
2331         validate_path_pattern "Kernel snapshot trace path is valid" "$pattern" "$trace_path"
2332 }
2333
2334 function validate_trace_path_kernel_snapshot_network ()
2335 {
2336         local trace_path=$1
2337         local session_name=$2
2338         local snapshot_name=$3
2339         local snapshot_number=$4
2340         local base_path=$5
2341         local hostname=$HOSTNAME
2342         local pattern
2343         local ret
2344
2345         # If the session/output was given a network base path (e.g
2346         # 127.0.0.1/my/custom/path on creation, there is no session name
2347         # component to the path on the relayd side. Caller can simply not pass a
2348         # session name for this scenario.
2349         if [ -n "$session_name" ]; then
2350                 session_name="$session_name-$date_time_pattern"
2351                 if [ -n "$base_path" ]; then
2352                         fail "Session name and base path are mutually exclusive"
2353                         return
2354                 fi
2355         fi
2356
2357         pattern="$trace_path/$hostname/$base_path/$session_name/$snapshot_name-$date_time_pattern-$snapshot_number/kernel/metadata"
2358
2359         validate_path_pattern "Kernel network snapshot trace path is valid" "$pattern" "$trace_path"
2360 }