From mboxrd@z Thu Jan 1 00:00:00 1970 From: Umesh Kartha Subject: [RFC PATCH v2 3/3] cryptodev: added asym queue pair and session apis Date: Thu, 11 May 2017 18:05:32 +0530 Message-ID: <1494506132-23107-4-git-send-email-Umesh.Kartha@caviumnetworks.com> References: <1490177802-13398-1-git-send-email-Umesh.Kartha@caviumnetworks.com> <1494506132-23107-1-git-send-email-Umesh.Kartha@caviumnetworks.com> Mime-Version: 1.0 Content-Type: text/plain Cc: Jerin Jacob , Balasubramanian Manoharan , Ram Kumar , Murthy Nidadavolu , declan.doherty@intel.com, pablo.de.lara.guarch@intel.com, Fiona Trahe To: dev@dpdk.org Return-path: Received: from NAM01-BN3-obe.outbound.protection.outlook.com (mail-bn3nam01on0070.outbound.protection.outlook.com [104.47.33.70]) by dpdk.org (Postfix) with ESMTP id BF13568C5 for ; Thu, 11 May 2017 14:36:59 +0200 (CEST) In-Reply-To: <1494506132-23107-1-git-send-email-Umesh.Kartha@caviumnetworks.com> List-Id: DPDK patches and discussions List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dev-bounces@dpdk.org Sender: "dev" Added asymmetric operation queue pairs to device file. Added asymmetric session creation/initialisation/deletion APIs. Added asymmetric queue pair APIs to device ops. Added APIs to attach asym session to queue pairs. Signed-off-by: Umesh Kartha --- lib/librte_cryptodev/rte_cryptodev.c | 352 ++++++++++++++++++++++++++++++- lib/librte_cryptodev/rte_cryptodev.h | 80 +++++++ lib/librte_cryptodev/rte_cryptodev_pmd.h | 113 ++++++++++ 3 files changed, 544 insertions(+), 1 deletion(-) diff --git lib/librte_cryptodev/rte_cryptodev.c lib/librte_cryptodev/rte_cryptodev.c index abcdeb0..d4e943c 100644 --- lib/librte_cryptodev/rte_cryptodev.c +++ lib/librte_cryptodev/rte_cryptodev.c @@ -1242,6 +1242,15 @@ struct rte_cryptodev * return dev->data->nb_queue_pairs; } +uint16_t +rte_cryptodev_asym_queue_pair_count(uint8_t dev_id) +{ + struct rte_cryptodev *dev; + + dev = &rte_crypto_devices[dev_id]; + return dev->data->asym_nb_queue_pairs; +} + static int rte_cryptodev_queue_pairs_config(struct rte_cryptodev *dev, uint16_t nb_qpairs, int socket_id) @@ -1320,6 +1329,87 @@ struct rte_cryptodev * return 0; } +static int +rte_cryptodev_asym_queue_pairs_config(struct rte_cryptodev *dev, + uint16_t nb_qpairs, int socket_id) +{ + struct rte_cryptodev_info dev_info; + void **qp; + unsigned i; + uint16_t sym_nb_qps = dev->data->nb_queue_pairs; + + if ((dev == NULL) || (nb_qpairs < 1)) { + CDEV_LOG_ERR("invalid param: dev %p, nb_queues %u", + dev, nb_qpairs); + return -EINVAL; + } + + CDEV_LOG_DEBUG("Setup asym %d queues pairs on device %u", + nb_qpairs, dev->data->dev_id); + + memset(&dev_info, 0, sizeof(struct rte_cryptodev_info)); + + RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->dev_infos_get, -ENOTSUP); + (*dev->dev_ops->dev_infos_get)(dev, &dev_info); + + if ((nb_qpairs + sym_nb_qps) > (dev_info.max_nb_queue_pairs)) { + CDEV_LOG_ERR("Invalid num asym queue_pairs (%u) for dev %u", + nb_qpairs, dev->data->dev_id); + return -EINVAL; + } + + if (dev->data->asym_queue_pairs == NULL) { + /* first time configuration */ + dev->data->asym_queue_pairs = rte_zmalloc_socket( + "cryptodev->queue_pairs", + sizeof(dev->data->asym_queue_pairs[0]) * nb_qpairs, + RTE_CACHE_LINE_SIZE, socket_id); + + if (dev->data->asym_queue_pairs == NULL) { + dev->data->asym_nb_queue_pairs = 0; + CDEV_LOG_ERR("failed to get memory for asym " + "qp meta data, " + "nb_queues %u", + nb_qpairs); + return -(ENOMEM); + } + } else { /* re-configure */ + int ret; + uint16_t old_nb_queues = dev->data->asym_nb_queue_pairs; + + qp = dev->data->asym_queue_pairs; + + RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->queue_pair_release, + -ENOTSUP); + + for (i = nb_qpairs; i < old_nb_queues; i++) { + ret = (*dev->dev_ops->queue_pair_release)(dev, i); + if (ret < 0) + return ret; + } + + qp = rte_realloc(qp, sizeof(qp[0]) * nb_qpairs, + RTE_CACHE_LINE_SIZE); + if (qp == NULL) { + CDEV_LOG_ERR("failed to realloc asym qp meta data," + " nb_queues %u", nb_qpairs); + return -(ENOMEM); + } + + if (nb_qpairs > old_nb_queues) { + uint16_t new_qs = nb_qpairs - old_nb_queues; + + memset(qp + old_nb_queues, 0, + sizeof(qp[0]) * new_qs); + } + + dev->data->asym_queue_pairs = qp; + + } + dev->data->asym_nb_queue_pairs = nb_qpairs; + return 0; +} + int rte_cryptodev_queue_pair_start(uint8_t dev_id, uint16_t queue_pair_id) { @@ -1368,6 +1458,10 @@ struct rte_cryptodev * rte_cryptodev_sym_session_pool_create(struct rte_cryptodev *dev, unsigned nb_objs, unsigned obj_cache_size, int socket_id); +static int +rte_cryptodev_asym_session_pool_create(struct rte_cryptodev *dev, + unsigned nb_objs, unsigned obj_cache_size, int socket_id); + int rte_cryptodev_configure(uint8_t dev_id, struct rte_cryptodev_config *config) { @@ -1398,6 +1492,16 @@ struct rte_cryptodev * return diag; } + /* Setup new number of asym queue pairs and reconfigure device. */ + diag = rte_cryptodev_asym_queue_pairs_config(dev, + config->asym_nb_queue_pairs, config->socket_id); + if (diag != 0) { + CDEV_LOG_ERR("dev%d rte_crypto_dev_asym_queue_pairs_config" + " = %d", + dev_id, diag); + return diag; + } + /* Setup Session mempool for device */ diag = rte_cryptodev_sym_session_pool_create(dev, config->session_mp.nb_objs, @@ -1406,6 +1510,15 @@ struct rte_cryptodev * if (diag != 0) return diag; + /* Setup Session mempool for device */ + diag = rte_cryptodev_asym_session_pool_create(dev, + config->asym_session_mp.nb_objs, + config->asym_session_mp.cache_size, + config->socket_id); + if (diag != 0) + return diag; + + return (*dev->dev_ops->dev_configure)(dev, config); } @@ -1496,6 +1609,16 @@ struct rte_cryptodev * return -EBUSY; } } + if (dev->data->asym_session_pool != NULL) { + if (!rte_mempool_full(dev->data->asym_session_pool)) { + CDEV_LOG_ERR("dev_id=%u close failed, session mempool " + "has sessions still in use, free " + "all sessions before calling close", + (unsigned)dev_id); + return -EBUSY; + } + } + RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->dev_close, -ENOTSUP); retval = (*dev->dev_ops->dev_close)(dev); @@ -1535,6 +1658,35 @@ struct rte_cryptodev * socket_id); } +int +rte_cryptodev_asym_queue_pair_setup(uint8_t dev_id, uint16_t queue_pair_id, + const struct rte_cryptodev_qp_conf *qp_conf, int socket_id) +{ + struct rte_cryptodev *dev; + + if (!rte_cryptodev_pmd_is_valid_dev(dev_id)) { + CDEV_LOG_ERR("Invalid dev_id=%" PRIu8, dev_id); + return -EINVAL; + } + + dev = &rte_crypto_devices[dev_id]; + if (queue_pair_id >= dev->data->asym_nb_queue_pairs) { + CDEV_LOG_ERR("Invalid queue_pair_id=%d", queue_pair_id); + return -EINVAL; + } + + if (dev->data->dev_started) { + CDEV_LOG_ERR( + "device %d must be stopped to allow configuration", dev_id); + return -EBUSY; + } + + RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->queue_pair_setup, -ENOTSUP); + + return (*dev->dev_ops->asym_queue_pair_setup)(dev, queue_pair_id, + qp_conf, socket_id); +} + int rte_cryptodev_stats_get(uint8_t dev_id, struct rte_cryptodev_stats *stats) @@ -1730,6 +1882,25 @@ struct rte_cryptodev * (*dev->dev_ops->session_initialize)(mp, sess); } +static void +rte_cryptodev_asym_session_init(struct rte_mempool *mp, + void *opaque_arg, + void *_sess, + __rte_unused unsigned i) +{ + struct rte_cryptodev_asym_session *sess = _sess; + struct rte_cryptodev *dev = opaque_arg; + + memset(sess, 0, mp->elt_size); + + sess->dev_id = dev->data->dev_id; + sess->dev_type = dev->dev_type; + sess->mp = mp; + + if (dev->dev_ops->asym_session_initialize) + (*dev->dev_ops->asym_session_initialize)(mp, sess); +} + static int rte_cryptodev_sym_session_pool_create(struct rte_cryptodev *dev, unsigned nb_objs, unsigned obj_cache_size, int socket_id) @@ -1792,6 +1963,70 @@ struct rte_cryptodev * return 0; } +static int +rte_cryptodev_asym_session_pool_create(struct rte_cryptodev *dev, + unsigned nb_objs, unsigned obj_cache_size, int socket_id) +{ + char mp_name[RTE_CRYPTODEV_NAME_MAX_LEN]; + unsigned priv_sess_size; + + unsigned n = snprintf(mp_name, sizeof(mp_name), "cdev_%d_sess_mp", + dev->data->dev_id); + if (n > sizeof(mp_name)) { + CDEV_LOG_ERR("Unable to create unique name for" + " session mempool"); + return -ENOMEM; + } + + RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->asym_session_get_size, + -ENOTSUP); + priv_sess_size = (*dev->dev_ops->asym_session_get_size)(dev); + if (priv_sess_size == 0) { + CDEV_LOG_ERR("%s returned and invalid private session size ", + dev->data->name); + return -ENOMEM; + } + + unsigned elt_size = sizeof(struct rte_cryptodev_asym_session) + + priv_sess_size; + + dev->data->asym_session_pool = rte_mempool_lookup(mp_name); + if (dev->data->asym_session_pool != NULL) { + if ((dev->data->asym_session_pool->elt_size != elt_size) || + (dev->data->asym_session_pool->cache_size < + obj_cache_size) || + (dev->data->asym_session_pool->size < nb_objs)) { + + CDEV_LOG_ERR("%s mempool already exists with different" + " initialization parameters", mp_name); + dev->data->asym_session_pool = NULL; + return -ENOMEM; + } + } else { + dev->data->asym_session_pool = rte_mempool_create( + mp_name, /* mempool name */ + nb_objs, /* number of elements*/ + elt_size, /* element size*/ + obj_cache_size, /* Cache size*/ + 0, /* private data size */ + NULL, /* obj initialization constructor */ + NULL, /* obj initialization constructor arg */ + rte_cryptodev_asym_session_init, + /**< obj constructor*/ + dev, /* obj constructor arg */ + socket_id, /* socket id */ + 0); /* flags */ + + if (dev->data->asym_session_pool == NULL) { + CDEV_LOG_ERR("%s mempool allocation failed", mp_name); + return -ENOMEM; + } + } + + CDEV_LOG_DEBUG("%s mempool created!", mp_name); + return 0; +} + struct rte_cryptodev_sym_session * rte_cryptodev_sym_session_create(uint8_t dev_id, struct rte_crypto_sym_xform *xform) @@ -1829,6 +2064,43 @@ struct rte_cryptodev_sym_session * return sess; } +struct rte_cryptodev_asym_session * +rte_cryptodev_asym_session_create(uint8_t dev_id, + struct rte_crypto_asym_xform *xform) +{ + struct rte_cryptodev *dev; + struct rte_cryptodev_asym_session *sess; + void *_sess; + + if (!rte_cryptodev_pmd_is_valid_dev(dev_id)) { + CDEV_LOG_ERR("Invalid dev_id=%d", dev_id); + return NULL; + } + + dev = &rte_crypto_devices[dev_id]; + + /* Allocate a session structure from the session pool */ + if (rte_mempool_get(dev->data->asym_session_pool, &_sess)) { + CDEV_LOG_ERR("Couldn't get object from session mempool"); + return NULL; + } + + sess = (struct rte_cryptodev_asym_session *)_sess; + + RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->session_configure, NULL); + if (dev->dev_ops->asym_session_configure(dev, xform, sess->_private) == + NULL) { + CDEV_LOG_ERR("dev_id %d failed to configure session details", + dev_id); + + /* Return session to mempool */ + rte_mempool_put(sess->mp, _sess); + return NULL; + } + + return sess; +} + int rte_cryptodev_queue_pair_attach_sym_session(uint16_t qp_id, struct rte_cryptodev_sym_session *sess) @@ -1854,6 +2126,30 @@ struct rte_cryptodev_sym_session * } int +rte_cryptodev_queue_pair_attach_asym_session(uint16_t qp_id, + struct rte_cryptodev_asym_session *sess) +{ + struct rte_cryptodev *dev; + + if (!rte_cryptodev_pmd_is_valid_dev(sess->dev_id)) { + CDEV_LOG_ERR("Invalid dev_id=%d", sess->dev_id); + return -EINVAL; + } + + dev = &rte_crypto_devices[sess->dev_id]; + + /* The API is optional, not returning error if driver do not suuport */ + RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->asym_qp_attach_session, 0); + if (dev->dev_ops->asym_qp_attach_session(dev, qp_id, sess->_private)) { + CDEV_LOG_ERR("dev_id %d failed to attach qp: %d with session", + sess->dev_id, qp_id); + return -EPERM; + } + + return 0; +} + +int rte_cryptodev_queue_pair_detach_sym_session(uint16_t qp_id, struct rte_cryptodev_sym_session *sess) { @@ -1876,6 +2172,31 @@ struct rte_cryptodev_sym_session * return 0; } + +int +rte_cryptodev_queue_pair_detach_asym_session(uint16_t qp_id, + struct rte_cryptodev_asym_session *sess) +{ + struct rte_cryptodev *dev; + + if (!rte_cryptodev_pmd_is_valid_dev(sess->dev_id)) { + CDEV_LOG_ERR("Invalid dev_id=%d", sess->dev_id); + return -EINVAL; + } + + dev = &rte_crypto_devices[sess->dev_id]; + + /* The API is optional, not returning error if driver do not suuport */ + RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->asym_qp_detach_session, 0); + if (dev->dev_ops->asym_qp_detach_session(dev, qp_id, sess->_private)) { + CDEV_LOG_ERR("dev_id %d failed to detach qp: %d from session", + sess->dev_id, qp_id); + return -EPERM; + } + + return 0; +} + struct rte_cryptodev_sym_session * rte_cryptodev_sym_session_free(uint8_t dev_id, struct rte_cryptodev_sym_session *sess) @@ -1903,6 +2224,33 @@ struct rte_cryptodev_sym_session * return NULL; } +struct rte_cryptodev_asym_session * +rte_cryptodev_asym_session_free(uint8_t dev_id, + struct rte_cryptodev_asym_session *sess) +{ + struct rte_cryptodev *dev; + + if (!rte_cryptodev_pmd_is_valid_dev(dev_id)) { + CDEV_LOG_ERR("Invalid dev_id=%d", dev_id); + return sess; + } + + dev = &rte_crypto_devices[dev_id]; + + /* Check the session belongs to this device type */ + if (sess->dev_type != dev->dev_type) + return sess; + + /* Let device implementation clear session material */ + RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->asym_session_clear, sess); + dev->dev_ops->asym_session_clear(dev, (void *)sess->_private); + + /* Return session to mempool */ + rte_mempool_put(sess->mp, (void *)sess); + + return NULL; +} + /** Initialise rte_crypto_op mempool element */ static void rte_crypto_op_init(struct rte_mempool *mempool, @@ -1930,7 +2278,9 @@ struct rte_mempool * struct rte_crypto_op_pool_private *priv; unsigned elt_size = sizeof(struct rte_crypto_op) + - sizeof(struct rte_crypto_sym_op) + + (type == RTE_CRYPTO_OP_TYPE_SYMMETRIC) ? + sizeof(struct rte_crypto_sym_op) : + sizeof(struct rte_crypto_asym_op) + priv_size; /* lookup mempool in case already allocated */ diff --git lib/librte_cryptodev/rte_cryptodev.h lib/librte_cryptodev/rte_cryptodev.h index f5f5a73..edfd8fd 100644 --- lib/librte_cryptodev/rte_cryptodev.h +++ lib/librte_cryptodev/rte_cryptodev.h @@ -674,6 +674,11 @@ struct rte_cryptodev_info { * Default 0 for infinite sessions */ } sym; + + struct { + unsigned max_nb_sessions; + /**< Maximum number of sessions supported by device. */ + } asym; }; #define RTE_CRYPTODEV_DETACHED (0) @@ -827,11 +832,18 @@ struct rte_cryptodev_config { int socket_id; /**< Socket to allocate resources on */ uint16_t nb_queue_pairs; /**< Number of queue pairs to configure on device */ + uint16_t asym_nb_queue_pairs; + /**< Number of asym_queue pairs to configure on device */ struct { uint32_t nb_objs; /**< Number of objects in mempool */ uint32_t cache_size; /**< l-core object cache size */ } session_mp; /**< Session mempool configuration */ + + struct { + uint32_t nb_objs; /**< Number of objects in mempool */ + uint32_t cache_size; /**< l-core object cache size */ + } asym_session_mp; /**< Session mempool configuration */ }; /** @@ -1098,11 +1110,22 @@ struct rte_cryptodev_data { struct rte_mempool *session_pool; /**< Session memory pool */ + + struct rte_mempool *asym_session_pool; + /**< Asymmetric xform session memory pool */ + void **queue_pairs; /**< Array of pointers to queue pairs. */ + + void **asym_queue_pairs; + /**< Array of pointers to asymmetric queue pairs */ + uint16_t nb_queue_pairs; /**< Number of device queue pairs. */ + uint16_t asym_nb_queue_pairs; + /**< Number of device queue pairs for asym ops */ + void *dev_private; /**< PMD-specific private data */ } __rte_cache_aligned; @@ -1216,6 +1239,24 @@ struct rte_cryptodev_sym_session { }; +/** Cryptodev symmetric crypto session */ +struct rte_cryptodev_asym_session { + RTE_STD_C11 + struct { + uint8_t dev_id; + /**< Device Id */ + enum rte_cryptodev_type dev_type; + /** Crypto Device type session created on */ + struct rte_mempool *mp; + /**< Mempool session allocated from */ + } __rte_aligned(8); + /**< Public asymmetric session details */ + + __extension__ char _private[0]; + /**< Private session material */ +}; + + /** * Initialise a session for symmetric cryptographic operations. * @@ -1241,6 +1282,32 @@ struct rte_cryptodev_sym_session { rte_cryptodev_sym_session_create(uint8_t dev_id, struct rte_crypto_sym_xform *xform); + +/** + * Initialise a session for asymmetric cryptographic operations. + * + * This function is used by the client to initialize immutable + * parameters of asymmetric cryptographic operation. + * To perform the operation the rte_cryptodev_enqueue_burst function is + * used. Each mbuf should contain a reference to the session + * pointer returned from this function contained within it's crypto_op if a + * session-based operation is being provisioned. Memory to contain the session + * information is allocated from within mempool managed by the cryptodev. + * + * The rte_cryptodev_session_free must be called to free allocated + * memory when the session is no longer required. + * + * @param dev_id The device identifier. + * @param xform Crypto transform chain. + + * + * @return + * Pointer to the created session or NULL + */ +extern struct rte_cryptodev_asym_session * +rte_cryptodev_asym_session_create(uint8_t dev_id, + struct rte_crypto_asym_xform *xform); + /** * Free the memory associated with a previously allocated session. * @@ -1257,6 +1324,19 @@ struct rte_cryptodev_sym_session { struct rte_cryptodev_sym_session *session); /** + * Free the memory associated with a previously allocated session. + * + * @param dev_id The device identifier. + * @param session Session pointer previously allocated by + * *rte_cryptodev_asym_session_create*. + * + * @return + * NULL on successful freeing of session. + * Session pointer on failure to free session. + */ +extern struct rte_cryptodev_asym_session * +rte_cryptodev_asym_session_free(uint8_t dev_id, + struct rte_cryptodev_asym_session *session); * Attach queue pair with sym session. * * @param qp_id Queue pair to which session will be attached. diff --git lib/librte_cryptodev/rte_cryptodev_pmd.h lib/librte_cryptodev/rte_cryptodev_pmd.h index 17ef37c..31c5804 100644 --- lib/librte_cryptodev/rte_cryptodev_pmd.h +++ lib/librte_cryptodev/rte_cryptodev_pmd.h @@ -327,6 +327,22 @@ typedef int (*cryptodev_sym_create_session_pool_t)( struct rte_cryptodev *dev, unsigned nb_objs, unsigned obj_cache_size, int socket_id); +/** + * Create asymmetric session mempool to allocate sessions from + * + * @param dev Crypto device pointer + * @param nb_objs number of sessions objects in mempool + * @param obj_cache l-core object cache size, see *rte_ring_create* + * @param socket_id Socket Id to allocate mempool on. + * + * @return + * - On success returns a pointer to a rte_mempool + * - On failure returns a NULL pointer + */ +typedef int (*cryptodev_asym_create_session_pool_t)( + struct rte_cryptodev *dev, unsigned nb_objs, + unsigned obj_cache_size, int socket_id); + /** * Get the size of a cryptodev session @@ -341,6 +357,18 @@ typedef unsigned (*cryptodev_sym_get_session_private_size_t)( struct rte_cryptodev *dev); /** + * Get the size of an asymmetric cryptodev session + * + * @param dev Crypto device pointer + * + * @return + * - On success returns the size of the session structure for device + * - On failure returns 0 + */ +typedef unsigned (*cryptodev_asym_get_session_private_size_t)( + struct rte_cryptodev *dev); + +/** * Initialize a Crypto session on a device. * * @param dev Crypto device pointer @@ -355,6 +383,20 @@ typedef void (*cryptodev_sym_initialize_session_t)(struct rte_mempool *mempool, void *session_private); /** + * Initialize an asymmetric Crypto session on a device. + * + * @param dev Crypto device pointer + * @param xform Single or chain of crypto xforms + * @param priv_sess Pointer to cryptodev's private session structure + * + * @return + * - Returns private session structure on success. + * - Returns NULL on failure. + */ +typedef void (*cryptodev_asym_initialize_session_t)(struct rte_mempool *mempool, + void *session_private); + +/** * Configure a Crypto session on a device. * * @param dev Crypto device pointer @@ -369,6 +411,20 @@ typedef void (*cryptodev_sym_initialize_session_t)(struct rte_mempool *mempool, struct rte_crypto_sym_xform *xform, void *session_private); /** + * Configure an asymmetric Crypto session on a device. + * + * @param dev Crypto device pointer + * @param xform Single or chain of asymmetric crypto xforms + * @param priv_sess Pointer to cryptodev's private session structure + * + * @return + * - Returns private session structure on success. + * - Returns NULL on failure. + */ +typedef void *(*cryptodev_asym_configure_session_t)(struct rte_cryptodev *dev, + struct rte_crypto_asym_xform *xform, void *session_private); + +/** * Free Crypto session. * @param session Cryptodev session structure to free */ @@ -376,6 +432,13 @@ typedef void (*cryptodev_sym_free_session_t)(struct rte_cryptodev *dev, void *session_private); /** + * Free asymmetric Crypto session. + * @param session Cryptodev session structure to free + */ +typedef void (*cryptodev_asym_free_session_t)(struct rte_cryptodev *dev, + void *session_private); + +/** * Optional API for drivers to attach sessions with queue pair. * @param dev Crypto device pointer * @param qp_id queue pair id for attaching session @@ -389,6 +452,19 @@ typedef int (*cryptodev_sym_queue_pair_attach_session_t)( void *session_private); /** + * Optional API for drivers to attach asymmetric sessions with queue pair. + * @param dev Crypto device pointer + * @param qp_id queue pair id for attaching session + * @param priv_sess Pointer to cryptodev's private session structure + * @return + * - Return 0 on success + */ +typedef int (*cryptodev_asym_queue_pair_attach_session_t)( + struct rte_cryptodev *dev, + uint16_t qp_id, + void *session_private); + +/** * Optional API for drivers to detach sessions from queue pair. * @param dev Crypto device pointer * @param qp_id queue pair id for detaching session @@ -401,6 +477,20 @@ typedef int (*cryptodev_sym_queue_pair_detach_session_t)( uint16_t qp_id, void *session_private); +/** + * Optional API for drivers to detach asymmetric sessions from queue pair. + * @param dev Crypto device pointer + * @param qp_id queue pair id for detaching session + * @param priv_sess Pointer to cryptodev's private session + * structure. + * @return + * - Return 0 on success + */ +typedef int (*cryptodev_asym_queue_pair_detach_session_t)( + struct rte_cryptodev *dev, + uint16_t qp_id, + void *session_private); + /** Crypto device operations function pointer table */ struct rte_cryptodev_ops { cryptodev_configure_t dev_configure; /**< Configure device. */ @@ -426,18 +516,41 @@ struct rte_cryptodev_ops { cryptodev_queue_pair_count_t queue_pair_count; /**< Get count of the queue pairs. */ + cryptodev_queue_pair_setup_t asym_queue_pair_setup; + /**< Set up a device queue pair. */ + cryptodev_queue_pair_release_t asym_queue_pair_release; + /**< Release a queue pair. */ + cryptodev_queue_pair_start_t asym_queue_pair_start; + /**< Start a queue pair. */ + cryptodev_queue_pair_stop_t asym_queue_pair_stop; + /**< Stop a queue pair. */ + cryptodev_queue_pair_count_t asym_queue_pair_count; + /**< Get count of the queue pairs. */ + cryptodev_sym_get_session_private_size_t session_get_size; /**< Return private session. */ + cryptodev_asym_get_session_private_size_t asym_session_get_size; + /**< Return asymmetric private session. */ cryptodev_sym_initialize_session_t session_initialize; /**< Initialization function for private session data */ + cryptodev_asym_initialize_session_t asym_session_initialize; + /**< Initialization asymmetric function for private session data */ cryptodev_sym_configure_session_t session_configure; /**< Configure a Crypto session. */ + cryptodev_asym_configure_session_t asym_session_configure; + /**< Configure an Asymmetric Crypto session. */ cryptodev_sym_free_session_t session_clear; /**< Clear a Crypto sessions private data. */ + cryptodev_asym_free_session_t asym_session_clear; + /**< Clear an asymmetric Crypto sessions private data. */ cryptodev_sym_queue_pair_attach_session_t qp_attach_session; /**< Attach session to queue pair. */ + cryptodev_asym_queue_pair_attach_session_t asym_qp_attach_session; + /**< Attach asymmetric session to queue pair. */ cryptodev_sym_queue_pair_attach_session_t qp_detach_session; /**< Detach session from queue pair. */ + cryptodev_asym_queue_pair_attach_session_t asym_qp_detach_session; + /**< Detach asymmetric session from queue pair. */ }; -- 1.8.3.1