X-Git-Url: https://gerrit.fd.io/r/gitweb?a=blobdiff_plain;f=src%2Fvnet%2Ftcp%2Ftcp_input.c;h=836d69b388275145c3ae7a8119158422ffd6c998;hb=196fce2b62c0d215722dd233aa8bf70a43aa0a66;hp=933f913bc5a22bf19be26c0761ecb5ea42979e1d;hpb=afef8bf22369d10ab8107a63b1e3529ed7dd6c8d;p=vpp.git diff --git a/src/vnet/tcp/tcp_input.c b/src/vnet/tcp/tcp_input.c index 933f913bc5a..836d69b3882 100755 --- a/src/vnet/tcp/tcp_input.c +++ b/src/vnet/tcp/tcp_input.c @@ -136,7 +136,7 @@ tcp_options_parse (tcp_header_t * th, tcp_options_t * to, u8 is_syn) /* Zero out all flags but those set in SYN */ to->flags &= (TCP_OPTS_FLAG_SACK_PERMITTED | TCP_OPTS_FLAG_WSCALE - | TCP_OPTS_FLAG_TSTAMP | TCP_OPTION_MSS); + | TCP_OPTS_FLAG_TSTAMP | TCP_OPTS_FLAG_MSS); for (; opts_len > 0; opts_len -= opt_len, data += opt_len) { @@ -503,13 +503,12 @@ tcp_update_rtt (tcp_connection_t * tc, tcp_rate_sample_t * rs, u32 ack) if (tcp_in_cong_recovery (tc)) { /* Accept rtt estimates for samples that have not been retransmitted */ - if ((tc->flags & TCP_CONN_RATE_SAMPLE) && !(rs->flags & TCP_BTS_IS_RXT)) + if ((tc->cfg_flags & TCP_CFG_F_RATE_SAMPLE) + && !(rs->flags & TCP_BTS_IS_RXT)) { mrtt = rs->rtt_time * THZ; goto estimate_rtt; } - if (tcp_in_recovery (tc)) - return 0; goto done; } @@ -601,7 +600,6 @@ tcp_handle_postponed_dequeues (tcp_worker_ctx_t * wrk) /* Dequeue the newly ACKed bytes */ session_tx_fifo_dequeue_drop (&tc->connection, tc->burst_acked); - tc->burst_acked = 0; tcp_validate_txf_size (tc, tc->snd_una_max - tc->snd_una); if (PREDICT_FALSE (tc->flags & TCP_CONN_PSH_PENDING)) @@ -616,6 +614,8 @@ tcp_handle_postponed_dequeues (tcp_worker_ctx_t * wrk) /* Update pacer based on our new cwnd estimate */ tcp_connection_tx_pacer_update (tc); + + tc->burst_acked = 0; } _vec_len (wrk->pending_deq_acked) = 0; } @@ -631,34 +631,6 @@ tcp_program_dequeue (tcp_worker_ctx_t * wrk, tcp_connection_t * tc) tc->burst_acked += tc->bytes_acked; } -/** - * Check if duplicate ack as per RFC5681 Sec. 2 - */ -static u8 -tcp_ack_is_dupack (tcp_connection_t * tc, vlib_buffer_t * b, u32 prev_snd_wnd, - u32 prev_snd_una) -{ - return ((vnet_buffer (b)->tcp.ack_number == prev_snd_una) - && seq_gt (tc->snd_nxt, tc->snd_una) - && (vnet_buffer (b)->tcp.seq_end == vnet_buffer (b)->tcp.seq_number) - && (prev_snd_wnd == tc->snd_wnd)); -} - -/** - * Checks if ack is a congestion control event. - */ -static u8 -tcp_ack_is_cc_event (tcp_connection_t * tc, vlib_buffer_t * b, - u32 prev_snd_wnd, u32 prev_snd_una, u8 * is_dack) -{ - /* Check if ack is duplicate. Per RFC 6675, ACKs that SACK new data are - * defined to be 'duplicate' */ - *is_dack = tc->sack_sb.last_sacked_bytes - || tcp_ack_is_dupack (tc, b, prev_snd_wnd, prev_snd_una); - - return ((*is_dack || tcp_in_cong_recovery (tc)) && !tcp_is_lost_fin (tc)); -} - #ifndef CLIB_MARCH_VARIANT static u32 scoreboard_hole_index (sack_scoreboard_t * sb, sack_scoreboard_hole_t * hole) @@ -784,9 +756,17 @@ scoreboard_insert_hole (sack_scoreboard_t * sb, u32 prev_index, return hole; } -#endif /* CLIB_MARCH_VARIANT */ -#ifndef CLIB_MARCH_VARIANT +always_inline void +scoreboard_update_sacked_rxt (sack_scoreboard_t * sb, u32 start, u32 end, + u8 has_rxt) +{ + if (!has_rxt || seq_geq (start, sb->high_rxt)) + return; + + sb->rxt_sacked += + seq_lt (end, sb->high_rxt) ? (end - start) : (sb->high_rxt - start); +} always_inline void scoreboard_update_bytes (sack_scoreboard_t * sb, u32 ack, u32 snd_mss) @@ -804,6 +784,8 @@ scoreboard_update_bytes (sack_scoreboard_t * sb, u32 ack, u32 snd_mss) if (!right) { sb->sacked_bytes = sb->high_sacked - ack; + sb->last_sacked_bytes = sb->sacked_bytes + - (old_sacked - sb->last_bytes_delivered); return; } @@ -837,7 +819,7 @@ scoreboard_update_bytes (sack_scoreboard_t * sb, u32 ack, u32 snd_mss) while (right) { sb->lost_bytes += scoreboard_hole_bytes (right); - sb->last_lost_bytes += right->is_lost ? 0 : right->end - right->start; + sb->last_lost_bytes += right->is_lost ? 0 : (right->end - right->start); right->is_lost = 1; left = scoreboard_prev_hole (sb, right); if (!left) @@ -893,6 +875,12 @@ scoreboard_next_rxt_hole (sack_scoreboard_t * sb, /* Rule (3): if hole not lost */ else if (seq_lt (hole->start, sb->high_sacked)) { + /* And we didn't already retransmit it */ + if (seq_leq (hole->end, sb->high_rxt)) + { + sb->cur_rxt_hole = TCP_INVALID_SACK_HOLE_INDEX; + return 0; + } *snd_limited = 0; sb->cur_rxt_hole = scoreboard_hole_index (sb, hole); } @@ -912,10 +900,9 @@ scoreboard_next_rxt_hole (sack_scoreboard_t * sb, return hole; } -#endif /* CLIB_MARCH_VARIANT */ -static void -scoreboard_init_high_rxt (sack_scoreboard_t * sb, u32 snd_una) +void +scoreboard_init_rxt (sack_scoreboard_t * sb, u32 snd_una) { sack_scoreboard_hole_t *hole; hole = scoreboard_first_hole (sb); @@ -928,7 +915,6 @@ scoreboard_init_high_rxt (sack_scoreboard_t * sb, u32 snd_una) sb->rescue_rxt = snd_una - 1; } -#ifndef CLIB_MARCH_VARIANT void scoreboard_init (sack_scoreboard_t * sb) { @@ -950,13 +936,28 @@ scoreboard_clear (sack_scoreboard_t * sb) sb->sacked_bytes = 0; sb->last_sacked_bytes = 0; sb->last_bytes_delivered = 0; - sb->high_sacked = 0; - sb->high_rxt = 0; sb->lost_bytes = 0; sb->last_lost_bytes = 0; sb->cur_rxt_hole = TCP_INVALID_SACK_HOLE_INDEX; sb->is_reneging = 0; } + +void +scoreboard_clear_reneging (sack_scoreboard_t * sb, u32 start, u32 end) +{ + sack_scoreboard_hole_t *last_hole; + + clib_warning ("sack reneging"); + + scoreboard_clear (sb); + last_hole = scoreboard_insert_hole (sb, TCP_INVALID_SACK_HOLE_INDEX, + start, end); + last_hole->is_lost = 1; + sb->tail = scoreboard_hole_index (sb, last_hole); + sb->high_sacked = start; + scoreboard_init_rxt (sb, start); +} + #endif /* CLIB_MARCH_VARIANT */ /** @@ -983,14 +984,18 @@ tcp_rcv_sacks (tcp_connection_t * tc, u32 ack) sack_scoreboard_t *sb = &tc->sack_sb; sack_block_t *blk, *rcv_sacks; u32 blk_index = 0, i, j; + u8 has_rxt; sb->last_sacked_bytes = 0; sb->last_bytes_delivered = 0; + sb->rxt_sacked = 0; - if (!tcp_opts_sack (&tc->rcv_opts) + if (!tcp_opts_sack (&tc->rcv_opts) && !sb->sacked_bytes && sb->head == TCP_INVALID_SACK_HOLE_INDEX) return; + has_rxt = tcp_in_cong_recovery (tc); + /* Remove invalid blocks */ blk = tc->rcv_opts.sacks; while (blk < vec_end (tc->rcv_opts.sacks)) @@ -1094,7 +1099,11 @@ tcp_rcv_sacks (tcp_connection_t * tc, u32 ack) hole = pool_elt_at_index (sb->holes, sb->head); if (PREDICT_FALSE (sb->is_reneging)) - sb->last_bytes_delivered += hole->start - tc->snd_una; + { + sb->last_bytes_delivered += clib_min (hole->start - tc->snd_una, + ack - tc->snd_una); + sb->is_reneging = seq_lt (ack, hole->start); + } while (hole && blk_index < vec_len (rcv_sacks)) { @@ -1121,6 +1130,8 @@ tcp_rcv_sacks (tcp_connection_t * tc, u32 ack) sb->is_reneging = 0; } } + scoreboard_update_sacked_rxt (sb, hole->start, hole->end, + has_rxt); scoreboard_remove_hole (sb, hole); hole = next_hole; } @@ -1129,6 +1140,8 @@ tcp_rcv_sacks (tcp_connection_t * tc, u32 ack) { if (seq_gt (blk->end, hole->start)) { + scoreboard_update_sacked_rxt (sb, hole->start, blk->end, + has_rxt); hole->start = blk->end; } blk_index++; @@ -1145,11 +1158,17 @@ tcp_rcv_sacks (tcp_connection_t * tc, u32 ack) /* Pool might've moved */ hole = scoreboard_get_hole (sb, hole_index); hole->end = blk->start; + + scoreboard_update_sacked_rxt (sb, blk->start, blk->end, + has_rxt); + blk_index++; ASSERT (hole->next == scoreboard_hole_index (sb, next_hole)); } else if (seq_lt (blk->start, hole->end)) { + scoreboard_update_sacked_rxt (sb, blk->start, hole->end, + has_rxt); hole->end = blk->start; } hole = scoreboard_next_hole (sb, hole); @@ -1166,6 +1185,10 @@ tcp_rcv_sacks (tcp_connection_t * tc, u32 ack) ASSERT (sb->head == TCP_INVALID_SACK_HOLE_INDEX || tcp_in_recovery (tc) || sb->is_reneging || sb->holes[sb->head].start == ack); ASSERT (sb->last_lost_bytes <= sb->lost_bytes); + ASSERT ((ack - tc->snd_una) + sb->last_sacked_bytes + - sb->last_bytes_delivered >= sb->rxt_sacked); + ASSERT ((ack - tc->snd_una) >= tc->sack_sb.last_bytes_delivered + || (tc->flags & TCP_CONN_FINSNT)); TCP_EVT (TCP_EVT_CC_SCOREBOARD, tc); } @@ -1209,70 +1232,43 @@ tcp_update_snd_wnd (tcp_connection_t * tc, u32 seq, u32 ack, u32 snd_wnd) } } -#ifndef CLIB_MARCH_VARIANT /** * Init loss recovery/fast recovery. * * Triggered by dup acks as opposed to timer timeout. Note that cwnd is * updated in @ref tcp_cc_handle_event after fast retransmit */ -void +static void tcp_cc_init_congestion (tcp_connection_t * tc) { tcp_fastrecovery_on (tc); tc->snd_congestion = tc->snd_nxt; tc->cwnd_acc_bytes = 0; tc->snd_rxt_bytes = 0; + tc->rxt_delivered = 0; + tc->prr_delivered = 0; + tc->prr_start = tc->snd_una; tc->prev_ssthresh = tc->ssthresh; tc->prev_cwnd = tc->cwnd; - tc->cc_algo->congestion (tc); - tc->fr_occurences += 1; - TCP_EVT (TCP_EVT_CC_EVT, tc, 4); -} -#endif /* CLIB_MARCH_VARIANT */ -static void -tcp_cc_recovery_exit (tcp_connection_t * tc) -{ - tc->rto_boff = 0; - tcp_update_rto (tc); - tc->snd_rxt_ts = 0; - tc->rtt_ts = 0; - tcp_recovery_off (tc); - TCP_EVT (TCP_EVT_CC_EVT, tc, 3); -} + tc->snd_rxt_ts = tcp_tstamp (tc); + tcp_cc_congestion (tc); -#ifndef CLIB_MARCH_VARIANT -void -tcp_cc_fastrecovery_clear (tcp_connection_t * tc) -{ - tc->snd_rxt_bytes = 0; - tc->rcv_dupacks = 0; - tc->rtt_ts = 0; - - tcp_fastrecovery_off (tc); - tcp_fastrecovery_first_off (tc); - tc->flags &= ~TCP_CONN_FRXT_PENDING; + /* Post retransmit update cwnd to ssthresh and account for the + * three segments that have left the network and should've been + * buffered at the receiver XXX */ + if (!tcp_opts_sack_permitted (&tc->rcv_opts)) + tc->cwnd += 3 * tc->snd_mss; - TCP_EVT (TCP_EVT_CC_EVT, tc, 3); + tc->fr_occurences += 1; + TCP_EVT (TCP_EVT_CC_EVT, tc, 4); } -#endif /* CLIB_MARCH_VARIANT */ static void tcp_cc_congestion_undo (tcp_connection_t * tc) { tc->cwnd = tc->prev_cwnd; tc->ssthresh = tc->prev_ssthresh; - tc->rcv_dupacks = 0; - if (tcp_in_recovery (tc)) - { - tcp_cc_recovery_exit (tc); - tc->snd_nxt = seq_max (tc->snd_nxt, tc->snd_congestion); - } - else if (tcp_in_fastrecovery (tc)) - { - tcp_cc_fastrecovery_clear (tc); - } tcp_cc_undo_recovery (tc); ASSERT (tc->rto_boff == 0); TCP_EVT (TCP_EVT_CC_EVT, tc, 5); @@ -1288,48 +1284,96 @@ tcp_cc_is_spurious_timeout_rxt (tcp_connection_t * tc) } static inline u8 -tcp_cc_is_spurious_fast_rxt (tcp_connection_t * tc) +tcp_cc_is_spurious_retransmit (tcp_connection_t * tc) { - return (tcp_in_fastrecovery (tc) - && tc->cwnd > tc->ssthresh + 3 * tc->snd_mss); + return (tcp_cc_is_spurious_timeout_rxt (tc)); } -static u8 -tcp_cc_is_spurious_retransmit (tcp_connection_t * tc) +static inline u8 +tcp_should_fastrecover_sack (tcp_connection_t * tc) { - return (tcp_cc_is_spurious_timeout_rxt (tc) - || tcp_cc_is_spurious_fast_rxt (tc)); + return (tc->sack_sb.lost_bytes + || ((TCP_DUPACK_THRESHOLD - 1) * tc->snd_mss + < tc->sack_sb.sacked_bytes)); +} + +static inline u8 +tcp_should_fastrecover (tcp_connection_t * tc, u8 has_sack) +{ + if (!has_sack) + { + /* If of of the two conditions lower hold, reset dupacks because + * we're probably after timeout (RFC6582 heuristics). + * If Cumulative ack does not cover more than congestion threshold, + * and: + * 1) The following doesn't hold: The congestion window is greater + * than SMSS bytes and the difference between highest_ack + * and prev_highest_ack is at most 4*SMSS bytes + * 2) Echoed timestamp in the last non-dup ack does not equal the + * stored timestamp + */ + if (seq_leq (tc->snd_una, tc->snd_congestion) + && ((!(tc->cwnd > tc->snd_mss + && tc->bytes_acked <= 4 * tc->snd_mss)) + || (tc->rcv_opts.tsecr != tc->tsecr_last_ack))) + { + tc->rcv_dupacks = 0; + return 0; + } + } + return ((tc->rcv_dupacks == TCP_DUPACK_THRESHOLD) + || tcp_should_fastrecover_sack (tc)); } static int tcp_cc_recover (tcp_connection_t * tc) { sack_scoreboard_hole_t *hole; + u8 is_spurious = 0; ASSERT (tcp_in_cong_recovery (tc)); - hole = scoreboard_first_hole (&tc->sack_sb); - if (hole && hole->start == tc->snd_una && hole->end == tc->snd_nxt) - scoreboard_clear (&tc->sack_sb); - if (tcp_cc_is_spurious_retransmit (tc)) { tcp_cc_congestion_undo (tc); - return 1; + is_spurious = 1; } - if (tcp_in_recovery (tc)) - tcp_cc_recovery_exit (tc); - else if (tcp_in_fastrecovery (tc)) + tcp_connection_tx_pacer_reset (tc, tc->cwnd, 0 /* start bucket */ ); + tc->rcv_dupacks = 0; + + /* Previous recovery left us congested. Continue sending as part + * of the current recovery event with an updated snd_congestion */ + if (tc->sack_sb.sacked_bytes) { - tcp_cc_recovered (tc); - tcp_cc_fastrecovery_clear (tc); + tc->snd_congestion = tc->snd_nxt; + tcp_program_retransmit (tc); + return is_spurious; } + tc->rxt_delivered = 0; + tc->snd_rxt_bytes = 0; + tc->snd_rxt_ts = 0; + tc->prr_delivered = 0; + tc->rtt_ts = 0; + tc->flags &= ~TCP_CONN_RXT_PENDING; + + hole = scoreboard_first_hole (&tc->sack_sb); + if (hole && hole->start == tc->snd_una && hole->end == tc->snd_nxt) + scoreboard_clear (&tc->sack_sb); + + if (!tcp_in_recovery (tc) && !is_spurious) + tcp_cc_recovered (tc); + + tcp_fastrecovery_off (tc); + tcp_fastrecovery_first_off (tc); + tcp_recovery_off (tc); + TCP_EVT (TCP_EVT_CC_EVT, tc, 3); + ASSERT (tc->rto_boff == 0); ASSERT (!tcp_in_cong_recovery (tc)); ASSERT (tcp_scoreboard_is_sane_post_recovery (tc)); - return 0; + return is_spurious; } static void @@ -1353,19 +1397,6 @@ tcp_cc_update (tcp_connection_t * tc, tcp_rate_sample_t * rs) tc->snd_congestion = tc->snd_una - 1; } -static u8 -tcp_should_fastrecover_sack (tcp_connection_t * tc) -{ - return (TCP_DUPACK_THRESHOLD - 1) * tc->snd_mss < tc->sack_sb.sacked_bytes; -} - -static u8 -tcp_should_fastrecover (tcp_connection_t * tc) -{ - return (tc->rcv_dupacks == TCP_DUPACK_THRESHOLD - || tcp_should_fastrecover_sack (tc)); -} - /** * One function to rule them all ... and in the darkness bind them */ @@ -1375,106 +1406,81 @@ tcp_cc_handle_event (tcp_connection_t * tc, tcp_rate_sample_t * rs, { u8 has_sack = tcp_opts_sack_permitted (&tc->rcv_opts); + /* If reneging, wait for timer based retransmits */ + if (PREDICT_FALSE (tcp_is_lost_fin (tc) || tc->sack_sb.is_reneging)) + return; + /* - * Already in fast recovery. Return if no data acked, partial acks - * and accounting for segments that have left the network are done - * lower. + * If not in recovery, figure out if we should enter */ - if (tcp_in_fastrecovery (tc)) + if (!tcp_in_cong_recovery (tc)) { - if (!has_sack) - tc->rcv_dupacks++; + ASSERT (is_dack); - if (!tc->bytes_acked) + tc->rcv_dupacks++; + TCP_EVT (TCP_EVT_DUPACK_RCVD, tc, 1); + tcp_cc_rcv_cong_ack (tc, TCP_CC_DUPACK, rs); + + if (tcp_should_fastrecover (tc, has_sack)) { - tcp_program_fastretransmit (tc); - if (!has_sack) - tcp_cc_rcv_cong_ack (tc, TCP_CC_DUPACK, rs); - return; + tcp_cc_init_congestion (tc); + + if (has_sack) + scoreboard_init_rxt (&tc->sack_sb, tc->snd_una); + + tcp_connection_tx_pacer_reset (tc, tc->cwnd, 0 /* start bucket */ ); + tcp_program_retransmit (tc); } + + return; } + /* - * In timer triggered recovery + * Already in recovery */ - else if (tcp_in_recovery (tc)) - { - /* No fast recovery entry at this point */ - if (!tc->bytes_acked) - return; - } + /* - * Duplicate ACK. Check if we should enter fast recovery + * Process (re)transmit feedback. Output path uses this to decide how much + * more data to release into the network */ - else if (is_dack) + if (has_sack) { - TCP_EVT (TCP_EVT_DUPACK_RCVD, tc, 1); - ASSERT (tc->snd_una != tc->snd_nxt || tc->sack_sb.last_sacked_bytes); - - tc->rcv_dupacks++; - - if (tcp_should_fastrecover (tc)) - { - u32 pacer_wnd; - - ASSERT (!tcp_in_fastrecovery (tc)); + if (!tc->bytes_acked && tc->sack_sb.rxt_sacked) + tcp_fastrecovery_first_on (tc); - /* Heuristic to catch potential late dupacks - * after fast retransmit exits */ - if (is_dack && tc->snd_una == tc->snd_congestion - && timestamp_leq (tc->rcv_opts.tsecr, tc->tsecr_last_ack)) - { - tc->rcv_dupacks = 0; - return; - } + tc->rxt_delivered += tc->sack_sb.rxt_sacked; + tc->prr_delivered += tc->bytes_acked + tc->sack_sb.last_sacked_bytes + - tc->sack_sb.last_bytes_delivered; - tcp_cc_init_congestion (tc); - - if (has_sack) - scoreboard_init_high_rxt (&tc->sack_sb, tc->snd_una); - - /* Constrain rate until we get a partial ack */ - pacer_wnd = clib_max (0.1 * tc->cwnd, 2 * tc->snd_mss); - tcp_connection_tx_pacer_reset (tc, pacer_wnd, - 0 /* start bucket */ ); - tcp_program_fastretransmit (tc); - return; - } - else - { - tcp_cc_rcv_cong_ack (tc, TCP_CC_DUPACK, rs); - return; - } + tcp_program_retransmit (tc); } - /* Don't allow entry in fast recovery if still in recovery, for now */ - else if (0 && is_dack && tcp_in_recovery (tc)) + else { - /* If of of the two conditions lower hold, reset dupacks because - * we're probably after timeout (RFC6582 heuristics). - * If Cumulative ack does not cover more than congestion threshold, - * and: - * 1) The following doesn't hold: The congestion window is greater - * than SMSS bytes and the difference between highest_ack - * and prev_highest_ack is at most 4*SMSS bytes - * 2) Echoed timestamp in the last non-dup ack does not equal the - * stored timestamp - */ - if (seq_leq (tc->snd_una, tc->snd_congestion) - && ((!(tc->cwnd > tc->snd_mss - && tc->bytes_acked <= 4 * tc->snd_mss)) - || (tc->rcv_opts.tsecr != tc->tsecr_last_ack))) + if (is_dack) { - tc->rcv_dupacks = 0; - return; + tc->rcv_dupacks += 1; + TCP_EVT (TCP_EVT_DUPACK_RCVD, tc, 1); } - } + tc->rxt_delivered = clib_min (tc->rxt_delivered + tc->bytes_acked, + tc->snd_rxt_bytes); + if (is_dack) + tc->prr_delivered += clib_min (tc->snd_mss, + tc->snd_nxt - tc->snd_una); + else + tc->prr_delivered += tc->bytes_acked - clib_min (tc->bytes_acked, + tc->snd_mss * + tc->rcv_dupacks); - ASSERT (tc->bytes_acked); - TCP_EVT (TCP_EVT_CC_PACK, tc); + /* If partial ack, assume that the first un-acked segment was lost */ + if (tc->bytes_acked || tc->rcv_dupacks == TCP_DUPACK_THRESHOLD) + tcp_fastrecovery_first_on (tc); + + tcp_program_retransmit (tc); + } /* - * Legitimate ACK. 1) See if we can exit recovery + * See if we can exit and stop retransmitting */ - if (seq_geq (tc->snd_una, tc->snd_congestion)) { /* If spurious return, we've already updated everything */ @@ -1490,58 +1496,68 @@ tcp_cc_handle_event (tcp_connection_t * tc, tcp_rate_sample_t * rs, } /* - * Legitimate ACK. 2) If PARTIAL ACK try to retransmit + * Notify cc of the event */ + if (!tc->bytes_acked) + { + tcp_cc_rcv_cong_ack (tc, TCP_CC_DUPACK, rs); + return; + } + /* RFC6675: If the incoming ACK is a cumulative acknowledgment, * reset dupacks to 0. Also needed if in congestion recovery */ tc->rcv_dupacks = 0; - /* Post RTO timeout don't try anything fancy */ if (tcp_in_recovery (tc)) - { - tcp_cc_rcv_ack (tc, rs); - transport_add_tx_event (&tc->connection); - return; - } + tcp_cc_rcv_ack (tc, rs); + else + tcp_cc_rcv_cong_ack (tc, TCP_CC_PARTIALACK, rs); +} - /* Remove retransmitted bytes that have been delivered */ - if (has_sack) - { - ASSERT (tc->bytes_acked >= tc->sack_sb.last_bytes_delivered - || (tc->flags & TCP_CONN_FINSNT)); +static void +tcp_handle_old_ack (tcp_connection_t * tc, tcp_rate_sample_t * rs) +{ + if (!tcp_in_cong_recovery (tc)) + return; - /* If we have sacks and we haven't gotten an ack beyond high_rxt, - * remove sacked bytes delivered */ - if (seq_lt (tc->snd_una, tc->sack_sb.high_rxt)) - { - u32 rxt_delivered; - rxt_delivered = tc->bytes_acked - tc->sack_sb.last_bytes_delivered; - ASSERT (tc->snd_rxt_bytes >= rxt_delivered); - tc->snd_rxt_bytes -= rxt_delivered; - } - else - { - /* Apparently all retransmitted holes have been acked */ - tc->snd_rxt_bytes = 0; - tc->sack_sb.high_rxt = tc->snd_una; - } - } - else - { - tcp_fastrecovery_first_on (tc); - if (tc->snd_rxt_bytes > tc->bytes_acked) - tc->snd_rxt_bytes -= tc->bytes_acked; - else - tc->snd_rxt_bytes = 0; - } + if (tcp_opts_sack_permitted (&tc->rcv_opts)) + tcp_rcv_sacks (tc, tc->snd_una); - tcp_cc_rcv_cong_ack (tc, TCP_CC_PARTIALACK, rs); + tc->bytes_acked = 0; - /* - * Since this was a partial ack, try to retransmit some more data - */ - tcp_program_fastretransmit (tc); + if (tc->cfg_flags & TCP_CFG_F_RATE_SAMPLE) + tcp_bt_sample_delivery_rate (tc, rs); + + tcp_cc_handle_event (tc, rs, 1); +} + +/** + * Check if duplicate ack as per RFC5681 Sec. 2 + */ +always_inline u8 +tcp_ack_is_dupack (tcp_connection_t * tc, vlib_buffer_t * b, u32 prev_snd_wnd, + u32 prev_snd_una) +{ + return ((vnet_buffer (b)->tcp.ack_number == prev_snd_una) + && seq_gt (tc->snd_nxt, tc->snd_una) + && (vnet_buffer (b)->tcp.seq_end == vnet_buffer (b)->tcp.seq_number) + && (prev_snd_wnd == tc->snd_wnd)); +} + +/** + * Checks if ack is a congestion control event. + */ +static u8 +tcp_ack_is_cc_event (tcp_connection_t * tc, vlib_buffer_t * b, + u32 prev_snd_wnd, u32 prev_snd_una, u8 * is_dack) +{ + /* Check if ack is duplicate. Per RFC 6675, ACKs that SACK new data are + * defined to be 'duplicate' as well */ + *is_dack = tc->sack_sb.last_sacked_bytes + || tcp_ack_is_dupack (tc, b, prev_snd_wnd, prev_snd_una); + + return (*is_dack || tcp_in_cong_recovery (tc)); } /** @@ -1581,8 +1597,12 @@ tcp_rcv_ack (tcp_worker_ctx_t * wrk, tcp_connection_t * tc, vlib_buffer_t * b, tc->errors.below_ack_wnd += 1; *error = TCP_ERROR_ACK_OLD; TCP_EVT (TCP_EVT_ACK_RCV_ERR, tc, 1, vnet_buffer (b)->tcp.ack_number); - if (tcp_in_fastrecovery (tc) && tc->rcv_dupacks == TCP_DUPACK_THRESHOLD) - tcp_cc_handle_event (tc, 0, 1); + + if (seq_lt (vnet_buffer (b)->tcp.ack_number, tc->snd_una - tc->rcv_wnd)) + return -1; + + tcp_handle_old_ack (tc, &rs); + /* Don't drop yet */ return 0; } @@ -1605,7 +1625,7 @@ process_ack: tc->snd_una = vnet_buffer (b)->tcp.ack_number; tcp_validate_txf_size (tc, tc->bytes_acked); - if (tc->flags & TCP_CONN_RATE_SAMPLE) + if (tc->cfg_flags & TCP_CFG_F_RATE_SAMPLE) tcp_bt_sample_delivery_rate (tc, &rs); if (tc->bytes_acked) @@ -1684,6 +1704,7 @@ tcp_rcv_fin (tcp_worker_ctx_t * wrk, tcp_connection_t * tc, vlib_buffer_t * b, /* Account for the FIN and send ack */ tc->rcv_nxt += 1; + tc->flags |= TCP_CONN_FINRCVD; tcp_program_ack (tc); /* Enter CLOSE-WAIT and notify session. To avoid lingering * in CLOSE-WAIT, set timer (reuse WAITCLOSE). */ @@ -2259,7 +2280,8 @@ VLIB_REGISTER_NODE (tcp6_established_node) = static u8 -tcp_lookup_is_valid (tcp_connection_t * tc, tcp_header_t * hdr) +tcp_lookup_is_valid (tcp_connection_t * tc, vlib_buffer_t * b, + tcp_header_t * hdr) { transport_connection_t *tmp = 0; u64 handle; @@ -2271,9 +2293,36 @@ tcp_lookup_is_valid (tcp_connection_t * tc, tcp_header_t * hdr) if (tc->c_lcl_port == 0 && tc->state == TCP_STATE_LISTEN) return 1; + u8 is_ip_valid = 0, val_l, val_r; + + if (tc->connection.is_ip4) + { + ip4_header_t *ip4_hdr = (ip4_header_t *) vlib_buffer_get_current (b); + + val_l = !ip4_address_compare (&ip4_hdr->dst_address, + &tc->connection.lcl_ip.ip4); + val_l = val_l || ip_is_zero (&tc->connection.lcl_ip, 1); + val_r = !ip4_address_compare (&ip4_hdr->src_address, + &tc->connection.rmt_ip.ip4); + val_r = val_r || tc->state == TCP_STATE_LISTEN; + is_ip_valid = val_l && val_r; + } + else + { + ip6_header_t *ip6_hdr = (ip6_header_t *) vlib_buffer_get_current (b); + + val_l = !ip6_address_compare (&ip6_hdr->dst_address, + &tc->connection.lcl_ip.ip6); + val_l = val_l || ip_is_zero (&tc->connection.lcl_ip, 0); + val_r = !ip6_address_compare (&ip6_hdr->src_address, + &tc->connection.rmt_ip.ip6); + val_r = val_r || tc->state == TCP_STATE_LISTEN; + is_ip_valid = val_l && val_r; + } + u8 is_valid = (tc->c_lcl_port == hdr->dst_port && (tc->state == TCP_STATE_LISTEN - || tc->c_rmt_port == hdr->src_port)); + || tc->c_rmt_port == hdr->src_port) && is_ip_valid); if (!is_valid) { @@ -2287,6 +2336,7 @@ tcp_lookup_is_valid (tcp_connection_t * tc, tcp_header_t * hdr) && tmp->rmt_port == hdr->src_port) { TCP_DBG ("half-open is valid!"); + is_valid = 1; } } } @@ -2317,7 +2367,7 @@ tcp_lookup_connection (u32 fib_index, vlib_buffer_t * b, u8 thread_index, TRANSPORT_PROTO_TCP, thread_index, &is_filtered); tc = tcp_get_connection_from_transport (tconn); - ASSERT (tcp_lookup_is_valid (tc, tcp)); + ASSERT (tcp_lookup_is_valid (tc, b, tcp)); } else { @@ -2332,11 +2382,41 @@ tcp_lookup_connection (u32 fib_index, vlib_buffer_t * b, u8 thread_index, TRANSPORT_PROTO_TCP, thread_index, &is_filtered); tc = tcp_get_connection_from_transport (tconn); - ASSERT (tcp_lookup_is_valid (tc, tcp)); + ASSERT (tcp_lookup_is_valid (tc, b, tcp)); } return tc; } +static tcp_connection_t * +tcp_lookup_listener (vlib_buffer_t * b, u32 fib_index, int is_ip4) +{ + session_t *s; + + if (is_ip4) + { + ip4_header_t *ip4 = vlib_buffer_get_current (b); + tcp_header_t *tcp = tcp_buffer_hdr (b); + s = session_lookup_listener4 (fib_index, + &ip4->dst_address, + tcp->dst_port, TRANSPORT_PROTO_TCP, 1); + } + else + { + ip6_header_t *ip6 = vlib_buffer_get_current (b); + tcp_header_t *tcp = tcp_buffer_hdr (b); + s = session_lookup_listener6 (fib_index, + &ip6->dst_address, + tcp->dst_port, TRANSPORT_PROTO_TCP, 1); + + } + if (PREDICT_TRUE (s != 0)) + return tcp_get_connection_from_transport (transport_get_listener + (TRANSPORT_PROTO_TCP, + s->connection_index)); + else + return 0; +} + always_inline void tcp_check_tx_offload (tcp_connection_t * tc, int is_ipv4) { @@ -2358,16 +2438,19 @@ tcp_check_tx_offload (tcp_connection_t * tc, int is_ipv4) } lb = load_balance_get (lb_idx); + if (PREDICT_FALSE (lb->lb_n_buckets > 1)) + return; dpo = load_balance_get_bucket_i (lb, 0); - sw_if_idx = dpo->dpoi_index; - hw_if = vnet_get_sup_hw_interface (vnm, sw_if_idx); + sw_if_idx = dpo_get_urpf (dpo); + if (PREDICT_FALSE (sw_if_idx == ~0)) + return; - tc->is_tso = - ((hw_if->flags & VNET_HW_INTERFACE_FLAG_SUPPORTS_GSO) == 0) ? 0 : 1; + hw_if = vnet_get_sup_hw_interface (vnm, sw_if_idx); + if (hw_if->flags & VNET_HW_INTERFACE_FLAG_SUPPORTS_GSO) + tc->cfg_flags |= TCP_CFG_F_TSO; } - always_inline uword tcp46_syn_sent_inline (vlib_main_t * vm, vlib_node_runtime_t * node, vlib_frame_t * from_frame, int is_ip4) @@ -2584,7 +2667,8 @@ tcp46_syn_sent_inline (vlib_main_t * vm, vlib_node_runtime_t * node, goto drop; } - tcp_check_tx_offload (new_tc0, is_ip4); + if (!(new_tc0->cfg_flags & TCP_CFG_F_NO_TSO)) + tcp_check_tx_offload (new_tc0, is_ip4); /* Read data, if any */ if (PREDICT_FALSE (vnet_buffer (b0)->tcp.data_len)) @@ -2596,7 +2680,9 @@ tcp46_syn_sent_inline (vlib_main_t * vm, vlib_node_runtime_t * node, } else { - tcp_program_ack (new_tc0); + /* Send ack now instead of programming it because connection was + * just established and it's not optional. */ + tcp_send_ack (new_tc0); } drop: @@ -2712,14 +2798,17 @@ tcp46_rcv_process_inline (vlib_main_t * vm, vlib_node_runtime_t * node, if (CLIB_DEBUG) { - tcp_connection_t *tmp; - tmp = tcp_lookup_connection (tc0->c_fib_index, b0, thread_index, - is_ip4); - if (tmp->state != tc0->state) + if (!(tc0->connection.flags & TRANSPORT_CONNECTION_F_NO_LOOKUP)) { - if (tc0->state != TCP_STATE_CLOSED) - clib_warning ("state changed"); - goto drop; + tcp_connection_t *tmp; + tmp = tcp_lookup_connection (tc0->c_fib_index, b0, thread_index, + is_ip4); + if (tmp->state != tc0->state) + { + if (tc0->state != TCP_STATE_CLOSED) + clib_warning ("state changed"); + goto drop; + } } } @@ -2767,12 +2856,14 @@ tcp46_rcv_process_inline (vlib_main_t * vm, vlib_node_runtime_t * node, /* Update rtt and rto */ tcp_estimate_initial_rtt (tc0); + tcp_connection_tx_pacer_update (tc0); /* Switch state to ESTABLISHED */ tc0->state = TCP_STATE_ESTABLISHED; TCP_EVT (TCP_EVT_STATE_CHANGE, tc0); - tcp_check_tx_offload (tc0, is_ip4); + if (!(tc0->cfg_flags & TCP_CFG_F_NO_TSO)) + tcp_check_tx_offload (tc0, is_ip4); /* Initialize session variables */ tc0->snd_una = vnet_buffer (b0)->tcp.ack_number; @@ -3108,6 +3199,7 @@ tcp46_listen_inline (vlib_main_t * vm, vlib_node_runtime_t * node, { u32 n_left_from, *from, n_syns = 0, *first_buffer; u32 my_thread_index = vm->thread_index; + tcp_connection_t *tc0; from = first_buffer = vlib_frame_vector_args (from_frame); n_left_from = from_frame->n_vectors; @@ -3129,17 +3221,31 @@ tcp46_listen_inline (vlib_main_t * vm, vlib_node_runtime_t * node, n_left_from -= 1; b0 = vlib_get_buffer (vm, bi0); - lc0 = tcp_listener_get (vnet_buffer (b0)->tcp.connection_index); if (is_ip4) { ip40 = vlib_buffer_get_current (b0); - th0 = ip4_next_header (ip40); + th0 = tcp_buffer_hdr (b0); } else { ip60 = vlib_buffer_get_current (b0); - th0 = ip6_next_header (ip60); + th0 = tcp_buffer_hdr (b0); + } + + lc0 = tcp_listener_get (vnet_buffer (b0)->tcp.connection_index); + if (PREDICT_FALSE (lc0 == 0)) + { + tc0 = tcp_connection_get (vnet_buffer (b0)->tcp.connection_index, + my_thread_index); + if (tc0->state != TCP_STATE_TIME_WAIT) + { + error0 = TCP_ERROR_CREATE_EXISTS; + goto drop; + } + lc0 = tcp_lookup_listener (b0, tc0->c_fib_index, is_ip4); + /* clean up the old session */ + tcp_connection_del (tc0); } /* Create child session. For syn-flood protection use filter */ @@ -3538,8 +3644,8 @@ tcp46_input_inline (vlib_main_t * vm, vlib_node_runtime_t * node, if (PREDICT_TRUE (!tc0 + !tc1 == 0)) { - ASSERT (tcp_lookup_is_valid (tc0, tcp_buffer_hdr (b[0]))); - ASSERT (tcp_lookup_is_valid (tc1, tcp_buffer_hdr (b[1]))); + ASSERT (tcp_lookup_is_valid (tc0, b[0], tcp_buffer_hdr (b[0]))); + ASSERT (tcp_lookup_is_valid (tc1, b[1], tcp_buffer_hdr (b[1]))); vnet_buffer (b[0])->tcp.connection_index = tc0->c_c_index; vnet_buffer (b[1])->tcp.connection_index = tc1->c_c_index; @@ -3551,7 +3657,7 @@ tcp46_input_inline (vlib_main_t * vm, vlib_node_runtime_t * node, { if (PREDICT_TRUE (tc0 != 0)) { - ASSERT (tcp_lookup_is_valid (tc0, tcp_buffer_hdr (b[0]))); + ASSERT (tcp_lookup_is_valid (tc0, b[0], tcp_buffer_hdr (b[0]))); vnet_buffer (b[0])->tcp.connection_index = tc0->c_c_index; tcp_input_dispatch_buffer (tm, tc0, b[0], &next[0], &error0); } @@ -3560,7 +3666,7 @@ tcp46_input_inline (vlib_main_t * vm, vlib_node_runtime_t * node, if (PREDICT_TRUE (tc1 != 0)) { - ASSERT (tcp_lookup_is_valid (tc1, tcp_buffer_hdr (b[1]))); + ASSERT (tcp_lookup_is_valid (tc1, b[1], tcp_buffer_hdr (b[1]))); vnet_buffer (b[1])->tcp.connection_index = tc1->c_c_index; tcp_input_dispatch_buffer (tm, tc1, b[1], &next[1], &error1); } @@ -3588,7 +3694,7 @@ tcp46_input_inline (vlib_main_t * vm, vlib_node_runtime_t * node, is_nolookup); if (PREDICT_TRUE (tc0 != 0)) { - ASSERT (tcp_lookup_is_valid (tc0, tcp_buffer_hdr (b[0]))); + ASSERT (tcp_lookup_is_valid (tc0, b[0], tcp_buffer_hdr (b[0]))); vnet_buffer (b[0])->tcp.connection_index = tc0->c_c_index; tcp_input_dispatch_buffer (tm, tc0, b[0], &next[0], &error0); } @@ -3927,7 +4033,7 @@ do { \ TCP_ERROR_NONE); _(LAST_ACK, TCP_FLAG_SYN | TCP_FLAG_RST | TCP_FLAG_ACK, TCP_INPUT_NEXT_RCV_PROCESS, TCP_ERROR_NONE); - _(TIME_WAIT, TCP_FLAG_SYN, TCP_INPUT_NEXT_RCV_PROCESS, TCP_ERROR_NONE); + _(TIME_WAIT, TCP_FLAG_SYN, TCP_INPUT_NEXT_LISTEN, TCP_ERROR_NONE); _(TIME_WAIT, TCP_FLAG_FIN, TCP_INPUT_NEXT_RCV_PROCESS, TCP_ERROR_NONE); _(TIME_WAIT, TCP_FLAG_FIN | TCP_FLAG_ACK, TCP_INPUT_NEXT_RCV_PROCESS, TCP_ERROR_NONE);