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