| # SPDX-License-Identifier: GPL-2.0 |
| |
| # This test sends a >1Gbps stream of traffic from H1, to the switch, which |
| # forwards it to a 1Gbps port. This 1Gbps stream is then looped back to the |
| # switch and forwarded to the port under test $swp3, which is also 1Gbps. |
| # |
| # This way, $swp3 should be 100% filled with traffic without any of it spilling |
| # to the backlog. Any extra packets sent should almost 1:1 go to backlog. That |
| # is what H2 is used for--it sends the extra traffic to create backlog. |
| # |
| # A RED Qdisc is installed on $swp3. The configuration is such that the minimum |
| # and maximum size are 1 byte apart, so there is a very clear border under which |
| # no marking or dropping takes place, and above which everything is marked or |
| # dropped. |
| # |
| # The test uses the buffer build-up behavior to test the installed RED. |
| # |
| # In order to test WRED, $swp3 actually contains RED under PRIO, with two |
| # different configurations. Traffic is prioritized using 802.1p and relies on |
| # the implicit mlxsw configuration, where packet priority is taken 1:1 from the |
| # 802.1p marking. |
| # |
| # +--------------------------+ +--------------------------+ |
| # | H1 | | H2 | |
| # | + $h1.10 | | + $h2.10 | |
| # | | 192.0.2.1/28 | | | 192.0.2.2/28 | |
| # | | | | | | |
| # | | $h1.11 + | | | $h2.11 + | |
| # | | 192.0.2.17/28 | | | | 192.0.2.18/28 | | |
| # | | | | | | | | |
| # | \______ ______/ | | \______ ______/ | |
| # | \ / | | \ / | |
| # | + $h1 | | + $h2 | |
| # +-------------|------------+ +-------------|------------+ |
| # | >1Gbps | |
| # +-------------|------------------------------------------------|------------+ |
| # | SW + $swp1 + $swp2 | |
| # | _______/ \___________ ___________/ \_______ | |
| # | / \ / \ | |
| # | +-|-----------------+ | +-|-----------------+ | | |
| # | | + $swp1.10 | | | + $swp2.10 | | | |
| # | | | | .-------------+ $swp5.10 | | | |
| # | | BR1_10 | | | | | | | |
| # | | | | | | BR2_10 | | | |
| # | | + $swp2.10 | | | | | | | |
| # | +-|-----------------+ | | | + $swp3.10 | | | |
| # | | | | +-|-----------------+ | | |
| # | | +-----------------|-+ | | +-----------------|-+ | |
| # | | | $swp1.11 + | | | | $swp2.11 + | | |
| # | | | | | .-----------------+ $swp5.11 | | |
| # | | | BR1_11 | | | | | | | |
| # | | | | | | | | BR2_11 | | |
| # | | | $swp2.11 + | | | | | | | |
| # | | +-----------------|-+ | | | | $swp3.11 + | | |
| # | | | | | | +-----------------|-+ | |
| # | \_______ ___________/ | | \___________ _______/ | |
| # | \ / \ / \ / | |
| # | + $swp4 + $swp5 + $swp3 | |
| # +-------------|----------------------|-------------------------|------------+ |
| # | | | 1Gbps |
| # \________1Gbps_________/ | |
| # +----------------------------|------------+ |
| # | H3 + $h3 | |
| # | _____________________/ \_______ | |
| # | / \ | |
| # | | | | |
| # | + $h3.10 $h3.11 + | |
| # | 192.0.2.3/28 192.0.2.19/28 | |
| # +-----------------------------------------+ |
| |
| NUM_NETIFS=8 |
| CHECK_TC="yes" |
| lib_dir=$(dirname $0)/../../../net/forwarding |
| source $lib_dir/lib.sh |
| source $lib_dir/devlink_lib.sh |
| source qos_lib.sh |
| |
| ipaddr() |
| { |
| local host=$1; shift |
| local vlan=$1; shift |
| |
| echo 192.0.2.$((16 * (vlan - 10) + host)) |
| } |
| |
| host_create() |
| { |
| local dev=$1; shift |
| local host=$1; shift |
| |
| simple_if_init $dev |
| mtu_set $dev 10000 |
| |
| vlan_create $dev 10 v$dev $(ipaddr $host 10)/28 |
| ip link set dev $dev.10 type vlan egress 0:0 |
| |
| vlan_create $dev 11 v$dev $(ipaddr $host 11)/28 |
| ip link set dev $dev.11 type vlan egress 0:1 |
| } |
| |
| host_destroy() |
| { |
| local dev=$1; shift |
| |
| vlan_destroy $dev 11 |
| vlan_destroy $dev 10 |
| mtu_restore $dev |
| simple_if_fini $dev |
| } |
| |
| h1_create() |
| { |
| host_create $h1 1 |
| } |
| |
| h1_destroy() |
| { |
| host_destroy $h1 |
| } |
| |
| h2_create() |
| { |
| host_create $h2 2 |
| tc qdisc add dev $h2 clsact |
| |
| # Some of the tests in this suite use multicast traffic. As this traffic |
| # enters BR2_10 resp. BR2_11, it is flooded to all other ports. Thus |
| # e.g. traffic ingressing through $swp2 is flooded to $swp3 (the |
| # intended destination) and $swp5 (which is intended as ingress for |
| # another stream of traffic). |
| # |
| # This is generally not a problem, but if the $swp5 throughput is lower |
| # than $swp2 throughput, there will be a build-up at $swp5. That may |
| # cause packets to fail to queue up at $swp3 due to shared buffer |
| # quotas, and the test to spuriously fail. |
| # |
| # Prevent this by setting the speed of $h2 to 1Gbps. |
| |
| ethtool -s $h2 speed 1000 autoneg off |
| } |
| |
| h2_destroy() |
| { |
| ethtool -s $h2 autoneg on |
| tc qdisc del dev $h2 clsact |
| host_destroy $h2 |
| } |
| |
| h3_create() |
| { |
| host_create $h3 3 |
| ethtool -s $h3 speed 1000 autoneg off |
| } |
| |
| h3_destroy() |
| { |
| ethtool -s $h3 autoneg on |
| host_destroy $h3 |
| } |
| |
| switch_create() |
| { |
| local intf |
| local vlan |
| |
| ip link add dev br1_10 type bridge |
| ip link add dev br1_11 type bridge |
| |
| ip link add dev br2_10 type bridge |
| ip link add dev br2_11 type bridge |
| |
| for intf in $swp1 $swp2 $swp3 $swp4 $swp5; do |
| ip link set dev $intf up |
| mtu_set $intf 10000 |
| done |
| |
| for intf in $swp1 $swp4; do |
| for vlan in 10 11; do |
| vlan_create $intf $vlan |
| ip link set dev $intf.$vlan master br1_$vlan |
| ip link set dev $intf.$vlan up |
| done |
| done |
| |
| for intf in $swp2 $swp3 $swp5; do |
| for vlan in 10 11; do |
| vlan_create $intf $vlan |
| ip link set dev $intf.$vlan master br2_$vlan |
| ip link set dev $intf.$vlan up |
| done |
| done |
| |
| ip link set dev $swp4.10 type vlan egress 0:0 |
| ip link set dev $swp4.11 type vlan egress 0:1 |
| for intf in $swp1 $swp2 $swp5; do |
| for vlan in 10 11; do |
| ip link set dev $intf.$vlan type vlan ingress 0:0 1:1 |
| done |
| done |
| |
| for intf in $swp2 $swp3 $swp4 $swp5; do |
| ethtool -s $intf speed 1000 autoneg off |
| done |
| |
| ip link set dev br1_10 up |
| ip link set dev br1_11 up |
| ip link set dev br2_10 up |
| ip link set dev br2_11 up |
| |
| local size=$(devlink_pool_size_thtype 0 | cut -d' ' -f 1) |
| devlink_port_pool_th_save $swp3 8 |
| devlink_port_pool_th_set $swp3 8 $size |
| } |
| |
| switch_destroy() |
| { |
| local intf |
| local vlan |
| |
| devlink_port_pool_th_restore $swp3 8 |
| |
| tc qdisc del dev $swp3 root 2>/dev/null |
| |
| ip link set dev br2_11 down |
| ip link set dev br2_10 down |
| ip link set dev br1_11 down |
| ip link set dev br1_10 down |
| |
| for intf in $swp5 $swp4 $swp3 $swp2; do |
| ethtool -s $intf autoneg on |
| done |
| |
| for intf in $swp5 $swp3 $swp2 $swp4 $swp1; do |
| for vlan in 11 10; do |
| ip link set dev $intf.$vlan down |
| ip link set dev $intf.$vlan nomaster |
| vlan_destroy $intf $vlan |
| done |
| |
| mtu_restore $intf |
| ip link set dev $intf down |
| done |
| |
| ip link del dev br2_11 |
| ip link del dev br2_10 |
| ip link del dev br1_11 |
| ip link del dev br1_10 |
| } |
| |
| setup_prepare() |
| { |
| h1=${NETIFS[p1]} |
| swp1=${NETIFS[p2]} |
| |
| swp2=${NETIFS[p3]} |
| h2=${NETIFS[p4]} |
| |
| swp3=${NETIFS[p5]} |
| h3=${NETIFS[p6]} |
| |
| swp4=${NETIFS[p7]} |
| swp5=${NETIFS[p8]} |
| |
| 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.10 $(ipaddr 3 10) " from host 1, vlan 10" |
| ping_test $h1.11 $(ipaddr 3 11) " from host 1, vlan 11" |
| ping_test $h2.10 $(ipaddr 3 10) " from host 2, vlan 10" |
| ping_test $h2.11 $(ipaddr 3 11) " from host 2, vlan 11" |
| } |
| |
| get_tc() |
| { |
| local vlan=$1; shift |
| |
| echo $((vlan - 10)) |
| } |
| |
| get_qdisc_handle() |
| { |
| local vlan=$1; shift |
| |
| local tc=$(get_tc $vlan) |
| local band=$((8 - tc)) |
| |
| # Handle is 107: for TC1, 108: for TC0. |
| echo "10$band:" |
| } |
| |
| get_qdisc_backlog() |
| { |
| local vlan=$1; shift |
| |
| qdisc_stats_get $swp3 $(get_qdisc_handle $vlan) .backlog |
| } |
| |
| get_mc_transmit_queue() |
| { |
| local vlan=$1; shift |
| |
| local tc=$(($(get_tc $vlan) + 8)) |
| ethtool_stats_get $swp3 tc_transmit_queue_tc_$tc |
| } |
| |
| get_nmarked() |
| { |
| local vlan=$1; shift |
| |
| ethtool_stats_get $swp3 ecn_marked |
| } |
| |
| get_qdisc_npackets() |
| { |
| local vlan=$1; shift |
| |
| busywait_for_counter 1100 +1 \ |
| qdisc_stats_get $swp3 $(get_qdisc_handle $vlan) .packets |
| } |
| |
| send_packets() |
| { |
| local vlan=$1; shift |
| local proto=$1; shift |
| local pkts=$1; shift |
| |
| $MZ $h2.$vlan -p 8000 -a own -b $h3_mac \ |
| -A $(ipaddr 2 $vlan) -B $(ipaddr 3 $vlan) \ |
| -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 vlan=$1; shift |
| local size=$1; shift |
| local proto=$1; shift |
| |
| local tc=$((vlan - 10)) |
| local band=$((8 - tc)) |
| local cur=-1 |
| local i=0 |
| |
| while :; do |
| local cur=$(busywait 1100 until_counter_is "> $cur" \ |
| get_qdisc_backlog $vlan) |
| local diff=$((size - cur)) |
| local pkts=$(((diff + 7999) / 8000)) |
| |
| if ((cur >= size)); then |
| echo $cur |
| return 0 |
| elif ((i++ > 10)); then |
| echo $cur |
| return 1 |
| fi |
| |
| send_packets $vlan $proto $pkts "$@" |
| done |
| } |
| |
| check_marking() |
| { |
| local vlan=$1; shift |
| local cond=$1; shift |
| |
| local npackets_0=$(get_qdisc_npackets $vlan) |
| local nmarked_0=$(get_nmarked $vlan) |
| sleep 5 |
| local npackets_1=$(get_qdisc_npackets $vlan) |
| local nmarked_1=$(get_nmarked $vlan) |
| |
| 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)) |
| } |
| |
| ecn_test_common() |
| { |
| local name=$1; shift |
| local vlan=$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 $vlan $((2 * limit / 3)) udp) |
| check_err $? "Could not build the requested backlog" |
| pct=$(check_marking $vlan "== 0") |
| check_err $? "backlog $backlog / $limit Got $pct% marked packets, expected == 0." |
| log_test "TC $((vlan - 10)): $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 $vlan $((3 * limit / 2)) tcp tos=0x01) |
| check_err $? "Could not build the requested backlog" |
| pct=$(check_marking $vlan ">= 95") |
| check_err $? "backlog $backlog / $limit Got $pct% marked packets, expected >= 95." |
| log_test "TC $((vlan - 10)): $name backlog > limit" |
| } |
| |
| do_ecn_test() |
| { |
| local vlan=$1; shift |
| local limit=$1; shift |
| local name=ECN |
| |
| start_tcp_traffic $h1.$vlan $(ipaddr 1 $vlan) $(ipaddr 3 $vlan) \ |
| $h3_mac tos=0x01 |
| sleep 1 |
| |
| ecn_test_common "$name" $vlan $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 $vlan $((2 * limit)) udp >/dev/null |
| check_fail $? "UDP traffic went into backlog instead of being early-dropped" |
| log_test "TC $((vlan - 10)): $name backlog > limit: UDP early-dropped" |
| |
| stop_traffic |
| sleep 1 |
| } |
| |
| do_ecn_nodrop_test() |
| { |
| local vlan=$1; shift |
| local limit=$1; shift |
| local name="ECN nodrop" |
| |
| start_tcp_traffic $h1.$vlan $(ipaddr 1 $vlan) $(ipaddr 3 $vlan) \ |
| $h3_mac tos=0x01 |
| sleep 1 |
| |
| ecn_test_common "$name" $vlan $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 $vlan $((2 * limit)) udp >/dev/null |
| check_err $? "UDP traffic was early-dropped instead of getting into backlog" |
| log_test "TC $((vlan - 10)): $name backlog > limit: UDP not dropped" |
| |
| stop_traffic |
| sleep 1 |
| } |
| |
| do_red_test() |
| { |
| local vlan=$1; shift |
| 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. |
| start_tcp_traffic $h1.$vlan $(ipaddr 1 $vlan) $(ipaddr 3 $vlan) \ |
| $h3_mac tos=0x01 |
| |
| # Pushing below the queue limit should work. |
| RET=0 |
| backlog=$(build_backlog $vlan $((2 * limit / 3)) tcp tos=0x01) |
| check_err $? "Could not build the requested backlog" |
| pct=$(check_marking $vlan "== 0") |
| check_err $? "backlog $backlog / $limit Got $pct% marked packets, expected == 0." |
| log_test "TC $((vlan - 10)): RED backlog < limit" |
| |
| # Pushing above should not. |
| RET=0 |
| backlog=$(build_backlog $vlan $((3 * limit / 2)) tcp tos=0x01) |
| check_fail $? "Traffic went into backlog instead of being early-dropped" |
| pct=$(check_marking $vlan "== 0") |
| check_err $? "backlog $backlog / $limit Got $pct% marked packets, expected == 0." |
| local diff=$((limit - backlog)) |
| pct=$((100 * diff / limit)) |
| ((0 <= pct && pct <= 10)) |
| check_err $? "backlog $backlog / $limit expected <= 10% distance" |
| log_test "TC $((vlan - 10)): RED backlog > limit" |
| |
| stop_traffic |
| sleep 1 |
| } |
| |
| do_mc_backlog_test() |
| { |
| local vlan=$1; shift |
| local limit=$1; shift |
| local backlog |
| local pct |
| |
| RET=0 |
| |
| start_tcp_traffic $h1.$vlan $(ipaddr 1 $vlan) $(ipaddr 3 $vlan) bc |
| start_tcp_traffic $h2.$vlan $(ipaddr 2 $vlan) $(ipaddr 3 $vlan) bc |
| |
| qbl=$(busywait 5000 until_counter_is ">= 500000" \ |
| get_qdisc_backlog $vlan) |
| check_err $? "Could not build MC backlog" |
| |
| # Verify that we actually see the backlog on BUM TC. Do a busywait as |
| # well, performance blips might cause false fail. |
| local ebl |
| ebl=$(busywait 5000 until_counter_is ">= 500000" \ |
| get_mc_transmit_queue $vlan) |
| check_err $? "MC backlog reported by qdisc not visible in ethtool" |
| |
| stop_traffic |
| stop_traffic |
| |
| log_test "TC $((vlan - 10)): Qdisc reports MC backlog" |
| } |
| |
| do_drop_test() |
| { |
| local vlan=$1; shift |
| local limit=$1; shift |
| local trigger=$1; shift |
| local subtest=$1; shift |
| local fetch_counter=$1; shift |
| local backlog |
| local base |
| local now |
| local pct |
| |
| RET=0 |
| |
| start_traffic $h1.$vlan $(ipaddr 1 $vlan) $(ipaddr 3 $vlan) $h3_mac |
| |
| # Create a bit of a backlog and observe no mirroring due to drops. |
| qevent_rule_install_$subtest |
| base=$($fetch_counter) |
| |
| build_backlog $vlan $((2 * limit / 3)) udp >/dev/null |
| |
| busywait 1100 until_counter_is ">= $((base + 1))" $fetch_counter >/dev/null |
| check_fail $? "Spurious packets observed without buffer pressure" |
| |
| # Push to the queue until it's at the limit. The configured limit is |
| # rounded by the qdisc and then by the driver, so this is the best we |
| # can do to get to the real limit of the system. |
| build_backlog $vlan $((3 * limit / 2)) udp >/dev/null |
| |
| base=$($fetch_counter) |
| send_packets $vlan udp 11 |
| |
| now=$(busywait 1100 until_counter_is ">= $((base + 10))" $fetch_counter) |
| check_err $? "Dropped packets not observed: 11 expected, $((now - base)) seen" |
| |
| # When no extra traffic is injected, there should be no mirroring. |
| busywait 1100 until_counter_is ">= $((base + 20))" $fetch_counter >/dev/null |
| check_fail $? "Spurious packets observed" |
| |
| # When the rule is uninstalled, there should be no mirroring. |
| qevent_rule_uninstall_$subtest |
| send_packets $vlan udp 11 |
| busywait 1100 until_counter_is ">= $((base + 20))" $fetch_counter >/dev/null |
| check_fail $? "Spurious packets observed after uninstall" |
| |
| log_test "TC $((vlan - 10)): ${trigger}ped packets $subtest'd" |
| |
| stop_traffic |
| sleep 1 |
| } |
| |
| qevent_rule_install_mirror() |
| { |
| tc filter add block 10 pref 1234 handle 102 matchall skip_sw \ |
| action mirred egress mirror dev $swp2 hw_stats disabled |
| } |
| |
| qevent_rule_uninstall_mirror() |
| { |
| tc filter del block 10 pref 1234 handle 102 matchall |
| } |
| |
| qevent_counter_fetch_mirror() |
| { |
| tc_rule_handle_stats_get "dev $h2 ingress" 101 |
| } |
| |
| do_drop_mirror_test() |
| { |
| local vlan=$1; shift |
| local limit=$1; shift |
| local qevent_name=$1; shift |
| |
| tc filter add dev $h2 ingress pref 1 handle 101 prot ip \ |
| flower skip_sw ip_proto udp \ |
| action drop |
| |
| do_drop_test "$vlan" "$limit" "$qevent_name" mirror \ |
| qevent_counter_fetch_mirror |
| |
| tc filter del dev $h2 ingress pref 1 handle 101 flower |
| } |
| |
| qevent_rule_install_trap() |
| { |
| tc filter add block 10 pref 1234 handle 102 matchall skip_sw \ |
| action trap hw_stats disabled |
| } |
| |
| qevent_rule_uninstall_trap() |
| { |
| tc filter del block 10 pref 1234 handle 102 matchall |
| } |
| |
| qevent_counter_fetch_trap() |
| { |
| local trap_name=$1; shift |
| |
| devlink_trap_rx_packets_get "$trap_name" |
| } |
| |
| do_drop_trap_test() |
| { |
| local vlan=$1; shift |
| local limit=$1; shift |
| local trap_name=$1; shift |
| |
| do_drop_test "$vlan" "$limit" "$trap_name" trap \ |
| "qevent_counter_fetch_trap $trap_name" |
| } |
