From 172cbe6771fd3b98233f71e42ac9c9407d534568 Mon Sep 17 00:00:00 2001 From: Etienne Dechamps Date: Tue, 30 Dec 2014 17:02:38 +0000 Subject: [PATCH] Adjust MTU probe counts. The recently introduced new MTU discovery algorithm converges much faster than the previous one, which allows us to reduce the number of probes required before we can confidently fix the MTU. This commit reduces the number of initial discovery probes from 90 to 20. With the new algorithm this is more than enough to get to the precise (byte-level accuracy) MTU value; in cases of packet loss or weird MTU values for which the algorithm is not optimized, we should get close to the actual value, and then we rely on MTU increase detection (steady state probes) to fine-tune it later if the need arises. This patch also triggers MTU increase detection even if the MTU we have is off by only one byte. Previously we only did that if it was off by at least 8 bytes. Considering that (1) this should happen less often, (2) restarting MTU discovery is cheaper than before and (3) having MTUs that are subtly off from their intended values by just a few bytes sounds like trouble, this sounds like a good idea. --- src/net_packet.c | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) diff --git a/src/net_packet.c b/src/net_packet.c index 2f15bb4e..13970602 100644 --- a/src/net_packet.c +++ b/src/net_packet.c @@ -69,7 +69,7 @@ static void try_fix_mtu(node_t *n) { if(n->mtuprobes < 0) return; - if(n->mtuprobes == 90 || n->minmtu >= n->maxmtu) { + if(n->mtuprobes == 20 || n->minmtu >= n->maxmtu) { if(n->minmtu > n->maxmtu) n->minmtu = n->maxmtu; else @@ -141,10 +141,10 @@ static void udp_probe_h(node_t *n, vpn_packet_t *packet, length_t len) { timeout_add(&n->udp_ping_timeout, &udp_probe_timeout_handler, n, &(struct timeval){udp_discovery_timeout, 0}); } - if(probelen >= n->maxmtu + 8) { + if(probelen >= n->maxmtu + 1) { logger(DEBUG_TRAFFIC, LOG_INFO, "Increase in PMTU to %s (%s) detected, restarting PMTU discovery", n->name, n->hostname); n->maxmtu = MTU; - n->mtuprobes = 30; + n->mtuprobes = 0; return; } @@ -897,8 +897,8 @@ static void try_mtu(node_t *n) { return; } - /* mtuprobes == 0..89: initial discovery, send bursts with 1 second interval, mtuprobes++ - mtuprobes == 90: fix MTU, and go to -1 + /* mtuprobes == 0..19: initial discovery, send bursts with 1 second interval, mtuprobes++ + mtuprobes == 20: fix MTU, and go to -1 mtuprobes == -1: send one >maxmtu probe every pingtimeout */ struct timeval now; @@ -919,8 +919,8 @@ static void try_mtu(node_t *n) { if(n->mtuprobes < 0) { /* After the initial discovery, we only send one >maxmtu probe to detect PMTU increases. */ - if(n->maxmtu + 8 < MTU) - send_udp_probe_packet(n, n->maxmtu + 8); + if(n->maxmtu + 1 < MTU) + send_udp_probe_packet(n, n->maxmtu + 1); } else { /* Decreasing the number of probes per cycle might make the algorithm react faster to lost packets, but it will typically increase convergence time in the no-loss case. */ -- 2.20.1