drivers/crypto/aesni_gcm/aesni_gcm_pmd.c

   1 /*-
   2  *   BSD LICENSE
   3  *
   4  *   Copyright(c) 2016-2017 Intel Corporation. All rights reserved.
   5  *
   6  *   Redistribution and use in source and binary forms, with or without
   7  *   modification, are permitted provided that the following conditions
   8  *   are met:
   9  *
  10  *     * Redistributions of source code must retain the above copyright
  11  *       notice, this list of conditions and the following disclaimer.
  12  *     * Redistributions in binary form must reproduce the above copyright
  13  *       notice, this list of conditions and the following disclaimer in
  14  *       the documentation and/or other materials provided with the
  15  *       distribution.
  16  *     * Neither the name of Intel Corporation nor the names of its
  17  *       contributors may be used to endorse or promote products derived
  18  *       from this software without specific prior written permission.
  19  *
  20  *   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  21  *   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  22  *   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  23  *   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  24  *   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  25  *   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  26  *   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  27  *   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  28  *   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  29  *   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  30  *   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  31  */
  32
  33 #include <rte_common.h>
  34 #include <rte_config.h>
  35 #include <rte_hexdump.h>
  36 #include <rte_cryptodev.h>
  37 #include <rte_cryptodev_pmd.h>
  38 #include <rte_cryptodev_vdev.h>
  39 #include <rte_vdev.h>
  40 #include <rte_malloc.h>
  41 #include <rte_cpuflags.h>
  42 #include <rte_byteorder.h>
  43
  44 #include "aesni_gcm_pmd_private.h"
  45
  46 static uint8_t cryptodev_driver_id;
  47
  48 /** Parse crypto xform chain and set private session parameters */
  49 int
  50 aesni_gcm_set_session_parameters(const struct aesni_gcm_ops *gcm_ops,
  51                 struct aesni_gcm_session *sess,
  52                 const struct rte_crypto_sym_xform *xform)
  53 {
  54         const struct rte_crypto_sym_xform *auth_xform;
  55         const struct rte_crypto_sym_xform *aead_xform;
  56         uint16_t digest_length;
  57         uint8_t key_length;
  58         uint8_t *key;
  59
  60         /* AES-GMAC */
  61         if (xform->type == RTE_CRYPTO_SYM_XFORM_AUTH) {
  62                 auth_xform = xform;
  63                 if (auth_xform->auth.algo != RTE_CRYPTO_AUTH_AES_GMAC) {
  64                         GCM_LOG_ERR("Only AES GMAC is supported as an "
  65                                         "authentication only algorithm");
  66                         return -ENOTSUP;
  67                 }
  68                 /* Set IV parameters */
  69                 sess->iv.offset = auth_xform->auth.iv.offset;
  70                 sess->iv.length = auth_xform->auth.iv.length;
  71
  72                 /* Select Crypto operation */
  73                 if (auth_xform->auth.op == RTE_CRYPTO_AUTH_OP_GENERATE)
  74                         sess->op = AESNI_GMAC_OP_GENERATE;
  75                 else
  76                         sess->op = AESNI_GMAC_OP_VERIFY;
  77
  78                 key_length = auth_xform->auth.key.length;
  79                 key = auth_xform->auth.key.data;
  80                 digest_length = auth_xform->auth.digest_length;
  81
  82         /* AES-GCM */
  83         } else if (xform->type == RTE_CRYPTO_SYM_XFORM_AEAD) {
  84                 aead_xform = xform;
  85
  86                 if (aead_xform->aead.algo != RTE_CRYPTO_AEAD_AES_GCM) {
  87                         GCM_LOG_ERR("The only combined operation "
  88                                                 "supported is AES GCM");
  89                         return -ENOTSUP;
  90                 }
  91
  92                 /* Set IV parameters */
  93                 sess->iv.offset = aead_xform->aead.iv.offset;
  94                 sess->iv.length = aead_xform->aead.iv.length;
  95
  96                 /* Select Crypto operation */
  97                 if (aead_xform->aead.op == RTE_CRYPTO_AEAD_OP_ENCRYPT)
  98                         sess->op = AESNI_GCM_OP_AUTHENTICATED_ENCRYPTION;
  99                 else
 100                         sess->op = AESNI_GCM_OP_AUTHENTICATED_DECRYPTION;
 101
 102                 key_length = aead_xform->aead.key.length;
 103                 key = aead_xform->aead.key.data;
 104
 105                 sess->aad_length = aead_xform->aead.aad_length;
 106                 digest_length = aead_xform->aead.digest_length;
 107         } else {
 108                 GCM_LOG_ERR("Wrong xform type, has to be AEAD or authentication");
 109                 return -ENOTSUP;
 110         }
 111
 112
 113         /* IV check */
 114         if (sess->iv.length != 16 && sess->iv.length != 12 &&
 115                         sess->iv.length != 0) {
 116                 GCM_LOG_ERR("Wrong IV length");
 117                 return -EINVAL;
 118         }
 119
 120         /* Check key length and calculate GCM pre-compute. */
 121         switch (key_length) {
 122         case 16:
 123                 sess->key = AESNI_GCM_KEY_128;
 124                 break;
 125         case 24:
 126                 sess->key = AESNI_GCM_KEY_192;
 127                 break;
 128         case 32:
 129                 sess->key = AESNI_GCM_KEY_256;
 130                 break;
 131         default:
 132                 GCM_LOG_ERR("Invalid key length");
 133                 return -EINVAL;
 134         }
 135
 136         gcm_ops[sess->key].precomp(key, &sess->gdata_key);
 137
 138         /* Digest check */
 139         if (digest_length != 16 &&
 140                         digest_length != 12 &&
 141                         digest_length != 8) {
 142                 GCM_LOG_ERR("digest");
 143                 return -EINVAL;
 144         }
 145         sess->digest_length = digest_length;
 146
 147         return 0;
 148 }
 149
 150 /** Get gcm session */
 151 static struct aesni_gcm_session *
 152 aesni_gcm_get_session(struct aesni_gcm_qp *qp, struct rte_crypto_op *op)
 153 {
 154         struct aesni_gcm_session *sess = NULL;
 155         struct rte_crypto_sym_op *sym_op = op->sym;
 156
 157         if (op->sess_type == RTE_CRYPTO_OP_WITH_SESSION) {
 158                 if (likely(sym_op->session != NULL))
 159                         sess = (struct aesni_gcm_session *)
 160                                         get_session_private_data(
 161                                         sym_op->session,
 162                                         cryptodev_driver_id);
 163         } else  {
 164                 void *_sess;
 165                 void *_sess_private_data = NULL;
 166
 167                 if (rte_mempool_get(qp->sess_mp, (void **)&_sess))
 168                         return NULL;
 169
 170                 if (rte_mempool_get(qp->sess_mp, (void **)&_sess_private_data))
 171                         return NULL;
 172
 173                 sess = (struct aesni_gcm_session *)_sess_private_data;
 174
 175                 if (unlikely(aesni_gcm_set_session_parameters(qp->ops,
 176                                 sess, sym_op->xform) != 0)) {
 177                         rte_mempool_put(qp->sess_mp, _sess);
 178                         rte_mempool_put(qp->sess_mp, _sess_private_data);
 179                         sess = NULL;
 180                 }
 181                 sym_op->session = (struct rte_cryptodev_sym_session *)_sess;
 182                 set_session_private_data(sym_op->session, cryptodev_driver_id,
 183                         _sess_private_data);
 184         }
 185
 186         if (unlikely(sess == NULL))
 187                 op->status = RTE_CRYPTO_OP_STATUS_INVALID_SESSION;
 188
 189         return sess;
 190 }
 191
 192 /**
 193  * Process a crypto operation, calling
 194  * the GCM API from the multi buffer library.
 195  *
 196  * @param       qp              queue pair
 197  * @param       op              symmetric crypto operation
 198  * @param       session         GCM session
 199  *
 200  * @return
 201  *
 202  */
 203 static int
 204 process_gcm_crypto_op(struct aesni_gcm_qp *qp, struct rte_crypto_op *op,
 205                 struct aesni_gcm_session *session)
 206 {
 207         uint8_t *src, *dst;
 208         uint8_t *iv_ptr;
 209         struct rte_crypto_sym_op *sym_op = op->sym;
 210         struct rte_mbuf *m_src = sym_op->m_src;
 211         uint32_t offset, data_offset, data_length;
 212         uint32_t part_len, total_len, data_len;
 213
 214         if (session->op == AESNI_GCM_OP_AUTHENTICATED_ENCRYPTION ||
 215                         session->op == AESNI_GCM_OP_AUTHENTICATED_DECRYPTION) {
 216                 offset = sym_op->aead.data.offset;
 217                 data_offset = offset;
 218                 data_length = sym_op->aead.data.length;
 219         } else {
 220                 offset = sym_op->auth.data.offset;
 221                 data_offset = offset;
 222                 data_length = sym_op->auth.data.length;
 223         }
 224
 225         RTE_ASSERT(m_src != NULL);
 226
 227         while (offset >= m_src->data_len) {
 228                 offset -= m_src->data_len;
 229                 m_src = m_src->next;
 230
 231                 RTE_ASSERT(m_src != NULL);
 232         }
 233
 234         data_len = m_src->data_len - offset;
 235         part_len = (data_len < data_length) ? data_len :
 236                         data_length;
 237
 238         /* Destination buffer is required when segmented source buffer */
 239         RTE_ASSERT((part_len == data_length) ||
 240                         ((part_len != data_length) &&
 241                                         (sym_op->m_dst != NULL)));
 242         /* Segmented destination buffer is not supported */
 243         RTE_ASSERT((sym_op->m_dst == NULL) ||
 244                         ((sym_op->m_dst != NULL) &&
 245                                         rte_pktmbuf_is_contiguous(sym_op->m_dst)));
 246
 247
 248         dst = sym_op->m_dst ?
 249                         rte_pktmbuf_mtod_offset(sym_op->m_dst, uint8_t *,
 250                                         data_offset) :
 251                         rte_pktmbuf_mtod_offset(sym_op->m_src, uint8_t *,
 252                                         data_offset);
 253
 254         src = rte_pktmbuf_mtod_offset(m_src, uint8_t *, offset);
 255
 256         iv_ptr = rte_crypto_op_ctod_offset(op, uint8_t *,
 257                                 session->iv.offset);
 258         /*
 259          * GCM working in 12B IV mode => 16B pre-counter block we need
 260          * to set BE LSB to 1, driver expects that 16B is allocated
 261          */
 262         if (session->iv.length == 12) {
 263                 uint32_t *iv_padd = (uint32_t *)&(iv_ptr[12]);
 264                 *iv_padd = rte_bswap32(1);
 265         }
 266
 267         if (session->op == AESNI_GCM_OP_AUTHENTICATED_ENCRYPTION) {
 268
 269                 qp->ops[session->key].init(&session->gdata_key,
 270                                 &qp->gdata_ctx,
 271                                 iv_ptr,
 272                                 sym_op->aead.aad.data,
 273                                 (uint64_t)session->aad_length);
 274
 275                 qp->ops[session->key].update_enc(&session->gdata_key,
 276                                 &qp->gdata_ctx, dst, src,
 277                                 (uint64_t)part_len);
 278                 total_len = data_length - part_len;
 279
 280                 while (total_len) {
 281                         dst += part_len;
 282                         m_src = m_src->next;
 283
 284                         RTE_ASSERT(m_src != NULL);
 285
 286                         src = rte_pktmbuf_mtod(m_src, uint8_t *);
 287                         part_len = (m_src->data_len < total_len) ?
 288                                         m_src->data_len : total_len;
 289
 290                         qp->ops[session->key].update_enc(&session->gdata_key,
 291                                         &qp->gdata_ctx, dst, src,
 292                                         (uint64_t)part_len);
 293                         total_len -= part_len;
 294                 }
 295
 296                 qp->ops[session->key].finalize(&session->gdata_key,
 297                                 &qp->gdata_ctx,
 298                                 sym_op->aead.digest.data,
 299                                 (uint64_t)session->digest_length);
 300         } else if (session->op == AESNI_GCM_OP_AUTHENTICATED_DECRYPTION) {
 301                 uint8_t *auth_tag = (uint8_t *)rte_pktmbuf_append(sym_op->m_dst ?
 302                                 sym_op->m_dst : sym_op->m_src,
 303                                 session->digest_length);
 304
 305                 if (!auth_tag) {
 306                         GCM_LOG_ERR("auth_tag");
 307                         return -1;
 308                 }
 309
 310                 qp->ops[session->key].init(&session->gdata_key,
 311                                 &qp->gdata_ctx,
 312                                 iv_ptr,
 313                                 sym_op->aead.aad.data,
 314                                 (uint64_t)session->aad_length);
 315
 316                 qp->ops[session->key].update_dec(&session->gdata_key,
 317                                 &qp->gdata_ctx, dst, src,
 318                                 (uint64_t)part_len);
 319                 total_len = data_length - part_len;
 320
 321                 while (total_len) {
 322                         dst += part_len;
 323                         m_src = m_src->next;
 324
 325                         RTE_ASSERT(m_src != NULL);
 326
 327                         src = rte_pktmbuf_mtod(m_src, uint8_t *);
 328                         part_len = (m_src->data_len < total_len) ?
 329                                         m_src->data_len : total_len;
 330
 331                         qp->ops[session->key].update_dec(&session->gdata_key,
 332                                         &qp->gdata_ctx,
 333                                         dst, src,
 334                                         (uint64_t)part_len);
 335                         total_len -= part_len;
 336                 }
 337
 338                 qp->ops[session->key].finalize(&session->gdata_key,
 339                                 &qp->gdata_ctx,
 340                                 auth_tag,
 341                                 (uint64_t)session->digest_length);
 342         } else if (session->op == AESNI_GMAC_OP_GENERATE) {
 343                 qp->ops[session->key].init(&session->gdata_key,
 344                                 &qp->gdata_ctx,
 345                                 iv_ptr,
 346                                 src,
 347                                 (uint64_t)data_length);
 348                 qp->ops[session->key].finalize(&session->gdata_key,
 349                                 &qp->gdata_ctx,
 350                                 sym_op->auth.digest.data,
 351                                 (uint64_t)session->digest_length);
 352         } else { /* AESNI_GMAC_OP_VERIFY */
 353                 uint8_t *auth_tag = (uint8_t *)rte_pktmbuf_append(sym_op->m_dst ?
 354                                 sym_op->m_dst : sym_op->m_src,
 355                                 session->digest_length);
 356
 357                 if (!auth_tag) {
 358                         GCM_LOG_ERR("auth_tag");
 359                         return -1;
 360                 }
 361
 362                 qp->ops[session->key].init(&session->gdata_key,
 363                                 &qp->gdata_ctx,
 364                                 iv_ptr,
 365                                 src,
 366                                 (uint64_t)data_length);
 367
 368                 qp->ops[session->key].finalize(&session->gdata_key,
 369                                 &qp->gdata_ctx,
 370                                 auth_tag,
 371                                 (uint64_t)session->digest_length);
 372         }
 373
 374         return 0;
 375 }
 376
 377 /**
 378  * Process a completed job and return rte_mbuf which job processed
 379  *
 380  * @param job   JOB_AES_HMAC job to process
 381  *
 382  * @return
 383  * - Returns processed mbuf which is trimmed of output digest used in
 384  * verification of supplied digest in the case of a HASH_CIPHER operation
 385  * - Returns NULL on invalid job
 386  */
 387 static void
 388 post_process_gcm_crypto_op(struct rte_crypto_op *op,
 389                 struct aesni_gcm_session *session)
 390 {
 391         struct rte_mbuf *m = op->sym->m_dst ? op->sym->m_dst : op->sym->m_src;
 392
 393         op->status = RTE_CRYPTO_OP_STATUS_SUCCESS;
 394
 395         /* Verify digest if required */
 396         if (session->op == AESNI_GCM_OP_AUTHENTICATED_DECRYPTION ||
 397                         session->op == AESNI_GMAC_OP_VERIFY) {
 398                 uint8_t *digest;
 399
 400                 uint8_t *tag = rte_pktmbuf_mtod_offset(m, uint8_t *,
 401                                 m->data_len - session->digest_length);
 402
 403                 if (session->op == AESNI_GMAC_OP_VERIFY)
 404                         digest = op->sym->auth.digest.data;
 405                 else
 406                         digest = op->sym->aead.digest.data;
 407
 408 #ifdef RTE_LIBRTE_PMD_AESNI_GCM_DEBUG
 409                 rte_hexdump(stdout, "auth tag (orig):",
 410                                 digest, session->digest_length);
 411                 rte_hexdump(stdout, "auth tag (calc):",
 412                                 tag, session->digest_length);
 413 #endif
 414
 415                 if (memcmp(tag, digest, session->digest_length) != 0)
 416                         op->status = RTE_CRYPTO_OP_STATUS_AUTH_FAILED;
 417
 418                 /* trim area used for digest from mbuf */
 419                 rte_pktmbuf_trim(m, session->digest_length);
 420         }
 421 }
 422
 423 /**
 424  * Process a completed GCM request
 425  *
 426  * @param qp            Queue Pair to process
 427  * @param op            Crypto operation
 428  * @param job           JOB_AES_HMAC job
 429  *
 430  * @return
 431  * - Number of processed jobs
 432  */
 433 static void
 434 handle_completed_gcm_crypto_op(struct aesni_gcm_qp *qp,
 435                 struct rte_crypto_op *op,
 436                 struct aesni_gcm_session *sess)
 437 {
 438         post_process_gcm_crypto_op(op, sess);
 439
 440         /* Free session if a session-less crypto op */
 441         if (op->sess_type == RTE_CRYPTO_OP_SESSIONLESS) {
 442                 memset(sess, 0, sizeof(struct aesni_gcm_session));
 443                 memset(op->sym->session, 0,
 444                                 rte_cryptodev_get_header_session_size());
 445                 rte_mempool_put(qp->sess_mp, sess);
 446                 rte_mempool_put(qp->sess_mp, op->sym->session);
 447                 op->sym->session = NULL;
 448         }
 449 }
 450
 451 static uint16_t
 452 aesni_gcm_pmd_dequeue_burst(void *queue_pair,
 453                 struct rte_crypto_op **ops, uint16_t nb_ops)
 454 {
 455         struct aesni_gcm_session *sess;
 456         struct aesni_gcm_qp *qp = queue_pair;
 457
 458         int retval = 0;
 459         unsigned int i, nb_dequeued;
 460
 461         nb_dequeued = rte_ring_dequeue_burst(qp->processed_pkts,
 462                         (void **)ops, nb_ops, NULL);
 463
 464         for (i = 0; i < nb_dequeued; i++) {
 465
 466                 sess = aesni_gcm_get_session(qp, ops[i]);
 467                 if (unlikely(sess == NULL)) {
 468                         ops[i]->status = RTE_CRYPTO_OP_STATUS_INVALID_ARGS;
 469                         qp->qp_stats.dequeue_err_count++;
 470                         break;
 471                 }
 472
 473                 retval = process_gcm_crypto_op(qp, ops[i], sess);
 474                 if (retval < 0) {
 475                         ops[i]->status = RTE_CRYPTO_OP_STATUS_INVALID_ARGS;
 476                         qp->qp_stats.dequeue_err_count++;
 477                         break;
 478                 }
 479
 480                 handle_completed_gcm_crypto_op(qp, ops[i], sess);
 481         }
 482
 483         qp->qp_stats.dequeued_count += i;
 484
 485         return i;
 486 }
 487
 488 static uint16_t
 489 aesni_gcm_pmd_enqueue_burst(void *queue_pair,
 490                 struct rte_crypto_op **ops, uint16_t nb_ops)
 491 {
 492         struct aesni_gcm_qp *qp = queue_pair;
 493
 494         unsigned int nb_enqueued;
 495
 496         nb_enqueued = rte_ring_enqueue_burst(qp->processed_pkts,
 497                         (void **)ops, nb_ops, NULL);
 498         qp->qp_stats.enqueued_count += nb_enqueued;
 499
 500         return nb_enqueued;
 501 }
 502
 503 static int aesni_gcm_remove(struct rte_vdev_device *vdev);
 504
 505 static int
 506 aesni_gcm_create(const char *name,
 507                 struct rte_vdev_device *vdev,
 508                 struct rte_crypto_vdev_init_params *init_params)
 509 {
 510         struct rte_cryptodev *dev;
 511         struct aesni_gcm_private *internals;
 512         enum aesni_gcm_vector_mode vector_mode;
 513
 514         if (init_params->name[0] == '\0')
 515                 snprintf(init_params->name, sizeof(init_params->name),
 516                                 "%s", name);
 517
 518         /* Check CPU for support for AES instruction set */
 519         if (!rte_cpu_get_flag_enabled(RTE_CPUFLAG_AES)) {
 520                 GCM_LOG_ERR("AES instructions not supported by CPU");
 521                 return -EFAULT;
 522         }
 523
 524         /* Check CPU for supported vector instruction set */
 525         if (rte_cpu_get_flag_enabled(RTE_CPUFLAG_AVX2))
 526                 vector_mode = RTE_AESNI_GCM_AVX2;
 527         else if (rte_cpu_get_flag_enabled(RTE_CPUFLAG_AVX))
 528                 vector_mode = RTE_AESNI_GCM_AVX;
 529         else
 530                 vector_mode = RTE_AESNI_GCM_SSE;
 531
 532         dev = rte_cryptodev_vdev_pmd_init(init_params->name,
 533                         sizeof(struct aesni_gcm_private), init_params->socket_id,
 534                         vdev);
 535         if (dev == NULL) {
 536                 GCM_LOG_ERR("failed to create cryptodev vdev");
 537                 goto init_error;
 538         }
 539
 540         dev->driver_id = cryptodev_driver_id;
 541         dev->dev_ops = rte_aesni_gcm_pmd_ops;
 542
 543         /* register rx/tx burst functions for data path */
 544         dev->dequeue_burst = aesni_gcm_pmd_dequeue_burst;
 545         dev->enqueue_burst = aesni_gcm_pmd_enqueue_burst;
 546
 547         dev->feature_flags = RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO |
 548                         RTE_CRYPTODEV_FF_SYM_OPERATION_CHAINING |
 549                         RTE_CRYPTODEV_FF_CPU_AESNI |
 550                         RTE_CRYPTODEV_FF_MBUF_SCATTER_GATHER;
 551
 552         switch (vector_mode) {
 553         case RTE_AESNI_GCM_SSE:
 554                 dev->feature_flags |= RTE_CRYPTODEV_FF_CPU_SSE;
 555                 break;
 556         case RTE_AESNI_GCM_AVX:
 557                 dev->feature_flags |= RTE_CRYPTODEV_FF_CPU_AVX;
 558                 break;
 559         case RTE_AESNI_GCM_AVX2:
 560                 dev->feature_flags |= RTE_CRYPTODEV_FF_CPU_AVX2;
 561                 break;
 562         default:
 563                 break;
 564         }
 565
 566         internals = dev->data->dev_private;
 567
 568         internals->vector_mode = vector_mode;
 569
 570         internals->max_nb_queue_pairs = init_params->max_nb_queue_pairs;
 571         internals->max_nb_sessions = init_params->max_nb_sessions;
 572
 573         return 0;
 574
 575 init_error:
 576         GCM_LOG_ERR("driver %s: create failed", init_params->name);
 577
 578         aesni_gcm_remove(vdev);
 579         return -EFAULT;
 580 }
 581
 582 static int
 583 aesni_gcm_probe(struct rte_vdev_device *vdev)
 584 {
 585         struct rte_crypto_vdev_init_params init_params = {
 586                 RTE_CRYPTODEV_VDEV_DEFAULT_MAX_NB_QUEUE_PAIRS,
 587                 RTE_CRYPTODEV_VDEV_DEFAULT_MAX_NB_SESSIONS,
 588                 rte_socket_id(),
 589                 {0}
 590         };
 591         const char *name;
 592         const char *input_args;
 593
 594         name = rte_vdev_device_name(vdev);
 595         if (name == NULL)
 596                 return -EINVAL;
 597         input_args = rte_vdev_device_args(vdev);
 598         rte_cryptodev_vdev_parse_init_params(&init_params, input_args);
 599
 600         RTE_LOG(INFO, PMD, "Initialising %s on NUMA node %d\n", name,
 601                         init_params.socket_id);
 602         if (init_params.name[0] != '\0')
 603                 RTE_LOG(INFO, PMD, "  User defined name = %s\n",
 604                         init_params.name);
 605         RTE_LOG(INFO, PMD, "  Max number of queue pairs = %d\n",
 606                         init_params.max_nb_queue_pairs);
 607         RTE_LOG(INFO, PMD, "  Max number of sessions = %d\n",
 608                         init_params.max_nb_sessions);
 609
 610         return aesni_gcm_create(name, vdev, &init_params);
 611 }
 612
 613 static int
 614 aesni_gcm_remove(struct rte_vdev_device *vdev)
 615 {
 616         const char *name;
 617
 618         name = rte_vdev_device_name(vdev);
 619         if (name == NULL)
 620                 return -EINVAL;
 621
 622         GCM_LOG_INFO("Closing AESNI crypto device %s on numa socket %u\n",
 623                         name, rte_socket_id());
 624
 625         return 0;
 626 }
 627
 628 static struct rte_vdev_driver aesni_gcm_pmd_drv = {
 629         .probe = aesni_gcm_probe,
 630         .remove = aesni_gcm_remove
 631 };
 632
 633 RTE_PMD_REGISTER_VDEV(CRYPTODEV_NAME_AESNI_GCM_PMD, aesni_gcm_pmd_drv);
 634 RTE_PMD_REGISTER_ALIAS(CRYPTODEV_NAME_AESNI_GCM_PMD, cryptodev_aesni_gcm_pmd);
 635 RTE_PMD_REGISTER_PARAM_STRING(CRYPTODEV_NAME_AESNI_GCM_PMD,
 636         "max_nb_queue_pairs=<int> "
 637         "max_nb_sessions=<int> "
 638         "socket_id=<int>");
 639 RTE_PMD_REGISTER_CRYPTO_DRIVER(aesni_gcm_pmd_drv, cryptodev_driver_id);