summaryrefslogtreecommitdiffstats
path: root/src/vnet
diff options
context:
space:
mode:
authorFlorin Coras <fcoras@cisco.com>2018-11-01 11:23:03 -0700
committerMarco Varlese <marco.varlese@suse.de>2018-11-02 08:06:46 +0000
commitbe72ae6149a432899698a887b1820cf5c9d9456f (patch)
treee88cc5bbbcccaee305ef21ec040a6331c643e780 /src/vnet
parentbf9f02cd395387bc596f1dab5e3566f6c5573eda (diff)
tcp: minimize use of tls
Also propagate tcp worker context instead of retrieving it multiple times. Change-Id: I7b273b981826b37783566d0172a64cd6957f3b33 Signed-off-by: Florin Coras <fcoras@cisco.com>
Diffstat (limited to 'src/vnet')
-rw-r--r--src/vnet/tcp/tcp.c50
-rw-r--r--src/vnet/tcp/tcp.h40
-rw-r--r--src/vnet/tcp/tcp_input.c32
-rw-r--r--src/vnet/tcp/tcp_output.c271
4 files changed, 195 insertions, 198 deletions
diff --git a/src/vnet/tcp/tcp.c b/src/vnet/tcp/tcp.c
index bdf9c7af608..1726355f0e3 100644
--- a/src/vnet/tcp/tcp.c
+++ b/src/vnet/tcp/tcp.c
@@ -546,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);
@@ -1113,12 +1113,12 @@ tcp_session_tx_fifo_offset (transport_connection_t * trans_conn)
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.
- wrk_ctx[thread_index].timer_wheel,
- now);
- tcp_do_fastretransmits (thread_index);
- 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_flush_frames_to_output (wrk);
}
static u32
@@ -1291,13 +1291,12 @@ tcp_initialize_timer_wheels (tcp_main_t * tm)
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;
@@ -1320,27 +1319,11 @@ 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, 0);
vec_validate (tm->wrk_ctx[thread].ongoing_fast_rxt, 0);
vec_validate (tm->wrk_ctx[thread].postponed_fast_rxt, 0);
@@ -1348,6 +1331,13 @@ tcp_main_enable (vlib_main_t * vm)
vec_reset_length (tm->wrk_ctx[thread].ongoing_fast_rxt);
vec_reset_length (tm->wrk_ctx[thread].postponed_fast_rxt);
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);
}
/*
diff --git a/src/vnet/tcp/tcp.h b/src/vnet/tcp/tcp.h
index f7424c3202e..71af461aca3 100644
--- a/src/vnet/tcp/tcp.h
+++ b/src/vnet/tcp/tcp.h
@@ -470,6 +470,12 @@ vnet_get_tcp_main ()
return &tcp_main;
}
+always_inline tcp_worker_ctx_t *
+tcp_get_worker (u32 thread_index)
+{
+ return &tcp_main.wrk_ctx[thread_index];
+}
+
always_inline tcp_header_t *
tcp_buffer_hdr (vlib_buffer_t * b)
{
@@ -559,10 +565,11 @@ void tcp_send_fin (tcp_connection_t * tc);
void tcp_init_mss (tcp_connection_t * tc);
void tcp_update_burst_snd_vars (tcp_connection_t * tc);
void tcp_update_rto (tcp_connection_t * tc);
-void tcp_flush_frame_to_output (vlib_main_t * vm, u8 thread_index, u8 is_ip4);
-void tcp_flush_frames_to_output (u8 thread_index);
-void tcp_program_fastretransmit (tcp_connection_t * tc);
-void tcp_do_fastretransmits (u32 thread_index);
+void tcp_flush_frame_to_output (tcp_worker_ctx_t * wrk, u8 is_ip4);
+void tcp_flush_frames_to_output (tcp_worker_ctx_t * wrk);
+void tcp_program_fastretransmit (tcp_worker_ctx_t * wrk,
+ tcp_connection_t * tc);
+void tcp_do_fastretransmits (tcp_worker_ctx_t * wrk);
always_inline u32
tcp_end_seq (tcp_header_t * th, u32 len)
@@ -680,10 +687,14 @@ tcp_is_lost_fin (tcp_connection_t * tc)
}
u32 tcp_snd_space (tcp_connection_t * tc);
-int tcp_retransmit_first_unacked (tcp_connection_t * tc);
-int tcp_fast_retransmit_no_sack (tcp_connection_t * tc, u32 burst_size);
-int tcp_fast_retransmit_sack (tcp_connection_t * tc, u32 burst_size);
-int tcp_fast_retransmit (tcp_connection_t * tc, u32 burst_size);
+int tcp_retransmit_first_unacked (tcp_worker_ctx_t * wrk,
+ tcp_connection_t * tc);
+int tcp_fast_retransmit_no_sack (tcp_worker_ctx_t * wrk,
+ tcp_connection_t * tc, u32 burst_size);
+int tcp_fast_retransmit_sack (tcp_worker_ctx_t * wrk, tcp_connection_t * tc,
+ u32 burst_size);
+int tcp_fast_retransmit (tcp_worker_ctx_t * wrk, tcp_connection_t * tc,
+ u32 burst_size);
void tcp_cc_init_congestion (tcp_connection_t * tc);
void tcp_cc_fastrecovery_exit (tcp_connection_t * tc);
@@ -699,6 +710,12 @@ tcp_time_now (void)
return tcp_main.wrk_ctx[vlib_get_thread_index ()].time_now;
}
+always_inline u32
+tcp_time_now_w_thread (u32 thread_index)
+{
+ return tcp_main.wrk_ctx[thread_index].time_now;
+}
+
always_inline f64
tcp_time_now_us (u32 thread_index)
{
@@ -706,11 +723,10 @@ tcp_time_now_us (u32 thread_index)
}
always_inline u32
-tcp_set_time_now (u32 thread_index)
+tcp_set_time_now (tcp_worker_ctx_t * wrk)
{
- tcp_main.wrk_ctx[thread_index].time_now = clib_cpu_time_now ()
- * tcp_main.tstamp_ticks_per_clock;
- return tcp_main.wrk_ctx[thread_index].time_now;
+ wrk->time_now = clib_cpu_time_now () * tcp_main.tstamp_ticks_per_clock;
+ return wrk->time_now;
}
u32 tcp_push_header (tcp_connection_t * tconn, vlib_buffer_t * b);
diff --git a/src/vnet/tcp/tcp_input.c b/src/vnet/tcp/tcp_input.c
index 154b9ac8363..af13c5f8215 100644
--- a/src/vnet/tcp/tcp_input.c
+++ b/src/vnet/tcp/tcp_input.c
@@ -258,7 +258,7 @@ tcp_update_timestamp (tcp_connection_t * tc, u32 seq, u32 seq_end)
{
ASSERT (timestamp_leq (tc->tsval_recent, tc->rcv_opts.tsval));
tc->tsval_recent = tc->rcv_opts.tsval;
- tc->tsval_recent_age = tcp_time_now ();
+ tc->tsval_recent_age = tcp_time_now_w_thread (tc->c_thread_index);
}
}
@@ -308,7 +308,7 @@ tcp_segment_validate (vlib_main_t * vm, tcp_connection_t * tc0,
/* If it just so happens that a segment updates tsval_recent for a
* segment over 24 days old, invalidate tsval_recent. */
if (timestamp_lt (tc0->tsval_recent_age + TCP_PAWS_IDLE,
- tcp_time_now ()))
+ tcp_time_now_w_thread (tc0->c_thread_index)))
{
/* Age isn't reset until we get a valid tsval (bsd inspired) */
tc0->tsval_recent = 0;
@@ -470,7 +470,8 @@ tcp_update_rtt (tcp_connection_t * tc, u32 ack)
* seq_lt (tc->snd_una, ack). This is a condition for calling update_rtt */
else if (tcp_opts_tstamp (&tc->rcv_opts) && tc->rcv_opts.tsecr)
{
- mrtt = clib_max (tcp_time_now () - tc->rcv_opts.tsecr, 1);
+ u32 now = tcp_time_now_w_thread (tc->c_thread_index);
+ mrtt = clib_max (now - tc->rcv_opts.tsecr, 1);
}
/* Ignore dubious measurements */
@@ -1185,9 +1186,8 @@ tcp_should_fastrecover (tcp_connection_t * tc)
}
void
-tcp_program_fastretransmit (tcp_connection_t * tc)
+tcp_program_fastretransmit (tcp_worker_ctx_t * wrk, tcp_connection_t * tc)
{
- tcp_worker_ctx_t *wrk = &tcp_main.wrk_ctx[tc->c_thread_index];
if (!(tc->flags & TCP_CONN_FRXT_PENDING))
{
vec_add1 (wrk->pending_fast_rxt, tc->c_c_index);
@@ -1196,11 +1196,10 @@ tcp_program_fastretransmit (tcp_connection_t * tc)
}
void
-tcp_do_fastretransmits (u32 thread_index)
+tcp_do_fastretransmits (tcp_worker_ctx_t * wrk)
{
- tcp_worker_ctx_t *wrk = &tcp_main.wrk_ctx[thread_index];
+ u32 *ongoing_fast_rxt, burst_bytes, sent_bytes, thread_index;
u32 max_burst_size, burst_size, n_segs = 0, n_segs_now;
- u32 *ongoing_fast_rxt, burst_bytes, sent_bytes;
tcp_connection_t *tc;
u64 last_cpu_time;
int i;
@@ -1209,6 +1208,7 @@ tcp_do_fastretransmits (u32 thread_index)
&& vec_len (wrk->postponed_fast_rxt) == 0)
return;
+ thread_index = wrk->vm->thread_index;
last_cpu_time = wrk->vm->clib_time.last_cpu_time;
ongoing_fast_rxt = wrk->ongoing_fast_rxt;
vec_append (ongoing_fast_rxt, wrk->postponed_fast_rxt);
@@ -1240,15 +1240,14 @@ tcp_do_fastretransmits (u32 thread_index)
burst_size = clib_min (burst_size, burst_bytes / tc->snd_mss);
if (!burst_size)
{
- tcp_program_fastretransmit (tc);
+ tcp_program_fastretransmit (wrk, tc);
continue;
}
- n_segs_now = tcp_fast_retransmit (tc, burst_size);
+ n_segs_now = tcp_fast_retransmit (wrk, tc, burst_size);
sent_bytes = clib_min (n_segs_now * tc->snd_mss, burst_bytes);
transport_connection_tx_pacer_update_bytes (&tc->connection,
sent_bytes);
-
n_segs += n_segs_now;
}
_vec_len (ongoing_fast_rxt) = 0;
@@ -1267,7 +1266,7 @@ tcp_cc_handle_event (tcp_connection_t * tc, u32 is_dack)
{
if (tc->bytes_acked)
goto partial_ack;
- tcp_program_fastretransmit (tc);
+ tcp_program_fastretransmit (tcp_get_worker (tc->c_thread_index), tc);
return;
}
/*
@@ -1322,7 +1321,8 @@ tcp_cc_handle_event (tcp_connection_t * tc, u32 is_dack)
byte_rate = (0.3 * tc->cwnd) / ((f64) TCP_TICK * tc->srtt);
transport_connection_tx_pacer_init (&tc->connection, byte_rate, 0);
- tcp_program_fastretransmit (tc);
+ tcp_program_fastretransmit (tcp_get_worker (tc->c_thread_index),
+ tc);
return;
}
else if (!tc->bytes_acked
@@ -1439,7 +1439,7 @@ partial_ack:
/*
* Since this was a partial ack, try to retransmit some more data
*/
- tcp_program_fastretransmit (tc);
+ tcp_program_fastretransmit (tcp_get_worker (tc->c_thread_index), tc);
}
/**
@@ -2102,7 +2102,7 @@ tcp46_established_inline (vlib_main_t * vm, vlib_node_runtime_t * node,
thread_index);
err_counters[TCP_ERROR_EVENT_FIFO_FULL] = errors;
tcp_store_err_counters (established, err_counters);
- tcp_flush_frame_to_output (vm, thread_index, is_ip4);
+ tcp_flush_frame_to_output (tcp_get_worker (thread_index), is_ip4);
return frame->n_vectors;
}
@@ -3393,7 +3393,7 @@ tcp46_input_inline (vlib_main_t * vm, vlib_node_runtime_t * node,
vlib_buffer_t *bufs[VLIB_FRAME_SIZE], **b;
u16 nexts[VLIB_FRAME_SIZE], *next;
- tcp_set_time_now (thread_index);
+ tcp_set_time_now (tcp_get_worker (thread_index));
from = vlib_frame_vector_args (frame);
n_left_from = frame->n_vectors;
diff --git a/src/vnet/tcp/tcp_output.c b/src/vnet/tcp/tcp_output.c
index 81579ef96a2..c315c031c97 100644
--- a/src/vnet/tcp/tcp_output.c
+++ b/src/vnet/tcp/tcp_output.c
@@ -361,7 +361,7 @@ tcp_make_established_options (tcp_connection_t * tc, tcp_options_t * opts)
if (tcp_opts_tstamp (&tc->rcv_opts))
{
opts->flags |= TCP_OPTS_FLAG_TSTAMP;
- opts->tsval = tcp_time_now ();
+ opts->tsval = tcp_time_now_w_thread (tc->c_thread_index);
opts->tsecr = tc->tsval_recent;
len += TCP_OPTION_LEN_TIMESTAMP;
}
@@ -459,41 +459,37 @@ tcp_init_mss (tcp_connection_t * tc)
}
static int
-tcp_alloc_tx_buffers (tcp_main_t * tm, u8 thread_index, u16 * n_bufs,
- u32 wanted)
+tcp_alloc_tx_buffers (tcp_worker_ctx_t * wrk, u16 * n_bufs, u32 wanted)
{
- tcp_worker_ctx_t *ctx = &tm->wrk_ctx[thread_index];
vlib_main_t *vm = vlib_get_main ();
u32 n_alloc;
ASSERT (wanted > *n_bufs);
- vec_validate_aligned (ctx->tx_buffers, wanted - 1, CLIB_CACHE_LINE_BYTES);
- n_alloc = vlib_buffer_alloc (vm, &ctx->tx_buffers[*n_bufs],
+ vec_validate_aligned (wrk->tx_buffers, wanted - 1, CLIB_CACHE_LINE_BYTES);
+ n_alloc = vlib_buffer_alloc (vm, &wrk->tx_buffers[*n_bufs],
wanted - *n_bufs);
*n_bufs += n_alloc;
- _vec_len (ctx->tx_buffers) = *n_bufs;
+ _vec_len (wrk->tx_buffers) = *n_bufs;
return n_alloc;
}
always_inline int
-tcp_get_free_buffer_index (tcp_main_t * tm, u32 * bidx)
+tcp_get_free_buffer_index (tcp_worker_ctx_t * wrk, u32 * bidx)
{
- u32 thread_index = vlib_get_thread_index ();
- tcp_worker_ctx_t *ctx = &tm->wrk_ctx[thread_index];
- u16 n_bufs = vec_len (ctx->tx_buffers);
+ u16 n_bufs = vec_len (wrk->tx_buffers);
- TCP_DBG_BUFFER_ALLOC_MAYBE_FAIL (thread_index);
+ TCP_DBG_BUFFER_ALLOC_MAYBE_FAIL (wrk->vm->thread_index);
if (PREDICT_FALSE (!n_bufs))
{
- if (!tcp_alloc_tx_buffers (tm, thread_index, &n_bufs, VLIB_FRAME_SIZE))
+ if (!tcp_alloc_tx_buffers (wrk, &n_bufs, VLIB_FRAME_SIZE))
{
*bidx = ~0;
return -1;
}
}
- *bidx = ctx->tx_buffers[--n_bufs];
- _vec_len (ctx->tx_buffers) = n_bufs;
+ *bidx = wrk->tx_buffers[--n_bufs];
+ _vec_len (wrk->tx_buffers) = n_bufs;
return 0;
}
@@ -644,11 +640,10 @@ tcp_make_synack (tcp_connection_t * tc, vlib_buffer_t * b)
}
always_inline void
-tcp_enqueue_to_ip_lookup_i (vlib_main_t * vm, vlib_buffer_t * b, u32 bi,
+tcp_enqueue_to_ip_lookup_i (tcp_worker_ctx_t * wrk, vlib_buffer_t * b, u32 bi,
u8 is_ip4, u32 fib_index, u8 flush)
{
- tcp_main_t *tm = vnet_get_tcp_main ();
- u32 thread_index = vlib_get_thread_index ();
+ vlib_main_t *vm = wrk->vm;
u32 *to_next, next_index;
vlib_frame_t *f;
@@ -662,12 +657,12 @@ tcp_enqueue_to_ip_lookup_i (vlib_main_t * vm, vlib_buffer_t * b, u32 bi,
next_index = is_ip4 ? ip4_lookup_node.index : ip6_lookup_node.index;
tcp_trajectory_add_start (b, 1);
- f = tm->wrk_ctx[thread_index].ip_lookup_tx_frames[!is_ip4];
+ f = wrk->ip_lookup_tx_frames[!is_ip4];
if (!f)
{
f = vlib_get_frame_to_node (vm, next_index);
ASSERT (f);
- tm->wrk_ctx[thread_index].ip_lookup_tx_frames[!is_ip4] = f;
+ wrk->ip_lookup_tx_frames[!is_ip4] = f;
}
to_next = vlib_frame_vector_args (f);
@@ -676,32 +671,30 @@ tcp_enqueue_to_ip_lookup_i (vlib_main_t * vm, vlib_buffer_t * b, u32 bi,
if (flush || f->n_vectors == VLIB_FRAME_SIZE)
{
vlib_put_frame_to_node (vm, next_index, f);
- tm->wrk_ctx[thread_index].ip_lookup_tx_frames[!is_ip4] = 0;
+ wrk->ip_lookup_tx_frames[!is_ip4] = 0;
}
}
static void
-tcp_enqueue_to_ip_lookup_now (vlib_main_t * vm, vlib_buffer_t * b, u32 bi,
- u8 is_ip4, u32 fib_index)
+tcp_enqueue_to_ip_lookup_now (tcp_worker_ctx_t * wrk, vlib_buffer_t * b,
+ u32 bi, u8 is_ip4, u32 fib_index)
{
- tcp_enqueue_to_ip_lookup_i (vm, b, bi, is_ip4, fib_index, 1);
+ tcp_enqueue_to_ip_lookup_i (wrk, b, bi, is_ip4, fib_index, 1);
}
static void
-tcp_enqueue_to_ip_lookup (vlib_main_t * vm, vlib_buffer_t * b, u32 bi,
+tcp_enqueue_to_ip_lookup (tcp_worker_ctx_t * wrk, vlib_buffer_t * b, u32 bi,
u8 is_ip4, u32 fib_index)
{
- tcp_enqueue_to_ip_lookup_i (vm, b, bi, is_ip4, fib_index, 0);
- if (vm->thread_index == 0 && vlib_num_workers ())
- session_flush_frames_main_thread (vm);
+ tcp_enqueue_to_ip_lookup_i (wrk, b, bi, is_ip4, fib_index, 0);
+ if (wrk->vm->thread_index == 0 && vlib_num_workers ())
+ session_flush_frames_main_thread (wrk->vm);
}
always_inline void
-tcp_enqueue_to_output_i (vlib_main_t * vm, vlib_buffer_t * b, u32 bi,
+tcp_enqueue_to_output_i (tcp_worker_ctx_t * wrk, vlib_buffer_t * b, u32 bi,
u8 is_ip4, u8 flush)
{
- tcp_main_t *tm = vnet_get_tcp_main ();
- u32 thread_index = vlib_get_thread_index ();
u32 *to_next, next_index;
vlib_frame_t *f;
@@ -713,34 +706,35 @@ tcp_enqueue_to_output_i (vlib_main_t * vm, vlib_buffer_t * b, u32 bi,
tcp_trajectory_add_start (b, 2);
/* Get frame to v4/6 output node */
- f = tm->wrk_ctx[thread_index].tx_frames[!is_ip4];
+ f = wrk->tx_frames[!is_ip4];
if (!f)
{
- f = vlib_get_frame_to_node (vm, next_index);
+ f = vlib_get_frame_to_node (wrk->vm, next_index);
ASSERT (f);
- tm->wrk_ctx[thread_index].tx_frames[!is_ip4] = f;
+ wrk->tx_frames[!is_ip4] = f;
}
to_next = vlib_frame_vector_args (f);
to_next[f->n_vectors] = bi;
f->n_vectors += 1;
if (flush || f->n_vectors == VLIB_FRAME_SIZE)
{
- vlib_put_frame_to_node (vm, next_index, f);
- tm->wrk_ctx[thread_index].tx_frames[!is_ip4] = 0;
+ vlib_put_frame_to_node (wrk->vm, next_index, f);
+ wrk->tx_frames[!is_ip4] = 0;
}
}
static void
-tcp_enqueue_to_output (vlib_main_t * vm, vlib_buffer_t * b, u32 bi, u8 is_ip4)
+tcp_enqueue_to_output (tcp_worker_ctx_t * wrk, vlib_buffer_t * b, u32 bi,
+ u8 is_ip4)
{
- tcp_enqueue_to_output_i (vm, b, bi, is_ip4, 0);
+ tcp_enqueue_to_output_i (wrk, b, bi, is_ip4, 0);
}
static void
-tcp_enqueue_to_output_now (vlib_main_t * vm, vlib_buffer_t * b, u32 bi,
+tcp_enqueue_to_output_now (tcp_worker_ctx_t * wrk, vlib_buffer_t * b, u32 bi,
u8 is_ip4)
{
- tcp_enqueue_to_output_i (vm, b, bi, is_ip4, 1);
+ tcp_enqueue_to_output_i (wrk, b, bi, is_ip4, 1);
}
static int
@@ -830,10 +824,10 @@ tcp_make_reset_in_place (vlib_main_t * vm, vlib_buffer_t * b0,
void
tcp_send_reset_w_pkt (tcp_connection_t * tc, vlib_buffer_t * pkt, u8 is_ip4)
{
+ tcp_worker_ctx_t *wrk = tcp_get_worker (tc->c_thread_index);
+ vlib_main_t *vm = wrk->vm;
vlib_buffer_t *b;
u32 bi, sw_if_index, fib_index;
- tcp_main_t *tm = vnet_get_tcp_main ();
- vlib_main_t *vm = vlib_get_main ();
u8 tcp_hdr_len, flags = 0;
tcp_header_t *th, *pkt_th;
u32 seq, ack;
@@ -841,7 +835,7 @@ tcp_send_reset_w_pkt (tcp_connection_t * tc, vlib_buffer_t * pkt, u8 is_ip4)
ip6_header_t *ih6, *pkt_ih6;
fib_protocol_t fib_proto;
- if (PREDICT_FALSE (tcp_get_free_buffer_index (tm, &bi)))
+ if (PREDICT_FALSE (tcp_get_free_buffer_index (wrk, &bi)))
return;
b = vlib_get_buffer (vm, bi);
@@ -899,7 +893,7 @@ tcp_send_reset_w_pkt (tcp_connection_t * tc, vlib_buffer_t * pkt, u8 is_ip4)
ASSERT (!bogus);
}
- tcp_enqueue_to_ip_lookup_now (vm, b, bi, is_ip4, fib_index);
+ tcp_enqueue_to_ip_lookup_now (wrk, b, bi, is_ip4, fib_index);
TCP_EVT_DBG (TCP_EVT_RST_SENT, tc);
}
@@ -909,15 +903,15 @@ tcp_send_reset_w_pkt (tcp_connection_t * tc, vlib_buffer_t * pkt, u8 is_ip4)
void
tcp_send_reset (tcp_connection_t * tc)
{
- vlib_main_t *vm = vlib_get_main ();
- tcp_main_t *tm = vnet_get_tcp_main ();
+ tcp_worker_ctx_t *wrk = tcp_get_worker (tc->c_thread_index);
+ vlib_main_t *vm = wrk->vm;
vlib_buffer_t *b;
u32 bi;
tcp_header_t *th;
u16 tcp_hdr_opts_len, advertise_wnd, opts_write_len;
u8 flags;
- if (PREDICT_FALSE (tcp_get_free_buffer_index (tm, &bi)))
+ if (PREDICT_FALSE (tcp_get_free_buffer_index (wrk, &bi)))
return;
b = vlib_get_buffer (vm, bi);
tcp_init_buffer (vm, b);
@@ -948,15 +942,16 @@ tcp_send_reset (tcp_connection_t * tc)
th->checksum = ip6_tcp_udp_icmp_compute_checksum (vm, b, ih6, &bogus);
ASSERT (!bogus);
}
- tcp_enqueue_to_ip_lookup_now (vm, b, bi, tc->c_is_ip4, tc->c_fib_index);
+ tcp_enqueue_to_ip_lookup_now (wrk, b, bi, tc->c_is_ip4, tc->c_fib_index);
TCP_EVT_DBG (TCP_EVT_RST_SENT, tc);
}
static void
-tcp_push_ip_hdr (tcp_main_t * tm, tcp_connection_t * tc, vlib_buffer_t * b)
+tcp_push_ip_hdr (tcp_worker_ctx_t * wrk, tcp_connection_t * tc,
+ vlib_buffer_t * b)
{
tcp_header_t *th = vlib_buffer_get_current (b);
- vlib_main_t *vm = vlib_get_main ();
+ vlib_main_t *vm = wrk->vm;
if (tc->c_is_ip4)
{
ip4_header_t *ih;
@@ -986,10 +981,10 @@ tcp_push_ip_hdr (tcp_main_t * tm, tcp_connection_t * tc, vlib_buffer_t * b)
void
tcp_send_syn (tcp_connection_t * tc)
{
+ tcp_worker_ctx_t *wrk = tcp_get_worker (tc->c_thread_index);
+ vlib_main_t *vm = wrk->vm;
vlib_buffer_t *b;
u32 bi;
- tcp_main_t *tm = vnet_get_tcp_main ();
- vlib_main_t *vm = vlib_get_main ();
/*
* Setup retransmit and establish timers before requesting buffer
@@ -999,7 +994,7 @@ tcp_send_syn (tcp_connection_t * tc)
tcp_timer_update (tc, TCP_TIMER_RETRANSMIT_SYN,
tc->rto * TCP_TO_TIMER_TICK);
- if (PREDICT_FALSE (tcp_get_free_buffer_index (tm, &bi)))
+ if (PREDICT_FALSE (tcp_get_free_buffer_index (wrk, &bi)))
return;
b = vlib_get_buffer (vm, bi);
@@ -1011,8 +1006,8 @@ tcp_send_syn (tcp_connection_t * tc)
tc->rtt_seq = tc->snd_nxt;
tc->rto_boff = 0;
- tcp_push_ip_hdr (tm, tc, b);
- tcp_enqueue_to_ip_lookup (vm, b, bi, tc->c_is_ip4, tc->c_fib_index);
+ tcp_push_ip_hdr (wrk, tc, b);
+ tcp_enqueue_to_ip_lookup (wrk, b, bi, tc->c_is_ip4, tc->c_fib_index);
TCP_EVT_DBG (TCP_EVT_SYN_SENT, tc);
}
@@ -1020,16 +1015,14 @@ tcp_send_syn (tcp_connection_t * tc)
* Flush tx frame populated by retransmits and timer pops
*/
void
-tcp_flush_frame_to_output (vlib_main_t * vm, u8 thread_index, u8 is_ip4)
+tcp_flush_frame_to_output (tcp_worker_ctx_t * wrk, u8 is_ip4)
{
- if (tcp_main.wrk_ctx[thread_index].tx_frames[!is_ip4])
+ if (wrk->tx_frames[!is_ip4])
{
u32 next_index;
next_index = is_ip4 ? tcp4_output_node.index : tcp6_output_node.index;
- vlib_put_frame_to_node (vm, next_index,
- tcp_main.
- wrk_ctx[thread_index].tx_frames[!is_ip4]);
- tcp_main.wrk_ctx[thread_index].tx_frames[!is_ip4] = 0;
+ vlib_put_frame_to_node (wrk->vm, next_index, wrk->tx_frames[!is_ip4]);
+ wrk->tx_frames[!is_ip4] = 0;
}
}
@@ -1037,17 +1030,15 @@ tcp_flush_frame_to_output (vlib_main_t * vm, u8 thread_index, u8 is_ip4)
* Flush ip lookup tx frames populated by timer pops
*/
static void
-tcp_flush_frame_to_ip_lookup (vlib_main_t * vm, u8 thread_index, u8 is_ip4)
+tcp_flush_frame_to_ip_lookup (tcp_worker_ctx_t * wrk, u8 is_ip4)
{
- if (tcp_main.wrk_ctx[thread_index].ip_lookup_tx_frames[!is_ip4])
+ if (wrk->ip_lookup_tx_frames[!is_ip4])
{
u32 next_index;
next_index = is_ip4 ? ip4_lookup_node.index : ip6_lookup_node.index;
- vlib_put_frame_to_node (vm, next_index,
- tcp_main.
- wrk_ctx[thread_index].ip_lookup_tx_frames
- [!is_ip4]);
- tcp_main.wrk_ctx[thread_index].ip_lookup_tx_frames[!is_ip4] = 0;
+ vlib_put_frame_to_node (wrk->vm, next_index,
+ wrk->ip_lookup_tx_frames[!is_ip4]);
+ wrk->ip_lookup_tx_frames[!is_ip4] = 0;
}
}
@@ -1055,13 +1046,12 @@ tcp_flush_frame_to_ip_lookup (vlib_main_t * vm, u8 thread_index, u8 is_ip4)
* Flush v4 and v6 tcp and ip-lookup tx frames for thread index
*/
void
-tcp_flush_frames_to_output (u8 thread_index)
+tcp_flush_frames_to_output (tcp_worker_ctx_t * wrk)
{
- vlib_main_t *vm = vlib_get_main ();
- tcp_flush_frame_to_output (vm, thread_index, 1);
- tcp_flush_frame_to_output (vm, thread_index, 0);
- tcp_flush_frame_to_ip_lookup (vm, thread_index, 1);
- tcp_flush_frame_to_ip_lookup (vm, thread_index, 0);
+ tcp_flush_frame_to_output (wrk, 1);
+ tcp_flush_frame_to_output (wrk, 0);
+ tcp_flush_frame_to_ip_lookup (wrk, 1);
+ tcp_flush_frame_to_ip_lookup (wrk, 0);
}
/**
@@ -1070,8 +1060,8 @@ tcp_flush_frames_to_output (u8 thread_index)
void
tcp_send_fin (tcp_connection_t * tc)
{
- tcp_main_t *tm = vnet_get_tcp_main ();
- vlib_main_t *vm = vlib_get_main ();
+ tcp_worker_ctx_t *wrk = tcp_get_worker (tc->c_thread_index);
+ vlib_main_t *vm = wrk->vm;
vlib_buffer_t *b;
u32 bi;
u8 fin_snt = 0;
@@ -1080,7 +1070,7 @@ tcp_send_fin (tcp_connection_t * tc)
if (fin_snt)
tc->snd_nxt = tc->snd_una;
- if (PREDICT_FALSE (tcp_get_free_buffer_index (tm, &bi)))
+ if (PREDICT_FALSE (tcp_get_free_buffer_index (wrk, &bi)))
{
/* Out of buffers so program fin retransmit ASAP */
tcp_timer_update (tc, TCP_TIMER_RETRANSMIT, 1);
@@ -1091,7 +1081,7 @@ tcp_send_fin (tcp_connection_t * tc)
b = vlib_get_buffer (vm, bi);
tcp_init_buffer (vm, b);
tcp_make_fin (tc, b);
- tcp_enqueue_to_output_now (vm, b, bi, tc->c_is_ip4);
+ tcp_enqueue_to_output_now (wrk, b, bi, tc->c_is_ip4);
TCP_EVT_DBG (TCP_EVT_FIN_SENT, tc);
post_enqueue:
@@ -1217,21 +1207,20 @@ tcp_push_header (tcp_connection_t * tc, vlib_buffer_t * b)
void
tcp_send_ack (tcp_connection_t * tc)
{
- tcp_main_t *tm = vnet_get_tcp_main ();
- vlib_main_t *vm = vlib_get_main ();
-
+ tcp_worker_ctx_t *wrk = tcp_get_worker (tc->c_thread_index);
+ vlib_main_t *vm = wrk->vm;
vlib_buffer_t *b;
u32 bi;
/* Get buffer */
- if (PREDICT_FALSE (tcp_get_free_buffer_index (tm, &bi)))
+ if (PREDICT_FALSE (tcp_get_free_buffer_index (wrk, &bi)))
return;
b = vlib_get_buffer (vm, bi);
tcp_init_buffer (vm, b);
/* Fill in the ACK */
tcp_make_ack (tc, b);
- tcp_enqueue_to_output (vm, b, bi, tc->c_is_ip4);
+ tcp_enqueue_to_output (wrk, b, bi, tc->c_is_ip4);
}
/**
@@ -1257,11 +1246,12 @@ tcp_timer_delack_handler (u32 index)
* retransmit
*/
static u32
-tcp_prepare_retransmit_segment (tcp_connection_t * tc, u32 offset,
+tcp_prepare_retransmit_segment (tcp_worker_ctx_t * wrk,
+ tcp_connection_t * tc, u32 offset,
u32 max_deq_bytes, vlib_buffer_t ** b)
{
- tcp_main_t *tm = vnet_get_tcp_main ();
- vlib_main_t *vm = vlib_get_main ();
+ u32 bytes_per_buffer = vnet_get_tcp_main ()->bytes_per_buffer;
+ vlib_main_t *vm = wrk->vm;
int n_bytes = 0;
u32 start, bi, available_bytes, seg_size;
u8 *data;
@@ -1305,9 +1295,9 @@ tcp_prepare_retransmit_segment (tcp_connection_t * tc, u32 offset,
*/
/* Easy case, buffer size greater than mss */
- if (PREDICT_TRUE (seg_size <= tm->bytes_per_buffer))
+ if (PREDICT_TRUE (seg_size <= bytes_per_buffer))
{
- if (PREDICT_FALSE (tcp_get_free_buffer_index (tm, &bi)))
+ if (PREDICT_FALSE (tcp_get_free_buffer_index (wrk, &bi)))
return 0;
*b = vlib_get_buffer (vm, bi);
data = tcp_init_buffer (vm, *b);
@@ -1323,19 +1313,16 @@ tcp_prepare_retransmit_segment (tcp_connection_t * tc, u32 offset,
else
{
u32 chain_bi = ~0, n_bufs_per_seg;
- u32 thread_index = vlib_get_thread_index ();
u16 n_peeked, len_to_deq, available_bufs;
vlib_buffer_t *chain_b, *prev_b;
int i;
/* Make sure we have enough buffers */
- n_bufs_per_seg = ceil ((double) seg_size / tm->bytes_per_buffer);
- available_bufs = vec_len (tm->wrk_ctx[thread_index].tx_buffers);
+ n_bufs_per_seg = ceil ((double) seg_size / bytes_per_buffer);
+ available_bufs = vec_len (wrk->tx_buffers);
if (n_bufs_per_seg > available_bufs)
{
- tcp_alloc_tx_buffers (tm, thread_index, &available_bufs,
- VLIB_FRAME_SIZE);
-
+ tcp_alloc_tx_buffers (wrk, &available_bufs, VLIB_FRAME_SIZE);
if (n_bufs_per_seg > available_bufs)
{
*b = 0;
@@ -1343,13 +1330,12 @@ tcp_prepare_retransmit_segment (tcp_connection_t * tc, u32 offset,
}
}
- tcp_get_free_buffer_index (tm, &bi);
+ tcp_get_free_buffer_index (wrk, &bi);
ASSERT (bi != (u32) ~ 0);
*b = vlib_get_buffer (vm, bi);
data = tcp_init_buffer (vm, *b);
n_bytes = stream_session_peek_bytes (&tc->connection, data, offset,
- tm->bytes_per_buffer -
- MAX_HDRS_LEN);
+ bytes_per_buffer - MAX_HDRS_LEN);
b[0]->current_length = n_bytes;
b[0]->flags |= VLIB_BUFFER_TOTAL_LENGTH_VALID;
b[0]->total_length_not_including_first_buffer = 0;
@@ -1359,8 +1345,8 @@ tcp_prepare_retransmit_segment (tcp_connection_t * tc, u32 offset,
for (i = 1; i < n_bufs_per_seg; i++)
{
prev_b = chain_b;
- len_to_deq = clib_min (max_deq_bytes, tm->bytes_per_buffer);
- tcp_get_free_buffer_index (tm, &chain_bi);
+ len_to_deq = clib_min (max_deq_bytes, bytes_per_buffer);
+ tcp_get_free_buffer_index (wrk, &chain_bi);
ASSERT (chain_bi != (u32) ~ 0);
chain_b = vlib_get_buffer (vm, chain_bi);
chain_b->current_data = 0;
@@ -1386,8 +1372,7 @@ tcp_prepare_retransmit_segment (tcp_connection_t * tc, u32 offset,
}
ASSERT (n_bytes > 0);
- ASSERT (((*b)->current_data + (*b)->current_length) <=
- tm->bytes_per_buffer);
+ ASSERT (((*b)->current_data + (*b)->current_length) <= bytes_per_buffer);
if (tcp_in_fastrecovery (tc))
tc->snd_rxt_bytes += n_bytes;
@@ -1428,9 +1413,9 @@ tcp_rxt_timeout_cc (tcp_connection_t * tc)
static inline void
tcp_timer_retransmit_handler_i (u32 index, u8 is_syn)
{
- tcp_main_t *tm = vnet_get_tcp_main ();
- vlib_main_t *vm = vlib_get_main ();
u32 thread_index = vlib_get_thread_index ();
+ tcp_worker_ctx_t *wrk = tcp_get_worker (thread_index);
+ vlib_main_t *vm = wrk->vm;
tcp_connection_t *tc;
vlib_buffer_t *b = 0;
u32 bi, n_bytes;
@@ -1503,7 +1488,7 @@ tcp_timer_retransmit_handler_i (u32 index, u8 is_syn)
/* Send one segment. Note that n_bytes may be zero due to buffer
* shortfall */
- n_bytes = tcp_prepare_retransmit_segment (tc, 0, tc->snd_mss, &b);
+ n_bytes = tcp_prepare_retransmit_segment (wrk, tc, 0, tc->snd_mss, &b);
if (n_bytes == 0)
{
@@ -1515,9 +1500,9 @@ tcp_timer_retransmit_handler_i (u32 index, u8 is_syn)
/* For first retransmit, record timestamp (Eifel detection RFC3522) */
if (tc->rto_boff == 1)
- tc->snd_rxt_ts = tcp_time_now ();
+ tc->snd_rxt_ts = tcp_time_now_w_thread (tc->c_thread_index);
- tcp_enqueue_to_output (vm, b, bi, tc->c_is_ip4);
+ tcp_enqueue_to_output (wrk, b, bi, tc->c_is_ip4);
tcp_retransmit_timer_force_update (tc);
}
/* Retransmit for SYN */
@@ -1547,7 +1532,7 @@ tcp_timer_retransmit_handler_i (u32 index, u8 is_syn)
tcp_timer_update (tc, TCP_TIMER_RETRANSMIT_SYN,
tc->rto * TCP_TO_TIMER_TICK);
- if (PREDICT_FALSE (tcp_get_free_buffer_index (tm, &bi)))
+ if (PREDICT_FALSE (tcp_get_free_buffer_index (wrk, &bi)))
return;
b = vlib_get_buffer (vm, bi);
@@ -1558,8 +1543,8 @@ tcp_timer_retransmit_handler_i (u32 index, u8 is_syn)
TCP_EVT_DBG (TCP_EVT_SYN_RXT, tc, 0);
/* This goes straight to ipx_lookup. Retransmit timer set already */
- tcp_push_ip_hdr (tm, tc, b);
- tcp_enqueue_to_ip_lookup (vm, b, bi, tc->c_is_ip4, tc->c_fib_index);
+ tcp_push_ip_hdr (wrk, tc, b);
+ tcp_enqueue_to_ip_lookup (wrk, b, bi, tc->c_is_ip4, tc->c_fib_index);
}
/* Retransmit SYN-ACK */
else if (tc->state == TCP_STATE_SYN_RCVD)
@@ -1571,7 +1556,7 @@ tcp_timer_retransmit_handler_i (u32 index, u8 is_syn)
tc->rto = clib_min (tc->rto << 1, TCP_RTO_MAX);
tc->rtt_ts = 0;
- if (PREDICT_FALSE (tcp_get_free_buffer_index (tm, &bi)))
+ if (PREDICT_FALSE (tcp_get_free_buffer_index (wrk, &bi)))
{
tcp_retransmit_timer_force_update (tc);
return;
@@ -1583,7 +1568,7 @@ tcp_timer_retransmit_handler_i (u32 index, u8 is_syn)
TCP_EVT_DBG (TCP_EVT_SYN_RXT, tc, 1);
/* Retransmit timer already updated, just enqueue to output */
- tcp_enqueue_to_output (vm, b, bi, tc->c_is_ip4);
+ tcp_enqueue_to_output (wrk, b, bi, tc->c_is_ip4);
}
else
{
@@ -1611,12 +1596,13 @@ tcp_timer_retransmit_syn_handler (u32 index)
void
tcp_timer_persist_handler (u32 index)
{
- tcp_main_t *tm = vnet_get_tcp_main ();
- vlib_main_t *vm = vlib_get_main ();
u32 thread_index = vlib_get_thread_index ();
+ tcp_worker_ctx_t *wrk = tcp_get_worker (thread_index);
+ u32 bi, max_snd_bytes, available_bytes, offset;
+ tcp_main_t *tm = vnet_get_tcp_main ();
+ vlib_main_t *vm = wrk->vm;
tcp_connection_t *tc;
vlib_buffer_t *b;
- u32 bi, max_snd_bytes, available_bytes, offset;
int n_bytes = 0;
u8 *data;
@@ -1657,7 +1643,7 @@ tcp_timer_persist_handler (u32 index)
/*
* Try to force the first unsent segment (or buffer)
*/
- if (PREDICT_FALSE (tcp_get_free_buffer_index (tm, &bi)))
+ if (PREDICT_FALSE (tcp_get_free_buffer_index (wrk, &bi)))
{
tcp_persist_timer_set (tc);
return;
@@ -1678,7 +1664,7 @@ tcp_timer_persist_handler (u32 index)
tcp_push_hdr_i (tc, b, tc->state, /* compute opts */ 0, /* burst */ 0);
tc->snd_una_max = tc->snd_nxt;
tcp_validate_txf_size (tc, tc->snd_una_max - tc->snd_una);
- tcp_enqueue_to_output (vm, b, bi, tc->c_is_ip4);
+ tcp_enqueue_to_output (wrk, b, bi, tc->c_is_ip4);
/* Just sent new data, enable retransmit */
tcp_retransmit_timer_update (tc);
@@ -1688,23 +1674,23 @@ tcp_timer_persist_handler (u32 index)
* Retransmit first unacked segment
*/
int
-tcp_retransmit_first_unacked (tcp_connection_t * tc)
+tcp_retransmit_first_unacked (tcp_worker_ctx_t * wrk, tcp_connection_t * tc)
{
- vlib_main_t *vm = vlib_get_main ();
- vlib_buffer_t *b;
u32 bi, old_snd_nxt, n_bytes;
+ vlib_main_t *vm = wrk->vm;
+ vlib_buffer_t *b;
old_snd_nxt = tc->snd_nxt;
tc->snd_nxt = tc->snd_una;
TCP_EVT_DBG (TCP_EVT_CC_EVT, tc, 1);
- n_bytes = tcp_prepare_retransmit_segment (tc, 0, tc->snd_mss, &b);
+ n_bytes = tcp_prepare_retransmit_segment (wrk, tc, 0, tc->snd_mss, &b);
if (!n_bytes)
return -1;
bi = vlib_get_buffer_index (vm, b);
- tcp_enqueue_to_output (vm, b, bi, tc->c_is_ip4);
+ tcp_enqueue_to_output (wrk, b, bi, tc->c_is_ip4);
tc->snd_nxt = old_snd_nxt;
return 0;
@@ -1714,9 +1700,10 @@ tcp_retransmit_first_unacked (tcp_connection_t * tc)
* Do fast retransmit with SACKs
*/
int
-tcp_fast_retransmit_sack (tcp_connection_t * tc, u32 burst_size)
+tcp_fast_retransmit_sack (tcp_worker_ctx_t * wrk, tcp_connection_t * tc,
+ u32 burst_size)
{
- vlib_main_t *vm = vlib_get_main ();
+ vlib_main_t *vm = wrk->vm;
u32 n_written = 0, offset, max_bytes, n_segs = 0;
vlib_buffer_t *b = 0;
sack_scoreboard_hole_t *hole;
@@ -1734,7 +1721,7 @@ tcp_fast_retransmit_sack (tcp_connection_t * tc, u32 burst_size)
if (snd_space < tc->snd_mss)
{
- tcp_program_fastretransmit (tc);
+ tcp_program_fastretransmit (wrk, tc);
goto done;
}
@@ -1758,7 +1745,7 @@ tcp_fast_retransmit_sack (tcp_connection_t * tc, u32 burst_size)
hole = scoreboard_first_hole (sb);
if (hole && hole->start == tc->snd_una)
{
- tcp_retransmit_first_unacked (tc);
+ tcp_retransmit_first_unacked (wrk, tc);
tcp_fastrecovery_first_on (tc);
n_segs += 1;
}
@@ -1776,13 +1763,13 @@ tcp_fast_retransmit_sack (tcp_connection_t * tc, u32 burst_size)
offset = tc->snd_congestion - tc->snd_una - max_bytes;
sb->rescue_rxt = tc->snd_congestion;
tc->snd_nxt = tc->snd_una + offset;
- n_written = tcp_prepare_retransmit_segment (tc, offset, max_bytes,
- &b);
+ n_written = tcp_prepare_retransmit_segment (wrk, tc, offset,
+ max_bytes, &b);
if (!n_written)
goto done;
bi = vlib_get_buffer_index (vm, b);
- tcp_enqueue_to_output (vm, b, bi, tc->c_is_ip4);
+ tcp_enqueue_to_output (wrk, b, bi, tc->c_is_ip4);
n_segs += 1;
break;
}
@@ -1793,7 +1780,8 @@ tcp_fast_retransmit_sack (tcp_connection_t * tc, u32 burst_size)
break;
offset = sb->high_rxt - tc->snd_una;
tc->snd_nxt = sb->high_rxt;
- n_written = tcp_prepare_retransmit_segment (tc, offset, max_bytes, &b);
+ n_written = tcp_prepare_retransmit_segment (wrk, tc, offset, max_bytes,
+ &b);
/* Nothing left to retransmit */
if (n_written == 0)
@@ -1801,14 +1789,14 @@ tcp_fast_retransmit_sack (tcp_connection_t * tc, u32 burst_size)
bi = vlib_get_buffer_index (vm, b);
sb->high_rxt += n_written;
- tcp_enqueue_to_output (vm, b, bi, tc->c_is_ip4);
+ tcp_enqueue_to_output (wrk, b, bi, tc->c_is_ip4);
ASSERT (n_written <= snd_space);
snd_space -= n_written;
n_segs += 1;
}
if (hole)
- tcp_program_fastretransmit (tc);
+ tcp_program_fastretransmit (wrk, tc);
done:
/* If window allows, send 1 SMSS of new data */
@@ -1820,10 +1808,11 @@ done:
* Fast retransmit without SACK info
*/
int
-tcp_fast_retransmit_no_sack (tcp_connection_t * tc, u32 burst_size)
+tcp_fast_retransmit_no_sack (tcp_worker_ctx_t * wrk, tcp_connection_t * tc,
+ u32 burst_size)
{
- vlib_main_t *vm = vlib_get_main ();
u32 n_written = 0, offset = 0, bi, old_snd_nxt;
+ vlib_main_t *vm = wrk->vm;
int snd_space, n_segs = 0;
vlib_buffer_t *b;
@@ -1838,21 +1827,22 @@ tcp_fast_retransmit_no_sack (tcp_connection_t * tc, u32 burst_size)
while (snd_space > 0 && n_segs < burst_size)
{
offset += n_written;
- n_written = tcp_prepare_retransmit_segment (tc, offset, snd_space, &b);
+ n_written = tcp_prepare_retransmit_segment (wrk, tc, offset, snd_space,
+ &b);
/* Nothing left to retransmit */
if (n_written == 0)
break;
bi = vlib_get_buffer_index (vm, b);
- tcp_enqueue_to_output (vm, b, bi, tc->c_is_ip4);
+ tcp_enqueue_to_output (wrk, b, bi, tc->c_is_ip4);
snd_space -= n_written;
n_segs += 1;
}
/* More data to resend */
if (seq_lt (tc->snd_nxt, tc->snd_congestion))
- tcp_program_fastretransmit (tc);
+ tcp_program_fastretransmit (wrk, tc);
/* Restore snd_nxt. If window allows, send 1 SMSS of new data */
tc->snd_nxt = old_snd_nxt;
@@ -1864,12 +1854,13 @@ tcp_fast_retransmit_no_sack (tcp_connection_t * tc, u32 burst_size)
* Do fast retransmit
*/
int
-tcp_fast_retransmit (tcp_connection_t * tc, u32 burst_size)
+tcp_fast_retransmit (tcp_worker_ctx_t * wrk, tcp_connection_t * tc,
+ u32 burst_size)
{
if (tcp_opts_sack_permitted (&tc->rcv_opts))
- return tcp_fast_retransmit_sack (tc, burst_size);
+ return tcp_fast_retransmit_sack (wrk, tc, burst_size);
else
- return tcp_fast_retransmit_no_sack (tc, burst_size);
+ return tcp_fast_retransmit_no_sack (wrk, tc, burst_size);
}
static u32
@@ -2016,7 +2007,7 @@ tcp46_output_inline (vlib_main_t * vm, vlib_node_runtime_t * node,
from = vlib_frame_vector_args (frame);
n_left_from = frame->n_vectors;
- tcp_set_time_now (thread_index);
+ tcp_set_time_now (tcp_get_worker (thread_index));
if (PREDICT_FALSE (node->flags & VLIB_NODE_FLAG_TRACE))
tcp46_output_trace_frame (vm, node, from, n_left_from);