Add support for tcp/session buffer chains
[vpp.git] / src / vnet / tcp / tcp_input.c
index 0030cfe..ceb00fc 100644 (file)
@@ -389,14 +389,17 @@ static int
 tcp_update_rtt (tcp_connection_t * tc, u32 ack)
 {
   u32 mrtt = 0;
+  u8 rtx_acked;
+
+  /* Determine if only rtx bytes are acked. TODO fast retransmit */
+  rtx_acked = tc->rto_boff && (tc->bytes_acked <= tc->snd_mss);
 
   /* Karn's rule, part 1. Don't use retransmitted segments to estimate
    * RTT because they're ambiguous. */
-  if (tc->rtt_seq && seq_gt (ack, tc->rtt_seq) && !tc->rto_boff)
+  if (tc->rtt_ts && seq_geq (ack, tc->rtt_seq) && !rtx_acked)
     {
       mrtt = tcp_time_now () - tc->rtt_ts;
     }
-
   /* As per RFC7323 TSecr can be used for RTTM only if the segment advances
    * snd_una, i.e., the left side of the send window:
    * seq_lt (tc->snd_una, ack). Note: last condition could be dropped, we don't
@@ -406,19 +409,22 @@ tcp_update_rtt (tcp_connection_t * tc, u32 ack)
       mrtt = tcp_time_now () - tc->opt.tsecr;
     }
 
+  /* Allow measuring of a new RTT */
+  tc->rtt_ts = 0;
+
+  /* If ACK moves left side of the wnd make sure boff is 0, even if mrtt is
+   * not valid */
+  if (tc->bytes_acked)
+    tc->rto_boff = 0;
+
   /* Ignore dubious measurements */
   if (mrtt == 0 || mrtt > TCP_RTT_MAX)
     return 0;
 
   tcp_estimate_rtt (tc, mrtt);
-
   tc->rto = clib_min (tc->srtt + (tc->rttvar << 2), TCP_RTO_MAX);
 
-  /* Allow measuring of RTT and make sure boff is 0 */
-  tc->rtt_seq = 0;
-  tc->rto_boff = 0;
-
-  return 1;
+  return 0;
 }
 
 /**
@@ -735,7 +741,7 @@ tcp_cc_rcv_ack (tcp_connection_t * tc, vlib_buffer_t * b)
 {
   u8 partial_ack;
 
-  if (tcp_in_cong_recovery (tc))
+  if (tcp_in_fastrecovery (tc))
     {
       partial_ack = seq_lt (tc->snd_una, tc->snd_congestion);
       if (!partial_ack)
@@ -749,6 +755,7 @@ tcp_cc_rcv_ack (tcp_connection_t * tc, vlib_buffer_t * b)
 
          /* Clear retransmitted bytes. XXX should we clear all? */
          tc->rtx_bytes = 0;
+
          tc->cc_algo->rcv_cong_ack (tc, TCP_CC_PARTIALACK);
 
          /* In case snd_nxt is still in the past and output tries to
@@ -772,6 +779,13 @@ tcp_cc_rcv_ack (tcp_connection_t * tc, vlib_buffer_t * b)
       tc->cc_algo->rcv_ack (tc);
       tc->tsecr_last_ack = tc->opt.tsecr;
       tc->rcv_dupacks = 0;
+      if (tcp_in_recovery (tc))
+       {
+         tc->rtx_bytes -= clib_min (tc->bytes_acked, tc->rtx_bytes);
+         tc->rto = clib_min (tc->srtt + (tc->rttvar << 2), TCP_RTO_MAX);
+         if (seq_geq (tc->snd_una, tc->snd_congestion))
+           tcp_recovery_off (tc);
+       }
     }
 }
 
@@ -897,7 +911,7 @@ tcp_rcv_ack (tcp_connection_t * tc, vlib_buffer_t * b,
       tcp_cc_rcv_ack (tc, b);
 
       /* If everything has been acked, stop retransmit timer
-       * otherwise update */
+       * otherwise update. */
       if (tc->snd_una == tc->snd_una_max)
        tcp_retransmit_timer_reset (tc);
       else
@@ -979,9 +993,8 @@ tcp_session_enqueue_data (tcp_connection_t * tc, vlib_buffer_t * b,
       return TCP_ERROR_PURE_ACK;
     }
 
-  written = stream_session_enqueue_data (&tc->connection,
-                                        vlib_buffer_get_current (b),
-                                        data_len, 1 /* queue event */ );
+  written = stream_session_enqueue_data (&tc->connection, b, 0,
+                                        1 /* queue event */ , 1);
 
   TCP_EVT_DBG (TCP_EVT_INPUT, tc, 0, data_len, written);
 
@@ -1039,12 +1052,10 @@ tcp_session_enqueue_ooo (tcp_connection_t * tc, vlib_buffer_t * b,
       return TCP_ERROR_PURE_ACK;
     }
 
-  s0 = stream_session_get (tc->c_s_index, tc->c_thread_index);
-
   /* Enqueue out-of-order data with absolute offset */
-  rv = svm_fifo_enqueue_with_offset (s0->server_rx_fifo,
-                                    vnet_buffer (b)->tcp.seq_number,
-                                    data_len, vlib_buffer_get_current (b));
+  rv = stream_session_enqueue_data (&tc->connection, b,
+                                   vnet_buffer (b)->tcp.seq_number,
+                                   0 /* queue event */ , 0);
 
   /* Nothing written */
   if (rv)
@@ -1061,6 +1072,8 @@ tcp_session_enqueue_ooo (tcp_connection_t * tc, vlib_buffer_t * b,
       ooo_segment_t *newest;
       u32 start, end;
 
+      s0 = stream_session_get (tc->c_s_index, tc->c_thread_index);
+
       /* Get the newest segment from the fifo */
       newest = svm_fifo_newest_ooo_segment (s0->server_rx_fifo);
       start = ooo_segment_offset (s0->server_rx_fifo, newest);
@@ -1778,6 +1791,11 @@ tcp46_rcv_process_inline (vlib_main_t * vm, vlib_node_runtime_t * node,
                  tcp_send_reset (b0, is_ip4);
                  goto drop;
                }
+
+             /* Update rtt and rto */
+             tc0->bytes_acked = 1;
+             tcp_update_rtt (tc0, vnet_buffer (b0)->tcp.ack_number);
+
              /* Switch state to ESTABLISHED */
              tc0->state = TCP_STATE_ESTABLISHED;
 
@@ -2524,6 +2542,7 @@ do {                                                              \
   _(FIN_WAIT_1, TCP_FLAG_FIN, TCP_INPUT_NEXT_RCV_PROCESS, TCP_ERROR_NONE);
   /* FIN confirming that the peer (app) has closed */
   _(FIN_WAIT_2, TCP_FLAG_FIN, TCP_INPUT_NEXT_RCV_PROCESS, TCP_ERROR_NONE);
+  _(FIN_WAIT_2, TCP_FLAG_ACK, TCP_INPUT_NEXT_RCV_PROCESS, TCP_ERROR_NONE);
   _(FIN_WAIT_2, TCP_FLAG_FIN | TCP_FLAG_ACK, TCP_INPUT_NEXT_RCV_PROCESS,
     TCP_ERROR_NONE);
   _(LAST_ACK, TCP_FLAG_ACK, TCP_INPUT_NEXT_RCV_PROCESS, TCP_ERROR_NONE);