Ticket #13633: tcp-rfc-6298-7323-updated-rto-calculations-and-semantics.patch

src/add-ons/kernel/network/protocols/tcp/TCPEndpoint.cpp

@@ -436 +436 @@
     fReceiveWindow(socket->receive.buffer_size),
     fReceiveMaxSegmentSize(TCP_DEFAULT_MAX_SEGMENT_SIZE),
     fReceiveQueue(socket->receive.buffer_size),
-    fRoundTripTime(TCP_INITIAL_RTT / kTimestampFactor),
-    fRoundTripDeviation(TCP_INITIAL_RTT / kTimestampFactor),
+    fSmoothedRoundTripTime(0),
+    fRoundTripVariation(0),
+    fSendTime(0),
     fRetransmitTimeout(TCP_INITIAL_RTT),
     fReceivedTimestamp(0),
     fCongestionWindow(0),
@@ -2124 +2125 @@
             return status;
         }
 
+        if(fSendTime == 0 && (segmentLength != 0 || segment.flags & TCP_FLAG_SYNCHRONIZE))
+            fSendTime = tcp_now();
+
         if (shouldStartRetransmitTimer && size > 0) {
             TRACE("starting initial retransmit timer of: %" B_PRIdBIGTIME,
                 fRetransmitTimeout);
@@ -2211 +2215 @@
         if (fSendNext < fSendUnacknowledged)
             fSendNext = fSendUnacknowledged;
 
-        if (segment.options & TCP_HAS_TIMESTAMPS)
-            _UpdateRoundTripTime(tcp_diff_timestamp(segment.timestamp_reply));
-        else {
-            // TODO: Fallback to RFC 793 type estimation; This just resets
-            // any potential exponential back off that happened due to
-            // retransmits.
-            fRetransmitTimeout = TCP_INITIAL_RTT;
+        if (fFlags & FLAG_OPTION_TIMESTAMP) {
+            uint32 flightSize = (fSendMax - fSendUnacknowledged).Number();
+            _UpdateRoundTripTime(tcp_diff_timestamp(segment.timestamp_reply),
+                1 + ((flightSize - 1) / (fSendMaxSegmentSize << 1)));
+        }
+
+        // Karn's algorithm: RTT measurement must not be made using segments that were retransmitted
+        else if (fSendTime > 1 && fSendNext == fSendMax) {
+            _UpdateRoundTripTime(tcp_diff_timestamp(fSendTime), 1);
+            fSendTime = 1;
         }
 
         if (fSendUnacknowledged == fSendMax) {
             TRACE("all acknowledged, cancelling retransmission timer");
             gStackModule->cancel_timer(&fRetransmitTimer);
             T(TimerSet(this, "retransmit", -1));
+
+            fSendTime = 0;
+
         } else {
             TRACE("data acknowledged, resetting retransmission timer to: %"
                 B_PRIdBIGTIME, fRetransmitTimeout);
@@ -2261 +2271 @@
 void
 TCPEndpoint::_Retransmit()
 {
-    TRACE("Retransmit()");
+    if (fState < ESTABLISHED) {
+        fRetransmitTimeout = TCP_SYN_RETRANSMIT_TIMEOUT;
+        fCongestionWindow = fSendMaxSegmentSize;
+    } else {
+        _ResetSlowStart();
 
-    _ResetSlowStart();
-    fSendNext = fSendUnacknowledged;
+        // Do exponential back off of the retransmit timeout
+        fRetransmitTimeout *= 2;
+        if (fRetransmitTimeout > TCP_MAX_RETRANSMIT_TIMEOUT)
+            fRetransmitTimeout = TCP_MAX_RETRANSMIT_TIMEOUT;
+    }
 
-    // Do exponential back off of the retransmit timeout
-    fRetransmitTimeout *= 2;
-    if (fRetransmitTimeout > TCP_MAX_RETRANSMIT_TIMEOUT)
-        fRetransmitTimeout = TCP_MAX_RETRANSMIT_TIMEOUT;
+    TRACE("Retransmit()");
 
+    fSendNext = fSendUnacknowledged;
     _SendQueued();
 }
 
 
 void
-TCPEndpoint::_UpdateRoundTripTime(int32 roundTripTime)
+TCPEndpoint::_UpdateRoundTripTime(int32 roundTripTime, uint32 expectedSamples)
 {
-    int32 rtt = roundTripTime;
-
-    // "smooth" round trip time as per Van Jacobson
-    rtt -= fRoundTripTime / 8;
-    fRoundTripTime += rtt;
-    if (rtt < 0)
-        rtt = -rtt;
-    rtt -= fRoundTripDeviation / 4;
-    fRoundTripDeviation += rtt;
+    if(fSmoothedRoundTripTime == 0) {
+        fSmoothedRoundTripTime = roundTripTime;
+        fRoundTripVariation = roundTripTime >> 1;
+        fRetransmitTimeout = (fSmoothedRoundTripTime + max_c(100, fRoundTripVariation << 2))
+                * kTimestampFactor;
+    } else {
+        int32 delta = fSmoothedRoundTripTime - roundTripTime;
+        if (delta < 0)
+            delta = -delta;
+        fRoundTripVariation += ((delta - fRoundTripVariation) >> 2) / expectedSamples;
+        fSmoothedRoundTripTime += ((roundTripTime - fSmoothedRoundTripTime) >> 3) / expectedSamples;
+        fRetransmitTimeout = (fSmoothedRoundTripTime + max_c(100, fRoundTripVariation << 2))
+            * kTimestampFactor;
+    }
 
-    fRetransmitTimeout = ((fRoundTripTime / 4 + fRoundTripDeviation) / 2)
-        * kTimestampFactor;
     if (fRetransmitTimeout < TCP_MIN_RETRANSMIT_TIMEOUT)
         fRetransmitTimeout = TCP_MIN_RETRANSMIT_TIMEOUT;
 
@@ -2317 +2335 @@
     T(TimerTriggered(endpoint, "retransmit"));
 
     MutexLocker locker(endpoint->fLock);
-    if (!locker.IsLocked())
+    if (!locker.IsLocked() || gStackModule->is_timer_active(timer))
         return;
 
     endpoint->_Retransmit();
@@ -2445 +2463 @@
         fInitialReceiveSequence.Number());
     kprintf("    duplicate acknowledge count: %" B_PRIu32 "\n",
         fDuplicateAcknowledgeCount);
-    kprintf("  round trip time: %" B_PRId32 " (deviation %" B_PRId32 ")\n",
-        fRoundTripTime, fRoundTripDeviation);
+    kprintf("  smoothed round trip time: %" B_PRId32 " (variation %" B_PRId32 ")\n",
+        fSmoothedRoundTripTime, fRoundTripVariation);
     kprintf("  retransmit timeout: %" B_PRId64 "\n", fRetransmitTimeout);
     kprintf("  congestion window: %" B_PRIu32 "\n", fCongestionWindow);
     kprintf("  slow start threshold: %" B_PRIu32 "\n", fSlowStartThreshold);

src/add-ons/kernel/network/protocols/tcp/TCPEndpoint.h

@@ -106 +106 @@
             status_t    _PrepareSendPath(const sockaddr* peer);
             void        _Acknowledged(tcp_segment_header& segment);
             void        _Retransmit();
-            void        _UpdateRoundTripTime(int32 roundTripTime);
+            void        _UpdateRoundTripTime(int32 roundTripTime, uint32 expectedSamples);
             void        _ResetSlowStart();
             void        _DuplicateAcknowledge(tcp_segment_header& segment);
 
@@ -164 +164 @@
     tcp_sequence    fInitialReceiveSequence;
 
     // round trip time and retransmit timeout computation
-    int32           fRoundTripTime;
-    int32           fRoundTripDeviation;
+    int32           fSmoothedRoundTripTime;
+    int32           fRoundTripVariation;
+    uint32          fSendTime;
     bigtime_t       fRetransmitTimeout;
 
     uint32          fReceivedTimestamp;

src/add-ons/kernel/network/protocols/tcp/tcp.h

@@ -193 +193 @@
 #define TCP_MIN_RETRANSMIT_TIMEOUT      200000      // 200 msecs
 // Maximum retransmit timeout (per RFC6298)
 #define TCP_MAX_RETRANSMIT_TIMEOUT      60000000    // 60 secs
+// New value for timeout in case of lost SYN (RFC 6298)
+#define TCP_SYN_RETRANSMIT_TIMEOUT      3000000     // 3 secs
 
 struct tcp_sack {
     uint32 left_edge;