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