#!/bin/bash
#
# SPDX-FileCopyrightText: 2013 Julien Desfossez <jdesfossez@efficios.com>
#
# SPDX-License-Identifier: LGPL-2.1-only

TEST_DESC="Snapshots - UST tracing"

CURDIR=$(dirname "$0")/
TESTDIR="$CURDIR/../../.."
EVENT_NAME="tp:tptest"
SESSION_NAME=""
CHANNEL_NAME="snapchan"
TESTAPP_PATH="$TESTDIR/utils/testapp"
TESTAPP_NAME="gen-ust-events"
TESTAPP_BIN="$TESTAPP_PATH/$TESTAPP_NAME/$TESTAPP_NAME"
APPS_PID=()

NUM_TESTS=201

TRACE_PATH=$(mktemp -d -t tmp.test_snapshots_ust_trace_path.XXXXXX)

# shellcheck source-path=SCRIPTDIR/../../../
source "$TESTDIR/utils/utils.sh"

if [ ! -x "$TESTAPP_BIN" ]; then
	BAIL_OUT "No UST events binary detected"
fi

# Need the number of snapshot to do.
if [ -z "$1" ]; then
	BAIL_OUT "A number of snapshot is needed"
fi
NR_SNAPSHOT=$1

NUM_TESTS=$((NUM_TESTS + (NR_SNAPSHOT * 3)))

function start_test_app()
{
	local tmp_file
	tmp_file=$(mktemp -u -t "tmp.${FUNCNAME[0]}_tmp_file.XXXXXX")
	TESTAPP_ARGS=(
		"-i"
		"${NR_ITER}"
		"-w"
		"${NR_USEC_WAIT}"
		"--sync-after-first-event"
		"${tmp_file}"
	)
	if [ -n "${TESTAPP_ITER_WAIT_FILE}" ] ; then
		TESTAPP_ARGS+=(
			"--sync-after-each-iter"
			"${TESTAPP_ITER_WAIT_FILE}"
		)
	fi
	# Start application with a temporary file.
	$TESTAPP_BIN "${TESTAPP_ARGS[@]}" &
	ret=$?
	APPS_PID+=(${!})
	ok $ret "Start application to trace"

	# Wait for the application file to appear indicating that at least one
	# tracepoint has been fired.
	while [ ! -f "$tmp_file" ]; do
		sleep 0.1
	done
	diag "Removing test app temporary file $tmp_file"
	rm -f "$tmp_file"
}

function wait_test_apps()
{
	diag "Waiting for $TESTAPP_NAME"
	wait "${APPS_PID[@]}" 2>/dev/null
}

function stop_test_apps()
{
	if [[ -n "${APPS_PID[*]}" ]]; then
		diag "Stopping $TESTAPP_NAME"
		kill "${APPS_PID[@]}"
		wait "${APPS_PID[@]}"
		APPS_PID=()
	fi
}

function snapshot_add_output ()
{
	local sess_name=$1
	local trace_path=$2
	local name=$3
	local max_size=$4
	local extra_opt=()

	if [ -n "$name" ]; then
		extra_opt+=(-n "$name")
	fi

	if [ -n "$max_size" ]; then
		extra_opt+=(-m "$max_size")
	fi

	"$TESTDIR/../src/bin/lttng/$LTTNG_BIN" snapshot add-output \
		-s "$sess_name" "${extra_opt[@]}" "$trace_path" > /dev/null 2>&1

	ok $? "Added snapshot output $trace_path (${extra_opt[*]})"
}

function snapshot_del_output ()
{
	local sess_name=$1
	local name=$2

	"$TESTDIR/../src/bin/lttng/$LTTNG_BIN" snapshot del-output \
		-s "$sess_name" "$name" > /dev/null 2>&1

	ok $? "Deleted snapshot output named $name"
}

function enable_mmap_overwrite_subbuf_ust_channel ()
{
	local sess_name=$1
	local chan_name=$2
	local subbuf_size=$3
	local subbuf_count=$4

	"$TESTDIR/../src/bin/lttng/$LTTNG_BIN" enable-channel -s "$sess_name" \
		"$chan_name" -u --output mmap --overwrite \
		--num-subbuf="$subbuf_count" \
		--subbuf-size "$subbuf_size" > /dev/null 2>&1

	ok $? "Enable channel $channel_name for session $sess_name with subbuf size $subbuf_size"
}

function enable_mmap_small_discard_ust_channel ()
{
	local sess_name=$1
	local chan_name=$2

	"$TESTDIR/../src/bin/lttng/$LTTNG_BIN" enable-channel -s "$sess_name" \
		"$chan_name" -u --output mmap --discard \
		--subbuf-size "$(getconf PAGE_SIZE)" --num-subbuf 2 \
		> /dev/null 2>&1

	ok $? "Enable channel $channel_name for session $sess_name with small discard buffers"
}

function enable_mmap_small_overwrite_ust_channel ()
{
	local sess_name=$1
	local chan_name=$2

	"$TESTDIR/../src/bin/lttng/$LTTNG_BIN" enable-channel -s "$sess_name" \
		"$chan_name" -u --output mmap --overwrite \
		--subbuf-size "$(getconf PAGE_SIZE)" --num-subbuf 2 \
		> /dev/null 2>&1

	ok $? "Enable channel $channel_name for session $sess_name with small discard buffers"
}

function test_ust_list_output ()
{
	output_names=("randomname" "somesnapshot")

	diag "Test UST snapshot output listing"
	create_lttng_session_no_output "$SESSION_NAME"
	enable_lttng_mmap_overwrite_ust_channel "$SESSION_NAME" $CHANNEL_NAME
	enable_ust_lttng_event_ok "$SESSION_NAME" $EVENT_NAME $CHANNEL_NAME

	start_lttng_tracing_ok "$SESSION_NAME"

	snapshot_add_output "$SESSION_NAME" "file://$TRACE_PATH" "${output_names[0]}"

	"$TESTDIR/../src/bin/lttng/$LTTNG_BIN" snapshot list-output \
		-s "$SESSION_NAME" 2>&1 | grep "${output_names[0]}" > /dev/null
	ok $? "Snapshot named ${output_names[0]} present in list-output listing"

	snapshot_del_output "$SESSION_NAME" "${output_names[0]}"

	snapshot_add_output "$SESSION_NAME" "file://$TRACE_PATH" "${output_names[1]}"

	"$TESTDIR/../src/bin/lttng/$LTTNG_BIN" snapshot list-output \
		-s "$SESSION_NAME" 2>&1 | grep "${output_names[1]}" > /dev/null

	ok $? "Snapshot named ${output_names[1]} present in list-output listing"

	stop_lttng_tracing_ok "$SESSION_NAME"
	destroy_lttng_session_ok "$SESSION_NAME"
}

function test_ust_local_snapshot ()
{
	NR_ITER=-1
	NR_USEC_WAIT=100

	diag "Test local UST snapshots"
	create_lttng_session_no_output "$SESSION_NAME"
	enable_lttng_mmap_overwrite_ust_channel "$SESSION_NAME" $CHANNEL_NAME
	enable_ust_lttng_event_ok "$SESSION_NAME" $EVENT_NAME $CHANNEL_NAME
	start_lttng_tracing_ok "$SESSION_NAME"
	lttng_snapshot_add_output_ok "$SESSION_NAME" "file://$TRACE_PATH"

	# Returns once the application has at least fired ONE tracepoint.
	start_test_app

	lttng_snapshot_record "$SESSION_NAME"
	stop_lttng_tracing_ok "$SESSION_NAME"
	destroy_lttng_session_ok "$SESSION_NAME"

	# Validate test
	validate_trace_path_ust_uid_snapshot "$TRACE_PATH" "" "snapshot-1" 0
	if validate_trace $EVENT_NAME "$TRACE_PATH/" ; then
		# Only delete if successful
		rm -rf "$TRACE_PATH"
	fi

	stop_test_apps
}

function test_ust_local_snapshot_small_discard_buffers ()
{
	NR_ITER=10000
	NR_USEC_WAIT=0
	OLDCPUSET=$(taskset -p $$)

	diag "Test local UST snapshots with small discard buffers"
	retry_anycpu_taskset $$
	ok $? "Set current process CPU affinity"
	create_lttng_session_no_output "$SESSION_NAME"
	enable_mmap_small_discard_ust_channel "$SESSION_NAME" $CHANNEL_NAME
	enable_ust_lttng_event_ok "$SESSION_NAME" $EVENT_NAME $CHANNEL_NAME
	start_lttng_tracing_ok "$SESSION_NAME"
	lttng_snapshot_add_output_ok "$SESSION_NAME" "file://$TRACE_PATH"

	# Run test apps, wait for them to complete.
	start_test_app
	wait_test_apps

	# Take first snapshot, remember first line.
	lttng_snapshot_record "$SESSION_NAME"
	FIRST_LINE="$(trace_first_line "$TRACE_PATH/")"
	diag "First line (1st snapshot): $FIRST_LINE"
	rm -rf "${TRACE_PATH:?}/"

	# Run test apps, wait for them to complete.
	start_test_app
	wait_test_apps

	# Take second snapshot, remember first line.
	lttng_snapshot_record "$SESSION_NAME"
	FIRST_LINE_2="$(trace_first_line "$TRACE_PATH/")"
	diag "First line (2nd snapshot): $FIRST_LINE_2"
	rm -rf "${TRACE_PATH:?}/"

	if [ x"$FIRST_LINE" != x"$FIRST_LINE_2" ]; then
		fail "First snapshot event do not match"
	else
		pass "First snapshot event match"
	fi

	stop_lttng_tracing_ok "$SESSION_NAME"
	destroy_lttng_session_ok "$SESSION_NAME"

	if ! taskset -p "$OLDCPUSET" $$ 1>/dev/null 2>&1 ; then
		# If returning to the original CPU set fails, create a mask e.g. FFF
		# which encompasses all possible CPUs.
		mask=''
		iter=0
		while [[ "${iter}" -lt $(($(get_possible_cpus_count) / 4 + 1)) ]]; do
			mask="${mask}F"
			iter=$((iter+1))
		done
		taskset -p "${mask}" $$
	fi
}

function test_ust_local_snapshot_small_overwrite_buffers ()
{
	NR_ITER=10000
	NR_USEC_WAIT=0
	OLDCPUSET=$(taskset -p $$)

	diag "Test local UST snapshots with small overwrite buffers"
	retry_anycpu_taskset $$ 1>/dev/null 2>&1
	ok $? "Set current process CPU affinity"
	create_lttng_session_no_output "$SESSION_NAME"
	enable_mmap_small_overwrite_ust_channel "$SESSION_NAME" $CHANNEL_NAME
	enable_ust_lttng_event_ok "$SESSION_NAME" $EVENT_NAME $CHANNEL_NAME
	start_lttng_tracing_ok "$SESSION_NAME"
	lttng_snapshot_add_output_ok "$SESSION_NAME" "file://$TRACE_PATH"

	# Run test apps, wait for them to complete.
	start_test_app
	wait_test_apps

	# Take first snapshot, remember first line.
	lttng_snapshot_record "$SESSION_NAME"
	FIRST_LINE="$(trace_first_line "$TRACE_PATH/")"
	diag "First line (1st snapshot): $FIRST_LINE"
	rm -rf "${TRACE_PATH:?}/"

	# Run test apps, wait for them to complete.
	start_test_app
	wait_test_apps

	# Take second snapshot, remember first line.
	lttng_snapshot_record "$SESSION_NAME"
	FIRST_LINE_2="$(trace_first_line "$TRACE_PATH/")"
	diag "First line (2nd snapshot): $FIRST_LINE_2"
	rm -rf "${TRACE_PATH:?}/"

	if [ x"$FIRST_LINE" != x"$FIRST_LINE_2" ]; then
		pass "First snapshot event do not match"
	else
		fail "First snapshot event match"
	fi

	stop_lttng_tracing_ok "$SESSION_NAME"
	destroy_lttng_session_ok "$SESSION_NAME"
	if ! taskset -p "$OLDCPUSET" $$ 1>/dev/null 2>&1 ; then
		# If returning to the original CPU set fails, create a mask e.g. FFF
		# which encompasses all possible CPUs.
		mask=''
		iter=0
		while [[ "${iter}" -lt $(($(get_possible_cpus_count) / 4 + 1)) ]]; do
			mask="${mask}F"
			iter=$((iter+1))
		done
		taskset -p "${mask}" $$
	fi
}

function test_ust_local_snapshot_max_size ()
{
	local possible_cpus
	local cpus_list
	local subbuf_size
	local subbuf_count
	local snapshot_max_size
	local channel_max_size_per_cpu

	IFS=" " read -r -a cpus_list <<< "$(get_online_cpus)"

	possible_cpus=$(get_possible_cpus_count)
	subbuf_size=$(getconf PAGE_SIZE)
	subbuf_count=8
	snapshot_max_size=$((subbuf_size*possible_cpus))
	channel_max_size_per_cpu=$((subbuf_size*subbuf_count))

	diag "Test local UST snapshots with max size $max_size"
	create_lttng_session_no_output "$SESSION_NAME"

	enable_mmap_overwrite_subbuf_ust_channel \
		"$SESSION_NAME" "$CHANNEL_NAME" \
		"$subbuf_size" "$subbuf_count"

	enable_ust_lttng_event_ok "$SESSION_NAME" "$EVENT_NAME" "$CHANNEL_NAME"
	start_lttng_tracing_ok "$SESSION_NAME"

	snapshot_add_output "$SESSION_NAME" "file://$TRACE_PATH" "" "$snapshot_max_size"

	# Fill all ring-buffers of the channel; assuming event size of at least one
	# byte
	for cpu in "${cpus_list[@]}";
	do
		diag "setting affinity to $cpu"
		taskset --cpu-list "$cpu" "$TESTAPP_BIN" \
			--iter "$channel_max_size_per_cpu"
	done
	diag "Filled channel ring-buffers"

	lttng_snapshot_record "$SESSION_NAME"

	# Check file size
	local snapshot_size
	snapshot_size=$(find "$TRACE_PATH" -name "${CHANNEL_NAME}_*" \
				-exec stat -c '%s' {} \; | \
				awk '{s = s + $1}END{print s}')

	if [ "$snapshot_size" -eq "$snapshot_max_size" ]; then
		pass "Tracefiles size sum validation"
	else
		fail "Tracefiles size sum validation"
		diag "Tracefiles size sum: $snapshot_size Expected max: $snapshot_max_size"
	fi

	stop_lttng_tracing_ok "$SESSION_NAME"
	destroy_lttng_session_ok "$SESSION_NAME"

	# Validate test
	validate_trace_path_ust_uid_snapshot "$TRACE_PATH" "" "snapshot-1" 0

	if validate_trace "$EVENT_NAME" "$TRACE_PATH/"; then
		# Only delete if successful
		rm -rf "$TRACE_PATH"
	fi

	stop_test_apps
}

function test_ust_local_snapshot_large_metadata ()
{
	LM_EVENT="tp:tptest1,tp:tptest2,tp:tptest3,tp:tptest4,tp:tptest5"
	LM_PATH="$TESTDIR/utils/testapp"
	LM_NAME="gen-ust-nevents"
	LM_BIN="$LM_PATH/$LM_NAME/$LM_NAME"

	diag "Test local UST snapshots with > 4kB metadata"
	create_lttng_session_no_output "$SESSION_NAME"
	enable_lttng_mmap_overwrite_ust_channel "$SESSION_NAME" $CHANNEL_NAME
	enable_ust_lttng_event_ok "$SESSION_NAME" $LM_EVENT $CHANNEL_NAME
	start_lttng_tracing_ok "$SESSION_NAME"
	lttng_snapshot_add_output_ok "$SESSION_NAME" "file://$TRACE_PATH"
	$LM_BIN --iter 1 --wait 1
	ok $? "Start application to trace"
	lttng_snapshot_record "$SESSION_NAME"
	stop_lttng_tracing_ok "$SESSION_NAME"
	destroy_lttng_session_ok "$SESSION_NAME"

	# Validate test
	validate_trace_path_ust_uid_snapshot "$TRACE_PATH" "" "snapshot-1" 0
	if validate_trace $LM_EVENT "$TRACE_PATH/" ; then
		# Only delete if successful
		rm -rf "${TRACE_PATH:?}/"
	fi
}

function enable_channel_per_uid_mmap_overwrite()
{
	sess_name=$1
	channel_name=$2

	"$TESTDIR/../src/bin/lttng/$LTTNG_BIN" enable-channel --buffer-ownership=user -u "$channel_name" -s "$sess_name" --output mmap --overwrite >/dev/null 2>&1
	ok $? "Enable channel $channel_name per UID for session $sess_name"
}

function test_ust_per_uid_local_snapshot ()
{
	NR_ITER=-1
	NR_USEC_WAIT=100
	diag "Test per-uid local UST snapshots"
	create_lttng_session_no_output "$SESSION_NAME"
	enable_channel_per_uid_mmap_overwrite "$SESSION_NAME" $CHANNEL_NAME
	enable_ust_lttng_event_ok "$SESSION_NAME" $EVENT_NAME $CHANNEL_NAME
	start_lttng_tracing_ok "$SESSION_NAME"
	lttng_snapshot_add_output_ok "$SESSION_NAME" "file://$TRACE_PATH"

	# Returns once the application has at least fired ONE tracepoint.
	start_test_app

	lttng_snapshot_record "$SESSION_NAME"
	stop_lttng_tracing_ok "$SESSION_NAME"
	destroy_lttng_session_ok "$SESSION_NAME"

	# Validate test
	validate_trace_path_ust_uid_snapshot "$TRACE_PATH" "" "snapshot-1" 0
	if validate_trace $EVENT_NAME "$TRACE_PATH/" ; then
		# Only delete if successful
		rm -rf "${TRACE_PATH:?}/"
	fi

	stop_test_apps
}

function test_ust_per_uid_local_snapshot_post_mortem ()
{
	NR_ITER=-1
	NR_USEC_WAIT=100

	diag "Test local UST snapshots post-mortem"
	create_lttng_session_no_output "$SESSION_NAME"
	enable_channel_per_uid_mmap_overwrite "$SESSION_NAME" $CHANNEL_NAME
	enable_ust_lttng_event_ok "$SESSION_NAME" $EVENT_NAME $CHANNEL_NAME
	start_lttng_tracing_ok "$SESSION_NAME"
	lttng_snapshot_add_output_ok "$SESSION_NAME" "file://$TRACE_PATH"

	# Returns once the application has at least fired ONE tracepoint.
	start_test_app
	stop_test_apps

	lttng_snapshot_record "$SESSION_NAME"
	stop_lttng_tracing_ok "$SESSION_NAME"
	destroy_lttng_session_ok "$SESSION_NAME"

	# Validate test
	validate_trace_path_ust_uid_snapshot "$TRACE_PATH" "" "snapshot-1" 0
	if validate_trace $EVENT_NAME "$TRACE_PATH/" ; then
		# Only delete if successful
		rm -rf "${TRACE_PATH:?}/"
	fi
}

function test_ust_local_snapshots ()
{
	NR_ITER=-1
	NR_USEC_WAIT=100

	diag "Test $NR_SNAPSHOT local UST snapshots"
	create_lttng_session_no_output "$SESSION_NAME"
	enable_lttng_mmap_overwrite_ust_channel "$SESSION_NAME" $CHANNEL_NAME
	enable_ust_lttng_event_ok "$SESSION_NAME" $EVENT_NAME $CHANNEL_NAME
	start_lttng_tracing_ok "$SESSION_NAME"
	lttng_snapshot_add_output_ok "$SESSION_NAME" "file://$TRACE_PATH"

	# Returns once the application has at least fired ONE tracepoint.
	start_test_app

	for i in $(seq 1 "$NR_SNAPSHOT"); do
		diag "Snapshot $i/$NR_SNAPSHOT"
		rm -rf "$TRACE_PATH/snapshot/*" 2>/dev/null
		lttng_snapshot_record "$SESSION_NAME"
		# Validate test
		validate_trace_path_ust_uid_snapshot "$TRACE_PATH" "" "snapshot-1" $((i - 1))
		if validate_trace $EVENT_NAME "$TRACE_PATH/" ; then
			# Only delete if successful
			rm -rf "${TRACE_PATH:?}/"
		fi
	done
	stop_lttng_tracing_ok "$SESSION_NAME"
	destroy_lttng_session_ok "$SESSION_NAME"

	stop_test_apps
}

function test_ust_local_snapshot_consecutive_no_new_events_discard
{
	NR_ITER=10000
	NR_USEC_WAIT=0

	# When a flush with SWITCH_FLUSH forces delivery of a packet even if it
	# contains no events, this test should fail. The number of iterations should
	# exceed the number of sub-buffers for the channel.
	diag "Test local UST snapshots with consecutive snapshots and no new events on a discard channel"
	create_lttng_session_no_output "$SESSION_NAME"
	enable_mmap_small_discard_ust_channel "$SESSION_NAME" $CHANNEL_NAME
	enable_ust_lttng_event_ok "$SESSION_NAME" $EVENT_NAME $CHANNEL_NAME
	start_lttng_tracing_ok "$SESSION_NAME"
	lttng_snapshot_add_output_ok "$SESSION_NAME" "file://$TRACE_PATH"

	start_test_app
	wait_test_apps
	FIRST_LINES=()
	COUNTS=()
	for i in $(seq 0 4); do
		# Take first snapshot, remember first line.
		lttng_snapshot_record "$SESSION_NAME"
		FIRST_LINES+=("$(trace_first_line "$TRACE_PATH/")")
		COUNTS+=("$($BABELTRACE_BIN "${TRACE_PATH}" | grep -c "${EVENT_NAME}")")
		rm -rf "${TRACE_PATH:?}/"
	done
	for x in $(seq 1 3); do
		[[ "${FIRST_LINES[0]}" == "${FIRST_LINES[${x}]}" ]]
		ok "${?}" "First lines of snapshot 0 and ${x} match"
		[[ "${COUNTS[0]}" == "${COUNTS[${x}]}" ]]
		ok "${?}" "Event counts in snapshot 0 and ${x} match"
	done

	stop_lttng_tracing_ok "$SESSION_NAME"
	destroy_lttng_session_ok "$SESSION_NAME"
}

function test_ust_local_snapshot_consecutive_no_new_events_overwrite
{
	NR_ITER=10000
	NR_USEC_WAIT=0

	# When a flush with SWITCH_FLUSH forces delivery of a packet even if it
	# contains no events, this test should fail. The number of iterations should
	# exceed the number of sub-buffers for the channel.
	diag "Test local UST snapshots with consecutive snapshots and no new events on an overwrite channel"
	create_lttng_session_no_output "$SESSION_NAME"
	enable_mmap_small_overwrite_ust_channel "$SESSION_NAME" $CHANNEL_NAME
	enable_ust_lttng_event_ok "$SESSION_NAME" $EVENT_NAME $CHANNEL_NAME
	start_lttng_tracing_ok "$SESSION_NAME"
	lttng_snapshot_add_output_ok "$SESSION_NAME" "file://$TRACE_PATH"

	start_test_app
	wait_test_apps
	FIRST_LINES=()
	COUNTS=()
	for i in $(seq 1 10); do
		# Take first snapshot, remember first line.
		lttng_snapshot_record "$SESSION_NAME"
		FIRST_LINES+=("$(trace_first_line "$TRACE_PATH/")")
		COUNTS+=("$($BABELTRACE_BIN "${TRACE_PATH}" | grep -c "${EVENT_NAME}")")
		rm -rf "${TRACE_PATH:?}/"
	done
	for x in $(seq 1 9); do
		[[ "${FIRST_LINES[0]}" == "${FIRST_LINES[${x}]}" ]]
		ok "${?}" "First line of snapshot 0 and ${x} match"
		[[ "${COUNTS[0]}" == "${COUNTS[${x}]}" ]]
		ok "${?}" "Event counts in snapshot 0 and ${x} match"
	done

	stop_lttng_tracing_ok "$SESSION_NAME"
	destroy_lttng_session_ok "$SESSION_NAME"
}

function test_ust_local_snapshot_duplicate_seq_num
{
	NR_ITER=5
	NR_USEC_WAIT=0
	TESTAPP_ITER_WAIT_FILE="$(mktemp -t "tmp.${FUNCNAME[0]}_tmp_file.XXXXXX")"

	local CPU_A=""
	local CPU_B=""
	local IS_X86_64=""
	local XXD="$(command -v xxd)"
	local TEST_SEQNUM=""
	local OLDCPUSET="$(taskset -p $$)"
	local PAGE_SIZE="$(getconf PAGE_SIZE)"
	if file $(command -v bash) | grep -q '64-bit' && uname -a | grep -q 'x86_64' ; then
		IS_X86_64="1"
	fi

	if [[ "${IS_X86_64}" && "${XXD}" ]] ; then
		TEST_SEQNUM="1"
	fi

	for CPU in $(get_online_cpus) ; do
		if [ -z "${CPU_A}" ] ; then
			CPU_A="${CPU}"
			continue
		fi
		if [ -z "${CPU_B}" ] ; then
			CPU_B="${CPU}"
		fi
	done
	if [[ "${CPU_A}" == "${CPU_B}" ]] || [ -z "${CPU_B}" ] ; then
		# todo
		skip 0 "Need at least two online CPUs to have a quiet channel for testing" 42
	fi

	diag "Test local UST snapshots that should contain packets with duplicate sequence numbers"
	taskset -cp "${CPU_A}" $$ 1>/dev/null 2>&1
	ok $? "Set current process CPU affinity"
	create_lttng_session_no_output "$SESSION_NAME"
	enable_lttng_mmap_overwrite_ust_channel "$SESSION_NAME" $CHANNEL_NAME
	enable_ust_lttng_event_ok "$SESSION_NAME" $EVENT_NAME $CHANNEL_NAME
	start_lttng_tracing_ok "$SESSION_NAME"
	lttng_snapshot_add_output_ok "$SESSION_NAME" "file://$TRACE_PATH"

	# This will produce a set of snapshots.
	# For the cpu that is currently active, the snapshots will contain the following:
	#  snapchan_0: events in one or more packets, possibly with a terminal packet
	#  snapchan_1 to snapchan_N: 1 event in 1 packet + terminal packet
	start_test_app
	for i in $(seq 0 3) ; do
		touch "${TESTAPP_ITER_WAIT_FILE}"
		# Wait until file disappears
		while [ -f "${TESTAPP_ITER_WAIT_FILE}" ] ; do
			sleep 0.1
		done
		lttng_snapshot_record "${SESSION_NAME}"
	done
	rm "${TESTAPP_ITER_WAIT_FILE}"

	lttng_snapshot_record "${SESSION_NAME}"

	stop_lttng_tracing_ok "$SESSION_NAME"
	destroy_lttng_session_ok "$SESSION_NAME"

	# Validate test
	validate_trace_path_ust_uid_snapshot "$TRACE_PATH" "" "snapshot-1" 0
	if validate_trace $EVENT_NAME "$TRACE_PATH/" ; then
		CPU_A_FILES=()
		while read -r f ; do
			CPU_A_FILES+=("${f}")
		done < <(find "${TRACE_PATH}" -iname "snapchan_${CPU_A}" | sort)

		CPU_B_FILES=()
		while read -r f ; do
			CPU_B_FILES+=("${f}")
		done < <(find "${TRACE_PATH}" -iname "snapchan_${CPU_B}" | sort)

		for i in $(seq 0 3); do
			A_SIZE="$(du -b "${CPU_A_FILES[${i}]}" | cut -f1)"
			B_SIZE="$(du -b "${CPU_B_FILES[${i}]}" | cut -f1)"
			if [[ "${TEST_SEQNUM}" ]] ; then
				SEQNUM_A1="$(xxd -g 0 -s 0x40 -l 8 "${CPU_A_FILES[${i}]}" | cut -d' ' -f2)"
				SEQNUM_A2="$(xxd -g 0 -s $((0x40 + PAGE_SIZE)) -l 8 "${CPU_A_FILES[${i}]}" | cut -d' ' -f2)"
				SEQNUM_B1="$(xxd -g 0 -s 0x40 -l 8 "${CPU_B_FILES[${i}]}" | cut -d' ' -f2)"
				SEQNUM_B2="$(xxd -g 0 -s $((0x40 + PAGE_SIZE)) -l 8 "${CPU_B_FILES[${i}]}" | cut -d' ' -f2)"
			fi

			diag "Snapshot #${i}"
			if [[ "${i}" == "0" ]] ;then
				# On the first iteration, the snapshot on the channel
				# for CPU should have just a single packet
				[[ "${A_SIZE}" -eq "$((PAGE_SIZE))" ]]
				ok $? "CPU_A stream file is one packet large"
				[[ "${B_SIZE}" -eq "$((PAGE_SIZE))" ]]
				ok $? "CPU_B stream file is one packet large"
				if [[ "${TEST_SEQNUM}" ]] ; then
					[[ "${SEQNUM_A1}" == "0000000000000000" ]]
					ok $? "First packet of CPU_A stream file has sequence number 0"
					[[ "${SEQNUM_A2}" == "" ]]
					ok $? "There is no second packet sequence number for CPU_A stream file"
					[[ "${SEQNUM_B1}" == "0000000000000000" ]]
					ok $? "First packet of CPU_B stream file has sequence number 0"
					[[ "${SEQNUM_B2}" == "" ]]
					ok $? "There is no second packet sequence number for CPU_B stream file"
				else
				   skip 0 "Sequence number testing not available" 4
				fi
			else
				# On subsequent iterations, the terminal packet
				# should be present, so there will be 2 packets.
				[[ "${A_SIZE}" -ge "$((PAGE_SIZE))" ]]
				ok $? "CPU_A stream file is greater or equal to one packet large"
				[[ "${B_SIZE}" -eq "$((PAGE_SIZE * 2 ))" ]]
				ok $? "CPU_B stream file is two packets large"
				if [[ "${TEST_SEQNUM}" ]] ; then
					[[ "${SEQNUM_A1}" == "0000000000000000" ]]
					ok $? "First packet of CPU_A stream file has sequence number 0"
					[[ "${SEQNUM_A2}" == "0100000000000000" ]]
					ok $? "Second packet of CPU_A stream file has sequence number 1"
					[[ "${SEQNUM_B1}" == "0000000000000000" ]]
					ok $? "First packet of CPU_B stream file has sequence number 0"
					[[ "${SEQNUM_B2}" == "0100000000000000" ]]
					ok $? "Second packet of CPU_B stream file has sequence number 1"
				else
				   skip 0 "Sequence number testing not available" 4
				fi
			fi
		done

		rm -rf "${TRACE_PATH:?}/"
	else
		skip 0 "Need a valid trace" 24
	fi

	stop_test_apps
	taskset -p "$OLDCPUSET" $$ 1>/dev/null 2>&1
}

plan_tests $NUM_TESTS

print_test_banner "$TEST_DESC"

bail_out_if_no_babeltrace

# shellcheck disable=SC2119
start_lttng_sessiond
tests=(
	test_ust_list_output
	test_ust_local_snapshot
	test_ust_local_snapshot_max_size
	test_ust_per_uid_local_snapshot
	test_ust_per_uid_local_snapshot_post_mortem
	test_ust_local_snapshot_large_metadata
	test_ust_local_snapshots
	test_ust_local_snapshot_small_discard_buffers
	test_ust_local_snapshot_small_overwrite_buffers
	test_ust_local_snapshot_consecutive_no_new_events_discard
	test_ust_local_snapshot_consecutive_no_new_events_overwrite
	test_ust_local_snapshot_duplicate_seq_num
)

for fct_test in "${tests[@]}";
do
	SESSION_NAME=$(randstring 16 0)
	${fct_test}
done

# shellcheck disable=SC2119
stop_lttng_sessiond