session: cleanup listener segment manager on wrk free

[vpp.git] / src / vnet / session / application_worker.c

diff --git a/src/vnet/session/application_worker.c b/src/vnet/session/application_worker.c
index c17f43e..8e3ba35 100644 (file)
--- a/src/vnet/session/application_worker.c
+++ b/src/vnet/session/application_worker.c
@@ -56,11 +56,11 @@ app_worker_free (app_worker_t * app_wrk)
 {
   application_t *app = application_get (app_wrk->app_index);
   vnet_unlisten_args_t _a, *a = &_a;
-  u64 handle, *handles = 0;
+  u64 handle, *handles = 0, *sm_indices = 0;
   segment_manager_t *sm;
   session_t *ls;
   u32 sm_index;
-  int i;
+  int i, j;
 
   /*
    *  Listener cleanup
@@ -70,19 +70,29 @@ app_worker_free (app_worker_t * app_wrk)
   hash_foreach (handle, sm_index, app_wrk->listeners_table, ({
     ls = listen_session_get_from_handle (handle);
     vec_add1 (handles, app_listen_session_handle (ls));
+    vec_add1 (sm_indices, sm_index);
     sm = segment_manager_get (sm_index);
-    sm->app_wrk_index = SEGMENT_MANAGER_INVALID_APP_INDEX;
   }));
   /* *INDENT-ON* */
 
   for (i = 0; i < vec_len (handles); i++)
     {
+      /* Cleanup listener */
       a->app_index = app->app_index;
       a->wrk_map_index = app_wrk->wrk_map_index;
       a->handle = handles[i];
-      /* seg manager is removed when unbind completes */
       (void) vnet_unlisten (a);
+
+      sm = segment_manager_get_if_valid (sm_indices[i]);
+      if (sm && !segment_manager_app_detached (sm))
+       {
+         sm->first_is_protected = 0;
+         segment_manager_init_free (sm);
+       }
     }
+  vec_reset_length (handles);
+  vec_free (sm_indices);
+  hash_free (app_wrk->listeners_table);
 
   /*
    * Connects segment manager cleanup
@@ -96,11 +106,36 @@ app_worker_free (app_worker_t * app_wrk)
       segment_manager_init_free (sm);
     }
 
-  /* If first segment manager is used by a listener */
-  if (app_wrk->first_segment_manager != APP_INVALID_SEGMENT_MANAGER_INDEX
-      && app_wrk->first_segment_manager != app_wrk->connects_seg_manager)
+  /*
+   * Half-open cleanup
+   */
+
+  for (i = 0; i < vec_len (app_wrk->half_open_table); i++)
+    {
+      if (!app_wrk->half_open_table[i])
+       continue;
+
+      /* *INDENT-OFF* */
+      hash_foreach (handle, sm_index, app_wrk->half_open_table[i], ({
+       vec_add1 (handles, handle);
+      }));
+      /* *INDENT-ON* */
+
+      for (j = 0; j < vec_len (handles); j++)
+       session_cleanup_half_open (i, handles[j]);
+
+      hash_free (app_wrk->half_open_table[i]);
+      vec_reset_length (handles);
+    }
+
+  vec_free (app_wrk->half_open_table);
+  vec_free (handles);
+
+  /* If first segment manager is used by a listener that recently
+   * stopped listening, mark it as detached */
+  if (app_wrk->first_segment_manager != app_wrk->connects_seg_manager
+      && (sm = segment_manager_get_if_valid (app_wrk->first_segment_manager)))
     {
-      sm = segment_manager_get (app_wrk->first_segment_manager);
       sm->first_is_protected = 0;
       sm->app_wrk_index = SEGMENT_MANAGER_INVALID_APP_INDEX;
       /* .. and has no fifos, e.g. it might be used for redirected sessions,
@@ -230,24 +265,22 @@ app_worker_stop_listen_session (app_worker_t * app_wrk, session_t * ls)
   if (PREDICT_FALSE (!sm_indexp))
     return;
 
-  /* Dealloc fifos first, if any, to avoid cleanup attempt lower */
+  /* Dealloc fifos, if any (dgram listeners) */
   if (ls->rx_fifo)
     {
       segment_manager_dealloc_fifos (ls->rx_fifo, ls->tx_fifo);
       ls->tx_fifo = ls->rx_fifo = 0;
     }
 
+  /* Try to cleanup segment manager */
   sm = segment_manager_get (*sm_indexp);
-  if (app_wrk->first_segment_manager == *sm_indexp)
+  if (sm && app_wrk->first_segment_manager != *sm_indexp)
     {
-      /* Delete sessions but don't remove segment manager */
-      app_wrk->first_segment_manager_in_use = 0;
-      segment_manager_del_sessions (sm);
-    }
-  else
-    {
-      segment_manager_init_free (sm);
+      segment_manager_app_detach (sm);
+      if (!segment_manager_has_fifos (sm))
+       segment_manager_free (sm);
     }
+
   hash_unset (app_wrk->listeners_table, handle);
 }
 
@@ -336,6 +369,40 @@ app_worker_connect_notify (app_worker_t * app_wrk, session_t * s,
                                                 s, err);
 }
 
+int
+app_worker_add_half_open (app_worker_t * app_wrk, transport_proto_t tp,
+                         session_handle_t ho_handle,
+                         session_handle_t wrk_handle)
+{
+  ASSERT (vlib_get_thread_index () == 0);
+  vec_validate (app_wrk->half_open_table, tp);
+  hash_set (app_wrk->half_open_table[tp], ho_handle, wrk_handle);
+  return 0;
+}
+
+int
+app_worker_del_half_open (app_worker_t * app_wrk, transport_proto_t tp,
+                         session_handle_t ho_handle)
+{
+  ASSERT (vlib_get_thread_index () == 0);
+  hash_unset (app_wrk->half_open_table[tp], ho_handle);
+  return 0;
+}
+
+u64
+app_worker_lookup_half_open (app_worker_t * app_wrk, transport_proto_t tp,
+                            session_handle_t ho_handle)
+{
+  u64 *ho_wrk_handlep;
+
+  /* No locking because all updates are done from main thread */
+  ho_wrk_handlep = hash_get (app_wrk->half_open_table[tp], ho_handle);
+  if (!ho_wrk_handlep)
+    return SESSION_INVALID_HANDLE;
+
+  return *ho_wrk_handlep;
+}
+
 int
 app_worker_close_notify (app_worker_t * app_wrk, session_t * s)
 {
@@ -699,10 +766,11 @@ format_app_worker_listener (u8 * s, va_list * args)
 
   if (verbose)
     {
-      char buf[32];
-      sprintf (buf, "%u(%u)", app_wrk->wrk_map_index, app_wrk->wrk_index);
-      s = format (s, "%-40s%-25s%=10s%-15u%-15u%-10u", str, app_name,
+      u8 *buf;
+      buf = format (0, "%u(%u)", app_wrk->wrk_map_index, app_wrk->wrk_index);
+      s = format (s, "%-40s%-25s%=10v%-15u%-15u%-10u", str, app_name,
                  buf, app_wrk->api_client_index, handle, sm_index);
+      vec_free (buf);
     }
   else
     s = format (s, "%-40s%-25s%=10u", str, app_name, app_wrk->wrk_map_index);