src/vnet/crypto/crypto.c

   1 /*
   2  * Copyright (c) 2018 Cisco and/or its affiliates.
   3  * Licensed under the Apache License, Version 2.0 (the "License");
   4  * you may not use this file except in compliance with the License.
   5  * You may obtain a copy of the License at:
   6  *
   7  *     http://www.apache.org/licenses/LICENSE-2.0
   8  *
   9  * Unless required by applicable law or agreed to in writing, software
  10  * distributed under the License is distributed on an "AS IS" BASIS,
  11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12  * See the License for the specific language governing permissions and
  13  * limitations under the License.
  14  */
  15
  16 #include <stdbool.h>
  17 #include <vlib/vlib.h>
  18 #include <vnet/crypto/crypto.h>
  19
  20 vnet_crypto_main_t crypto_main;
  21
  22 static_always_inline void
  23 crypto_set_op_status (vnet_crypto_op_t * ops[], u32 n_ops, int status)
  24 {
  25   while (n_ops--)
  26     {
  27       ops[0]->status = status;
  28       ops++;
  29     }
  30 }
  31
  32 static_always_inline u32
  33 vnet_crypto_process_ops_call_handler (vlib_main_t * vm,
  34                                       vnet_crypto_main_t * cm,
  35                                       vnet_crypto_op_id_t opt,
  36                                       vnet_crypto_op_t * ops[],
  37                                       vnet_crypto_op_chunk_t * chunks,
  38                                       u32 n_ops)
  39 {
  40   u32 rv = 0;
  41   if (n_ops == 0)
  42     return 0;
  43
  44   if (chunks)
  45     {
  46
  47       if (cm->chained_ops_handlers[opt] == 0)
  48         crypto_set_op_status (ops, n_ops,
  49                               VNET_CRYPTO_OP_STATUS_FAIL_NO_HANDLER);
  50       else
  51         rv = (cm->chained_ops_handlers[opt]) (vm, ops, chunks, n_ops);
  52     }
  53   else
  54     {
  55       if (cm->ops_handlers[opt] == 0)
  56         crypto_set_op_status (ops, n_ops,
  57                               VNET_CRYPTO_OP_STATUS_FAIL_NO_HANDLER);
  58       else
  59         rv = (cm->ops_handlers[opt]) (vm, ops, n_ops);
  60     }
  61   return rv;
  62 }
  63
  64 static_always_inline u32
  65 vnet_crypto_process_ops_inline (vlib_main_t * vm, vnet_crypto_op_t ops[],
  66                                 vnet_crypto_op_chunk_t * chunks, u32 n_ops)
  67 {
  68   vnet_crypto_main_t *cm = &crypto_main;
  69   const int op_q_size = VLIB_FRAME_SIZE;
  70   vnet_crypto_op_t *op_queue[op_q_size];
  71   vnet_crypto_op_id_t opt, current_op_type = ~0;
  72   u32 n_op_queue = 0;
  73   u32 rv = 0, i;
  74
  75   ASSERT (n_ops >= 1);
  76
  77   for (i = 0; i < n_ops; i++)
  78     {
  79       opt = ops[i].op;
  80
  81       if (current_op_type != opt || n_op_queue >= op_q_size)
  82         {
  83           rv += vnet_crypto_process_ops_call_handler (vm, cm, current_op_type,
  84                                                       op_queue, chunks,
  85                                                       n_op_queue);
  86           n_op_queue = 0;
  87           current_op_type = opt;
  88         }
  89
  90       op_queue[n_op_queue++] = &ops[i];
  91     }
  92
  93   rv += vnet_crypto_process_ops_call_handler (vm, cm, current_op_type,
  94                                               op_queue, chunks, n_op_queue);
  95   return rv;
  96 }
  97
  98 u32
  99 vnet_crypto_process_ops (vlib_main_t * vm, vnet_crypto_op_t ops[], u32 n_ops)
 100 {
 101   return vnet_crypto_process_ops_inline (vm, ops, 0, n_ops);
 102 }
 103
 104 u32
 105 vnet_crypto_process_chained_ops (vlib_main_t * vm, vnet_crypto_op_t ops[],
 106                                  vnet_crypto_op_chunk_t * chunks, u32 n_ops)
 107 {
 108   return vnet_crypto_process_ops_inline (vm, ops, chunks, n_ops);
 109 }
 110
 111 u32
 112 vnet_crypto_register_engine (vlib_main_t * vm, char *name, int prio,
 113                              char *desc)
 114 {
 115   vnet_crypto_main_t *cm = &crypto_main;
 116   vnet_crypto_engine_t *p;
 117
 118   vec_add2 (cm->engines, p, 1);
 119   p->name = name;
 120   p->desc = desc;
 121   p->priority = prio;
 122
 123   hash_set_mem (cm->engine_index_by_name, p->name, p - cm->engines);
 124
 125   return p - cm->engines;
 126 }
 127
 128 static_always_inline void
 129 crypto_set_active_engine (vnet_crypto_op_data_t * od,
 130                           vnet_crypto_op_id_t id, u32 ei,
 131                           crypto_op_class_type_t oct)
 132 {
 133   vnet_crypto_main_t *cm = &crypto_main;
 134   vnet_crypto_engine_t *ce = vec_elt_at_index (cm->engines, ei);
 135
 136   if (oct == CRYPTO_OP_BOTH || oct == CRYPTO_OP_CHAINED)
 137     {
 138       if (ce->chained_ops_handlers[id])
 139         {
 140           od->active_engine_index_chained = ei;
 141           cm->chained_ops_handlers[id] = ce->chained_ops_handlers[id];
 142         }
 143     }
 144
 145   if (oct == CRYPTO_OP_BOTH || oct == CRYPTO_OP_SIMPLE)
 146     {
 147       if (ce->ops_handlers[id])
 148         {
 149           od->active_engine_index_simple = ei;
 150           cm->ops_handlers[id] = ce->ops_handlers[id];
 151         }
 152     }
 153 }
 154
 155 int
 156 vnet_crypto_set_handler2 (char *alg_name, char *engine,
 157                           crypto_op_class_type_t oct)
 158 {
 159   uword *p;
 160   vnet_crypto_main_t *cm = &crypto_main;
 161   vnet_crypto_alg_data_t *ad;
 162   int i;
 163
 164   p = hash_get_mem (cm->alg_index_by_name, alg_name);
 165   if (!p)
 166     return -1;
 167
 168   ad = vec_elt_at_index (cm->algs, p[0]);
 169
 170   p = hash_get_mem (cm->engine_index_by_name, engine);
 171   if (!p)
 172     return -1;
 173
 174   for (i = 0; i < VNET_CRYPTO_OP_N_TYPES; i++)
 175     {
 176       vnet_crypto_op_data_t *od;
 177       vnet_crypto_op_id_t id = ad->op_by_type[i];
 178       if (id == 0)
 179         continue;
 180
 181       od = cm->opt_data + id;
 182       crypto_set_active_engine (od, id, p[0], oct);
 183     }
 184
 185   return 0;
 186 }
 187
 188 int
 189 vnet_crypto_is_set_handler (vnet_crypto_alg_t alg)
 190 {
 191   vnet_crypto_main_t *cm = &crypto_main;
 192   vnet_crypto_op_id_t opt = 0;
 193   int i;
 194
 195   if (alg > vec_len (cm->algs))
 196     return 0;
 197
 198   for (i = 0; i < VNET_CRYPTO_OP_N_TYPES; i++)
 199     if ((opt = cm->algs[alg].op_by_type[i]) != 0)
 200       break;
 201
 202   return NULL != cm->ops_handlers[opt];
 203 }
 204
 205 void
 206 vnet_crypto_register_ops_handler_inline (vlib_main_t * vm, u32 engine_index,
 207                                          vnet_crypto_op_id_t opt,
 208                                          vnet_crypto_ops_handler_t * fn,
 209                                          vnet_crypto_chained_ops_handler_t *
 210                                          cfn)
 211 {
 212   vnet_crypto_main_t *cm = &crypto_main;
 213   vnet_crypto_engine_t *ae, *e = vec_elt_at_index (cm->engines, engine_index);
 214   vnet_crypto_op_data_t *otd = cm->opt_data + opt;
 215   vec_validate_aligned (cm->ops_handlers, VNET_CRYPTO_N_OP_IDS - 1,
 216                         CLIB_CACHE_LINE_BYTES);
 217   vec_validate_aligned (cm->chained_ops_handlers, VNET_CRYPTO_N_OP_IDS - 1,
 218                         CLIB_CACHE_LINE_BYTES);
 219
 220   if (fn)
 221     {
 222       e->ops_handlers[opt] = fn;
 223       if (otd->active_engine_index_simple == ~0)
 224         {
 225           otd->active_engine_index_simple = engine_index;
 226           cm->ops_handlers[opt] = fn;
 227         }
 228
 229       ae = vec_elt_at_index (cm->engines, otd->active_engine_index_simple);
 230       if (ae->priority < e->priority)
 231         crypto_set_active_engine (otd, opt, engine_index, CRYPTO_OP_SIMPLE);
 232     }
 233
 234   if (cfn)
 235     {
 236       e->chained_ops_handlers[opt] = cfn;
 237       if (otd->active_engine_index_chained == ~0)
 238         {
 239           otd->active_engine_index_chained = engine_index;
 240           cm->chained_ops_handlers[opt] = cfn;
 241         }
 242
 243       ae = vec_elt_at_index (cm->engines, otd->active_engine_index_chained);
 244       if (ae->priority < e->priority)
 245         crypto_set_active_engine (otd, opt, engine_index, CRYPTO_OP_CHAINED);
 246     }
 247
 248   return;
 249 }
 250
 251 void
 252 vnet_crypto_register_ops_handler (vlib_main_t * vm, u32 engine_index,
 253                                   vnet_crypto_op_id_t opt,
 254                                   vnet_crypto_ops_handler_t * fn)
 255 {
 256   vnet_crypto_register_ops_handler_inline (vm, engine_index, opt, fn, 0);
 257 }
 258
 259 void
 260 vnet_crypto_register_chained_ops_handler (vlib_main_t * vm, u32 engine_index,
 261                                           vnet_crypto_op_id_t opt,
 262                                           vnet_crypto_chained_ops_handler_t *
 263                                           fn)
 264 {
 265   vnet_crypto_register_ops_handler_inline (vm, engine_index, opt, 0, fn);
 266 }
 267
 268 void
 269 vnet_crypto_register_ops_handlers (vlib_main_t * vm, u32 engine_index,
 270                                    vnet_crypto_op_id_t opt,
 271                                    vnet_crypto_ops_handler_t * fn,
 272                                    vnet_crypto_chained_ops_handler_t * cfn)
 273 {
 274   vnet_crypto_register_ops_handler_inline (vm, engine_index, opt, fn, cfn);
 275 }
 276
 277 void
 278 vnet_crypto_register_enqueue_handler (vlib_main_t *vm, u32 engine_index,
 279                                       vnet_crypto_async_op_id_t opt,
 280                                       vnet_crypto_frame_enqueue_t *enqueue_hdl)
 281 {
 282   vnet_crypto_main_t *cm = &crypto_main;
 283   vnet_crypto_engine_t *ae, *e = vec_elt_at_index (cm->engines, engine_index);
 284   vnet_crypto_async_op_data_t *otd = cm->async_opt_data + opt;
 285   vec_validate_aligned (cm->enqueue_handlers, VNET_CRYPTO_ASYNC_OP_N_IDS,
 286                         CLIB_CACHE_LINE_BYTES);
 287   vec_validate_aligned (cm->dequeue_handlers, VNET_CRYPTO_ASYNC_OP_N_IDS,
 288                         CLIB_CACHE_LINE_BYTES);
 289
 290   if (!enqueue_hdl)
 291     return;
 292
 293   e->enqueue_handlers[opt] = enqueue_hdl;
 294   if (otd->active_engine_index_async == ~0)
 295     {
 296       otd->active_engine_index_async = engine_index;
 297       cm->enqueue_handlers[opt] = enqueue_hdl;
 298     }
 299
 300   ae = vec_elt_at_index (cm->engines, otd->active_engine_index_async);
 301   if (ae->priority <= e->priority)
 302     {
 303       otd->active_engine_index_async = engine_index;
 304       cm->enqueue_handlers[opt] = enqueue_hdl;
 305     }
 306
 307   return;
 308 }
 309
 310 static int
 311 engine_index_cmp (void *v1, void *v2)
 312 {
 313   u32 *a1 = v1;
 314   u32 *a2 = v2;
 315
 316   if (*a1 > *a2)
 317     return 1;
 318   if (*a1 < *a2)
 319     return -1;
 320   return 0;
 321 }
 322
 323 static void
 324 vnet_crypto_update_cm_dequeue_handlers (void)
 325 {
 326   vnet_crypto_main_t *cm = &crypto_main;
 327   vnet_crypto_async_op_data_t *otd;
 328   vnet_crypto_engine_t *e;
 329   u32 *active_engines = 0, *ei, last_ei = ~0, i;
 330
 331   vec_reset_length (cm->dequeue_handlers);
 332
 333   for (i = 0; i < VNET_CRYPTO_ASYNC_OP_N_IDS; i++)
 334     {
 335       otd = cm->async_opt_data + i;
 336       if (otd->active_engine_index_async == ~0)
 337         continue;
 338       e = cm->engines + otd->active_engine_index_async;
 339       if (!e->dequeue_handler)
 340         continue;
 341       vec_add1 (active_engines, otd->active_engine_index_async);
 342     }
 343
 344   vec_sort_with_function (active_engines, engine_index_cmp);
 345
 346   vec_foreach (ei, active_engines)
 347     {
 348       if (ei[0] == last_ei)
 349         continue;
 350       if (ei[0] == ~0)
 351         continue;
 352
 353       e = cm->engines + ei[0];
 354       vec_add1 (cm->dequeue_handlers, e->dequeue_handler);
 355       last_ei = ei[0];
 356     }
 357
 358   vec_free (active_engines);
 359 }
 360
 361 void
 362 vnet_crypto_register_dequeue_handler (vlib_main_t *vm, u32 engine_index,
 363                                       vnet_crypto_frame_dequeue_t *deq_fn)
 364 {
 365   vnet_crypto_main_t *cm = &crypto_main;
 366   vnet_crypto_engine_t *e = vec_elt_at_index (cm->engines, engine_index);
 367
 368   if (!deq_fn)
 369     return;
 370
 371   e->dequeue_handler = deq_fn;
 372
 373   return;
 374 }
 375
 376 void
 377 vnet_crypto_register_key_handler (vlib_main_t * vm, u32 engine_index,
 378                                   vnet_crypto_key_handler_t * key_handler)
 379 {
 380   vnet_crypto_main_t *cm = &crypto_main;
 381   vnet_crypto_engine_t *e = vec_elt_at_index (cm->engines, engine_index);
 382   e->key_op_handler = key_handler;
 383   return;
 384 }
 385
 386 static int
 387 vnet_crypto_key_len_check (vnet_crypto_alg_t alg, u16 length)
 388 {
 389   switch (alg)
 390     {
 391     case VNET_CRYPTO_N_ALGS:
 392       return 0;
 393     case VNET_CRYPTO_ALG_NONE:
 394       return 1;
 395
 396 #define _(n, s, l) \
 397       case VNET_CRYPTO_ALG_##n: \
 398         if ((l) == length) \
 399           return 1;        \
 400         break;
 401       foreach_crypto_cipher_alg foreach_crypto_aead_alg
 402 #undef _
 403         /* HMAC allows any key length */
 404 #define _(n, s) \
 405       case VNET_CRYPTO_ALG_HMAC_##n: \
 406         return 1;
 407         foreach_crypto_hmac_alg
 408 #undef _
 409
 410 #define _(n, s)                                                               \
 411   case VNET_CRYPTO_ALG_HASH_##n:                                              \
 412     return 1;
 413           foreach_crypto_hash_alg
 414 #undef _
 415     }
 416
 417   return 0;
 418 }
 419
 420 u32
 421 vnet_crypto_key_add (vlib_main_t * vm, vnet_crypto_alg_t alg, u8 * data,
 422                      u16 length)
 423 {
 424   u32 index;
 425   vnet_crypto_main_t *cm = &crypto_main;
 426   vnet_crypto_engine_t *engine;
 427   vnet_crypto_key_t *key;
 428
 429   u8 need_barrier_sync = 0;
 430
 431   if (!vnet_crypto_key_len_check (alg, length))
 432     return ~0;
 433
 434   pool_get_aligned_will_expand (cm->keys, need_barrier_sync,
 435                                 CLIB_CACHE_LINE_BYTES);
 436   /* If the cm->keys will expand, stop the parade. */
 437   if (need_barrier_sync)
 438     vlib_worker_thread_barrier_sync (vm);
 439
 440   pool_get_zero (cm->keys, key);
 441
 442   if (need_barrier_sync)
 443     vlib_worker_thread_barrier_release (vm);
 444
 445   index = key - cm->keys;
 446   key->type = VNET_CRYPTO_KEY_TYPE_DATA;
 447   key->alg = alg;
 448   vec_validate_aligned (key->data, length - 1, CLIB_CACHE_LINE_BYTES);
 449   clib_memcpy (key->data, data, length);
 450   /* *INDENT-OFF* */
 451   vec_foreach (engine, cm->engines)
 452     if (engine->key_op_handler)
 453       engine->key_op_handler (vm, VNET_CRYPTO_KEY_OP_ADD, index);
 454   /* *INDENT-ON* */
 455   return index;
 456 }
 457
 458 void
 459 vnet_crypto_key_del (vlib_main_t * vm, vnet_crypto_key_index_t index)
 460 {
 461   vnet_crypto_main_t *cm = &crypto_main;
 462   vnet_crypto_engine_t *engine;
 463   vnet_crypto_key_t *key = pool_elt_at_index (cm->keys, index);
 464
 465   /* *INDENT-OFF* */
 466   vec_foreach (engine, cm->engines)
 467     if (engine->key_op_handler)
 468       engine->key_op_handler (vm, VNET_CRYPTO_KEY_OP_DEL, index);
 469   /* *INDENT-ON* */
 470
 471   if (key->type == VNET_CRYPTO_KEY_TYPE_DATA)
 472     {
 473       clib_memset (key->data, 0, vec_len (key->data));
 474       vec_free (key->data);
 475     }
 476   else if (key->type == VNET_CRYPTO_KEY_TYPE_LINK)
 477     {
 478       key->index_crypto = key->index_integ = 0;
 479     }
 480
 481   pool_put (cm->keys, key);
 482 }
 483
 484 vnet_crypto_async_alg_t
 485 vnet_crypto_link_algs (vnet_crypto_alg_t crypto_alg,
 486                        vnet_crypto_alg_t integ_alg)
 487 {
 488 #define _(c, h, s, k ,d) \
 489   if (crypto_alg == VNET_CRYPTO_ALG_##c && \
 490       integ_alg == VNET_CRYPTO_ALG_HMAC_##h) \
 491     return VNET_CRYPTO_ALG_##c##_##h##_TAG##d;
 492   foreach_crypto_link_async_alg
 493 #undef _
 494     return ~0;
 495 }
 496
 497 u32
 498 vnet_crypto_key_add_linked (vlib_main_t * vm,
 499                             vnet_crypto_key_index_t index_crypto,
 500                             vnet_crypto_key_index_t index_integ)
 501 {
 502   u32 index;
 503   vnet_crypto_main_t *cm = &crypto_main;
 504   vnet_crypto_engine_t *engine;
 505   vnet_crypto_key_t *key_crypto, *key_integ, *key;
 506   vnet_crypto_async_alg_t linked_alg;
 507
 508   key_crypto = pool_elt_at_index (cm->keys, index_crypto);
 509   key_integ = pool_elt_at_index (cm->keys, index_integ);
 510
 511   linked_alg = vnet_crypto_link_algs (key_crypto->alg, key_integ->alg);
 512   if (linked_alg == ~0)
 513     return ~0;
 514
 515   pool_get_zero (cm->keys, key);
 516   index = key - cm->keys;
 517   key->type = VNET_CRYPTO_KEY_TYPE_LINK;
 518   key->index_crypto = index_crypto;
 519   key->index_integ = index_integ;
 520   key->async_alg = linked_alg;
 521
 522   /* *INDENT-OFF* */
 523   vec_foreach (engine, cm->engines)
 524     if (engine->key_op_handler)
 525       engine->key_op_handler (vm, VNET_CRYPTO_KEY_OP_ADD, index);
 526   /* *INDENT-ON* */
 527
 528   return index;
 529 }
 530
 531 clib_error_t *
 532 crypto_dispatch_enable_disable (int is_enable)
 533 {
 534   vnet_crypto_main_t *cm = &crypto_main;
 535   vlib_thread_main_t *tm = vlib_get_thread_main ();
 536   u32 skip_master = vlib_num_workers () > 0, i;
 537   vlib_node_state_t state = VLIB_NODE_STATE_DISABLED;
 538   u8 state_change = 0;
 539
 540   CLIB_MEMORY_STORE_BARRIER ();
 541   if (is_enable && cm->async_refcnt > 0)
 542     {
 543       state_change = 1;
 544       state =
 545         cm->dispatch_mode ==
 546         VNET_CRYPTO_ASYNC_DISPATCH_POLLING ? VLIB_NODE_STATE_POLLING :
 547         VLIB_NODE_STATE_INTERRUPT;
 548     }
 549
 550   if (!is_enable && cm->async_refcnt == 0)
 551     {
 552       state_change = 1;
 553       state = VLIB_NODE_STATE_DISABLED;
 554     }
 555
 556   if (state_change)
 557     for (i = skip_master; i < tm->n_vlib_mains; i++)
 558       {
 559         vlib_main_t *ovm = vlib_get_main_by_index (i);
 560         if (state != vlib_node_get_state (ovm, cm->crypto_node_index))
 561           vlib_node_set_state (ovm, cm->crypto_node_index, state);
 562       }
 563   return 0;
 564 }
 565
 566 static_always_inline void
 567 crypto_set_active_async_engine (vnet_crypto_async_op_data_t * od,
 568                                 vnet_crypto_async_op_id_t id, u32 ei)
 569 {
 570   vnet_crypto_main_t *cm = &crypto_main;
 571   vnet_crypto_engine_t *ce = vec_elt_at_index (cm->engines, ei);
 572
 573   if (ce->enqueue_handlers[id] && ce->dequeue_handler)
 574     {
 575       od->active_engine_index_async = ei;
 576       cm->enqueue_handlers[id] = ce->enqueue_handlers[id];
 577       cm->dequeue_handlers[id] = ce->dequeue_handler;
 578     }
 579 }
 580
 581 int
 582 vnet_crypto_set_async_handler2 (char *alg_name, char *engine)
 583 {
 584   uword *p;
 585   vnet_crypto_main_t *cm = &crypto_main;
 586   vnet_crypto_async_alg_data_t *ad;
 587   int i;
 588
 589   if (cm->async_refcnt)
 590     return -EBUSY;
 591
 592   p = hash_get_mem (cm->async_alg_index_by_name, alg_name);
 593   if (!p)
 594     return -1;
 595
 596   ad = vec_elt_at_index (cm->async_algs, p[0]);
 597
 598   p = hash_get_mem (cm->engine_index_by_name, engine);
 599   if (!p)
 600     return -1;
 601
 602   for (i = 0; i < VNET_CRYPTO_ASYNC_OP_N_TYPES; i++)
 603     {
 604       vnet_crypto_async_op_data_t *od;
 605       vnet_crypto_async_op_id_t id = ad->op_by_type[i];
 606       if (id == 0)
 607         continue;
 608
 609       od = cm->async_opt_data + id;
 610       crypto_set_active_async_engine (od, id, p[0]);
 611     }
 612
 613   vnet_crypto_update_cm_dequeue_handlers ();
 614
 615   return 0;
 616 }
 617
 618 u32
 619 vnet_crypto_register_post_node (vlib_main_t * vm, char *post_node_name)
 620 {
 621   vnet_crypto_main_t *cm = &crypto_main;
 622   vnet_crypto_async_next_node_t *nn = 0;
 623   vlib_node_t *cc, *pn;
 624   uword index = vec_len (cm->next_nodes);
 625
 626   pn = vlib_get_node_by_name (vm, (u8 *) post_node_name);
 627   if (!pn)
 628     return ~0;
 629
 630   /* *INDENT-OFF* */
 631   vec_foreach (cm->next_nodes, nn)
 632   {
 633     if (nn->node_idx == pn->index)
 634       return nn->next_idx;
 635   }
 636   /* *INDENT-ON* */
 637
 638   vec_validate (cm->next_nodes, index);
 639   nn = vec_elt_at_index (cm->next_nodes, index);
 640
 641   cc = vlib_get_node_by_name (vm, (u8 *) "crypto-dispatch");
 642   nn->next_idx = vlib_node_add_named_next (vm, cc->index, post_node_name);
 643   nn->node_idx = pn->index;
 644
 645   return nn->next_idx;
 646 }
 647
 648 void
 649 vnet_crypto_request_async_mode (int is_enable)
 650 {
 651   vnet_crypto_main_t *cm = &crypto_main;
 652   vlib_thread_main_t *tm = vlib_get_thread_main ();
 653   u32 skip_master = vlib_num_workers () > 0, i;
 654   vlib_node_state_t state = VLIB_NODE_STATE_DISABLED;
 655   u8 state_change = 0;
 656
 657   CLIB_MEMORY_STORE_BARRIER ();
 658   if (is_enable && cm->async_refcnt == 0)
 659     {
 660       state_change = 1;
 661       state =
 662         cm->dispatch_mode == VNET_CRYPTO_ASYNC_DISPATCH_POLLING ?
 663         VLIB_NODE_STATE_POLLING : VLIB_NODE_STATE_INTERRUPT;
 664     }
 665   if (!is_enable && cm->async_refcnt == 1)
 666     {
 667       state_change = 1;
 668       state = VLIB_NODE_STATE_DISABLED;
 669     }
 670
 671   if (state_change)
 672     {
 673
 674       for (i = skip_master; i < tm->n_vlib_mains; i++)
 675         {
 676           vlib_main_t *ovm = vlib_get_main_by_index (i);
 677           if (state != vlib_node_get_state (ovm, cm->crypto_node_index))
 678             vlib_node_set_state (ovm, cm->crypto_node_index, state);
 679         }
 680
 681       if (is_enable)
 682         vnet_crypto_update_cm_dequeue_handlers ();
 683     }
 684
 685   if (is_enable)
 686     cm->async_refcnt += 1;
 687   else if (cm->async_refcnt > 0)
 688     cm->async_refcnt -= 1;
 689 }
 690
 691 void
 692 vnet_crypto_set_async_dispatch_mode (u8 mode)
 693 {
 694   vnet_crypto_main_t *cm = &crypto_main;
 695   u32 skip_master = vlib_num_workers () > 0, i;
 696   vlib_thread_main_t *tm = vlib_get_thread_main ();
 697   vlib_node_state_t state = VLIB_NODE_STATE_DISABLED;
 698
 699   CLIB_MEMORY_STORE_BARRIER ();
 700   cm->dispatch_mode = mode;
 701   if (mode == VNET_CRYPTO_ASYNC_DISPATCH_INTERRUPT)
 702     {
 703       state =
 704         cm->async_refcnt == 0 ?
 705         VLIB_NODE_STATE_DISABLED : VLIB_NODE_STATE_INTERRUPT;
 706     }
 707   else if (mode == VNET_CRYPTO_ASYNC_DISPATCH_POLLING)
 708     {
 709       state =
 710         cm->async_refcnt == 0 ?
 711         VLIB_NODE_STATE_DISABLED : VLIB_NODE_STATE_POLLING;
 712     }
 713
 714   for (i = skip_master; i < tm->n_vlib_mains; i++)
 715     {
 716       vlib_main_t *ovm = vlib_get_main_by_index (i);
 717       if (state != vlib_node_get_state (ovm, cm->crypto_node_index))
 718         vlib_node_set_state (ovm, cm->crypto_node_index, state);
 719     }
 720 }
 721
 722 int
 723 vnet_crypto_is_set_async_handler (vnet_crypto_async_op_id_t op)
 724 {
 725   vnet_crypto_main_t *cm = &crypto_main;
 726
 727   return (op < vec_len (cm->enqueue_handlers) &&
 728           NULL != cm->enqueue_handlers[op]);
 729 }
 730
 731 static void
 732 vnet_crypto_init_cipher_data (vnet_crypto_alg_t alg, vnet_crypto_op_id_t eid,
 733                               vnet_crypto_op_id_t did, char *name, u8 is_aead)
 734 {
 735   vnet_crypto_op_type_t eopt, dopt;
 736   vnet_crypto_main_t *cm = &crypto_main;
 737
 738   cm->algs[alg].name = name;
 739   cm->opt_data[eid].alg = cm->opt_data[did].alg = alg;
 740   cm->opt_data[eid].active_engine_index_simple = ~0;
 741   cm->opt_data[did].active_engine_index_simple = ~0;
 742   cm->opt_data[eid].active_engine_index_chained = ~0;
 743   cm->opt_data[did].active_engine_index_chained = ~0;
 744   if (is_aead)
 745     {
 746       eopt = VNET_CRYPTO_OP_TYPE_AEAD_ENCRYPT;
 747       dopt = VNET_CRYPTO_OP_TYPE_AEAD_DECRYPT;
 748     }
 749   else
 750     {
 751       eopt = VNET_CRYPTO_OP_TYPE_ENCRYPT;
 752       dopt = VNET_CRYPTO_OP_TYPE_DECRYPT;
 753     }
 754   cm->opt_data[eid].type = eopt;
 755   cm->opt_data[did].type = dopt;
 756   cm->algs[alg].op_by_type[eopt] = eid;
 757   cm->algs[alg].op_by_type[dopt] = did;
 758   hash_set_mem (cm->alg_index_by_name, name, alg);
 759 }
 760
 761 static void
 762 vnet_crypto_init_hash_data (vnet_crypto_alg_t alg, vnet_crypto_op_id_t id,
 763                             char *name)
 764 {
 765   vnet_crypto_main_t *cm = &crypto_main;
 766   cm->algs[alg].name = name;
 767   cm->algs[alg].op_by_type[VNET_CRYPTO_OP_TYPE_HASH] = id;
 768   cm->opt_data[id].alg = alg;
 769   cm->opt_data[id].active_engine_index_simple = ~0;
 770   cm->opt_data[id].active_engine_index_chained = ~0;
 771   cm->opt_data[id].type = VNET_CRYPTO_OP_TYPE_HASH;
 772   hash_set_mem (cm->alg_index_by_name, name, alg);
 773 }
 774
 775 static void
 776 vnet_crypto_init_hmac_data (vnet_crypto_alg_t alg,
 777                             vnet_crypto_op_id_t id, char *name)
 778 {
 779   vnet_crypto_main_t *cm = &crypto_main;
 780   cm->algs[alg].name = name;
 781   cm->algs[alg].op_by_type[VNET_CRYPTO_OP_TYPE_HMAC] = id;
 782   cm->opt_data[id].alg = alg;
 783   cm->opt_data[id].active_engine_index_simple = ~0;
 784   cm->opt_data[id].active_engine_index_chained = ~0;
 785   cm->opt_data[id].type = VNET_CRYPTO_OP_TYPE_HMAC;
 786   hash_set_mem (cm->alg_index_by_name, name, alg);
 787 }
 788
 789 static void
 790 vnet_crypto_init_async_data (vnet_crypto_async_alg_t alg,
 791                              vnet_crypto_async_op_id_t eid,
 792                              vnet_crypto_async_op_id_t did, char *name)
 793 {
 794   vnet_crypto_main_t *cm = &crypto_main;
 795
 796   cm->async_algs[alg].name = name;
 797   cm->async_algs[alg].op_by_type[VNET_CRYPTO_ASYNC_OP_TYPE_ENCRYPT] = eid;
 798   cm->async_algs[alg].op_by_type[VNET_CRYPTO_ASYNC_OP_TYPE_DECRYPT] = did;
 799   cm->async_opt_data[eid].type = VNET_CRYPTO_ASYNC_OP_TYPE_ENCRYPT;
 800   cm->async_opt_data[eid].alg = alg;
 801   cm->async_opt_data[eid].active_engine_index_async = ~0;
 802   cm->async_opt_data[eid].active_engine_index_async = ~0;
 803   cm->async_opt_data[did].type = VNET_CRYPTO_ASYNC_OP_TYPE_DECRYPT;
 804   cm->async_opt_data[did].alg = alg;
 805   cm->async_opt_data[did].active_engine_index_async = ~0;
 806   cm->async_opt_data[did].active_engine_index_async = ~0;
 807   hash_set_mem (cm->async_alg_index_by_name, name, alg);
 808 }
 809
 810 clib_error_t *
 811 vnet_crypto_init (vlib_main_t * vm)
 812 {
 813   vnet_crypto_main_t *cm = &crypto_main;
 814   vlib_thread_main_t *tm = vlib_get_thread_main ();
 815   vnet_crypto_thread_t *ct = 0;
 816
 817   cm->dispatch_mode = VNET_CRYPTO_ASYNC_DISPATCH_POLLING;
 818   cm->engine_index_by_name = hash_create_string ( /* size */ 0,
 819                                                  sizeof (uword));
 820   cm->alg_index_by_name = hash_create_string (0, sizeof (uword));
 821   cm->async_alg_index_by_name = hash_create_string (0, sizeof (uword));
 822   vec_validate_aligned (cm->threads, tm->n_vlib_mains, CLIB_CACHE_LINE_BYTES);
 823   vec_foreach (ct, cm->threads)
 824     pool_alloc_aligned (ct->frame_pool, VNET_CRYPTO_FRAME_POOL_SIZE,
 825                         CLIB_CACHE_LINE_BYTES);
 826   vec_validate (cm->algs, VNET_CRYPTO_N_ALGS);
 827   vec_validate (cm->async_algs, VNET_CRYPTO_N_ASYNC_ALGS);
 828
 829 #define _(n, s, l) \
 830   vnet_crypto_init_cipher_data (VNET_CRYPTO_ALG_##n, \
 831                                 VNET_CRYPTO_OP_##n##_ENC, \
 832                                 VNET_CRYPTO_OP_##n##_DEC, s, 0);
 833   foreach_crypto_cipher_alg;
 834 #undef _
 835 #define _(n, s, l) \
 836   vnet_crypto_init_cipher_data (VNET_CRYPTO_ALG_##n, \
 837                                 VNET_CRYPTO_OP_##n##_ENC, \
 838                                 VNET_CRYPTO_OP_##n##_DEC, s, 1);
 839   foreach_crypto_aead_alg;
 840 #undef _
 841 #define _(n, s) \
 842   vnet_crypto_init_hmac_data (VNET_CRYPTO_ALG_HMAC_##n, \
 843                               VNET_CRYPTO_OP_##n##_HMAC, "hmac-" s);
 844   foreach_crypto_hmac_alg;
 845 #undef _
 846 #define _(n, s)                                                               \
 847   vnet_crypto_init_hash_data (VNET_CRYPTO_ALG_HASH_##n,                       \
 848                               VNET_CRYPTO_OP_##n##_HASH, s);
 849   foreach_crypto_hash_alg;
 850 #undef _
 851 #define _(n, s, k, t, a) \
 852   vnet_crypto_init_async_data (VNET_CRYPTO_ALG_##n##_TAG##t##_AAD##a, \
 853                                VNET_CRYPTO_OP_##n##_TAG##t##_AAD##a##_ENC, \
 854                                VNET_CRYPTO_OP_##n##_TAG##t##_AAD##a##_DEC, \
 855                                s);
 856   foreach_crypto_aead_async_alg
 857 #undef _
 858 #define _(c, h, s, k ,d) \
 859   vnet_crypto_init_async_data (VNET_CRYPTO_ALG_##c##_##h##_TAG##d, \
 860                                VNET_CRYPTO_OP_##c##_##h##_TAG##d##_ENC, \
 861                                VNET_CRYPTO_OP_##c##_##h##_TAG##d##_DEC, \
 862                                s);
 863     foreach_crypto_link_async_alg
 864 #undef _
 865     cm->crypto_node_index =
 866     vlib_get_node_by_name (vm, (u8 *) "crypto-dispatch")->index;
 867
 868   return 0;
 869 }
 870
 871 VLIB_INIT_FUNCTION (vnet_crypto_init);
 872
 873 /*
 874  * fd.io coding-style-patch-verification: ON
 875  *
 876  * Local Variables:
 877  * eval: (c-set-style "gnu")
 878  * End:
 879  */