src/plugins/dpdk/cryptodev/cryptodev_raw_data_path.c

   1 /*
   2  *------------------------------------------------------------------
   3  * Copyright (c) 2020 Intel and/or its affiliates.
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at:
   7  *
   8  *     http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  *------------------------------------------------------------------
  16  */
  17
  18 #include <vlib/vlib.h>
  19 #include <vnet/plugin/plugin.h>
  20 #include <vnet/crypto/crypto.h>
  21 #include <vnet/ipsec/ipsec.h>
  22 #include <vpp/app/version.h>
  23
  24 #include <dpdk/buffer.h>
  25 #include <dpdk/device/dpdk.h>
  26 #include <dpdk/device/dpdk_priv.h>
  27 #undef always_inline
  28 #include <rte_bus_vdev.h>
  29 #include <rte_cryptodev.h>
  30 #include <rte_crypto_sym.h>
  31 #include <rte_crypto.h>
  32 #include <rte_cryptodev_pmd.h>
  33 #include <rte_config.h>
  34
  35 #include "cryptodev.h"
  36
  37 #if CLIB_DEBUG > 0
  38 #define always_inline static inline
  39 #else
  40 #define always_inline static inline __attribute__ ((__always_inline__))
  41 #endif
  42
  43 static_always_inline u64
  44 compute_ofs_linked_alg (vnet_crypto_async_frame_elt_t *fe, i16 *min_ofs,
  45                         u32 *max_end)
  46 {
  47   union rte_crypto_sym_ofs ofs;
  48   u32 crypto_end = fe->crypto_start_offset + fe->crypto_total_length;
  49   u32 integ_end =
  50     fe->integ_start_offset + fe->crypto_total_length + fe->integ_length_adj;
  51
  52   *min_ofs = clib_min (fe->crypto_start_offset, fe->integ_start_offset);
  53   *max_end = clib_max (crypto_end, integ_end);
  54
  55   ofs.ofs.cipher.head = fe->crypto_start_offset - *min_ofs;
  56   ofs.ofs.cipher.tail = *max_end - crypto_end;
  57   ofs.ofs.auth.head = fe->integ_start_offset - *min_ofs;
  58   ofs.ofs.auth.tail = *max_end - integ_end;
  59
  60   return ofs.raw;
  61 }
  62
  63 static_always_inline int
  64 cryptodev_frame_build_sgl (vlib_main_t *vm, enum rte_iova_mode iova_mode,
  65                            struct rte_crypto_vec *data_vec, u16 *n_seg,
  66                            vlib_buffer_t *b, u32 size)
  67 {
  68   struct rte_crypto_vec *vec = data_vec + 1;
  69   if (vlib_buffer_chain_linearize (vm, b) > CRYPTODEV_MAX_N_SGL)
  70     return -1;
  71
  72   while ((b->flags & VLIB_BUFFER_NEXT_PRESENT) && size)
  73     {
  74       u32 len;
  75       b = vlib_get_buffer (vm, b->next_buffer);
  76       len = clib_min (b->current_length, size);
  77       vec->base = (void *) vlib_buffer_get_current (b);
  78       if (iova_mode == RTE_IOVA_VA)
  79         vec->iova = pointer_to_uword (vec->base);
  80       else
  81         vec->iova = vlib_buffer_get_current_pa (vm, b);
  82       vec->len = len;
  83       size -= len;
  84       vec++;
  85       *n_seg += 1;
  86     }
  87
  88   if (size)
  89     return -1;
  90
  91   return 0;
  92 }
  93
  94 static_always_inline void
  95 cryptodev_reset_ctx (cryptodev_engine_thread_t *cet)
  96 {
  97   union rte_cryptodev_session_ctx sess_ctx;
  98
  99   ASSERT (cet->reset_sess != 0);
 100
 101   sess_ctx.crypto_sess = cet->reset_sess;
 102
 103   rte_cryptodev_configure_raw_dp_ctx (cet->cryptodev_id, cet->cryptodev_q,
 104                                       cet->ctx, RTE_CRYPTO_OP_WITH_SESSION,
 105                                       sess_ctx, 0);
 106 }
 107
 108 static_always_inline int
 109 cryptodev_frame_linked_algs_enqueue (vlib_main_t *vm,
 110                                      vnet_crypto_async_frame_t *frame,
 111                                      cryptodev_op_type_t op_type)
 112 {
 113   cryptodev_main_t *cmt = &cryptodev_main;
 114   cryptodev_engine_thread_t *cet = cmt->per_thread_data + vm->thread_index;
 115   vnet_crypto_async_frame_elt_t *fe;
 116   vlib_buffer_t **b;
 117   struct rte_crypto_vec vec[CRYPTODEV_MAX_N_SGL];
 118   struct rte_crypto_va_iova_ptr iv_vec, digest_vec;
 119   u32 n_elts;
 120   u32 last_key_index = ~0;
 121   i16 min_ofs;
 122   u32 max_end;
 123   u8 is_update = 0;
 124   int status;
 125
 126   n_elts = frame->n_elts;
 127
 128   if (PREDICT_FALSE (CRYPTODEV_MAX_INFLIGHT - cet->inflight < n_elts))
 129     {
 130       cryptodev_mark_frame_err_status (frame,
 131                                        VNET_CRYPTO_OP_STATUS_FAIL_ENGINE_ERR);
 132       return -1;
 133     }
 134
 135   vlib_get_buffers (vm, frame->buffer_indices, cet->b, frame->n_elts);
 136
 137   b = cet->b;
 138   fe = frame->elts;
 139
 140   while (n_elts)
 141     {
 142       union rte_crypto_sym_ofs cofs;
 143       u16 n_seg = 1;
 144
 145       if (n_elts > 2)
 146         {
 147           clib_prefetch_load (&fe[1]);
 148           clib_prefetch_load (&fe[2]);
 149           vlib_prefetch_buffer_header (b[1], LOAD);
 150           vlib_prefetch_buffer_header (b[2], LOAD);
 151         }
 152
 153       if (PREDICT_FALSE (last_key_index != fe->key_index))
 154         {
 155           cryptodev_key_t *key = vec_elt_at_index (cmt->keys, fe->key_index);
 156           union rte_cryptodev_session_ctx sess_ctx;
 157
 158           if (PREDICT_FALSE (key->keys[vm->numa_node][op_type] == 0))
 159             {
 160               status = cryptodev_session_create (vm, fe->key_index, 0);
 161               if (PREDICT_FALSE (status < 0))
 162                 goto error_exit;
 163             }
 164
 165           /* Borrow a created session to reset session ctx, based on a valid
 166            * assumption that the session reset won't happen until first valid
 167            * packet is processed */
 168           if (PREDICT_FALSE (cet->reset_sess == 0))
 169             cet->reset_sess = key->keys[vm->numa_node][op_type];
 170
 171           sess_ctx.crypto_sess = key->keys[vm->numa_node][op_type];
 172
 173           status = rte_cryptodev_configure_raw_dp_ctx (
 174             cet->cryptodev_id, cet->cryptodev_q, cet->ctx,
 175             RTE_CRYPTO_OP_WITH_SESSION, sess_ctx, is_update);
 176           if (PREDICT_FALSE (status < 0))
 177             goto error_exit;
 178
 179           last_key_index = fe->key_index;
 180           is_update = 1;
 181         }
 182
 183       cofs.raw = compute_ofs_linked_alg (fe, &min_ofs, &max_end);
 184
 185       vec->len = max_end - min_ofs;
 186       if (cmt->iova_mode == RTE_IOVA_VA)
 187         {
 188           vec[0].base = (void *) (b[0]->data + min_ofs);
 189           vec[0].iova = pointer_to_uword (b[0]->data) + min_ofs;
 190           iv_vec.va = (void *) fe->iv;
 191           iv_vec.iova = pointer_to_uword (fe->iv);
 192           digest_vec.va = (void *) fe->tag;
 193           digest_vec.iova = pointer_to_uword (fe->tag);
 194         }
 195       else
 196         {
 197           vec[0].base = (void *) (b[0]->data + min_ofs);
 198           vec[0].iova = vlib_buffer_get_pa (vm, b[0]) + min_ofs;
 199           iv_vec.va = (void *) fe->iv;
 200           iv_vec.iova = vlib_physmem_get_pa (vm, fe->iv);
 201           digest_vec.va = (void *) fe->tag;
 202           digest_vec.iova = vlib_physmem_get_pa (vm, fe->digest);
 203         }
 204
 205       if (PREDICT_FALSE (fe->flags & VNET_CRYPTO_OP_FLAG_CHAINED_BUFFERS))
 206         {
 207           vec[0].len = b[0]->current_data + b[0]->current_length - min_ofs;
 208           if (cryptodev_frame_build_sgl (vm, cmt->iova_mode, vec, &n_seg, b[0],
 209                                          max_end - min_ofs - vec->len) < 0)
 210             goto error_exit;
 211         }
 212
 213       status = rte_cryptodev_raw_enqueue (cet->ctx, vec, n_seg, cofs, &iv_vec,
 214                                           &digest_vec, 0, (void *) frame);
 215       if (PREDICT_FALSE (status < 0))
 216         goto error_exit;
 217
 218       b++;
 219       fe++;
 220       n_elts--;
 221     }
 222
 223   status = rte_cryptodev_raw_enqueue_done (cet->ctx, frame->n_elts);
 224   if (PREDICT_FALSE (status < 0))
 225     {
 226       cryptodev_reset_ctx (cet);
 227       return -1;
 228     }
 229
 230   cet->inflight += frame->n_elts;
 231   return 0;
 232
 233 error_exit:
 234   cryptodev_mark_frame_err_status (frame,
 235                                    VNET_CRYPTO_OP_STATUS_FAIL_ENGINE_ERR);
 236   cryptodev_reset_ctx (cet);
 237   return -1;
 238 }
 239
 240 static_always_inline int
 241 cryptodev_raw_aead_enqueue (vlib_main_t *vm, vnet_crypto_async_frame_t *frame,
 242                             cryptodev_op_type_t op_type, u8 aad_len)
 243 {
 244   cryptodev_main_t *cmt = &cryptodev_main;
 245   cryptodev_engine_thread_t *cet = cmt->per_thread_data + vm->thread_index;
 246   vnet_crypto_async_frame_elt_t *fe;
 247   vlib_buffer_t **b;
 248   u32 n_elts;
 249   union rte_crypto_sym_ofs cofs;
 250   struct rte_crypto_vec vec[CRYPTODEV_MAX_N_SGL];
 251   struct rte_crypto_va_iova_ptr iv_vec, digest_vec, aad_vec;
 252   u32 last_key_index = ~0;
 253   u8 is_update = 0;
 254   int status;
 255
 256   n_elts = frame->n_elts;
 257
 258   if (PREDICT_FALSE (CRYPTODEV_MAX_INFLIGHT - cet->inflight < n_elts))
 259     {
 260       cryptodev_mark_frame_err_status (frame,
 261                                        VNET_CRYPTO_OP_STATUS_FAIL_ENGINE_ERR);
 262       return -1;
 263     }
 264
 265   vlib_get_buffers (vm, frame->buffer_indices, cet->b, frame->n_elts);
 266
 267   fe = frame->elts;
 268   b = cet->b;
 269   cofs.raw = 0;
 270
 271   while (n_elts)
 272     {
 273       u32 aad_offset = ((cet->aad_index++) & CRYPTODEV_AAD_MASK) << 4;
 274       u16 n_seg = 1;
 275
 276       if (n_elts > 1)
 277         {
 278           clib_prefetch_load (&fe[1]);
 279           vlib_prefetch_buffer_header (b[1], LOAD);
 280         }
 281
 282       if (PREDICT_FALSE (last_key_index != fe->key_index))
 283         {
 284           cryptodev_key_t *key = vec_elt_at_index (cmt->keys, fe->key_index);
 285           union rte_cryptodev_session_ctx sess_ctx;
 286
 287           if (PREDICT_FALSE (key->keys[vm->numa_node][op_type] == 0))
 288             {
 289               status = cryptodev_session_create (vm, fe->key_index, aad_len);
 290               if (PREDICT_FALSE (status < 0))
 291                 goto error_exit;
 292             }
 293
 294           if (PREDICT_FALSE (
 295                 (u8) key->keys[vm->numa_node][op_type]->opaque_data !=
 296                 aad_len))
 297             {
 298               cryptodev_sess_handler (vm, VNET_CRYPTO_KEY_OP_DEL,
 299                                       fe->key_index, aad_len);
 300               status = cryptodev_session_create (vm, fe->key_index, aad_len);
 301               if (PREDICT_FALSE (status < 0))
 302                 goto error_exit;
 303             }
 304
 305           /* Borrow a created session to reset session ctx, based on a valid
 306            * assumption that the session reset won't happen until first valid
 307            * packet is processed */
 308
 309           if (PREDICT_FALSE (cet->reset_sess == 0))
 310             cet->reset_sess = key->keys[vm->numa_node][op_type];
 311
 312           sess_ctx.crypto_sess = key->keys[vm->numa_node][op_type];
 313
 314           status = rte_cryptodev_configure_raw_dp_ctx (
 315             cet->cryptodev_id, cet->cryptodev_q, cet->ctx,
 316             RTE_CRYPTO_OP_WITH_SESSION, sess_ctx, is_update);
 317           if (PREDICT_FALSE (status < 0))
 318             goto error_exit;
 319
 320           last_key_index = fe->key_index;
 321           is_update = 1;
 322         }
 323
 324       if (cmt->iova_mode == RTE_IOVA_VA)
 325         {
 326           vec[0].base = (void *) (b[0]->data + fe->crypto_start_offset);
 327           vec[0].iova = pointer_to_uword (vec[0].base);
 328           vec[0].len = fe->crypto_total_length;
 329           iv_vec.va = (void *) fe->iv;
 330           iv_vec.iova = pointer_to_uword (fe->iv);
 331           digest_vec.va = (void *) fe->tag;
 332           digest_vec.iova = pointer_to_uword (fe->tag);
 333           aad_vec.va = (void *) (cet->aad_buf + aad_offset);
 334           aad_vec.iova = cet->aad_phy_addr + aad_offset;
 335         }
 336       else
 337         {
 338           vec[0].base = (void *) (b[0]->data + fe->crypto_start_offset);
 339           vec[0].iova =
 340             vlib_buffer_get_pa (vm, b[0]) + fe->crypto_start_offset;
 341           vec[0].len = fe->crypto_total_length;
 342           iv_vec.va = (void *) fe->iv;
 343           iv_vec.iova = vlib_physmem_get_pa (vm, fe->iv);
 344           aad_vec.va = (void *) (cet->aad_buf + aad_offset);
 345           aad_vec.iova = cet->aad_phy_addr + aad_offset;
 346           digest_vec.va = (void *) fe->tag;
 347           digest_vec.iova = vlib_physmem_get_pa (vm, fe->tag);
 348         }
 349
 350       if (aad_len == 8)
 351         *(u64 *) (cet->aad_buf + aad_offset) = *(u64 *) fe->aad;
 352       else
 353         {
 354           /* aad_len == 12 */
 355           *(u64 *) (cet->aad_buf + aad_offset) = *(u64 *) fe->aad;
 356           *(u32 *) (cet->aad_buf + aad_offset + 8) = *(u32 *) (fe->aad + 8);
 357         }
 358
 359       if (PREDICT_FALSE (fe->flags & VNET_CRYPTO_OP_FLAG_CHAINED_BUFFERS))
 360         {
 361           vec[0].len = b[0]->current_data + b[0]->current_length -
 362                        fe->crypto_start_offset;
 363           status =
 364             cryptodev_frame_build_sgl (vm, cmt->iova_mode, vec, &n_seg, b[0],
 365                                        fe->crypto_total_length - vec[0].len);
 366           if (status < 0)
 367             goto error_exit;
 368         }
 369
 370       status =
 371         rte_cryptodev_raw_enqueue (cet->ctx, vec, n_seg, cofs, &iv_vec,
 372                                    &digest_vec, &aad_vec, (void *) frame);
 373       if (PREDICT_FALSE (status < 0))
 374         goto error_exit;
 375
 376       fe++;
 377       b++;
 378       n_elts--;
 379     }
 380
 381   status = rte_cryptodev_raw_enqueue_done (cet->ctx, frame->n_elts);
 382   if (PREDICT_FALSE (status < 0))
 383     goto error_exit;
 384
 385   cet->inflight += frame->n_elts;
 386
 387   return 0;
 388
 389 error_exit:
 390   cryptodev_mark_frame_err_status (frame,
 391                                    VNET_CRYPTO_OP_STATUS_FAIL_ENGINE_ERR);
 392   cryptodev_reset_ctx (cet);
 393   return -1;
 394 }
 395
 396 static_always_inline u32
 397 cryptodev_get_frame_n_elts (void *frame)
 398 {
 399   vnet_crypto_async_frame_t *f = (vnet_crypto_async_frame_t *) frame;
 400   return f->n_elts;
 401 }
 402
 403 static_always_inline void
 404 cryptodev_post_dequeue (void *frame, u32 index, u8 is_op_success)
 405 {
 406   vnet_crypto_async_frame_t *f = (vnet_crypto_async_frame_t *) frame;
 407
 408   f->elts[index].status = is_op_success ? VNET_CRYPTO_OP_STATUS_COMPLETED :
 409                                           VNET_CRYPTO_OP_STATUS_FAIL_BAD_HMAC;
 410 }
 411
 412 #define GET_RING_OBJ(r, pos, f)                                               \
 413   do                                                                          \
 414     {                                                                         \
 415       vnet_crypto_async_frame_t **ring = (void *) &r[1];                      \
 416       f = ring[(r->cons.head + pos) & r->mask];                               \
 417     }                                                                         \
 418   while (0)
 419
 420 static_always_inline vnet_crypto_async_frame_t *
 421 cryptodev_raw_dequeue (vlib_main_t *vm, u32 *nb_elts_processed,
 422                        u32 *enqueue_thread_idx)
 423 {
 424   cryptodev_main_t *cmt = &cryptodev_main;
 425   vnet_crypto_main_t *cm = &crypto_main;
 426   cryptodev_engine_thread_t *cet = cmt->per_thread_data + vm->thread_index;
 427   vnet_crypto_async_frame_t *frame, *frame_ret = 0;
 428   u32 n_deq, n_success;
 429   u32 n_cached_frame = rte_ring_count (cet->cached_frame), n_room_left;
 430   u8 no_job_to_deq = 0;
 431   u16 inflight = cet->inflight;
 432   int dequeue_status;
 433
 434   n_room_left = CRYPTODEV_DEQ_CACHE_SZ - n_cached_frame - 1;
 435
 436   if (n_cached_frame)
 437     {
 438       u32 i;
 439       for (i = 0; i < n_cached_frame; i++)
 440         {
 441           vnet_crypto_async_frame_t *f;
 442           void *f_ret;
 443           enum rte_crypto_op_status op_status;
 444           u8 n_left, err, j;
 445
 446           GET_RING_OBJ (cet->cached_frame, i, f);
 447
 448           if (i < n_cached_frame - 2)
 449             {
 450               vnet_crypto_async_frame_t *f1, *f2;
 451               GET_RING_OBJ (cet->cached_frame, i + 1, f1);
 452               GET_RING_OBJ (cet->cached_frame, i + 2, f2);
 453               clib_prefetch_load (f1);
 454               clib_prefetch_load (f2);
 455             }
 456
 457           n_left = f->state & 0x7f;
 458           err = f->state & 0x80;
 459
 460           for (j = f->n_elts - n_left; j < f->n_elts && inflight; j++)
 461             {
 462               int ret;
 463               f_ret = rte_cryptodev_raw_dequeue (cet->ctx, &ret, &op_status);
 464
 465               if (!f_ret)
 466                 break;
 467
 468               switch (op_status)
 469                 {
 470                 case RTE_CRYPTO_OP_STATUS_SUCCESS:
 471                   f->elts[j].status = VNET_CRYPTO_OP_STATUS_COMPLETED;
 472                   break;
 473                 default:
 474                   f->elts[j].status = VNET_CRYPTO_OP_STATUS_FAIL_ENGINE_ERR;
 475                   err |= 1 << 7;
 476                 }
 477
 478               inflight--;
 479             }
 480
 481           if (j == f->n_elts)
 482             {
 483               if (i == 0)
 484                 {
 485                   frame_ret = f;
 486                   f->state = err ? VNET_CRYPTO_FRAME_STATE_ELT_ERROR :
 487                                    VNET_CRYPTO_FRAME_STATE_SUCCESS;
 488                 }
 489               else
 490                 {
 491                   f->state = f->n_elts - j;
 492                   f->state |= err;
 493                 }
 494               if (inflight)
 495                 continue;
 496             }
 497
 498           /* to here f is not completed dequeued and no more job can be
 499            * dequeued
 500            */
 501           f->state = f->n_elts - j;
 502           f->state |= err;
 503           no_job_to_deq = 1;
 504           break;
 505         }
 506
 507       if (frame_ret)
 508         {
 509           rte_ring_sc_dequeue (cet->cached_frame, (void **) &frame_ret);
 510           n_room_left++;
 511         }
 512     }
 513
 514   if (cm->dispatch_mode == VNET_CRYPTO_ASYNC_DISPATCH_INTERRUPT &&
 515       inflight > 0)
 516     vlib_node_set_interrupt_pending (vlib_get_main_by_index (vm->thread_index),
 517                                      cm->crypto_node_index);
 518
 519   /* no point to dequeue further */
 520   if (!inflight || no_job_to_deq || !n_room_left)
 521     goto end_deq;
 522
 523 #if RTE_VERSION >= RTE_VERSION_NUM(21, 5, 0, 0)
 524   n_deq = rte_cryptodev_raw_dequeue_burst (
 525     cet->ctx, cryptodev_get_frame_n_elts, 0, cryptodev_post_dequeue,
 526     (void **) &frame, 0, &n_success, &dequeue_status);
 527 #else
 528   n_deq = rte_cryptodev_raw_dequeue_burst (
 529     cet->ctx, cryptodev_get_frame_n_elts, cryptodev_post_dequeue,
 530     (void **) &frame, 0, &n_success, &dequeue_status);
 531 #endif
 532
 533   if (!n_deq)
 534     goto end_deq;
 535
 536   inflight -= n_deq;
 537   no_job_to_deq = n_deq < frame->n_elts;
 538   /* we have to cache the frame */
 539   if (frame_ret || n_cached_frame || no_job_to_deq)
 540     {
 541       frame->state = frame->n_elts - n_deq;
 542       frame->state |= ((n_success < n_deq) << 7);
 543       rte_ring_sp_enqueue (cet->cached_frame, (void *) frame);
 544       n_room_left--;
 545     }
 546   else
 547     {
 548       frame->state = n_success == frame->n_elts ?
 549                        VNET_CRYPTO_FRAME_STATE_SUCCESS :
 550                        VNET_CRYPTO_FRAME_STATE_ELT_ERROR;
 551       frame_ret = frame;
 552     }
 553
 554   /* see if we can dequeue more */
 555   while (inflight && n_room_left && !no_job_to_deq)
 556     {
 557 #if RTE_VERSION >= RTE_VERSION_NUM(21, 5, 0, 0)
 558       n_deq = rte_cryptodev_raw_dequeue_burst (
 559         cet->ctx, cryptodev_get_frame_n_elts, 0, cryptodev_post_dequeue,
 560         (void **) &frame, 0, &n_success, &dequeue_status);
 561 #else
 562       n_deq = rte_cryptodev_raw_dequeue_burst (
 563         cet->ctx, cryptodev_get_frame_n_elts, cryptodev_post_dequeue,
 564         (void **) &frame, 0, &n_success, &dequeue_status);
 565 #endif
 566       if (!n_deq)
 567         break;
 568       inflight -= n_deq;
 569       no_job_to_deq = n_deq < frame->n_elts;
 570       frame->state = frame->n_elts - n_deq;
 571       frame->state |= ((n_success < n_deq) << 7);
 572       rte_ring_sp_enqueue (cet->cached_frame, (void *) frame);
 573       n_room_left--;
 574     }
 575
 576 end_deq:
 577   if (inflight < cet->inflight)
 578     {
 579       int res =
 580         rte_cryptodev_raw_dequeue_done (cet->ctx, cet->inflight - inflight);
 581       ASSERT (res == 0);
 582       cet->inflight = inflight;
 583     }
 584
 585   if (frame_ret)
 586     {
 587       *nb_elts_processed = frame_ret->n_elts;
 588       *enqueue_thread_idx = frame_ret->enqueue_thread_index;
 589     }
 590
 591   return frame_ret;
 592 }
 593
 594 static_always_inline int
 595 cryptodev_raw_enq_aead_aad_8_enc (vlib_main_t *vm,
 596                                   vnet_crypto_async_frame_t *frame)
 597 {
 598   return cryptodev_raw_aead_enqueue (vm, frame, CRYPTODEV_OP_TYPE_ENCRYPT, 8);
 599 }
 600 static_always_inline int
 601 cryptodev_raw_enq_aead_aad_12_enc (vlib_main_t *vm,
 602                                    vnet_crypto_async_frame_t *frame)
 603 {
 604   return cryptodev_raw_aead_enqueue (vm, frame, CRYPTODEV_OP_TYPE_ENCRYPT, 12);
 605 }
 606
 607 static_always_inline int
 608 cryptodev_raw_enq_aead_aad_8_dec (vlib_main_t *vm,
 609                                   vnet_crypto_async_frame_t *frame)
 610 {
 611   return cryptodev_raw_aead_enqueue (vm, frame, CRYPTODEV_OP_TYPE_DECRYPT, 8);
 612 }
 613 static_always_inline int
 614 cryptodev_raw_enq_aead_aad_12_dec (vlib_main_t *vm,
 615                                    vnet_crypto_async_frame_t *frame)
 616 {
 617   return cryptodev_raw_aead_enqueue (vm, frame, CRYPTODEV_OP_TYPE_DECRYPT, 12);
 618 }
 619
 620 static_always_inline int
 621 cryptodev_raw_enq_linked_alg_enc (vlib_main_t *vm,
 622                                   vnet_crypto_async_frame_t *frame)
 623 {
 624   return cryptodev_frame_linked_algs_enqueue (vm, frame,
 625                                               CRYPTODEV_OP_TYPE_ENCRYPT);
 626 }
 627
 628 static_always_inline int
 629 cryptodev_raw_enq_linked_alg_dec (vlib_main_t *vm,
 630                                   vnet_crypto_async_frame_t *frame)
 631 {
 632   return cryptodev_frame_linked_algs_enqueue (vm, frame,
 633                                               CRYPTODEV_OP_TYPE_DECRYPT);
 634 }
 635
 636 clib_error_t *
 637 cryptodev_register_raw_hdl (vlib_main_t *vm, u32 eidx)
 638 {
 639   cryptodev_main_t *cmt = &cryptodev_main;
 640   cryptodev_engine_thread_t *cet;
 641   cryptodev_inst_t *cinst;
 642   struct rte_cryptodev_info info;
 643   struct rte_cryptodev_sym_capability_idx cap_auth_idx;
 644   struct rte_cryptodev_sym_capability_idx cap_cipher_idx;
 645   struct rte_cryptodev_sym_capability_idx cap_aead_idx;
 646   u32 support_raw_api = 1, max_ctx_size = 0;
 647   clib_error_t *error = 0;
 648   u8 ref_cnt = 0;
 649
 650   vec_foreach (cinst, cmt->cryptodev_inst)
 651     {
 652       u32 ctx_size;
 653       rte_cryptodev_info_get (cinst->dev_id, &info);
 654       if (!(info.feature_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))
 655         {
 656           support_raw_api = 0;
 657           break;
 658         }
 659
 660       ctx_size = rte_cryptodev_get_raw_dp_ctx_size (cinst->dev_id);
 661       max_ctx_size = clib_max (ctx_size, max_ctx_size);
 662     }
 663
 664   if (!support_raw_api)
 665     return cryptodev_register_cop_hdl (vm, eidx);
 666
 667   vec_foreach (cet, cmt->per_thread_data)
 668     {
 669       u32 thread_id = cet - cmt->per_thread_data;
 670       u32 numa = vlib_get_main_by_index (thread_id)->numa_node;
 671       u8 *name = format (0, "cache_frame_ring_%u_%u", numa, thread_id);
 672
 673       cet->cached_frame =
 674         rte_ring_create ((char *) name, CRYPTODEV_DEQ_CACHE_SZ, numa,
 675                          RING_F_SC_DEQ | RING_F_SP_ENQ);
 676
 677       cet->aad_buf = rte_zmalloc_socket (
 678         0, CRYPTODEV_NB_CRYPTO_OPS * CRYPTODEV_MAX_AAD_SIZE,
 679         CLIB_CACHE_LINE_BYTES, numa);
 680       if (cet->aad_buf == 0)
 681         {
 682           error = clib_error_return (0, "Failed to alloc aad buf");
 683           goto err_handling;
 684         }
 685       cet->aad_phy_addr = rte_malloc_virt2iova (cet->aad_buf);
 686
 687       cet->ctx =
 688         rte_zmalloc_socket (0, max_ctx_size, CLIB_CACHE_LINE_BYTES, numa);
 689       if (!cet->ctx)
 690         {
 691           error = clib_error_return (0, "Failed to alloc raw dp ctx");
 692           goto err_handling;
 693         }
 694
 695       if (cet->cached_frame == 0)
 696         {
 697           error = clib_error_return (0, "Failed to alloc frame ring %s", name);
 698           goto err_handling;
 699         }
 700
 701       vec_free (name);
 702     }
 703
 704 #define _(a, b, c, d, e, f, g)                                                \
 705   cap_aead_idx.type = RTE_CRYPTO_SYM_XFORM_AEAD;                              \
 706   cap_aead_idx.algo.aead = RTE_CRYPTO_##b##_##c;                              \
 707   if (cryptodev_check_cap_support (&cap_aead_idx, g, e, f))                   \
 708     {                                                                         \
 709       vnet_crypto_register_enqueue_handler (                                  \
 710         vm, eidx, VNET_CRYPTO_OP_##a##_TAG##e##_AAD##f##_ENC,                 \
 711         cryptodev_raw_enq_aead_aad_##f##_enc);                                \
 712       vnet_crypto_register_enqueue_handler (                                  \
 713         vm, eidx, VNET_CRYPTO_OP_##a##_TAG##e##_AAD##f##_DEC,                 \
 714         cryptodev_raw_enq_aead_aad_##f##_dec);                                \
 715       ref_cnt++;                                                              \
 716     }
 717   foreach_vnet_aead_crypto_conversion
 718 #undef _
 719
 720 #define _(a, b, c, d, e)                                                      \
 721   cap_auth_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;                              \
 722   cap_auth_idx.algo.auth = RTE_CRYPTO_AUTH_##d##_HMAC;                        \
 723   cap_cipher_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;                          \
 724   cap_cipher_idx.algo.cipher = RTE_CRYPTO_CIPHER_##b;                         \
 725   if (cryptodev_check_cap_support (&cap_cipher_idx, c, -1, -1) &&             \
 726       cryptodev_check_cap_support (&cap_auth_idx, -1, e, -1))                 \
 727     {                                                                         \
 728       vnet_crypto_register_enqueue_handler (                                  \
 729         vm, eidx, VNET_CRYPTO_OP_##a##_##d##_TAG##e##_ENC,                    \
 730         cryptodev_raw_enq_linked_alg_enc);                                    \
 731       vnet_crypto_register_enqueue_handler (                                  \
 732         vm, eidx, VNET_CRYPTO_OP_##a##_##d##_TAG##e##_DEC,                    \
 733         cryptodev_raw_enq_linked_alg_dec);                                    \
 734       ref_cnt++;                                                              \
 735     }
 736     foreach_cryptodev_link_async_alg
 737 #undef _
 738
 739     if (ref_cnt)
 740       vnet_crypto_register_dequeue_handler (vm, eidx, cryptodev_raw_dequeue);
 741
 742   cmt->is_raw_api = 1;
 743
 744   return 0;
 745
 746 err_handling:
 747   vec_foreach (cet, cmt->per_thread_data)
 748     {
 749       if (cet->cached_frame)
 750         rte_ring_free (cet->cached_frame);
 751     }
 752
 753   return error;
 754 }