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