ipv4/ipv6: Cache pmtu on all paths of a multipath route
Subsystems (4)
v2 cover ipv4/ipv6: Cache pmtu on all paths of a multipath route
IPv6 counterpart of commit 7d3f3b4367f3 ("net: ipv4: Cache pmtu for all packet paths if multipath enabled"), deferred back then:
https://lore.kernel.org/netdev/[email protected]/
Patch 1 keeps the IPv4 fan-out from raising a pmtu a path already has, patch 2 creates or updates the PMTU exception on every path of an IPv6 multipath route, patch 3 adds the IPv6 variant of the pmtu.sh multipath test and multipath tests with paths of different MTU for both families. The IPv6 tests fail without patch 2.
Changes in v2, after the Sashiko review of v1:
- Update the PMTU exception a path already has instead of replacing it, so a lower pmtu or a gateway learned from a redirect on another path is kept. The pmtu is now propagated to the other paths on every Packet Too Big, not only on the first one, when the looked up dst is still a plain route and not a cached exception yet.
- Don't walk the siblings of a fib6_info that is no longer in the
tree: after NLM_F_REPLACE the old route and its siblings are freed with the sibling list still linked.
- Describe the real mechanism in the commit message: ip6_update_pmtu() looks the destination up without the protocol and ports of the offending packet, so the multipath hash may pick another path than the one that packet took.
- New patch 1: the same "a cached pmtu never goes up" rule for the IPv4 fan-out in update_or_create_fnhe().
- Add selftests with a different MTU behind each router, so a second, lower Packet Too Big is covered as well.
- Rebased on net-next.
v1: https://lore.kernel.org/netdev/[email protected]/
Vladimir Vdovin (3):
ipv4: Don't raise a cached pmtu from another path's Packet Too Big
ipv6: Cache pmtu for all paths of a multipath route
selftests: net: pmtu: Add IPv6 and asymmetric multipath tests
net/ipv4/route.c | 8 + net/ipv6/route.c | 124 ++++++++----- tools/testing/selftests/net/pmtu.sh | 276 ++++++++++++++++++++++++---- 3 files changed, 328 insertions(+), 80 deletions(-)
base-commit: d26955e57475434b59d43ba372b2a50d33d5e0ed
Signature · 1 line
2.56.0
PATCH v2 1/3 ipv4: Don't raise a cached pmtu from another path's Packet Too Big
Since commit 7d3f3b4367f3 ("net: ipv4: Cache pmtu for all packet paths if multipath enabled") __ip_rt_update_pmtu() updates the exception of every path of a multipath route, but update_or_create_fnhe() overwrites whatever pmtu a path already has. A Packet Too Big from a wider path thus raises the pmtu a narrower path has learned, and flows on that path blackhole until it gets its own Packet Too Big again.
The early return in __ip_rt_update_pmtu() already keeps a pmtu from going up on the path the Packet Too Big was looked up on. Do the same for the other paths: leave an unexpired exception with a lower pmtu alone.
--- net/ipv4/route.c | 8 ++++++++ 1 file changed, 8 insertions(+)
net/ipv4/route.c +8 -0
@@ -676,6 +676,14 @@ static void update_or_create_fnhe(struct fib_nh_common *nhc, __be32 daddr, }if (fnhe) { +/* __ip_rt_update_pmtu() caches a pmtu on every path of a +* multipath route, don't let a Packet Too Big from one path +* raise the pmtu another path already learned. +*/ +if (pmtu && fnhe->fnhe_genid == genid && fnhe->fnhe_pmtu && + pmtu > fnhe->fnhe_pmtu && +time_before (jiffies, fnhe->fnhe_expires)) + goto out_unlock;if (fnhe->fnhe_genid != genid) fnhe->fnhe_genid = genid;if (gw)
Signature · 1 line
2.56.0
PATCH v2 2/3 ipv6: Cache pmtu for all paths of a multipath route
In reply to Vladimir Vdovinip6_update_pmtu() looks the destination up without the protocol and ports the offending packet was hashed on, so with a multipath route the exception may be created on another path than the one the packet took. The flow then keeps sending too big packets on its path, every Packet Too Big lands on the same wrong path, and the flow blackholes.
Same problem and same fix as for IPv4 in commit 7d3f3b4367f3 ("net:
ipv4: Cache pmtu for all packet paths if multipath enabled"): cache the pmtu on every path of the route. For a nexthop object walk all of its fib6_nh, for a legacy multipath route walk the siblings of the fib6_info the dst came from. A path that already has an exception for the destination gets it updated in place, so its gateway from a redirect stays and its pmtu never goes up, and that also covers a dst that is itself a cached exception, which used to be updated alone.
--- net/ipv6/route.c | 124 +++++++++++++++++++++++++++++++---------------- 1 file changed, 82 insertions(+), 42 deletions(-)
net/ipv6/route.c +82 -42
@@ -2911,12 +2911,52 @@ static bool rt6_cache_allowed_for_pmtu(const struct rt6_info *rt) (rt->rt6i_flags &RTF_PCPU ||rcu_access_pointer (rt->from)); } +struct rt6_pmtu_arg { +struct fib6_result res; +const struct in6_addr *daddr; +const struct in6_addr *saddr; +u32 mtu; +}; + +/* Cache a pmtu on one path of a route: update the exception the path already +* has for daddr, keeping its gateway and never raising its pmtu, or create one. +*/ +static int rt6_nh_update_pmtu (struct fib6_nh *nh,void *_arg) +{ +struct rt6_pmtu_arg *arg = _arg; +struct fib6_result *res = &arg->res; +struct rt6_info *rt; + + res->nh = nh; + rt =rt6_find_cached_rt (res, arg->daddr, arg->saddr); +if (rt) { +u32 mtu =dst_metric_raw (&rt->dst,RTAX_MTU ); + +if (!mtu || arg->mtu < mtu) { +rt6_do_update_pmtu (rt, arg->mtu); +fib6_nh_update_exception (nh, res->f6i->fib6_src.plen, rt); + } +return 0 ; + } + + rt =ip6_rt_cache_alloc (res, arg->daddr, arg->saddr); +if (rt) { +rt6_do_update_pmtu (rt, arg->mtu); +if (rt6_insert_exception (rt, res)) +dst_release_immediate (&rt->dst); + } + +return 0 ; +} +static void __ip6_rt_update_pmtu (struct dst_entry *dst,const struct sock *sk,const struct ipv6hdr *iph,u32 mtu,bool confirm_neigh) { -const struct in6_addr *daddr, *saddr; +struct rt6_pmtu_arg arg = { .mtu = mtu };struct rt6_info *rt6 =dst_rt6_info (dst); +const struct in6_addr *daddr, *saddr; +struct fib6_info *f6i, *sibling;/* Note: do *NOT* check dst_metric_locked(dst, RTAX_MTU) * IPv6 pmtu discovery isn't optional, so 'mtu lock' cannot disable it.
@@ -2942,52 +2982,52 @@ static void __ip6_rt_update_pmtu(struct dst_entry *dst, const struct sock *sk,if (mtu >=dst6_mtu (dst))return ; -if (!rt6_cache_allowed_for_pmtu (rt6)) { -rt6_do_update_pmtu (rt6, mtu); -/* update rt6_ex->stamp for cache */ -if (rt6->rt6i_flags &RTF_CACHE ) -rt6_update_exception_stamp_rt (rt6); - }else if (daddr) { -struct fib6_result res = {}; -struct rt6_info *nrt6; - -rcu_read_lock (); - res.f6i =rcu_dereference (rt6->from); -if (!res.f6i) - goto out_unlock; - - res.fib6_flags = res.f6i->fib6_flags; - res.fib6_type = res.f6i->fib6_type; - -if (res.f6i->nh) { -struct fib6_nh_match_arg arg = { - .dev =dst_dev_rcu (dst), - .gw = &rt6->rt6i_gateway, - }; +rcu_read_lock (); + f6i =rcu_dereference (rt6->from); +/* fib6_del_route() and a NLM_F_REPLACE clear fib6_node before the +* route and its siblings are released, don't walk them then. +*/ +if (!daddr || !f6i || !rcu_access_pointer (f6i->fib6_node)) { +if (!rt6_cache_allowed_for_pmtu (rt6)) { +rt6_do_update_pmtu (rt6, mtu); +/* update rt6_ex->stamp for cache */ +if (rt6->rt6i_flags &RTF_CACHE ) +rt6_update_exception_stamp_rt (rt6); + } + goto out; + } -nexthop_for_each_fib6_nh (res.f6i->nh, - fib6_nh_find_match, &arg); + arg.daddr = daddr; + arg.saddr = saddr; + arg.res.f6i = f6i; + arg.res.fib6_flags = f6i->fib6_flags; + arg.res.fib6_type = f6i->fib6_type; -/* fib6_info uses a nexthop that does not have fib6_nh -* using the dst->dev + gw. Should be impossible. -*/ -if (!arg.match) - goto out_unlock; +/* ip6_update_pmtu() looks dst up without the protocol and ports the +* too big packet was hashed on, so dst may be another path of a +* multipath route than the one that packet took. Cache the pmtu on +* every path, or that flow would keep sending too big packets. +*/ +if (f6i->nh) { +nexthop_for_each_fib6_nh (f6i->nh, rt6_nh_update_pmtu, &arg); + goto out; + } - res.nh = arg.match; - }else { - res.nh = res.f6i->fib6_nh; - } +rt6_nh_update_pmtu (f6i->fib6_nh, &arg); - nrt6 =ip6_rt_cache_alloc (&res, daddr, saddr); -if (nrt6) { -rt6_do_update_pmtu (nrt6, mtu); -if (rt6_insert_exception (nrt6, &res)) -dst_release_immediate (&nrt6->dst); - } -out_unlock: -rcu_read_unlock (); +/* fib6_del_route() zeroes fib6_nsiblings before unlinking f6i, stop +* then as the walk would never get back to its head. +*/ +list_for_each_entry_rcu (sibling, &f6i->fib6_siblings, fib6_siblings) { + arg.res.f6i = sibling; + arg.res.fib6_flags = sibling->fib6_flags; + arg.res.fib6_type = sibling->fib6_type; +rt6_nh_update_pmtu (sibling->fib6_nh, &arg); +if (!READ_ONCE (f6i->fib6_nsiblings)) +break ; } +out: +rcu_read_unlock (); } static void ip6_rt_update_pmtu(struct dst_entry *dst, struct sock *sk,
Signature · 1 line
2.56.0
PATCH v2 3/3 selftests: net: pmtu: Add IPv6 and asymmetric multipath tests
In reply to Vladimir VdovinMake pmtu_ipv4_mp_exceptions family agnostic and addpmtu_ipv6_mp_exceptions: one oversized ping over a multipath route must leave PMTU exceptions on both paths.
Add pmtu_ipv4_mp_asym_exceptions and pmtu_ipv6_mp_asym_exceptions with an MTU of 1400 behind one router and 1300 behind the other. They pick a flow through each router (a source address for IPv4, whose multipath hash covers addresses only, a flow label for IPv6) and check that a Packet Too Big from the first router is cached on both paths, then that a flow through the second router lowers the PMTU of both paths.
Without the preceding fix the IPv6 tests fail with both legacy nexthops and nexthop objects:
PMTU exception wasn't created after exceeding MTU (veth_A-R2)
--- tools/testing/selftests/net/pmtu.sh | 276 ++++++++++++++++++++++++---- 1 file changed, 238 insertions(+), 38 deletions(-)
tools/testing/selftests/net/pmtu.sh +238 -38
@@ -203,6 +203,18 @@ # on host A and B on lo reachable via both routers. Host A and B # addresses have multipath routes to each other, b_r1 mtu = 1500. # Check that PMTU exceptions are created for both paths. +# +# - pmtu_ipv6_mp_exceptions +# Same as above but with IPv6 +# +# - pmtu_ipv4_mp_asym_exceptions +# Same topology as pmtu_ipv4_mp_exceptions, with b_r1 mtu = 1400 and +# b_r2 mtu = 1300. Pick a flow through each router and check that a +# Packet Too Big from R1 is cached on both paths, then that a flow +# through R2 lowers the PMTU of both paths +# +# - pmtu_ipv6_mp_asym_exceptions +# Same as above but with IPv6 source lib.sh
@@ -272,7 +284,10 @@ tests=" list_flush_ipv6_exception ipv6: list and flush cached exceptions 1 pmtu_ipv4_route_change ipv4: PMTU exception w/route replace 1 pmtu_ipv6_route_change ipv6: PMTU exception w/route replace 1 - pmtu_ipv4_mp_exceptions ipv4: PMTU multipath nh exceptions 1" + pmtu_ipv4_mp_exceptions ipv4: PMTU multipath nh exceptions 1 + pmtu_ipv6_mp_exceptions ipv6: PMTU multipath nh exceptions 1 + pmtu_ipv4_mp_asym_exceptions ipv4: PMTU multipath nh exceptions, asymmetric MTUs 1 + pmtu_ipv6_mp_asym_exceptions ipv6: PMTU multipath nh exceptions, asymmetric MTUs 1" # Addressing and routing for tests with routers: four network segments, with # index SEGMENT between 1 and 4, a common prefix (PREFIX4 or PREFIX6) and an
@@ -350,8 +365,12 @@ tunnel6_b_addr="fd00:2::b" tunnel6_mask="64" host4_a_addr="192.168.99.99" +host4_a_net="192.168.97" host4_b_addr="192.168.88.88" +host6_a_addr="fc00:1000::a" +host6_b_addr="fc00:1001::b" + dummy6_0_prefix="fc00:1000::" dummy6_1_prefix="fc00:1001::" dummy6_mask="64"
@@ -994,49 +1013,112 @@ setup_ovs_bridge() { } setup_multipath_new() { - # Set up host A with multipath routes to host B host4_b_addr - run_cmd ${ns_a} ip addr add ${host4_a_addr} dev lo - run_cmd ${ns_a} ip nexthop add id 401 via ${prefix4}.${a_r1}.2 dev veth_A-R1 - run_cmd ${ns_a} ip nexthop add id 402 via ${prefix4}.${a_r2}.2 dev veth_A-R2 - run_cmd ${ns_a} ip nexthop add id 403 group 401/402 - run_cmd ${ns_a} ip route add ${host4_b_addr} src ${host4_a_addr} nhid 403 + family=${1} + + if [ ${family} -eq 4 ]; then + host_a_addr=${host4_a_addr} + host_b_addr=${host4_b_addr} + nh_a_r1=${prefix4}.${a_r1}.2 + nh_a_r2=${prefix4}.${a_r2}.2 + nh_b_r1=${prefix4}.${b_r1}.2 + nh_b_r2=${prefix4}.${b_r2}.2 + else + host_a_addr=${host6_a_addr} + host_b_addr=${host6_b_addr} + nh_a_r1=${prefix6}:${a_r1}::2 + nh_a_r2=${prefix6}:${a_r2}::2 + nh_b_r1=${prefix6}:${b_r1}::2 + nh_b_r2=${prefix6}:${b_r2}::2 + fi + + # Set up host A with multipath routes to host B host_b_addr + run_cmd ${ns_a} ip addr add ${host_a_addr} dev lo + run_cmd ${ns_a} ip nexthop add id ${family}01 via ${nh_a_r1} dev veth_A-R1 + run_cmd ${ns_a} ip nexthop add id ${family}02 via ${nh_a_r2} dev veth_A-R2 + run_cmd ${ns_a} ip nexthop add id ${family}03 group ${family}01/${family}02 + run_cmd ${ns_a} ip route add ${host_b_addr} src ${host_a_addr} nhid ${family}03 - # Set up host B with multipath routes to host A host4_a_addr - run_cmd ${ns_b} ip addr add ${host4_b_addr} dev lo - run_cmd ${ns_b} ip nexthop add id 401 via ${prefix4}.${b_r1}.2 dev veth_B-R1 - run_cmd ${ns_b} ip nexthop add id 402 via ${prefix4}.${b_r2}.2 dev veth_B-R2 - run_cmd ${ns_b} ip nexthop add id 403 group 401/402 - run_cmd ${ns_b} ip route add ${host4_a_addr} src ${host4_b_addr} nhid 403 + # Set up host B with multipath routes to host A host_a_addr + run_cmd ${ns_b} ip addr add ${host_b_addr} dev lo + run_cmd ${ns_b} ip nexthop add id ${family}01 via ${nh_b_r1} dev veth_B-R1 + run_cmd ${ns_b} ip nexthop add id ${family}02 via ${nh_b_r2} dev veth_B-R2 + run_cmd ${ns_b} ip nexthop add id ${family}03 group ${family}01/${family}02 + run_cmd ${ns_b} ip route add ${host_a_addr} src ${host_b_addr} nhid ${family}03 } setup_multipath_old() { - # Set up host A with multipath routes to host B host4_b_addr - run_cmd ${ns_a} ip addr add ${host4_a_addr} dev lo - run_cmd ${ns_a} ip route add ${host4_b_addr} \ - src ${host4_a_addr} \ - nexthop via ${prefix4}.${a_r1}.2 weight 1 \ - nexthop via ${prefix4}.${a_r2}.2 weight 1 + family=${1} + + if [ ${family} -eq 4 ]; then + host_a_addr=${host4_a_addr} + host_b_addr=${host4_b_addr} + nh_a_r1=${prefix4}.${a_r1}.2 + nh_a_r2=${prefix4}.${a_r2}.2 + nh_b_r1=${prefix4}.${b_r1}.2 + nh_b_r2=${prefix4}.${b_r2}.2 + else + host_a_addr=${host6_a_addr} + host_b_addr=${host6_b_addr} + nh_a_r1=${prefix6}:${a_r1}::2 + nh_a_r2=${prefix6}:${a_r2}::2 + nh_b_r1=${prefix6}:${b_r1}::2 + nh_b_r2=${prefix6}:${b_r2}::2 + fi + + # Set up host A with multipath routes to host B host_b_addr + run_cmd ${ns_a} ip addr add ${host_a_addr} dev lo + run_cmd ${ns_a} ip route add ${host_b_addr} \ + src ${host_a_addr} \ + nexthop via ${nh_a_r1} weight 1 \ + nexthop via ${nh_a_r2} weight 1 - # Set up host B with multipath routes to host A host4_a_addr - run_cmd ${ns_b} ip addr add ${host4_b_addr} dev lo - run_cmd ${ns_b} ip route add ${host4_a_addr} \ - src ${host4_b_addr} \ - nexthop via ${prefix4}.${b_r1}.2 weight 1 \ - nexthop via ${prefix4}.${b_r2}.2 weight 1 + # Set up host B with multipath routes to host A host_a_addr + run_cmd ${ns_b} ip addr add ${host_b_addr} dev lo + run_cmd ${ns_b} ip route add ${host_a_addr} \ + src ${host_b_addr} \ + nexthop via ${nh_b_r1} weight 1 \ + nexthop via ${nh_b_r2} weight 1 } + setup_multipath() { + family="$1" + + if [ ${family} -eq 4 ]; then + host_a_addr=${host4_a_addr} + host_b_addr=${host4_b_addr} + nh_r1_a=${prefix4}.${a_r1}.1 + nh_r1_b=${prefix4}.${b_r1}.1 + nh_r2_a=${prefix4}.${a_r2}.1 + nh_r2_b=${prefix4}.${b_r2}.1 + else + host_a_addr=${host6_a_addr} + host_b_addr=${host6_b_addr} + nh_r1_a=${prefix6}:${a_r1}::1 + nh_r1_b=${prefix6}:${b_r1}::1 + nh_r2_a=${prefix6}:${a_r2}::1 + nh_r2_b=${prefix6}:${b_r2}::1 + fi + if [ "$USE_NH" = "yes" ]; then - setup_multipath_new + setup_multipath_new ${family} else - setup_multipath_old + setup_multipath_old ${family} fi # Set up routers with routes to dummies - run_cmd ${ns_r1} ip route add ${host4_a_addr} via ${prefix4}.${a_r1}.1 - run_cmd ${ns_r2} ip route add ${host4_a_addr} via ${prefix4}.${a_r2}.1 - run_cmd ${ns_r1} ip route add ${host4_b_addr} via ${prefix4}.${b_r1}.1 - run_cmd ${ns_r2} ip route add ${host4_b_addr} via ${prefix4}.${b_r2}.1 + run_cmd ${ns_r1} ip route add ${host_a_addr} via ${nh_r1_a} + run_cmd ${ns_r2} ip route add ${host_a_addr} via ${nh_r2_a} + run_cmd ${ns_r1} ip route add ${host_b_addr} via ${nh_r1_b} + run_cmd ${ns_r2} ip route add ${host_b_addr} via ${nh_r2_b} +} + +setup_multipath4() { + setup_multipath 4 +} + +setup_multipath6() { + setup_multipath 6 } setup() {
@@ -2377,8 +2459,18 @@ test_pmtu_ipv6_route_change() { test_pmtu_ipvX_route_change 6 } -test_pmtu_ipv4_mp_exceptions() { - setup namespaces routing multipath || return $ksft_skip +test_pmtu_ipvX_mp_exceptions() { + family=${1} + + if [ ${family} -eq 4 ]; then + ping=ping + dst="${host4_b_addr}" + else + ping=${ping6} + dst="${host6_b_addr}" + fi + + setup namespaces routing multipath${family} || return $ksft_skip trace "${ns_a}" veth_A-R1 "${ns_r1}" veth_R1-A \ "${ns_r1}" veth_R1-B "${ns_b}" veth_B-R1 \
@@ -2395,18 +2487,126 @@ test_pmtu_ipv4_mp_exceptions() { mtu "${ns_r2}" veth_R2-A 2000 mtu "${ns_r2}" veth_R2-B 1500 mtu "${ns_b}" veth_B-R2 1500 - # Ping and expect two nexthop exceptions for two routes - run_cmd ${ns_a} ping -q -M want -i 0.1 -c 1 -s 1800 "${host4_b_addr}" + run_cmd ${ns_a} ${ping} -q -M want -i 0.1 -c 1 -s 1800 "${dst}" # Check that exceptions have been created with the correct PMTU - pmtu_a_R1="$(route_get_dst_pmtu_from_exception "${ns_a}" "${host4_b_addr}" oif veth_A-R1)" - pmtu_a_R2="$(route_get_dst_pmtu_from_exception "${ns_a}" "${host4_b_addr}" oif veth_A-R2)" - + pmtu_a_R1="$(route_get_dst_pmtu_from_exception "${ns_a}" "${dst}" oif veth_A-R1)" + pmtu_a_R2="$(route_get_dst_pmtu_from_exception "${ns_a}" "${dst}" oif veth_A-R2)" check_pmtu_value "1500" "${pmtu_a_R1}" "exceeding MTU (veth_A-R1)" || return 1 check_pmtu_value "1500" "${pmtu_a_R2}" "exceeding MTU (veth_A-R2)" || return 1 } +test_pmtu_ipv4_mp_exceptions() { + test_pmtu_ipvX_mp_exceptions 4 +} + +# Find a flow from host A to ${2} that goes out through ${3}: a source +# address out of ${host4_a_net}, added to lo as needed, since the IPv4 +# multipath hash covers addresses only, or an IPv6 flow label for a packet +# sent from ${host6_a_addr} +mp_flow_via() { + family="${1}" + dst="${2}" + oif="${3}" + + for i in $(seq 1 32); do + if [ ${family} -eq 4 ]; then + flow="${host4_a_net}.${i}" + ${ns_a} ip addr add ${flow}/32 dev lo 2>/dev/null + out="$(${ns_a} ip route get ${dst} from ${flow} 2>/dev/null)" + else + flow="${i}" + out="$(${ns_a} ip route get ${dst} from ${host6_a_addr} \ + ipproto 58 flowlabel ${flow} 2>/dev/null)" + fi + case "${out}" in + *" dev ${oif} "*) + echo "${flow}" + return 0 + ;; + esac + done + + return 1 +} + +test_pmtu_ipvX_mp_asym_exceptions() { + family=${1} + + if [ ${family} -eq 4 ]; then + ping=ping + dst="${host4_b_addr}" + else + ping=${ping6} + dst="${host6_b_addr}" + fi + + setup namespaces routing multipath${family} || return $ksft_skip + + trace "${ns_a}" veth_A-R1 "${ns_r1}" veth_R1-A \ + "${ns_r1}" veth_R1-B "${ns_b}" veth_B-R1 \ + "${ns_a}" veth_A-R2 "${ns_r2}" veth_R2-A \ + "${ns_r2}" veth_R2-B "${ns_b}" veth_B-R2 + + if [ ${family} -eq 4 ]; then + # Routes back to the source addresses mp_flow_via() picks + run_cmd ${ns_r1} ip route add ${host4_a_net}.0/24 via ${prefix4}.${a_r1}.2 + run_cmd ${ns_r2} ip route add ${host4_a_net}.0/24 via ${prefix4}.${a_r2}.2 + fi + + # Set up initial MTU values: 1400 behind R1, 1300 behind R2 + mtu "${ns_a}" veth_A-R1 2000 + mtu "${ns_r1}" veth_R1-A 2000 + mtu "${ns_r1}" veth_R1-B 1400 + mtu "${ns_b}" veth_B-R1 1400 + + mtu "${ns_a}" veth_A-R2 2000 + mtu "${ns_r2}" veth_R2-A 2000 + mtu "${ns_r2}" veth_R2-B 1300 + mtu "${ns_b}" veth_B-R2 1300 + + flow_r1="$(mp_flow_via ${family} ${dst} veth_A-R1)" || { + err " no flow through veth_A-R1 found"; return 1; } + flow_r2="$(mp_flow_via ${family} ${dst} veth_A-R2)" || { + err " no flow through veth_A-R2 found"; return 1; } + if [ ${family} -eq 4 ]; then + ping_r1="${ping} -I ${flow_r1}" + ping_r2="${ping} -I ${flow_r2}" + else + ping_r1="${ping} -I ${host6_a_addr} -F ${flow_r1}" + ping_r2="${ping} -I ${host6_a_addr} -F ${flow_r2}" + fi + + # A Packet Too Big from R1 is cached on both paths + run_cmd ${ns_a} ${ping_r1} -q -M want -i 0.1 -c 1 -s 1800 "${dst}" + + pmtu_a_R1="$(route_get_dst_pmtu_from_exception "${ns_a}" "${dst}" oif veth_A-R1)" + pmtu_a_R2="$(route_get_dst_pmtu_from_exception "${ns_a}" "${dst}" oif veth_A-R2)" + check_pmtu_value "1400" "${pmtu_a_R1}" "exceeding MTU via R1 (veth_A-R1)" || return 1 + check_pmtu_value "1400" "${pmtu_a_R2}" "exceeding MTU via R1 (veth_A-R2)" || return 1 + + # The lower MTU behind R2 lowers the PMTU of both paths + run_cmd ${ns_a} ${ping_r2} -q -M want -i 0.1 -c 1 -s 1350 "${dst}" + + pmtu_a_R1="$(route_get_dst_pmtu_from_exception "${ns_a}" "${dst}" oif veth_A-R1)" + pmtu_a_R2="$(route_get_dst_pmtu_from_exception "${ns_a}" "${dst}" oif veth_A-R2)" + check_pmtu_value "1300" "${pmtu_a_R1}" "exceeding MTU via R2 (veth_A-R1)" || return 1 + check_pmtu_value "1300" "${pmtu_a_R2}" "exceeding MTU via R2 (veth_A-R2)" || return 1 +} + +test_pmtu_ipv4_mp_asym_exceptions() { + test_pmtu_ipvX_mp_asym_exceptions 4 +} + +test_pmtu_ipv6_mp_asym_exceptions() { + test_pmtu_ipvX_mp_asym_exceptions 6 +} + +test_pmtu_ipv6_mp_exceptions() { + test_pmtu_ipvX_mp_exceptions 6 +} + usage() { echo echo "$0 [OPTIONS] [TEST]..."
Signature · 1 line
2.56.0
[email protected]
AI reviewThis is an automated message. This series looks like a fix, but its commit messages seem to be missing some information:
Hi!
This is an automated message. This series looks like a fix, but its commit messages seem to be missing some information:
- How the issue was discovered, e.g. hit in production, hit during development, syzbot report, manual code inspection, LLM or static analysis tool scan.
Please do not repost the series just to address the above. Instead, reply to this email with the missing information, so that reviewers can take it into account. If the series needs another revision for other reasons, please include the information in the commit messages then.
The evaluation is done by an LLM so it may be wrong, if you think that is the case please reply and explain.
Quoted 3 lines · netdev-bot+sinfo
- How the issue was discovered, e.g. hit in production, hit during development, syzbot report, manual code inspection, LLM or static analysis tool scan.
Patch 2 (ipv6) is the counterpart of the IPv4 issue fixed in commit 7d3f3b4367f3 ("net: ipv4: Cache pmtu for all packet paths if multipath enabled") [1]: a host with two ECMP uplinks and a smaller MTU further down the path had flows blackholing after a Packet Too Big. The IPv6 side was deferred back then at David's request [2]. The new pmtu.sh tests in patch 3 reproduce it and fail without patch 2.
Patch 1 (ipv4) was found by code inspection while reworking v1 after the Sashiko (LLM) review of it [3]: the same "replace the exception" step that review flagged in the IPv6 code is in the IPv4 fan-out from 7d3f3b4367f3 as well.
[1] https://lore.kernel.org/netdev/[email protected]/
[2] https://lore.kernel.org/netdev/[email protected]/
[3] https://lore.kernel.org/netdev/[email protected]/