4 * Copyright(c) 2016-2017 Intel Corporation. All rights reserved.
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
10 * * Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 * * Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in
14 * the documentation and/or other materials provided with the
16 * * Neither the name of Intel Corporation nor the names of its
17 * contributors may be used to endorse or promote products derived
18 * from this software without specific prior written permission.
20 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
21 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
22 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
23 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
24 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
25 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
26 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
27 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
28 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
29 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
30 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
33 #ifndef _RTE_CRYPTO_H_
34 #define _RTE_CRYPTO_H_
39 * RTE Cryptography Common Definitions
49 #include <rte_memory.h>
50 #include <rte_mempool.h>
51 #include <rte_common.h>
53 #include "rte_crypto_sym.h"
55 /** Crypto operation types */
56 enum rte_crypto_op_type {
57 RTE_CRYPTO_OP_TYPE_UNDEFINED,
58 /**< Undefined operation type */
59 RTE_CRYPTO_OP_TYPE_SYMMETRIC,
60 /**< Symmetric operation */
63 /** Status of crypto operation */
64 enum rte_crypto_op_status {
65 RTE_CRYPTO_OP_STATUS_SUCCESS,
66 /**< Operation completed successfully */
67 RTE_CRYPTO_OP_STATUS_NOT_PROCESSED,
68 /**< Operation has not yet been processed by a crypto device */
69 RTE_CRYPTO_OP_STATUS_ENQUEUED,
70 /**< Operation is enqueued on device */
71 RTE_CRYPTO_OP_STATUS_AUTH_FAILED,
72 /**< Authentication verification failed */
73 RTE_CRYPTO_OP_STATUS_INVALID_SESSION,
75 * Symmetric operation failed due to invalid session arguments, or if
76 * in session-less mode, failed to allocate private operation material.
78 RTE_CRYPTO_OP_STATUS_INVALID_ARGS,
79 /**< Operation failed due to invalid arguments in request */
80 RTE_CRYPTO_OP_STATUS_ERROR,
81 /**< Error handling operation */
85 * Crypto operation session type. This is used to specify whether a crypto
86 * operation has session structure attached for immutable parameters or if all
87 * operation information is included in the operation data structure.
89 enum rte_crypto_op_sess_type {
90 RTE_CRYPTO_OP_WITH_SESSION, /**< Session based crypto operation */
91 RTE_CRYPTO_OP_SESSIONLESS /**< Session-less crypto operation */
95 * Cryptographic Operation.
97 * This structure contains data relating to performing cryptographic
98 * operations. This operation structure is used to contain any operation which
99 * is supported by the cryptodev API, PMDs should check the type parameter to
100 * verify that the operation is a support function of the device. Crypto
101 * operations are enqueued and dequeued in crypto PMDs using the
102 * rte_cryptodev_enqueue_burst() / rte_cryptodev_dequeue_burst() .
104 struct rte_crypto_op {
106 /**< operation type */
109 * operation status - this is reset to
110 * RTE_CRYPTO_OP_STATUS_NOT_PROCESSED on allocation from mempool and
111 * will be set to RTE_CRYPTO_OP_STATUS_SUCCESS after crypto operation
112 * is successfully processed by a crypto PMD
115 /**< operation session type */
118 /**< Reserved bytes to fill 64 bits for future additions */
119 struct rte_mempool *mempool;
120 /**< crypto operation mempool which operation is allocated from */
122 phys_addr_t phys_addr;
123 /**< physical address of crypto operation */
126 /**< Opaque pointer for user data */
130 struct rte_crypto_sym_op *sym;
131 /**< Symmetric operation parameters */
132 }; /**< operation specific parameters */
133 } __rte_cache_aligned;
136 * Reset the fields of a crypto operation to their default values.
138 * @param op The crypto operation to be reset.
139 * @param type The crypto operation type.
142 __rte_crypto_op_reset(struct rte_crypto_op *op, enum rte_crypto_op_type type)
145 op->status = RTE_CRYPTO_OP_STATUS_NOT_PROCESSED;
146 op->sess_type = RTE_CRYPTO_OP_SESSIONLESS;
149 case RTE_CRYPTO_OP_TYPE_SYMMETRIC:
150 /** Symmetric operation structure starts after the end of the
151 * rte_crypto_op structure.
153 op->sym = (struct rte_crypto_sym_op *)(op + 1);
156 __rte_crypto_sym_op_reset(op->sym);
162 op->opaque_data = NULL;
166 * Private data structure belonging to a crypto symmetric operation pool.
168 struct rte_crypto_op_pool_private {
169 enum rte_crypto_op_type type;
170 /**< Crypto op pool type operation. */
172 /**< Size of private area in each crypto operation. */
177 * Returns the size of private data allocated with each rte_crypto_op object by
180 * @param mempool rte_crypto_op mempool
182 * @return private data size
184 static inline uint16_t
185 __rte_crypto_op_get_priv_data_size(struct rte_mempool *mempool)
187 struct rte_crypto_op_pool_private *priv =
188 (struct rte_crypto_op_pool_private *) rte_mempool_get_priv(mempool);
190 return priv->priv_size;
195 * Creates a crypto operation pool
197 * @param name pool name
198 * @param type crypto operation type, use
199 * RTE_CRYPTO_OP_TYPE_UNDEFINED for a pool which
200 * supports all operation types
201 * @param nb_elts number of elements in pool
202 * @param cache_size Number of elements to cache on lcore, see
203 * *rte_mempool_create* for further details about
205 * @param priv_size Size of private data to allocate with each
207 * @param socket_id Socket to allocate memory on
210 * - On success pointer to mempool
213 extern struct rte_mempool *
214 rte_crypto_op_pool_create(const char *name, enum rte_crypto_op_type type,
215 unsigned nb_elts, unsigned cache_size, uint16_t priv_size,
219 * Bulk allocate raw element from mempool and return as crypto operations
221 * @param mempool crypto operation mempool.
222 * @param type crypto operation type.
223 * @param ops Array to place allocated crypto operations
224 * @param nb_ops Number of crypto operations to allocate
227 * - On success returns number of ops allocated
230 __rte_crypto_op_raw_bulk_alloc(struct rte_mempool *mempool,
231 enum rte_crypto_op_type type,
232 struct rte_crypto_op **ops, uint16_t nb_ops)
234 struct rte_crypto_op_pool_private *priv;
236 priv = (struct rte_crypto_op_pool_private *) rte_mempool_get_priv(mempool);
237 if (unlikely(priv->type != type &&
238 priv->type != RTE_CRYPTO_OP_TYPE_UNDEFINED))
241 if (rte_mempool_get_bulk(mempool, (void **)ops, nb_ops) == 0)
248 * Allocate a crypto operation from a mempool with default parameters set
250 * @param mempool crypto operation mempool
251 * @param type operation type to allocate
254 * - On success returns a valid rte_crypto_op structure
255 * - On failure returns NULL
257 static inline struct rte_crypto_op *
258 rte_crypto_op_alloc(struct rte_mempool *mempool, enum rte_crypto_op_type type)
260 struct rte_crypto_op *op = NULL;
263 retval = __rte_crypto_op_raw_bulk_alloc(mempool, type, &op, 1);
264 if (unlikely(retval != 1))
267 __rte_crypto_op_reset(op, type);
274 * Bulk allocate crypto operations from a mempool with default parameters set
276 * @param mempool crypto operation mempool
277 * @param type operation type to allocate
278 * @param ops Array to place allocated crypto operations
279 * @param nb_ops Number of crypto operations to allocate
282 * - On success returns a valid rte_crypto_op structure
283 * - On failure returns NULL
286 static inline unsigned
287 rte_crypto_op_bulk_alloc(struct rte_mempool *mempool,
288 enum rte_crypto_op_type type,
289 struct rte_crypto_op **ops, uint16_t nb_ops)
293 if (unlikely(__rte_crypto_op_raw_bulk_alloc(mempool, type, ops, nb_ops)
297 for (i = 0; i < nb_ops; i++)
298 __rte_crypto_op_reset(ops[i], type);
306 * Returns a pointer to the private data of a crypto operation if
307 * that operation has enough capacity for requested size.
309 * @param op crypto operation.
310 * @param size size of space requested in private data.
313 * - if sufficient space available returns pointer to start of private data
314 * - if insufficient space returns NULL
317 __rte_crypto_op_get_priv_data(struct rte_crypto_op *op, uint32_t size)
321 if (likely(op->mempool != NULL)) {
322 priv_size = __rte_crypto_op_get_priv_data_size(op->mempool);
324 if (likely(priv_size >= size))
325 return (void *)((uint8_t *)(op + 1) +
326 sizeof(struct rte_crypto_sym_op));
333 * free crypto operation structure
334 * If operation has been allocate from a rte_mempool, then the operation will
335 * be returned to the mempool.
337 * @param op symmetric crypto operation
340 rte_crypto_op_free(struct rte_crypto_op *op)
342 if (op != NULL && op->mempool != NULL)
343 rte_mempool_put(op->mempool, op);
347 * Allocate a symmetric crypto operation in the private data of an mbuf.
349 * @param m mbuf which is associated with the crypto operation, the
350 * operation will be allocated in the private data of that
354 * - On success returns a pointer to the crypto operation.
355 * - On failure returns NULL.
357 static inline struct rte_crypto_op *
358 rte_crypto_sym_op_alloc_from_mbuf_priv_data(struct rte_mbuf *m)
360 if (unlikely(m == NULL))
364 * check that the mbuf's private data size is sufficient to contain a
367 if (unlikely(m->priv_size < (sizeof(struct rte_crypto_op) +
368 sizeof(struct rte_crypto_sym_op))))
371 /* private data starts immediately after the mbuf header in the mbuf. */
372 struct rte_crypto_op *op = (struct rte_crypto_op *)(m + 1);
374 __rte_crypto_op_reset(op, RTE_CRYPTO_OP_TYPE_SYMMETRIC);
383 * Allocate space for symmetric crypto xforms in the private data space of the
384 * crypto operation. This also defaults the crypto xform type and configures
385 * the chaining of the xforms in the crypto operation
388 * - On success returns pointer to first crypto xform in crypto operations chain
389 * - On failure returns NULL
391 static inline struct rte_crypto_sym_xform *
392 rte_crypto_op_sym_xforms_alloc(struct rte_crypto_op *op, uint8_t nb_xforms)
397 if (unlikely(op->type != RTE_CRYPTO_OP_TYPE_SYMMETRIC))
400 size = sizeof(struct rte_crypto_sym_xform) * nb_xforms;
402 priv_data = __rte_crypto_op_get_priv_data(op, size);
403 if (priv_data == NULL)
406 return __rte_crypto_sym_op_sym_xforms_alloc(op->sym, priv_data,
412 * Attach a session to a crypto operation
414 * @param op crypto operation, must be of type symmetric
415 * @param sess cryptodev session
418 rte_crypto_op_attach_sym_session(struct rte_crypto_op *op,
419 struct rte_cryptodev_sym_session *sess)
421 if (unlikely(op->type != RTE_CRYPTO_OP_TYPE_SYMMETRIC))
424 op->sess_type = RTE_CRYPTO_OP_WITH_SESSION;
426 return __rte_crypto_sym_op_attach_sym_session(op->sym, sess);
433 #endif /* _RTE_CRYPTO_H_ */