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