27 #define TCP_TICK 0.001 28 #define THZ (u32) (1/TCP_TICK) 29 #define TCP_TSTAMP_RESOLUTION TCP_TICK 30 #define TCP_PAWS_IDLE 24 * 24 * 60 * 60 * THZ 31 #define TCP_FIB_RECHECK_PERIOD 1 * THZ 32 #define TCP_MAX_OPTION_SPACE 40 33 #define TCP_CC_DATA_SZ 24 35 #define TCP_DUPACK_THRESHOLD 3 36 #define TCP_IW_N_SEGMENTS 10 37 #define TCP_ALWAYS_ACK 1 38 #define TCP_USE_SACKS 1 41 #define foreach_tcp_fsm_state \ 44 _(SYN_SENT, "SYN_SENT") \ 45 _(SYN_RCVD, "SYN_RCVD") \ 46 _(ESTABLISHED, "ESTABLISHED") \ 47 _(CLOSE_WAIT, "CLOSE_WAIT") \ 48 _(FIN_WAIT_1, "FIN_WAIT_1") \ 49 _(LAST_ACK, "LAST_ACK") \ 50 _(CLOSING, "CLOSING") \ 51 _(FIN_WAIT_2, "FIN_WAIT_2") \ 52 _(TIME_WAIT, "TIME_WAIT") 54 typedef enum _tcp_state
56 #define _(sym, str) TCP_STATE_##sym, 68 #define foreach_tcp_timer \ 69 _(RETRANSMIT, "RETRANSMIT") \ 70 _(DELACK, "DELAYED ACK") \ 71 _(PERSIST, "PERSIST") \ 72 _(WAITCLOSE, "WAIT CLOSE") \ 73 _(RETRANSMIT_SYN, "RETRANSMIT SYN") \ 75 typedef enum _tcp_timers
77 #define _(sym, str) TCP_TIMER_##sym, 90 #define TCP_TIMER_HANDLE_INVALID ((u32) ~0) 92 #define TCP_TIMER_TICK 0.1 93 #define TCP_TO_TIMER_TICK TCP_TICK*10 96 #define TCP_RTO_MAX 60 * THZ 97 #define TCP_RTO_MIN 0.2 * THZ 98 #define TCP_RTT_MAX 30 * THZ 99 #define TCP_RTO_SYN_RETRIES 3 100 #define TCP_RTO_INIT 1 * THZ 101 #define TCP_RTO_BOFF_MAX 8 102 #define TCP_ESTABLISH_TIME (60 * THZ) 105 #define foreach_tcp_connection_flag \ 106 _(SNDACK, "Send ACK") \ 107 _(FINSNT, "FIN sent") \ 108 _(RECOVERY, "Recovery") \ 109 _(FAST_RECOVERY, "Fast Recovery") \ 110 _(DCNT_PENDING, "Disconnect pending") \ 111 _(HALF_OPEN_DONE, "Half-open completed") \ 112 _(FINPNDG, "FIN pending") \ 113 _(FRXT_PENDING, "Fast-retransmit pending") \ 114 _(FRXT_FIRST, "Fast-retransmit first again") \ 115 _(DEQ_PENDING, "Pending dequeue acked") \ 116 _(PSH_PENDING, "PSH pending") \ 117 _(FINRCVD, "FIN received") \ 118 _(RATE_SAMPLE, "Conn does rate sampling") \ 119 _(TRACK_BURST, "Track burst") \ 120 _(ZERO_RWND_SENT, "Zero RWND sent") \ 122 typedef enum _tcp_connection_flag_bits
124 #define _(sym, str) TCP_CONN_##sym##_BIT, 130 typedef enum _tcp_connection_flag
132 #define _(sym, str) TCP_CONN_##sym = 1 << TCP_CONN_##sym##_BIT, 138 #define TCP_SCOREBOARD_TRACE (0) 139 #define TCP_MAX_SACK_BLOCKS 256 140 #define TCP_INVALID_SACK_HOLE_INDEX ((u32)~0) 142 typedef struct _scoreboard_trace_elt
151 typedef struct _sack_scoreboard_hole
160 typedef struct _sack_scoreboard
166 u32 last_sacked_bytes;
167 u32 last_bytes_delivered;
176 #if TCP_SCOREBOARD_TRACE 182 #if TCP_SCOREBOARD_TRACE 183 #define tcp_scoreboard_trace_add(_tc, _ack) \ 185 static u64 _group = 0; \ 186 sack_scoreboard_t *_sb = &_tc->sack_sb; \ 187 sack_block_t *_sack, *_sacks; \ 188 scoreboard_trace_elt_t *_elt; \ 191 _sacks = _tc->rcv_opts.sacks; \ 192 for (i = 0; i < vec_len (_sacks); i++) \ 194 _sack = &_sacks[i]; \ 195 vec_add2 (_sb->trace, _elt, 1); \ 196 _elt->start = _sack->start; \ 197 _elt->end = _sack->end; \ 198 _elt->ack = _elt->end == _ack ? _ack : 0; \ 199 _elt->snd_una_max = _elt->end == _ack ? _tc->snd_una_max : 0; \ 200 _elt->group = _group; \ 204 #define tcp_scoreboard_trace_add(_tc, _ack) 209 start,
u8 have_sent_1_smss,
225 #define TCP_BTS_INVALID_INDEX ((u32)~0) 269 typedef enum _tcp_cc_algorithm_type
278 typedef enum _tcp_cc_ack_t
301 typedef struct _tcp_connection
340 u32 tsval_recent_age;
387 u32 next_node_opaque;
388 u32 limited_transmit;
406 struct _tcp_cc_algorithm
423 #define tcp_fastrecovery_on(tc) (tc)->flags |= TCP_CONN_FAST_RECOVERY 424 #define tcp_fastrecovery_off(tc) (tc)->flags &= ~TCP_CONN_FAST_RECOVERY 425 #define tcp_recovery_on(tc) (tc)->flags |= TCP_CONN_RECOVERY 426 #define tcp_recovery_off(tc) (tc)->flags &= ~TCP_CONN_RECOVERY 427 #define tcp_in_fastrecovery(tc) ((tc)->flags & TCP_CONN_FAST_RECOVERY) 428 #define tcp_in_recovery(tc) ((tc)->flags & (TCP_CONN_RECOVERY)) 429 #define tcp_in_slowstart(tc) (tc->cwnd < tc->ssthresh) 430 #define tcp_disconnect_pending(tc) ((tc)->flags & TCP_CONN_DCNT_PENDING) 431 #define tcp_disconnect_pending_on(tc) ((tc)->flags |= TCP_CONN_DCNT_PENDING) 432 #define tcp_disconnect_pending_off(tc) ((tc)->flags &= ~TCP_CONN_DCNT_PENDING) 433 #define tcp_fastrecovery_first(tc) ((tc)->flags & TCP_CONN_FRXT_FIRST) 434 #define tcp_fastrecovery_first_on(tc) ((tc)->flags |= TCP_CONN_FRXT_FIRST) 435 #define tcp_fastrecovery_first_off(tc) ((tc)->flags &= ~TCP_CONN_FRXT_FIRST) 437 #define tcp_in_cong_recovery(tc) ((tc)->flags & \ 438 (TCP_CONN_FAST_RECOVERY | TCP_CONN_RECOVERY)) 443 tc->flags &= ~(TCP_CONN_FAST_RECOVERY | TCP_CONN_RECOVERY);
447 #define tcp_zero_rwnd_sent(tc) ((tc)->flags & TCP_CONN_ZERO_RWND_SENT) 448 #define tcp_zero_rwnd_sent_on(tc) (tc)->flags |= TCP_CONN_ZERO_RWND_SENT 449 #define tcp_zero_rwnd_sent_off(tc) (tc)->flags &= ~TCP_CONN_ZERO_RWND_SENT 451 typedef enum _tcp_error
453 #define tcp_error(n,s) TCP_ERROR_##n, 459 typedef struct _tcp_lookup_dispatch
471 tw_timer_wheel_16t_2w_512sl_t timer_wheel;
483 u32 *pending_deq_acked;
486 u32 *pending_disconnects;
518 u16 initial_cwnd_multiplier;
551 u32 preallocated_connections;
554 u32 preallocated_half_open_connections;
561 f64 buffer_fail_fraction;
564 typedef struct _tcp_main
575 u8 log2_tstamp_clocks_per_tick;
576 f64 tstamp_ticks_per_clock;
586 u32 bytes_per_buffer;
595 uword *cc_algo_by_name;
610 u32 last_v4_addr_rotor;
613 u32 last_v6_addr_rotor;
633 #define tcp_cfg tcp_main.cfg 634 #define tcp_node_index(node_id, is_ip4) \ 635 ((is_ip4) ? tcp4_##node_id##_node.index : tcp6_##node_id##_node.index) 646 return &
tcp_main.wrk_ctx[thread_index];
657 #if (VLIB_BUFFER_TRACE_TRAJECTORY) 658 #define tcp_trajectory_add_start(b, start) \ 660 (*vlib_buffer_trace_trajectory_cb) (b, start); \ 663 #define tcp_trajectory_add_start(b, start) 682 if (
tcp_main.connections[thread_index] == 0)
738 u32 thread_index,
u8 is_ip4);
821 #define seq_lt(_s1, _s2) ((i32)((_s1)-(_s2)) < 0) 822 #define seq_leq(_s1, _s2) ((i32)((_s1)-(_s2)) <= 0) 823 #define seq_gt(_s1, _s2) ((i32)((_s1)-(_s2)) > 0) 824 #define seq_geq(_s1, _s2) ((i32)((_s1)-(_s2)) >= 0) 825 #define seq_max(_s1, _s2) (seq_gt((_s1), (_s2)) ? (_s1) : (_s2)) 828 #define timestamp_lt(_t1, _t2) ((i32)((_t1)-(_t2)) < 0) 829 #define timestamp_leq(_t1, _t2) ((i32)((_t1)-(_t2)) <= 0) 838 return tc->sack_sb.sacked_bytes + tc->sack_sb.lost_bytes;
840 return tc->rcv_dupacks * tc->snd_mss;
851 flight_size = (int) (tc->snd_nxt - tc->snd_una) -
tcp_bytes_out (tc)
858 (
"Negative: %u %u %u dupacks %u sacked bytes %u flags %d",
860 tc->snd_rxt_bytes, tc->rcv_dupacks, tc->sack_sb.sacked_bytes,
874 if (
tcp_cfg.initial_cwnd_multiplier > 0)
875 return tcp_cfg.initial_cwnd_multiplier * tc->snd_mss;
877 if (tc->snd_mss > 2190)
878 return 2 * tc->snd_mss;
879 else if (tc->snd_mss > 1095)
880 return 3 * tc->snd_mss;
882 return 4 * tc->snd_mss;
894 tc->cwnd_acc_bytes += bytes;
895 if (tc->cwnd_acc_bytes >= thresh)
897 u32 inc = tc->cwnd_acc_bytes / thresh;
898 tc->cwnd_acc_bytes -= inc * thresh;
899 tc->cwnd += inc * tc->snd_mss;
900 tc->cwnd =
clib_min (tc->cwnd, tc->tx_fifo_size);
913 return clib_min (tc->cwnd, tc->snd_wnd);
920 int flight_size = (int) (tc->snd_nxt - tc->snd_una);
922 if (available_wnd <= flight_size)
925 return available_wnd - flight_size;
937 if (available_wnd <= flight_size)
940 return available_wnd - flight_size;
946 if ((tc->flags & TCP_CONN_FINSNT) && tc->snd_una_max - tc->snd_una == 1)
978 return tcp_main.wrk_ctx[thread_index].time_now;
987 return (
tcp_main.wrk_ctx[tc->c_thread_index].time_now -
988 tc->timestamp_delta);
1019 tc->cc_algo->rcv_ack (tc, rs);
1020 tc->tsecr_last_ack = tc->rcv_opts.tsecr;
1027 tc->cc_algo->rcv_cong_ack (tc, ack_type, rs);
1033 tc->cc_algo->loss (tc);
1039 tc->cc_algo->recovered (tc);
1045 if (tc->cc_algo->undo_recovery)
1046 tc->cc_algo->undo_recovery (tc);
1052 if (tc->cc_algo->event)
1053 tc->cc_algo->event (tc, evt);
1061 tc->timers[timer_id] =
1062 tw_timer_start_16t_2w_512sl (&
tcp_main.
1063 wrk_ctx[tc->c_thread_index].timer_wheel,
1064 tc->c_c_index, timer_id, interval);
1074 tw_timer_stop_16t_2w_512sl (&
tcp_main.
1075 wrk_ctx[tc->c_thread_index].timer_wheel,
1076 tc->timers[timer_id]);
1085 tw_timer_update_16t_2w_512sl (&
tcp_main.
1086 wrk_ctx[tc->c_thread_index].timer_wheel,
1087 tc->timers[timer_id], interval);
1089 tc->timers[timer_id] =
1090 tw_timer_start_16t_2w_512sl (&
tcp_main.
1091 wrk_ctx[tc->c_thread_index].timer_wheel,
1092 tc->c_c_index, timer_id, interval);
1098 ASSERT (tc->snd_una != tc->snd_una_max);
1140 if (tc->snd_una == tc->snd_nxt)
1143 if (tc->snd_wnd < tc->snd_mss)
1157 #define tcp_validate_txf_size(_tc, _a) \ 1158 ASSERT(_tc->state != TCP_STATE_ESTABLISHED \ 1159 || transport_max_tx_dequeue (&_tc->connection) >= _a) 1176 static inline void *
1179 return (
void *) tc->cc_data;
1211 th->seq_number = seq;
1212 th->ack_number = ack;
1213 th->data_offset_and_reserved = (tcp_hdr_opts_len >> 2) << 4;
1217 th->urgent_pointer = 0;
1240 clib_host_to_net_u32 (seq),
1241 clib_host_to_net_u32 (ack),
1242 tcp_hdr_opts_len,
flags,
1243 clib_host_to_net_u16 (wnd));
vlib_node_registration_t tcp6_listen_node
(constructor) VLIB_REGISTER_NODE (tcp6_listen_node)
static vlib_cli_command_t trace
(constructor) VLIB_CLI_COMMAND (trace)
#define CLIB_CACHE_LINE_ALIGN_MARK(mark)
void tcp_send_window_update_ack(tcp_connection_t *tc)
Send Window Update ACK, ensuring that it will be sent once, if RWND became non-zero, after zero RWND has been advertised in ACK before.
void scoreboard_clear(sack_scoreboard_t *sb)
static f64 tcp_time_now_us(u32 thread_index)
static void tcp_retransmit_timer_set(tcp_connection_t *tc)
void tcp_make_fin(tcp_connection_t *tc, vlib_buffer_t *b)
Convert buffer to FIN-ACK.
struct _sack_block sack_block_t
void tcp_cc_init_congestion(tcp_connection_t *tc)
Init loss recovery/fast recovery.
struct _scoreboard_trace_elt scoreboard_trace_elt_t
void tcp_connection_timers_reset(tcp_connection_t *tc)
Stop all connection timers.
static f64 transport_time_now(u32 thread_index)
#define TCP_TO_TIMER_TICK
Factor for converting ticks to timer ticks.
vlib_node_registration_t tcp4_output_node
(constructor) VLIB_REGISTER_NODE (tcp4_output_node)
void scoreboard_init(sack_scoreboard_t *sb)
static u32 tcp_bytes_out(const tcp_connection_t *tc)
Our estimate of the number of bytes that have left the network.
i16 current_data
signed offset in data[], pre_data[] that we are currently processing.
static tcp_connection_t * tcp_connection_get_if_valid(u32 conn_index, u32 thread_index)
void tcp_connection_del(tcp_connection_t *tc)
Connection removal.
struct _sack_scoreboard sack_scoreboard_t
void tcp_update_sack_list(tcp_connection_t *tc, u32 start, u32 end)
Build SACK list as per RFC2018.
enum tcp_bts_flags_ tcp_bts_flags_t
u32 tcp_snd_space(tcp_connection_t *tc)
int tcp_bt_is_sane(tcp_byte_tracker_t *bt)
Check if the byte tracker is in sane state.
static tcp_connection_t * tcp_half_open_connection_get(u32 conn_index)
sack_scoreboard_hole_t * scoreboard_last_hole(sack_scoreboard_t *sb)
sack_scoreboard_hole_t * scoreboard_next_hole(sack_scoreboard_t *sb, sack_scoreboard_hole_t *hole)
#define VLIB_BUFFER_PRE_DATA_SIZE
static_always_inline void clib_spinlock_unlock_if_init(clib_spinlock_t *p)
struct _tcp_main tcp_main_t
vlib_node_registration_t tcp6_output_node
(constructor) VLIB_REGISTER_NODE (tcp6_output_node)
static u64 clib_cpu_time_now(void)
timer_expiration_handler tcp_timer_retransmit_handler
u8 * format_tcp_scoreboard(u8 *s, va_list *args)
u32 tcp_session_push_header(transport_connection_t *tconn, vlib_buffer_t *b)
struct _tcp_lookup_dispatch tcp_lookup_dispatch_t
void tcp_connection_tx_pacer_update(tcp_connection_t *tc)
enum tcp_cc_event_ tcp_cc_event_t
void tcp_update_burst_snd_vars(tcp_connection_t *tc)
Update burst send vars.
struct _tcp_connection tcp_connection_t
static u32 tcp_available_cc_snd_space(const tcp_connection_t *tc)
Estimate of how many bytes we can still push into the network.
static u32 tcp_available_snd_wnd(const tcp_connection_t *tc)
static tcp_connection_t * tcp_get_connection_from_transport(transport_connection_t *tconn)
void tcp_connection_cleanup(tcp_connection_t *tc)
Cleans up connection state.
format_function_t format_tcp_flags
struct _tcp_header tcp_header_t
void tcp_connection_reset(tcp_connection_t *tc)
Notify session that connection has been reset.
struct _sack_scoreboard_hole sack_scoreboard_hole_t
vlib_node_registration_t tcp4_syn_sent_node
(constructor) VLIB_REGISTER_NODE (tcp4_syn_sent_node)
u8 * tcp_scoreboard_replay(u8 *s, tcp_connection_t *tc, u8 verbose)
static void tcp_connection_set_state(tcp_connection_t *tc, tcp_state_t state)
vl_api_interface_index_t sw_if_index
sack_scoreboard_hole_t * scoreboard_get_hole(sack_scoreboard_t *sb, u32 index)
struct tcp_bt_sample_ tcp_bt_sample_t
static u32 tcp_available_output_snd_space(const tcp_connection_t *tc)
int tcp_retransmit_first_unacked(tcp_worker_ctx_t *wrk, tcp_connection_t *tc)
Retransmit first unacked segment.
static void tcp_cc_loss(tcp_connection_t *tc)
static tcp_header_t * tcp_buffer_hdr(vlib_buffer_t *b)
enum _tcp_state tcp_state_t
vhost_vring_state_t state
timer_expiration_handler tcp_timer_retransmit_syn_handler
static u32 tcp_time_now(void)
static ct_connection_t * connections
sack_scoreboard_hole_t * scoreboard_next_rxt_hole(sack_scoreboard_t *sb, sack_scoreboard_hole_t *start, u8 have_sent_1_smss, u8 *can_rescue, u8 *snd_limited)
Figure out the next hole to retransmit.
void tcp_api_reference(void)
#define TCP_EVT_DBG(_evt, _args...)
struct tcp_byte_tracker_ tcp_byte_tracker_t
static void tcp_timer_set(tcp_connection_t *tc, u8 timer_id, u32 interval)
static heap_elt_t * first(heap_header_t *h)
vl_api_fib_path_type_t type
struct tcp_worker_ctx_ tcp_worker_ctx_t
#define pool_elt_at_index(p, i)
Returns pointer to element at given index.
void tcp_bt_init(tcp_connection_t *tc)
Byte tracker initialize.
timer_expiration_handler tcp_timer_persist_handler
vlib_node_registration_t tcp6_syn_sent_node
(constructor) VLIB_REGISTER_NODE (tcp6_syn_sent_node)
u32 tcp_sack_list_bytes(tcp_connection_t *tc)
static void * vlib_buffer_push_tcp_net_order(vlib_buffer_t *b, u16 sp, u16 dp, u32 seq, u32 ack, u8 tcp_hdr_opts_len, u8 flags, u16 wnd)
Push TCP header to buffer.
void tcp_rcv_sacks(tcp_connection_t *tc, u32 ack)
int tcp_fast_retransmit_sack(tcp_worker_ctx_t *wrk, tcp_connection_t *tc, u32 burst_size)
Do fast retransmit with SACKs.
clib_error_t * vnet_tcp_enable_disable(vlib_main_t *vm, u8 is_en)
void tcp_send_syn(tcp_connection_t *tc)
Send SYN.
static void * tcp_cc_data(tcp_connection_t *tc)
sack_scoreboard_hole_t * scoreboard_prev_hole(sack_scoreboard_t *sb, sack_scoreboard_hole_t *hole)
static void cleanup(void)
#define TCP_TIMER_HANDLE_INVALID
static void tcp_cc_rcv_cong_ack(tcp_connection_t *tc, tcp_cc_ack_t ack_type, tcp_rate_sample_t *rs)
static u32 tcp_flight_size(const tcp_connection_t *tc)
Our estimate of the number of bytes in flight (pipe size)
tcp_connection_t * tcp_connection_alloc(u8 thread_index)
void tcp_connection_tx_pacer_reset(tcp_connection_t *tc, u32 window, u32 start_bucket)
void tcp_cc_algo_register(tcp_cc_algorithm_type_e type, const tcp_cc_algorithm_t *vft)
Register exiting cc algo type.
void( timer_expiration_handler)(u32 index)
enum _tcp_cc_ack_t tcp_cc_ack_t
static void tcp_cwnd_accumulate(tcp_connection_t *tc, u32 thresh, u32 bytes)
void newreno_rcv_cong_ack(tcp_connection_t *tc, tcp_cc_ack_t ack_type, tcp_rate_sample_t *rs)
static void tcp_timer_reset(tcp_connection_t *tc, u8 timer_id)
vlib_node_registration_t tcp4_listen_node
(constructor) VLIB_REGISTER_NODE (tcp4_listen_node)
enum _tcp_error tcp_error_t
static void * vlib_buffer_push_tcp(vlib_buffer_t *b, u16 sp_net, u16 dp_net, u32 seq, u32 ack, u8 tcp_hdr_opts_len, u8 flags, u16 wnd)
Push TCP header to buffer.
int tcp_configure_v4_source_address_range(vlib_main_t *vm, ip4_address_t *start, ip4_address_t *end, u32 table_id)
Configure an ipv4 source address range.
static_always_inline uword vlib_get_thread_index(void)
void tcp_program_dupack(tcp_connection_t *tc)
void tcp_send_reset(tcp_connection_t *tc)
Build and set reset packet for connection.
static u32 tcp_tstamp(tcp_connection_t *tc)
Generate timestamp for tcp connection.
void tcp_bt_track_tx(tcp_connection_t *tc)
Track a tcp tx burst.
void tcp_punt_unknown(vlib_main_t *vm, u8 is_ip4, u8 is_add)
format_function_t format_tcp_state
static void tcp_cc_undo_recovery(tcp_connection_t *tc)
#define clib_warning(format, args...)
enum _tcp_timers tcp_timers_e
struct _transport_connection transport_connection_t
int tcp_half_open_connection_cleanup(tcp_connection_t *tc)
Try to cleanup half-open connection.
u32 fib_node_index_t
A typedef of a node index.
void tcp_connection_timers_init(tcp_connection_t *tc)
Initialize all connection timers as invalid.
void tcp_make_synack(tcp_connection_t *ts, vlib_buffer_t *b)
Convert buffer to SYN-ACK.
#define pool_is_free_index(P, I)
Use free bitmap to query whether given index is free.
format_function_t format_tcp_rcv_sacks
vlib_node_registration_t tcp6_input_node
(constructor) VLIB_REGISTER_NODE (tcp6_input_node)
fib_node_index_t tcp_lookup_rmt_in_fib(tcp_connection_t *tc)
void tcp_send_synack(tcp_connection_t *tc)
static void tcp_timer_update(tcp_connection_t *tc, u8 timer_id, u32 interval)
enum _tcp_cc_algorithm_type tcp_cc_algorithm_type_e
struct tcp_rate_sample_ tcp_rate_sample_t
void tcp_flush_frames_to_output(tcp_worker_ctx_t *wrk)
Flush v4 and v6 tcp and ip-lookup tx frames for thread index.
enum _tcp_connection_flag_bits tcp_connection_flag_bits_e
void tcp_connection_init_vars(tcp_connection_t *tc)
Initialize tcp connection variables.
void tcp_bt_sample_delivery_rate(tcp_connection_t *tc, tcp_rate_sample_t *rs)
Generate a delivery rate sample from recently acked bytes.
vlib_node_registration_t tcp4_rcv_process_node
(constructor) VLIB_REGISTER_NODE (tcp4_rcv_process_node)
u8 * format_tcp_connection(u8 *s, va_list *args)
static u32 tcp_end_seq(tcp_header_t *th, u32 len)
vlib_node_registration_t tcp6_established_node
(constructor) VLIB_REGISTER_NODE (tcp6_established_node)
#define tcp_fastrecovery_first_off(tc)
void tcp_flush_frame_to_output(tcp_worker_ctx_t *wrk, u8 is_ip4)
Flush tx frame populated by retransmits and timer pops.
struct _tcp_cc_algorithm tcp_cc_algorithm_t
static u32 tcp_time_now_w_thread(u32 thread_index)
void tcp_cc_fastrecovery_clear(tcp_connection_t *tc)
struct _vlib_node_registration vlib_node_registration_t
struct tcp_iss_seed_ tcp_iss_seed_t
static void tcp_persist_timer_update(tcp_connection_t *tc)
void tcp_send_reset_w_pkt(tcp_connection_t *tc, vlib_buffer_t *pkt, u32 thread_index, u8 is_ip4)
Send reset without reusing existing buffer.
static void * vlib_buffer_push_uninit(vlib_buffer_t *b, u8 size)
Prepend uninitialized data to buffer.
void tcp_bt_check_app_limited(tcp_connection_t *tc)
Check if sample to be generated is app limited.
vlib_node_registration_t tcp4_input_node
(constructor) VLIB_REGISTER_NODE (tcp4_input_node)
tcp_cc_algorithm_t * tcp_cc_algo_get(tcp_cc_algorithm_type_e type)
static u32 tcp_initial_cwnd(const tcp_connection_t *tc)
Initial cwnd as per RFC5681.
vlib_node_registration_t tcp6_rcv_process_node
(constructor) VLIB_REGISTER_NODE (tcp6_rcv_process_node)
#define foreach_tcp_fsm_state
TCP FSM state definitions as per RFC793.
void tcp_send_fin(tcp_connection_t *tc)
Send FIN.
#define foreach_tcp_connection_flag
TCP connection flags.
#define foreach_tcp_timer
TCP timers.
static u8 tcp_is_lost_fin(tcp_connection_t *tc)
static void tcp_cc_rcv_ack(tcp_connection_t *tc, tcp_rate_sample_t *rs)
sack_scoreboard_hole_t * scoreboard_first_hole(sack_scoreboard_t *sb)
static tcp_worker_ctx_t * tcp_get_worker(u32 thread_index)
static void tcp_retransmit_timer_update(tcp_connection_t *tc)
VLIB buffer representation.
int tcp_fast_retransmit_no_sack(tcp_worker_ctx_t *wrk, tcp_connection_t *tc, u32 burst_size)
Fast retransmit without SACK info.
int tcp_fast_retransmit(tcp_worker_ctx_t *wrk, tcp_connection_t *tc, u32 burst_size)
Do fast retransmit.
static void tcp_cc_recovered(tcp_connection_t *tc)
void tcp_init_snd_vars(tcp_connection_t *tc)
Initialize connection send variables.
struct tcp_configuration_ tcp_configuration_t
void tcp_connection_close(tcp_connection_t *tc)
Begin connection closing procedure.
void tcp_program_fastretransmit(tcp_connection_t *tc)
static void tcp_retransmit_timer_force_update(tcp_connection_t *tc)
static tcp_connection_t * tcp_connection_get(u32 conn_index, u32 thread_index)
static void tcp_cc_event(tcp_connection_t *tc, tcp_cc_event_t evt)
void tcp_update_rto(tcp_connection_t *tc)
void tcp_init_mss(tcp_connection_t *tc)
enum _tcp_connection_flag tcp_connection_flags_e
format_function_t format_tcp_sacks
tcp_cc_algorithm_type_e tcp_cc_algo_new_type(const tcp_cc_algorithm_t *vft)
Register new cc algo type.
void tcp_program_ack(tcp_connection_t *tc)
#define tcp_opts_sack_permitted(_to)
static u32 tcp_loss_wnd(const tcp_connection_t *tc)
struct tcp_errors_ tcp_errors_t
int tcp_configure_v6_source_address_range(vlib_main_t *vm, ip6_address_t *start, ip6_address_t *end, u32 table_id)
Configure an ipv6 source address range.
static void tcp_persist_timer_set(tcp_connection_t *tc)
static tcp_main_t * vnet_get_tcp_main()
static void tcp_cong_recovery_off(tcp_connection_t *tc)
timer_expiration_handler tcp_timer_delack_handler
void tcp_connection_free(tcp_connection_t *tc)
static_always_inline void clib_spinlock_lock_if_init(clib_spinlock_t *p)
static void tcp_retransmit_timer_reset(tcp_connection_t *tc)
static u32 tcp_set_time_now(tcp_worker_ctx_t *wrk)
void tcp_bt_track_rxt(tcp_connection_t *tc, u32 start, u32 end)
Track a tcp retransmission.
void tcp_bt_flush_samples(tcp_connection_t *tc)
Flush byte tracker samples.
static u8 tcp_timer_is_active(tcp_connection_t *tc, tcp_timers_e timer)
void tcp_bt_cleanup(tcp_connection_t *tc)
Byte tracker cleanup.
static tcp_connection_t * tcp_listener_get(u32 tli)
vlib_node_registration_t tcp4_established_node
(constructor) VLIB_REGISTER_NODE (tcp4_established_node)
static void tcp_persist_timer_reset(tcp_connection_t *tc)
int tcp_session_custom_tx(void *conn, u32 max_burst_size)