From 04e5344a358a9ad42d896486d2d226149fd326f4 Mon Sep 17 00:00:00 2001
From: Florin Coras <fcoras@cisco.com>
Date: Sun, 16 Jul 2017 17:12:15 -0700
Subject: Cleanup/refactor session layer code

Change-Id: Ica99e8cb919fca6b069c37c969d60e8ccc2c6bf9
Signed-off-by: Florin Coras <fcoras@cisco.com>
---
 src/vnet/session/session_lookup.c | 620 ++++++++++++++++++++++++++++++++++++++
 1 file changed, 620 insertions(+)
 create mode 100644 src/vnet/session/session_lookup.c

(limited to 'src/vnet/session/session_lookup.c')

diff --git a/src/vnet/session/session_lookup.c b/src/vnet/session/session_lookup.c
new file mode 100644
index 00000000..b3862ee3
--- /dev/null
+++ b/src/vnet/session/session_lookup.c
@@ -0,0 +1,620 @@
+/*
+ * Copyright (c) 2017 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/** Generate typed init functions for multiple hash table styles... */
+#include <vppinfra/bihash_16_8.h>
+#include <vppinfra/bihash_template.h>
+
+#include <vppinfra/bihash_template.c>
+
+#undef __included_bihash_template_h__
+
+#include <vppinfra/bihash_48_8.h>
+#include <vppinfra/bihash_template.h>
+
+#include <vppinfra/bihash_template.c>
+#include <vnet/session/session_lookup.h>
+#include <vnet/session/session.h>
+
+static session_lookup_t session_lookup;
+extern transport_proto_vft_t *tp_vfts;
+
+/* *INDENT-OFF* */
+/* 16 octets */
+typedef CLIB_PACKED (struct {
+  union
+    {
+      struct
+	{
+	  ip4_address_t src;
+	  ip4_address_t dst;
+	  u16 src_port;
+	  u16 dst_port;
+	  /* align by making this 4 octets even though its a 1-bit field
+	   * NOTE: avoid key overlap with other transports that use 5 tuples for
+	   * session identification.
+	   */
+	  u32 proto;
+	};
+      u64 as_u64[2];
+    };
+}) v4_connection_key_t;
+
+typedef CLIB_PACKED (struct {
+  union
+    {
+      struct
+	{
+	  /* 48 octets */
+	  ip6_address_t src;
+	  ip6_address_t dst;
+	  u16 src_port;
+	  u16 dst_port;
+	  u32 proto;
+	  u64 unused;
+	};
+      u64 as_u64[6];
+    };
+}) v6_connection_key_t;
+/* *INDENT-ON* */
+
+typedef clib_bihash_kv_16_8_t session_kv4_t;
+typedef clib_bihash_kv_48_8_t session_kv6_t;
+
+always_inline void
+make_v4_ss_kv (session_kv4_t * kv, ip4_address_t * lcl, ip4_address_t * rmt,
+	       u16 lcl_port, u16 rmt_port, u8 proto)
+{
+  v4_connection_key_t *key = (v4_connection_key_t *) kv->key;
+
+  key->src.as_u32 = lcl->as_u32;
+  key->dst.as_u32 = rmt->as_u32;
+  key->src_port = lcl_port;
+  key->dst_port = rmt_port;
+  key->proto = proto;
+
+  kv->value = ~0ULL;
+}
+
+always_inline void
+make_v4_listener_kv (session_kv4_t * kv, ip4_address_t * lcl, u16 lcl_port,
+		     u8 proto)
+{
+  v4_connection_key_t *key = (v4_connection_key_t *) kv->key;
+
+  key->src.as_u32 = lcl->as_u32;
+  key->dst.as_u32 = 0;
+  key->src_port = lcl_port;
+  key->dst_port = 0;
+  key->proto = proto;
+
+  kv->value = ~0ULL;
+}
+
+always_inline void
+make_v4_ss_kv_from_tc (session_kv4_t * kv, transport_connection_t * t)
+{
+  return make_v4_ss_kv (kv, &t->lcl_ip.ip4, &t->rmt_ip.ip4, t->lcl_port,
+			t->rmt_port, t->proto);
+}
+
+always_inline void
+make_v6_ss_kv (session_kv6_t * kv, ip6_address_t * lcl, ip6_address_t * rmt,
+	       u16 lcl_port, u16 rmt_port, u8 proto)
+{
+  v6_connection_key_t *key = (v6_connection_key_t *) kv->key;
+
+  key->src.as_u64[0] = lcl->as_u64[0];
+  key->src.as_u64[1] = lcl->as_u64[1];
+  key->dst.as_u64[0] = rmt->as_u64[0];
+  key->dst.as_u64[1] = rmt->as_u64[1];
+  key->src_port = lcl_port;
+  key->dst_port = rmt_port;
+  key->proto = proto;
+  key->unused = 0;
+
+  kv->value = ~0ULL;
+}
+
+always_inline void
+make_v6_listener_kv (session_kv6_t * kv, ip6_address_t * lcl, u16 lcl_port,
+		     u8 proto)
+{
+  v6_connection_key_t *key = (v6_connection_key_t *) kv->key;
+
+  key->src.as_u64[0] = lcl->as_u64[0];
+  key->src.as_u64[1] = lcl->as_u64[1];
+  key->dst.as_u64[0] = 0;
+  key->dst.as_u64[1] = 0;
+  key->src_port = lcl_port;
+  key->dst_port = 0;
+  key->proto = proto;
+  key->unused = 0;
+
+  kv->value = ~0ULL;
+}
+
+always_inline void
+make_v6_ss_kv_from_tc (session_kv6_t * kv, transport_connection_t * t)
+{
+  make_v6_ss_kv (kv, &t->lcl_ip.ip6, &t->rmt_ip.ip6, t->lcl_port,
+		 t->rmt_port, t->proto);
+}
+
+/*
+ * Session lookup key; (src-ip, dst-ip, src-port, dst-port, session-type)
+ * Value: (owner thread index << 32 | session_index);
+ */
+void
+stream_session_table_add_for_tc (transport_connection_t * tc, u64 value)
+{
+  session_lookup_t *sl = &session_lookup;
+  session_kv4_t kv4;
+  session_kv6_t kv6;
+
+  switch (tc->proto)
+    {
+    case SESSION_TYPE_IP4_UDP:
+    case SESSION_TYPE_IP4_TCP:
+      make_v4_ss_kv_from_tc (&kv4, tc);
+      kv4.value = value;
+      clib_bihash_add_del_16_8 (&sl->v4_session_hash, &kv4, 1 /* is_add */ );
+      break;
+    case SESSION_TYPE_IP6_UDP:
+    case SESSION_TYPE_IP6_TCP:
+      make_v6_ss_kv_from_tc (&kv6, tc);
+      kv6.value = value;
+      clib_bihash_add_del_48_8 (&sl->v6_session_hash, &kv6, 1 /* is_add */ );
+      break;
+    default:
+      clib_warning ("Session type not supported");
+      ASSERT (0);
+    }
+}
+
+void
+stream_session_table_add (session_manager_main_t * smm, stream_session_t * s,
+			  u64 value)
+{
+  transport_connection_t *tc;
+
+  tc = tp_vfts[s->session_type].get_connection (s->connection_index,
+						s->thread_index);
+  stream_session_table_add_for_tc (tc, value);
+}
+
+void
+stream_session_half_open_table_add (session_type_t sst,
+				    transport_connection_t * tc, u64 value)
+{
+  session_lookup_t *sl = &session_lookup;
+  session_kv4_t kv4;
+  session_kv6_t kv6;
+
+  switch (sst)
+    {
+    case SESSION_TYPE_IP4_UDP:
+    case SESSION_TYPE_IP4_TCP:
+      make_v4_ss_kv_from_tc (&kv4, tc);
+      kv4.value = value;
+      clib_bihash_add_del_16_8 (&sl->v4_half_open_hash, &kv4,
+				1 /* is_add */ );
+      break;
+    case SESSION_TYPE_IP6_UDP:
+    case SESSION_TYPE_IP6_TCP:
+      make_v6_ss_kv_from_tc (&kv6, tc);
+      kv6.value = value;
+      clib_bihash_add_del_48_8 (&sl->v6_half_open_hash, &kv6,
+				1 /* is_add */ );
+      break;
+    default:
+      clib_warning ("Session type not supported");
+      ASSERT (0);
+    }
+}
+
+int
+stream_session_table_del_for_tc (transport_connection_t * tc)
+{
+  session_lookup_t *sl = &session_lookup;
+  session_kv4_t kv4;
+  session_kv6_t kv6;
+  switch (tc->proto)
+    {
+    case SESSION_TYPE_IP4_UDP:
+    case SESSION_TYPE_IP4_TCP:
+      make_v4_ss_kv_from_tc (&kv4, tc);
+      return clib_bihash_add_del_16_8 (&sl->v4_session_hash, &kv4,
+				       0 /* is_add */ );
+      break;
+    case SESSION_TYPE_IP6_UDP:
+    case SESSION_TYPE_IP6_TCP:
+      make_v6_ss_kv_from_tc (&kv6, tc);
+      return clib_bihash_add_del_48_8 (&sl->v6_session_hash, &kv6,
+				       0 /* is_add */ );
+      break;
+    default:
+      clib_warning ("Session type not supported");
+      ASSERT (0);
+    }
+
+  return 0;
+}
+
+int
+stream_session_table_del (stream_session_t * s)
+{
+  transport_connection_t *ts;
+  ts = tp_vfts[s->session_type].get_connection (s->connection_index,
+						s->thread_index);
+  return stream_session_table_del_for_tc (ts);
+}
+
+void
+stream_session_half_open_table_del (u8 sst, transport_connection_t * tc)
+{
+  session_lookup_t *sl = &session_lookup;
+  session_kv4_t kv4;
+  session_kv6_t kv6;
+
+  switch (sst)
+    {
+    case SESSION_TYPE_IP4_UDP:
+    case SESSION_TYPE_IP4_TCP:
+      make_v4_ss_kv_from_tc (&kv4, tc);
+      clib_bihash_add_del_16_8 (&sl->v4_half_open_hash, &kv4,
+				0 /* is_add */ );
+      break;
+    case SESSION_TYPE_IP6_UDP:
+    case SESSION_TYPE_IP6_TCP:
+      make_v6_ss_kv_from_tc (&kv6, tc);
+      clib_bihash_add_del_48_8 (&sl->v6_half_open_hash, &kv6,
+				0 /* is_add */ );
+      break;
+    default:
+      clib_warning ("Session type not supported");
+      ASSERT (0);
+    }
+}
+
+stream_session_t *
+stream_session_lookup_listener4 (ip4_address_t * lcl, u16 lcl_port, u8 proto)
+{
+  session_lookup_t *sl = &session_lookup;
+  session_kv4_t kv4;
+  int rv;
+
+  make_v4_listener_kv (&kv4, lcl, lcl_port, proto);
+  rv = clib_bihash_search_inline_16_8 (&sl->v4_session_hash, &kv4);
+  if (rv == 0)
+    return session_manager_get_listener (proto, (u32) kv4.value);
+
+  /* Zero out the lcl ip */
+  kv4.key[0] = 0;
+  rv = clib_bihash_search_inline_16_8 (&sl->v4_session_hash, &kv4);
+  if (rv == 0)
+    return session_manager_get_listener (proto, (u32) kv4.value);
+
+  return 0;
+}
+
+/** Looks up a session based on the 5-tuple passed as argument.
+ *
+ * First it tries to find an established session, if this fails, it tries
+ * finding a listener session if this fails, it tries a lookup with a
+ * wildcarded local source (listener bound to all interfaces)
+ */
+stream_session_t *
+stream_session_lookup4 (ip4_address_t * lcl, ip4_address_t * rmt,
+			u16 lcl_port, u16 rmt_port, u8 proto)
+{
+  session_lookup_t *sl = &session_lookup;
+  session_kv4_t kv4;
+  stream_session_t *s;
+  int rv;
+
+  /* Lookup session amongst established ones */
+  make_v4_ss_kv (&kv4, lcl, rmt, lcl_port, rmt_port, proto);
+  rv = clib_bihash_search_inline_16_8 (&sl->v4_session_hash, &kv4);
+  if (rv == 0)
+    return stream_session_get_from_handle (kv4.value);
+
+  /* If nothing is found, check if any listener is available */
+  if ((s = stream_session_lookup_listener4 (lcl, lcl_port, proto)))
+    return s;
+
+  /* Finally, try half-open connections */
+  rv = clib_bihash_search_inline_16_8 (&sl->v4_half_open_hash, &kv4);
+  if (rv == 0)
+    return stream_session_get_from_handle (kv4.value);
+  return 0;
+}
+
+stream_session_t *
+stream_session_lookup_listener6 (ip6_address_t * lcl, u16 lcl_port, u8 proto)
+{
+  session_lookup_t *sl = &session_lookup;
+  session_kv6_t kv6;
+  int rv;
+
+  make_v6_listener_kv (&kv6, lcl, lcl_port, proto);
+  rv = clib_bihash_search_inline_48_8 (&sl->v6_session_hash, &kv6);
+  if (rv == 0)
+    return session_manager_get_listener (proto, (u32) kv6.value);
+
+  /* Zero out the lcl ip */
+  kv6.key[0] = kv6.key[1] = 0;
+  rv = clib_bihash_search_inline_48_8 (&sl->v6_session_hash, &kv6);
+  if (rv == 0)
+    return session_manager_get_listener (proto, (u32) kv6.value);
+
+  return 0;
+}
+
+/* Looks up a session based on the 5-tuple passed as argument.
+ * First it tries to find an established session, if this fails, it tries
+ * finding a listener session if this fails, it tries a lookup with a
+ * wildcarded local source (listener bound to all interfaces) */
+stream_session_t *
+stream_session_lookup6 (ip6_address_t * lcl, ip6_address_t * rmt,
+			u16 lcl_port, u16 rmt_port, u8 proto)
+{
+  session_lookup_t *sl = &session_lookup;
+  session_kv6_t kv6;
+  stream_session_t *s;
+  int rv;
+
+  make_v6_ss_kv (&kv6, lcl, rmt, lcl_port, rmt_port, proto);
+  rv = clib_bihash_search_inline_48_8 (&sl->v6_session_hash, &kv6);
+  if (rv == 0)
+    return stream_session_get_from_handle (kv6.value);
+
+  /* If nothing is found, check if any listener is available */
+  if ((s = stream_session_lookup_listener6 (lcl, lcl_port, proto)))
+    return s;
+
+  /* Finally, try half-open connections */
+  rv = clib_bihash_search_inline_48_8 (&sl->v6_half_open_hash, &kv6);
+  if (rv == 0)
+    return stream_session_get_from_handle (kv6.value);
+  return 0;
+}
+
+stream_session_t *
+stream_session_lookup_listener (ip46_address_t * lcl, u16 lcl_port, u8 proto)
+{
+  switch (proto)
+    {
+    case SESSION_TYPE_IP4_UDP:
+    case SESSION_TYPE_IP4_TCP:
+      return stream_session_lookup_listener4 (&lcl->ip4, lcl_port, proto);
+      break;
+    case SESSION_TYPE_IP6_UDP:
+    case SESSION_TYPE_IP6_TCP:
+      return stream_session_lookup_listener6 (&lcl->ip6, lcl_port, proto);
+      break;
+    }
+  return 0;
+}
+
+u64
+stream_session_half_open_lookup_handle (ip46_address_t * lcl,
+					ip46_address_t * rmt, u16 lcl_port,
+					u16 rmt_port, u8 proto)
+{
+  session_lookup_t *sl = &session_lookup;
+  session_kv4_t kv4;
+  session_kv6_t kv6;
+  int rv;
+
+  switch (proto)
+    {
+    case SESSION_TYPE_IP4_UDP:
+    case SESSION_TYPE_IP4_TCP:
+      make_v4_ss_kv (&kv4, &lcl->ip4, &rmt->ip4, lcl_port, rmt_port, proto);
+      rv = clib_bihash_search_inline_16_8 (&sl->v4_half_open_hash, &kv4);
+
+      if (rv == 0)
+	return kv4.value;
+
+      return HALF_OPEN_LOOKUP_INVALID_VALUE;
+      break;
+    case SESSION_TYPE_IP6_UDP:
+    case SESSION_TYPE_IP6_TCP:
+      make_v6_ss_kv (&kv6, &lcl->ip6, &rmt->ip6, lcl_port, rmt_port, proto);
+      rv = clib_bihash_search_inline_48_8 (&sl->v6_half_open_hash, &kv6);
+
+      if (rv == 0)
+	return kv6.value;
+
+      return HALF_OPEN_LOOKUP_INVALID_VALUE;
+      break;
+    }
+  return HALF_OPEN_LOOKUP_INVALID_VALUE;
+}
+
+transport_connection_t *
+stream_session_half_open_lookup (ip46_address_t * lcl, ip46_address_t * rmt,
+				 u16 lcl_port, u16 rmt_port, u8 proto)
+{
+  u64 handle;
+  handle =
+    stream_session_half_open_lookup_handle (lcl, rmt, lcl_port, rmt_port,
+					    proto);
+  if (handle != HALF_OPEN_LOOKUP_INVALID_VALUE)
+    return tp_vfts[proto].get_half_open (handle & 0xFFFFFFFF);
+  return 0;
+}
+
+always_inline stream_session_t *
+stream_session_get_tsi (u64 ti_and_si, u32 thread_index)
+{
+  ASSERT ((u32) (ti_and_si >> 32) == thread_index);
+  return pool_elt_at_index (session_manager_main.sessions[thread_index],
+			    ti_and_si & 0xFFFFFFFFULL);
+}
+
+transport_connection_t *
+stream_session_lookup_transport_wt4 (ip4_address_t * lcl, ip4_address_t * rmt,
+				     u16 lcl_port, u16 rmt_port, u8 proto,
+				     u32 my_thread_index)
+{
+  session_lookup_t *sl = &session_lookup;
+  session_kv4_t kv4;
+  stream_session_t *s;
+  int rv;
+
+  /* Lookup session amongst established ones */
+  make_v4_ss_kv (&kv4, lcl, rmt, lcl_port, rmt_port, proto);
+  rv = clib_bihash_search_inline_16_8 (&sl->v4_session_hash, &kv4);
+  if (rv == 0)
+    {
+      s = stream_session_get_tsi (kv4.value, my_thread_index);
+      return tp_vfts[s->session_type].get_connection (s->connection_index,
+						      my_thread_index);
+    }
+
+  /* If nothing is found, check if any listener is available */
+  s = stream_session_lookup_listener4 (lcl, lcl_port, proto);
+  if (s)
+    return tp_vfts[s->session_type].get_listener (s->connection_index);
+
+  /* Finally, try half-open connections */
+  rv = clib_bihash_search_inline_16_8 (&sl->v4_half_open_hash, &kv4);
+  if (rv == 0)
+    return tp_vfts[proto].get_half_open (kv4.value & 0xFFFFFFFF);
+  return 0;
+}
+
+transport_connection_t *
+stream_session_lookup_transport4 (ip4_address_t * lcl, ip4_address_t * rmt,
+				  u16 lcl_port, u16 rmt_port, u8 proto)
+{
+  session_lookup_t *sl = &session_lookup;
+  session_kv4_t kv4;
+  stream_session_t *s;
+  int rv;
+
+  /* Lookup session amongst established ones */
+  make_v4_ss_kv (&kv4, lcl, rmt, lcl_port, rmt_port, proto);
+  rv = clib_bihash_search_inline_16_8 (&sl->v4_session_hash, &kv4);
+  if (rv == 0)
+    {
+      s = stream_session_get_from_handle (kv4.value);
+      return tp_vfts[s->session_type].get_connection (s->connection_index,
+						      s->thread_index);
+    }
+
+  /* If nothing is found, check if any listener is available */
+  s = stream_session_lookup_listener4 (lcl, lcl_port, proto);
+  if (s)
+    return tp_vfts[s->session_type].get_listener (s->connection_index);
+
+  /* Finally, try half-open connections */
+  rv = clib_bihash_search_inline_16_8 (&sl->v4_half_open_hash, &kv4);
+  if (rv == 0)
+    return tp_vfts[proto].get_half_open (kv4.value & 0xFFFFFFFF);
+  return 0;
+}
+
+transport_connection_t *
+stream_session_lookup_transport_wt6 (ip6_address_t * lcl, ip6_address_t * rmt,
+				     u16 lcl_port, u16 rmt_port, u8 proto,
+				     u32 my_thread_index)
+{
+  session_lookup_t *sl = &session_lookup;
+  stream_session_t *s;
+  session_kv6_t kv6;
+  int rv;
+
+  make_v6_ss_kv (&kv6, lcl, rmt, lcl_port, rmt_port, proto);
+  rv = clib_bihash_search_inline_48_8 (&sl->v6_session_hash, &kv6);
+  if (rv == 0)
+    {
+      s = stream_session_get_tsi (kv6.value, my_thread_index);
+      return tp_vfts[s->session_type].get_connection (s->connection_index,
+						      my_thread_index);
+    }
+
+  /* If nothing is found, check if any listener is available */
+  s = stream_session_lookup_listener6 (lcl, lcl_port, proto);
+  if (s)
+    return tp_vfts[s->session_type].get_listener (s->connection_index);
+
+  /* Finally, try half-open connections */
+  rv = clib_bihash_search_inline_48_8 (&sl->v6_half_open_hash, &kv6);
+  if (rv == 0)
+    return tp_vfts[proto].get_half_open (kv6.value & 0xFFFFFFFF);
+
+  return 0;
+}
+
+transport_connection_t *
+stream_session_lookup_transport6 (ip6_address_t * lcl, ip6_address_t * rmt,
+				  u16 lcl_port, u16 rmt_port, u8 proto)
+{
+  session_lookup_t *sl = &session_lookup;
+  stream_session_t *s;
+  session_kv6_t kv6;
+  int rv;
+
+  make_v6_ss_kv (&kv6, lcl, rmt, lcl_port, rmt_port, proto);
+  rv = clib_bihash_search_inline_48_8 (&sl->v6_session_hash, &kv6);
+  if (rv == 0)
+    {
+      s = stream_session_get_from_handle (kv6.value);
+      return tp_vfts[s->session_type].get_connection (s->connection_index,
+						      s->thread_index);
+    }
+
+  /* If nothing is found, check if any listener is available */
+  s = stream_session_lookup_listener6 (lcl, lcl_port, proto);
+  if (s)
+    return tp_vfts[s->session_type].get_listener (s->connection_index);
+
+  /* Finally, try half-open connections */
+  rv = clib_bihash_search_inline_48_8 (&sl->v6_half_open_hash, &kv6);
+  if (rv == 0)
+    return tp_vfts[proto].get_half_open (kv6.value & 0xFFFFFFFF);
+
+  return 0;
+}
+
+void
+session_lookup_init (void)
+{
+  session_lookup_t *sl = &session_lookup;
+  clib_bihash_init_16_8 (&sl->v4_session_hash, "v4 session table",
+			 200000 /* $$$$ config parameter nbuckets */ ,
+			 (64 << 20) /*$$$ config parameter table size */ );
+  clib_bihash_init_48_8 (&sl->v6_session_hash, "v6 session table",
+			 200000 /* $$$$ config parameter nbuckets */ ,
+			 (64 << 20) /*$$$ config parameter table size */ );
+
+  clib_bihash_init_16_8 (&sl->v4_half_open_hash, "v4 half-open table",
+			 200000 /* $$$$ config parameter nbuckets */ ,
+			 (64 << 20) /*$$$ config parameter table size */ );
+  clib_bihash_init_48_8 (&sl->v6_half_open_hash, "v6 half-open table",
+			 200000 /* $$$$ config parameter nbuckets */ ,
+			 (64 << 20) /*$$$ config parameter table size */ );
+}
+
+/*
+ * fd.io coding-style-patch-verification: ON
+ *
+ * Local Variables:
+ * eval: (c-set-style "gnu")
+ * End:
+ */
-- 
cgit 1.2.3-korg


From 68810624f84467503482b82662c980e8f0e36deb Mon Sep 17 00:00:00 2001
From: Florin Coras <fcoras@cisco.com>
Date: Mon, 24 Jul 2017 17:40:28 -0700
Subject: Make tcp active open data structures thread safe

- Cleanup half-open connections and timers on the right thread
- Ensure half-open connection and transport endpoint pools are thread safe
- Enqueue TX events to the correct vpp thread in the builtin client
- Use transport proto in transport connections instead of session type

Change-Id: Id13239a206afbff6f34a38afa510fe014e4b2049
Signed-off-by: Florin Coras <fcoras@cisco.com>
Signed-off-by: Dave Barach <dave@barachs.net>
---
 src/svm/svm_fifo_segment.c             |   6 ++
 src/vnet/session/session.c             |  14 +--
 src/vnet/session/session.h             |   3 +-
 src/vnet/session/session_cli.c         |   2 +-
 src/vnet/session/session_lookup.c      | 103 ++++++++------------
 src/vnet/session/session_lookup.h      |   5 +-
 src/vnet/session/transport.h           |   6 +-
 src/vnet/session/transport_interface.c |   5 +-
 src/vnet/session/transport_interface.h |   2 +-
 src/vnet/tcp/builtin_client.c          | 125 +++++++++++++++----------
 src/vnet/tcp/builtin_client.h          |   9 +-
 src/vnet/tcp/tcp.c                     | 166 ++++++++++++++++++++-------------
 src/vnet/tcp/tcp.h                     |  18 ++--
 src/vnet/tcp/tcp_debug.h               |  32 +++----
 src/vnet/tcp/tcp_input.c               |  36 ++++---
 src/vnet/tcp/tcp_output.c              |  19 +++-
 src/vnet/tcp/tcp_test.c                |  14 +--
 src/vnet/udp/udp.c                     |   8 +-
 src/vnet/udp/udp_input.c               |   2 +-
 19 files changed, 321 insertions(+), 254 deletions(-)

(limited to 'src/vnet/session/session_lookup.c')

diff --git a/src/svm/svm_fifo_segment.c b/src/svm/svm_fifo_segment.c
index c80374a7..a01e26e4 100644
--- a/src/svm/svm_fifo_segment.c
+++ b/src/svm/svm_fifo_segment.c
@@ -376,6 +376,12 @@ svm_fifo_segment_free_fifo (svm_fifo_segment_private_t * s, svm_fifo_t * f,
       break;
     }
 
+  if (CLIB_DEBUG)
+    {
+      f->master_session_index = ~0;
+      f->master_thread_index = ~0;
+    }
+
   ssvm_pop_heap (oldheap);
   ssvm_unlock_non_recursive (sh);
 }
diff --git a/src/vnet/session/session.c b/src/vnet/session/session.c
index 48000a6f..004c7193 100644
--- a/src/vnet/session/session.c
+++ b/src/vnet/session/session.c
@@ -64,7 +64,8 @@ stream_session_create_i (segment_manager_t * sm, transport_connection_t * tc,
   s->server_tx_fifo = server_tx_fifo;
 
   /* Initialize state machine, such as it is... */
-  s->session_type = tc->proto;
+  s->session_type = session_type_from_proto_and_ip (tc->transport_proto,
+						    tc->is_ip4);
   s->session_state = SESSION_STATE_CONNECTING;
   s->svm_segment_index = fifo_segment_index;
   s->thread_index = thread_index;
@@ -354,8 +355,7 @@ stream_session_init_fifos_pointers (transport_connection_t * tc,
 }
 
 int
-stream_session_connect_notify (transport_connection_t * tc, u8 sst,
-			       u8 is_fail)
+stream_session_connect_notify (transport_connection_t * tc, u8 is_fail)
 {
   application_t *app;
   stream_session_t *new_s = 0;
@@ -365,7 +365,7 @@ stream_session_connect_notify (transport_connection_t * tc, u8 sst,
 
   handle = stream_session_half_open_lookup_handle (&tc->lcl_ip, &tc->rmt_ip,
 						   tc->lcl_port, tc->rmt_port,
-						   tc->proto);
+						   tc->transport_proto);
   if (handle == HALF_OPEN_LOOKUP_INVALID_VALUE)
     {
       clib_warning ("This can't be good!");
@@ -391,7 +391,7 @@ stream_session_connect_notify (transport_connection_t * tc, u8 sst,
 	new_s->app_index = app->index;
     }
 
-  /* Notify client */
+  /* Notify client application */
   if (app->cb_fns.session_connected_callback (app->index, api_context, new_s,
 					      is_fail))
     {
@@ -406,7 +406,7 @@ stream_session_connect_notify (transport_connection_t * tc, u8 sst,
     }
 
   /* Cleanup session lookup */
-  stream_session_half_open_table_del (sst, tc);
+  stream_session_half_open_table_del (tc);
 
   return error;
 }
@@ -567,7 +567,7 @@ stream_session_open (u32 app_index, session_type_t st,
   handle = (((u64) app_index) << 32) | (u64) tc->c_index;
 
   /* Add to the half-open lookup table */
-  stream_session_half_open_table_add (st, tc, handle);
+  stream_session_half_open_table_add (tc, handle);
 
   *res = tc;
 
diff --git a/src/vnet/session/session.h b/src/vnet/session/session.h
index bb22f100..180b9f8a 100644
--- a/src/vnet/session/session.h
+++ b/src/vnet/session/session.h
@@ -274,8 +274,7 @@ stream_session_peek_bytes (transport_connection_t * tc, u8 * buffer,
 			   u32 offset, u32 max_bytes);
 u32 stream_session_dequeue_drop (transport_connection_t * tc, u32 max_bytes);
 
-int stream_session_connect_notify (transport_connection_t * tc, u8 sst,
-				   u8 is_fail);
+int stream_session_connect_notify (transport_connection_t * tc, u8 is_fail);
 void stream_session_init_fifos_pointers (transport_connection_t * tc,
 					 u32 rx_pointer, u32 tx_pointer);
 
diff --git a/src/vnet/session/session_cli.c b/src/vnet/session/session_cli.c
index 4d432977..de564ea7 100755
--- a/src/vnet/session/session_cli.c
+++ b/src/vnet/session/session_cli.c
@@ -57,7 +57,7 @@ format_stream_session (u8 * s, va_list * args)
   u8 *str = 0;
   tp_vft = session_get_transport_vft (ss->session_type);
 
-  if (verbose == 1)
+  if (verbose == 1 && ss->session_state >= SESSION_STATE_ACCEPTING)
     str = format (0, "%-10u%-10u%-10lld",
 		  svm_fifo_max_dequeue (ss->server_rx_fifo),
 		  svm_fifo_max_enqueue (ss->server_tx_fifo),
diff --git a/src/vnet/session/session_lookup.c b/src/vnet/session/session_lookup.c
index b3862ee3..1ce22f80 100644
--- a/src/vnet/session/session_lookup.c
+++ b/src/vnet/session/session_lookup.c
@@ -107,7 +107,7 @@ always_inline void
 make_v4_ss_kv_from_tc (session_kv4_t * kv, transport_connection_t * t)
 {
   return make_v4_ss_kv (kv, &t->lcl_ip.ip4, &t->rmt_ip.ip4, t->lcl_port,
-			t->rmt_port, t->proto);
+			t->rmt_port, t->transport_proto);
 }
 
 always_inline void
@@ -150,7 +150,7 @@ always_inline void
 make_v6_ss_kv_from_tc (session_kv6_t * kv, transport_connection_t * t)
 {
   make_v6_ss_kv (kv, &t->lcl_ip.ip6, &t->rmt_ip.ip6, t->lcl_port,
-		 t->rmt_port, t->proto);
+		 t->rmt_port, t->transport_proto);
 }
 
 /*
@@ -164,23 +164,17 @@ stream_session_table_add_for_tc (transport_connection_t * tc, u64 value)
   session_kv4_t kv4;
   session_kv6_t kv6;
 
-  switch (tc->proto)
+  if (tc->is_ip4)
     {
-    case SESSION_TYPE_IP4_UDP:
-    case SESSION_TYPE_IP4_TCP:
       make_v4_ss_kv_from_tc (&kv4, tc);
       kv4.value = value;
       clib_bihash_add_del_16_8 (&sl->v4_session_hash, &kv4, 1 /* is_add */ );
-      break;
-    case SESSION_TYPE_IP6_UDP:
-    case SESSION_TYPE_IP6_TCP:
+    }
+  else
+    {
       make_v6_ss_kv_from_tc (&kv6, tc);
       kv6.value = value;
       clib_bihash_add_del_48_8 (&sl->v6_session_hash, &kv6, 1 /* is_add */ );
-      break;
-    default:
-      clib_warning ("Session type not supported");
-      ASSERT (0);
     }
 }
 
@@ -195,59 +189,24 @@ stream_session_table_add (session_manager_main_t * smm, stream_session_t * s,
   stream_session_table_add_for_tc (tc, value);
 }
 
-void
-stream_session_half_open_table_add (session_type_t sst,
-				    transport_connection_t * tc, u64 value)
-{
-  session_lookup_t *sl = &session_lookup;
-  session_kv4_t kv4;
-  session_kv6_t kv6;
-
-  switch (sst)
-    {
-    case SESSION_TYPE_IP4_UDP:
-    case SESSION_TYPE_IP4_TCP:
-      make_v4_ss_kv_from_tc (&kv4, tc);
-      kv4.value = value;
-      clib_bihash_add_del_16_8 (&sl->v4_half_open_hash, &kv4,
-				1 /* is_add */ );
-      break;
-    case SESSION_TYPE_IP6_UDP:
-    case SESSION_TYPE_IP6_TCP:
-      make_v6_ss_kv_from_tc (&kv6, tc);
-      kv6.value = value;
-      clib_bihash_add_del_48_8 (&sl->v6_half_open_hash, &kv6,
-				1 /* is_add */ );
-      break;
-    default:
-      clib_warning ("Session type not supported");
-      ASSERT (0);
-    }
-}
-
 int
 stream_session_table_del_for_tc (transport_connection_t * tc)
 {
   session_lookup_t *sl = &session_lookup;
   session_kv4_t kv4;
   session_kv6_t kv6;
-  switch (tc->proto)
+
+  if (tc->is_ip4)
     {
-    case SESSION_TYPE_IP4_UDP:
-    case SESSION_TYPE_IP4_TCP:
       make_v4_ss_kv_from_tc (&kv4, tc);
       return clib_bihash_add_del_16_8 (&sl->v4_session_hash, &kv4,
 				       0 /* is_add */ );
-      break;
-    case SESSION_TYPE_IP6_UDP:
-    case SESSION_TYPE_IP6_TCP:
+    }
+  else
+    {
       make_v6_ss_kv_from_tc (&kv6, tc);
       return clib_bihash_add_del_48_8 (&sl->v6_session_hash, &kv6,
 				       0 /* is_add */ );
-      break;
-    default:
-      clib_warning ("Session type not supported");
-      ASSERT (0);
     }
 
   return 0;
@@ -262,30 +221,48 @@ stream_session_table_del (stream_session_t * s)
   return stream_session_table_del_for_tc (ts);
 }
 
+
 void
-stream_session_half_open_table_del (u8 sst, transport_connection_t * tc)
+stream_session_half_open_table_add (transport_connection_t * tc, u64 value)
 {
   session_lookup_t *sl = &session_lookup;
   session_kv4_t kv4;
   session_kv6_t kv6;
 
-  switch (sst)
+  if (tc->is_ip4)
+    {
+      make_v4_ss_kv_from_tc (&kv4, tc);
+      kv4.value = value;
+      clib_bihash_add_del_16_8 (&sl->v4_half_open_hash, &kv4,
+				1 /* is_add */ );
+    }
+  else
+    {
+      make_v6_ss_kv_from_tc (&kv6, tc);
+      kv6.value = value;
+      clib_bihash_add_del_48_8 (&sl->v6_half_open_hash, &kv6,
+				1 /* is_add */ );
+    }
+}
+
+void
+stream_session_half_open_table_del (transport_connection_t * tc)
+{
+  session_lookup_t *sl = &session_lookup;
+  session_kv4_t kv4;
+  session_kv6_t kv6;
+
+  if (tc->is_ip4)
     {
-    case SESSION_TYPE_IP4_UDP:
-    case SESSION_TYPE_IP4_TCP:
       make_v4_ss_kv_from_tc (&kv4, tc);
       clib_bihash_add_del_16_8 (&sl->v4_half_open_hash, &kv4,
 				0 /* is_add */ );
-      break;
-    case SESSION_TYPE_IP6_UDP:
-    case SESSION_TYPE_IP6_TCP:
+    }
+  else
+    {
       make_v6_ss_kv_from_tc (&kv6, tc);
       clib_bihash_add_del_48_8 (&sl->v6_half_open_hash, &kv6,
 				0 /* is_add */ );
-      break;
-    default:
-      clib_warning ("Session type not supported");
-      ASSERT (0);
     }
 }
 
diff --git a/src/vnet/session/session_lookup.h b/src/vnet/session/session_lookup.h
index 9e92dab1..cf1dc013 100644
--- a/src/vnet/session/session_lookup.h
+++ b/src/vnet/session/session_lookup.h
@@ -83,9 +83,8 @@ transport_connection_t *stream_session_half_open_lookup (ip46_address_t * lcl,
 void stream_session_table_add_for_tc (transport_connection_t * tc, u64 value);
 int stream_session_table_del_for_tc (transport_connection_t * tc);
 int stream_session_table_del (stream_session_t * s);
-void stream_session_half_open_table_del (u8 sst, transport_connection_t * tc);
-void stream_session_half_open_table_add (session_type_t sst,
-					 transport_connection_t * tc,
+void stream_session_half_open_table_del (transport_connection_t * tc);
+void stream_session_half_open_table_add (transport_connection_t * tc,
 					 u64 value);
 
 void session_lookup_init (void);
diff --git a/src/vnet/session/transport.h b/src/vnet/session/transport.h
index 3895a60a..e56be338 100644
--- a/src/vnet/session/transport.h
+++ b/src/vnet/session/transport.h
@@ -31,12 +31,12 @@ typedef struct _transport_connection
   ip46_address_t lcl_ip;	/**< Local IP */
   u16 lcl_port;			/**< Local port */
   u16 rmt_port;			/**< Remote port */
-  u8 proto;			/**< Protocol id (also session type) */
+  u8 transport_proto;		/**< Protocol id */
+  u8 is_ip4;			/**< Flag if IP4 connection */
   u32 vrf;			/**< FIB table id */
 
   u32 s_index;			/**< Parent session index */
   u32 c_index;			/**< Connection index in transport pool */
-  u8 is_ip4;			/**< Flag if IP4 connection */
   u32 thread_index;		/**< Worker-thread index */
 
   fib_node_index_t rmt_fei;	/**< FIB entry index for rmt */
@@ -56,7 +56,7 @@ typedef struct _transport_connection
 #define c_rmt_ip6 connection.rmt_ip.ip6
 #define c_lcl_port connection.lcl_port
 #define c_rmt_port connection.rmt_port
-#define c_proto connection.proto
+#define c_transport_proto connection.transport_proto
 #define c_vrf connection.vrf
 #define c_state connection.state
 #define c_s_index connection.s_index
diff --git a/src/vnet/session/transport_interface.c b/src/vnet/session/transport_interface.c
index eb12aa69..ef8d1e49 100644
--- a/src/vnet/session/transport_interface.c
+++ b/src/vnet/session/transport_interface.c
@@ -73,9 +73,12 @@ transport_endpoint_table_del (transport_endpoint_table_t * ht,
  * @param vft - virtual function table
  */
 void
-session_register_transport (u8 session_type,
+session_register_transport (transport_proto_t transport_proto, u8 is_ip4,
 			    const transport_proto_vft_t * vft)
 {
+  u8 session_type;
+  session_type = session_type_from_proto_and_ip (transport_proto, is_ip4);
+
   vec_validate (tp_vfts, session_type);
   tp_vfts[session_type] = *vft;
 
diff --git a/src/vnet/session/transport_interface.h b/src/vnet/session/transport_interface.h
index b7e86ee7..661221c4 100644
--- a/src/vnet/session/transport_interface.h
+++ b/src/vnet/session/transport_interface.h
@@ -67,7 +67,7 @@ void transport_endpoint_table_add (transport_endpoint_table_t * ht,
 void transport_endpoint_table_del (transport_endpoint_table_t * ht,
 				   transport_endpoint_t * te);
 
-void session_register_transport (u8 session_type,
+void session_register_transport (transport_proto_t transport_proto, u8 is_ip4,
 				 const transport_proto_vft_t * vft);
 transport_proto_vft_t *session_get_transport_vft (u8 session_type);
 
diff --git a/src/vnet/tcp/builtin_client.c b/src/vnet/tcp/builtin_client.c
index 744f50e7..27e20f8e 100644
--- a/src/vnet/tcp/builtin_client.c
+++ b/src/vnet/tcp/builtin_client.c
@@ -45,6 +45,24 @@
 
 #define TCP_BUILTIN_CLIENT_DBG (0)
 
+static void
+signal_evt_to_cli_i (int *code)
+{
+  tclient_main_t *tm = &tclient_main;
+  ASSERT (vlib_get_thread_index () == 0);
+  vlib_process_signal_event (tm->vlib_main, tm->cli_node_index, *code, 0);
+}
+
+static void
+signal_evt_to_cli (int code)
+{
+  if (vlib_get_thread_index () != 0)
+    vl_api_rpc_call_main_thread (signal_evt_to_cli_i, (u8 *) & code,
+				 sizeof (code));
+  else
+    signal_evt_to_cli_i (&code);
+}
+
 static void
 send_test_chunk (tclient_main_t * tm, session_t * s)
 {
@@ -53,6 +71,7 @@ send_test_chunk (tclient_main_t * tm, session_t * s)
   u32 bytes_this_chunk;
   session_fifo_event_t evt;
   static int serial_number = 0;
+  svm_fifo_t *txf;
   int rv;
 
   ASSERT (vec_len (test_data) > 0);
@@ -63,7 +82,8 @@ send_test_chunk (tclient_main_t * tm, session_t * s)
   bytes_this_chunk = bytes_this_chunk < s->bytes_to_send
     ? bytes_this_chunk : s->bytes_to_send;
 
-  rv = svm_fifo_enqueue_nowait (s->server_tx_fifo, bytes_this_chunk,
+  txf = s->server_tx_fifo;
+  rv = svm_fifo_enqueue_nowait (txf, bytes_this_chunk,
 				test_data + test_buf_offset);
 
   /* If we managed to enqueue data... */
@@ -93,15 +113,16 @@ send_test_chunk (tclient_main_t * tm, session_t * s)
 	}
 
       /* Poke the session layer */
-      if (svm_fifo_set_event (s->server_tx_fifo))
+      if (svm_fifo_set_event (txf))
 	{
 	  /* Fabricate TX event, send to vpp */
-	  evt.fifo = s->server_tx_fifo;
+	  evt.fifo = txf;
 	  evt.event_type = FIFO_EVENT_APP_TX;
 	  evt.event_id = serial_number++;
 
-	  if (unix_shared_memory_queue_add (tm->vpp_event_queue, (u8 *) & evt,
-					    0 /* do wait for mutex */ ))
+	  if (unix_shared_memory_queue_add
+	      (tm->vpp_event_queue[txf->master_thread_index], (u8 *) & evt,
+	       0 /* do wait for mutex */ ))
 	    clib_warning ("could not enqueue event");
 	}
     }
@@ -112,14 +133,16 @@ receive_test_chunk (tclient_main_t * tm, session_t * s)
 {
   svm_fifo_t *rx_fifo = s->server_rx_fifo;
   int n_read, test_bytes = 0;
+  u32 my_thread_index = vlib_get_thread_index ();
 
   /* Allow enqueuing of new event */
   // svm_fifo_unset_event (rx_fifo);
 
   if (test_bytes)
     {
-      n_read = svm_fifo_dequeue_nowait (rx_fifo, vec_len (tm->rx_buf),
-					tm->rx_buf);
+      n_read = svm_fifo_dequeue_nowait (rx_fifo,
+					vec_len (tm->rx_buf[my_thread_index]),
+					tm->rx_buf[my_thread_index]);
     }
   else
     {
@@ -151,10 +174,12 @@ receive_test_chunk (tclient_main_t * tm, session_t * s)
 	  int i;
 	  for (i = 0; i < n_read; i++)
 	    {
-	      if (tm->rx_buf[i] != ((s->bytes_received + i) & 0xff))
+	      if (tm->rx_buf[my_thread_index][i]
+		  != ((s->bytes_received + i) & 0xff))
 		{
 		  clib_warning ("read %d error at byte %lld, 0x%x not 0x%x",
-				n_read, s->bytes_received + i, tm->rx_buf[i],
+				n_read, s->bytes_received + i,
+				tm->rx_buf[my_thread_index][i],
 				((s->bytes_received + i) & 0xff));
 		}
 	    }
@@ -247,7 +272,11 @@ builtin_client_node_fn (vlib_main_t * vm, vlib_node_runtime_t * node,
 
 	  if (s)
 	    {
-	      stream_session_disconnect (s);
+	      vnet_disconnect_args_t _a, *a = &_a;
+	      a->handle = stream_session_handle (s);
+	      a->app_index = tm->app_index;
+	      vnet_disconnect_session (a);
+
 	      vec_delete (connections_this_batch, 1, i);
 	      i--;
 	      __sync_fetch_and_add (&tm->ready_connections, -1);
@@ -258,9 +287,7 @@ builtin_client_node_fn (vlib_main_t * vm, vlib_node_runtime_t * node,
 	  /* Kick the debug CLI process */
 	  if (tm->ready_connections == 0)
 	    {
-	      tm->test_end_time = vlib_time_now (vm);
-	      vlib_process_signal_event (vm, tm->cli_node_index,
-					 2, 0 /* data */ );
+	      signal_evt_to_cli (2);
 	    }
 	}
     }
@@ -369,27 +396,31 @@ static int
 tcp_test_clients_init (vlib_main_t * vm)
 {
   tclient_main_t *tm = &tclient_main;
-  vlib_thread_main_t *thread_main = vlib_get_thread_main ();
+  vlib_thread_main_t *vtm = vlib_get_thread_main ();
+  u32 num_threads;
   int i;
 
   tclient_api_hookup (vm);
   if (create_api_loopback (tm))
     return -1;
 
+  num_threads = 1 /* main thread */  + vtm->n_threads;
+
   /* Init test data. Big buffer */
   vec_validate (tm->connect_test_data, 1024 * 1024 - 1);
   for (i = 0; i < vec_len (tm->connect_test_data); i++)
     tm->connect_test_data[i] = i & 0xff;
 
-  tm->session_index_by_vpp_handles = hash_create (0, sizeof (uword));
-  vec_validate (tm->rx_buf, vec_len (tm->connect_test_data) - 1);
+  vec_validate (tm->rx_buf, num_threads - 1);
+  for (i = 0; i < num_threads; i++)
+    vec_validate (tm->rx_buf[i], vec_len (tm->connect_test_data) - 1);
 
   tm->is_init = 1;
-  tm->vlib_main = vm;
 
-  vec_validate (tm->connection_index_by_thread, thread_main->n_vlib_mains);
-  vec_validate (tm->connections_this_batch_by_thread,
-		thread_main->n_vlib_mains);
+  vec_validate (tm->connection_index_by_thread, vtm->n_vlib_mains);
+  vec_validate (tm->connections_this_batch_by_thread, vtm->n_vlib_mains);
+  vec_validate (tm->vpp_event_queue, vtm->n_vlib_mains);
+
   return 0;
 }
 
@@ -400,23 +431,28 @@ builtin_session_connected_callback (u32 app_index, u32 api_context,
   tclient_main_t *tm = &tclient_main;
   session_t *session;
   u32 session_index;
-  int i;
+  u8 thread_index = vlib_get_thread_index ();
+
+  ASSERT (s->thread_index == thread_index);
 
   if (is_fail)
     {
       clib_warning ("connection %d failed!", api_context);
-      vlib_process_signal_event (tm->vlib_main, tm->cli_node_index, -1,
-				 0 /* data */ );
-      return -1;
+      signal_evt_to_cli (-1);
+      return 0;
     }
 
-  tm->our_event_queue = session_manager_get_vpp_event_queue (s->thread_index);
-  tm->vpp_event_queue = session_manager_get_vpp_event_queue (s->thread_index);
+  if (!tm->vpp_event_queue[thread_index])
+    tm->vpp_event_queue[thread_index] =
+      session_manager_get_vpp_event_queue (thread_index);
 
   /*
    * Setup session
    */
+  clib_spinlock_lock_if_init (&tm->sessions_lock);
   pool_get (tm->sessions, session);
+  clib_spinlock_unlock_if_init (&tm->sessions_lock);
+
   memset (session, 0, sizeof (*session));
   session_index = session - tm->sessions;
   session->bytes_to_send = tm->bytes_to_send;
@@ -427,32 +463,13 @@ builtin_session_connected_callback (u32 app_index, u32 api_context,
   session->server_tx_fifo->client_session_index = session_index;
   session->vpp_session_handle = stream_session_handle (s);
 
-  /* Add it to the session lookup table */
-  hash_set (tm->session_index_by_vpp_handles, session->vpp_session_handle,
-	    session_index);
-
-  if (tm->ready_connections == tm->expected_connections - 1)
-    {
-      vlib_thread_main_t *thread_main = vlib_get_thread_main ();
-      int thread_index;
-
-      thread_index = 0;
-      for (i = 0; i < pool_elts (tm->sessions); i++)
-	{
-	  vec_add1 (tm->connection_index_by_thread[thread_index], i);
-	  thread_index++;
-	  if (thread_index == thread_main->n_vlib_mains)
-	    thread_index = 0;
-	}
-    }
+  vec_add1 (tm->connection_index_by_thread[thread_index], session_index);
   __sync_fetch_and_add (&tm->ready_connections, 1);
   if (tm->ready_connections == tm->expected_connections)
     {
       tm->run_test = 1;
-      tm->test_start_time = vlib_time_now (tm->vlib_main);
       /* Signal the CLI process that the action is starting... */
-      vlib_process_signal_event (tm->vlib_main, tm->cli_node_index, 1,
-				 0 /* data */ );
+      signal_evt_to_cli (1);
     }
 
   return 0;
@@ -606,7 +623,9 @@ test_tcp_clients_command_fn (vlib_main_t * vm,
   tm->connections_per_batch = 1000;
   tm->private_segment_count = 0;
   tm->private_segment_size = 0;
-
+  tm->vlib_main = vm;
+  if (thread_main->n_vlib_mains > 1)
+    clib_spinlock_init (&tm->sessions_lock);
   vec_free (tm->connect_uri);
 
   while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
@@ -668,7 +687,9 @@ test_tcp_clients_command_fn (vlib_main_t * vm,
   start_tx_pthread ();
 #endif
 
+  vlib_worker_thread_barrier_sync (vm);
   vnet_session_enable_disable (vm, 1 /* turn on TCP, etc. */ );
+  vlib_worker_thread_barrier_release (vm);
 
   if (tm->test_client_attached == 0)
     {
@@ -688,9 +709,8 @@ test_tcp_clients_command_fn (vlib_main_t * vm,
   clients_connect (vm, uri, n_clients);
 
   /* Park until the sessions come up, or ten seconds elapse... */
-  vlib_process_wait_for_event_or_clock (vm, 10.0 /* timeout, seconds */ );
+  vlib_process_wait_for_event_or_clock (vm, 10 /* timeout, seconds */ );
   event_type = vlib_process_get_events (vm, &event_data);
-
   switch (event_type)
     {
     case ~0:
@@ -699,6 +719,7 @@ test_tcp_clients_command_fn (vlib_main_t * vm,
       goto cleanup;
 
     case 1:
+      tm->test_start_time = vlib_time_now (tm->vlib_main);
       vlib_cli_output (vm, "Test started at %.6f", tm->test_start_time);
       break;
 
@@ -710,7 +731,6 @@ test_tcp_clients_command_fn (vlib_main_t * vm,
   /* Now wait for the sessions to finish... */
   vlib_process_wait_for_event_or_clock (vm, cli_timeout);
   event_type = vlib_process_get_events (vm, &event_data);
-
   switch (event_type)
     {
     case ~0:
@@ -719,6 +739,7 @@ test_tcp_clients_command_fn (vlib_main_t * vm,
       goto cleanup;
 
     case 2:
+      tm->test_end_time = vlib_time_now (vm);
       vlib_cli_output (vm, "Test finished at %.6f", tm->test_end_time);
       break;
 
@@ -753,6 +774,7 @@ cleanup:
       vec_reset_length (tm->connection_index_by_thread[i]);
       vec_reset_length (tm->connections_this_batch_by_thread[i]);
     }
+
   pool_free (tm->sessions);
 
   return 0;
@@ -765,6 +787,7 @@ VLIB_CLI_COMMAND (test_clients_command, static) =
   .short_help = "test tcp clients [nclients %d]"
   "[iterations %d] [bytes %d] [uri tcp://6.0.1.1/1234]",
   .function = test_tcp_clients_command_fn,
+  .is_mp_safe = 1,
 };
 /* *INDENT-ON* */
 
diff --git a/src/vnet/tcp/builtin_client.h b/src/vnet/tcp/builtin_client.h
index 38af231d..06d239ef 100644
--- a/src/vnet/tcp/builtin_client.h
+++ b/src/vnet/tcp/builtin_client.h
@@ -48,8 +48,7 @@ typedef struct
    * Application setup parameters
    */
   unix_shared_memory_queue_t *vl_input_queue;	/**< vpe input queue */
-  unix_shared_memory_queue_t *our_event_queue;	/**< Our event queue */
-  unix_shared_memory_queue_t *vpp_event_queue;	/**< $$$ single thread */
+  unix_shared_memory_queue_t **vpp_event_queue;
 
   u32 cli_node_index;			/**< cli process node index */
   u32 my_client_index;			/**< loopback API client handle */
@@ -70,9 +69,9 @@ typedef struct
   /*
    * Test state variables
    */
-  session_t *sessions;			/**< Sessions pool */
-  u8 *rx_buf;				/**< intermediate rx buffer */
-  uword *session_index_by_vpp_handles;	/**< Hash table for disconnecting */
+  session_t *sessions;			/**< Session pool, shared */
+  clib_spinlock_t sessions_lock;
+  u8 **rx_buf;				/**< intermediate rx buffers */
   u8 *connect_test_data;		/**< Pre-computed test data */
   u32 **connection_index_by_thread;
   u32 **connections_this_batch_by_thread; /**< active connection batch */
diff --git a/src/vnet/tcp/tcp.c b/src/vnet/tcp/tcp.c
index 6d1cfa07..59b20747 100644
--- a/src/vnet/tcp/tcp.c
+++ b/src/vnet/tcp/tcp.c
@@ -37,15 +37,14 @@ tcp_connection_bind (u32 session_index, transport_endpoint_t * lcl)
     {
       listener->c_lcl_ip4.as_u32 = lcl->ip.ip4.as_u32;
       listener->c_is_ip4 = 1;
-      listener->c_proto = SESSION_TYPE_IP4_TCP;
     }
   else
     {
       clib_memcpy (&listener->c_lcl_ip6, &lcl->ip.ip6,
 		   sizeof (ip6_address_t));
-      listener->c_proto = SESSION_TYPE_IP6_TCP;
-    }
 
+    }
+  listener->c_transport_proto = TRANSPORT_PROTO_TCP;
   listener->c_s_index = session_index;
   listener->state = TCP_STATE_LISTEN;
 
@@ -95,6 +94,71 @@ tcp_session_get_listener (u32 listener_index)
   return &tc->connection;
 }
 
+always_inline void
+transport_endpoint_del (u32 tepi)
+{
+  tcp_main_t *tm = vnet_get_tcp_main ();
+  clib_spinlock_lock_if_init (&tm->local_endpoints_lock);
+  pool_put_index (tm->local_endpoints, tepi);
+  clib_spinlock_unlock_if_init (&tm->local_endpoints_lock);
+}
+
+always_inline transport_endpoint_t *
+transport_endpoint_new (void)
+{
+  tcp_main_t *tm = vnet_get_tcp_main ();
+  transport_endpoint_t *tep;
+  pool_get (tm->local_endpoints, tep);
+  return tep;
+}
+
+/**
+ * Cleanup half-open connection
+ *
+ */
+void
+tcp_half_open_connection_del (tcp_connection_t * tc)
+{
+  tcp_main_t *tm = vnet_get_tcp_main ();
+  clib_spinlock_lock_if_init (&tm->half_open_lock);
+  pool_put_index (tm->half_open_connections, tc->c_c_index);
+  if (CLIB_DEBUG)
+    memset (tc, 0xFA, sizeof (*tc));
+  clib_spinlock_unlock_if_init (&tm->half_open_lock);
+}
+
+/**
+ * Try to cleanup half-open connection
+ *
+ * If called from a thread that doesn't own tc, the call won't have any
+ * effect.
+ *
+ * @param tc - connection to be cleaned up
+ * @return non-zero if cleanup failed.
+ */
+int
+tcp_half_open_connection_cleanup (tcp_connection_t * tc)
+{
+  /* Make sure this is the owning thread */
+  if (tc->c_thread_index != vlib_get_thread_index ())
+    return 1;
+  tcp_timer_reset (tc, TCP_TIMER_ESTABLISH);
+  tcp_timer_reset (tc, TCP_TIMER_RETRANSMIT_SYN);
+  tcp_half_open_connection_del (tc);
+  return 0;
+}
+
+tcp_connection_t *
+tcp_half_open_connection_new (void)
+{
+  tcp_main_t *tm = vnet_get_tcp_main ();
+  tcp_connection_t *tc = 0;
+  pool_get (tm->half_open_connections, tc);
+  memset (tc, 0, sizeof (*tc));
+  tc->c_c_index = tc - tm->half_open_connections;
+  return tc;
+}
+
 /**
  * Cleans up connection state.
  *
@@ -110,26 +174,28 @@ tcp_connection_cleanup (tcp_connection_t * tc)
   /* Cleanup local endpoint if this was an active connect */
   tepi = transport_endpoint_lookup (&tm->local_endpoints_table, &tc->c_lcl_ip,
 				    tc->c_lcl_port);
-
-  /*XXX lock */
   if (tepi != TRANSPORT_ENDPOINT_INVALID_INDEX)
     {
       tep = pool_elt_at_index (tm->local_endpoints, tepi);
       transport_endpoint_table_del (&tm->local_endpoints_table, tep);
-      pool_put (tm->local_endpoints, tep);
+      transport_endpoint_del (tepi);
     }
 
-  /* Make sure all timers are cleared */
-  tcp_connection_timers_reset (tc);
-
-  /* Check if half-open */
+  /* Check if connection is not yet fully established */
   if (tc->state == TCP_STATE_SYN_SENT)
     {
-      tcp_half_open_connection_del (tc);
+      /* Try to remove the half-open connection. If this is not the owning
+       * thread, tc won't be removed. Retransmit or establish timers will
+       * eventually expire and call again cleanup on the right thread. */
+      tcp_half_open_connection_cleanup (tc);
     }
   else
     {
       int thread_index = tc->c_thread_index;
+
+      /* Make sure all timers are cleared */
+      tcp_connection_timers_reset (tc);
+
       /* Poison the entry */
       if (CLIB_DEBUG > 0)
 	memset (tc, 0xFA, sizeof (*tc));
@@ -152,32 +218,6 @@ tcp_connection_del (tcp_connection_t * tc)
   tcp_connection_cleanup (tc);
 }
 
-/**
- * Cleanup half-open connection
- */
-void
-tcp_half_open_connection_del (tcp_connection_t * tc)
-{
-  tcp_main_t *tm = vnet_get_tcp_main ();
-  if (CLIB_DEBUG)
-    memset (tc, 0xFA, sizeof (*tc));
-  clib_spinlock_lock_if_init (&tm->half_open_lock);
-  pool_put (tm->half_open_connections, tc);
-  clib_spinlock_unlock_if_init (&tm->half_open_lock);
-}
-
-tcp_connection_t *
-tcp_half_open_connection_new ()
-{
-  tcp_main_t *tm = vnet_get_tcp_main ();
-  tcp_connection_t *tc = 0;
-  clib_spinlock_lock_if_init (&tm->half_open_lock);
-  pool_get (tm->half_open_connections, tc);
-  clib_spinlock_unlock_if_init (&tm->half_open_lock);
-  memset (tc, 0, sizeof (*tc));
-  return tc;
-}
-
 tcp_connection_t *
 tcp_connection_new (u8 thread_index)
 {
@@ -207,9 +247,7 @@ tcp_connection_reset (tcp_connection_t * tc)
       tcp_connection_cleanup (tc);
       break;
     case TCP_STATE_SYN_SENT:
-      /* XXX remove sst from call */
-      stream_session_connect_notify (&tc->connection, tc->connection.proto,
-				     1 /* fail */ );
+      stream_session_connect_notify (&tc->connection, 1 /* fail */ );
       tcp_connection_cleanup (tc);
       break;
     case TCP_STATE_ESTABLISHED:
@@ -225,7 +263,7 @@ tcp_connection_reset (tcp_connection_t * tc)
       stream_session_reset_notify (&tc->connection);
 
       /* Wait for cleanup from session layer but not forever */
-      tcp_timer_set (tc, TCP_TIMER_WAITCLOSE, TCP_CLEANUP_TIME);
+      tcp_timer_update (tc, TCP_TIMER_WAITCLOSE, TCP_CLEANUP_TIME);
       break;
     case TCP_STATE_CLOSED:
       return;
@@ -325,8 +363,9 @@ ip_interface_get_first_ip (u32 sw_if_index, u8 is_ip4)
  * table to mark the pair as used.
  */
 int
-tcp_allocate_local_port (tcp_main_t * tm, ip46_address_t * ip)
+tcp_allocate_local_port (ip46_address_t * ip)
 {
+  tcp_main_t *tm = vnet_get_tcp_main ();
   transport_endpoint_t *tep;
   u32 time_now, tei;
   u16 min = 1024, max = 65535;	/* XXX configurable ? */
@@ -338,10 +377,6 @@ tcp_allocate_local_port (tcp_main_t * tm, ip46_address_t * ip)
   /* Only support active opens from thread 0 */
   ASSERT (vlib_get_thread_index () == 0);
 
-  /* Start at random point or max */
-  pool_get (tm->local_endpoints, tep);
-  clib_memcpy (&tep->ip, ip, sizeof (*ip));
-
   /* Search for first free slot */
   for (; tries >= 0; tries--)
     {
@@ -355,21 +390,22 @@ tcp_allocate_local_port (tcp_main_t * tm, ip46_address_t * ip)
 	    break;
 	}
 
-      tep->port = port;
-
       /* Look it up */
-      tei = transport_endpoint_lookup (&tm->local_endpoints_table, &tep->ip,
-				       tep->port);
+      tei = transport_endpoint_lookup (&tm->local_endpoints_table, ip, port);
       /* If not found, we're done */
       if (tei == TRANSPORT_ENDPOINT_INVALID_INDEX)
 	{
+	  clib_spinlock_lock_if_init (&tm->local_endpoints_lock);
+	  tep = transport_endpoint_new ();
+	  clib_memcpy (&tep->ip, ip, sizeof (*ip));
+	  tep->port = port;
 	  transport_endpoint_table_add (&tm->local_endpoints_table, tep,
 					tep - tm->local_endpoints);
+	  clib_spinlock_unlock_if_init (&tm->local_endpoints_lock);
+
 	  return tep->port;
 	}
     }
-  /* No free ports */
-  pool_put (tm->local_endpoints, tep);
   return -1;
 }
 
@@ -592,7 +628,7 @@ tcp_connection_open (transport_endpoint_t * rmt)
     }
 
   /* Allocate source port */
-  lcl_port = tcp_allocate_local_port (tm, &lcl_addr);
+  lcl_port = tcp_allocate_local_port (&lcl_addr);
   if (lcl_port < 1)
     {
       clib_warning ("Failed to allocate src port");
@@ -602,16 +638,14 @@ tcp_connection_open (transport_endpoint_t * rmt)
   /*
    * Create connection and send SYN
    */
-
+  clib_spinlock_lock_if_init (&tm->half_open_lock);
   tc = tcp_half_open_connection_new ();
-
   clib_memcpy (&tc->c_rmt_ip, &rmt->ip, sizeof (ip46_address_t));
   clib_memcpy (&tc->c_lcl_ip, &lcl_addr, sizeof (ip46_address_t));
   tc->c_rmt_port = clib_host_to_net_u16 (rmt->port);
   tc->c_lcl_port = clib_host_to_net_u16 (lcl_port);
-  tc->c_c_index = tc - tm->half_open_connections;
   tc->c_is_ip4 = rmt->is_ip4;
-  tc->c_proto = rmt->is_ip4 ? SESSION_TYPE_IP4_TCP : SESSION_TYPE_IP6_TCP;
+  tc->c_transport_proto = TRANSPORT_PROTO_TCP;
   tc->c_vrf = rmt->vrf;
   /* The other connection vars will be initialized after SYN ACK */
   tcp_connection_timers_init (tc);
@@ -619,6 +653,7 @@ tcp_connection_open (transport_endpoint_t * rmt)
   TCP_EVT_DBG (TCP_EVT_OPEN, tc);
   tc->state = TCP_STATE_SYN_SENT;
   tcp_send_syn (tc);
+  clib_spinlock_unlock_if_init (&tm->half_open_lock);
 
   return tc->c_c_index;
 }
@@ -1057,16 +1092,12 @@ void
 tcp_timer_establish_handler (u32 conn_index)
 {
   tcp_connection_t *tc;
-  u8 sst;
 
   tc = tcp_half_open_connection_get (conn_index);
   tc->timers[TCP_TIMER_ESTABLISH] = TCP_TIMER_HANDLE_INVALID;
 
   ASSERT (tc->state == TCP_STATE_SYN_SENT);
-
-  sst = tc->c_is_ip4 ? SESSION_TYPE_IP4_TCP : SESSION_TYPE_IP6_TCP;
-  stream_session_connect_notify (&tc->connection, sst, 1 /* fail */ );
-
+  stream_session_connect_notify (&tc->connection, 1 /* fail */ );
   tcp_connection_cleanup (tc);
 }
 
@@ -1077,6 +1108,8 @@ tcp_timer_waitclose_handler (u32 conn_index)
   tcp_connection_t *tc;
 
   tc = tcp_connection_get (conn_index, thread_index);
+  if (!tc)
+    return;
   tc->timers[TCP_TIMER_WAITCLOSE] = TCP_TIMER_HANDLE_INVALID;
 
   /* Session didn't come back with a close(). Send FIN either way
@@ -1180,8 +1213,8 @@ tcp_main_enable (vlib_main_t * vm)
   ip4_register_protocol (IP_PROTOCOL_TCP, tcp4_input_node.index);
 
   /* Register as transport with session layer */
-  session_register_transport (SESSION_TYPE_IP4_TCP, &tcp_proto);
-  session_register_transport (SESSION_TYPE_IP6_TCP, &tcp_proto);
+  session_register_transport (TRANSPORT_PROTO_TCP, 1, &tcp_proto);
+  session_register_transport (TRANSPORT_PROTO_TCP, 0, &tcp_proto);
 
   /*
    * Initialize data structures
@@ -1227,7 +1260,10 @@ tcp_main_enable (vlib_main_t * vm)
 			 200000 /* $$$$ config parameter nbuckets */ ,
 			 (64 << 20) /*$$$ config parameter table size */ );
   if (num_threads > 1)
-    clib_spinlock_init (&tm->half_open_lock);
+    {
+      clib_spinlock_init (&tm->half_open_lock);
+      clib_spinlock_init (&tm->local_endpoints_lock);
+    }
   return error;
 }
 
diff --git a/src/vnet/tcp/tcp.h b/src/vnet/tcp/tcp.h
index 89c30616..4fa681f8 100644
--- a/src/vnet/tcp/tcp.h
+++ b/src/vnet/tcp/tcp.h
@@ -115,7 +115,8 @@ extern timer_expiration_handler tcp_timer_retransmit_syn_handler;
   _(SENT_RCV_WND0, "Sent 0 receive window")     \
   _(RECOVERY, "Recovery on")                    \
   _(FAST_RECOVERY, "Fast Recovery on")		\
-  _(FR_1_SMSS, "Sent 1 SMSS")
+  _(FR_1_SMSS, "Sent 1 SMSS")			\
+  _(HALF_OPEN_DONE, "Half-open completed")
 
 typedef enum _tcp_connection_flag_bits
 {
@@ -381,6 +382,7 @@ typedef struct _tcp_main
 
   /* Local endpoints lookup table */
   transport_endpoint_table_t local_endpoints_table;
+  clib_spinlock_t local_endpoints_lock;
 
   /* Congestion control algorithms registered */
   tcp_cc_algorithm_t *cc_algos;
@@ -430,7 +432,8 @@ clib_error_t *vnet_tcp_enable_disable (vlib_main_t * vm, u8 is_en);
 always_inline tcp_connection_t *
 tcp_connection_get (u32 conn_index, u32 thread_index)
 {
-  if (pool_is_free_index (tcp_main.connections[thread_index], conn_index))
+  if (PREDICT_FALSE
+      (pool_is_free_index (tcp_main.connections[thread_index], conn_index)))
     return 0;
   return pool_elt_at_index (tcp_main.connections[thread_index], conn_index);
 }
@@ -454,7 +457,7 @@ tcp_get_connection_from_transport (transport_connection_t * tconn)
 void tcp_connection_close (tcp_connection_t * tc);
 void tcp_connection_cleanup (tcp_connection_t * tc);
 void tcp_connection_del (tcp_connection_t * tc);
-void tcp_half_open_connection_del (tcp_connection_t * tc);
+int tcp_half_open_connection_cleanup (tcp_connection_t * tc);
 tcp_connection_t *tcp_connection_new (u8 thread_index);
 void tcp_connection_reset (tcp_connection_t * tc);
 
@@ -473,9 +476,12 @@ tcp_listener_get (u32 tli)
 always_inline tcp_connection_t *
 tcp_half_open_connection_get (u32 conn_index)
 {
-  if (pool_is_free_index (tcp_main.half_open_connections, conn_index))
-    return 0;
-  return pool_elt_at_index (tcp_main.half_open_connections, conn_index);
+  tcp_connection_t *tc = 0;
+  clib_spinlock_lock_if_init (&tcp_main.half_open_lock);
+  if (!pool_is_free_index (tcp_main.half_open_connections, conn_index))
+    tc = pool_elt_at_index (tcp_main.half_open_connections, conn_index);
+  clib_spinlock_unlock_if_init (&tcp_main.half_open_lock);
+  return tc;
 }
 
 void tcp_make_ack (tcp_connection_t * ts, vlib_buffer_t * b);
diff --git a/src/vnet/tcp/tcp_debug.h b/src/vnet/tcp/tcp_debug.h
index e3da56f4..fc36eb29 100755
--- a/src/vnet/tcp/tcp_debug.h
+++ b/src/vnet/tcp/tcp_debug.h
@@ -19,9 +19,9 @@
 #include <vlib/vlib.h>
 
 #define TCP_DEBUG (1)
-#define TCP_DEBUG_SM (2)
-#define TCP_DEBUG_CC (0)
-#define TCP_DEBUG_CC_STAT (0)
+#define TCP_DEBUG_SM (0)
+#define TCP_DEBUG_CC (1)
+#define TCP_DEBUG_CC_STAT (1)
 
 #define foreach_tcp_dbg_evt		\
   _(INIT, "")				\
@@ -197,6 +197,19 @@ typedef enum _tcp_dbg_evt
   ed->data[0] = _tc->c_c_index;						\
 }
 
+#define TCP_EVT_SYN_RCVD_HANDLER(_tc, ...)				\
+{									\
+  TCP_EVT_INIT_HANDLER(_tc, 0);						\
+  ELOG_TYPE_DECLARE (_e) =						\
+  {									\
+    .format = "syn-rx: irs %u",						\
+    .format_args = "i4",						\
+  };									\
+  DECLARE_ETD(_tc, _e, 1);						\
+  ed->data[0] = _tc->irs;						\
+  TCP_EVT_STATE_CHANGE_HANDLER(_tc);					\
+}
+
 #define TCP_EVT_UNBIND_HANDLER(_tc, ...)				\
 {									\
   TCP_EVT_DEALLOC_HANDLER(_tc);						\
@@ -258,19 +271,6 @@ typedef enum _tcp_dbg_evt
   ed->data[0] = _tc->state;						\
 }
 
-#define TCP_EVT_SYN_RCVD_HANDLER(_tc, ...)				\
-{									\
-  TCP_EVT_INIT_HANDLER(_tc, 0);						\
-  ELOG_TYPE_DECLARE (_e) =						\
-  {									\
-    .format = "syn-rx: irs %u",						\
-    .format_args = "i4",						\
-  };									\
-  DECLARE_ETD(_tc, _e, 1);						\
-  ed->data[0] = _tc->irs;						\
-  TCP_EVT_STATE_CHANGE_HANDLER(_tc);					\
-}
-
 #define TCP_EVT_SYN_SENT_HANDLER(_tc, ...)				\
 {									\
   ELOG_TYPE_DECLARE (_e) =						\
diff --git a/src/vnet/tcp/tcp_input.c b/src/vnet/tcp/tcp_input.c
index d32b4fc8..6c59d70f 100644
--- a/src/vnet/tcp/tcp_input.c
+++ b/src/vnet/tcp/tcp_input.c
@@ -1724,9 +1724,13 @@ tcp46_established_inline (vlib_main_t * vm, vlib_node_runtime_t * node,
 	       * in CLOSE-WAIT, set timer (reuse WAITCLOSE). */
 	      tc0->state = TCP_STATE_CLOSE_WAIT;
 	      TCP_EVT_DBG (TCP_EVT_FIN_RCVD, tc0);
-	      tc0->rcv_nxt += (vnet_buffer (b0)->tcp.data_len == 0);
+	      if (vnet_buffer (b0)->tcp.data_len == 0)
+		{
+		  tc0->rcv_nxt += 1;
+		  next0 = TCP_ESTABLISHED_NEXT_DROP;
+		}
 	      stream_session_disconnect_notify (&tc0->connection);
-	      tcp_timer_set (tc0, TCP_TIMER_WAITCLOSE, TCP_CLOSEWAIT_TIME);
+	      tcp_timer_update (tc0, TCP_TIMER_WAITCLOSE, TCP_CLOSEWAIT_TIME);
 	    }
 
 	done:
@@ -1819,7 +1823,6 @@ tcp46_syn_sent_inline (vlib_main_t * vm, vlib_node_runtime_t * node,
   tcp_main_t *tm = vnet_get_tcp_main ();
   u32 n_left_from, next_index, *from, *to_next;
   u32 my_thread_index = vm->thread_index, errors = 0;
-  u8 sst = is_ip4 ? SESSION_TYPE_IP4_TCP : SESSION_TYPE_IP6_TCP;
 
   from = vlib_frame_vector_args (from_frame);
   n_left_from = from_frame->n_vectors;
@@ -1936,10 +1939,6 @@ tcp46_syn_sent_inline (vlib_main_t * vm, vlib_node_runtime_t * node,
 	  if (tcp_options_parse (tcp0, &tc0->rcv_opts))
 	    goto drop;
 
-	  /* Stop connection establishment and retransmit timers */
-	  tcp_timer_reset (tc0, TCP_TIMER_ESTABLISH);
-	  tcp_timer_reset (tc0, TCP_TIMER_RETRANSMIT_SYN);
-
 	  /* Valid SYN or SYN-ACK. Move connection from half-open pool to
 	   * current thread pool. */
 	  pool_get (tm->connections[my_thread_index], new_tc0);
@@ -1948,7 +1947,14 @@ tcp46_syn_sent_inline (vlib_main_t * vm, vlib_node_runtime_t * node,
 	  new_tc0->c_thread_index = my_thread_index;
 	  new_tc0->rcv_nxt = vnet_buffer (b0)->tcp.seq_end;
 	  new_tc0->irs = seq0;
-	  tcp_half_open_connection_del (tc0);
+	  new_tc0->timers[TCP_TIMER_ESTABLISH] = TCP_TIMER_HANDLE_INVALID;
+	  new_tc0->timers[TCP_TIMER_RETRANSMIT_SYN] =
+	    TCP_TIMER_HANDLE_INVALID;
+
+	  /* If this is not the owning thread, wait for syn retransmit to
+	   * expire and cleanup then */
+	  if (tcp_half_open_connection_cleanup (tc0))
+	    tc0->flags |= TCP_CONN_HALF_OPEN_DONE;
 
 	  if (tcp_opts_tstamp (&new_tc0->rcv_opts))
 	    {
@@ -1980,11 +1986,10 @@ tcp46_syn_sent_inline (vlib_main_t * vm, vlib_node_runtime_t * node,
 
 	      /* Notify app that we have connection. If session layer can't
 	       * allocate session send reset */
-	      if (stream_session_connect_notify (&new_tc0->connection, sst,
-						 0))
+	      if (stream_session_connect_notify (&new_tc0->connection, 0))
 		{
+		  tcp_send_reset (new_tc0, b0, is_ip4);
 		  tcp_connection_cleanup (new_tc0);
-		  tcp_send_reset (tc0, b0, is_ip4);
 		  goto drop;
 		}
 
@@ -2002,8 +2007,7 @@ tcp46_syn_sent_inline (vlib_main_t * vm, vlib_node_runtime_t * node,
 	      new_tc0->state = TCP_STATE_SYN_RCVD;
 
 	      /* Notify app that we have connection */
-	      if (stream_session_connect_notify
-		  (&new_tc0->connection, sst, 0))
+	      if (stream_session_connect_notify (&new_tc0->connection, 0))
 		{
 		  tcp_connection_cleanup (new_tc0);
 		  tcp_send_reset (tc0, b0, is_ip4);
@@ -2250,6 +2254,7 @@ tcp46_rcv_process_inline (vlib_main_t * vm, vlib_node_runtime_t * node,
 	      if (tc0->snd_una == tc0->snd_una_max)
 		{
 		  ASSERT (tcp_fin (tcp0));
+		  tc0->rcv_nxt += 1;
 		  tc0->state = TCP_STATE_FIN_WAIT_2;
 		  TCP_EVT_DBG (TCP_EVT_STATE_CHANGE, tc0);
 
@@ -2263,6 +2268,7 @@ tcp46_rcv_process_inline (vlib_main_t * vm, vlib_node_runtime_t * node,
 	       * acknowledged ("ok") but do not delete the TCB. */
 	      if (tcp_rcv_ack (tc0, b0, tcp0, &next0, &error0))
 		goto drop;
+
 	      /* check if rtx queue is empty and ack CLOSE TODO */
 	      break;
 	    case TCP_STATE_CLOSE_WAIT:
@@ -2384,7 +2390,7 @@ tcp46_rcv_process_inline (vlib_main_t * vm, vlib_node_runtime_t * node,
 	      /* Got FIN, send ACK! */
 	      tc0->state = TCP_STATE_TIME_WAIT;
 	      tcp_connection_timers_reset (tc0);
-	      tcp_timer_set (tc0, TCP_TIMER_WAITCLOSE, TCP_CLOSEWAIT_TIME);
+	      tcp_timer_update (tc0, TCP_TIMER_WAITCLOSE, TCP_CLOSEWAIT_TIME);
 	      tcp_make_ack (tc0, b0);
 	      next0 = tcp_next_output (is_ip4);
 	      TCP_EVT_DBG (TCP_EVT_STATE_CHANGE, tc0);
@@ -2745,7 +2751,7 @@ tcp_lookup_is_valid (tcp_connection_t * tc, tcp_header_t * hdr)
       if ((tmp =
 	   stream_session_half_open_lookup (&tc->c_lcl_ip, &tc->c_rmt_ip,
 					    tc->c_lcl_port, tc->c_rmt_port,
-					    tc->c_proto)))
+					    tc->c_transport_proto)))
 	{
 	  if (tmp->lcl_port == hdr->dst_port
 	      && tmp->rmt_port == hdr->src_port)
diff --git a/src/vnet/tcp/tcp_output.c b/src/vnet/tcp/tcp_output.c
index 5e9ecf11..1ecb6ce6 100644
--- a/src/vnet/tcp/tcp_output.c
+++ b/src/vnet/tcp/tcp_output.c
@@ -1087,15 +1087,14 @@ tcp_timer_retransmit_handler_i (u32 index, u8 is_syn)
   if (is_syn)
     {
       tc = tcp_half_open_connection_get (index);
+      tc->timers[TCP_TIMER_RETRANSMIT_SYN] = TCP_TIMER_HANDLE_INVALID;
     }
   else
     {
       tc = tcp_connection_get (index, thread_index);
+      tc->timers[TCP_TIMER_RETRANSMIT] = TCP_TIMER_HANDLE_INVALID;
     }
 
-  /* Make sure timer handle is set to invalid */
-  tc->timers[TCP_TIMER_RETRANSMIT] = TCP_TIMER_HANDLE_INVALID;
-
   if (!tcp_in_recovery (tc) && tc->rto_boff > 0
       && tc->state >= TCP_STATE_ESTABLISHED)
     {
@@ -1154,6 +1153,20 @@ tcp_timer_retransmit_handler_i (u32 index, u8 is_syn)
   /* Retransmit for SYN/SYNACK */
   else if (tc->state == TCP_STATE_SYN_RCVD || tc->state == TCP_STATE_SYN_SENT)
     {
+      /* Half-open connection actually moved to established but we were
+       * waiting for syn retransmit to pop to call cleanup from the right
+       * thread. */
+      if (tc->flags & TCP_CONN_HALF_OPEN_DONE)
+	{
+	  ASSERT (tc->state == TCP_STATE_SYN_SENT);
+	  if (tcp_half_open_connection_cleanup (tc))
+	    {
+	      clib_warning ("could not remove half-open connection");
+	      ASSERT (0);
+	    }
+	  return;
+	}
+
       /* Try without increasing RTO a number of times. If this fails,
        * start growing RTO exponentially */
       if (tc->rto_boff > TCP_RTO_SYN_RETRIES)
diff --git a/src/vnet/tcp/tcp_test.c b/src/vnet/tcp/tcp_test.c
index 5c40ddf9..37640cc6 100644
--- a/src/vnet/tcp/tcp_test.c
+++ b/src/vnet/tcp/tcp_test.c
@@ -1574,7 +1574,7 @@ tcp_test_lookup (vlib_main_t * vm, unformat_input_t * input)
   tc->connection.rmt_ip.ip4.as_u32 = clib_host_to_net_u32 (0x06000103);
   tc->connection.lcl_port = 35051;
   tc->connection.rmt_port = 53764;
-  tc->connection.proto = 0;
+  tc->connection.transport_proto = 0;
   clib_memcpy (tc1, &tc->connection, sizeof (*tc1));
 
   pool_get (session_manager_main.sessions[0], s);
@@ -1590,7 +1590,7 @@ tcp_test_lookup (vlib_main_t * vm, unformat_input_t * input)
   tc->connection.rmt_ip.ip4.as_u32 = clib_host_to_net_u32 (0x06000102);
   tc->connection.lcl_port = 38225;
   tc->connection.rmt_port = 53764;
-  tc->connection.proto = 0;
+  tc->connection.transport_proto = 0;
   clib_memcpy (tc2, &tc->connection, sizeof (*tc2));
 
   /*
@@ -1601,7 +1601,7 @@ tcp_test_lookup (vlib_main_t * vm, unformat_input_t * input)
   tconn = stream_session_lookup_transport_wt4 (&tc1->lcl_ip.ip4,
 					       &tc1->rmt_ip.ip4,
 					       tc1->lcl_port, tc1->rmt_port,
-					       tc1->proto, 0);
+					       tc1->transport_proto, 0);
   cmp = (memcmp (&tconn->rmt_ip, &tc1->rmt_ip, sizeof (tc1->rmt_ip)) == 0);
   TCP_TEST ((cmp), "rmt ip is identical %d", cmp);
   TCP_TEST ((tconn->lcl_port == tc1->lcl_port),
@@ -1614,7 +1614,7 @@ tcp_test_lookup (vlib_main_t * vm, unformat_input_t * input)
   tconn = stream_session_lookup_transport_wt4 (&tc2->lcl_ip.ip4,
 					       &tc2->rmt_ip.ip4,
 					       tc2->lcl_port, tc2->rmt_port,
-					       tc2->proto, 0);
+					       tc2->transport_proto, 0);
   TCP_TEST ((tconn == 0), "lookup result should be null");
 
   /*
@@ -1624,12 +1624,12 @@ tcp_test_lookup (vlib_main_t * vm, unformat_input_t * input)
   tconn = stream_session_lookup_transport_wt4 (&tc1->lcl_ip.ip4,
 					       &tc1->rmt_ip.ip4,
 					       tc1->lcl_port, tc1->rmt_port,
-					       tc1->proto, 0);
+					       tc1->transport_proto, 0);
   TCP_TEST ((tconn == 0), "lookup result should be null");
   tconn = stream_session_lookup_transport_wt4 (&tc2->lcl_ip.ip4,
 					       &tc2->rmt_ip.ip4,
 					       tc2->lcl_port, tc2->rmt_port,
-					       tc2->proto, 0);
+					       tc2->transport_proto, 0);
   TCP_TEST ((tconn == 0), "lookup result should be null");
 
   /*
@@ -1639,7 +1639,7 @@ tcp_test_lookup (vlib_main_t * vm, unformat_input_t * input)
   tconn = stream_session_lookup_transport_wt4 (&tc2->lcl_ip.ip4,
 					       &tc2->rmt_ip.ip4,
 					       tc2->lcl_port, tc2->rmt_port,
-					       tc2->proto, 0);
+					       tc2->transport_proto, 0);
   TCP_TEST ((tconn == 0), "lookup result should be null");
 
   return 0;
diff --git a/src/vnet/udp/udp.c b/src/vnet/udp/udp.c
index ff76a82e..fedf2cc0 100644
--- a/src/vnet/udp/udp.c
+++ b/src/vnet/udp/udp.c
@@ -34,7 +34,7 @@ udp_session_bind_ip4 (u32 session_index, transport_endpoint_t * lcl)
   memset (listener, 0, sizeof (udp_connection_t));
   listener->c_lcl_port = clib_host_to_net_u16 (lcl->port);
   listener->c_lcl_ip4.as_u32 = lcl->ip.ip4.as_u32;
-  listener->c_proto = SESSION_TYPE_IP4_UDP;
+  listener->c_transport_proto = TRANSPORT_PROTO_UDP;
   udp_register_dst_port (um->vlib_main, lcl->port, udp4_uri_input_node.index,
 			 1 /* is_ipv4 */ );
   return 0;
@@ -49,7 +49,7 @@ udp_session_bind_ip6 (u32 session_index, transport_endpoint_t * lcl)
   pool_get (um->udp_listeners, listener);
   listener->c_lcl_port = clib_host_to_net_u16 (lcl->port);
   clib_memcpy (&listener->c_lcl_ip6, &lcl->ip.ip6, sizeof (ip6_address_t));
-  listener->c_proto = SESSION_TYPE_IP6_UDP;
+  listener->c_transport_proto = TRANSPORT_PROTO_UDP;
   udp_register_dst_port (um->vlib_main, lcl->port,
 			 udp4_uri_input_node.index, 0 /* is_ipv4 */ );
   return 0;
@@ -318,8 +318,8 @@ udp_init (vlib_main_t * vm)
 
 
   /* Register as transport with URI */
-  session_register_transport (SESSION_TYPE_IP4_UDP, &udp4_proto);
-  session_register_transport (SESSION_TYPE_IP6_UDP, &udp6_proto);
+  session_register_transport (TRANSPORT_PROTO_UDP, 1, &udp4_proto);
+  session_register_transport (TRANSPORT_PROTO_UDP, 0, &udp6_proto);
 
   /*
    * Initialize data structures
diff --git a/src/vnet/udp/udp_input.c b/src/vnet/udp/udp_input.c
index 9a8ff076..6ccb1e52 100644
--- a/src/vnet/udp/udp_input.c
+++ b/src/vnet/udp/udp_input.c
@@ -179,7 +179,7 @@ udp4_uri_input_node_fn (vlib_main_t * vm,
 	      us->c_rmt_ip4.as_u32 = ip0->src_address.as_u32;
 	      us->c_lcl_port = udp0->dst_port;
 	      us->c_rmt_port = udp0->src_port;
-	      us->c_proto = SESSION_TYPE_IP4_UDP;
+	      us->c_transport_proto = TRANSPORT_PROTO_UDP;
 	      us->c_c_index = us - um->udp_sessions[my_thread_index];
 
 	      /*
-- 
cgit 1.2.3-korg


From 66b11318a1e5f24880e3ec77c95d70647732a4a8 Mon Sep 17 00:00:00 2001
From: Florin Coras <fcoras@cisco.com>
Date: Mon, 31 Jul 2017 17:18:03 -0700
Subject: Fix tcp tx buffer allocation

- Make tcp output buffer allocation macro an inline function
- Use per ip version per thread tx frames for retransmits and timer
  events
- Fix / parameterize tcp data structure preallocation
- Add a couple of gdb-callable show commands
- Fix local endpoint cleanup

Change-Id: I67b47b7570aa14cb4634b6fd93c57cd2eacbfa29
Signed-off-by: Florin Coras <fcoras@cisco.com>
Signed-off-by: Dave Barach <dave@barachs.net>
---
 src/plugins/dpdk/device/cli.c     |   1 +
 src/vlib/error.c                  |   2 +-
 src/vlib/node_funcs.h             |  16 ++--
 src/vnet/ip/ip4.h                 |   2 -
 src/vnet/session/session.c        |  82 +++++++++++++++--
 src/vnet/session/session.h        |  10 ++
 src/vnet/session/session_cli.c    |   2 +-
 src/vnet/session/session_lookup.c |  40 ++++++--
 src/vnet/tcp/builtin_client.c     |  39 ++++++--
 src/vnet/tcp/tcp.c                |  52 +++++++----
 src/vnet/tcp/tcp.h                |  12 ++-
 src/vnet/tcp/tcp_input.c          |   2 +
 src/vnet/tcp/tcp_output.c         | 188 +++++++++++++++++++++++++-------------
 src/vnet/unix/gdb_funcs.c         |  45 ++++++++-
 src/vppinfra/pool.h               |   2 +-
 15 files changed, 375 insertions(+), 120 deletions(-)

(limited to 'src/vnet/session/session_lookup.c')

diff --git a/src/plugins/dpdk/device/cli.c b/src/plugins/dpdk/device/cli.c
index aeeb772d..fe1c41c2 100644
--- a/src/plugins/dpdk/device/cli.c
+++ b/src/plugins/dpdk/device/cli.c
@@ -357,6 +357,7 @@ show_dpdk_buffer (vlib_main_t * vm, unformat_input_t * input,
 			   "name=\"%s\"  available = %7d allocated = %7d total = %7d\n",
 			   rmp->name, (u32) count, (u32) free_count,
 			   (u32) (count + free_count));
+	  rte_mempool_dump (stderr, rmp);
 	}
       else
 	{
diff --git a/src/vlib/error.c b/src/vlib/error.c
index e4ed4ee3..dec90bbe 100644
--- a/src/vlib/error.c
+++ b/src/vlib/error.c
@@ -280,7 +280,7 @@ show_errors (vlib_main_t * vm,
 }
 
 /* *INDENT-OFF* */
-VLIB_CLI_COMMAND (cli_show_errors, static) = {
+VLIB_CLI_COMMAND (vlib_cli_show_errors) = {
   .path = "show errors",
   .short_help = "Show error counts",
   .function = show_errors,
diff --git a/src/vlib/node_funcs.h b/src/vlib/node_funcs.h
index c0389b2f..c4c06454 100644
--- a/src/vlib/node_funcs.h
+++ b/src/vlib/node_funcs.h
@@ -410,19 +410,21 @@ vlib_frame_t *vlib_get_frame_to_node (vlib_main_t * vm, u32 to_node_index);
 void vlib_put_frame_to_node (vlib_main_t * vm, u32 to_node_index,
 			     vlib_frame_t * f);
 
-always_inline vlib_process_t *
-vlib_get_current_process (vlib_main_t * vm)
-{
-  vlib_node_main_t *nm = &vm->node_main;
-  return vec_elt (nm->processes, nm->current_process_index);
-}
-
 always_inline uword
 vlib_in_process_context (vlib_main_t * vm)
 {
   return vm->node_main.current_process_index != ~0;
 }
 
+always_inline vlib_process_t *
+vlib_get_current_process (vlib_main_t * vm)
+{
+  vlib_node_main_t *nm = &vm->node_main;
+  if (vlib_in_process_context (vm))
+    return vec_elt (nm->processes, nm->current_process_index);
+  return 0;
+}
+
 always_inline uword
 vlib_current_process (vlib_main_t * vm)
 {
diff --git a/src/vnet/ip/ip4.h b/src/vnet/ip/ip4.h
index 8f9a8e27..74faa059 100644
--- a/src/vnet/ip/ip4.h
+++ b/src/vnet/ip/ip4.h
@@ -354,8 +354,6 @@ vlib_buffer_push_ip4 (vlib_main_t * vm, vlib_buffer_t * b,
       ih->checksum = 0;
       b->flags |= VNET_BUFFER_F_OFFLOAD_IP_CKSUM | VNET_BUFFER_F_IS_IP4;
       vnet_buffer (b)->l3_hdr_offset = (u8 *) ih - b->data;
-      vnet_buffer (b)->l4_hdr_offset = vnet_buffer (b)->l3_hdr_offset +
-	sizeof (*ih);
     }
   else
     ih->checksum = ip4_header_checksum (ih);
diff --git a/src/vnet/session/session.c b/src/vnet/session/session.c
index 004c7193..4ba15291 100644
--- a/src/vnet/session/session.c
+++ b/src/vnet/session/session.c
@@ -759,6 +759,7 @@ session_manager_main_enable (vlib_main_t * vm)
   session_manager_main_t *smm = &session_manager_main;
   vlib_thread_main_t *vtm = vlib_get_thread_main ();
   u32 num_threads;
+  u32 preallocated_sessions_per_worker;
   int i;
 
   num_threads = 1 /* main thread */  + vtm->n_threads;
@@ -795,15 +796,35 @@ session_manager_main_enable (vlib_main_t * vm)
   for (i = 0; i < vec_len (smm->vpp_event_queues); i++)
     session_vpp_event_queue_allocate (smm, i);
 
-  /* $$$$ preallocate hack config parameter */
-  for (i = 0; i < smm->preallocated_sessions; i++)
+  /* Preallocate sessions */
+  if (num_threads == 1)
     {
-      stream_session_t *ss __attribute__ ((unused));
-      pool_get_aligned (smm->sessions[0], ss, CLIB_CACHE_LINE_BYTES);
+      for (i = 0; i < smm->preallocated_sessions; i++)
+	{
+	  stream_session_t *ss __attribute__ ((unused));
+	  pool_get_aligned (smm->sessions[0], ss, CLIB_CACHE_LINE_BYTES);
+	}
+
+      for (i = 0; i < smm->preallocated_sessions; i++)
+	pool_put_index (smm->sessions[0], i);
     }
+  else
+    {
+      int j;
+      preallocated_sessions_per_worker = smm->preallocated_sessions /
+	(num_threads - 1);
 
-  for (i = 0; i < smm->preallocated_sessions; i++)
-    pool_put_index (smm->sessions[0], i);
+      for (j = 1; j < num_threads; j++)
+	{
+	  for (i = 0; i < preallocated_sessions_per_worker; i++)
+	    {
+	      stream_session_t *ss __attribute__ ((unused));
+	      pool_get_aligned (smm->sessions[j], ss, CLIB_CACHE_LINE_BYTES);
+	    }
+	  for (i = 0; i < preallocated_sessions_per_worker; i++)
+	    pool_put_index (smm->sessions[j], i);
+	}
+    }
 
   session_lookup_init ();
 
@@ -863,6 +884,7 @@ session_config_fn (vlib_main_t * vm, unformat_input_t * input)
 {
   session_manager_main_t *smm = &session_manager_main;
   u32 nitems;
+  uword tmp;
 
   while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
     {
@@ -873,9 +895,53 @@ session_config_fn (vlib_main_t * vm, unformat_input_t * input)
 	  else
 	    clib_warning ("event queue length %d too small, ignored", nitems);
 	}
-      if (unformat (input, "preallocated-sessions %d",
-		    &smm->preallocated_sessions))
+      else if (unformat (input, "preallocated-sessions %d",
+			 &smm->preallocated_sessions))
+	;
+      else if (unformat (input, "v4-session-table-buckets %d",
+			 &smm->configured_v4_session_table_buckets))
 	;
+      else if (unformat (input, "v4-halfopen-table-buckets %d",
+			 &smm->configured_v4_halfopen_table_buckets))
+	;
+      else if (unformat (input, "v6-session-table-buckets %d",
+			 &smm->configured_v6_session_table_buckets))
+	;
+      else if (unformat (input, "v6-halfopen-table-buckets %d",
+			 &smm->configured_v6_halfopen_table_buckets))
+	;
+      else if (unformat (input, "v4-session-table-memory %U",
+			 unformat_memory_size, &tmp))
+	{
+	  if (tmp >= 0x100000000)
+	    return clib_error_return (0, "memory size %llx (%lld) too large",
+				      tmp, tmp);
+	  smm->configured_v4_session_table_memory = tmp;
+	}
+      else if (unformat (input, "v4-halfopen-table-memory %U",
+			 unformat_memory_size, &tmp))
+	{
+	  if (tmp >= 0x100000000)
+	    return clib_error_return (0, "memory size %llx (%lld) too large",
+				      tmp, tmp);
+	  smm->configured_v4_halfopen_table_memory = tmp;
+	}
+      else if (unformat (input, "v6-session-table-memory %U",
+			 unformat_memory_size, &tmp))
+	{
+	  if (tmp >= 0x100000000)
+	    return clib_error_return (0, "memory size %llx (%lld) too large",
+				      tmp, tmp);
+	  smm->configured_v6_session_table_memory = tmp;
+	}
+      else if (unformat (input, "v6-halfopen-table-memory %U",
+			 unformat_memory_size, &tmp))
+	{
+	  if (tmp >= 0x100000000)
+	    return clib_error_return (0, "memory size %llx (%lld) too large",
+				      tmp, tmp);
+	  smm->configured_v6_halfopen_table_memory = tmp;
+	}
       else
 	return clib_error_return (0, "unknown input `%U'",
 				  format_unformat_error, input);
diff --git a/src/vnet/session/session.h b/src/vnet/session/session.h
index 180b9f8a..538433da 100644
--- a/src/vnet/session/session.h
+++ b/src/vnet/session/session.h
@@ -133,6 +133,16 @@ struct _session_manager_main
   /** vpp fifo event queue configured length */
   u32 configured_event_queue_length;
 
+  /** session table size parameters */
+  u32 configured_v4_session_table_buckets;
+  u32 configured_v4_session_table_memory;
+  u32 configured_v4_halfopen_table_buckets;
+  u32 configured_v4_halfopen_table_memory;
+  u32 configured_v6_session_table_buckets;
+  u32 configured_v6_session_table_memory;
+  u32 configured_v6_halfopen_table_buckets;
+  u32 configured_v6_halfopen_table_memory;
+
   /** Unique segment name counter */
   u32 unique_segment_name_counter;
 
diff --git a/src/vnet/session/session_cli.c b/src/vnet/session/session_cli.c
index de564ea7..9f3d217c 100755
--- a/src/vnet/session/session_cli.c
+++ b/src/vnet/session/session_cli.c
@@ -312,7 +312,7 @@ show_session_command_fn (vlib_main_t * vm, unformat_input_t * input,
 }
 
 /* *INDENT-OFF* */
-VLIB_CLI_COMMAND (show_session_command, static) =
+VLIB_CLI_COMMAND (vlib_cli_show_session_command) =
 {
   .path = "show session",
   .short_help = "show session [verbose]",
diff --git a/src/vnet/session/session_lookup.c b/src/vnet/session/session_lookup.c
index 1ce22f80..41f9dbf0 100644
--- a/src/vnet/session/session_lookup.c
+++ b/src/vnet/session/session_lookup.c
@@ -569,23 +569,45 @@ stream_session_lookup_transport6 (ip6_address_t * lcl, ip6_address_t * rmt,
   return 0;
 }
 
+#define foreach_hash_table_parameter            \
+  _(v4,session,buckets,20000)                   \
+  _(v4,session,memory,(64<<20))                 \
+  _(v6,session,buckets,20000)                   \
+  _(v6,session,memory,(64<<20))                 \
+  _(v4,halfopen,buckets,20000)                  \
+  _(v4,halfopen,memory,(64<<20))                \
+  _(v6,halfopen,buckets,20000)                  \
+  _(v6,halfopen,memory,(64<<20))
+
 void
 session_lookup_init (void)
 {
   session_lookup_t *sl = &session_lookup;
+
+#define _(af,table,parm,value) \
+  u32 configured_##af##_##table##_table_##parm = value;
+  foreach_hash_table_parameter;
+#undef _
+
+#define _(af,table,parm,value)                                          \
+  if (session_manager_main.configured_##af##_##table##_table_##parm)    \
+    configured_##af##_##table##_table_##parm =                          \
+      session_manager_main.configured_##af##_##table##_table_##parm;
+  foreach_hash_table_parameter;
+#undef _
+
   clib_bihash_init_16_8 (&sl->v4_session_hash, "v4 session table",
-			 200000 /* $$$$ config parameter nbuckets */ ,
-			 (64 << 20) /*$$$ config parameter table size */ );
+			 configured_v4_session_table_buckets,
+			 configured_v4_session_table_memory);
   clib_bihash_init_48_8 (&sl->v6_session_hash, "v6 session table",
-			 200000 /* $$$$ config parameter nbuckets */ ,
-			 (64 << 20) /*$$$ config parameter table size */ );
-
+			 configured_v6_session_table_buckets,
+			 configured_v6_session_table_memory);
   clib_bihash_init_16_8 (&sl->v4_half_open_hash, "v4 half-open table",
-			 200000 /* $$$$ config parameter nbuckets */ ,
-			 (64 << 20) /*$$$ config parameter table size */ );
+			 configured_v4_halfopen_table_buckets,
+			 configured_v4_halfopen_table_memory);
   clib_bihash_init_48_8 (&sl->v6_half_open_hash, "v6 half-open table",
-			 200000 /* $$$$ config parameter nbuckets */ ,
-			 (64 << 20) /*$$$ config parameter table size */ );
+			 configured_v6_halfopen_table_buckets,
+			 configured_v6_halfopen_table_memory);
 }
 
 /*
diff --git a/src/vnet/tcp/builtin_client.c b/src/vnet/tcp/builtin_client.c
index 27e20f8e..48daffb4 100644
--- a/src/vnet/tcp/builtin_client.c
+++ b/src/vnet/tcp/builtin_client.c
@@ -597,8 +597,9 @@ clients_connect (vlib_main_t * vm, u8 * uri, u32 n_clients)
       a->mp = 0;
       vnet_connect_uri (a);
 
-      /* Crude pacing for call setups, 100k/sec  */
-      vlib_process_suspend (vm, 10e-6);
+      /* Crude pacing for call setups  */
+      if ((i % 4) == 0)
+	vlib_process_suspend (vm, 10e-6);
     }
 }
 
@@ -612,8 +613,10 @@ test_tcp_clients_command_fn (vlib_main_t * vm,
   uword *event_data = 0, event_type;
   u8 *default_connect_uri = (u8 *) "tcp://6.0.1.1/1234", *uri;
   u64 tmp, total_bytes;
-  f64 cli_timeout = 20.0, delta;
+  f64 test_timeout = 20.0, syn_timeout = 20.0, delta;
+  f64 time_before_connects;
   u32 n_clients = 1;
+  int preallocate_sessions = 0;
   char *transfer_type;
   int i;
 
@@ -640,7 +643,9 @@ test_tcp_clients_command_fn (vlib_main_t * vm,
 	;
       else if (unformat (input, "uri %s", &tm->connect_uri))
 	;
-      else if (unformat (input, "cli-timeout %f", &cli_timeout))
+      else if (unformat (input, "test-timeout %f", &test_timeout))
+	;
+      else if (unformat (input, "syn-timeout %f", &syn_timeout))
 	;
       else if (unformat (input, "no-return"))
 	tm->no_return = 1;
@@ -657,6 +662,8 @@ test_tcp_clients_command_fn (vlib_main_t * vm,
 	tm->private_segment_size = tmp;
       else if (unformat (input, "preallocate-fifos"))
 	tm->prealloc_fifos = 1;
+      else if (unformat (input, "preallocate-sessions"))
+	preallocate_sessions = 1;
       else
 	if (unformat (input, "client-batch %d", &tm->connections_per_batch))
 	;
@@ -674,6 +681,7 @@ test_tcp_clients_command_fn (vlib_main_t * vm,
 	return clib_error_return (0, "failed init");
     }
 
+
   tm->ready_connections = 0;
   tm->expected_connections = n_clients;
   tm->rx_total = 0;
@@ -705,11 +713,21 @@ test_tcp_clients_command_fn (vlib_main_t * vm,
     vlib_node_set_state (vlib_mains[i], builtin_client_node.index,
 			 VLIB_NODE_STATE_POLLING);
 
+  if (preallocate_sessions)
+    {
+      session_t *sp __attribute__ ((unused));
+      for (i = 0; i < n_clients; i++)
+	pool_get (tm->sessions, sp);
+      for (i = 0; i < n_clients; i++)
+	pool_put_index (tm->sessions, i);
+    }
+
   /* Fire off connect requests */
+  time_before_connects = vlib_time_now (vm);
   clients_connect (vm, uri, n_clients);
 
   /* Park until the sessions come up, or ten seconds elapse... */
-  vlib_process_wait_for_event_or_clock (vm, 10 /* timeout, seconds */ );
+  vlib_process_wait_for_event_or_clock (vm, syn_timeout);
   event_type = vlib_process_get_events (vm, &event_data);
   switch (event_type)
     {
@@ -719,6 +737,15 @@ test_tcp_clients_command_fn (vlib_main_t * vm,
       goto cleanup;
 
     case 1:
+      delta = vlib_time_now (vm) - time_before_connects;
+
+      if (delta != 0.0)
+	{
+	  vlib_cli_output
+	    (vm, "%d three-way handshakes in %.2f seconds, %.2f/sec",
+	     n_clients, delta, ((f64) n_clients) / delta);
+	}
+
       tm->test_start_time = vlib_time_now (tm->vlib_main);
       vlib_cli_output (vm, "Test started at %.6f", tm->test_start_time);
       break;
@@ -729,7 +756,7 @@ test_tcp_clients_command_fn (vlib_main_t * vm,
     }
 
   /* Now wait for the sessions to finish... */
-  vlib_process_wait_for_event_or_clock (vm, cli_timeout);
+  vlib_process_wait_for_event_or_clock (vm, test_timeout);
   event_type = vlib_process_get_events (vm, &event_data);
   switch (event_type)
     {
diff --git a/src/vnet/tcp/tcp.c b/src/vnet/tcp/tcp.c
index 59b20747..8e2eb9f4 100644
--- a/src/vnet/tcp/tcp.c
+++ b/src/vnet/tcp/tcp.c
@@ -173,7 +173,7 @@ tcp_connection_cleanup (tcp_connection_t * tc)
 
   /* Cleanup local endpoint if this was an active connect */
   tepi = transport_endpoint_lookup (&tm->local_endpoints_table, &tc->c_lcl_ip,
-				    tc->c_lcl_port);
+				    clib_net_to_host_u16 (tc->c_lcl_port));
   if (tepi != TRANSPORT_ENDPOINT_INVALID_INDEX)
     {
       tep = pool_elt_at_index (tm->local_endpoints, tepi);
@@ -367,25 +367,24 @@ tcp_allocate_local_port (ip46_address_t * ip)
 {
   tcp_main_t *tm = vnet_get_tcp_main ();
   transport_endpoint_t *tep;
-  u32 time_now, tei;
+  u32 tei;
   u16 min = 1024, max = 65535;	/* XXX configurable ? */
-  int tries;
+  int tries, limit;
 
-  tries = max - min;
-  time_now = tcp_time_now ();
+  limit = max - min;
 
   /* Only support active opens from thread 0 */
   ASSERT (vlib_get_thread_index () == 0);
 
   /* Search for first free slot */
-  for (; tries >= 0; tries--)
+  for (tries = 0; tries < limit; tries++)
     {
       u16 port = 0;
 
       /* Find a port in the specified range */
       while (1)
 	{
-	  port = random_u32 (&time_now) & PORT_MASK;
+	  port = random_u32 (&tm->port_allocator_seed) & PORT_MASK;
 	  if (PREDICT_TRUE (port >= min && port < max))
 	    break;
 	}
@@ -1189,8 +1188,9 @@ tcp_main_enable (vlib_main_t * vm)
   vlib_thread_main_t *vtm = vlib_get_thread_main ();
   clib_error_t *error = 0;
   u32 num_threads;
-  int thread, i;
+  int i, thread;
   tcp_connection_t *tc __attribute__ ((unused));
+  u32 preallocated_connections_per_thread;
 
   if ((error = vlib_call_init_function (vm, ip_main_init)))
     return error;
@@ -1224,14 +1224,26 @@ tcp_main_enable (vlib_main_t * vm)
   vec_validate (tm->connections, num_threads - 1);
 
   /*
-   * Preallocate connections
+   * Preallocate connections. Assume that thread 0 won't
+   * use preallocated threads when running multi-core
    */
-  for (thread = 0; thread < num_threads; thread++)
+  if (num_threads == 1)
     {
-      for (i = 0; i < tm->preallocated_connections; i++)
+      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++)
+    {
+      for (i = 0; i < preallocated_connections_per_thread; i++)
 	pool_get (tm->connections[thread], tc);
 
-      for (i = 0; i < tm->preallocated_connections; i++)
+      for (i = 0; i < preallocated_connections_per_thread; i++)
 	pool_put_index (tm->connections[thread], i);
     }
 
@@ -1257,13 +1269,21 @@ tcp_main_enable (vlib_main_t * vm)
     / TCP_TSTAMP_RESOLUTION;
 
   clib_bihash_init_24_8 (&tm->local_endpoints_table, "local endpoint table",
-			 200000 /* $$$$ config parameter nbuckets */ ,
-			 (64 << 20) /*$$$ config parameter table size */ );
+			 1000000 /* $$$$ config parameter nbuckets */ ,
+			 (512 << 20) /*$$$ config parameter table size */ );
+
+  /* Initialize [port-allocator] random number seed */
+  tm->port_allocator_seed = (u32) clib_cpu_time_now ();
+
   if (num_threads > 1)
     {
       clib_spinlock_init (&tm->half_open_lock);
       clib_spinlock_init (&tm->local_endpoints_lock);
     }
+
+  vec_validate (tm->tx_frames[0], num_threads - 1);
+  vec_validate (tm->tx_frames[1], num_threads - 1);
+
   return error;
 }
 
@@ -1289,16 +1309,12 @@ clib_error_t *
 tcp_init (vlib_main_t * vm)
 {
   tcp_main_t *tm = vnet_get_tcp_main ();
-
-  tm->vnet_main = vnet_get_main ();
   tm->is_enabled = 0;
-
   return 0;
 }
 
 VLIB_INIT_FUNCTION (tcp_init);
 
-
 static clib_error_t *
 tcp_config_fn (vlib_main_t * vm, unformat_input_t * input)
 {
diff --git a/src/vnet/tcp/tcp.h b/src/vnet/tcp/tcp.h
index 4fa681f8..997df76f 100644
--- a/src/vnet/tcp/tcp.h
+++ b/src/vnet/tcp/tcp.h
@@ -369,6 +369,8 @@ typedef struct _tcp_main
 
   /** per-worker tx buffer free lists */
   u32 **tx_buffers;
+  /** per-worker tx frames to 4/6 output nodes */
+  vlib_frame_t **tx_frames[2];
 
   /* Per worker-thread timer wheel for connections timers */
   tw_timer_wheel_16t_2w_512sl_t *timer_wheels;
@@ -400,11 +402,8 @@ typedef struct _tcp_main
   u32 last_v6_address_rotor;
   ip6_address_t *ip6_src_addresses;
 
-  /* convenience */
-  vlib_main_t *vlib_main;
-  vnet_main_t *vnet_main;
-  ip4_main_t *ip4_main;
-  ip6_main_t *ip6_main;
+  /** Port allocator random number generator seed */
+  u32 port_allocator_seed;
 } tcp_main_t;
 
 extern tcp_main_t tcp_main;
@@ -493,6 +492,8 @@ void tcp_send_fin (tcp_connection_t * tc);
 void tcp_init_mss (tcp_connection_t * tc);
 void tcp_update_snd_mss (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);
 
 always_inline u32
 tcp_end_seq (tcp_header_t * th, u32 len)
@@ -614,6 +615,7 @@ tcp_update_time (f64 now, u32 thread_index)
 {
   tw_timer_expire_timers_16t_2w_512sl (&tcp_main.timer_wheels[thread_index],
 				       now);
+  tcp_flush_frames_to_output (thread_index);
 }
 
 u32 tcp_push_header (transport_connection_t * tconn, vlib_buffer_t * b);
diff --git a/src/vnet/tcp/tcp_input.c b/src/vnet/tcp/tcp_input.c
index 6c59d70f..29f4f08d 100644
--- a/src/vnet/tcp/tcp_input.c
+++ b/src/vnet/tcp/tcp_input.c
@@ -1751,6 +1751,8 @@ tcp46_established_inline (vlib_main_t * vm, vlib_node_runtime_t * node,
 
   errors = session_manager_flush_enqueue_events (my_thread_index);
   tcp_established_inc_counter (vm, is_ip4, TCP_ERROR_EVENT_FIFO_FULL, errors);
+  tcp_flush_frame_to_output (vm, my_thread_index, is_ip4);
+
   return from_frame->n_vectors;
 }
 
diff --git a/src/vnet/tcp/tcp_output.c b/src/vnet/tcp/tcp_output.c
index ad13493a..f8fbb8a9 100644
--- a/src/vnet/tcp/tcp_output.c
+++ b/src/vnet/tcp/tcp_output.c
@@ -436,34 +436,41 @@ tcp_init_mss (tcp_connection_t * tc)
     tc->snd_mss -= TCP_OPTION_LEN_TIMESTAMP;
 }
 
-#define tcp_get_free_buffer_index(tm, bidx)                             \
-do {                                                                    \
-  u32 *my_tx_buffers, n_free_buffers;                                   \
-  u32 thread_index = vlib_get_thread_index();                           \
-  my_tx_buffers = tm->tx_buffers[thread_index];                         \
-  if (PREDICT_FALSE(vec_len (my_tx_buffers) == 0))                      \
-    {                                                                   \
-      n_free_buffers = 32;      /* TODO config or macro */              \
-      vec_validate (my_tx_buffers, n_free_buffers - 1);                 \
-      _vec_len(my_tx_buffers) = vlib_buffer_alloc_from_free_list (      \
-       vlib_get_main(), my_tx_buffers, n_free_buffers,                  \
-          VLIB_BUFFER_DEFAULT_FREE_LIST_INDEX);                         \
-      tm->tx_buffers[thread_index] = my_tx_buffers;                     \
-    }                                                                   \
-  /* buffer shortage */                                                 \
-  if (PREDICT_FALSE (vec_len (my_tx_buffers) == 0))                     \
-    return;                                                             \
-  *bidx = my_tx_buffers[_vec_len (my_tx_buffers)-1];                    \
-  _vec_len (my_tx_buffers) -= 1;                                        \
-} while (0)
-
-#define tcp_return_buffer(tm)                   \
-do {                                            \
-  u32 *my_tx_buffers;                           \
-  u32 thread_index = vlib_get_thread_index();   \
-  my_tx_buffers = tm->tx_buffers[thread_index]; \
-  _vec_len (my_tx_buffers) +=1;                 \
-} while (0)
+always_inline int
+tcp_get_free_buffer_index (tcp_main_t * tm, u32 * bidx)
+{
+  u32 *my_tx_buffers, n_free_buffers;
+  u32 thread_index = vlib_get_thread_index ();
+  my_tx_buffers = tm->tx_buffers[thread_index];
+  if (PREDICT_FALSE (vec_len (my_tx_buffers) == 0))
+    {
+      n_free_buffers = VLIB_FRAME_SIZE;
+      vec_validate (my_tx_buffers, n_free_buffers - 1);
+      _vec_len (my_tx_buffers) =
+	vlib_buffer_alloc_from_free_list (vlib_get_main (), my_tx_buffers,
+					  n_free_buffers,
+					  VLIB_BUFFER_DEFAULT_FREE_LIST_INDEX);
+      /* buffer shortage, report failure */
+      if (vec_len (my_tx_buffers) == 0)
+	{
+	  clib_warning ("out of buffers");
+	  return -1;
+	}
+      tm->tx_buffers[thread_index] = my_tx_buffers;
+    }
+  *bidx = my_tx_buffers[_vec_len (my_tx_buffers) - 1];
+  _vec_len (my_tx_buffers) -= 1;
+  return 0;
+}
+
+always_inline void
+tcp_return_buffer (tcp_main_t * tm)
+{
+  u32 *my_tx_buffers;
+  u32 thread_index = vlib_get_thread_index ();
+  my_tx_buffers = tm->tx_buffers[thread_index];
+  _vec_len (my_tx_buffers) += 1;
+}
 
 always_inline void
 tcp_reuse_buffer (vlib_main_t * vm, vlib_buffer_t * b)
@@ -706,7 +713,9 @@ tcp_send_reset (tcp_connection_t * tc, vlib_buffer_t * pkt, u8 is_ip4)
   ip4_header_t *ih4, *pkt_ih4;
   ip6_header_t *ih6, *pkt_ih6;
 
-  tcp_get_free_buffer_index (tm, &bi);
+  if (PREDICT_FALSE (tcp_get_free_buffer_index (tm, &bi)))
+    return;
+
   b = vlib_get_buffer (vm, bi);
 
   /* Leave enough space for headers */
@@ -811,7 +820,9 @@ tcp_send_syn (tcp_connection_t * tc)
   u16 initial_wnd;
   tcp_options_t snd_opts;
 
-  tcp_get_free_buffer_index (tm, &bi);
+  if (PREDICT_FALSE (tcp_get_free_buffer_index (tm, &bi)))
+    return;
+
   b = vlib_get_buffer (vm, bi);
 
   /* Leave enough space for headers */
@@ -854,8 +865,11 @@ tcp_send_syn (tcp_connection_t * tc)
 }
 
 always_inline void
-tcp_enqueue_to_output (vlib_main_t * vm, vlib_buffer_t * b, u32 bi, u8 is_ip4)
+tcp_enqueue_to_output_i (vlib_main_t * vm, 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;
 
@@ -872,12 +886,62 @@ tcp_enqueue_to_output (vlib_main_t * vm, vlib_buffer_t * b, u32 bi, u8 is_ip4)
       b->pre_data[1] = next_index;
     }
 
-  /* Enqueue the packet */
-  f = vlib_get_frame_to_node (vm, next_index);
+  /* Get frame to v4/6 output node */
+  f = tm->tx_frames[!is_ip4][thread_index];
+  if (!f)
+    {
+      f = vlib_get_frame_to_node (vm, next_index);
+      ASSERT (f);
+      tm->tx_frames[!is_ip4][thread_index] = f;
+    }
   to_next = vlib_frame_vector_args (f);
-  to_next[0] = bi;
-  f->n_vectors = 1;
-  vlib_put_frame_to_node (vm, next_index, 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->tx_frames[!is_ip4][thread_index] = 0;
+    }
+}
+
+always_inline void
+tcp_enqueue_to_output (vlib_main_t * vm, vlib_buffer_t * b, u32 bi, u8 is_ip4)
+{
+  tcp_enqueue_to_output_i (vm, b, bi, is_ip4, 0);
+}
+
+always_inline void
+tcp_enqueue_to_output_now (vlib_main_t * vm, vlib_buffer_t * b, u32 bi,
+			   u8 is_ip4)
+{
+  tcp_enqueue_to_output_i (vm, b, bi, is_ip4, 1);
+}
+
+/**
+ * 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)
+{
+  if (tcp_main.tx_frames[!is_ip4][thread_index])
+    {
+      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.tx_frames[!is_ip4][thread_index]);
+      tcp_main.tx_frames[!is_ip4][thread_index] = 0;
+    }
+}
+
+/**
+ * Flush both v4 and v6 tx frames for thread index
+ */
+void
+tcp_flush_frames_to_output (u8 thread_index)
+{
+  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);
 }
 
 /**
@@ -891,14 +955,15 @@ tcp_send_fin (tcp_connection_t * tc)
   tcp_main_t *tm = vnet_get_tcp_main ();
   vlib_main_t *vm = vlib_get_main ();
 
-  tcp_get_free_buffer_index (tm, &bi);
+  if (PREDICT_FALSE (tcp_get_free_buffer_index (tm, &bi)))
+    return;
   b = vlib_get_buffer (vm, bi);
 
   /* Leave enough space for headers */
   vlib_buffer_make_headroom (b, MAX_HDRS_LEN);
 
   tcp_make_fin (tc, b);
-  tcp_enqueue_to_output (vm, b, bi, tc->c_is_ip4);
+  tcp_enqueue_to_output_now (vm, b, bi, tc->c_is_ip4);
   tc->flags |= TCP_CONN_FINSNT;
   tcp_retransmit_timer_force_update (tc);
   TCP_EVT_DBG (TCP_EVT_FIN_SENT, tc);
@@ -981,7 +1046,8 @@ tcp_send_ack (tcp_connection_t * tc)
   u32 bi;
 
   /* Get buffer */
-  tcp_get_free_buffer_index (tm, &bi);
+  if (PREDICT_FALSE (tcp_get_free_buffer_index (tm, &bi)))
+    return;
   b = vlib_get_buffer (vm, bi);
 
   /* Fill in the ACK */
@@ -1108,7 +1174,9 @@ tcp_timer_retransmit_handler_i (u32 index, u8 is_syn)
   /* Go back to first un-acked byte */
   tc->snd_nxt = tc->snd_una;
 
-  tcp_get_free_buffer_index (tm, &bi);
+  if (PREDICT_FALSE (tcp_get_free_buffer_index (tm, &bi)))
+    return;
+
   b = vlib_get_buffer (vm, bi);
 
   if (tc->state >= TCP_STATE_ESTABLISHED)
@@ -1116,6 +1184,7 @@ tcp_timer_retransmit_handler_i (u32 index, u8 is_syn)
       /* Lost FIN, retransmit and return */
       if (tc->flags & TCP_CONN_FINSNT)
 	{
+	  tcp_return_buffer (tm);
 	  tcp_send_fin (tc);
 	  return;
 	}
@@ -1143,6 +1212,7 @@ tcp_timer_retransmit_handler_i (u32 index, u8 is_syn)
 	  tcp_retransmit_timer_set (tc);
 	  ASSERT (0 || (tc->rto_boff > 1
 			&& tc->snd_una == tc->snd_congestion));
+	  tcp_return_buffer (tm);
 	  return;
 	}
 
@@ -1164,6 +1234,7 @@ tcp_timer_retransmit_handler_i (u32 index, u8 is_syn)
 	      clib_warning ("could not remove half-open connection");
 	      ASSERT (0);
 	    }
+	  tcp_return_buffer (tm);
 	  return;
 	}
 
@@ -1185,6 +1256,7 @@ tcp_timer_retransmit_handler_i (u32 index, u8 is_syn)
     {
       ASSERT (tc->state == TCP_STATE_CLOSED);
       clib_warning ("connection closed ...");
+      tcp_return_buffer (tm);
       return;
     }
 
@@ -1254,7 +1326,9 @@ tcp_timer_persist_handler (u32 index)
   tc->rto = clib_min (tc->rto << 1, TCP_RTO_MAX);
 
   /* Try to force the first unsent segment  */
-  tcp_get_free_buffer_index (tm, &bi);
+  if (PREDICT_FALSE (tcp_get_free_buffer_index (tm, &bi)))
+    return;
+
   b = vlib_get_buffer (vm, bi);
 
   tcp_validate_txf_size (tc, tc->snd_una_max - tc->snd_una);
@@ -1300,7 +1374,9 @@ tcp_retransmit_first_unacked (tcp_connection_t * tc)
   tc->snd_nxt = tc->snd_una;
 
   /* Get buffer */
-  tcp_get_free_buffer_index (tm, &bi);
+  if (PREDICT_FALSE (tcp_get_free_buffer_index (tm, &bi)))
+    return;
+
   b = vlib_get_buffer (vm, bi);
 
   TCP_EVT_DBG (TCP_EVT_CC_EVT, tc, 2);
@@ -1344,9 +1420,10 @@ tcp_fast_retransmit_sack (tcp_connection_t * tc)
   hole = scoreboard_get_hole (sb, sb->cur_rxt_hole);
   while (hole && snd_space > 0)
     {
-      tcp_get_free_buffer_index (tm, &bi);
-      b = vlib_get_buffer (vm, bi);
+      if (PREDICT_FALSE (tcp_get_free_buffer_index (tm, &bi)))
+	return;
 
+      b = vlib_get_buffer (vm, bi);
       hole = scoreboard_next_rxt_hole (sb, hole,
 				       tcp_fastrecovery_sent_1_smss (tc),
 				       &can_rescue, &snd_limited);
@@ -1414,9 +1491,9 @@ tcp_fast_retransmit_no_sack (tcp_connection_t * tc)
 
   while (snd_space > 0)
     {
-      tcp_get_free_buffer_index (tm, &bi);
+      if (PREDICT_FALSE (tcp_get_free_buffer_index (tm, &bi)))
+	return;
       b = vlib_get_buffer (vm, bi);
-
       offset += n_written;
       n_written = tcp_prepare_retransmit_segment (tc, b, offset, snd_space);
 
@@ -1506,32 +1583,21 @@ tcp46_output_inline (vlib_main_t * vm,
 
 	  if (is_ip4)
 	    {
-	      ip4_header_t *ih0;
-	      ih0 = vlib_buffer_push_ip4 (vm, b0, &tc0->c_lcl_ip4,
-					  &tc0->c_rmt_ip4, IP_PROTOCOL_TCP,
-					  1);
-	      b0->flags |=
-		VNET_BUFFER_F_IS_IP4 | VNET_BUFFER_F_OFFLOAD_IP_CKSUM |
-		VNET_BUFFER_F_OFFLOAD_TCP_CKSUM;
-	      vnet_buffer (b0)->l3_hdr_offset = (u8 *) ih0 - b0->data;
+	      vlib_buffer_push_ip4 (vm, b0, &tc0->c_lcl_ip4, &tc0->c_rmt_ip4,
+				    IP_PROTOCOL_TCP, 1);
+	      b0->flags |= VNET_BUFFER_F_OFFLOAD_TCP_CKSUM;
 	      vnet_buffer (b0)->l4_hdr_offset = (u8 *) th0 - b0->data;
 	      th0->checksum = 0;
 	    }
 	  else
 	    {
 	      ip6_header_t *ih0;
-	      int bogus = ~0;
-
 	      ih0 = vlib_buffer_push_ip6 (vm, b0, &tc0->c_lcl_ip6,
 					  &tc0->c_rmt_ip6, IP_PROTOCOL_TCP);
-
-	      b0->flags |= VNET_BUFFER_F_IS_IP6 |
-		VNET_BUFFER_F_OFFLOAD_IP_CKSUM |
-		VNET_BUFFER_F_OFFLOAD_TCP_CKSUM;
+	      b0->flags |= VNET_BUFFER_F_OFFLOAD_TCP_CKSUM;
 	      vnet_buffer (b0)->l3_hdr_offset = (u8 *) ih0 - b0->data;
 	      vnet_buffer (b0)->l4_hdr_offset = (u8 *) th0 - b0->data;
 	      th0->checksum = 0;
-	      ASSERT (!bogus);
 	    }
 
 	  /* Filter out DUPACKs if there are no OOO segments left */
diff --git a/src/vnet/unix/gdb_funcs.c b/src/vnet/unix/gdb_funcs.c
index cca2e420..32e22d92 100644
--- a/src/vnet/unix/gdb_funcs.c
+++ b/src/vnet/unix/gdb_funcs.c
@@ -21,7 +21,7 @@
 
 #include <vlib/threads.h>
 #include <vnet/vnet.h>
-
+#include <vppinfra/format.h>
 
 /**
  * @brief GDB callable function: vl - Return vector length of vector
@@ -135,6 +135,47 @@ void vlib_runtime_index_to_node_name (u32 index)
   fformat(stderr, "node runtime index %d name %s\n", index, nm->nodes[index]->name);
 }
 
+void gdb_show_errors (int verbose)
+{
+  extern vlib_cli_command_t vlib_cli_show_errors;
+  unformat_input_t input;
+  vlib_main_t * vm = vlib_get_main();
+
+  if (verbose == 0)
+    unformat_init_string (&input, "verbose 0", 9);
+  else if (verbose == 1)
+    unformat_init_string (&input, "verbose 1", 9);
+  else 
+    {
+      fformat(stderr, "verbose not 0 or 1\n");
+      return;
+    }
+
+  vlib_cli_show_errors.function (vm, &input, 0 /* cmd */);
+  unformat_free (&input);
+}  
+
+void gdb_show_session (int verbose)
+{
+  extern vlib_cli_command_t vlib_cli_show_session_command;
+  unformat_input_t input;
+  vlib_main_t * vm = vlib_get_main();
+
+  if (verbose == 0)
+    unformat_init_string (&input, "verbose 0", 9);
+  else if (verbose == 1)
+    unformat_init_string (&input, "verbose 1", 9);
+  else if (verbose == 2)
+    unformat_init_string (&input, "verbose 2", 9);
+  else 
+    {
+      fformat(stderr, "verbose not 0 - 2\n");
+      return;
+    }
+
+  vlib_cli_show_session_command.function (vm, &input, 0 /* cmd */);
+  unformat_free (&input);
+}  
 
 /**
  * @brief GDB callable function: show_gdb_command_fn - show gdb
@@ -151,6 +192,8 @@ show_gdb_command_fn (vlib_main_t * vm,
   vlib_cli_output (vm, "vl(p) returns vec_len(p)");
   vlib_cli_output (vm, "pe(p) returns pool_elts(p)");
   vlib_cli_output (vm, "pifi(p, i) returns pool_is_free_index(p, i)");
+  vlib_cli_output (vm, "gdb_show_errors(0|1) dumps error counters");
+  vlib_cli_output (vm, "gdb_show_session dumps session counters");
   vlib_cli_output (vm, "debug_hex_bytes (ptr, n_bytes) dumps n_bytes in hex");
   vlib_cli_output (vm, "vlib_dump_frame_ownership() does what it says");
   vlib_cli_output (vm, "vlib_runtime_index_to_node_name (index) prints NN");
diff --git a/src/vppinfra/pool.h b/src/vppinfra/pool.h
index 57838e1c..56536b77 100644
--- a/src/vppinfra/pool.h
+++ b/src/vppinfra/pool.h
@@ -200,7 +200,7 @@ do {									\
 #define pool_get(P,E) pool_get_aligned(P,E,0)
 
 /** See if pool_get will expand the pool or not */
-#define pool_get_aligned_will_expand (P,YESNO,A)                        \
+#define pool_get_aligned_will_expand(P,YESNO,A)                         \
 do {                                                                    \
   pool_header_t * _pool_var (p) = pool_header (P);                      \
   uword _pool_var (l);                                                  \
-- 
cgit 1.2.3-korg


From c9d1c5b6b3668e243bbdd978069976cc1184892b Mon Sep 17 00:00:00 2001
From: root <root@wasa-ucs-13.linuxfoundation.org>
Date: Tue, 15 Aug 2017 12:58:31 -0400
Subject: tcp: fix v6 sessions

Change-Id: Ia6dd5e948b17b2f3866fe70838eabb09e35415e1
Signed-off-by: Dave Barach <dbarach@cisco.com>
Signed-off-by: Florin Coras <fcoras@cisco.com>
---
 src/vnet/ip/ip6_forward.c         | 118 +++++++++++++++++++++-----------------
 src/vnet/session/session.c        |   4 +-
 src/vnet/session/session_cli.c    |   2 +-
 src/vnet/session/session_lookup.c |   8 +--
 src/vnet/tcp/tcp.c                |  17 +++++-
 src/vnet/tcp/tcp_input.c          |  16 +-----
 src/vnet/tcp/tcp_output.c         |   6 +-
 7 files changed, 90 insertions(+), 81 deletions(-)

(limited to 'src/vnet/session/session_lookup.c')

diff --git a/src/vnet/ip/ip6_forward.c b/src/vnet/ip/ip6_forward.c
index 8ae08a01..5832bd0b 100644
--- a/src/vnet/ip/ip6_forward.c
+++ b/src/vnet/ip/ip6_forward.c
@@ -1323,6 +1323,20 @@ ip6_urpf_loose_check (ip6_main_t * im, vlib_buffer_t * b, ip6_header_t * i)
   return (fib_urpf_check_size (lb0->lb_urpf));
 }
 
+always_inline u8
+ip6_next_proto_is_tcp_udp (vlib_buffer_t * p0, ip6_header_t * ip0,
+			   u32 * udp_offset0)
+{
+  u32 proto0;
+  proto0 = ip6_locate_header (p0, ip0, IP_PROTOCOL_UDP, udp_offset0);
+  if (proto0 != IP_PROTOCOL_UDP)
+    {
+      proto0 = ip6_locate_header (p0, ip0, IP_PROTOCOL_TCP, udp_offset0);
+      proto0 = (proto0 == IP_PROTOCOL_TCP) ? proto0 : 0;
+    }
+  return proto0;
+}
+
 static uword
 ip6_local (vlib_main_t * vm, vlib_node_runtime_t * node, vlib_frame_t * frame)
 {
@@ -1352,8 +1366,8 @@ ip6_local (vlib_main_t * vm, vlib_node_runtime_t * node, vlib_frame_t * frame)
 	  u32 pi0, ip_len0, udp_len0, flags0, next0;
 	  u32 pi1, ip_len1, udp_len1, flags1, next1;
 	  i32 len_diff0, len_diff1;
-	  u8 error0, type0, good_l4_checksum0;
-	  u8 error1, type1, good_l4_checksum1;
+	  u8 error0, type0, good_l4_csum0, is_tcp_udp0;
+	  u8 error1, type1, good_l4_csum1, is_tcp_udp1;
 	  u32 udp_offset0, udp_offset1;
 
 	  pi0 = to_next[0] = from[0];
@@ -1381,67 +1395,69 @@ ip6_local (vlib_main_t * vm, vlib_node_runtime_t * node, vlib_frame_t * frame)
 	  flags0 = p0->flags;
 	  flags1 = p1->flags;
 
-	  good_l4_checksum0 =
-	    (flags0 & VNET_BUFFER_F_L4_CHECKSUM_CORRECT) != 0;
-	  good_l4_checksum1 =
-	    (flags1 & VNET_BUFFER_F_L4_CHECKSUM_CORRECT) != 0;
+	  is_tcp_udp0 = ip6_next_proto_is_tcp_udp (p0, ip0, &udp_offset0);
+	  is_tcp_udp1 = ip6_next_proto_is_tcp_udp (p1, ip1, &udp_offset1);
+
+	  good_l4_csum0 = (flags0 & VNET_BUFFER_F_L4_CHECKSUM_CORRECT) != 0;
+	  good_l4_csum1 = (flags1 & VNET_BUFFER_F_L4_CHECKSUM_CORRECT) != 0;
 	  len_diff0 = 0;
 	  len_diff1 = 0;
 
-	  if (PREDICT_TRUE (IP_PROTOCOL_UDP == ip6_locate_header (p0, ip0,
-								  IP_PROTOCOL_UDP,
-								  &udp_offset0)))
+	  if (PREDICT_TRUE (is_tcp_udp0))
 	    {
 	      udp0 = (udp_header_t *) ((u8 *) ip0 + udp_offset0);
 	      /* Don't verify UDP checksum for packets with explicit zero checksum. */
-	      good_l4_checksum0 |= type0 == IP_BUILTIN_PROTOCOL_UDP
+	      good_l4_csum0 |= type0 == IP_BUILTIN_PROTOCOL_UDP
 		&& udp0->checksum == 0;
 	      /* Verify UDP length. */
-	      ip_len0 = clib_net_to_host_u16 (ip0->payload_length);
-	      udp_len0 = clib_net_to_host_u16 (udp0->length);
-	      len_diff0 = ip_len0 - udp_len0;
+	      if (is_tcp_udp0 == IP_PROTOCOL_UDP)
+		{
+		  ip_len0 = clib_net_to_host_u16 (ip0->payload_length);
+		  udp_len0 = clib_net_to_host_u16 (udp0->length);
+		  len_diff0 = ip_len0 - udp_len0;
+		}
 	    }
-	  if (PREDICT_TRUE (IP_PROTOCOL_UDP == ip6_locate_header (p1, ip1,
-								  IP_PROTOCOL_UDP,
-								  &udp_offset1)))
+	  if (PREDICT_TRUE (is_tcp_udp1))
 	    {
 	      udp1 = (udp_header_t *) ((u8 *) ip1 + udp_offset1);
 	      /* Don't verify UDP checksum for packets with explicit zero checksum. */
-	      good_l4_checksum1 |= type1 == IP_BUILTIN_PROTOCOL_UDP
+	      good_l4_csum1 |= type1 == IP_BUILTIN_PROTOCOL_UDP
 		&& udp1->checksum == 0;
 	      /* Verify UDP length. */
-	      ip_len1 = clib_net_to_host_u16 (ip1->payload_length);
-	      udp_len1 = clib_net_to_host_u16 (udp1->length);
-	      len_diff1 = ip_len1 - udp_len1;
+	      if (is_tcp_udp1 == IP_PROTOCOL_UDP)
+		{
+		  ip_len1 = clib_net_to_host_u16 (ip1->payload_length);
+		  udp_len1 = clib_net_to_host_u16 (udp1->length);
+		  len_diff1 = ip_len1 - udp_len1;
+		}
 	    }
 
-	  good_l4_checksum0 |= type0 == IP_BUILTIN_PROTOCOL_UNKNOWN;
-	  good_l4_checksum1 |= type1 == IP_BUILTIN_PROTOCOL_UNKNOWN;
+	  good_l4_csum0 |= type0 == IP_BUILTIN_PROTOCOL_UNKNOWN;
+	  good_l4_csum1 |= type1 == IP_BUILTIN_PROTOCOL_UNKNOWN;
 
 	  len_diff0 = type0 == IP_BUILTIN_PROTOCOL_UDP ? len_diff0 : 0;
 	  len_diff1 = type1 == IP_BUILTIN_PROTOCOL_UDP ? len_diff1 : 0;
 
 	  if (PREDICT_FALSE (type0 != IP_BUILTIN_PROTOCOL_UNKNOWN
-			     && !good_l4_checksum0
+			     && !good_l4_csum0
 			     && !(flags0 &
 				  VNET_BUFFER_F_L4_CHECKSUM_COMPUTED)))
 	    {
 	      flags0 = ip6_tcp_udp_icmp_validate_checksum (vm, p0);
-	      good_l4_checksum0 =
+	      good_l4_csum0 =
 		(flags0 & VNET_BUFFER_F_L4_CHECKSUM_CORRECT) != 0;
 	    }
 	  if (PREDICT_FALSE (type1 != IP_BUILTIN_PROTOCOL_UNKNOWN
-			     && !good_l4_checksum1
+			     && !good_l4_csum1
 			     && !(flags1 &
 				  VNET_BUFFER_F_L4_CHECKSUM_COMPUTED)))
 	    {
 	      flags1 = ip6_tcp_udp_icmp_validate_checksum (vm, p1);
-	      good_l4_checksum1 =
+	      good_l4_csum1 =
 		(flags1 & VNET_BUFFER_F_L4_CHECKSUM_CORRECT) != 0;
 	    }
 
 	  error0 = error1 = IP6_ERROR_UNKNOWN_PROTOCOL;
-
 	  error0 = len_diff0 < 0 ? IP6_ERROR_UDP_LENGTH : error0;
 	  error1 = len_diff1 < 0 ? IP6_ERROR_UDP_LENGTH : error1;
 
@@ -1449,10 +1465,8 @@ ip6_local (vlib_main_t * vm, vlib_node_runtime_t * node, vlib_frame_t * frame)
 		  IP6_ERROR_UDP_CHECKSUM);
 	  ASSERT (IP6_ERROR_UDP_CHECKSUM + IP_BUILTIN_PROTOCOL_ICMP ==
 		  IP6_ERROR_ICMP_CHECKSUM);
-	  error0 =
-	    (!good_l4_checksum0 ? IP6_ERROR_UDP_CHECKSUM + type0 : error0);
-	  error1 =
-	    (!good_l4_checksum1 ? IP6_ERROR_UDP_CHECKSUM + type1 : error1);
+	  error0 = (!good_l4_csum0 ? IP6_ERROR_UDP_CHECKSUM + type0 : error0);
+	  error1 = (!good_l4_csum1 ? IP6_ERROR_UDP_CHECKSUM + type1 : error1);
 
 	  /* Drop packets from unroutable hosts. */
 	  /* If this is a neighbor solicitation (ICMP), skip source RPF check */
@@ -1491,8 +1505,9 @@ ip6_local (vlib_main_t * vm, vlib_node_runtime_t * node, vlib_frame_t * frame)
 	  udp_header_t *udp0;
 	  u32 pi0, ip_len0, udp_len0, flags0, next0;
 	  i32 len_diff0;
-	  u8 error0, type0, good_l4_checksum0;
+	  u8 error0, type0, good_l4_csum0;
 	  u32 udp_offset0;
+	  u8 is_tcp_udp0;
 
 	  pi0 = to_next[0] = from[0];
 	  from += 1;
@@ -1501,59 +1516,55 @@ ip6_local (vlib_main_t * vm, vlib_node_runtime_t * node, vlib_frame_t * frame)
 	  n_left_to_next -= 1;
 
 	  p0 = vlib_get_buffer (vm, pi0);
-
 	  ip0 = vlib_buffer_get_current (p0);
-
 	  vnet_buffer (p0)->l3_hdr_offset = p0->current_data;
 
 	  type0 = lm->builtin_protocol_by_ip_protocol[ip0->protocol];
 	  next0 = lm->local_next_by_ip_protocol[ip0->protocol];
-
 	  flags0 = p0->flags;
+	  is_tcp_udp0 = ip6_next_proto_is_tcp_udp (p0, ip0, &udp_offset0);
+	  good_l4_csum0 = (flags0 & VNET_BUFFER_F_L4_CHECKSUM_CORRECT) != 0;
 
-	  good_l4_checksum0 =
-	    (flags0 & VNET_BUFFER_F_L4_CHECKSUM_CORRECT) != 0;
 	  len_diff0 = 0;
-
-	  if (PREDICT_TRUE (IP_PROTOCOL_UDP == ip6_locate_header (p0, ip0,
-								  IP_PROTOCOL_UDP,
-								  &udp_offset0)))
+	  if (PREDICT_TRUE (is_tcp_udp0))
 	    {
 	      udp0 = (udp_header_t *) ((u8 *) ip0 + udp_offset0);
-	      /* Don't verify UDP checksum for packets with explicit zero checksum. */
-	      good_l4_checksum0 |= type0 == IP_BUILTIN_PROTOCOL_UDP
+	      /* Don't verify UDP checksum for packets with explicit zero
+	       * checksum. */
+	      good_l4_csum0 |= type0 == IP_BUILTIN_PROTOCOL_UDP
 		&& udp0->checksum == 0;
 	      /* Verify UDP length. */
-	      ip_len0 = clib_net_to_host_u16 (ip0->payload_length);
-	      udp_len0 = clib_net_to_host_u16 (udp0->length);
-	      len_diff0 = ip_len0 - udp_len0;
+	      if (is_tcp_udp0 == IP_PROTOCOL_UDP)
+		{
+		  ip_len0 = clib_net_to_host_u16 (ip0->payload_length);
+		  udp_len0 = clib_net_to_host_u16 (udp0->length);
+		  len_diff0 = ip_len0 - udp_len0;
+		}
 	    }
 
-	  good_l4_checksum0 |= type0 == IP_BUILTIN_PROTOCOL_UNKNOWN;
+	  good_l4_csum0 |= type0 == IP_BUILTIN_PROTOCOL_UNKNOWN;
 	  len_diff0 = type0 == IP_BUILTIN_PROTOCOL_UDP ? len_diff0 : 0;
 
 	  if (PREDICT_FALSE (type0 != IP_BUILTIN_PROTOCOL_UNKNOWN
-			     && !good_l4_checksum0
+			     && !good_l4_csum0
 			     && !(flags0 &
 				  VNET_BUFFER_F_L4_CHECKSUM_COMPUTED)))
 	    {
 	      flags0 = ip6_tcp_udp_icmp_validate_checksum (vm, p0);
-	      good_l4_checksum0 =
+	      good_l4_csum0 =
 		(flags0 & VNET_BUFFER_F_L4_CHECKSUM_CORRECT) != 0;
 	    }
 
 	  error0 = IP6_ERROR_UNKNOWN_PROTOCOL;
-
 	  error0 = len_diff0 < 0 ? IP6_ERROR_UDP_LENGTH : error0;
 
 	  ASSERT (IP6_ERROR_UDP_CHECKSUM + IP_BUILTIN_PROTOCOL_UDP ==
 		  IP6_ERROR_UDP_CHECKSUM);
 	  ASSERT (IP6_ERROR_UDP_CHECKSUM + IP_BUILTIN_PROTOCOL_ICMP ==
 		  IP6_ERROR_ICMP_CHECKSUM);
-	  error0 =
-	    (!good_l4_checksum0 ? IP6_ERROR_UDP_CHECKSUM + type0 : error0);
+	  error0 = (!good_l4_csum0 ? IP6_ERROR_UDP_CHECKSUM + type0 : error0);
 
-	  /* If this is a neighbor solicitation (ICMP), skip source RPF check */
+	  /* If this is a neighbor solicitation (ICMP), skip src RPF check */
 	  if (error0 == IP6_ERROR_UNKNOWN_PROTOCOL &&
 	      type0 != IP_BUILTIN_PROTOCOL_ICMP &&
 	      !ip6_address_is_link_local_unicast (&ip0->src_address))
@@ -1564,7 +1575,6 @@ ip6_local (vlib_main_t * vm, vlib_node_runtime_t * node, vlib_frame_t * frame)
 
 	  next0 =
 	    error0 != IP6_ERROR_UNKNOWN_PROTOCOL ? IP_LOCAL_NEXT_DROP : next0;
-
 	  p0->error = error_node->errors[error0];
 
 	  vlib_validate_buffer_enqueue_x1 (vm, node, next_index,
diff --git a/src/vnet/session/session.c b/src/vnet/session/session.c
index 843d474f..70a5cd83 100644
--- a/src/vnet/session/session.c
+++ b/src/vnet/session/session.c
@@ -375,10 +375,12 @@ stream_session_connect_notify (transport_connection_t * tc, u8 is_fail)
   u64 handle;
   u32 opaque = 0;
   int error = 0;
+  u8 st;
 
+  st = session_type_from_proto_and_ip (tc->transport_proto, tc->is_ip4);
   handle = stream_session_half_open_lookup_handle (&tc->lcl_ip, &tc->rmt_ip,
 						   tc->lcl_port, tc->rmt_port,
-						   tc->transport_proto);
+						   st);
   if (handle == HALF_OPEN_LOOKUP_INVALID_VALUE)
     {
       clib_warning ("This can't be good!");
diff --git a/src/vnet/session/session_cli.c b/src/vnet/session/session_cli.c
index 9f3d217c..f60048f1 100755
--- a/src/vnet/session/session_cli.c
+++ b/src/vnet/session/session_cli.c
@@ -315,7 +315,7 @@ show_session_command_fn (vlib_main_t * vm, unformat_input_t * input,
 VLIB_CLI_COMMAND (vlib_cli_show_session_command) =
 {
   .path = "show session",
-  .short_help = "show session [verbose]",
+  .short_help = "show session [verbose [nnn]]",
   .function = show_session_command_fn,
 };
 /* *INDENT-ON* */
diff --git a/src/vnet/session/session_lookup.c b/src/vnet/session/session_lookup.c
index 41f9dbf0..0f9abf9a 100644
--- a/src/vnet/session/session_lookup.c
+++ b/src/vnet/session/session_lookup.c
@@ -106,8 +106,8 @@ make_v4_listener_kv (session_kv4_t * kv, ip4_address_t * lcl, u16 lcl_port,
 always_inline void
 make_v4_ss_kv_from_tc (session_kv4_t * kv, transport_connection_t * t)
 {
-  return make_v4_ss_kv (kv, &t->lcl_ip.ip4, &t->rmt_ip.ip4, t->lcl_port,
-			t->rmt_port, t->transport_proto);
+  make_v4_ss_kv (kv, &t->lcl_ip.ip4, &t->rmt_ip.ip4, t->lcl_port, t->rmt_port,
+		 session_type_from_proto_and_ip (t->transport_proto, 1));
 }
 
 always_inline void
@@ -149,8 +149,8 @@ make_v6_listener_kv (session_kv6_t * kv, ip6_address_t * lcl, u16 lcl_port,
 always_inline void
 make_v6_ss_kv_from_tc (session_kv6_t * kv, transport_connection_t * t)
 {
-  make_v6_ss_kv (kv, &t->lcl_ip.ip6, &t->rmt_ip.ip6, t->lcl_port,
-		 t->rmt_port, t->transport_proto);
+  make_v6_ss_kv (kv, &t->lcl_ip.ip6, &t->rmt_ip.ip6, t->lcl_port, t->rmt_port,
+		 session_type_from_proto_and_ip (t->transport_proto, 0));
 }
 
 /*
diff --git a/src/vnet/tcp/tcp.c b/src/vnet/tcp/tcp.c
index 75c9d8dc..d1690022 100644
--- a/src/vnet/tcp/tcp.c
+++ b/src/vnet/tcp/tcp.c
@@ -362,7 +362,11 @@ ip_interface_get_first_ip (u32 sw_if_index, u8 is_ip4)
       /* *INDENT-OFF* */
       foreach_ip_interface_address (lm6, ia, sw_if_index, 1 /* unnumbered */ ,
       ({
-        return ip_interface_address_get_address (lm6, ia);
+        ip6_address_t *rv;
+        rv = ip_interface_address_get_address (lm6, ia);
+        /* Trying to use a link-local ip6 src address is a fool's errand */
+        if (!ip6_address_is_link_local_unicast (rv))
+          return rv;
       }));
       /* *INDENT-ON* */
     }
@@ -635,6 +639,14 @@ tcp_connection_open (transport_endpoint_t * rmt)
       else
 	{
 	  ip6 = ip_interface_get_first_ip (sw_if_index, 0);
+	  if (ip6 == 0)
+	    {
+	      clib_warning ("no routable ip6 addresses on %U",
+			    format_vnet_sw_if_index_name, vnet_get_main (),
+			    sw_if_index);
+	      return -1;
+	    }
+
 	  clib_memcpy (&lcl_addr.ip6, ip6, sizeof (*ip6));
 	}
     }
@@ -1109,7 +1121,6 @@ tcp_timer_establish_handler (u32 conn_index)
   if (tc)
     {
       ASSERT (tc->state == TCP_STATE_SYN_SENT);
-      tc->timers[TCP_TIMER_ESTABLISH] = TCP_TIMER_HANDLE_INVALID;
       stream_session_connect_notify (&tc->connection, 1 /* fail */ );
     }
   else
@@ -1117,6 +1128,7 @@ tcp_timer_establish_handler (u32 conn_index)
       tc = tcp_connection_get (conn_index, vlib_get_thread_index ());
       ASSERT (tc->state == TCP_STATE_SYN_RCVD);
     }
+  tc->timers[TCP_TIMER_ESTABLISH] = TCP_TIMER_HANDLE_INVALID;
   tcp_connection_cleanup (tc);
 }
 
@@ -1231,6 +1243,7 @@ tcp_main_enable (vlib_main_t * vm)
   pi->unformat_pg_edit = unformat_pg_tcp_header;
 
   ip4_register_protocol (IP_PROTOCOL_TCP, tcp4_input_node.index);
+  ip6_register_protocol (IP_PROTOCOL_TCP, tcp6_input_node.index);
 
   /* Register as transport with session layer */
   session_register_transport (TRANSPORT_PROTO_TCP, 1, &tcp_proto);
diff --git a/src/vnet/tcp/tcp_input.c b/src/vnet/tcp/tcp_input.c
index a3c4f1d8..6f9e4c7a 100644
--- a/src/vnet/tcp/tcp_input.c
+++ b/src/vnet/tcp/tcp_input.c
@@ -1877,26 +1877,12 @@ tcp46_syn_sent_inline (vlib_main_t * vm, vlib_node_runtime_t * node,
 	  tc0 =
 	    tcp_half_open_connection_get (vnet_buffer (b0)->
 					  tcp.connection_index);
+	  ASSERT (tc0);
 
 	  ack0 = vnet_buffer (b0)->tcp.ack_number;
 	  seq0 = vnet_buffer (b0)->tcp.seq_number;
 	  tcp0 = tcp_buffer_hdr (b0);
 
-	  if (!tc0)
-	    {
-	      ip4_header_t *ip40 = vlib_buffer_get_current (b0);
-	      tcp0 = ip4_next_header (ip40);
-	      tc0 =
-		(tcp_connection_t *)
-		stream_session_lookup_transport_wt4 (&ip40->dst_address,
-						     &ip40->src_address,
-						     tcp0->dst_port,
-						     tcp0->src_port,
-						     SESSION_TYPE_IP4_TCP,
-						     my_thread_index);
-	      ASSERT (0);
-	      goto drop;
-	    }
 	  if (PREDICT_FALSE
 	      (!tcp_ack (tcp0) && !tcp_rst (tcp0) && !tcp_syn (tcp0)))
 	    goto drop;
diff --git a/src/vnet/tcp/tcp_output.c b/src/vnet/tcp/tcp_output.c
index 5a395b9f..e6a211ba 100644
--- a/src/vnet/tcp/tcp_output.c
+++ b/src/vnet/tcp/tcp_output.c
@@ -775,12 +775,10 @@ tcp_send_reset (tcp_connection_t * tc, vlib_buffer_t * pkt, u8 is_ip4)
   else
     {
       int bogus = ~0;
-      pkt_ih6 = (ip6_header_t *) (pkt_th - 1);
       ASSERT ((pkt_ih6->ip_version_traffic_class_and_flow_label & 0xF0) ==
 	      0x60);
-      ih6 =
-	vlib_buffer_push_ip6 (vm, b, &pkt_ih6->dst_address,
-			      &pkt_ih6->src_address, IP_PROTOCOL_TCP);
+      ih6 = vlib_buffer_push_ip6 (vm, b, &pkt_ih6->dst_address,
+				  &pkt_ih6->src_address, IP_PROTOCOL_TCP);
       th->checksum = ip6_tcp_udp_icmp_compute_checksum (vm, b, ih6, &bogus);
       ASSERT (!bogus);
     }
-- 
cgit 1.2.3-korg


From b2bcad6238b7e8a669ae29c74079eb9bb9fbb694 Mon Sep 17 00:00:00 2001
From: Chris Luke <chrisy@flirble.org>
Date: Mon, 18 Sep 2017 08:51:22 -0400
Subject: Fixes for issues Coverity has reported (VPP-972)

177117: fstat() returns -1 on error; the code is
        checking for any positive value instead
175142: final return could never be reached; simple
        refactoring
175235,175236: Warning suppressed with an explicit
        cast to (void)
174817: Final return couldn't be reached; is
        is_in_order is 0 then 'rv' is already returned
        above
172095,172093: If is_is_set does not get set to 1,
        then return 0 has already been invoked
174405: Re-kill this (nothing sets rv)
171136: Looks like a cmd line flag to set test_bytes
        was missing; added it, and refactored the
        argc/argv processing to avoid two other
        potential segv's
176813: Add range checking for term width/height.
        First stab at a reasonable range is 1-512
        for both.
175350: Fix implicit casting in shift operation
174272: Not a c+p error; try using a coverity
        annotation to ignore it
174273,175320: Annotated FORWARD_NULL

Change-Id: I58d0f860fc2209f59f8d1b6b344d631b8d429ace
Signed-off-by: Chris Luke <chrisy@flirble.org>
---
 src/uri/sock_test_client.c        |  1 +
 src/uri/uri_socket_test.c         | 24 ++++++++++++++++++++++--
 src/uri/vppcom.c                  |  8 ++++++--
 src/vlib/linux/physmem.c          |  2 +-
 src/vlib/unix/cli.c               | 30 ++++++++++++++++++++++++++++++
 src/vnet/mpls/mpls_api.c          |  2 +-
 src/vnet/session/session.c        |  5 +----
 src/vnet/session/session_cli.c    | 37 +++++++------------------------------
 src/vnet/session/session_lookup.c |  8 ++++----
 src/vppinfra/linux/mem.c          |  2 +-
 10 files changed, 74 insertions(+), 45 deletions(-)

(limited to 'src/vnet/session/session_lookup.c')

diff --git a/src/uri/sock_test_client.c b/src/uri/sock_test_client.c
index ab8e5a0e..151c90b2 100644
--- a/src/uri/sock_test_client.c
+++ b/src/uri/sock_test_client.c
@@ -429,6 +429,7 @@ exit_client (void)
       tsock = &scm->test_socket[i];
       tsock->cfg.test = SOCK_TEST_TYPE_EXIT;
 
+      /* coverity[COPY_PASTE_ERROR] */
       if (ctrl->cfg.verbose)
 	{
 	  printf ("\nCLIENT (fd %d): Sending exit cfg to server...\n",
diff --git a/src/uri/uri_socket_test.c b/src/uri/uri_socket_test.c
index 5f7084d5..4469b03d 100644
--- a/src/uri/uri_socket_test.c
+++ b/src/uri/uri_socket_test.c
@@ -36,8 +36,6 @@ main (int argc, char *argv[])
 
   if (argc >= 3)
     {
-      bytes = ((long) atoi (argv[4])) << 20;
-      no_echo = atoi (argv[3]);
       portno = atoi (argv[2]);
       server = gethostbyname (argv[1]);
       if (server == NULL)
@@ -45,6 +43,28 @@ main (int argc, char *argv[])
 	  clib_unix_warning ("gethostbyname");
 	  exit (1);
 	}
+
+      argc -= 3;
+      argv += 3;
+
+      if (argc)
+	{
+	  bytes = ((long) atoi (argv[0])) << 20;
+	  argc--;
+	  argv++;
+	}
+      if (argc)
+	{
+	  no_echo = atoi (argv[0]);
+	  argc--;
+	  argv++;
+	}
+      if (argc)
+	{
+	  test_bytes = atoi (argv[0]);
+	  argc--;
+	  argv++;
+	}
     }
   else
     {
diff --git a/src/uri/vppcom.c b/src/uri/vppcom.c
index 8a8a806c..c7ae0ea5 100644
--- a/src/uri/vppcom.c
+++ b/src/uri/vppcom.c
@@ -1478,7 +1478,7 @@ vppcom_cfg_read (char *conf_fname)
 
   while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
     {
-      unformat_user (input, unformat_line_input, line_input);
+      (void) unformat_user (input, unformat_line_input, line_input);
       unformat_skip_white_space (line_input);
 
       if (unformat (line_input, "vppcom {"))
@@ -2359,12 +2359,14 @@ vppcom_select (unsigned long n_bits, unsigned long *read_map,
               clib_bitmap_get (vcm->ex_bitmap, session_index) && (rv < 0))
             {
               // TBD: clib_warning
+              /* coverity[FORWARD_NULL] */
               clib_bitmap_set_no_check (except_map, session_index, 1);
               bits_set++;
             }
           else if (rv > 0)
             {
               // TBD: clib_warning
+              /* coverity[FORWARD_NULL] */
               clib_bitmap_set_no_check (read_map, session_index, 1);
               bits_set++;
             }
@@ -2387,9 +2389,10 @@ vppcom_select (unsigned long n_bits, unsigned long *read_map,
 
           rv = vppcom_session_write_ready (session, session_index);
           clib_spinlock_unlock (&vcm->sessions_lockp);
-          if (rv > 0)
+          if (rv > 0 )
             {
               // TBD: clib_warning
+              /* coverity[FORWARD_NULL] */
               clib_bitmap_set_no_check (write_map, session_index, 1);
               bits_set++;
             }
@@ -2415,6 +2418,7 @@ vppcom_select (unsigned long n_bits, unsigned long *read_map,
           if (rv < 0)
             {
               // TBD: clib_warning
+              /* coverity[FORWARD_NULL] */
               clib_bitmap_set_no_check (except_map, session_index, 1);
               bits_set++;
             }
diff --git a/src/vlib/linux/physmem.c b/src/vlib/linux/physmem.c
index 3cc42a06..6d3f7c55 100644
--- a/src/vlib/linux/physmem.c
+++ b/src/vlib/linux/physmem.c
@@ -157,7 +157,7 @@ unix_physmem_region_alloc (vlib_main_t * vm, char *name, u32 size,
   pr->mem = alloc.addr;
   pr->log2_page_size = alloc.log2_page_size;
   pr->n_pages = alloc.n_pages;
-  pr->size = pr->n_pages << pr->log2_page_size;
+  pr->size = (u64) pr->n_pages << (u64) pr->log2_page_size;
   pr->page_mask = (1 << pr->log2_page_size) - 1;
   pr->numa_node = numa_node;
   pr->name = format (0, "%s", name);
diff --git a/src/vlib/unix/cli.c b/src/vlib/unix/cli.c
index 1567cc2a..1624ce38 100644
--- a/src/vlib/unix/cli.c
+++ b/src/vlib/unix/cli.c
@@ -91,6 +91,15 @@
  * protocol message. This is a saftey measure. */
 #define UNIX_CLI_MAX_DEPTH_TELNET 24
 
+/** Minimum terminal width we will accept */
+#define UNIX_CLI_MIN_TERMINAL_WIDTH 1
+/** Maximum terminal width we will accept */
+#define UNIX_CLI_MAX_TERMINAL_WIDTH 512
+/** Minimum terminal height we will accept */
+#define UNIX_CLI_MIN_TERMINAL_HEIGHT 1
+/** Maximum terminal height we will accept */
+#define UNIX_CLI_MAX_TERMINAL_HEIGHT 512
+
 /** Unix standard in */
 #define UNIX_CLI_STDIN_FD 0
 
@@ -1164,10 +1173,21 @@ unix_cli_process_telnet (unix_main_t * um,
 		    /* Window size */
 		    if (i != 8)	/* check message is correct size */
 		      break;
+
 		    cf->width =
 		      clib_net_to_host_u16 (*((u16 *) (input_vector + 3)));
+		    if (cf->width > UNIX_CLI_MAX_TERMINAL_WIDTH)
+		      cf->width = UNIX_CLI_MAX_TERMINAL_WIDTH;
+		    if (cf->width < UNIX_CLI_MIN_TERMINAL_WIDTH)
+		      cf->width = UNIX_CLI_MIN_TERMINAL_WIDTH;
+
 		    cf->height =
 		      clib_net_to_host_u16 (*((u16 *) (input_vector + 5)));
+		    if (cf->height > UNIX_CLI_MAX_TERMINAL_HEIGHT)
+		      cf->height = UNIX_CLI_MAX_TERMINAL_HEIGHT;
+		    if (cf->height < UNIX_CLI_MIN_TERMINAL_HEIGHT)
+		      cf->height = UNIX_CLI_MIN_TERMINAL_HEIGHT;
+
 		    /* reindex pager buffer */
 		    unix_cli_pager_reindex (cf);
 		    /* redraw page */
@@ -2539,8 +2559,18 @@ unix_cli_resize_interrupt (int signum)
       /* We can't trust ws.XXX... */
       return;
     }
+
   cf->width = ws.ws_col;
+  if (cf->width > UNIX_CLI_MAX_TERMINAL_WIDTH)
+    cf->width = UNIX_CLI_MAX_TERMINAL_WIDTH;
+  if (cf->width < UNIX_CLI_MIN_TERMINAL_WIDTH)
+    cf->width = UNIX_CLI_MIN_TERMINAL_WIDTH;
+
   cf->height = ws.ws_row;
+  if (cf->height > UNIX_CLI_MAX_TERMINAL_HEIGHT)
+    cf->height = UNIX_CLI_MAX_TERMINAL_HEIGHT;
+  if (cf->height < UNIX_CLI_MIN_TERMINAL_HEIGHT)
+    cf->height = UNIX_CLI_MIN_TERMINAL_HEIGHT;
 
   /* Reindex the pager buffer */
   unix_cli_pager_reindex (cf);
diff --git a/src/vnet/mpls/mpls_api.c b/src/vnet/mpls/mpls_api.c
index 988c2c98..762c40ff 100644
--- a/src/vnet/mpls/mpls_api.c
+++ b/src/vnet/mpls/mpls_api.c
@@ -96,7 +96,7 @@ vl_api_mpls_table_add_del_t_handler (vl_api_mpls_table_add_del_t * mp)
   else
     mpls_table_delete (ntohl (mp->mt_table_id), 1);
 
-  rv = (rv == 0) ? vnm->api_errno : rv;
+  // NB: Nothing sets rv; none of the above returns an error
 
   REPLY_MACRO (VL_API_MPLS_TABLE_ADD_DEL_REPLY);
 }
diff --git a/src/vnet/session/session.c b/src/vnet/session/session.c
index 4544f9a0..792e6612 100644
--- a/src/vnet/session/session.c
+++ b/src/vnet/session/session.c
@@ -267,10 +267,7 @@ stream_session_enqueue_data (transport_connection_t * tc, vlib_buffer_t * b,
 	}
     }
 
-  if (is_in_order)
-    return enqueued;
-
-  return 0;
+  return enqueued;
 }
 
 /** Check if we have space in rx fifo to push more bytes */
diff --git a/src/vnet/session/session_cli.c b/src/vnet/session/session_cli.c
index d9f516be..8c30a1df 100755
--- a/src/vnet/session/session_cli.c
+++ b/src/vnet/session/session_cli.c
@@ -127,13 +127,8 @@ unformat_stream_session_id (unformat_input_t * input, va_list * args)
       *is_ip4 = 0;
       tuple_is_set = 1;
     }
-  else
-    return 0;
-
-  if (tuple_is_set)
-    return 1;
 
-  return 0;
+  return tuple_is_set;
 }
 
 uword
@@ -144,21 +139,12 @@ unformat_stream_session (unformat_input_t * input, va_list * args)
   u8 proto = ~0;
   ip46_address_t lcl, rmt;
   u32 lcl_port = 0, rmt_port = 0;
-  u8 is_ip4 = 0, s_type = ~0, id_is_set = 0;
+  u8 is_ip4 = 0, s_type = ~0;
 
-  if (unformat (input, "%U", unformat_stream_session_id, &proto, &lcl, &rmt,
-		&lcl_port, &rmt_port, &is_ip4))
-    {
-      id_is_set = 1;
-    }
-  else
+  if (!unformat (input, "%U", unformat_stream_session_id, &proto, &lcl, &rmt,
+		 &lcl_port, &rmt_port, &is_ip4))
     return 0;
 
-  if (!id_is_set)
-    {
-      return 0;
-    }
-
   s_type = session_type_from_proto_and_ip (proto, is_ip4);
   if (is_ip4)
     s = stream_session_lookup4 (&lcl.ip4, &rmt.ip4,
@@ -185,21 +171,12 @@ unformat_transport_connection (unformat_input_t * input, va_list * args)
   u8 proto = ~0;
   ip46_address_t lcl, rmt;
   u32 lcl_port = 0, rmt_port = 0;
-  u8 is_ip4 = 0, s_type = ~0, id_is_set = 0;
+  u8 is_ip4 = 0, s_type = ~0;
 
-  if (unformat (input, "%U", unformat_stream_session_id, &proto, &lcl, &rmt,
-		&lcl_port, &rmt_port, &is_ip4))
-    {
-      id_is_set = 1;
-    }
-  else
+  if (!unformat (input, "%U", unformat_stream_session_id, &proto, &lcl, &rmt,
+		 &lcl_port, &rmt_port, &is_ip4))
     return 0;
 
-  if (!id_is_set)
-    {
-      return 0;
-    }
-
   proto = (proto == (u8) ~ 0) ? suggested_proto : proto;
   if (proto == (u8) ~ 0)
     return 0;
diff --git a/src/vnet/session/session_lookup.c b/src/vnet/session/session_lookup.c
index 0f9abf9a..4487b1c3 100644
--- a/src/vnet/session/session_lookup.c
+++ b/src/vnet/session/session_lookup.c
@@ -233,15 +233,15 @@ stream_session_half_open_table_add (transport_connection_t * tc, u64 value)
     {
       make_v4_ss_kv_from_tc (&kv4, tc);
       kv4.value = value;
-      clib_bihash_add_del_16_8 (&sl->v4_half_open_hash, &kv4,
-				1 /* is_add */ );
+      (void) clib_bihash_add_del_16_8 (&sl->v4_half_open_hash, &kv4,
+				       1 /* is_add */ );
     }
   else
     {
       make_v6_ss_kv_from_tc (&kv6, tc);
       kv6.value = value;
-      clib_bihash_add_del_48_8 (&sl->v6_half_open_hash, &kv6,
-				1 /* is_add */ );
+      (void) clib_bihash_add_del_48_8 (&sl->v6_half_open_hash, &kv6,
+				       1 /* is_add */ );
     }
 }
 
diff --git a/src/vppinfra/linux/mem.c b/src/vppinfra/linux/mem.c
index 665ddf61..df46763a 100644
--- a/src/vppinfra/linux/mem.c
+++ b/src/vppinfra/linux/mem.c
@@ -49,7 +49,7 @@ int
 clib_mem_vm_get_log2_page_size (int fd)
 {
   struct stat st = { 0 };
-  if (fstat (fd, &st))
+  if (fstat (fd, &st) == -1)
     return 0;
   return min_log2 (st.st_blksize);
 }
-- 
cgit 1.2.3-korg