DPDK 22.11.5
|
#include <rte_compat.h>
#include "rte_kvargs.h"
#include "rte_crypto.h"
#include <rte_common.h>
#include <rte_rcu_qsbr.h>
#include "rte_cryptodev_trace_fp.h"
#include <rte_cryptodev_core.h>
Go to the source code of this file.
Data Structures | |
struct | rte_crypto_param_range |
struct | rte_cryptodev_symmetric_capability |
struct | rte_cryptodev_asymmetric_xform_capability |
struct | rte_cryptodev_asymmetric_capability |
struct | rte_cryptodev_capabilities |
struct | rte_cryptodev_sym_capability_idx |
struct | rte_cryptodev_asym_capability_idx |
struct | rte_cryptodev_info |
struct | rte_cryptodev_qp_conf |
struct | rte_cryptodev_stats |
struct | rte_cryptodev_config |
struct | rte_cryptodev_cb |
union | rte_cryptodev_session_ctx |
struct | rte_crypto_raw_dp_ctx |
Typedefs | |
typedef uint16_t(* | rte_cryptodev_callback_fn) (uint16_t dev_id, uint16_t qp_id, struct rte_crypto_op **ops, uint16_t nb_ops, void *user_param) |
typedef void(* | rte_cryptodev_cb_fn) (uint8_t dev_id, enum rte_cryptodev_event_type event, void *cb_arg) |
typedef uint32_t(* | cryptodev_sym_raw_enqueue_burst_t) (void *qp, uint8_t *drv_ctx, struct rte_crypto_sym_vec *vec, union rte_crypto_sym_ofs ofs, void *user_data[], int *enqueue_status) |
typedef int(* | cryptodev_sym_raw_enqueue_t) (void *qp, uint8_t *drv_ctx, struct rte_crypto_vec *data_vec, uint16_t n_data_vecs, union rte_crypto_sym_ofs ofs, struct rte_crypto_va_iova_ptr *iv, struct rte_crypto_va_iova_ptr *digest, struct rte_crypto_va_iova_ptr *aad_or_auth_iv, void *user_data) |
typedef int(* | cryptodev_sym_raw_operation_done_t) (void *qp, uint8_t *drv_ctx, uint32_t n) |
typedef uint32_t(* | rte_cryptodev_raw_get_dequeue_count_t) (void *user_data) |
typedef void(* | rte_cryptodev_raw_post_dequeue_t) (void *user_data, uint32_t index, uint8_t is_op_success) |
typedef uint32_t(* | cryptodev_sym_raw_dequeue_burst_t) (void *qp, uint8_t *drv_ctx, rte_cryptodev_raw_get_dequeue_count_t get_dequeue_count, uint32_t max_nb_to_dequeue, rte_cryptodev_raw_post_dequeue_t post_dequeue, void **out_user_data, uint8_t is_user_data_array, uint32_t *n_success, int *dequeue_status) |
typedef void *(* | cryptodev_sym_raw_dequeue_t) (void *qp, uint8_t *drv_ctx, int *dequeue_status, enum rte_crypto_op_status *op_status) |
Enumerations | |
enum | rte_cryptodev_event_type { RTE_CRYPTODEV_EVENT_UNKNOWN , RTE_CRYPTODEV_EVENT_ERROR , RTE_CRYPTODEV_EVENT_MAX } |
Functions | |
const struct rte_cryptodev_symmetric_capability * | rte_cryptodev_sym_capability_get (uint8_t dev_id, const struct rte_cryptodev_sym_capability_idx *idx) |
__rte_experimental const struct rte_cryptodev_asymmetric_xform_capability * | rte_cryptodev_asym_capability_get (uint8_t dev_id, const struct rte_cryptodev_asym_capability_idx *idx) |
int | rte_cryptodev_sym_capability_check_cipher (const struct rte_cryptodev_symmetric_capability *capability, uint16_t key_size, uint16_t iv_size) |
int | rte_cryptodev_sym_capability_check_auth (const struct rte_cryptodev_symmetric_capability *capability, uint16_t key_size, uint16_t digest_size, uint16_t iv_size) |
int | rte_cryptodev_sym_capability_check_aead (const struct rte_cryptodev_symmetric_capability *capability, uint16_t key_size, uint16_t digest_size, uint16_t aad_size, uint16_t iv_size) |
__rte_experimental int | rte_cryptodev_asym_xform_capability_check_optype (const struct rte_cryptodev_asymmetric_xform_capability *capability, enum rte_crypto_asym_op_type op_type) |
__rte_experimental int | rte_cryptodev_asym_xform_capability_check_modlen (const struct rte_cryptodev_asymmetric_xform_capability *capability, uint16_t modlen) |
int | rte_cryptodev_get_cipher_algo_enum (enum rte_crypto_cipher_algorithm *algo_enum, const char *algo_string) |
int | rte_cryptodev_get_auth_algo_enum (enum rte_crypto_auth_algorithm *algo_enum, const char *algo_string) |
int | rte_cryptodev_get_aead_algo_enum (enum rte_crypto_aead_algorithm *algo_enum, const char *algo_string) |
__rte_experimental int | rte_cryptodev_asym_get_xform_enum (enum rte_crypto_asym_xform_type *xform_enum, const char *xform_string) |
const char * | rte_cryptodev_get_feature_name (uint64_t flag) |
int | rte_cryptodev_get_dev_id (const char *name) |
const char * | rte_cryptodev_name_get (uint8_t dev_id) |
uint8_t | rte_cryptodev_count (void) |
uint8_t | rte_cryptodev_device_count_by_driver (uint8_t driver_id) |
uint8_t | rte_cryptodev_devices_get (const char *driver_name, uint8_t *devices, uint8_t nb_devices) |
int | rte_cryptodev_configure (uint8_t dev_id, struct rte_cryptodev_config *config) |
int | rte_cryptodev_start (uint8_t dev_id) |
void | rte_cryptodev_stop (uint8_t dev_id) |
int | rte_cryptodev_close (uint8_t dev_id) |
int | rte_cryptodev_queue_pair_setup (uint8_t dev_id, uint16_t queue_pair_id, const struct rte_cryptodev_qp_conf *qp_conf, int socket_id) |
__rte_experimental int | rte_cryptodev_get_qp_status (uint8_t dev_id, uint16_t queue_pair_id) |
uint16_t | rte_cryptodev_queue_pair_count (uint8_t dev_id) |
int | rte_cryptodev_stats_get (uint8_t dev_id, struct rte_cryptodev_stats *stats) |
void | rte_cryptodev_stats_reset (uint8_t dev_id) |
void | rte_cryptodev_info_get (uint8_t dev_id, struct rte_cryptodev_info *dev_info) |
int | rte_cryptodev_callback_register (uint8_t dev_id, enum rte_cryptodev_event_type event, rte_cryptodev_cb_fn cb_fn, void *cb_arg) |
int | rte_cryptodev_callback_unregister (uint8_t dev_id, enum rte_cryptodev_event_type event, rte_cryptodev_cb_fn cb_fn, void *cb_arg) |
RTE_TAILQ_HEAD (rte_cryptodev_cb_list, rte_cryptodev_callback) | |
void * | rte_cryptodev_get_sec_ctx (uint8_t dev_id) |
__rte_experimental struct rte_mempool * | 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) |
__rte_experimental struct rte_mempool * | rte_cryptodev_asym_session_pool_create (const char *name, uint32_t nb_elts, uint32_t cache_size, uint16_t user_data_size, int socket_id) |
void * | rte_cryptodev_sym_session_create (uint8_t dev_id, struct rte_crypto_sym_xform *xforms, struct rte_mempool *mp) |
__rte_experimental int | rte_cryptodev_asym_session_create (uint8_t dev_id, struct rte_crypto_asym_xform *xforms, struct rte_mempool *mp, void **session) |
int | rte_cryptodev_sym_session_free (uint8_t dev_id, void *sess) |
__rte_experimental int | rte_cryptodev_asym_session_free (uint8_t dev_id, void *sess) |
__rte_experimental unsigned int | rte_cryptodev_asym_get_header_session_size (void) |
unsigned int | rte_cryptodev_sym_get_private_session_size (uint8_t dev_id) |
__rte_experimental unsigned int | rte_cryptodev_asym_get_private_session_size (uint8_t dev_id) |
unsigned int | rte_cryptodev_is_valid_dev (uint8_t dev_id) |
int | rte_cryptodev_driver_id_get (const char *name) |
const char * | rte_cryptodev_driver_name_get (uint8_t driver_id) |
__rte_experimental int | rte_cryptodev_sym_session_set_user_data (void *sess, void *data, uint16_t size) |
static uint64_t | rte_cryptodev_sym_session_opaque_data_get (void *sess) |
static void | rte_cryptodev_sym_session_opaque_data_set (void *sess, uint64_t opaque) |
__rte_experimental void * | rte_cryptodev_sym_session_get_user_data (void *sess) |
__rte_experimental int | rte_cryptodev_asym_session_set_user_data (void *sess, void *data, uint16_t size) |
__rte_experimental void * | rte_cryptodev_asym_session_get_user_data (void *sess) |
__rte_experimental uint32_t | rte_cryptodev_sym_cpu_crypto_process (uint8_t dev_id, void *sess, union rte_crypto_sym_ofs ofs, struct rte_crypto_sym_vec *vec) |
__rte_experimental int | rte_cryptodev_get_raw_dp_ctx_size (uint8_t dev_id) |
__rte_experimental int | rte_cryptodev_session_event_mdata_set (uint8_t dev_id, void *sess, enum rte_crypto_op_type op_type, enum rte_crypto_op_sess_type sess_type, void *ev_mdata, uint16_t size) |
__rte_experimental int | rte_cryptodev_configure_raw_dp_ctx (uint8_t dev_id, uint16_t qp_id, struct rte_crypto_raw_dp_ctx *ctx, enum rte_crypto_op_sess_type sess_type, union rte_cryptodev_session_ctx session_ctx, uint8_t is_update) |
__rte_experimental uint32_t | rte_cryptodev_raw_enqueue_burst (struct rte_crypto_raw_dp_ctx *ctx, struct rte_crypto_sym_vec *vec, union rte_crypto_sym_ofs ofs, void **user_data, int *enqueue_status) |
static __rte_experimental __rte_always_inline int | rte_cryptodev_raw_enqueue (struct rte_crypto_raw_dp_ctx *ctx, struct rte_crypto_vec *data_vec, uint16_t n_data_vecs, union rte_crypto_sym_ofs ofs, struct rte_crypto_va_iova_ptr *iv, struct rte_crypto_va_iova_ptr *digest, struct rte_crypto_va_iova_ptr *aad_or_auth_iv, void *user_data) |
__rte_experimental int | rte_cryptodev_raw_enqueue_done (struct rte_crypto_raw_dp_ctx *ctx, uint32_t n) |
__rte_experimental uint32_t | rte_cryptodev_raw_dequeue_burst (struct rte_crypto_raw_dp_ctx *ctx, rte_cryptodev_raw_get_dequeue_count_t get_dequeue_count, uint32_t max_nb_to_dequeue, rte_cryptodev_raw_post_dequeue_t post_dequeue, void **out_user_data, uint8_t is_user_data_array, uint32_t *n_success, int *dequeue_status) |
static __rte_experimental __rte_always_inline void * | rte_cryptodev_raw_dequeue (struct rte_crypto_raw_dp_ctx *ctx, int *dequeue_status, enum rte_crypto_op_status *op_status) |
__rte_experimental int | rte_cryptodev_raw_dequeue_done (struct rte_crypto_raw_dp_ctx *ctx, uint32_t n) |
__rte_experimental struct rte_cryptodev_cb * | rte_cryptodev_add_enq_callback (uint8_t dev_id, uint16_t qp_id, rte_cryptodev_callback_fn cb_fn, void *cb_arg) |
__rte_experimental int | rte_cryptodev_remove_enq_callback (uint8_t dev_id, uint16_t qp_id, struct rte_cryptodev_cb *cb) |
__rte_experimental struct rte_cryptodev_cb * | rte_cryptodev_add_deq_callback (uint8_t dev_id, uint16_t qp_id, rte_cryptodev_callback_fn cb_fn, void *cb_arg) |
__rte_experimental int | rte_cryptodev_remove_deq_callback (uint8_t dev_id, uint16_t qp_id, struct rte_cryptodev_cb *cb) |
static uint16_t | rte_cryptodev_dequeue_burst (uint8_t dev_id, uint16_t qp_id, struct rte_crypto_op **ops, uint16_t nb_ops) |
static uint16_t | rte_cryptodev_enqueue_burst (uint8_t dev_id, uint16_t qp_id, struct rte_crypto_op **ops, uint16_t nb_ops) |
RTE Cryptographic Device APIs
Defines RTE Crypto Device APIs for the provisioning of cipher and authentication operations.
Definition in file rte_cryptodev.h.
#define rte_crypto_op_ctod_offset | ( | c, | |
t, | |||
o | |||
) | ((t)((char *)(c) + (o))) |
A macro that points to an offset from the start of the crypto operation structure (rte_crypto_op)
The returned pointer is cast to type t.
c | The crypto operation. |
o | The offset from the start of the crypto operation. |
t | The type to cast the result into. |
Definition at line 64 of file rte_cryptodev.h.
#define rte_crypto_op_ctophys_offset | ( | c, | |
o | |||
) | (rte_iova_t)((c)->phys_addr + (o)) |
A macro that returns the physical address that points to an offset from the start of the crypto operation (rte_crypto_op)
c | The crypto operation. |
o | The offset from the start of the crypto operation to calculate address from. |
Definition at line 78 of file rte_cryptodev.h.
#define RTE_CRYPTO_CIPHER_DATA_UNIT_LEN_512_BYTES RTE_BIT32(0) |
Data-unit supported lengths of cipher algorithms. A bit can represent any set of data-unit sizes (single size, multiple size, range, etc).
Definition at line 100 of file rte_cryptodev.h.
#define RTE_CRYPTODEV_END_OF_CAPABILITIES_LIST | ( | ) | { RTE_CRYPTO_OP_TYPE_UNDEFINED } |
Macro used at end of crypto PMD list
Definition at line 409 of file rte_cryptodev.h.
#define RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO (1ULL << 0) |
Crypto device supported feature flags
Note: New features flags should be added to the end of the list
Keep these flags synchronised with rte_cryptodev_get_feature_name() Symmetric crypto operations are supported
Definition at line 422 of file rte_cryptodev.h.
#define RTE_CRYPTODEV_FF_ASYMMETRIC_CRYPTO (1ULL << 1) |
Asymmetric crypto operations are supported
Definition at line 424 of file rte_cryptodev.h.
#define RTE_CRYPTODEV_FF_SYM_OPERATION_CHAINING (1ULL << 2) |
Chaining symmetric crypto operations are supported
Definition at line 426 of file rte_cryptodev.h.
#define RTE_CRYPTODEV_FF_CPU_SSE (1ULL << 3) |
Utilises CPU SIMD SSE instructions
Definition at line 428 of file rte_cryptodev.h.
#define RTE_CRYPTODEV_FF_CPU_AVX (1ULL << 4) |
Utilises CPU SIMD AVX instructions
Definition at line 430 of file rte_cryptodev.h.
#define RTE_CRYPTODEV_FF_CPU_AVX2 (1ULL << 5) |
Utilises CPU SIMD AVX2 instructions
Definition at line 432 of file rte_cryptodev.h.
#define RTE_CRYPTODEV_FF_CPU_AESNI (1ULL << 6) |
Utilises CPU AES-NI instructions
Definition at line 434 of file rte_cryptodev.h.
#define RTE_CRYPTODEV_FF_HW_ACCELERATED (1ULL << 7) |
Operations are off-loaded to an external hardware accelerator
Definition at line 438 of file rte_cryptodev.h.
#define RTE_CRYPTODEV_FF_CPU_AVX512 (1ULL << 8) |
Utilises CPU SIMD AVX512 instructions
Definition at line 440 of file rte_cryptodev.h.
#define RTE_CRYPTODEV_FF_IN_PLACE_SGL (1ULL << 9) |
In-place Scatter-gather (SGL) buffers, with multiple segments, are supported
Definition at line 444 of file rte_cryptodev.h.
#define RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT (1ULL << 10) |
Out-of-place Scatter-gather (SGL) buffers are supported in input and output
Definition at line 448 of file rte_cryptodev.h.
#define RTE_CRYPTODEV_FF_OOP_SGL_IN_LB_OUT (1ULL << 11) |
Out-of-place Scatter-gather (SGL) buffers are supported in input, combined with linear buffers (LB), with a single segment in output
Definition at line 453 of file rte_cryptodev.h.
#define RTE_CRYPTODEV_FF_OOP_LB_IN_SGL_OUT (1ULL << 12) |
Out-of-place Scatter-gather (SGL) buffers are supported in output, combined with linear buffers (LB) in input
Definition at line 457 of file rte_cryptodev.h.
#define RTE_CRYPTODEV_FF_OOP_LB_IN_LB_OUT (1ULL << 13) |
Out-of-place linear buffers (LB) are supported in input and output
Definition at line 459 of file rte_cryptodev.h.
#define RTE_CRYPTODEV_FF_CPU_NEON (1ULL << 14) |
Utilises CPU NEON instructions
Definition at line 461 of file rte_cryptodev.h.
#define RTE_CRYPTODEV_FF_CPU_ARM_CE (1ULL << 15) |
Utilises ARM CPU Cryptographic Extensions
Definition at line 463 of file rte_cryptodev.h.
#define RTE_CRYPTODEV_FF_SECURITY (1ULL << 16) |
Support Security Protocol Processing
Definition at line 465 of file rte_cryptodev.h.
#define RTE_CRYPTODEV_FF_RSA_PRIV_OP_KEY_EXP (1ULL << 17) |
Support RSA Private Key OP with exponent
Definition at line 467 of file rte_cryptodev.h.
#define RTE_CRYPTODEV_FF_RSA_PRIV_OP_KEY_QT (1ULL << 18) |
Support RSA Private Key OP with CRT (quintuple) Keys
Definition at line 469 of file rte_cryptodev.h.
#define RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED (1ULL << 19) |
Support encrypted-digest operations where digest is appended to data
Definition at line 471 of file rte_cryptodev.h.
#define RTE_CRYPTODEV_FF_ASYM_SESSIONLESS (1ULL << 20) |
Support asymmetric session-less operations
Definition at line 473 of file rte_cryptodev.h.
#define RTE_CRYPTODEV_FF_SYM_CPU_CRYPTO (1ULL << 21) |
Support symmetric cpu-crypto processing
Definition at line 475 of file rte_cryptodev.h.
#define RTE_CRYPTODEV_FF_SYM_SESSIONLESS (1ULL << 22) |
Support symmetric session-less operations
Definition at line 477 of file rte_cryptodev.h.
#define RTE_CRYPTODEV_FF_NON_BYTE_ALIGNED_DATA (1ULL << 23) |
Support operations on data which is not byte aligned
Definition at line 479 of file rte_cryptodev.h.
#define RTE_CRYPTODEV_FF_SYM_RAW_DP (1ULL << 24) |
Support accelerator specific symmetric raw data-path APIs
Definition at line 481 of file rte_cryptodev.h.
#define RTE_CRYPTODEV_FF_CIPHER_MULTIPLE_DATA_UNITS (1ULL << 25) |
Support operations on multiple data-units message
Definition at line 483 of file rte_cryptodev.h.
#define RTE_CRYPTODEV_FF_CIPHER_WRAPPED_KEY (1ULL << 26) |
Support wrapped key in cipher xform
Definition at line 485 of file rte_cryptodev.h.
#define RTE_CRYPTODEV_FF_SECURITY_INNER_CSUM (1ULL << 27) |
Support inner checksum computation/verification
Definition at line 487 of file rte_cryptodev.h.
#define RTE_CRYPTODEV_NAME_MAX_LEN (64) |
Max length of name of crypto PMD
Definition at line 603 of file rte_cryptodev.h.
typedef uint16_t(* rte_cryptodev_callback_fn) (uint16_t dev_id, uint16_t qp_id, struct rte_crypto_op **ops, uint16_t nb_ops, void *user_param) |
Function type used for processing crypto ops when enqueue/dequeue burst is called.
The callback function is called on enqueue/dequeue burst immediately.
dev_id | The identifier of the device. |
qp_id | The index of the queue pair on which ops are enqueued/dequeued. The value must be in the range [0, nb_queue_pairs - 1] previously supplied to rte_cryptodev_configure. |
ops | The address of an array of nb_ops pointers to rte_crypto_op structures which contain the crypto operations to be processed. |
nb_ops | The number of operations to process. |
user_param | The arbitrary user parameter passed in by the application when the callback was originally registered. |
Definition at line 573 of file rte_cryptodev.h.
typedef void(* rte_cryptodev_cb_fn) (uint8_t dev_id, enum rte_cryptodev_event_type event, void *cb_arg) |
Typedef for application callback function to be registered by application software for notification of device events
dev_id | Crypto device identifier |
event | Crypto device event to register for notification of. |
cb_arg | User specified parameter to be passed as to passed to users callback function. |
Definition at line 585 of file rte_cryptodev.h.
typedef uint32_t(* cryptodev_sym_raw_enqueue_burst_t) (void *qp, uint8_t *drv_ctx, struct rte_crypto_sym_vec *vec, union rte_crypto_sym_ofs ofs, void *user_data[], int *enqueue_status) |
Enqueue a vectorized operation descriptor into the device queue but the driver may or may not start processing until rte_cryptodev_raw_enqueue_done() is called.
qp | Driver specific queue pair data. |
drv_ctx | Driver specific context data. |
vec | Vectorized operation descriptor. |
ofs | Start and stop offsets for auth and cipher operations. |
user_data | The array of user data for dequeue later. |
enqueue_status | Driver written value to specify the enqueue status. Possible values:
|
Definition at line 1294 of file rte_cryptodev.h.
typedef int(* cryptodev_sym_raw_enqueue_t) (void *qp, uint8_t *drv_ctx, struct rte_crypto_vec *data_vec, uint16_t n_data_vecs, union rte_crypto_sym_ofs ofs, struct rte_crypto_va_iova_ptr *iv, struct rte_crypto_va_iova_ptr *digest, struct rte_crypto_va_iova_ptr *aad_or_auth_iv, void *user_data) |
Enqueue single raw data vector into the device queue but the driver may or may not start processing until rte_cryptodev_raw_enqueue_done() is called.
qp | Driver specific queue pair data. |
drv_ctx | Driver specific context data. |
data_vec | The buffer data vector. |
n_data_vecs | Number of buffer data vectors. |
ofs | Start and stop offsets for auth and cipher operations. |
iv | IV virtual and IOVA addresses |
digest | digest virtual and IOVA addresses |
aad_or_auth_iv | AAD or auth IV virtual and IOVA addresses, depends on the algorithm used. |
user_data | The user data. |
Definition at line 1319 of file rte_cryptodev.h.
typedef int(* cryptodev_sym_raw_operation_done_t) (void *qp, uint8_t *drv_ctx, uint32_t n) |
Inform the cryptodev queue pair to start processing or finish dequeuing all enqueued/dequeued operations.
qp | Driver specific queue pair data. |
drv_ctx | Driver specific context data. |
n | The total number of processed operations. |
Definition at line 1338 of file rte_cryptodev.h.
typedef uint32_t(* rte_cryptodev_raw_get_dequeue_count_t) (void *user_data) |
Typedef that the user provided for the driver to get the dequeue count. The function may return a fixed number or the number parsed from the user data stored in the first processed operation.
user_data | Dequeued user data. |
Definition at line 1350 of file rte_cryptodev.h.
typedef void(* rte_cryptodev_raw_post_dequeue_t) (void *user_data, uint32_t index, uint8_t is_op_success) |
Typedef that the user provided to deal with post dequeue operation, such as filling status.
user_data | Dequeued user data. |
index | Index number of the processed descriptor. |
is_op_success | Operation status provided by the driver. |
Definition at line 1360 of file rte_cryptodev.h.
typedef uint32_t(* cryptodev_sym_raw_dequeue_burst_t) (void *qp, uint8_t *drv_ctx, rte_cryptodev_raw_get_dequeue_count_t get_dequeue_count, uint32_t max_nb_to_dequeue, rte_cryptodev_raw_post_dequeue_t post_dequeue, void **out_user_data, uint8_t is_user_data_array, uint32_t *n_success, int *dequeue_status) |
Dequeue a burst of symmetric crypto processing.
qp | Driver specific queue pair data. |
drv_ctx | Driver specific context data. |
get_dequeue_count | User provided callback function to obtain dequeue operation count. |
max_nb_to_dequeue | When get_dequeue_count is NULL this value is used to pass the maximum number of operations to be dequeued. |
post_dequeue | User provided callback function to post-process a dequeued operation. |
out_user_data | User data pointer array to be retrieve from device queue. In case of is_user_data_array is set there should be enough room to store all user data. |
is_user_data_array | Set 1 if every dequeued user data will be written into out_user_data array. Set 0 if only the first user data will be written into out_user_data array. |
n_success | Driver written value to specific the total successful operations count. |
dequeue_status | Driver written value to specify the dequeue status. Possible values:
|
Definition at line 1404 of file rte_cryptodev.h.
typedef void *(* cryptodev_sym_raw_dequeue_t) (void *qp, uint8_t *drv_ctx, int *dequeue_status, enum rte_crypto_op_status *op_status) |
Dequeue a symmetric crypto processing.
qp | Driver specific queue pair data. |
drv_ctx | Driver specific context data. |
dequeue_status | Driver written value to specify the dequeue status. Possible values:
|
op_status | Driver written value to specify operation status. |
Definition at line 1435 of file rte_cryptodev.h.
Definitions of Crypto device event types
Enumerator | |
---|---|
RTE_CRYPTODEV_EVENT_UNKNOWN | unknown event type |
RTE_CRYPTODEV_EVENT_ERROR | error interrupt event |
RTE_CRYPTODEV_EVENT_MAX | max value of this enum |
Definition at line 537 of file rte_cryptodev.h.
const struct rte_cryptodev_symmetric_capability * rte_cryptodev_sym_capability_get | ( | uint8_t | dev_id, |
const struct rte_cryptodev_sym_capability_idx * | idx | ||
) |
Provide capabilities available for defined device and algorithm
dev_id | The identifier of the device. |
idx | Description of crypto algorithms. |
__rte_experimental const struct rte_cryptodev_asymmetric_xform_capability * rte_cryptodev_asym_capability_get | ( | uint8_t | dev_id, |
const struct rte_cryptodev_asym_capability_idx * | idx | ||
) |
Provide capabilities available for defined device and xform
dev_id | The identifier of the device. |
idx | Description of asym crypto xform. |
int rte_cryptodev_sym_capability_check_cipher | ( | const struct rte_cryptodev_symmetric_capability * | capability, |
uint16_t | key_size, | ||
uint16_t | iv_size | ||
) |
Check if key size and initial vector are supported in crypto cipher capability
capability | Description of the symmetric crypto capability. |
key_size | Cipher key size. |
iv_size | Cipher initial vector size. |
int rte_cryptodev_sym_capability_check_auth | ( | const struct rte_cryptodev_symmetric_capability * | capability, |
uint16_t | key_size, | ||
uint16_t | digest_size, | ||
uint16_t | iv_size | ||
) |
Check if key size and initial vector are supported in crypto auth capability
capability | Description of the symmetric crypto capability. |
key_size | Auth key size. |
digest_size | Auth digest size. |
iv_size | Auth initial vector size. |
int rte_cryptodev_sym_capability_check_aead | ( | const struct rte_cryptodev_symmetric_capability * | capability, |
uint16_t | key_size, | ||
uint16_t | digest_size, | ||
uint16_t | aad_size, | ||
uint16_t | iv_size | ||
) |
Check if key, digest, AAD and initial vector sizes are supported in crypto AEAD capability
capability | Description of the symmetric crypto capability. |
key_size | AEAD key size. |
digest_size | AEAD digest size. |
aad_size | AEAD AAD size. |
iv_size | AEAD IV size. |
__rte_experimental int rte_cryptodev_asym_xform_capability_check_optype | ( | const struct rte_cryptodev_asymmetric_xform_capability * | capability, |
enum rte_crypto_asym_op_type | op_type | ||
) |
Check if op type is supported
capability | Description of the asymmetric crypto capability. |
op_type | op type |
__rte_experimental int rte_cryptodev_asym_xform_capability_check_modlen | ( | const struct rte_cryptodev_asymmetric_xform_capability * | capability, |
uint16_t | modlen | ||
) |
Check if modulus length is in supported range
capability | Description of the asymmetric crypto capability. |
modlen | modulus length. |
int rte_cryptodev_get_cipher_algo_enum | ( | enum rte_crypto_cipher_algorithm * | algo_enum, |
const char * | algo_string | ||
) |
Provide the cipher algorithm enum, given an algorithm string
algo_enum | A pointer to the cipher algorithm enum to be filled |
algo_string | Authentication algo string |
int rte_cryptodev_get_auth_algo_enum | ( | enum rte_crypto_auth_algorithm * | algo_enum, |
const char * | algo_string | ||
) |
Provide the authentication algorithm enum, given an algorithm string
algo_enum | A pointer to the authentication algorithm enum to be filled |
algo_string | Authentication algo string |
int rte_cryptodev_get_aead_algo_enum | ( | enum rte_crypto_aead_algorithm * | algo_enum, |
const char * | algo_string | ||
) |
Provide the AEAD algorithm enum, given an algorithm string
algo_enum | A pointer to the AEAD algorithm enum to be filled |
algo_string | AEAD algorithm string |
__rte_experimental int rte_cryptodev_asym_get_xform_enum | ( | enum rte_crypto_asym_xform_type * | xform_enum, |
const char * | xform_string | ||
) |
Provide the Asymmetric xform enum, given an xform string
xform_enum | A pointer to the xform type enum to be filled |
xform_string | xform string |
const char * rte_cryptodev_get_feature_name | ( | uint64_t | flag | ) |
Get the name of a crypto device feature flag
flag | The mask describing the flag. |
int rte_cryptodev_get_dev_id | ( | const char * | name | ) |
Get the device identifier for the named crypto device.
name | device name to select the device structure. |
const char * rte_cryptodev_name_get | ( | uint8_t | dev_id | ) |
Get the crypto device name given a device identifier.
dev_id | The identifier of the device |
uint8_t rte_cryptodev_count | ( | void | ) |
Get the total number of crypto devices that have been successfully initialised.
uint8_t rte_cryptodev_device_count_by_driver | ( | uint8_t | driver_id | ) |
Get number of crypto device defined type.
driver_id | driver identifier. |
uint8_t rte_cryptodev_devices_get | ( | const char * | driver_name, |
uint8_t * | devices, | ||
uint8_t | nb_devices | ||
) |
Get number and identifiers of attached crypto devices that use the same crypto driver.
driver_name | driver name. |
devices | output devices identifiers. |
nb_devices | maximal number of devices. |
int rte_cryptodev_configure | ( | uint8_t | dev_id, |
struct rte_cryptodev_config * | config | ||
) |
Configure a device.
This function must be invoked first before any other function in the API. This function can also be re-invoked when a device is in the stopped state.
dev_id | The identifier of the device to configure. |
config | The crypto device configuration structure. |
int rte_cryptodev_start | ( | uint8_t | dev_id | ) |
Start an device.
The device start step is the last one and consists of setting the configured offload features and in starting the transmit and the receive units of the device. On success, all basic functions exported by the API (link status, receive/transmit, and so on) can be invoked.
dev_id | The identifier of the device. |
void rte_cryptodev_stop | ( | uint8_t | dev_id | ) |
Stop an device. The device can be restarted with a call to rte_cryptodev_start()
dev_id | The identifier of the device. |
int rte_cryptodev_close | ( | uint8_t | dev_id | ) |
Close an device. The device cannot be restarted!
dev_id | The identifier of the device. |
int rte_cryptodev_queue_pair_setup | ( | uint8_t | dev_id, |
uint16_t | queue_pair_id, | ||
const struct rte_cryptodev_qp_conf * | qp_conf, | ||
int | socket_id | ||
) |
Allocate and set up a receive queue pair for a device.
dev_id | The identifier of the device. |
queue_pair_id | The index of the queue pairs to set up. The value must be in the range [0, nb_queue_pair
|
qp_conf | The pointer to the configuration data to be used for the queue pair. |
socket_id | The socket_id argument is the socket identifier in case of NUMA. The value can be SOCKET_ID_ANY if there is no NUMA constraint for the DMA memory allocated for the receive queue pair. |
__rte_experimental int rte_cryptodev_get_qp_status | ( | uint8_t | dev_id, |
uint16_t | queue_pair_id | ||
) |
Get the status of queue pairs setup on a specific crypto device
dev_id | Crypto device identifier. |
queue_pair_id | The index of the queue pairs to set up. The value must be in the range [0, nb_queue_pair
|
uint16_t rte_cryptodev_queue_pair_count | ( | uint8_t | dev_id | ) |
Get the number of queue pairs on a specific crypto device
dev_id | Crypto device identifier. |
int rte_cryptodev_stats_get | ( | uint8_t | dev_id, |
struct rte_cryptodev_stats * | stats | ||
) |
Retrieve the general I/O statistics of a device.
dev_id | The identifier of the device. |
stats | A pointer to a structure of type rte_cryptodev_stats to be filled with the values of device counters. |
void rte_cryptodev_stats_reset | ( | uint8_t | dev_id | ) |
Reset the general I/O statistics of a device.
dev_id | The identifier of the device. |
void rte_cryptodev_info_get | ( | uint8_t | dev_id, |
struct rte_cryptodev_info * | dev_info | ||
) |
Retrieve the contextual information of a device.
dev_id | The identifier of the device. |
dev_info | A pointer to a structure of type rte_cryptodev_info to be filled with the contextual information of the device. |
int rte_cryptodev_callback_register | ( | uint8_t | dev_id, |
enum rte_cryptodev_event_type | event, | ||
rte_cryptodev_cb_fn | cb_fn, | ||
void * | cb_arg | ||
) |
Register a callback function for specific device id.
dev_id | Device id. |
event | Event interested. |
cb_fn | User supplied callback function to be called. |
cb_arg | Pointer to the parameters for the registered callback. |
int rte_cryptodev_callback_unregister | ( | uint8_t | dev_id, |
enum rte_cryptodev_event_type | event, | ||
rte_cryptodev_cb_fn | cb_fn, | ||
void * | cb_arg | ||
) |
Unregister a callback function for specific device id.
dev_id | The device identifier. |
event | Event interested. |
cb_fn | User supplied callback function to be called. |
cb_arg | Pointer to the parameters for the registered callback. |
RTE_TAILQ_HEAD | ( | rte_cryptodev_cb_list | , |
rte_cryptodev_callback | |||
) |
Structure to keep track of registered callbacks
void * rte_cryptodev_get_sec_ctx | ( | uint8_t | dev_id | ) |
Get the security context for the cryptodev.
dev_id | The device identifier. |
__rte_experimental struct rte_mempool * 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 a symmetric session mempool.
name | The unique mempool name. |
nb_elts | The number of elements in the mempool. |
elt_size | The size of the element. This should be the size of the cryptodev PMD session private data obtained through rte_cryptodev_sym_get_private_session_size() function call. For the user who wants to use the same mempool for heterogeneous PMDs this value should be the maximum value of their private session sizes. Please note the created mempool will have bigger elt size than this value as necessary session header and the possible padding are filled into each elt. |
cache_size | The number of per-lcore cache elements |
priv_size | The private data size of each session. |
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. |
__rte_experimental struct rte_mempool * rte_cryptodev_asym_session_pool_create | ( | const char * | name, |
uint32_t | nb_elts, | ||
uint32_t | cache_size, | ||
uint16_t | user_data_size, | ||
int | socket_id | ||
) |
Create an asymmetric session mempool.
name | The unique mempool name. |
nb_elts | The number of elements in the mempool. |
cache_size | The number of per-lcore cache elements |
user_data_size | The size of user data to be placed after session private data. |
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. |
void * rte_cryptodev_sym_session_create | ( | uint8_t | dev_id, |
struct rte_crypto_sym_xform * | xforms, | ||
struct rte_mempool * | mp | ||
) |
Create symmetric crypto session and fill out private data for the device id, based on its device type.
dev_id | ID of device that we want the session to be used on |
xforms | Symmetric crypto transform operations to apply on flow processed with this session |
mp | Mempool to allocate symmetric session objects from |
__rte_experimental int rte_cryptodev_asym_session_create | ( | uint8_t | dev_id, |
struct rte_crypto_asym_xform * | xforms, | ||
struct rte_mempool * | mp, | ||
void ** | session | ||
) |
Create and initialise an asymmetric crypto session structure. Calls the PMD to configure the private session data.
dev_id | ID of device that we want the session to be used on |
xforms | Asymmetric crypto transform operations to apply on flow processed with this session |
mp | mempool to allocate asymmetric session objects from |
session | void ** for session to be used |
int rte_cryptodev_sym_session_free | ( | uint8_t | dev_id, |
void * | sess | ||
) |
Frees session for the device id and returning it to its mempool. It is the application's responsibility to ensure that the session is not still in-flight operations using it.
dev_id | ID of device that uses the session. |
sess | Session header to be freed. |
__rte_experimental int rte_cryptodev_asym_session_free | ( | uint8_t | dev_id, |
void * | sess | ||
) |
Clears and frees asymmetric crypto session header and private data, returning it to its original mempool.
dev_id | ID of device that uses the asymmetric session. |
sess | Session header to be freed. |
__rte_experimental unsigned int rte_cryptodev_asym_get_header_session_size | ( | void | ) |
Get the size of the asymmetric session header.
unsigned int rte_cryptodev_sym_get_private_session_size | ( | uint8_t | dev_id | ) |
Get the size of the private symmetric session data for a device.
dev_id | The device identifier. |
__rte_experimental unsigned int rte_cryptodev_asym_get_private_session_size | ( | uint8_t | dev_id | ) |
Get the size of the private data for asymmetric session on device
dev_id | The device identifier. |
unsigned int rte_cryptodev_is_valid_dev | ( | uint8_t | dev_id | ) |
Validate if the crypto device index is valid attached crypto device.
dev_id | Crypto device index. |
int rte_cryptodev_driver_id_get | ( | const char * | name | ) |
Provide driver identifier.
name | The pointer to a driver name. |
const char * rte_cryptodev_driver_name_get | ( | uint8_t | driver_id | ) |
Provide driver name.
driver_id | The driver identifier. |
__rte_experimental int rte_cryptodev_sym_session_set_user_data | ( | void * | sess, |
void * | data, | ||
uint16_t | size | ||
) |
Store user data in a session.
sess | Session pointer allocated by rte_cryptodev_sym_session_create. |
data | Pointer to the user data. |
size | Size of the user data. |
|
inlinestatic |
Get opaque data from session handle
Definition at line 1146 of file rte_cryptodev.h.
|
inlinestatic |
Set opaque data in session handle
Definition at line 1155 of file rte_cryptodev.h.
__rte_experimental void * rte_cryptodev_sym_session_get_user_data | ( | void * | sess | ) |
Get user data stored in a session.
sess | Session pointer allocated by rte_cryptodev_sym_session_create. |
__rte_experimental int rte_cryptodev_asym_session_set_user_data | ( | void * | sess, |
void * | data, | ||
uint16_t | size | ||
) |
Store user data in an asymmetric session.
sess | Session pointer allocated by rte_cryptodev_asym_session_create. |
data | Pointer to the user data. |
size | Size of the user data. |
__rte_experimental void * rte_cryptodev_asym_session_get_user_data | ( | void * | sess | ) |
Get user data stored in an asymmetric session.
sess | Session pointer allocated by rte_cryptodev_asym_session_create. |
__rte_experimental uint32_t rte_cryptodev_sym_cpu_crypto_process | ( | uint8_t | dev_id, |
void * | sess, | ||
union rte_crypto_sym_ofs | ofs, | ||
struct rte_crypto_sym_vec * | vec | ||
) |
Perform actual crypto processing (encrypt/digest or auth/decrypt) on user provided data.
dev_id | The device identifier. |
sess | Cryptodev session structure |
ofs | Start and stop offsets for auth and cipher operations |
vec | Vectorized operation descriptor |
__rte_experimental int rte_cryptodev_get_raw_dp_ctx_size | ( | uint8_t | dev_id | ) |
Get the size of the raw data-path context buffer.
dev_id | The device identifier. |
__rte_experimental int rte_cryptodev_session_event_mdata_set | ( | uint8_t | dev_id, |
void * | sess, | ||
enum rte_crypto_op_type | op_type, | ||
enum rte_crypto_op_sess_type | sess_type, | ||
void * | ev_mdata, | ||
uint16_t | size | ||
) |
Set session event meta data
dev_id | The device identifier. |
sess | Crypto or security session. |
op_type | Operation type. |
sess_type | Session type. |
ev_mdata | Pointer to the event crypto meta data (aka union rte_event_crypto_metadata) |
size | Size of ev_mdata. |
__rte_experimental int rte_cryptodev_configure_raw_dp_ctx | ( | uint8_t | dev_id, |
uint16_t | qp_id, | ||
struct rte_crypto_raw_dp_ctx * | ctx, | ||
enum rte_crypto_op_sess_type | sess_type, | ||
union rte_cryptodev_session_ctx | session_ctx, | ||
uint8_t | is_update | ||
) |
Configure raw data-path context data.
NOTE: After the context data is configured, the user should call rte_cryptodev_raw_attach_session() before using it in rte_cryptodev_raw_enqueue/dequeue function call.
dev_id | The device identifier. |
qp_id | The index of the queue pair from which to retrieve processed packets. The value must be in the range [0, nb_queue_pair - 1] previously supplied to rte_cryptodev_configure(). |
ctx | The raw data-path context data. |
sess_type | session type. |
session_ctx | Session context data. |
is_update | Set 0 if it is to initialize the ctx. Set 1 if ctx is initialized and only to update session context data. |
__rte_experimental uint32_t rte_cryptodev_raw_enqueue_burst | ( | struct rte_crypto_raw_dp_ctx * | ctx, |
struct rte_crypto_sym_vec * | vec, | ||
union rte_crypto_sym_ofs | ofs, | ||
void ** | user_data, | ||
int * | enqueue_status | ||
) |
Enqueue a vectorized operation descriptor into the device queue but the driver may or may not start processing until rte_cryptodev_raw_enqueue_done() is called.
ctx | The initialized raw data-path context data. |
vec | Vectorized operation descriptor. |
ofs | Start and stop offsets for auth and cipher operations. |
user_data | The array of user data for dequeue later. |
enqueue_status | Driver written value to specify the enqueue status. Possible values:
|
|
static |
Enqueue single raw data vector into the device queue but the driver may or may not start processing until rte_cryptodev_raw_enqueue_done() is called.
ctx | The initialized raw data-path context data. |
data_vec | The buffer data vector. |
n_data_vecs | Number of buffer data vectors. |
ofs | Start and stop offsets for auth and cipher operations. |
iv | IV virtual and IOVA addresses |
digest | digest virtual and IOVA addresses |
aad_or_auth_iv | AAD or auth IV virtual and IOVA addresses, depends on the algorithm used. |
user_data | The user data. |
Definition at line 1541 of file rte_cryptodev.h.
__rte_experimental int rte_cryptodev_raw_enqueue_done | ( | struct rte_crypto_raw_dp_ctx * | ctx, |
uint32_t | n | ||
) |
Start processing all enqueued operations from last rte_cryptodev_configure_raw_dp_ctx() call.
ctx | The initialized raw data-path context data. |
n | The number of operations cached. |
__rte_experimental uint32_t rte_cryptodev_raw_dequeue_burst | ( | struct rte_crypto_raw_dp_ctx * | ctx, |
rte_cryptodev_raw_get_dequeue_count_t | get_dequeue_count, | ||
uint32_t | max_nb_to_dequeue, | ||
rte_cryptodev_raw_post_dequeue_t | post_dequeue, | ||
void ** | out_user_data, | ||
uint8_t | is_user_data_array, | ||
uint32_t * | n_success, | ||
int * | dequeue_status | ||
) |
Dequeue a burst of symmetric crypto processing.
ctx | The initialized raw data-path context data. |
get_dequeue_count | User provided callback function to obtain dequeue operation count. |
max_nb_to_dequeue | When get_dequeue_count is NULL this value is used to pass the maximum number of operations to be dequeued. |
post_dequeue | User provided callback function to post-process a dequeued operation. |
out_user_data | User data pointer array to be retrieve from device queue. In case of is_user_data_array is set there should be enough room to store all user data. |
is_user_data_array | Set 1 if every dequeued user data will be written into out_user_data array. Set 0 if only the first user data will be written into out_user_data array. |
n_success | Driver written value to specific the total successful operations count. |
dequeue_status | Driver written value to specify the dequeue status. Possible values:
|
|
static |
Dequeue a symmetric crypto processing.
ctx | The initialized raw data-path context data. |
dequeue_status | Driver written value to specify the dequeue status. Possible values:
|
op_status | Driver written value to specify operation status. |
Definition at line 1643 of file rte_cryptodev.h.
__rte_experimental int rte_cryptodev_raw_dequeue_done | ( | struct rte_crypto_raw_dp_ctx * | ctx, |
uint32_t | n | ||
) |
Inform the queue pair dequeue operations is finished.
ctx | The initialized raw data-path context data. |
n | The number of operations. |
__rte_experimental struct rte_cryptodev_cb * rte_cryptodev_add_enq_callback | ( | uint8_t | dev_id, |
uint16_t | qp_id, | ||
rte_cryptodev_callback_fn | cb_fn, | ||
void * | cb_arg | ||
) |
Add a user callback for a given crypto device and queue pair which will be called on crypto ops enqueue.
This API configures a function to be called for each burst of crypto ops received on a given crypto device queue pair. The return value is a pointer that can be used later to remove the callback using rte_cryptodev_remove_enq_callback().
Callbacks registered by application would not survive rte_cryptodev_configure() as it reinitializes the callback list. It is user responsibility to remove all installed callbacks before calling rte_cryptodev_configure() to avoid possible memory leakage. Application is expected to call add API after rte_cryptodev_configure().
Multiple functions can be registered per queue pair & they are called in the order they were added. The API does not restrict on maximum number of callbacks.
dev_id | The identifier of the device. |
qp_id | The index of the queue pair on which ops are to be enqueued for processing. The value must be in the range [0, nb_queue_pairs - 1] previously supplied to rte_cryptodev_configure. |
cb_fn | The callback function |
cb_arg | A generic pointer parameter which will be passed to each invocation of the callback function on this crypto device and queue pair. |
__rte_experimental int rte_cryptodev_remove_enq_callback | ( | uint8_t | dev_id, |
uint16_t | qp_id, | ||
struct rte_cryptodev_cb * | cb | ||
) |
Remove a user callback function for given crypto device and queue pair.
This function is used to remove enqueue callbacks that were added to a crypto device queue pair using rte_cryptodev_add_enq_callback().
dev_id | The identifier of the device. |
qp_id | The index of the queue pair on which ops are to be enqueued. The value must be in the range [0, nb_queue_pairs - 1] previously supplied to rte_cryptodev_configure. |
cb | Pointer to user supplied callback created via rte_cryptodev_add_enq_callback(). |
__rte_experimental struct rte_cryptodev_cb * rte_cryptodev_add_deq_callback | ( | uint8_t | dev_id, |
uint16_t | qp_id, | ||
rte_cryptodev_callback_fn | cb_fn, | ||
void * | cb_arg | ||
) |
Add a user callback for a given crypto device and queue pair which will be called on crypto ops dequeue.
This API configures a function to be called for each burst of crypto ops received on a given crypto device queue pair. The return value is a pointer that can be used later to remove the callback using rte_cryptodev_remove_deq_callback().
Callbacks registered by application would not survive rte_cryptodev_configure() as it reinitializes the callback list. It is user responsibility to remove all installed callbacks before calling rte_cryptodev_configure() to avoid possible memory leakage. Application is expected to call add API after rte_cryptodev_configure().
Multiple functions can be registered per queue pair & they are called in the order they were added. The API does not restrict on maximum number of callbacks.
dev_id | The identifier of the device. |
qp_id | The index of the queue pair on which ops are to be dequeued. The value must be in the range [0, nb_queue_pairs - 1] previously supplied to rte_cryptodev_configure. |
cb_fn | The callback function |
cb_arg | A generic pointer parameter which will be passed to each invocation of the callback function on this crypto device and queue pair. |
__rte_experimental int rte_cryptodev_remove_deq_callback | ( | uint8_t | dev_id, |
uint16_t | qp_id, | ||
struct rte_cryptodev_cb * | cb | ||
) |
Remove a user callback function for given crypto device and queue pair.
This function is used to remove dequeue callbacks that were added to a crypto device queue pair using rte_cryptodev_add_deq_callback().
dev_id | The identifier of the device. |
qp_id | The index of the queue pair on which ops are to be dequeued. The value must be in the range [0, nb_queue_pairs - 1] previously supplied to rte_cryptodev_configure. |
cb | Pointer to user supplied callback created via rte_cryptodev_add_deq_callback(). |
|
inlinestatic |
Dequeue a burst of processed crypto operations from a queue on the crypto device. The dequeued operation are stored in rte_crypto_op structures whose pointers are supplied in the ops array.
The rte_cryptodev_dequeue_burst() function returns the number of ops actually dequeued, which is the number of rte_crypto_op data structures effectively supplied into the ops array.
A return value equal to nb_ops indicates that the queue contained at least nb_ops operations, and this is likely to signify that other processed operations remain in the devices output queue. Applications implementing a "retrieve as many processed operations as possible" policy can check this specific case and keep invoking the rte_cryptodev_dequeue_burst() function until a value less than nb_ops is returned.
The rte_cryptodev_dequeue_burst() function does not provide any error notification to avoid the corresponding overhead.
dev_id | The symmetric crypto device identifier |
qp_id | The index of the queue pair from which to retrieve processed packets. The value must be in the range [0, nb_queue_pair - 1] previously supplied to rte_cryptodev_configure(). |
ops | The address of an array of pointers to rte_crypto_op structures that must be large enough to store nb_ops pointers in it. |
nb_ops | The maximum number of operations to dequeue. |
Definition at line 1840 of file rte_cryptodev.h.
|
inlinestatic |
Enqueue a burst of operations for processing on a crypto device.
The rte_cryptodev_enqueue_burst() function is invoked to place crypto operations on the queue qp_id of the device designated by its dev_id.
The nb_ops parameter is the number of operations to process which are supplied in the ops array of rte_crypto_op structures.
The rte_cryptodev_enqueue_burst() function returns the number of operations it actually enqueued for processing. A return value equal to nb_ops means that all packets have been enqueued.
dev_id | The identifier of the device. |
qp_id | The index of the queue pair which packets are to be enqueued for processing. The value must be in the range [0, nb_queue_pairs - 1] previously supplied to rte_cryptodev_configure. |
ops | The address of an array of nb_ops pointers to rte_crypto_op structures which contain the crypto operations to be processed. |
nb_ops | The number of operations to process. |
Definition at line 1912 of file rte_cryptodev.h.