X-Git-Url: https://gerrit.fd.io/r/gitweb?a=blobdiff_plain;f=src%2Fvnet%2Fsession%2Fsegment_manager.c;h=9e6a1b55cbbd36f80ed8e86ef253dd236f98781b;hb=ecf844cbaecd6cd3a69fd5b7c747dce616a86de8;hp=c23e4c0237cc1070936c1a9c7ddc65525e3e8063;hpb=91f3e744a37b9f6f3c87ac45e54142f16fd2d3d5;p=vpp.git

diff --git a/src/vnet/session/segment_manager.c b/src/vnet/session/segment_manager.c
index c23e4c0237c..9e6a1b55cbb 100644
--- a/src/vnet/session/segment_manager.c
+++ b/src/vnet/session/segment_manager.c
@@ -27,6 +27,11 @@ u32 segment_name_counter = 0;
  */
 segment_manager_t *segment_managers = 0;
 
+/*
+ * Pool of segment manager properties
+ */
+static segment_manager_properties_t *segment_manager_properties_pool;
+
 /**
  * Process private segment index
  */
@@ -38,6 +43,36 @@ u32 *private_segment_indices;
 u32 default_fifo_size = 1 << 16;
 u32 default_segment_size = 1 << 20;
 
+segment_manager_properties_t *
+segment_manager_properties_alloc (void)
+{
+  segment_manager_properties_t *props;
+  pool_get (segment_manager_properties_pool, props);
+  memset (props, 0, sizeof (*props));
+  return props;
+}
+
+void
+segment_manager_properties_free (segment_manager_properties_t * props)
+{
+  pool_put (segment_manager_properties_pool, props);
+  memset (props, 0xFB, sizeof (*props));
+}
+
+segment_manager_properties_t *
+segment_manager_properties_get (u32 smp_index)
+{
+  if (pool_is_free_index (segment_manager_properties_pool, smp_index))
+    return 0;
+  return pool_elt_at_index (segment_manager_properties_pool, smp_index);
+}
+
+u32
+segment_manager_properties_index (segment_manager_properties_t * p)
+{
+  return p - segment_manager_properties_pool;
+}
+
 void
 segment_manager_get_segment_info (u32 index, u8 ** name, u32 * size)
 {
@@ -52,17 +87,18 @@ session_manager_add_segment_i (segment_manager_t * sm, u32 segment_size,
 			       u8 * segment_name)
 {
   svm_fifo_segment_create_args_t _ca, *ca = &_ca;
+  segment_manager_properties_t *props;
   int rv;
 
   memset (ca, 0, sizeof (*ca));
-
-  if (!sm->properties->use_private_segment)
+  props = segment_manager_properties_get (sm->properties_index);
+  if (!props->use_private_segment)
     {
       ca->segment_name = (char *) segment_name;
       ca->segment_size = segment_size;
-      ca->rx_fifo_size = sm->properties->rx_fifo_size;
-      ca->tx_fifo_size = sm->properties->tx_fifo_size;
-      ca->preallocated_fifo_pairs = sm->properties->preallocated_fifo_pairs;
+      ca->rx_fifo_size = props->rx_fifo_size;
+      ca->tx_fifo_size = props->tx_fifo_size;
+      ca->preallocated_fifo_pairs = props->preallocated_fifo_pairs;
 
       rv = svm_fifo_segment_create (ca);
       if (rv)
@@ -80,16 +116,11 @@ session_manager_add_segment_i (segment_manager_t * sm, u32 segment_size,
       u64 approx_total_size;
 
       ca->segment_name = "process-private-segment";
-      ca->segment_size = ~0;
-      ca->rx_fifo_size = sm->properties->rx_fifo_size;
-      ca->tx_fifo_size = sm->properties->tx_fifo_size;
-      ca->preallocated_fifo_pairs = sm->properties->preallocated_fifo_pairs;
-      ca->private_segment_count = sm->properties->private_segment_count;
-      ca->private_segment_size = sm->properties->private_segment_size;
-
-      /* Default to a small private segment */
-      if (ca->private_segment_size == 0)
-	ca->private_segment_size = 128 << 20;
+      ca->segment_size = segment_size;
+      ca->rx_fifo_size = props->rx_fifo_size;
+      ca->tx_fifo_size = props->tx_fifo_size;
+      ca->preallocated_fifo_pairs = props->preallocated_fifo_pairs;
+      ca->private_segment_count = props->private_segment_count;
 
       /* Calculate space requirements */
       rx_rounded_data_size = (1 << (max_log2 (ca->rx_fifo_size)));
@@ -100,9 +131,8 @@ session_manager_add_segment_i (segment_manager_t * sm, u32 segment_size,
 
       approx_total_size = (u64) ca->preallocated_fifo_pairs
 	* (rx_fifo_size + tx_fifo_size);
-      approx_segment_count =
-	(approx_total_size +
-	 (ca->private_segment_size - 1)) / (u64) ca->private_segment_size;
+      approx_segment_count = (approx_total_size + (ca->segment_size - 1))
+	/ (u64) ca->segment_size;
 
       /* The user asked us to figure it out... */
       if (ca->private_segment_count == 0)
@@ -112,9 +142,8 @@ session_manager_add_segment_i (segment_manager_t * sm, u32 segment_size,
       /* Follow directions, but issue a warning */
       else if (approx_segment_count != ca->private_segment_count)
 	{
-	  clib_warning
-	    ("Honoring segment count %u, but calculated count was %u",
-	     ca->private_segment_count, approx_segment_count);
+	  clib_warning ("Honoring segment count %u, calculated count was %u",
+			ca->private_segment_count, approx_segment_count);
 	}
 
       if (svm_fifo_segment_create_process_private (ca))
@@ -130,15 +159,17 @@ session_manager_add_segment_i (segment_manager_t * sm, u32 segment_size,
 int
 session_manager_add_segment (segment_manager_t * sm)
 {
-  u8 *segment_name;
   svm_fifo_segment_create_args_t _ca, *ca = &_ca;
+  segment_manager_properties_t *props;
   u32 add_segment_size;
+  u8 *segment_name;
   int rv;
 
   memset (ca, 0, sizeof (*ca));
+  props = segment_manager_properties_get (sm->properties_index);
   segment_name = format (0, "%d-%d%c", getpid (), segment_name_counter++, 0);
-  add_segment_size = sm->properties->add_segment_size ?
-    sm->properties->add_segment_size : default_segment_size;
+  add_segment_size = props->add_segment_size ?
+    props->add_segment_size : default_segment_size;
 
   rv = session_manager_add_segment_i (sm, add_segment_size, segment_name);
   vec_free (segment_name);
@@ -171,17 +202,14 @@ segment_manager_new ()
  * Returns error if svm segment allocation fails.
  */
 int
-segment_manager_init (segment_manager_t * sm,
-		      segment_manager_properties_t * properties,
+segment_manager_init (segment_manager_t * sm, u32 props_index,
 		      u32 first_seg_size)
 {
   int rv;
 
   /* app allocates these */
-  sm->properties = properties;
-
+  sm->properties_index = props_index;
   first_seg_size = first_seg_size > 0 ? first_seg_size : default_segment_size;
-
   rv = session_manager_add_first_segment (sm, first_seg_size);
   if (rv)
     {
@@ -197,27 +225,30 @@ u8
 segment_manager_has_fifos (segment_manager_t * sm)
 {
   svm_fifo_segment_private_t *segment;
-  /* Weird, but handle it */
-  if (vec_len (sm->segment_indices) == 0)
-    return 0;
-  if (vec_len (sm->segment_indices) == 1)
-    {
-      segment = svm_fifo_segment_get_segment (sm->segment_indices[0]);
-      if (svm_fifo_segment_num_fifos (segment) == 0)
-	return 0;
-    }
-  if (CLIB_DEBUG)
+  int i;
+
+  for (i = 0; i < vec_len (sm->segment_indices); i++)
     {
-      svm_fifo_segment_private_t *segment;
-      int i;
-      for (i = 1; i < vec_len (sm->segment_indices); i++)
-	{
-	  segment = svm_fifo_segment_get_segment (sm->segment_indices[i]);
-	  if (!svm_fifo_segment_has_fifos (segment))
-	    clib_warning ("segment has no fifos!");
-	}
+      segment = svm_fifo_segment_get_segment (sm->segment_indices[i]);
+      if (CLIB_DEBUG && i && !svm_fifo_segment_has_fifos (segment)
+	  && !(segment->h->flags & FIFO_SEGMENT_F_IS_PREALLOCATED))
+	clib_warning ("segment %d has no fifos!", sm->segment_indices[i]);
+      if (svm_fifo_segment_has_fifos (segment))
+	return 1;
     }
-  return 1;
+  return 0;
+}
+
+static u8
+segment_manager_app_detached (segment_manager_t * sm)
+{
+  return (sm->app_index == SEGMENT_MANAGER_INVALID_APP_INDEX);
+}
+
+void
+segment_manager_app_detach (segment_manager_t * sm)
+{
+  sm->app_index = SEGMENT_MANAGER_INVALID_APP_INDEX;
 }
 
 static void
@@ -228,6 +259,13 @@ segment_manager_del_segment (segment_manager_t * sm, u32 segment_index)
   clib_spinlock_lock (&sm->lockp);
   svm_segment_index = sm->segment_indices[segment_index];
   fifo_segment = svm_fifo_segment_get_segment (svm_segment_index);
+  if (!fifo_segment
+      || ((fifo_segment->h->flags & FIFO_SEGMENT_F_IS_PREALLOCATED)
+	  && !segment_manager_app_detached (sm)))
+    {
+      clib_spinlock_unlock (&sm->lockp);
+      return;
+    }
   svm_fifo_segment_delete (fifo_segment);
   vec_del1 (sm->segment_indices, segment_index);
   clib_spinlock_unlock (&sm->lockp);
@@ -263,13 +301,13 @@ segment_manager_del_sessions (segment_manager_t * sm)
 
 	  session_index = fifo->master_session_index;
 	  thread_index = fifo->master_thread_index;
-	  session = stream_session_get (session_index, thread_index);
+	  session = session_get (session_index, thread_index);
 
 	  /* Instead of directly removing the session call disconnect */
 	  if (session->session_state != SESSION_STATE_CLOSED)
 	    {
 	      session->session_state = SESSION_STATE_CLOSED;
-	      session_send_session_evt_to_thread (stream_session_handle
+	      session_send_session_evt_to_thread (session_handle
 						  (session),
 						  FIFO_EVENT_DISCONNECT,
 						  thread_index);
@@ -288,26 +326,29 @@ segment_manager_del_sessions (segment_manager_t * sm)
  *
  * Since the fifos allocated in the segment keep backpointers to the sessions
  * prior to removing the segment, we call session disconnect. This
- * subsequently propages into transport.
+ * subsequently propagates into transport.
  */
 void
 segment_manager_del (segment_manager_t * sm)
 {
+  int i;
 
-  ASSERT (vec_len (sm->segment_indices) <= 1);
-  if (vec_len (sm->segment_indices))
+  ASSERT (!segment_manager_has_fifos (sm)
+	  && segment_manager_app_detached (sm));
+
+  /* If we have empty preallocated segments that haven't been removed, remove
+   * them now. Apart from that, the first segment in the first segment manager
+   * is not removed when all fifos are removed. It can only be removed when
+   * the manager is explicitly deleted/detached by the app. */
+  for (i = vec_len (sm->segment_indices) - 1; i >= 0; i--)
     {
-      /* The first segment in the first segment manager is not removed when
-       * all fifos are removed. It can only be removed when the manager is
-       * explicitly deleted/detached by the app. */
       if (CLIB_DEBUG)
 	{
-	  svm_fifo_segment_private_t *fifo_segment;
-	  fifo_segment =
-	    svm_fifo_segment_get_segment (sm->segment_indices[0]);
-	  ASSERT (!svm_fifo_segment_has_fifos (fifo_segment));
+	  svm_fifo_segment_private_t *segment;
+	  segment = svm_fifo_segment_get_segment (sm->segment_indices[i]);
+	  ASSERT (!svm_fifo_segment_has_fifos (segment));
 	}
-      segment_manager_del_segment (sm, 0);
+      segment_manager_del_segment (sm, i);
     }
   clib_spinlock_free (&sm->lockp);
   if (CLIB_DEBUG)
@@ -318,12 +359,12 @@ segment_manager_del (segment_manager_t * sm)
 void
 segment_manager_init_del (segment_manager_t * sm)
 {
+  segment_manager_app_detach (sm);
   if (segment_manager_has_fifos (sm))
     segment_manager_del_sessions (sm);
   else
     {
-      ASSERT (!sm->first_is_protected
-	      || sm->app_index == SEGMENT_MANAGER_INVALID_APP_INDEX);
+      ASSERT (!sm->first_is_protected || segment_manager_app_detached (sm));
       segment_manager_del (sm);
     }
 }
@@ -335,6 +376,7 @@ segment_manager_alloc_session_fifos (segment_manager_t * sm,
 				     u32 * fifo_segment_index)
 {
   svm_fifo_segment_private_t *fifo_segment;
+  segment_manager_properties_t *props;
   u32 fifo_size, sm_index;
   u8 added_a_segment = 0;
   int i;
@@ -346,19 +388,20 @@ segment_manager_alloc_session_fifos (segment_manager_t * sm,
   clib_spinlock_lock (&sm->lockp);
 
   /* Allocate svm fifos */
+  props = segment_manager_properties_get (sm->properties_index);
 again:
   for (i = 0; i < vec_len (sm->segment_indices); i++)
     {
       *fifo_segment_index = sm->segment_indices[i];
       fifo_segment = svm_fifo_segment_get_segment (*fifo_segment_index);
 
-      fifo_size = sm->properties->rx_fifo_size;
+      fifo_size = props->rx_fifo_size;
       fifo_size = (fifo_size == 0) ? default_fifo_size : fifo_size;
       *server_rx_fifo =
 	svm_fifo_segment_alloc_fifo (fifo_segment, fifo_size,
 				     FIFO_SEGMENT_RX_FREELIST);
 
-      fifo_size = sm->properties->tx_fifo_size;
+      fifo_size = props->tx_fifo_size;
       fifo_size = (fifo_size == 0) ? default_fifo_size : fifo_size;
       *server_tx_fifo =
 	svm_fifo_segment_alloc_fifo (fifo_segment, fifo_size,
@@ -391,7 +434,7 @@ again:
   /* See if we're supposed to create another segment */
   if (*server_rx_fifo == 0)
     {
-      if (sm->properties->add_segment && !sm->properties->use_private_segment)
+      if (props->add_segment && !props->use_private_segment)
 	{
 	  if (added_a_segment)
 	    {
@@ -478,7 +521,8 @@ segment_manager_dealloc_fifos (u32 svm_segment_index, svm_fifo_t * rx_fifo,
 	}
 
       /* Remove segment manager if no sessions and detached from app */
-      if (sm->app_index == SEGMENT_MANAGER_INVALID_APP_INDEX && is_first)
+      if (segment_manager_app_detached (sm)
+	  && !segment_manager_has_fifos (sm))
 	segment_manager_del (sm);
     }
 }
@@ -573,7 +617,7 @@ segment_manager_show_fn (vlib_main_t * vm, unformat_input_t * input,
       segments = svm_fifo_segment_segments_pool ();
       vlib_cli_output (vm, "%d svm fifo segments allocated",
 		       pool_elts (segments));
-      vlib_cli_output (vm, "%-20s%=12s%=16s%=16s%=16s", "Name",
+      vlib_cli_output (vm, "%-25s%15s%16s%16s%16s", "Name",
 		       "HeapSize (M)", "ActiveFifos", "FreeFifos", "Address");
 
       /* *INDENT-OFF* */
@@ -596,7 +640,7 @@ segment_manager_show_fn (vlib_main_t * vm, unformat_input_t * input,
 	  }
 	active_fifos = svm_fifo_segment_num_fifos (seg);
         free_fifos = svm_fifo_segment_num_free_fifos (seg, ~0 /* size */);
-	vlib_cli_output (vm, "%-20v%=16llu%=16u%=16u%16llx",
+	vlib_cli_output (vm, "%-25v%15llu%16u%16u%16llx",
                          name, size >> 20ULL, active_fifos, free_fifos,
 			 address);
         if (verbose)
@@ -611,7 +655,7 @@ segment_manager_show_fn (vlib_main_t * vm, unformat_input_t * input,
   return 0;
 }
 
-		          /* *INDENT-OFF* */
+/* *INDENT-OFF* */
 VLIB_CLI_COMMAND (segment_manager_show_command, static) =
 {
   .path = "show segment-manager",