Add a polling configure to make thread bind with hardware engine

[vpp.git] / src / plugins / tlsopenssl / tls_async.c

diff --git a/src/plugins/tlsopenssl/tls_async.c b/src/plugins/tlsopenssl/tls_async.c
index aec1d7d..a05996b 100644 (file)
--- a/src/plugins/tlsopenssl/tls_async.c
+++ b/src/plugins/tlsopenssl/tls_async.c
@@ -62,6 +62,7 @@ typedef struct openssl_async_
   openssl_evt_t ***evt_pool;
   openssl_async_status_t *status;
   void (*polling) (void);
+  void (*polling_conf) (void);
   u8 start_polling;
   ENGINE *engine;
 
@@ -69,6 +70,7 @@ typedef struct openssl_async_
 
 void qat_polling ();
 void qat_pre_init ();
+void qat_polling_config ();
 void dasync_polling ();
 
 struct engine_polling
@@ -76,11 +78,12 @@ struct engine_polling
   char *engine;
   void (*polling) (void);
   void (*pre_init) (void);
+  void (*polling_conf) (void);
 };
 
 struct engine_polling engine_list[] = {
-  {"qat", qat_polling, qat_pre_init},
-  {"dasync", dasync_polling, NULL}
+  {"qat", qat_polling, qat_pre_init, qat_polling_config},
+  {"dasync", dasync_polling, NULL, NULL}
 };
 
 openssl_async_t openssl_async_main;
@@ -99,7 +102,7 @@ evt_pool_init (vlib_main_t * vm)
 
   num_threads = 1 /* main thread */  + vtm->n_threads;
 
-  TLS_DBG ("Totally there is %d thread\n", num_threads);
+  TLS_DBG (2, "Totally there is %d thread\n", num_threads);
 
   vec_validate (om->evt_pool, num_threads - 1);
   vec_validate (om->status, num_threads - 1);
@@ -115,7 +118,6 @@ evt_pool_init (vlib_main_t * vm)
     }
   om->polling = NULL;
 
-  TLS_DBG ("Node disabled\n");
   openssl_async_node_enable_disable (0);
 
   return;
@@ -134,6 +136,7 @@ openssl_engine_register (char *engine_name, char *algorithm)
       if (!strcmp (engine_list[i].engine, engine_name))
        {
          om->polling = engine_list[i].polling;
+         om->polling_conf = engine_list[i].polling_conf;
 
          registered = i;
        }
@@ -253,7 +256,7 @@ openssl_async_run (void *evt)
   int *evt_run_tail = &om->status[thread_index].evt_run_tail;
   int *evt_run_head = &om->status[thread_index].evt_run_head;
 
-  TLS_DBG ("Set event %d to run\n", event_index);
+  TLS_DBG (2, "Set event %d to run\n", event_index);
 
   event = openssl_evt_get_w_thread (event_index, thread_index);
 
@@ -271,7 +274,9 @@ openssl_async_run (void *evt)
     }
   *evt_run_tail = event_index;
   if (*evt_run_head < 0)
-    *evt_run_head = event_index;
+    {
+      *evt_run_head = event_index;
+    }
 
   return 1;
 }
@@ -303,10 +308,33 @@ vpp_add_async_pending_event (tls_ctx_t * ctx,
   event->next = *evt_pending_head;
   *evt_pending_head = eidx;
 
-
   return &event->engine_callback;
 }
 
+int
+vpp_add_async_run_event (tls_ctx_t * ctx, openssl_resume_handler * handler)
+{
+  u32 eidx;
+  openssl_evt_t *event;
+  openssl_ctx_t *oc = (openssl_ctx_t *) ctx;
+  u32 thread_id = ctx->c_thread_index;
+
+  eidx = openssl_evt_alloc ();
+  event = openssl_evt_get (eidx);
+
+  event->ctx_index = oc->openssl_ctx_index;
+  event->status = SSL_ASYNC_PENDING;
+  event->handler = handler;
+  event->cb_args.event_index = eidx;
+  event->cb_args.thread_index = thread_id;
+  event->engine_callback.callback = openssl_async_run;
+  event->engine_callback.arg = &event->cb_args;
+
+  /* This is a retry event, and need to put to ring to make it run again */
+  return openssl_async_run (&event->cb_args);
+
+}
+
 void
 event_handler (void *tls_async)
 {
@@ -325,7 +353,6 @@ event_handler (void *tls_async)
 
   if (handler)
     {
-      TLS_DBG ("relaunch...\n");
       (*handler) (ctx, tls_session);
     }
 
@@ -349,7 +376,7 @@ dasync_polling ()
   evt_pending = &om->status[thread_index].evt_pending_head;
   while (*evt_pending >= 0)
     {
-      TLS_DBG ("polling... current head = %d\n", *evt_pending);
+      TLS_DBG (2, "polling... current head = %d\n", *evt_pending);
       event = openssl_evt_get_w_thread (*evt_pending, thread_index);
       *evt_pending = event->next;
       if (event->status == SSL_ASYNC_PENDING)
@@ -378,14 +405,14 @@ qat_polling_config ()
   int *config;
 
   config = &om->status[thread_index].poll_config;
-  if (*config)
+  if (PREDICT_TRUE (*config))
     return;
 
   ENGINE_ctrl_cmd (om->engine, "SET_INSTANCE_FOR_THREAD", thread_index,
                   NULL, NULL, 0);
   *config = 1;
 
-  TLS_DBG ("set thread %d and instance %d mapping\n", thread_index,
+  TLS_DBG (2, "set thread %d and instance %d mapping\n", thread_index,
           thread_index);
 
 }
@@ -394,14 +421,11 @@ void
 qat_polling ()
 {
   openssl_async_t *om = &openssl_async_main;
-  int ret;
+  int poll_status = 0;
 
   if (om->start_polling)
     {
-      qat_polling_config ();
-#define QAT_CMD_POLL (ENGINE_CMD_BASE + 1)
-      ENGINE_ctrl (om->engine, QAT_CMD_POLL, 0, &ret, NULL);
-      ;
+      ENGINE_ctrl_cmd (om->engine, "POLL", 0, &poll_status, NULL, 0);
     }
 }
 
@@ -462,7 +486,7 @@ tls_resume_from_crypto (int thread_index)
       if (*evt_run_head >= 0)
        {
          event = openssl_evt_get_w_thread (*evt_run_head, thread_index);
-         TLS_DBG ("event run = %d\n", *evt_run_head);
+         TLS_DBG (2, "event run = %d\n", *evt_run_head);
          tls_async_do_job (*evt_run_head, thread_index);
 
          *evt_run_head = event->next;
@@ -481,8 +505,6 @@ tls_resume_from_crypto (int thread_index)
 static clib_error_t *
 tls_async_init (vlib_main_t * vm)
 {
-
-  TLS_DBG ("Start to call tls_async_init\n");
   evt_pool_init (vm);
   return 0;
 
@@ -493,11 +515,16 @@ tls_async_process (vlib_main_t * vm, vlib_node_runtime_t * rt,
                   vlib_frame_t * f)
 {
   u8 thread_index;
+  openssl_async_t *om = &openssl_async_main;
 
+  if (om->polling_conf)
+    (*om->polling_conf) ();
   thread_index = vlib_get_thread_index ();
-  openssl_async_polling ();
-
-  tls_resume_from_crypto (thread_index);
+  if (pool_elts (om->evt_pool[thread_index]) > 0)
+    {
+      openssl_async_polling ();
+      tls_resume_from_crypto (thread_index);
+    }
 
   return 0;
 }