diff options
| -rw-r--r-- | src/vnet/tcp/tcp.c | 134 | ||||
| -rw-r--r-- | src/vnet/tcp/tcp.h | 137 | ||||
| -rwxr-xr-x | src/vnet/tcp/tcp_debug.h | 4 | ||||
| -rwxr-xr-x | src/vnet/tcp/tcp_input.c | 33 | ||||
| -rw-r--r-- | src/vnet/tcp/tcp_output.c | 20 |
5 files changed, 195 insertions, 133 deletions
diff --git a/src/vnet/tcp/tcp.c b/src/vnet/tcp/tcp.c index 752257f4100..3b94420e639 100644 --- a/src/vnet/tcp/tcp.c +++ b/src/vnet/tcp/tcp.c @@ -73,7 +73,7 @@ tcp_add_del_adjacency (tcp_connection_t * tc, u8 is_add) static void tcp_cc_init (tcp_connection_t * tc) { - tc->cc_algo = tcp_cc_algo_get (tcp_main.cc_algo); + tc->cc_algo = tcp_cc_algo_get (tcp_cfg.cc_algo); tc->cc_algo->init (tc); } @@ -343,7 +343,7 @@ tcp_connection_reset (tcp_connection_t * tc) 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); + tcp_timer_set (tc, TCP_TIMER_WAITCLOSE, tcp_cfg.closewait_time); session_transport_reset_notify (&tc->connection); tcp_connection_set_state (tc, TCP_STATE_CLOSED); session_transport_closed_notify (&tc->connection); @@ -354,7 +354,7 @@ tcp_connection_reset (tcp_connection_t * tc) case TCP_STATE_CLOSING: case TCP_STATE_LAST_ACK: tcp_connection_timers_reset (tc); - tcp_timer_set (tc, TCP_TIMER_WAITCLOSE, TCP_CLOSEWAIT_TIME); + tcp_timer_set (tc, TCP_TIMER_WAITCLOSE, tcp_cfg.closewait_time); /* 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); @@ -398,7 +398,7 @@ 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 (tc, TCP_TIMER_WAITCLOSE, tcp_cfg.finwait1_time); break; case TCP_STATE_ESTABLISHED: /* If closing with unread data, reset the connection */ @@ -407,7 +407,7 @@ tcp_connection_close (tcp_connection_t * tc) tcp_send_reset (tc); tcp_connection_timers_reset (tc); tcp_connection_set_state (tc, TCP_STATE_CLOSED); - tcp_timer_set (tc, TCP_TIMER_WAITCLOSE, TCP_CLOSEWAIT_TIME); + tcp_timer_set (tc, TCP_TIMER_WAITCLOSE, tcp_cfg.closewait_time); session_transport_closed_notify (&tc->connection); break; } @@ -419,7 +419,7 @@ 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 (tc, TCP_TIMER_WAITCLOSE, tcp_cfg.finwait1_time); break; case TCP_STATE_CLOSE_WAIT: if (!transport_max_tx_dequeue (&tc->connection)) @@ -427,20 +427,20 @@ tcp_connection_close (tcp_connection_t * tc) 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 (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 (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); + tcp_timer_update (tc, TCP_TIMER_WAITCLOSE, tcp_cfg.cleanup_time); break; default: TCP_DBG ("state: %u", tc->state); @@ -664,7 +664,7 @@ tcp_connection_init_vars (tcp_connection_t * tc) /* 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->flags & TCP_CONN_RATE_SAMPLE) @@ -680,17 +680,17 @@ 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); @@ -715,8 +715,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 @@ -1308,7 +1308,7 @@ tcp_timer_waitclose_handler (u32 conn_index) if (!(tc->flags & TCP_CONN_FINPNDG)) { tcp_connection_set_state (tc, TCP_STATE_CLOSED); - tcp_timer_set (tc, TCP_TIMER_WAITCLOSE, TCP_CLEANUP_TIME); + tcp_timer_set (tc, TCP_TIMER_WAITCLOSE, tcp_cfg.cleanup_time); break; } @@ -1321,7 +1321,7 @@ tcp_timer_waitclose_handler (u32 conn_index) tcp_connection_set_state (tc, TCP_STATE_LAST_ACK); /* Make sure we don't wait in LAST ACK forever */ - tcp_timer_set (tc, TCP_TIMER_WAITCLOSE, TCP_2MSL_TIME); + tcp_timer_set (tc, TCP_TIMER_WAITCLOSE, tcp_cfg.lastack_time); /* Don't delete the connection yet */ break; @@ -1334,21 +1334,21 @@ tcp_timer_waitclose_handler (u32 conn_index) * Notify session layer that transport is closed. */ tcp_connection_set_state (tc, TCP_STATE_CLOSED); tcp_send_reset (tc); - tcp_timer_set (tc, TCP_TIMER_WAITCLOSE, TCP_CLEANUP_TIME); + tcp_timer_set (tc, TCP_TIMER_WAITCLOSE, tcp_cfg.cleanup_time); } 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_timer_set (tc, TCP_TIMER_WAITCLOSE, tcp_cfg.cleanup_time); } break; case TCP_STATE_LAST_ACK: 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); + tcp_timer_set (tc, TCP_TIMER_WAITCLOSE, tcp_cfg.cleanup_time); session_transport_closed_notify (&tc->connection); break; default: @@ -1395,7 +1395,7 @@ tcp_initialize_timer_wheels (tcp_main_t * tm) 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); + TCP_TIMER_TICK, ~0); tw->last_run_time = vlib_time_now (this_vlib_main); })); /* *INDENT-ON* */ @@ -1443,7 +1443,7 @@ tcp_main_enable (vlib_main_t * vm) 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; for (thread = 0; thread < num_threads; thread++) { @@ -1464,9 +1464,9 @@ tcp_main_enable (vlib_main_t * 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); + tcp_cfg.preallocated_half_open_connections); /* Initialize clocks per tick for TCP timestamp. Used to compute * monotonically increasing timestamps. */ @@ -1514,6 +1514,34 @@ 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 = 1460; + tcp_cfg.initial_cwnd_multiplier = 0; + tcp_cfg.enable_tx_pacing = 1; + tcp_cfg.cc_algo = TCP_CC_NEWRENO; + + /* Time constants defined as timer tick (100ms) multiples */ + tcp_cfg.delack_time = 1; /* 0.1s */ + tcp_cfg.closewait_time = 20; /* 2s */ + tcp_cfg.timewait_time = 100; /* 10s */ + tcp_cfg.finwait1_time = 600; /* 60s */ + tcp_cfg.lastack_time = 300; /* 30s */ + tcp_cfg.finwait2_time = 300; /* 30s */ + tcp_cfg.closing_time = 300; /* 30s */ + tcp_cfg.cleanup_time = 1; /* 0.1s */ +} + static clib_error_t * tcp_init (vlib_main_t * vm) { @@ -1538,11 +1566,10 @@ tcp_init (vlib_main_t * vm) FIB_PROTOCOL_IP6, tcp6_output_node.index); tcp_api_reference (); + tcp_configuration_init (); + tm->cc_algo_by_name = hash_create_string (0, sizeof (uword)); - tm->tx_pacing = 1; - tm->cc_algo = TCP_CC_NEWRENO; - tm->default_mtu = 1460; - tm->initial_cwnd_multiplier = 0; + return 0; } @@ -1594,34 +1621,49 @@ 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) { - 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)) + &tcp_cfg.preallocated_connections)) ; else if (unformat (input, "preallocated-half-open-connections %d", - &tm->preallocated_half_open_connections)) + &tcp_cfg.preallocated_half_open_connections)) ; else if (unformat (input, "buffer-fail-fraction %f", - &tm->buffer_fail_fraction)) + &tcp_cfg.buffer_fail_fraction)) ; else if (unformat (input, "max-rx-fifo %U", unformat_memory_size, - &tm->max_rx_fifo)) + &tcp_cfg.max_rx_fifo)) ; - else if (unformat (input, "mtu %d", &tm->default_mtu)) + else if (unformat (input, "min-rx-fifo %U", unformat_memory_size, + &tcp_cfg.min_rx_fifo)) + ; + else if (unformat (input, "mtu %d", &tcp_cfg.default_mtu)) ; else if (unformat (input, "initial-cwnd-multiplier %d", - &tm->initial_cwnd_multiplier)) + &tcp_cfg.initial_cwnd_multiplier)) ; else if (unformat (input, "no-tx-pacing")) - tm->tx_pacing = 0; + tcp_cfg.enable_tx_pacing = 0; else if (unformat (input, "cc-algo %U", unformat_tcp_cc_algo, - &tm->cc_algo)) + &tcp_cfg.cc_algo)) ; else if (unformat (input, "%U", unformat_tcp_cc_algo_cfg)) ; + else if (unformat (input, "closewait-time %d", &tcp_cfg.closewait_time)) + tcp_cfg.closewait_time /= TCP_TIMER_TICK; + else if (unformat (input, "timewait-time %d", &tcp_cfg.timewait_time)) + tcp_cfg.timewait_time /= TCP_TIMER_TICK; + else if (unformat (input, "finwait1-time %d", &tcp_cfg.finwait1_time)) + tcp_cfg.finwait1_time /= TCP_TIMER_TICK; + else if (unformat (input, "finwait2-time %d", &tcp_cfg.finwait2_time)) + tcp_cfg.finwait2_time /= TCP_TIMER_TICK; + else if (unformat (input, "lastack-time %d", &tcp_cfg.lastack_time)) + tcp_cfg.lastack_time /= TCP_TIMER_TICK; + else if (unformat (input, "closing-time %d", &tcp_cfg.closing_time)) + tcp_cfg.closing_time /= TCP_TIMER_TICK; + else if (unformat (input, "cleanup-time %d", &tcp_cfg.cleanup_time)) + tcp_cfg.cleanup_time /= TCP_TIMER_TICK; else return clib_error_return (0, "unknown input `%U'", format_unformat_error, input); @@ -1646,7 +1688,6 @@ 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; @@ -1697,7 +1738,7 @@ tcp_configure_v4_source_address_range (vlib_main_t * vm, { dpo_id_t dpo = DPO_INVALID; - vec_add1 (tm->ip4_src_addresses, start[0]); + vec_add1 (tcp_cfg.ip4_src_addrs, start[0]); /* Add local adjacencies for the range */ @@ -1735,7 +1776,6 @@ 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; @@ -1755,7 +1795,7 @@ tcp_configure_v6_source_address_range (vlib_main_t * vm, dpo_id_t dpo = DPO_INVALID; /* Remember this address */ - vec_add1 (tm->ip6_src_addresses, start[0]); + vec_add1 (tcp_cfg.ip6_src_addrs, start[0]); /* Lookup the prefix, to identify the interface involved */ prefix.fp_len = 128; diff --git a/src/vnet/tcp/tcp.h b/src/vnet/tcp/tcp.h index ae50947b797..753a1ca6996 100644 --- a/src/vnet/tcp/tcp.h +++ b/src/vnet/tcp/tcp.h @@ -33,8 +33,6 @@ #define TCP_CC_DATA_SZ 24 #define TCP_DUPACK_THRESHOLD 3 -#define TCP_MAX_RX_FIFO_SIZE 32 << 20 -#define TCP_MIN_RX_FIFO_SIZE 4 << 10 #define TCP_IW_N_SEGMENTS 10 #define TCP_ALWAYS_ACK 1 /**< On/off delayed acks */ #define TCP_USE_SACKS 1 /**< Disable only for testing */ @@ -91,17 +89,9 @@ extern timer_expiration_handler tcp_timer_retransmit_syn_handler; #define TCP_TIMER_HANDLE_INVALID ((u32) ~0) -/* Timer delays as multiples of 100ms */ -#define TCP_TO_TIMER_TICK TCP_TICK*10 /* Period for converting from TCP - * ticks to timer units */ -#define TCP_DELACK_TIME 1 /* 0.1s */ -#define TCP_SYN_RCVD_TIME 600 /* 60s */ -#define TCP_2MSL_TIME 300 /* 30s */ -#define TCP_CLOSEWAIT_TIME 20 /* 2s */ -#define TCP_TIMEWAIT_TIME 100 /* 10s */ -#define TCP_FINWAIT1_TIME 600 /* 60s */ -#define TCP_CLEANUP_TIME 1 /* 0.1s */ -#define TCP_TIMER_PERSIST_MIN 2 /* 0.2s */ +#define TCP_TIMER_TICK 0.1 /**< Timer tick in seconds */ +#define TCP_TO_TIMER_TICK TCP_TICK*10 /**< Factor for converting + ticks to timer ticks */ #define TCP_RTO_MAX 60 * THZ /* Min max RTO (60s) as per RFC6298 */ #define TCP_RTO_MIN 0.2 * THZ /* Min RTO (200ms) - lower than standard */ @@ -511,6 +501,66 @@ typedef struct tcp_iss_seed_ u64 second; } tcp_iss_seed_t; +typedef struct tcp_configuration_ +{ + /** Max rx fifo size for a session (in bytes). It is used in to compute the + * rfc 7323 window scaling factor */ + u32 max_rx_fifo; + + /** Min rx fifo for a session (in bytes) */ + u32 min_rx_fifo; + + /** Default MTU to be used when establishing connections */ + u16 default_mtu; + + /** Initial CWND multiplier, which multiplies MSS to determine initial CWND. + * Set 0 to determine the initial CWND by another way */ + u16 initial_cwnd_multiplier; + + /** Enable tx pacing for new connections */ + u8 enable_tx_pacing; + + /** Default congestion control algorithm type */ + tcp_cc_algorithm_type_e cc_algo; + + /** Delayed ack time (disabled) */ + u16 delack_time; + + /** Timer ticks to wait for close from app */ + u16 closewait_time; + + /** Timer ticks to wait in time-wait. Also known as 2MSL */ + u16 timewait_time; + + /** Timer ticks to wait in fin-wait1 to send fin and rcv fin-ack */ + u16 finwait1_time; + + /** Timer ticks to wait in last ack for ack */ + u16 lastack_time; + + /** Timer ticks to wait in fin-wait2 for fin */ + u16 finwait2_time; + + /** Timer ticks to wait in closing for fin ack */ + u16 closing_time; + + /** Timer ticks to wait before cleaning up the connection */ + u16 cleanup_time; + + /** Number of preallocated connections */ + u32 preallocated_connections; + + /** Number of preallocated half-open connections */ + u32 preallocated_half_open_connections; + + /** Vectors of src addresses. Optional unless one needs > 63K active-opens */ + ip4_address_t *ip4_src_addrs; + ip6_address_t *ip6_src_addrs; + + /** Fault-injection. Debug only */ + f64 buffer_fail_fraction; +} tcp_configuration_t; + typedef struct _tcp_main { /* Per-worker thread tcp connection pools */ @@ -528,17 +578,17 @@ typedef struct _tcp_main /** per-worker context */ tcp_worker_ctx_t *wrk_ctx; - /* Pool of half-open connections on which we've sent a SYN */ + /** Pool of half-open connections on which we've sent a SYN */ tcp_connection_t *half_open_connections; clib_spinlock_t half_open_lock; /** vlib buffer size */ u32 bytes_per_buffer; - /* Seed used to generate random iss */ + /** Seed used to generate random iss */ tcp_iss_seed_t iss_seed; - /* Congestion control algorithms registered */ + /** Congestion control algorithms registered */ tcp_cc_algorithm_t *cc_algos; /** Hash table of cc algorithms by name */ @@ -547,45 +597,23 @@ typedef struct _tcp_main /** Last cc algo registered */ tcp_cc_algorithm_type_e cc_last_type; - /* - * Configuration - */ - - /* Flag that indicates if stack is on or off */ + /** Flag that indicates if stack is on or off */ u8 is_enabled; - /** Max rx fifo size for a session. It is used in to compute the - * rfc 7323 window scaling factor */ - u32 max_rx_fifo; - - /** Default MTU to be used when establishing connections */ - u16 default_mtu; - - /** Initial CWND multiplier, which multiplies MSS to determine initial CWND. - * Set 0 to determine the initial CWND by another way */ - u16 initial_cwnd_multiplier; - - /** Number of preallocated connections */ - u32 preallocated_connections; - u32 preallocated_half_open_connections; - - /** Vectors of src addresses. Optional unless one needs > 63K active-opens */ - ip4_address_t *ip4_src_addresses; - u32 last_v4_address_rotor; - u32 last_v6_address_rotor; - ip6_address_t *ip6_src_addresses; - - /** Enable tx pacing for new connections */ - u8 tx_pacing; - + /** Flag that indicates if v4 punting is enabled */ u8 punt_unknown4; + + /** Flag that indicates if v6 punting is enabled */ u8 punt_unknown6; - /** fault-injection */ - f64 buffer_fail_fraction; + /** Rotor for v4 source addresses */ + u32 last_v4_addr_rotor; - /** Default congestion control algorithm type */ - tcp_cc_algorithm_type_e cc_algo; + /** Rotor for v6 source addresses */ + u32 last_v6_addr_rotor; + + /** Protocol configuration */ + tcp_configuration_t cfg; } tcp_main_t; extern tcp_main_t tcp_main; @@ -602,6 +630,7 @@ extern vlib_node_registration_t tcp6_rcv_process_node; extern vlib_node_registration_t tcp4_listen_node; extern vlib_node_registration_t tcp6_listen_node; +#define tcp_cfg tcp_main.cfg #define tcp_node_index(node_id, is_ip4) \ ((is_ip4) ? tcp4_##node_id##_node.index : tcp6_##node_id##_node.index) @@ -842,8 +871,8 @@ tcp_flight_size (const tcp_connection_t * tc) always_inline u32 tcp_initial_cwnd (const tcp_connection_t * tc) { - if (tcp_main.initial_cwnd_multiplier > 0) - return tcp_main.initial_cwnd_multiplier * tc->snd_mss; + if (tcp_cfg.initial_cwnd_multiplier > 0) + return tcp_cfg.initial_cwnd_multiplier * tc->snd_mss; if (tc->snd_mss > 2190) return 2 * tc->snd_mss; @@ -1089,16 +1118,14 @@ tcp_persist_timer_set (tcp_connection_t * tc) { /* Reuse RTO. It's backed off in handler */ tcp_timer_set (tc, TCP_TIMER_PERSIST, - clib_max (tc->rto * TCP_TO_TIMER_TICK, - TCP_TIMER_PERSIST_MIN)); + clib_max (tc->rto * TCP_TO_TIMER_TICK, 1)); } always_inline void tcp_persist_timer_update (tcp_connection_t * tc) { tcp_timer_update (tc, TCP_TIMER_PERSIST, - clib_max (tc->rto * TCP_TO_TIMER_TICK, - TCP_TIMER_PERSIST_MIN)); + clib_max (tc->rto * TCP_TO_TIMER_TICK, 1)); } always_inline void diff --git a/src/vnet/tcp/tcp_debug.h b/src/vnet/tcp/tcp_debug.h index 262d3faae10..dd2ada848cf 100755 --- a/src/vnet/tcp/tcp_debug.h +++ b/src/vnet/tcp/tcp_debug.h @@ -901,12 +901,12 @@ if (tcp_cc_time_to_print_stats (_tc)) \ num_threads = 1 /* main thread */ + vtm->n_threads; \ vec_validate (buffer_fail_counters, num_threads - 1); \ } \ - if (PREDICT_FALSE (tcp_main.buffer_fail_fraction != 0.0)) \ + if (PREDICT_FALSE (tcp_cfg.buffer_fail_fraction != 0.0)) \ { \ if (PREDICT_TRUE (buffer_fail_counters[thread_index] > 0)) \ { \ if ((1.0 / (f32) (buffer_fail_counters[thread_index])) \ - < tcp_main.buffer_fail_fraction) \ + < tcp_cfg.buffer_fail_fraction) \ { \ buffer_fail_counters[thread_index] = 0.0000001; \ return -1; \ diff --git a/src/vnet/tcp/tcp_input.c b/src/vnet/tcp/tcp_input.c index 595a76d6853..ccefe74e69a 100755 --- a/src/vnet/tcp/tcp_input.c +++ b/src/vnet/tcp/tcp_input.c @@ -1650,7 +1650,7 @@ tcp_rcv_fin (tcp_worker_ctx_t * wrk, tcp_connection_t * tc, vlib_buffer_t * b, * in CLOSE-WAIT, set timer (reuse WAITCLOSE). */ tcp_connection_set_state (tc, TCP_STATE_CLOSE_WAIT); tcp_program_disconnect (wrk, tc); - tcp_timer_update (tc, TCP_TIMER_WAITCLOSE, TCP_CLOSEWAIT_TIME); + tcp_timer_update (tc, TCP_TIMER_WAITCLOSE, tcp_cfg.closewait_time); TCP_EVT_DBG (TCP_EVT_FIN_RCVD, tc); *error = TCP_ERROR_FIN_RCVD; } @@ -1947,7 +1947,7 @@ in_order: if (tcp_can_delack (tc)) { if (!tcp_timer_is_active (tc, TCP_TIMER_DELACK)) - tcp_timer_set (tc, TCP_TIMER_DELACK, TCP_DELACK_TIME); + tcp_timer_set (tc, TCP_TIMER_DELACK, tcp_cfg.delack_time); goto done; } @@ -2745,7 +2745,7 @@ tcp46_rcv_process_inline (vlib_main_t * vm, vlib_node_runtime_t * node, /* If a fin was received and data was acked extend wait */ else if ((tc0->flags & TCP_CONN_FINRCVD) && tc0->bytes_acked) tcp_timer_update (tc0, TCP_TIMER_WAITCLOSE, - TCP_CLOSEWAIT_TIME); + tcp_cfg.closewait_time); } /* If FIN is ACKed */ else if (tc0->snd_una == tc0->snd_nxt) @@ -2759,7 +2759,8 @@ tcp46_rcv_process_inline (vlib_main_t * vm, vlib_node_runtime_t * node, if (tc0->flags & TCP_CONN_FINRCVD) { tcp_connection_set_state (tc0, TCP_STATE_CLOSED); - tcp_timer_set (tc0, TCP_TIMER_WAITCLOSE, TCP_CLEANUP_TIME); + tcp_timer_set (tc0, TCP_TIMER_WAITCLOSE, + tcp_cfg.cleanup_time); session_transport_closed_notify (&tc0->connection); goto drop; } @@ -2767,7 +2768,7 @@ tcp46_rcv_process_inline (vlib_main_t * vm, vlib_node_runtime_t * node, tcp_connection_set_state (tc0, TCP_STATE_FIN_WAIT_2); /* Enable waitclose because we're willing to wait for peer's * FIN but not indefinitely. */ - tcp_timer_set (tc0, TCP_TIMER_WAITCLOSE, TCP_2MSL_TIME); + tcp_timer_set (tc0, TCP_TIMER_WAITCLOSE, tcp_cfg.finwait2_time); /* Don't try to deq the FIN acked */ if (tc0->burst_acked > 1) @@ -2800,7 +2801,7 @@ tcp46_rcv_process_inline (vlib_main_t * vm, vlib_node_runtime_t * node, tcp_send_fin (tc0); tcp_connection_timers_reset (tc0); tcp_connection_set_state (tc0, TCP_STATE_LAST_ACK); - tcp_timer_set (tc0, TCP_TIMER_WAITCLOSE, TCP_2MSL_TIME); + tcp_timer_set (tc0, TCP_TIMER_WAITCLOSE, tcp_cfg.lastack_time); break; case TCP_STATE_CLOSING: /* In addition to the processing for the ESTABLISHED state, if @@ -2814,7 +2815,7 @@ tcp46_rcv_process_inline (vlib_main_t * vm, vlib_node_runtime_t * node, tcp_connection_timers_reset (tc0); tcp_connection_set_state (tc0, TCP_STATE_TIME_WAIT); - tcp_timer_set (tc0, TCP_TIMER_WAITCLOSE, TCP_TIMEWAIT_TIME); + tcp_timer_set (tc0, TCP_TIMER_WAITCLOSE, tcp_cfg.timewait_time); session_transport_closed_notify (&tc0->connection); goto drop; @@ -2841,7 +2842,7 @@ tcp46_rcv_process_inline (vlib_main_t * vm, vlib_node_runtime_t * node, * we can't ensure that we have no packets already enqueued * to output. Rely instead on the waitclose timer */ tcp_connection_timers_reset (tc0); - tcp_timer_set (tc0, TCP_TIMER_WAITCLOSE, TCP_CLEANUP_TIME); + tcp_timer_set (tc0, TCP_TIMER_WAITCLOSE, tcp_cfg.cleanup_time); goto drop; @@ -2858,7 +2859,7 @@ tcp46_rcv_process_inline (vlib_main_t * vm, vlib_node_runtime_t * node, goto drop; tcp_program_ack (tc0); - tcp_timer_update (tc0, TCP_TIMER_WAITCLOSE, TCP_TIMEWAIT_TIME); + tcp_timer_update (tc0, TCP_TIMER_WAITCLOSE, tcp_cfg.timewait_time); goto drop; break; @@ -2900,7 +2901,7 @@ tcp46_rcv_process_inline (vlib_main_t * vm, vlib_node_runtime_t * node, tcp_program_ack (tc0); tcp_connection_set_state (tc0, TCP_STATE_CLOSE_WAIT); tcp_program_disconnect (wrk, tc0); - tcp_timer_update (tc0, TCP_TIMER_WAITCLOSE, TCP_CLOSEWAIT_TIME); + tcp_timer_update (tc0, TCP_TIMER_WAITCLOSE, tcp_cfg.closewait_time); break; case TCP_STATE_SYN_RCVD: /* Send FIN-ACK, enter LAST-ACK and because the app was not @@ -2910,7 +2911,7 @@ tcp46_rcv_process_inline (vlib_main_t * vm, vlib_node_runtime_t * node, tc0->rcv_nxt += 1; tcp_send_fin (tc0); tcp_connection_set_state (tc0, TCP_STATE_LAST_ACK); - tcp_timer_set (tc0, TCP_TIMER_WAITCLOSE, TCP_2MSL_TIME); + tcp_timer_set (tc0, TCP_TIMER_WAITCLOSE, tcp_cfg.lastack_time); break; case TCP_STATE_CLOSE_WAIT: case TCP_STATE_CLOSING: @@ -2926,14 +2927,16 @@ tcp46_rcv_process_inline (vlib_main_t * vm, vlib_node_runtime_t * node, * sending it. Since we already received a fin, do not wait * for too long. */ tc0->flags |= TCP_CONN_FINRCVD; - tcp_timer_update (tc0, TCP_TIMER_WAITCLOSE, TCP_CLOSEWAIT_TIME); + tcp_timer_update (tc0, TCP_TIMER_WAITCLOSE, + tcp_cfg.closewait_time); } else { tcp_connection_set_state (tc0, TCP_STATE_CLOSING); tcp_program_ack (tc0); /* Wait for ACK for our FIN but not forever */ - tcp_timer_update (tc0, TCP_TIMER_WAITCLOSE, TCP_2MSL_TIME); + tcp_timer_update (tc0, TCP_TIMER_WAITCLOSE, + tcp_cfg.closing_time); } break; case TCP_STATE_FIN_WAIT_2: @@ -2941,7 +2944,7 @@ tcp46_rcv_process_inline (vlib_main_t * vm, vlib_node_runtime_t * node, tc0->rcv_nxt += 1; tcp_connection_set_state (tc0, TCP_STATE_TIME_WAIT); tcp_connection_timers_reset (tc0); - tcp_timer_set (tc0, TCP_TIMER_WAITCLOSE, TCP_TIMEWAIT_TIME); + tcp_timer_set (tc0, TCP_TIMER_WAITCLOSE, tcp_cfg.timewait_time); tcp_program_ack (tc0); session_transport_closed_notify (&tc0->connection); break; @@ -2949,7 +2952,7 @@ tcp46_rcv_process_inline (vlib_main_t * vm, vlib_node_runtime_t * node, /* Remain in the TIME-WAIT state. Restart the time-wait * timeout. */ - tcp_timer_update (tc0, TCP_TIMER_WAITCLOSE, TCP_TIMEWAIT_TIME); + tcp_timer_update (tc0, TCP_TIMER_WAITCLOSE, tcp_cfg.timewait_time); break; } error0 = TCP_ERROR_FIN_RCVD; diff --git a/src/vnet/tcp/tcp_output.c b/src/vnet/tcp/tcp_output.c index ef8b756e4e8..ea4dc428187 100644 --- a/src/vnet/tcp/tcp_output.c +++ b/src/vnet/tcp/tcp_output.c @@ -85,7 +85,7 @@ void tcp_update_rcv_mss (tcp_connection_t * tc) { /* TODO find our iface MTU */ - tc->mss = tcp_main.default_mtu - sizeof (tcp_header_t); + tc->mss = tcp_cfg.default_mtu - sizeof (tcp_header_t); } /** @@ -103,7 +103,7 @@ tcp_initial_wnd_unscaled (tcp_connection_t * tc) tcp_update_rcv_mss (tc); TCP_IW_N_SEGMENTS * tc->mss; */ - return TCP_MIN_RX_FIFO_SIZE; + return tcp_cfg.min_rx_fifo; } /** @@ -113,17 +113,9 @@ tcp_initial_wnd_unscaled (tcp_connection_t * tc) u32 tcp_initial_window_to_advertise (tcp_connection_t * tc) { - tcp_main_t *tm = &tcp_main; - u32 max_fifo; - - /* Initial wnd for SYN. Fifos are not allocated yet. - * Use some predefined value. For SYN-ACK we still want the - * scale to be computed in the same way */ - max_fifo = tm->max_rx_fifo ? tm->max_rx_fifo : TCP_MAX_RX_FIFO_SIZE; - /* Compute rcv wscale only if peer advertised support for it */ if (tc->state != TCP_STATE_SYN_RCVD || tcp_opts_wscale (&tc->rcv_opts)) - tc->rcv_wscale = tcp_window_compute_scale (max_fifo); + tc->rcv_wscale = tcp_window_compute_scale (tcp_cfg.max_rx_fifo); tc->rcv_wnd = tcp_initial_wnd_unscaled (tc); @@ -276,7 +268,7 @@ tcp_make_syn_options (tcp_options_t * opts, u8 wnd_scale) u8 len = 0; opts->flags |= TCP_OPTS_FLAG_MSS; - opts->mss = tcp_main.default_mtu; /*XXX discover that */ + opts->mss = tcp_cfg.default_mtu; /*XXX discover that */ len += TCP_OPTION_LEN_MSS; opts->flags |= TCP_OPTS_FLAG_WSCALE; @@ -1529,7 +1521,7 @@ tcp_timer_retransmit_handler (u32 tc_index) tcp_connection_set_state (tc, TCP_STATE_CLOSED); session_transport_closing_notify (&tc->connection); tcp_connection_timers_reset (tc); - tcp_timer_update (tc, TCP_TIMER_WAITCLOSE, TCP_CLOSEWAIT_TIME); + tcp_timer_update (tc, TCP_TIMER_WAITCLOSE, tcp_cfg.closewait_time); return; } @@ -1581,7 +1573,7 @@ tcp_timer_retransmit_handler (u32 tc_index) { tcp_connection_set_state (tc, TCP_STATE_CLOSED); tcp_connection_timers_reset (tc); - tcp_timer_update (tc, TCP_TIMER_WAITCLOSE, TCP_CLEANUP_TIME); + tcp_timer_update (tc, TCP_TIMER_WAITCLOSE, tcp_cfg.cleanup_time); return; } |