DPDK  20.05.0
Data Structures | Macros | Typedefs | Enumerations | Functions
rte_cryptodev.h File Reference
#include "rte_kvargs.h"
#include "rte_crypto.h"
#include "rte_dev.h"
#include <rte_common.h>
#include <rte_config.h>
#include "rte_cryptodev_trace_fp.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
 
struct  rte_cryptodev_data
 
struct  rte_cryptodev_sym_session
 
struct  rte_cryptodev_asym_session
 

Macros

#define rte_crypto_op_ctod_offset(c, t, o)   ((t)((char *)(c) + (o)))
 
#define rte_crypto_op_ctophys_offset(c, o)   (rte_iova_t)((c)->phys_addr + (o))
 
#define RTE_CRYPTODEV_END_OF_CAPABILITIES_LIST()   { RTE_CRYPTO_OP_TYPE_UNDEFINED }
 
#define RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO   (1ULL << 0)
 
#define RTE_CRYPTODEV_FF_ASYMMETRIC_CRYPTO   (1ULL << 1)
 
#define RTE_CRYPTODEV_FF_SYM_OPERATION_CHAINING   (1ULL << 2)
 
#define RTE_CRYPTODEV_FF_CPU_SSE   (1ULL << 3)
 
#define RTE_CRYPTODEV_FF_CPU_AVX   (1ULL << 4)
 
#define RTE_CRYPTODEV_FF_CPU_AVX2   (1ULL << 5)
 
#define RTE_CRYPTODEV_FF_CPU_AESNI   (1ULL << 6)
 
#define RTE_CRYPTODEV_FF_HW_ACCELERATED   (1ULL << 7)
 
#define RTE_CRYPTODEV_FF_CPU_AVX512   (1ULL << 8)
 
#define RTE_CRYPTODEV_FF_IN_PLACE_SGL   (1ULL << 9)
 
#define RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT   (1ULL << 10)
 
#define RTE_CRYPTODEV_FF_OOP_SGL_IN_LB_OUT   (1ULL << 11)
 
#define RTE_CRYPTODEV_FF_OOP_LB_IN_SGL_OUT   (1ULL << 12)
 
#define RTE_CRYPTODEV_FF_OOP_LB_IN_LB_OUT   (1ULL << 13)
 
#define RTE_CRYPTODEV_FF_CPU_NEON   (1ULL << 14)
 
#define RTE_CRYPTODEV_FF_CPU_ARM_CE   (1ULL << 15)
 
#define RTE_CRYPTODEV_FF_SECURITY   (1ULL << 16)
 
#define RTE_CRYPTODEV_FF_RSA_PRIV_OP_KEY_EXP   (1ULL << 17)
 
#define RTE_CRYPTODEV_FF_RSA_PRIV_OP_KEY_QT   (1ULL << 18)
 
#define RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED   (1ULL << 19)
 
#define RTE_CRYPTODEV_FF_ASYM_SESSIONLESS   (1ULL << 20)
 
#define RTE_CRYPTODEV_FF_SYM_CPU_CRYPTO   (1ULL << 21)
 
#define RTE_CRYPTODEV_FF_SYM_SESSIONLESS   (1ULL << 22)
 
#define RTE_CRYPTODEV_FF_NON_BYTE_ALIGNED_DATA   (1ULL << 23)
 
#define RTE_CRYPTODEV_NAME_MAX_LEN   (64)
 

Typedefs

typedef void(* rte_cryptodev_cb_fn) (uint8_t dev_id, enum rte_cryptodev_event_type event, void *cb_arg)
 
typedef uint16_t(* dequeue_pkt_burst_t) (void *qp, struct rte_crypto_op **ops, uint16_t nb_ops)
 
typedef uint16_t(* enqueue_pkt_burst_t) (void *qp, struct rte_crypto_op **ops, uint16_t nb_ops)
 

Enumerations

enum  rte_cryptodev_event_type { RTE_CRYPTODEV_EVENT_UNKNOWN, RTE_CRYPTODEV_EVENT_ERROR, RTE_CRYPTODEV_EVENT_MAX }
 

Functions

const struct rte_cryptodev_symmetric_capabilityrte_cryptodev_sym_capability_get_v20 (uint8_t dev_id, const struct rte_cryptodev_sym_capability_idx *idx)
 
__rte_experimental const struct rte_cryptodev_asymmetric_xform_capabilityrte_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)
 
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)
 
 TAILQ_HEAD (rte_cryptodev_cb_list, rte_cryptodev_callback)
 
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_experimental struct rte_mempoolrte_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)
 
struct rte_cryptodev_sym_sessionrte_cryptodev_sym_session_create (struct rte_mempool *mempool)
 
__rte_experimental struct rte_cryptodev_asym_sessionrte_cryptodev_asym_session_create (struct rte_mempool *mempool)
 
int rte_cryptodev_sym_session_free (struct rte_cryptodev_sym_session *sess)
 
__rte_experimental int rte_cryptodev_asym_session_free (struct rte_cryptodev_asym_session *sess)
 
int rte_cryptodev_sym_session_init (uint8_t dev_id, struct rte_cryptodev_sym_session *sess, struct rte_crypto_sym_xform *xforms, struct rte_mempool *mempool)
 
__rte_experimental int rte_cryptodev_asym_session_init (uint8_t dev_id, struct rte_cryptodev_asym_session *sess, struct rte_crypto_asym_xform *xforms, struct rte_mempool *mempool)
 
int rte_cryptodev_sym_session_clear (uint8_t dev_id, struct rte_cryptodev_sym_session *sess)
 
__rte_experimental int rte_cryptodev_asym_session_clear (uint8_t dev_id, struct rte_cryptodev_asym_session *sess)
 
unsigned int rte_cryptodev_sym_get_header_session_size (void)
 
__rte_experimental unsigned int rte_cryptodev_sym_get_existing_header_session_size (struct rte_cryptodev_sym_session *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)
 
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 (struct rte_cryptodev_sym_session *sess, void *data, uint16_t size)
 
__rte_experimental void * rte_cryptodev_sym_session_get_user_data (struct rte_cryptodev_sym_session *sess)
 
__rte_experimental uint32_t rte_cryptodev_sym_cpu_crypto_process (uint8_t dev_id, struct rte_cryptodev_sym_session *sess, union rte_crypto_sym_ofs ofs, struct rte_crypto_sym_vec *vec)
 

Detailed Description

RTE Cryptographic Device APIs

Defines RTE Crypto Device APIs for the provisioning of cipher and authentication operations.

Definition in file rte_cryptodev.h.

Macro Definition Documentation

#define rte_crypto_op_ctod_offset (   c,
  t,
 
)    ((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.

Parameters
cThe crypto operation.
oThe offset from the start of the crypto operation.
tThe type to cast the result into.
Examples:
examples/fips_validation/fips_dev_self_test.c, examples/fips_validation/main.c, examples/ipsec-secgw/esp.c, and examples/l2fwd-crypto/main.c.

Definition at line 66 of file rte_cryptodev.h.

#define rte_crypto_op_ctophys_offset (   c,
 
)    (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)

Parameters
cThe crypto operation.
oThe offset from the start of the crypto operation to calculate address from.

Definition at line 80 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 398 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 410 of file rte_cryptodev.h.

#define RTE_CRYPTODEV_FF_ASYMMETRIC_CRYPTO   (1ULL << 1)

Asymmetric crypto operations are supported

Examples:
examples/ipsec-secgw/ipsec-secgw.c.

Definition at line 412 of file rte_cryptodev.h.

#define RTE_CRYPTODEV_FF_SYM_OPERATION_CHAINING   (1ULL << 2)

Chaining symmetric crypto operations are supported

Examples:
examples/ipsec-secgw/ipsec-secgw.c.

Definition at line 414 of file rte_cryptodev.h.

#define RTE_CRYPTODEV_FF_CPU_SSE   (1ULL << 3)

Utilises CPU SIMD SSE instructions

Definition at line 416 of file rte_cryptodev.h.

#define RTE_CRYPTODEV_FF_CPU_AVX   (1ULL << 4)

Utilises CPU SIMD AVX instructions

Definition at line 418 of file rte_cryptodev.h.

#define RTE_CRYPTODEV_FF_CPU_AVX2   (1ULL << 5)

Utilises CPU SIMD AVX2 instructions

Definition at line 420 of file rte_cryptodev.h.

#define RTE_CRYPTODEV_FF_CPU_AESNI   (1ULL << 6)

Utilises CPU AES-NI instructions

Definition at line 422 of file rte_cryptodev.h.

#define RTE_CRYPTODEV_FF_HW_ACCELERATED   (1ULL << 7)

Operations are off-loaded to an external hardware accelerator

Examples:
examples/l2fwd-crypto/main.c.

Definition at line 424 of file rte_cryptodev.h.

#define RTE_CRYPTODEV_FF_CPU_AVX512   (1ULL << 8)

Utilises CPU SIMD AVX512 instructions

Definition at line 428 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

Examples:
examples/ipsec-secgw/ipsec-secgw.c.

Definition at line 430 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 434 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 438 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 443 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 447 of file rte_cryptodev.h.

#define RTE_CRYPTODEV_FF_CPU_NEON   (1ULL << 14)

Utilises CPU NEON instructions

Definition at line 449 of file rte_cryptodev.h.

#define RTE_CRYPTODEV_FF_CPU_ARM_CE   (1ULL << 15)

Utilises ARM CPU Cryptographic Extensions

Definition at line 451 of file rte_cryptodev.h.

#define RTE_CRYPTODEV_FF_SECURITY   (1ULL << 16)

Support Security Protocol Processing

Examples:
examples/l2fwd-crypto/main.c, and examples/vhost_crypto/main.c.

Definition at line 453 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 455 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 457 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 459 of file rte_cryptodev.h.

#define RTE_CRYPTODEV_FF_ASYM_SESSIONLESS   (1ULL << 20)

Support asymmetric session-less operations

Definition at line 461 of file rte_cryptodev.h.

#define RTE_CRYPTODEV_FF_SYM_CPU_CRYPTO   (1ULL << 21)

Support symmetric cpu-crypto processing

Examples:
examples/ipsec-secgw/ipsec.c.

Definition at line 463 of file rte_cryptodev.h.

#define RTE_CRYPTODEV_FF_SYM_SESSIONLESS   (1ULL << 22)

Support symmetric session-less operations

Definition at line 465 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 467 of file rte_cryptodev.h.

#define RTE_CRYPTODEV_NAME_MAX_LEN   (64)

Max length of name of crypto PMD

Definition at line 558 of file rte_cryptodev.h.

Typedef Documentation

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

Parameters
dev_idCrypto device identifier
eventCrypto device event to register for notification of.
cb_argUser specified parameter to be passed as to passed to users callback function.

Definition at line 541 of file rte_cryptodev.h.

typedef uint16_t(* dequeue_pkt_burst_t) (void *qp, struct rte_crypto_op **ops, uint16_t nb_ops)

Dequeue processed packets from queue pair of a device.

Definition at line 840 of file rte_cryptodev.h.

typedef uint16_t(* enqueue_pkt_burst_t) (void *qp, struct rte_crypto_op **ops, uint16_t nb_ops)

Enqueue packets for processing on queue pair of a device.

Definition at line 844 of file rte_cryptodev.h.

Enumeration Type Documentation

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 517 of file rte_cryptodev.h.

Function Documentation

const struct rte_cryptodev_symmetric_capability* rte_cryptodev_sym_capability_get_v20 ( uint8_t  dev_id,
const struct rte_cryptodev_sym_capability_idx idx 
)

Provide capabilities available for defined device and algorithm

Parameters
dev_idThe identifier of the device.
idxDescription of crypto algorithms.
Returns
  • Return description of the symmetric crypto capability if exist.
  • Return NULL if the capability not exist.
__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

Parameters
dev_idThe identifier of the device.
idxDescription of asym crypto xform.
Returns
  • Return description of the asymmetric crypto capability if exist.
  • Return NULL if the capability not exist.
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

Parameters
capabilityDescription of the symmetric crypto capability.
key_sizeCipher key size.
iv_sizeCipher initial vector size.
Returns
  • Return 0 if the parameters are in range of the capability.
  • Return -1 if the parameters are out of range of the capability.
Examples:
examples/fips_validation/fips_dev_self_test.c, and examples/fips_validation/main.c.
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

Parameters
capabilityDescription of the symmetric crypto capability.
key_sizeAuth key size.
digest_sizeAuth digest size.
iv_sizeAuth initial vector size.
Returns
  • Return 0 if the parameters are in range of the capability.
  • Return -1 if the parameters are out of range of the capability.
Examples:
examples/fips_validation/fips_dev_self_test.c, and examples/fips_validation/main.c.
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

Parameters
capabilityDescription of the symmetric crypto capability.
key_sizeAEAD key size.
digest_sizeAEAD digest size.
aad_sizeAEAD AAD size.
iv_sizeAEAD IV size.
Returns
  • Return 0 if the parameters are in range of the capability.
  • Return -1 if the parameters are out of range of the capability.
Examples:
examples/fips_validation/fips_dev_self_test.c, and examples/fips_validation/main.c.
__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

Parameters
capabilityDescription of the asymmetric crypto capability.
op_typeop type
Returns
  • Return 1 if the op type is supported
  • Return 0 if unsupported
__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

Parameters
capabilityDescription of the asymmetric crypto capability.
modlenmodulus length.
Returns
  • Return 0 if the parameters are in range of the capability.
  • Return -1 if the parameters are out of range of the capability.
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

Parameters
algo_enumA pointer to the cipher algorithm enum to be filled
algo_stringAuthentication algo string
Returns
  • Return -1 if string is not valid
  • Return 0 is the string is valid
Examples:
examples/ip_pipeline/cli.c, and examples/l2fwd-crypto/main.c.
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

Parameters
algo_enumA pointer to the authentication algorithm enum to be filled
algo_stringAuthentication algo string
Returns
  • Return -1 if string is not valid
  • Return 0 is the string is valid
Examples:
examples/ip_pipeline/cli.c, and examples/l2fwd-crypto/main.c.
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

Parameters
algo_enumA pointer to the AEAD algorithm enum to be filled
algo_stringAEAD algorithm string
Returns
  • Return -1 if string is not valid
  • Return 0 is the string is valid
Examples:
examples/ip_pipeline/cli.c, and examples/l2fwd-crypto/main.c.
__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

Parameters
xform_enumA pointer to the xform type enum to be filled
xform_stringxform string
Returns
  • Return -1 if string is not valid
  • Return 0 if the string is valid
const char* rte_cryptodev_get_feature_name ( uint64_t  flag)

Get the name of a crypto device feature flag

Parameters
flagThe mask describing the flag.
Returns
The name of this flag, or NULL if it's not a valid feature flag.
Examples:
examples/ipsec-secgw/ipsec-secgw.c.
int rte_cryptodev_get_dev_id ( const char *  name)

Get the device identifier for the named crypto device.

Parameters
namedevice name to select the device structure.
Returns
  • Returns crypto device identifier on success.
  • Return -1 on failure to find named crypto device.
Examples:
examples/fips_validation/main.c, and examples/ip_pipeline/cryptodev.c.
const char* rte_cryptodev_name_get ( uint8_t  dev_id)

Get the crypto device name given a device identifier.

Parameters
dev_idThe identifier of the device
Returns
  • Returns crypto device name.
  • Returns NULL if crypto device is not present.
Examples:
examples/fips_validation/fips_dev_self_test.c, and examples/fips_validation/main.c.
uint8_t rte_cryptodev_count ( void  )

Get the total number of crypto devices that have been successfully initialised.

Returns
  • The total number of usable crypto devices.
Examples:
examples/ipsec-secgw/ipsec-secgw.c, and examples/l2fwd-crypto/main.c.
uint8_t rte_cryptodev_device_count_by_driver ( uint8_t  driver_id)

Get number of crypto device defined type.

Parameters
driver_iddriver identifier.
Returns
Returns number of crypto device.
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.

Parameters
driver_namedriver name.
devicesoutput devices identifiers.
nb_devicesmaximal number of devices.
Returns
Returns number of attached crypto device.
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.

Parameters
dev_idThe identifier of the device to configure.
configThe crypto device configuration structure.
Returns
  • 0: Success, device configured.
  • <0: Error code returned by the driver configuration function.
Examples:
examples/fips_validation/fips_dev_self_test.c, examples/fips_validation/main.c, examples/ip_pipeline/cryptodev.c, examples/ipsec-secgw/ipsec-secgw.c, examples/l2fwd-crypto/main.c, and examples/vhost_crypto/main.c.
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.

Parameters
dev_idThe identifier of the device.
Returns
  • 0: Success, device started.
  • <0: Error code of the driver device start function.
Examples:
examples/fips_validation/fips_dev_self_test.c, examples/ip_pipeline/cryptodev.c, examples/ipsec-secgw/ipsec-secgw.c, examples/l2fwd-crypto/main.c, and examples/vhost_crypto/main.c.
void rte_cryptodev_stop ( uint8_t  dev_id)

Stop an device. The device can be restarted with a call to rte_cryptodev_start()

Parameters
dev_idThe identifier of the device.
Examples:
examples/fips_validation/fips_dev_self_test.c, examples/ip_pipeline/cryptodev.c, and examples/ipsec-secgw/ipsec-secgw.c.
int rte_cryptodev_close ( uint8_t  dev_id)

Close an device. The device cannot be restarted!

Parameters
dev_idThe identifier of the device.
Returns
  • 0 on successfully closing device
  • <0 on failure to close device
Examples:
examples/ipsec-secgw/ipsec-secgw.c.
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.

Parameters
dev_idThe identifier of the device.
queue_pair_idThe index of the queue pairs to set up. The value must be in the range [0, nb_queue_pair
qp_confThe pointer to the configuration data to be used for the queue pair.
socket_idThe 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.
Returns
  • 0: Success, queue pair correctly set up.
  • <0: Queue pair configuration failed
Examples:
examples/fips_validation/fips_dev_self_test.c, examples/fips_validation/main.c, examples/ip_pipeline/cryptodev.c, examples/ipsec-secgw/ipsec-secgw.c, examples/l2fwd-crypto/main.c, and examples/vhost_crypto/main.c.
uint16_t rte_cryptodev_queue_pair_count ( uint8_t  dev_id)

Get the number of queue pairs on a specific crypto device

Parameters
dev_idCrypto device identifier.
Returns
  • The number of configured queue pairs.
int rte_cryptodev_stats_get ( uint8_t  dev_id,
struct rte_cryptodev_stats stats 
)

Retrieve the general I/O statistics of a device.

Parameters
dev_idThe identifier of the device.
statsA pointer to a structure of type rte_cryptodev_stats to be filled with the values of device counters.
Returns
  • Zero if successful.
  • Non-zero otherwise.
void rte_cryptodev_stats_reset ( uint8_t  dev_id)

Reset the general I/O statistics of a device.

Parameters
dev_idThe 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.

Parameters
dev_idThe identifier of the device.
dev_infoA pointer to a structure of type rte_cryptodev_info to be filled with the contextual information of the device.
Note
The capabilities field of dev_info is set to point to the first element of an array of struct rte_cryptodev_capabilities. The element after the last valid element has it's op field set to RTE_CRYPTO_OP_TYPE_UNDEFINED.
Examples:
examples/ip_pipeline/cryptodev.c, examples/ipsec-secgw/ipsec-secgw.c, examples/ipsec-secgw/ipsec.c, examples/l2fwd-crypto/main.c, and examples/vhost_crypto/main.c.
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.

Parameters
dev_idDevice id.
eventEvent interested.
cb_fnUser supplied callback function to be called.
cb_argPointer to the parameters for the registered callback.
Returns
  • On success, zero.
  • On failure, a negative value.
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.

Parameters
dev_idThe device identifier.
eventEvent interested.
cb_fnUser supplied callback function to be called.
cb_argPointer to the parameters for the registered callback.
Returns
  • On success, zero.
  • On failure, a negative value.
TAILQ_HEAD ( rte_cryptodev_cb_list  ,
rte_cryptodev_callback   
)

Structure to keep track of registered callbacks

static uint16_t rte_cryptodev_dequeue_burst ( uint8_t  dev_id,
uint16_t  qp_id,
struct rte_crypto_op **  ops,
uint16_t  nb_ops 
)
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.

Parameters
dev_idThe symmetric crypto device identifier
qp_idThe 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().
opsThe address of an array of pointers to rte_crypto_op structures that must be large enough to store nb_ops pointers in it.
nb_opsThe maximum number of operations to dequeue.
Returns
  • The number of operations actually dequeued, which is the number of pointers to rte_crypto_op structures effectively supplied to the ops array.
Examples:
examples/fips_validation/fips_dev_self_test.c, examples/fips_validation/main.c, examples/ipsec-secgw/ipsec.c, examples/ipsec-secgw/ipsec_process.c, examples/l2fwd-crypto/main.c, and examples/vhost_crypto/main.c.

Definition at line 957 of file rte_cryptodev.h.

static uint16_t rte_cryptodev_enqueue_burst ( uint8_t  dev_id,
uint16_t  qp_id,
struct rte_crypto_op **  ops,
uint16_t  nb_ops 
)
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.

Parameters
dev_idThe identifier of the device.
qp_idThe 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.
opsThe address of an array of nb_ops pointers to rte_crypto_op structures which contain the crypto operations to be processed.
nb_opsThe number of operations to process.
Returns
The number of operations actually enqueued on the crypto device. The return value can be less than the value of the nb_ops parameter when the crypto devices queue is full or if invalid parameters are specified in a rte_crypto_op.
Examples:
examples/fips_validation/fips_dev_self_test.c, examples/fips_validation/main.c, examples/ipsec-secgw/ipsec.c, examples/ipsec-secgw/ipsec_process.c, examples/l2fwd-crypto/main.c, and examples/vhost_crypto/main.c.

Definition at line 1001 of file rte_cryptodev.h.

__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.

Parameters
nameThe unique mempool name.
nb_eltsThe number of elements in the mempool.
elt_sizeThe size of the element. This value will be ignored if it is smaller than the minimum session header size required for the system. For the user who want to use the same mempool for sym session and session private data it can be the maximum value of all existing devices' private data and session header sizes.
cache_sizeThe number of per-lcore cache elements
priv_sizeThe private data size of each session.
socket_idThe 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.
Returns
  • On success return size of the session
  • On failure returns 0
Examples:
examples/fips_validation/fips_dev_self_test.c, examples/fips_validation/main.c, examples/ip_pipeline/cryptodev.c, examples/ipsec-secgw/ipsec-secgw.c, examples/l2fwd-crypto/main.c, and examples/vhost_crypto/main.c.
struct rte_cryptodev_sym_session* rte_cryptodev_sym_session_create ( struct rte_mempool mempool)

Create symmetric crypto session header (generic with no private data)

Parameters
mempoolSymmetric session mempool to allocate session objects from
Returns
  • On success return pointer to sym-session
  • On failure returns NULL
Examples:
examples/fips_validation/fips_dev_self_test.c, examples/fips_validation/main.c, examples/ipsec-secgw/ipsec.c, and examples/l2fwd-crypto/main.c.
__rte_experimental struct rte_cryptodev_asym_session* rte_cryptodev_asym_session_create ( struct rte_mempool mempool)

Create asymmetric crypto session header (generic with no private data)

Parameters
mempoolmempool to allocate asymmetric session objects from
Returns
  • On success return pointer to asym-session
  • On failure returns NULL
int rte_cryptodev_sym_session_free ( struct rte_cryptodev_sym_session sess)

Frees symmetric crypto session header, after checking that all the device private data has been freed, returning it to its original mempool.

Parameters
sessSession header to be freed.
Returns
  • 0 if successful.
  • -EINVAL if session is NULL.
  • -EBUSY if not all device private data has been freed.
Examples:
examples/fips_validation/fips_dev_self_test.c, and examples/fips_validation/main.c.
__rte_experimental int rte_cryptodev_asym_session_free ( struct rte_cryptodev_asym_session sess)

Frees asymmetric crypto session header, after checking that all the device private data has been freed, returning it to its original mempool.

Parameters
sessSession header to be freed.
Returns
  • 0 if successful.
  • -EINVAL if session is NULL.
  • -EBUSY if not all device private data has been freed.
int rte_cryptodev_sym_session_init ( uint8_t  dev_id,
struct rte_cryptodev_sym_session sess,
struct rte_crypto_sym_xform xforms,
struct rte_mempool mempool 
)

Fill out private data for the device id, based on its device type.

Parameters
dev_idID of device that we want the session to be used on
sessSession where the private data will be attached to
xformsSymmetric crypto transform operations to apply on flow processed with this session
mempoolMempool where the private data is allocated.
Returns
  • On success, zero.
  • -EINVAL if input parameters are invalid.
  • -ENOTSUP if crypto device does not support the crypto transform or does not support symmetric operations.
  • -ENOMEM if the private session could not be allocated.
Examples:
examples/fips_validation/fips_dev_self_test.c, examples/fips_validation/main.c, examples/ipsec-secgw/ipsec.c, and examples/l2fwd-crypto/main.c.
__rte_experimental int rte_cryptodev_asym_session_init ( uint8_t  dev_id,
struct rte_cryptodev_asym_session sess,
struct rte_crypto_asym_xform xforms,
struct rte_mempool mempool 
)

Initialize asymmetric session on a device with specific asymmetric xform

Parameters
dev_idID of device that we want the session to be used on
sessSession to be set up on a device
xformsAsymmetric crypto transform operations to apply on flow processed with this session
mempoolMempool to be used for internal allocation.
Returns
  • On success, zero.
  • -EINVAL if input parameters are invalid.
  • -ENOTSUP if crypto device does not support the crypto transform.
  • -ENOMEM if the private session could not be allocated.
int rte_cryptodev_sym_session_clear ( uint8_t  dev_id,
struct rte_cryptodev_sym_session sess 
)

Frees private data for the device id, based on its device type, returning it to its mempool. It is the application's responsibility to ensure that private session data is not cleared while there are still in-flight operations using it.

Parameters
dev_idID of device that uses the session.
sessSession containing the reference to the private data
Returns
  • 0 if successful.
  • -EINVAL if device is invalid or session is NULL.
  • -ENOTSUP if crypto device does not support symmetric operations.
Examples:
examples/fips_validation/fips_dev_self_test.c, and examples/fips_validation/main.c.
__rte_experimental int rte_cryptodev_asym_session_clear ( uint8_t  dev_id,
struct rte_cryptodev_asym_session sess 
)

Frees resources held by asymmetric session during rte_cryptodev_session_init

Parameters
dev_idID of device that uses the asymmetric session.
sessAsymmetric session setup on device using rte_cryptodev_session_init
Returns
  • 0 if successful.
  • -EINVAL if device is invalid or session is NULL.
unsigned int rte_cryptodev_sym_get_header_session_size ( void  )

Get the size of the header session, for all registered drivers excluding the user data size.

Returns
Size of the symmetric header session.
__rte_experimental unsigned int rte_cryptodev_sym_get_existing_header_session_size ( struct rte_cryptodev_sym_session sess)

Get the size of the header session from created session.

Parameters
sessThe sym cryptodev session pointer
Returns
  • If sess is not NULL, return the size of the header session including the private data size defined within sess.
  • If sess is NULL, return 0.
__rte_experimental unsigned int rte_cryptodev_asym_get_header_session_size ( void  )

Get the size of the asymmetric session header, for all registered drivers.

Returns
Size of the asymmetric header session.
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.

Parameters
dev_idThe device identifier.
Returns
  • Size of the private data, if successful
  • 0 if device is invalid or does not have private symmetric session
Examples:
examples/fips_validation/fips_dev_self_test.c, examples/fips_validation/main.c, examples/ip_pipeline/cryptodev.c, examples/ipsec-secgw/ipsec-secgw.c, examples/l2fwd-crypto/main.c, and examples/vhost_crypto/main.c.
__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

Parameters
dev_idThe device identifier.
Returns
  • Size of the asymmetric private data, if successful
  • 0 if device is invalid or does not have private session
int rte_cryptodev_driver_id_get ( const char *  name)

Provide driver identifier.

Parameters
nameThe pointer to a driver name.
Returns
The driver type identifier or -1 if no driver found
const char* rte_cryptodev_driver_name_get ( uint8_t  driver_id)

Provide driver name.

Parameters
driver_idThe driver identifier.
Returns
The driver name or null if no driver found
__rte_experimental int rte_cryptodev_sym_session_set_user_data ( struct rte_cryptodev_sym_session sess,
void *  data,
uint16_t  size 
)

Store user data in a session.

Parameters
sessSession pointer allocated by rte_cryptodev_sym_session_create.
dataPointer to the user data.
sizeSize of the user data.
Returns
  • On success, zero.
  • On failure, a negative value.
__rte_experimental void* rte_cryptodev_sym_session_get_user_data ( struct rte_cryptodev_sym_session sess)

Get user data stored in a session.

Parameters
sessSession pointer allocated by rte_cryptodev_sym_session_create.
Returns
  • On success return pointer to user data.
  • On failure returns NULL.
__rte_experimental uint32_t rte_cryptodev_sym_cpu_crypto_process ( uint8_t  dev_id,
struct rte_cryptodev_sym_session 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.

Parameters
dev_idThe device identifier.
sessCryptodev session structure
ofsStart and stop offsets for auth and cipher operations
vecVectorized operation descriptor
Returns
  • Returns number of successfully processed packets.