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