#include <vnet/tcp/tcp.h>
#include <math.h>
-vlib_node_registration_t tcp4_output_node;
-vlib_node_registration_t tcp6_output_node;
-
typedef enum _tcp_output_next
{
TCP_OUTPUT_NEXT_DROP,
tcp_connection_t tcp_connection;
} tcp_tx_trace_t;
-u16 dummy_mtu = 1460;
-
-u8 *
+static u8 *
format_tcp_tx_trace (u8 * s, va_list * args)
{
CLIB_UNUSED (vlib_main_t * vm) = va_arg (*args, vlib_main_t *);
return s;
}
+#ifndef CLIB_MARCH_VARIANT
static u8
tcp_window_compute_scale (u32 window)
{
tcp_update_rcv_mss (tcp_connection_t * tc)
{
/* TODO find our iface MTU */
- tc->mss = dummy_mtu - sizeof (tcp_header_t);
+ tc->mss = tcp_cfg.default_mtu - sizeof (tcp_header_t);
}
/**
tcp_update_rcv_mss (tc);
TCP_IW_N_SEGMENTS * tc->mss;
*/
- return TCP_MIN_RX_FIFO_SIZE;
+ return tcp_cfg.min_rx_fifo;
}
/**
u32
tcp_initial_window_to_advertise (tcp_connection_t * tc)
{
- tcp_main_t *tm = &tcp_main;
- u32 max_fifo;
-
- /* Initial wnd for SYN. Fifos are not allocated yet.
- * Use some predefined value. For SYN-ACK we still want the
- * scale to be computed in the same way */
- max_fifo = tm->max_rx_fifo ? tm->max_rx_fifo : TCP_MAX_RX_FIFO_SIZE;
-
/* Compute rcv wscale only if peer advertised support for it */
if (tc->state != TCP_STATE_SYN_RCVD || tcp_opts_wscale (&tc->rcv_opts))
- tc->rcv_wscale = tcp_window_compute_scale (max_fifo);
+ tc->rcv_wscale = tcp_window_compute_scale (tcp_cfg.max_rx_fifo);
tc->rcv_wnd = tcp_initial_wnd_unscaled (tc);
return clib_min (tc->rcv_wnd, TCP_WND_MAX);
}
-static void
+static inline void
tcp_update_rcv_wnd (tcp_connection_t * tc)
{
+ u32 available_space, wnd;
i32 observed_wnd;
- u32 available_space, max_fifo, wnd;
+
+ ASSERT (tc->rcv_opts.mss < transport_rx_fifo_size (&tc->connection));
/*
* Figure out how much space we have available
*/
available_space = transport_max_rx_enqueue (&tc->connection);
- max_fifo = transport_rx_fifo_size (&tc->connection);
-
- ASSERT (tc->rcv_opts.mss < max_fifo);
- if (available_space < tc->rcv_opts.mss && available_space < max_fifo >> 3)
+ if (PREDICT_FALSE (available_space < tc->rcv_opts.mss))
available_space = 0;
/*
* to compute the new window
*/
observed_wnd = (i32) tc->rcv_wnd - (tc->rcv_nxt - tc->rcv_las);
- if (observed_wnd < 0)
- observed_wnd = 0;
/* Bad. Thou shalt not shrink */
- if (available_space < observed_wnd)
+ if (PREDICT_FALSE ((i32) available_space < observed_wnd))
{
- wnd = observed_wnd;
- TCP_EVT_DBG (TCP_EVT_RCV_WND_SHRUNK, tc, observed_wnd, available_space);
+ wnd = clib_max (observed_wnd, 0);
+ TCP_EVT (TCP_EVT_RCV_WND_SHRUNK, tc, observed_wnd, available_space);
}
else
{
/* Make sure we have a multiple of rcv_wscale */
if (wnd && tc->rcv_wscale)
{
- wnd &= ~(1 << tc->rcv_wscale);
+ wnd &= ~((1 << tc->rcv_wscale) - 1);
if (wnd == 0)
wnd = 1 << tc->rcv_wscale;
}
/**
* Compute and return window to advertise, scaled as per RFC1323
*/
-static u32
+static inline u32
tcp_window_to_advertise (tcp_connection_t * tc, tcp_state_t state)
{
if (state < TCP_STATE_ESTABLISHED)
return tcp_initial_window_to_advertise (tc);
tcp_update_rcv_wnd (tc);
-
- if (tc->rcv_wnd == 0)
- {
- tc->flags |= TCP_CONN_SENT_RCV_WND0;
- }
- else
- {
- tc->flags &= ~TCP_CONN_SENT_RCV_WND0;
- }
-
return tc->rcv_wnd >> tc->rcv_wscale;
}
u8 len = 0;
opts->flags |= TCP_OPTS_FLAG_MSS;
- opts->mss = dummy_mtu; /*XXX discover that */
+ opts->mss = tcp_cfg.default_mtu; /*XXX discover that */
len += TCP_OPTION_LEN_MSS;
opts->flags |= TCP_OPTS_FLAG_WSCALE;
if (tcp_opts_tstamp (&tc->rcv_opts))
{
opts->flags |= TCP_OPTS_FLAG_TSTAMP;
- opts->tsval = tcp_time_now_w_thread (tc->c_thread_index);
+ opts->tsval = tcp_tstamp (tc);
opts->tsecr = tc->tsval_recent;
len += TCP_OPTION_LEN_TIMESTAMP;
}
&tc->snd_opts);
tcp_update_rcv_wnd (tc);
+
+ if (tc->flags & TCP_CONN_RATE_SAMPLE)
+ tc->flags |= TCP_CONN_TRACK_BURST;
+
+ if (tc->snd_una == tc->snd_nxt)
+ tcp_cc_event (tc, TCP_CC_EVT_START_TX);
}
void
if (tcp_opts_tstamp (&tc->rcv_opts))
tc->snd_mss -= TCP_OPTION_LEN_TIMESTAMP;
}
+#endif /* CLIB_MARCH_VARIANT */
static void *
tcp_reuse_buffer (vlib_main_t * vm, vlib_buffer_t * b)
return vlib_buffer_make_headroom (b, TRANSPORT_MAX_HDRS_LEN);
}
+#ifndef CLIB_MARCH_VARIANT
static void *
tcp_init_buffer (vlib_main_t * vm, vlib_buffer_t * b)
{
tcp_options_write ((u8 *) (th + 1), snd_opts);
vnet_buffer (b)->tcp.connection_index = tc->c_c_index;
+
+ if (wnd == 0)
+ tcp_zero_rwnd_sent_on (tc);
+ else
+ tcp_zero_rwnd_sent_off (tc);
}
/**
tcp_make_ack (tcp_connection_t * tc, vlib_buffer_t * b)
{
tcp_make_ack_i (tc, b, TCP_STATE_ESTABLISHED, TCP_FLAG_ACK);
- TCP_EVT_DBG (TCP_EVT_ACK_SENT, tc);
+ TCP_EVT (TCP_EVT_ACK_SENT, tc);
tc->rcv_las = tc->rcv_nxt;
}
tcp_make_fin (tcp_connection_t * tc, vlib_buffer_t * b)
{
tcp_make_ack_i (tc, b, TCP_STATE_ESTABLISHED, TCP_FLAG_FIN | TCP_FLAG_ACK);
-
- /* Reset flags, make sure ack is sent */
- vnet_buffer (b)->tcp.flags &= ~TCP_BUF_FLAG_DUPACK;
}
/**
{
tcp_enqueue_to_output_i (wrk, b, bi, is_ip4, 1);
}
+#endif /* CLIB_MARCH_VARIANT */
static int
tcp_make_reset_in_place (vlib_main_t * vm, vlib_buffer_t * b0,
return 0;
}
+#ifndef CLIB_MARCH_VARIANT
/**
* Send reset without reusing existing buffer
*
}
tcp_enqueue_to_ip_lookup_now (wrk, b, bi, is_ip4, fib_index);
- TCP_EVT_DBG (TCP_EVT_RST_SENT, tc);
+ TCP_EVT (TCP_EVT_RST_SENT, tc);
+ vlib_node_increment_counter (vm, tcp_node_index (output, tc->c_is_ip4),
+ TCP_ERROR_RST_SENT, 1);
}
/**
opts_write_len = tcp_options_write ((u8 *) (th + 1), &tc->snd_opts);
ASSERT (opts_write_len == tc->snd_opts_len);
vnet_buffer (b)->tcp.connection_index = tc->c_c_index;
- if (tc->c_is_ip4)
- {
- ip4_header_t *ih4;
- ih4 = vlib_buffer_push_ip4 (vm, b, &tc->c_lcl_ip.ip4,
- &tc->c_rmt_ip.ip4, IP_PROTOCOL_TCP, 0);
- th->checksum = ip4_tcp_udp_compute_checksum (vm, b, ih4);
- }
- else
- {
- int bogus = ~0;
- ip6_header_t *ih6;
- ih6 = vlib_buffer_push_ip6 (vm, b, &tc->c_lcl_ip.ip6,
- &tc->c_rmt_ip.ip6, IP_PROTOCOL_TCP);
- th->checksum = ip6_tcp_udp_icmp_compute_checksum (vm, b, ih6, &bogus);
- ASSERT (!bogus);
- }
- tcp_enqueue_to_ip_lookup_now (wrk, b, bi, tc->c_is_ip4, tc->c_fib_index);
- TCP_EVT_DBG (TCP_EVT_RST_SENT, tc);
+ tcp_enqueue_to_output (wrk, b, bi, tc->c_is_ip4);
+ TCP_EVT (TCP_EVT_RST_SENT, tc);
+ vlib_node_increment_counter (vm, tcp_node_index (output, tc->c_is_ip4),
+ TCP_ERROR_RST_SENT, 1);
}
static void
* Setup retransmit and establish timers before requesting buffer
* such that we can return if we've ran out.
*/
- tcp_timer_set (tc, TCP_TIMER_ESTABLISH_AO, TCP_ESTABLISH_TIME);
tcp_timer_update (tc, TCP_TIMER_RETRANSMIT_SYN,
tc->rto * TCP_TO_TIMER_TICK);
tcp_push_ip_hdr (wrk, tc, b);
tcp_enqueue_to_ip_lookup (wrk, b, bi, tc->c_is_ip4, tc->c_fib_index);
- TCP_EVT_DBG (TCP_EVT_SYN_SENT, tc);
+ TCP_EVT (TCP_EVT_SYN_SENT, tc);
}
void
tcp_init_buffer (vm, b);
tcp_make_synack (tc, b);
tcp_enqueue_to_output (wrk, b, bi, tc->c_is_ip4);
- TCP_EVT_DBG (TCP_EVT_SYNACK_SENT, tc);
+ TCP_EVT (TCP_EVT_SYNACK_SENT, tc);
}
/**
fin_snt = tc->flags & TCP_CONN_FINSNT;
if (fin_snt)
- tc->snd_nxt = tc->snd_una;
+ tc->snd_nxt -= 1;
if (PREDICT_FALSE (!vlib_buffer_alloc (vm, &bi, 1)))
{
/* Out of buffers so program fin retransmit ASAP */
tcp_timer_update (tc, TCP_TIMER_RETRANSMIT, 1);
if (fin_snt)
- tc->snd_nxt = tc->snd_una_max;
+ tc->snd_nxt += 1;
else
/* Make sure retransmit retries a fin not data */
tc->flags |= TCP_CONN_FINSNT;
tcp_init_buffer (vm, b);
tcp_make_fin (tc, b);
tcp_enqueue_to_output_now (wrk, b, bi, tc->c_is_ip4);
- TCP_EVT_DBG (TCP_EVT_FIN_SENT, tc);
-
+ TCP_EVT (TCP_EVT_FIN_SENT, tc);
+ /* Account for the FIN */
+ tc->snd_nxt += 1;
if (!fin_snt)
{
tc->flags |= TCP_CONN_FINSNT;
tc->flags &= ~TCP_CONN_FINPNDG;
- /* Account for the FIN */
- tc->snd_una_max += 1;
- tc->snd_nxt = tc->snd_una_max;
+ tc->snd_una_max = seq_max (tc->snd_una_max, tc->snd_nxt);
}
- else
- {
- tc->snd_nxt = tc->snd_una_max;
- }
-}
-
-always_inline u8
-tcp_make_state_flags (tcp_connection_t * tc, tcp_state_t next_state)
-{
- switch (next_state)
- {
- case TCP_STATE_ESTABLISHED:
- case TCP_STATE_CLOSE_WAIT:
- case TCP_STATE_TIME_WAIT:
- case TCP_STATE_FIN_WAIT_2:
- return TCP_FLAG_ACK;
- case TCP_STATE_SYN_RCVD:
- return TCP_FLAG_SYN | TCP_FLAG_ACK;
- case TCP_STATE_SYN_SENT:
- return TCP_FLAG_SYN;
- case TCP_STATE_LAST_ACK:
- case TCP_STATE_FIN_WAIT_1:
- case TCP_STATE_CLOSING:
- if (tc->snd_nxt + 1 < tc->snd_una_max)
- return TCP_FLAG_ACK;
- else
- return TCP_FLAG_FIN;
- default:
- clib_warning ("Shouldn't be here!");
- }
- return 0;
}
/**
- * Push TCP header and update connection variables
+ * Push TCP header and update connection variables. Should only be called
+ * for segments with data, not for 'control' packets.
*/
always_inline void
-tcp_push_hdr_i (tcp_connection_t * tc, vlib_buffer_t * b,
- tcp_state_t next_state, u8 compute_opts, u8 maybe_burst)
+tcp_push_hdr_i (tcp_connection_t * tc, vlib_buffer_t * b, u32 snd_nxt,
+ u8 compute_opts, u8 maybe_burst, u8 update_snd_nxt)
{
+ u8 tcp_hdr_opts_len, flags = TCP_FLAG_ACK;
u32 advertise_wnd, data_len;
- u8 tcp_hdr_opts_len, flags;
tcp_main_t *tm = &tcp_main;
tcp_header_t *th;
if (maybe_burst)
advertise_wnd = tc->rcv_wnd >> tc->rcv_wscale;
else
- advertise_wnd = tcp_window_to_advertise (tc, next_state);
+ advertise_wnd = tcp_window_to_advertise (tc, TCP_STATE_ESTABLISHED);
- flags = tcp_make_state_flags (tc, next_state);
if (PREDICT_FALSE (tc->flags & TCP_CONN_PSH_PENDING))
{
- if (seq_geq (tc->psh_seq, tc->snd_nxt)
- && seq_lt (tc->psh_seq, tc->snd_nxt + data_len))
+ if (seq_geq (tc->psh_seq, snd_nxt)
+ && seq_lt (tc->psh_seq, snd_nxt + data_len))
flags |= TCP_FLAG_PSH;
}
- th = vlib_buffer_push_tcp (b, tc->c_lcl_port, tc->c_rmt_port, tc->snd_nxt,
+ th = vlib_buffer_push_tcp (b, tc->c_lcl_port, tc->c_rmt_port, snd_nxt,
tc->rcv_nxt, tcp_hdr_opts_len, flags,
advertise_wnd);
* Update connection variables
*/
- tc->snd_nxt += data_len;
+ if (update_snd_nxt)
+ tc->snd_nxt += data_len;
tc->rcv_las = tc->rcv_nxt;
- TCP_EVT_DBG (TCP_EVT_PKTIZE, tc);
+ tc->bytes_out += data_len;
+ tc->data_segs_out += 1;
+
+ TCP_EVT (TCP_EVT_PKTIZE, tc);
}
u32
-tcp_push_header (tcp_connection_t * tc, vlib_buffer_t * b)
+tcp_session_push_header (transport_connection_t * tconn, vlib_buffer_t * b)
{
- tcp_push_hdr_i (tc, b, TCP_STATE_ESTABLISHED, /* compute opts */ 0,
- /* burst */ 1);
- tc->snd_una_max = tc->snd_nxt;
- ASSERT (seq_leq (tc->snd_una_max, tc->snd_una + tc->snd_wnd));
+ tcp_connection_t *tc = (tcp_connection_t *) tconn;
+
+ if (tc->flags & TCP_CONN_TRACK_BURST)
+ {
+ tcp_bt_check_app_limited (tc);
+ tcp_bt_track_tx (tc);
+ tc->flags &= ~TCP_CONN_TRACK_BURST;
+ }
+
+ tcp_push_hdr_i (tc, b, tc->snd_nxt, /* compute opts */ 0, /* burst */ 1,
+ /* update_snd_nxt */ 1);
+
+ tc->snd_una_max = seq_max (tc->snd_nxt, tc->snd_una_max);
tcp_validate_txf_size (tc, tc->snd_una_max - tc->snd_una);
/* If not tracking an ACK, start tracking */
if (tc->rtt_ts == 0 && !tcp_in_cong_recovery (tc))
}
void
-tcp_program_ack (tcp_worker_ctx_t * wrk, tcp_connection_t * tc)
+tcp_program_ack (tcp_connection_t * tc)
{
if (!(tc->flags & TCP_CONN_SNDACK))
{
- vec_add1 (wrk->pending_acks, tc->c_c_index);
+ session_add_self_custom_tx_evt (&tc->connection, 1);
tc->flags |= TCP_CONN_SNDACK;
}
}
void
-tcp_program_dupack (tcp_worker_ctx_t * wrk, tcp_connection_t * tc)
+tcp_program_dupack (tcp_connection_t * tc)
{
if (!(tc->flags & TCP_CONN_SNDACK))
{
- vec_add1 (wrk->pending_acks, tc->c_c_index);
+ session_add_self_custom_tx_evt (&tc->connection, 1);
tc->flags |= TCP_CONN_SNDACK;
}
if (tc->pending_dupacks < 255)
}
void
-tcp_send_acks (tcp_worker_ctx_t * wrk)
+tcp_program_fastretransmit (tcp_connection_t * tc)
{
- u32 thread_index, *pending_acks;
- tcp_connection_t *tc;
- int i, j, n_acks;
-
- if (!vec_len (wrk->pending_acks))
- return;
-
- thread_index = wrk->vm->thread_index;
- pending_acks = wrk->pending_acks;
- for (i = 0; i < vec_len (pending_acks); i++)
+ if (!(tc->flags & TCP_CONN_FRXT_PENDING))
{
- tc = tcp_connection_get (pending_acks[i], thread_index);
- tc->flags &= ~TCP_CONN_SNDACK;
- if (!tc->pending_dupacks)
- {
- tcp_send_ack (tc);
- continue;
- }
-
- /* If we're supposed to send dupacks but have no ooo data
- * send only one ack */
- if (!vec_len (tc->snd_sacks))
- {
- tcp_send_ack (tc);
- continue;
- }
-
- /* Start with first sack block */
- tc->snd_sack_pos = 0;
-
- /* Generate enough dupacks to cover all sack blocks. Do not generate
- * more sacks than the number of packets received. But do generate at
- * least 3, i.e., the number needed to signal congestion, if needed. */
- n_acks = vec_len (tc->snd_sacks) / TCP_OPTS_MAX_SACK_BLOCKS;
- n_acks = clib_min (n_acks, tc->pending_dupacks);
- n_acks = clib_max (n_acks, clib_min (tc->pending_dupacks, 3));
- for (j = 0; j < n_acks; j++)
- tcp_send_ack (tc);
-
- tc->pending_dupacks = 0;
- tc->snd_sack_pos = 0;
+ session_add_self_custom_tx_evt (&tc->connection, 0);
+ tc->flags |= TCP_CONN_FRXT_PENDING;
}
- _vec_len (wrk->pending_acks) = 0;
}
/**
tcp_send_ack (tc);
}
+/**
+ * Send Window Update ACK,
+ * ensuring that it will be sent once, if RWND became non-zero,
+ * after zero RWND has been advertised in ACK before
+ */
+void
+tcp_send_window_update_ack (tcp_connection_t * tc)
+{
+ u32 win;
+
+ if (tcp_zero_rwnd_sent (tc))
+ {
+ win = tcp_window_to_advertise (tc, tc->state);
+ if (win > 0)
+ {
+ tcp_zero_rwnd_sent_off (tc);
+ tcp_program_ack (tc);
+ }
+ }
+}
+
/**
* Allocate a new buffer and build a new tcp segment
*
max_deq_bytes);
ASSERT (n_bytes == max_deq_bytes);
b[0]->current_length = n_bytes;
- tcp_push_hdr_i (tc, *b, tc->state, /* compute opts */ 0, /* burst */ 0);
- if (seq_gt (tc->snd_nxt, tc->snd_una_max))
- tc->snd_una_max = tc->snd_nxt;
+ tcp_push_hdr_i (tc, *b, tc->snd_una + offset, /* compute opts */ 0,
+ /* burst */ 0, /* update_snd_nxt */ 0);
}
/* Split mss into multiple buffers */
else
b[0]->total_length_not_including_first_buffer += n_peeked;
}
- tcp_push_hdr_i (tc, *b, tc->state, /* compute opts */ 0, /* burst */ 0);
- if (seq_gt (tc->snd_nxt, tc->snd_una_max))
- tc->snd_una_max = tc->snd_nxt;
+ tcp_push_hdr_i (tc, *b, tc->snd_una + offset, /* compute opts */ 0,
+ /* burst */ 0, /* update_snd_nxt */ 0);
if (PREDICT_FALSE (n_bufs))
{
/* Start is beyond snd_congestion */
start = tc->snd_una + offset;
if (seq_geq (start, tc->snd_congestion))
- goto done;
+ return 0;
/* Don't overshoot snd_congestion */
if (seq_gt (start + max_deq_bytes, tc->snd_congestion))
{
max_deq_bytes = tc->snd_congestion - start;
if (max_deq_bytes == 0)
- goto done;
+ return 0;
}
n_bytes = tcp_prepare_segment (wrk, tc, offset, max_deq_bytes, b);
return 0;
if (tcp_in_fastrecovery (tc))
- tc->snd_rxt_bytes += n_bytes;
+ {
+ tc->snd_rxt_bytes += n_bytes;
+ if (tc->flags & TCP_CONN_RATE_SAMPLE)
+ tcp_bt_track_rxt (tc, start, start + n_bytes);
+ }
-done:
- TCP_EVT_DBG (TCP_EVT_CC_RTX, tc, offset, n_bytes);
+ tc->bytes_retrans += n_bytes;
+ tc->segs_retrans += 1;
+ TCP_EVT (TCP_EVT_CC_RTX, tc, offset, n_bytes);
return n_bytes;
}
* Reset congestion control, switch cwnd to loss window and try again.
*/
static void
-tcp_rxt_timeout_cc (tcp_connection_t * tc)
+tcp_cc_init_rxt_timeout (tcp_connection_t * tc)
{
- TCP_EVT_DBG (TCP_EVT_CC_EVT, tc, 6);
+ TCP_EVT (TCP_EVT_CC_EVT, tc, 6);
tc->prev_ssthresh = tc->ssthresh;
tc->prev_cwnd = tc->cwnd;
- /* Cleanly recover cc (also clears up fast retransmit) */
+ /* Clear fast recovery state if needed */
if (tcp_in_fastrecovery (tc))
- {
- /* TODO be less aggressive about this */
- scoreboard_clear (&tc->sack_sb);
- tcp_cc_fastrecovery_exit (tc);
- }
- else
- tc->rcv_dupacks = 0;
+ tcp_cc_fastrecovery_clear (tc);
+
+ /* Let cc algo decide loss cwnd and ssthresh */
+ tcp_cc_loss (tc);
/* Start again from the beginning */
- tc->cc_algo->congestion (tc);
- tc->cwnd = tcp_loss_wnd (tc);
- tc->snd_congestion = tc->snd_una_max;
+ tc->snd_congestion = tc->snd_nxt;
+ tc->rcv_dupacks = 0;
tc->rtt_ts = 0;
tc->cwnd_acc_bytes = 0;
+ tc->tr_occurences += 1;
tcp_connection_tx_pacer_reset (tc, tc->cwnd, 2 * tc->snd_mss);
tcp_recovery_on (tc);
}
-static inline void
-tcp_timer_retransmit_handler_i (u32 index, u8 is_syn)
+void
+tcp_timer_retransmit_handler (u32 tc_index)
{
u32 thread_index = vlib_get_thread_index ();
tcp_worker_ctx_t *wrk = tcp_get_worker (thread_index);
vlib_buffer_t *b = 0;
u32 bi, n_bytes;
- if (is_syn)
- {
- tc = tcp_half_open_connection_get (index);
- /* Note: the connection may have transitioned to ESTABLISHED... */
- if (PREDICT_FALSE (tc == 0 || tc->state != TCP_STATE_SYN_SENT))
- return;
- tc->timers[TCP_TIMER_RETRANSMIT_SYN] = TCP_TIMER_HANDLE_INVALID;
- }
- else
- {
- tc = tcp_connection_get (index, thread_index);
- /* Note: the connection may have been closed and pool_put */
- if (PREDICT_FALSE (tc == 0 || tc->state == TCP_STATE_SYN_SENT))
- return;
- tc->timers[TCP_TIMER_RETRANSMIT] = TCP_TIMER_HANDLE_INVALID;
- /* Wait-close and retransmit could pop at the same time */
- if (tc->state == TCP_STATE_CLOSED)
- return;
- }
+ tc = tcp_connection_get (tc_index, thread_index);
+
+ /* Note: the connection may have been closed and pool_put */
+ if (PREDICT_FALSE (tc == 0 || tc->state == TCP_STATE_SYN_SENT))
+ return;
+
+ tc->timers[TCP_TIMER_RETRANSMIT] = TCP_TIMER_HANDLE_INVALID;
+
+ /* Wait-close and retransmit could pop at the same time */
+ if (tc->state == TCP_STATE_CLOSED)
+ return;
if (tc->state >= TCP_STATE_ESTABLISHED)
{
- TCP_EVT_DBG (TCP_EVT_CC_EVT, tc, 2);
+ TCP_EVT (TCP_EVT_CC_EVT, tc, 2);
/* Lost FIN, retransmit and return */
if (tc->flags & TCP_CONN_FINSNT)
/* Shouldn't be here. This condition is tricky because it has to take
* into account boff > 0 due to persist timeout. */
- if ((tc->rto_boff == 0 && tc->snd_una == tc->snd_una_max)
+ if ((tc->rto_boff == 0 && tc->snd_una == tc->snd_nxt)
|| (tc->rto_boff > 0 && seq_geq (tc->snd_una, tc->snd_congestion)
&& !tcp_flight_size (tc)))
{
tcp_update_rto (tc);
}
+ /* Peer is dead or network connectivity is lost. Close connection.
+ * RFC 1122 section 4.2.3.5 recommends a value of at least 100s. For
+ * a min rto of 0.2s we need to retry about 8 times. */
+ if (tc->rto_boff >= TCP_RTO_BOFF_MAX)
+ {
+ tcp_send_reset (tc);
+ tcp_connection_set_state (tc, TCP_STATE_CLOSED);
+ session_transport_closing_notify (&tc->connection);
+ tcp_connection_timers_reset (tc);
+ tcp_timer_update (tc, TCP_TIMER_WAITCLOSE, tcp_cfg.closewait_time);
+ return;
+ }
+
/* Increment RTO backoff (also equal to number of retries) and go back
* to first un-acked byte */
tc->rto_boff += 1;
+ /* TODO be less aggressive about clearing scoreboard */
+ scoreboard_clear (&tc->sack_sb);
+
/* First retransmit timeout */
if (tc->rto_boff == 1)
- tcp_rxt_timeout_cc (tc);
- else
- scoreboard_clear (&tc->sack_sb);
+ {
+ tcp_cc_init_rxt_timeout (tc);
+ /* Record timestamp. Eifel detection algorithm RFC3522 */
+ tc->snd_rxt_ts = tcp_tstamp (tc);
+ }
- /* If we've sent beyond snd_congestion, update it */
- if (seq_gt (tc->snd_una_max, tc->snd_congestion))
- tc->snd_congestion = tc->snd_una_max;
+ if (tc->flags & TCP_CONN_RATE_SAMPLE)
+ tcp_bt_flush_samples (tc);
- tc->snd_una_max = tc->snd_nxt = tc->snd_una;
- tc->rto = clib_min (tc->rto << 1, TCP_RTO_MAX);
+ /* If we've sent beyond snd_congestion, update it */
+ tc->snd_congestion = seq_max (tc->snd_nxt, tc->snd_congestion);
+ tc->snd_nxt = tc->snd_una;
- /* Send one segment. Note that n_bytes may be zero due to buffer
- * shortfall */
+ /* Send one segment. n_bytes may be zero due to buffer shortfall */
n_bytes = tcp_prepare_retransmit_segment (wrk, tc, 0, tc->snd_mss, &b);
if (!n_bytes)
{
}
bi = vlib_get_buffer_index (vm, b);
-
- /* For first retransmit, record timestamp (Eifel detection RFC3522) */
- if (tc->rto_boff == 1)
- tc->snd_rxt_ts = tcp_time_now_w_thread (tc->c_thread_index);
-
tcp_enqueue_to_output (wrk, b, bi, tc->c_is_ip4);
+
+ tc->rto = clib_min (tc->rto << 1, TCP_RTO_MAX);
tcp_retransmit_timer_force_update (tc);
}
- /* Retransmit for SYN */
- else if (tc->state == TCP_STATE_SYN_SENT)
+ /* Retransmit SYN-ACK */
+ else if (tc->state == TCP_STATE_SYN_RCVD)
{
- /* Half-open connection actually moved to established but we were
- * waiting for syn retransmit to pop to call cleanup from the right
- * thread. */
- if (tc->flags & TCP_CONN_HALF_OPEN_DONE)
+ TCP_EVT (TCP_EVT_CC_EVT, tc, 2);
+
+ tc->rtt_ts = 0;
+
+ /* Passive open establish timeout */
+ if (tc->rto > TCP_ESTABLISH_TIME >> 1)
{
- if (tcp_half_open_connection_cleanup (tc))
- TCP_DBG ("could not remove half-open connection");
+ tcp_connection_set_state (tc, TCP_STATE_CLOSED);
+ tcp_connection_timers_reset (tc);
+ tcp_timer_update (tc, TCP_TIMER_WAITCLOSE, tcp_cfg.cleanup_time);
return;
}
- TCP_EVT_DBG (TCP_EVT_CC_EVT, tc, 2);
-
- /* Try without increasing RTO a number of times. If this fails,
- * start growing RTO exponentially */
- tc->rto_boff += 1;
- if (tc->rto_boff > TCP_RTO_SYN_RETRIES)
- tc->rto = clib_min (tc->rto << 1, TCP_RTO_MAX);
-
- tcp_timer_update (tc, TCP_TIMER_RETRANSMIT_SYN,
- tc->rto * TCP_TO_TIMER_TICK);
-
if (PREDICT_FALSE (!vlib_buffer_alloc (vm, &bi, 1)))
{
- tcp_timer_update (tc, TCP_TIMER_RETRANSMIT_SYN, 1);
+ tcp_timer_update (tc, TCP_TIMER_RETRANSMIT, 1);
return;
}
- b = vlib_get_buffer (vm, bi);
- tcp_init_buffer (vm, b);
- tcp_make_syn (tc, b);
-
- tc->rtt_ts = 0;
- TCP_EVT_DBG (TCP_EVT_SYN_RXT, tc, 0);
-
- /* This goes straight to ipx_lookup. Retransmit timer set already */
- tcp_push_ip_hdr (wrk, tc, b);
- tcp_enqueue_to_ip_lookup (wrk, b, bi, tc->c_is_ip4, tc->c_fib_index);
- }
- /* Retransmit SYN-ACK */
- else if (tc->state == TCP_STATE_SYN_RCVD)
- {
- TCP_EVT_DBG (TCP_EVT_CC_EVT, tc, 2);
-
tc->rto_boff += 1;
if (tc->rto_boff > TCP_RTO_SYN_RETRIES)
tc->rto = clib_min (tc->rto << 1, TCP_RTO_MAX);
- tc->rtt_ts = 0;
tcp_retransmit_timer_force_update (tc);
- if (PREDICT_FALSE (!vlib_buffer_alloc (vm, &bi, 1)))
- {
- tcp_timer_update (tc, TCP_TIMER_RETRANSMIT, 1);
- return;
- }
-
b = vlib_get_buffer (vm, bi);
tcp_init_buffer (vm, b);
tcp_make_synack (tc, b);
- TCP_EVT_DBG (TCP_EVT_SYN_RXT, tc, 1);
+ TCP_EVT (TCP_EVT_SYN_RXT, tc, 1);
/* Retransmit timer already updated, just enqueue to output */
tcp_enqueue_to_output (wrk, b, bi, tc->c_is_ip4);
}
}
+/**
+ * SYN retransmit timer handler. Active open only.
+ */
void
-tcp_timer_retransmit_handler (u32 index)
+tcp_timer_retransmit_syn_handler (u32 tc_index)
{
- tcp_timer_retransmit_handler_i (index, 0);
-}
+ u32 thread_index = vlib_get_thread_index ();
+ tcp_worker_ctx_t *wrk = tcp_get_worker (thread_index);
+ vlib_main_t *vm = wrk->vm;
+ tcp_connection_t *tc;
+ vlib_buffer_t *b = 0;
+ u32 bi;
-void
-tcp_timer_retransmit_syn_handler (u32 index)
-{
- tcp_timer_retransmit_handler_i (index, 1);
+ tc = tcp_half_open_connection_get (tc_index);
+
+ /* Note: the connection may have transitioned to ESTABLISHED... */
+ if (PREDICT_FALSE (tc == 0 || tc->state != TCP_STATE_SYN_SENT))
+ return;
+
+ tc->timers[TCP_TIMER_RETRANSMIT_SYN] = TCP_TIMER_HANDLE_INVALID;
+
+ /* Half-open connection actually moved to established but we were
+ * waiting for syn retransmit to pop to call cleanup from the right
+ * thread. */
+ if (tc->flags & TCP_CONN_HALF_OPEN_DONE)
+ {
+ if (tcp_half_open_connection_cleanup (tc))
+ TCP_DBG ("could not remove half-open connection");
+ return;
+ }
+
+ TCP_EVT (TCP_EVT_CC_EVT, tc, 2);
+ tc->rtt_ts = 0;
+
+ /* Active open establish timeout */
+ if (tc->rto >= TCP_ESTABLISH_TIME >> 1)
+ {
+ session_stream_connect_notify (&tc->connection, 1 /* fail */ );
+ tcp_connection_cleanup (tc);
+ return;
+ }
+
+ if (PREDICT_FALSE (!vlib_buffer_alloc (vm, &bi, 1)))
+ {
+ tcp_timer_update (tc, TCP_TIMER_RETRANSMIT_SYN, 1);
+ return;
+ }
+
+ /* Try without increasing RTO a number of times. If this fails,
+ * start growing RTO exponentially */
+ tc->rto_boff += 1;
+ if (tc->rto_boff > TCP_RTO_SYN_RETRIES)
+ tc->rto = clib_min (tc->rto << 1, TCP_RTO_MAX);
+
+ b = vlib_get_buffer (vm, bi);
+ tcp_init_buffer (vm, b);
+ tcp_make_syn (tc, b);
+
+ TCP_EVT (TCP_EVT_SYN_RXT, tc, 0);
+
+ /* This goes straight to ipx_lookup */
+ tcp_push_ip_hdr (wrk, tc, b);
+ tcp_enqueue_to_ip_lookup (wrk, b, bi, tc->c_is_ip4, tc->c_fib_index);
+
+ tcp_timer_update (tc, TCP_TIMER_RETRANSMIT_SYN,
+ tc->rto * TCP_TO_TIMER_TICK);
}
/**
u8 *data;
tc = tcp_connection_get_if_valid (index, thread_index);
-
if (!tc)
return;
tc->timers[TCP_TIMER_PERSIST] = TCP_TIMER_HANDLE_INVALID;
/* Problem already solved or worse */
- if (tc->state == TCP_STATE_CLOSED || tc->state > TCP_STATE_ESTABLISHED
- || tc->snd_wnd > tc->snd_mss)
+ if (tc->state == TCP_STATE_CLOSED || tc->snd_wnd > tc->snd_mss
+ || (tc->flags & TCP_CONN_FINSNT))
return;
available_bytes = transport_max_tx_dequeue (&tc->connection);
- offset = tc->snd_una_max - tc->snd_una;
+ offset = tc->snd_nxt - tc->snd_una;
/* Reprogram persist if no new bytes available to send. We may have data
* next time */
tcp_validate_txf_size (tc, offset);
tc->snd_opts_len = tcp_make_options (tc, &tc->snd_opts, tc->state);
- max_snd_bytes =
- clib_min (tc->snd_mss, tm->bytes_per_buffer - TRANSPORT_MAX_HDRS_LEN);
- n_bytes =
- session_tx_fifo_peek_bytes (&tc->connection, data, offset, max_snd_bytes);
+ max_snd_bytes = clib_min (tc->snd_mss,
+ tm->bytes_per_buffer - TRANSPORT_MAX_HDRS_LEN);
+ n_bytes = session_tx_fifo_peek_bytes (&tc->connection, data, offset,
+ max_snd_bytes);
b->current_length = n_bytes;
ASSERT (n_bytes != 0 && (tcp_timer_is_active (tc, TCP_TIMER_RETRANSMIT)
|| tc->snd_nxt == tc->snd_una_max
|| tc->rto_boff > 1));
- tcp_push_hdr_i (tc, b, tc->state, /* compute opts */ 0, /* burst */ 0);
- tc->snd_una_max = tc->snd_nxt;
+ tcp_push_hdr_i (tc, b, tc->snd_nxt, /* compute opts */ 0,
+ /* burst */ 0, /* update_snd_nxt */ 1);
+ tc->snd_una_max = seq_max (tc->snd_nxt, tc->snd_una_max);
tcp_validate_txf_size (tc, tc->snd_una_max - tc->snd_una);
tcp_enqueue_to_output (wrk, b, bi, tc->c_is_ip4);
int
tcp_retransmit_first_unacked (tcp_worker_ctx_t * wrk, tcp_connection_t * tc)
{
- u32 bi, old_snd_nxt, n_bytes;
vlib_main_t *vm = wrk->vm;
vlib_buffer_t *b;
+ u32 bi, n_bytes;
- old_snd_nxt = tc->snd_nxt;
- tc->snd_nxt = tc->snd_una;
-
- TCP_EVT_DBG (TCP_EVT_CC_EVT, tc, 1);
+ TCP_EVT (TCP_EVT_CC_EVT, tc, 1);
n_bytes = tcp_prepare_retransmit_segment (wrk, tc, 0, tc->snd_mss, &b);
if (!n_bytes)
bi = vlib_get_buffer_index (vm, b);
tcp_enqueue_to_output (wrk, b, bi, tc->c_is_ip4);
- tc->snd_nxt = old_snd_nxt;
return 0;
}
tcp_fast_retransmit_unsent (tcp_worker_ctx_t * wrk, tcp_connection_t * tc,
u32 burst_size)
{
- u32 offset, n_segs = 0, n_written, bi;
+ u32 offset, n_segs = 0, n_written, bi, available_wnd;
vlib_main_t *vm = wrk->vm;
vlib_buffer_t *b = 0;
- tc->snd_nxt = tc->snd_una_max;
- offset = tc->snd_una_max - tc->snd_una;
+ offset = tc->snd_nxt - tc->snd_una;
+ available_wnd = tc->snd_wnd - offset;
+ burst_size = clib_min (burst_size, available_wnd / tc->snd_mss);
+
while (n_segs < burst_size)
{
n_written = tcp_prepare_segment (wrk, tc, offset, tc->snd_mss, &b);
tcp_enqueue_to_output (wrk, b, bi, tc->c_is_ip4);
offset += n_written;
n_segs += 1;
+
+ tc->snd_nxt += n_written;
+ tc->snd_una_max = seq_max (tc->snd_nxt, tc->snd_una_max);
}
done:
vlib_main_t *vm = wrk->vm;
vlib_buffer_t *b = 0;
sack_scoreboard_t *sb;
- u32 bi, old_snd_nxt;
+ u32 bi, max_deq;
int snd_space;
- u32 max_deq;
u8 snd_limited = 0, can_rescue = 0;
ASSERT (tcp_in_fastrecovery (tc));
snd_space = tcp_available_cc_snd_space (tc);
if (snd_space < tc->snd_mss)
{
- tcp_program_fastretransmit (wrk, tc);
+ tcp_program_fastretransmit (tc);
return 0;
}
- TCP_EVT_DBG (TCP_EVT_CC_EVT, tc, 0);
- old_snd_nxt = tc->snd_nxt;
+ TCP_EVT (TCP_EVT_CC_EVT, tc, 0);
sb = &tc->sack_sb;
hole = scoreboard_get_hole (sb, sb->cur_rxt_hole);
max_deq = transport_max_tx_dequeue (&tc->connection);
- max_deq -= tc->snd_una_max - tc->snd_una;
+ max_deq -= tc->snd_nxt - tc->snd_una;
while (snd_space > 0 && n_segs < burst_size)
{
snd_space / tc->snd_mss);
n_segs_now = tcp_fast_retransmit_unsent (wrk, tc, burst_size);
if (max_deq > n_segs_now * tc->snd_mss)
- tcp_program_fastretransmit (wrk, tc);
+ tcp_program_fastretransmit (tc);
n_segs += n_segs_now;
goto done;
}
max_bytes = clib_min (max_bytes, snd_space);
offset = tc->snd_congestion - tc->snd_una - max_bytes;
sb->rescue_rxt = tc->snd_congestion;
- tc->snd_nxt = tc->snd_una + offset;
n_written = tcp_prepare_retransmit_segment (wrk, tc, offset,
max_bytes, &b);
if (!n_written)
break;
offset = sb->high_rxt - tc->snd_una;
- tc->snd_nxt = sb->high_rxt;
n_written = tcp_prepare_retransmit_segment (wrk, tc, offset, max_bytes,
&b);
ASSERT (n_written <= snd_space);
}
if (hole)
- tcp_program_fastretransmit (wrk, tc);
+ tcp_program_fastretransmit (tc);
done:
- /* If window allows, send 1 SMSS of new data */
- tc->snd_nxt = old_snd_nxt;
return n_segs;
}
tcp_fast_retransmit_no_sack (tcp_worker_ctx_t * wrk, tcp_connection_t * tc,
u32 burst_size)
{
- u32 n_written = 0, offset = 0, bi, old_snd_nxt, max_deq, n_segs_now;
+ u32 n_written = 0, offset = 0, bi, max_deq, n_segs_now;
vlib_main_t *vm = wrk->vm;
int snd_space, n_segs = 0;
vlib_buffer_t *b;
ASSERT (tcp_in_fastrecovery (tc));
- TCP_EVT_DBG (TCP_EVT_CC_EVT, tc, 0);
- old_snd_nxt = tc->snd_nxt;
+ TCP_EVT (TCP_EVT_CC_EVT, tc, 0);
+
+ snd_space = tcp_available_cc_snd_space (tc);
if (!tcp_fastrecovery_first (tc))
goto send_unsent;
/* RFC 6582: [If a partial ack], retransmit the first unacknowledged
* segment. */
- snd_space = tc->sack_sb.last_bytes_delivered;
- tc->snd_nxt = tc->snd_una;
while (snd_space > 0 && n_segs < burst_size)
{
n_written = tcp_prepare_retransmit_segment (wrk, tc, offset,
send_unsent:
/* RFC 6582: Send a new segment if permitted by the new value of cwnd. */
- snd_space = tcp_available_cc_snd_space (tc);
if (snd_space < tc->snd_mss || tc->snd_mss == 0)
goto done;
max_deq = transport_max_tx_dequeue (&tc->connection);
- max_deq -= tc->snd_una_max - tc->snd_una;
+ max_deq -= tc->snd_nxt - tc->snd_una;
if (max_deq)
{
snd_space = clib_min (max_deq, snd_space);
burst_size = clib_min (burst_size - n_segs, snd_space / tc->snd_mss);
n_segs_now = tcp_fast_retransmit_unsent (wrk, tc, burst_size);
if (max_deq > n_segs_now * tc->snd_mss)
- tcp_program_fastretransmit (wrk, tc);
+ tcp_program_fastretransmit (tc);
n_segs += n_segs_now;
}
- /* Restore snd_nxt */
- tc->snd_nxt = old_snd_nxt;
-
done:
tcp_fastrecovery_first_off (tc);
return n_segs;
return tcp_fast_retransmit_no_sack (wrk, tc, burst_size);
}
+static int
+tcp_send_acks (tcp_connection_t * tc, u32 max_burst_size)
+{
+ int j, n_acks;
+
+ if (!tc->pending_dupacks)
+ {
+ tcp_send_ack (tc);
+ return 1;
+ }
+
+ /* If we're supposed to send dupacks but have no ooo data
+ * send only one ack */
+ if (!vec_len (tc->snd_sacks))
+ {
+ tcp_send_ack (tc);
+ return 1;
+ }
+
+ /* Start with first sack block */
+ tc->snd_sack_pos = 0;
+
+ /* Generate enough dupacks to cover all sack blocks. Do not generate
+ * more sacks than the number of packets received. But do generate at
+ * least 3, i.e., the number needed to signal congestion, if needed. */
+ n_acks = vec_len (tc->snd_sacks) / TCP_OPTS_MAX_SACK_BLOCKS;
+ n_acks = clib_min (n_acks, tc->pending_dupacks);
+ n_acks = clib_max (n_acks, clib_min (tc->pending_dupacks, 3));
+ for (j = 0; j < clib_min (n_acks, max_burst_size); j++)
+ tcp_send_ack (tc);
+
+ if (n_acks < max_burst_size)
+ {
+ tc->pending_dupacks = 0;
+ tc->snd_sack_pos = 0;
+ tc->dupacks_out += n_acks;
+ return n_acks;
+ }
+ else
+ {
+ TCP_DBG ("constrained by burst size");
+ tc->pending_dupacks = n_acks - max_burst_size;
+ tc->dupacks_out += max_burst_size;
+ tcp_program_dupack (tc);
+ return max_burst_size;
+ }
+}
+
+static int
+tcp_do_fastretransmit (tcp_connection_t * tc, u32 max_burst_size)
+{
+ u32 n_segs = 0, burst_size, sent_bytes, burst_bytes;
+ tcp_worker_ctx_t *wrk;
+
+ wrk = tcp_get_worker (tc->c_thread_index);
+ burst_bytes = transport_connection_tx_pacer_burst (&tc->connection,
+ wrk->vm->
+ clib_time.last_cpu_time);
+ burst_size = clib_min (max_burst_size, burst_bytes / tc->snd_mss);
+ if (!burst_size)
+ {
+ tcp_program_fastretransmit (tc);
+ return 0;
+ }
+
+ n_segs = tcp_fast_retransmit (wrk, tc, burst_size);
+ sent_bytes = clib_min (n_segs * tc->snd_mss, burst_bytes);
+ transport_connection_tx_pacer_update_bytes (&tc->connection, sent_bytes);
+ return n_segs;
+}
+
+int
+tcp_session_custom_tx (void *conn, u32 max_burst_size)
+{
+ tcp_connection_t *tc = (tcp_connection_t *) conn;
+ u32 n_segs = 0;
+
+ if (tcp_in_fastrecovery (tc) && (tc->flags & TCP_CONN_FRXT_PENDING))
+ {
+ tc->flags &= ~TCP_CONN_FRXT_PENDING;
+ n_segs = tcp_do_fastretransmit (tc, max_burst_size);
+ max_burst_size -= n_segs;
+ }
+
+ if (!(tc->flags & TCP_CONN_SNDACK))
+ return n_segs;
+
+ tc->flags &= ~TCP_CONN_SNDACK;
+
+ /* We have retransmitted packets and no dupack */
+ if (n_segs && !tc->pending_dupacks)
+ return n_segs;
+
+ if (!max_burst_size)
+ {
+ tcp_program_ack (tc);
+ return max_burst_size;
+ }
+
+ n_segs += tcp_send_acks (tc, max_burst_size);
+
+ return n_segs;
+}
+#endif /* CLIB_MARCH_VARIANT */
+
static void
tcp_output_handle_link_local (tcp_connection_t * tc0, vlib_buffer_t * b0,
u16 * next0, u32 * error0)
tcp_header_t *th0 = 0;
th0 = vlib_buffer_get_current (b0);
- TCP_EVT_DBG (TCP_EVT_OUTPUT, tc0, th0->flags, b0->current_length);
+ TCP_EVT (TCP_EVT_OUTPUT, tc0, th0->flags, b0->current_length);
if (is_ip4)
{
vlib_buffer_push_ip4 (vm, b0, &tc0->c_lcl_ip4, &tc0->c_rmt_ip4,
always_inline void
tcp_output_handle_packet (tcp_connection_t * tc0, vlib_buffer_t * b0,
- u32 * error0, u16 * next0, u8 is_ip4)
+ vlib_node_runtime_t * error_node, u16 * next0,
+ u8 is_ip4)
{
-
- if (PREDICT_FALSE (tc0->state == TCP_STATE_CLOSED))
+ /* If next_index is not drop use it */
+ if (tc0->next_node_index)
{
- *error0 = TCP_ERROR_INVALID_CONNECTION;
- *next0 = TCP_OUTPUT_NEXT_DROP;
- return;
+ *next0 = tc0->next_node_index;
+ vnet_buffer (b0)->tcp.next_node_opaque = tc0->next_node_opaque;
}
vnet_buffer (b0)->sw_if_index[VLIB_TX] = tc0->c_fib_index;
if (!is_ip4)
{
+ u32 error0 = 0;
+
if (PREDICT_FALSE (ip6_address_is_link_local_unicast (&tc0->c_rmt_ip6)))
- tcp_output_handle_link_local (tc0, b0, next0, error0);
+ tcp_output_handle_link_local (tc0, b0, next0, &error0);
+
+ if (PREDICT_FALSE (error0))
+ {
+ b0->error = error_node->errors[error0];
+ return;
+ }
}
if (!TCP_ALWAYS_ACK)
tcp_timer_reset (tc0, TCP_TIMER_DELACK);
+
+ tc0->segs_out += 1;
}
always_inline uword
u32 n_left_from, *from, thread_index = vm->thread_index;
vlib_buffer_t *bufs[VLIB_FRAME_SIZE], **b;
u16 nexts[VLIB_FRAME_SIZE], *next;
+ vlib_node_runtime_t *error_node;
+
+ error_node = vlib_node_get_runtime (vm, tcp_node_index (output, is_ip4));
from = vlib_frame_vector_args (frame);
n_left_from = frame->n_vectors;
while (n_left_from >= 4)
{
- u32 error0 = TCP_ERROR_PKTS_SENT, error1 = TCP_ERROR_PKTS_SENT;
tcp_connection_t *tc0, *tc1;
{
tcp_output_push_ip (vm, b[0], tc0, is_ip4);
tcp_output_push_ip (vm, b[1], tc1, is_ip4);
- tcp_output_handle_packet (tc0, b[0], &error0, &next[0], is_ip4);
- tcp_output_handle_packet (tc1, b[1], &error1, &next[1], is_ip4);
+ tcp_output_handle_packet (tc0, b[0], error_node, &next[0], is_ip4);
+ tcp_output_handle_packet (tc1, b[1], error_node, &next[1], is_ip4);
b += 2;
next += 2;
}
while (n_left_from > 0)
{
- u32 error0 = TCP_ERROR_PKTS_SENT;
tcp_connection_t *tc0;
if (n_left_from > 1)
thread_index);
tcp_output_push_ip (vm, b[0], tc0, is_ip4);
- tcp_output_handle_packet (tc0, b[0], &error0, &next[0], is_ip4);
+ tcp_output_handle_packet (tc0, b[0], error_node, &next[0], is_ip4);
b += 1;
next += 1;
}
vlib_buffer_enqueue_to_next (vm, node, from, nexts, frame->n_vectors);
+ vlib_node_increment_counter (vm, tcp_node_index (output, is_ip4),
+ TCP_ERROR_PKTS_SENT, frame->n_vectors);
return frame->n_vectors;
}
-static uword
-tcp4_output (vlib_main_t * vm, vlib_node_runtime_t * node,
- vlib_frame_t * from_frame)
+VLIB_NODE_FN (tcp4_output_node) (vlib_main_t * vm, vlib_node_runtime_t * node,
+ vlib_frame_t * from_frame)
{
return tcp46_output_inline (vm, node, from_frame, 1 /* is_ip4 */ );
}
-static uword
-tcp6_output (vlib_main_t * vm, vlib_node_runtime_t * node,
- vlib_frame_t * from_frame)
+VLIB_NODE_FN (tcp6_output_node) (vlib_main_t * vm, vlib_node_runtime_t * node,
+ vlib_frame_t * from_frame)
{
return tcp46_output_inline (vm, node, from_frame, 0 /* is_ip4 */ );
}
/* *INDENT-OFF* */
VLIB_REGISTER_NODE (tcp4_output_node) =
{
- .function = tcp4_output,
.name = "tcp4-output",
/* Takes a vector of packets. */
.vector_size = sizeof (u32),
};
/* *INDENT-ON* */
-VLIB_NODE_FUNCTION_MULTIARCH (tcp4_output_node, tcp4_output);
-
/* *INDENT-OFF* */
VLIB_REGISTER_NODE (tcp6_output_node) =
{
- .function = tcp6_output,
.name = "tcp6-output",
/* Takes a vector of packets. */
.vector_size = sizeof (u32),
};
/* *INDENT-ON* */
-VLIB_NODE_FUNCTION_MULTIARCH (tcp6_output_node, tcp6_output);
-
typedef enum _tcp_reset_next
{
TCP_RESET_NEXT_DROP,
return from_frame->n_vectors;
}
-static uword
-tcp4_send_reset (vlib_main_t * vm, vlib_node_runtime_t * node,
- vlib_frame_t * from_frame)
+VLIB_NODE_FN (tcp4_reset_node) (vlib_main_t * vm, vlib_node_runtime_t * node,
+ vlib_frame_t * from_frame)
{
return tcp46_send_reset_inline (vm, node, from_frame, 1);
}
-static uword
-tcp6_send_reset (vlib_main_t * vm, vlib_node_runtime_t * node,
- vlib_frame_t * from_frame)
+VLIB_NODE_FN (tcp6_reset_node) (vlib_main_t * vm, vlib_node_runtime_t * node,
+ vlib_frame_t * from_frame)
{
return tcp46_send_reset_inline (vm, node, from_frame, 0);
}
/* *INDENT-OFF* */
VLIB_REGISTER_NODE (tcp4_reset_node) = {
- .function = tcp4_send_reset,
.name = "tcp4-reset",
.vector_size = sizeof (u32),
.n_errors = TCP_N_ERROR,
};
/* *INDENT-ON* */
-VLIB_NODE_FUNCTION_MULTIARCH (tcp4_reset_node, tcp4_send_reset);
-
/* *INDENT-OFF* */
VLIB_REGISTER_NODE (tcp6_reset_node) = {
- .function = tcp6_send_reset,
.name = "tcp6-reset",
.vector_size = sizeof (u32),
.n_errors = TCP_N_ERROR,
};
/* *INDENT-ON* */
-VLIB_NODE_FUNCTION_MULTIARCH (tcp6_reset_node, tcp6_send_reset);
-
/*
* fd.io coding-style-patch-verification: ON
*
Code Review / vpp.git / blobdiff