X-Git-Url: https://gerrit.fd.io/r/gitweb?a=blobdiff_plain;f=src%2Fvnet%2Ftcp%2Ftcp_output.c;h=c315c031c97d1d3a616ae81870df2b3d4196666d;hb=be72ae6149a432899698a887b1820cf5c9d9456f;hp=81579ef96a2be8403cdc3fe0d5278a865a7319b8;hpb=bf9f02cd395387bc596f1dab5e3566f6c5573eda;p=vpp.git

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);