| #!/bin/bash | |
| # SPDX-License-Identifier: GPL-2.0 | |
| # | |
| # Test that GRE packets carried over UDP (FOU or GUE) get through when the | |
| # receiver merges them with GRO. | |
| # | |
| # Send bulk TCP through such tunnels with GRO on at the receiver, and | |
| # segmentation off at the sender so the receiver gets wire-sized packets | |
| # to merge, and check that the receiver counts no UDP errors (UdpInErrors | |
| # or Udp6InErrors). Also check that GRO really merged packets, by comparing | |
| # the UDP datagrams the receiver delivered with the packets its veth | |
| # received, so that a setup where GRO doesn't engage skips rather than | |
| # passes. | |
| source lib.sh | |
| NSEND="" | |
| NRECV="" | |
| FOU_PORT=5555 | |
| TCP_PORT=9000 | |
| SIZE_MB=4 | |
| TUN_S=192.168.99.1 | |
| TUN_R=192.168.99.2 | |
| cleanup() { | |
| cleanup_all_ns | |
| } | |
| trap cleanup EXIT | |
| # setup_tunnel creates the namespaces, the veth between them and a GRE | |
| # tunnel over UDP encapsulation $1 (fou or gue) over IPv$2. It returns | |
| # $ksft_skip if the kernel or iproute2 can't set it up. | |
| setup_tunnel() { | |
| local encap=$1 | |
| local family=$2 | |
| local type=gre | |
| local addr_s=10.0.0.1 | |
| local addr_r=10.0.0.2 | |
| local fou_args="ipproto 47" | |
| if [ "$encap" = gue ]; then | |
| fou_args=gue | |
| fi | |
| if [ "$family" = 6 ]; then | |
| type=ip6gre | |
| addr_s=2001:db8::1 | |
| addr_r=2001:db8::2 | |
| fou_args="$fou_args -6" | |
| fi | |
| setup_ns NSEND NRECV || return "$ksft_skip" | |
| ip link add veth_s netns "$NSEND" type veth \ | |
| peer name veth_r netns "$NRECV" || return "$ksft_skip" | |
| ip -n "$NSEND" addr add 10.0.0.1/24 dev veth_s | |
| ip -n "$NRECV" addr add 10.0.0.2/24 dev veth_r | |
| ip -n "$NSEND" addr add 2001:db8::1/64 dev veth_s nodad | |
| ip -n "$NRECV" addr add 2001:db8::2/64 dev veth_r nodad | |
| ip -n "$NSEND" link set veth_s up | |
| ip -n "$NRECV" link set veth_r up | |
| ip netns exec "$NRECV" ethtool -K veth_r gro on || return "$ksft_skip" | |
| ip netns exec "$NSEND" ethtool -K veth_s tso off gso off \ | |
| tx-gre-segmentation off tx-gre-csum-segmentation off \ | |
| tx-udp_tnl-segmentation off tx-udp_tnl-csum-segmentation off || | |
| return "$ksft_skip" | |
| # shellcheck disable=SC2086 # $fou_args is several arguments | |
| ip netns exec "$NSEND" ip fou add port "$FOU_PORT" $fou_args || | |
| return "$ksft_skip" | |
| # shellcheck disable=SC2086 | |
| ip netns exec "$NRECV" ip fou add port "$FOU_PORT" $fou_args || | |
| return "$ksft_skip" | |
| ip -n "$NSEND" link add gre_t type "$type" \ | |
| local "$addr_s" remote "$addr_r" \ | |
| encap "$encap" encap-sport auto encap-dport "$FOU_PORT" || | |
| return "$ksft_skip" | |
| ip -n "$NRECV" link add gre_t type "$type" \ | |
| local "$addr_r" remote "$addr_s" \ | |
| encap "$encap" encap-sport auto encap-dport "$FOU_PORT" || | |
| return "$ksft_skip" | |
| ip -n "$NSEND" addr add "$TUN_S/30" dev gre_t | |
| ip -n "$NRECV" addr add "$TUN_R/30" dev gre_t | |
| ip -n "$NSEND" link set gre_t up | |
| ip -n "$NRECV" link set gre_t up | |
| } | |
| # recv_counter prints the sum of the receiver's nstat counters "$@". | |
| recv_counter() { | |
| ip netns exec "$NRECV" nstat -az "$@" | | |
| awk '!/^#/ { n += $2 } END { print n + 0 }' | |
| } | |
| run_test() { | |
| local encap=$1 | |
| local family=$2 | |
| local name="GRO of GRE in ${encap^^} over IPv$family" | |
| local datagrams | |
| local packets | |
| local errors | |
| local pid | |
| local rc | |
| RET=0 | |
| if ! setup_tunnel "$encap" "$family"; then | |
| log_test_skip "$name" | |
| cleanup_all_ns | |
| return | |
| fi | |
| ip netns exec "$NRECV" socat -u \ | |
| TCP4-LISTEN:"$TCP_PORT",bind="$TUN_R",reuseaddr OPEN:/dev/null & | |
| pid=$! | |
| wait_local_port_listen "$NRECV" "$TCP_PORT" tcp | |
| # The timeout only bounds failing runs; passing ones take under a second. | |
| dd if=/dev/zero bs=1M count="$SIZE_MB" 2>/dev/null | | |
| ip netns exec "$NSEND" timeout 20 \ | |
| socat -u STDIN TCP4:"$TUN_R":"$TCP_PORT" | |
| rc=$? | |
| # Check the UDP error count rather than the duration, which depends | |
| # on the machine. | |
| errors=$(recv_counter UdpInErrors Udp6InErrors) | |
| check_err "$errors" "$errors UDP errors at the receiver" | |
| check_err "$rc" "transfer failed" | |
| # Without errors, a pass only means something if GRO merged packets: | |
| # then the encapsulation socket sees far fewer datagrams than the | |
| # veth received packets. | |
| datagrams=$(recv_counter UdpInDatagrams Udp6InDatagrams) | |
| packets=$(ip netns exec "$NRECV" \ | |
| cat /sys/class/net/veth_r/statistics/rx_packets) | |
| if [ "$RET" -eq 0 ] && [ $((datagrams * 2)) -gt "$packets" ]; then | |
| ret_set_ksft_status "$ksft_skip" \ | |
| "GRO didn't merge: $datagrams UDP datagrams from $packets packets" | |
| fi | |
| log_test "$name" | |
| kill "$pid" 2>/dev/null | |
| wait "$pid" 2>/dev/null | |
| cleanup_all_ns | |
| } | |
| require_command socat | |
| require_command ethtool | |
| require_command nstat | |
| modprobe -q fou | |
| modprobe -q ip_gre | |
| modprobe -q fou6 | |
| modprobe -q ip6_gre | |
| run_test fou 4 | |
| run_test gue 4 | |
| run_test fou 6 | |
| run_test gue 6 | |
| exit "$EXIT_STATUS" |