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   ERROR_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   cryptodev_cache_ring_t *ring = &cet->cache_ring;
 116   ERROR_ASSERT (frame != 0);
 117   ERROR_ASSERT (frame->n_elts > 0);
 118   cryptodev_cache_ring_elt_t *ring_elt =
 119     cryptodev_cache_ring_push (ring, frame);
 120
 121   if (PREDICT_FALSE (ring_elt == NULL))
 122     return -1;
 123
 124   ring_elt->aad_len = 1;
 125   ring_elt->op_type = (u8) op_type;
 126   return 0;
 127 }
 128
 129 static_always_inline void
 130 cryptodev_frame_linked_algs_enqueue_internal (vlib_main_t *vm,
 131                                               vnet_crypto_async_frame_t *frame,
 132                                               cryptodev_op_type_t op_type)
 133 {
 134   cryptodev_main_t *cmt = &cryptodev_main;
 135   cryptodev_engine_thread_t *cet = cmt->per_thread_data + vm->thread_index;
 136   vnet_crypto_async_frame_elt_t *fe;
 137   vlib_buffer_t **b;
 138   struct rte_crypto_vec vec[CRYPTODEV_MAX_N_SGL];
 139   struct rte_crypto_va_iova_ptr iv_vec, digest_vec;
 140   cryptodev_cache_ring_t *ring = &cet->cache_ring;
 141   u16 *const enq = &ring->enq_head;
 142   u32 n_elts;
 143   u32 last_key_index = ~0;
 144   i16 min_ofs;
 145   u32 max_end;
 146   u32 max_to_enq = clib_min (CRYPTODE_ENQ_MAX,
 147                              frame->n_elts - ring->frames[*enq].enq_elts_head);
 148   u8 is_update = 0;
 149   int status;
 150
 151   if (cet->inflight + max_to_enq > CRYPTODEV_MAX_INFLIGHT)
 152     return;
 153
 154   n_elts = max_to_enq;
 155
 156   vlib_get_buffers (vm, frame->buffer_indices, cet->b, frame->n_elts);
 157
 158   b = cet->b + ring->frames[*enq].enq_elts_head;
 159   fe = frame->elts + ring->frames[*enq].enq_elts_head;
 160
 161   while (n_elts)
 162     {
 163       union rte_crypto_sym_ofs cofs;
 164       u16 n_seg = 1;
 165
 166       if (n_elts > 2)
 167         {
 168           clib_prefetch_load (&fe[1]);
 169           clib_prefetch_load (&fe[2]);
 170           vlib_prefetch_buffer_header (b[1], LOAD);
 171           vlib_prefetch_buffer_header (b[2], LOAD);
 172         }
 173
 174       if (PREDICT_FALSE (last_key_index != fe->key_index))
 175         {
 176           cryptodev_key_t *key = vec_elt_at_index (cmt->keys, fe->key_index);
 177           union rte_cryptodev_session_ctx sess_ctx;
 178
 179           if (PREDICT_FALSE (key->keys[vm->numa_node][op_type] == 0))
 180             {
 181               status = cryptodev_session_create (vm, fe->key_index, 0);
 182               if (PREDICT_FALSE (status < 0))
 183                 goto error_exit;
 184             }
 185
 186           /* Borrow a created session to reset session ctx, based on a valid
 187            * assumption that the session reset won't happen until first valid
 188            * packet is processed */
 189           if (PREDICT_FALSE (cet->reset_sess == 0))
 190             cet->reset_sess = key->keys[vm->numa_node][op_type];
 191
 192           sess_ctx.crypto_sess = key->keys[vm->numa_node][op_type];
 193
 194           status = rte_cryptodev_configure_raw_dp_ctx (
 195             cet->cryptodev_id, cet->cryptodev_q, cet->ctx,
 196             RTE_CRYPTO_OP_WITH_SESSION, sess_ctx, is_update);
 197           if (PREDICT_FALSE (status < 0))
 198             goto error_exit;
 199
 200           last_key_index = fe->key_index;
 201           is_update = 1;
 202         }
 203
 204       cofs.raw = compute_ofs_linked_alg (fe, &min_ofs, &max_end);
 205
 206       vec->len = max_end - min_ofs;
 207       if (cmt->iova_mode == RTE_IOVA_VA)
 208         {
 209           vec[0].base = (void *) (b[0]->data + min_ofs);
 210           vec[0].iova = pointer_to_uword (b[0]->data) + min_ofs;
 211           iv_vec.va = (void *) fe->iv;
 212           iv_vec.iova = pointer_to_uword (fe->iv);
 213           digest_vec.va = (void *) fe->tag;
 214           digest_vec.iova = pointer_to_uword (fe->tag);
 215         }
 216       else
 217         {
 218           vec[0].base = (void *) (b[0]->data + min_ofs);
 219           vec[0].iova = vlib_buffer_get_pa (vm, b[0]) + min_ofs;
 220           iv_vec.va = (void *) fe->iv;
 221           iv_vec.iova = vlib_physmem_get_pa (vm, fe->iv);
 222           digest_vec.va = (void *) fe->tag;
 223           digest_vec.iova = vlib_physmem_get_pa (vm, fe->digest);
 224         }
 225
 226       if (PREDICT_FALSE (fe->flags & VNET_CRYPTO_OP_FLAG_CHAINED_BUFFERS))
 227         {
 228           vec[0].len = b[0]->current_data + b[0]->current_length - min_ofs;
 229           if (cryptodev_frame_build_sgl (vm, cmt->iova_mode, vec, &n_seg, b[0],
 230                                          max_end - min_ofs - vec->len) < 0)
 231             goto error_exit;
 232         }
 233
 234       status = rte_cryptodev_raw_enqueue (cet->ctx, vec, n_seg, cofs, &iv_vec,
 235                                           &digest_vec, 0, (void *) frame);
 236       if (PREDICT_FALSE (status < 0))
 237         goto error_exit;
 238
 239       ring->frames[*enq].enq_elts_head += 1;
 240       b++;
 241       fe++;
 242       n_elts--;
 243     }
 244
 245   status = rte_cryptodev_raw_enqueue_done (cet->ctx, max_to_enq);
 246   if (PREDICT_FALSE (status < 0))
 247     goto error_exit;
 248
 249   cet->inflight += max_to_enq;
 250   cryptodev_cache_ring_update_enq_head (ring, frame);
 251   return;
 252
 253 error_exit:
 254   cryptodev_mark_frame_fill_err (frame,
 255                                  ring->frames[*enq].frame_elts_errs_mask,
 256                                  ring->frames[*enq].enq_elts_head, max_to_enq,
 257                                  VNET_CRYPTO_OP_STATUS_FAIL_ENGINE_ERR);
 258   ring->frames[*enq].enq_elts_head += max_to_enq;
 259   ring->frames[*enq].deq_elts_tail += max_to_enq;
 260   cryptodev_cache_ring_update_enq_head (ring, frame);
 261   cryptodev_reset_ctx (cet);
 262
 263   return;
 264 }
 265
 266 static_always_inline int
 267 cryptodev_raw_aead_enqueue (vlib_main_t *vm, vnet_crypto_async_frame_t *frame,
 268                             cryptodev_op_type_t op_type, u8 aad_len)
 269 {
 270   cryptodev_main_t *cmt = &cryptodev_main;
 271   cryptodev_engine_thread_t *cet = cmt->per_thread_data + vm->thread_index;
 272   cryptodev_cache_ring_t *ring = &cet->cache_ring;
 273   ERROR_ASSERT (frame != 0);
 274   ERROR_ASSERT (frame->n_elts > 0);
 275   cryptodev_cache_ring_elt_t *ring_elt =
 276     cryptodev_cache_ring_push (ring, frame);
 277
 278   if (PREDICT_FALSE (ring_elt == NULL))
 279     return -1;
 280
 281   ring_elt->aad_len = aad_len;
 282   ring_elt->op_type = (u8) op_type;
 283   return 0;
 284 }
 285
 286 static_always_inline void
 287 cryptodev_raw_aead_enqueue_internal (vlib_main_t *vm,
 288                                      vnet_crypto_async_frame_t *frame,
 289                                      cryptodev_op_type_t op_type, u8 aad_len)
 290 {
 291   cryptodev_main_t *cmt = &cryptodev_main;
 292   cryptodev_engine_thread_t *cet = cmt->per_thread_data + vm->thread_index;
 293   cryptodev_cache_ring_t *ring = &cet->cache_ring;
 294   vnet_crypto_async_frame_elt_t *fe;
 295   vlib_buffer_t **b;
 296   u32 n_elts;
 297   union rte_crypto_sym_ofs cofs;
 298   struct rte_crypto_vec vec[CRYPTODEV_MAX_N_SGL];
 299   struct rte_crypto_va_iova_ptr iv_vec, digest_vec, aad_vec;
 300   u32 last_key_index = ~0;
 301   u16 *const enq = &ring->enq_head;
 302   u16 left_to_enq = frame->n_elts - ring->frames[*enq].enq_elts_head;
 303   u16 max_to_enq = clib_min (CRYPTODE_ENQ_MAX, left_to_enq);
 304   u8 is_update = 0;
 305   int status;
 306
 307   if (cet->inflight + max_to_enq > CRYPTODEV_MAX_INFLIGHT)
 308     {
 309       return;
 310     }
 311
 312   n_elts = max_to_enq;
 313
 314   vlib_get_buffers (vm, frame->buffer_indices, cet->b, frame->n_elts);
 315
 316   fe = frame->elts + ring->frames[*enq].enq_elts_head;
 317   b = cet->b + ring->frames[*enq].enq_elts_head;
 318   cofs.raw = 0;
 319
 320   while (n_elts)
 321     {
 322       u32 aad_offset = ((cet->aad_index++) & CRYPTODEV_AAD_MASK) << 4;
 323       u16 n_seg = 1;
 324
 325       if (n_elts > 1)
 326         {
 327           clib_prefetch_load (&fe[1]);
 328           vlib_prefetch_buffer_header (b[1], LOAD);
 329         }
 330
 331       if (PREDICT_FALSE (last_key_index != fe->key_index))
 332         {
 333           cryptodev_key_t *key = vec_elt_at_index (cmt->keys, fe->key_index);
 334           union rte_cryptodev_session_ctx sess_ctx;
 335
 336           if (PREDICT_FALSE (key->keys[vm->numa_node][op_type] == 0))
 337             {
 338               status = cryptodev_session_create (vm, fe->key_index, aad_len);
 339               if (PREDICT_FALSE (status < 0))
 340                 goto error_exit;
 341             }
 342
 343           if (PREDICT_FALSE (
 344 #if RTE_VERSION >= RTE_VERSION_NUM(22, 11, 0, 0)
 345                 rte_cryptodev_sym_session_opaque_data_get (
 346                   key->keys[vm->numa_node][op_type]) != (u64) aad_len
 347 #else
 348                 (u8) key->keys[vm->numa_node][op_type]->opaque_data != aad_len
 349 #endif
 350                 ))
 351             {
 352               cryptodev_sess_handler (vm, VNET_CRYPTO_KEY_OP_DEL,
 353                                       fe->key_index, aad_len);
 354               status = cryptodev_session_create (vm, fe->key_index, aad_len);
 355               if (PREDICT_FALSE (status < 0))
 356                 goto error_exit;
 357             }
 358
 359           /* Borrow a created session to reset session ctx, based on a valid
 360            * assumption that the session reset won't happen until first valid
 361            * packet is processed */
 362
 363           if (PREDICT_FALSE (cet->reset_sess == 0))
 364             cet->reset_sess = key->keys[vm->numa_node][op_type];
 365
 366           sess_ctx.crypto_sess = key->keys[vm->numa_node][op_type];
 367
 368           status = rte_cryptodev_configure_raw_dp_ctx (
 369             cet->cryptodev_id, cet->cryptodev_q, cet->ctx,
 370             RTE_CRYPTO_OP_WITH_SESSION, sess_ctx, is_update);
 371           if (PREDICT_FALSE (status < 0))
 372             goto error_exit;
 373
 374           last_key_index = fe->key_index;
 375           is_update = 1;
 376         }
 377
 378       if (cmt->iova_mode == RTE_IOVA_VA)
 379         {
 380           vec[0].base = (void *) (b[0]->data + fe->crypto_start_offset);
 381           vec[0].iova = pointer_to_uword (vec[0].base);
 382           vec[0].len = fe->crypto_total_length;
 383           iv_vec.va = (void *) fe->iv;
 384           iv_vec.iova = pointer_to_uword (fe->iv);
 385           digest_vec.va = (void *) fe->tag;
 386           digest_vec.iova = pointer_to_uword (fe->tag);
 387           aad_vec.va = (void *) (cet->aad_buf + aad_offset);
 388           aad_vec.iova = cet->aad_phy_addr + aad_offset;
 389         }
 390       else
 391         {
 392           vec[0].base = (void *) (b[0]->data + fe->crypto_start_offset);
 393           vec[0].iova =
 394             vlib_buffer_get_pa (vm, b[0]) + fe->crypto_start_offset;
 395           vec[0].len = fe->crypto_total_length;
 396           iv_vec.va = (void *) fe->iv;
 397           iv_vec.iova = vlib_physmem_get_pa (vm, fe->iv);
 398           aad_vec.va = (void *) (cet->aad_buf + aad_offset);
 399           aad_vec.iova = cet->aad_phy_addr + aad_offset;
 400           digest_vec.va = (void *) fe->tag;
 401           digest_vec.iova = vlib_physmem_get_pa (vm, fe->tag);
 402         }
 403
 404       if (aad_len == 8)
 405         *(u64 *) (cet->aad_buf + aad_offset) = *(u64 *) fe->aad;
 406       else if (aad_len != 0)
 407         {
 408           /* aad_len == 12 */
 409           *(u64 *) (cet->aad_buf + aad_offset) = *(u64 *) fe->aad;
 410           *(u32 *) (cet->aad_buf + aad_offset + 8) = *(u32 *) (fe->aad + 8);
 411         }
 412
 413       if (PREDICT_FALSE (fe->flags & VNET_CRYPTO_OP_FLAG_CHAINED_BUFFERS))
 414         {
 415           vec[0].len = b[0]->current_data + b[0]->current_length -
 416                        fe->crypto_start_offset;
 417           status =
 418             cryptodev_frame_build_sgl (vm, cmt->iova_mode, vec, &n_seg, b[0],
 419                                        fe->crypto_total_length - vec[0].len);
 420           if (status < 0)
 421             goto error_exit;
 422         }
 423
 424       status =
 425         rte_cryptodev_raw_enqueue (cet->ctx, vec, n_seg, cofs, &iv_vec,
 426                                    &digest_vec, &aad_vec, (void *) frame);
 427       if (PREDICT_FALSE (status < 0))
 428         goto error_exit;
 429
 430       ring->frames[*enq].enq_elts_head += 1;
 431       fe++;
 432       b++;
 433       n_elts--;
 434     }
 435
 436   status = rte_cryptodev_raw_enqueue_done (cet->ctx, max_to_enq);
 437   if (PREDICT_FALSE (status < 0))
 438     goto error_exit;
 439
 440   cet->inflight += max_to_enq;
 441   cryptodev_cache_ring_update_enq_head (ring, frame);
 442   return;
 443
 444 error_exit:
 445   cryptodev_mark_frame_fill_err (frame,
 446                                  ring->frames[*enq].frame_elts_errs_mask,
 447                                  ring->frames[*enq].enq_elts_head, max_to_enq,
 448                                  VNET_CRYPTO_OP_STATUS_FAIL_ENGINE_ERR);
 449   ring->frames[*enq].enq_elts_head += max_to_enq;
 450   ring->frames[*enq].deq_elts_tail += max_to_enq;
 451   cryptodev_cache_ring_update_enq_head (ring, frame);
 452   cryptodev_reset_ctx (cet);
 453   return;
 454 }
 455
 456 static_always_inline void
 457 cryptodev_post_dequeue (void *frame, u32 index, u8 is_op_success)
 458 {
 459   vnet_crypto_async_frame_t *f = (vnet_crypto_async_frame_t *) frame;
 460
 461   f->elts[index].status = is_op_success ? VNET_CRYPTO_OP_STATUS_COMPLETED :
 462                                           VNET_CRYPTO_OP_STATUS_FAIL_BAD_HMAC;
 463 }
 464
 465 static_always_inline u8
 466 cryptodev_raw_dequeue_internal (vlib_main_t *vm, u32 *nb_elts_processed,
 467                                 u32 *enqueue_thread_idx)
 468 {
 469   cryptodev_main_t *cmt = &cryptodev_main;
 470   cryptodev_engine_thread_t *cet = cmt->per_thread_data + vm->thread_index;
 471   vnet_crypto_async_frame_t *frame;
 472   cryptodev_cache_ring_t *ring = &cet->cache_ring;
 473   u16 *const deq = &ring->deq_tail;
 474   u32 n_success;
 475   u16 n_deq, i, left_to_deq;
 476   u16 max_to_deq = 0;
 477   u16 inflight = cet->inflight;
 478   u8 dequeue_more = 0;
 479   int dequeue_status;
 480
 481   left_to_deq = ring->frames[*deq].n_elts - ring->frames[*deq].deq_elts_tail;
 482   max_to_deq = clib_min (left_to_deq, CRYPTODE_DEQ_MAX);
 483
 484   /* deq field can be used to track frame that is currently dequeued */
 485   /* based on thatthe amount of elements to deq for the frame can be specified
 486    */
 487
 488   n_deq = rte_cryptodev_raw_dequeue_burst (
 489     cet->ctx, NULL, max_to_deq, cryptodev_post_dequeue, (void **) &frame, 0,
 490     &n_success, &dequeue_status);
 491
 492   if (n_deq == 0)
 493     return dequeue_more;
 494
 495   inflight -= n_deq;
 496   if (PREDICT_FALSE (n_success < n_deq))
 497     {
 498       u16 idx = ring->frames[*deq].deq_elts_tail;
 499
 500       for (i = 0; i < n_deq; i++)
 501         {
 502           if (frame->elts[idx + i].status != VNET_CRYPTO_OP_STATUS_COMPLETED)
 503             ring->frames[*deq].frame_elts_errs_mask |= 1 << (idx + i);
 504         }
 505     }
 506   ring->frames[*deq].deq_elts_tail += n_deq;
 507
 508   if (cryptodev_cache_ring_update_deq_tail (ring, deq))
 509     {
 510       u32 fr_processed =
 511         (CRYPTODEV_CACHE_QUEUE_SIZE - ring->tail + ring->deq_tail) &
 512         CRYPTODEV_CACHE_QUEUE_MASK;
 513
 514       *nb_elts_processed = frame->n_elts;
 515       *enqueue_thread_idx = frame->enqueue_thread_index;
 516       dequeue_more = (fr_processed < CRYPTODEV_MAX_PROCESED_IN_CACHE_QUEUE);
 517     }
 518
 519   int res =
 520     rte_cryptodev_raw_dequeue_done (cet->ctx, cet->inflight - inflight);
 521   ERROR_ASSERT (res == 0);
 522   cet->inflight = inflight;
 523   return dequeue_more;
 524 }
 525
 526 static_always_inline void
 527 cryptodev_enqueue_frame_to_qat (vlib_main_t *vm,
 528                                 cryptodev_cache_ring_elt_t *ring_elt)
 529 {
 530   cryptodev_op_type_t op_type = (cryptodev_op_type_t) ring_elt->op_type;
 531   u8 linked_or_aad_len = ring_elt->aad_len;
 532
 533   if (linked_or_aad_len == 1)
 534     cryptodev_frame_linked_algs_enqueue_internal (vm, ring_elt->f, op_type);
 535   else
 536     cryptodev_raw_aead_enqueue_internal (vm, ring_elt->f, op_type,
 537                                          linked_or_aad_len);
 538 }
 539
 540 static_always_inline vnet_crypto_async_frame_t *
 541 cryptodev_raw_dequeue (vlib_main_t *vm, u32 *nb_elts_processed,
 542                        u32 *enqueue_thread_idx)
 543 {
 544   cryptodev_main_t *cmt = &cryptodev_main;
 545   vnet_crypto_main_t *cm = &crypto_main;
 546   cryptodev_engine_thread_t *cet = cmt->per_thread_data + vm->thread_index;
 547   cryptodev_cache_ring_t *ring = &cet->cache_ring;
 548   cryptodev_cache_ring_elt_t *ring_elt = &ring->frames[ring->tail];
 549   vnet_crypto_async_frame_t *ret_frame = 0;
 550   u8 dequeue_more = 1;
 551
 552   while (cet->inflight > 0 && dequeue_more)
 553       dequeue_more = cryptodev_raw_dequeue_internal (vm, nb_elts_processed,
 554                                                      enqueue_thread_idx);
 555
 556   if (PREDICT_TRUE (ring->frames[ring->enq_head].f != 0))
 557     cryptodev_enqueue_frame_to_qat (vm, &ring->frames[ring->enq_head]);
 558
 559   if (PREDICT_TRUE (ring_elt->f != 0) &&
 560       (ring_elt->n_elts == ring_elt->deq_elts_tail))
 561     {
 562       vlib_node_set_interrupt_pending (
 563         vlib_get_main_by_index (vm->thread_index), cm->crypto_node_index);
 564       ret_frame = cryptodev_cache_ring_pop (ring);
 565     }
 566
 567   return ret_frame;
 568 }
 569
 570 static_always_inline int
 571 cryptodev_raw_enq_aead_aad_0_enc (vlib_main_t *vm,
 572                                   vnet_crypto_async_frame_t *frame)
 573 {
 574   return cryptodev_raw_aead_enqueue (vm, frame, CRYPTODEV_OP_TYPE_ENCRYPT, 0);
 575 }
 576
 577 static_always_inline int
 578 cryptodev_raw_enq_aead_aad_8_enc (vlib_main_t *vm,
 579                                   vnet_crypto_async_frame_t *frame)
 580 {
 581   return cryptodev_raw_aead_enqueue (vm, frame, CRYPTODEV_OP_TYPE_ENCRYPT, 8);
 582 }
 583 static_always_inline int
 584 cryptodev_raw_enq_aead_aad_12_enc (vlib_main_t *vm,
 585                                    vnet_crypto_async_frame_t *frame)
 586 {
 587   return cryptodev_raw_aead_enqueue (vm, frame, CRYPTODEV_OP_TYPE_ENCRYPT, 12);
 588 }
 589
 590 static_always_inline int
 591 cryptodev_raw_enq_aead_aad_0_dec (vlib_main_t *vm,
 592                                   vnet_crypto_async_frame_t *frame)
 593 {
 594   return cryptodev_raw_aead_enqueue (vm, frame, CRYPTODEV_OP_TYPE_DECRYPT, 0);
 595 }
 596
 597 static_always_inline int
 598 cryptodev_raw_enq_aead_aad_8_dec (vlib_main_t *vm,
 599                                   vnet_crypto_async_frame_t *frame)
 600 {
 601   return cryptodev_raw_aead_enqueue (vm, frame, CRYPTODEV_OP_TYPE_DECRYPT, 8);
 602 }
 603 static_always_inline int
 604 cryptodev_raw_enq_aead_aad_12_dec (vlib_main_t *vm,
 605                                    vnet_crypto_async_frame_t *frame)
 606 {
 607   return cryptodev_raw_aead_enqueue (vm, frame, CRYPTODEV_OP_TYPE_DECRYPT, 12);
 608 }
 609
 610 static_always_inline int
 611 cryptodev_raw_enq_linked_alg_enc (vlib_main_t *vm,
 612                                   vnet_crypto_async_frame_t *frame)
 613 {
 614   return cryptodev_frame_linked_algs_enqueue (vm, frame,
 615                                               CRYPTODEV_OP_TYPE_ENCRYPT);
 616 }
 617
 618 static_always_inline int
 619 cryptodev_raw_enq_linked_alg_dec (vlib_main_t *vm,
 620                                   vnet_crypto_async_frame_t *frame)
 621 {
 622   return cryptodev_frame_linked_algs_enqueue (vm, frame,
 623                                               CRYPTODEV_OP_TYPE_DECRYPT);
 624 }
 625
 626 clib_error_t *
 627 cryptodev_register_raw_hdl (vlib_main_t *vm, u32 eidx)
 628 {
 629   cryptodev_main_t *cmt = &cryptodev_main;
 630   cryptodev_engine_thread_t *cet;
 631   cryptodev_inst_t *cinst;
 632   struct rte_cryptodev_info info;
 633   struct rte_cryptodev_sym_capability_idx cap_auth_idx;
 634   struct rte_cryptodev_sym_capability_idx cap_cipher_idx;
 635   struct rte_cryptodev_sym_capability_idx cap_aead_idx;
 636   u32 support_raw_api = 1, max_ctx_size = 0;
 637   clib_error_t *error = 0;
 638   u8 ref_cnt = 0;
 639
 640   vec_foreach (cinst, cmt->cryptodev_inst)
 641     {
 642       u32 ctx_size;
 643       rte_cryptodev_info_get (cinst->dev_id, &info);
 644       if (!(info.feature_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))
 645         {
 646           support_raw_api = 0;
 647           break;
 648         }
 649
 650       ctx_size = rte_cryptodev_get_raw_dp_ctx_size (cinst->dev_id);
 651       max_ctx_size = clib_max (ctx_size, max_ctx_size);
 652     }
 653
 654   if (!support_raw_api)
 655     return cryptodev_register_cop_hdl (vm, eidx);
 656
 657   vec_foreach (cet, cmt->per_thread_data)
 658     {
 659       u32 thread_id = cet - cmt->per_thread_data;
 660       u32 numa = vlib_get_main_by_index (thread_id)->numa_node;
 661       u8 *name = format (0, "cache_cache_ring_%u_%u", numa, thread_id);
 662
 663       cet->aad_buf = rte_zmalloc_socket (
 664         0, CRYPTODEV_NB_CRYPTO_OPS * CRYPTODEV_MAX_AAD_SIZE,
 665         CLIB_CACHE_LINE_BYTES, numa);
 666       if (cet->aad_buf == 0)
 667         {
 668           error = clib_error_return (0, "Failed to alloc aad buf");
 669           goto err_handling;
 670         }
 671       cet->aad_phy_addr = rte_malloc_virt2iova (cet->aad_buf);
 672
 673       cet->ctx =
 674         rte_zmalloc_socket (0, max_ctx_size, CLIB_CACHE_LINE_BYTES, numa);
 675       if (!cet->ctx)
 676         {
 677           error = clib_error_return (0, "Failed to alloc raw dp ctx");
 678           goto err_handling;
 679         }
 680       vec_free (name);
 681     }
 682
 683 #define _(a, b, c, d, e, f, g)                                                \
 684   cap_aead_idx.type = RTE_CRYPTO_SYM_XFORM_AEAD;                              \
 685   cap_aead_idx.algo.aead = RTE_CRYPTO_##b##_##c;                              \
 686   if (cryptodev_check_cap_support (&cap_aead_idx, g, e, f))                   \
 687     {                                                                         \
 688       vnet_crypto_register_enqueue_handler (                                  \
 689         vm, eidx, VNET_CRYPTO_OP_##a##_TAG##e##_AAD##f##_ENC,                 \
 690         cryptodev_raw_enq_aead_aad_##f##_enc);                                \
 691       vnet_crypto_register_enqueue_handler (                                  \
 692         vm, eidx, VNET_CRYPTO_OP_##a##_TAG##e##_AAD##f##_DEC,                 \
 693         cryptodev_raw_enq_aead_aad_##f##_dec);                                \
 694       ref_cnt++;                                                              \
 695     }
 696   foreach_vnet_aead_crypto_conversion
 697 #undef _
 698
 699 #define _(a, b, c, d, e)                                                      \
 700   cap_auth_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;                              \
 701   cap_auth_idx.algo.auth = RTE_CRYPTO_AUTH_##d##_HMAC;                        \
 702   cap_cipher_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;                          \
 703   cap_cipher_idx.algo.cipher = RTE_CRYPTO_CIPHER_##b;                         \
 704   if (cryptodev_check_cap_support (&cap_cipher_idx, c, -1, -1) &&             \
 705       cryptodev_check_cap_support (&cap_auth_idx, -1, e, -1))                 \
 706     {                                                                         \
 707       vnet_crypto_register_enqueue_handler (                                  \
 708         vm, eidx, VNET_CRYPTO_OP_##a##_##d##_TAG##e##_ENC,                    \
 709         cryptodev_raw_enq_linked_alg_enc);                                    \
 710       vnet_crypto_register_enqueue_handler (                                  \
 711         vm, eidx, VNET_CRYPTO_OP_##a##_##d##_TAG##e##_DEC,                    \
 712         cryptodev_raw_enq_linked_alg_dec);                                    \
 713       ref_cnt++;                                                              \
 714     }
 715     foreach_cryptodev_link_async_alg
 716 #undef _
 717
 718     if (ref_cnt)
 719       vnet_crypto_register_dequeue_handler (vm, eidx, cryptodev_raw_dequeue);
 720
 721   cmt->is_raw_api = 1;
 722
 723   return 0;
 724
 725 err_handling:
 726   return error;
 727 }