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