tcp: cleanup rcv-process and bulk buffer translation

Type: improvement

Signed-off-by: Florin Coras <fcoras@cisco.com>
Change-Id: I2ca8a5e30e55a84d4567422e4b7fcf90830921d3

1 files changed, 160 insertions, 141 deletions

diff --git a/src/vnet/tcp/tcp_input.c b/src/vnet/tcp/tcp_input.c
index a9159ad5973..2ba96a5fe78 100644
--- a/src/vnet/tcp/tcp_input.c
+++ b/src/vnet/tcp/tcp_input.c
@@ -2101,55 +2101,77 @@ VLIB_REGISTER_NODE (tcp6_syn_sent_node) =
 };
 /* *INDENT-ON* */
 
+static void
+tcp46_rcv_process_trace_frame (vlib_main_t *vm, vlib_node_runtime_t *node,
+			       u32 *from, u32 n_bufs)
+{
+  u32 thread_index = vm->thread_index;
+  tcp_connection_t *tc = 0;
+  tcp_rx_trace_t *t;
+  vlib_buffer_t *b;
+  int i;
+
+  for (i = 0; i < n_bufs; i++)
+    {
+      b = vlib_get_buffer (vm, from[i]);
+      if (!(b->flags & VLIB_BUFFER_IS_TRACED))
+	continue;
+      tc = tcp_connection_get (vnet_buffer (b)->tcp.connection_index,
+			       thread_index);
+      t = vlib_add_trace (vm, node, b, sizeof (*t));
+      tcp_set_rx_trace_data (t, tc, tcp_buffer_hdr (b), b, 1);
+    }
+}
+
 /**
  * Handles reception for all states except LISTEN, SYN-SENT and ESTABLISHED
  * as per RFC793 p. 64
  */
 always_inline uword
-tcp46_rcv_process_inline (vlib_main_t * vm, vlib_node_runtime_t * node,
-			  vlib_frame_t * from_frame, int is_ip4)
+tcp46_rcv_process_inline (vlib_main_t *vm, vlib_node_runtime_t *node,
+			  vlib_frame_t *frame, int is_ip4)
 {
-  u32 thread_index = vm->thread_index, errors = 0, *first_buffer;
+  u32 thread_index = vm->thread_index, errors, n_left_from, *from, max_deq;
   tcp_worker_ctx_t *wrk = tcp_get_worker (thread_index);
-  u32 n_left_from, *from, max_dequeue;
+  vlib_buffer_t *bufs[VLIB_FRAME_SIZE], **b;
 
-  from = first_buffer = vlib_frame_vector_args (from_frame);
-  n_left_from = from_frame->n_vectors;
+  from = vlib_frame_vector_args (frame);
+  n_left_from = frame->n_vectors;
+
+  if (PREDICT_FALSE (node->flags & VLIB_NODE_FLAG_TRACE))
+    tcp46_rcv_process_trace_frame (vm, node, from, n_left_from);
+
+  vlib_get_buffers (vm, from, bufs, n_left_from);
+  b = bufs;
 
   while (n_left_from > 0)
     {
-      u32 bi0, error0 = TCP_ERROR_NONE;
-      tcp_header_t *tcp0 = 0;
-      tcp_connection_t *tc0;
-      vlib_buffer_t *b0;
-      u8 is_fin0;
-
-      bi0 = from[0];
-      from += 1;
-      n_left_from -= 1;
+      u32 error = TCP_ERROR_NONE;
+      tcp_header_t *tcp = 0;
+      tcp_connection_t *tc;
+      u8 is_fin;
 
-      b0 = vlib_get_buffer (vm, bi0);
-      tc0 = tcp_connection_get (vnet_buffer (b0)->tcp.connection_index,
-				thread_index);
-      if (PREDICT_FALSE (tc0 == 0))
+      tc = tcp_connection_get (vnet_buffer (b[0])->tcp.connection_index,
+			       thread_index);
+      if (PREDICT_FALSE (tc == 0))
 	{
-	  error0 = TCP_ERROR_INVALID_CONNECTION;
+	  error = TCP_ERROR_INVALID_CONNECTION;
 	  goto drop;
 	}
 
-      tcp0 = tcp_buffer_hdr (b0);
-      is_fin0 = tcp_is_fin (tcp0);
+      tcp = tcp_buffer_hdr (b[0]);
+      is_fin = tcp_is_fin (tcp);
 
       if (CLIB_DEBUG)
 	{
-	  if (!(tc0->connection.flags & TRANSPORT_CONNECTION_F_NO_LOOKUP))
+	  if (!(tc->connection.flags & TRANSPORT_CONNECTION_F_NO_LOOKUP))
 	    {
 	      tcp_connection_t *tmp;
-	      tmp = tcp_lookup_connection (tc0->c_fib_index, b0, thread_index,
+	      tmp = tcp_lookup_connection (tc->c_fib_index, b[0], thread_index,
 					   is_ip4);
-	      if (tmp->state != tc0->state)
+	      if (tmp->state != tc->state)
 		{
-		  if (tc0->state != TCP_STATE_CLOSED)
+		  if (tc->state != TCP_STATE_CLOSED)
 		    clib_warning ("state changed");
 		  goto drop;
 		}
@@ -2159,9 +2181,9 @@ tcp46_rcv_process_inline (vlib_main_t * vm, vlib_node_runtime_t * node,
       /*
        * Special treatment for CLOSED
        */
-      if (PREDICT_FALSE (tc0->state == TCP_STATE_CLOSED))
+      if (PREDICT_FALSE (tc->state == TCP_STATE_CLOSED))
 	{
-	  error0 = TCP_ERROR_CONNECTION_CLOSED;
+	  error = TCP_ERROR_CONNECTION_CLOSED;
 	  goto drop;
 	}
 
@@ -2170,19 +2192,19 @@ tcp46_rcv_process_inline (vlib_main_t * vm, vlib_node_runtime_t * node,
        */
 
       /* 1-4: check SEQ, RST, SYN */
-      if (PREDICT_FALSE (tcp_segment_validate (wrk, tc0, b0, tcp0, &error0)))
+      if (PREDICT_FALSE (tcp_segment_validate (wrk, tc, b[0], tcp, &error)))
 	goto drop;
 
       /* 5: check the ACK field  */
-      switch (tc0->state)
+      switch (tc->state)
 	{
 	case TCP_STATE_SYN_RCVD:
 
 	  /* Make sure the segment is exactly right */
-	  if (tc0->rcv_nxt != vnet_buffer (b0)->tcp.seq_number || is_fin0)
+	  if (tc->rcv_nxt != vnet_buffer (b[0])->tcp.seq_number || is_fin)
 	    {
-	      tcp_send_reset_w_pkt (tc0, b0, thread_index, is_ip4);
-	      error0 = TCP_ERROR_SEGMENT_INVALID;
+	      tcp_send_reset_w_pkt (tc, b[0], thread_index, is_ip4);
+	      error = TCP_ERROR_SEGMENT_INVALID;
 	      goto drop;
 	    }
 
@@ -2192,47 +2214,47 @@ tcp46_rcv_process_inline (vlib_main_t * vm, vlib_node_runtime_t * node,
 	   *  <SEQ=SEG.ACK><CTL=RST>
 	   * and send it.
 	   */
-	  if (tcp_rcv_ack_no_cc (tc0, b0, &error0))
+	  if (tcp_rcv_ack_no_cc (tc, b[0], &error))
 	    {
-	      tcp_send_reset_w_pkt (tc0, b0, thread_index, is_ip4);
-	      error0 = TCP_ERROR_SEGMENT_INVALID;
+	      tcp_send_reset_w_pkt (tc, b[0], thread_index, is_ip4);
+	      error = TCP_ERROR_SEGMENT_INVALID;
 	      goto drop;
 	    }
 
 	  /* Update rtt and rto */
-	  tcp_estimate_initial_rtt (tc0);
-	  tcp_connection_tx_pacer_update (tc0);
+	  tcp_estimate_initial_rtt (tc);
+	  tcp_connection_tx_pacer_update (tc);
 
 	  /* Switch state to ESTABLISHED */
-	  tc0->state = TCP_STATE_ESTABLISHED;
-	  TCP_EVT (TCP_EVT_STATE_CHANGE, tc0);
+	  tc->state = TCP_STATE_ESTABLISHED;
+	  TCP_EVT (TCP_EVT_STATE_CHANGE, tc);
 
-	  if (!(tc0->cfg_flags & TCP_CFG_F_NO_TSO))
-	    tcp_check_tx_offload (tc0, is_ip4);
+	  if (!(tc->cfg_flags & TCP_CFG_F_NO_TSO))
+	    tcp_check_tx_offload (tc, is_ip4);
 
 	  /* Initialize session variables */
-	  tc0->snd_una = vnet_buffer (b0)->tcp.ack_number;
-	  tc0->snd_wnd = clib_net_to_host_u16 (tcp0->window)
-	    << tc0->rcv_opts.wscale;
-	  tc0->snd_wl1 = vnet_buffer (b0)->tcp.seq_number;
-	  tc0->snd_wl2 = vnet_buffer (b0)->tcp.ack_number;
+	  tc->snd_una = vnet_buffer (b[0])->tcp.ack_number;
+	  tc->snd_wnd = clib_net_to_host_u16 (tcp->window)
+			<< tc->rcv_opts.wscale;
+	  tc->snd_wl1 = vnet_buffer (b[0])->tcp.seq_number;
+	  tc->snd_wl2 = vnet_buffer (b[0])->tcp.ack_number;
 
 	  /* Reset SYN-ACK retransmit and SYN_RCV establish timers */
-	  tcp_retransmit_timer_reset (&wrk->timer_wheel, tc0);
-	  if (session_stream_accept_notify (&tc0->connection))
+	  tcp_retransmit_timer_reset (&wrk->timer_wheel, tc);
+	  if (session_stream_accept_notify (&tc->connection))
 	    {
-	      error0 = TCP_ERROR_MSG_QUEUE_FULL;
-	      tcp_send_reset (tc0);
-	      session_transport_delete_notify (&tc0->connection);
-	      tcp_connection_cleanup (tc0);
+	      error = TCP_ERROR_MSG_QUEUE_FULL;
+	      tcp_send_reset (tc);
+	      session_transport_delete_notify (&tc->connection);
+	      tcp_connection_cleanup (tc);
 	      goto drop;
 	    }
-	  error0 = TCP_ERROR_ACK_OK;
+	  error = TCP_ERROR_ACK_OK;
 	  break;
 	case TCP_STATE_ESTABLISHED:
 	  /* We can get packets in established state here because they
 	   * were enqueued before state change */
-	  if (tcp_rcv_ack (wrk, tc0, b0, tcp0, &error0))
+	  if (tcp_rcv_ack (wrk, tc, b[0], tcp, &error))
 	    goto drop;
 
 	  break;
@@ -2240,93 +2262,93 @@ tcp46_rcv_process_inline (vlib_main_t * vm, vlib_node_runtime_t * node,
 	  /* In addition to the processing for the ESTABLISHED state, if
 	   * our FIN is now acknowledged then enter FIN-WAIT-2 and
 	   * continue processing in that state. */
-	  if (tcp_rcv_ack (wrk, tc0, b0, tcp0, &error0))
+	  if (tcp_rcv_ack (wrk, tc, b[0], tcp, &error))
 	    goto drop;
 
 	  /* Still have to send the FIN */
-	  if (tc0->flags & TCP_CONN_FINPNDG)
+	  if (tc->flags & TCP_CONN_FINPNDG)
 	    {
 	      /* TX fifo finally drained */
-	      max_dequeue = transport_max_tx_dequeue (&tc0->connection);
-	      if (max_dequeue <= tc0->burst_acked)
-		tcp_send_fin (tc0);
+	      max_deq = transport_max_tx_dequeue (&tc->connection);
+	      if (max_deq <= tc->burst_acked)
+		tcp_send_fin (tc);
 	      /* If a fin was received and data was acked extend wait */
-	      else if ((tc0->flags & TCP_CONN_FINRCVD) && tc0->bytes_acked)
-		tcp_timer_update (&wrk->timer_wheel, tc0, TCP_TIMER_WAITCLOSE,
+	      else if ((tc->flags & TCP_CONN_FINRCVD) && tc->bytes_acked)
+		tcp_timer_update (&wrk->timer_wheel, tc, TCP_TIMER_WAITCLOSE,
 				  tcp_cfg.closewait_time);
 	    }
 	  /* If FIN is ACKed */
-	  else if (tc0->snd_una == tc0->snd_nxt)
+	  else if (tc->snd_una == tc->snd_nxt)
 	    {
 	      /* Stop all retransmit timers because we have nothing more
 	       * to send. */
-	      tcp_connection_timers_reset (tc0);
+	      tcp_connection_timers_reset (tc);
 
 	      /* We already have a FIN but didn't transition to CLOSING
 	       * because of outstanding tx data. Close the connection. */
-	      if (tc0->flags & TCP_CONN_FINRCVD)
+	      if (tc->flags & TCP_CONN_FINRCVD)
 		{
-		  tcp_connection_set_state (tc0, TCP_STATE_CLOSED);
-		  session_transport_closed_notify (&tc0->connection);
-		  tcp_program_cleanup (wrk, tc0);
+		  tcp_connection_set_state (tc, TCP_STATE_CLOSED);
+		  session_transport_closed_notify (&tc->connection);
+		  tcp_program_cleanup (wrk, tc);
 		  goto drop;
 		}
 
-	      tcp_connection_set_state (tc0, TCP_STATE_FIN_WAIT_2);
+	      tcp_connection_set_state (tc, TCP_STATE_FIN_WAIT_2);
 	      /* Enable waitclose because we're willing to wait for peer's
 	       * FIN but not indefinitely. */
-	      tcp_timer_set (&wrk->timer_wheel, tc0, TCP_TIMER_WAITCLOSE,
+	      tcp_timer_set (&wrk->timer_wheel, tc, TCP_TIMER_WAITCLOSE,
 			     tcp_cfg.finwait2_time);
 
 	      /* Don't try to deq the FIN acked */
-	      if (tc0->burst_acked > 1)
-		session_tx_fifo_dequeue_drop (&tc0->connection,
-					      tc0->burst_acked - 1);
-	      tc0->burst_acked = 0;
+	      if (tc->burst_acked > 1)
+		session_tx_fifo_dequeue_drop (&tc->connection,
+					      tc->burst_acked - 1);
+	      tc->burst_acked = 0;
 	    }
 	  break;
 	case TCP_STATE_FIN_WAIT_2:
 	  /* In addition to the processing for the ESTABLISHED state, if
 	   * the retransmission queue is empty, the user's CLOSE can be
 	   * acknowledged ("ok") but do not delete the TCB. */
-	  if (tcp_rcv_ack_no_cc (tc0, b0, &error0))
+	  if (tcp_rcv_ack_no_cc (tc, b[0], &error))
 	    goto drop;
-	  tc0->burst_acked = 0;
+	  tc->burst_acked = 0;
 	  break;
 	case TCP_STATE_CLOSE_WAIT:
 	  /* Do the same processing as for the ESTABLISHED state. */
-	  if (tcp_rcv_ack (wrk, tc0, b0, tcp0, &error0))
+	  if (tcp_rcv_ack (wrk, tc, b[0], tcp, &error))
 	    goto drop;
 
-	  if (!(tc0->flags & TCP_CONN_FINPNDG))
+	  if (!(tc->flags & TCP_CONN_FINPNDG))
 	    break;
 
 	  /* Still have outstanding tx data */
-	  max_dequeue = transport_max_tx_dequeue (&tc0->connection);
-	  if (max_dequeue > tc0->burst_acked)
+	  max_deq = transport_max_tx_dequeue (&tc->connection);
+	  if (max_deq > tc->burst_acked)
 	    break;
 
-	  tcp_send_fin (tc0);
-	  tcp_connection_timers_reset (tc0);
-	  tcp_connection_set_state (tc0, TCP_STATE_LAST_ACK);
-	  tcp_timer_set (&wrk->timer_wheel, tc0, TCP_TIMER_WAITCLOSE,
+	  tcp_send_fin (tc);
+	  tcp_connection_timers_reset (tc);
+	  tcp_connection_set_state (tc, TCP_STATE_LAST_ACK);
+	  tcp_timer_set (&wrk->timer_wheel, tc, TCP_TIMER_WAITCLOSE,
 			 tcp_cfg.lastack_time);
 	  break;
 	case TCP_STATE_CLOSING:
 	  /* In addition to the processing for the ESTABLISHED state, if
 	   * the ACK acknowledges our FIN then enter the TIME-WAIT state,
 	   * otherwise ignore the segment. */
-	  if (tcp_rcv_ack_no_cc (tc0, b0, &error0))
+	  if (tcp_rcv_ack_no_cc (tc, b[0], &error))
 	    goto drop;
 
-	  if (tc0->snd_una != tc0->snd_nxt)
+	  if (tc->snd_una != tc->snd_nxt)
 	    goto drop;
 
-	  tcp_connection_timers_reset (tc0);
-	  tcp_connection_set_state (tc0, TCP_STATE_TIME_WAIT);
-	  tcp_timer_set (&wrk->timer_wheel, tc0, TCP_TIMER_WAITCLOSE,
+	  tcp_connection_timers_reset (tc);
+	  tcp_connection_set_state (tc, TCP_STATE_TIME_WAIT);
+	  tcp_timer_set (&wrk->timer_wheel, tc, TCP_TIMER_WAITCLOSE,
 			 tcp_cfg.timewait_time);
-	  session_transport_closed_notify (&tc0->connection);
+	  session_transport_closed_notify (&tc->connection);
 	  goto drop;
 
 	  break;
@@ -2335,24 +2357,24 @@ tcp46_rcv_process_inline (vlib_main_t * vm, vlib_node_runtime_t * node,
 	   * acknowledgment of our FIN. If our FIN is now acknowledged,
 	   * delete the TCB, enter the CLOSED state, and return. */
 
-	  if (tcp_rcv_ack_no_cc (tc0, b0, &error0))
+	  if (tcp_rcv_ack_no_cc (tc, b[0], &error))
 	    goto drop;
 
 	  /* Apparently our ACK for the peer's FIN was lost */
-	  if (is_fin0 && tc0->snd_una != tc0->snd_nxt)
+	  if (is_fin && tc->snd_una != tc->snd_nxt)
 	    {
-	      tcp_send_fin (tc0);
+	      tcp_send_fin (tc);
 	      goto drop;
 	    }
 
-	  tcp_connection_set_state (tc0, TCP_STATE_CLOSED);
-	  session_transport_closed_notify (&tc0->connection);
+	  tcp_connection_set_state (tc, TCP_STATE_CLOSED);
+	  session_transport_closed_notify (&tc->connection);
 
 	  /* Don't free the connection from the data path since
 	   * 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_program_cleanup (tcp_get_worker (tc0->c_thread_index), tc0);
+	  tcp_connection_timers_reset (tc);
+	  tcp_program_cleanup (tcp_get_worker (tc->c_thread_index), tc);
 
 	  goto drop;
 
@@ -2362,14 +2384,14 @@ tcp46_rcv_process_inline (vlib_main_t * vm, vlib_node_runtime_t * node,
 	   * retransmission of the remote FIN. Acknowledge it, and restart
 	   * the 2 MSL timeout. */
 
-	  if (tcp_rcv_ack_no_cc (tc0, b0, &error0))
+	  if (tcp_rcv_ack_no_cc (tc, b[0], &error))
 	    goto drop;
 
-	  if (!is_fin0)
+	  if (!is_fin)
 	    goto drop;
 
-	  tcp_program_ack (tc0);
-	  tcp_timer_update (&wrk->timer_wheel, tc0, TCP_TIMER_WAITCLOSE,
+	  tcp_program_ack (tc);
+	  tcp_timer_update (&wrk->timer_wheel, tc, TCP_TIMER_WAITCLOSE,
 			    tcp_cfg.timewait_time);
 	  goto drop;
 
@@ -2381,15 +2403,15 @@ tcp46_rcv_process_inline (vlib_main_t * vm, vlib_node_runtime_t * node,
       /* 6: check the URG bit TODO */
 
       /* 7: process the segment text */
-      switch (tc0->state)
+      switch (tc->state)
 	{
 	case TCP_STATE_ESTABLISHED:
 	case TCP_STATE_FIN_WAIT_1:
 	case TCP_STATE_FIN_WAIT_2:
-	  if (vnet_buffer (b0)->tcp.data_len)
-	    error0 = tcp_segment_rcv (wrk, tc0, b0);
+	  if (vnet_buffer (b[0])->tcp.data_len)
+	    error = tcp_segment_rcv (wrk, tc, b[0]);
 	  /* Don't accept out of order fins lower */
-	  if (vnet_buffer (b0)->tcp.seq_end != tc0->rcv_nxt)
+	  if (vnet_buffer (b[0])->tcp.seq_end != tc->rcv_nxt)
 	    goto drop;
 	  break;
 	case TCP_STATE_CLOSE_WAIT:
@@ -2402,31 +2424,31 @@ tcp46_rcv_process_inline (vlib_main_t * vm, vlib_node_runtime_t * node,
 	}
 
       /* 8: check the FIN bit */
-      if (!is_fin0)
+      if (!is_fin)
 	goto drop;
 
-      TCP_EVT (TCP_EVT_FIN_RCVD, tc0);
+      TCP_EVT (TCP_EVT_FIN_RCVD, tc);
 
-      switch (tc0->state)
+      switch (tc->state)
 	{
 	case TCP_STATE_ESTABLISHED:
 	  /* Account for the FIN and send ack */
-	  tc0->rcv_nxt += 1;
-	  tcp_program_ack (tc0);
-	  tcp_connection_set_state (tc0, TCP_STATE_CLOSE_WAIT);
-	  tcp_program_disconnect (wrk, tc0);
-	  tcp_timer_update (&wrk->timer_wheel, tc0, TCP_TIMER_WAITCLOSE,
+	  tc->rcv_nxt += 1;
+	  tcp_program_ack (tc);
+	  tcp_connection_set_state (tc, TCP_STATE_CLOSE_WAIT);
+	  tcp_program_disconnect (wrk, tc);
+	  tcp_timer_update (&wrk->timer_wheel, tc, 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
 	   * notified yet, set a cleanup timer instead of relying on
 	   * disconnect notify and the implicit close call. */
-	  tcp_connection_timers_reset (tc0);
-	  tc0->rcv_nxt += 1;
-	  tcp_send_fin (tc0);
-	  tcp_connection_set_state (tc0, TCP_STATE_LAST_ACK);
-	  tcp_timer_set (&wrk->timer_wheel, tc0, TCP_TIMER_WAITCLOSE,
+	  tcp_connection_timers_reset (tc);
+	  tc->rcv_nxt += 1;
+	  tcp_send_fin (tc);
+	  tcp_connection_set_state (tc, TCP_STATE_LAST_ACK);
+	  tcp_timer_set (&wrk->timer_wheel, tc, TCP_TIMER_WAITCLOSE,
 			 tcp_cfg.lastack_time);
 	  break;
 	case TCP_STATE_CLOSE_WAIT:
@@ -2435,54 +2457,51 @@ tcp46_rcv_process_inline (vlib_main_t * vm, vlib_node_runtime_t * node,
 	  /* move along .. */
 	  break;
 	case TCP_STATE_FIN_WAIT_1:
-	  tc0->rcv_nxt += 1;
+	  tc->rcv_nxt += 1;
 
-	  if (tc0->flags & TCP_CONN_FINPNDG)
+	  if (tc->flags & TCP_CONN_FINPNDG)
 	    {
 	      /* If data is outstanding, stay in FIN_WAIT_1 and try to finish
 	       * sending it. Since we already received a fin, do not wait
 	       * for too long. */
-	      tc0->flags |= TCP_CONN_FINRCVD;
-	      tcp_timer_update (&wrk->timer_wheel, tc0, TCP_TIMER_WAITCLOSE,
+	      tc->flags |= TCP_CONN_FINRCVD;
+	      tcp_timer_update (&wrk->timer_wheel, tc, TCP_TIMER_WAITCLOSE,
 				tcp_cfg.closewait_time);
 	    }
 	  else
 	    {
-	      tcp_connection_set_state (tc0, TCP_STATE_CLOSING);
-	      tcp_program_ack (tc0);
+	      tcp_connection_set_state (tc, TCP_STATE_CLOSING);
+	      tcp_program_ack (tc);
 	      /* Wait for ACK for our FIN but not forever */
-	      tcp_timer_update (&wrk->timer_wheel, tc0, TCP_TIMER_WAITCLOSE,
+	      tcp_timer_update (&wrk->timer_wheel, tc, TCP_TIMER_WAITCLOSE,
 				tcp_cfg.closing_time);
 	    }
 	  break;
 	case TCP_STATE_FIN_WAIT_2:
 	  /* Got FIN, send ACK! Be more aggressive with resource cleanup */
-	  tc0->rcv_nxt += 1;
-	  tcp_connection_set_state (tc0, TCP_STATE_TIME_WAIT);
-	  tcp_connection_timers_reset (tc0);
-	  tcp_timer_set (&wrk->timer_wheel, tc0, TCP_TIMER_WAITCLOSE,
+	  tc->rcv_nxt += 1;
+	  tcp_connection_set_state (tc, TCP_STATE_TIME_WAIT);
+	  tcp_connection_timers_reset (tc);
+	  tcp_timer_set (&wrk->timer_wheel, tc, TCP_TIMER_WAITCLOSE,
 			 tcp_cfg.timewait_time);
-	  tcp_program_ack (tc0);
-	  session_transport_closed_notify (&tc0->connection);
+	  tcp_program_ack (tc);
+	  session_transport_closed_notify (&tc->connection);
 	  break;
 	case TCP_STATE_TIME_WAIT:
 	  /* Remain in the TIME-WAIT state. Restart the time-wait
 	   * timeout.
 	   */
-	  tcp_timer_update (&wrk->timer_wheel, tc0, TCP_TIMER_WAITCLOSE,
+	  tcp_timer_update (&wrk->timer_wheel, tc, TCP_TIMER_WAITCLOSE,
 			    tcp_cfg.timewait_time);
 	  break;
 	}
-      error0 = TCP_ERROR_FIN_RCVD;
+      error = TCP_ERROR_FIN_RCVD;
 
     drop:
 
-      tcp_inc_counter (rcv_process, error0, 1);
-      if (PREDICT_FALSE (b0->flags & VLIB_BUFFER_IS_TRACED))
-	{
-	  tcp_rx_trace_t *t0 = vlib_add_trace (vm, node, b0, sizeof (*t0));
-	  tcp_set_rx_trace_data (t0, tc0, tcp0, b0, is_ip4);
-	}
+      b += 1;
+      n_left_from -= 1;
+      tcp_inc_counter (rcv_process, error, 1);
     }
 
   errors = session_main_flush_enqueue_events (TRANSPORT_PROTO_TCP,
@@ -2490,9 +2509,9 @@ tcp46_rcv_process_inline (vlib_main_t * vm, vlib_node_runtime_t * node,
   tcp_inc_counter (rcv_process, TCP_ERROR_MSG_QUEUE_FULL, errors);
   tcp_handle_postponed_dequeues (wrk);
   tcp_handle_disconnects (wrk);
-  vlib_buffer_free (vm, first_buffer, from_frame->n_vectors);
+  vlib_buffer_free (vm, from, frame->n_vectors);
 
-  return from_frame->n_vectors;
+  return frame->n_vectors;
 }
 
 VLIB_NODE_FN (tcp4_rcv_process_node) (vlib_main_t * vm,