*/
static int
tcp_segment_validate (vlib_main_t * vm, tcp_connection_t * tc0,
- vlib_buffer_t * b0, tcp_header_t * th0, u32 * next0)
+ vlib_buffer_t * b0, tcp_header_t * th0,
+ u32 * next0, u32 * error0)
{
if (PREDICT_FALSE (!tcp_ack (th0) && !tcp_rst (th0) && !tcp_syn (th0)))
- return -1;
+ {
+ *error0 = TCP_ERROR_SEGMENT_INVALID;
+ goto drop;
+ }
if (PREDICT_FALSE (tcp_options_parse (th0, &tc0->rcv_opts)))
{
clib_warning ("options parse error");
- return -1;
+ *error0 = TCP_ERROR_OPTIONS;
+ goto drop;
}
- if (tcp_segment_check_paws (tc0))
+ if (PREDICT_FALSE (tcp_segment_check_paws (tc0)))
{
+ *error0 = TCP_ERROR_PAWS;
if (CLIB_DEBUG > 2)
{
clib_warning ("paws failed\n%U", format_tcp_connection, tc0, 2);
if (!tcp_rst (th0))
{
tcp_make_ack (tc0, b0);
- *next0 = tcp_next_output (tc0->c_is_ip4);
TCP_EVT_DBG (TCP_EVT_DUPACK_SENT, tc0);
- return -1;
+ goto error;
}
}
+ goto drop;
}
/* 1st: check sequence number */
if (!tcp_segment_in_rcv_wnd (tc0, vnet_buffer (b0)->tcp.seq_number,
vnet_buffer (b0)->tcp.seq_end))
{
+ *error0 = TCP_ERROR_RCV_WND;
+
/* If our window is 0 and the packet is in sequence, let it pass
- * through for ack processing. It should be dropped later.*/
- if (tc0->rcv_wnd == 0
- && tc0->rcv_nxt == vnet_buffer (b0)->tcp.seq_number)
- {
- /* TODO Should segment be tagged? */
- }
- else
+ * through for ack processing. It should be dropped later. */
+ if (!(tc0->rcv_wnd == 0
+ && tc0->rcv_nxt == vnet_buffer (b0)->tcp.seq_number))
{
/* If not RST, send dup ack */
if (!tcp_rst (th0))
{
tcp_make_ack (tc0, b0);
- *next0 = tcp_next_output (tc0->c_is_ip4);
TCP_EVT_DBG (TCP_EVT_DUPACK_SENT, tc0);
+ goto error;
}
- return -1;
+ goto drop;
}
}
/* 2nd: check the RST bit */
- if (tcp_rst (th0))
+ if (PREDICT_FALSE (tcp_rst (th0)))
{
tcp_connection_reset (tc0);
- return -1;
+ *error0 = TCP_ERROR_RST_RCVD;
+ goto drop;
}
/* 3rd: check security and precedence (skip) */
/* 4th: check the SYN bit */
- if (tcp_syn (th0))
+ if (PREDICT_FALSE (tcp_syn (th0)))
{
/* TODO implement RFC 5961 */
if (tc0->state == TCP_STATE_SYN_RCVD)
tcp_make_ack (tc0, b0);
TCP_EVT_DBG (TCP_EVT_SYNACK_RCVD, tc0);
}
- *next0 = tcp_next_output (tc0->c_is_ip4);
- return -1;
+ goto error;
}
/* If segment in window, save timestamp */
tcp_update_timestamp (tc0, vnet_buffer (b0)->tcp.seq_number,
vnet_buffer (b0)->tcp.seq_end);
return 0;
+
+drop:
+ *next0 = tcp_next_drop (tc0->c_is_ip4);
+ return -1;
+error:
+ *next0 = tcp_next_output (tc0->c_is_ip4);
+ return -1;
}
always_inline int
}
}
+/**
+ * Init loss recovery/fast recovery.
+ *
+ * Triggered by dup acks as opposed to timer timeout. Note that cwnd is
+ * updated in @ref tcp_cc_handle_event after fast retransmit
+ */
void
tcp_cc_init_congestion (tcp_connection_t * tc)
{
tcp_fastrecovery_on (tc);
tc->snd_congestion = tc->snd_una_max;
+ tc->cwnd_acc_bytes = 0;
tc->cc_algo->congestion (tc);
TCP_EVT_DBG (TCP_EVT_CC_EVT, tc, 4);
}
static void
tcp_cc_recovery_exit (tcp_connection_t * tc)
{
- /* Deflate rto */
tc->rto_boff = 0;
tcp_update_rto (tc);
tc->snd_rxt_ts = 0;
ASSERT (tcp_in_cong_recovery (tc));
if (tcp_cc_is_spurious_retransmit (tc))
{
+ clib_warning ("here");
tcp_cc_congestion_undo (tc);
return 1;
}
* Duplicate ACK. Check if we should enter fast recovery, or if already in
* it account for the bytes that left the network.
*/
- if (is_dack)
+ if (is_dack && !tcp_in_recovery (tc))
{
+ TCP_EVT_DBG (TCP_EVT_DUPACK_RCVD, tc, 1);
ASSERT (tc->snd_una != tc->snd_una_max
|| tc->sack_sb.last_sacked_bytes);
tc->rcv_dupacks++;
+ /* Pure duplicate ack. If some data got acked, it's handled lower */
if (tc->rcv_dupacks > TCP_DUPACK_THRESHOLD && !tc->bytes_acked)
{
ASSERT (tcp_in_fastrecovery (tc));
- /* Pure duplicate ack. If some data got acked, it's handled lower */
tc->cc_algo->rcv_cong_ack (tc, TCP_CC_DUPACK);
return;
}
else if (tcp_should_fastrecover (tc))
{
- /* Things are already bad */
- if (tcp_in_cong_recovery (tc))
- {
- tc->rcv_dupacks = 0;
- goto partial_ack_test;
- }
+ ASSERT (!tcp_in_fastrecovery (tc));
/* If of of the two conditions lower hold, reset dupacks because
* we're probably after timeout (RFC6582 heuristics).
goto partial_ack;
}
-partial_ack_test:
-
if (!tc->bytes_acked)
return;
partial_ack:
+ TCP_EVT_DBG (TCP_EVT_CC_PACK, tc);
+
/*
* Legitimate ACK. 1) See if we can exit recovery
*/
/*
* Legitimate ACK. 2) If PARTIAL ACK try to retransmit
*/
- TCP_EVT_DBG (TCP_EVT_CC_PACK, tc);
/* RFC6675: If the incoming ACK is a cumulative acknowledgment,
- * reset dupacks to 0 */
+ * reset dupacks to 0. Also needed if in congestion recovery */
tc->rcv_dupacks = 0;
- tcp_retransmit_first_unacked (tc);
-
/* Post RTO timeout don't try anything fancy */
if (tcp_in_recovery (tc))
- return;
+ {
+ tc->cc_algo->rcv_ack (tc);
+ tc->tsecr_last_ack = tc->rcv_opts.tsecr;
+ return;
+ }
/* Remove retransmitted bytes that have been delivered */
ASSERT (tc->bytes_acked + tc->sack_sb.snd_una_adv
vnet_buffer (b)->tcp.ack_number);
if (tcp_in_fastrecovery (tc) && tc->rcv_dupacks == TCP_DUPACK_THRESHOLD)
{
- TCP_EVT_DBG (TCP_EVT_DUPACK_RCVD, tc);
tcp_cc_handle_event (tc, 1);
}
/* Don't drop yet */
if (!tcp_in_cong_recovery (tc))
return 0;
*error = TCP_ERROR_ACK_DUP;
- TCP_EVT_DBG (TCP_EVT_DUPACK_RCVD, tc, 1);
return vnet_buffer (b)->tcp.data_len ? 0 : -1;
}
* Update congestion control (slow start/congestion avoidance)
*/
tcp_cc_update (tc, b);
-
+ *error = TCP_ERROR_ACK_OK;
return 0;
}
int written, error = TCP_ERROR_ENQUEUED;
ASSERT (seq_geq (vnet_buffer (b)->tcp.seq_number, tc->rcv_nxt));
-
- /* Pure ACK. Update rcv_nxt and be done. */
- if (PREDICT_FALSE (data_len == 0))
- {
- return TCP_ERROR_PURE_ACK;
- }
-
+ ASSERT (data_len);
written = session_enqueue_stream_connection (&tc->connection, b, 0,
1 /* queue event */ , 1);
int rv, offset;
ASSERT (seq_gt (vnet_buffer (b)->tcp.seq_number, tc->rcv_nxt));
-
- /* Pure ACK. Do nothing */
- if (PREDICT_FALSE (data_len == 0))
- {
- return TCP_ERROR_PURE_ACK;
- }
+ ASSERT (data_len);
/* Enqueue out-of-order data with relative offset */
rv = session_enqueue_stream_connection (&tc->connection, b,
}
}
- return TCP_ERROR_ENQUEUED;
+ return TCP_ERROR_ENQUEUED_OOO;
}
/**
return 0;
}
+/**
+ * Receive buffer for connection and handle acks
+ *
+ * It handles both in order or out-of-order data.
+ */
static int
-tcp_segment_rcv (tcp_main_t * tm, tcp_connection_t * tc, vlib_buffer_t * b,
- u32 * next0)
+tcp_segment_rcv (tcp_connection_t * tc, vlib_buffer_t * b, u32 * next0)
{
- u32 error = 0, n_bytes_to_drop, n_data_bytes;
+ u32 error, n_bytes_to_drop, n_data_bytes;
vlib_buffer_advance (b, vnet_buffer (b)->tcp.data_offset);
n_data_bytes = vnet_buffer (b)->tcp.data_len;
* the rx window */
if (seq_lt (vnet_buffer (b)->tcp.seq_number, tc->rcv_nxt))
{
- error = TCP_ERROR_SEGMENT_OLD;
- *next0 = tcp_next_drop (tc->c_is_ip4);
-
- /* Completely in the past (possible retransmit) */
+ /* Completely in the past (possible retransmit). Ack
+ * retransmissions since we may not have any data to send */
if (seq_leq (vnet_buffer (b)->tcp.seq_end, tc->rcv_nxt))
{
- /* Ack retransmissions since we may not have any data to send */
tcp_make_ack (tc, b);
+ error = TCP_ERROR_SEGMENT_OLD;
*next0 = tcp_next_output (tc->c_is_ip4);
goto done;
}
- /* Chop off the bytes in the past */
+ /* Chop off the bytes in the past and see if what is left
+ * can be enqueued in order */
n_bytes_to_drop = tc->rcv_nxt - vnet_buffer (b)->tcp.seq_number;
n_data_bytes -= n_bytes_to_drop;
vnet_buffer (b)->tcp.seq_number = tc->rcv_nxt;
if (tcp_buffer_discard_bytes (b, n_bytes_to_drop))
- goto done;
-
+ {
+ error = TCP_ERROR_SEGMENT_OLD;
+ *next0 = tcp_next_drop (tc->c_is_ip4);
+ goto done;
+ }
goto in_order;
}
+ /* RFC2581: Enqueue and send DUPACK for fast retransmit */
error = tcp_session_enqueue_ooo (tc, b, n_data_bytes);
-
- /* N.B. Should not filter burst of dupacks. Two issues 1) dupacks open
- * cwnd on remote peer when congested 2) acks leaving should have the
- * latest rcv_wnd since the burst may eaten up all of it, so only the
- * old ones could be filtered.
- */
-
- /* RFC2581: Send DUPACK for fast retransmit */
- tcp_make_ack (tc, b);
*next0 = tcp_next_output (tc->c_is_ip4);
-
- /* Mark as DUPACK. We may filter these in output if
- * the burst fills the holes. */
- if (n_data_bytes)
- vnet_buffer (b)->tcp.flags = TCP_BUF_FLAG_DUPACK;
-
+ tcp_make_ack (tc, b);
+ vnet_buffer (b)->tcp.flags = TCP_BUF_FLAG_DUPACK;
TCP_EVT_DBG (TCP_EVT_DUPACK_SENT, tc);
goto done;
}
/* 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);
-
- /* Check if ACK can be delayed */
if (tcp_can_delack (tc))
{
+ *next0 = tcp_next_drop (tc->c_is_ip4);
if (!tcp_timer_is_active (tc, TCP_TIMER_DELACK))
tcp_timer_set (tc, TCP_TIMER_DELACK, TCP_DELACK_TIME);
goto done;
}
always_inline void
-tcp_node_inc_counter (vlib_main_t * vm, u32 tcp4_node, u32 tcp6_node,
- u8 is_ip4, u8 evt, u8 val)
+tcp_node_inc_counter_i (vlib_main_t * vm, u32 tcp4_node, u32 tcp6_node,
+ u8 is_ip4, u32 evt, u32 val)
{
- if (PREDICT_TRUE (!val))
- return;
-
if (is_ip4)
vlib_node_increment_counter (vm, tcp4_node, evt, val);
else
vlib_node_increment_counter (vm, tcp6_node, evt, val);
}
+#define tcp_maybe_inc_counter(node_id, err, count) \
+{ \
+ if (next0 != tcp_next_drop (is_ip4)) \
+ tcp_node_inc_counter_i (vm, tcp4_##node_id##_node.index, \
+ tcp6_##node_id##_node.index, is_ip4, err, \
+ 1); \
+}
+#define tcp_inc_counter(node_id, err, count) \
+ tcp_node_inc_counter_i (vm, tcp4_##node_id##_node.index, \
+ tcp6_##node_id##_node.index, is_ip4, \
+ err, count)
+#define tcp_maybe_inc_err_counter(cnts, err) \
+{ \
+ cnts[err] += (next0 != tcp_next_drop (is_ip4)); \
+}
+#define tcp_inc_err_counter(cnts, err, val) \
+{ \
+ cnts[err] += val; \
+}
+#define tcp_store_err_counters(node_id, cnts) \
+{ \
+ int i; \
+ for (i = 0; i < TCP_N_ERROR; i++) \
+ if (cnts[i]) \
+ tcp_inc_counter(node_id, i, cnts[i]); \
+}
+
+
always_inline uword
tcp46_established_inline (vlib_main_t * vm, vlib_node_runtime_t * node,
vlib_frame_t * from_frame, int is_ip4)
{
- u32 n_left_from, next_index, *from, *to_next;
u32 my_thread_index = vm->thread_index, errors = 0;
- tcp_main_t *tm = vnet_get_tcp_main ();
+ u32 n_left_from, next_index, *from, *to_next;
+ u16 err_counters[TCP_N_ERROR] = { 0 };
u8 is_fin = 0;
from = vlib_frame_vector_args (from_frame);
n_left_from = from_frame->n_vectors;
-
next_index = node->cached_next_index;
while (n_left_from > 0)
vlib_buffer_t *b0;
tcp_header_t *th0 = 0;
tcp_connection_t *tc0;
- u32 next0 = tcp_next_drop (is_ip4), error0 = TCP_ERROR_ENQUEUED;
+ u32 next0 = tcp_next_drop (is_ip4), error0 = TCP_ERROR_ACK_OK;
if (n_left_from > 1)
{
/* TODO header prediction fast path */
/* 1-4: check SEQ, RST, SYN */
- if (PREDICT_FALSE (tcp_segment_validate (vm, tc0, b0, th0, &next0)))
+ if (PREDICT_FALSE (tcp_segment_validate (vm, tc0, b0, th0, &next0,
+ &error0)))
{
- error0 = TCP_ERROR_SEGMENT_INVALID;
+ tcp_maybe_inc_err_counter (err_counters, error0);
TCP_EVT_DBG (TCP_EVT_SEG_INVALID, tc0,
vnet_buffer (b0)->tcp.seq_number,
vnet_buffer (b0)->tcp.seq_end);
}
/* 5: check the ACK field */
- if (tcp_rcv_ack (tc0, b0, th0, &next0, &error0))
- goto done;
+ if (PREDICT_FALSE (tcp_rcv_ack (tc0, b0, th0, &next0, &error0)))
+ {
+ tcp_maybe_inc_err_counter (err_counters, error0);
+ goto done;
+ }
/* 6: check the URG bit TODO */
/* 7: process the segment text */
if (vnet_buffer (b0)->tcp.data_len)
- error0 = tcp_segment_rcv (tm, tc0, b0, &next0);
+ {
+ error0 = tcp_segment_rcv (tc0, b0, &next0);
+ tcp_maybe_inc_err_counter (err_counters, error0);
+ }
/* 8: check the FIN bit */
if (PREDICT_FALSE (is_fin))
stream_session_disconnect_notify (&tc0->connection);
tcp_timer_update (tc0, TCP_TIMER_WAITCLOSE, TCP_CLOSEWAIT_TIME);
TCP_EVT_DBG (TCP_EVT_FIN_RCVD, tc0);
+ tcp_inc_err_counter (err_counters, TCP_ERROR_FIN_RCVD, 1);
}
done:
b0->error = node->errors[error0];
if (PREDICT_FALSE (b0->flags & VLIB_BUFFER_IS_TRACED))
{
- tcp_rx_trace_t *t0 =
- vlib_add_trace (vm, node, b0, sizeof (*t0));
+ tcp_rx_trace_t *t0 = vlib_add_trace (vm, node, b0,
+ sizeof (*t0));
tcp_set_rx_trace_data (t0, tc0, th0, b0, is_ip4);
}
errors = session_manager_flush_enqueue_events (TRANSPORT_PROTO_TCP,
my_thread_index);
- tcp_node_inc_counter (vm, is_ip4, tcp4_established_node.index,
- tcp6_established_node.index,
- TCP_ERROR_EVENT_FIFO_FULL, errors);
+ err_counters[TCP_ERROR_EVENT_FIFO_FULL] = errors;
+ tcp_store_err_counters (established, err_counters);
tcp_flush_frame_to_output (vm, my_thread_index, is_ip4);
-
return from_frame->n_vectors;
}
new_tc0->timers[TCP_TIMER_ESTABLISH] = TCP_TIMER_HANDLE_INVALID;
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 */
/* Read data, if any */
if (PREDICT_FALSE (vnet_buffer (b0)->tcp.data_len))
{
- ASSERT (0);
- error0 = tcp_segment_rcv (tm, new_tc0, b0, &next0);
- if (error0 == TCP_ERROR_PURE_ACK)
+ clib_warning ("rcvd data in syn-sent");
+ error0 = tcp_segment_rcv (new_tc0, b0, &next0);
+ if (error0 == TCP_ERROR_ACK_OK)
error0 = TCP_ERROR_SYN_ACKS_RCVD;
+ tcp_maybe_inc_counter (syn_sent, error0, 1);
}
else
{
errors = session_manager_flush_enqueue_events (TRANSPORT_PROTO_TCP,
my_thread_index);
- tcp_node_inc_counter (vm, is_ip4, tcp4_syn_sent_node.index,
- tcp6_syn_sent_node.index,
- TCP_ERROR_EVENT_FIFO_FULL, errors);
+ tcp_inc_counter (syn_sent, TCP_ERROR_EVENT_FIFO_FULL, errors);
return from_frame->n_vectors;
}
tcp46_rcv_process_inline (vlib_main_t * vm, vlib_node_runtime_t * node,
vlib_frame_t * from_frame, int is_ip4)
{
- tcp_main_t *tm = vnet_get_tcp_main ();
- u32 n_left_from, next_index, *from, *to_next;
+ u32 n_left_from, next_index, *from, *to_next, n_fins = 0;
u32 my_thread_index = vm->thread_index, errors = 0;
from = vlib_frame_vector_args (from_frame);
n_left_from = from_frame->n_vectors;
-
next_index = node->cached_next_index;
while (n_left_from > 0)
vlib_buffer_t *b0;
tcp_header_t *tcp0 = 0;
tcp_connection_t *tc0;
- u32 next0 = tcp_next_drop (is_ip4), error0 = TCP_ERROR_ENQUEUED;
+ u32 next0 = tcp_next_drop (is_ip4), error0 = TCP_ERROR_NONE;
u8 is_fin0;
bi0 = from[0];
if (CLIB_DEBUG)
{
tcp_connection_t *tmp;
- tmp =
- tcp_lookup_connection (tc0->c_fib_index, b0, my_thread_index,
- is_ip4);
+ tmp = tcp_lookup_connection (tc0->c_fib_index, b0,
+ my_thread_index, is_ip4);
if (tmp->state != tc0->state)
{
clib_warning ("state changed");
- ASSERT (0);
goto drop;
}
}
/*
* Special treatment for CLOSED
*/
- switch (tc0->state)
+ if (PREDICT_FALSE (tc0->state == TCP_STATE_CLOSED))
{
- case TCP_STATE_CLOSED:
+ error0 = TCP_ERROR_CONNECTION_CLOSED;
goto drop;
- break;
}
/*
/* 1-4: check SEQ, RST, SYN */
if (PREDICT_FALSE (tcp_segment_validate (vm, tc0, b0, tcp0,
- &next0)))
+ &next0, &error0)))
{
- error0 = TCP_ERROR_SEGMENT_INVALID;
+ tcp_maybe_inc_counter (rcv_process, error0, 1);
goto drop;
}
{
TCP_DBG ("connection not accepted");
tcp_send_reset_w_pkt (tc0, b0, is_ip4);
+ error0 = TCP_ERROR_ACK_INVALID;
goto drop;
}
/* Reset SYN-ACK retransmit and SYN_RCV establish timers */
tcp_retransmit_timer_reset (tc0);
tcp_timer_reset (tc0, TCP_TIMER_ESTABLISH);
-
stream_session_accept_notify (&tc0->connection);
+ error0 = 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 (tc0, b0, tcp0, &next0, &error0))
- goto drop;
+ {
+ tcp_maybe_inc_counter (rcv_process, error0, 1);
+ goto drop;
+ }
break;
case TCP_STATE_FIN_WAIT_1:
* our FIN is now acknowledged then enter FIN-WAIT-2 and
* continue processing in that state. */
if (tcp_rcv_ack (tc0, b0, tcp0, &next0, &error0))
- goto drop;
+ {
+ tcp_maybe_inc_counter (rcv_process, error0, 1);
+ goto drop;
+ }
/* Still have to send the FIN */
if (tc0->flags & TCP_CONN_FINPNDG)
* the retransmission queue is empty, the user's CLOSE can be
* acknowledged ("ok") but do not delete the TCB. */
if (tcp_rcv_ack (tc0, b0, tcp0, &next0, &error0))
- goto drop;
+ {
+ tcp_maybe_inc_counter (rcv_process, error0, 1);
+ goto drop;
+ }
break;
case TCP_STATE_CLOSE_WAIT:
/* Do the same processing as for the ESTABLISHED state. */
if (tcp_rcv_ack (tc0, b0, tcp0, &next0, &error0))
- goto drop;
+ {
+ tcp_maybe_inc_counter (rcv_process, error0, 1);
+ goto drop;
+ }
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 (tc0, b0, tcp0, &next0, &error0))
- goto drop;
+ {
+ tcp_maybe_inc_counter (rcv_process, error0, 1);
+ goto drop;
+ }
tc0->state = TCP_STATE_TIME_WAIT;
TCP_EVT_DBG (TCP_EVT_STATE_CHANGE, tc0);
error0 = TCP_ERROR_ACK_INVALID;
goto drop;
}
-
+ error0 = TCP_ERROR_ACK_OK;
tc0->snd_una = vnet_buffer (b0)->tcp.ack_number;
/* Apparently our ACK for the peer's FIN was lost */
if (is_fin0 && tc0->snd_una != tc0->snd_una_max)
* the 2 MSL timeout. */
if (tcp_rcv_ack (tc0, b0, tcp0, &next0, &error0))
- goto drop;
+ {
+ tcp_maybe_inc_counter (rcv_process, error0, 1);
+ goto drop;
+ }
tcp_make_ack (tc0, b0);
next0 = tcp_next_output (is_ip4);
tcp_timer_update (tc0, TCP_TIMER_WAITCLOSE, TCP_TIMEWAIT_TIME);
-
goto drop;
break;
case TCP_STATE_FIN_WAIT_1:
case TCP_STATE_FIN_WAIT_2:
if (vnet_buffer (b0)->tcp.data_len)
- error0 = tcp_segment_rcv (tm, tc0, b0, &next0);
+ {
+ error0 = tcp_segment_rcv (tc0, b0, &next0);
+ tcp_maybe_inc_counter (rcv_process, error0, 1);
+ }
else if (is_fin0)
tc0->rcv_nxt += 1;
break;
break;
}
TCP_EVT_DBG (TCP_EVT_FIN_RCVD, tc0);
+ n_fins += 1;
drop:
b0->error = error0 ? node->errors[error0] : 0;
errors = session_manager_flush_enqueue_events (TRANSPORT_PROTO_TCP,
my_thread_index);
- tcp_node_inc_counter (vm, is_ip4, tcp4_rcv_process_node.index,
- tcp6_rcv_process_node.index,
- TCP_ERROR_EVENT_FIFO_FULL, errors);
-
+ tcp_inc_counter (rcv_process, TCP_ERROR_EVENT_FIFO_FULL, errors);
+ tcp_inc_counter (rcv_process, TCP_ERROR_FIN_RCVD, n_fins);
return from_frame->n_vectors;
}
tcp46_listen_inline (vlib_main_t * vm, vlib_node_runtime_t * node,
vlib_frame_t * from_frame, int is_ip4)
{
- u32 n_left_from, next_index, *from, *to_next;
+ u32 n_left_from, next_index, *from, *to_next, n_syns = 0;
u32 my_thread_index = vm->thread_index;
from = vlib_frame_vector_args (from_frame);
ip4_header_t *ip40;
ip6_header_t *ip60;
tcp_connection_t *child0;
- u32 error0 = TCP_ERROR_SYNS_RCVD, next0 = tcp_next_drop (is_ip4);
+ u32 error0 = TCP_ERROR_NONE, next0 = tcp_next_drop (is_ip4);
bi0 = from[0];
to_next[0] = bi0;
/* 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);
+ 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;
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];
/* RFC1323: TSval timestamps sent on {SYN} and {SYN,ACK}
* segments are used to initialize PAWS. */
sizeof (t0->tcp_connection));
}
+ n_syns += (error0 == TCP_ERROR_NONE);
b0->error = node->errors[error0];
vlib_validate_buffer_enqueue_x1 (vm, node, next_index, to_next,
vlib_put_next_frame (vm, node, next_index, n_left_to_next);
}
+
+ tcp_inc_counter (listen, TCP_ERROR_SYNS_RCVD, n_syns);
return from_frame->n_vectors;
}
/* SYNs for new connections -> tcp-listen. */
_(LISTEN, TCP_FLAG_SYN, TCP_INPUT_NEXT_LISTEN, TCP_ERROR_NONE);
_(LISTEN, TCP_FLAG_ACK, TCP_INPUT_NEXT_RESET, TCP_ERROR_NONE);
- _(LISTEN, TCP_FLAG_RST, TCP_INPUT_NEXT_DROP, TCP_ERROR_NONE);
+ _(LISTEN, TCP_FLAG_RST, TCP_INPUT_NEXT_DROP, TCP_ERROR_RST_RCVD);
_(LISTEN, TCP_FLAG_FIN | TCP_FLAG_ACK, TCP_INPUT_NEXT_RESET,
TCP_ERROR_NONE);
/* ACK for for a SYN-ACK -> tcp-rcv-process. */
Code Review / vpp.git / blobdiff