X-Git-Url: https://gerrit.fd.io/r/gitweb?a=blobdiff_plain;f=src%2Fvnet%2Ftcp%2Ftcp.c;h=ea350dddc69c6ad10bdcd090948acc27dff68537;hb=7ac053b27fee8f9e437cf7b61357943356381061;hp=8d222e3c684b5fa181c4de95e0eefffa41b871b5;hpb=561af9b441c7392cf391dd46399b0b16b876a08a;p=vpp.git diff --git a/src/vnet/tcp/tcp.c b/src/vnet/tcp/tcp.c index 8d222e3c684..ea350dddc69 100644 --- a/src/vnet/tcp/tcp.c +++ b/src/vnet/tcp/tcp.c @@ -28,6 +28,47 @@ tcp_main_t tcp_main; +typedef struct +{ + fib_protocol_t nh_proto; + vnet_link_t link_type; + ip46_address_t ip; + u32 sw_if_index; + u8 is_add; +} tcp_add_del_adj_args_t; + +static void +tcp_add_del_adj_cb (tcp_add_del_adj_args_t * args) +{ + u32 ai; + if (args->is_add) + { + adj_nbr_add_or_lock (args->nh_proto, args->link_type, &args->ip, + args->sw_if_index); + } + else + { + ai = adj_nbr_find (FIB_PROTOCOL_IP6, VNET_LINK_IP6, &args->ip, + args->sw_if_index); + if (ai != ADJ_INDEX_INVALID) + adj_unlock (ai); + } +} + +static void +tcp_add_del_adjacency (tcp_connection_t * tc, u8 is_add) +{ + tcp_add_del_adj_args_t args = { + .nh_proto = FIB_PROTOCOL_IP6, + .link_type = VNET_LINK_IP6, + .ip = tc->c_rmt_ip, + .sw_if_index = tc->sw_if_index, + .is_add = is_add + }; + vlib_rpc_call_main_thread (tcp_add_del_adj_cb, (u8 *) & args, + sizeof (args)); +} + static u32 tcp_connection_bind (u32 session_index, transport_endpoint_t * lcl) { @@ -36,7 +77,7 @@ tcp_connection_bind (u32 session_index, transport_endpoint_t * lcl) void *iface_ip; pool_get (tm->listener_pool, listener); - memset (listener, 0, sizeof (*listener)); + clib_memset (listener, 0, sizeof (*listener)); listener->c_c_index = listener - tm->listener_pool; listener->c_lcl_port = lcl->port; @@ -62,7 +103,7 @@ tcp_connection_bind (u32 session_index, transport_endpoint_t * lcl) return listener->c_c_index; } -u32 +static u32 tcp_session_bind (u32 session_index, transport_endpoint_t * tep) { return tcp_connection_bind (session_index, tep); @@ -80,19 +121,19 @@ tcp_connection_unbind (u32 listener_index) /* Poison the entry */ if (CLIB_DEBUG > 0) - memset (tc, 0xFA, sizeof (*tc)); + clib_memset (tc, 0xFA, sizeof (*tc)); pool_put_index (tm->listener_pool, listener_index); } -u32 +static u32 tcp_session_unbind (u32 listener_index) { tcp_connection_unbind (listener_index); return 0; } -transport_connection_t * +static transport_connection_t * tcp_session_get_listener (u32 listener_index) { tcp_main_t *tm = vnet_get_tcp_main (); @@ -105,14 +146,14 @@ tcp_session_get_listener (u32 listener_index) * Cleanup half-open connection * */ -void +static void tcp_half_open_connection_del (tcp_connection_t * tc) { tcp_main_t *tm = vnet_get_tcp_main (); clib_spinlock_lock_if_init (&tm->half_open_lock); pool_put_index (tm->half_open_connections, tc->c_c_index); if (CLIB_DEBUG) - memset (tc, 0xFA, sizeof (*tc)); + clib_memset (tc, 0xFA, sizeof (*tc)); clib_spinlock_unlock_if_init (&tm->half_open_lock); } @@ -137,14 +178,14 @@ tcp_half_open_connection_cleanup (tcp_connection_t * tc) return 0; } -tcp_connection_t * +static tcp_connection_t * tcp_half_open_connection_new (void) { tcp_main_t *tm = vnet_get_tcp_main (); tcp_connection_t *tc = 0; ASSERT (vlib_get_thread_index () == 0); pool_get (tm->half_open_connections, tc); - memset (tc, 0, sizeof (*tc)); + clib_memset (tc, 0, sizeof (*tc)); tc->c_c_index = tc - tm->half_open_connections; return tc; } @@ -169,7 +210,8 @@ tcp_connection_cleanup (tcp_connection_t * tc) /* Try to remove the half-open connection. If this is not the owning * thread, tc won't be removed. Retransmit or establish timers will * eventually expire and call again cleanup on the right thread. */ - tcp_half_open_connection_cleanup (tc); + if (tcp_half_open_connection_cleanup (tc)) + tc->flags |= TCP_CONN_HALF_OPEN_DONE; } else { @@ -178,9 +220,12 @@ tcp_connection_cleanup (tcp_connection_t * tc) /* 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) - memset (tc, 0xFA, sizeof (*tc)); + clib_memset (tc, 0xFA, sizeof (*tc)); pool_put (tm->connections[thread_index], tc); } } @@ -207,7 +252,7 @@ tcp_connection_new (u8 thread_index) tcp_connection_t *tc; pool_get (tm->connections[thread_index], tc); - memset (tc, 0, sizeof (*tc)); + clib_memset (tc, 0, sizeof (*tc)); tc->c_c_index = tc - tm->connections[thread_index]; tc->c_thread_index = thread_index; return tc; @@ -233,19 +278,19 @@ tcp_connection_reset (tcp_connection_t * tc) 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_update (tc, TCP_TIMER_WAITCLOSE, TCP_CLEANUP_TIME); stream_session_reset_notify (&tc->connection); - /* fall through */ + break; case TCP_STATE_CLOSE_WAIT: case TCP_STATE_FIN_WAIT_1: case TCP_STATE_FIN_WAIT_2: case TCP_STATE_CLOSING: tc->state = TCP_STATE_CLOSED; TCP_EVT_DBG (TCP_EVT_STATE_CHANGE, tc); - - /* Make sure all timers are cleared */ tcp_connection_timers_reset (tc); - - /* Wait for cleanup from session layer but not forever */ tcp_timer_update (tc, TCP_TIMER_WAITCLOSE, TCP_CLEANUP_TIME); break; case TCP_STATE_CLOSED: @@ -278,21 +323,28 @@ tcp_connection_close (tcp_connection_t * tc) tc->state = TCP_STATE_CLOSED; break; case TCP_STATE_SYN_RCVD: + tcp_connection_timers_reset (tc); tcp_send_fin (tc); tc->state = TCP_STATE_FIN_WAIT_1; + tcp_timer_update (tc, TCP_TIMER_WAITCLOSE, TCP_CLEANUP_TIME); break; case TCP_STATE_ESTABLISHED: - if (!stream_session_tx_fifo_max_dequeue (&tc->connection)) + if (!session_tx_fifo_max_dequeue (&tc->connection)) tcp_send_fin (tc); else tc->flags |= TCP_CONN_FINPNDG; tc->state = TCP_STATE_FIN_WAIT_1; break; case TCP_STATE_CLOSE_WAIT: - tcp_connection_timers_reset (tc); - tcp_send_fin (tc); - tc->state = TCP_STATE_LAST_ACK; - tcp_timer_update (tc, TCP_TIMER_WAITCLOSE, TCP_2MSL_TIME); + if (!session_tx_fifo_max_dequeue (&tc->connection)) + { + tcp_send_fin (tc); + tcp_connection_timers_reset (tc); + tc->state = TCP_STATE_LAST_ACK; + tcp_timer_update (tc, TCP_TIMER_WAITCLOSE, TCP_2MSL_TIME); + } + else + tc->flags |= TCP_CONN_FINPNDG; break; case TCP_STATE_FIN_WAIT_1: tcp_timer_update (tc, TCP_TIMER_WAITCLOSE, TCP_2MSL_TIME); @@ -309,7 +361,7 @@ tcp_connection_close (tcp_connection_t * tc) tcp_connection_del (tc); } -void +static void tcp_session_close (u32 conn_index, u32 thread_index) { tcp_connection_t *tc; @@ -317,17 +369,15 @@ tcp_session_close (u32 conn_index, u32 thread_index) tcp_connection_close (tc); } -void +static void tcp_session_cleanup (u32 conn_index, u32 thread_index) { tcp_connection_t *tc; tc = tcp_connection_get (conn_index, thread_index); tcp_connection_timers_reset (tc); - - /* Wait for the session tx events to clear */ tc->state = TCP_STATE_CLOSED; TCP_EVT_DBG (TCP_EVT_STATE_CHANGE, tc); - tcp_timer_update (tc, TCP_TIMER_WAITCLOSE, TCP_CLEANUP_TIME); + tcp_connection_cleanup (tc); } /** @@ -385,7 +435,7 @@ tcp_connection_select_lb_bucket (tcp_connection_t * tc, const dpo_id_t * dpo, if (tc->c_is_ip4) { ip4_tcp_hdr_t hdr; - memset (&hdr, 0, sizeof (hdr)); + clib_memset (&hdr, 0, sizeof (hdr)); hdr.ip.protocol = IP_PROTOCOL_TCP; hdr.ip.address_pair.src.as_u32 = tc->c_lcl_ip.ip4.as_u32; hdr.ip.address_pair.dst.as_u32 = tc->c_rmt_ip.ip4.as_u32; @@ -396,7 +446,7 @@ tcp_connection_select_lb_bucket (tcp_connection_t * tc, const dpo_id_t * dpo, else { ip6_tcp_hdr_t hdr; - memset (&hdr, 0, sizeof (hdr)); + clib_memset (&hdr, 0, sizeof (hdr)); hdr.ip.protocol = IP_PROTOCOL_TCP; clib_memcpy (&hdr.ip.src_address, &tc->c_lcl_ip.ip6, sizeof (ip6_address_t)); @@ -457,6 +507,31 @@ 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_CC_NEWRENO); + 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]; +} + + /** * Initialize connection send variables. */ @@ -471,7 +546,7 @@ 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 (vlib_get_thread_index ()); + tcp_set_time_now (tcp_get_worker (vlib_get_thread_index ())); time_now = tcp_time_now (); tc->iss = random_u32 (&time_now); @@ -480,6 +555,17 @@ tcp_init_snd_vars (tcp_connection_t * tc) tc->snd_una_max = tc->snd_nxt; } +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); + tc->mrtt_us = (u32) ~ 0; +} + /** Initialize tcp connection variables * * Should be called after having received a msg from the peer, i.e., a SYN or @@ -494,7 +580,14 @@ tcp_connection_init_vars (tcp_connection_t * tc) if (tc->state == TCP_STATE_SYN_RCVD) tcp_init_snd_vars (tc); - // tcp_connection_fib_attach (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_enable_pacing (tc); } static int @@ -527,8 +620,8 @@ tcp_alloc_custom_local_endpoint (tcp_main_t * tm, ip46_address_t * lcl_addr, return 0; } -int -tcp_connection_open (transport_endpoint_t * rmt) +static int +tcp_session_open (transport_endpoint_cfg_t * rmt) { tcp_main_t *tm = vnet_get_tcp_main (); tcp_connection_t *tc; @@ -574,12 +667,6 @@ tcp_connection_open (transport_endpoint_t * rmt) return tc->c_c_index; } -int -tcp_session_open (transport_endpoint_t * tep) -{ - return tcp_connection_open (tep); -} - const char *tcp_dbg_evt_str[] = { #define _(sym, str) str, foreach_tcp_dbg_evt @@ -610,7 +697,7 @@ const char *tcp_connection_flags_str[] = { #undef _ }; -u8 * +static u8 * format_tcp_connection_flags (u8 * s, va_list * args) { tcp_connection_t *tc = va_arg (*args, tcp_connection_t *); @@ -635,7 +722,7 @@ const char *tcp_conn_timers[] = { #undef _ }; -u8 * +static u8 * format_tcp_timers (u8 * s, va_list * args) { tcp_connection_t *tc = va_arg (*args, tcp_connection_t *); @@ -645,7 +732,6 @@ format_tcp_timers (u8 * s, va_list * args) if (tc->timers[i] != TCP_TIMER_HANDLE_INVALID) last = i; - s = format (s, "["); for (i = 0; i < last; i++) { if (tc->timers[i] != TCP_TIMER_HANDLE_INVALID) @@ -653,14 +739,12 @@ format_tcp_timers (u8 * s, va_list * args) } if (last >= 0) - s = format (s, "%s]", tcp_conn_timers[i]); - else - s = format (s, "]"); + s = format (s, "%s", tcp_conn_timers[i]); return s; } -u8 * +static u8 * format_tcp_congestion_status (u8 * s, va_list * args) { tcp_connection_t *tc = va_arg (*args, tcp_connection_t *); @@ -673,47 +757,68 @@ format_tcp_congestion_status (u8 * s, va_list * args) return s; } -u8 * +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, " flags: %U timers: %U\n", format_tcp_connection_flags, tc, - format_tcp_timers, tc); + 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 snd_wl1 %u snd_wl2 %u\n", - tc->snd_wnd, tc->rcv_wnd, tc->snd_wl1 - 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 send space %u rcv_wnd_av %d\n", + 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, " cong %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, " prev_ssthresh %u snd_congestion %u dupack %u", - tc->prev_ssthresh, tc->snd_congestion - tc->iss, - tc->rcv_dupacks); - s = format (s, " limited_transmit %u\n", tc->limited_transmit - tc->iss); - s = format (s, " tsecr %u tsecr_last_ack %u\n", tc->rcv_opts.tsecr, - tc->tsecr_last_ack); - s = format (s, " rto %u rto_boff %u srtt %u rttvar %u rtt_ts %u ", tc->rto, - tc->rto_boff, tc->srtt, tc->rttvar, tc->rtt_ts); - s = format (s, "rtt_seq %u\n", tc->rtt_seq); 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 rttvar %u rtt_ts %2.5f ", + tc->rto, tc->rto_boff, tc->srtt, 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, " scoreboard: %U\n", format_tcp_scoreboard, &tc->sack_sb, - tc); + { + 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; } -u8 * +static u8 * format_tcp_connection_id (u8 * s, va_list * args) { tcp_connection_t *tc = va_arg (*args, tcp_connection_t *); @@ -721,15 +826,15 @@ format_tcp_connection_id (u8 * s, va_list * args) return s; if (tc->c_is_ip4) { - s = format (s, "[#%d][%s] %U:%d->%U:%d", tc->c_thread_index, "T", - format_ip4_address, &tc->c_lcl_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][%s] %U:%d->%U:%d", tc->c_thread_index, "T", - format_ip6_address, &tc->c_lcl_ip6, + 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)); } @@ -756,7 +861,7 @@ format_tcp_connection (u8 * s, va_list * args) return s; } -u8 * +static u8 * format_tcp_session (u8 * s, va_list * args) { u32 tci = va_arg (*args, u32); @@ -772,7 +877,7 @@ format_tcp_session (u8 * s, va_list * args) return s; } -u8 * +static u8 * format_tcp_listener_session (u8 * s, va_list * args) { u32 tci = va_arg (*args, u32); @@ -780,7 +885,7 @@ format_tcp_listener_session (u8 * s, va_list * args) return format (s, "%U", format_tcp_connection_id, tc); } -u8 * +static u8 * format_tcp_half_open_session (u8 * s, va_list * args) { u32 tci = va_arg (*args, u32); @@ -836,7 +941,7 @@ format_tcp_rcv_sacks (u8 * s, va_list * args) return s; } -u8 * +static u8 * format_tcp_sack_hole (u8 * s, va_list * args) { sack_scoreboard_hole_t *hole = va_arg (*args, sack_scoreboard_hole_t *); @@ -854,16 +959,22 @@ format_tcp_scoreboard (u8 * s, va_list * args) 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, " last_bytes_delivered %u high_sacked %u snd_una_adv %u\n", - sb->last_bytes_delivered, sb->high_sacked, sb->snd_una_adv); - s = format (s, " cur_rxt_hole %u high_rxt %u rescue_rxt %u", - sb->cur_rxt_hole, sb->high_rxt, sb->rescue_rxt); + 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); hole = scoreboard_first_hole (sb); if (hole) - s = format (s, "\n head %u tail %u holes:\n", sb->head, sb->tail); + 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) { @@ -874,14 +985,14 @@ format_tcp_scoreboard (u8 * s, va_list * args) return s; } -transport_connection_t * +static transport_connection_t * tcp_session_get_transport (u32 conn_index, u32 thread_index) { tcp_connection_t *tc = tcp_connection_get (conn_index, thread_index); return &tc->connection; } -transport_connection_t * +static transport_connection_t * tcp_half_open_session_get_transport (u32 conn_index) { tcp_connection_t *tc = tcp_half_open_connection_get (conn_index); @@ -895,7 +1006,7 @@ tcp_half_open_session_get_transport (u32 conn_index) * the tcp options to be used in the next burst and subtracts their * length from the connection's snd_mss. */ -u16 +static u16 tcp_session_send_mss (transport_connection_t * trans_conn) { tcp_connection_t *tc = (tcp_connection_t *) trans_conn; @@ -903,7 +1014,7 @@ tcp_session_send_mss (transport_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_snd_mss (tc); + tcp_update_burst_snd_vars (tc); return tc->snd_mss; } @@ -935,70 +1046,47 @@ tcp_round_snd_space (tcp_connection_t * tc, u32 snd_space) * @param tc tcp connection * @return number of bytes session is allowed to write */ -u32 -tcp_snd_space (tcp_connection_t * tc) +static inline u32 +tcp_snd_space_inline (tcp_connection_t * tc) { int snd_space, snt_limited; - if (PREDICT_TRUE (tcp_in_cong_recovery (tc) == 0)) - { - snd_space = tcp_available_output_snd_space (tc); + if (PREDICT_FALSE (tcp_in_fastrecovery (tc))) + return 0; - /* 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 (tc->rcv_dupacks == 1 && tc->limited_transmit != tc->snd_nxt) - tc->limited_transmit = tc->snd_nxt; - ASSERT (seq_leq (tc->limited_transmit, tc->snd_nxt)); + snd_space = tcp_available_output_snd_space (tc); - snt_limited = tc->snd_nxt - tc->limited_transmit; - snd_space = clib_max (2 * tc->snd_mss - snt_limited, 0); - } - return tcp_round_snd_space (tc, snd_space); - } - - if (tcp_in_recovery (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))) { - tc->snd_nxt = tc->snd_una_max; - snd_space = tcp_available_snd_wnd (tc) - tc->snd_rxt_bytes - - (tc->snd_una_max - tc->snd_congestion); - if (snd_space <= 0 || (tc->snd_una_max - tc->snd_una) >= tc->snd_wnd) - return 0; - return tcp_round_snd_space (tc, snd_space); - } + if (tc->rcv_dupacks == 1 && tc->limited_transmit != tc->snd_nxt) + tc->limited_transmit = tc->snd_nxt; + ASSERT (seq_leq (tc->limited_transmit, tc->snd_nxt)); - /* RFC 5681: When previously unsent data is available and the new value of - * cwnd and the receiver's advertised window allow, a TCP SHOULD send 1*SMSS - * bytes of previously unsent data. */ - if (tcp_in_fastrecovery (tc) && !tcp_fastrecovery_sent_1_smss (tc)) - { - if (tcp_available_output_snd_space (tc) < tc->snd_mss) - return 0; - tcp_fastrecovery_1_smss_on (tc); - return tc->snd_mss; + snt_limited = tc->snd_nxt - tc->limited_transmit; + snd_space = clib_max (2 * tc->snd_mss - snt_limited, 0); } - - return 0; + return tcp_round_snd_space (tc, snd_space); } u32 -tcp_session_send_space (transport_connection_t * trans_conn) +tcp_snd_space (tcp_connection_t * tc) { - tcp_connection_t *tc = (tcp_connection_t *) trans_conn; - return clib_min (tcp_snd_space (tc), - tc->snd_wnd - (tc->snd_nxt - tc->snd_una)); + return tcp_snd_space_inline (tc); } -i32 -tcp_rcv_wnd_available (tcp_connection_t * tc) +static u32 +tcp_session_send_space (transport_connection_t * trans_conn) { - return (i32) tc->rcv_wnd - (tc->rcv_nxt - tc->rcv_las); + 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)); } -u32 +static u32 tcp_session_tx_fifo_offset (transport_connection_t * trans_conn) { tcp_connection_t *tc = (tcp_connection_t *) trans_conn; @@ -1009,13 +1097,23 @@ tcp_session_tx_fifo_offset (transport_connection_t * trans_conn) return (tc->snd_nxt - tc->snd_una); } -void +static void tcp_update_time (f64 now, u8 thread_index) { - tcp_set_time_now (thread_index); - tw_timer_expire_timers_16t_2w_512sl (&tcp_main.timer_wheels[thread_index], - now); - tcp_flush_frames_to_output (thread_index); + tcp_worker_ctx_t *wrk = tcp_get_worker (thread_index); + + 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); +} + +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); } /* *INDENT-OFF* */ @@ -1023,7 +1121,7 @@ const static transport_proto_vft_t tcp_proto = { .enable = vnet_tcp_enable_disable, .bind = tcp_session_bind, .unbind = tcp_session_unbind, - .push_header = tcp_push_header, + .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, @@ -1037,10 +1135,39 @@ const static transport_proto_vft_t tcp_proto = { .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_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 (); @@ -1052,7 +1179,7 @@ tcp_timer_keep_handler (u32 conn_index) tcp_connection_close (tc); } -void +static void tcp_timer_establish_handler (u32 conn_index) { tcp_connection_t *tc; @@ -1080,7 +1207,7 @@ tcp_timer_establish_handler (u32 conn_index) tcp_connection_cleanup (tc); } -void +static void tcp_timer_waitclose_handler (u32 conn_index) { u32 thread_index = vlib_get_thread_index (); @@ -1100,6 +1227,10 @@ tcp_timer_waitclose_handler (u32 conn_index) clib_warning ("FIN was sent and still in CLOSE WAIT. Weird!"); } + /* Make sure we don't try to send unsent data */ + tcp_connection_timers_reset (tc); + tcp_cong_recovery_off (tc); + tc->snd_una_max = tc->snd_nxt = tc->snd_una; tcp_send_fin (tc); tc->state = TCP_STATE_LAST_ACK; @@ -1145,13 +1276,13 @@ tcp_expired_timers_dispatch (u32 * expired_timers) } } -void +static void tcp_initialize_timer_wheels (tcp_main_t * tm) { tw_timer_wheel_16t_2w_512sl_t *tw; /* *INDENT-OFF* */ foreach_vlib_main (({ - tw = &tm->timer_wheels[ii]; + 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); @@ -1159,16 +1290,15 @@ tcp_initialize_timer_wheels (tcp_main_t * tm) /* *INDENT-ON* */ } -clib_error_t * +static clib_error_t * tcp_main_enable (vlib_main_t * vm) { - tcp_main_t *tm = vnet_get_tcp_main (); vlib_thread_main_t *vtm = vlib_get_thread_main (); + u32 num_threads, n_workers, prealloc_conn_per_wrk; + tcp_connection_t *tc __attribute__ ((unused)); + tcp_main_t *tm = vnet_get_tcp_main (); clib_error_t *error = 0; - u32 num_threads; int thread; - tcp_connection_t *tc __attribute__ ((unused)); - u32 preallocated_connections_per_thread; if ((error = vlib_call_init_function (vm, ip_main_init))) return error; @@ -1190,27 +1320,30 @@ 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; - /* - * Preallocate connections. Assume that thread 0 won't - * use preallocated threads when running multi-core - */ - if (num_threads == 1) + for (thread = 0; thread < num_threads; thread++) { - thread = 0; - preallocated_connections_per_thread = tm->preallocated_connections; - } - else - { - thread = 1; - preallocated_connections_per_thread = - tm->preallocated_connections / (num_threads - 1); - } - for (; thread < num_threads; thread++) - { - if (preallocated_connections_per_thread) - pool_init_fixed (tm->connections[thread], - preallocated_connections_per_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_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); + tm->wrk_ctx[thread].vm = vlib_mains[thread]; + + /* + * 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); } /* @@ -1220,13 +1353,6 @@ tcp_main_enable (vlib_main_t * vm) pool_init_fixed (tm->half_open_connections, tm->preallocated_half_open_connections); - /* Initialize per worker thread tx buffers (used for control messages) */ - vec_validate (tm->tx_buffers, num_threads - 1); - - /* Initialize timer wheels */ - vec_validate (tm->timer_wheels, num_threads - 1); - tcp_initialize_timer_wheels (tm); - /* Initialize clocks per tick for TCP timestamp. Used to compute * monotonically increasing timestamps. */ tm->tstamp_ticks_per_clock = vm->clib_time.seconds_per_clock @@ -1237,15 +1363,11 @@ tcp_main_enable (vlib_main_t * vm) clib_spinlock_init (&tm->half_open_lock); } - vec_validate (tm->tx_frames[0], num_threads - 1); - vec_validate (tm->tx_frames[1], num_threads - 1); - vec_validate (tm->ip_lookup_tx_frames[0], num_threads - 1); - vec_validate (tm->ip_lookup_tx_frames[1], num_threads - 1); + tcp_initialize_timer_wheels (tm); tm->bytes_per_buffer = vlib_buffer_free_list_buffer_size (vm, VLIB_BUFFER_DEFAULT_FREE_LIST_INDEX); - vec_validate (tm->time_now, num_threads - 1); return error; } @@ -1277,7 +1399,7 @@ tcp_punt_unknown (vlib_main_t * vm, u8 is_ip4, u8 is_add) tm->punt_unknown6 = is_add; } -clib_error_t * +static clib_error_t * tcp_init (vlib_main_t * vm) { tcp_main_t *tm = vnet_get_tcp_main (); @@ -1301,6 +1423,7 @@ tcp_init (vlib_main_t * vm) FIB_PROTOCOL_IP6, tcp6_output_node.index); tcp_api_reference (); + tm->tx_pacing = 1; return 0; } @@ -1313,9 +1436,8 @@ tcp_config_fn (vlib_main_t * vm, unformat_input_t * input) while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) { - if (unformat - (input, "preallocated-connections %d", - &tm->preallocated_connections)) + if (unformat (input, "preallocated-connections %d", + &tm->preallocated_connections)) ; else if (unformat (input, "preallocated-half-open-connections %d", &tm->preallocated_half_open_connections)) @@ -1323,6 +1445,11 @@ tcp_config_fn (vlib_main_t * vm, unformat_input_t * input) 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 return clib_error_return (0, "unknown input `%U'", format_unformat_error, input); @@ -1360,7 +1487,7 @@ tcp_configure_v4_source_address_range (vlib_main_t * vm, ip4_address_t * hi_addr, u32 fib_index, int is_del); - memset (&prefix, 0, sizeof (prefix)); + clib_memset (&prefix, 0, sizeof (prefix)); fib_index = fib_table_find (FIB_PROTOCOL_IP4, table_id); @@ -1445,7 +1572,7 @@ tcp_configure_v6_source_address_range (vlib_main_t * vm, fib_node_index_t fei; u32 sw_if_index; - memset (&prefix, 0, sizeof (prefix)); + clib_memset (&prefix, 0, sizeof (prefix)); fib_index = fib_table_find (FIB_PROTOCOL_IP6, table_id); @@ -1667,10 +1794,16 @@ tcp_scoreboard_replay (u8 * s, tcp_connection_t * tc, u8 verbose) 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; - memset (dummy_tc, 0, sizeof (*dummy_tc)); + 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; @@ -1678,9 +1811,6 @@ tcp_scoreboard_replay (u8 * s, tcp_connection_t * tc, u8 verbose) #if TCP_SCOREBOARD_TRACE trace = tc->sack_sb.trace; trace_len = vec_len (tc->sack_sb.trace); -#else - trace = 0; - trace_len = 0; #endif for (i = 0; i < trace_len; i++)