X-Git-Url: https://gerrit.fd.io/r/gitweb?a=blobdiff_plain;f=src%2Fvnet%2Ftcp%2Ftcp.c;h=915675c11ed654ac36167ed2905740a522c2306d;hb=cbe25aab3be72154f2c706c39eeba6a77f34450f;hp=5090b7dd2d777dc24142928c61e6b704a0c58a19;hpb=5bb23ecd098eac639641e2b3d62eb8744e0efef0;p=vpp.git diff --git a/src/vnet/tcp/tcp.c b/src/vnet/tcp/tcp.c index 5090b7dd2d7..915675c11ed 100644 --- a/src/vnet/tcp/tcp.c +++ b/src/vnet/tcp/tcp.c @@ -23,9 +23,8 @@ #include #include #include -#include +#include #include -#include tcp_main_t tcp_main; @@ -192,9 +191,9 @@ 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) clib_memset (tc, 0xFA, sizeof (*tc)); + pool_put (tm->half_open_connections, tc); clib_spinlock_unlock_if_init (&tm->half_open_lock); } @@ -268,8 +267,10 @@ tcp_connection_cleanup (tcp_connection_t * 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->flags & TCP_CONN_RATE_SAMPLE) + if (tc->cfg_flags & TCP_CFG_F_RATE_SAMPLE) tcp_bt_cleanup (tc); /* Poison the entry */ @@ -358,6 +359,7 @@ tcp_connection_reset (tcp_connection_t * tc) * cleanly close the connection */ tcp_timer_set (tc, TCP_TIMER_WAITCLOSE, tcp_cfg.closewait_time); session_transport_reset_notify (&tc->connection); + tcp_cong_recovery_off (tc); tcp_connection_set_state (tc, TCP_STATE_CLOSED); session_transport_closed_notify (&tc->connection); break; @@ -368,6 +370,7 @@ tcp_connection_reset (tcp_connection_t * tc) case TCP_STATE_LAST_ACK: tcp_connection_timers_reset (tc); tcp_timer_set (tc, TCP_TIMER_WAITCLOSE, tcp_cfg.closewait_time); + tcp_cong_recovery_off (tc); /* Make sure we mark the session as closed. In some states we may * be still trying to send data */ tcp_connection_set_state (tc, TCP_STATE_CLOSED); @@ -473,6 +476,8 @@ 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); } @@ -485,6 +490,7 @@ tcp_session_reset (u32 conn_index, u32 thread_index) session_transport_closed_notify (&tc->connection); tcp_send_reset (tc); tcp_connection_timers_reset (tc); + tcp_cong_recovery_off (tc); tcp_connection_set_state (tc, TCP_STATE_CLOSED); tcp_timer_update (tc, TCP_TIMER_WAITCLOSE, tcp_cfg.cleanup_time); } @@ -697,17 +703,18 @@ tcp_init_snd_vars (tcp_connection_t * tc) tc->snd_una = tc->iss; tc->snd_nxt = tc->iss + 1; tc->snd_una_max = tc->snd_nxt; - tc->srtt = 0; + tc->srtt = 100; /* 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; } @@ -721,10 +728,11 @@ 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); @@ -734,9 +742,12 @@ tcp_connection_init_vars (tcp_connection_t * tc) || tcp_cfg.enable_tx_pacing) tcp_enable_pacing (tc); - if (tc->flags & TCP_CONN_RATE_SAMPLE) + 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); } @@ -836,6 +847,31 @@ format_tcp_state (u8 * s, va_list * args) return s; } +const char *tcp_cfg_flags_str[] = { +#define _(sym, str) str, + foreach_tcp_cfg_flag +#undef _ +}; + +static u8 * +format_tcp_cfg_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_CFG_N_FLAG_BITS; i++) + if (tc->cfg_flags & (1 << i)) + last = i; + for (i = 0; i < last; i++) + { + if (tc->cfg_flags & (1 << i)) + s = format (s, "%s, ", tcp_cfg_flags_str[i]); + } + if (last >= 0) + s = format (s, "%s", tcp_cfg_flags_str[last]); + return s; +} + const char *tcp_connection_flags_str[] = { #define _(sym, str) str, foreach_tcp_connection_flag @@ -912,17 +948,26 @@ 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); + u32 indent = format_get_indent (s), prr_space = 0; s = format (s, "%U ", format_tcp_congestion_status, tc); 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", + s = format (s, "%Ucc space %u prev_cwnd %u prev_ssthresh %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", + tc->prev_cwnd, tc->prev_ssthresh); + s = format (s, "%Usnd_cong %u dupack %u limited_tx %u\n", format_white_space, indent, tc->snd_congestion - tc->iss, tc->rcv_dupacks, tc->limited_transmit - tc->iss); + s = format (s, "%Urxt_bytes %u rxt_delivered %u rxt_head %u rxt_ts %u\n", + format_white_space, indent, tc->snd_rxt_bytes, + tc->rxt_delivered, tc->rxt_head - tc->iss, + tcp_time_now_w_thread (tc->c_thread_index) - tc->snd_rxt_ts); + if (tcp_in_fastrecovery (tc)) + prr_space = tcp_fastrecovery_prr_snd_space (tc); + s = format (s, "%Uprr_start %u prr_delivered %u prr space %u\n", + format_white_space, indent, tc->prr_start - tc->iss, + tc->prr_delivered, prr_space); return s; } @@ -951,8 +996,9 @@ 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, " index: %u cfg: %U flags: %U timers: %U\n", tc->c_c_index, + format_tcp_cfg_flags, tc, 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); @@ -974,6 +1020,8 @@ format_tcp_vars (u8 * s, va_list * args) 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, " next_node %u opaque 0x%x\n", tc->next_node_index, + tc->next_node_opaque); s = format (s, " cong: %U", format_tcp_congestion, tc); if (tc->state >= TCP_STATE_ESTABLISHED) @@ -1137,11 +1185,13 @@ format_tcp_scoreboard (u8 * s, va_list * args) 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", + s = format (s, "sacked %u last_sacked %u lost %u last_lost %u" + " rxt_sacked %u\n", + sb->sacked_bytes, sb->last_sacked_bytes, sb->lost_bytes, + sb->last_lost_bytes, sb->rxt_sacked); + s = format (s, "%Ulast_delivered %u high_sacked %u is_reneging %u\n", format_white_space, indent, sb->last_bytes_delivered, - sb->high_sacked - tc->iss, sb->snd_una_adv); + sb->high_sacked - tc->iss, sb->is_reneging); 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); @@ -1177,6 +1227,17 @@ tcp_half_open_session_get_transport (u32 conn_index) return &tc->connection; } +static u16 +tcp_session_cal_goal_size (tcp_connection_t * tc) +{ + u16 goal_size = tc->snd_mss; + + goal_size = TCP_MAX_GSO_SZ - tc->snd_mss % TCP_MAX_GSO_SZ; + goal_size = clib_min (goal_size, tc->snd_wnd / 2); + + return goal_size > tc->snd_mss ? goal_size : tc->snd_mss; +} + /** * Compute maximum segment size for session layer. * @@ -1194,6 +1255,9 @@ tcp_session_send_mss (transport_connection_t * trans_conn) * the current state of the connection. */ tcp_update_burst_snd_vars (tc); + if (PREDICT_FALSE (tc->cfg_flags & TCP_CFG_F_TSO)) + return tcp_session_cal_goal_size (tc); + return tc->snd_mss; } @@ -1227,7 +1291,7 @@ 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) || tc->state == TCP_STATE_CLOSED)) @@ -1235,18 +1299,21 @@ tcp_snd_space_inline (tcp_connection_t * tc) 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 != 0 || tc->sack_sb.sacked_bytes)) { - if (tc->rcv_dupacks == 1 && tc->limited_transmit != tc->snd_nxt) + if (tc->limited_transmit != tc->snd_nxt + && (seq_lt (tc->limited_transmit, tc->snd_nxt - 2 * 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); + int snt_limited = tc->snd_nxt - tc->limited_transmit; + snd_space = clib_max ((int) 2 * tc->snd_mss - snt_limited, 0); } return tcp_round_snd_space (tc, snd_space); } @@ -1331,33 +1398,33 @@ 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)); + 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) { - 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); + 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); } static void -tcp_timer_waitclose_handler (u32 conn_index) +tcp_timer_waitclose_handler (u32 conn_index, u32 thread_index) { - u32 thread_index = vlib_get_thread_index (); 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: @@ -1430,19 +1497,38 @@ static timer_expiration_handler *timer_expiration_handlers[TCP_N_TIMERS] = static void tcp_expired_timers_dispatch (u32 * expired_timers) { - int i; + u32 thread_index = vlib_get_thread_index (); u32 connection_index, timer_id; + tcp_connection_t *tc; + int i; + /* + * Invalidate all timer handles before dispatching. This avoids dangling + * index references to timer wheel pool entries that have been freed. + */ for (i = 0; i < vec_len (expired_timers); i++) { - /* Get session index and timer id */ 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); - /* Handle expiration */ - (*timer_expiration_handlers[timer_id]) (connection_index); + tc->timers[timer_id] = TCP_TIMER_HANDLE_INVALID; + } + + /* + * Dispatch expired timers + */ + for (i = 0; i < vec_len (expired_timers); i++) + { + connection_index = expired_timers[i] & 0x0FFFFFFF; + timer_id = expired_timers[i] >> 28; + (*timer_expiration_handlers[timer_id]) (connection_index, thread_index); } } @@ -1588,6 +1674,8 @@ tcp_configuration_init (void) 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_NEWRENO; tcp_cfg.rwnd_min_update_ack = 1; @@ -1681,7 +1769,9 @@ unformat_tcp_cc_algo_cfg (unformat_input_t * input, va_list * va) static clib_error_t * tcp_config_fn (vlib_main_t * vm, unformat_input_t * input) { + u32 cwnd_multiplier, tmp_time; uword memory_size; + while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) { if (unformat (input, "preallocated-connections %d", @@ -1695,39 +1785,59 @@ tcp_config_fn (vlib_main_t * vm, unformat_input_t * input) ; else if (unformat (input, "max-rx-fifo %U", unformat_memory_size, &memory_size)) - tcp_cfg.max_rx_fifo = memory_size; + { + if (memory_size >= 0x100000000) + { + return clib_error_return + (0, "max-rx-fifo %llu (0x%llx) too large", memory_size, + memory_size); + } + tcp_cfg.max_rx_fifo = memory_size; + } else if (unformat (input, "min-rx-fifo %U", unformat_memory_size, &memory_size)) - tcp_cfg.min_rx_fifo = memory_size; + { + if (memory_size >= 0x100000000) + { + return clib_error_return + (0, "min-rx-fifo %llu (0x%llx) too large", memory_size, + memory_size); + } + tcp_cfg.min_rx_fifo = memory_size; + } else if (unformat (input, "mtu %u", &tcp_cfg.default_mtu)) ; else if (unformat (input, "rwnd-min-update-ack %d", &tcp_cfg.rwnd_min_update_ack)) ; else if (unformat (input, "initial-cwnd-multiplier %u", - &tcp_cfg.initial_cwnd_multiplier)) - ; + &cwnd_multiplier)) + tcp_cfg.initial_cwnd_multiplier = cwnd_multiplier; else if (unformat (input, "no-tx-pacing")) tcp_cfg.enable_tx_pacing = 0; + else if (unformat (input, "tso")) + tcp_cfg.allow_tso = 1; + else if (unformat (input, "no-csum-offload")) + tcp_cfg.csum_offload = 0; else if (unformat (input, "cc-algo %U", unformat_tcp_cc_algo, &tcp_cfg.cc_algo)) ; else if (unformat (input, "%U", unformat_tcp_cc_algo_cfg)) ; - else if (unformat (input, "closewait-time %u", &tcp_cfg.closewait_time)) - tcp_cfg.closewait_time /= TCP_TIMER_TICK; - else if (unformat (input, "timewait-time %u", &tcp_cfg.timewait_time)) - tcp_cfg.timewait_time /= TCP_TIMER_TICK; - else if (unformat (input, "finwait1-time %u", &tcp_cfg.finwait1_time)) - tcp_cfg.finwait1_time /= TCP_TIMER_TICK; - else if (unformat (input, "finwait2-time %u", &tcp_cfg.finwait2_time)) - tcp_cfg.finwait2_time /= TCP_TIMER_TICK; - else if (unformat (input, "lastack-time %u", &tcp_cfg.lastack_time)) - tcp_cfg.lastack_time /= TCP_TIMER_TICK; - else if (unformat (input, "closing-time %u", &tcp_cfg.closing_time)) - tcp_cfg.closing_time /= TCP_TIMER_TICK; - else if (unformat (input, "cleanup-time %u", &tcp_cfg.cleanup_time)) - tcp_cfg.cleanup_time /= TCP_TIMER_TICK; + else if (unformat (input, "closewait-time %u", &tmp_time)) + tcp_cfg.closewait_time = tmp_time / TCP_TIMER_TICK; + else if (unformat (input, "timewait-time %u", &tmp_time)) + tcp_cfg.timewait_time = tmp_time / TCP_TIMER_TICK; + else if (unformat (input, "finwait1-time %u", &tmp_time)) + tcp_cfg.finwait1_time = tmp_time / TCP_TIMER_TICK; + else if (unformat (input, "finwait2-time %u", &tmp_time)) + tcp_cfg.finwait2_time = tmp_time / TCP_TIMER_TICK; + else if (unformat (input, "lastack-time %u", &tmp_time)) + tcp_cfg.lastack_time = tmp_time / TCP_TIMER_TICK; + else if (unformat (input, "closing-time %u", &tmp_time)) + tcp_cfg.closing_time = tmp_time / TCP_TIMER_TICK; + else if (unformat (input, "cleanup-time %u", &tmp_time)) + tcp_cfg.cleanup_time = tmp_time / TCP_TIMER_TICK; else return clib_error_return (0, "unknown input `%U'", format_unformat_error, input); @@ -1752,7 +1862,6 @@ tcp_configure_v4_source_address_range (vlib_main_t * vm, ip4_address_t * start, ip4_address_t * end, u32 table_id) { - vnet_main_t *vnm = vnet_get_main (); u32 start_host_byte_order, end_host_byte_order; fib_prefix_t prefix; fib_node_index_t fei; @@ -1788,12 +1897,12 @@ tcp_configure_v4_source_address_range (vlib_main_t * vm, sw_if_index = fib_entry_get_resolving_interface (fei); /* Configure proxy arp across the range */ - rv = vnet_proxy_arp_add_del (start, end, fib_index, 0 /* is_del */ ); + rv = ip4_neighbor_proxy_add (fib_index, start, end); if (rv) return rv; - rv = vnet_proxy_arp_enable_disable (vnm, sw_if_index, 1); + rv = ip4_neighbor_proxy_enable (sw_if_index); if (rv) return rv; @@ -1878,7 +1987,7 @@ tcp_configure_v6_source_address_range (vlib_main_t * vm, return VNET_API_ERROR_NO_MATCHING_INTERFACE; /* Add a proxy neighbor discovery entry for this address */ - ip6_neighbor_proxy_add_del (sw_if_index, start, 0 /* is_del */ ); + ip6_neighbor_proxy_add (sw_if_index, start); /* Add a receive adjacency for this address */ receive_dpo_add_or_lock (DPO_PROTO_IP6, ~0 /* sw_if_index */ , @@ -2127,7 +2236,7 @@ tcp_scoreboard_replay (u8 * s, tcp_connection_t * tc, u8 verbose) /* 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; + dummy_tc->snd_una = next_ack; if (verbose) s = format (s, "result: %U", format_tcp_scoreboard,