{
listener->c_lcl_ip4.as_u32 = lcl->ip.ip4.as_u32;
listener->c_is_ip4 = 1;
- listener->c_proto = SESSION_TYPE_IP4_TCP;
}
else
{
clib_memcpy (&listener->c_lcl_ip6, &lcl->ip.ip6,
sizeof (ip6_address_t));
- listener->c_proto = SESSION_TYPE_IP6_TCP;
- }
+ }
+ listener->c_transport_proto = TRANSPORT_PROTO_TCP;
listener->c_s_index = session_index;
listener->state = TCP_STATE_LISTEN;
return &tc->connection;
}
+always_inline void
+transport_endpoint_del (u32 tepi)
+{
+ tcp_main_t *tm = vnet_get_tcp_main ();
+ clib_spinlock_lock_if_init (&tm->local_endpoints_lock);
+ pool_put_index (tm->local_endpoints, tepi);
+ clib_spinlock_unlock_if_init (&tm->local_endpoints_lock);
+}
+
+always_inline transport_endpoint_t *
+transport_endpoint_new (void)
+{
+ tcp_main_t *tm = vnet_get_tcp_main ();
+ transport_endpoint_t *tep;
+ pool_get (tm->local_endpoints, tep);
+ return tep;
+}
+
+/**
+ * Cleanup half-open connection
+ *
+ */
+void
+tcp_half_open_connection_del (tcp_connection_t * tc)
+{
+ tcp_main_t *tm = vnet_get_tcp_main ();
+ clib_spinlock_lock_if_init (&tm->half_open_lock);
+ pool_put_index (tm->half_open_connections, tc->c_c_index);
+ if (CLIB_DEBUG)
+ memset (tc, 0xFA, sizeof (*tc));
+ clib_spinlock_unlock_if_init (&tm->half_open_lock);
+}
+
+/**
+ * Try to cleanup half-open connection
+ *
+ * If called from a thread that doesn't own tc, the call won't have any
+ * effect.
+ *
+ * @param tc - connection to be cleaned up
+ * @return non-zero if cleanup failed.
+ */
+int
+tcp_half_open_connection_cleanup (tcp_connection_t * tc)
+{
+ /* 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_RETRANSMIT_SYN);
+ tcp_half_open_connection_del (tc);
+ return 0;
+}
+
+tcp_connection_t *
+tcp_half_open_connection_new (void)
+{
+ tcp_main_t *tm = vnet_get_tcp_main ();
+ tcp_connection_t *tc = 0;
+ pool_get (tm->half_open_connections, tc);
+ memset (tc, 0, sizeof (*tc));
+ tc->c_c_index = tc - tm->half_open_connections;
+ return tc;
+}
+
/**
* Cleans up connection state.
*
/* Cleanup local endpoint if this was an active connect */
tepi = transport_endpoint_lookup (&tm->local_endpoints_table, &tc->c_lcl_ip,
- tc->c_lcl_port);
-
- /*XXX lock */
+ clib_net_to_host_u16 (tc->c_lcl_port));
if (tepi != TRANSPORT_ENDPOINT_INVALID_INDEX)
{
tep = pool_elt_at_index (tm->local_endpoints, tepi);
transport_endpoint_table_del (&tm->local_endpoints_table, tep);
- pool_put (tm->local_endpoints, tep);
+ transport_endpoint_del (tepi);
}
- /* Make sure all timers are cleared */
- tcp_connection_timers_reset (tc);
-
- /* Check if half-open */
+ /* Check if connection is not yet fully established */
if (tc->state == TCP_STATE_SYN_SENT)
{
- tcp_half_open_connection_del (tc);
+ /* Try to remove the half-open connection. If this is not the owning
+ * thread, tc won't be removed. Retransmit or establish timers will
+ * eventually expire and call again cleanup on the right thread. */
+ tcp_half_open_connection_cleanup (tc);
}
else
{
int thread_index = tc->c_thread_index;
+
+ /* Make sure all timers are cleared */
+ tcp_connection_timers_reset (tc);
+
/* Poison the entry */
if (CLIB_DEBUG > 0)
memset (tc, 0xFA, sizeof (*tc));
tcp_connection_cleanup (tc);
}
-/**
- * Cleanup half-open connection
- */
-void
-tcp_half_open_connection_del (tcp_connection_t * tc)
-{
- tcp_main_t *tm = vnet_get_tcp_main ();
- if (CLIB_DEBUG)
- memset (tc, 0xFA, sizeof (*tc));
- clib_spinlock_lock_if_init (&tm->half_open_lock);
- pool_put (tm->half_open_connections, tc);
- clib_spinlock_unlock_if_init (&tm->half_open_lock);
-}
-
-tcp_connection_t *
-tcp_half_open_connection_new ()
-{
- tcp_main_t *tm = vnet_get_tcp_main ();
- tcp_connection_t *tc = 0;
- clib_spinlock_lock_if_init (&tm->half_open_lock);
- pool_get (tm->half_open_connections, tc);
- clib_spinlock_unlock_if_init (&tm->half_open_lock);
- memset (tc, 0, sizeof (*tc));
- return tc;
-}
-
tcp_connection_t *
tcp_connection_new (u8 thread_index)
{
tcp_connection_cleanup (tc);
break;
case TCP_STATE_SYN_SENT:
- /* XXX remove sst from call */
- stream_session_connect_notify (&tc->connection, tc->connection.proto,
- 1 /* fail */ );
+ stream_session_connect_notify (&tc->connection, 1 /* fail */ );
tcp_connection_cleanup (tc);
break;
case TCP_STATE_ESTABLISHED:
stream_session_reset_notify (&tc->connection);
/* Wait for cleanup from session layer but not forever */
- tcp_timer_set (tc, TCP_TIMER_WAITCLOSE, TCP_CLEANUP_TIME);
+ tcp_timer_update (tc, TCP_TIMER_WAITCLOSE, TCP_CLEANUP_TIME);
break;
case TCP_STATE_CLOSED:
return;
* table to mark the pair as used.
*/
int
-tcp_allocate_local_port (tcp_main_t * tm, ip46_address_t * ip)
+tcp_allocate_local_port (ip46_address_t * ip)
{
+ tcp_main_t *tm = vnet_get_tcp_main ();
transport_endpoint_t *tep;
- u32 time_now, tei;
+ u32 tei;
u16 min = 1024, max = 65535; /* XXX configurable ? */
- int tries;
+ int tries, limit;
- tries = max - min;
- time_now = tcp_time_now ();
+ limit = max - min;
/* Only support active opens from thread 0 */
ASSERT (vlib_get_thread_index () == 0);
- /* Start at random point or max */
- pool_get (tm->local_endpoints, tep);
- clib_memcpy (&tep->ip, ip, sizeof (*ip));
-
/* Search for first free slot */
- for (; tries >= 0; tries--)
+ for (tries = 0; tries < limit; tries++)
{
u16 port = 0;
/* Find a port in the specified range */
while (1)
{
- port = random_u32 (&time_now) & PORT_MASK;
+ port = random_u32 (&tm->port_allocator_seed) & PORT_MASK;
if (PREDICT_TRUE (port >= min && port < max))
break;
}
- tep->port = port;
-
/* Look it up */
- tei = transport_endpoint_lookup (&tm->local_endpoints_table, &tep->ip,
- tep->port);
+ tei = transport_endpoint_lookup (&tm->local_endpoints_table, ip, port);
/* If not found, we're done */
if (tei == TRANSPORT_ENDPOINT_INVALID_INDEX)
{
+ clib_spinlock_lock_if_init (&tm->local_endpoints_lock);
+ tep = transport_endpoint_new ();
+ clib_memcpy (&tep->ip, ip, sizeof (*ip));
+ tep->port = port;
transport_endpoint_table_add (&tm->local_endpoints_table, tep,
tep - tm->local_endpoints);
+ clib_spinlock_unlock_if_init (&tm->local_endpoints_lock);
+
return tep->port;
}
}
- /* No free ports */
- pool_put (tm->local_endpoints, tep);
return -1;
}
}
/* Allocate source port */
- lcl_port = tcp_allocate_local_port (tm, &lcl_addr);
+ lcl_port = tcp_allocate_local_port (&lcl_addr);
if (lcl_port < 1)
{
clib_warning ("Failed to allocate src port");
/*
* Create connection and send SYN
*/
-
+ clib_spinlock_lock_if_init (&tm->half_open_lock);
tc = tcp_half_open_connection_new ();
-
clib_memcpy (&tc->c_rmt_ip, &rmt->ip, sizeof (ip46_address_t));
clib_memcpy (&tc->c_lcl_ip, &lcl_addr, sizeof (ip46_address_t));
tc->c_rmt_port = clib_host_to_net_u16 (rmt->port);
tc->c_lcl_port = clib_host_to_net_u16 (lcl_port);
- tc->c_c_index = tc - tm->half_open_connections;
tc->c_is_ip4 = rmt->is_ip4;
- tc->c_proto = rmt->is_ip4 ? SESSION_TYPE_IP4_TCP : SESSION_TYPE_IP6_TCP;
+ tc->c_transport_proto = TRANSPORT_PROTO_TCP;
tc->c_vrf = rmt->vrf;
/* The other connection vars will be initialized after SYN ACK */
tcp_connection_timers_init (tc);
TCP_EVT_DBG (TCP_EVT_OPEN, tc);
tc->state = TCP_STATE_SYN_SENT;
tcp_send_syn (tc);
+ clib_spinlock_unlock_if_init (&tm->half_open_lock);
return tc->c_c_index;
}
tcp_timer_establish_handler (u32 conn_index)
{
tcp_connection_t *tc;
- u8 sst;
tc = tcp_half_open_connection_get (conn_index);
tc->timers[TCP_TIMER_ESTABLISH] = TCP_TIMER_HANDLE_INVALID;
ASSERT (tc->state == TCP_STATE_SYN_SENT);
-
- sst = tc->c_is_ip4 ? SESSION_TYPE_IP4_TCP : SESSION_TYPE_IP6_TCP;
- stream_session_connect_notify (&tc->connection, sst, 1 /* fail */ );
-
+ stream_session_connect_notify (&tc->connection, 1 /* fail */ );
tcp_connection_cleanup (tc);
}
tcp_connection_t *tc;
tc = tcp_connection_get (conn_index, thread_index);
+ if (!tc)
+ return;
tc->timers[TCP_TIMER_WAITCLOSE] = TCP_TIMER_HANDLE_INVALID;
/* Session didn't come back with a close(). Send FIN either way
vlib_thread_main_t *vtm = vlib_get_thread_main ();
clib_error_t *error = 0;
u32 num_threads;
- int thread, i;
+ int i, thread;
tcp_connection_t *tc __attribute__ ((unused));
+ u32 preallocated_connections_per_thread;
if ((error = vlib_call_init_function (vm, ip_main_init)))
return error;
ip4_register_protocol (IP_PROTOCOL_TCP, tcp4_input_node.index);
/* Register as transport with session layer */
- session_register_transport (SESSION_TYPE_IP4_TCP, &tcp_proto);
- session_register_transport (SESSION_TYPE_IP6_TCP, &tcp_proto);
+ session_register_transport (TRANSPORT_PROTO_TCP, 1, &tcp_proto);
+ session_register_transport (TRANSPORT_PROTO_TCP, 0, &tcp_proto);
/*
* Initialize data structures
vec_validate (tm->connections, num_threads - 1);
/*
- * Preallocate connections
+ * Preallocate connections. Assume that thread 0 won't
+ * use preallocated threads when running multi-core
*/
- for (thread = 0; thread < num_threads; thread++)
+ if (num_threads == 1)
{
- for (i = 0; i < tm->preallocated_connections; i++)
+ thread = 0;
+ preallocated_connections_per_thread = tm->preallocated_connections;
+ }
+ else
+ {
+ thread = 1;
+ preallocated_connections_per_thread =
+ tm->preallocated_connections / (num_threads - 1);
+ }
+ for (; thread < num_threads; thread++)
+ {
+ for (i = 0; i < preallocated_connections_per_thread; i++)
pool_get (tm->connections[thread], tc);
- for (i = 0; i < tm->preallocated_connections; i++)
+ for (i = 0; i < preallocated_connections_per_thread; i++)
pool_put_index (tm->connections[thread], i);
}
/ TCP_TSTAMP_RESOLUTION;
clib_bihash_init_24_8 (&tm->local_endpoints_table, "local endpoint table",
- 200000 /* $$$$ config parameter nbuckets */ ,
- (64 << 20) /*$$$ config parameter table size */ );
+ 1000000 /* $$$$ config parameter nbuckets */ ,
+ (512 << 20) /*$$$ config parameter table size */ );
+
+ /* Initialize [port-allocator] random number seed */
+ tm->port_allocator_seed = (u32) clib_cpu_time_now ();
+
if (num_threads > 1)
- clib_spinlock_init (&tm->half_open_lock);
+ {
+ clib_spinlock_init (&tm->half_open_lock);
+ clib_spinlock_init (&tm->local_endpoints_lock);
+ }
+
+ vec_validate (tm->tx_frames[0], num_threads - 1);
+ vec_validate (tm->tx_frames[1], num_threads - 1);
+
return error;
}
tcp_init (vlib_main_t * vm)
{
tcp_main_t *tm = vnet_get_tcp_main ();
-
- tm->vnet_main = vnet_get_main ();
tm->is_enabled = 0;
-
return 0;
}
VLIB_INIT_FUNCTION (tcp_init);
-
static clib_error_t *
tcp_config_fn (vlib_main_t * vm, unformat_input_t * input)
{