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_malloc.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 #if RTE_VERSION >= RTE_VERSION_NUM(22, 11, 0, 0)
 296                 rte_cryptodev_sym_session_opaque_data_get (
 297                   key->keys[vm->numa_node][op_type]) != (u64) aad_len
 298 #else
 299                 (u8) key->keys[vm->numa_node][op_type]->opaque_data != aad_len
 300 #endif
 301                 ))
 302             {
 303               cryptodev_sess_handler (vm, VNET_CRYPTO_KEY_OP_DEL,
 304                                       fe->key_index, aad_len);
 305               status = cryptodev_session_create (vm, fe->key_index, aad_len);
 306               if (PREDICT_FALSE (status < 0))
 307                 goto error_exit;
 308             }
 309
 310           /* Borrow a created session to reset session ctx, based on a valid
 311            * assumption that the session reset won't happen until first valid
 312            * packet is processed */
 313
 314           if (PREDICT_FALSE (cet->reset_sess == 0))
 315             cet->reset_sess = key->keys[vm->numa_node][op_type];
 316
 317           sess_ctx.crypto_sess = key->keys[vm->numa_node][op_type];
 318
 319           status = rte_cryptodev_configure_raw_dp_ctx (
 320             cet->cryptodev_id, cet->cryptodev_q, cet->ctx,
 321             RTE_CRYPTO_OP_WITH_SESSION, sess_ctx, is_update);
 322           if (PREDICT_FALSE (status < 0))
 323             goto error_exit;
 324
 325           last_key_index = fe->key_index;
 326           is_update = 1;
 327         }
 328
 329       if (cmt->iova_mode == RTE_IOVA_VA)
 330         {
 331           vec[0].base = (void *) (b[0]->data + fe->crypto_start_offset);
 332           vec[0].iova = pointer_to_uword (vec[0].base);
 333           vec[0].len = fe->crypto_total_length;
 334           iv_vec.va = (void *) fe->iv;
 335           iv_vec.iova = pointer_to_uword (fe->iv);
 336           digest_vec.va = (void *) fe->tag;
 337           digest_vec.iova = pointer_to_uword (fe->tag);
 338           aad_vec.va = (void *) (cet->aad_buf + aad_offset);
 339           aad_vec.iova = cet->aad_phy_addr + aad_offset;
 340         }
 341       else
 342         {
 343           vec[0].base = (void *) (b[0]->data + fe->crypto_start_offset);
 344           vec[0].iova =
 345             vlib_buffer_get_pa (vm, b[0]) + fe->crypto_start_offset;
 346           vec[0].len = fe->crypto_total_length;
 347           iv_vec.va = (void *) fe->iv;
 348           iv_vec.iova = vlib_physmem_get_pa (vm, fe->iv);
 349           aad_vec.va = (void *) (cet->aad_buf + aad_offset);
 350           aad_vec.iova = cet->aad_phy_addr + aad_offset;
 351           digest_vec.va = (void *) fe->tag;
 352           digest_vec.iova = vlib_physmem_get_pa (vm, fe->tag);
 353         }
 354
 355       if (aad_len == 8)
 356         *(u64 *) (cet->aad_buf + aad_offset) = *(u64 *) fe->aad;
 357       else if (aad_len != 0)
 358         {
 359           /* aad_len == 12 */
 360           *(u64 *) (cet->aad_buf + aad_offset) = *(u64 *) fe->aad;
 361           *(u32 *) (cet->aad_buf + aad_offset + 8) = *(u32 *) (fe->aad + 8);
 362         }
 363
 364       if (PREDICT_FALSE (fe->flags & VNET_CRYPTO_OP_FLAG_CHAINED_BUFFERS))
 365         {
 366           vec[0].len = b[0]->current_data + b[0]->current_length -
 367                        fe->crypto_start_offset;
 368           status =
 369             cryptodev_frame_build_sgl (vm, cmt->iova_mode, vec, &n_seg, b[0],
 370                                        fe->crypto_total_length - vec[0].len);
 371           if (status < 0)
 372             goto error_exit;
 373         }
 374
 375       status =
 376         rte_cryptodev_raw_enqueue (cet->ctx, vec, n_seg, cofs, &iv_vec,
 377                                    &digest_vec, &aad_vec, (void *) frame);
 378       if (PREDICT_FALSE (status < 0))
 379         goto error_exit;
 380
 381       fe++;
 382       b++;
 383       n_elts--;
 384     }
 385
 386   status = rte_cryptodev_raw_enqueue_done (cet->ctx, frame->n_elts);
 387   if (PREDICT_FALSE (status < 0))
 388     goto error_exit;
 389
 390   cet->inflight += frame->n_elts;
 391
 392   return 0;
 393
 394 error_exit:
 395   cryptodev_mark_frame_err_status (frame,
 396                                    VNET_CRYPTO_OP_STATUS_FAIL_ENGINE_ERR);
 397   cryptodev_reset_ctx (cet);
 398   return -1;
 399 }
 400
 401 static_always_inline u32
 402 cryptodev_get_frame_n_elts (void *frame)
 403 {
 404   vnet_crypto_async_frame_t *f = (vnet_crypto_async_frame_t *) frame;
 405   return f->n_elts;
 406 }
 407
 408 static_always_inline void
 409 cryptodev_post_dequeue (void *frame, u32 index, u8 is_op_success)
 410 {
 411   vnet_crypto_async_frame_t *f = (vnet_crypto_async_frame_t *) frame;
 412
 413   f->elts[index].status = is_op_success ? VNET_CRYPTO_OP_STATUS_COMPLETED :
 414                                           VNET_CRYPTO_OP_STATUS_FAIL_BAD_HMAC;
 415 }
 416
 417 #define GET_RING_OBJ(r, pos, f)                                               \
 418   do                                                                          \
 419     {                                                                         \
 420       vnet_crypto_async_frame_t **ring = (void *) &r[1];                      \
 421       f = ring[(r->cons.head + pos) & r->mask];                               \
 422     }                                                                         \
 423   while (0)
 424
 425 static_always_inline vnet_crypto_async_frame_t *
 426 cryptodev_raw_dequeue (vlib_main_t *vm, u32 *nb_elts_processed,
 427                        u32 *enqueue_thread_idx)
 428 {
 429   cryptodev_main_t *cmt = &cryptodev_main;
 430   vnet_crypto_main_t *cm = &crypto_main;
 431   cryptodev_engine_thread_t *cet = cmt->per_thread_data + vm->thread_index;
 432   vnet_crypto_async_frame_t *frame, *frame_ret = 0;
 433   u32 n_deq, n_success;
 434   u32 n_cached_frame = rte_ring_count (cet->cached_frame), n_room_left;
 435   u8 no_job_to_deq = 0;
 436   u16 inflight = cet->inflight;
 437   int dequeue_status;
 438
 439   n_room_left = CRYPTODEV_DEQ_CACHE_SZ - n_cached_frame - 1;
 440
 441   if (n_cached_frame)
 442     {
 443       u32 i;
 444       for (i = 0; i < n_cached_frame; i++)
 445         {
 446           vnet_crypto_async_frame_t *f;
 447           void *f_ret;
 448           enum rte_crypto_op_status op_status;
 449           u8 n_left, err, j;
 450
 451           GET_RING_OBJ (cet->cached_frame, i, f);
 452
 453           if (i < n_cached_frame - 2)
 454             {
 455               vnet_crypto_async_frame_t *f1, *f2;
 456               GET_RING_OBJ (cet->cached_frame, i + 1, f1);
 457               GET_RING_OBJ (cet->cached_frame, i + 2, f2);
 458               clib_prefetch_load (f1);
 459               clib_prefetch_load (f2);
 460             }
 461
 462           n_left = f->state & 0x7f;
 463           err = f->state & 0x80;
 464
 465           for (j = f->n_elts - n_left; j < f->n_elts && inflight; j++)
 466             {
 467               int ret;
 468               f_ret = rte_cryptodev_raw_dequeue (cet->ctx, &ret, &op_status);
 469
 470               if (!f_ret)
 471                 break;
 472
 473               switch (op_status)
 474                 {
 475                 case RTE_CRYPTO_OP_STATUS_SUCCESS:
 476                   f->elts[j].status = VNET_CRYPTO_OP_STATUS_COMPLETED;
 477                   break;
 478                 default:
 479                   f->elts[j].status = VNET_CRYPTO_OP_STATUS_FAIL_ENGINE_ERR;
 480                   err |= 1 << 7;
 481                 }
 482
 483               inflight--;
 484             }
 485
 486           if (j == f->n_elts)
 487             {
 488               if (i == 0)
 489                 {
 490                   frame_ret = f;
 491                   f->state = err ? VNET_CRYPTO_FRAME_STATE_ELT_ERROR :
 492                                    VNET_CRYPTO_FRAME_STATE_SUCCESS;
 493                 }
 494               else
 495                 {
 496                   f->state = f->n_elts - j;
 497                   f->state |= err;
 498                 }
 499               if (inflight)
 500                 continue;
 501             }
 502
 503           /* to here f is not completed dequeued and no more job can be
 504            * dequeued
 505            */
 506           f->state = f->n_elts - j;
 507           f->state |= err;
 508           no_job_to_deq = 1;
 509           break;
 510         }
 511
 512       if (frame_ret)
 513         {
 514           rte_ring_sc_dequeue (cet->cached_frame, (void **) &frame_ret);
 515           n_room_left++;
 516         }
 517     }
 518
 519   if (cm->dispatch_mode == VNET_CRYPTO_ASYNC_DISPATCH_INTERRUPT &&
 520       inflight > 0)
 521     vlib_node_set_interrupt_pending (vlib_get_main_by_index (vm->thread_index),
 522                                      cm->crypto_node_index);
 523
 524   /* no point to dequeue further */
 525   if (!inflight || no_job_to_deq || !n_room_left)
 526     goto end_deq;
 527
 528 #if RTE_VERSION >= RTE_VERSION_NUM(21, 5, 0, 0)
 529   n_deq = rte_cryptodev_raw_dequeue_burst (
 530     cet->ctx, cryptodev_get_frame_n_elts, 0, cryptodev_post_dequeue,
 531     (void **) &frame, 0, &n_success, &dequeue_status);
 532 #else
 533   n_deq = rte_cryptodev_raw_dequeue_burst (
 534     cet->ctx, cryptodev_get_frame_n_elts, cryptodev_post_dequeue,
 535     (void **) &frame, 0, &n_success, &dequeue_status);
 536 #endif
 537
 538   if (!n_deq)
 539     goto end_deq;
 540
 541   inflight -= n_deq;
 542   no_job_to_deq = n_deq < frame->n_elts;
 543   /* we have to cache the frame */
 544   if (frame_ret || n_cached_frame || no_job_to_deq)
 545     {
 546       frame->state = frame->n_elts - n_deq;
 547       frame->state |= ((n_success < n_deq) << 7);
 548       rte_ring_sp_enqueue (cet->cached_frame, (void *) frame);
 549       n_room_left--;
 550     }
 551   else
 552     {
 553       frame->state = n_success == frame->n_elts ?
 554                        VNET_CRYPTO_FRAME_STATE_SUCCESS :
 555                        VNET_CRYPTO_FRAME_STATE_ELT_ERROR;
 556       frame_ret = frame;
 557     }
 558
 559   /* see if we can dequeue more */
 560   while (inflight && n_room_left && !no_job_to_deq)
 561     {
 562 #if RTE_VERSION >= RTE_VERSION_NUM(21, 5, 0, 0)
 563       n_deq = rte_cryptodev_raw_dequeue_burst (
 564         cet->ctx, cryptodev_get_frame_n_elts, 0, cryptodev_post_dequeue,
 565         (void **) &frame, 0, &n_success, &dequeue_status);
 566 #else
 567       n_deq = rte_cryptodev_raw_dequeue_burst (
 568         cet->ctx, cryptodev_get_frame_n_elts, cryptodev_post_dequeue,
 569         (void **) &frame, 0, &n_success, &dequeue_status);
 570 #endif
 571       if (!n_deq)
 572         break;
 573       inflight -= n_deq;
 574       no_job_to_deq = n_deq < frame->n_elts;
 575       frame->state = frame->n_elts - n_deq;
 576       frame->state |= ((n_success < n_deq) << 7);
 577       rte_ring_sp_enqueue (cet->cached_frame, (void *) frame);
 578       n_room_left--;
 579     }
 580
 581 end_deq:
 582   if (inflight < cet->inflight)
 583     {
 584       int res =
 585         rte_cryptodev_raw_dequeue_done (cet->ctx, cet->inflight - inflight);
 586       ASSERT (res == 0);
 587       cet->inflight = inflight;
 588     }
 589
 590   if (frame_ret)
 591     {
 592       *nb_elts_processed = frame_ret->n_elts;
 593       *enqueue_thread_idx = frame_ret->enqueue_thread_index;
 594     }
 595
 596   return frame_ret;
 597 }
 598
 599 static_always_inline int
 600 cryptodev_raw_enq_aead_aad_0_enc (vlib_main_t *vm,
 601                                   vnet_crypto_async_frame_t *frame)
 602 {
 603   return cryptodev_raw_aead_enqueue (vm, frame, CRYPTODEV_OP_TYPE_ENCRYPT, 0);
 604 }
 605
 606 static_always_inline int
 607 cryptodev_raw_enq_aead_aad_8_enc (vlib_main_t *vm,
 608                                   vnet_crypto_async_frame_t *frame)
 609 {
 610   return cryptodev_raw_aead_enqueue (vm, frame, CRYPTODEV_OP_TYPE_ENCRYPT, 8);
 611 }
 612 static_always_inline int
 613 cryptodev_raw_enq_aead_aad_12_enc (vlib_main_t *vm,
 614                                    vnet_crypto_async_frame_t *frame)
 615 {
 616   return cryptodev_raw_aead_enqueue (vm, frame, CRYPTODEV_OP_TYPE_ENCRYPT, 12);
 617 }
 618
 619 static_always_inline int
 620 cryptodev_raw_enq_aead_aad_0_dec (vlib_main_t *vm,
 621                                   vnet_crypto_async_frame_t *frame)
 622 {
 623   return cryptodev_raw_aead_enqueue (vm, frame, CRYPTODEV_OP_TYPE_DECRYPT, 0);
 624 }
 625
 626 static_always_inline int
 627 cryptodev_raw_enq_aead_aad_8_dec (vlib_main_t *vm,
 628                                   vnet_crypto_async_frame_t *frame)
 629 {
 630   return cryptodev_raw_aead_enqueue (vm, frame, CRYPTODEV_OP_TYPE_DECRYPT, 8);
 631 }
 632 static_always_inline int
 633 cryptodev_raw_enq_aead_aad_12_dec (vlib_main_t *vm,
 634                                    vnet_crypto_async_frame_t *frame)
 635 {
 636   return cryptodev_raw_aead_enqueue (vm, frame, CRYPTODEV_OP_TYPE_DECRYPT, 12);
 637 }
 638
 639 static_always_inline int
 640 cryptodev_raw_enq_linked_alg_enc (vlib_main_t *vm,
 641                                   vnet_crypto_async_frame_t *frame)
 642 {
 643   return cryptodev_frame_linked_algs_enqueue (vm, frame,
 644                                               CRYPTODEV_OP_TYPE_ENCRYPT);
 645 }
 646
 647 static_always_inline int
 648 cryptodev_raw_enq_linked_alg_dec (vlib_main_t *vm,
 649                                   vnet_crypto_async_frame_t *frame)
 650 {
 651   return cryptodev_frame_linked_algs_enqueue (vm, frame,
 652                                               CRYPTODEV_OP_TYPE_DECRYPT);
 653 }
 654
 655 clib_error_t *
 656 cryptodev_register_raw_hdl (vlib_main_t *vm, u32 eidx)
 657 {
 658   cryptodev_main_t *cmt = &cryptodev_main;
 659   cryptodev_engine_thread_t *cet;
 660   cryptodev_inst_t *cinst;
 661   struct rte_cryptodev_info info;
 662   struct rte_cryptodev_sym_capability_idx cap_auth_idx;
 663   struct rte_cryptodev_sym_capability_idx cap_cipher_idx;
 664   struct rte_cryptodev_sym_capability_idx cap_aead_idx;
 665   u32 support_raw_api = 1, max_ctx_size = 0;
 666   clib_error_t *error = 0;
 667   u8 ref_cnt = 0;
 668
 669   vec_foreach (cinst, cmt->cryptodev_inst)
 670     {
 671       u32 ctx_size;
 672       rte_cryptodev_info_get (cinst->dev_id, &info);
 673       if (!(info.feature_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))
 674         {
 675           support_raw_api = 0;
 676           break;
 677         }
 678
 679       ctx_size = rte_cryptodev_get_raw_dp_ctx_size (cinst->dev_id);
 680       max_ctx_size = clib_max (ctx_size, max_ctx_size);
 681     }
 682
 683   if (!support_raw_api)
 684     return cryptodev_register_cop_hdl (vm, eidx);
 685
 686   vec_foreach (cet, cmt->per_thread_data)
 687     {
 688       u32 thread_id = cet - cmt->per_thread_data;
 689       u32 numa = vlib_get_main_by_index (thread_id)->numa_node;
 690       u8 *name = format (0, "cache_frame_ring_%u_%u", numa, thread_id);
 691
 692       cet->cached_frame =
 693         rte_ring_create ((char *) name, CRYPTODEV_DEQ_CACHE_SZ, numa,
 694                          RING_F_SC_DEQ | RING_F_SP_ENQ);
 695
 696       cet->aad_buf = rte_zmalloc_socket (
 697         0, CRYPTODEV_NB_CRYPTO_OPS * CRYPTODEV_MAX_AAD_SIZE,
 698         CLIB_CACHE_LINE_BYTES, numa);
 699       if (cet->aad_buf == 0)
 700         {
 701           error = clib_error_return (0, "Failed to alloc aad buf");
 702           goto err_handling;
 703         }
 704       cet->aad_phy_addr = rte_malloc_virt2iova (cet->aad_buf);
 705
 706       cet->ctx =
 707         rte_zmalloc_socket (0, max_ctx_size, CLIB_CACHE_LINE_BYTES, numa);
 708       if (!cet->ctx)
 709         {
 710           error = clib_error_return (0, "Failed to alloc raw dp ctx");
 711           goto err_handling;
 712         }
 713
 714       if (cet->cached_frame == 0)
 715         {
 716           error = clib_error_return (0, "Failed to alloc frame ring %s", name);
 717           goto err_handling;
 718         }
 719
 720       vec_free (name);
 721     }
 722
 723 #define _(a, b, c, d, e, f, g)                                                \
 724   cap_aead_idx.type = RTE_CRYPTO_SYM_XFORM_AEAD;                              \
 725   cap_aead_idx.algo.aead = RTE_CRYPTO_##b##_##c;                              \
 726   if (cryptodev_check_cap_support (&cap_aead_idx, g, e, f))                   \
 727     {                                                                         \
 728       vnet_crypto_register_enqueue_handler (                                  \
 729         vm, eidx, VNET_CRYPTO_OP_##a##_TAG##e##_AAD##f##_ENC,                 \
 730         cryptodev_raw_enq_aead_aad_##f##_enc);                                \
 731       vnet_crypto_register_enqueue_handler (                                  \
 732         vm, eidx, VNET_CRYPTO_OP_##a##_TAG##e##_AAD##f##_DEC,                 \
 733         cryptodev_raw_enq_aead_aad_##f##_dec);                                \
 734       ref_cnt++;                                                              \
 735     }
 736   foreach_vnet_aead_crypto_conversion
 737 #undef _
 738
 739 #define _(a, b, c, d, e)                                                      \
 740   cap_auth_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;                              \
 741   cap_auth_idx.algo.auth = RTE_CRYPTO_AUTH_##d##_HMAC;                        \
 742   cap_cipher_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;                          \
 743   cap_cipher_idx.algo.cipher = RTE_CRYPTO_CIPHER_##b;                         \
 744   if (cryptodev_check_cap_support (&cap_cipher_idx, c, -1, -1) &&             \
 745       cryptodev_check_cap_support (&cap_auth_idx, -1, e, -1))                 \
 746     {                                                                         \
 747       vnet_crypto_register_enqueue_handler (                                  \
 748         vm, eidx, VNET_CRYPTO_OP_##a##_##d##_TAG##e##_ENC,                    \
 749         cryptodev_raw_enq_linked_alg_enc);                                    \
 750       vnet_crypto_register_enqueue_handler (                                  \
 751         vm, eidx, VNET_CRYPTO_OP_##a##_##d##_TAG##e##_DEC,                    \
 752         cryptodev_raw_enq_linked_alg_dec);                                    \
 753       ref_cnt++;                                                              \
 754     }
 755     foreach_cryptodev_link_async_alg
 756 #undef _
 757
 758     if (ref_cnt)
 759       vnet_crypto_register_dequeue_handler (vm, eidx, cryptodev_raw_dequeue);
 760
 761   cmt->is_raw_api = 1;
 762
 763   return 0;
 764
 765 err_handling:
 766   vec_foreach (cet, cmt->per_thread_data)
 767     {
 768       if (cet->cached_frame)
 769         rte_ring_free (cet->cached_frame);
 770     }
 771
 772   return error;
 773 }