path: root/tools/testing/selftests/net/forwarding/sch_red.sh

# SPDX-License-Identifier: GPL-2.0

# This test sends one stream of traffic from H1 through a TBF shaper, to a RED
# within TBF shaper on $swp3. The two shapers have the same configuration, and
# thus the resulting stream should fill all available bandwidth on the latter
# shaper. A second stream is sent from H2 also via $swp3, and used to inject
# additional traffic. Since all available bandwidth is taken, this traffic has
# to go to backlog.
#
# +--------------------------+                     +--------------------------+
# | H1                       |                     | H2                       |
# |     + $h1                |                     |     + $h2                |
# |     | 192.0.2.1/28       |                     |     | 192.0.2.2/28       |
# |     | TBF 10Mbps         |                     |     |                    |
# +-----|--------------------+                     +-----|--------------------+
#       |                                                |
# +-----|------------------------------------------------|--------------------+
# | SW  |                                                |                    |
# |  +--|------------------------------------------------|----------------+   |
# |  |  + $swp1                                          + $swp2          |   |
# |  |                               BR                                   |   |
# |  |                                                                    |   |
# |  |                                + $swp3                             |   |
# |  |                                | TBF 10Mbps / RED                  |   |
# |  +--------------------------------|-----------------------------------+   |
# |                                   |                                       |
# +-----------------------------------|---------------------------------------+
#                                     |
#                               +-----|--------------------+
#			        | H3  |                    |
#			        |     + $h1                |
#			        |       192.0.2.3/28       |
#			        |                          |
#			        +--------------------------+

ALL_TESTS="
	ping_ipv4
	ecn_test
	ecn_nodrop_test
	red_test
	red_qevent_test
	ecn_qevent_test
"

NUM_NETIFS=6
CHECK_TC="yes"
source lib.sh

BACKLOG=30000
PKTSZ=1400

h1_create()
{
	simple_if_init $h1 192.0.2.1/28
	mtu_set $h1 10000
	tc qdisc replace dev $h1 root handle 1: tbf \
	   rate 10Mbit burst 10K limit 1M
}

h1_destroy()
{
	tc qdisc del dev $h1 root
	mtu_restore $h1
	simple_if_fini $h1 192.0.2.1/28
}

h2_create()
{
	simple_if_init $h2 192.0.2.2/28
	mtu_set $h2 10000
}

h2_destroy()
{
	mtu_restore $h2
	simple_if_fini $h2 192.0.2.2/28
}

h3_create()
{
	simple_if_init $h3 192.0.2.3/28
	mtu_set $h3 10000
}

h3_destroy()
{
	mtu_restore $h3
	simple_if_fini $h3 192.0.2.3/28
}

switch_create()
{
	ip link add dev br up type bridge
	ip link set dev $swp1 up master br
	ip link set dev $swp2 up master br
	ip link set dev $swp3 up master br

	mtu_set $swp1 10000
	mtu_set $swp2 10000
	mtu_set $swp3 10000

	tc qdisc replace dev $swp3 root handle 1: tbf \
	   rate 10Mbit burst 10K limit 1M
	ip link add name _drop_test up type dummy
}

switch_destroy()
{
	ip link del dev _drop_test
	tc qdisc del dev $swp3 root

	mtu_restore $h3
	mtu_restore $h2
	mtu_restore $h1

	ip link set dev $swp3 down nomaster
	ip link set dev $swp2 down nomaster
	ip link set dev $swp1 down nomaster
	ip link del dev br
}

setup_prepare()
{
	h1=${NETIFS[p1]}
	swp1=${NETIFS[p2]}

	h2=${NETIFS[p3]}
	swp2=${NETIFS[p4]}

	swp3=${NETIFS[p5]}
	h3=${NETIFS[p6]}

	h3_mac=$(mac_get $h3)

	vrf_prepare

	h1_create
	h2_create
	h3_create
	switch_create
}

cleanup()
{
	pre_cleanup

	switch_destroy
	h3_destroy
	h2_destroy
	h1_destroy

	vrf_cleanup
}

ping_ipv4()
{
	ping_test $h1 192.0.2.3 " from host 1"
	ping_test $h2 192.0.2.3 " from host 2"
}

get_qdisc_backlog()
{
	qdisc_stats_get $swp3 11: .backlog
}

get_nmarked()
{
	qdisc_stats_get $swp3 11: .marked
}

get_qdisc_npackets()
{
	qdisc_stats_get $swp3 11: .packets
}

get_nmirrored()
{
	link_stats_get _drop_test tx packets
}

send_packets()
{
	local proto=$1; shift
	local pkts=$1; shift

	$MZ $h2 -p $PKTSZ -a own -b $h3_mac -A 192.0.2.2 -B 192.0.2.3 -t $proto -q -c $pkts "$@"
}

# This sends traffic in an attempt to build a backlog of $size. Returns 0 on
# success. After 10 failed attempts it bails out and returns 1. It dumps the
# backlog size to stdout.
build_backlog()
{
	local size=$1; shift
	local proto=$1; shift

	local i=0

	while :; do
		local cur=$(get_qdisc_backlog)
		local diff=$((size - cur))
		local pkts=$(((diff + PKTSZ - 1) / PKTSZ))

		if ((cur >= size)); then
			echo $cur
			return 0
		elif ((i++ > 10)); then
			echo $cur
			return 1
		fi

		send_packets $proto $pkts "$@"
		sleep 1
	done
}

check_marking()
{
	local cond=$1; shift

	local npackets_0=$(get_qdisc_npackets)
	local nmarked_0=$(get_nmarked)
	sleep 5
	local npackets_1=$(get_qdisc_npackets)
	local nmarked_1=$(get_nmarked)

	local nmarked_d=$((nmarked_1 - nmarked_0))
	local npackets_d=$((npackets_1 - npackets_0))
	local pct=$((100 * nmarked_d / npackets_d))

	echo $pct
	((pct $cond))
}

check_mirroring()
{
	local cond=$1; shift

	local npackets_0=$(get_qdisc_npackets)
	local nmirrored_0=$(get_nmirrored)
	sleep 5
	local npackets_1=$(get_qdisc_npackets)
	local nmirrored_1=$(get_nmirrored)

	local nmirrored_d=$((nmirrored_1 - nmirrored_0))
	local npackets_d=$((npackets_1 - npackets_0))
	local pct=$((100 * nmirrored_d / npackets_d))

	echo $pct
	((pct $cond))
}

ecn_test_common()
{
	local name=$1; shift
	local limit=$1; shift
	local backlog
	local pct

	# Build the below-the-limit backlog using UDP. We could use TCP just
	# fine, but this way we get a proof that UDP is accepted when queue
	# length is below the limit. The main stream is using TCP, and if the
	# limit is misconfigured, we would see this traffic being ECN marked.
	RET=0
	backlog=$(build_backlog $((2 * limit / 3)) udp)
	check_err $? "Could not build the requested backlog"
	pct=$(check_marking "== 0")
	check_err $? "backlog $backlog / $limit Got $pct% marked packets, expected == 0."
	log_test "$name backlog < limit"

	# Now push TCP, because non-TCP traffic would be early-dropped after the
	# backlog crosses the limit, and we want to make sure that the backlog
	# is above the limit.
	RET=0
	backlog=$(build_backlog $((3 * limit / 2)) tcp tos=0x01)
	check_err $? "Could not build the requested backlog"
	pct=$(check_marking ">= 95")
	check_err $? "backlog $backlog / $limit Got $pct% marked packets, expected >= 95."
	log_test "$name backlog > limit"
}

do_ecn_test()
{
	local limit=$1; shift
	local name=ECN

	$MZ $h1 -p $PKTSZ -A 192.0.2.1 -B 192.0.2.3 -c 0 \
		-a own -b $h3_mac -t tcp -q tos=0x01 &
	sleep 1

	ecn_test_common "$name" $limit

	# Up there we saw that UDP gets accepted when backlog is below the
	# limit. Now that it is above, it should all get dropped, and backlog
	# building should fail.
	RET=0
	build_backlog $((2 * limit)) udp >/dev/null
	check_fail $? "UDP traffic went into backlog instead of being early-dropped"
	log_test "$name backlog > limit: UDP early-dropped"

	stop_traffic
	sleep 1
}

do_ecn_nodrop_test()
{
	local limit=$1; shift
	local name="ECN nodrop"

	$MZ $h1 -p $PKTSZ -A 192.0.2.1 -B 192.0.2.3 -c 0 \
		-a own -b $h3_mac -t tcp -q tos=0x01 &
	sleep 1

	ecn_test_common "$name" $limit

	# Up there we saw that UDP gets accepted when backlog is below the
	# limit. Now that it is above, in nodrop mode, make sure it goes to
	# backlog as well.
	RET=0
	build_backlog $((2 * limit)) udp >/dev/null
	check_err $? "UDP traffic was early-dropped instead of getting into backlog"
	log_test "$name backlog > limit: UDP not dropped"

	stop_traffic
	sleep 1
}

do_red_test()
{
	local limit=$1; shift
	local backlog
	local pct

	# Use ECN-capable TCP to verify there's no marking even though the queue
	# is above limit.
	$MZ $h1 -p $PKTSZ -A 192.0.2.1 -B 192.0.2.3 -c 0 \
		-a own -b $h3_mac -t tcp -q tos=0x01 &

	# Pushing below the queue limit should work.
	RET=0
	backlog=$(build_backlog $((2 * limit / 3)) tcp tos=0x01)
	check_err $? "Could not build the requested backlog"
	pct=$(check_marking "== 0")
	check_err $? "backlog $backlog / $limit Got $pct% marked packets, expected == 0."
	log_test "RED backlog < limit"

	# Pushing above should not.
	RET=0
	backlog=$(build_backlog $((3 * limit / 2)) tcp tos=0x01)
	check_fail $? "Traffic went into backlog instead of being early-dropped"
	pct=$(check_marking "== 0")
	check_err $? "backlog $backlog / $limit Got $pct% marked packets, expected == 0."
	log_test "RED backlog > limit"

	stop_traffic
	sleep 1
}

do_red_qevent_test()
{
	local limit=$1; shift
	local backlog
	local base
	local now
	local pct

	RET=0

	$MZ $h1 -p $PKTSZ -A 192.0.2.1 -B 192.0.2.3 -c 0 \
		-a own -b $h3_mac -t udp -q &
	sleep 1

	tc filter add block 10 pref 1234 handle 102 matchall skip_hw \
	   action mirred egress mirror dev _drop_test

	# Push to the queue until it's at the limit. The configured limit is
	# rounded by the qdisc, so this is the best we can do to get to the real
	# limit.
	build_backlog $((3 * limit / 2)) udp >/dev/null

	base=$(get_nmirrored)
	send_packets udp 100
	sleep 1
	now=$(get_nmirrored)
	((now >= base + 100))
	check_err $? "Dropped packets not observed: 100 expected, $((now - base)) seen"

	tc filter del block 10 pref 1234 handle 102 matchall

	base=$(get_nmirrored)
	send_packets udp 100
	sleep 1
	now=$(get_nmirrored)
	((now == base))
	check_err $? "Dropped packets still observed: 0 expected, $((now - base)) seen"

	log_test "RED early_dropped packets mirrored"

	stop_traffic
	sleep 1
}

do_ecn_qevent_test()
{
	local limit=$1; shift
	local name=ECN

	RET=0

	$MZ $h1 -p $PKTSZ -A 192.0.2.1 -B 192.0.2.3 -c 0 \
		-a own -b $h3_mac -t tcp -q tos=0x01 &
	sleep 1

	tc filter add block 10 pref 1234 handle 102 matchall skip_hw \
	   action mirred egress mirror dev _drop_test

	backlog=$(build_backlog $((2 * limit / 3)) tcp tos=0x01)
	check_err $? "Could not build the requested backlog"
	pct=$(check_mirroring "== 0")
	check_err $? "backlog $backlog / $limit Got $pct% mirrored packets, expected == 0."

	backlog=$(build_backlog $((3 * limit / 2)) tcp tos=0x01)
	check_err $? "Could not build the requested backlog"
	pct=$(check_mirroring ">= 95")
	check_err $? "backlog $backlog / $limit Got $pct% mirrored packets, expected >= 95."

	tc filter del block 10 pref 1234 handle 102 matchall

	log_test "ECN marked packets mirrored"

	stop_traffic
	sleep 1
}

install_qdisc()
{
	local -a args=("$@")

	tc qdisc replace dev $swp3 parent 1:1 handle 11: red \
	   limit 1M avpkt $PKTSZ probability 1 \
	   min $BACKLOG max $((BACKLOG + 1)) burst 38 "${args[@]}"
	sleep 1
}

uninstall_qdisc()
{
	tc qdisc del dev $swp3 parent 1:1
}

ecn_test()
{
	install_qdisc ecn
	do_ecn_test $BACKLOG
	uninstall_qdisc
}

ecn_nodrop_test()
{
	install_qdisc ecn nodrop
	do_ecn_nodrop_test $BACKLOG
	uninstall_qdisc
}

red_test()
{
	install_qdisc
	do_red_test $BACKLOG
	uninstall_qdisc
}

red_qevent_test()
{
	install_qdisc qevent early_drop block 10
	do_red_qevent_test $BACKLOG
	uninstall_qdisc
}

ecn_qevent_test()
{
	install_qdisc ecn qevent mark block 10
	do_ecn_qevent_test $BACKLOG
	uninstall_qdisc
}

trap cleanup EXIT

setup_prepare
setup_wait

tests_run

exit $EXIT_STATUS