crypto: fixed vnet_crypto_is_set_handler()

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

diff --git a/src/vnet/crypto/crypto.c b/src/vnet/crypto/crypto.c
index 288e227..e52e68e 100644 (file)
--- a/src/vnet/crypto/crypto.c
+++ b/src/vnet/crypto/crypto.c
@@ -189,8 +189,17 @@ int
 vnet_crypto_is_set_handler (vnet_crypto_alg_t alg)
 {
   vnet_crypto_main_t *cm = &crypto_main;
+  vnet_crypto_op_id_t opt = 0;
+  int i;
+
+  if (alg > vec_len (cm->algs))
+    return 0;
+
+  for (i = 0; i < VNET_CRYPTO_OP_N_TYPES; i++)
+    if ((opt = cm->algs[alg].op_by_type[i]) != 0)
+      break;
 
-  return (alg < vec_len (cm->ops_handlers) && NULL != cm->ops_handlers[alg]);
+  return NULL != cm->ops_handlers[opt];
 }
 
 void
@@ -446,18 +455,20 @@ vnet_crypto_key_add_linked (vlib_main_t * vm,
 clib_error_t *
 crypto_dispatch_enable_disable (int is_enable)
 {
-  vlib_main_t *vm = vlib_get_main ();
-  vlib_thread_main_t *tm = vlib_get_thread_main ();
-  vlib_node_t *node = vlib_get_node_by_name (vm, (u8 *) "crypto-dispatch");
   vnet_crypto_main_t *cm = &crypto_main;
+  vlib_thread_main_t *tm = vlib_get_thread_main ();
   u32 skip_master = vlib_num_workers () > 0, i;
-  u32 state_change = 0;
-  vlib_node_state_t state;
+  vlib_node_state_t state = VLIB_NODE_STATE_DISABLED;
+  u8 state_change = 0;
 
+  CLIB_MEMORY_STORE_BARRIER ();
   if (is_enable && cm->async_refcnt > 0)
     {
       state_change = 1;
-      state = VLIB_NODE_STATE_POLLING;
+      state =
+       cm->dispatch_mode ==
+       VNET_CRYPTO_ASYNC_DISPATCH_POLLING ? VLIB_NODE_STATE_POLLING :
+       VLIB_NODE_STATE_INTERRUPT;
     }
 
   if (!is_enable && cm->async_refcnt == 0)
@@ -468,8 +479,11 @@ crypto_dispatch_enable_disable (int is_enable)
 
   if (state_change)
     for (i = skip_master; i < tm->n_vlib_mains; i++)
-      vlib_node_set_state (vlib_mains[i], node->index, state);
-
+      {
+       if (state !=
+           vlib_node_get_state (vlib_mains[i], cm->crypto_node_index))
+         vlib_node_set_state (vlib_mains[i], cm->crypto_node_index, state);
+      }
   return 0;
 }
 
@@ -553,20 +567,20 @@ vnet_crypto_register_post_node (vlib_main_t * vm, char *post_node_name)
 void
 vnet_crypto_request_async_mode (int is_enable)
 {
-  vlib_main_t *vm = vlib_get_main ();
-  vlib_thread_main_t *tm = vlib_get_thread_main ();
-  vlib_node_t *node = vlib_get_node_by_name (vm, (u8 *) "crypto-dispatch");
   vnet_crypto_main_t *cm = &crypto_main;
+  vlib_thread_main_t *tm = vlib_get_thread_main ();
   u32 skip_master = vlib_num_workers () > 0, i;
-  u32 state_change = 0;
-  vlib_node_state_t state;
+  vlib_node_state_t state = VLIB_NODE_STATE_DISABLED;
+  u8 state_change = 0;
 
+  CLIB_MEMORY_STORE_BARRIER ();
   if (is_enable && cm->async_refcnt == 0)
     {
       state_change = 1;
-      state = VLIB_NODE_STATE_POLLING;
+      state =
+       cm->dispatch_mode == VNET_CRYPTO_ASYNC_DISPATCH_POLLING ?
+       VLIB_NODE_STATE_POLLING : VLIB_NODE_STATE_INTERRUPT;
     }
-
   if (!is_enable && cm->async_refcnt == 1)
     {
       state_change = 1;
@@ -575,7 +589,11 @@ vnet_crypto_request_async_mode (int is_enable)
 
   if (state_change)
     for (i = skip_master; i < tm->n_vlib_mains; i++)
-      vlib_node_set_state (vlib_mains[i], node->index, state);
+      {
+       if (state !=
+           vlib_node_get_state (vlib_mains[i], cm->crypto_node_index))
+         vlib_node_set_state (vlib_mains[i], cm->crypto_node_index, state);
+      }
 
   if (is_enable)
     cm->async_refcnt += 1;
@@ -583,6 +601,36 @@ vnet_crypto_request_async_mode (int is_enable)
     cm->async_refcnt -= 1;
 }
 
+void
+vnet_crypto_set_async_dispatch_mode (u8 mode)
+{
+  vnet_crypto_main_t *cm = &crypto_main;
+  u32 skip_master = vlib_num_workers () > 0, i;
+  vlib_thread_main_t *tm = vlib_get_thread_main ();
+  vlib_node_state_t state = VLIB_NODE_STATE_DISABLED;
+
+  CLIB_MEMORY_STORE_BARRIER ();
+  cm->dispatch_mode = mode;
+  if (mode == VNET_CRYPTO_ASYNC_DISPATCH_INTERRUPT)
+    {
+      state =
+       cm->async_refcnt == 0 ?
+       VLIB_NODE_STATE_DISABLED : VLIB_NODE_STATE_INTERRUPT;
+    }
+  else if (mode == VNET_CRYPTO_ASYNC_DISPATCH_POLLING)
+    {
+      state =
+       cm->async_refcnt == 0 ?
+       VLIB_NODE_STATE_DISABLED : VLIB_NODE_STATE_POLLING;
+    }
+
+  for (i = skip_master; i < tm->n_vlib_mains; i++)
+    {
+      if (state != vlib_node_get_state (vlib_mains[i], cm->crypto_node_index))
+       vlib_node_set_state (vlib_mains[i], cm->crypto_node_index, state);
+    }
+}
+
 int
 vnet_crypto_is_set_async_handler (vnet_crypto_async_op_id_t op)
 {
@@ -663,13 +711,15 @@ vnet_crypto_init (vlib_main_t * vm)
   vnet_crypto_main_t *cm = &crypto_main;
   vlib_thread_main_t *tm = vlib_get_thread_main ();
   vnet_crypto_thread_t *ct = 0;
+
+  cm->dispatch_mode = VNET_CRYPTO_ASYNC_DISPATCH_POLLING;
   cm->engine_index_by_name = hash_create_string ( /* size */ 0,
                                                 sizeof (uword));
   cm->alg_index_by_name = hash_create_string (0, sizeof (uword));
   cm->async_alg_index_by_name = hash_create_string (0, sizeof (uword));
   vec_validate_aligned (cm->threads, tm->n_vlib_mains, CLIB_CACHE_LINE_BYTES);
   vec_foreach (ct, cm->threads)
-    pool_alloc_aligned (ct->frame_pool, 256, CLIB_CACHE_LINE_BYTES);
+    pool_alloc_aligned (ct->frame_pool, 1024, CLIB_CACHE_LINE_BYTES);
   vec_validate (cm->algs, VNET_CRYPTO_N_ALGS);
   vec_validate (cm->async_algs, VNET_CRYPTO_N_ASYNC_ALGS);
   clib_bitmap_validate (cm->async_active_ids, VNET_CRYPTO_ASYNC_OP_N_IDS - 1);
@@ -705,7 +755,10 @@ vnet_crypto_init (vlib_main_t * vm)
                               s);
     foreach_crypto_link_async_alg
 #undef _
-    return 0;
+    cm->crypto_node_index =
+    vlib_get_node_by_name (vm, (u8 *) "crypto-dispatch")->index;
+
+  return 0;
 }
 
 VLIB_INIT_FUNCTION (vnet_crypto_init);