X-Git-Url: https://gerrit.fd.io/r/gitweb?a=blobdiff_plain;f=src%2Fvcl%2Fvcl_private.c;h=d12d2d31a8fc420352fe13894a8d07926e3e5911;hb=6068719f37419a9b636571706087e835c5956434;hp=3b30d1753c28666f486cda3120f6a94db0173bb8;hpb=cbb5e824afc3f6de0663e7b9a201d4c281c36ec0;p=vpp.git

diff --git a/src/vcl/vcl_private.c b/src/vcl/vcl_private.c
index 3b30d1753c2..d12d2d31a8f 100644
--- a/src/vcl/vcl_private.c
+++ b/src/vcl/vcl_private.c
@@ -128,9 +128,16 @@ vcl_worker_cleanup (vcl_worker_t * wrk, u8 notify_vpp)
 
   if (wrk->mqs_epfd > 0)
     close (wrk->mqs_epfd);
+  pool_free (wrk->sessions);
+  pool_free (wrk->mq_evt_conns);
   hash_free (wrk->session_index_by_vpp_handles);
   vec_free (wrk->mq_events);
   vec_free (wrk->mq_msg_vector);
+  vec_free (wrk->unhandled_evts_vector);
+  vec_free (wrk->pending_session_wrk_updates);
+  clib_bitmap_free (wrk->rd_bitmap);
+  clib_bitmap_free (wrk->wr_bitmap);
+  clib_bitmap_free (wrk->ex_bitmap);
   vcl_worker_free (wrk);
   clib_spinlock_unlock (&vcm->workers_lock);
 }
@@ -138,8 +145,14 @@ vcl_worker_cleanup (vcl_worker_t * wrk, u8 notify_vpp)
 static void
 vcl_worker_cleanup_cb (void *arg)
 {
-  vcl_worker_t *wrk = vcl_worker_get_current ();
-  u32 wrk_index = wrk->wrk_index;
+  vcl_worker_t *wrk;
+  u32 wrk_index;
+
+  wrk_index = vcl_get_worker_index ();
+  wrk = vcl_worker_get_if_valid (wrk_index);
+  if (!wrk)
+    return;
+
   vcl_worker_cleanup (wrk, 1 /* notify vpp */ );
   vcl_set_worker_index (~0);
   VDBG (0, "cleaned up worker %u", wrk_index);
@@ -154,16 +167,19 @@ vcl_worker_alloc_and_init ()
   if (vcl_get_worker_index () != ~0)
     return 0;
 
+  /* Grab lock before selecting mem thread index */
+  clib_spinlock_lock (&vcm->workers_lock);
+
   /* Use separate heap map entry for worker */
   clib_mem_set_thread_index ();
 
   if (pool_elts (vcm->workers) == vcm->cfg.max_workers)
     {
       VDBG (0, "max-workers %u limit reached", vcm->cfg.max_workers);
-      return 0;
+      wrk = 0;
+      goto done;
     }
 
-  clib_spinlock_lock (&vcm->workers_lock);
   wrk = vcl_worker_alloc ();
   vcl_set_worker_index (wrk->wrk_index);
   wrk->thread_id = pthread_self ();
@@ -182,6 +198,7 @@ vcl_worker_alloc_and_init ()
 	}
     }
 
+  wrk->ep_lt_current = VCL_INVALID_SESSION_INDEX;
   wrk->session_index_by_vpp_handles = hash_create (0, sizeof (uword));
   clib_time_init (&wrk->clib_time);
   vec_validate (wrk->mq_events, 64);
@@ -189,9 +206,9 @@ vcl_worker_alloc_and_init ()
   vec_reset_length (wrk->mq_msg_vector);
   vec_validate (wrk->unhandled_evts_vector, 128);
   vec_reset_length (wrk->unhandled_evts_vector);
-  clib_spinlock_unlock (&vcm->workers_lock);
 
 done:
+  clib_spinlock_unlock (&vcm->workers_lock);
   return wrk;
 }
 
@@ -302,6 +319,10 @@ vcl_session_write_ready (vcl_session_t * s)
       else
 	return VPPCOM_EBADFD;
     }
+  else if (s->session_state == VCL_STATE_UPDATED)
+    {
+      return 0;
+    }
   else
     {
       return (s->session_state == VCL_STATE_DISCONNECT) ?
@@ -309,6 +330,21 @@ vcl_session_write_ready (vcl_session_t * s)
     }
 }
 
+int
+vcl_session_alloc_ext_cfg (vcl_session_t *s,
+			   transport_endpt_ext_cfg_type_t type, u32 len)
+{
+  if (s->ext_config)
+    return -1;
+
+  s->ext_config = clib_mem_alloc (len);
+  clib_memset (s->ext_config, 0, len);
+  s->ext_config->len = len;
+  s->ext_config->type = type;
+
+  return 0;
+}
+
 int
 vcl_segment_attach (u64 segment_handle, char *name, ssvm_segment_type_t type,
 		    int fd)
@@ -334,7 +370,7 @@ vcl_segment_attach (u64 segment_handle, char *name, ssvm_segment_type_t type,
 
   clib_rwlock_writer_unlock (&vcm->segment_table_lock);
 
-  vec_reset_length (a->new_segment_indices);
+  vec_free (a->new_segment_indices);
   return 0;
 }
 
@@ -376,8 +412,8 @@ vcl_segment_detach (u64 segment_handle)
 
 int
 vcl_segment_attach_session (uword segment_handle, uword rxf_offset,
-			    uword txf_offset, uword mq_offset, u8 is_ct,
-			    vcl_session_t *s)
+			    uword txf_offset, uword mq_offset, u32 mq_index,
+			    u8 is_ct, vcl_session_t *s)
 {
   u32 fs_index, eqs_index;
   svm_fifo_t *rxf, *txf;
@@ -410,8 +446,7 @@ vcl_segment_attach_session (uword segment_handle, uword rxf_offset,
   if (!is_ct && mq_offset != (uword) ~0)
     {
       fs = fifo_segment_get_segment (&vcm->segment_main, eqs_index);
-      s->vpp_evt_q =
-	fifo_segment_msg_q_attach (fs, mq_offset, rxf->shr->slice_index);
+      s->vpp_evt_q = fifo_segment_msg_q_attach (fs, mq_offset, mq_index);
     }
 
   clib_rwlock_reader_unlock (&vcm->segment_table_lock);
@@ -453,8 +488,11 @@ vcl_session_detach_fifos (vcl_session_t *s)
   fifo_segment_free_client_fifo (fs, s->tx_fifo);
   if (s->ct_rx_fifo)
     {
-      fs = fifo_segment_get_segment (&vcm->segment_main,
-				     s->ct_rx_fifo->segment_index);
+      fs = fifo_segment_get_segment_if_valid (&vcm->segment_main,
+					      s->ct_rx_fifo->segment_index);
+      if (!fs)
+	goto done;
+
       fifo_segment_free_client_fifo (fs, s->ct_rx_fifo);
       fifo_segment_free_client_fifo (fs, s->ct_tx_fifo);
     }
@@ -510,6 +548,172 @@ vcl_segment_discover_mqs (uword segment_handle, int *fds, u32 n_fds)
   return 0;
 }
 
+svm_fifo_chunk_t *
+vcl_segment_alloc_chunk (uword segment_handle, u32 slice_index, u32 size,
+			 uword *offset)
+{
+  svm_fifo_chunk_t *c;
+  fifo_segment_t *fs;
+  u32 fs_index;
+
+  fs_index = vcl_segment_table_lookup (segment_handle);
+  if (fs_index == VCL_INVALID_SEGMENT_INDEX)
+    {
+      VDBG (0, "ERROR: mq segment %lx for is not attached!", segment_handle);
+      return 0;
+    }
+
+  clib_rwlock_reader_lock (&vcm->segment_table_lock);
+
+  fs = fifo_segment_get_segment (&vcm->segment_main, fs_index);
+  c = fifo_segment_alloc_chunk_w_slice (fs, slice_index, size);
+  *offset = fifo_segment_chunk_offset (fs, c);
+
+  clib_rwlock_reader_unlock (&vcm->segment_table_lock);
+
+  return c;
+}
+
+int
+vcl_session_share_fifos (vcl_session_t *s, svm_fifo_t *rxf, svm_fifo_t *txf)
+{
+  vcl_worker_t *wrk = vcl_worker_get_current ();
+  fifo_segment_t *fs;
+
+  clib_rwlock_reader_lock (&vcm->segment_table_lock);
+
+  fs = fifo_segment_get_segment (&vcm->segment_main, rxf->segment_index);
+  s->rx_fifo = fifo_segment_duplicate_fifo (fs, rxf);
+  s->tx_fifo = fifo_segment_duplicate_fifo (fs, txf);
+
+  clib_rwlock_reader_unlock (&vcm->segment_table_lock);
+
+  svm_fifo_add_subscriber (s->rx_fifo, wrk->vpp_wrk_index);
+  svm_fifo_add_subscriber (s->tx_fifo, wrk->vpp_wrk_index);
+
+  return 0;
+}
+
+const char *
+vcl_session_state_str (vcl_session_state_t state)
+{
+  char *st;
+
+  switch (state)
+    {
+    case VCL_STATE_CLOSED:
+      st = "STATE_CLOSED";
+      break;
+    case VCL_STATE_LISTEN:
+      st = "STATE_LISTEN";
+      break;
+    case VCL_STATE_READY:
+      st = "STATE_READY";
+      break;
+    case VCL_STATE_VPP_CLOSING:
+      st = "STATE_VPP_CLOSING";
+      break;
+    case VCL_STATE_DISCONNECT:
+      st = "STATE_DISCONNECT";
+      break;
+    case VCL_STATE_DETACHED:
+      st = "STATE_DETACHED";
+      break;
+    case VCL_STATE_UPDATED:
+      st = "STATE_UPDATED";
+      break;
+    case VCL_STATE_LISTEN_NO_MQ:
+      st = "STATE_LISTEN_NO_MQ";
+      break;
+    default:
+      st = "UNKNOWN_STATE";
+      break;
+    }
+
+  return st;
+}
+
+u8 *
+vcl_format_ip4_address (u8 *s, va_list *args)
+{
+  u8 *a = va_arg (*args, u8 *);
+  return format (s, "%d.%d.%d.%d", a[0], a[1], a[2], a[3]);
+}
+
+u8 *
+vcl_format_ip6_address (u8 *s, va_list *args)
+{
+  ip6_address_t *a = va_arg (*args, ip6_address_t *);
+  u32 i, i_max_n_zero, max_n_zeros, i_first_zero, n_zeros, last_double_colon;
+
+  i_max_n_zero = ARRAY_LEN (a->as_u16);
+  max_n_zeros = 0;
+  i_first_zero = i_max_n_zero;
+  n_zeros = 0;
+  for (i = 0; i < ARRAY_LEN (a->as_u16); i++)
+    {
+      u32 is_zero = a->as_u16[i] == 0;
+      if (is_zero && i_first_zero >= ARRAY_LEN (a->as_u16))
+	{
+	  i_first_zero = i;
+	  n_zeros = 0;
+	}
+      n_zeros += is_zero;
+      if ((!is_zero && n_zeros > max_n_zeros) ||
+	  (i + 1 >= ARRAY_LEN (a->as_u16) && n_zeros > max_n_zeros))
+	{
+	  i_max_n_zero = i_first_zero;
+	  max_n_zeros = n_zeros;
+	  i_first_zero = ARRAY_LEN (a->as_u16);
+	  n_zeros = 0;
+	}
+    }
+
+  last_double_colon = 0;
+  for (i = 0; i < ARRAY_LEN (a->as_u16); i++)
+    {
+      if (i == i_max_n_zero && max_n_zeros > 1)
+	{
+	  s = format (s, "::");
+	  i += max_n_zeros - 1;
+	  last_double_colon = 1;
+	}
+      else
+	{
+	  s = format (s, "%s%x", (last_double_colon || i == 0) ? "" : ":",
+		      clib_net_to_host_u16 (a->as_u16[i]));
+	  last_double_colon = 0;
+	}
+    }
+
+  return s;
+}
+
+/* Format an IP46 address. */
+u8 *
+vcl_format_ip46_address (u8 *s, va_list *args)
+{
+  ip46_address_t *ip46 = va_arg (*args, ip46_address_t *);
+  ip46_type_t type = va_arg (*args, ip46_type_t);
+  int is_ip4 = 1;
+
+  switch (type)
+    {
+    case IP46_TYPE_ANY:
+      is_ip4 = ip46_address_is_ip4 (ip46);
+      break;
+    case IP46_TYPE_IP4:
+      is_ip4 = 1;
+      break;
+    case IP46_TYPE_IP6:
+      is_ip4 = 0;
+      break;
+    }
+
+  return is_ip4 ? format (s, "%U", vcl_format_ip4_address, &ip46->ip4) :
+		  format (s, "%U", vcl_format_ip6_address, &ip46->ip6);
+}
+
 /*
  * fd.io coding-style-patch-verification: ON
  *