From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from mga17.intel.com (mga17.intel.com [192.55.52.151]) by dpdk.org (Postfix) with ESMTP id CA3011B7F2 for ; Thu, 10 Jan 2019 15:50:29 +0100 (CET) X-Amp-Result: SKIPPED(no attachment in message) X-Amp-File-Uploaded: False Received: from orsmga001.jf.intel.com ([10.7.209.18]) by fmsmga107.fm.intel.com with ESMTP/TLS/DHE-RSA-AES256-GCM-SHA384; 10 Jan 2019 06:50:29 -0800 X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="5.56,461,1539673200"; d="scan'208";a="126595027" Received: from silpixa00398673.ir.intel.com (HELO silpixa00398673.ger.corp.intel.com) ([10.237.223.54]) by orsmga001.jf.intel.com with ESMTP; 10 Jan 2019 06:50:27 -0800 From: Fan Zhang To: dev@dpdk.org Cc: akhil.goyal@nxp.com, pablo.de.lara.guarch@intel.com, fiona.trahe@intel.com Date: Thu, 10 Jan 2019 14:50:12 +0000 Message-Id: <20190110145022.42883-3-roy.fan.zhang@intel.com> X-Mailer: git-send-email 2.13.6 In-Reply-To: <20190110145022.42883-1-roy.fan.zhang@intel.com> References: <20190109225609.20590-1-roy.fan.zhang@intel.com> <20190110145022.42883-1-roy.fan.zhang@intel.com> Subject: [dpdk-dev] [PATCH v5 02/12] cryptodev: add sym session mempool create X-BeenThere: dev@dpdk.org X-Mailman-Version: 2.1.15 Precedence: list List-Id: DPDK patches and discussions List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-List-Received-Date: Thu, 10 Jan 2019 14:50:30 -0000 This patch adds a new API "rte_cryptodev_sym_session_pool_create()" to cryptodev library. All applications are required to use this API to create sym session mempool as it adds private data and nb_drivers information to the mempool private data. Signed-off-by: Fan Zhang Acked-by: Fiona Trahe --- doc/guides/prog_guide/cryptodev_lib.rst | 69 ++++++++++++++++++-------- doc/guides/rel_notes/release_19_02.rst | 5 ++ lib/librte_cryptodev/rte_cryptodev.c | 50 +++++++++++++++++++ lib/librte_cryptodev/rte_cryptodev.h | 31 ++++++++++++ lib/librte_cryptodev/rte_cryptodev_version.map | 1 + 5 files changed, 134 insertions(+), 22 deletions(-) diff --git a/doc/guides/prog_guide/cryptodev_lib.rst b/doc/guides/prog_guide/cryptodev_lib.rst index 0bb6a8841..f68fb72d3 100644 --- a/doc/guides/prog_guide/cryptodev_lib.rst +++ b/doc/guides/prog_guide/cryptodev_lib.rst @@ -455,21 +455,23 @@ Crypto workloads. .. figure:: img/cryptodev_sym_sess.* -The Crypto device framework provides APIs to allocate and initialize sessions -for crypto devices, where sessions are mempool objects. -It is the application's responsibility to create and manage the session mempools. -This approach allows for different scenarios such as having a single session -mempool for all crypto devices (where the mempool object size is big -enough to hold the private session of any crypto device), as well as having -multiple session mempools of different sizes for better memory usage. - -An application can use ``rte_cryptodev_sym_get_private_session_size()`` to -get the private session size of given crypto device. This function would allow -an application to calculate the max device session size of all crypto devices -to create a single session mempool. -If instead an application creates multiple session mempools, the Crypto device -framework also provides ``rte_cryptodev_sym_get_header_session_size`` to get -the size of an uninitialized session. +The Crypto device framework provides APIs to create session mempool and allocate +and initialize sessions for crypto devices, where sessions are mempool objects. +The application has to use ``rte_cryptodev_sym_session_pool_create()`` to +create the session header mempool that creates a mempool with proper element +size automatically and stores necessary information for safely accessing the +session in the mempool's private data field. + +To create a mempool for storing session private data, the application has two +options. The first is to create another mempool with elt size equal to or +bigger than the maximum session private data size of all crypto devices that +will share the same session header. The creation of the mempool shall use the +traditional ``rte_mempool_create()`` with the correct ``elt_size``. The other +option is to change the ``elt_size`` parameter in +``rte_cryptodev_sym_session_pool_create()`` to the correct value. The first +option is more complex to implement but may result in better memory usage as +a session header normally takes smaller memory footprint as the session private +data. Once the session mempools have been created, ``rte_cryptodev_sym_session_create()`` is used to allocate an uninitialized session from the given mempool. @@ -623,7 +625,8 @@ using one of the crypto PMDs available in DPDK. #define IV_OFFSET (sizeof(struct rte_crypto_op) + \ sizeof(struct rte_crypto_sym_op)) - struct rte_mempool *mbuf_pool, *crypto_op_pool, *session_pool; + struct rte_mempool *mbuf_pool, *crypto_op_pool; + struct rte_mempool *session_pool, *session_priv_pool; unsigned int session_size; int ret; @@ -673,28 +676,50 @@ using one of the crypto PMDs available in DPDK. /* Get private session data size. */ session_size = rte_cryptodev_sym_get_private_session_size(cdev_id); + #ifdef USE_TWO_MEMPOOLS + /* Create session mempool for the session header. */ + session_pool = rte_cryptodev_sym_session_pool_create("session_pool", + MAX_SESSIONS, + 0, + POOL_CACHE_SIZE, + 0, + socket_id); + /* - * Create session mempool, with two objects per session, - * one for the session header and another one for the + * Create session private data mempool for the * private session data for the crypto device. */ - session_pool = rte_mempool_create("session_pool", - MAX_SESSIONS * 2, + session_priv_pool = rte_mempool_create("session_pool", + MAX_SESSIONS, session_size, POOL_CACHE_SIZE, 0, NULL, NULL, NULL, NULL, socket_id, 0); + #else + /* Use of the same mempool for session header and private data */ + session_pool = rte_cryptodev_sym_session_pool_create("session_pool", + MAX_SESSIONS * 2, + session_size, + POOL_CACHE_SIZE, + 0, + socket_id); + + session_priv_pool = session_pool; + + #endif + /* Configure the crypto device. */ struct rte_cryptodev_config conf = { .nb_queue_pairs = 1, .socket_id = socket_id }; + struct rte_cryptodev_qp_conf qp_conf = { .nb_descriptors = 2048, .mp_session = session_pool, - .mp_session_private = session_pool + .mp_session_private = session_priv_pool }; if (rte_cryptodev_configure(cdev_id, &conf) < 0) @@ -732,7 +757,7 @@ using one of the crypto PMDs available in DPDK. rte_exit(EXIT_FAILURE, "Session could not be created\n"); if (rte_cryptodev_sym_session_init(cdev_id, session, - &cipher_xform, session_pool) < 0) + &cipher_xform, session_priv_pool) < 0) rte_exit(EXIT_FAILURE, "Session could not be initialized " "for the crypto device\n"); diff --git a/doc/guides/rel_notes/release_19_02.rst b/doc/guides/rel_notes/release_19_02.rst index 527705926..ace4bcfe7 100644 --- a/doc/guides/rel_notes/release_19_02.rst +++ b/doc/guides/rel_notes/release_19_02.rst @@ -167,6 +167,11 @@ API Changes * cryptodev: The parameter ``session_pool`` in the function ``rte_cryptodev_queue_pair_setup()`` is removed. +* cryptodev: a new function ``rte_cryptodev_sym_session_pool_create()`` is + introduced. This function is now mandatory when creating symmetric session + header mempool. Please note all crypto applications are required to use this + function from now on. + ABI Changes ----------- diff --git a/lib/librte_cryptodev/rte_cryptodev.c b/lib/librte_cryptodev/rte_cryptodev.c index 4929d0451..ccc4c2132 100644 --- a/lib/librte_cryptodev/rte_cryptodev.c +++ b/lib/librte_cryptodev/rte_cryptodev.c @@ -189,6 +189,16 @@ const char *rte_crypto_asym_op_strings[] = { [RTE_CRYPTO_ASYM_OP_SHARED_SECRET_COMPUTE] = "sharedsecret_compute", }; +/** + * The private data structure stored in the session mempool private data. + */ +struct rte_cryptodev_sym_session_pool_private_data { + uint16_t nb_drivers; + /**< number of elements in sess_data array */ + uint16_t user_data_sz; + /**< session user data will be placed after sess_data */ +}; + int rte_cryptodev_get_cipher_algo_enum(enum rte_crypto_cipher_algorithm *algo_enum, const char *algo_string) @@ -1223,6 +1233,46 @@ rte_cryptodev_asym_session_init(uint8_t dev_id, return 0; } +struct rte_mempool * __rte_experimental +rte_cryptodev_sym_session_pool_create(const char *name, uint32_t nb_elts, + uint32_t elt_size, uint32_t cache_size, uint16_t user_data_size, + int socket_id) +{ + struct rte_mempool *mp; + struct rte_cryptodev_sym_session_pool_private_data *pool_priv; + uint32_t obj_sz; + + obj_sz = rte_cryptodev_sym_get_header_session_size() + user_data_size; + if (obj_sz > elt_size) + CDEV_LOG_INFO("elt_size %u is expanded to %u\n", elt_size, + obj_sz); + else + obj_sz = elt_size; + + mp = rte_mempool_create(name, nb_elts, obj_sz, cache_size, + (uint32_t)(sizeof(*pool_priv)), + NULL, NULL, NULL, NULL, + socket_id, 0); + if (mp == NULL) { + CDEV_LOG_ERR("%s(name=%s) failed, rte_errno=%d\n", + __func__, name, rte_errno); + return NULL; + } + + pool_priv = rte_mempool_get_priv(mp); + if (!pool_priv) { + CDEV_LOG_ERR("%s(name=%s) failed to get private data\n", + __func__, name); + rte_mempool_free(mp); + return NULL; + } + + pool_priv->nb_drivers = nb_drivers; + pool_priv->user_data_sz = user_data_size; + + return mp; +} + struct rte_cryptodev_sym_session * rte_cryptodev_sym_session_create(struct rte_mempool *mp) { diff --git a/lib/librte_cryptodev/rte_cryptodev.h b/lib/librte_cryptodev/rte_cryptodev.h index f9e7507da..052213e1f 100644 --- a/lib/librte_cryptodev/rte_cryptodev.h +++ b/lib/librte_cryptodev/rte_cryptodev.h @@ -968,6 +968,37 @@ struct rte_cryptodev_asym_session { }; /** + * Create a symmetric session mempool. + * + * @param name + * The unique mempool name. + * @param nb_elts + * The number of elements in the mempool. + * @param elt_size + * The size of the element. This value will be ignored if it is smaller than + * the minimum session header size required for the system. For the user who + * want to use the same mempool for sym session and session private data it + * can be the maximum value of all existing devices' private data and session + * header sizes. + * @param cache_size + * The number of per-lcore cache elements + * @param priv_size + * The private data size of each session. + * @param socket_id + * The *socket_id* argument is the socket identifier in the case of + * NUMA. The value can be *SOCKET_ID_ANY* if there is no NUMA + * constraint for the reserved zone. + * + * @return + * - On success return size of the session + * - On failure returns 0 + */ +struct rte_mempool * __rte_experimental +rte_cryptodev_sym_session_pool_create(const char *name, uint32_t nb_elts, + uint32_t elt_size, uint32_t cache_size, uint16_t priv_size, + int socket_id); + +/** * Create symmetric crypto session header (generic with no private data) * * @param mempool Symmetric session mempool to allocate session diff --git a/lib/librte_cryptodev/rte_cryptodev_version.map b/lib/librte_cryptodev/rte_cryptodev_version.map index a695b61dc..5609da04b 100644 --- a/lib/librte_cryptodev/rte_cryptodev_version.map +++ b/lib/librte_cryptodev/rte_cryptodev_version.map @@ -102,6 +102,7 @@ EXPERIMENTAL { rte_cryptodev_asym_xform_capability_check_modlen; rte_cryptodev_asym_xform_capability_check_optype; rte_cryptodev_sym_session_get_user_data; + rte_cryptodev_sym_session_pool_create; rte_cryptodev_sym_session_set_user_data; rte_crypto_asym_op_strings; rte_crypto_asym_xform_strings; -- 2.13.6