optimize init_server to reduce session overhead

[vpp.git] / src / vnet / tls / tls.c

diff --git a/src/vnet/tls/tls.c b/src/vnet/tls/tls.c
index d4c40f7..4b12248 100644 (file)
--- a/src/vnet/tls/tls.c
+++ b/src/vnet/tls/tls.c
@@ -41,63 +41,15 @@ tls_get_available_engine (void)
 int
 tls_add_vpp_q_evt (svm_fifo_t * f, u8 evt_type)
 {
-  session_fifo_event_t evt;
-  svm_queue_t *q;
-
   if (svm_fifo_set_event (f))
-    {
-      evt.fifo = f;
-      evt.event_type = evt_type;
-
-      q = session_manager_get_vpp_event_queue (f->master_thread_index);
-      if (PREDICT_TRUE (q->cursize < q->maxsize))
-       {
-         svm_queue_add (q, (u8 *) & evt, 0 /* do wait for mutex */ );
-       }
-      else
-       {
-         clib_warning ("vpp's evt q full");
-         return -1;
-       }
-    }
+    session_send_io_evt_to_thread (f, evt_type);
   return 0;
 }
 
 static inline int
 tls_add_app_q_evt (application_t * app, stream_session_t * app_session)
 {
-  session_fifo_event_t evt;
-  svm_queue_t *q;
-
-  if (PREDICT_FALSE (app_session->session_state == SESSION_STATE_CLOSED))
-    {
-      /* Session is closed so app will never clean up. Flush rx fifo */
-      u32 to_dequeue = svm_fifo_max_dequeue (app_session->server_rx_fifo);
-      if (to_dequeue)
-       svm_fifo_dequeue_drop (app_session->server_rx_fifo, to_dequeue);
-      return 0;
-    }
-
-  if (app->cb_fns.builtin_app_rx_callback)
-    return app->cb_fns.builtin_app_rx_callback (app_session);
-
-  if (svm_fifo_set_event (app_session->server_rx_fifo))
-    {
-      evt.fifo = app_session->server_rx_fifo;
-      evt.event_type = FIFO_EVENT_APP_RX;
-      q = app->event_queue;
-
-      if (PREDICT_TRUE (q->cursize < q->maxsize))
-       {
-         svm_queue_add (q, (u8 *) & evt, 0 /* do wait for mutex */ );
-       }
-      else
-       {
-         clib_warning ("app evt q full");
-         return -1;
-       }
-    }
-  return 0;
+  return application_send_event (app, app_session, FIFO_EVENT_APP_RX);
 }
 
 u32
@@ -204,14 +156,15 @@ tls_notify_app_accept (tls_ctx_t * ctx)
 
   app = application_get (ctx->parent_app_index);
   lctx = tls_listener_ctx_get (ctx->listener_ctx_index);
-  app_listener = listen_session_get_from_handle (lctx->app_session_handle);
-  sm = application_get_listen_segment_manager (app, app_listener);
 
   app_session = session_alloc (vlib_get_thread_index ());
   app_session->app_index = ctx->parent_app_index;
   app_session->connection_index = ctx->tls_ctx_handle;
+
+  app_listener = listen_session_get_from_handle (lctx->app_session_handle);
   app_session->session_type = app_listener->session_type;
   app_session->listener_index = app_listener->session_index;
+  sm = application_get_listen_segment_manager (app, app_listener);
   if ((rv = session_alloc_fifos (sm, app_session)))
     {
       TLS_DBG (1, "failed to allocate fifos");
@@ -384,8 +337,7 @@ tls_session_accept_callback (stream_session_t * tls_session)
   tls_ctx_t *lctx, *ctx;
   u32 ctx_handle;
 
-  tls_listener = listen_session_get (tls_session->session_type,
-                                    tls_session->listener_index);
+  tls_listener = listen_session_get (tls_session->listener_index);
   lctx = tls_listener_ctx_get (tls_listener->opaque);
 
   ctx_handle = tls_ctx_alloc (lctx->tls_ctx_engine);
@@ -557,7 +509,6 @@ tls_start_listen (u32 app_listener_index, transport_endpoint_t * tep)
   stream_session_t *tls_listener;
   tls_ctx_t *lctx;
   u32 lctx_index;
-  session_type_t st;
   stream_session_t *app_listener;
   tls_engine_type_t engine_type;
 
@@ -581,8 +532,7 @@ tls_start_listen (u32 app_listener_index, transport_endpoint_t * tep)
   tls_listener = listen_session_get_from_handle (tls_handle);
   tls_listener->opaque = lctx_index;
 
-  st = session_type_from_proto_and_ip (TRANSPORT_PROTO_TLS, sep->is_ip4);
-  app_listener = listen_session_get (st, app_listener_index);
+  app_listener = listen_session_get (app_listener_index);
 
   lctx = tls_listener_ctx_get (lctx_index);
   lctx->parent_app_index = sep->app_index;
@@ -591,6 +541,8 @@ tls_start_listen (u32 app_listener_index, transport_endpoint_t * tep)
   lctx->tcp_is_ip4 = sep->is_ip4;
   lctx->tls_ctx_engine = engine_type;
 
+  tls_vfts[engine_type].ctx_start_listen (lctx);
+
   TLS_DBG (1, "Started listening %d, engine type %d", lctx_index,
           engine_type);
   return lctx_index;
@@ -602,9 +554,15 @@ tls_stop_listen (u32 lctx_index)
   tls_main_t *tm = &tls_main;
   application_t *tls_app;
   tls_ctx_t *lctx;
+  tls_engine_type_t engine_type;
+
   lctx = tls_listener_ctx_get (lctx_index);
   tls_app = application_get (tm->app_index);
   application_stop_listen (tls_app, lctx->tls_session_handle);
+
+  engine_type = lctx->tls_ctx_engine;
+  tls_vfts[engine_type].ctx_stop_listen (lctx);
+
   tls_listener_ctx_free (lctx);
   return 0;
 }
@@ -668,10 +626,10 @@ format_tls_listener (u8 * s, va_list * args)
 {
   u32 tc_index = va_arg (*args, u32);
   tls_ctx_t *ctx = tls_listener_ctx_get (tc_index);
-  u32 listener_index, type;
+  u32 listener_index, thread_index;
 
-  listen_session_parse_handle (ctx->tls_session_handle, &type,
-                              &listener_index);
+  listen_session_parse_handle (ctx->tls_session_handle, &listener_index,
+                              &thread_index);
   return format (s, "[TLS] listener app %u child %u", ctx->parent_app_index,
                 listener_index);
 }
@@ -709,7 +667,7 @@ tls_register_engine (const tls_engine_vft_t * vft, tls_engine_type_t type)
   tls_vfts[type] = *vft;
 }
 
-clib_error_t *
+static clib_error_t *
 tls_init (vlib_main_t * vm)
 {
   vlib_thread_main_t *vtm = vlib_get_thread_main ();
@@ -726,8 +684,9 @@ tls_init (vlib_main_t * vm)
   memset (options, 0, sizeof (options));
 
   a->session_cb_vft = &tls_app_cb_vft;
-  a->api_client_index = (1 << 24) + 1;
+  a->api_client_index = APP_INVALID_INDEX;
   a->options = options;
+  a->name = format (0, "tls");
   a->options[APP_OPTIONS_SEGMENT_SIZE] = segment_size;
   a->options[APP_OPTIONS_RX_FIFO_SIZE] = fifo_size;
   a->options[APP_OPTIONS_TX_FIFO_SIZE] = fifo_size;
@@ -753,7 +712,7 @@ tls_init (vlib_main_t * vm)
                               FIB_PROTOCOL_IP4, ~0);
   transport_register_protocol (TRANSPORT_PROTO_TLS, &tls_proto,
                               FIB_PROTOCOL_IP6, ~0);
-
+  vec_free (a->name);
   return 0;
 }