/* Make sure this is the owning thread */
if (tc->c_thread_index != vlib_get_thread_index ())
return 1;
- tcp_timer_reset (tc, TCP_TIMER_ESTABLISH);
+ tcp_timer_reset (tc, TCP_TIMER_ESTABLISH_AO);
tcp_timer_reset (tc, TCP_TIMER_RETRANSMIT_SYN);
tcp_half_open_connection_del (tc);
return 0;
tcp_connection_del (tcp_connection_t * tc)
{
TCP_EVT_DBG (TCP_EVT_DELETE, tc);
- stream_session_delete_notify (&tc->connection);
+ session_transport_delete_notify (&tc->connection);
tcp_connection_cleanup (tc);
}
tcp_connection_t *
-tcp_connection_new (u8 thread_index)
+tcp_connection_alloc (u8 thread_index)
{
tcp_main_t *tm = vnet_get_tcp_main ();
tcp_connection_t *tc;
return tc;
}
+void
+tcp_connection_free (tcp_connection_t * tc)
+{
+ tcp_main_t *tm = &tcp_main;
+ pool_put (tm->connections[tc->c_thread_index], tc);
+ if (CLIB_DEBUG > 0)
+ clib_memset (tc, 0xFA, sizeof (*tc));
+}
+
/** Notify session that connection has been reset.
*
* Switch state to closed and wait for session to call cleanup.
{
case TCP_STATE_SYN_RCVD:
/* Cleanup everything. App wasn't notified yet */
- stream_session_delete_notify (&tc->connection);
+ session_transport_delete_notify (&tc->connection);
tcp_connection_cleanup (tc);
break;
case TCP_STATE_SYN_SENT:
session_stream_connect_notify (&tc->connection, 1 /* fail */ );
- tcp_connection_cleanup (tc);
+ tcp_connection_set_state (tc, TCP_STATE_CLOSED);
+ tcp_timer_set (tc, TCP_TIMER_WAITCLOSE, TCP_CLEANUP_TIME);
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_update (tc, TCP_TIMER_WAITCLOSE, TCP_CLEANUP_TIME);
- stream_session_reset_notify (&tc->connection);
+ tcp_timer_set (tc, TCP_TIMER_WAITCLOSE, TCP_CLOSEWAIT_TIME);
+ session_transport_reset_notify (&tc->connection);
+ tcp_connection_set_state (tc, TCP_STATE_CLOSED);
break;
case TCP_STATE_CLOSE_WAIT:
case TCP_STATE_FIN_WAIT_1:
case TCP_STATE_FIN_WAIT_2:
case TCP_STATE_CLOSING:
- tc->state = TCP_STATE_CLOSED;
- TCP_EVT_DBG (TCP_EVT_STATE_CHANGE, tc);
+ case TCP_STATE_LAST_ACK:
tcp_connection_timers_reset (tc);
- tcp_timer_update (tc, TCP_TIMER_WAITCLOSE, TCP_CLEANUP_TIME);
+ tcp_timer_set (tc, TCP_TIMER_WAITCLOSE, TCP_CLOSEWAIT_TIME);
+ /* Make sure we mark the session as closed. In some states we may
+ * be still trying to send data */
+ session_transport_closed_notify (&tc->connection);
+ tcp_connection_set_state (tc, TCP_STATE_CLOSED);
break;
case TCP_STATE_CLOSED:
- return;
+ case TCP_STATE_TIME_WAIT:
+ break;
+ default:
+ TCP_DBG ("reset state: %u", tc->state);
}
}
switch (tc->state)
{
case TCP_STATE_SYN_SENT:
- tc->state = TCP_STATE_CLOSED;
+ /* Try to cleanup. If not on the right thread, mark as half-open done.
+ * Connection will be cleaned up when establish timer pops */
+ tcp_connection_cleanup (tc);
break;
case TCP_STATE_SYN_RCVD:
tcp_connection_timers_reset (tc);
tcp_send_fin (tc);
- tc->state = TCP_STATE_FIN_WAIT_1;
- tcp_timer_update (tc, TCP_TIMER_WAITCLOSE, TCP_CLEANUP_TIME);
+ tcp_connection_set_state (tc, TCP_STATE_FIN_WAIT_1);
+ tcp_timer_update (tc, TCP_TIMER_WAITCLOSE, TCP_FINWAIT1_TIME);
break;
case TCP_STATE_ESTABLISHED:
if (!session_tx_fifo_max_dequeue (&tc->connection))
tcp_send_fin (tc);
else
tc->flags |= TCP_CONN_FINPNDG;
- tc->state = TCP_STATE_FIN_WAIT_1;
+ tcp_connection_set_state (tc, TCP_STATE_FIN_WAIT_1);
+ /* Set a timer in case the peer stops responding. Otherwise the
+ * connection will be stuck here forever. */
+ ASSERT (tc->timers[TCP_TIMER_WAITCLOSE] == TCP_TIMER_HANDLE_INVALID);
+ tcp_timer_set (tc, TCP_TIMER_WAITCLOSE, TCP_FINWAIT1_TIME);
break;
case TCP_STATE_CLOSE_WAIT:
if (!session_tx_fifo_max_dequeue (&tc->connection))
{
tcp_send_fin (tc);
tcp_connection_timers_reset (tc);
- tc->state = TCP_STATE_LAST_ACK;
+ tcp_connection_set_state (tc, TCP_STATE_LAST_ACK);
tcp_timer_update (tc, TCP_TIMER_WAITCLOSE, TCP_2MSL_TIME);
}
else
case TCP_STATE_FIN_WAIT_1:
tcp_timer_update (tc, TCP_TIMER_WAITCLOSE, TCP_2MSL_TIME);
break;
+ case TCP_STATE_CLOSED:
+ tcp_connection_timers_reset (tc);
+ /* Delete connection but instead of doing it now wait until next
+ * dispatch cycle to give the session layer a chance to clear
+ * unhandled events */
+ tcp_timer_update (tc, TCP_TIMER_WAITCLOSE, TCP_CLEANUP_TIME);
+ break;
default:
TCP_DBG ("state: %u", tc->state);
}
-
- TCP_EVT_DBG (TCP_EVT_STATE_CHANGE, tc);
-
- /* If in CLOSED and WAITCLOSE timer is not set, delete connection now */
- if (!tcp_timer_is_active (tc, TCP_TIMER_WAITCLOSE)
- && tc->state == TCP_STATE_CLOSED)
- tcp_connection_del (tc);
}
static void
{
tcp_connection_t *tc;
tc = tcp_connection_get (conn_index, thread_index);
- tcp_connection_timers_reset (tc);
- tc->state = TCP_STATE_CLOSED;
- TCP_EVT_DBG (TCP_EVT_STATE_CHANGE, tc);
+ tcp_connection_set_state (tc, TCP_STATE_CLOSED);
tcp_connection_cleanup (tc);
}
ip6_tcp_hdr_t hdr;
clib_memset (&hdr, 0, sizeof (hdr));
hdr.ip.protocol = IP_PROTOCOL_TCP;
- clib_memcpy (&hdr.ip.src_address, &tc->c_lcl_ip.ip6,
- sizeof (ip6_address_t));
- clib_memcpy (&hdr.ip.dst_address, &tc->c_rmt_ip.ip6,
- sizeof (ip6_address_t));
+ clib_memcpy_fast (&hdr.ip.src_address, &tc->c_lcl_ip.ip6,
+ sizeof (ip6_address_t));
+ clib_memcpy_fast (&hdr.ip.dst_address, &tc->c_rmt_ip.ip6,
+ sizeof (ip6_address_t));
hdr.tcp.src_port = tc->c_lcl_port;
hdr.tcp.dst_port = tc->c_rmt_port;
hash = ip6_compute_flow_hash (&hdr.ip, lb->lb_hash_config);
fib_prefix_t prefix;
u32 fib_index;
- clib_memcpy (&prefix.fp_addr, &tc->c_rmt_ip, sizeof (prefix.fp_addr));
+ clib_memcpy_fast (&prefix.fp_addr, &tc->c_rmt_ip, sizeof (prefix.fp_addr));
prefix.fp_proto = tc->c_is_ip4 ? FIB_PROTOCOL_IP4 : FIB_PROTOCOL_IP6;
prefix.fp_len = tc->c_is_ip4 ? 32 : 128;
fib_index = fib_table_find (prefix.fp_proto, tc->c_fib_index);
static void
tcp_cc_init (tcp_connection_t * tc)
{
- tc->cc_algo = tcp_cc_algo_get (TCP_CC_NEWRENO);
+ tc->cc_algo = tcp_cc_algo_get (tcp_main.cc_algo);
tc->cc_algo->init (tc);
}
return &tm->cc_algos[type];
}
+/**
+ * Generate random iss as per rfc6528
+ */
+static u32
+tcp_generate_random_iss (tcp_connection_t * tc)
+{
+ tcp_main_t *tm = &tcp_main;
+ u64 tmp;
+
+ if (tc->c_is_ip4)
+ tmp = (u64) tc->c_lcl_ip.ip4.as_u32 << 32 | (u64) tc->c_rmt_ip.ip4.as_u32;
+ else
+ tmp = tc->c_lcl_ip.ip6.as_u64[0] ^ tc->c_lcl_ip.ip6.as_u64[1]
+ ^ tc->c_rmt_ip.ip6.as_u64[0] ^ tc->c_rmt_ip.ip6.as_u64[1];
+
+ tmp ^= tm->iss_seed.first | ((u64) tc->c_lcl_port << 16 | tc->c_rmt_port);
+ tmp ^= tm->iss_seed.second;
+ tmp = clib_xxhash (tmp) + clib_cpu_time_now ();
+ return ((tmp >> 32) ^ (tmp & 0xffffffff));
+}
/**
* Initialize connection send variables.
void
tcp_init_snd_vars (tcp_connection_t * tc)
{
- u32 time_now;
-
/*
* We use the time to randomize iss and for setting up the initial
* timestamp. Make sure it's updated otherwise syn and ack in the
* direction for us.
*/
tcp_set_time_now (tcp_get_worker (vlib_get_thread_index ()));
- time_now = tcp_time_now ();
- tc->iss = random_u32 (&time_now);
+ tc->iss = tcp_generate_random_iss (tc);
tc->snd_una = tc->iss;
tc->snd_nxt = tc->iss + 1;
tc->snd_una_max = tc->snd_nxt;
+ tc->srtt = 0;
}
void
index = tm->last_v6_address_rotor++;
if (tm->last_v6_address_rotor >= vec_len (tm->ip6_src_addresses))
tm->last_v6_address_rotor = 0;
- clib_memcpy (&lcl_addr->ip6, &tm->ip6_src_addresses[index],
- sizeof (ip6_address_t));
+ clib_memcpy_fast (&lcl_addr->ip6, &tm->ip6_src_addresses[index],
+ sizeof (ip6_address_t));
}
port = transport_alloc_local_port (TRANSPORT_PROTO_TCP, lcl_addr);
if (port < 1)
{
int snd_space, snt_limited;
- if (PREDICT_FALSE (tcp_in_fastrecovery (tc)))
+ if (PREDICT_FALSE (tcp_in_fastrecovery (tc)
+ || tc->state == TCP_STATE_CLOSED))
return 0;
snd_space = tcp_available_output_snd_space (tc);
return tcp_push_header (tc, b);
}
+static void
+tcp_session_flush_data (transport_connection_t * tconn)
+{
+ tcp_connection_t *tc = (tcp_connection_t *) tconn;
+ if (tc->flags & TCP_CONN_PSH_PENDING)
+ return;
+ tc->flags |= TCP_CONN_PSH_PENDING;
+ tc->psh_seq = tc->snd_una_max + transport_max_tx_dequeue (tconn) - 1;
+}
+
/* *INDENT-OFF* */
const static transport_proto_vft_t tcp_proto = {
.enable = vnet_tcp_enable_disable,
.send_space = tcp_session_send_space,
.update_time = tcp_update_time,
.tx_fifo_offset = tcp_session_tx_fifo_offset,
+ .flush_data = tcp_session_flush_data,
.format_connection = format_tcp_session,
.format_listener = format_tcp_listener_session,
.format_half_open = format_tcp_half_open_session,
{
tcp_connection_t *tc;
- tc = tcp_half_open_connection_get (conn_index);
- if (tc)
- {
- ASSERT (tc->state == TCP_STATE_SYN_SENT);
- session_stream_connect_notify (&tc->connection, 1 /* fail */ );
- TCP_DBG ("establish pop: %U", format_tcp_connection, tc, 2);
- }
- else
- {
- tc = tcp_connection_get (conn_index, vlib_get_thread_index ());
- /* note: the connection may have already disappeared */
- if (PREDICT_FALSE (tc == 0))
- return;
- TCP_DBG ("establish pop: %U", format_tcp_connection, tc, 2);
- ASSERT (tc->state == TCP_STATE_SYN_RCVD);
- /* Start cleanup. App wasn't notified yet so use delete notify as
- * opposed to delete to cleanup session layer state. */
- stream_session_delete_notify (&tc->connection);
- }
+ tc = tcp_connection_get (conn_index, vlib_get_thread_index ());
+ /* note: the connection may have already disappeared */
+ if (PREDICT_FALSE (tc == 0))
+ return;
+ ASSERT (tc->state == TCP_STATE_SYN_RCVD);
+ /* Start cleanup. App wasn't notified yet so use delete notify as
+ * opposed to delete to cleanup session layer state. */
+ session_transport_delete_notify (&tc->connection);
tc->timers[TCP_TIMER_ESTABLISH] = TCP_TIMER_HANDLE_INVALID;
tcp_connection_cleanup (tc);
}
+static void
+tcp_timer_establish_ao_handler (u32 conn_index)
+{
+ tcp_connection_t *tc;
+
+ tc = tcp_half_open_connection_get (conn_index);
+ if (!tc)
+ return;
+
+ ASSERT (tc->state == TCP_STATE_SYN_SENT);
+ /* Notify app if we haven't tried to clean this up already */
+ if (!(tc->flags & TCP_CONN_HALF_OPEN_DONE))
+ session_stream_connect_notify (&tc->connection, 1 /* fail */ );
+
+ tc->timers[TCP_TIMER_ESTABLISH_AO] = TCP_TIMER_HANDLE_INVALID;
+ tcp_connection_cleanup (tc);
+}
+
static void
tcp_timer_waitclose_handler (u32 conn_index)
{
- u32 thread_index = vlib_get_thread_index ();
+ u32 thread_index = vlib_get_thread_index (), rto;
tcp_connection_t *tc;
tc = tcp_connection_get (conn_index, thread_index);
return;
tc->timers[TCP_TIMER_WAITCLOSE] = TCP_TIMER_HANDLE_INVALID;
- /* Session didn't come back with a close(). Send FIN either way
- * and switch to LAST_ACK. */
- if (tc->state == TCP_STATE_CLOSE_WAIT)
+ switch (tc->state)
{
- if (tc->flags & TCP_CONN_FINSNT)
+ case TCP_STATE_CLOSE_WAIT:
+ tcp_connection_timers_reset (tc);
+ session_transport_closed_notify (&tc->connection);
+
+ if (!(tc->flags & TCP_CONN_FINPNDG))
{
- clib_warning ("FIN was sent and still in CLOSE WAIT. Weird!");
+ tcp_connection_set_state (tc, TCP_STATE_CLOSED);
+ tcp_timer_set (tc, TCP_TIMER_WAITCLOSE, TCP_CLEANUP_TIME);
+ break;
}
- /* Make sure we don't try to send unsent data */
- tcp_connection_timers_reset (tc);
+ /* Session didn't come back with a close. Send FIN either way
+ * and switch to LAST_ACK. */
tcp_cong_recovery_off (tc);
+ /* Make sure we don't try to send unsent data */
tc->snd_una_max = tc->snd_nxt = tc->snd_una;
tcp_send_fin (tc);
- tc->state = TCP_STATE_LAST_ACK;
+ tcp_connection_set_state (tc, TCP_STATE_LAST_ACK);
/* Make sure we don't wait in LAST ACK forever */
tcp_timer_set (tc, TCP_TIMER_WAITCLOSE, TCP_2MSL_TIME);
/* Don't delete the connection yet */
- return;
+ break;
+ case TCP_STATE_FIN_WAIT_1:
+ tcp_connection_timers_reset (tc);
+ if (tc->flags & TCP_CONN_FINPNDG)
+ {
+ /* If FIN pending send it before closing and wait as long as
+ * the rto timeout would wait. Notify session layer that transport
+ * is closed. We haven't sent everything but we did try. */
+ tcp_cong_recovery_off (tc);
+ tcp_send_fin (tc);
+ rto = clib_max ((tc->rto >> tc->rto_boff) * TCP_TO_TIMER_TICK, 1);
+ tcp_timer_set (tc, TCP_TIMER_WAITCLOSE,
+ clib_min (rto, TCP_2MSL_TIME));
+ session_transport_closed_notify (&tc->connection);
+ }
+ else
+ {
+ /* We've sent the fin but no progress. Close the connection and
+ * to make sure everything is flushed, setup a cleanup timer */
+ tcp_connection_set_state (tc, TCP_STATE_CLOSED);
+ tcp_timer_set (tc, TCP_TIMER_WAITCLOSE, TCP_CLEANUP_TIME);
+ }
+ break;
+ case TCP_STATE_LAST_ACK:
+ case TCP_STATE_CLOSING:
+ tcp_connection_timers_reset (tc);
+ tcp_connection_set_state (tc, TCP_STATE_CLOSED);
+ tcp_timer_set (tc, TCP_TIMER_WAITCLOSE, TCP_CLEANUP_TIME);
+ session_transport_closed_notify (&tc->connection);
+ break;
+ default:
+ tcp_connection_del (tc);
+ break;
}
-
- tcp_connection_del (tc);
}
/* *INDENT-OFF* */
tcp_timer_keep_handler,
tcp_timer_waitclose_handler,
tcp_timer_retransmit_syn_handler,
- tcp_timer_establish_handler
+ tcp_timer_establish_handler,
+ tcp_timer_establish_ao_handler,
};
/* *INDENT-ON* */
/* *INDENT-ON* */
}
+static void
+tcp_initialize_iss_seed (tcp_main_t * tm)
+{
+ u32 default_seed = random_default_seed ();
+ u64 time_now = clib_cpu_time_now ();
+
+ tm->iss_seed.first = (u64) random_u32 (&default_seed) << 32;
+ tm->iss_seed.second = random_u64 (&time_now);
+}
+
static clib_error_t *
tcp_main_enable (vlib_main_t * vm)
{
vec_validate (tm->wrk_ctx[thread].postponed_fast_rxt, 255);
vec_validate (tm->wrk_ctx[thread].pending_deq_acked, 255);
vec_validate (tm->wrk_ctx[thread].pending_acks, 255);
+ vec_validate (tm->wrk_ctx[thread].pending_disconnects, 255);
vec_reset_length (tm->wrk_ctx[thread].pending_fast_rxt);
vec_reset_length (tm->wrk_ctx[thread].ongoing_fast_rxt);
vec_reset_length (tm->wrk_ctx[thread].postponed_fast_rxt);
vec_reset_length (tm->wrk_ctx[thread].pending_deq_acked);
vec_reset_length (tm->wrk_ctx[thread].pending_acks);
+ vec_reset_length (tm->wrk_ctx[thread].pending_disconnects);
tm->wrk_ctx[thread].vm = vlib_mains[thread];
/*
}
tcp_initialize_timer_wheels (tm);
+ tcp_initialize_iss_seed (tm);
- tm->bytes_per_buffer = vlib_buffer_free_list_buffer_size
- (vm, VLIB_BUFFER_DEFAULT_FREE_LIST_INDEX);
+ tm->bytes_per_buffer = VLIB_BUFFER_DATA_SIZE;
return error;
}
tcp_api_reference ();
tm->tx_pacing = 1;
+ tm->cc_algo = TCP_CC_NEWRENO;
return 0;
}
VLIB_INIT_FUNCTION (tcp_init);
+uword
+unformat_tcp_cc_algo (unformat_input_t * input, va_list * va)
+{
+ uword *result = va_arg (*va, uword *);
+
+ if (unformat (input, "newreno"))
+ *result = TCP_CC_NEWRENO;
+ else if (unformat (input, "cubic"))
+ *result = TCP_CC_CUBIC;
+ else
+ return 0;
+
+ return 1;
+}
+
+uword
+unformat_tcp_cc_algo_cfg (unformat_input_t * input, va_list * va)
+{
+ tcp_main_t *tm = vnet_get_tcp_main ();
+ tcp_cc_algorithm_t *cc_alg;
+ unformat_input_t sub_input;
+ int found = 0;
+
+ vec_foreach (cc_alg, tm->cc_algos)
+ {
+ if (!unformat (input, cc_alg->name))
+ continue;
+
+ if (cc_alg->unformat_cfg
+ && unformat (input, "%U", unformat_vlib_cli_sub_input, &sub_input))
+ {
+ if (cc_alg->unformat_cfg (&sub_input))
+ found = 1;
+ }
+ }
+ return found;
+}
+
static clib_error_t *
tcp_config_fn (vlib_main_t * vm, unformat_input_t * input)
{
;
else if (unformat (input, "no-tx-pacing"))
tm->tx_pacing = 0;
+ else if (unformat (input, "cc-algo %U", unformat_tcp_cc_algo,
+ &tm->cc_algo))
+ ;
+ else if (unformat (input, "%U", unformat_tcp_cc_algo_cfg))
+ ;
else
return clib_error_return (0, "unknown input `%U'",
format_unformat_error, input);
Code Review / vpp.git / blobdiff