---
name: "rte_cryptodev.h"
section: "3"
platform: "linux"
package: "dpdk-doc"
version: "24.11.4-0+deb13u1"
release: "Debian 13 (Trixie)"
platforms: ["linux"]
url: "https://new.carta.tech/rte_cryptodev.h"
---

# rte\_cryptodev.h(3)

## NAME

rte\_cryptodev.h

## SYNOPSIS

`#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'`\

### 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**\

### 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\_CRYPTO\_CIPHER\_DATA\_UNIT\_LEN\_512\_BYTES**   **RTE\_BIT32**(0)\
 \#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\_FF\_SYM\_RAW\_DP**   (1ULL \<\< 24)\
 \#define **RTE\_CRYPTODEV\_FF\_CIPHER\_MULTIPLE\_DATA\_UNITS**   (1ULL \<\< 25)\
 \#define **RTE\_CRYPTODEV\_FF\_CIPHER\_WRAPPED\_KEY**   (1ULL \<\< 26)\
 \#define **RTE\_CRYPTODEV\_FF\_SECURITY\_INNER\_CSUM**   (1ULL \<\< 27)\
 \#define **RTE\_CRYPTODEV\_FF\_SECURITY\_RX\_INJECT**   (1ULL \<\< 28)\
 \#define **RTE\_CRYPTODEV\_QP\_PRIORITY\_HIGHEST**   0\
 \#define **RTE\_CRYPTODEV\_QP\_PRIORITY\_NORMAL**   128\
 \#define **RTE\_CRYPTODEV\_QP\_PRIORITY\_LOWEST**   255\
 \#define **RTE\_CRYPTODEV\_NAME\_MAX\_LEN**   (64)\

### 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)\
 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)\
 int **rte\_cryptodev\_asym\_xform\_capability\_check\_optype** (const struct **rte\_cryptodev\_asymmetric\_xform\_capability** \*capability, enum **rte\_crypto\_asym\_op\_type** op\_type)\
 int **rte\_cryptodev\_asym\_xform\_capability\_check\_modlen** (const struct **rte\_cryptodev\_asymmetric\_xform\_capability** \*capability, uint16\_t modlen)\
 bool **rte\_cryptodev\_asym\_xform\_capability\_check\_hash** (const struct **rte\_cryptodev\_asymmetric\_xform\_capability** \*capability, enum **rte\_crypto\_auth\_algorithm** hash)\
 \_\_rte\_experimental int **rte\_cryptodev\_asym\_xform\_capability\_check\_opcap** (const struct **rte\_cryptodev\_asymmetric\_xform\_capability** \*capability, enum **rte\_crypto\_asym\_op\_type** op\_type, uint8\_t cap)\
 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)\
 int **rte\_cryptodev\_asym\_get\_xform\_enum** (enum **rte\_crypto\_asym\_xform\_type** \*xform\_enum, const char \*xform\_string)\
 \_\_rte\_experimental const char \* **rte\_cryptodev\_get\_cipher\_algo\_string** (enum **rte\_crypto\_cipher\_algorithm** algo\_enum)\
 \_\_rte\_experimental const char \* **rte\_cryptodev\_get\_auth\_algo\_string** (enum **rte\_crypto\_auth\_algorithm** algo\_enum)\
 \_\_rte\_experimental const char \* **rte\_cryptodev\_get\_aead\_algo\_string** (enum **rte\_crypto\_aead\_algorithm** algo\_enum)\
 \_\_rte\_experimental const char \* **rte\_cryptodev\_asym\_get\_xform\_string** (enum **rte\_crypto\_asym\_xform\_type** xform\_enum)\
 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\_queue\_pair\_reset** (uint8\_t dev\_id, uint16\_t queue\_pair\_id, const struct **rte\_cryptodev\_qp\_conf** \*qp\_conf, int socket\_id)\
 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\_experimental int **rte\_cryptodev\_queue\_pair\_event\_error\_query** (uint8\_t dev\_id, uint16\_t qp\_id)\
 **RTE\_TAILQ\_HEAD** (rte\_cryptodev\_cb\_list, rte\_cryptodev\_callback)\
 void \* **rte\_cryptodev\_get\_sec\_ctx** (uint8\_t dev\_id)\
 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)\
 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)\
 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)\
 int **rte\_cryptodev\_asym\_session\_free** (uint8\_t dev\_id, void \*sess)\
 unsigned int **rte\_cryptodev\_asym\_get\_header\_session\_size** (void)\
 unsigned int **rte\_cryptodev\_sym\_get\_private\_session\_size** (uint8\_t dev\_id)\
 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)\
 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)\
 void \* **rte\_cryptodev\_sym\_session\_get\_user\_data** (void \*sess)\
 int **rte\_cryptodev\_asym\_session\_set\_user\_data** (void \*sess, void \*data, uint16\_t size)\
 void \* **rte\_cryptodev\_asym\_session\_get\_user\_data** (void \*sess)\
 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)\
 int **rte\_cryptodev\_get\_raw\_dp\_ctx\_size** (uint8\_t dev\_id)\
 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)\
 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)\
 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)\
 int **rte\_cryptodev\_raw\_enqueue\_done** (struct **rte\_crypto\_raw\_dp\_ctx** \*ctx, uint32\_t n)\
 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)\
 int **rte\_cryptodev\_raw\_dequeue\_done** (struct **rte\_crypto\_raw\_dp\_ctx** \*ctx, uint32\_t n)\
 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)\
 int **rte\_cryptodev\_remove\_enq\_callback** (uint8\_t dev\_id, uint16\_t qp\_id, struct **rte\_cryptodev\_cb** \*cb)\
 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)\
 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)\
 static \_\_rte\_experimental int **rte\_cryptodev\_qp\_depth\_used** (uint8\_t dev\_id, uint16\_t qp\_id)\

## 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, 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.

**Parameters**

*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**)

**Parameters**

*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 **499** 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 **512** of file **rte\_cryptodev.h**.

### #define RTE\_CRYPTODEV\_FF\_ASYMMETRIC\_CRYPTO (1ULL \<\< 1)

Asymmetric crypto operations are supported

Definition at line **514** of file **rte\_cryptodev.h**.

### #define RTE\_CRYPTODEV\_FF\_SYM\_OPERATION\_CHAINING (1ULL \<\< 2)

Chaining symmetric crypto operations are supported

Definition at line **516** of file **rte\_cryptodev.h**.

### #define RTE\_CRYPTODEV\_FF\_CPU\_SSE (1ULL \<\< 3)

Utilises CPU SIMD SSE instructions

Definition at line **518** of file **rte\_cryptodev.h**.

### #define RTE\_CRYPTODEV\_FF\_CPU\_AVX (1ULL \<\< 4)

Utilises CPU SIMD AVX instructions

Definition at line **520** of file **rte\_cryptodev.h**.

### #define RTE\_CRYPTODEV\_FF\_CPU\_AVX2 (1ULL \<\< 5)

Utilises CPU SIMD AVX2 instructions

Definition at line **522** of file **rte\_cryptodev.h**.

### #define RTE\_CRYPTODEV\_FF\_CPU\_AESNI (1ULL \<\< 6)

Utilises CPU AES-NI instructions

Definition at line **524** 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 **528** of file **rte\_cryptodev.h**.

### #define RTE\_CRYPTODEV\_FF\_CPU\_AVX512 (1ULL \<\< 8)

Utilises CPU SIMD AVX512 instructions

Definition at line **530** 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 **534** 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 **538** 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 **543** 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 **547** 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 **549** of file **rte\_cryptodev.h**.

### #define RTE\_CRYPTODEV\_FF\_CPU\_NEON (1ULL \<\< 14)

Utilises CPU NEON instructions

Definition at line **551** of file **rte\_cryptodev.h**.

### #define RTE\_CRYPTODEV\_FF\_CPU\_ARM\_CE (1ULL \<\< 15)

Utilises ARM CPU Cryptographic Extensions

Definition at line **553** of file **rte\_cryptodev.h**.

### #define RTE\_CRYPTODEV\_FF\_SECURITY (1ULL \<\< 16)

Support Security Protocol Processing

Definition at line **555** 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 **557** 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 **559** 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 **561** of file **rte\_cryptodev.h**.

### #define RTE\_CRYPTODEV\_FF\_ASYM\_SESSIONLESS (1ULL \<\< 20)

Support asymmetric session-less operations

Definition at line **563** of file **rte\_cryptodev.h**.

### #define RTE\_CRYPTODEV\_FF\_SYM\_CPU\_CRYPTO (1ULL \<\< 21)

Support symmetric cpu-crypto processing

Definition at line **565** of file **rte\_cryptodev.h**.

### #define RTE\_CRYPTODEV\_FF\_SYM\_SESSIONLESS (1ULL \<\< 22)

Support symmetric session-less operations

Definition at line **567** 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 **569** 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 **571** 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 **573** of file **rte\_cryptodev.h**.

### #define RTE\_CRYPTODEV\_FF\_CIPHER\_WRAPPED\_KEY (1ULL \<\< 26)

Support wrapped key in cipher xform \

Definition at line **575** of file **rte\_cryptodev.h**.

### #define RTE\_CRYPTODEV\_FF\_SECURITY\_INNER\_CSUM (1ULL \<\< 27)

Support inner checksum computation/verification

Definition at line **577** of file **rte\_cryptodev.h**.

### #define RTE\_CRYPTODEV\_FF\_SECURITY\_RX\_INJECT (1ULL \<\< 28)

Support Rx injection after security processing

Definition at line **579** of file **rte\_cryptodev.h**.

### #define RTE\_CRYPTODEV\_QP\_PRIORITY\_HIGHEST 0

Highest priority of a cryptodev queue pair

**See also**

**rte\_cryptodev\_queue\_pair\_setup()**, **rte\_cryptodev\_enqueue\_burst()**

Definition at line **638** of file **rte\_cryptodev.h**.

### #define RTE\_CRYPTODEV\_QP\_PRIORITY\_NORMAL 128

Normal priority of a cryptodev queue pair

**See also**

**rte\_cryptodev\_queue\_pair\_setup()**, **rte\_cryptodev\_enqueue\_burst()**

Definition at line **642** of file **rte\_cryptodev.h**.

### #define RTE\_CRYPTODEV\_QP\_PRIORITY\_LOWEST 255

Lowest priority of a cryptodev queue pair

**See also**

**rte\_cryptodev\_queue\_pair\_setup()**, **rte\_cryptodev\_enqueue\_burst()**

Definition at line **646** of file **rte\_cryptodev.h**.

### #define RTE\_CRYPTODEV\_NAME\_MAX\_LEN (64)

Max length of name of crypto PMD

Definition at line **716** of file **rte\_cryptodev.h**.

## Typedef Documentation

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

**Parameters**

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

**Returns**

**The number of ops to be enqueued to the crypto device.**

**Definition at line 686 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**

**Parameters**

*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 698 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.**

**Parameters**

*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:**

- •

  **1: The number of operations returned are enqueued successfully.**

- •

  **0: The number of operations returned are cached into the queue but are not processed until rte\_cryptodev\_raw\_enqueue\_done() is called.**

- •

  **negative integer: Error occurred.**

**Returns**

- •

  **The number of operations in the descriptor successfully enqueued or cached into the queue but not enqueued yet, depends on the 'enqueue\_status' value.**

**Definition at line 1441 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.**

**Parameters**

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

**Returns**

- •

  **1: The data vector is enqueued successfully.**

- •

  **0: The data vector is cached into the queue but is not processed until rte\_cryptodev\_raw\_enqueue\_done() is called.**

- •

  **negative integer: failure.**

**Definition at line 1466 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.**

**Parameters**

*qp* **Driver specific queue pair data.** \
 *drv\_ctx* **Driver specific context data.** \
 *n* **The total number of processed operations.**

**Returns**

- •

  **On success return 0.**

- •

  **On failure return negative integer.**

**Definition at line 1485 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.**

**Parameters**

*user\_data* **Dequeued user data.**

**Returns**

- •

  **The number of operations to be dequeued.**

**Definition at line 1497 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.**

**Parameters**

*user\_data* **Dequeued user data.** \
 *index* **Index number of the processed descriptor.** \
 *is\_op\_success* **Operation status provided by the driver.**

**Definition at line 1507 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.**

**Parameters**

*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:**

- •

  **1: Successfully dequeued the number of operations returned. The user data previously set during enqueue is stored in the 'out\_user\_data'.**

- •

  **0: The number of operations returned are completed and the user data is stored in the 'out\_user\_data', but they are not freed from the queue until rte\_cryptodev\_raw\_dequeue\_done() is called.**

- •

  **negative integer: Error occurred.**

**Returns**

- •

  **The number of operations dequeued or completed but not freed from the queue, depends on 'dequeue\_status' value.**

**Definition at line 1551 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.**

**Parameters**

*qp* **Driver specific queue pair data.** \
 *drv\_ctx* **Driver specific context data.** \
 *dequeue\_status* **Driver written value to specify the dequeue status. Possible values:**

- •

  **1: Successfully dequeued a operation. The user data is returned.**

- •

  **0: The first operation in the queue is completed and the user data previously set during enqueue is returned, but it is not freed from the queue until rte\_cryptodev\_raw\_dequeue\_done() is called.**

- •

  **negative integer: Error occurred.**

*op\_status* **Driver written value to specify operation status.**

**Returns**

- •

  **The user data pointer retrieved from device queue or NULL if no operation is ready for dequeue.**

**Definition at line 1582 of file rte\_cryptodev.h.**

## Enumeration Type Documentation

### enum rte\_cryptodev\_event\_type

**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* **628** *of file* **rte\_cryptodev.h***.*

## Function Documentation

### 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*

**Parameters**

*dev\_id The identifier of the device.* \
 *idx Description of crypto algorithms.*

**Returns**

- •

  *Return description of the symmetric crypto capability if exist.*

- •

  *Return NULL if the capability not exist.*

### 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\_id The identifier of the device.* \
 *idx Description 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**

*capability Description of the symmetric crypto capability.* \
 *key\_size Cipher key size.* \
 *iv\_size Cipher 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.*

### 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**

*capability Description of the symmetric crypto capability.* \
 *key\_size Auth key size.* \
 *digest\_size Auth digest size.* \
 *iv\_size Auth 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.*

### 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**

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

**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\_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**

*capability Description of the asymmetric crypto capability.* \
 *op\_type op type*

**Returns**

- •

  *Return 1 if the op type is supported*

- •

  *Return 0 if unsupported*

### 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**

*capability Description of the asymmetric crypto capability.* \
 *modlen modulus 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.*

### bool rte\_cryptodev\_asym\_xform\_capability\_check\_hash (const struct rte\_cryptodev\_asymmetric\_xform\_capability \* capability, enum rte\_crypto\_auth\_algorithm hash)

*Check if hash algorithm is supported.*

**Parameters**

*capability Asymmetric crypto capability.* \
 *hash Hash algorithm.*

**Returns**

- •

  *Return true if the hash algorithm is supported.*

- •

  *Return false if the hash algorithm is not supported.*

### \_\_rte\_experimental int rte\_cryptodev\_asym\_xform\_capability\_check\_opcap (const struct rte\_cryptodev\_asymmetric\_xform\_capability \* capability, enum rte\_crypto\_asym\_op\_type op\_type, uint8\_t cap)

**Warning**

**EXPERIMENTAL:** *this API may change without prior notice.*

*Check if op capability is supported*

**Parameters**

*capability Description of the asymmetric crypto capability.* \
 *op\_type op type* \
 *cap op capability*

**Returns**

- •

  *Return 1 if the op capability is supported*

- •

  *Return 0 if unsupported*

### 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\_enum A pointer to the cipher algorithm enum to be filled* \
 *algo\_string Authentication algo string*

**Returns**

- •

  *Return -1 if string is not valid*

- •

  *Return 0 is the string is valid*

### 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\_enum A pointer to the authentication algorithm enum to be filled* \
 *algo\_string Authentication algo string*

**Returns**

- •

  *Return -1 if string is not valid*

- •

  *Return 0 is the string is valid*

### 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\_enum A pointer to the AEAD algorithm enum to be filled* \
 *algo\_string AEAD algorithm string*

**Returns**

- •

  *Return -1 if string is not valid*

- •

  *Return 0 is the string is valid*

### 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\_enum A pointer to the xform type enum to be filled* \
 *xform\_string xform string*

**Returns**

- •

  *Return -1 if string is not valid*

- •

  *Return 0 if the string is valid*

### \_\_rte\_experimental const char \* rte\_cryptodev\_get\_cipher\_algo\_string (enum rte\_crypto\_cipher\_algorithm algo\_enum)

*Provide the cipher algorithm string, given an algorithm enum.*

**Parameters**

*algo\_enum cipher algorithm enum*

**Returns**

- •

  *Return NULL if enum is not valid*

- •

  *Return algo\_string corresponding to enum*

### \_\_rte\_experimental const char \* rte\_cryptodev\_get\_auth\_algo\_string (enum rte\_crypto\_auth\_algorithm algo\_enum)

*Provide the authentication algorithm string, given an algorithm enum.*

**Parameters**

*algo\_enum auth algorithm enum*

**Returns**

- •

  *Return NULL if enum is not valid*

- •

  *Return algo\_string corresponding to enum*

### \_\_rte\_experimental const char \* rte\_cryptodev\_get\_aead\_algo\_string (enum rte\_crypto\_aead\_algorithm algo\_enum)

*Provide the AEAD algorithm string, given an algorithm enum.*

**Parameters**

*algo\_enum AEAD algorithm enum*

**Returns**

- •

  *Return NULL if enum is not valid*

- •

  *Return algo\_string corresponding to enum*

### \_\_rte\_experimental const char \* rte\_cryptodev\_asym\_get\_xform\_string (enum rte\_crypto\_asym\_xform\_type xform\_enum)

*Provide the Asymmetric xform string, given an xform enum.*

**Parameters**

*xform\_enum xform type enum*

**Returns**

- •

  *Return NULL, if enum is not valid.*

- •

  *Return xform string, for valid enum.*

### const char \* rte\_cryptodev\_get\_feature\_name (uint64\_t flag)

*Get the name of a crypto device feature flag*

**Parameters**

*flag The mask describing the flag.*

**Returns**

*The name of this flag, or NULL if it's not a valid feature flag.*

### int rte\_cryptodev\_get\_dev\_id (const char \* name)

*Get the device identifier for the named crypto device.*

**Parameters**

*name device name to select the device structure.*

**Returns**

- •

  *Returns crypto device identifier on success.*

- •

  *Return -1 on failure to find named crypto device.*

### const char \* rte\_cryptodev\_name\_get (uint8\_t dev\_id)

*Get the crypto device name given a device identifier.*

**Parameters**

*dev\_id The identifier of the device*

**Returns**

- •

  *Returns crypto device name.*

- •

  *Returns NULL if crypto device is not present.*

### 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.*

### uint8\_t rte\_cryptodev\_device\_count\_by\_driver (uint8\_t driver\_id)

*Get number of crypto device defined type.*

**Parameters**

*driver\_id driver 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\_name driver name.* \
 *devices output devices identifiers.* \
 *nb\_devices maximal 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\_id The identifier of the device to configure.* \
 *config The crypto device configuration structure.*

**Returns**

- •

  *0: Success, device configured.*

- •

  *\<0: Error code returned by the driver configuration function.*

### 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\_id The identifier of the device.*

**Returns**

- •

  *0: Success, device started.*

- •

  *\<0: Error code of the driver device start function.*

### 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\_id The identifier of the device.*

### int rte\_cryptodev\_close (uint8\_t dev\_id)

*Close an device. The device cannot be restarted!*

**Parameters**

*dev\_id The identifier of the device.*

**Returns**

- •

  *0 on successfully closing device*

- •

  *\<0 on failure to close 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.*

**Parameters**

*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*

- •

  *1\] previously supplied to* **rte\_cryptodev\_configure()***.*

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

**Returns**

- •

  *0: Success, queue pair correctly set up.*

- •

  *\<0: Queue pair configuration failed*

### \_\_rte\_experimental int rte\_cryptodev\_queue\_pair\_reset (uint8\_t dev\_id, uint16\_t queue\_pair\_id, const struct rte\_cryptodev\_qp\_conf \* qp\_conf, int socket\_id)

**Warning**

**EXPERIMENTAL:** *this API may change without prior notice.*

*Reset a queue pair for a device. The caller of this API must ensure that, there are no enqueues to the queue and there are no pending/inflight packets in the queue when the API is called. The API can reconfigure the queue pair when the queue pair configuration data is provided.*

**Parameters**

*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 - 1\] previously supplied to* **rte\_cryptodev\_configure()***.* \
 *qp\_conf The pointer to configuration data to be used for the queue pair. It should be NULL, if the API is called from an interrupt context.* \
 *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 queue pair.*

**Returns**

- •

  *0: Queue pair is reset successfully.*

- •

  *ENOTSUP: If the operation is not supported by the PMD.*

- •

  *\<0: Queue pair reset failed*

### 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*

**Parameters**

*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*

- •

  *1\] previously supplied to* **rte\_cryptodev\_configure()***.*

**Returns**

- •

  *0: qp was not configured*

- •

  *1: qp was configured*

- •

  *-EINVAL: device was not configured*

### uint16\_t rte\_cryptodev\_queue\_pair\_count (uint8\_t dev\_id)

*Get the number of queue pairs on a specific crypto device*

**Parameters**

*dev\_id Crypto 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\_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.**

**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\_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.**

**Parameters**

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

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

### 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\_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.**

**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\_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.**

**Returns**

- •

  **On success, zero.**

- •

  **On failure, a negative value.**

### \_\_rte\_experimental int rte\_cryptodev\_queue\_pair\_event\_error\_query (uint8\_t dev\_id, uint16\_t qp\_id)

**Warning**

**EXPERIMENTAL: this API may change without prior notice.**

**Query a cryptodev queue pair if there are pending RTE\_CRYPTODEV\_EVENT\_ERROR events.**

**Parameters**

*dev\_id* **The device identifier.** \
 *qp\_id* **Queue pair index to be queried.**

**Returns**

- •

  **1 if requested queue has a pending event.**

- •

  **0 if no pending event is found.**

- •

  **a negative value on failure**

### 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.**

**Parameters**

*dev\_id* **The device identifier.**

**Returns**

- •

  **NULL on error.**

- •

  **Pointer to security context on success.**

### 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**

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

**Returns**

- •

  **On success returns the created session mempool pointer**

- •

  **On failure returns NULL**

### 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.**

**Parameters**

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

**Returns**

- •

  **On success return mempool**

- •

  **On failure returns NULL**

### 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.**

**Parameters**

*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**

**Returns**

- •

  **On success return pointer to sym-session.**

- •

  **On failure returns NULL and rte\_errno is set to the error code:**

- •

  **EINVAL on invalid arguments.**

- •

  **ENOMEM on memory error for session allocation.**

- •

  **ENOTSUP if device doesn't support session configuration.**

### 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.**

**Parameters**

*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**

**Returns**

- •

  **0 on success.**

- •

  **-EINVAL on invalid arguments.**

- •

  **-ENOMEM on memory error for session allocation.**

- •

  **-ENOTSUP if device doesn't support session configuration.**

### 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.**

**Parameters**

*dev\_id* **ID of device that uses the session.** \
 *sess* **Session header to be freed.**

**Returns**

- •

  **0 if successful.**

- •

  **-EINVAL if session is NULL or the mismatched device ids.**

### 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.**

**Parameters**

*dev\_id* **ID of device that uses the asymmetric session.** \
 *sess* **Session header to be freed.**

**Returns**

- •

  **0 if successful.**

- •

  **-EINVAL if device is invalid or session is NULL.**

### unsigned int rte\_cryptodev\_asym\_get\_header\_session\_size (void)

**Get the size of the asymmetric session header.**

**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\_id* **The device identifier.**

**Returns**

- •

  **Size of the private data, if successful**

- •

  **0 if device is invalid or does not have private symmetric session**

### 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\_id* **The device identifier.**

**Returns**

- •

  **Size of the asymmetric private data, if successful**

- •

  **0 if device is invalid or does not have private session**

### unsigned int rte\_cryptodev\_is\_valid\_dev (uint8\_t dev\_id)

**Validate if the crypto device index is valid attached crypto device.**

**Parameters**

*dev\_id* **Crypto device index.**

**Returns**

- •

  **If the device index is valid (1) or not (0).**

### int rte\_cryptodev\_driver\_id\_get (const char \* name)

**Provide driver identifier.**

**Parameters**

*name* **The 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\_id* **The driver identifier.**

**Returns**

**The driver name or null if no driver found**

### int rte\_cryptodev\_sym\_session\_set\_user\_data (void \* sess, void \* data, uint16\_t size)

**Store user data in a session.**

**Parameters**

*sess* **Session pointer allocated by** *rte\_cryptodev\_sym\_session\_create***.** \
 *data* **Pointer to the user data.** \
 *size* **Size of the user data.**

**Returns**

- •

  **On success, zero.**

- •

  **On failure, a negative value.**

### static uint64\_t rte\_cryptodev\_sym\_session\_opaque\_data\_get (void \* sess)` [inline]`, ` [static]`

**Get opaque data from session handle**

**Definition at line 1299 of file rte\_cryptodev.h.**

### static void rte\_cryptodev\_sym\_session\_opaque\_data\_set (void \* sess, uint64\_t opaque)` [inline]`, ` [static]`

**Set opaque data in session handle**

**Definition at line 1308 of file rte\_cryptodev.h.**

### void \* rte\_cryptodev\_sym\_session\_get\_user\_data (void \* sess)

**Get user data stored in a session.**

**Parameters**

*sess* **Session pointer allocated by** *rte\_cryptodev\_sym\_session\_create***.**

**Returns**

- •

  **On success return pointer to user data.**

- •

  **On failure returns NULL.**

### int rte\_cryptodev\_asym\_session\_set\_user\_data (void \* sess, void \* data, uint16\_t size)

**Store user data in an asymmetric session.**

**Parameters**

*sess* **Session pointer allocated by** *rte\_cryptodev\_asym\_session\_create***.** \
 *data* **Pointer to the user data.** \
 *size* **Size of the user data.**

**Returns**

- •

  **On success, zero.**

- •

  **-EINVAL if the session pointer is invalid.**

- •

  **-ENOMEM if the available user data size is smaller than the size parameter.**

### void \* rte\_cryptodev\_asym\_session\_get\_user\_data (void \* sess)

**Get user data stored in an asymmetric session.**

**Parameters**

*sess* **Session pointer allocated by** *rte\_cryptodev\_asym\_session\_create***.**

**Returns**

- •

  **On success return pointer to user data.**

- •

  **On failure returns NULL.**

### 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.**

**Parameters**

*dev\_id* **The device identifier.** \
 *sess* **Cryptodev session structure** \
 *ofs* **Start and stop offsets for auth and cipher operations** \
 *vec* **Vectorized operation descriptor**

**Returns**

- •

  **Returns number of successfully processed packets.**

### int rte\_cryptodev\_get\_raw\_dp\_ctx\_size (uint8\_t dev\_id)

**Get the size of the raw data-path context buffer.**

**Parameters**

*dev\_id* **The device identifier.**

**Returns**

- •

  **If the device supports raw data-path APIs, return the context size.**

- •

  **If the device does not support the APIs, return -1.**

### 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**

**Parameters**

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

**Returns**

- •

  **On success, zero.**

- •

  **On failure, a negative value.**

### 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.**

**Parameters**

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

**Returns**

- •

  **On success return 0.**

- •

  **On failure return negative integer.**

- •

  **-EINVAL if input parameters are invalid.**

- •

  **-ENOTSUP if crypto device does not support raw DP operations with the provided session.**

### 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.**

**Parameters**

*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:**

- •

  **1: The number of operations returned are enqueued successfully.**

- •

  **0: The number of operations returned are cached into the queue but are not processed until rte\_cryptodev\_raw\_enqueue\_done() is called.**

- •

  **negative integer: Error occurred.**

**Returns**

- •

  **The number of operations in the descriptor successfully enqueued or cached into the queue but not enqueued yet, depends on the 'enqueue\_status' value.**

### 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)` [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.**

**Parameters**

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

**Returns**

- •

  **1: The data vector is enqueued successfully.**

- •

  **0: The data vector is cached into the queue but is not processed until rte\_cryptodev\_raw\_enqueue\_done() is called.**

- •

  **negative integer: failure.**

**Definition at line 1684 of file rte\_cryptodev.h.**

### 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.**

**Parameters**

*ctx* **The initialized raw data-path context data.** \
 *n* **The number of operations cached.**

**Returns**

- •

  **On success return 0.**

- •

  **On failure return negative integer.**

### 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.**

**Parameters**

*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:**

- •

  **1: Successfully dequeued the number of operations returned. The user data previously set during enqueue is stored in the 'out\_user\_data'.**

- •

  **0: The number of operations returned are completed and the user data is stored in the 'out\_user\_data', but they are not freed from the queue until rte\_cryptodev\_raw\_dequeue\_done() is called.**

- •

  **negative integer: Error occurred.**

**Returns**

- •

  **The number of operations dequeued or completed but not freed from the queue, depends on 'dequeue\_status' value.**

### 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)` [static]`

**Dequeue a symmetric crypto processing.**

**Parameters**

*ctx* **The initialized raw data-path context data.** \
 *dequeue\_status* **Driver written value to specify the dequeue status. Possible values:**

- •

  **1: Successfully dequeued a operation. The user data is returned.**

- •

  **0: The first operation in the queue is completed and the user data previously set during enqueue is returned, but it is not freed from the queue until rte\_cryptodev\_raw\_dequeue\_done() is called.**

- •

  **negative integer: Error occurred.**

*op\_status* **Driver written value to specify operation status.**

**Returns**

- •

  **The user data pointer retrieved from device queue or NULL if no operation is ready for dequeue.**

**Definition at line 1784 of file rte\_cryptodev.h.**

### int rte\_cryptodev\_raw\_dequeue\_done (struct rte\_crypto\_raw\_dp\_ctx \* ctx, uint32\_t n)

**Inform the queue pair dequeue operations is finished.**

**Parameters**

*ctx* **The initialized raw data-path context data.** \
 *n* **The number of operations.**

**Returns**

- •

  **On success return 0.**

- •

  **On failure return negative integer.**

### 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.**

**Parameters**

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

**Returns**

- •

  **NULL on error & rte\_errno will contain the error code.**

- •

  **On success, a pointer value which can later be used to remove the callback.**

### 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().**

**Parameters**

*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().**

**Returns**

- •

  **0: Success. Callback was removed.**

- •

  **\<0: The dev\_id or the qp\_id is out of range, or the callback is NULL or not found for the crypto device queue pair.**

### 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.**

**Parameters**

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

**Returns**

- •

  **NULL on error & rte\_errno will contain the error code.**

- •

  **On success, a pointer value which can later be used to remove the callback.**

### 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().**

**Parameters**

*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().**

**Returns**

- •

  **0: Success. Callback was removed.**

- •

  **\<0: The dev\_id or the qp\_id is out of range, or the callback is NULL or not found for the crypto device queue pair.**

### static uint16\_t rte\_cryptodev\_dequeue\_burst (uint8\_t dev\_id, uint16\_t qp\_id, struct rte\_crypto\_op \*\* ops, uint16\_t nb\_ops)` [inline]`, ` [static]`

**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\_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.**

**Returns**

- •

  **The number of operations actually dequeued, which is the number of pointers to rte\_crypto\_op structures effectively supplied to the** *ops* **array.**

**Definition at line 1982 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)` [inline]`, ` [static]`

**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\_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.**

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

**Definition at line 2054 of file rte\_cryptodev.h.**

### static \_\_rte\_experimental int rte\_cryptodev\_qp\_depth\_used (uint8\_t dev\_id, uint16\_t qp\_id)` [inline]`, ` [static]`

**Warning**

**EXPERIMENTAL: this API may change, or be removed, without prior notice**

**Get the number of used descriptors or depth of a cryptodev queue pair.**

**This function retrieves the number of used descriptors in a crypto queue. Applications can use this API in the fast path to inspect QP occupancy and take appropriate action.**

**Since it is a fast-path function, no check is performed on dev\_id and qp\_id. Caller must therefore ensure that the device is enabled and queue pair is setup.**

**Parameters**

*dev\_id* **The identifier of the device.** \
 *qp\_id* **The index of the queue pair for which used descriptor count is to be retrieved. The value must be in the range \[0, nb\_queue\_pairs - 1\] previously supplied to** *rte\_cryptodev\_configure***.**

**Returns**

**The number of used descriptors on the specified queue pair, or:**

- •

  **(-ENOTSUP) if the device does not support this function.**

**Definition at line 2117 of file rte\_cryptodev.h.**

## Author

**Generated automatically by Doxygen for DPDK from the source code.**