/*
- * Copyright (c) 2016 Cisco and/or its affiliates.
+ * Copyright (c) 2016-2019 Cisco and/or its affiliates.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at:
{
tcp_main_t *tm = &tcp_main;
+ TCP_EVT_DBG (TCP_EVT_DELETE, tc);
+
/* Cleanup local endpoint if this was an active connect */
transport_endpoint_cleanup (TRANSPORT_PROTO_TCP, &tc->c_lcl_ip,
tc->c_lcl_port);
if (!tc->c_is_ip4 && ip6_address_is_link_local_unicast (&tc->c_rmt_ip6))
tcp_add_del_adjacency (tc, 0);
+ vec_free (tc->snd_sacks);
+ vec_free (tc->snd_sacks_fl);
+
/* Poison the entry */
if (CLIB_DEBUG > 0)
clib_memset (tc, 0xFA, sizeof (*tc));
void
tcp_connection_del (tcp_connection_t * tc)
{
- TCP_EVT_DBG (TCP_EVT_DELETE, tc);
session_transport_delete_notify (&tc->connection);
tcp_connection_cleanup (tc);
}
tcp_connection_free (tcp_connection_t * tc)
{
tcp_main_t *tm = &tcp_main;
+ if (CLIB_DEBUG)
+ {
+ u8 thread_index = tc->c_thread_index;
+ clib_memset (tc, 0xFA, sizeof (*tc));
+ pool_put (tm->connections[thread_index], tc);
+ return;
+ }
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.
tcp_timer_update (tc, TCP_TIMER_WAITCLOSE, TCP_FINWAIT1_TIME);
break;
case TCP_STATE_ESTABLISHED:
- if (!session_tx_fifo_max_dequeue (&tc->connection))
+ /* If closing with unread data, reset the connection */
+ if (transport_max_rx_dequeue (&tc->connection))
+ {
+ tcp_send_reset (tc);
+ tcp_connection_timers_reset (tc);
+ tcp_connection_set_state (tc, TCP_STATE_CLOSED);
+ tcp_timer_set (tc, TCP_TIMER_WAITCLOSE, TCP_CLOSEWAIT_TIME);
+ break;
+ }
+ if (!transport_max_tx_dequeue (&tc->connection))
tcp_send_fin (tc);
else
tc->flags |= TCP_CONN_FINPNDG;
tcp_timer_set (tc, TCP_TIMER_WAITCLOSE, TCP_FINWAIT1_TIME);
break;
case TCP_STATE_CLOSE_WAIT:
- if (!session_tx_fifo_max_dequeue (&tc->connection))
+ if (!transport_max_tx_dequeue (&tc->connection))
{
tcp_send_fin (tc);
tcp_connection_timers_reset (tc);
vec_validate (tm->cc_algos, type);
tm->cc_algos[type] = *vft;
+ hash_set_mem (tm->cc_algo_by_name, vft->name, type);
}
tcp_cc_algorithm_t *
u32 indent = format_get_indent (s);
s = format (s, "%U ", format_tcp_congestion_status, tc);
- s = format (s, "cwnd %u ssthresh %u rtx_bytes %u bytes_acked %u\n",
- tc->cwnd, tc->ssthresh, tc->snd_rxt_bytes, tc->bytes_acked);
- s = format (s, "%Ucc space %u prev_ssthresh %u snd_congestion %u"
- " dupack %u\n", format_white_space, indent,
- tcp_available_cc_snd_space (tc), tc->prev_ssthresh,
- tc->snd_congestion - tc->iss, tc->rcv_dupacks);
- s = format (s, "%Utsecr %u tsecr_last_ack %u limited_transmit %u\n",
- format_white_space, indent, tc->rcv_opts.tsecr,
- tc->tsecr_last_ack, tc->limited_transmit - tc->iss);
+ s = format (s, "algo %s cwnd %u ssthresh %u bytes_acked %u\n",
+ tc->cc_algo->name, tc->cwnd, tc->ssthresh, tc->bytes_acked);
+ s = format (s, "%Ucc space %u prev_cwnd %u prev_ssthresh %u rtx_bytes %u\n",
+ format_white_space, indent, tcp_available_cc_snd_space (tc),
+ tc->prev_cwnd, tc->prev_ssthresh, tc->snd_rxt_bytes);
+ s = format (s, "%Usnd_congestion %u dupack %u limited_transmit %u\n",
+ format_white_space, indent, tc->snd_congestion - tc->iss,
+ tc->rcv_dupacks, tc->limited_transmit - tc->iss);
return s;
}
tc->snd_wnd, tc->rcv_wnd, tc->rcv_wscale);
s = format (s, "snd_wl1 %u snd_wl2 %u\n", tc->snd_wl1 - tc->irs,
tc->snd_wl2 - tc->iss);
- s = format (s, " flight size %u out space %u rcv_wnd_av %u\n",
+ s = format (s, " flight size %u out space %u rcv_wnd_av %u",
tcp_flight_size (tc), tcp_available_output_snd_space (tc),
tcp_rcv_wnd_available (tc));
- s = format (s, " tsval_recent %u tsval_recent_age %u\n", tc->tsval_recent,
+ s = format (s, " tsval_recent %u\n", tc->tsval_recent);
+ s = format (s, " tsecr %u tsecr_last_ack %u tsval_recent_age %u",
+ tc->rcv_opts.tsecr, tc->tsecr_last_ack,
tcp_time_now () - tc->tsval_recent_age);
- s = format (s, " rto %u rto_boff %u srtt %u us %.3f rttvar %u rtt_ts %x",
+ s = format (s, " snd_mss %u\n", tc->snd_mss);
+ s = format (s, " rto %u rto_boff %u srtt %u us %.3f rttvar %u rtt_ts %.4f",
tc->rto, tc->rto_boff, tc->srtt, tc->mrtt_us * 1000, tc->rttvar,
tc->rtt_ts);
s = format (s, " rtt_seq %u\n", tc->rtt_seq - tc->iss);
tcp_flush_frames_to_output (wrk);
}
-static u32
-tcp_session_push_header (transport_connection_t * tconn, vlib_buffer_t * b)
-{
- tcp_connection_t *tc = (tcp_connection_t *) tconn;
- return tcp_push_header (tc, b);
-}
-
static void
tcp_session_flush_data (transport_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;
+ tc->psh_seq = tc->snd_una + transport_max_tx_dequeue (tconn) - 1;
}
/* *INDENT-OFF* */
const static transport_proto_vft_t tcp_proto = {
.enable = vnet_tcp_enable_disable,
- .bind = tcp_session_bind,
- .unbind = tcp_session_unbind,
+ .start_listen = tcp_session_bind,
+ .stop_listen = tcp_session_unbind,
.push_header = tcp_session_push_header,
.get_connection = tcp_session_get_transport,
.get_listener = tcp_session_get_listener,
.get_half_open = tcp_half_open_session_get_transport,
- .open = tcp_session_open,
+ .connect = tcp_session_open,
.close = tcp_session_close,
.cleanup = tcp_session_cleanup,
.send_mss = tcp_session_send_mss,
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);
+ tcp_connection_set_state (tc, TCP_STATE_CLOSED);
+ tcp_connection_timers_reset (tc);
+ /* Start cleanup. Do NOT delete the session until we do the connection
+ * cleanup. Otherwise, we end up with a dangling session index in the
+ * tcp connection. */
+ tcp_timer_update (tc, TCP_TIMER_WAITCLOSE, TCP_CLEANUP_TIME);
}
static void
static void
tcp_timer_waitclose_handler (u32 conn_index)
{
- u32 thread_index = vlib_get_thread_index (), rto;
+ u32 thread_index = vlib_get_thread_index ();
tcp_connection_t *tc;
tc = tcp_connection_get (conn_index, thread_index);
* 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;
+ tc->snd_nxt = tc->snd_una;
tcp_send_fin (tc);
tcp_connection_set_state (tc, TCP_STATE_LAST_ACK);
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));
+ /* If FIN pending, we haven't sent everything, but we did try.
+ * Notify session layer that transport is closed. */
+ tcp_connection_set_state (tc, TCP_STATE_CLOSED);
session_transport_closed_notify (&tc->connection);
+ tcp_send_reset (tc);
+ tcp_timer_set (tc, TCP_TIMER_WAITCLOSE, TCP_CLEANUP_TIME);
}
else
{
tcp_initialize_timer_wheels (tm);
tcp_initialize_iss_seed (tm);
- tm->bytes_per_buffer = VLIB_BUFFER_DATA_SIZE;
+ tm->bytes_per_buffer = vlib_buffer_get_default_data_size (vm);
return error;
}
FIB_PROTOCOL_IP6, tcp6_output_node.index);
tcp_api_reference ();
+ tm->cc_algo_by_name = hash_create_string (0, sizeof (uword));
tm->tx_pacing = 1;
tm->cc_algo = TCP_CC_NEWRENO;
+ tm->default_mtu = 1460;
return 0;
}
unformat_tcp_cc_algo (unformat_input_t * input, va_list * va)
{
uword *result = va_arg (*va, uword *);
+ tcp_main_t *tm = &tcp_main;
+ char *cc_algo_name;
+ u8 found = 0;
+ uword *p;
- if (unformat (input, "newreno"))
- *result = TCP_CC_NEWRENO;
- else if (unformat (input, "cubic"))
- *result = TCP_CC_CUBIC;
- else
- return 0;
+ if (unformat (input, "%s", &cc_algo_name)
+ && ((p = hash_get_mem (tm->cc_algo_by_name, cc_algo_name))))
+ {
+ *result = *p;
+ found = 1;
+ }
- return 1;
+ vec_free (cc_algo_name);
+ return found;
}
uword
else if (unformat (input, "max-rx-fifo %U", unformat_memory_size,
&tm->max_rx_fifo))
;
+ else if (unformat (input, "mtu %d", &tm->default_mtu))
+ ;
else if (unformat (input, "no-tx-pacing"))
tm->tx_pacing = 0;
else if (unformat (input, "cc-algo %U", unformat_tcp_cc_algo,