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

eventdev: introduce event cryptodev vector type

Browse Source 
Introduce ability to aggregate crypto operations processed by event
crypto adapter into single event containing rte_event_vector whose event
type is RTE_EVENT_TYPE_CRYPTODEV_VECTOR.

Application should set RTE_EVENT_CRYPTO_ADAPTER_EVENT_VECTOR in
rte_event_crypto_adapter_queue_conf::flag and provide vector configuration
with respect of rte_event_crypto_adapter_vector_limits, which could be
obtained by calling rte_event_crypto_adapter_vector_limits_get, to enable
vectorization.

The event crypto adapter would be responsible for vectorizing the crypto
operations based on provided response information in
rte_event_crypto_metadata::response_info.

Updated drivers and tests accordingly to new API.

Signed-off-by: Volodymyr Fialko <vfialko@marvell.com>
Acked-by: Akhil Goyal <gakhil@marvell.com>
This commit is contained in:
Volodymyr Fialko 2022-10-01 02:42:12 +02:00 committed by Akhil Goyal
parent a0a17e2a3e
commit c1749bc5ee
15 changed files with 297 additions and 53 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

11
app/test-eventdev/test_perf_common.c
View File

@ -837,14 +837,13 @@ perf_event_crypto_adapter_setup(struct test_perf *t, struct prod_data *p)
}
if (cap & RTE_EVENT_CRYPTO_ADAPTER_CAP_INTERNAL_PORT_QP_EV_BIND) {
struct rte_event response_info;
struct rte_event_crypto_adapter_queue_conf conf;
response_info.event = 0;
response_info.sched_type = RTE_SCHED_TYPE_ATOMIC;
response_info.queue_id = p->queue_id;
memset(&conf, 0, sizeof(conf));
conf.ev.sched_type = RTE_SCHED_TYPE_ATOMIC;
conf.ev.queue_id = p->queue_id;
ret = rte_event_crypto_adapter_queue_pair_add(
TEST_PERF_CA_ID, p->ca.cdev_id, p->ca.cdev_qp_id,
&response_info);
TEST_PERF_CA_ID, p->ca.cdev_id, p->ca.cdev_qp_id, &conf);
} else {
ret = rte_event_crypto_adapter_queue_pair_add(
TEST_PERF_CA_ID, p->ca.cdev_id, p->ca.cdev_qp_id, NULL);

12
app/test/test_event_crypto_adapter.c
View File

@ -1175,6 +1175,10 @@ test_crypto_adapter_create(void)
static int
test_crypto_adapter_qp_add_del(void)
{
struct rte_event_crypto_adapter_queue_conf queue_conf = {
.ev = response_info,
};
uint32_t cap;
int ret;
@ -1183,7 +1187,7 @@ test_crypto_adapter_qp_add_del(void)
if (cap & RTE_EVENT_CRYPTO_ADAPTER_CAP_INTERNAL_PORT_QP_EV_BIND) {
ret = rte_event_crypto_adapter_queue_pair_add(TEST_ADAPTER_ID,
TEST_CDEV_ID, TEST_CDEV_QP_ID, &response_info);
TEST_CDEV_ID, TEST_CDEV_QP_ID, &queue_conf);
} else
ret = rte_event_crypto_adapter_queue_pair_add(TEST_ADAPTER_ID,
TEST_CDEV_ID, TEST_CDEV_QP_ID, NULL);
@ -1206,6 +1210,10 @@ configure_event_crypto_adapter(enum rte_event_crypto_adapter_mode mode)
.new_event_threshold = 1200,
};
struct rte_event_crypto_adapter_queue_conf queue_conf = {
.ev = response_info,
};
uint32_t cap;
int ret;
@ -1238,7 +1246,7 @@ configure_event_crypto_adapter(enum rte_event_crypto_adapter_mode mode)
if (cap & RTE_EVENT_CRYPTO_ADAPTER_CAP_INTERNAL_PORT_QP_EV_BIND) {
ret = rte_event_crypto_adapter_queue_pair_add(TEST_ADAPTER_ID,
TEST_CDEV_ID, TEST_CDEV_QP_ID, &response_info);
TEST_CDEV_ID, TEST_CDEV_QP_ID, &queue_conf);
} else
ret = rte_event_crypto_adapter_queue_pair_add(TEST_ADAPTER_ID,
TEST_CDEV_ID, TEST_CDEV_QP_ID, NULL);

23
doc/guides/prog_guide/event_crypto_adapter.rst
View File

@ -201,10 +201,10 @@ capability, event information must be passed to the add API.
ret = rte_event_crypto_adapter_caps_get(id, evdev, &cap);
if (cap & RTE_EVENT_CRYPTO_ADAPTER_CAP_INTERNAL_PORT_QP_EV_BIND) {
struct rte_event event;
struct rte_event_crypto_adapter_queue_conf conf;
// Fill in event information & pass it to add API
rte_event_crypto_adapter_queue_pair_add(id, cdev_id, qp_id, &event);
// Fill in conf.event information & pass it to add API
rte_event_crypto_adapter_queue_pair_add(id, cdev_id, qp_id, &conf);
} else
rte_event_crypto_adapter_queue_pair_add(id, cdev_id, qp_id, NULL);
@ -291,6 +291,23 @@ the ``rte_crypto_op``.
rte_memcpy(op + len, &m_data, sizeof(m_data));
}
Enable event vectorization
~~~~~~~~~~~~~~~~~~~~~~~~~~
The event crypto adapter can aggregate outcoming crypto operations based on
provided response information of ``rte_event_crypto_metadata::response_info``
and generate a ``rte_event`` containing ``rte_event_vector`` whose event type
is ``RTE_EVENT_TYPE_CRYPTODEV_VECTOR``.
To enable vectorization application should set
RTE_EVENT_CRYPTO_ADAPTER_EVENT_VECTOR in
``rte_event_crypto_adapter_queue_conf::flag`` and provide vector
configuration(size, mempool, etc.) with respect of
``rte_event_crypto_adapter_vector_limits``, which could be obtained by calling
``rte_event_crypto_adapter_vector_limits_get()``.
The RTE_EVENT_CRYPTO_ADAPTER_CAP_EVENT_VECTOR capability indicates whether
PMD supports this feature.
Start the adapter instance
~~~~~~~~~~~~~~~~~~~~~~~~~~

6
doc/guides/rel_notes/deprecation.rst
View File

@ -148,11 +148,5 @@ Deprecation Notices
pointer for the private data to the application which can be attached
to the packet while enqueuing.
* eventdev: The function ``rte_event_crypto_adapter_queue_pair_add`` will
accept configuration of type ``rte_event_crypto_adapter_queue_conf`` instead
of ``rte_event``, similar to ``rte_event_eth_rx_adapter_queue_add`` signature.
Event will be one of the configuration fields,
together with additional vector parameters.
* raw/dpaa2_cmdif: The ``dpaa2_cmdif`` rawdev driver will be deprecated
in DPDK 22.11, as it is no longer in use, no active user known.

13
doc/guides/rel_notes/release_22_11.rst
View File

@ -117,6 +117,12 @@ New Features
* Added ``rte_event_eth_tx_adapter_queue_stop`` to stop the Tx Adapter
from enqueueing any packets to the Tx queue.
* **Added event crypto adapter vectorization support.**
Added support to aggregate crypto operations processed by event crypto adapter
into single event containing ``rte_event_vector``
whose event type is ``RTE_EVENT_TYPE_CRYPTODEV_VECTOR``.
Removed Items
-------------
@ -262,6 +268,13 @@ API Changes
The API is now removed and the application can directly get the userdata from
mbuf dynamic field.
* eventdev: The function ``rte_event_crypto_adapter_queue_pair_add`` was updated
to accept configuration of type ``rte_event_crypto_adapter_queue_conf``
instead of ``rte_event``,
similar to ``rte_event_eth_rx_adapter_queue_add`` signature.
Event will be one of the configuration fields,
together with additional vector parameters.
* metrics: Updated ``rte_metrics_init`` so it returns an error code instead
of calling ``rte_exit``.

4
drivers/event/cnxk/cn10k_eventdev.c
View File

@ -1034,12 +1034,12 @@ static int
cn10k_crypto_adapter_qp_add(const struct rte_eventdev *event_dev,
const struct rte_cryptodev *cdev,
int32_t queue_pair_id,
const struct rte_event *event)
const struct rte_event_crypto_adapter_queue_conf *conf)
{
struct cnxk_sso_evdev *dev = cnxk_sso_pmd_priv(event_dev);
int ret;
RTE_SET_USED(event);
RTE_SET_USED(conf);
CNXK_VALID_DEV_OR_ERR_RET(event_dev->dev, "event_cn10k");
CNXK_VALID_DEV_OR_ERR_RET(cdev->device, "crypto_cn10k");

5
drivers/event/cnxk/cn9k_eventdev.c
View File

@ -1125,12 +1125,13 @@ cn9k_crypto_adapter_caps_get(const struct rte_eventdev *event_dev,
static int
cn9k_crypto_adapter_qp_add(const struct rte_eventdev *event_dev,
const struct rte_cryptodev *cdev,
int32_t queue_pair_id, const struct rte_event *event)
int32_t queue_pair_id,
const struct rte_event_crypto_adapter_queue_conf *conf)
{
struct cnxk_sso_evdev *dev = cnxk_sso_pmd_priv(event_dev);
int ret;
RTE_SET_USED(event);
RTE_SET_USED(conf);
CNXK_VALID_DEV_OR_ERR_RET(event_dev->dev, "event_cn9k");
CNXK_VALID_DEV_OR_ERR_RET(cdev->device, "crypto_cn9k");

9
drivers/event/dpaa/dpaa_eventdev.c
View File

@ -26,6 +26,7 @@
#include <rte_eventdev.h>
#include <eventdev_pmd_vdev.h>
#include <rte_ethdev.h>
#include <rte_event_crypto_adapter.h>
#include <rte_event_eth_rx_adapter.h>
#include <rte_event_eth_tx_adapter.h>
#include <cryptodev_pmd.h>
@ -775,10 +776,10 @@ static int
dpaa_eventdev_crypto_queue_add(const struct rte_eventdev *dev,
const struct rte_cryptodev *cryptodev,
int32_t rx_queue_id,
const struct rte_event *ev)
const struct rte_event_crypto_adapter_queue_conf *conf)
{
struct dpaa_eventdev *priv = dev->data->dev_private;
uint8_t ev_qid = ev->queue_id;
uint8_t ev_qid = conf->ev.queue_id;
u16 ch_id = priv->evq_info[ev_qid].ch_id;
int ret;
@ -786,10 +787,10 @@ dpaa_eventdev_crypto_queue_add(const struct rte_eventdev *dev,
if (rx_queue_id == -1)
return dpaa_eventdev_crypto_queue_add_all(dev,
cryptodev, ev);
cryptodev, &conf->ev);
ret = dpaa_sec_eventq_attach(cryptodev, rx_queue_id,
ch_id, ev);
ch_id, &conf->ev);
if (ret) {
DPAA_EVENTDEV_ERR(
"dpaa_sec_eventq_attach failed: ret: %d\n", ret);

9
drivers/event/dpaa2/dpaa2_eventdev.c
View File

@ -26,6 +26,7 @@
#include <bus_vdev_driver.h>
#include <ethdev_driver.h>
#include <cryptodev_pmd.h>
#include <rte_event_crypto_adapter.h>
#include <rte_event_eth_rx_adapter.h>
#include <rte_event_eth_tx_adapter.h>
@ -865,10 +866,10 @@ static int
dpaa2_eventdev_crypto_queue_add(const struct rte_eventdev *dev,
const struct rte_cryptodev *cryptodev,
int32_t rx_queue_id,
const struct rte_event *ev)
const struct rte_event_crypto_adapter_queue_conf *conf)
{
struct dpaa2_eventdev *priv = dev->data->dev_private;
uint8_t ev_qid = ev->queue_id;
uint8_t ev_qid = conf->ev.queue_id;
struct dpaa2_dpcon_dev *dpcon = priv->evq_info[ev_qid].dpcon;
int ret;
@ -876,10 +877,10 @@ dpaa2_eventdev_crypto_queue_add(const struct rte_eventdev *dev,
if (rx_queue_id == -1)
return dpaa2_eventdev_crypto_queue_add_all(dev,
cryptodev, ev);
cryptodev, &conf->ev);
ret = dpaa2_sec_eventq_attach(cryptodev, rx_queue_id,
dpcon, ev);
dpcon, &conf->ev);
if (ret) {
DPAA2_EVENTDEV_ERR(
"dpaa2_sec_eventq_attach failed: ret: %d\n", ret);

4
drivers/event/octeontx/ssovf_evdev.c
View File

@ -746,12 +746,12 @@ static int
ssovf_crypto_adapter_qp_add(const struct rte_eventdev *dev,
const struct rte_cryptodev *cdev,
int32_t queue_pair_id,
const struct rte_event *event)
const struct rte_event_crypto_adapter_queue_conf *conf)
{
struct cpt_instance *qp;
uint8_t qp_id;
RTE_SET_USED(event);
RTE_SET_USED(conf);
if (queue_pair_id == -1) {
for (qp_id = 0; qp_id < cdev->data->nb_queue_pairs; qp_id++) {

35
lib/eventdev/eventdev_pmd.h
View File

@ -910,6 +910,7 @@ rte_event_pmd_selftest_seqn(struct rte_mbuf *mbuf)
}
struct rte_cryptodev;
struct rte_event_crypto_adapter_queue_conf;
/**
* This API may change without prior notice
@ -964,11 +965,11 @@ typedef int (*eventdev_crypto_adapter_caps_get_t)
* - <0: Error code returned by the driver function.
*
*/
typedef int (*eventdev_crypto_adapter_queue_pair_add_t)
(const struct rte_eventdev *dev,
const struct rte_cryptodev *cdev,
int32_t queue_pair_id,
const struct rte_event *event);
typedef int (*eventdev_crypto_adapter_queue_pair_add_t)(
const struct rte_eventdev *dev,
const struct rte_cryptodev *cdev,
int32_t queue_pair_id,
const struct rte_event_crypto_adapter_queue_conf *queue_conf);
/**
@ -1077,6 +1078,27 @@ typedef int (*eventdev_crypto_adapter_stats_reset)
(const struct rte_eventdev *dev,
const struct rte_cryptodev *cdev);
struct rte_event_crypto_adapter_vector_limits;
/**
* Get event vector limits for a given event, crypto device pair.
*
* @param dev
* Event device pointer
*
* @param cdev
* Crypto device pointer
*
* @param[out] limits
* Pointer to the limits structure to be filled.
*
* @return
* - 0: Success.
* - <0: Error code returned by the driver function.
*/
typedef int (*eventdev_crypto_adapter_vector_limits_get_t)(
const struct rte_eventdev *dev, const struct rte_cryptodev *cdev,
struct rte_event_crypto_adapter_vector_limits *limits);
/**
* Retrieve the event device's eth Tx adapter capabilities.
*
@ -1402,6 +1424,9 @@ struct eventdev_ops {
/**< Get crypto stats */
eventdev_crypto_adapter_stats_reset crypto_adapter_stats_reset;
/**< Reset crypto stats */
eventdev_crypto_adapter_vector_limits_get_t
crypto_adapter_vector_limits_get;
/**< Get event vector limits for the crypto adapter */
eventdev_eth_rx_adapter_q_stats_get eth_rx_adapter_queue_stats_get;
/**< Get ethernet Rx queue stats */

6
lib/eventdev/eventdev_trace.h
View File

@ -18,6 +18,7 @@ extern "C" {
#include <rte_trace_point.h>
#include "rte_eventdev.h"
#include "rte_event_crypto_adapter.h"
#include "rte_event_eth_rx_adapter.h"
#include "rte_event_timer_adapter.h"
@ -271,11 +272,12 @@ RTE_TRACE_POINT(
RTE_TRACE_POINT(
rte_eventdev_trace_crypto_adapter_queue_pair_add,
RTE_TRACE_POINT_ARGS(uint8_t adptr_id, uint8_t cdev_id,
const void *event, int32_t queue_pair_id),
int32_t queue_pair_id,
const struct rte_event_crypto_adapter_queue_conf *conf),
rte_trace_point_emit_u8(adptr_id);
rte_trace_point_emit_u8(cdev_id);
rte_trace_point_emit_i32(queue_pair_id);
rte_trace_point_emit_ptr(event);
rte_trace_point_emit_ptr(conf);
)
RTE_TRACE_POINT(

104
lib/eventdev/rte_event_crypto_adapter.c
View File

@ -921,11 +921,12 @@ int
rte_event_crypto_adapter_queue_pair_add(uint8_t id,
uint8_t cdev_id,
int32_t queue_pair_id,
const struct rte_event *event)
const struct rte_event_crypto_adapter_queue_conf *conf)
{
struct rte_event_crypto_adapter_vector_limits limits;
struct event_crypto_adapter *adapter;
struct rte_eventdev *dev;
struct crypto_device_info *dev_info;
struct rte_eventdev *dev;
uint32_t cap;
int ret;
@ -950,11 +951,49 @@ rte_event_crypto_adapter_queue_pair_add(uint8_t id,
return ret;
}
if ((cap & RTE_EVENT_CRYPTO_ADAPTER_CAP_INTERNAL_PORT_QP_EV_BIND) &&
(event == NULL)) {
RTE_EDEV_LOG_ERR("Conf value can not be NULL for dev_id=%u",
cdev_id);
return -EINVAL;
if (conf == NULL) {
if (cap & RTE_EVENT_CRYPTO_ADAPTER_CAP_INTERNAL_PORT_QP_EV_BIND) {
RTE_EDEV_LOG_ERR("Conf value can not be NULL for dev_id=%u",
cdev_id);
return -EINVAL;
}
} else {
if (conf->flags & RTE_EVENT_CRYPTO_ADAPTER_EVENT_VECTOR) {
if ((cap & RTE_EVENT_CRYPTO_ADAPTER_CAP_EVENT_VECTOR) == 0) {
RTE_EDEV_LOG_ERR("Event vectorization is not supported,"
"dev %" PRIu8 " cdev %" PRIu8, id,
cdev_id);
return -ENOTSUP;
}
ret = rte_event_crypto_adapter_vector_limits_get(
adapter->eventdev_id, cdev_id, &limits);
if (ret < 0) {
RTE_EDEV_LOG_ERR("Failed to get event device vector "
"limits, dev %" PRIu8 " cdev %" PRIu8,
id, cdev_id);
return -EINVAL;
}
if (conf->vector_sz < limits.min_sz ||
conf->vector_sz > limits.max_sz ||
conf->vector_timeout_ns < limits.min_timeout_ns ||
conf->vector_timeout_ns > limits.max_timeout_ns ||
conf->vector_mp == NULL) {
RTE_EDEV_LOG_ERR("Invalid event vector configuration,"
" dev %" PRIu8 " cdev %" PRIu8,
id, cdev_id);
return -EINVAL;
}
if (conf->vector_mp->elt_size < (sizeof(struct rte_event_vector) +
(sizeof(uintptr_t) * conf->vector_sz))) {
RTE_EDEV_LOG_ERR("Invalid event vector configuration,"
" dev %" PRIu8 " cdev %" PRIu8,
id, cdev_id);
return -EINVAL;
}
}
}
dev_info = &adapter->cdevs[cdev_id];
@ -989,7 +1028,7 @@ rte_event_crypto_adapter_queue_pair_add(uint8_t id,
ret = (*dev->dev_ops->crypto_adapter_queue_pair_add)(dev,
dev_info->dev,
queue_pair_id,
event);
conf);
if (ret)
return ret;
@ -1029,8 +1068,8 @@ rte_event_crypto_adapter_queue_pair_add(uint8_t id,
rte_service_component_runstate_set(adapter->service_id, 1);
}
rte_eventdev_trace_crypto_adapter_queue_pair_add(id, cdev_id, event,
queue_pair_id);
rte_eventdev_trace_crypto_adapter_queue_pair_add(id, cdev_id,
queue_pair_id, conf);
return 0;
}
@ -1288,3 +1327,48 @@ rte_event_crypto_adapter_event_port_get(uint8_t id, uint8_t *event_port_id)
return 0;
}
int
rte_event_crypto_adapter_vector_limits_get(
uint8_t dev_id, uint16_t cdev_id,
struct rte_event_crypto_adapter_vector_limits *limits)
{
struct rte_cryptodev *cdev;
struct rte_eventdev *dev;
uint32_t cap;
int ret;
RTE_EVENTDEV_VALID_DEVID_OR_ERR_RET(dev_id, -EINVAL);
if (!rte_cryptodev_is_valid_dev(cdev_id)) {
RTE_EDEV_LOG_ERR("Invalid dev_id=%" PRIu8, cdev_id);
return -EINVAL;
}
if (limits == NULL) {
RTE_EDEV_LOG_ERR("Invalid limits storage provided");
return -EINVAL;
}
dev = &rte_eventdevs[dev_id];
cdev = rte_cryptodev_pmd_get_dev(cdev_id);
ret = rte_event_crypto_adapter_caps_get(dev_id, cdev_id, &cap);
if (ret) {
RTE_EDEV_LOG_ERR("Failed to get adapter caps edev %" PRIu8
"cdev %" PRIu16, dev_id, cdev_id);
return ret;
}
if (!(cap & RTE_EVENT_CRYPTO_ADAPTER_CAP_EVENT_VECTOR)) {
RTE_EDEV_LOG_ERR("Event vectorization is not supported,"
"dev %" PRIu8 " cdev %" PRIu8, dev_id, cdev_id);
return -ENOTSUP;
}
if ((*dev->dev_ops->crypto_adapter_vector_limits_get) == NULL)
return -ENOTSUP;
return dev->dev_ops->crypto_adapter_vector_limits_get(
dev, cdev, limits);
}

101
lib/eventdev/rte_event_crypto_adapter.h
View File

@ -253,6 +253,78 @@ struct rte_event_crypto_adapter_conf {
*/
};
#define RTE_EVENT_CRYPTO_ADAPTER_EVENT_VECTOR 0x1
/**< This flag indicates that crypto operations processed on the crypto
* adapter need to be vectorized
* @see rte_event_crypto_adapter_queue_conf::flags
*/
/**
* Adapter queue configuration structure
*/
struct rte_event_crypto_adapter_queue_conf {
uint32_t flags;
/**< Flags for handling crypto operations
* @see RTE_EVENT_CRYPTO_ADAPTER_EVENT_VECTOR
*/
struct rte_event ev;
/**< If HW supports cryptodev queue pair to event queue binding,
* application is expected to fill in event information.
* @see RTE_EVENT_CRYPTO_ADAPTER_CAP_INTERNAL_PORT_QP_EV_BIND
*/
uint16_t vector_sz;
/**< Indicates the maximum number for crypto operations to combine and
* form a vector.
* @see rte_event_crypto_adapter_vector_limits::min_sz
* @see rte_event_crypto_adapter_vector_limits::max_sz
* Valid when RTE_EVENT_CRYPTO_ADAPTER_EVENT_VECTOR flag is set in
* @see rte_event_crypto_adapter_queue_conf::flags
*/
uint64_t vector_timeout_ns;
/**<
* Indicates the maximum number of nanoseconds to wait for aggregating
* crypto operations. Should be within vectorization limits of the
* adapter
* @see rte_event_crypto_adapter_vector_limits::min_timeout_ns
* @see rte_event_crypto_adapter_vector_limits::max_timeout_ns
* Valid when RTE_EVENT_CRYPTO_ADAPTER_EVENT_VECTOR flag is set in
* @see rte_event_crypto_adapter_queue_conf::flags
*/
struct rte_mempool *vector_mp;
/**< Indicates the mempool that should be used for allocating
* rte_event_vector container.
* Should be created by using `rte_event_vector_pool_create`.
* Valid when RTE_EVENT_CRYPTO_ADAPTER_EVENT_VECTOR flag is set in
* @see rte_event_crypto_adapter_queue_conf::flags.
*/
};
/**
* A structure used to retrieve event crypto adapter vector limits.
*/
struct rte_event_crypto_adapter_vector_limits {
uint16_t min_sz;
/**< Minimum vector limit configurable.
* @see rte_event_crypto_adapter_queue_conf::vector_sz
*/
uint16_t max_sz;
/**< Maximum vector limit configurable.
* @see rte_event_crypto_adapter_queue_conf::vector_sz
*/
uint8_t log2_sz;
/**< True if the size configured should be in log2.
* @see rte_event_crypto_adapter_queue_conf::vector_sz
*/
uint64_t min_timeout_ns;
/**< Minimum vector timeout configurable.
* @see rte_event_crypto_adapter_queue_conf::vector_timeout_ns
*/
uint64_t max_timeout_ns;
/**< Maximum vector timeout configurable.
* @see rte_event_crypto_adapter_queue_conf::vector_timeout_ns
*/
};
/**
* Function type used for adapter configuration callback. The callback is
* used to fill in members of the struct rte_event_crypto_adapter_conf, this
@ -392,10 +464,9 @@ rte_event_crypto_adapter_free(uint8_t id);
* Cryptodev queue pair identifier. If queue_pair_id is set -1,
* adapter adds all the pre configured queue pairs to the instance.
*
* @param event
* if HW supports cryptodev queue pair to event queue binding, application is
* expected to fill in event information, else it will be NULL.
* @see RTE_EVENT_CRYPTO_ADAPTER_CAP_INTERNAL_PORT_QP_EV_BIND
* @param conf
* Additional configuration structure of type
* *rte_event_crypto_adapter_queue_conf*
*
* @return
* - 0: Success, queue pair added correctly.
@ -405,7 +476,7 @@ int
rte_event_crypto_adapter_queue_pair_add(uint8_t id,
uint8_t cdev_id,
int32_t queue_pair_id,
const struct rte_event *event);
const struct rte_event_crypto_adapter_queue_conf *conf);
/**
* Delete a queue pair from an event crypto adapter.
@ -523,6 +594,26 @@ rte_event_crypto_adapter_service_id_get(uint8_t id, uint32_t *service_id);
int
rte_event_crypto_adapter_event_port_get(uint8_t id, uint8_t *event_port_id);
/**
* Retrieve vector limits for a given event dev and crypto dev pair.
* @see rte_event_crypto_adapter_vector_limits
*
* @param dev_id
* Event device identifier.
* @param cdev_id
* Crypto device identifier.
* @param [out] limits
* A pointer to rte_event_crypto_adapter_vector_limits structure that has to
* be filled.
*
* @return
* - 0: Success.
* - <0: Error code on failure.
*/
int rte_event_crypto_adapter_vector_limits_get(
uint8_t dev_id, uint16_t cdev_id,
struct rte_event_crypto_adapter_vector_limits *limits);
/**
* Enqueue a burst of crypto operations as event objects supplied in *rte_event*
* structure on an event crypto adapter designated by its event *dev_id* through

8
lib/eventdev/rte_eventdev.h
View File

@ -1220,6 +1220,9 @@ struct rte_event_vector {
#define RTE_EVENT_TYPE_ETH_RX_ADAPTER_VECTOR \
(RTE_EVENT_TYPE_VECTOR | RTE_EVENT_TYPE_ETH_RX_ADAPTER)
/**< The event vector generated from eth Rx adapter. */
#define RTE_EVENT_TYPE_CRYPTODEV_VECTOR \
(RTE_EVENT_TYPE_VECTOR | RTE_EVENT_TYPE_CRYPTODEV)
/**< The event vector generated from cryptodev adapter. */
#define RTE_EVENT_TYPE_MAX 0x10
/**< Maximum number of event types */
@ -1437,6 +1440,11 @@ rte_event_timer_adapter_caps_get(uint8_t dev_id, uint32_t *caps);
* the private data information along with the crypto session.
*/
#define RTE_EVENT_CRYPTO_ADAPTER_CAP_EVENT_VECTOR 0x10
/**< Flag indicates HW is capable of aggregating processed
* crypto operations into rte_event_vector.
*/
/**
* Retrieve the event device's crypto adapter capabilities for the
* specified cryptodev device