tools/testing/selftests/net/forwarding/tc_taprio.sh - linux - Git at Google

 #!/bin/bash
 # SPDX-License-Identifier: GPL-2.0

 ALL_TESTS=" \
 	test_clock_jump_backward \
 	test_taprio_after_ptp \
 	test_max_sdu \
 	test_clock_jump_backward_forward \
 "
 NUM_NETIFS=4
 source tc_common.sh
 source lib.sh
 source tsn_lib.sh

 require_command python3

 # The test assumes the usual topology from the README, where h1 is connected to
 # swp1, h2 to swp2, and swp1 and swp2 are together in a bridge.
 # Additional assumption: h1 and h2 use the same PHC, and so do swp1 and swp2.
 # By synchronizing h1 to swp1 via PTP, h2 is also implicitly synchronized to
 # swp1 (and both to CLOCK_REALTIME).
 h1=${NETIFS[p1]}
 swp1=${NETIFS[p2]}
 swp2=${NETIFS[p3]}
 h2=${NETIFS[p4]}

 UDS_ADDRESS_H1="/var/run/ptp4l_h1"
 UDS_ADDRESS_SWP1="/var/run/ptp4l_swp1"

 H1_IPV4="192.0.2.1"
 H2_IPV4="192.0.2.2"
 H1_IPV6="2001:db8:1::1"
 H2_IPV6="2001:db8:1::2"

 # Tunables
 NUM_PKTS=100
 STREAM_VID=10
 STREAM_PRIO_1=6
 STREAM_PRIO_2=5
 STREAM_PRIO_3=4
 # PTP uses TC 0
 ALL_GATES=$((1 << 0 | 1 << STREAM_PRIO_1 | 1 << STREAM_PRIO_2))
 # Use a conservative cycle of 10 ms to allow the test to still pass when the
 # kernel has some extra overhead like lockdep etc
 CYCLE_TIME_NS=10000000
 # Create two Gate Control List entries, one OPEN and one CLOSE, of equal
 # durations
 GATE_DURATION_NS=$((CYCLE_TIME_NS / 2))
 # Give 2/3 of the cycle time to user space and 1/3 to the kernel
 FUDGE_FACTOR=$((CYCLE_TIME_NS / 3))
 # Shift the isochron base time by half the gate time, so that packets are
 # always received by swp1 close to the middle of the time slot, to minimize
 # inaccuracies due to network sync
 SHIFT_TIME_NS=$((GATE_DURATION_NS / 2))

 path_delay=

 h1_create()
 {
 	simple_if_init $h1 $H1_IPV4/24 $H1_IPV6/64
 }

 h1_destroy()
 {
 	simple_if_fini $h1 $H1_IPV4/24 $H1_IPV6/64
 }

 h2_create()
 {
 	simple_if_init $h2 $H2_IPV4/24 $H2_IPV6/64
 }

 h2_destroy()
 {
 	simple_if_fini $h2 $H2_IPV4/24 $H2_IPV6/64
 }

 switch_create()
 {
 	local h2_mac_addr=$(mac_get $h2)

 	ip link set $swp1 up
 	ip link set $swp2 up

 	ip link add br0 type bridge vlan_filtering 1
 	ip link set $swp1 master br0
 	ip link set $swp2 master br0
 	ip link set br0 up

 	bridge vlan add dev $swp2 vid $STREAM_VID
 	bridge vlan add dev $swp1 vid $STREAM_VID
 	bridge fdb add dev $swp2 \
 		$h2_mac_addr vlan $STREAM_VID static master
 }

 switch_destroy()
 {
 	ip link del br0
 }

 ptp_setup()
 {
 	# Set up swp1 as a master PHC for h1, synchronized to the local
 	# CLOCK_REALTIME.
 	phc2sys_start $UDS_ADDRESS_SWP1
 	ptp4l_start $h1 true $UDS_ADDRESS_H1
 	ptp4l_start $swp1 false $UDS_ADDRESS_SWP1
 }

 ptp_cleanup()
 {
 	ptp4l_stop $swp1
 	ptp4l_stop $h1
 	phc2sys_stop
 }

 txtime_setup()
 {
 	local if_name=$1

 	tc qdisc add dev $if_name clsact
 	# Classify PTP on TC 7 and isochron on TC 6
 	tc filter add dev $if_name egress protocol 0x88f7 \
 		flower action skbedit priority 7
 	tc filter add dev $if_name egress protocol 802.1Q \
 		flower vlan_ethtype 0xdead action skbedit priority 6
 	tc qdisc add dev $if_name handle 100: parent root mqprio num_tc 8 \
 		queues 1@0 1@1 1@2 1@3 1@4 1@5 1@6 1@7 \
 		map 0 1 2 3 4 5 6 7 \
 		hw 1
 	# Set up TC 5, 6, 7 for SO_TXTIME. tc-mqprio queues count from 1.
 	tc qdisc replace dev $if_name parent 100:$((STREAM_PRIO_1 + 1)) etf \
 		clockid CLOCK_TAI offload delta $FUDGE_FACTOR
 	tc qdisc replace dev $if_name parent 100:$((STREAM_PRIO_2 + 1)) etf \
 		clockid CLOCK_TAI offload delta $FUDGE_FACTOR
 	tc qdisc replace dev $if_name parent 100:$((STREAM_PRIO_3 + 1)) etf \
 		clockid CLOCK_TAI offload delta $FUDGE_FACTOR
 }

 txtime_cleanup()
 {
 	local if_name=$1

 	tc qdisc del dev $if_name clsact
 	tc qdisc del dev $if_name root
 }

 taprio_replace()
 {
 	local if_name="$1"; shift
 	local extra_args="$1"; shift

 	# STREAM_PRIO_1 always has an open gate.
 	# STREAM_PRIO_2 has a gate open for GATE_DURATION_NS (half the cycle time)
 	# STREAM_PRIO_3 always has a closed gate.
 	tc qdisc replace dev $if_name root stab overhead 24 taprio num_tc 8 \
 		queues 1@0 1@1 1@2 1@3 1@4 1@5 1@6 1@7 \
 		map 0 1 2 3 4 5 6 7 \
 		sched-entry S $(printf "%x" $ALL_GATES) $GATE_DURATION_NS \
 		sched-entry S $(printf "%x" $((ALL_GATES & ~(1 << STREAM_PRIO_2)))) $GATE_DURATION_NS \
 		base-time 0 flags 0x2 $extra_args
 	taprio_wait_for_admin $if_name
 }

 taprio_cleanup()
 {
 	local if_name=$1

 	tc qdisc del dev $if_name root
 }

 probe_path_delay()
 {
 	local isochron_dat="$(mktemp)"
 	local received

 	log_info "Probing path delay"

 	isochron_do "$h1" "$h2" "$UDS_ADDRESS_H1" "" 0 \
 		"$CYCLE_TIME_NS" "" "" "$NUM_PKTS" \
 		"$STREAM_VID" "$STREAM_PRIO_1" "" "$isochron_dat"

 	received=$(isochron_report_num_received "$isochron_dat")
 	if [ "$received" != "$NUM_PKTS" ]; then
 		echo "Cannot establish basic data path between $h1 and $h2"
 		exit $ksft_fail
 	fi

 	printf "pdelay = {}\n" > isochron_data.py
 	isochron report --input-file "$isochron_dat" \
 		--printf-format "pdelay[%u] = %d - %d\n" \
 		--printf-args "qRT" \
 		>> isochron_data.py
 	cat <<-'EOF' > isochron_postprocess.py
 	#!/usr/bin/env python3

 	from isochron_data import pdelay
 	import numpy as np

 	w = np.array(list(pdelay.values()))
 	print("{}".format(np.max(w)))
 	EOF
 	path_delay=$(python3 ./isochron_postprocess.py)

 	log_info "Path delay from $h1 to $h2 estimated at $path_delay ns"

 	if [ "$path_delay" -gt "$GATE_DURATION_NS" ]; then
 		echo "Path delay larger than gate duration, aborting"
 		exit $ksft_fail
 	fi

 	rm -f ./isochron_data.py 2> /dev/null
 	rm -f ./isochron_postprocess.py 2> /dev/null
 	rm -f "$isochron_dat" 2> /dev/null
 }

 setup_prepare()
 {
 	vrf_prepare

 	h1_create
 	h2_create
 	switch_create

 	txtime_setup $h1

 	# Temporarily set up PTP just to probe the end-to-end path delay.
 	ptp_setup
 	probe_path_delay
 	ptp_cleanup
 }

 cleanup()
 {
 	pre_cleanup

 	isochron_recv_stop
 	txtime_cleanup $h1

 	switch_destroy
 	h2_destroy
 	h1_destroy

 	vrf_cleanup
 }

 run_test()
 {
 	local base_time=$1; shift
 	local stream_prio=$1; shift
 	local expected_delay=$1; shift
 	local should_fail=$1; shift
 	local test_name=$1; shift
 	local isochron_dat="$(mktemp)"
 	local received
 	local median_delay

 	RET=0

 	# Set the shift time equal to the cycle time, which effectively
 	# cancels the default advance time. Packets won't be sent early in
 	# software, which ensures that they won't prematurely enter through
 	# the open gate in __test_out_of_band(). Also, the gate is open for
 	# long enough that this won't cause a problem in __test_in_band().
 	isochron_do "$h1" "$h2" "$UDS_ADDRESS_H1" "" "$base_time" \
 		"$CYCLE_TIME_NS" "$SHIFT_TIME_NS" "$GATE_DURATION_NS" \
 		"$NUM_PKTS" "$STREAM_VID" "$stream_prio" "" "$isochron_dat"

 	received=$(isochron_report_num_received "$isochron_dat")
 	[ "$received" = "$NUM_PKTS" ]
 	check_err_fail $should_fail $? "Reception of $NUM_PKTS packets"

 	if [ $should_fail = 0 ] && [ "$received" = "$NUM_PKTS" ]; then
 		printf "pdelay = {}\n" > isochron_data.py
 		isochron report --input-file "$isochron_dat" \
 			--printf-format "pdelay[%u] = %d - %d\n" \
 			--printf-args "qRT" \
 			>> isochron_data.py
 		cat <<-'EOF' > isochron_postprocess.py
 		#!/usr/bin/env python3

 		from isochron_data import pdelay
 		import numpy as np

 		w = np.array(list(pdelay.values()))
 		print("{}".format(int(np.median(w))))
 		EOF
 		median_delay=$(python3 ./isochron_postprocess.py)

 		# If the condition below is true, packets were delayed by a closed gate
 		[ "$median_delay" -gt $((path_delay + expected_delay)) ]
 		check_fail $? "Median delay $median_delay is greater than expected delay $expected_delay plus path delay $path_delay"

 		# If the condition below is true, packets were sent expecting them to
 		# hit a closed gate in the switch, but were not delayed
 		[ "$expected_delay" -gt 0 ] && [ "$median_delay" -lt "$expected_delay" ]
 		check_fail $? "Median delay $median_delay is less than expected delay $expected_delay"
 	fi

 	log_test "$test_name"

 	rm -f ./isochron_data.py 2> /dev/null
 	rm -f ./isochron_postprocess.py 2> /dev/null
 	rm -f "$isochron_dat" 2> /dev/null
 }

 __test_always_open()
 {
 	run_test 0.000000000 $STREAM_PRIO_1 0 0 "Gate always open"
 }

 __test_always_closed()
 {
 	run_test 0.000000000 $STREAM_PRIO_3 0 1 "Gate always closed"
 }

 __test_in_band()
 {
 	# Send packets in-band with the OPEN gate entry
 	run_test 0.000000000 $STREAM_PRIO_2 0 0 "In band with gate"
 }

 __test_out_of_band()
 {
 	# Send packets in-band with the CLOSE gate entry
 	run_test 0.005000000 $STREAM_PRIO_2 \
 		$((GATE_DURATION_NS - SHIFT_TIME_NS)) 0 \
 		"Out of band with gate"
 }

 run_subtests()
 {
 	__test_always_open
 	__test_always_closed
 	__test_in_band
 	__test_out_of_band
 }

 test_taprio_after_ptp()
 {
 	log_info "Setting up taprio after PTP"
 	ptp_setup
 	taprio_replace $swp2
 	run_subtests
 	taprio_cleanup $swp2
 	ptp_cleanup
 }

 __test_under_max_sdu()
 {
 	# Limit max-sdu for STREAM_PRIO_1
 	taprio_replace "$swp2" "max-sdu 0 0 0 0 0 0 100 0"
 	run_test 0.000000000 $STREAM_PRIO_1 0 0 "Under maximum SDU"
 }

 __test_over_max_sdu()
 {
 	# Limit max-sdu for STREAM_PRIO_1
 	taprio_replace "$swp2" "max-sdu 0 0 0 0 0 0 20 0"
 	run_test 0.000000000 $STREAM_PRIO_1 0 1 "Over maximum SDU"
 }

 test_max_sdu()
 {
 	ptp_setup
 	__test_under_max_sdu
 	__test_over_max_sdu
 	taprio_cleanup $swp2
 	ptp_cleanup
 }

 # Perform a clock jump in the past without synchronization running, so that the
 # time base remains where it was set by phc_ctl.
 test_clock_jump_backward()
 {
 	# This is a more complex schedule specifically crafted in a way that
 	# has been problematic on NXP LS1028A. Not much to test with it other
 	# than the fact that it passes traffic.
 	tc qdisc replace dev $swp2 root stab overhead 24 taprio num_tc 8 \
 		queues 1@0 1@1 1@2 1@3 1@4 1@5 1@6 1@7 map 0 1 2 3 4 5 6 7 \
 		base-time 0 sched-entry S 20 300000 sched-entry S 10 200000 \
 		sched-entry S 20 300000 sched-entry S 48 200000 \
 		sched-entry S 20 300000 sched-entry S 83 200000 \
 		sched-entry S 40 300000 sched-entry S 00 200000 flags 2

 	log_info "Forcing a backward clock jump"
 	phc_ctl $swp1 set 0

 	ping_test $h1 192.0.2.2
 	taprio_cleanup $swp2
 }

 # Test that taprio tolerates clock jumps.
 # Since ptp4l and phc2sys are running, it is expected for the time to
 # eventually recover (through yet another clock jump). Isochron waits
 # until that is the case.
 test_clock_jump_backward_forward()
 {
 	log_info "Forcing a backward and a forward clock jump"
 	taprio_replace $swp2
 	phc_ctl $swp1 set 0
 	ptp_setup
 	ping_test $h1 192.0.2.2
 	run_subtests
 	ptp_cleanup
 	taprio_cleanup $swp2
 }

 tc_offload_check
 if [[ $? -ne 0 ]]; then
 	log_test_skip "Could not test offloaded functionality"
 	exit $EXIT_STATUS
 fi

 trap cleanup EXIT

 setup_prepare
 setup_wait
 tests_run

 exit $EXIT_STATUS
	#!/bin/bash
	# SPDX-License-Identifier: GPL-2.0

	ALL_TESTS=" \
	test_clock_jump_backward \
	test_taprio_after_ptp \
	test_max_sdu \
	test_clock_jump_backward_forward \
	"
	NUM_NETIFS=4
	source tc_common.sh
	source lib.sh
	source tsn_lib.sh

	require_command python3

	# The test assumes the usual topology from the README, where h1 is connected to
	# swp1, h2 to swp2, and swp1 and swp2 are together in a bridge.
	# Additional assumption: h1 and h2 use the same PHC, and so do swp1 and swp2.
	# By synchronizing h1 to swp1 via PTP, h2 is also implicitly synchronized to
	# swp1 (and both to CLOCK_REALTIME).
	h1=${NETIFS[p1]}
	swp1=${NETIFS[p2]}
	swp2=${NETIFS[p3]}
	h2=${NETIFS[p4]}

	UDS_ADDRESS_H1="/var/run/ptp4l_h1"
	UDS_ADDRESS_SWP1="/var/run/ptp4l_swp1"

	H1_IPV4="192.0.2.1"
	H2_IPV4="192.0.2.2"
	H1_IPV6="2001:db8:1::1"
	H2_IPV6="2001:db8:1::2"

	# Tunables
	NUM_PKTS=100
	STREAM_VID=10
	STREAM_PRIO_1=6
	STREAM_PRIO_2=5
	STREAM_PRIO_3=4
	# PTP uses TC 0
	ALL_GATES=$((1 << 0 \| 1 << STREAM_PRIO_1 \| 1 << STREAM_PRIO_2))
	# Use a conservative cycle of 10 ms to allow the test to still pass when the
	# kernel has some extra overhead like lockdep etc
	CYCLE_TIME_NS=10000000
	# Create two Gate Control List entries, one OPEN and one CLOSE, of equal
	# durations
	GATE_DURATION_NS=$((CYCLE_TIME_NS / 2))
	# Give 2/3 of the cycle time to user space and 1/3 to the kernel
	FUDGE_FACTOR=$((CYCLE_TIME_NS / 3))
	# Shift the isochron base time by half the gate time, so that packets are
	# always received by swp1 close to the middle of the time slot, to minimize
	# inaccuracies due to network sync
	SHIFT_TIME_NS=$((GATE_DURATION_NS / 2))

	path_delay=

	h1_create()
	{
	simple_if_init $h1 $H1_IPV4/24 $H1_IPV6/64
	}

	h1_destroy()
	{
	simple_if_fini $h1 $H1_IPV4/24 $H1_IPV6/64
	}

	h2_create()
	{
	simple_if_init $h2 $H2_IPV4/24 $H2_IPV6/64
	}

	h2_destroy()
	{
	simple_if_fini $h2 $H2_IPV4/24 $H2_IPV6/64
	}

	switch_create()
	{
	local h2_mac_addr=$(mac_get $h2)

	ip link set $swp1 up
	ip link set $swp2 up

	ip link add br0 type bridge vlan_filtering 1
	ip link set $swp1 master br0
	ip link set $swp2 master br0
	ip link set br0 up

	bridge vlan add dev $swp2 vid $STREAM_VID
	bridge vlan add dev $swp1 vid $STREAM_VID
	bridge fdb add dev $swp2 \
	$h2_mac_addr vlan $STREAM_VID static master
	}

	switch_destroy()
	{
	ip link del br0
	}

	ptp_setup()
	{
	# Set up swp1 as a master PHC for h1, synchronized to the local
	# CLOCK_REALTIME.
	phc2sys_start $UDS_ADDRESS_SWP1
	ptp4l_start $h1 true $UDS_ADDRESS_H1
	ptp4l_start $swp1 false $UDS_ADDRESS_SWP1
	}

	ptp_cleanup()
	{
	ptp4l_stop $swp1
	ptp4l_stop $h1
	phc2sys_stop
	}

	txtime_setup()
	{
	local if_name=$1

	tc qdisc add dev $if_name clsact
	# Classify PTP on TC 7 and isochron on TC 6
	tc filter add dev $if_name egress protocol 0x88f7 \
	flower action skbedit priority 7
	tc filter add dev $if_name egress protocol 802.1Q \
	flower vlan_ethtype 0xdead action skbedit priority 6
	tc qdisc add dev $if_name handle 100: parent root mqprio num_tc 8 \
	queues 1@0 1@1 1@2 1@3 1@4 1@5 1@6 1@7 \
	map 0 1 2 3 4 5 6 7 \
	hw 1
	# Set up TC 5, 6, 7 for SO_TXTIME. tc-mqprio queues count from 1.
	tc qdisc replace dev $if_name parent 100:$((STREAM_PRIO_1 + 1)) etf \
	clockid CLOCK_TAI offload delta $FUDGE_FACTOR
	tc qdisc replace dev $if_name parent 100:$((STREAM_PRIO_2 + 1)) etf \
	clockid CLOCK_TAI offload delta $FUDGE_FACTOR
	tc qdisc replace dev $if_name parent 100:$((STREAM_PRIO_3 + 1)) etf \
	clockid CLOCK_TAI offload delta $FUDGE_FACTOR
	}

	txtime_cleanup()
	{
	local if_name=$1

	tc qdisc del dev $if_name clsact
	tc qdisc del dev $if_name root
	}

	taprio_replace()
	{
	local if_name="$1"; shift
	local extra_args="$1"; shift

	# STREAM_PRIO_1 always has an open gate.
	# STREAM_PRIO_2 has a gate open for GATE_DURATION_NS (half the cycle time)
	# STREAM_PRIO_3 always has a closed gate.
	tc qdisc replace dev $if_name root stab overhead 24 taprio num_tc 8 \
	queues 1@0 1@1 1@2 1@3 1@4 1@5 1@6 1@7 \
	map 0 1 2 3 4 5 6 7 \
	sched-entry S $(printf "%x" $ALL_GATES) $GATE_DURATION_NS \
	sched-entry S $(printf "%x" $((ALL_GATES & ~(1 << STREAM_PRIO_2)))) $GATE_DURATION_NS \
	base-time 0 flags 0x2 $extra_args
	taprio_wait_for_admin $if_name
	}

	taprio_cleanup()
	{
	local if_name=$1

	tc qdisc del dev $if_name root
	}

	probe_path_delay()
	{
	local isochron_dat="$(mktemp)"
	local received

	log_info "Probing path delay"

	isochron_do "$h1" "$h2" "$UDS_ADDRESS_H1" "" 0 \
	"$CYCLE_TIME_NS" "" "" "$NUM_PKTS" \
	"$STREAM_VID" "$STREAM_PRIO_1" "" "$isochron_dat"

	received=$(isochron_report_num_received "$isochron_dat")
	if [ "$received" != "$NUM_PKTS" ]; then
	echo "Cannot establish basic data path between $h1 and $h2"
	exit $ksft_fail
	fi

	printf "pdelay = {}\n" > isochron_data.py
	isochron report --input-file "$isochron_dat" \
	--printf-format "pdelay[%u] = %d - %d\n" \
	--printf-args "qRT" \
	>> isochron_data.py
	cat <<-'EOF' > isochron_postprocess.py
	#!/usr/bin/env python3

	from isochron_data import pdelay
	import numpy as np

	w = np.array(list(pdelay.values()))
	print("{}".format(np.max(w)))
	EOF
	path_delay=$(python3 ./isochron_postprocess.py)

	log_info "Path delay from $h1 to $h2 estimated at $path_delay ns"

	if [ "$path_delay" -gt "$GATE_DURATION_NS" ]; then
	echo "Path delay larger than gate duration, aborting"
	exit $ksft_fail
	fi

	rm -f ./isochron_data.py 2> /dev/null
	rm -f ./isochron_postprocess.py 2> /dev/null
	rm -f "$isochron_dat" 2> /dev/null
	}

	setup_prepare()
	{
	vrf_prepare

	h1_create
	h2_create
	switch_create

	txtime_setup $h1

	# Temporarily set up PTP just to probe the end-to-end path delay.
	ptp_setup
	probe_path_delay
	ptp_cleanup
	}

	cleanup()
	{
	pre_cleanup

	isochron_recv_stop
	txtime_cleanup $h1

	switch_destroy
	h2_destroy
	h1_destroy

	vrf_cleanup
	}

	run_test()
	{
	local base_time=$1; shift
	local stream_prio=$1; shift
	local expected_delay=$1; shift
	local should_fail=$1; shift
	local test_name=$1; shift
	local isochron_dat="$(mktemp)"
	local received
	local median_delay

	RET=0

	# Set the shift time equal to the cycle time, which effectively
	# cancels the default advance time. Packets won't be sent early in
	# software, which ensures that they won't prematurely enter through
	# the open gate in __test_out_of_band(). Also, the gate is open for
	# long enough that this won't cause a problem in __test_in_band().
	isochron_do "$h1" "$h2" "$UDS_ADDRESS_H1" "" "$base_time" \
	"$CYCLE_TIME_NS" "$SHIFT_TIME_NS" "$GATE_DURATION_NS" \
	"$NUM_PKTS" "$STREAM_VID" "$stream_prio" "" "$isochron_dat"

	received=$(isochron_report_num_received "$isochron_dat")
	[ "$received" = "$NUM_PKTS" ]
	check_err_fail $should_fail $? "Reception of $NUM_PKTS packets"

	if [ $should_fail = 0 ] && [ "$received" = "$NUM_PKTS" ]; then
	printf "pdelay = {}\n" > isochron_data.py
	isochron report --input-file "$isochron_dat" \
	--printf-format "pdelay[%u] = %d - %d\n" \
	--printf-args "qRT" \
	>> isochron_data.py
	cat <<-'EOF' > isochron_postprocess.py
	#!/usr/bin/env python3

	from isochron_data import pdelay
	import numpy as np

	w = np.array(list(pdelay.values()))
	print("{}".format(int(np.median(w))))
	EOF
	median_delay=$(python3 ./isochron_postprocess.py)

	# If the condition below is true, packets were delayed by a closed gate
	[ "$median_delay" -gt $((path_delay + expected_delay)) ]
	check_fail $? "Median delay $median_delay is greater than expected delay $expected_delay plus path delay $path_delay"

	# If the condition below is true, packets were sent expecting them to
	# hit a closed gate in the switch, but were not delayed
	[ "$expected_delay" -gt 0 ] && [ "$median_delay" -lt "$expected_delay" ]
	check_fail $? "Median delay $median_delay is less than expected delay $expected_delay"
	fi

	log_test "$test_name"

	rm -f ./isochron_data.py 2> /dev/null
	rm -f ./isochron_postprocess.py 2> /dev/null
	rm -f "$isochron_dat" 2> /dev/null
	}

	__test_always_open()
	{
	run_test 0.000000000 $STREAM_PRIO_1 0 0 "Gate always open"
	}

	__test_always_closed()
	{
	run_test 0.000000000 $STREAM_PRIO_3 0 1 "Gate always closed"
	}

	__test_in_band()
	{
	# Send packets in-band with the OPEN gate entry
	run_test 0.000000000 $STREAM_PRIO_2 0 0 "In band with gate"
	}

	__test_out_of_band()
	{
	# Send packets in-band with the CLOSE gate entry
	run_test 0.005000000 $STREAM_PRIO_2 \
	$((GATE_DURATION_NS - SHIFT_TIME_NS)) 0 \
	"Out of band with gate"
	}

	run_subtests()
	{
	__test_always_open
	__test_always_closed
	__test_in_band
	__test_out_of_band
	}

	test_taprio_after_ptp()
	{
	log_info "Setting up taprio after PTP"
	ptp_setup
	taprio_replace $swp2
	run_subtests
	taprio_cleanup $swp2
	ptp_cleanup
	}

	__test_under_max_sdu()
	{
	# Limit max-sdu for STREAM_PRIO_1
	taprio_replace "$swp2" "max-sdu 0 0 0 0 0 0 100 0"
	run_test 0.000000000 $STREAM_PRIO_1 0 0 "Under maximum SDU"
	}

	__test_over_max_sdu()
	{
	# Limit max-sdu for STREAM_PRIO_1
	taprio_replace "$swp2" "max-sdu 0 0 0 0 0 0 20 0"
	run_test 0.000000000 $STREAM_PRIO_1 0 1 "Over maximum SDU"
	}

	test_max_sdu()
	{
	ptp_setup
	__test_under_max_sdu
	__test_over_max_sdu
	taprio_cleanup $swp2
	ptp_cleanup
	}

	# Perform a clock jump in the past without synchronization running, so that the
	# time base remains where it was set by phc_ctl.
	test_clock_jump_backward()
	{
	# This is a more complex schedule specifically crafted in a way that
	# has been problematic on NXP LS1028A. Not much to test with it other
	# than the fact that it passes traffic.
	tc qdisc replace dev $swp2 root stab overhead 24 taprio num_tc 8 \
	queues 1@0 1@1 1@2 1@3 1@4 1@5 1@6 1@7 map 0 1 2 3 4 5 6 7 \
	base-time 0 sched-entry S 20 300000 sched-entry S 10 200000 \
	sched-entry S 20 300000 sched-entry S 48 200000 \
	sched-entry S 20 300000 sched-entry S 83 200000 \
	sched-entry S 40 300000 sched-entry S 00 200000 flags 2

	log_info "Forcing a backward clock jump"
	phc_ctl $swp1 set 0

	ping_test $h1 192.0.2.2
	taprio_cleanup $swp2
	}

	# Test that taprio tolerates clock jumps.
	# Since ptp4l and phc2sys are running, it is expected for the time to
	# eventually recover (through yet another clock jump). Isochron waits
	# until that is the case.
	test_clock_jump_backward_forward()
	{
	log_info "Forcing a backward and a forward clock jump"
	taprio_replace $swp2
	phc_ctl $swp1 set 0
	ptp_setup
	ping_test $h1 192.0.2.2
	run_subtests
	ptp_cleanup
	taprio_cleanup $swp2
	}

	tc_offload_check
	if [[ $? -ne 0 ]]; then
	log_test_skip "Could not test offloaded functionality"
	exit $EXIT_STATUS
	fi

	trap cleanup EXIT

	setup_prepare
	setup_wait
	tests_run

	exit $EXIT_STATUS