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