LCOV - code coverage report
Current view: top level - app/test-crypto-perf - cperf_test_common.c (source / functions) Hit Total Coverage
Test: Code coverage Lines: 0 141 0.0 %
Date: 2024-04-01 19:00:53 Functions: 0 5 0.0 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 0 0 -

           Branch data     Line data    Source code
       1                 :            : /* SPDX-License-Identifier: BSD-3-Clause
       2                 :            :  * Copyright(c) 2017 Intel Corporation
       3                 :            :  */
       4                 :            : 
       5                 :            : #include <rte_malloc.h>
       6                 :            : #include <rte_mbuf_pool_ops.h>
       7                 :            : 
       8                 :            : #include "cperf_test_common.h"
       9                 :            : 
      10                 :            : struct obj_params {
      11                 :            :         uint32_t src_buf_offset;
      12                 :            :         uint32_t dst_buf_offset;
      13                 :            :         uint16_t segment_sz;
      14                 :            :         uint16_t headroom_sz;
      15                 :            :         uint16_t data_len;
      16                 :            :         uint16_t segments_nb;
      17                 :            : };
      18                 :            : 
      19                 :            : static void
      20                 :            : fill_single_seg_mbuf(struct rte_mbuf *m, struct rte_mempool *mp,
      21                 :            :                 void *obj, uint32_t mbuf_offset, uint16_t segment_sz,
      22                 :            :                 uint16_t headroom, uint16_t data_len)
      23                 :            : {
      24                 :            :         uint32_t mbuf_hdr_size = sizeof(struct rte_mbuf);
      25                 :            : 
      26                 :            :         /* start of buffer is after mbuf structure and priv data */
      27                 :          0 :         m->priv_size = 0;
      28                 :          0 :         m->buf_addr = (char *)m + mbuf_hdr_size;
      29                 :          0 :         rte_mbuf_iova_set(m, rte_mempool_virt2iova(obj) + mbuf_offset + mbuf_hdr_size);
      30                 :          0 :         m->buf_len = segment_sz;
      31                 :          0 :         m->data_len = data_len;
      32                 :          0 :         m->pkt_len = data_len;
      33                 :            : 
      34                 :            :         /* Use headroom specified for the buffer */
      35                 :          0 :         m->data_off = headroom;
      36                 :            : 
      37                 :            :         /* init some constant fields */
      38                 :          0 :         m->pool = mp;
      39                 :          0 :         m->nb_segs = 1;
      40                 :          0 :         m->port = 0xff;
      41                 :            :         rte_mbuf_refcnt_set(m, 1);
      42                 :          0 :         m->next = NULL;
      43                 :          0 : }
      44                 :            : 
      45                 :            : static void
      46                 :          0 : fill_multi_seg_mbuf(struct rte_mbuf *m, struct rte_mempool *mp,
      47                 :            :                 void *obj, uint32_t mbuf_offset, uint16_t segment_sz,
      48                 :            :                 uint16_t headroom, uint16_t data_len, uint16_t segments_nb)
      49                 :            : {
      50                 :            :         uint16_t mbuf_hdr_size = sizeof(struct rte_mbuf);
      51                 :            :         uint16_t remaining_segments = segments_nb;
      52                 :          0 :         rte_iova_t next_seg_phys_addr = rte_mempool_virt2iova(obj) +
      53                 :            :                          mbuf_offset + mbuf_hdr_size;
      54                 :            : 
      55                 :            :         do {
      56                 :            :                 /* start of buffer is after mbuf structure and priv data */
      57                 :          0 :                 m->priv_size = 0;
      58                 :          0 :                 m->buf_addr = (char *)m + mbuf_hdr_size;
      59                 :            :                 rte_mbuf_iova_set(m, next_seg_phys_addr);
      60                 :          0 :                 next_seg_phys_addr += mbuf_hdr_size + segment_sz;
      61                 :          0 :                 m->buf_len = segment_sz;
      62                 :          0 :                 m->data_len = data_len;
      63                 :            : 
      64                 :            :                 /* Use headroom specified for the buffer */
      65                 :          0 :                 m->data_off = headroom;
      66                 :            : 
      67                 :            :                 /* init some constant fields */
      68                 :          0 :                 m->pool = mp;
      69                 :          0 :                 m->nb_segs = segments_nb;
      70                 :          0 :                 m->port = 0xff;
      71                 :            :                 rte_mbuf_refcnt_set(m, 1);
      72                 :            : 
      73                 :          0 :                 remaining_segments--;
      74                 :          0 :                 if (remaining_segments > 0) {
      75                 :          0 :                         m->next = (struct rte_mbuf *)((uint8_t *) m + mbuf_hdr_size + segment_sz);
      76                 :            :                         m = m->next;
      77                 :            :                 } else {
      78                 :          0 :                         m->next = NULL;
      79                 :            :                 }
      80                 :          0 :         } while (remaining_segments > 0);
      81                 :          0 : }
      82                 :            : 
      83                 :            : static void
      84                 :          0 : mempool_asym_obj_init(struct rte_mempool *mp, __rte_unused void *opaque_arg,
      85                 :            :                       void *obj, __rte_unused unsigned int i)
      86                 :            : {
      87                 :            :         struct rte_crypto_op *op = obj;
      88                 :            : 
      89                 :            :         /* Set crypto operation */
      90                 :          0 :         op->type = RTE_CRYPTO_OP_TYPE_ASYMMETRIC;
      91                 :          0 :         op->status = RTE_CRYPTO_OP_STATUS_NOT_PROCESSED;
      92                 :          0 :         op->sess_type = RTE_CRYPTO_OP_WITH_SESSION;
      93                 :          0 :         op->phys_addr = rte_mem_virt2iova(obj);
      94                 :          0 :         op->mempool = mp;
      95                 :          0 : }
      96                 :            : 
      97                 :            : static void
      98                 :          0 : mempool_obj_init(struct rte_mempool *mp,
      99                 :            :                  void *opaque_arg,
     100                 :            :                  void *obj,
     101                 :            :                  __rte_unused unsigned int i)
     102                 :            : {
     103                 :            :         struct obj_params *params = opaque_arg;
     104                 :            :         struct rte_crypto_op *op = obj;
     105                 :          0 :         struct rte_mbuf *m = (struct rte_mbuf *) ((uint8_t *) obj +
     106                 :          0 :                                         params->src_buf_offset);
     107                 :            :         /* Set crypto operation */
     108                 :          0 :         op->type = RTE_CRYPTO_OP_TYPE_SYMMETRIC;
     109                 :          0 :         op->status = RTE_CRYPTO_OP_STATUS_NOT_PROCESSED;
     110                 :          0 :         op->sess_type = RTE_CRYPTO_OP_WITH_SESSION;
     111                 :          0 :         op->phys_addr = rte_mem_virt2iova(obj);
     112                 :          0 :         op->mempool = mp;
     113                 :            : 
     114                 :            :         /* Set source buffer */
     115                 :          0 :         op->sym->m_src = m;
     116                 :          0 :         if (params->segments_nb == 1)
     117                 :          0 :                 fill_single_seg_mbuf(m, mp, obj, params->src_buf_offset,
     118                 :          0 :                                 params->segment_sz, params->headroom_sz,
     119                 :          0 :                                 params->data_len);
     120                 :            :         else
     121                 :          0 :                 fill_multi_seg_mbuf(m, mp, obj, params->src_buf_offset,
     122                 :          0 :                                 params->segment_sz, params->headroom_sz,
     123                 :          0 :                                 params->data_len, params->segments_nb);
     124                 :            : 
     125                 :            : 
     126                 :            :         /* Set destination buffer */
     127                 :          0 :         if (params->dst_buf_offset) {
     128                 :          0 :                 m = (struct rte_mbuf *) ((uint8_t *) obj +
     129                 :          0 :                                 params->dst_buf_offset);
     130                 :            :                 fill_single_seg_mbuf(m, mp, obj, params->dst_buf_offset,
     131                 :          0 :                                 params->segment_sz, params->headroom_sz,
     132                 :          0 :                                 params->data_len);
     133                 :          0 :                 op->sym->m_dst = m;
     134                 :            :         } else
     135                 :          0 :                 op->sym->m_dst = NULL;
     136                 :          0 : }
     137                 :            : 
     138                 :            : int
     139                 :          0 : cperf_alloc_common_memory(const struct cperf_options *options,
     140                 :            :                         const struct cperf_test_vector *test_vector,
     141                 :            :                         uint8_t dev_id, uint16_t qp_id,
     142                 :            :                         size_t extra_op_priv_size,
     143                 :            :                         uint32_t *src_buf_offset,
     144                 :            :                         uint32_t *dst_buf_offset,
     145                 :            :                         struct rte_mempool **pool)
     146                 :            : {
     147                 :            :         const char *mp_ops_name;
     148                 :          0 :         char pool_name[32] = "";
     149                 :            :         int ret;
     150                 :            : 
     151                 :            :         /* Calculate the object size */
     152                 :            :         uint16_t crypto_op_size = sizeof(struct rte_crypto_op) +
     153                 :            :                 sizeof(struct rte_crypto_sym_op);
     154                 :            :         uint16_t crypto_op_private_size;
     155                 :            : 
     156                 :          0 :         if (options->op_type == CPERF_ASYM_MODEX) {
     157                 :          0 :                 snprintf(pool_name, RTE_MEMPOOL_NAMESIZE, "perf_asym_op_pool%u",
     158                 :            :                          rte_socket_id());
     159                 :          0 :                 *pool = rte_crypto_op_pool_create(
     160                 :            :                         pool_name, RTE_CRYPTO_OP_TYPE_ASYMMETRIC,
     161                 :          0 :                         options->pool_sz, RTE_MEMPOOL_CACHE_MAX_SIZE, 0,
     162                 :          0 :                         rte_socket_id());
     163                 :          0 :                 if (*pool == NULL) {
     164                 :          0 :                         RTE_LOG(ERR, USER1,
     165                 :            :                                 "Cannot allocate mempool for device %u\n",
     166                 :            :                                 dev_id);
     167                 :          0 :                         return -1;
     168                 :            :                 }
     169                 :          0 :                 rte_mempool_obj_iter(*pool, mempool_asym_obj_init, NULL);
     170                 :          0 :                 return 0;
     171                 :            :         }
     172                 :            : 
     173                 :            :         /*
     174                 :            :          * If doing AES-CCM, IV field needs to be 16 bytes long,
     175                 :            :          * and AAD field needs to be long enough to have 18 bytes,
     176                 :            :          * plus the length of the AAD, and all rounded to a
     177                 :            :          * multiple of 16 bytes.
     178                 :            :          */
     179                 :          0 :         if (options->aead_algo == RTE_CRYPTO_AEAD_AES_CCM) {
     180                 :          0 :                 crypto_op_private_size = extra_op_priv_size +
     181                 :          0 :                         test_vector->cipher_iv.length +
     182                 :          0 :                         test_vector->auth_iv.length +
     183                 :          0 :                         RTE_ALIGN_CEIL(test_vector->aead_iv.length, 16) +
     184                 :          0 :                         RTE_ALIGN_CEIL(options->aead_aad_sz + 18, 16);
     185                 :            :         } else {
     186                 :          0 :                 crypto_op_private_size = extra_op_priv_size +
     187                 :          0 :                         test_vector->cipher_iv.length +
     188                 :          0 :                         test_vector->auth_iv.length +
     189                 :          0 :                         test_vector->aead_iv.length +
     190                 :          0 :                         options->aead_aad_sz;
     191                 :            :         }
     192                 :            : 
     193                 :            :         uint16_t crypto_op_total_size = crypto_op_size +
     194                 :            :                                 crypto_op_private_size;
     195                 :          0 :         uint16_t crypto_op_total_size_padded =
     196                 :          0 :                                 RTE_CACHE_LINE_ROUNDUP(crypto_op_total_size);
     197                 :          0 :         uint32_t mbuf_size = sizeof(struct rte_mbuf) + options->segment_sz;
     198                 :          0 :         uint32_t max_size = options->max_buffer_size + options->digest_sz;
     199                 :          0 :         uint32_t segment_data_len = options->segment_sz - options->headroom_sz -
     200                 :          0 :                                     options->tailroom_sz;
     201                 :          0 :         uint16_t segments_nb = (max_size % segment_data_len) ?
     202                 :          0 :                                 (max_size / segment_data_len) + 1 :
     203                 :          0 :                                 (max_size / segment_data_len);
     204                 :          0 :         uint32_t obj_size = crypto_op_total_size_padded +
     205                 :          0 :                                 (mbuf_size * segments_nb);
     206                 :            : 
     207                 :          0 :         snprintf(pool_name, sizeof(pool_name), "pool_cdev_%u_qp_%u",
     208                 :            :                         dev_id, qp_id);
     209                 :            : 
     210                 :          0 :         *src_buf_offset = crypto_op_total_size_padded;
     211                 :            : 
     212                 :          0 :         struct obj_params params = {
     213                 :          0 :                 .segment_sz = options->segment_sz,
     214                 :          0 :                 .headroom_sz = options->headroom_sz,
     215                 :            :                 /* Data len = segment size - (headroom + tailroom) */
     216                 :          0 :                 .data_len = options->segment_sz -
     217                 :          0 :                             options->headroom_sz -
     218                 :          0 :                             options->tailroom_sz,
     219                 :            :                 .segments_nb = segments_nb,
     220                 :            :                 .src_buf_offset = crypto_op_total_size_padded,
     221                 :            :                 .dst_buf_offset = 0
     222                 :            :         };
     223                 :            : 
     224                 :          0 :         if (options->out_of_place) {
     225                 :          0 :                 *dst_buf_offset = *src_buf_offset +
     226                 :            :                                 (mbuf_size * segments_nb);
     227                 :          0 :                 params.dst_buf_offset = *dst_buf_offset;
     228                 :            :                 /* Destination buffer will be one segment only */
     229                 :          0 :                 obj_size += max_size + sizeof(struct rte_mbuf) +
     230                 :          0 :                         options->headroom_sz + options->tailroom_sz;
     231                 :            :         }
     232                 :            : 
     233                 :          0 :         *pool = rte_mempool_create_empty(pool_name,
     234                 :          0 :                         options->pool_sz, obj_size, 512, 0,
     235                 :          0 :                         rte_socket_id(), 0);
     236                 :          0 :         if (*pool == NULL) {
     237                 :          0 :                 RTE_LOG(ERR, USER1,
     238                 :            :                         "Cannot allocate mempool for device %u\n",
     239                 :            :                         dev_id);
     240                 :          0 :                 return -1;
     241                 :            :         }
     242                 :            : 
     243                 :          0 :         mp_ops_name = rte_mbuf_best_mempool_ops();
     244                 :            : 
     245                 :          0 :         ret = rte_mempool_set_ops_byname(*pool,
     246                 :            :                 mp_ops_name, NULL);
     247                 :          0 :         if (ret != 0) {
     248                 :          0 :                 RTE_LOG(ERR, USER1,
     249                 :            :                          "Error setting mempool handler for device %u\n",
     250                 :            :                          dev_id);
     251                 :          0 :                 return -1;
     252                 :            :         }
     253                 :            : 
     254                 :          0 :         ret = rte_mempool_populate_default(*pool);
     255                 :          0 :         if (ret < 0) {
     256                 :          0 :                 RTE_LOG(ERR, USER1,
     257                 :            :                          "Error populating mempool for device %u\n",
     258                 :            :                          dev_id);
     259                 :          0 :                 return -1;
     260                 :            :         }
     261                 :            : 
     262                 :          0 :         rte_mempool_obj_iter(*pool, mempool_obj_init, (void *)&params);
     263                 :            : 
     264                 :          0 :         return 0;
     265                 :            : }
     266                 :            : 
     267                 :            : void
     268                 :          0 : cperf_mbuf_set(struct rte_mbuf *mbuf,
     269                 :            :                 const struct cperf_options *options,
     270                 :            :                 const struct cperf_test_vector *test_vector)
     271                 :            : {
     272                 :          0 :         uint32_t segment_sz = options->segment_sz - options->headroom_sz - options->tailroom_sz;
     273                 :            :         uint8_t *mbuf_data;
     274                 :            :         uint8_t *test_data;
     275                 :          0 :         uint32_t remaining_bytes = options->max_buffer_size;
     276                 :            : 
     277                 :          0 :         if (options->op_type == CPERF_AEAD) {
     278                 :          0 :                 test_data = (options->aead_op == RTE_CRYPTO_AEAD_OP_ENCRYPT) ?
     279                 :          0 :                                         test_vector->plaintext.data :
     280                 :            :                                         test_vector->ciphertext.data;
     281                 :            :         } else {
     282                 :            :                 test_data =
     283                 :          0 :                         (options->cipher_op == RTE_CRYPTO_CIPHER_OP_ENCRYPT) ?
     284                 :          0 :                                 test_vector->plaintext.data :
     285                 :            :                                 test_vector->ciphertext.data;
     286                 :            :         }
     287                 :            : 
     288                 :          0 :         while (remaining_bytes) {
     289                 :          0 :                 mbuf_data = rte_pktmbuf_mtod(mbuf, uint8_t *);
     290                 :            : 
     291                 :          0 :                 if (remaining_bytes <= segment_sz) {
     292                 :          0 :                         memcpy(mbuf_data, test_data, remaining_bytes);
     293                 :          0 :                         return;
     294                 :            :                 }
     295                 :            : 
     296                 :          0 :                 memcpy(mbuf_data, test_data, segment_sz);
     297                 :          0 :                 remaining_bytes -= segment_sz;
     298                 :          0 :                 test_data += segment_sz;
     299                 :          0 :                 mbuf = mbuf->next;
     300                 :            :         }
     301                 :            : }

Generated by: LCOV version 1.14