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 */
68 /* Auxiliary flags related to IPsec offload with RTE_SECURITY */
70 #define RTE_CRYPTO_OP_AUX_FLAGS_IPSEC_SOFT_EXPIRY (1 << 0)
71 /**< SA soft expiry limit has been reached */
74 * Cryptographic Operation.
76 * This structure contains data relating to performing cryptographic
77 * operations. This operation structure is used to contain any operation which
78 * is supported by the cryptodev API, PMDs should check the type parameter to
79 * verify that the operation is a support function of the device. Crypto
80 * operations are enqueued and dequeued in crypto PMDs using the
81 * rte_cryptodev_enqueue_burst() / rte_cryptodev_dequeue_burst() .
83 struct rte_crypto_op {
90 /**< operation type */
93 * operation status - this is reset to
94 * RTE_CRYPTO_OP_STATUS_NOT_PROCESSED on allocation
95 * from mempool and will be set to
96 * RTE_CRYPTO_OP_STATUS_SUCCESS after crypto operation
97 * is successfully processed by a crypto PMD
100 /**< operation session type */
102 /**< Operation specific auxiliary/additional flags.
103 * These flags carry additional information from the
104 * operation. Processing of the same is optional.
107 /**< Reserved bytes to fill 64 bits for
110 uint16_t private_data_offset;
111 /**< Offset to indicate start of private data (if any).
112 * The offset is counted from the start of the
113 * rte_crypto_op including IV.
114 * The private data may be used by the application
115 * to store information which should remain untouched
116 * in the library/driver
120 struct rte_mempool *mempool;
121 /**< crypto operation mempool which operation is allocated from */
123 rte_iova_t phys_addr;
124 /**< physical address of crypto operation */
126 /* empty structures do not have zero size in C++ leading to compilation errors
127 * with clang about structure/union having different sizes in C and C++.
128 * While things are clearer with an explicit union, since each field is
129 * zero-sized it's not actually needed, so omit it for C++
135 struct rte_crypto_sym_op sym[0];
136 /**< Symmetric operation parameters */
138 struct rte_crypto_asym_op asym[0];
139 /**< Asymmetric operation parameters */
142 }; /**< operation specific parameters */
147 * Reset the fields of a crypto operation to their default values.
149 * @param op The crypto operation to be reset.
150 * @param type The crypto operation type.
153 __rte_crypto_op_reset(struct rte_crypto_op *op, enum rte_crypto_op_type type)
156 op->status = RTE_CRYPTO_OP_STATUS_NOT_PROCESSED;
157 op->sess_type = RTE_CRYPTO_OP_SESSIONLESS;
160 case RTE_CRYPTO_OP_TYPE_SYMMETRIC:
161 __rte_crypto_sym_op_reset(op->sym);
163 case RTE_CRYPTO_OP_TYPE_ASYMMETRIC:
164 memset(op->asym, 0, sizeof(struct rte_crypto_asym_op));
166 case RTE_CRYPTO_OP_TYPE_UNDEFINED:
173 * Private data structure belonging to a crypto symmetric operation pool.
175 struct rte_crypto_op_pool_private {
176 enum rte_crypto_op_type type;
177 /**< Crypto op pool type operation. */
179 /**< Size of private area in each crypto operation. */
184 * Returns the size of private data allocated with each rte_crypto_op object by
187 * @param mempool rte_crypto_op mempool
189 * @return private data size
191 static inline uint16_t
192 __rte_crypto_op_get_priv_data_size(struct rte_mempool *mempool)
194 struct rte_crypto_op_pool_private *priv =
195 (struct rte_crypto_op_pool_private *) rte_mempool_get_priv(mempool);
197 return priv->priv_size;
202 * Creates a crypto operation pool
204 * @param name pool name
205 * @param type crypto operation type, use
206 * RTE_CRYPTO_OP_TYPE_UNDEFINED for a pool which
207 * supports all operation types
208 * @param nb_elts number of elements in pool
209 * @param cache_size Number of elements to cache on lcore, see
210 * *rte_mempool_create* for further details about
212 * @param priv_size Size of private data to allocate with each
214 * @param socket_id Socket to allocate memory on
217 * - On success pointer to mempool
220 extern struct rte_mempool *
221 rte_crypto_op_pool_create(const char *name, enum rte_crypto_op_type type,
222 unsigned nb_elts, unsigned cache_size, uint16_t priv_size,
226 * Bulk allocate raw element from mempool and return as crypto operations
228 * @param mempool crypto operation mempool.
229 * @param type crypto operation type.
230 * @param ops Array to place allocated crypto operations
231 * @param nb_ops Number of crypto operations to allocate
234 * - On success returns number of ops allocated
237 __rte_crypto_op_raw_bulk_alloc(struct rte_mempool *mempool,
238 enum rte_crypto_op_type type,
239 struct rte_crypto_op **ops, uint16_t nb_ops)
241 struct rte_crypto_op_pool_private *priv;
243 priv = (struct rte_crypto_op_pool_private *) rte_mempool_get_priv(mempool);
244 if (unlikely(priv->type != type &&
245 priv->type != RTE_CRYPTO_OP_TYPE_UNDEFINED))
248 if (rte_mempool_get_bulk(mempool, (void **)ops, nb_ops) == 0)
255 * Allocate a crypto operation from a mempool with default parameters set
257 * @param mempool crypto operation mempool
258 * @param type operation type to allocate
261 * - On success returns a valid rte_crypto_op structure
262 * - On failure returns NULL
264 static inline struct rte_crypto_op *
265 rte_crypto_op_alloc(struct rte_mempool *mempool, enum rte_crypto_op_type type)
267 struct rte_crypto_op *op = NULL;
270 retval = __rte_crypto_op_raw_bulk_alloc(mempool, type, &op, 1);
271 if (unlikely(retval != 1))
274 __rte_crypto_op_reset(op, type);
281 * Bulk allocate crypto operations from a mempool with default parameters set
283 * @param mempool crypto operation mempool
284 * @param type operation type to allocate
285 * @param ops Array to place allocated crypto operations
286 * @param nb_ops Number of crypto operations to allocate
289 * - nb_ops if the number of operations requested were allocated.
290 * - 0 if the requested number of ops are not available.
291 * None are allocated in this case.
294 static inline unsigned
295 rte_crypto_op_bulk_alloc(struct rte_mempool *mempool,
296 enum rte_crypto_op_type type,
297 struct rte_crypto_op **ops, uint16_t nb_ops)
301 if (unlikely(__rte_crypto_op_raw_bulk_alloc(mempool, type, ops, nb_ops)
305 for (i = 0; i < nb_ops; i++)
306 __rte_crypto_op_reset(ops[i], type);
314 * Returns a pointer to the private data of a crypto operation if
315 * that operation has enough capacity for requested size.
317 * @param op crypto operation.
318 * @param size size of space requested in private data.
321 * - if sufficient space available returns pointer to start of private data
322 * - if insufficient space returns NULL
325 __rte_crypto_op_get_priv_data(struct rte_crypto_op *op, uint32_t size)
329 if (likely(op->mempool != NULL)) {
330 priv_size = __rte_crypto_op_get_priv_data_size(op->mempool);
332 if (likely(priv_size >= size)) {
333 if (op->type == RTE_CRYPTO_OP_TYPE_SYMMETRIC)
334 return (void *)((uint8_t *)(op + 1) +
335 sizeof(struct rte_crypto_sym_op));
336 if (op->type == RTE_CRYPTO_OP_TYPE_ASYMMETRIC)
337 return (void *)((uint8_t *)(op + 1) +
338 sizeof(struct rte_crypto_asym_op));
346 * free crypto operation structure
347 * If operation has been allocate from a rte_mempool, then the operation will
348 * be returned to the mempool.
350 * @param op symmetric crypto operation
353 rte_crypto_op_free(struct rte_crypto_op *op)
355 if (op != NULL && op->mempool != NULL)
356 rte_mempool_put(op->mempool, op);
360 * Allocate a symmetric crypto operation in the private data of an mbuf.
362 * @param m mbuf which is associated with the crypto operation, the
363 * operation will be allocated in the private data of that
367 * - On success returns a pointer to the crypto operation.
368 * - On failure returns NULL.
370 static inline struct rte_crypto_op *
371 rte_crypto_sym_op_alloc_from_mbuf_priv_data(struct rte_mbuf *m)
373 if (unlikely(m == NULL))
377 * check that the mbuf's private data size is sufficient to contain a
380 if (unlikely(m->priv_size < (sizeof(struct rte_crypto_op) +
381 sizeof(struct rte_crypto_sym_op))))
384 /* private data starts immediately after the mbuf header in the mbuf. */
385 struct rte_crypto_op *op = (struct rte_crypto_op *)(m + 1);
387 __rte_crypto_op_reset(op, RTE_CRYPTO_OP_TYPE_SYMMETRIC);
396 * Allocate space for symmetric crypto xforms in the private data space of the
397 * crypto operation. This also defaults the crypto xform type and configures
398 * the chaining of the xforms in the crypto operation
401 * - On success returns pointer to first crypto xform in crypto operations chain
402 * - On failure returns NULL
404 static inline struct rte_crypto_sym_xform *
405 rte_crypto_op_sym_xforms_alloc(struct rte_crypto_op *op, uint8_t nb_xforms)
410 if (unlikely(op->type != RTE_CRYPTO_OP_TYPE_SYMMETRIC))
413 size = sizeof(struct rte_crypto_sym_xform) * nb_xforms;
415 priv_data = __rte_crypto_op_get_priv_data(op, size);
416 if (priv_data == NULL)
419 return __rte_crypto_sym_op_sym_xforms_alloc(op->sym, priv_data,
425 * Attach a session to a crypto operation
427 * @param op crypto operation, must be of type symmetric
428 * @param sess cryptodev session
431 rte_crypto_op_attach_sym_session(struct rte_crypto_op *op,
432 struct rte_cryptodev_sym_session *sess)
434 if (unlikely(op->type != RTE_CRYPTO_OP_TYPE_SYMMETRIC))
437 op->sess_type = RTE_CRYPTO_OP_WITH_SESSION;
439 return __rte_crypto_sym_op_attach_sym_session(op->sym, sess);
443 * Attach a asymmetric session to a crypto operation
445 * @param op crypto operation, must be of type asymmetric
446 * @param sess cryptodev session
449 rte_crypto_op_attach_asym_session(struct rte_crypto_op *op,
450 struct rte_cryptodev_asym_session *sess)
452 if (unlikely(op->type != RTE_CRYPTO_OP_TYPE_ASYMMETRIC))
455 op->sess_type = RTE_CRYPTO_OP_WITH_SESSION;
456 op->asym->session = sess;
464 #endif /* _RTE_CRYPTO_H_ */