examples/l2fwd-crypto: fix session mempool size

The session mempool size for this application depends
on the number of crypto devices that are capable
of performing the operation given by the parameters on the app.

However, previously this calculation was done before all devices
were checked, resulting in an incorrect number of sessions
required.

Now the calculation of the devices to be used is done first
(checking the capabilities of the enabled devices),
followed by the creation of the session pool, resulting
in a correct number of objects needed for the sessions
to be created.

Fixes: e3bcb99a5e13 ("examples/l2fwd-crypto: limit number of sessions")

Signed-off-by: Pablo de Lara <pablo.de.lara.guarch@intel.com>
Acked-by: Fiona Trahe <fiona.trahe@intel.com>

diff --git a/examples/l2fwd-crypto/main.c b/examples/l2fwd-crypto/main.c
index 15f6b85..a98190a 100644 (file)
--- a/examples/l2fwd-crypto/main.c
+++ b/examples/l2fwd-crypto/main.c
@@ -1960,11 +1960,252 @@ check_iv_param(const struct rte_crypto_param_range *iv_range_size,
        return 0;
 }
 
+static int
+check_capabilities(struct l2fwd_crypto_options *options, uint8_t cdev_id)
+{
+       struct rte_cryptodev_info dev_info;
+       const struct rte_cryptodev_capabilities *cap;
+
+       rte_cryptodev_info_get(cdev_id, &dev_info);
+
+       /* Set AEAD parameters */
+       if (options->xform_chain == L2FWD_CRYPTO_AEAD) {
+               /* Check if device supports AEAD algo */
+               cap = check_device_support_aead_algo(options, &dev_info,
+                                               cdev_id);
+               if (cap == NULL)
+                       return -1;
+
+               if (check_iv_param(&cap->sym.aead.iv_size,
+                               options->aead_iv_param,
+                               options->aead_iv_random_size,
+                               options->aead_iv.length) != 0) {
+                       RTE_LOG(DEBUG, USER1,
+                               "Device %u does not support IV length\n",
+                               cdev_id);
+                       return -1;
+               }
+
+               /*
+                * Check if length of provided AEAD key is supported
+                * by the algorithm chosen.
+                */
+               if (options->aead_key_param) {
+                       if (check_supported_size(
+                                       options->aead_xform.aead.key.length,
+                                       cap->sym.aead.key_size.min,
+                                       cap->sym.aead.key_size.max,
+                                       cap->sym.aead.key_size.increment)
+                                               != 0) {
+                               RTE_LOG(DEBUG, USER1,
+                                       "Device %u does not support "
+                                       "AEAD key length\n",
+                                       cdev_id);
+                               return -1;
+                       }
+               /*
+                * Check if length of the aead key to be randomly generated
+                * is supported by the algorithm chosen.
+                */
+               } else if (options->aead_key_random_size != -1) {
+                       if (check_supported_size(options->aead_key_random_size,
+                                       cap->sym.aead.key_size.min,
+                                       cap->sym.aead.key_size.max,
+                                       cap->sym.aead.key_size.increment)
+                                               != 0) {
+                               RTE_LOG(DEBUG, USER1,
+                                       "Device %u does not support "
+                                       "AEAD key length\n",
+                                       cdev_id);
+                               return -1;
+                       }
+               }
+
+
+               /*
+                * Check if length of provided AAD is supported
+                * by the algorithm chosen.
+                */
+               if (options->aad_param) {
+                       if (check_supported_size(options->aad.length,
+                                       cap->sym.aead.aad_size.min,
+                                       cap->sym.aead.aad_size.max,
+                                       cap->sym.aead.aad_size.increment)
+                                               != 0) {
+                               RTE_LOG(DEBUG, USER1,
+                                       "Device %u does not support "
+                                       "AAD length\n",
+                                       cdev_id);
+                               return -1;
+                       }
+               /*
+                * Check if length of AAD to be randomly generated
+                * is supported by the algorithm chosen.
+                */
+               } else if (options->aad_random_size != -1) {
+                       if (check_supported_size(options->aad_random_size,
+                                       cap->sym.aead.aad_size.min,
+                                       cap->sym.aead.aad_size.max,
+                                       cap->sym.aead.aad_size.increment)
+                                               != 0) {
+                               RTE_LOG(DEBUG, USER1,
+                                       "Device %u does not support "
+                                       "AAD length\n",
+                                       cdev_id);
+                               return -1;
+                       }
+               }
+
+               /* Check if digest size is supported by the algorithm. */
+               if (options->digest_size != -1) {
+                       if (check_supported_size(options->digest_size,
+                                       cap->sym.aead.digest_size.min,
+                                       cap->sym.aead.digest_size.max,
+                                       cap->sym.aead.digest_size.increment)
+                                               != 0) {
+                               RTE_LOG(DEBUG, USER1,
+                                       "Device %u does not support "
+                                       "digest length\n",
+                                       cdev_id);
+                               return -1;
+                       }
+               }
+       }
+
+       /* Set cipher parameters */
+       if (options->xform_chain == L2FWD_CRYPTO_CIPHER_HASH ||
+                       options->xform_chain == L2FWD_CRYPTO_HASH_CIPHER ||
+                       options->xform_chain == L2FWD_CRYPTO_CIPHER_ONLY) {
+               /* Check if device supports cipher algo */
+               cap = check_device_support_cipher_algo(options, &dev_info,
+                                               cdev_id);
+               if (cap == NULL)
+                       return -1;
+
+               if (check_iv_param(&cap->sym.cipher.iv_size,
+                               options->cipher_iv_param,
+                               options->cipher_iv_random_size,
+                               options->cipher_iv.length) != 0) {
+                       RTE_LOG(DEBUG, USER1,
+                               "Device %u does not support IV length\n",
+                               cdev_id);
+                       return -1;
+               }
+
+               /*
+                * Check if length of provided cipher key is supported
+                * by the algorithm chosen.
+                */
+               if (options->ckey_param) {
+                       if (check_supported_size(
+                                       options->cipher_xform.cipher.key.length,
+                                       cap->sym.cipher.key_size.min,
+                                       cap->sym.cipher.key_size.max,
+                                       cap->sym.cipher.key_size.increment)
+                                               != 0) {
+                               RTE_LOG(DEBUG, USER1,
+                                       "Device %u does not support cipher "
+                                       "key length\n",
+                                       cdev_id);
+                               return -1;
+                       }
+               /*
+                * Check if length of the cipher key to be randomly generated
+                * is supported by the algorithm chosen.
+                */
+               } else if (options->ckey_random_size != -1) {
+                       if (check_supported_size(options->ckey_random_size,
+                                       cap->sym.cipher.key_size.min,
+                                       cap->sym.cipher.key_size.max,
+                                       cap->sym.cipher.key_size.increment)
+                                               != 0) {
+                               RTE_LOG(DEBUG, USER1,
+                                       "Device %u does not support cipher "
+                                       "key length\n",
+                                       cdev_id);
+                               return -1;
+                       }
+               }
+       }
+
+       /* Set auth parameters */
+       if (options->xform_chain == L2FWD_CRYPTO_CIPHER_HASH ||
+                       options->xform_chain == L2FWD_CRYPTO_HASH_CIPHER ||
+                       options->xform_chain == L2FWD_CRYPTO_HASH_ONLY) {
+               /* Check if device supports auth algo */
+               cap = check_device_support_auth_algo(options, &dev_info,
+                                               cdev_id);
+               if (cap == NULL)
+                       return -1;
+
+               if (check_iv_param(&cap->sym.auth.iv_size,
+                               options->auth_iv_param,
+                               options->auth_iv_random_size,
+                               options->auth_iv.length) != 0) {
+                       RTE_LOG(DEBUG, USER1,
+                               "Device %u does not support IV length\n",
+                               cdev_id);
+                       return -1;
+               }
+               /*
+                * Check if length of provided auth key is supported
+                * by the algorithm chosen.
+                */
+               if (options->akey_param) {
+                       if (check_supported_size(
+                                       options->auth_xform.auth.key.length,
+                                       cap->sym.auth.key_size.min,
+                                       cap->sym.auth.key_size.max,
+                                       cap->sym.auth.key_size.increment)
+                                               != 0) {
+                               RTE_LOG(DEBUG, USER1,
+                                       "Device %u does not support auth "
+                                       "key length\n",
+                                       cdev_id);
+                               return -1;
+                       }
+               /*
+                * Check if length of the auth key to be randomly generated
+                * is supported by the algorithm chosen.
+                */
+               } else if (options->akey_random_size != -1) {
+                       if (check_supported_size(options->akey_random_size,
+                                       cap->sym.auth.key_size.min,
+                                       cap->sym.auth.key_size.max,
+                                       cap->sym.auth.key_size.increment)
+                                               != 0) {
+                               RTE_LOG(DEBUG, USER1,
+                                       "Device %u does not support auth "
+                                       "key length\n",
+                                       cdev_id);
+                               return -1;
+                       }
+               }
+
+               /* Check if digest size is supported by the algorithm. */
+               if (options->digest_size != -1) {
+                       if (check_supported_size(options->digest_size,
+                                       cap->sym.auth.digest_size.min,
+                                       cap->sym.auth.digest_size.max,
+                                       cap->sym.auth.digest_size.increment)
+                                               != 0) {
+                               RTE_LOG(DEBUG, USER1,
+                                       "Device %u does not support "
+                                       "digest length\n",
+                                       cdev_id);
+                               return -1;
+                       }
+               }
+       }
+
+       return 0;
+}
+
 static int
 initialize_cryptodevs(struct l2fwd_crypto_options *options, unsigned nb_ports,
                uint8_t *enabled_cdevs)
 {
-       unsigned int cdev_id, cdev_count, enabled_cdev_count = 0;
+       uint8_t cdev_id, cdev_count, enabled_cdev_count = 0;
        const struct rte_cryptodev_capabilities *cap;
        unsigned int sess_sz, max_sess_sz = 0;
        uint32_t sessions_needed = 0;
@@ -1976,16 +2217,31 @@ initialize_cryptodevs(struct l2fwd_crypto_options *options, unsigned nb_ports,
                return -1;
        }
 
-       for (cdev_id = 0; cdev_id < cdev_count; cdev_id++) {
+       for (cdev_id = 0; cdev_id < cdev_count && enabled_cdev_count < nb_ports;
+                       cdev_id++) {
+               if (check_cryptodev_mask(options, cdev_id) < 0)
+                       continue;
+
+               if (check_capabilities(options, cdev_id) < 0)
+                       continue;
+
                sess_sz = rte_cryptodev_sym_get_private_session_size(cdev_id);
                if (sess_sz > max_sess_sz)
                        max_sess_sz = sess_sz;
+
+               l2fwd_enabled_crypto_mask |= (((uint64_t)1) << cdev_id);
+
+               enabled_cdevs[cdev_id] = 1;
+               enabled_cdev_count++;
        }
 
-       for (cdev_id = 0; cdev_id < cdev_count && enabled_cdev_count < nb_ports;
-                       cdev_id++) {
+       for (cdev_id = 0; cdev_id < cdev_count; cdev_id++) {
                struct rte_cryptodev_qp_conf qp_conf;
                struct rte_cryptodev_info dev_info;
+
+               if (enabled_cdevs[cdev_id] == 0)
+                       continue;
+
                retval = rte_cryptodev_socket_id(cdev_id);
 
                if (retval < 0) {
@@ -2000,9 +2256,6 @@ initialize_cryptodevs(struct l2fwd_crypto_options *options, unsigned nb_ports,
                        .socket_id = socket_id,
                };
 
-               if (check_cryptodev_mask(options, (uint8_t)cdev_id))
-                       continue;
-
                rte_cryptodev_info_get(cdev_id, &dev_info);
 
                /*
@@ -2349,11 +2602,6 @@ initialize_cryptodevs(struct l2fwd_crypto_options *options, unsigned nb_ports,
                                        cdev_id, retval);
                        return -1;
                }
-
-               l2fwd_enabled_crypto_mask |= (((uint64_t)1) << cdev_id);
-
-               enabled_cdevs[cdev_id] = 1;
-               enabled_cdev_count++;
        }
 
        return enabled_cdev_count;