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