X-Git-Url: https://gerrit.fd.io/r/gitweb?a=blobdiff_plain;f=src%2Fvnet%2Ftcp%2Ftcp.c;h=7f1e63e7b84eb8c82b7884f0aa0766ae55bf8baf;hb=04ae8273f;hp=c51224447fc6364dc54e3b96451844d6c4c76c2a;hpb=222e1f4160a5828bb2b5bf62716cd76664f6100b;p=vpp.git diff --git a/src/vnet/tcp/tcp.c b/src/vnet/tcp/tcp.c index c51224447fc..7f1e63e7b84 100644 --- a/src/vnet/tcp/tcp.c +++ b/src/vnet/tcp/tcp.c @@ -19,11 +19,10 @@ */ #include +#include #include #include #include -#include -#include #include tcp_main_t tcp_main; @@ -69,6 +68,45 @@ tcp_add_del_adjacency (tcp_connection_t * tc, u8 is_add) sizeof (args)); } +static void +tcp_cc_init (tcp_connection_t * tc) +{ + tc->cc_algo->init (tc); +} + +static void +tcp_cc_cleanup (tcp_connection_t * tc) +{ + if (tc->cc_algo->cleanup) + tc->cc_algo->cleanup (tc); +} + +void +tcp_cc_algo_register (tcp_cc_algorithm_type_e type, + const tcp_cc_algorithm_t * vft) +{ + tcp_main_t *tm = vnet_get_tcp_main (); + 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 * +tcp_cc_algo_get (tcp_cc_algorithm_type_e type) +{ + tcp_main_t *tm = vnet_get_tcp_main (); + return &tm->cc_algos[type]; +} + +tcp_cc_algorithm_type_e +tcp_cc_algo_new_type (const tcp_cc_algorithm_t * vft) +{ + tcp_main_t *tm = vnet_get_tcp_main (); + tcp_cc_algo_register (++tm->cc_last_type, vft); + return tm->cc_last_type; +} + static u32 tcp_connection_bind (u32 session_index, transport_endpoint_t * lcl) { @@ -95,10 +133,11 @@ tcp_connection_bind (u32 session_index, transport_endpoint_t * lcl) listener->c_s_index = session_index; listener->c_fib_index = lcl->fib_index; listener->state = TCP_STATE_LISTEN; + listener->cc_algo = tcp_cc_algo_get (tcp_cfg.cc_algo); tcp_connection_timers_init (listener); - TCP_EVT_DBG (TCP_EVT_BIND, listener); + TCP_EVT (TCP_EVT_BIND, listener); return listener->c_c_index; } @@ -117,7 +156,7 @@ tcp_connection_unbind (u32 listener_index) tc = pool_elt_at_index (tm->listener_pool, listener_index); - TCP_EVT_DBG (TCP_EVT_UNBIND, tc); + TCP_EVT (TCP_EVT_UNBIND, tc); /* Poison the entry */ if (CLIB_DEBUG > 0) @@ -147,13 +186,13 @@ tcp_session_get_listener (u32 listener_index) * */ static void -tcp_half_open_connection_del (tcp_connection_t * tc) +tcp_half_open_connection_free (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) clib_memset (tc, 0xFA, sizeof (*tc)); + pool_put (tm->half_open_connections, tc); clib_spinlock_unlock_if_init (&tm->half_open_lock); } @@ -169,12 +208,16 @@ tcp_half_open_connection_del (tcp_connection_t * tc) int tcp_half_open_connection_cleanup (tcp_connection_t * tc) { + tcp_worker_ctx_t *wrk; + /* 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_AO); - tcp_timer_reset (tc, TCP_TIMER_RETRANSMIT_SYN); - tcp_half_open_connection_del (tc); + + session_half_open_delete_notify (TRANSPORT_PROTO_TCP, tc->c_s_ho_handle); + wrk = tcp_get_worker (tc->c_thread_index); + tcp_timer_reset (&wrk->timer_wheel, tc, TCP_TIMER_RETRANSMIT_SYN); + tcp_half_open_connection_free (tc); return 0; } @@ -198,11 +241,12 @@ tcp_half_open_connection_new (void) void tcp_connection_cleanup (tcp_connection_t * tc) { - tcp_main_t *tm = &tcp_main; + TCP_EVT (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->cfg_flags & TCP_CFG_F_NO_ENDPOINT)) + transport_endpoint_cleanup (TRANSPORT_PROTO_TCP, &tc->c_lcl_ip, + tc->c_lcl_port); /* Check if connection is not yet fully established */ if (tc->state == TCP_STATE_SYN_SENT) @@ -215,18 +259,22 @@ tcp_connection_cleanup (tcp_connection_t * tc) } else { - int thread_index = tc->c_thread_index; - /* Make sure all timers are cleared */ tcp_connection_timers_reset (tc); if (!tc->c_is_ip4 && ip6_address_is_link_local_unicast (&tc->c_rmt_ip6)) tcp_add_del_adjacency (tc, 0); - /* Poison the entry */ - if (CLIB_DEBUG > 0) - clib_memset (tc, 0xFA, sizeof (*tc)); - pool_put (tm->connections[thread_index], tc); + tcp_cc_cleanup (tc); + vec_free (tc->snd_sacks); + vec_free (tc->snd_sacks_fl); + vec_free (tc->rcv_opts.sacks); + pool_free (tc->sack_sb.holes); + + if (tc->cfg_flags & TCP_CFG_F_RATE_SAMPLE) + tcp_bt_cleanup (tc); + + tcp_connection_free (tc); } } @@ -240,7 +288,6 @@ tcp_connection_cleanup (tcp_connection_t * 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); } @@ -248,70 +295,52 @@ tcp_connection_del (tcp_connection_t * tc) tcp_connection_t * tcp_connection_alloc (u8 thread_index) { - tcp_main_t *tm = vnet_get_tcp_main (); + tcp_worker_ctx_t *wrk = tcp_get_worker (thread_index); tcp_connection_t *tc; - pool_get (tm->connections[thread_index], tc); + pool_get (wrk->connections, tc); clib_memset (tc, 0, sizeof (*tc)); - tc->c_c_index = tc - tm->connections[thread_index]; + tc->c_c_index = tc - wrk->connections; tc->c_thread_index = thread_index; return tc; } -void -tcp_connection_free (tcp_connection_t * tc) +tcp_connection_t * +tcp_connection_alloc_w_base (u8 thread_index, tcp_connection_t * base) { - 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)); + tcp_worker_ctx_t *wrk = tcp_get_worker (thread_index); + tcp_connection_t *tc; + + pool_get (wrk->connections, tc); + clib_memcpy_fast (tc, base, sizeof (*tc)); + tc->c_c_index = tc - wrk->connections; + tc->c_thread_index = thread_index; + return tc; } -/** Notify session that connection has been reset. - * - * Switch state to closed and wait for session to call cleanup. - */ void -tcp_connection_reset (tcp_connection_t * tc) +tcp_connection_free (tcp_connection_t * tc) { - TCP_EVT_DBG (TCP_EVT_RST_RCVD, tc); - switch (tc->state) + tcp_worker_ctx_t *wrk = tcp_get_worker (tc->c_thread_index); + if (CLIB_DEBUG) { - case TCP_STATE_SYN_RCVD: - /* Cleanup everything. App wasn't notified yet */ - 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); - 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_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: - case TCP_STATE_LAST_ACK: - tcp_connection_timers_reset (tc); - 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: - case TCP_STATE_TIME_WAIT: - break; - default: - TCP_DBG ("reset state: %u", tc->state); + clib_memset (tc, 0xFA, sizeof (*tc)); + pool_put (wrk->connections, tc); + return; } + pool_put (wrk->connections, tc); +} + +void +tcp_program_cleanup (tcp_worker_ctx_t * wrk, tcp_connection_t * tc) +{ + tcp_cleanup_req_t *req; + clib_time_type_t now; + + now = tcp_time_now_us (tc->c_thread_index); + clib_fifo_add2 (wrk->pending_cleanups, req); + req->connection_index = tc->c_c_index; + req->free_time = now + tcp_cfg.cleanup_time; } /** @@ -330,7 +359,9 @@ tcp_connection_reset (tcp_connection_t * tc) void tcp_connection_close (tcp_connection_t * tc) { - TCP_EVT_DBG (TCP_EVT_CLOSE, tc); + tcp_worker_ctx_t *wrk = tcp_get_worker (tc->c_thread_index); + + TCP_EVT (TCP_EVT_CLOSE, tc); /* Send/Program FIN if needed and switch state */ switch (tc->state) @@ -344,10 +375,22 @@ tcp_connection_close (tcp_connection_t * tc) tcp_connection_timers_reset (tc); tcp_send_fin (tc); tcp_connection_set_state (tc, TCP_STATE_FIN_WAIT_1); - tcp_timer_update (tc, TCP_TIMER_WAITCLOSE, TCP_FINWAIT1_TIME); + tcp_timer_update (&wrk->timer_wheel, tc, TCP_TIMER_WAITCLOSE, + tcp_cfg.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); + session_transport_closed_notify (&tc->connection); + tcp_program_cleanup (tcp_get_worker (tc->c_thread_index), tc); + tcp_worker_stats_inc (wrk, rst_unread, 1); + break; + } + if (!transport_max_tx_dequeue (&tc->connection)) tcp_send_fin (tc); else tc->flags |= TCP_CONN_FINPNDG; @@ -355,28 +398,27 @@ tcp_connection_close (tcp_connection_t * tc) /* 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); + tcp_timer_set (&wrk->timer_wheel, tc, TCP_TIMER_WAITCLOSE, + tcp_cfg.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); tcp_connection_set_state (tc, TCP_STATE_LAST_ACK); - tcp_timer_update (tc, TCP_TIMER_WAITCLOSE, TCP_2MSL_TIME); + tcp_timer_update (&wrk->timer_wheel, tc, TCP_TIMER_WAITCLOSE, + tcp_cfg.lastack_time); } else tc->flags |= TCP_CONN_FINPNDG; break; case TCP_STATE_FIN_WAIT_1: - tcp_timer_update (tc, TCP_TIMER_WAITCLOSE, TCP_2MSL_TIME); + tcp_timer_update (&wrk->timer_wheel, tc, TCP_TIMER_WAITCLOSE, + tcp_cfg.finwait1_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); + /* Cleanup should've been programmed already */ break; default: TCP_DBG ("state: %u", tc->state); @@ -396,10 +438,37 @@ tcp_session_cleanup (u32 conn_index, u32 thread_index) { tcp_connection_t *tc; tc = tcp_connection_get (conn_index, thread_index); + if (!tc) + return; tcp_connection_set_state (tc, TCP_STATE_CLOSED); tcp_connection_cleanup (tc); } +static void +tcp_session_cleanup_ho (u32 conn_index) +{ + tcp_worker_ctx_t *wrk; + tcp_connection_t *tc; + + tc = tcp_half_open_connection_get (conn_index); + wrk = tcp_get_worker (tc->c_thread_index); + tcp_timer_reset (&wrk->timer_wheel, tc, TCP_TIMER_RETRANSMIT_SYN); + tcp_half_open_connection_free (tc); +} + +static void +tcp_session_reset (u32 conn_index, u32 thread_index) +{ + tcp_connection_t *tc; + tc = tcp_connection_get (conn_index, thread_index); + tcp_send_reset (tc); + tcp_connection_timers_reset (tc); + tcp_cong_recovery_off (tc); + tcp_connection_set_state (tc, TCP_STATE_CLOSED); + session_transport_closed_notify (&tc->connection); + tcp_program_cleanup (tcp_get_worker (thread_index), tc); +} + /** * Initialize all connection timers as invalid */ @@ -423,11 +492,11 @@ tcp_connection_timers_init (tcp_connection_t * tc) void tcp_connection_timers_reset (tcp_connection_t * tc) { + tcp_worker_ctx_t *wrk = tcp_get_worker (tc->c_thread_index); int i; + for (i = 0; i < TCP_N_TIMERS; i++) - { - tcp_timer_reset (tc, i); - } + tcp_timer_reset (&wrk->timer_wheel, tc, i); } #if 0 @@ -527,30 +596,6 @@ tcp_connection_fib_attach (tcp_connection_t * tc) } #endif /* 0 */ -static void -tcp_cc_init (tcp_connection_t * tc) -{ - tc->cc_algo = tcp_cc_algo_get (tcp_main.cc_algo); - tc->cc_algo->init (tc); -} - -void -tcp_cc_algo_register (tcp_cc_algorithm_type_e type, - const tcp_cc_algorithm_t * vft) -{ - tcp_main_t *tm = vnet_get_tcp_main (); - vec_validate (tm->cc_algos, type); - - tm->cc_algos[type] = *vft; -} - -tcp_cc_algorithm_t * -tcp_cc_algo_get (tcp_cc_algorithm_type_e type) -{ - tcp_main_t *tm = vnet_get_tcp_main (); - return &tm->cc_algos[type]; -} - /** * Generate random iss as per rfc6528 */ @@ -572,6 +617,52 @@ tcp_generate_random_iss (tcp_connection_t * tc) return ((tmp >> 32) ^ (tmp & 0xffffffff)); } +/** + * Initialize max segment size we're able to process. + * + * The value is constrained by the output interface's MTU and by the size + * of the IP and TCP headers (see RFC6691). It is also what we advertise + * to our peer. + */ +static void +tcp_init_rcv_mss (tcp_connection_t * tc) +{ + u8 ip_hdr_len; + + /* Already provided at connection init time */ + if (tc->mss) + return; + + ip_hdr_len = tc->c_is_ip4 ? sizeof (ip4_header_t) : sizeof (ip6_header_t); + tc->mss = tcp_cfg.default_mtu - sizeof (tcp_header_t) - ip_hdr_len; +} + +static void +tcp_init_mss (tcp_connection_t * tc) +{ + u16 default_min_mss = 536; + + tcp_init_rcv_mss (tc); + + /* TODO consider PMTU discovery */ + tc->snd_mss = clib_min (tc->rcv_opts.mss, tc->mss); + + if (tc->snd_mss < 45) + { + /* Assume that at least the min default mss works */ + tc->snd_mss = default_min_mss; + tc->rcv_opts.mss = default_min_mss; + } + + /* We should have enough space for 40 bytes of options */ + ASSERT (tc->snd_mss > 45); + + /* If we use timestamp option, account for it and make sure + * the options are 4-byte aligned */ + if (tcp_opts_tstamp (&tc->rcv_opts)) + tc->snd_mss -= TCP_OPTION_LEN_TIMESTAMP + 2 /* alignment */; +} + /** * Initialize connection send variables. */ @@ -584,23 +675,24 @@ tcp_init_snd_vars (tcp_connection_t * tc) * handshake may make it look as if time has flown in the opposite * direction for us. */ - tcp_set_time_now (tcp_get_worker (vlib_get_thread_index ())); + tcp_update_time_now (tcp_get_worker (vlib_get_thread_index ())); + tcp_init_rcv_mss (tc); 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; + tc->srtt = 0.1 * THZ; /* 100 ms */ + + if (!tcp_cfg.csum_offload) + tc->cfg_flags |= TCP_CFG_F_NO_CSUM_OFFLOAD; } void tcp_enable_pacing (tcp_connection_t * tc) { - u32 initial_bucket, byte_rate; - initial_bucket = 16 * tc->snd_mss; - byte_rate = 2 << 16; - transport_connection_tx_pacer_init (&tc->connection, byte_rate, - initial_bucket); + u32 byte_rate; + byte_rate = tc->cwnd / (tc->srtt * TCP_TICK); + transport_connection_tx_pacer_init (&tc->connection, byte_rate, tc->cwnd); tc->mrtt_us = (u32) ~ 0; } @@ -614,18 +706,27 @@ tcp_connection_init_vars (tcp_connection_t * tc) tcp_connection_timers_init (tc); tcp_init_mss (tc); scoreboard_init (&tc->sack_sb); - tcp_cc_init (tc); if (tc->state == TCP_STATE_SYN_RCVD) tcp_init_snd_vars (tc); + tcp_cc_init (tc); + if (!tc->c_is_ip4 && ip6_address_is_link_local_unicast (&tc->c_rmt_ip6)) tcp_add_del_adjacency (tc, 1); /* tcp_connection_fib_attach (tc); */ if (transport_connection_is_tx_paced (&tc->connection) - || tcp_main.tx_pacing) + || tcp_cfg.enable_tx_pacing) tcp_enable_pacing (tc); + + if (tc->cfg_flags & TCP_CFG_F_RATE_SAMPLE) + tcp_bt_init (tc); + + if (!tcp_cfg.allow_tso) + tc->cfg_flags |= TCP_CFG_F_NO_TSO; + + tc->start_ts = tcp_time_now_us (tc->c_thread_index); } static int @@ -635,25 +736,22 @@ tcp_alloc_custom_local_endpoint (tcp_main_t * tm, ip46_address_t * lcl_addr, int index, port; if (is_ip4) { - index = tm->last_v4_address_rotor++; - if (tm->last_v4_address_rotor >= vec_len (tm->ip4_src_addresses)) - tm->last_v4_address_rotor = 0; - lcl_addr->ip4.as_u32 = tm->ip4_src_addresses[index].as_u32; + index = tm->last_v4_addr_rotor++; + if (tm->last_v4_addr_rotor >= vec_len (tcp_cfg.ip4_src_addrs)) + tm->last_v4_addr_rotor = 0; + lcl_addr->ip4.as_u32 = tcp_cfg.ip4_src_addrs[index].as_u32; } else { - 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_fast (&lcl_addr->ip6, &tm->ip6_src_addresses[index], + index = tm->last_v6_addr_rotor++; + if (tm->last_v6_addr_rotor >= vec_len (tcp_cfg.ip6_src_addrs)) + tm->last_v6_addr_rotor = 0; + clib_memcpy_fast (&lcl_addr->ip6, &tcp_cfg.ip6_src_addrs[index], sizeof (ip6_address_t)); } port = transport_alloc_local_port (TRANSPORT_PROTO_TCP, lcl_addr); if (port < 1) - { - clib_warning ("Failed to allocate src port"); - return -1; - } + return SESSION_E_NOPORT; *lcl_port = port; return 0; } @@ -670,8 +768,8 @@ tcp_session_open (transport_endpoint_cfg_t * rmt) /* * Allocate local endpoint */ - if ((rmt->is_ip4 && vec_len (tm->ip4_src_addresses)) - || (!rmt->is_ip4 && vec_len (tm->ip6_src_addresses))) + if ((rmt->is_ip4 && vec_len (tcp_cfg.ip4_src_addrs)) + || (!rmt->is_ip4 && vec_len (tcp_cfg.ip6_src_addrs))) rv = tcp_alloc_custom_local_endpoint (tm, &lcl_addr, &lcl_port, rmt->is_ip4); else @@ -679,7 +777,20 @@ tcp_session_open (transport_endpoint_cfg_t * rmt) rmt, &lcl_addr, &lcl_port); if (rv) - return -1; + { + if (rv != SESSION_E_PORTINUSE) + return rv; + + if (session_lookup_connection (rmt->fib_index, &lcl_addr, &rmt->ip, + lcl_port, rmt->port, TRANSPORT_PROTO_UDP, + rmt->is_ip4)) + return SESSION_E_PORTINUSE; + + /* 5-tuple is available so increase lcl endpoint refcount and proceed + * with connection allocation */ + transport_share_local_endpoint (TRANSPORT_PROTO_UDP, &lcl_addr, + lcl_port); + } /* * Create connection and send SYN @@ -693,10 +804,12 @@ tcp_session_open (transport_endpoint_cfg_t * rmt) tc->c_is_ip4 = rmt->is_ip4; tc->c_proto = TRANSPORT_PROTO_TCP; tc->c_fib_index = rmt->fib_index; + tc->cc_algo = tcp_cc_algo_get (tcp_cfg.cc_algo); /* The other connection vars will be initialized after SYN ACK */ tcp_connection_timers_init (tc); + tc->mss = rmt->mss; - TCP_EVT_DBG (TCP_EVT_OPEN, tc); + TCP_EVT (TCP_EVT_OPEN, tc); tc->state = TCP_STATE_SYN_SENT; tcp_init_snd_vars (tc); tcp_send_syn (tc); @@ -705,201 +818,6 @@ tcp_session_open (transport_endpoint_cfg_t * rmt) return tc->c_c_index; } -const char *tcp_dbg_evt_str[] = { -#define _(sym, str) str, - foreach_tcp_dbg_evt -#undef _ -}; - -const char *tcp_fsm_states[] = { -#define _(sym, str) str, - foreach_tcp_fsm_state -#undef _ -}; - -u8 * -format_tcp_state (u8 * s, va_list * args) -{ - u32 state = va_arg (*args, u32); - - if (state < TCP_N_STATES) - s = format (s, "%s", tcp_fsm_states[state]); - else - s = format (s, "UNKNOWN (%d (0x%x))", state, state); - return s; -} - -const char *tcp_connection_flags_str[] = { -#define _(sym, str) str, - foreach_tcp_connection_flag -#undef _ -}; - -static u8 * -format_tcp_connection_flags (u8 * s, va_list * args) -{ - tcp_connection_t *tc = va_arg (*args, tcp_connection_t *); - int i, last = -1; - - for (i = 0; i < TCP_CONN_N_FLAG_BITS; i++) - if (tc->flags & (1 << i)) - last = i; - for (i = 0; i < last; i++) - { - if (tc->flags & (1 << i)) - s = format (s, "%s, ", tcp_connection_flags_str[i]); - } - if (last >= 0) - s = format (s, "%s", tcp_connection_flags_str[last]); - return s; -} - -const char *tcp_conn_timers[] = { -#define _(sym, str) str, - foreach_tcp_timer -#undef _ -}; - -static u8 * -format_tcp_timers (u8 * s, va_list * args) -{ - tcp_connection_t *tc = va_arg (*args, tcp_connection_t *); - int i, last = -1; - - for (i = 0; i < TCP_N_TIMERS; i++) - if (tc->timers[i] != TCP_TIMER_HANDLE_INVALID) - last = i; - - for (i = 0; i < last; i++) - { - if (tc->timers[i] != TCP_TIMER_HANDLE_INVALID) - s = format (s, "%s,", tcp_conn_timers[i]); - } - - if (last >= 0) - s = format (s, "%s", tcp_conn_timers[i]); - - return s; -} - -static u8 * -format_tcp_congestion_status (u8 * s, va_list * args) -{ - tcp_connection_t *tc = va_arg (*args, tcp_connection_t *); - if (tcp_in_recovery (tc)) - s = format (s, "recovery"); - else if (tcp_in_fastrecovery (tc)) - s = format (s, "fastrecovery"); - else - s = format (s, "none"); - return s; -} - -static i32 -tcp_rcv_wnd_available (tcp_connection_t * tc) -{ - return (i32) tc->rcv_wnd - (tc->rcv_nxt - tc->rcv_las); -} - -static u8 * -format_tcp_congestion (u8 * s, va_list * args) -{ - tcp_connection_t *tc = va_arg (*args, tcp_connection_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); - return s; -} - -static u8 * -format_tcp_vars (u8 * s, va_list * args) -{ - tcp_connection_t *tc = va_arg (*args, tcp_connection_t *); - s = format (s, " index: %u flags: %U timers: %U\n", tc->c_c_index, - format_tcp_connection_flags, tc, format_tcp_timers, tc); - s = format (s, " snd_una %u snd_nxt %u snd_una_max %u", - tc->snd_una - tc->iss, tc->snd_nxt - tc->iss, - tc->snd_una_max - tc->iss); - s = format (s, " rcv_nxt %u rcv_las %u\n", - tc->rcv_nxt - tc->irs, tc->rcv_las - tc->irs); - s = format (s, " snd_wnd %u rcv_wnd %u rcv_wscale %u ", - 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", - 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, - tcp_time_now () - tc->tsval_recent_age); - s = format (s, " rto %u rto_boff %u srtt %u us %.3f rttvar %u rtt_ts %x", - 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); - s = format (s, " cong: %U", format_tcp_congestion, tc); - - if (tc->state >= TCP_STATE_ESTABLISHED) - { - s = format (s, " sboard: %U\n", format_tcp_scoreboard, &tc->sack_sb, - tc); - } - if (vec_len (tc->snd_sacks)) - s = format (s, " sacks tx: %U\n", format_tcp_sacks, tc); - - return s; -} - -static u8 * -format_tcp_connection_id (u8 * s, va_list * args) -{ - tcp_connection_t *tc = va_arg (*args, tcp_connection_t *); - if (!tc) - return s; - if (tc->c_is_ip4) - { - s = format (s, "[%d:%d][%s] %U:%d->%U:%d", tc->c_thread_index, - tc->c_s_index, "T", format_ip4_address, &tc->c_lcl_ip4, - clib_net_to_host_u16 (tc->c_lcl_port), format_ip4_address, - &tc->c_rmt_ip4, clib_net_to_host_u16 (tc->c_rmt_port)); - } - else - { - s = format (s, "[%d:%d][%s] %U:%d->%U:%d", tc->c_thread_index, - tc->c_s_index, "T", format_ip6_address, &tc->c_lcl_ip6, - clib_net_to_host_u16 (tc->c_lcl_port), format_ip6_address, - &tc->c_rmt_ip6, clib_net_to_host_u16 (tc->c_rmt_port)); - } - - return s; -} - -u8 * -format_tcp_connection (u8 * s, va_list * args) -{ - tcp_connection_t *tc = va_arg (*args, tcp_connection_t *); - u32 verbose = va_arg (*args, u32); - - if (!tc) - return s; - s = format (s, "%-50U", format_tcp_connection_id, tc); - if (verbose) - { - s = format (s, "%-15U", format_tcp_state, tc->state); - if (verbose > 1) - s = format (s, "\n%U", format_tcp_vars, tc); - } - - return s; -} - static u8 * format_tcp_session (u8 * s, va_list * args) { @@ -920,11 +838,13 @@ static u8 * format_tcp_listener_session (u8 * s, va_list * args) { u32 tci = va_arg (*args, u32); + u32 __clib_unused thread_index = va_arg (*args, u32); u32 verbose = va_arg (*args, u32); tcp_connection_t *tc = tcp_listener_get (tci); - s = format (s, "%-50U", format_tcp_connection_id, tc); + s = format (s, "%-" SESSION_CLI_ID_LEN "U", format_tcp_connection_id, tc); if (verbose) - s = format (s, "%-15U", format_tcp_state, tc->state); + s = format (s, "%-" SESSION_CLI_STATE_LEN "U", format_tcp_state, + tc->state); return s; } @@ -932,134 +852,131 @@ static u8 * format_tcp_half_open_session (u8 * s, va_list * args) { u32 tci = va_arg (*args, u32); + u32 __clib_unused thread_index = va_arg (*args, u32); tcp_connection_t *tc = tcp_half_open_connection_get (tci); return format (s, "%U", format_tcp_connection_id, tc); } -u8 * -format_tcp_sacks (u8 * s, va_list * args) +static transport_connection_t * +tcp_session_get_transport (u32 conn_index, u32 thread_index) { - tcp_connection_t *tc = va_arg (*args, tcp_connection_t *); - sack_block_t *sacks = tc->snd_sacks; - sack_block_t *block; - int i, len = 0; + tcp_connection_t *tc = tcp_connection_get (conn_index, thread_index); + if (PREDICT_FALSE (!tc)) + return 0; + return &tc->connection; +} - len = vec_len (sacks); - for (i = 0; i < len - 1; i++) - { - block = &sacks[i]; - s = format (s, " start %u end %u\n", block->start - tc->irs, - block->end - tc->irs); - } - if (len) - { - block = &sacks[len - 1]; - s = format (s, " start %u end %u", block->start - tc->irs, - block->end - tc->irs); - } - return s; +static transport_connection_t * +tcp_half_open_session_get_transport (u32 conn_index) +{ + tcp_connection_t *tc = tcp_half_open_connection_get (conn_index); + return &tc->connection; } -u8 * -format_tcp_rcv_sacks (u8 * s, va_list * args) +static int +tcp_set_attribute (tcp_connection_t *tc, transport_endpt_attr_t *attr) { - tcp_connection_t *tc = va_arg (*args, tcp_connection_t *); - sack_block_t *sacks = tc->rcv_opts.sacks; - sack_block_t *block; - int i, len = 0; + int rv = 0; - len = vec_len (sacks); - for (i = 0; i < len - 1; i++) - { - block = &sacks[i]; - s = format (s, " start %u end %u\n", block->start - tc->iss, - block->end - tc->iss); - } - if (len) + switch (attr->type) { - block = &sacks[len - 1]; - s = format (s, " start %u end %u", block->start - tc->iss, - block->end - tc->iss); + case TRANSPORT_ENDPT_ATTR_NEXT_OUTPUT_NODE: + tc->next_node_index = attr->next_output_node & 0xffffffff; + tc->next_node_opaque = attr->next_output_node >> 32; + break; + case TRANSPORT_ENDPT_ATTR_MSS: + tc->mss = attr->mss; + tc->snd_mss = clib_min (tc->snd_mss, tc->mss); + break; + case TRANSPORT_ENDPT_ATTR_FLAGS: + if (attr->flags & TRANSPORT_ENDPT_ATTR_F_CSUM_OFFLOAD) + tc->cfg_flags |= TCP_CFG_F_NO_CSUM_OFFLOAD; + else + tc->cfg_flags &= ~TCP_CFG_F_NO_CSUM_OFFLOAD; + if (attr->flags & TRANSPORT_ENDPT_ATTR_F_GSO) + { + if (!(tc->cfg_flags & TCP_CFG_F_TSO)) + tcp_check_gso (tc); + tc->cfg_flags &= ~TCP_CFG_F_NO_TSO; + } + else + { + tc->cfg_flags |= TCP_CFG_F_NO_TSO; + tc->cfg_flags &= ~TCP_CFG_F_TSO; + } + break; + case TRANSPORT_ENDPT_ATTR_CC_ALGO: + if (tc->cc_algo == tcp_cc_algo_get (attr->cc_algo)) + break; + tcp_cc_cleanup (tc); + tc->cc_algo = tcp_cc_algo_get (attr->cc_algo); + tcp_cc_init (tc); + break; + default: + rv = -1; + break; } - return s; -} -static u8 * -format_tcp_sack_hole (u8 * s, va_list * args) -{ - sack_scoreboard_hole_t *hole = va_arg (*args, sack_scoreboard_hole_t *); - tcp_connection_t *tc = va_arg (*args, tcp_connection_t *); - if (tc) - s = format (s, " [%u, %u]", hole->start - tc->iss, hole->end - tc->iss); - else - s = format (s, " [%u, %u]", hole->start, hole->end); - return s; + return rv; } -u8 * -format_tcp_scoreboard (u8 * s, va_list * args) +static int +tcp_get_attribute (tcp_connection_t *tc, transport_endpt_attr_t *attr) { - sack_scoreboard_t *sb = va_arg (*args, sack_scoreboard_t *); - tcp_connection_t *tc = va_arg (*args, tcp_connection_t *); - sack_scoreboard_hole_t *hole; - u32 indent = format_get_indent (s); - - s = format (s, "sacked_bytes %u last_sacked_bytes %u lost_bytes %u\n", - sb->sacked_bytes, sb->last_sacked_bytes, sb->lost_bytes); - s = format (s, "%Ulast_bytes_delivered %u high_sacked %u snd_una_adv %u\n", - format_white_space, indent, sb->last_bytes_delivered, - sb->high_sacked - tc->iss, sb->snd_una_adv); - s = format (s, "%Ucur_rxt_hole %u high_rxt %u rescue_rxt %u", - format_white_space, indent, sb->cur_rxt_hole, - sb->high_rxt - tc->iss, sb->rescue_rxt - tc->iss); + int rv = 0; + u64 non; - hole = scoreboard_first_hole (sb); - if (hole) - s = format (s, "\n%Uhead %u tail %u %u holes:\n%U", format_white_space, - indent, sb->head, sb->tail, pool_elts (sb->holes), - format_white_space, indent); - - while (hole) + switch (attr->type) { - s = format (s, "%U", format_tcp_sack_hole, hole, tc); - hole = scoreboard_next_hole (sb, hole); + case TRANSPORT_ENDPT_ATTR_NEXT_OUTPUT_NODE: + non = (u64) tc->next_node_opaque << 32 | tc->next_node_index; + attr->next_output_node = non; + break; + case TRANSPORT_ENDPT_ATTR_MSS: + attr->mss = tc->snd_mss; + break; + case TRANSPORT_ENDPT_ATTR_FLAGS: + attr->flags = 0; + if (!(tc->cfg_flags & TCP_CFG_F_NO_CSUM_OFFLOAD)) + attr->flags |= TRANSPORT_ENDPT_ATTR_F_CSUM_OFFLOAD; + if (tc->cfg_flags & TCP_CFG_F_TSO) + attr->flags |= TRANSPORT_ENDPT_ATTR_F_GSO; + break; + case TRANSPORT_ENDPT_ATTR_CC_ALGO: + attr->cc_algo = tc->cc_algo - tcp_main.cc_algos; + break; + default: + rv = -1; + break; } - return s; + return rv; } -static transport_connection_t * -tcp_session_get_transport (u32 conn_index, u32 thread_index) +static int +tcp_session_attribute (u32 conn_index, u32 thread_index, u8 is_get, + transport_endpt_attr_t *attr) { tcp_connection_t *tc = tcp_connection_get (conn_index, thread_index); - return &tc->connection; -} -static transport_connection_t * -tcp_half_open_session_get_transport (u32 conn_index) -{ - tcp_connection_t *tc = tcp_half_open_connection_get (conn_index); - return &tc->connection; + if (PREDICT_FALSE (!tc)) + return -1; + + if (is_get) + return tcp_get_attribute (tc, attr); + else + return tcp_set_attribute (tc, attr); } -/** - * Compute maximum segment size for session layer. - * - * Since the result needs to be the actual data length, it first computes - * the tcp options to be used in the next burst and subtracts their - * length from the connection's snd_mss. - */ static u16 -tcp_session_send_mss (transport_connection_t * trans_conn) +tcp_session_cal_goal_size (tcp_connection_t * tc) { - tcp_connection_t *tc = (tcp_connection_t *) trans_conn; + u16 goal_size = tc->snd_mss; - /* Ensure snd_mss does accurately reflect the amount of data we can push - * in a segment. This also makes sure that options are updated according to - * the current state of the connection. */ - tcp_update_burst_snd_vars (tc); + goal_size = tcp_cfg.max_gso_size - tc->snd_mss % tcp_cfg.max_gso_size; + goal_size = clib_min (goal_size, tc->snd_wnd / 2); - return tc->snd_mss; + return goal_size > tc->snd_mss ? goal_size : tc->snd_mss; } always_inline u32 @@ -1092,26 +1009,36 @@ tcp_round_snd_space (tcp_connection_t * tc, u32 snd_space) static inline u32 tcp_snd_space_inline (tcp_connection_t * tc) { - int snd_space, snt_limited; + int snd_space; - if (PREDICT_FALSE (tcp_in_fastrecovery (tc) + /* Fast path is disabled when recovery is on. @ref tcp_session_custom_tx + * controls both retransmits and the sending of new data while congested + */ + if (PREDICT_FALSE (tcp_in_cong_recovery (tc) || tc->state == TCP_STATE_CLOSED)) return 0; snd_space = tcp_available_output_snd_space (tc); - /* If we haven't gotten dupacks or if we did and have gotten sacked - * bytes then we can still send as per Limited Transmit (RFC3042) */ - if (PREDICT_FALSE (tc->rcv_dupacks != 0 - && (tcp_opts_sack_permitted (tc) - && tc->sack_sb.last_sacked_bytes == 0))) + /* If we got dupacks or sacked bytes but we're not yet in recovery, try + * to force the peer to send enough dupacks to start retransmitting as + * per Limited Transmit (RFC3042) + */ + if (PREDICT_FALSE (tc->rcv_dupacks || tc->sack_sb.sacked_bytes)) { - if (tc->rcv_dupacks == 1 && tc->limited_transmit != tc->snd_nxt) + int snt_limited, n_pkts; + + n_pkts = tcp_opts_sack_permitted (&tc->rcv_opts) + ? tc->sack_sb.reorder - 1 : 2; + + if ((seq_lt (tc->limited_transmit, tc->snd_nxt - n_pkts * tc->snd_mss) + || seq_gt (tc->limited_transmit, tc->snd_nxt))) tc->limited_transmit = tc->snd_nxt; + ASSERT (seq_leq (tc->limited_transmit, tc->snd_nxt)); snt_limited = tc->snd_nxt - tc->limited_transmit; - snd_space = clib_max (2 * tc->snd_mss - snt_limited, 0); + snd_space = clib_max (n_pkts * tc->snd_mss - snt_limited, 0); } return tcp_round_snd_space (tc, snd_space); } @@ -1122,189 +1049,65 @@ tcp_snd_space (tcp_connection_t * tc) return tcp_snd_space_inline (tc); } -static u32 -tcp_session_send_space (transport_connection_t * trans_conn) +static int +tcp_session_send_params (transport_connection_t * trans_conn, + transport_send_params_t * sp) { tcp_connection_t *tc = (tcp_connection_t *) trans_conn; - return clib_min (tcp_snd_space_inline (tc), - tc->snd_wnd - (tc->snd_nxt - tc->snd_una)); -} -static u32 -tcp_session_tx_fifo_offset (transport_connection_t * trans_conn) -{ - tcp_connection_t *tc = (tcp_connection_t *) trans_conn; + /* Ensure snd_mss does accurately reflect the amount of data we can push + * in a segment. This also makes sure that options are updated according to + * the current state of the connection. */ + tcp_update_burst_snd_vars (tc); - ASSERT (seq_geq (tc->snd_nxt, tc->snd_una)); + if (PREDICT_FALSE (tc->cfg_flags & TCP_CFG_F_TSO)) + sp->snd_mss = tcp_session_cal_goal_size (tc); + else + sp->snd_mss = tc->snd_mss; - /* This still works if fast retransmit is on */ - return (tc->snd_nxt - tc->snd_una); -} + sp->snd_space = clib_min (tcp_snd_space_inline (tc), + tc->snd_wnd - (tc->snd_nxt - tc->snd_una)); -static void -tcp_update_time (f64 now, u8 thread_index) -{ - tcp_worker_ctx_t *wrk = tcp_get_worker (thread_index); + ASSERT (seq_geq (tc->snd_nxt, tc->snd_una)); + /* This still works if fast retransmit is on */ + sp->tx_offset = tc->snd_nxt - tc->snd_una; - tcp_set_time_now (wrk); - tw_timer_expire_timers_16t_2w_512sl (&wrk->timer_wheel, now); - tcp_do_fastretransmits (wrk); - tcp_send_acks (wrk); - tcp_flush_frames_to_output (wrk); -} + sp->flags = sp->snd_space ? 0 : TRANSPORT_SND_F_DESCHED; -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); + return 0; } 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, - .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, - .connect = tcp_session_open, - .close = tcp_session_close, - .cleanup = tcp_session_cleanup, - .send_mss = tcp_session_send_mss, - .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, - .tx_type = TRANSPORT_TX_PEEK, - .service_type = TRANSPORT_SERVICE_VC, -}; -/* *INDENT-ON* */ - -void -tcp_connection_tx_pacer_update (tcp_connection_t * tc) -{ - f64 srtt; - u64 rate; - - if (!transport_connection_is_tx_paced (&tc->connection)) - return; - - srtt = clib_min ((f64) tc->srtt * TCP_TICK, tc->mrtt_us); - /* TODO should constrain to interface's max throughput but - * we don't have link speeds for sw ifs ..*/ - rate = tc->cwnd / srtt; - transport_connection_tx_pacer_update (&tc->connection, rate); -} - -void -tcp_connection_tx_pacer_reset (tcp_connection_t * tc, u32 window, - u32 start_bucket) +tcp_timer_waitclose_handler (tcp_connection_t * tc) { tcp_worker_ctx_t *wrk = tcp_get_worker (tc->c_thread_index); - u32 byte_rate = window / ((f64) TCP_TICK * tc->srtt); - u64 last_time = wrk->vm->clib_time.last_cpu_time; - transport_connection_tx_pacer_reset (&tc->connection, byte_rate, - start_bucket, last_time); -} - -static void -tcp_timer_keep_handler (u32 conn_index) -{ - u32 thread_index = vlib_get_thread_index (); - tcp_connection_t *tc; - - tc = tcp_connection_get (conn_index, thread_index); - tc->timers[TCP_TIMER_KEEP] = TCP_TIMER_HANDLE_INVALID; - - tcp_connection_close (tc); -} - -static void -tcp_timer_establish_handler (u32 conn_index) -{ - tcp_connection_t *tc; - - 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); - tc->timers[TCP_TIMER_ESTABLISH] = TCP_TIMER_HANDLE_INVALID; - tcp_connection_set_state (tc, TCP_STATE_CLOSED); - /* Start cleanup. App wasn't notified yet so use delete notify as - * opposed to delete to cleanup session layer state. */ - tcp_connection_timers_reset (tc); - session_transport_delete_notify (&tc->connection); - tcp_timer_update (tc, TCP_TIMER_WAITCLOSE, TCP_CLEANUP_TIME); -} - -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 (), rto; - tcp_connection_t *tc; - - tc = tcp_connection_get (conn_index, thread_index); - if (!tc) - return; - tc->timers[TCP_TIMER_WAITCLOSE] = TCP_TIMER_HANDLE_INVALID; switch (tc->state) { case TCP_STATE_CLOSE_WAIT: tcp_connection_timers_reset (tc); - session_transport_closed_notify (&tc->connection); - + /* App never returned with a close */ if (!(tc->flags & TCP_CONN_FINPNDG)) { tcp_connection_set_state (tc, TCP_STATE_CLOSED); - tcp_timer_set (tc, TCP_TIMER_WAITCLOSE, TCP_CLEANUP_TIME); + session_transport_closed_notify (&tc->connection); + tcp_program_cleanup (wrk, tc); + tcp_worker_stats_inc (wrk, to_closewait, 1); break; } - /* Session didn't come back with a close. Send FIN either way - * and switch to LAST_ACK. */ + /* 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; + tc->snd_nxt = tc->snd_una; tcp_send_fin (tc); tcp_connection_set_state (tc, TCP_STATE_LAST_ACK); + session_transport_closed_notify (&tc->connection); /* Make sure we don't wait in LAST ACK forever */ - tcp_timer_set (tc, TCP_TIMER_WAITCLOSE, TCP_2MSL_TIME); + tcp_timer_set (&wrk->timer_wheel, tc, TCP_TIMER_WAITCLOSE, + tcp_cfg.lastack_time); + tcp_worker_stats_inc (wrk, to_closewait2, 1); /* Don't delete the connection yet */ break; @@ -1312,33 +1115,50 @@ tcp_timer_waitclose_handler (u32 conn_index) 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); + /* 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); + tcp_send_reset (tc); + tcp_program_cleanup (wrk, tc); } 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); + tcp_program_cleanup (wrk, tc); } + session_transport_closed_notify (&tc->connection); + tcp_worker_stats_inc (wrk, to_finwait1, 1); break; case TCP_STATE_LAST_ACK: + tcp_connection_timers_reset (tc); + tcp_connection_set_state (tc, TCP_STATE_CLOSED); + session_transport_closed_notify (&tc->connection); + tcp_program_cleanup (wrk, tc); + tcp_worker_stats_inc (wrk, to_lastack, 1); + break; 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); + tcp_program_cleanup (wrk, tc); + tcp_worker_stats_inc (wrk, to_closing, 1); + break; + case TCP_STATE_FIN_WAIT_2: + tcp_send_reset (tc); + tcp_connection_timers_reset (tc); + tcp_connection_set_state (tc, TCP_STATE_CLOSED); + session_transport_closed_notify (&tc->connection); + tcp_program_cleanup (wrk, tc); + tcp_worker_stats_inc (wrk, to_finwait2, 1); + break; + case TCP_STATE_TIME_WAIT: + tcp_connection_set_state (tc, TCP_STATE_CLOSED); + tcp_program_cleanup (wrk, tc); break; default: - tcp_connection_del (tc); + clib_warning ("waitclose in state: %U", format_tcp_state, tc->state); break; } } @@ -1347,47 +1167,203 @@ tcp_timer_waitclose_handler (u32 conn_index) static timer_expiration_handler *timer_expiration_handlers[TCP_N_TIMERS] = { tcp_timer_retransmit_handler, - tcp_timer_delack_handler, tcp_timer_persist_handler, - tcp_timer_keep_handler, tcp_timer_waitclose_handler, tcp_timer_retransmit_syn_handler, - tcp_timer_establish_handler, - tcp_timer_establish_ao_handler, }; /* *INDENT-ON* */ static void -tcp_expired_timers_dispatch (u32 * expired_timers) +tcp_dispatch_pending_timers (tcp_worker_ctx_t * wrk) { + u32 n_timers, connection_index, timer_id, thread_index, timer_handle; + tcp_connection_t *tc; int i; - u32 connection_index, timer_id; - for (i = 0; i < vec_len (expired_timers); i++) + if (!(n_timers = clib_fifo_elts (wrk->pending_timers))) + return; + + thread_index = wrk->vm->thread_index; + for (i = 0; i < clib_min (n_timers, wrk->max_timers_per_loop); i++) { - /* Get session index and timer id */ - connection_index = expired_timers[i] & 0x0FFFFFFF; - timer_id = expired_timers[i] >> 28; + clib_fifo_sub1 (wrk->pending_timers, timer_handle); + connection_index = timer_handle & 0x0FFFFFFF; + timer_id = timer_handle >> 28; + + if (PREDICT_TRUE (timer_id != TCP_TIMER_RETRANSMIT_SYN)) + tc = tcp_connection_get (connection_index, thread_index); + else + tc = tcp_half_open_connection_get (connection_index); + + if (PREDICT_FALSE (!tc)) + continue; + + /* Skip if the timer is not pending. Probably it was reset while + * waiting for dispatch */ + if (PREDICT_FALSE (!(tc->pending_timers & (1 << timer_id)))) + continue; + + tc->pending_timers &= ~(1 << timer_id); + + /* Skip timer if it was rearmed while pending dispatch */ + if (PREDICT_FALSE (tc->timers[timer_id] != TCP_TIMER_HANDLE_INVALID)) + continue; + + (*timer_expiration_handlers[timer_id]) (tc); + } + + if (thread_index == 0 && clib_fifo_elts (wrk->pending_timers)) + session_queue_run_on_main_thread (wrk->vm); +} - TCP_EVT_DBG (TCP_EVT_TIMER_POP, connection_index, timer_id); +static void +tcp_handle_cleanups (tcp_worker_ctx_t * wrk, clib_time_type_t now) +{ + u32 thread_index = wrk->vm->thread_index; + tcp_cleanup_req_t *req; + tcp_connection_t *tc; - /* Handle expiration */ - (*timer_expiration_handlers[timer_id]) (connection_index); + while (clib_fifo_elts (wrk->pending_cleanups)) + { + req = clib_fifo_head (wrk->pending_cleanups); + if (req->free_time > now) + break; + clib_fifo_sub2 (wrk->pending_cleanups, req); + tc = tcp_connection_get (req->connection_index, thread_index); + if (PREDICT_FALSE (!tc)) + continue; + session_transport_delete_notify (&tc->connection); + tcp_connection_cleanup (tc); } } static void -tcp_initialize_timer_wheels (tcp_main_t * tm) +tcp_update_time (f64 now, u8 thread_index) { - tw_timer_wheel_16t_2w_512sl_t *tw; - /* *INDENT-OFF* */ - foreach_vlib_main (({ - tw = &tm->wrk_ctx[ii].timer_wheel; - tw_timer_wheel_init_16t_2w_512sl (tw, tcp_expired_timers_dispatch, - 100e-3 /* timer period 100ms */ , ~0); - tw->last_run_time = vlib_time_now (this_vlib_main); - })); - /* *INDENT-ON* */ + tcp_worker_ctx_t *wrk = tcp_get_worker (thread_index); + + tcp_set_time_now (wrk, now); + tcp_handle_cleanups (wrk, now); + tcp_timer_expire_timers (&wrk->timer_wheel, now); + tcp_dispatch_pending_timers (wrk); +} + +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 + transport_max_tx_dequeue (tconn) - 1; +} + +/* *INDENT-OFF* */ +const static transport_proto_vft_t tcp_proto = { + .enable = vnet_tcp_enable_disable, + .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, + .attribute = tcp_session_attribute, + .connect = tcp_session_open, + .close = tcp_session_close, + .cleanup = tcp_session_cleanup, + .cleanup_ho = tcp_session_cleanup_ho, + .reset = tcp_session_reset, + .send_params = tcp_session_send_params, + .update_time = tcp_update_time, + .flush_data = tcp_session_flush_data, + .custom_tx = tcp_session_custom_tx, + .format_connection = format_tcp_session, + .format_listener = format_tcp_listener_session, + .format_half_open = format_tcp_half_open_session, + .transport_options = { + .name = "tcp", + .short_name = "T", + .tx_type = TRANSPORT_TX_PEEK, + .service_type = TRANSPORT_SERVICE_VC, + }, +}; +/* *INDENT-ON* */ + +void +tcp_connection_tx_pacer_update (tcp_connection_t * tc) +{ + if (!transport_connection_is_tx_paced (&tc->connection)) + return; + + f64 srtt = clib_min ((f64) tc->srtt * TCP_TICK, tc->mrtt_us); + + transport_connection_tx_pacer_update (&tc->connection, + tcp_cc_get_pacing_rate (tc), + srtt * CLIB_US_TIME_FREQ); +} + +void +tcp_connection_tx_pacer_reset (tcp_connection_t * tc, u32 window, + u32 start_bucket) +{ + f64 srtt = clib_min ((f64) tc->srtt * TCP_TICK, tc->mrtt_us); + transport_connection_tx_pacer_reset (&tc->connection, + tcp_cc_get_pacing_rate (tc), + start_bucket, + srtt * CLIB_US_TIME_FREQ); +} + +void +tcp_reschedule (tcp_connection_t * tc) +{ + if (tcp_in_cong_recovery (tc) || tcp_snd_space_inline (tc)) + transport_connection_reschedule (&tc->connection); +} + +static void +tcp_expired_timers_dispatch (u32 * expired_timers) +{ + u32 thread_index = vlib_get_thread_index (), n_left, max_per_loop; + u32 connection_index, timer_id, n_expired, max_loops; + tcp_worker_ctx_t *wrk; + tcp_connection_t *tc; + int i; + + wrk = tcp_get_worker (thread_index); + n_expired = vec_len (expired_timers); + tcp_worker_stats_inc (wrk, timer_expirations, n_expired); + n_left = clib_fifo_elts (wrk->pending_timers); + + /* + * Invalidate all timer handles before dispatching. This avoids dangling + * index references to timer wheel pool entries that have been freed. + */ + for (i = 0; i < n_expired; i++) + { + connection_index = expired_timers[i] & 0x0FFFFFFF; + timer_id = expired_timers[i] >> 28; + + if (timer_id != TCP_TIMER_RETRANSMIT_SYN) + tc = tcp_connection_get (connection_index, thread_index); + else + tc = tcp_half_open_connection_get (connection_index); + + TCP_EVT (TCP_EVT_TIMER_POP, connection_index, timer_id); + + tc->timers[timer_id] = TCP_TIMER_HANDLE_INVALID; + tc->pending_timers |= (1 << timer_id); + } + + clib_fifo_add (wrk->pending_timers, expired_timers, n_expired); + + max_loops = clib_max (1, 0.5 * TCP_TIMER_TICK * wrk->vm->loops_per_second); + max_per_loop = clib_max ((n_left + n_expired) / max_loops, 10); + max_per_loop = clib_min (max_per_loop, VLIB_FRAME_SIZE); + wrk->max_timers_per_loop = clib_max (n_left ? wrk->max_timers_per_loop : 0, + max_per_loop); + + if (thread_index == 0) + session_queue_run_on_main_thread (wrk->vm); } static void @@ -1407,6 +1383,7 @@ tcp_main_enable (vlib_main_t * vm) u32 num_threads, n_workers, prealloc_conn_per_wrk; tcp_connection_t *tc __attribute__ ((unused)); tcp_main_t *tm = vnet_get_tcp_main (); + tcp_worker_ctx_t *wrk; clib_error_t *error = 0; int thread; @@ -1429,57 +1406,68 @@ tcp_main_enable (vlib_main_t * vm) */ num_threads = 1 /* main thread */ + vtm->n_threads; - vec_validate (tm->connections, num_threads - 1); vec_validate (tm->wrk_ctx, num_threads - 1); n_workers = num_threads == 1 ? 1 : vtm->n_threads; - prealloc_conn_per_wrk = tm->preallocated_connections / n_workers; + prealloc_conn_per_wrk = tcp_cfg.preallocated_connections / n_workers; + + wrk = &tm->wrk_ctx[0]; + wrk->tco_next_node[0] = vlib_node_get_next (vm, session_queue_node.index, + tcp4_output_node.index); + wrk->tco_next_node[1] = vlib_node_get_next (vm, session_queue_node.index, + tcp6_output_node.index); for (thread = 0; thread < num_threads; thread++) { - vec_validate (tm->wrk_ctx[thread].pending_fast_rxt, 255); - vec_validate (tm->wrk_ctx[thread].ongoing_fast_rxt, 255); - 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]; + wrk = &tm->wrk_ctx[thread]; + + vec_validate (wrk->pending_deq_acked, 255); + vec_validate (wrk->pending_disconnects, 255); + vec_validate (wrk->pending_resets, 255); + vec_reset_length (wrk->pending_deq_acked); + vec_reset_length (wrk->pending_disconnects); + vec_reset_length (wrk->pending_resets); + wrk->vm = vlib_get_main_by_index (thread); + wrk->max_timers_per_loop = 10; + + if (thread > 0) + { + wrk->tco_next_node[0] = tm->wrk_ctx[0].tco_next_node[0]; + wrk->tco_next_node[1] = tm->wrk_ctx[0].tco_next_node[1]; + } /* * Preallocate connections. Assume that thread 0 won't * use preallocated threads when running multi-core */ if ((thread > 0 || num_threads == 1) && prealloc_conn_per_wrk) - pool_init_fixed (tm->connections[thread], prealloc_conn_per_wrk); + pool_init_fixed (wrk->connections, prealloc_conn_per_wrk); + + tcp_timer_initialize_wheel (&wrk->timer_wheel, + tcp_expired_timers_dispatch, + vlib_time_now (vm)); } /* * Use a preallocated half-open connection pool? */ - if (tm->preallocated_half_open_connections) + if (tcp_cfg.preallocated_half_open_connections) pool_init_fixed (tm->half_open_connections, - tm->preallocated_half_open_connections); - - /* Initialize clocks per tick for TCP timestamp. Used to compute - * monotonically increasing timestamps. */ - tm->tstamp_ticks_per_clock = vm->clib_time.seconds_per_clock - / TCP_TSTAMP_RESOLUTION; + tcp_cfg.preallocated_half_open_connections); if (num_threads > 1) { clib_spinlock_init (&tm->half_open_lock); } - tcp_initialize_timer_wheels (tm); tcp_initialize_iss_seed (tm); tm->bytes_per_buffer = vlib_buffer_get_default_data_size (vm); + tm->cc_last_type = TCP_CC_LAST; + tm->ipl_next_node[0] = vlib_node_get_next (vm, session_queue_node.index, + ip4_lookup_node.index); + tm->ipl_next_node[1] = vlib_node_get_next (vm, session_queue_node.index, + ip6_lookup_node.index); return error; } @@ -1511,6 +1499,39 @@ tcp_punt_unknown (vlib_main_t * vm, u8 is_ip4, u8 is_add) tm->punt_unknown6 = is_add; } +/** + * Initialize default values for tcp parameters + */ +static void +tcp_configuration_init (void) +{ + /* Initial wnd for SYN. Fifos are not allocated at that point so use some + * predefined value. For SYN-ACK we still want the scale to be computed in + * the same way */ + tcp_cfg.max_rx_fifo = 32 << 20; + tcp_cfg.min_rx_fifo = 4 << 10; + + tcp_cfg.default_mtu = 1500; + tcp_cfg.initial_cwnd_multiplier = 0; + tcp_cfg.enable_tx_pacing = 1; + tcp_cfg.allow_tso = 0; + tcp_cfg.csum_offload = 1; + tcp_cfg.cc_algo = TCP_CC_CUBIC; + tcp_cfg.rwnd_min_update_ack = 1; + tcp_cfg.max_gso_size = TCP_MAX_GSO_SZ; + + /* Time constants defined as timer tick (100us) multiples */ + tcp_cfg.closewait_time = 20000; /* 2s */ + tcp_cfg.timewait_time = 100000; /* 10s */ + tcp_cfg.finwait1_time = 600000; /* 60s */ + tcp_cfg.lastack_time = 300000; /* 30s */ + tcp_cfg.finwait2_time = 300000; /* 30s */ + tcp_cfg.closing_time = 300000; /* 30s */ + + /* This value is seconds */ + tcp_cfg.cleanup_time = 0.1; /* 100ms */ +} + static clib_error_t * tcp_init (vlib_main_t * vm) { @@ -1534,559 +1555,14 @@ tcp_init (vlib_main_t * vm) transport_register_protocol (TRANSPORT_PROTO_TCP, &tcp_proto, FIB_PROTOCOL_IP6, tcp6_output_node.index); - 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) -{ - tcp_main_t *tm = vnet_get_tcp_main (); - - while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) - { - if (unformat (input, "preallocated-connections %d", - &tm->preallocated_connections)) - ; - else if (unformat (input, "preallocated-half-open-connections %d", - &tm->preallocated_half_open_connections)) - ; - else if (unformat (input, "buffer-fail-fraction %f", - &tm->buffer_fail_fraction)) - ; - else if (unformat (input, "max-rx-fifo %U", unformat_memory_size, - &tm->max_rx_fifo)) - ; - 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); - } - return 0; -} - -VLIB_CONFIG_FUNCTION (tcp_config_fn, "tcp"); - - -/** - * \brief Configure an ipv4 source address range - * @param vm vlib_main_t pointer - * @param start first ipv4 address in the source address range - * @param end last ipv4 address in the source address range - * @param table_id VRF / table ID, 0 for the default FIB - * @return 0 if all OK, else an error indication from api_errno.h - */ - -int -tcp_configure_v4_source_address_range (vlib_main_t * vm, - ip4_address_t * start, - ip4_address_t * end, u32 table_id) -{ - tcp_main_t *tm = vnet_get_tcp_main (); - vnet_main_t *vnm = vnet_get_main (); - u32 start_host_byte_order, end_host_byte_order; - fib_prefix_t prefix; - vnet_sw_interface_t *si; - fib_node_index_t fei; - u32 fib_index = 0; - u32 sw_if_index; - int rv; - int vnet_proxy_arp_add_del (ip4_address_t * lo_addr, - ip4_address_t * hi_addr, u32 fib_index, - int is_del); - - clib_memset (&prefix, 0, sizeof (prefix)); - - fib_index = fib_table_find (FIB_PROTOCOL_IP4, table_id); - - if (fib_index == ~0) - return VNET_API_ERROR_NO_SUCH_FIB; - - start_host_byte_order = clib_net_to_host_u32 (start->as_u32); - end_host_byte_order = clib_net_to_host_u32 (end->as_u32); - - /* sanity check for reversed args or some such */ - if ((end_host_byte_order - start_host_byte_order) > (10 << 10)) - return VNET_API_ERROR_INVALID_ARGUMENT; - - /* Lookup the last address, to identify the interface involved */ - prefix.fp_len = 32; - prefix.fp_proto = FIB_PROTOCOL_IP4; - memcpy (&prefix.fp_addr.ip4, end, sizeof (ip4_address_t)); - - fei = fib_table_lookup (fib_index, &prefix); - - /* Couldn't find route to destination. Bail out. */ - if (fei == FIB_NODE_INDEX_INVALID) - return VNET_API_ERROR_NEXT_HOP_NOT_IN_FIB; - - sw_if_index = fib_entry_get_resolving_interface (fei); - - /* Enable proxy arp on the interface */ - si = vnet_get_sw_interface (vnm, sw_if_index); - si->flags |= VNET_SW_INTERFACE_FLAG_PROXY_ARP; - - /* Configure proxy arp across the range */ - rv = vnet_proxy_arp_add_del (start, end, fib_index, 0 /* is_del */ ); - - if (rv) - return rv; - - do - { - dpo_id_t dpo = DPO_INVALID; - - vec_add1 (tm->ip4_src_addresses, start[0]); - - /* Add local adjacencies for the range */ - - receive_dpo_add_or_lock (DPO_PROTO_IP4, ~0 /* sw_if_index */ , - NULL, &dpo); - prefix.fp_len = 32; - prefix.fp_proto = FIB_PROTOCOL_IP4; - prefix.fp_addr.ip4.as_u32 = start->as_u32; - - fib_table_entry_special_dpo_update (fib_index, - &prefix, - FIB_SOURCE_API, - FIB_ENTRY_FLAG_EXCLUSIVE, &dpo); - dpo_reset (&dpo); - - start_host_byte_order++; - start->as_u32 = clib_host_to_net_u32 (start_host_byte_order); - } - while (start_host_byte_order <= end_host_byte_order); - - return 0; -} - -/** - * \brief Configure an ipv6 source address range - * @param vm vlib_main_t pointer - * @param start first ipv6 address in the source address range - * @param end last ipv6 address in the source address range - * @param table_id VRF / table ID, 0 for the default FIB - * @return 0 if all OK, else an error indication from api_errno.h - */ - -int -tcp_configure_v6_source_address_range (vlib_main_t * vm, - ip6_address_t * start, - ip6_address_t * end, u32 table_id) -{ - tcp_main_t *tm = vnet_get_tcp_main (); - fib_prefix_t prefix; - u32 fib_index = 0; - fib_node_index_t fei; - u32 sw_if_index; - - clib_memset (&prefix, 0, sizeof (prefix)); - - fib_index = fib_table_find (FIB_PROTOCOL_IP6, table_id); - - if (fib_index == ~0) - return VNET_API_ERROR_NO_SUCH_FIB; - - while (1) - { - int i; - ip6_address_t tmp; - dpo_id_t dpo = DPO_INVALID; - - /* Remember this address */ - vec_add1 (tm->ip6_src_addresses, start[0]); - - /* Lookup the prefix, to identify the interface involved */ - prefix.fp_len = 128; - prefix.fp_proto = FIB_PROTOCOL_IP6; - memcpy (&prefix.fp_addr.ip6, start, sizeof (ip6_address_t)); - - fei = fib_table_lookup (fib_index, &prefix); - - /* Couldn't find route to destination. Bail out. */ - if (fei == FIB_NODE_INDEX_INVALID) - return VNET_API_ERROR_NEXT_HOP_NOT_IN_FIB; - - sw_if_index = fib_entry_get_resolving_interface (fei); - - if (sw_if_index == (u32) ~ 0) - return VNET_API_ERROR_NO_MATCHING_INTERFACE; + tcp_configuration_init (); - /* Add a proxy neighbor discovery entry for this address */ - ip6_neighbor_proxy_add_del (sw_if_index, start, 0 /* is_del */ ); + tm->cc_algo_by_name = hash_create_string (0, sizeof (uword)); - /* Add a receive adjacency for this address */ - receive_dpo_add_or_lock (DPO_PROTO_IP6, ~0 /* sw_if_index */ , - NULL, &dpo); - - fib_table_entry_special_dpo_update (fib_index, - &prefix, - FIB_SOURCE_API, - FIB_ENTRY_FLAG_EXCLUSIVE, &dpo); - dpo_reset (&dpo); - - /* Done with the entire range? */ - if (!memcmp (start, end, sizeof (start[0]))) - break; - - /* Increment the address. DGMS. */ - tmp = start[0]; - for (i = 15; i >= 0; i--) - { - tmp.as_u8[i] += 1; - if (tmp.as_u8[i] != 0) - break; - } - start[0] = tmp; - } - return 0; -} - -static clib_error_t * -tcp_src_address (vlib_main_t * vm, - unformat_input_t * input, vlib_cli_command_t * cmd_arg) -{ - ip4_address_t v4start, v4end; - ip6_address_t v6start, v6end; - u32 table_id = 0; - int v4set = 0; - int v6set = 0; - int rv; - - while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) - { - if (unformat (input, "%U - %U", unformat_ip4_address, &v4start, - unformat_ip4_address, &v4end)) - v4set = 1; - else if (unformat (input, "%U", unformat_ip4_address, &v4start)) - { - memcpy (&v4end, &v4start, sizeof (v4start)); - v4set = 1; - } - else if (unformat (input, "%U - %U", unformat_ip6_address, &v6start, - unformat_ip6_address, &v6end)) - v6set = 1; - else if (unformat (input, "%U", unformat_ip6_address, &v6start)) - { - memcpy (&v6end, &v6start, sizeof (v6start)); - v6set = 1; - } - else if (unformat (input, "fib-table %d", &table_id)) - ; - else - break; - } - - if (!v4set && !v6set) - return clib_error_return (0, "at least one v4 or v6 address required"); - - if (v4set) - { - rv = tcp_configure_v4_source_address_range (vm, &v4start, &v4end, - table_id); - switch (rv) - { - case 0: - break; - - case VNET_API_ERROR_NO_SUCH_FIB: - return clib_error_return (0, "Invalid table-id %d", table_id); - - case VNET_API_ERROR_INVALID_ARGUMENT: - return clib_error_return (0, "Invalid address range %U - %U", - format_ip4_address, &v4start, - format_ip4_address, &v4end); - default: - return clib_error_return (0, "error %d", rv); - break; - } - } - if (v6set) - { - rv = tcp_configure_v6_source_address_range (vm, &v6start, &v6end, - table_id); - switch (rv) - { - case 0: - break; - - case VNET_API_ERROR_NO_SUCH_FIB: - return clib_error_return (0, "Invalid table-id %d", table_id); - - default: - return clib_error_return (0, "error %d", rv); - break; - } - } - return 0; -} - -/* *INDENT-OFF* */ -VLIB_CLI_COMMAND (tcp_src_address_command, static) = -{ - .path = "tcp src-address", - .short_help = "tcp src-address [- ] add src address range", - .function = tcp_src_address, -}; -/* *INDENT-ON* */ - -static u8 * -tcp_scoreboard_dump_trace (u8 * s, sack_scoreboard_t * sb) -{ -#if TCP_SCOREBOARD_TRACE - - scoreboard_trace_elt_t *block; - int i = 0; - - if (!sb->trace) - return s; - - s = format (s, "scoreboard trace:"); - vec_foreach (block, sb->trace) - { - s = format (s, "{%u, %u, %u, %u, %u}, ", block->start, block->end, - block->ack, block->snd_una_max, block->group); - if ((++i % 3) == 0) - s = format (s, "\n"); - } - return s; -#else return 0; -#endif } -static clib_error_t * -tcp_show_scoreboard_trace_fn (vlib_main_t * vm, unformat_input_t * input, - vlib_cli_command_t * cmd_arg) -{ - transport_connection_t *tconn = 0; - tcp_connection_t *tc; - u8 *s = 0; - while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) - { - if (unformat (input, "%U", unformat_transport_connection, &tconn, - TRANSPORT_PROTO_TCP)) - ; - else - return clib_error_return (0, "unknown input `%U'", - format_unformat_error, input); - } - - if (!TCP_SCOREBOARD_TRACE) - { - vlib_cli_output (vm, "scoreboard tracing not enabled"); - return 0; - } - - tc = tcp_get_connection_from_transport (tconn); - s = tcp_scoreboard_dump_trace (s, &tc->sack_sb); - vlib_cli_output (vm, "%v", s); - return 0; -} - -/* *INDENT-OFF* */ -VLIB_CLI_COMMAND (tcp_show_scoreboard_trace_command, static) = -{ - .path = "show tcp scoreboard trace", - .short_help = "show tcp scoreboard trace ", - .function = tcp_show_scoreboard_trace_fn, -}; -/* *INDENT-ON* */ - -u8 * -tcp_scoreboard_replay (u8 * s, tcp_connection_t * tc, u8 verbose) -{ - int i, trace_len; - scoreboard_trace_elt_t *trace; - u32 next_ack, left, group, has_new_ack = 0; - tcp_connection_t _dummy_tc, *dummy_tc = &_dummy_tc; - sack_block_t *block; - - if (!TCP_SCOREBOARD_TRACE) - { - s = format (s, "scoreboard tracing not enabled"); - return s; - } - - if (!tc) - return s; - - clib_memset (dummy_tc, 0, sizeof (*dummy_tc)); - tcp_connection_timers_init (dummy_tc); - scoreboard_init (&dummy_tc->sack_sb); - dummy_tc->rcv_opts.flags |= TCP_OPTS_FLAG_SACK; - -#if TCP_SCOREBOARD_TRACE - trace = tc->sack_sb.trace; - trace_len = vec_len (tc->sack_sb.trace); -#endif - - for (i = 0; i < trace_len; i++) - { - if (trace[i].ack != 0) - { - dummy_tc->snd_una = trace[i].ack - 1448; - dummy_tc->snd_una_max = trace[i].ack; - } - } - - left = 0; - while (left < trace_len) - { - group = trace[left].group; - vec_reset_length (dummy_tc->rcv_opts.sacks); - has_new_ack = 0; - while (trace[left].group == group) - { - if (trace[left].ack != 0) - { - if (verbose) - s = format (s, "Adding ack %u, snd_una_max %u, segs: ", - trace[left].ack, trace[left].snd_una_max); - dummy_tc->snd_una_max = trace[left].snd_una_max; - next_ack = trace[left].ack; - has_new_ack = 1; - } - else - { - if (verbose) - s = format (s, "[%u, %u], ", trace[left].start, - trace[left].end); - vec_add2 (dummy_tc->rcv_opts.sacks, block, 1); - block->start = trace[left].start; - block->end = trace[left].end; - } - left++; - } - - /* Push segments */ - tcp_rcv_sacks (dummy_tc, next_ack); - if (has_new_ack) - dummy_tc->snd_una = next_ack + dummy_tc->sack_sb.snd_una_adv; - - if (verbose) - s = format (s, "result: %U", format_tcp_scoreboard, - &dummy_tc->sack_sb); - - } - s = format (s, "result: %U", format_tcp_scoreboard, &dummy_tc->sack_sb); - - return s; -} - -static clib_error_t * -tcp_scoreboard_trace_fn (vlib_main_t * vm, unformat_input_t * input, - vlib_cli_command_t * cmd_arg) -{ - transport_connection_t *tconn = 0; - tcp_connection_t *tc = 0; - u8 *str = 0; - while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) - { - if (unformat (input, "%U", unformat_transport_connection, &tconn, - TRANSPORT_PROTO_TCP)) - ; - else - return clib_error_return (0, "unknown input `%U'", - format_unformat_error, input); - } - - if (!TCP_SCOREBOARD_TRACE) - { - vlib_cli_output (vm, "scoreboard tracing not enabled"); - return 0; - } - - tc = tcp_get_connection_from_transport (tconn); - if (!tc) - { - vlib_cli_output (vm, "connection not found"); - return 0; - } - str = tcp_scoreboard_replay (str, tc, 1); - vlib_cli_output (vm, "%v", str); - return 0; -} - -/* *INDENT-OFF* */ -VLIB_CLI_COMMAND (tcp_replay_scoreboard_command, static) = -{ - .path = "tcp replay scoreboard", - .short_help = "tcp replay scoreboard ", - .function = tcp_scoreboard_trace_fn, -}; -/* *INDENT-ON* */ - -static clib_error_t * -show_tcp_punt_fn (vlib_main_t * vm, unformat_input_t * input, - vlib_cli_command_t * cmd_arg) -{ - tcp_main_t *tm = vnet_get_tcp_main (); - if (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) - return clib_error_return (0, "unknown input `%U'", format_unformat_error, - input); - vlib_cli_output (vm, "IPv4 TCP punt: %s", - tm->punt_unknown4 ? "enabled" : "disabled"); - vlib_cli_output (vm, "IPv6 TCP punt: %s", - tm->punt_unknown6 ? "enabled" : "disabled"); - return 0; -} -/* *INDENT-OFF* */ -VLIB_CLI_COMMAND (show_tcp_punt_command, static) = -{ - .path = "show tcp punt", - .short_help = "show tcp punt", - .function = show_tcp_punt_fn, -}; -/* *INDENT-ON* */ +VLIB_INIT_FUNCTION (tcp_init); /* * fd.io coding-style-patch-verification: ON