1 /* SPDX-License-Identifier: BSD-3-Clause
2 * Copyright(c) 2016-2017 Intel Corporation
11 * RTE Cryptography Common Definitions
21 #include <rte_memory.h>
22 #include <rte_mempool.h>
23 #include <rte_common.h>
25 #include "rte_crypto_sym.h"
26 #include "rte_crypto_asym.h"
28 /** Crypto operation types */
29 enum rte_crypto_op_type
{
30 RTE_CRYPTO_OP_TYPE_UNDEFINED
,
31 /**< Undefined operation type */
32 RTE_CRYPTO_OP_TYPE_SYMMETRIC
,
33 /**< Symmetric operation */
34 RTE_CRYPTO_OP_TYPE_ASYMMETRIC
35 /**< Asymmetric operation */
38 /** Status of crypto operation */
39 enum rte_crypto_op_status
{
40 RTE_CRYPTO_OP_STATUS_SUCCESS
,
41 /**< Operation completed successfully */
42 RTE_CRYPTO_OP_STATUS_NOT_PROCESSED
,
43 /**< Operation has not yet been processed by a crypto device */
44 RTE_CRYPTO_OP_STATUS_AUTH_FAILED
,
45 /**< Authentication verification failed */
46 RTE_CRYPTO_OP_STATUS_INVALID_SESSION
,
48 * Symmetric operation failed due to invalid session arguments, or if
49 * in session-less mode, failed to allocate private operation material.
51 RTE_CRYPTO_OP_STATUS_INVALID_ARGS
,
52 /**< Operation failed due to invalid arguments in request */
53 RTE_CRYPTO_OP_STATUS_ERROR
,
54 /**< Error handling operation */
58 * Crypto operation session type. This is used to specify whether a crypto
59 * operation has session structure attached for immutable parameters or if all
60 * operation information is included in the operation data structure.
62 enum rte_crypto_op_sess_type
{
63 RTE_CRYPTO_OP_WITH_SESSION
, /**< Session based crypto operation */
64 RTE_CRYPTO_OP_SESSIONLESS
, /**< Session-less crypto operation */
65 RTE_CRYPTO_OP_SECURITY_SESSION
/**< Security session crypto operation */
69 * Cryptographic Operation.
71 * This structure contains data relating to performing cryptographic
72 * operations. This operation structure is used to contain any operation which
73 * is supported by the cryptodev API, PMDs should check the type parameter to
74 * verify that the operation is a support function of the device. Crypto
75 * operations are enqueued and dequeued in crypto PMDs using the
76 * rte_cryptodev_enqueue_burst() / rte_cryptodev_dequeue_burst() .
78 struct rte_crypto_op
{
85 /**< operation type */
88 * operation status - this is reset to
89 * RTE_CRYPTO_OP_STATUS_NOT_PROCESSED on allocation
90 * from mempool and will be set to
91 * RTE_CRYPTO_OP_STATUS_SUCCESS after crypto operation
92 * is successfully processed by a crypto PMD
95 /**< operation session type */
97 /**< Reserved bytes to fill 64 bits for
100 uint16_t private_data_offset
;
101 /**< Offset to indicate start of private data (if any).
102 * The offset is counted from the start of the
103 * rte_crypto_op including IV.
104 * The private data may be used by the application
105 * to store information which should remain untouched
106 * in the library/driver
110 struct rte_mempool
*mempool
;
111 /**< crypto operation mempool which operation is allocated from */
113 rte_iova_t phys_addr
;
114 /**< physical address of crypto operation */
118 struct rte_crypto_sym_op sym
[0];
119 /**< Symmetric operation parameters */
121 struct rte_crypto_asym_op asym
[0];
122 /**< Asymmetric operation parameters */
124 }; /**< operation specific parameters */
128 * Reset the fields of a crypto operation to their default values.
130 * @param op The crypto operation to be reset.
131 * @param type The crypto operation type.
134 __rte_crypto_op_reset(struct rte_crypto_op
*op
, enum rte_crypto_op_type type
)
137 op
->status
= RTE_CRYPTO_OP_STATUS_NOT_PROCESSED
;
138 op
->sess_type
= RTE_CRYPTO_OP_SESSIONLESS
;
141 case RTE_CRYPTO_OP_TYPE_SYMMETRIC
:
142 __rte_crypto_sym_op_reset(op
->sym
);
144 case RTE_CRYPTO_OP_TYPE_ASYMMETRIC
:
145 memset(op
->asym
, 0, sizeof(struct rte_crypto_asym_op
));
147 case RTE_CRYPTO_OP_TYPE_UNDEFINED
:
154 * Private data structure belonging to a crypto symmetric operation pool.
156 struct rte_crypto_op_pool_private
{
157 enum rte_crypto_op_type type
;
158 /**< Crypto op pool type operation. */
160 /**< Size of private area in each crypto operation. */
165 * Returns the size of private data allocated with each rte_crypto_op object by
168 * @param mempool rte_crypto_op mempool
170 * @return private data size
172 static inline uint16_t
173 __rte_crypto_op_get_priv_data_size(struct rte_mempool
*mempool
)
175 struct rte_crypto_op_pool_private
*priv
=
176 (struct rte_crypto_op_pool_private
*) rte_mempool_get_priv(mempool
);
178 return priv
->priv_size
;
183 * Creates a crypto operation pool
185 * @param name pool name
186 * @param type crypto operation type, use
187 * RTE_CRYPTO_OP_TYPE_UNDEFINED for a pool which
188 * supports all operation types
189 * @param nb_elts number of elements in pool
190 * @param cache_size Number of elements to cache on lcore, see
191 * *rte_mempool_create* for further details about
193 * @param priv_size Size of private data to allocate with each
195 * @param socket_id Socket to allocate memory on
198 * - On success pointer to mempool
201 extern struct rte_mempool
*
202 rte_crypto_op_pool_create(const char *name
, enum rte_crypto_op_type type
,
203 unsigned nb_elts
, unsigned cache_size
, uint16_t priv_size
,
207 * Bulk allocate raw element from mempool and return as crypto operations
209 * @param mempool crypto operation mempool.
210 * @param type crypto operation type.
211 * @param ops Array to place allocated crypto operations
212 * @param nb_ops Number of crypto operations to allocate
215 * - On success returns number of ops allocated
218 __rte_crypto_op_raw_bulk_alloc(struct rte_mempool
*mempool
,
219 enum rte_crypto_op_type type
,
220 struct rte_crypto_op
**ops
, uint16_t nb_ops
)
222 struct rte_crypto_op_pool_private
*priv
;
224 priv
= (struct rte_crypto_op_pool_private
*) rte_mempool_get_priv(mempool
);
225 if (unlikely(priv
->type
!= type
&&
226 priv
->type
!= RTE_CRYPTO_OP_TYPE_UNDEFINED
))
229 if (rte_mempool_get_bulk(mempool
, (void **)ops
, nb_ops
) == 0)
236 * Allocate a crypto operation from a mempool with default parameters set
238 * @param mempool crypto operation mempool
239 * @param type operation type to allocate
242 * - On success returns a valid rte_crypto_op structure
243 * - On failure returns NULL
245 static inline struct rte_crypto_op
*
246 rte_crypto_op_alloc(struct rte_mempool
*mempool
, enum rte_crypto_op_type type
)
248 struct rte_crypto_op
*op
= NULL
;
251 retval
= __rte_crypto_op_raw_bulk_alloc(mempool
, type
, &op
, 1);
252 if (unlikely(retval
!= 1))
255 __rte_crypto_op_reset(op
, type
);
262 * Bulk allocate crypto operations from a mempool with default parameters set
264 * @param mempool crypto operation mempool
265 * @param type operation type to allocate
266 * @param ops Array to place allocated crypto operations
267 * @param nb_ops Number of crypto operations to allocate
270 * - nb_ops if the number of operations requested were allocated.
271 * - 0 if the requested number of ops are not available.
272 * None are allocated in this case.
275 static inline unsigned
276 rte_crypto_op_bulk_alloc(struct rte_mempool
*mempool
,
277 enum rte_crypto_op_type type
,
278 struct rte_crypto_op
**ops
, uint16_t nb_ops
)
282 if (unlikely(__rte_crypto_op_raw_bulk_alloc(mempool
, type
, ops
, nb_ops
)
286 for (i
= 0; i
< nb_ops
; i
++)
287 __rte_crypto_op_reset(ops
[i
], type
);
295 * Returns a pointer to the private data of a crypto operation if
296 * that operation has enough capacity for requested size.
298 * @param op crypto operation.
299 * @param size size of space requested in private data.
302 * - if sufficient space available returns pointer to start of private data
303 * - if insufficient space returns NULL
306 __rte_crypto_op_get_priv_data(struct rte_crypto_op
*op
, uint32_t size
)
310 if (likely(op
->mempool
!= NULL
)) {
311 priv_size
= __rte_crypto_op_get_priv_data_size(op
->mempool
);
313 if (likely(priv_size
>= size
)) {
314 if (op
->type
== RTE_CRYPTO_OP_TYPE_SYMMETRIC
)
315 return (void *)((uint8_t *)(op
+ 1) +
316 sizeof(struct rte_crypto_sym_op
));
317 if (op
->type
== RTE_CRYPTO_OP_TYPE_ASYMMETRIC
)
318 return (void *)((uint8_t *)(op
+ 1) +
319 sizeof(struct rte_crypto_asym_op
));
327 * free crypto operation structure
328 * If operation has been allocate from a rte_mempool, then the operation will
329 * be returned to the mempool.
331 * @param op symmetric crypto operation
334 rte_crypto_op_free(struct rte_crypto_op
*op
)
336 if (op
!= NULL
&& op
->mempool
!= NULL
)
337 rte_mempool_put(op
->mempool
, op
);
341 * Allocate a symmetric crypto operation in the private data of an mbuf.
343 * @param m mbuf which is associated with the crypto operation, the
344 * operation will be allocated in the private data of that
348 * - On success returns a pointer to the crypto operation.
349 * - On failure returns NULL.
351 static inline struct rte_crypto_op
*
352 rte_crypto_sym_op_alloc_from_mbuf_priv_data(struct rte_mbuf
*m
)
354 if (unlikely(m
== NULL
))
358 * check that the mbuf's private data size is sufficient to contain a
361 if (unlikely(m
->priv_size
< (sizeof(struct rte_crypto_op
) +
362 sizeof(struct rte_crypto_sym_op
))))
365 /* private data starts immediately after the mbuf header in the mbuf. */
366 struct rte_crypto_op
*op
= (struct rte_crypto_op
*)(m
+ 1);
368 __rte_crypto_op_reset(op
, RTE_CRYPTO_OP_TYPE_SYMMETRIC
);
377 * Allocate space for symmetric crypto xforms in the private data space of the
378 * crypto operation. This also defaults the crypto xform type and configures
379 * the chaining of the xforms in the crypto operation
382 * - On success returns pointer to first crypto xform in crypto operations chain
383 * - On failure returns NULL
385 static inline struct rte_crypto_sym_xform
*
386 rte_crypto_op_sym_xforms_alloc(struct rte_crypto_op
*op
, uint8_t nb_xforms
)
391 if (unlikely(op
->type
!= RTE_CRYPTO_OP_TYPE_SYMMETRIC
))
394 size
= sizeof(struct rte_crypto_sym_xform
) * nb_xforms
;
396 priv_data
= __rte_crypto_op_get_priv_data(op
, size
);
397 if (priv_data
== NULL
)
400 return __rte_crypto_sym_op_sym_xforms_alloc(op
->sym
, priv_data
,
406 * Attach a session to a crypto operation
408 * @param op crypto operation, must be of type symmetric
409 * @param sess cryptodev session
412 rte_crypto_op_attach_sym_session(struct rte_crypto_op
*op
,
413 struct rte_cryptodev_sym_session
*sess
)
415 if (unlikely(op
->type
!= RTE_CRYPTO_OP_TYPE_SYMMETRIC
))
418 op
->sess_type
= RTE_CRYPTO_OP_WITH_SESSION
;
420 return __rte_crypto_sym_op_attach_sym_session(op
->sym
, sess
);
424 * Attach a asymmetric session to a crypto operation
426 * @param op crypto operation, must be of type asymmetric
427 * @param sess cryptodev session
430 rte_crypto_op_attach_asym_session(struct rte_crypto_op
*op
,
431 struct rte_cryptodev_asym_session
*sess
)
433 if (unlikely(op
->type
!= RTE_CRYPTO_OP_TYPE_ASYMMETRIC
))
436 op
->sess_type
= RTE_CRYPTO_OP_WITH_SESSION
;
437 op
->asym
->session
= sess
;
445 #endif /* _RTE_CRYPTO_H_ */