X-Git-Url: https://gerrit.fd.io/r/gitweb?a=blobdiff_plain;f=src%2Fvnet%2Ftcp%2Ftcp_input.c;h=2ba96a5fe78eb8106471591a9cf917d35d9fd238;hb=9592909ecc1522cf36d4701f998b6f03c738e319;hp=67cec5aa6f27a4afe81b3e9e281991b5ed1effff;hpb=96acc9b04a837c8517b33c5f37f679204b5d5f67;p=vpp.git diff --git a/src/vnet/tcp/tcp_input.c b/src/vnet/tcp/tcp_input.c old mode 100755 new mode 100644 index 67cec5aa6f2..2ba96a5fe78 --- a/src/vnet/tcp/tcp_input.c +++ b/src/vnet/tcp/tcp_input.c @@ -16,8 +16,8 @@ #include #include #include -#include #include +#include #include #include @@ -115,119 +115,6 @@ tcp_segment_in_rcv_wnd (tcp_connection_t * tc, u32 seq, u32 end_seq) && seq_leq (seq, tc->rcv_nxt + tc->rcv_wnd)); } -/** - * Parse TCP header options. - * - * @param th TCP header - * @param to TCP options data structure to be populated - * @param is_syn set if packet is syn - * @return -1 if parsing failed - */ -static inline int -tcp_options_parse (tcp_header_t * th, tcp_options_t * to, u8 is_syn) -{ - const u8 *data; - u8 opt_len, opts_len, kind; - int j; - sack_block_t b; - - opts_len = (tcp_doff (th) << 2) - sizeof (tcp_header_t); - data = (const u8 *) (th + 1); - - /* 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_OPTS_FLAG_MSS); - - for (; opts_len > 0; opts_len -= opt_len, data += opt_len) - { - kind = data[0]; - - /* Get options length */ - if (kind == TCP_OPTION_EOL) - break; - else if (kind == TCP_OPTION_NOOP) - { - opt_len = 1; - continue; - } - else - { - /* broken options */ - if (opts_len < 2) - return -1; - opt_len = data[1]; - - /* weird option length */ - if (opt_len < 2 || opt_len > opts_len) - return -1; - } - - /* Parse options */ - switch (kind) - { - case TCP_OPTION_MSS: - if (!is_syn) - break; - if ((opt_len == TCP_OPTION_LEN_MSS) && tcp_syn (th)) - { - to->flags |= TCP_OPTS_FLAG_MSS; - to->mss = clib_net_to_host_u16 (*(u16 *) (data + 2)); - } - break; - case TCP_OPTION_WINDOW_SCALE: - if (!is_syn) - break; - if ((opt_len == TCP_OPTION_LEN_WINDOW_SCALE) && tcp_syn (th)) - { - to->flags |= TCP_OPTS_FLAG_WSCALE; - to->wscale = data[2]; - if (to->wscale > TCP_MAX_WND_SCALE) - to->wscale = TCP_MAX_WND_SCALE; - } - break; - case TCP_OPTION_TIMESTAMP: - if (is_syn) - to->flags |= TCP_OPTS_FLAG_TSTAMP; - if ((to->flags & TCP_OPTS_FLAG_TSTAMP) - && opt_len == TCP_OPTION_LEN_TIMESTAMP) - { - to->tsval = clib_net_to_host_u32 (*(u32 *) (data + 2)); - to->tsecr = clib_net_to_host_u32 (*(u32 *) (data + 6)); - } - break; - case TCP_OPTION_SACK_PERMITTED: - if (!is_syn) - break; - if (opt_len == TCP_OPTION_LEN_SACK_PERMITTED && tcp_syn (th)) - to->flags |= TCP_OPTS_FLAG_SACK_PERMITTED; - break; - case TCP_OPTION_SACK_BLOCK: - /* If SACK permitted was not advertised or a SYN, break */ - if ((to->flags & TCP_OPTS_FLAG_SACK_PERMITTED) == 0 || tcp_syn (th)) - break; - - /* If too short or not correctly formatted, break */ - if (opt_len < 10 || ((opt_len - 2) % TCP_OPTION_LEN_SACK_BLOCK)) - break; - - to->flags |= TCP_OPTS_FLAG_SACK; - to->n_sack_blocks = (opt_len - 2) / TCP_OPTION_LEN_SACK_BLOCK; - vec_reset_length (to->sacks); - for (j = 0; j < to->n_sack_blocks; j++) - { - b.start = clib_net_to_host_u32 (*(u32 *) (data + 2 + 8 * j)); - b.end = clib_net_to_host_u32 (*(u32 *) (data + 6 + 8 * j)); - vec_add1 (to->sacks, b); - } - break; - default: - /* Nothing to see here */ - continue; - } - } - return 0; -} - /** * RFC1323: Check against wrapped sequence numbers (PAWS). If we have * timestamp to echo and it's less than tsval_recent, drop segment @@ -262,7 +149,7 @@ tcp_update_timestamp (tcp_connection_t * tc, u32 seq, u32 seq_end) { ASSERT (timestamp_leq (tc->tsval_recent, tc->rcv_opts.tsval)); tc->tsval_recent = tc->rcv_opts.tsval; - tc->tsval_recent_age = tcp_time_now_w_thread (tc->c_thread_index); + tc->tsval_recent_age = tcp_time_tstamp (tc->c_thread_index); } } @@ -277,7 +164,7 @@ tcp_handle_rst (tcp_connection_t * tc) tcp_connection_cleanup (tc); break; case TCP_STATE_SYN_SENT: - session_stream_connect_notify (&tc->connection, 1 /* fail */ ); + session_stream_connect_notify (&tc->connection, SESSION_E_REFUSED); tcp_connection_cleanup (tc); break; case TCP_STATE_ESTABLISHED: @@ -328,16 +215,15 @@ tcp_rcv_rst (tcp_worker_ctx_t * wrk, tcp_connection_t * tc) break; case TCP_STATE_SYN_SENT: /* Do not program ntf because the connection is half-open */ + tc->rst_state = tc->state; tcp_handle_rst (tc); break; case TCP_STATE_ESTABLISHED: tcp_connection_timers_reset (tc); - /* Set the cleanup timer, in case the session layer/app don't - * cleanly close the connection */ - tcp_timer_set (tc, TCP_TIMER_WAITCLOSE, tcp_cfg.closewait_time); tcp_cong_recovery_off (tc); tcp_program_reset_ntf (wrk, tc); tcp_connection_set_state (tc, TCP_STATE_CLOSED); + tcp_program_cleanup (wrk, tc); break; case TCP_STATE_CLOSE_WAIT: case TCP_STATE_FIN_WAIT_1: @@ -345,12 +231,12 @@ tcp_rcv_rst (tcp_worker_ctx_t * wrk, tcp_connection_t * tc) case TCP_STATE_CLOSING: case TCP_STATE_LAST_ACK: tcp_connection_timers_reset (tc); - tcp_timer_set (tc, TCP_TIMER_WAITCLOSE, tcp_cfg.closewait_time); tcp_cong_recovery_off (tc); tcp_program_reset_ntf (wrk, tc); /* Make sure we mark the session as closed. In some states we may * be still trying to send data */ tcp_connection_set_state (tc, TCP_STATE_CLOSED); + tcp_program_cleanup (wrk, tc); break; case TCP_STATE_CLOSED: case TCP_STATE_TIME_WAIT: @@ -402,7 +288,7 @@ tcp_segment_validate (tcp_worker_ctx_t * wrk, tcp_connection_t * tc0, /* If it just so happens that a segment updates tsval_recent for a * segment over 24 days old, invalidate tsval_recent. */ if (timestamp_lt (tc0->tsval_recent_age + TCP_PAWS_IDLE, - tcp_time_now_w_thread (tc0->c_thread_index))) + tcp_time_tstamp (tc0->c_thread_index))) { tc0->tsval_recent = tc0->rcv_opts.tsval; clib_warning ("paws failed: 24-day old segment"); @@ -518,7 +404,7 @@ tcp_rcv_ack_no_cc (tcp_connection_t * tc, vlib_buffer_t * b, u32 * error) if (!(seq_leq (tc->snd_una, vnet_buffer (b)->tcp.ack_number) && seq_leq (vnet_buffer (b)->tcp.ack_number, tc->snd_nxt))) { - if (seq_leq (vnet_buffer (b)->tcp.ack_number, tc->snd_una_max) + if (seq_leq (vnet_buffer (b)->tcp.ack_number, tc->snd_nxt) && seq_gt (vnet_buffer (b)->tcp.ack_number, tc->snd_una)) { tc->snd_nxt = vnet_buffer (b)->tcp.ack_number; @@ -538,54 +424,50 @@ acceptable: /** * Compute smoothed RTT as per VJ's '88 SIGCOMM and RFC6298 * - * Note that although the original article, srtt and rttvar are scaled + * Note that although in the original article srtt and rttvar are scaled * to minimize round-off errors, here we don't. Instead, we rely on * better precision time measurements. * - * TODO support us rtt resolution + * A known limitation of the algorithm is that a drop in rtt results in a + * rttvar increase and bigger RTO. + * + * mrtt must be provided in @ref TCP_TICK multiples, i.e., in us. Note that + * timestamps are measured as ms ticks so they must be converted before + * calling this function. */ static void tcp_estimate_rtt (tcp_connection_t * tc, u32 mrtt) { int err, diff; - if (tc->srtt != 0) - { - err = mrtt - tc->srtt; - - /* XXX Drop in RTT results in RTTVAR increase and bigger RTO. - * The increase should be bound */ - tc->srtt = clib_max ((int) tc->srtt + (err >> 3), 1); - diff = (clib_abs (err) - (int) tc->rttvar) >> 2; - tc->rttvar = clib_max ((int) tc->rttvar + diff, 1); - } - else - { - /* First measurement. */ - tc->srtt = mrtt; - tc->rttvar = mrtt >> 1; - } + err = mrtt - tc->srtt; + tc->srtt = clib_max ((int) tc->srtt + (err >> 3), 1); + diff = (clib_abs (err) - (int) tc->rttvar) >> 2; + tc->rttvar = clib_max ((int) tc->rttvar + diff, 1); } -#ifndef CLIB_MARCH_VARIANT -void -tcp_update_rto (tcp_connection_t * tc) +static inline void +tcp_estimate_rtt_us (tcp_connection_t * tc, f64 mrtt) { - tc->rto = clib_min (tc->srtt + (tc->rttvar << 2), TCP_RTO_MAX); - tc->rto = clib_max (tc->rto, TCP_RTO_MIN); + tc->mrtt_us = tc->mrtt_us + (mrtt - tc->mrtt_us) * 0.125; } -#endif /* CLIB_MARCH_VARIANT */ /** - * Update RTT estimate and RTO timer + * Update rtt estimate + * + * We have potentially three sources of rtt measurements: * - * Measure RTT: We have two sources of RTT measurements: TSOPT and ACK - * timing. Middle boxes are known to fiddle with TCP options so we - * should give higher priority to ACK timing. + * TSOPT difference between current and echoed timestamp. It has ms + * precision and can be computed per ack + * ACK timing one sequence number is tracked per rtt with us (micro second) + * precision. + * rate sample if enabled, all outstanding bytes are tracked with us + * precision. Every ack and sack are a rtt sample * - * This should be called only if previously sent bytes have been acked. + * Middle boxes are known to fiddle with TCP options so we give higher + * priority to ACK timing. * - * return 1 if valid rtt 0 otherwise + * For now, rate sample rtts are only used under congestion. */ static int tcp_update_rtt (tcp_connection_t * tc, tcp_rate_sample_t * rs, u32 ack) @@ -597,19 +479,19 @@ 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->cfg_flags & TCP_CFG_F_RATE_SAMPLE) - && !(rs->flags & TCP_BTS_IS_RXT)) - { - mrtt = rs->rtt_time * THZ; - goto estimate_rtt; - } - goto done; + if (!(tc->cfg_flags & TCP_CFG_F_RATE_SAMPLE) + || (rs->flags & TCP_BTS_IS_RXT)) + goto done; + if (rs->rtt_time) + tcp_estimate_rtt_us (tc, rs->rtt_time); + mrtt = rs->rtt_time * THZ; + goto estimate_rtt; } if (tc->rtt_ts && seq_geq (ack, tc->rtt_seq)) { f64 sample = tcp_time_now_us (tc->c_thread_index) - tc->rtt_ts; - tc->mrtt_us = tc->mrtt_us + (sample - tc->mrtt_us) * 0.125; + tcp_estimate_rtt_us (tc, sample); mrtt = clib_max ((u32) (sample * THZ), 1); /* Allow measuring of a new RTT */ tc->rtt_ts = 0; @@ -619,8 +501,8 @@ tcp_update_rtt (tcp_connection_t * tc, tcp_rate_sample_t * rs, u32 ack) * seq_lt (tc->snd_una, ack). This is a condition for calling update_rtt */ else if (tcp_opts_tstamp (&tc->rcv_opts) && tc->rcv_opts.tsecr) { - u32 now = tcp_tstamp (tc); - mrtt = clib_max (now - tc->rcv_opts.tsecr, 1); + mrtt = clib_max (tcp_tstamp (tc) - tc->rcv_opts.tsecr, 1); + mrtt *= TCP_TSTP_TO_HZ; } estimate_rtt: @@ -656,8 +538,8 @@ tcp_estimate_initial_rtt (tcp_connection_t * tc) } else { - mrtt = tcp_time_now_w_thread (thread_index) - tc->rcv_opts.tsecr; - mrtt = clib_max (mrtt, 1); + mrtt = tcp_tstamp (tc) - tc->rcv_opts.tsecr; + mrtt = clib_max (mrtt, 1) * TCP_TSTP_TO_HZ; /* Due to retransmits we don't know the initial mrtt */ if (tc->rto_boff && mrtt > 1 * THZ) mrtt = 1 * THZ; @@ -665,7 +547,11 @@ tcp_estimate_initial_rtt (tcp_connection_t * tc) } if (mrtt > 0 && mrtt < TCP_RTT_MAX) - tcp_estimate_rtt (tc, mrtt); + { + /* First measurement as per RFC 6298 */ + tc->srtt = mrtt; + tc->rttvar = mrtt >> 1; + } tcp_update_rto (tc); } @@ -694,17 +580,14 @@ tcp_handle_postponed_dequeues (tcp_worker_ctx_t * wrk) /* Dequeue the newly ACKed bytes */ session_tx_fifo_dequeue_drop (&tc->connection, tc->burst_acked); - tcp_validate_txf_size (tc, tc->snd_una_max - tc->snd_una); + tcp_validate_txf_size (tc, tc->snd_nxt - tc->snd_una); - if (PREDICT_FALSE (tc->flags & TCP_CONN_PSH_PENDING)) - { - if (seq_leq (tc->psh_seq, tc->snd_una)) - tc->flags &= ~TCP_CONN_PSH_PENDING; - } + if (tcp_is_descheduled (tc)) + tcp_reschedule (tc); /* If everything has been acked, stop retransmit timer * otherwise update. */ - tcp_retransmit_timer_update (tc); + tcp_retransmit_timer_update (&wrk->timer_wheel, tc); /* Update pacer based on our new cwnd estimate */ tcp_connection_tx_pacer_update (tc); @@ -725,569 +608,6 @@ tcp_program_dequeue (tcp_worker_ctx_t * wrk, tcp_connection_t * tc) tc->burst_acked += tc->bytes_acked; } -#ifndef CLIB_MARCH_VARIANT -static u32 -scoreboard_hole_index (sack_scoreboard_t * sb, sack_scoreboard_hole_t * hole) -{ - ASSERT (!pool_is_free_index (sb->holes, hole - sb->holes)); - return hole - sb->holes; -} - -static u32 -scoreboard_hole_bytes (sack_scoreboard_hole_t * hole) -{ - return hole->end - hole->start; -} - -sack_scoreboard_hole_t * -scoreboard_get_hole (sack_scoreboard_t * sb, u32 index) -{ - if (index != TCP_INVALID_SACK_HOLE_INDEX) - return pool_elt_at_index (sb->holes, index); - return 0; -} - -sack_scoreboard_hole_t * -scoreboard_next_hole (sack_scoreboard_t * sb, sack_scoreboard_hole_t * hole) -{ - if (hole->next != TCP_INVALID_SACK_HOLE_INDEX) - return pool_elt_at_index (sb->holes, hole->next); - return 0; -} - -sack_scoreboard_hole_t * -scoreboard_prev_hole (sack_scoreboard_t * sb, sack_scoreboard_hole_t * hole) -{ - if (hole->prev != TCP_INVALID_SACK_HOLE_INDEX) - return pool_elt_at_index (sb->holes, hole->prev); - return 0; -} - -sack_scoreboard_hole_t * -scoreboard_first_hole (sack_scoreboard_t * sb) -{ - if (sb->head != TCP_INVALID_SACK_HOLE_INDEX) - return pool_elt_at_index (sb->holes, sb->head); - return 0; -} - -sack_scoreboard_hole_t * -scoreboard_last_hole (sack_scoreboard_t * sb) -{ - if (sb->tail != TCP_INVALID_SACK_HOLE_INDEX) - return pool_elt_at_index (sb->holes, sb->tail); - return 0; -} - -static void -scoreboard_remove_hole (sack_scoreboard_t * sb, sack_scoreboard_hole_t * hole) -{ - sack_scoreboard_hole_t *next, *prev; - - if (hole->next != TCP_INVALID_SACK_HOLE_INDEX) - { - next = pool_elt_at_index (sb->holes, hole->next); - next->prev = hole->prev; - } - else - { - sb->tail = hole->prev; - } - - if (hole->prev != TCP_INVALID_SACK_HOLE_INDEX) - { - prev = pool_elt_at_index (sb->holes, hole->prev); - prev->next = hole->next; - } - else - { - sb->head = hole->next; - } - - if (scoreboard_hole_index (sb, hole) == sb->cur_rxt_hole) - sb->cur_rxt_hole = TCP_INVALID_SACK_HOLE_INDEX; - - /* Poison the entry */ - if (CLIB_DEBUG > 0) - clib_memset (hole, 0xfe, sizeof (*hole)); - - pool_put (sb->holes, hole); -} - -static sack_scoreboard_hole_t * -scoreboard_insert_hole (sack_scoreboard_t * sb, u32 prev_index, - u32 start, u32 end) -{ - sack_scoreboard_hole_t *hole, *next, *prev; - u32 hole_index; - - pool_get (sb->holes, hole); - clib_memset (hole, 0, sizeof (*hole)); - - hole->start = start; - hole->end = end; - hole_index = scoreboard_hole_index (sb, hole); - - prev = scoreboard_get_hole (sb, prev_index); - if (prev) - { - hole->prev = prev_index; - hole->next = prev->next; - - if ((next = scoreboard_next_hole (sb, hole))) - next->prev = hole_index; - else - sb->tail = hole_index; - - prev->next = hole_index; - } - else - { - sb->head = hole_index; - hole->prev = TCP_INVALID_SACK_HOLE_INDEX; - hole->next = TCP_INVALID_SACK_HOLE_INDEX; - } - - return hole; -} - -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) -{ - sack_scoreboard_hole_t *left, *right; - u32 sacked = 0, blks = 0, old_sacked; - - old_sacked = sb->sacked_bytes; - - sb->last_lost_bytes = 0; - sb->lost_bytes = 0; - sb->sacked_bytes = 0; - - right = scoreboard_last_hole (sb); - if (!right) - { - sb->sacked_bytes = sb->high_sacked - ack; - sb->last_sacked_bytes = sb->sacked_bytes - - (old_sacked - sb->last_bytes_delivered); - return; - } - - if (seq_gt (sb->high_sacked, right->end)) - { - sacked = sb->high_sacked - right->end; - blks = 1; - } - - while (sacked < (TCP_DUPACK_THRESHOLD - 1) * snd_mss - && blks < TCP_DUPACK_THRESHOLD) - { - if (right->is_lost) - sb->lost_bytes += scoreboard_hole_bytes (right); - - left = scoreboard_prev_hole (sb, right); - if (!left) - { - ASSERT (right->start == ack || sb->is_reneging); - sacked += right->start - ack; - right = 0; - break; - } - - sacked += right->start - left->end; - blks++; - right = left; - } - - /* right is first lost */ - while (right) - { - sb->lost_bytes += scoreboard_hole_bytes (right); - sb->last_lost_bytes += right->is_lost ? 0 : (right->end - right->start); - right->is_lost = 1; - left = scoreboard_prev_hole (sb, right); - if (!left) - { - ASSERT (right->start == ack || sb->is_reneging); - sacked += right->start - ack; - break; - } - sacked += right->start - left->end; - right = left; - } - - sb->sacked_bytes = sacked; - sb->last_sacked_bytes = sacked - (old_sacked - sb->last_bytes_delivered); -} - -/** - * Figure out the next hole to retransmit - * - * Follows logic proposed in RFC6675 Sec. 4, NextSeg() - */ -sack_scoreboard_hole_t * -scoreboard_next_rxt_hole (sack_scoreboard_t * sb, - sack_scoreboard_hole_t * start, - u8 have_unsent, u8 * can_rescue, u8 * snd_limited) -{ - sack_scoreboard_hole_t *hole = 0; - - hole = start ? start : scoreboard_first_hole (sb); - while (hole && seq_leq (hole->end, sb->high_rxt) && hole->is_lost) - hole = scoreboard_next_hole (sb, hole); - - /* Nothing, return */ - if (!hole) - { - sb->cur_rxt_hole = TCP_INVALID_SACK_HOLE_INDEX; - return 0; - } - - /* Rule (1): if higher than rxt, less than high_sacked and lost */ - if (hole->is_lost && seq_lt (hole->start, sb->high_sacked)) - { - sb->cur_rxt_hole = scoreboard_hole_index (sb, hole); - } - else - { - /* Rule (2): available unsent data */ - if (have_unsent) - { - sb->cur_rxt_hole = TCP_INVALID_SACK_HOLE_INDEX; - return 0; - } - /* 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); - } - /* Rule (4): if hole beyond high_sacked */ - else - { - ASSERT (seq_geq (hole->start, sb->high_sacked)); - *snd_limited = 1; - *can_rescue = 1; - /* HighRxt MUST NOT be updated */ - return 0; - } - } - - if (hole && seq_lt (sb->high_rxt, hole->start)) - sb->high_rxt = hole->start; - - return hole; -} - -void -scoreboard_init_rxt (sack_scoreboard_t * sb, u32 snd_una) -{ - sack_scoreboard_hole_t *hole; - hole = scoreboard_first_hole (sb); - if (hole) - { - snd_una = seq_gt (snd_una, hole->start) ? snd_una : hole->start; - sb->cur_rxt_hole = sb->head; - } - sb->high_rxt = snd_una; - sb->rescue_rxt = snd_una - 1; -} - -void -scoreboard_init (sack_scoreboard_t * sb) -{ - sb->head = TCP_INVALID_SACK_HOLE_INDEX; - sb->tail = TCP_INVALID_SACK_HOLE_INDEX; - sb->cur_rxt_hole = TCP_INVALID_SACK_HOLE_INDEX; -} - -void -scoreboard_clear (sack_scoreboard_t * sb) -{ - sack_scoreboard_hole_t *hole; - while ((hole = scoreboard_first_hole (sb))) - { - scoreboard_remove_hole (sb, hole); - } - ASSERT (sb->head == sb->tail && sb->head == TCP_INVALID_SACK_HOLE_INDEX); - ASSERT (pool_elts (sb->holes) == 0); - sb->sacked_bytes = 0; - sb->last_sacked_bytes = 0; - sb->last_bytes_delivered = 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 */ - -/** - * Test that scoreboard is sane after recovery - * - * Returns 1 if scoreboard is empty or if first hole beyond - * snd_una. - */ -static u8 -tcp_scoreboard_is_sane_post_recovery (tcp_connection_t * tc) -{ - sack_scoreboard_hole_t *hole; - hole = scoreboard_first_hole (&tc->sack_sb); - return (!hole || (seq_geq (hole->start, tc->snd_una) - && seq_lt (hole->end, tc->snd_nxt))); -} - -#ifndef CLIB_MARCH_VARIANT - -void -tcp_rcv_sacks (tcp_connection_t * tc, u32 ack) -{ - sack_scoreboard_hole_t *hole, *next_hole; - 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) && !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)) - { - if (seq_lt (blk->start, blk->end) - && seq_gt (blk->start, tc->snd_una) - && seq_gt (blk->start, ack) - && seq_lt (blk->start, tc->snd_nxt) - && seq_leq (blk->end, tc->snd_nxt)) - { - blk++; - continue; - } - vec_del1 (tc->rcv_opts.sacks, blk - tc->rcv_opts.sacks); - } - - /* Add block for cumulative ack */ - if (seq_gt (ack, tc->snd_una)) - { - vec_add2 (tc->rcv_opts.sacks, blk, 1); - blk->start = tc->snd_una; - blk->end = ack; - } - - if (vec_len (tc->rcv_opts.sacks) == 0) - return; - - tcp_scoreboard_trace_add (tc, ack); - - /* Make sure blocks are ordered */ - rcv_sacks = tc->rcv_opts.sacks; - for (i = 0; i < vec_len (rcv_sacks); i++) - for (j = i + 1; j < vec_len (rcv_sacks); j++) - if (seq_lt (rcv_sacks[j].start, rcv_sacks[i].start)) - { - sack_block_t tmp = rcv_sacks[i]; - rcv_sacks[i] = rcv_sacks[j]; - rcv_sacks[j] = tmp; - } - - if (sb->head == TCP_INVALID_SACK_HOLE_INDEX) - { - /* Handle reneging as a special case */ - if (PREDICT_FALSE (sb->is_reneging)) - { - /* No holes, only sacked bytes */ - if (seq_leq (tc->snd_nxt, sb->high_sacked)) - { - /* No progress made so return */ - if (seq_leq (ack, tc->snd_una)) - return; - - /* Update sacked bytes delivered and return */ - sb->last_bytes_delivered = ack - tc->snd_una; - sb->sacked_bytes -= sb->last_bytes_delivered; - sb->is_reneging = seq_lt (ack, sb->high_sacked); - return; - } - - /* New hole above high sacked. Add it and process normally */ - hole = scoreboard_insert_hole (sb, TCP_INVALID_SACK_HOLE_INDEX, - sb->high_sacked, tc->snd_nxt); - sb->tail = scoreboard_hole_index (sb, hole); - } - /* Not reneging and no holes. Insert the first that covers all - * outstanding bytes */ - else - { - hole = scoreboard_insert_hole (sb, TCP_INVALID_SACK_HOLE_INDEX, - tc->snd_una, tc->snd_nxt); - sb->tail = scoreboard_hole_index (sb, hole); - } - sb->high_sacked = rcv_sacks[vec_len (rcv_sacks) - 1].end; - } - else - { - /* If we have holes but snd_nxt is beyond the last hole, update - * last hole end or add new hole after high sacked */ - hole = scoreboard_last_hole (sb); - if (seq_gt (tc->snd_nxt, hole->end)) - { - if (seq_geq (hole->start, sb->high_sacked)) - { - hole->end = tc->snd_nxt; - } - /* New hole after high sacked block */ - else if (seq_lt (sb->high_sacked, tc->snd_nxt)) - { - scoreboard_insert_hole (sb, sb->tail, sb->high_sacked, - tc->snd_nxt); - } - } - - /* Keep track of max byte sacked for when the last hole - * is acked */ - sb->high_sacked = seq_max (rcv_sacks[vec_len (rcv_sacks) - 1].end, - sb->high_sacked); - } - - /* Walk the holes with the SACK blocks */ - hole = pool_elt_at_index (sb->holes, sb->head); - - if (PREDICT_FALSE (sb->is_reneging)) - { - 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)) - { - blk = &rcv_sacks[blk_index]; - if (seq_leq (blk->start, hole->start)) - { - /* Block covers hole. Remove hole */ - if (seq_geq (blk->end, hole->end)) - { - next_hole = scoreboard_next_hole (sb, hole); - - /* If covered by ack, compute delivered bytes */ - if (blk->end == ack) - { - u32 sacked = next_hole ? next_hole->start : sb->high_sacked; - if (PREDICT_FALSE (seq_lt (ack, sacked))) - { - sb->last_bytes_delivered += ack - hole->end; - sb->is_reneging = 1; - } - else - { - sb->last_bytes_delivered += sacked - hole->end; - sb->is_reneging = 0; - } - } - scoreboard_update_sacked_rxt (sb, hole->start, hole->end, - has_rxt); - scoreboard_remove_hole (sb, hole); - hole = next_hole; - } - /* Partial 'head' overlap */ - else - { - if (seq_gt (blk->end, hole->start)) - { - scoreboard_update_sacked_rxt (sb, hole->start, blk->end, - has_rxt); - hole->start = blk->end; - } - blk_index++; - } - } - else - { - /* Hole must be split */ - if (seq_lt (blk->end, hole->end)) - { - u32 hole_index = scoreboard_hole_index (sb, hole); - next_hole = scoreboard_insert_hole (sb, hole_index, blk->end, - hole->end); - /* 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); - } - } - - scoreboard_update_bytes (sb, ack, tc->snd_mss); - - ASSERT (sb->last_sacked_bytes <= sb->sacked_bytes || tcp_in_recovery (tc)); - ASSERT (sb->sacked_bytes == 0 || tcp_in_recovery (tc) - || sb->sacked_bytes <= tc->snd_nxt - seq_max (tc->snd_una, ack)); - ASSERT (sb->last_sacked_bytes + sb->lost_bytes <= tc->snd_nxt - - seq_max (tc->snd_una, ack) || tcp_in_recovery (tc)); - 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); -} -#endif /* CLIB_MARCH_VARIANT */ - /** * Try to update snd_wnd based on feedback received from peer. * @@ -1312,11 +632,22 @@ tcp_update_snd_wnd (tcp_connection_t * tc, u32 seq, u32 ack, u32 snd_wnd) /* Set persist timer if not set and we just got 0 wnd */ if (!tcp_timer_is_active (tc, TCP_TIMER_PERSIST) && !tcp_timer_is_active (tc, TCP_TIMER_RETRANSMIT)) - tcp_persist_timer_set (tc); + { + tcp_worker_ctx_t *wrk = tcp_get_worker (tc->c_thread_index); + tcp_persist_timer_set (&wrk->timer_wheel, tc); + } } else { - tcp_persist_timer_reset (tc); + if (PREDICT_FALSE (tcp_timer_is_active (tc, TCP_TIMER_PERSIST))) + { + tcp_worker_ctx_t *wrk = tcp_get_worker (tc->c_thread_index); + tcp_persist_timer_reset (&wrk->timer_wheel, tc); + } + + if (PREDICT_FALSE (tcp_is_descheduled (tc))) + tcp_reschedule (tc); + if (PREDICT_FALSE (!tcp_in_recovery (tc) && tc->rto_boff > 0)) { tc->rto_boff = 0; @@ -1352,7 +683,7 @@ tcp_cc_init_congestion (tcp_connection_t * tc) * 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; + tc->cwnd += TCP_DUPACK_THRESHOLD * tc->snd_mss; tc->fr_occurences += 1; TCP_EVT (TCP_EVT_CC_EVT, tc, 4); @@ -1383,14 +714,6 @@ tcp_cc_is_spurious_retransmit (tcp_connection_t * tc) return (tcp_cc_is_spurious_timeout_rxt (tc)); } -static inline u8 -tcp_should_fastrecover_sack (tcp_connection_t * 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) { @@ -1415,8 +738,7 @@ tcp_should_fastrecover (tcp_connection_t * tc, u8 has_sack) return 0; } } - return ((tc->rcv_dupacks == TCP_DUPACK_THRESHOLD) - || tcp_should_fastrecover_sack (tc)); + return tc->sack_sb.lost_bytes || tc->rcv_dupacks >= tc->sack_sb.reorder; } static int @@ -1467,6 +789,7 @@ tcp_cc_recover (tcp_connection_t * tc) ASSERT (tc->rto_boff == 0); ASSERT (!tcp_in_cong_recovery (tc)); ASSERT (tcp_scoreboard_is_sane_post_recovery (tc)); + return is_spurious; } @@ -1545,8 +868,6 @@ tcp_cc_handle_event (tcp_connection_t * tc, tcp_rate_sample_t * rs, 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_program_retransmit (tc); } else { @@ -1568,8 +889,6 @@ tcp_cc_handle_event (tcp_connection_t * tc, tcp_rate_sample_t * rs, /* 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); } /* @@ -1589,6 +908,8 @@ tcp_cc_handle_event (tcp_connection_t * tc, tcp_rate_sample_t * rs, return; } + tcp_program_retransmit (tc); + /* * Notify cc of the event */ @@ -1672,7 +993,7 @@ tcp_rcv_ack (tcp_worker_ctx_t * wrk, tcp_connection_t * tc, vlib_buffer_t * b, { /* We've probably entered recovery and the peer still has some * of the data we've sent. Update snd_nxt and accept the ack */ - if (seq_leq (vnet_buffer (b)->tcp.ack_number, tc->snd_una_max) + if (seq_leq (vnet_buffer (b)->tcp.ack_number, tc->snd_nxt) && seq_gt (vnet_buffer (b)->tcp.ack_number, tc->snd_una)) { tc->snd_nxt = vnet_buffer (b)->tcp.ack_number; @@ -1722,10 +1043,11 @@ process_ack: if (tc->cfg_flags & TCP_CFG_F_RATE_SAMPLE) tcp_bt_sample_delivery_rate (tc, &rs); - if (tc->bytes_acked) + if (tc->bytes_acked + tc->sack_sb.last_sacked_bytes) { - tcp_program_dequeue (wrk, tc); tcp_update_rtt (tc, &rs, vnet_buffer (b)->tcp.ack_number); + if (tc->bytes_acked) + tcp_program_dequeue (wrk, tc); } TCP_EVT (TCP_EVT_ACK_RCVD, tc); @@ -1797,113 +1119,31 @@ tcp_handle_disconnects (tcp_worker_ctx_t * wrk) tcp_disconnect_pending_off (tc); tcp_handle_rst (tc); } - _vec_len (wrk->pending_resets) = 0; - } -} - -static void -tcp_rcv_fin (tcp_worker_ctx_t * wrk, tcp_connection_t * tc, vlib_buffer_t * b, - u32 * error) -{ - /* Reject out-of-order fins */ - if (vnet_buffer (b)->tcp.seq_end != tc->rcv_nxt) - return; - - /* 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). */ - tcp_connection_set_state (tc, TCP_STATE_CLOSE_WAIT); - tcp_program_disconnect (wrk, tc); - tcp_timer_update (tc, TCP_TIMER_WAITCLOSE, tcp_cfg.closewait_time); - TCP_EVT (TCP_EVT_FIN_RCVD, tc); - *error = TCP_ERROR_FIN_RCVD; -} - -#ifndef CLIB_MARCH_VARIANT -static u8 -tcp_sack_vector_is_sane (sack_block_t * sacks) -{ - int i; - for (i = 1; i < vec_len (sacks); i++) - { - if (sacks[i - 1].end == sacks[i].start) - return 0; - } - return 1; -} - -/** - * Build SACK list as per RFC2018. - * - * Makes sure the first block contains the segment that generated the current - * ACK and the following ones are the ones most recently reported in SACK - * blocks. - * - * @param tc TCP connection for which the SACK list is updated - * @param start Start sequence number of the newest SACK block - * @param end End sequence of the newest SACK block - */ -void -tcp_update_sack_list (tcp_connection_t * tc, u32 start, u32 end) -{ - sack_block_t *new_list = tc->snd_sacks_fl, *block = 0; - int i; - - /* If the first segment is ooo add it to the list. Last write might've moved - * rcv_nxt over the first segment. */ - if (seq_lt (tc->rcv_nxt, start)) - { - vec_add2 (new_list, block, 1); - block->start = start; - block->end = end; - } - - /* Find the blocks still worth keeping. */ - for (i = 0; i < vec_len (tc->snd_sacks); i++) - { - /* Discard if rcv_nxt advanced beyond current block */ - if (seq_leq (tc->snd_sacks[i].start, tc->rcv_nxt)) - continue; - - /* Merge or drop if segment overlapped by the new segment */ - if (block && (seq_geq (tc->snd_sacks[i].end, new_list[0].start) - && seq_leq (tc->snd_sacks[i].start, new_list[0].end))) - { - if (seq_lt (tc->snd_sacks[i].start, new_list[0].start)) - new_list[0].start = tc->snd_sacks[i].start; - if (seq_lt (new_list[0].end, tc->snd_sacks[i].end)) - new_list[0].end = tc->snd_sacks[i].end; - continue; - } - - /* Save to new SACK list if we have space. */ - if (vec_len (new_list) < TCP_MAX_SACK_BLOCKS) - vec_add1 (new_list, tc->snd_sacks[i]); + _vec_len (wrk->pending_resets) = 0; } - - ASSERT (vec_len (new_list) <= TCP_MAX_SACK_BLOCKS); - - /* Replace old vector with new one */ - vec_reset_length (tc->snd_sacks); - tc->snd_sacks_fl = tc->snd_sacks; - tc->snd_sacks = new_list; - - /* Segments should not 'touch' */ - ASSERT (tcp_sack_vector_is_sane (tc->snd_sacks)); } -u32 -tcp_sack_list_bytes (tcp_connection_t * tc) +static void +tcp_rcv_fin (tcp_worker_ctx_t * wrk, tcp_connection_t * tc, vlib_buffer_t * b, + u32 * error) { - u32 bytes = 0, i; - for (i = 0; i < vec_len (tc->snd_sacks); i++) - bytes += tc->snd_sacks[i].end - tc->snd_sacks[i].start; - return bytes; + /* Reject out-of-order fins */ + if (vnet_buffer (b)->tcp.seq_end != tc->rcv_nxt) + return; + + /* 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). */ + tcp_connection_set_state (tc, TCP_STATE_CLOSE_WAIT); + tcp_program_disconnect (wrk, tc); + tcp_timer_update (&wrk->timer_wheel, tc, TCP_TIMER_WAITCLOSE, + tcp_cfg.closewait_time); + TCP_EVT (TCP_EVT_FIN_RCVD, tc); + *error = TCP_ERROR_FIN_RCVD; } -#endif /* CLIB_MARCH_VARIANT */ /** Enqueue data for delivery to application */ static int @@ -1939,11 +1179,15 @@ tcp_session_enqueue_data (tcp_connection_t * tc, vlib_buffer_t * b, } else { + /* Packet made it through for ack processing */ + if (tc->rcv_wnd < tc->snd_mss) + return TCP_ERROR_ZERO_RWND; + return TCP_ERROR_FIFO_FULL; } /* Update SACK list if need be */ - if (tcp_opts_sack_permitted (&tc->rcv_opts)) + if (tcp_opts_sack_permitted (&tc->rcv_opts) && vec_len (tc->snd_sacks)) { /* Remove SACK blocks that have been delivered */ tcp_update_sack_list (tc, tc->rcv_nxt, tc->rcv_nxt); @@ -2004,26 +1248,6 @@ tcp_session_enqueue_ooo (tcp_connection_t * tc, vlib_buffer_t * b, return TCP_ERROR_ENQUEUED_OOO; } -/** - * Check if ACK could be delayed. If ack can be delayed, it should return - * true for a full frame. If we're always acking return 0. - */ -always_inline int -tcp_can_delack (tcp_connection_t * tc) -{ - /* Send ack if ... */ - if (TCP_ALWAYS_ACK - /* just sent a rcv wnd 0 - || (tc->flags & TCP_CONN_SENT_RCV_WND0) != 0 */ - /* constrained to send ack */ - || (tc->flags & TCP_CONN_SNDACK) != 0 - /* we're almost out of tx wnd */ - || tcp_available_cc_snd_space (tc) < 4 * tc->snd_mss) - return 0; - - return 1; -} - static int tcp_buffer_discard_bytes (vlib_buffer_t * b, u32 n_bytes_to_drop) { @@ -2068,6 +1292,10 @@ tcp_segment_rcv (tcp_worker_ctx_t * wrk, tcp_connection_t * tc, ASSERT (n_data_bytes); tc->data_segs_in += 1; + /* Make sure we don't consume trailing bytes */ + if (PREDICT_FALSE (b->current_length > n_data_bytes)) + b->current_length = n_data_bytes; + /* Handle out-of-order data */ if (PREDICT_FALSE (vnet_buffer (b)->tcp.seq_number != tc->rcv_nxt)) { @@ -2079,7 +1307,8 @@ tcp_segment_rcv (tcp_worker_ctx_t * wrk, tcp_connection_t * tc, * retransmissions since we may not have any data to send */ if (seq_leq (vnet_buffer (b)->tcp.seq_end, tc->rcv_nxt)) { - tcp_program_ack (tc); + tcp_program_dupack (tc); + tc->errors.below_data_wnd++; error = TCP_ERROR_SEGMENT_OLD; goto done; } @@ -2111,13 +1340,6 @@ in_order: /* In order data, enqueue. Fifo figures out by itself if any out-of-order * segments can be enqueued after fifo tail offset changes. */ error = tcp_session_enqueue_data (tc, b, n_data_bytes); - if (tcp_can_delack (tc)) - { - if (!tcp_timer_is_active (tc, TCP_TIMER_DELACK)) - tcp_timer_set (tc, TCP_TIMER_DELACK, tcp_cfg.delack_time); - goto done; - } - tcp_program_ack (tc); done: @@ -2255,71 +1477,70 @@ tcp46_established_inline (vlib_main_t * vm, vlib_node_runtime_t * node, { u32 thread_index = vm->thread_index, errors = 0; tcp_worker_ctx_t *wrk = tcp_get_worker (thread_index); - u32 n_left_from, *from, *first_buffer; + vlib_buffer_t *bufs[VLIB_FRAME_SIZE], **b; u16 err_counters[TCP_N_ERROR] = { 0 }; + u32 n_left_from, *from; if (node->flags & VLIB_NODE_FLAG_TRACE) tcp_established_trace_frame (vm, node, frame, is_ip4); - first_buffer = from = vlib_frame_vector_args (frame); + from = vlib_frame_vector_args (frame); n_left_from = frame->n_vectors; + vlib_get_buffers (vm, from, bufs, n_left_from); + b = bufs; + while (n_left_from > 0) { - u32 bi0, error0 = TCP_ERROR_ACK_OK; - vlib_buffer_t *b0; - tcp_header_t *th0; - tcp_connection_t *tc0; + u32 error = TCP_ERROR_ACK_OK; + tcp_connection_t *tc; + tcp_header_t *th; if (n_left_from > 1) { - vlib_buffer_t *pb; - pb = vlib_get_buffer (vm, from[1]); - vlib_prefetch_buffer_header (pb, LOAD); - CLIB_PREFETCH (pb->data, 2 * CLIB_CACHE_LINE_BYTES, LOAD); + vlib_prefetch_buffer_header (b[1], LOAD); + CLIB_PREFETCH (b[1]->data, 2 * CLIB_CACHE_LINE_BYTES, LOAD); } - bi0 = from[0]; - from += 1; - n_left_from -= 1; - - b0 = vlib_get_buffer (vm, bi0); - tc0 = tcp_connection_get (vnet_buffer (b0)->tcp.connection_index, - thread_index); + tc = tcp_connection_get (vnet_buffer (b[0])->tcp.connection_index, + thread_index); - if (PREDICT_FALSE (tc0 == 0)) + if (PREDICT_FALSE (tc == 0)) { - error0 = TCP_ERROR_INVALID_CONNECTION; + error = TCP_ERROR_INVALID_CONNECTION; goto done; } - th0 = tcp_buffer_hdr (b0); + th = tcp_buffer_hdr (b[0]); /* TODO header prediction fast path */ /* 1-4: check SEQ, RST, SYN */ - if (PREDICT_FALSE (tcp_segment_validate (wrk, tc0, b0, th0, &error0))) + if (PREDICT_FALSE (tcp_segment_validate (wrk, tc, b[0], th, &error))) { - TCP_EVT (TCP_EVT_SEG_INVALID, tc0, vnet_buffer (b0)->tcp); + TCP_EVT (TCP_EVT_SEG_INVALID, tc, vnet_buffer (b[0])->tcp); goto done; } /* 5: check the ACK field */ - if (PREDICT_FALSE (tcp_rcv_ack (wrk, tc0, b0, th0, &error0))) + if (PREDICT_FALSE (tcp_rcv_ack (wrk, tc, b[0], th, &error))) goto done; /* 6: check the URG bit TODO */ /* 7: process the segment text */ - if (vnet_buffer (b0)->tcp.data_len) - error0 = tcp_segment_rcv (wrk, tc0, b0); + if (vnet_buffer (b[0])->tcp.data_len) + error = tcp_segment_rcv (wrk, tc, b[0]); /* 8: check the FIN bit */ - if (PREDICT_FALSE (tcp_is_fin (th0))) - tcp_rcv_fin (wrk, tc0, b0, &error0); + if (PREDICT_FALSE (tcp_is_fin (th))) + tcp_rcv_fin (wrk, tc, b[0], &error); done: - tcp_inc_err_counter (err_counters, error0, 1); + tcp_inc_err_counter (err_counters, error, 1); + + n_left_from -= 1; + b += 1; } errors = session_main_flush_enqueue_events (TRANSPORT_PROTO_TCP, @@ -2328,7 +1549,7 @@ tcp46_established_inline (vlib_main_t * vm, vlib_node_runtime_t * node, tcp_store_err_counters (established, err_counters); tcp_handle_postponed_dequeues (wrk); tcp_handle_disconnects (wrk); - vlib_buffer_free (vm, first_buffer, frame->n_vectors); + vlib_buffer_free (vm, from, frame->n_vectors); return frame->n_vectors; } @@ -2524,6 +1745,27 @@ tcp_lookup_listener (vlib_buffer_t * b, u32 fib_index, int is_ip4) return 0; } +static void +tcp46_syn_sent_trace_frame (vlib_main_t *vm, vlib_node_runtime_t *node, + u32 *from, u32 n_bufs) +{ + tcp_connection_t *tc = 0; + tcp_rx_trace_t *t; + vlib_buffer_t *b; + int i; + + for (i = 0; i < n_bufs; i++) + { + b = vlib_get_buffer (vm, from[i]); + if (!(b->flags & VLIB_BUFFER_IS_TRACED)) + continue; + tc = + tcp_half_open_connection_get (vnet_buffer (b)->tcp.connection_index); + t = vlib_add_trace (vm, node, b, sizeof (*t)); + tcp_set_rx_trace_data (t, tc, tcp_buffer_hdr (b), b, 1); + } +} + always_inline void tcp_check_tx_offload (tcp_connection_t * tc, int is_ipv4) { @@ -2554,75 +1796,70 @@ tcp_check_tx_offload (tcp_connection_t * tc, int is_ipv4) return; hw_if = vnet_get_sup_hw_interface (vnm, sw_if_idx); - if (hw_if->flags & VNET_HW_INTERFACE_FLAG_SUPPORTS_GSO) + if (hw_if->caps & VNET_HW_INTERFACE_CAP_SUPPORTS_TCP_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) +tcp46_syn_sent_inline (vlib_main_t *vm, vlib_node_runtime_t *node, + vlib_frame_t *frame, int is_ip4) { - u32 n_left_from, *from, *first_buffer, errors = 0; - u32 my_thread_index = vm->thread_index; - tcp_worker_ctx_t *wrk = tcp_get_worker (my_thread_index); + u32 n_left_from, *from, thread_index = vm->thread_index, errors = 0; + tcp_worker_ctx_t *wrk = tcp_get_worker (thread_index); + vlib_buffer_t *bufs[VLIB_FRAME_SIZE], **b; + + from = vlib_frame_vector_args (frame); + n_left_from = frame->n_vectors; - from = first_buffer = vlib_frame_vector_args (from_frame); - n_left_from = from_frame->n_vectors; + if (PREDICT_FALSE (node->flags & VLIB_NODE_FLAG_TRACE)) + tcp46_syn_sent_trace_frame (vm, node, from, n_left_from); + + vlib_get_buffers (vm, from, bufs, n_left_from); + b = bufs; while (n_left_from > 0) { - u32 bi0, ack0, seq0, error0 = TCP_ERROR_NONE; - tcp_connection_t *tc0, *new_tc0; - tcp_header_t *tcp0 = 0; - tcp_rx_trace_t *t0; - vlib_buffer_t *b0; - - bi0 = from[0]; - from += 1; - n_left_from -= 1; + u32 ack, seq, error = TCP_ERROR_NONE; + tcp_connection_t *tc, *new_tc; + tcp_header_t *tcp; - b0 = vlib_get_buffer (vm, bi0); - tc0 = - tcp_half_open_connection_get (vnet_buffer (b0)->tcp.connection_index); - if (PREDICT_FALSE (tc0 == 0)) + tc = tcp_half_open_connection_get ( + vnet_buffer (b[0])->tcp.connection_index); + if (PREDICT_FALSE (tc == 0)) { - error0 = TCP_ERROR_INVALID_CONNECTION; + error = TCP_ERROR_INVALID_CONNECTION; goto drop; } - /* Half-open completed recently but the connection was't removed - * yet by the owning thread */ - if (PREDICT_FALSE (tc0->flags & TCP_CONN_HALF_OPEN_DONE)) + /* Half-open completed or cancelled recently but the connection + * was't removed yet by the owning thread */ + if (PREDICT_FALSE (tc->flags & TCP_CONN_HALF_OPEN_DONE)) { - /* Make sure the connection actually exists */ - ASSERT (tcp_lookup_connection (tc0->c_fib_index, b0, - my_thread_index, is_ip4)); - error0 = TCP_ERROR_SPURIOUS_SYN_ACK; + error = TCP_ERROR_SPURIOUS_SYN_ACK; goto drop; } - ack0 = vnet_buffer (b0)->tcp.ack_number; - seq0 = vnet_buffer (b0)->tcp.seq_number; - tcp0 = tcp_buffer_hdr (b0); + ack = vnet_buffer (b[0])->tcp.ack_number; + seq = vnet_buffer (b[0])->tcp.seq_number; + tcp = tcp_buffer_hdr (b[0]); /* Crude check to see if the connection handle does not match * the packet. Probably connection just switched to established */ - if (PREDICT_FALSE (tcp0->dst_port != tc0->c_lcl_port - || tcp0->src_port != tc0->c_rmt_port)) + if (PREDICT_FALSE (tcp->dst_port != tc->c_lcl_port || + tcp->src_port != tc->c_rmt_port)) { - error0 = TCP_ERROR_INVALID_CONNECTION; + error = TCP_ERROR_INVALID_CONNECTION; goto drop; } - if (PREDICT_FALSE (!tcp_ack (tcp0) && !tcp_rst (tcp0) - && !tcp_syn (tcp0))) + if (PREDICT_FALSE (!tcp_ack (tcp) && !tcp_rst (tcp) && !tcp_syn (tcp))) { - error0 = TCP_ERROR_SEGMENT_INVALID; + error = TCP_ERROR_SEGMENT_INVALID; goto drop; } /* SYNs consume sequence numbers */ - vnet_buffer (b0)->tcp.seq_end += tcp_is_syn (tcp0); + vnet_buffer (b[0])->tcp.seq_end += tcp_is_syn (tcp); /* * 1. check the ACK bit @@ -2636,20 +1873,20 @@ tcp46_syn_sent_inline (vlib_main_t * vm, vlib_node_runtime_t * node, * and discard the segment. Return. * If SND.UNA =< SEG.ACK =< SND.NXT then the ACK is acceptable. */ - if (tcp_ack (tcp0)) + if (tcp_ack (tcp)) { - if (seq_leq (ack0, tc0->iss) || seq_gt (ack0, tc0->snd_nxt)) + if (seq_leq (ack, tc->iss) || seq_gt (ack, tc->snd_nxt)) { - if (!tcp_rst (tcp0)) - tcp_send_reset_w_pkt (tc0, b0, my_thread_index, is_ip4); - error0 = TCP_ERROR_RCV_WND; + if (!tcp_rst (tcp)) + tcp_send_reset_w_pkt (tc, b[0], thread_index, is_ip4); + error = TCP_ERROR_RCV_WND; goto drop; } /* Make sure ACK is valid */ - if (seq_gt (tc0->snd_una, ack0)) + if (seq_gt (tc->snd_una, ack)) { - error0 = TCP_ERROR_ACK_INVALID; + error = TCP_ERROR_ACK_INVALID; goto drop; } } @@ -2658,13 +1895,13 @@ tcp46_syn_sent_inline (vlib_main_t * vm, vlib_node_runtime_t * node, * 2. check the RST bit */ - if (tcp_rst (tcp0)) + if (tcp_rst (tcp)) { /* If ACK is acceptable, signal client that peer is not * willing to accept connection and drop connection*/ - if (tcp_ack (tcp0)) - tcp_rcv_rst (wrk, tc0); - error0 = TCP_ERROR_RST_RCVD; + if (tcp_ack (tcp)) + tcp_rcv_rst (wrk, tc); + error = TCP_ERROR_RST_RCVD; goto drop; } @@ -2677,140 +1914,139 @@ tcp46_syn_sent_inline (vlib_main_t * vm, vlib_node_runtime_t * node, */ /* No SYN flag. Drop. */ - if (!tcp_syn (tcp0)) + if (!tcp_syn (tcp)) { - error0 = TCP_ERROR_SEGMENT_INVALID; + error = TCP_ERROR_SEGMENT_INVALID; goto drop; } /* Parse options */ - if (tcp_options_parse (tcp0, &tc0->rcv_opts, 1)) + if (tcp_options_parse (tcp, &tc->rcv_opts, 1)) { - error0 = TCP_ERROR_OPTIONS; + error = TCP_ERROR_OPTIONS; goto drop; } /* Valid SYN or SYN-ACK. Move connection from half-open pool to * current thread pool. */ - new_tc0 = tcp_connection_alloc_w_base (my_thread_index, tc0); - new_tc0->rcv_nxt = vnet_buffer (b0)->tcp.seq_end; - new_tc0->irs = seq0; - new_tc0->timers[TCP_TIMER_RETRANSMIT_SYN] = TCP_TIMER_HANDLE_INVALID; - new_tc0->sw_if_index = vnet_buffer (b0)->sw_if_index[VLIB_RX]; - - /* If this is not the owning thread, wait for syn retransmit to - * expire and cleanup then */ - if (tcp_half_open_connection_cleanup (tc0)) - tc0->flags |= TCP_CONN_HALF_OPEN_DONE; + new_tc = tcp_connection_alloc_w_base (thread_index, tc); + new_tc->rcv_nxt = vnet_buffer (b[0])->tcp.seq_end; + new_tc->irs = seq; + new_tc->timers[TCP_TIMER_RETRANSMIT_SYN] = TCP_TIMER_HANDLE_INVALID; + new_tc->sw_if_index = vnet_buffer (b[0])->sw_if_index[VLIB_RX]; - if (tcp_opts_tstamp (&new_tc0->rcv_opts)) + if (tcp_opts_tstamp (&new_tc->rcv_opts)) { - new_tc0->tsval_recent = new_tc0->rcv_opts.tsval; - new_tc0->tsval_recent_age = tcp_time_now (); + new_tc->tsval_recent = new_tc->rcv_opts.tsval; + new_tc->tsval_recent_age = tcp_time_tstamp (thread_index); } - if (tcp_opts_wscale (&new_tc0->rcv_opts)) - new_tc0->snd_wscale = new_tc0->rcv_opts.wscale; + if (tcp_opts_wscale (&new_tc->rcv_opts)) + new_tc->snd_wscale = new_tc->rcv_opts.wscale; else - new_tc0->rcv_wscale = 0; + new_tc->rcv_wscale = 0; - new_tc0->snd_wnd = clib_net_to_host_u16 (tcp0->window) - << new_tc0->snd_wscale; - new_tc0->snd_wl1 = seq0; - new_tc0->snd_wl2 = ack0; + new_tc->snd_wnd = clib_net_to_host_u16 (tcp->window) + << new_tc->snd_wscale; + new_tc->snd_wl1 = seq; + new_tc->snd_wl2 = ack; - tcp_connection_init_vars (new_tc0); + tcp_connection_init_vars (new_tc); /* SYN-ACK: See if we can switch to ESTABLISHED state */ - if (PREDICT_TRUE (tcp_ack (tcp0))) + if (PREDICT_TRUE (tcp_ack (tcp))) { /* Our SYN is ACKed: we have iss < ack = snd_una */ /* TODO Dequeue acknowledged segments if we support Fast Open */ - new_tc0->snd_una = ack0; - new_tc0->state = TCP_STATE_ESTABLISHED; + new_tc->snd_una = ack; + new_tc->state = TCP_STATE_ESTABLISHED; /* Make sure las is initialized for the wnd computation */ - new_tc0->rcv_las = new_tc0->rcv_nxt; + new_tc->rcv_las = new_tc->rcv_nxt; /* Notify app that we have connection. If session layer can't * allocate session send reset */ - if (session_stream_connect_notify (&new_tc0->connection, 0)) + if (session_stream_connect_notify (&new_tc->connection, + SESSION_E_NONE)) { - tcp_send_reset_w_pkt (new_tc0, b0, my_thread_index, is_ip4); - tcp_connection_cleanup (new_tc0); - error0 = TCP_ERROR_CREATE_SESSION_FAIL; - goto drop; + tcp_send_reset_w_pkt (new_tc, b[0], thread_index, is_ip4); + tcp_connection_cleanup (new_tc); + error = TCP_ERROR_CREATE_SESSION_FAIL; + goto cleanup_ho; } - new_tc0->tx_fifo_size = - transport_tx_fifo_size (&new_tc0->connection); + transport_fifos_init_ooo (&new_tc->connection); + new_tc->tx_fifo_size = transport_tx_fifo_size (&new_tc->connection); /* Update rtt with the syn-ack sample */ - tcp_estimate_initial_rtt (new_tc0); - TCP_EVT (TCP_EVT_SYNACK_RCVD, new_tc0); - error0 = TCP_ERROR_SYN_ACKS_RCVD; + tcp_estimate_initial_rtt (new_tc); + TCP_EVT (TCP_EVT_SYNACK_RCVD, new_tc); + error = TCP_ERROR_SYN_ACKS_RCVD; } /* SYN: Simultaneous open. Change state to SYN-RCVD and send SYN-ACK */ else { - new_tc0->state = TCP_STATE_SYN_RCVD; + new_tc->state = TCP_STATE_SYN_RCVD; /* Notify app that we have connection */ - if (session_stream_connect_notify (&new_tc0->connection, 0)) + if (session_stream_connect_notify (&new_tc->connection, + SESSION_E_NONE)) { - tcp_connection_cleanup (new_tc0); - tcp_send_reset_w_pkt (tc0, b0, my_thread_index, is_ip4); - TCP_EVT (TCP_EVT_RST_SENT, tc0); - error0 = TCP_ERROR_CREATE_SESSION_FAIL; - goto drop; + tcp_connection_cleanup (new_tc); + tcp_send_reset_w_pkt (tc, b[0], thread_index, is_ip4); + TCP_EVT (TCP_EVT_RST_SENT, tc); + error = TCP_ERROR_CREATE_SESSION_FAIL; + goto cleanup_ho; } - new_tc0->tx_fifo_size = - transport_tx_fifo_size (&new_tc0->connection); - new_tc0->rtt_ts = 0; - tcp_init_snd_vars (new_tc0); - tcp_send_synack (new_tc0); - error0 = TCP_ERROR_SYNS_RCVD; - goto drop; + transport_fifos_init_ooo (&new_tc->connection); + new_tc->tx_fifo_size = transport_tx_fifo_size (&new_tc->connection); + new_tc->rtt_ts = 0; + tcp_init_snd_vars (new_tc); + tcp_send_synack (new_tc); + error = TCP_ERROR_SYNS_RCVD; + goto cleanup_ho; } - if (!(new_tc0->cfg_flags & TCP_CFG_F_NO_TSO)) - tcp_check_tx_offload (new_tc0, is_ip4); + if (!(new_tc->cfg_flags & TCP_CFG_F_NO_TSO)) + tcp_check_tx_offload (new_tc, is_ip4); /* Read data, if any */ - if (PREDICT_FALSE (vnet_buffer (b0)->tcp.data_len)) + if (PREDICT_FALSE (vnet_buffer (b[0])->tcp.data_len)) { clib_warning ("rcvd data in syn-sent"); - error0 = tcp_segment_rcv (wrk, new_tc0, b0); - if (error0 == TCP_ERROR_ACK_OK) - error0 = TCP_ERROR_SYN_ACKS_RCVD; + error = tcp_segment_rcv (wrk, new_tc, b[0]); + if (error == TCP_ERROR_ACK_OK) + error = TCP_ERROR_SYN_ACKS_RCVD; } else { /* Send ack now instead of programming it because connection was * just established and it's not optional. */ - tcp_send_ack (new_tc0); + tcp_send_ack (new_tc); } + cleanup_ho: + + /* If this is not the owning thread, wait for syn retransmit to + * expire and cleanup then */ + if (tcp_half_open_connection_cleanup (tc)) + tc->flags |= TCP_CONN_HALF_OPEN_DONE; + drop: - tcp_inc_counter (syn_sent, error0, 1); - if (PREDICT_FALSE ((b0->flags & VLIB_BUFFER_IS_TRACED) && tcp0 != 0)) - { - t0 = vlib_add_trace (vm, node, b0, sizeof (*t0)); - clib_memcpy_fast (&t0->tcp_header, tcp0, sizeof (t0->tcp_header)); - clib_memcpy_fast (&t0->tcp_connection, tc0, - sizeof (t0->tcp_connection)); - } + b += 1; + n_left_from -= 1; + tcp_inc_counter (syn_sent, error, 1); } - errors = session_main_flush_enqueue_events (TRANSPORT_PROTO_TCP, - my_thread_index); + errors = + session_main_flush_enqueue_events (TRANSPORT_PROTO_TCP, thread_index); tcp_inc_counter (syn_sent, TCP_ERROR_MSG_QUEUE_FULL, errors); - vlib_buffer_free (vm, first_buffer, from_frame->n_vectors); + vlib_buffer_free (vm, from, frame->n_vectors); tcp_handle_disconnects (wrk); - return from_frame->n_vectors; + return frame->n_vectors; } VLIB_NODE_FN (tcp4_syn_sent_node) (vlib_main_t * vm, @@ -2865,55 +2101,77 @@ VLIB_REGISTER_NODE (tcp6_syn_sent_node) = }; /* *INDENT-ON* */ +static void +tcp46_rcv_process_trace_frame (vlib_main_t *vm, vlib_node_runtime_t *node, + u32 *from, u32 n_bufs) +{ + u32 thread_index = vm->thread_index; + tcp_connection_t *tc = 0; + tcp_rx_trace_t *t; + vlib_buffer_t *b; + int i; + + for (i = 0; i < n_bufs; i++) + { + b = vlib_get_buffer (vm, from[i]); + if (!(b->flags & VLIB_BUFFER_IS_TRACED)) + continue; + tc = tcp_connection_get (vnet_buffer (b)->tcp.connection_index, + thread_index); + t = vlib_add_trace (vm, node, b, sizeof (*t)); + tcp_set_rx_trace_data (t, tc, tcp_buffer_hdr (b), b, 1); + } +} + /** * Handles reception for all states except LISTEN, SYN-SENT and ESTABLISHED * as per RFC793 p. 64 */ always_inline uword -tcp46_rcv_process_inline (vlib_main_t * vm, vlib_node_runtime_t * node, - vlib_frame_t * from_frame, int is_ip4) +tcp46_rcv_process_inline (vlib_main_t *vm, vlib_node_runtime_t *node, + vlib_frame_t *frame, int is_ip4) { - u32 thread_index = vm->thread_index, errors = 0, *first_buffer; + u32 thread_index = vm->thread_index, errors, n_left_from, *from, max_deq; tcp_worker_ctx_t *wrk = tcp_get_worker (thread_index); - u32 n_left_from, *from, max_dequeue; + vlib_buffer_t *bufs[VLIB_FRAME_SIZE], **b; - from = first_buffer = vlib_frame_vector_args (from_frame); - n_left_from = from_frame->n_vectors; + from = vlib_frame_vector_args (frame); + n_left_from = frame->n_vectors; + + if (PREDICT_FALSE (node->flags & VLIB_NODE_FLAG_TRACE)) + tcp46_rcv_process_trace_frame (vm, node, from, n_left_from); + + vlib_get_buffers (vm, from, bufs, n_left_from); + b = bufs; while (n_left_from > 0) { - u32 bi0, error0 = TCP_ERROR_NONE; - tcp_header_t *tcp0 = 0; - tcp_connection_t *tc0; - vlib_buffer_t *b0; - u8 is_fin0; - - bi0 = from[0]; - from += 1; - n_left_from -= 1; + u32 error = TCP_ERROR_NONE; + tcp_header_t *tcp = 0; + tcp_connection_t *tc; + u8 is_fin; - b0 = vlib_get_buffer (vm, bi0); - tc0 = tcp_connection_get (vnet_buffer (b0)->tcp.connection_index, - thread_index); - if (PREDICT_FALSE (tc0 == 0)) + tc = tcp_connection_get (vnet_buffer (b[0])->tcp.connection_index, + thread_index); + if (PREDICT_FALSE (tc == 0)) { - error0 = TCP_ERROR_INVALID_CONNECTION; + error = TCP_ERROR_INVALID_CONNECTION; goto drop; } - tcp0 = tcp_buffer_hdr (b0); - is_fin0 = tcp_is_fin (tcp0); + tcp = tcp_buffer_hdr (b[0]); + is_fin = tcp_is_fin (tcp); if (CLIB_DEBUG) { - if (!(tc0->connection.flags & TRANSPORT_CONNECTION_F_NO_LOOKUP)) + if (!(tc->connection.flags & TRANSPORT_CONNECTION_F_NO_LOOKUP)) { tcp_connection_t *tmp; - tmp = tcp_lookup_connection (tc0->c_fib_index, b0, thread_index, + tmp = tcp_lookup_connection (tc->c_fib_index, b[0], thread_index, is_ip4); - if (tmp->state != tc0->state) + if (tmp->state != tc->state) { - if (tc0->state != TCP_STATE_CLOSED) + if (tc->state != TCP_STATE_CLOSED) clib_warning ("state changed"); goto drop; } @@ -2923,9 +2181,9 @@ tcp46_rcv_process_inline (vlib_main_t * vm, vlib_node_runtime_t * node, /* * Special treatment for CLOSED */ - if (PREDICT_FALSE (tc0->state == TCP_STATE_CLOSED)) + if (PREDICT_FALSE (tc->state == TCP_STATE_CLOSED)) { - error0 = TCP_ERROR_CONNECTION_CLOSED; + error = TCP_ERROR_CONNECTION_CLOSED; goto drop; } @@ -2934,19 +2192,19 @@ tcp46_rcv_process_inline (vlib_main_t * vm, vlib_node_runtime_t * node, */ /* 1-4: check SEQ, RST, SYN */ - if (PREDICT_FALSE (tcp_segment_validate (wrk, tc0, b0, tcp0, &error0))) + if (PREDICT_FALSE (tcp_segment_validate (wrk, tc, b[0], tcp, &error))) goto drop; /* 5: check the ACK field */ - switch (tc0->state) + switch (tc->state) { case TCP_STATE_SYN_RCVD: /* Make sure the segment is exactly right */ - if (tc0->rcv_nxt != vnet_buffer (b0)->tcp.seq_number || is_fin0) + if (tc->rcv_nxt != vnet_buffer (b[0])->tcp.seq_number || is_fin) { - tcp_send_reset_w_pkt (tc0, b0, thread_index, is_ip4); - error0 = TCP_ERROR_SEGMENT_INVALID; + tcp_send_reset_w_pkt (tc, b[0], thread_index, is_ip4); + error = TCP_ERROR_SEGMENT_INVALID; goto drop; } @@ -2956,47 +2214,47 @@ tcp46_rcv_process_inline (vlib_main_t * vm, vlib_node_runtime_t * node, * * and send it. */ - if (tcp_rcv_ack_no_cc (tc0, b0, &error0)) + if (tcp_rcv_ack_no_cc (tc, b[0], &error)) { - tcp_send_reset_w_pkt (tc0, b0, thread_index, is_ip4); - error0 = TCP_ERROR_SEGMENT_INVALID; + tcp_send_reset_w_pkt (tc, b[0], thread_index, is_ip4); + error = TCP_ERROR_SEGMENT_INVALID; goto drop; } /* Update rtt and rto */ - tcp_estimate_initial_rtt (tc0); - tcp_connection_tx_pacer_update (tc0); + tcp_estimate_initial_rtt (tc); + tcp_connection_tx_pacer_update (tc); /* Switch state to ESTABLISHED */ - tc0->state = TCP_STATE_ESTABLISHED; - TCP_EVT (TCP_EVT_STATE_CHANGE, tc0); + tc->state = TCP_STATE_ESTABLISHED; + TCP_EVT (TCP_EVT_STATE_CHANGE, tc); - if (!(tc0->cfg_flags & TCP_CFG_F_NO_TSO)) - tcp_check_tx_offload (tc0, is_ip4); + if (!(tc->cfg_flags & TCP_CFG_F_NO_TSO)) + tcp_check_tx_offload (tc, is_ip4); /* Initialize session variables */ - tc0->snd_una = vnet_buffer (b0)->tcp.ack_number; - tc0->snd_wnd = clib_net_to_host_u16 (tcp0->window) - << tc0->rcv_opts.wscale; - tc0->snd_wl1 = vnet_buffer (b0)->tcp.seq_number; - tc0->snd_wl2 = vnet_buffer (b0)->tcp.ack_number; + tc->snd_una = vnet_buffer (b[0])->tcp.ack_number; + tc->snd_wnd = clib_net_to_host_u16 (tcp->window) + << tc->rcv_opts.wscale; + tc->snd_wl1 = vnet_buffer (b[0])->tcp.seq_number; + tc->snd_wl2 = vnet_buffer (b[0])->tcp.ack_number; /* Reset SYN-ACK retransmit and SYN_RCV establish timers */ - tcp_retransmit_timer_reset (tc0); - if (session_stream_accept_notify (&tc0->connection)) + tcp_retransmit_timer_reset (&wrk->timer_wheel, tc); + if (session_stream_accept_notify (&tc->connection)) { - error0 = TCP_ERROR_MSG_QUEUE_FULL; - tcp_send_reset (tc0); - session_transport_delete_notify (&tc0->connection); - tcp_connection_cleanup (tc0); + error = TCP_ERROR_MSG_QUEUE_FULL; + tcp_send_reset (tc); + session_transport_delete_notify (&tc->connection); + tcp_connection_cleanup (tc); goto drop; } - error0 = TCP_ERROR_ACK_OK; + error = TCP_ERROR_ACK_OK; break; case TCP_STATE_ESTABLISHED: /* We can get packets in established state here because they * were enqueued before state change */ - if (tcp_rcv_ack (wrk, tc0, b0, tcp0, &error0)) + if (tcp_rcv_ack (wrk, tc, b[0], tcp, &error)) goto drop; break; @@ -3004,91 +2262,93 @@ tcp46_rcv_process_inline (vlib_main_t * vm, vlib_node_runtime_t * node, /* In addition to the processing for the ESTABLISHED state, if * our FIN is now acknowledged then enter FIN-WAIT-2 and * continue processing in that state. */ - if (tcp_rcv_ack (wrk, tc0, b0, tcp0, &error0)) + if (tcp_rcv_ack (wrk, tc, b[0], tcp, &error)) goto drop; /* Still have to send the FIN */ - if (tc0->flags & TCP_CONN_FINPNDG) + if (tc->flags & TCP_CONN_FINPNDG) { /* TX fifo finally drained */ - max_dequeue = transport_max_tx_dequeue (&tc0->connection); - if (max_dequeue <= tc0->burst_acked) - tcp_send_fin (tc0); + max_deq = transport_max_tx_dequeue (&tc->connection); + if (max_deq <= tc->burst_acked) + tcp_send_fin (tc); /* If a fin was received and data was acked extend wait */ - else if ((tc0->flags & TCP_CONN_FINRCVD) && tc0->bytes_acked) - tcp_timer_update (tc0, TCP_TIMER_WAITCLOSE, + else if ((tc->flags & TCP_CONN_FINRCVD) && tc->bytes_acked) + tcp_timer_update (&wrk->timer_wheel, tc, TCP_TIMER_WAITCLOSE, tcp_cfg.closewait_time); } /* If FIN is ACKed */ - else if (tc0->snd_una == tc0->snd_nxt) + else if (tc->snd_una == tc->snd_nxt) { /* Stop all retransmit timers because we have nothing more * to send. */ - tcp_connection_timers_reset (tc0); + tcp_connection_timers_reset (tc); /* We already have a FIN but didn't transition to CLOSING * because of outstanding tx data. Close the connection. */ - if (tc0->flags & TCP_CONN_FINRCVD) + if (tc->flags & TCP_CONN_FINRCVD) { - tcp_connection_set_state (tc0, TCP_STATE_CLOSED); - tcp_timer_set (tc0, TCP_TIMER_WAITCLOSE, - tcp_cfg.cleanup_time); - session_transport_closed_notify (&tc0->connection); + tcp_connection_set_state (tc, TCP_STATE_CLOSED); + session_transport_closed_notify (&tc->connection); + tcp_program_cleanup (wrk, tc); goto drop; } - tcp_connection_set_state (tc0, TCP_STATE_FIN_WAIT_2); + tcp_connection_set_state (tc, TCP_STATE_FIN_WAIT_2); /* Enable waitclose because we're willing to wait for peer's * FIN but not indefinitely. */ - tcp_timer_set (tc0, TCP_TIMER_WAITCLOSE, tcp_cfg.finwait2_time); + tcp_timer_set (&wrk->timer_wheel, tc, TCP_TIMER_WAITCLOSE, + tcp_cfg.finwait2_time); /* Don't try to deq the FIN acked */ - if (tc0->burst_acked > 1) - session_tx_fifo_dequeue_drop (&tc0->connection, - tc0->burst_acked - 1); - tc0->burst_acked = 0; + if (tc->burst_acked > 1) + session_tx_fifo_dequeue_drop (&tc->connection, + tc->burst_acked - 1); + tc->burst_acked = 0; } break; case TCP_STATE_FIN_WAIT_2: /* In addition to the processing for the ESTABLISHED state, if * the retransmission queue is empty, the user's CLOSE can be * acknowledged ("ok") but do not delete the TCB. */ - if (tcp_rcv_ack_no_cc (tc0, b0, &error0)) + if (tcp_rcv_ack_no_cc (tc, b[0], &error)) goto drop; - tc0->burst_acked = 0; + tc->burst_acked = 0; break; case TCP_STATE_CLOSE_WAIT: /* Do the same processing as for the ESTABLISHED state. */ - if (tcp_rcv_ack (wrk, tc0, b0, tcp0, &error0)) + if (tcp_rcv_ack (wrk, tc, b[0], tcp, &error)) goto drop; - if (!(tc0->flags & TCP_CONN_FINPNDG)) + if (!(tc->flags & TCP_CONN_FINPNDG)) break; /* Still have outstanding tx data */ - max_dequeue = transport_max_tx_dequeue (&tc0->connection); - if (max_dequeue > tc0->burst_acked) + max_deq = transport_max_tx_dequeue (&tc->connection); + if (max_deq > tc->burst_acked) break; - tcp_send_fin (tc0); - tcp_connection_timers_reset (tc0); - tcp_connection_set_state (tc0, TCP_STATE_LAST_ACK); - tcp_timer_set (tc0, TCP_TIMER_WAITCLOSE, tcp_cfg.lastack_time); + tcp_send_fin (tc); + tcp_connection_timers_reset (tc); + tcp_connection_set_state (tc, TCP_STATE_LAST_ACK); + tcp_timer_set (&wrk->timer_wheel, tc, TCP_TIMER_WAITCLOSE, + tcp_cfg.lastack_time); break; case TCP_STATE_CLOSING: /* In addition to the processing for the ESTABLISHED state, if * the ACK acknowledges our FIN then enter the TIME-WAIT state, * otherwise ignore the segment. */ - if (tcp_rcv_ack_no_cc (tc0, b0, &error0)) + if (tcp_rcv_ack_no_cc (tc, b[0], &error)) goto drop; - if (tc0->snd_una != tc0->snd_nxt) + if (tc->snd_una != tc->snd_nxt) goto drop; - tcp_connection_timers_reset (tc0); - tcp_connection_set_state (tc0, TCP_STATE_TIME_WAIT); - tcp_timer_set (tc0, TCP_TIMER_WAITCLOSE, tcp_cfg.timewait_time); - session_transport_closed_notify (&tc0->connection); + tcp_connection_timers_reset (tc); + tcp_connection_set_state (tc, TCP_STATE_TIME_WAIT); + tcp_timer_set (&wrk->timer_wheel, tc, TCP_TIMER_WAITCLOSE, + tcp_cfg.timewait_time); + session_transport_closed_notify (&tc->connection); goto drop; break; @@ -3097,24 +2357,24 @@ tcp46_rcv_process_inline (vlib_main_t * vm, vlib_node_runtime_t * node, * acknowledgment of our FIN. If our FIN is now acknowledged, * delete the TCB, enter the CLOSED state, and return. */ - if (tcp_rcv_ack_no_cc (tc0, b0, &error0)) + if (tcp_rcv_ack_no_cc (tc, b[0], &error)) goto drop; /* Apparently our ACK for the peer's FIN was lost */ - if (is_fin0 && tc0->snd_una != tc0->snd_nxt) + if (is_fin && tc->snd_una != tc->snd_nxt) { - tcp_send_fin (tc0); + tcp_send_fin (tc); goto drop; } - tcp_connection_set_state (tc0, TCP_STATE_CLOSED); - session_transport_closed_notify (&tc0->connection); + tcp_connection_set_state (tc, TCP_STATE_CLOSED); + session_transport_closed_notify (&tc->connection); /* Don't free the connection from the data path since * we can't ensure that we have no packets already enqueued * to output. Rely instead on the waitclose timer */ - tcp_connection_timers_reset (tc0); - tcp_timer_set (tc0, TCP_TIMER_WAITCLOSE, tcp_cfg.cleanup_time); + tcp_connection_timers_reset (tc); + tcp_program_cleanup (tcp_get_worker (tc->c_thread_index), tc); goto drop; @@ -3124,14 +2384,15 @@ tcp46_rcv_process_inline (vlib_main_t * vm, vlib_node_runtime_t * node, * retransmission of the remote FIN. Acknowledge it, and restart * the 2 MSL timeout. */ - if (tcp_rcv_ack_no_cc (tc0, b0, &error0)) + if (tcp_rcv_ack_no_cc (tc, b[0], &error)) goto drop; - if (!is_fin0) + if (!is_fin) goto drop; - tcp_program_ack (tc0); - tcp_timer_update (tc0, TCP_TIMER_WAITCLOSE, tcp_cfg.timewait_time); + tcp_program_ack (tc); + tcp_timer_update (&wrk->timer_wheel, tc, TCP_TIMER_WAITCLOSE, + tcp_cfg.timewait_time); goto drop; break; @@ -3142,13 +2403,16 @@ tcp46_rcv_process_inline (vlib_main_t * vm, vlib_node_runtime_t * node, /* 6: check the URG bit TODO */ /* 7: process the segment text */ - switch (tc0->state) + switch (tc->state) { case TCP_STATE_ESTABLISHED: case TCP_STATE_FIN_WAIT_1: case TCP_STATE_FIN_WAIT_2: - if (vnet_buffer (b0)->tcp.data_len) - error0 = tcp_segment_rcv (wrk, tc0, b0); + if (vnet_buffer (b[0])->tcp.data_len) + error = tcp_segment_rcv (wrk, tc, b[0]); + /* Don't accept out of order fins lower */ + if (vnet_buffer (b[0])->tcp.seq_end != tc->rcv_nxt) + goto drop; break; case TCP_STATE_CLOSE_WAIT: case TCP_STATE_CLOSING: @@ -3160,30 +2424,32 @@ tcp46_rcv_process_inline (vlib_main_t * vm, vlib_node_runtime_t * node, } /* 8: check the FIN bit */ - if (!is_fin0) + if (!is_fin) goto drop; - TCP_EVT (TCP_EVT_FIN_RCVD, tc0); + TCP_EVT (TCP_EVT_FIN_RCVD, tc); - switch (tc0->state) + switch (tc->state) { case TCP_STATE_ESTABLISHED: /* Account for the FIN and send ack */ - tc0->rcv_nxt += 1; - tcp_program_ack (tc0); - tcp_connection_set_state (tc0, TCP_STATE_CLOSE_WAIT); - tcp_program_disconnect (wrk, tc0); - tcp_timer_update (tc0, TCP_TIMER_WAITCLOSE, tcp_cfg.closewait_time); + tc->rcv_nxt += 1; + tcp_program_ack (tc); + tcp_connection_set_state (tc, TCP_STATE_CLOSE_WAIT); + tcp_program_disconnect (wrk, tc); + tcp_timer_update (&wrk->timer_wheel, tc, TCP_TIMER_WAITCLOSE, + tcp_cfg.closewait_time); break; case TCP_STATE_SYN_RCVD: /* Send FIN-ACK, enter LAST-ACK and because the app was not * notified yet, set a cleanup timer instead of relying on * disconnect notify and the implicit close call. */ - tcp_connection_timers_reset (tc0); - tc0->rcv_nxt += 1; - tcp_send_fin (tc0); - tcp_connection_set_state (tc0, TCP_STATE_LAST_ACK); - tcp_timer_set (tc0, TCP_TIMER_WAITCLOSE, tcp_cfg.lastack_time); + tcp_connection_timers_reset (tc); + tc->rcv_nxt += 1; + tcp_send_fin (tc); + tcp_connection_set_state (tc, TCP_STATE_LAST_ACK); + tcp_timer_set (&wrk->timer_wheel, tc, TCP_TIMER_WAITCLOSE, + tcp_cfg.lastack_time); break; case TCP_STATE_CLOSE_WAIT: case TCP_STATE_CLOSING: @@ -3191,52 +2457,51 @@ tcp46_rcv_process_inline (vlib_main_t * vm, vlib_node_runtime_t * node, /* move along .. */ break; case TCP_STATE_FIN_WAIT_1: - tc0->rcv_nxt += 1; + tc->rcv_nxt += 1; - if (tc0->flags & TCP_CONN_FINPNDG) + if (tc->flags & TCP_CONN_FINPNDG) { /* If data is outstanding, stay in FIN_WAIT_1 and try to finish * sending it. Since we already received a fin, do not wait * for too long. */ - tc0->flags |= TCP_CONN_FINRCVD; - tcp_timer_update (tc0, TCP_TIMER_WAITCLOSE, + tc->flags |= TCP_CONN_FINRCVD; + tcp_timer_update (&wrk->timer_wheel, tc, TCP_TIMER_WAITCLOSE, tcp_cfg.closewait_time); } else { - tcp_connection_set_state (tc0, TCP_STATE_CLOSING); - tcp_program_ack (tc0); + tcp_connection_set_state (tc, TCP_STATE_CLOSING); + tcp_program_ack (tc); /* Wait for ACK for our FIN but not forever */ - tcp_timer_update (tc0, TCP_TIMER_WAITCLOSE, + tcp_timer_update (&wrk->timer_wheel, tc, TCP_TIMER_WAITCLOSE, tcp_cfg.closing_time); } break; case TCP_STATE_FIN_WAIT_2: /* Got FIN, send ACK! Be more aggressive with resource cleanup */ - tc0->rcv_nxt += 1; - tcp_connection_set_state (tc0, TCP_STATE_TIME_WAIT); - tcp_connection_timers_reset (tc0); - tcp_timer_set (tc0, TCP_TIMER_WAITCLOSE, tcp_cfg.timewait_time); - tcp_program_ack (tc0); - session_transport_closed_notify (&tc0->connection); + tc->rcv_nxt += 1; + tcp_connection_set_state (tc, TCP_STATE_TIME_WAIT); + tcp_connection_timers_reset (tc); + tcp_timer_set (&wrk->timer_wheel, tc, TCP_TIMER_WAITCLOSE, + tcp_cfg.timewait_time); + tcp_program_ack (tc); + session_transport_closed_notify (&tc->connection); break; case TCP_STATE_TIME_WAIT: /* Remain in the TIME-WAIT state. Restart the time-wait * timeout. */ - tcp_timer_update (tc0, TCP_TIMER_WAITCLOSE, tcp_cfg.timewait_time); + tcp_timer_update (&wrk->timer_wheel, tc, TCP_TIMER_WAITCLOSE, + tcp_cfg.timewait_time); break; } - error0 = TCP_ERROR_FIN_RCVD; + error = TCP_ERROR_FIN_RCVD; drop: - tcp_inc_counter (rcv_process, error0, 1); - if (PREDICT_FALSE (b0->flags & VLIB_BUFFER_IS_TRACED)) - { - tcp_rx_trace_t *t0 = vlib_add_trace (vm, node, b0, sizeof (*t0)); - tcp_set_rx_trace_data (t0, tc0, tcp0, b0, is_ip4); - } + b += 1; + n_left_from -= 1; + tcp_inc_counter (rcv_process, error, 1); } errors = session_main_flush_enqueue_events (TRANSPORT_PROTO_TCP, @@ -3244,9 +2509,9 @@ tcp46_rcv_process_inline (vlib_main_t * vm, vlib_node_runtime_t * node, tcp_inc_counter (rcv_process, TCP_ERROR_MSG_QUEUE_FULL, errors); tcp_handle_postponed_dequeues (wrk); tcp_handle_disconnects (wrk); - vlib_buffer_free (vm, first_buffer, from_frame->n_vectors); + vlib_buffer_free (vm, from, frame->n_vectors); - return from_frame->n_vectors; + return frame->n_vectors; } VLIB_NODE_FN (tcp4_rcv_process_node) (vlib_main_t * vm, @@ -3301,172 +2566,144 @@ VLIB_REGISTER_NODE (tcp6_rcv_process_node) = }; /* *INDENT-ON* */ +static void +tcp46_listen_trace_frame (vlib_main_t *vm, vlib_node_runtime_t *node, + u32 *to_next, u32 n_bufs) +{ + tcp_connection_t *tc = 0; + tcp_rx_trace_t *t; + vlib_buffer_t *b; + int i; + + for (i = 0; i < n_bufs; i++) + { + b = vlib_get_buffer (vm, to_next[i]); + if (!(b->flags & VLIB_BUFFER_IS_TRACED)) + continue; + if (vnet_buffer (b)->tcp.flags == TCP_STATE_LISTEN) + tc = tcp_listener_get (vnet_buffer (b)->tcp.connection_index); + t = vlib_add_trace (vm, node, b, sizeof (*t)); + tcp_set_rx_trace_data (t, tc, tcp_buffer_hdr (b), b, 1); + } +} + /** * LISTEN state processing as per RFC 793 p. 65 */ always_inline uword -tcp46_listen_inline (vlib_main_t * vm, vlib_node_runtime_t * node, - vlib_frame_t * from_frame, int is_ip4) +tcp46_listen_inline (vlib_main_t *vm, vlib_node_runtime_t *node, + vlib_frame_t *frame, int is_ip4) { - u32 n_left_from, *from, n_syns = 0, *first_buffer; - u32 my_thread_index = vm->thread_index; - tcp_connection_t *tc0; + u32 n_left_from, *from, n_syns = 0; + vlib_buffer_t *bufs[VLIB_FRAME_SIZE], **b; + u32 thread_index = vm->thread_index; - from = first_buffer = vlib_frame_vector_args (from_frame); - n_left_from = from_frame->n_vectors; + from = vlib_frame_vector_args (frame); + n_left_from = frame->n_vectors; - while (n_left_from > 0) - { - u32 bi0; - vlib_buffer_t *b0; - tcp_rx_trace_t *t0; - tcp_header_t *th0 = 0; - tcp_connection_t *lc0; - ip4_header_t *ip40; - ip6_header_t *ip60; - tcp_connection_t *child0; - u32 error0 = TCP_ERROR_NONE; + if (PREDICT_FALSE (node->flags & VLIB_NODE_FLAG_TRACE)) + tcp46_listen_trace_frame (vm, node, from, n_left_from); - bi0 = from[0]; - from += 1; - n_left_from -= 1; + vlib_get_buffers (vm, from, bufs, n_left_from); + b = bufs; - b0 = vlib_get_buffer (vm, bi0); + while (n_left_from > 0) + { + u32 error = TCP_ERROR_NONE; + tcp_connection_t *lc, *child; - if (is_ip4) + /* Flags initialized with connection state after lookup */ + if (vnet_buffer (b[0])->tcp.flags == TCP_STATE_LISTEN) { - ip40 = vlib_buffer_get_current (b0); - th0 = tcp_buffer_hdr (b0); + lc = tcp_listener_get (vnet_buffer (b[0])->tcp.connection_index); } else { - ip60 = vlib_buffer_get_current (b0); - 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) + tcp_connection_t *tc; + tc = tcp_connection_get (vnet_buffer (b[0])->tcp.connection_index, + thread_index); + if (tc->state != TCP_STATE_TIME_WAIT) { - error0 = TCP_ERROR_CREATE_EXISTS; - goto drop; + error = TCP_ERROR_CREATE_EXISTS; + goto done; } - lc0 = tcp_lookup_listener (b0, tc0->c_fib_index, is_ip4); + lc = tcp_lookup_listener (b[0], tc->c_fib_index, is_ip4); /* clean up the old session */ - tcp_connection_del (tc0); + tcp_connection_del (tc); + /* listener was cleaned up */ + if (!lc) + { + error = TCP_ERROR_NO_LISTENER; + goto done; + } + } + + /* Make sure connection wasn't just created */ + child = + tcp_lookup_connection (lc->c_fib_index, b[0], thread_index, is_ip4); + if (PREDICT_FALSE (child->state != TCP_STATE_LISTEN)) + { + error = TCP_ERROR_CREATE_EXISTS; + goto done; } /* Create child session. For syn-flood protection use filter */ - /* 1. first check for an RST: handled in dispatch */ - /* if (tcp_rst (th0)) - goto drop; - */ + /* 1. first check for an RST: handled by input dispatch */ - /* 2. second check for an ACK: handled in dispatch */ - /* if (tcp_ack (th0)) - { - tcp_send_reset (b0, is_ip4); - goto drop; - } - */ + /* 2. second check for an ACK: handled by input dispatch */ /* 3. check for a SYN (did that already) */ - /* Make sure connection wasn't just created */ - child0 = tcp_lookup_connection (lc0->c_fib_index, b0, my_thread_index, - is_ip4); - if (PREDICT_FALSE (child0->state != TCP_STATE_LISTEN)) - { - error0 = TCP_ERROR_CREATE_EXISTS; - goto drop; - } - /* Create child session and send SYN-ACK */ - child0 = tcp_connection_alloc (my_thread_index); - child0->c_lcl_port = th0->dst_port; - child0->c_rmt_port = th0->src_port; - child0->c_is_ip4 = is_ip4; - child0->state = TCP_STATE_SYN_RCVD; - child0->c_fib_index = lc0->c_fib_index; - child0->cc_algo = lc0->cc_algo; - - if (is_ip4) - { - child0->c_lcl_ip4.as_u32 = ip40->dst_address.as_u32; - child0->c_rmt_ip4.as_u32 = ip40->src_address.as_u32; - } - else - { - clib_memcpy_fast (&child0->c_lcl_ip6, &ip60->dst_address, - sizeof (ip6_address_t)); - clib_memcpy_fast (&child0->c_rmt_ip6, &ip60->src_address, - sizeof (ip6_address_t)); - } - - if (tcp_options_parse (th0, &child0->rcv_opts, 1)) - { - error0 = TCP_ERROR_OPTIONS; - tcp_connection_free (child0); - goto drop; - } - - child0->irs = vnet_buffer (b0)->tcp.seq_number; - child0->rcv_nxt = vnet_buffer (b0)->tcp.seq_number + 1; - child0->rcv_las = child0->rcv_nxt; - child0->sw_if_index = vnet_buffer (b0)->sw_if_index[VLIB_RX]; + child = tcp_connection_alloc (thread_index); - /* RFC1323: TSval timestamps sent on {SYN} and {SYN,ACK} - * segments are used to initialize PAWS. */ - if (tcp_opts_tstamp (&child0->rcv_opts)) + if (tcp_options_parse (tcp_buffer_hdr (b[0]), &child->rcv_opts, 1)) { - child0->tsval_recent = child0->rcv_opts.tsval; - child0->tsval_recent_age = tcp_time_now (); + error = TCP_ERROR_OPTIONS; + tcp_connection_free (child); + goto done; } - if (tcp_opts_wscale (&child0->rcv_opts)) - child0->snd_wscale = child0->rcv_opts.wscale; + tcp_init_w_buffer (child, b[0], is_ip4); - child0->snd_wnd = clib_net_to_host_u16 (th0->window) - << child0->snd_wscale; - child0->snd_wl1 = vnet_buffer (b0)->tcp.seq_number; - child0->snd_wl2 = vnet_buffer (b0)->tcp.ack_number; + child->state = TCP_STATE_SYN_RCVD; + child->c_fib_index = lc->c_fib_index; + child->cc_algo = lc->cc_algo; + tcp_connection_init_vars (child); + child->rto = TCP_RTO_MIN; - tcp_connection_init_vars (child0); - child0->rto = TCP_RTO_MIN; + /* + * This initializes elog track, must be done before synack. + * We also do it before possible tcp_connection_cleanup() as it + * generates TCP_EVT_DELETE event. + */ + TCP_EVT (TCP_EVT_SYN_RCVD, child, 1); - if (session_stream_accept (&child0->connection, lc0->c_s_index, - lc0->c_thread_index, 0 /* notify */ )) + if (session_stream_accept (&child->connection, lc->c_s_index, + lc->c_thread_index, 0 /* notify */ )) { - tcp_connection_cleanup (child0); - error0 = TCP_ERROR_CREATE_SESSION_FAIL; - goto drop; + tcp_connection_cleanup (child); + error = TCP_ERROR_CREATE_SESSION_FAIL; + goto done; } - TCP_EVT (TCP_EVT_SYN_RCVD, child0, 1); - child0->tx_fifo_size = transport_tx_fifo_size (&child0->connection); - tcp_send_synack (child0); + transport_fifos_init_ooo (&child->connection); + child->tx_fifo_size = transport_tx_fifo_size (&child->connection); - drop: + tcp_send_synack (child); - if (PREDICT_FALSE (b0->flags & VLIB_BUFFER_IS_TRACED)) - { - t0 = vlib_add_trace (vm, node, b0, sizeof (*t0)); - clib_memcpy_fast (&t0->tcp_header, th0, sizeof (t0->tcp_header)); - clib_memcpy_fast (&t0->tcp_connection, lc0, - sizeof (t0->tcp_connection)); - } + done: - n_syns += (error0 == TCP_ERROR_NONE); + b += 1; + n_left_from -= 1; + n_syns += (error == TCP_ERROR_NONE); } tcp_inc_counter (listen, TCP_ERROR_SYNS_RCVD, n_syns); - vlib_buffer_free (vm, first_buffer, from_frame->n_vectors); + vlib_buffer_free (vm, from, frame->n_vectors); - return from_frame->n_vectors; + return frame->n_vectors; } VLIB_NODE_FN (tcp4_listen_node) (vlib_main_t * vm, vlib_node_runtime_t * node, @@ -3592,102 +2829,6 @@ tcp_input_set_error_next (tcp_main_t * tm, u16 * next, u32 * error, u8 is_ip4) } } -always_inline tcp_connection_t * -tcp_input_lookup_buffer (vlib_buffer_t * b, u8 thread_index, u32 * error, - u8 is_ip4, u8 is_nolookup) -{ - u32 fib_index = vnet_buffer (b)->ip.fib_index; - int n_advance_bytes, n_data_bytes; - transport_connection_t *tc; - tcp_header_t *tcp; - u8 result = 0; - - if (is_ip4) - { - ip4_header_t *ip4 = vlib_buffer_get_current (b); - int ip_hdr_bytes = ip4_header_bytes (ip4); - if (PREDICT_FALSE (b->current_length < ip_hdr_bytes + sizeof (*tcp))) - { - *error = TCP_ERROR_LENGTH; - return 0; - } - tcp = ip4_next_header (ip4); - vnet_buffer (b)->tcp.hdr_offset = (u8 *) tcp - (u8 *) ip4; - n_advance_bytes = (ip_hdr_bytes + tcp_header_bytes (tcp)); - n_data_bytes = clib_net_to_host_u16 (ip4->length) - n_advance_bytes; - - /* Length check. Checksum computed by ipx_local no need to compute again */ - if (PREDICT_FALSE (n_data_bytes < 0)) - { - *error = TCP_ERROR_LENGTH; - return 0; - } - - if (!is_nolookup) - tc = session_lookup_connection_wt4 (fib_index, &ip4->dst_address, - &ip4->src_address, tcp->dst_port, - tcp->src_port, - TRANSPORT_PROTO_TCP, thread_index, - &result); - } - else - { - ip6_header_t *ip6 = vlib_buffer_get_current (b); - if (PREDICT_FALSE (b->current_length < sizeof (*ip6) + sizeof (*tcp))) - { - *error = TCP_ERROR_LENGTH; - return 0; - } - tcp = ip6_next_header (ip6); - vnet_buffer (b)->tcp.hdr_offset = (u8 *) tcp - (u8 *) ip6; - n_advance_bytes = tcp_header_bytes (tcp); - n_data_bytes = clib_net_to_host_u16 (ip6->payload_length) - - n_advance_bytes; - n_advance_bytes += sizeof (ip6[0]); - - if (PREDICT_FALSE (n_data_bytes < 0)) - { - *error = TCP_ERROR_LENGTH; - return 0; - } - - if (!is_nolookup) - { - if (PREDICT_FALSE - (ip6_address_is_link_local_unicast (&ip6->dst_address))) - { - ip4_main_t *im = &ip4_main; - fib_index = vec_elt (im->fib_index_by_sw_if_index, - vnet_buffer (b)->sw_if_index[VLIB_RX]); - } - - tc = session_lookup_connection_wt6 (fib_index, &ip6->dst_address, - &ip6->src_address, - tcp->dst_port, tcp->src_port, - TRANSPORT_PROTO_TCP, - thread_index, &result); - } - } - - if (is_nolookup) - tc = - (transport_connection_t *) tcp_connection_get (vnet_buffer (b)-> - tcp.connection_index, - thread_index); - - vnet_buffer (b)->tcp.seq_number = clib_net_to_host_u32 (tcp->seq_number); - vnet_buffer (b)->tcp.ack_number = clib_net_to_host_u32 (tcp->ack_number); - vnet_buffer (b)->tcp.data_offset = n_advance_bytes; - vnet_buffer (b)->tcp.data_len = n_data_bytes; - vnet_buffer (b)->tcp.seq_end = vnet_buffer (b)->tcp.seq_number - + n_data_bytes; - vnet_buffer (b)->tcp.flags = 0; - - *error = result ? TCP_ERROR_NONE + result : *error; - - return tcp_get_connection_from_transport (tc); -} - static inline void tcp_input_dispatch_buffer (tcp_main_t * tm, tcp_connection_t * tc, vlib_buffer_t * b, u16 * next, @@ -3703,6 +2844,10 @@ tcp_input_dispatch_buffer (tcp_main_t * tm, tcp_connection_t * tc, error = tm->dispatch_table[tc->state][flags].error; tc->segs_in += 1; + /* Track connection state when packet was received. It helps + * @ref tcp46_listen_inline detect port reuse */ + vnet_buffer (b)->tcp.flags = tc->state; + if (PREDICT_FALSE (error != TCP_ERROR_NONE)) { b->error = error_node->errors[error]; @@ -3721,11 +2866,9 @@ tcp46_input_inline (vlib_main_t * vm, vlib_node_runtime_t * node, tcp_main_t *tm = vnet_get_tcp_main (); vlib_buffer_t *bufs[VLIB_FRAME_SIZE], **b; u16 nexts[VLIB_FRAME_SIZE], *next; - vlib_node_runtime_t *error_node; - tcp_set_time_now (tcp_get_worker (thread_index)); + tcp_update_time_now (tcp_get_worker (thread_index)); - error_node = vlib_node_get_runtime (vm, tcp_node_index (input, is_ip4)); from = vlib_frame_vector_args (frame); n_left_from = frame->n_vectors; vlib_get_buffers (vm, from, bufs, n_left_from); @@ -3761,8 +2904,8 @@ tcp46_input_inline (vlib_main_t * vm, vlib_node_runtime_t * node, vnet_buffer (b[0])->tcp.connection_index = tc0->c_c_index; vnet_buffer (b[1])->tcp.connection_index = tc1->c_c_index; - tcp_input_dispatch_buffer (tm, tc0, b[0], &next[0], error_node); - tcp_input_dispatch_buffer (tm, tc1, b[1], &next[1], error_node); + tcp_input_dispatch_buffer (tm, tc0, b[0], &next[0], node); + tcp_input_dispatch_buffer (tm, tc1, b[1], &next[1], node); } else { @@ -3770,24 +2913,24 @@ tcp46_input_inline (vlib_main_t * vm, vlib_node_runtime_t * node, { 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], error_node); + tcp_input_dispatch_buffer (tm, tc0, b[0], &next[0], node); } else { tcp_input_set_error_next (tm, &next[0], &error0, is_ip4); - b[0]->error = error_node->errors[error0]; + b[0]->error = node->errors[error0]; } if (PREDICT_TRUE (tc1 != 0)) { 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], error_node); + tcp_input_dispatch_buffer (tm, tc1, b[1], &next[1], node); } else { tcp_input_set_error_next (tm, &next[1], &error1, is_ip4); - b[1]->error = error_node->errors[error1]; + b[1]->error = node->errors[error1]; } } @@ -3813,12 +2956,12 @@ tcp46_input_inline (vlib_main_t * vm, vlib_node_runtime_t * node, { 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], error_node); + tcp_input_dispatch_buffer (tm, tc0, b[0], &next[0], node); } else { tcp_input_set_error_next (tm, &next[0], &error0, is_ip4); - b[0]->error = error_node->errors[error0]; + b[0]->error = node->errors[error0]; } b += 1; @@ -3944,6 +3087,12 @@ VLIB_REGISTER_NODE (tcp6_input_node) = /* *INDENT-ON* */ #ifndef CLIB_MARCH_VARIANT +void +tcp_check_gso (tcp_connection_t *tc) +{ + tcp_check_tx_offload (tc, tc->c_is_ip4); +} + static void tcp_dispatch_table_init (tcp_main_t * tm) { @@ -4120,12 +3269,14 @@ do { \ _(FIN_WAIT_2, TCP_FLAG_RST, TCP_INPUT_NEXT_RCV_PROCESS, TCP_ERROR_NONE); _(FIN_WAIT_2, TCP_FLAG_RST | TCP_FLAG_ACK, TCP_INPUT_NEXT_RCV_PROCESS, TCP_ERROR_NONE); + _(FIN_WAIT_2, TCP_FLAG_SYN, TCP_INPUT_NEXT_RCV_PROCESS, TCP_ERROR_NONE); _(CLOSE_WAIT, TCP_FLAG_ACK, TCP_INPUT_NEXT_RCV_PROCESS, TCP_ERROR_NONE); _(CLOSE_WAIT, TCP_FLAG_FIN | TCP_FLAG_ACK, TCP_INPUT_NEXT_RCV_PROCESS, TCP_ERROR_NONE); _(CLOSE_WAIT, TCP_FLAG_RST, TCP_INPUT_NEXT_RCV_PROCESS, TCP_ERROR_NONE); _(CLOSE_WAIT, TCP_FLAG_RST | TCP_FLAG_ACK, TCP_INPUT_NEXT_RCV_PROCESS, TCP_ERROR_NONE); + _(CLOSE_WAIT, TCP_FLAG_SYN, TCP_INPUT_NEXT_RCV_PROCESS, TCP_ERROR_NONE); _(LAST_ACK, 0, TCP_INPUT_NEXT_DROP, TCP_ERROR_SEGMENT_INVALID); _(LAST_ACK, TCP_FLAG_ACK, TCP_INPUT_NEXT_RCV_PROCESS, TCP_ERROR_NONE); _(LAST_ACK, TCP_FLAG_FIN, TCP_INPUT_NEXT_RCV_PROCESS, TCP_ERROR_NONE);