Don't send MTU probes smaller than 512 bytes.

[tinc] / src / net_packet.c

diff --git a/src/net_packet.c b/src/net_packet.c
index 9bebca4..626114c 100644 (file)
--- 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;
                }
 
@@ -157,10 +157,9 @@ static void udp_probe_h(node_t *n, vpn_packet_t *packet, length_t len) {
                        try_fix_mtu(n);
                }
 
-               /* Calculate RTT and bandwidth.
+               /* Calculate RTT.
                   The RTT is the time between the MTU probe burst was sent and the first
-                  reply is received. The bandwidth is measured using the time between the
-                  arrival of the first and third probe reply (or type 2 probe requests).
+                  reply is received.
                 */
 
                struct timeval now, diff;
@@ -180,12 +179,7 @@ static void udp_probe_h(node_t *n, vpn_packet_t *packet, length_t len) {
                if(n->probe_counter == 1) {
                        n->rtt = diff.tv_sec + diff.tv_usec * 1e-6;
                        n->probe_time = probe_timestamp;
-               } else if(n->probe_counter == 3) {
-                       /* TODO: this will never fire - we're not sending batches of three anymore. */
-                       struct timeval probe_timestamp_diff;
-                       timersub(&probe_timestamp, &n->probe_time, &probe_timestamp_diff);
-                       n->bandwidth = 2.0 * probelen / (probe_timestamp_diff.tv_sec + probe_timestamp_diff.tv_usec * 1e-6);
-                       logger(DEBUG_TRAFFIC, LOG_DEBUG, "%s (%s) RTT %.2f ms, burst bandwidth %.3f Mbit/s, rx packet loss %.2f %%", n->name, n->hostname, n->rtt * 1e3, n->bandwidth * 8e-6, n->packetloss * 1e2);
+                       logger(DEBUG_TRAFFIC, LOG_DEBUG, "%s (%s) RTT %.2f ms, rx packet loss %.2f %%", n->name, n->hostname, n->rtt * 1e3, n->packetloss * 1e2);
                }
        }
 }
@@ -903,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;
@@ -925,16 +919,33 @@ 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 {
-               /* Probes are sent with random sizes between the
-                  lower and upper boundaries for the MTU thus far discovered. */
-               int len = n->maxmtu;
-               if(n->minmtu < n->maxmtu)
-                       len = n->minmtu + 1 + rand() % (n->maxmtu - n->minmtu);
-               send_udp_probe_packet(n, MAX(len, 64));
-
+               /* 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. */
+               const length_t probes_per_cycle = 8;
+
+               /* This magic value was determined using math simulations.
+                  It will result in a 1329-byte first probe, followed (if there was a reply) by a 1407-byte probe.
+                  Since 1407 is just below the range of tinc MTUs over typical networks,
+                  this fine-tuning allows tinc to cover a lot of ground very quickly. */
+               const float multiplier = 0.97;
+
+               const float cycle_position = probes_per_cycle - (n->mtuprobes % probes_per_cycle) - 1;
+               const length_t minmtu = MAX(n->minmtu, 512);
+               const float interval = n->maxmtu - minmtu;
+
+               /* The core of the discovery algorithm is this exponential.
+                  It produces very large probes early in the cycle, and then it very quickly decreases the probe size.
+                  This reflects the fact that in the most difficult cases, we don't get any feedback for probes that
+                  are too large, and therefore we need to concentrate on small offsets so that we can quickly converge
+                  on the precise MTU as we are approaching it.
+                  The last probe of the cycle is always 1 byte in size - this is to make sure we'll get at least one
+                  reply per cycle so that we can make progress. */
+               const length_t offset = powf(interval, multiplier * cycle_position / (probes_per_cycle - 1));
+
+               send_udp_probe_packet(n, minmtu + offset);
                if(n->mtuprobes >= 0)
                        n->mtuprobes++;
        }