selftests/net/udpgro.sh

0001 #!/bin/bash
0002 # SPDX-License-Identifier: GPL-2.0
0003 #
0004 # Run a series of udpgro functional tests.
0005
0006 readonly PEER_NS="ns-peer-$(mktemp -u XXXXXX)"
0007
0008 # set global exit status, but never reset nonzero one.
0009 check_err()
0010 {
0011         if [ $ret -eq 0 ]; then
0012                 ret=$1
0013         fi
0014 }
0015
0016 cleanup() {
0017         local -r jobs="$(jobs -p)"
0018         local -r ns="$(ip netns list|grep $PEER_NS)"
0019
0020         [ -n "${jobs}" ] && kill -1 ${jobs} 2>/dev/null
0021         [ -n "$ns" ] && ip netns del $ns 2>/dev/null
0022 }
0023 trap cleanup EXIT
0024
0025 cfg_veth() {
0026         ip netns add "${PEER_NS}"
0027         ip -netns "${PEER_NS}" link set lo up
0028         ip link add type veth
0029         ip link set dev veth0 up
0030         ip addr add dev veth0 192.168.1.2/24
0031         ip addr add dev veth0 2001:db8::2/64 nodad
0032
0033         ip link set dev veth1 netns "${PEER_NS}"
0034         ip -netns "${PEER_NS}" addr add dev veth1 192.168.1.1/24
0035         ip -netns "${PEER_NS}" addr add dev veth1 2001:db8::1/64 nodad
0036         ip -netns "${PEER_NS}" link set dev veth1 up
0037         ip -n "${PEER_NS}" link set veth1 xdp object ../bpf/xdp_dummy.o section xdp
0038 }
0039
0040 run_one() {
0041         # use 'rx' as separator between sender args and receiver args
0042         local -r all="$@"
0043         local -r tx_args=${all%rx*}
0044         local -r rx_args=${all#*rx}
0045
0046         cfg_veth
0047
0048         ip netns exec "${PEER_NS}" ./udpgso_bench_rx -C 1000 -R 10 ${rx_args} && \
0049                 echo "ok" || \
0050                 echo "failed" &
0051
0052         # Hack: let bg programs complete the startup
0053         sleep 0.1
0054         ./udpgso_bench_tx ${tx_args}
0055         ret=$?
0056         wait $(jobs -p)
0057         return $ret
0058 }
0059
0060 run_test() {
0061         local -r args=$@
0062
0063         printf " %-40s" "$1"
0064         ./in_netns.sh $0 __subprocess $2 rx -G -r $3
0065 }
0066
0067 run_one_nat() {
0068         # use 'rx' as separator between sender args and receiver args
0069         local addr1 addr2 pid family="" ipt_cmd=ip6tables
0070         local -r all="$@"
0071         local -r tx_args=${all%rx*}
0072         local -r rx_args=${all#*rx}
0073
0074         if [[ ${tx_args} = *-4* ]]; then
0075                 ipt_cmd=iptables
0076                 family=-4
0077                 addr1=192.168.1.1
0078                 addr2=192.168.1.3/24
0079         else
0080                 addr1=2001:db8::1
0081                 addr2="2001:db8::3/64 nodad"
0082         fi
0083
0084         cfg_veth
0085         ip -netns "${PEER_NS}" addr add dev veth1 ${addr2}
0086
0087         # fool the GRO engine changing the destination address ...
0088         ip netns exec "${PEER_NS}" $ipt_cmd -t nat -I PREROUTING -d ${addr1} -j DNAT --to-destination ${addr2%/*}
0089
0090         # ... so that GRO will match the UDP_GRO enabled socket, but packets
0091         # will land on the 'plain' one
0092         ip netns exec "${PEER_NS}" ./udpgso_bench_rx -G ${family} -b ${addr1} -n 0 &
0093         pid=$!
0094         ip netns exec "${PEER_NS}" ./udpgso_bench_rx -C 1000 -R 10 ${family} -b ${addr2%/*} ${rx_args} && \
0095                 echo "ok" || \
0096                 echo "failed"&
0097
0098         sleep 0.1
0099         ./udpgso_bench_tx ${tx_args}
0100         ret=$?
0101         kill -INT $pid
0102         wait $(jobs -p)
0103         return $ret
0104 }
0105
0106 run_one_2sock() {
0107         # use 'rx' as separator between sender args and receiver args
0108         local -r all="$@"
0109         local -r tx_args=${all%rx*}
0110         local -r rx_args=${all#*rx}
0111
0112         cfg_veth
0113
0114         ip netns exec "${PEER_NS}" ./udpgso_bench_rx -C 1000 -R 10 ${rx_args} -p 12345 &
0115         ip netns exec "${PEER_NS}" ./udpgso_bench_rx -C 2000 -R 10 ${rx_args} && \
0116                 echo "ok" || \
0117                 echo "failed" &
0118
0119         # Hack: let bg programs complete the startup
0120         sleep 0.1
0121         ./udpgso_bench_tx ${tx_args} -p 12345
0122         sleep 0.1
0123         # first UDP GSO socket should be closed at this point
0124         ./udpgso_bench_tx ${tx_args}
0125         ret=$?
0126         wait $(jobs -p)
0127         return $ret
0128 }
0129
0130 run_nat_test() {
0131         local -r args=$@
0132
0133         printf " %-40s" "$1"
0134         ./in_netns.sh $0 __subprocess_nat $2 rx -r $3
0135 }
0136
0137 run_2sock_test() {
0138         local -r args=$@
0139
0140         printf " %-40s" "$1"
0141         ./in_netns.sh $0 __subprocess_2sock $2 rx -G -r $3
0142 }
0143
0144 run_all() {
0145         local -r core_args="-l 4"
0146         local -r ipv4_args="${core_args} -4 -D 192.168.1.1"
0147         local -r ipv6_args="${core_args} -6 -D 2001:db8::1"
0148         ret=0
0149
0150         echo "ipv4"
0151         run_test "no GRO" "${ipv4_args} -M 10 -s 1400" "-4 -n 10 -l 1400"
0152         check_err $?
0153
0154         # explicitly check we are not receiving UDP_SEGMENT cmsg (-S -1)
0155         # when GRO does not take place
0156         run_test "no GRO chk cmsg" "${ipv4_args} -M 10 -s 1400" "-4 -n 10 -l 1400 -S -1"
0157         check_err $?
0158
0159         # the GSO packets are aggregated because:
0160         # * veth schedule napi after each xmit
0161         # * segmentation happens in BH context, veth napi poll is delayed after
0162         #   the transmission of the last segment
0163         run_test "GRO" "${ipv4_args} -M 1 -s 14720 -S 0 " "-4 -n 1 -l 14720"
0164         check_err $?
0165         run_test "GRO chk cmsg" "${ipv4_args} -M 1 -s 14720 -S 0 " "-4 -n 1 -l 14720 -S 1472"
0166         check_err $?
0167         run_test "GRO with custom segment size" "${ipv4_args} -M 1 -s 14720 -S 500 " "-4 -n 1 -l 14720"
0168         check_err $?
0169         run_test "GRO with custom segment size cmsg" "${ipv4_args} -M 1 -s 14720 -S 500 " "-4 -n 1 -l 14720 -S 500"
0170         check_err $?
0171
0172         run_nat_test "bad GRO lookup" "${ipv4_args} -M 1 -s 14720 -S 0" "-n 10 -l 1472"
0173         check_err $?
0174         run_2sock_test "multiple GRO socks" "${ipv4_args} -M 1 -s 14720 -S 0 " "-4 -n 1 -l 14720 -S 1472"
0175         check_err $?
0176
0177         echo "ipv6"
0178         run_test "no GRO" "${ipv6_args} -M 10 -s 1400" "-n 10 -l 1400"
0179         check_err $?
0180         run_test "no GRO chk cmsg" "${ipv6_args} -M 10 -s 1400" "-n 10 -l 1400 -S -1"
0181         check_err $?
0182         run_test "GRO" "${ipv6_args} -M 1 -s 14520 -S 0" "-n 1 -l 14520"
0183         check_err $?
0184         run_test "GRO chk cmsg" "${ipv6_args} -M 1 -s 14520 -S 0" "-n 1 -l 14520 -S 1452"
0185         check_err $?
0186         run_test "GRO with custom segment size" "${ipv6_args} -M 1 -s 14520 -S 500" "-n 1 -l 14520"
0187         check_err $?
0188         run_test "GRO with custom segment size cmsg" "${ipv6_args} -M 1 -s 14520 -S 500" "-n 1 -l 14520 -S 500"
0189         check_err $?
0190
0191         run_nat_test "bad GRO lookup" "${ipv6_args} -M 1 -s 14520 -S 0" "-n 10 -l 1452"
0192         check_err $?
0193         run_2sock_test "multiple GRO socks" "${ipv6_args} -M 1 -s 14520 -S 0 " "-n 1 -l 14520 -S 1452"
0194         check_err $?
0195         return $ret
0196 }
0197
0198 if [ ! -f ../bpf/xdp_dummy.o ]; then
0199         echo "Missing xdp_dummy helper. Build bpf selftest first"
0200         exit -1
0201 fi
0202
0203 if [[ $# -eq 0 ]]; then
0204         run_all
0205 elif [[ $1 == "__subprocess" ]]; then
0206         shift
0207         run_one $@
0208 elif [[ $1 == "__subprocess_nat" ]]; then
0209         shift
0210         run_one_nat $@
0211 elif [[ $1 == "__subprocess_2sock" ]]; then
0212         shift
0213         run_one_2sock $@
0214 fi
0215
0216 exit $?