d/numam-dpdk
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

cryptodev: add sym session mempool create

Browse Source 
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 <roy.fan.zhang@intel.com>
Acked-by: Fiona Trahe <fiona.trahe@intel.com>
Acked-by: Pablo de Lara <pablo.de.lara.guarch@intel.com>
Acked-by: Akhil Goyal <akhil.goyal@nxp.com>
This commit is contained in:
Fan Zhang 2019-01-10 14:50:12 +00:00 committed by Pablo de Lara
parent 725d2a7fbf
commit 1d6f89885e
5 changed files with 133 additions and 21 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

67
doc/guides/prog_guide/cryptodev_lib.rst
View File

@ -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.
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.
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.
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");

5
doc/guides/rel_notes/release_19_02.rst
View File

@ -173,6 +173,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
-----------

50
lib/librte_cryptodev/rte_cryptodev.c
View File

@ -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)
{

31
lib/librte_cryptodev/rte_cryptodev.h
View File

@ -963,6 +963,37 @@ struct rte_cryptodev_asym_session {
/**< Private asymmetric session material */
};
/**
* 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)
*

1
lib/librte_cryptodev/rte_cryptodev_version.map
View File

@ -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;