# 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