Branch data Line data Source code
1 : : /* SPDX-License-Identifier: BSD-3-Clause
2 : : * Copyright(c) 2015-2020 Intel Corporation
3 : : */
4 : :
5 : : #include <sys/queue.h>
6 : : #include <ctype.h>
7 : : #include <stdio.h>
8 : : #include <stdlib.h>
9 : : #include <string.h>
10 : : #include <errno.h>
11 : : #include <stdint.h>
12 : : #include <inttypes.h>
13 : :
14 : : #include <eal_export.h>
15 : : #include <rte_log.h>
16 : : #include <rte_debug.h>
17 : : #include <dev_driver.h>
18 : : #include <rte_memory.h>
19 : : #include <rte_memcpy.h>
20 : : #include <rte_memzone.h>
21 : : #include <rte_eal.h>
22 : : #include <rte_common.h>
23 : : #include <rte_mempool.h>
24 : : #include <rte_malloc.h>
25 : : #include <rte_errno.h>
26 : : #include <rte_spinlock.h>
27 : : #include <rte_string_fns.h>
28 : : #include <rte_telemetry.h>
29 : :
30 : : #include "rte_crypto.h"
31 : : #include "rte_cryptodev.h"
32 : : #include "cryptodev_pmd.h"
33 : : #include "cryptodev_trace.h"
34 : :
35 : : static uint8_t nb_drivers;
36 : :
37 : : static struct rte_cryptodev rte_crypto_devices[RTE_CRYPTO_MAX_DEVS];
38 : :
39 : : RTE_EXPORT_INTERNAL_SYMBOL(rte_cryptodevs)
40 : : struct rte_cryptodev *rte_cryptodevs = rte_crypto_devices;
41 : :
42 : : static struct rte_cryptodev_global cryptodev_globals = {
43 : : .devs = rte_crypto_devices,
44 : : .data = { NULL },
45 : : .nb_devs = 0
46 : : };
47 : :
48 : : /* Public fastpath APIs. */
49 : : RTE_EXPORT_SYMBOL(rte_crypto_fp_ops)
50 : : struct rte_crypto_fp_ops rte_crypto_fp_ops[RTE_CRYPTO_MAX_DEVS];
51 : :
52 : : /* spinlock for crypto device callbacks */
53 : : static rte_spinlock_t rte_cryptodev_cb_lock = RTE_SPINLOCK_INITIALIZER;
54 : :
55 : : RTE_EXPORT_SYMBOL(rte_cryptodev_logtype)
56 [ - + ]: 252 : RTE_LOG_REGISTER_DEFAULT(rte_cryptodev_logtype, INFO);
57 : :
58 : : /**
59 : : * The user application callback description.
60 : : *
61 : : * It contains callback address to be registered by user application,
62 : : * the pointer to the parameters for callback, and the event type.
63 : : */
64 : : struct rte_cryptodev_callback {
65 : : TAILQ_ENTRY(rte_cryptodev_callback) next; /**< Callbacks list */
66 : : rte_cryptodev_cb_fn cb_fn; /**< Callback address */
67 : : void *cb_arg; /**< Parameter for callback */
68 : : enum rte_cryptodev_event_type event; /**< Interrupt event type */
69 : : uint32_t active; /**< Callback is executing */
70 : : };
71 : :
72 : : /**
73 : : * The crypto cipher algorithm strings identifiers.
74 : : * Not to be used in application directly.
75 : : * Application can use rte_cryptodev_get_cipher_algo_string().
76 : : */
77 : : static const char *
78 : : crypto_cipher_algorithm_strings[] = {
79 : : [RTE_CRYPTO_CIPHER_3DES_CBC] = "3des-cbc",
80 : : [RTE_CRYPTO_CIPHER_3DES_ECB] = "3des-ecb",
81 : : [RTE_CRYPTO_CIPHER_3DES_CTR] = "3des-ctr",
82 : :
83 : : [RTE_CRYPTO_CIPHER_AES_CBC] = "aes-cbc",
84 : : [RTE_CRYPTO_CIPHER_AES_CTR] = "aes-ctr",
85 : : [RTE_CRYPTO_CIPHER_AES_DOCSISBPI] = "aes-docsisbpi",
86 : : [RTE_CRYPTO_CIPHER_AES_ECB] = "aes-ecb",
87 : : [RTE_CRYPTO_CIPHER_AES_F8] = "aes-f8",
88 : : [RTE_CRYPTO_CIPHER_AES_XTS] = "aes-xts",
89 : :
90 : : [RTE_CRYPTO_CIPHER_ARC4] = "arc4",
91 : :
92 : : [RTE_CRYPTO_CIPHER_DES_CBC] = "des-cbc",
93 : : [RTE_CRYPTO_CIPHER_DES_DOCSISBPI] = "des-docsisbpi",
94 : :
95 : : [RTE_CRYPTO_CIPHER_NULL] = "null",
96 : :
97 : : [RTE_CRYPTO_CIPHER_KASUMI_F8] = "kasumi-f8",
98 : : [RTE_CRYPTO_CIPHER_SNOW3G_UEA2] = "snow3g-uea2",
99 : : [RTE_CRYPTO_CIPHER_ZUC_EEA3] = "zuc-eea3",
100 : : [RTE_CRYPTO_CIPHER_SM4_ECB] = "sm4-ecb",
101 : : [RTE_CRYPTO_CIPHER_SM4_CBC] = "sm4-cbc",
102 : : [RTE_CRYPTO_CIPHER_SM4_CTR] = "sm4-ctr",
103 : : [RTE_CRYPTO_CIPHER_SM4_CFB] = "sm4-cfb",
104 : : [RTE_CRYPTO_CIPHER_SM4_OFB] = "sm4-ofb",
105 : : [RTE_CRYPTO_CIPHER_SM4_XTS] = "sm4-xts"
106 : : };
107 : :
108 : : /**
109 : : * The crypto cipher operation strings identifiers.
110 : : * It could be used in application command line.
111 : : */
112 : : RTE_EXPORT_SYMBOL(rte_crypto_cipher_operation_strings)
113 : : const char *
114 : : rte_crypto_cipher_operation_strings[] = {
115 : : [RTE_CRYPTO_CIPHER_OP_ENCRYPT] = "encrypt",
116 : : [RTE_CRYPTO_CIPHER_OP_DECRYPT] = "decrypt"
117 : : };
118 : :
119 : : /**
120 : : * The crypto auth algorithm strings identifiers.
121 : : * Not to be used in application directly.
122 : : * Application can use rte_cryptodev_get_auth_algo_string().
123 : : */
124 : : static const char *
125 : : crypto_auth_algorithm_strings[] = {
126 : : [RTE_CRYPTO_AUTH_AES_CBC_MAC] = "aes-cbc-mac",
127 : : [RTE_CRYPTO_AUTH_AES_CMAC] = "aes-cmac",
128 : : [RTE_CRYPTO_AUTH_AES_GMAC] = "aes-gmac",
129 : : [RTE_CRYPTO_AUTH_AES_XCBC_MAC] = "aes-xcbc-mac",
130 : :
131 : : [RTE_CRYPTO_AUTH_MD5] = "md5",
132 : : [RTE_CRYPTO_AUTH_MD5_HMAC] = "md5-hmac",
133 : :
134 : : [RTE_CRYPTO_AUTH_NULL] = "null",
135 : :
136 : : [RTE_CRYPTO_AUTH_SHA1] = "sha1",
137 : : [RTE_CRYPTO_AUTH_SHA1_HMAC] = "sha1-hmac",
138 : :
139 : : [RTE_CRYPTO_AUTH_SHA224] = "sha2-224",
140 : : [RTE_CRYPTO_AUTH_SHA224_HMAC] = "sha2-224-hmac",
141 : : [RTE_CRYPTO_AUTH_SHA256] = "sha2-256",
142 : : [RTE_CRYPTO_AUTH_SHA256_HMAC] = "sha2-256-hmac",
143 : : [RTE_CRYPTO_AUTH_SHA384] = "sha2-384",
144 : : [RTE_CRYPTO_AUTH_SHA384_HMAC] = "sha2-384-hmac",
145 : : [RTE_CRYPTO_AUTH_SHA512] = "sha2-512",
146 : : [RTE_CRYPTO_AUTH_SHA512_HMAC] = "sha2-512-hmac",
147 : :
148 : : [RTE_CRYPTO_AUTH_SHA3_224] = "sha3-224",
149 : : [RTE_CRYPTO_AUTH_SHA3_224_HMAC] = "sha3-224-hmac",
150 : : [RTE_CRYPTO_AUTH_SHA3_256] = "sha3-256",
151 : : [RTE_CRYPTO_AUTH_SHA3_256_HMAC] = "sha3-256-hmac",
152 : : [RTE_CRYPTO_AUTH_SHA3_384] = "sha3-384",
153 : : [RTE_CRYPTO_AUTH_SHA3_384_HMAC] = "sha3-384-hmac",
154 : : [RTE_CRYPTO_AUTH_SHA3_512] = "sha3-512",
155 : : [RTE_CRYPTO_AUTH_SHA3_512_HMAC] = "sha3-512-hmac",
156 : :
157 : : [RTE_CRYPTO_AUTH_KASUMI_F9] = "kasumi-f9",
158 : : [RTE_CRYPTO_AUTH_SNOW3G_UIA2] = "snow3g-uia2",
159 : : [RTE_CRYPTO_AUTH_ZUC_EIA3] = "zuc-eia3",
160 : : [RTE_CRYPTO_AUTH_SM3] = "sm3",
161 : : [RTE_CRYPTO_AUTH_SM3_HMAC] = "sm3-hmac",
162 : :
163 : : [RTE_CRYPTO_AUTH_SHAKE_128] = "shake-128",
164 : : [RTE_CRYPTO_AUTH_SHAKE_256] = "shake-256",
165 : : };
166 : :
167 : : /**
168 : : * The crypto AEAD algorithm strings identifiers.
169 : : * Not to be used in application directly.
170 : : * Application can use rte_cryptodev_get_aead_algo_string().
171 : : */
172 : : static const char *
173 : : crypto_aead_algorithm_strings[] = {
174 : : [RTE_CRYPTO_AEAD_AES_CCM] = "aes-ccm",
175 : : [RTE_CRYPTO_AEAD_AES_GCM] = "aes-gcm",
176 : : [RTE_CRYPTO_AEAD_CHACHA20_POLY1305] = "chacha20-poly1305",
177 : : [RTE_CRYPTO_AEAD_SM4_GCM] = "sm4-gcm",
178 : : };
179 : :
180 : :
181 : : /**
182 : : * The crypto AEAD operation strings identifiers.
183 : : * It could be used in application command line.
184 : : */
185 : : RTE_EXPORT_SYMBOL(rte_crypto_aead_operation_strings)
186 : : const char *
187 : : rte_crypto_aead_operation_strings[] = {
188 : : [RTE_CRYPTO_AEAD_OP_ENCRYPT] = "encrypt",
189 : : [RTE_CRYPTO_AEAD_OP_DECRYPT] = "decrypt"
190 : : };
191 : :
192 : : /**
193 : : * Asymmetric crypto transform operation strings identifiers.
194 : : * Not to be used in application directly.
195 : : * Application can use rte_cryptodev_asym_get_xform_string().
196 : : */
197 : : static const char *
198 : : crypto_asym_xform_strings[] = {
199 : : [RTE_CRYPTO_ASYM_XFORM_NONE] = "none",
200 : : [RTE_CRYPTO_ASYM_XFORM_RSA] = "rsa",
201 : : [RTE_CRYPTO_ASYM_XFORM_MODEX] = "modexp",
202 : : [RTE_CRYPTO_ASYM_XFORM_MODINV] = "modinv",
203 : : [RTE_CRYPTO_ASYM_XFORM_DH] = "dh",
204 : : [RTE_CRYPTO_ASYM_XFORM_DSA] = "dsa",
205 : : [RTE_CRYPTO_ASYM_XFORM_ECDSA] = "ecdsa",
206 : : [RTE_CRYPTO_ASYM_XFORM_ECPM] = "ecpm",
207 : : [RTE_CRYPTO_ASYM_XFORM_SM2] = "sm2",
208 : : };
209 : :
210 : : /**
211 : : * Asymmetric crypto operation strings identifiers.
212 : : */
213 : : RTE_EXPORT_SYMBOL(rte_crypto_asym_op_strings)
214 : : const char *rte_crypto_asym_op_strings[] = {
215 : : [RTE_CRYPTO_ASYM_OP_ENCRYPT] = "encrypt",
216 : : [RTE_CRYPTO_ASYM_OP_DECRYPT] = "decrypt",
217 : : [RTE_CRYPTO_ASYM_OP_SIGN] = "sign",
218 : : [RTE_CRYPTO_ASYM_OP_VERIFY] = "verify"
219 : : };
220 : :
221 : : /**
222 : : * Asymmetric crypto key exchange operation strings identifiers.
223 : : */
224 : : RTE_EXPORT_SYMBOL(rte_crypto_asym_ke_strings)
225 : : const char *rte_crypto_asym_ke_strings[] = {
226 : : [RTE_CRYPTO_ASYM_KE_PRIV_KEY_GENERATE] = "priv_key_generate",
227 : : [RTE_CRYPTO_ASYM_KE_PUB_KEY_GENERATE] = "pub_key_generate",
228 : : [RTE_CRYPTO_ASYM_KE_SHARED_SECRET_COMPUTE] = "sharedsecret_compute",
229 : : [RTE_CRYPTO_ASYM_KE_PUB_KEY_VERIFY] = "pub_ec_key_verify"
230 : : };
231 : :
232 : : struct rte_cryptodev_sym_session_pool_private_data {
233 : : uint16_t sess_data_sz;
234 : : /**< driver session data size */
235 : : uint16_t user_data_sz;
236 : : /**< session user data will be placed after sess_data */
237 : : };
238 : :
239 : : /**
240 : : * The private data structure stored in the asym session mempool private data.
241 : : */
242 : : struct rte_cryptodev_asym_session_pool_private_data {
243 : : uint16_t max_priv_session_sz;
244 : : /**< Size of private session data used when creating mempool */
245 : : uint16_t user_data_sz;
246 : : /**< Session user data will be placed after sess_private_data */
247 : : };
248 : :
249 : : RTE_EXPORT_SYMBOL(rte_cryptodev_get_cipher_algo_enum)
250 : : int
251 : 0 : rte_cryptodev_get_cipher_algo_enum(enum rte_crypto_cipher_algorithm *algo_enum,
252 : : const char *algo_string)
253 : : {
254 : : unsigned int i;
255 : : int ret = -1; /* Invalid string */
256 : :
257 [ # # ]: 0 : for (i = 1; i < RTE_DIM(crypto_cipher_algorithm_strings); i++) {
258 [ # # ]: 0 : if (strcmp(algo_string, crypto_cipher_algorithm_strings[i]) == 0) {
259 : 0 : *algo_enum = (enum rte_crypto_cipher_algorithm) i;
260 : : ret = 0;
261 : 0 : break;
262 : : }
263 : : }
264 : :
265 [ # # ]: 0 : rte_cryptodev_trace_get_cipher_algo_enum(algo_string, *algo_enum, ret);
266 : :
267 : 0 : return ret;
268 : : }
269 : :
270 : : RTE_EXPORT_SYMBOL(rte_cryptodev_get_auth_algo_enum)
271 : : int
272 : 0 : rte_cryptodev_get_auth_algo_enum(enum rte_crypto_auth_algorithm *algo_enum,
273 : : const char *algo_string)
274 : : {
275 : : unsigned int i;
276 : : int ret = -1; /* Invalid string */
277 : :
278 [ # # ]: 0 : for (i = 1; i < RTE_DIM(crypto_auth_algorithm_strings); i++) {
279 [ # # ]: 0 : if (strcmp(algo_string, crypto_auth_algorithm_strings[i]) == 0) {
280 : 0 : *algo_enum = (enum rte_crypto_auth_algorithm) i;
281 : : ret = 0;
282 : 0 : break;
283 : : }
284 : : }
285 : :
286 [ # # ]: 0 : rte_cryptodev_trace_get_auth_algo_enum(algo_string, *algo_enum, ret);
287 : :
288 : 0 : return ret;
289 : : }
290 : :
291 : : RTE_EXPORT_SYMBOL(rte_cryptodev_get_aead_algo_enum)
292 : : int
293 : 0 : rte_cryptodev_get_aead_algo_enum(enum rte_crypto_aead_algorithm *algo_enum,
294 : : const char *algo_string)
295 : : {
296 : : unsigned int i;
297 : : int ret = -1; /* Invalid string */
298 : :
299 [ # # ]: 0 : for (i = 1; i < RTE_DIM(crypto_aead_algorithm_strings); i++) {
300 [ # # ]: 0 : if (strcmp(algo_string, crypto_aead_algorithm_strings[i]) == 0) {
301 : 0 : *algo_enum = (enum rte_crypto_aead_algorithm) i;
302 : : ret = 0;
303 : 0 : break;
304 : : }
305 : : }
306 : :
307 [ # # ]: 0 : rte_cryptodev_trace_get_aead_algo_enum(algo_string, *algo_enum, ret);
308 : :
309 : 0 : return ret;
310 : : }
311 : :
312 : : RTE_EXPORT_SYMBOL(rte_cryptodev_asym_get_xform_enum)
313 : : int
314 : 2 : rte_cryptodev_asym_get_xform_enum(enum rte_crypto_asym_xform_type *xform_enum,
315 : : const char *xform_string)
316 : : {
317 : : unsigned int i;
318 : : int ret = -1; /* Invalid string */
319 : :
320 [ + - ]: 11 : for (i = 1; i < RTE_DIM(crypto_asym_xform_strings); i++) {
321 [ + + ]: 11 : if (strcmp(xform_string,
322 : : crypto_asym_xform_strings[i]) == 0) {
323 : 2 : *xform_enum = (enum rte_crypto_asym_xform_type) i;
324 : : ret = 0;
325 : 2 : break;
326 : : }
327 : : }
328 : :
329 [ - + ]: 2 : rte_cryptodev_trace_asym_get_xform_enum(xform_string, *xform_enum, ret);
330 : :
331 : 2 : return ret;
332 : : }
333 : :
334 : : RTE_EXPORT_EXPERIMENTAL_SYMBOL(rte_cryptodev_get_cipher_algo_string, 23.03)
335 : : const char *
336 : 0 : rte_cryptodev_get_cipher_algo_string(enum rte_crypto_cipher_algorithm algo_enum)
337 : : {
338 : : const char *alg_str = NULL;
339 : :
340 [ # # ]: 0 : if ((unsigned int)algo_enum < RTE_DIM(crypto_cipher_algorithm_strings))
341 : 0 : alg_str = crypto_cipher_algorithm_strings[algo_enum];
342 : :
343 : 0 : rte_cryptodev_trace_get_cipher_algo_string(algo_enum, alg_str);
344 : :
345 : 0 : return alg_str;
346 : : }
347 : :
348 : : RTE_EXPORT_EXPERIMENTAL_SYMBOL(rte_cryptodev_get_auth_algo_string, 23.03)
349 : : const char *
350 : 0 : rte_cryptodev_get_auth_algo_string(enum rte_crypto_auth_algorithm algo_enum)
351 : : {
352 : : const char *alg_str = NULL;
353 : :
354 [ # # ]: 0 : if ((unsigned int)algo_enum < RTE_DIM(crypto_auth_algorithm_strings))
355 : 0 : alg_str = crypto_auth_algorithm_strings[algo_enum];
356 : :
357 : 0 : rte_cryptodev_trace_get_auth_algo_string(algo_enum, alg_str);
358 : :
359 : 0 : return alg_str;
360 : : }
361 : :
362 : : RTE_EXPORT_EXPERIMENTAL_SYMBOL(rte_cryptodev_get_aead_algo_string, 23.03)
363 : : const char *
364 : 0 : rte_cryptodev_get_aead_algo_string(enum rte_crypto_aead_algorithm algo_enum)
365 : : {
366 : : const char *alg_str = NULL;
367 : :
368 [ # # ]: 0 : if ((unsigned int)algo_enum < RTE_DIM(crypto_aead_algorithm_strings))
369 : 0 : alg_str = crypto_aead_algorithm_strings[algo_enum];
370 : :
371 : 0 : rte_cryptodev_trace_get_aead_algo_string(algo_enum, alg_str);
372 : :
373 : 0 : return alg_str;
374 : : }
375 : :
376 : : RTE_EXPORT_EXPERIMENTAL_SYMBOL(rte_cryptodev_asym_get_xform_string, 23.03)
377 : : const char *
378 : 8 : rte_cryptodev_asym_get_xform_string(enum rte_crypto_asym_xform_type xform_enum)
379 : : {
380 : : const char *xform_str = NULL;
381 : :
382 [ + + ]: 8 : if ((unsigned int)xform_enum < RTE_DIM(crypto_asym_xform_strings))
383 : 7 : xform_str = crypto_asym_xform_strings[xform_enum];
384 : :
385 : 8 : rte_cryptodev_trace_asym_get_xform_string(xform_enum, xform_str);
386 : :
387 : 8 : return xform_str;
388 : : }
389 : :
390 : : /**
391 : : * The crypto auth operation strings identifiers.
392 : : * It could be used in application command line.
393 : : */
394 : : RTE_EXPORT_SYMBOL(rte_crypto_auth_operation_strings)
395 : : const char *
396 : : rte_crypto_auth_operation_strings[] = {
397 : : [RTE_CRYPTO_AUTH_OP_VERIFY] = "verify",
398 : : [RTE_CRYPTO_AUTH_OP_GENERATE] = "generate"
399 : : };
400 : :
401 : : RTE_EXPORT_SYMBOL(rte_cryptodev_sym_capability_get)
402 : : const struct rte_cryptodev_symmetric_capability *
403 : 517 : rte_cryptodev_sym_capability_get(uint8_t dev_id,
404 : : const struct rte_cryptodev_sym_capability_idx *idx)
405 : : {
406 : : const struct rte_cryptodev_capabilities *capability;
407 : : const struct rte_cryptodev_symmetric_capability *sym_capability = NULL;
408 : : struct rte_cryptodev_info dev_info;
409 : : int i = 0;
410 : :
411 : 517 : rte_cryptodev_info_get(dev_id, &dev_info);
412 : :
413 [ + + ]: 9316 : while ((capability = &dev_info.capabilities[i++])->op !=
414 : : RTE_CRYPTO_OP_TYPE_UNDEFINED) {
415 [ + + ]: 9170 : if (capability->op != RTE_CRYPTO_OP_TYPE_SYMMETRIC)
416 : 1168 : continue;
417 : :
418 [ + + ]: 8002 : if (capability->sym.xform_type != idx->type)
419 : 5304 : continue;
420 : :
421 [ + + ]: 2698 : if (idx->type == RTE_CRYPTO_SYM_XFORM_AUTH &&
422 [ + + ]: 1717 : capability->sym.auth.algo == idx->algo.auth) {
423 : 128 : sym_capability = &capability->sym;
424 : 128 : break;
425 : : }
426 : :
427 [ + + ]: 2570 : if (idx->type == RTE_CRYPTO_SYM_XFORM_CIPHER &&
428 [ + + ]: 864 : capability->sym.cipher.algo == idx->algo.cipher) {
429 : 149 : sym_capability = &capability->sym;
430 : 149 : break;
431 : : }
432 : :
433 [ + + ]: 2421 : if (idx->type == RTE_CRYPTO_SYM_XFORM_AEAD &&
434 [ + + ]: 117 : capability->sym.aead.algo == idx->algo.aead) {
435 : 94 : sym_capability = &capability->sym;
436 : 94 : break;
437 : : }
438 : : }
439 : :
440 : 1034 : rte_cryptodev_trace_sym_capability_get(dev_id, dev_info.driver_name,
441 [ - + ]: 517 : dev_info.driver_id, idx->type, sym_capability);
442 : :
443 : 517 : return sym_capability;
444 : : }
445 : :
446 : : static int
447 : : param_range_check(uint16_t size, const struct rte_crypto_param_range *range)
448 : : {
449 : : unsigned int next_size;
450 : :
451 : : /* Check lower/upper bounds */
452 [ + - + - : 539 : if (size < range->min)
+ + + - +
- + + ]
453 : : return -1;
454 : :
455 [ + - + - : 812 : if (size > range->max)
+ - + - +
- + - + -
+ - + - ]
456 : : return -1;
457 : :
458 : : /* If range is actually only one value, size is correct */
459 [ + - + + : 812 : if (range->increment == 0)
+ - + - +
+ + + - +
+ + - + ]
460 : : return 0;
461 : :
462 : : /* Check if value is one of the supported sizes */
463 [ + - + - : 266402 : for (next_size = range->min; next_size <= range->max;
+ - + - +
- + - - -
+ - - - ]
464 : 265899 : next_size += range->increment)
465 [ + + + + : 266402 : if (size == next_size)
+ + + + +
+ + + - -
+ + - - ]
466 : : return 0;
467 : :
468 : : return -1;
469 : : }
470 : :
471 : : RTE_EXPORT_SYMBOL(rte_cryptodev_asym_capability_get)
472 : : const struct rte_cryptodev_asymmetric_xform_capability *
473 : 19 : rte_cryptodev_asym_capability_get(uint8_t dev_id,
474 : : const struct rte_cryptodev_asym_capability_idx *idx)
475 : : {
476 : : const struct rte_cryptodev_capabilities *capability;
477 : : const struct rte_cryptodev_asymmetric_xform_capability *asym_cap = NULL;
478 : : struct rte_cryptodev_info dev_info;
479 : : unsigned int i = 0;
480 : :
481 : : memset(&dev_info, 0, sizeof(struct rte_cryptodev_info));
482 : 19 : rte_cryptodev_info_get(dev_id, &dev_info);
483 : :
484 [ + - ]: 499 : while ((capability = &dev_info.capabilities[i++])->op !=
485 : : RTE_CRYPTO_OP_TYPE_UNDEFINED) {
486 [ + + ]: 499 : if (capability->op != RTE_CRYPTO_OP_TYPE_ASYMMETRIC)
487 : 418 : continue;
488 : :
489 [ + + ]: 81 : if (capability->asym.xform_capa.xform_type == idx->type) {
490 : 19 : asym_cap = &capability->asym.xform_capa;
491 : 19 : break;
492 : : }
493 : : }
494 : :
495 : 38 : rte_cryptodev_trace_asym_capability_get(dev_info.driver_name,
496 [ - + ]: 19 : dev_info.driver_id, idx->type, asym_cap);
497 : :
498 : 19 : return asym_cap;
499 : : };
500 : :
501 : : RTE_EXPORT_SYMBOL(rte_cryptodev_sym_capability_check_cipher)
502 : : int
503 [ + - ]: 106 : rte_cryptodev_sym_capability_check_cipher(
504 : : const struct rte_cryptodev_symmetric_capability *capability,
505 : : uint16_t key_size, uint16_t iv_size)
506 : : {
507 : : int ret = 0; /* success */
508 : :
509 [ - + ]: 92 : if (param_range_check(key_size, &capability->cipher.key_size) != 0) {
510 : : ret = -1;
511 : 0 : goto done;
512 : : }
513 : :
514 [ # # ]: 0 : if (param_range_check(iv_size, &capability->cipher.iv_size) != 0)
515 : : ret = -1;
516 : :
517 [ - + ]: 106 : done:
518 : 106 : rte_cryptodev_trace_sym_capability_check_cipher(capability, key_size,
519 : : iv_size, ret);
520 : :
521 : 106 : return ret;
522 : : }
523 : :
524 : : RTE_EXPORT_SYMBOL(rte_cryptodev_sym_capability_check_auth)
525 : : int
526 [ + - ]: 83 : rte_cryptodev_sym_capability_check_auth(
527 : : const struct rte_cryptodev_symmetric_capability *capability,
528 : : uint16_t key_size, uint16_t digest_size, uint16_t iv_size)
529 : : {
530 : : int ret = 0; /* success */
531 : :
532 [ - + ]: 63 : if (param_range_check(key_size, &capability->auth.key_size) != 0) {
533 : : ret = -1;
534 : 0 : goto done;
535 : : }
536 : :
537 [ - + ]: 65 : if (param_range_check(digest_size,
538 : : &capability->auth.digest_size) != 0) {
539 : : ret = -1;
540 : 0 : goto done;
541 : : }
542 : :
543 [ # # ]: 0 : if (param_range_check(iv_size, &capability->auth.iv_size) != 0)
544 : : ret = -1;
545 : :
546 [ - + ]: 83 : done:
547 : 83 : rte_cryptodev_trace_sym_capability_check_auth(capability, key_size,
548 : : digest_size, iv_size, ret);
549 : :
550 : 83 : return ret;
551 : : }
552 : :
553 : : RTE_EXPORT_SYMBOL(rte_cryptodev_sym_capability_check_aead)
554 : : int
555 [ + - ]: 89 : rte_cryptodev_sym_capability_check_aead(
556 : : const struct rte_cryptodev_symmetric_capability *capability,
557 : : uint16_t key_size, uint16_t digest_size, uint16_t aad_size,
558 : : uint16_t iv_size)
559 : : {
560 : : int ret = 0; /* success */
561 : :
562 [ - + ]: 89 : if (param_range_check(key_size, &capability->aead.key_size) != 0) {
563 : : ret = -1;
564 : 0 : goto done;
565 : : }
566 : :
567 [ - + ]: 18 : if (param_range_check(digest_size,
568 : : &capability->aead.digest_size) != 0) {
569 : : ret = -1;
570 : 0 : goto done;
571 : : }
572 : :
573 [ - + ]: 89 : if (param_range_check(aad_size, &capability->aead.aad_size) != 0) {
574 : : ret = -1;
575 : 0 : goto done;
576 : : }
577 : :
578 [ + - ]: 87 : if (param_range_check(iv_size, &capability->aead.iv_size) != 0)
579 : : ret = -1;
580 : :
581 [ - + ]: 89 : done:
582 : 89 : rte_cryptodev_trace_sym_capability_check_aead(capability, key_size,
583 : : digest_size, aad_size, iv_size, ret);
584 : :
585 : 89 : return ret;
586 : : }
587 : :
588 : : RTE_EXPORT_SYMBOL(rte_cryptodev_asym_xform_capability_check_optype)
589 : : int
590 : 32 : rte_cryptodev_asym_xform_capability_check_optype(
591 : : const struct rte_cryptodev_asymmetric_xform_capability *capability,
592 : : enum rte_crypto_asym_op_type op_type)
593 : : {
594 : : int ret = 0;
595 : :
596 [ + + ]: 32 : if (capability->op_types & (1 << op_type))
597 : : ret = 1;
598 : :
599 : 32 : rte_cryptodev_trace_asym_xform_capability_check_optype(
600 : : capability->op_types, op_type, ret);
601 : :
602 : 32 : return ret;
603 : : }
604 : :
605 : : RTE_EXPORT_SYMBOL(rte_cryptodev_asym_xform_capability_check_modlen)
606 : : int
607 : 2 : rte_cryptodev_asym_xform_capability_check_modlen(
608 : : const struct rte_cryptodev_asymmetric_xform_capability *capability,
609 : : uint16_t modlen)
610 : : {
611 : : int ret = 0; /* success */
612 : :
613 : : /* no need to check for limits, if min or max = 0 */
614 [ - + ]: 2 : if (capability->modlen.min != 0) {
615 [ # # ]: 0 : if (modlen < capability->modlen.min) {
616 : : ret = -1;
617 : 0 : goto done;
618 : : }
619 : : }
620 : :
621 [ - + ]: 2 : if (capability->modlen.max != 0) {
622 [ # # ]: 0 : if (modlen > capability->modlen.max) {
623 : : ret = -1;
624 : 0 : goto done;
625 : : }
626 : : }
627 : :
628 : : /* in any case, check if given modlen is module increment */
629 [ - + ]: 2 : if (capability->modlen.increment != 0) {
630 [ + - ]: 2 : if (modlen % (capability->modlen.increment))
631 : : ret = -1;
632 : : }
633 : :
634 [ - + ]: 2 : done:
635 : 2 : rte_cryptodev_trace_asym_xform_capability_check_modlen(capability,
636 : : modlen, ret);
637 : :
638 : 2 : return ret;
639 : : }
640 : :
641 : : RTE_EXPORT_SYMBOL(rte_cryptodev_asym_xform_capability_check_hash)
642 : : bool
643 : 0 : rte_cryptodev_asym_xform_capability_check_hash(
644 : : const struct rte_cryptodev_asymmetric_xform_capability *capability,
645 : : enum rte_crypto_auth_algorithm hash)
646 : : {
647 : : bool ret = false;
648 : :
649 [ # # ]: 0 : if (capability->hash_algos & RTE_BIT64(hash))
650 : : ret = true;
651 : :
652 [ # # ]: 0 : rte_cryptodev_trace_asym_xform_capability_check_hash(
653 : : capability->hash_algos, hash, ret);
654 : :
655 : 0 : return ret;
656 : : }
657 : :
658 : : RTE_EXPORT_EXPERIMENTAL_SYMBOL(rte_cryptodev_asym_xform_capability_check_opcap, 24.11)
659 : : int
660 : 8 : rte_cryptodev_asym_xform_capability_check_opcap(
661 : : const struct rte_cryptodev_asymmetric_xform_capability *capability,
662 : : enum rte_crypto_asym_op_type op_type, uint8_t cap)
663 : : {
664 : : int ret = 0;
665 : :
666 [ + - ]: 8 : if (!(capability->op_types & (1 << op_type)))
667 : : return ret;
668 : :
669 [ + + ]: 8 : if (capability->op_capa[op_type] & (1 << cap))
670 : : ret = 1;
671 : :
672 : : return ret;
673 : : }
674 : :
675 : : /* spinlock for crypto device enq callbacks */
676 : : static rte_spinlock_t rte_cryptodev_callback_lock = RTE_SPINLOCK_INITIALIZER;
677 : :
678 : : static void
679 : 468 : cryptodev_cb_cleanup(struct rte_cryptodev *dev)
680 : : {
681 : : struct rte_cryptodev_cb_rcu *list;
682 : : struct rte_cryptodev_cb *cb, *next;
683 : : uint16_t qp_id;
684 : :
685 [ + + - + ]: 468 : if (dev->enq_cbs == NULL && dev->deq_cbs == NULL)
686 : : return;
687 : :
688 [ + + ]: 4153 : for (qp_id = 0; qp_id < dev->data->nb_queue_pairs; qp_id++) {
689 : 3690 : list = &dev->enq_cbs[qp_id];
690 : 3690 : cb = list->next;
691 [ - + ]: 3690 : while (cb != NULL) {
692 : 0 : next = cb->next;
693 : 0 : rte_free(cb);
694 : : cb = next;
695 : : }
696 : :
697 : 3690 : rte_free(list->qsbr);
698 : : }
699 : :
700 [ + + ]: 4153 : for (qp_id = 0; qp_id < dev->data->nb_queue_pairs; qp_id++) {
701 : 3690 : list = &dev->deq_cbs[qp_id];
702 : 3690 : cb = list->next;
703 [ - + ]: 3690 : while (cb != NULL) {
704 : 0 : next = cb->next;
705 : 0 : rte_free(cb);
706 : : cb = next;
707 : : }
708 : :
709 : 3690 : rte_free(list->qsbr);
710 : : }
711 : :
712 : 463 : rte_free(dev->enq_cbs);
713 : 463 : dev->enq_cbs = NULL;
714 : 463 : rte_free(dev->deq_cbs);
715 : 463 : dev->deq_cbs = NULL;
716 : : }
717 : :
718 : : static int
719 : 465 : cryptodev_cb_init(struct rte_cryptodev *dev)
720 : : {
721 : : struct rte_cryptodev_cb_rcu *list;
722 : : struct rte_rcu_qsbr *qsbr;
723 : : uint16_t qp_id;
724 : : size_t size;
725 : :
726 : : /* Max thread set to 1, as one DP thread accessing a queue-pair */
727 : : const uint32_t max_threads = 1;
728 : :
729 : 930 : dev->enq_cbs = rte_zmalloc(NULL,
730 : : sizeof(struct rte_cryptodev_cb_rcu) *
731 : 465 : dev->data->nb_queue_pairs, 0);
732 [ - + ]: 465 : if (dev->enq_cbs == NULL) {
733 : 0 : CDEV_LOG_ERR("Failed to allocate memory for enq callbacks");
734 : 0 : return -ENOMEM;
735 : : }
736 : :
737 : 930 : dev->deq_cbs = rte_zmalloc(NULL,
738 : : sizeof(struct rte_cryptodev_cb_rcu) *
739 : 465 : dev->data->nb_queue_pairs, 0);
740 [ - + ]: 465 : if (dev->deq_cbs == NULL) {
741 : 0 : CDEV_LOG_ERR("Failed to allocate memory for deq callbacks");
742 : 0 : rte_free(dev->enq_cbs);
743 : 0 : return -ENOMEM;
744 : : }
745 : :
746 : : /* Create RCU QSBR variable */
747 : 465 : size = rte_rcu_qsbr_get_memsize(max_threads);
748 : :
749 [ + + ]: 4171 : for (qp_id = 0; qp_id < dev->data->nb_queue_pairs; qp_id++) {
750 : 3706 : list = &dev->enq_cbs[qp_id];
751 : 3706 : qsbr = rte_zmalloc(NULL, size, RTE_CACHE_LINE_SIZE);
752 [ - + ]: 3706 : if (qsbr == NULL) {
753 : 0 : CDEV_LOG_ERR("Failed to allocate memory for RCU on "
754 : : "queue_pair_id=%d", qp_id);
755 : 0 : goto cb_init_err;
756 : : }
757 : :
758 [ - + ]: 3706 : if (rte_rcu_qsbr_init(qsbr, max_threads)) {
759 : 0 : CDEV_LOG_ERR("Failed to initialize for RCU on "
760 : : "queue_pair_id=%d", qp_id);
761 : 0 : goto cb_init_err;
762 : : }
763 : :
764 : 3706 : list->qsbr = qsbr;
765 : : }
766 : :
767 [ + + ]: 4171 : for (qp_id = 0; qp_id < dev->data->nb_queue_pairs; qp_id++) {
768 : 3706 : list = &dev->deq_cbs[qp_id];
769 : 3706 : qsbr = rte_zmalloc(NULL, size, RTE_CACHE_LINE_SIZE);
770 [ - + ]: 3706 : if (qsbr == NULL) {
771 : 0 : CDEV_LOG_ERR("Failed to allocate memory for RCU on "
772 : : "queue_pair_id=%d", qp_id);
773 : 0 : goto cb_init_err;
774 : : }
775 : :
776 [ - + ]: 3706 : if (rte_rcu_qsbr_init(qsbr, max_threads)) {
777 : 0 : CDEV_LOG_ERR("Failed to initialize for RCU on "
778 : : "queue_pair_id=%d", qp_id);
779 : 0 : goto cb_init_err;
780 : : }
781 : :
782 : 3706 : list->qsbr = qsbr;
783 : : }
784 : :
785 : : return 0;
786 : :
787 : 0 : cb_init_err:
788 : 0 : cryptodev_cb_cleanup(dev);
789 : 0 : return -ENOMEM;
790 : : }
791 : :
792 : : RTE_EXPORT_SYMBOL(rte_cryptodev_get_feature_name)
793 : : const char *
794 [ # # ]: 0 : rte_cryptodev_get_feature_name(uint64_t flag)
795 : : {
796 : 0 : rte_cryptodev_trace_get_feature_name(flag);
797 : :
798 [ # # # # : 0 : switch (flag) {
# # # # #
# # # # #
# # # # #
# # # # #
# # # ]
799 : : case RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO:
800 : : return "SYMMETRIC_CRYPTO";
801 : 0 : case RTE_CRYPTODEV_FF_ASYMMETRIC_CRYPTO:
802 : 0 : return "ASYMMETRIC_CRYPTO";
803 : 0 : case RTE_CRYPTODEV_FF_SYM_OPERATION_CHAINING:
804 : 0 : return "SYM_OPERATION_CHAINING";
805 : 0 : case RTE_CRYPTODEV_FF_CPU_SSE:
806 : 0 : return "CPU_SSE";
807 : 0 : case RTE_CRYPTODEV_FF_CPU_AVX:
808 : 0 : return "CPU_AVX";
809 : 0 : case RTE_CRYPTODEV_FF_CPU_AVX2:
810 : 0 : return "CPU_AVX2";
811 : 0 : case RTE_CRYPTODEV_FF_CPU_AVX512:
812 : 0 : return "CPU_AVX512";
813 : 0 : case RTE_CRYPTODEV_FF_CPU_AESNI:
814 : 0 : return "CPU_AESNI";
815 : 0 : case RTE_CRYPTODEV_FF_HW_ACCELERATED:
816 : 0 : return "HW_ACCELERATED";
817 : 0 : case RTE_CRYPTODEV_FF_IN_PLACE_SGL:
818 : 0 : return "IN_PLACE_SGL";
819 : 0 : case RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT:
820 : 0 : return "OOP_SGL_IN_SGL_OUT";
821 : 0 : case RTE_CRYPTODEV_FF_OOP_SGL_IN_LB_OUT:
822 : 0 : return "OOP_SGL_IN_LB_OUT";
823 : 0 : case RTE_CRYPTODEV_FF_OOP_LB_IN_SGL_OUT:
824 : 0 : return "OOP_LB_IN_SGL_OUT";
825 : 0 : case RTE_CRYPTODEV_FF_OOP_LB_IN_LB_OUT:
826 : 0 : return "OOP_LB_IN_LB_OUT";
827 : 0 : case RTE_CRYPTODEV_FF_CPU_NEON:
828 : 0 : return "CPU_NEON";
829 : 0 : case RTE_CRYPTODEV_FF_CPU_ARM_CE:
830 : 0 : return "CPU_ARM_CE";
831 : 0 : case RTE_CRYPTODEV_FF_SECURITY:
832 : 0 : return "SECURITY_PROTOCOL";
833 : 0 : case RTE_CRYPTODEV_FF_RSA_PRIV_OP_KEY_EXP:
834 : 0 : return "RSA_PRIV_OP_KEY_EXP";
835 : 0 : case RTE_CRYPTODEV_FF_RSA_PRIV_OP_KEY_QT:
836 : 0 : return "RSA_PRIV_OP_KEY_QT";
837 : 0 : case RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED:
838 : 0 : return "DIGEST_ENCRYPTED";
839 : 0 : case RTE_CRYPTODEV_FF_SYM_CPU_CRYPTO:
840 : 0 : return "SYM_CPU_CRYPTO";
841 : 0 : case RTE_CRYPTODEV_FF_ASYM_SESSIONLESS:
842 : 0 : return "ASYM_SESSIONLESS";
843 : 0 : case RTE_CRYPTODEV_FF_SYM_SESSIONLESS:
844 : 0 : return "SYM_SESSIONLESS";
845 : 0 : case RTE_CRYPTODEV_FF_NON_BYTE_ALIGNED_DATA:
846 : 0 : return "NON_BYTE_ALIGNED_DATA";
847 : 0 : case RTE_CRYPTODEV_FF_CIPHER_MULTIPLE_DATA_UNITS:
848 : 0 : return "CIPHER_MULTIPLE_DATA_UNITS";
849 : 0 : case RTE_CRYPTODEV_FF_CIPHER_WRAPPED_KEY:
850 : 0 : return "CIPHER_WRAPPED_KEY";
851 : 0 : default:
852 : 0 : return NULL;
853 : : }
854 : : }
855 : :
856 : : RTE_EXPORT_INTERNAL_SYMBOL(rte_cryptodev_pmd_get_dev)
857 : : struct rte_cryptodev *
858 : 22546 : rte_cryptodev_pmd_get_dev(uint8_t dev_id)
859 : : {
860 : 22546 : return &cryptodev_globals.devs[dev_id];
861 : : }
862 : :
863 : : RTE_EXPORT_INTERNAL_SYMBOL(rte_cryptodev_pmd_get_named_dev)
864 : : struct rte_cryptodev *
865 : 6 : rte_cryptodev_pmd_get_named_dev(const char *name)
866 : : {
867 : : struct rte_cryptodev *dev;
868 : : unsigned int i;
869 : :
870 [ + - ]: 6 : if (name == NULL)
871 : : return NULL;
872 : :
873 [ + + ]: 198 : for (i = 0; i < RTE_CRYPTO_MAX_DEVS; i++) {
874 : 195 : dev = &cryptodev_globals.devs[i];
875 : :
876 [ + + ]: 195 : if ((dev->attached == RTE_CRYPTODEV_ATTACHED) &&
877 [ + - ]: 3 : (strcmp(dev->data->name, name) == 0))
878 : 3 : return dev;
879 : : }
880 : :
881 : : return NULL;
882 : : }
883 : :
884 : : static inline uint8_t
885 : : rte_cryptodev_is_valid_device_data(uint8_t dev_id)
886 : : {
887 : 29218 : if (dev_id >= RTE_CRYPTO_MAX_DEVS ||
888 [ - - - - : 14576 : rte_crypto_devices[dev_id].data == NULL)
+ + ]
889 : : return 0;
890 : :
891 : : return 1;
892 : : }
893 : :
894 : : RTE_EXPORT_SYMBOL(rte_cryptodev_is_valid_dev)
895 : : unsigned int
896 : 14578 : rte_cryptodev_is_valid_dev(uint8_t dev_id)
897 : : {
898 : : struct rte_cryptodev *dev = NULL;
899 : : unsigned int ret = 1;
900 : :
901 [ + + ]: 14578 : if (!rte_cryptodev_is_valid_device_data(dev_id)) {
902 : : ret = 0;
903 : 67 : goto done;
904 : : }
905 : :
906 : 14511 : dev = rte_cryptodev_pmd_get_dev(dev_id);
907 [ + - ]: 14511 : if (dev->attached != RTE_CRYPTODEV_ATTACHED)
908 : : ret = 0;
909 : :
910 [ - + ]: 14578 : done:
911 : 14578 : rte_cryptodev_trace_is_valid_dev(dev_id, ret);
912 : :
913 : 14578 : return ret;
914 : : }
915 : :
916 : : RTE_EXPORT_SYMBOL(rte_cryptodev_get_dev_id)
917 : : int
918 : 0 : rte_cryptodev_get_dev_id(const char *name)
919 : : {
920 : : unsigned i;
921 : : int ret = -1;
922 : :
923 [ # # ]: 0 : if (name == NULL)
924 : : return -1;
925 : :
926 [ # # ]: 0 : for (i = 0; i < RTE_CRYPTO_MAX_DEVS; i++) {
927 [ # # ]: 0 : if (!rte_cryptodev_is_valid_device_data(i))
928 : 0 : continue;
929 [ # # ]: 0 : if ((strcmp(cryptodev_globals.devs[i].data->name, name)
930 : 0 : == 0) &&
931 [ # # ]: 0 : (cryptodev_globals.devs[i].attached ==
932 : : RTE_CRYPTODEV_ATTACHED)) {
933 : 0 : ret = (int)i;
934 : 0 : break;
935 : : }
936 : : }
937 : :
938 : 0 : rte_cryptodev_trace_get_dev_id(name, ret);
939 : :
940 : 0 : return ret;
941 : : }
942 : :
943 : : RTE_EXPORT_SYMBOL(rte_cryptodev_count)
944 : : uint8_t
945 : 5 : rte_cryptodev_count(void)
946 : : {
947 [ - + ]: 5 : rte_cryptodev_trace_count(cryptodev_globals.nb_devs);
948 : :
949 : 5 : return cryptodev_globals.nb_devs;
950 : : }
951 : :
952 : : RTE_EXPORT_SYMBOL(rte_cryptodev_device_count_by_driver)
953 : : uint8_t
954 : 2 : rte_cryptodev_device_count_by_driver(uint8_t driver_id)
955 : : {
956 : : uint8_t i, dev_count = 0;
957 : :
958 [ + + ]: 130 : for (i = 0; i < RTE_CRYPTO_MAX_DEVS; i++)
959 [ + + ]: 128 : if (cryptodev_globals.devs[i].driver_id == driver_id &&
960 [ + - ]: 2 : cryptodev_globals.devs[i].attached ==
961 : : RTE_CRYPTODEV_ATTACHED)
962 : 2 : dev_count++;
963 : :
964 : 2 : rte_cryptodev_trace_device_count_by_driver(driver_id, dev_count);
965 : :
966 : 2 : return dev_count;
967 : : }
968 : :
969 : : RTE_EXPORT_SYMBOL(rte_cryptodev_devices_get)
970 : : uint8_t
971 : 1 : rte_cryptodev_devices_get(const char *driver_name, uint8_t *devices,
972 : : uint8_t nb_devices)
973 : : {
974 : : uint8_t i, count = 0;
975 : 1 : struct rte_cryptodev *devs = cryptodev_globals.devs;
976 : :
977 [ + + ]: 65 : for (i = 0; i < RTE_CRYPTO_MAX_DEVS && count < nb_devices; i++) {
978 [ + + ]: 64 : if (!rte_cryptodev_is_valid_device_data(i))
979 : 63 : continue;
980 : :
981 [ + - ]: 1 : if (devs[i].attached == RTE_CRYPTODEV_ATTACHED) {
982 : : int cmp;
983 : :
984 : 1 : cmp = strncmp(devs[i].device->driver->name,
985 : : driver_name,
986 : 1 : strlen(driver_name) + 1);
987 : :
988 [ + - ]: 1 : if (cmp == 0)
989 : 1 : devices[count++] = devs[i].data->dev_id;
990 : : }
991 : : }
992 : :
993 : 1 : rte_cryptodev_trace_devices_get(driver_name, count);
994 : :
995 : 1 : return count;
996 : : }
997 : :
998 : : RTE_EXPORT_SYMBOL(rte_cryptodev_get_sec_ctx)
999 : : void *
1000 : 1 : rte_cryptodev_get_sec_ctx(uint8_t dev_id)
1001 : : {
1002 : : void *sec_ctx = NULL;
1003 : :
1004 [ + - ]: 1 : if (dev_id < RTE_CRYPTO_MAX_DEVS &&
1005 [ - + ]: 1 : (rte_crypto_devices[dev_id].feature_flags &
1006 : : RTE_CRYPTODEV_FF_SECURITY))
1007 : 0 : sec_ctx = rte_crypto_devices[dev_id].security_ctx;
1008 : :
1009 : 1 : rte_cryptodev_trace_get_sec_ctx(dev_id, sec_ctx);
1010 : :
1011 : 1 : return sec_ctx;
1012 : : }
1013 : :
1014 : : RTE_EXPORT_SYMBOL(rte_cryptodev_socket_id)
1015 : : int
1016 : 3691 : rte_cryptodev_socket_id(uint8_t dev_id)
1017 : : {
1018 : : struct rte_cryptodev *dev;
1019 : :
1020 [ + - ]: 3691 : if (!rte_cryptodev_is_valid_dev(dev_id))
1021 : : return -1;
1022 : :
1023 : 3691 : dev = rte_cryptodev_pmd_get_dev(dev_id);
1024 : :
1025 : 7382 : rte_cryptodev_trace_socket_id(dev_id, dev->data->name,
1026 [ - + ]: 3691 : dev->data->socket_id);
1027 : 3691 : return dev->data->socket_id;
1028 : : }
1029 : :
1030 : : static inline int
1031 : 3 : rte_cryptodev_data_alloc(uint8_t dev_id, struct rte_cryptodev_data **data,
1032 : : int socket_id)
1033 : : {
1034 : : char mz_name[RTE_MEMZONE_NAMESIZE];
1035 : : const struct rte_memzone *mz;
1036 : : int n;
1037 : :
1038 : : /* generate memzone name */
1039 [ + - ]: 3 : n = snprintf(mz_name, sizeof(mz_name), "rte_cryptodev_data_%u", dev_id);
1040 [ + - ]: 3 : if (n >= (int)sizeof(mz_name))
1041 : : return -EINVAL;
1042 : :
1043 [ + - ]: 3 : if (rte_eal_process_type() == RTE_PROC_PRIMARY) {
1044 : 3 : mz = rte_memzone_reserve(mz_name,
1045 : : sizeof(struct rte_cryptodev_data),
1046 : : socket_id, 0);
1047 : 3 : CDEV_LOG_DEBUG("PRIMARY:reserved memzone for %s (%p)",
1048 : : mz_name, mz);
1049 : : } else {
1050 : 0 : mz = rte_memzone_lookup(mz_name);
1051 : 0 : CDEV_LOG_DEBUG("SECONDARY:looked up memzone for %s (%p)",
1052 : : mz_name, mz);
1053 : : }
1054 : :
1055 [ + - ]: 3 : if (mz == NULL)
1056 : : return -ENOMEM;
1057 : :
1058 : 3 : *data = mz->addr;
1059 [ + - ]: 3 : if (rte_eal_process_type() == RTE_PROC_PRIMARY)
1060 : 3 : memset(*data, 0, sizeof(struct rte_cryptodev_data));
1061 : :
1062 : : return 0;
1063 : : }
1064 : :
1065 : : static inline int
1066 : 3 : rte_cryptodev_data_free(uint8_t dev_id, struct rte_cryptodev_data **data)
1067 : : {
1068 : : char mz_name[RTE_MEMZONE_NAMESIZE];
1069 : : const struct rte_memzone *mz;
1070 : : int n;
1071 : :
1072 : : /* generate memzone name */
1073 [ + - ]: 3 : n = snprintf(mz_name, sizeof(mz_name), "rte_cryptodev_data_%u", dev_id);
1074 [ + - ]: 3 : if (n >= (int)sizeof(mz_name))
1075 : : return -EINVAL;
1076 : :
1077 : 3 : mz = rte_memzone_lookup(mz_name);
1078 [ + - ]: 3 : if (mz == NULL)
1079 : : return -ENOMEM;
1080 : :
1081 : : RTE_ASSERT(*data == mz->addr);
1082 : 3 : *data = NULL;
1083 : :
1084 [ + - ]: 3 : if (rte_eal_process_type() == RTE_PROC_PRIMARY) {
1085 : 3 : CDEV_LOG_DEBUG("PRIMARY:free memzone of %s (%p)",
1086 : : mz_name, mz);
1087 : 3 : return rte_memzone_free(mz);
1088 : : } else {
1089 : 0 : CDEV_LOG_DEBUG("SECONDARY:don't free memzone of %s (%p)",
1090 : : mz_name, mz);
1091 : : }
1092 : :
1093 : 0 : return 0;
1094 : : }
1095 : :
1096 : : static uint8_t
1097 : : rte_cryptodev_find_free_device_index(void)
1098 : : {
1099 : : uint8_t dev_id;
1100 : :
1101 [ + - ]: 3 : for (dev_id = 0; dev_id < RTE_CRYPTO_MAX_DEVS; dev_id++) {
1102 [ - + ]: 3 : if (rte_crypto_devices[dev_id].attached ==
1103 : : RTE_CRYPTODEV_DETACHED)
1104 : : return dev_id;
1105 : : }
1106 : : return RTE_CRYPTO_MAX_DEVS;
1107 : : }
1108 : :
1109 : : RTE_EXPORT_INTERNAL_SYMBOL(rte_cryptodev_pmd_allocate)
1110 : : struct rte_cryptodev *
1111 : 3 : rte_cryptodev_pmd_allocate(const char *name, int socket_id)
1112 : : {
1113 : : struct rte_cryptodev *cryptodev;
1114 : : uint8_t dev_id;
1115 : :
1116 [ - + ]: 3 : if (rte_cryptodev_pmd_get_named_dev(name) != NULL) {
1117 : 0 : CDEV_LOG_ERR("Crypto device with name %s already "
1118 : : "allocated!", name);
1119 : 0 : return NULL;
1120 : : }
1121 : :
1122 : : dev_id = rte_cryptodev_find_free_device_index();
1123 [ - + ]: 3 : if (dev_id == RTE_CRYPTO_MAX_DEVS) {
1124 : 0 : CDEV_LOG_ERR("Reached maximum number of crypto devices");
1125 : 0 : return NULL;
1126 : : }
1127 : :
1128 : 3 : cryptodev = rte_cryptodev_pmd_get_dev(dev_id);
1129 : :
1130 [ + - ]: 3 : if (cryptodev->data == NULL) {
1131 : 3 : struct rte_cryptodev_data **cryptodev_data =
1132 : : &cryptodev_globals.data[dev_id];
1133 : :
1134 : 3 : int retval = rte_cryptodev_data_alloc(dev_id, cryptodev_data,
1135 : : socket_id);
1136 : :
1137 [ + - + - ]: 3 : if (retval < 0 || *cryptodev_data == NULL)
1138 : : return NULL;
1139 : :
1140 : 3 : cryptodev->data = *cryptodev_data;
1141 : :
1142 [ + - ]: 3 : if (rte_eal_process_type() == RTE_PROC_PRIMARY) {
1143 : 3 : strlcpy(cryptodev->data->name, name,
1144 : : RTE_CRYPTODEV_NAME_MAX_LEN);
1145 : :
1146 : 3 : cryptodev->data->dev_id = dev_id;
1147 : 3 : cryptodev->data->socket_id = socket_id;
1148 : 3 : cryptodev->data->dev_started = 0;
1149 : 3 : CDEV_LOG_DEBUG("PRIMARY:init data");
1150 : : }
1151 : :
1152 : 3 : CDEV_LOG_DEBUG("Data for %s: dev_id %d, socket %d, started %d",
1153 : : cryptodev->data->name,
1154 : : cryptodev->data->dev_id,
1155 : : cryptodev->data->socket_id,
1156 : : cryptodev->data->dev_started);
1157 : :
1158 : : /* init user callbacks */
1159 : 3 : TAILQ_INIT(&(cryptodev->link_intr_cbs));
1160 : :
1161 : 3 : cryptodev->attached = RTE_CRYPTODEV_ATTACHED;
1162 : :
1163 : 3 : cryptodev_globals.nb_devs++;
1164 : : }
1165 : :
1166 : : return cryptodev;
1167 : : }
1168 : :
1169 : : RTE_EXPORT_INTERNAL_SYMBOL(rte_cryptodev_pmd_release_device)
1170 : : int
1171 : 3 : rte_cryptodev_pmd_release_device(struct rte_cryptodev *cryptodev)
1172 : : {
1173 : : int ret;
1174 : : uint8_t dev_id;
1175 : :
1176 [ + - ]: 3 : if (cryptodev == NULL)
1177 : : return -EINVAL;
1178 : :
1179 : 3 : dev_id = cryptodev->data->dev_id;
1180 : :
1181 : 3 : cryptodev_fp_ops_reset(rte_crypto_fp_ops + dev_id);
1182 : :
1183 : : /* Close device only if device operations have been set */
1184 [ + - + - ]: 3 : if (cryptodev->dev_ops && (rte_eal_process_type() == RTE_PROC_PRIMARY)) {
1185 : 3 : ret = rte_cryptodev_close(dev_id);
1186 [ + - ]: 3 : if (ret < 0)
1187 : : return ret;
1188 : : }
1189 : :
1190 : 3 : ret = rte_cryptodev_data_free(dev_id, &cryptodev_globals.data[dev_id]);
1191 [ + - ]: 3 : if (ret < 0)
1192 : : return ret;
1193 : :
1194 : 3 : cryptodev->attached = RTE_CRYPTODEV_DETACHED;
1195 : 3 : cryptodev_globals.nb_devs--;
1196 : 3 : return 0;
1197 : : }
1198 : :
1199 : : RTE_EXPORT_SYMBOL(rte_cryptodev_queue_pair_count)
1200 : : uint16_t
1201 : 0 : rte_cryptodev_queue_pair_count(uint8_t dev_id)
1202 : : {
1203 : : struct rte_cryptodev *dev;
1204 : :
1205 [ # # ]: 0 : if (!rte_cryptodev_is_valid_device_data(dev_id)) {
1206 : 0 : CDEV_LOG_ERR("Invalid dev_id=%" PRIu8, dev_id);
1207 : 0 : return 0;
1208 : : }
1209 : :
1210 : 0 : dev = &rte_crypto_devices[dev_id];
1211 : 0 : rte_cryptodev_trace_queue_pair_count(dev, dev->data->name,
1212 : 0 : dev->data->socket_id, dev->data->dev_id,
1213 [ # # ]: 0 : dev->data->nb_queue_pairs);
1214 : :
1215 : 0 : return dev->data->nb_queue_pairs;
1216 : : }
1217 : :
1218 : : static int
1219 : 468 : rte_cryptodev_queue_pairs_config(struct rte_cryptodev *dev, uint16_t nb_qpairs,
1220 : : int socket_id)
1221 : : {
1222 : : struct rte_cryptodev_info dev_info;
1223 : : void **qp;
1224 : : unsigned i;
1225 : :
1226 [ + + ]: 468 : if ((dev == NULL) || (nb_qpairs < 1)) {
1227 : 1 : CDEV_LOG_ERR("invalid param: dev %p, nb_queues %u",
1228 : : dev, nb_qpairs);
1229 : 1 : return -EINVAL;
1230 : : }
1231 : :
1232 : 467 : CDEV_LOG_DEBUG("Setup %d queues pairs on device %u",
1233 : : nb_qpairs, dev->data->dev_id);
1234 : :
1235 : : memset(&dev_info, 0, sizeof(struct rte_cryptodev_info));
1236 : :
1237 [ + - ]: 467 : if (dev->dev_ops->dev_infos_get == NULL)
1238 : : return -ENOTSUP;
1239 : 467 : dev->dev_ops->dev_infos_get(dev, &dev_info);
1240 : :
1241 [ + + ]: 467 : if (nb_qpairs > (dev_info.max_nb_queue_pairs)) {
1242 : 2 : CDEV_LOG_ERR("Invalid num queue_pairs (%u) for dev %u",
1243 : : nb_qpairs, dev->data->dev_id);
1244 : 2 : return -EINVAL;
1245 : : }
1246 : :
1247 [ + + ]: 465 : if (dev->data->queue_pairs == NULL) { /* first time configuration */
1248 : 4 : dev->data->queue_pairs = rte_zmalloc_socket(
1249 : : "cryptodev->queue_pairs",
1250 : : sizeof(dev->data->queue_pairs[0]) *
1251 : 2 : dev_info.max_nb_queue_pairs,
1252 : : RTE_CACHE_LINE_SIZE, socket_id);
1253 : :
1254 [ - + ]: 2 : if (dev->data->queue_pairs == NULL) {
1255 : 0 : dev->data->nb_queue_pairs = 0;
1256 : 0 : CDEV_LOG_ERR("failed to get memory for qp meta data, "
1257 : : "nb_queues %u",
1258 : : nb_qpairs);
1259 : 0 : return -(ENOMEM);
1260 : : }
1261 : : } else { /* re-configure */
1262 : : int ret;
1263 : 463 : uint16_t old_nb_queues = dev->data->nb_queue_pairs;
1264 : :
1265 : : qp = dev->data->queue_pairs;
1266 : :
1267 [ + - ]: 463 : if (dev->dev_ops->queue_pair_release == NULL)
1268 : : return -ENOTSUP;
1269 : :
1270 [ + + ]: 477 : for (i = nb_qpairs; i < old_nb_queues; i++) {
1271 : 14 : ret = dev->dev_ops->queue_pair_release(dev, i);
1272 [ - + ]: 14 : if (ret < 0)
1273 : 0 : return ret;
1274 : 14 : qp[i] = NULL;
1275 : : }
1276 : :
1277 : : }
1278 : 465 : dev->data->nb_queue_pairs = nb_qpairs;
1279 : 465 : return 0;
1280 : : }
1281 : :
1282 : : RTE_EXPORT_EXPERIMENTAL_SYMBOL(rte_cryptodev_queue_pair_reset, 24.11)
1283 : : int
1284 : 1 : rte_cryptodev_queue_pair_reset(uint8_t dev_id, uint16_t queue_pair_id,
1285 : : const struct rte_cryptodev_qp_conf *qp_conf, int socket_id)
1286 : : {
1287 : : struct rte_cryptodev *dev;
1288 : :
1289 [ - + ]: 1 : if (!rte_cryptodev_is_valid_dev(dev_id)) {
1290 : 0 : CDEV_LOG_ERR("Invalid dev_id=%" PRIu8, dev_id);
1291 : 0 : return -EINVAL;
1292 : : }
1293 : :
1294 : 1 : dev = &rte_crypto_devices[dev_id];
1295 [ - + ]: 1 : if (queue_pair_id >= dev->data->nb_queue_pairs) {
1296 : 0 : CDEV_LOG_ERR("Invalid queue_pair_id=%d", queue_pair_id);
1297 : 0 : return -EINVAL;
1298 : : }
1299 : :
1300 [ - + ]: 1 : if (dev->dev_ops->queue_pair_reset == NULL)
1301 : : return -ENOTSUP;
1302 : :
1303 [ # # ]: 0 : rte_cryptodev_trace_queue_pair_reset(dev_id, queue_pair_id, qp_conf, socket_id);
1304 : 0 : return dev->dev_ops->queue_pair_reset(dev, queue_pair_id, qp_conf, socket_id);
1305 : : }
1306 : :
1307 : : RTE_EXPORT_SYMBOL(rte_cryptodev_configure)
1308 : : int
1309 : 470 : rte_cryptodev_configure(uint8_t dev_id, struct rte_cryptodev_config *config)
1310 : : {
1311 : : struct rte_cryptodev *dev;
1312 : : int diag;
1313 : :
1314 [ + + ]: 470 : if (!rte_cryptodev_is_valid_dev(dev_id)) {
1315 : 2 : CDEV_LOG_ERR("Invalid dev_id=%" PRIu8, dev_id);
1316 : 2 : return -EINVAL;
1317 : : }
1318 : :
1319 : 468 : dev = &rte_crypto_devices[dev_id];
1320 : :
1321 [ - + ]: 468 : if (dev->data->dev_started) {
1322 : 0 : CDEV_LOG_ERR(
1323 : : "device %d must be stopped to allow configuration", dev_id);
1324 : 0 : return -EBUSY;
1325 : : }
1326 : :
1327 [ + - ]: 468 : if (dev->dev_ops->dev_configure == NULL)
1328 : : return -ENOTSUP;
1329 : :
1330 : : rte_spinlock_lock(&rte_cryptodev_callback_lock);
1331 : 468 : cryptodev_cb_cleanup(dev);
1332 : : rte_spinlock_unlock(&rte_cryptodev_callback_lock);
1333 : :
1334 : : /* Setup new number of queue pairs and reconfigure device. */
1335 : 468 : diag = rte_cryptodev_queue_pairs_config(dev, config->nb_queue_pairs,
1336 : : config->socket_id);
1337 [ + + ]: 468 : if (diag != 0) {
1338 : 3 : CDEV_LOG_ERR("dev%d rte_crypto_dev_queue_pairs_config = %d",
1339 : : dev_id, diag);
1340 : 3 : return diag;
1341 : : }
1342 : :
1343 : : rte_spinlock_lock(&rte_cryptodev_callback_lock);
1344 : 465 : diag = cryptodev_cb_init(dev);
1345 : : rte_spinlock_unlock(&rte_cryptodev_callback_lock);
1346 [ - + ]: 465 : if (diag) {
1347 : 0 : CDEV_LOG_ERR("Callback init failed for dev_id=%d", dev_id);
1348 : 0 : return diag;
1349 : : }
1350 : :
1351 : 465 : rte_cryptodev_trace_configure(dev_id, config);
1352 : 465 : return dev->dev_ops->dev_configure(dev, config);
1353 : : }
1354 : :
1355 : : RTE_EXPORT_SYMBOL(rte_cryptodev_start)
1356 : : int
1357 : 455 : rte_cryptodev_start(uint8_t dev_id)
1358 : : {
1359 : : struct rte_cryptodev *dev;
1360 : : int diag;
1361 : :
1362 : 455 : CDEV_LOG_DEBUG("Start dev_id=%" PRIu8, dev_id);
1363 : :
1364 [ - + ]: 455 : if (!rte_cryptodev_is_valid_dev(dev_id)) {
1365 : 0 : CDEV_LOG_ERR("Invalid dev_id=%" PRIu8, dev_id);
1366 : 0 : return -EINVAL;
1367 : : }
1368 : :
1369 : 455 : dev = &rte_crypto_devices[dev_id];
1370 : :
1371 [ + - ]: 455 : if (dev->dev_ops->dev_start == NULL)
1372 : : return -ENOTSUP;
1373 : :
1374 [ - + ]: 455 : if (dev->data->dev_started != 0) {
1375 : 0 : CDEV_LOG_ERR("Device with dev_id=%" PRIu8 " already started",
1376 : : dev_id);
1377 : 0 : return 0;
1378 : : }
1379 : :
1380 : 455 : diag = dev->dev_ops->dev_start(dev);
1381 : : /* expose selection of PMD fast-path functions */
1382 : 455 : cryptodev_fp_ops_set(rte_crypto_fp_ops + dev_id, dev);
1383 : :
1384 : 455 : rte_cryptodev_trace_start(dev_id, diag);
1385 [ + - ]: 455 : if (diag == 0)
1386 : 455 : dev->data->dev_started = 1;
1387 : : else
1388 : : return diag;
1389 : :
1390 : 455 : return 0;
1391 : : }
1392 : :
1393 : : RTE_EXPORT_SYMBOL(rte_cryptodev_stop)
1394 : : void
1395 : 458 : rte_cryptodev_stop(uint8_t dev_id)
1396 : : {
1397 : : struct rte_cryptodev *dev;
1398 : :
1399 [ - + ]: 458 : if (!rte_cryptodev_is_valid_dev(dev_id)) {
1400 : 0 : CDEV_LOG_ERR("Invalid dev_id=%" PRIu8, dev_id);
1401 : 0 : return;
1402 : : }
1403 : :
1404 : 458 : dev = &rte_crypto_devices[dev_id];
1405 : :
1406 [ + - ]: 458 : if (dev->dev_ops->dev_stop == NULL)
1407 : : return;
1408 : :
1409 [ + + ]: 458 : if (dev->data->dev_started == 0) {
1410 : 3 : CDEV_LOG_ERR("Device with dev_id=%" PRIu8 " already stopped",
1411 : : dev_id);
1412 : 3 : return;
1413 : : }
1414 : :
1415 : : /* point fast-path functions to dummy ones */
1416 : 455 : cryptodev_fp_ops_reset(rte_crypto_fp_ops + dev_id);
1417 : :
1418 : 455 : dev->dev_ops->dev_stop(dev);
1419 : 455 : rte_cryptodev_trace_stop(dev_id);
1420 : 455 : dev->data->dev_started = 0;
1421 : : }
1422 : :
1423 : : RTE_EXPORT_SYMBOL(rte_cryptodev_close)
1424 : : int
1425 : 4 : rte_cryptodev_close(uint8_t dev_id)
1426 : : {
1427 : : struct rte_cryptodev *dev;
1428 : : int retval;
1429 : :
1430 [ - + ]: 4 : if (!rte_cryptodev_is_valid_dev(dev_id)) {
1431 : 0 : CDEV_LOG_ERR("Invalid dev_id=%" PRIu8, dev_id);
1432 : 0 : return -1;
1433 : : }
1434 : :
1435 : 4 : dev = &rte_crypto_devices[dev_id];
1436 : :
1437 : : /* Device must be stopped before it can be closed */
1438 [ - + ]: 4 : if (dev->data->dev_started == 1) {
1439 : 0 : CDEV_LOG_ERR("Device %u must be stopped before closing",
1440 : : dev_id);
1441 : 0 : return -EBUSY;
1442 : : }
1443 : :
1444 : : /* We can't close the device if there are outstanding sessions in use */
1445 [ - + ]: 4 : if (dev->data->session_pool != NULL) {
1446 [ # # ]: 0 : if (!rte_mempool_full(dev->data->session_pool)) {
1447 : 0 : CDEV_LOG_ERR("dev_id=%u close failed, session mempool "
1448 : : "has sessions still in use, free "
1449 : : "all sessions before calling close",
1450 : : (unsigned)dev_id);
1451 : 0 : return -EBUSY;
1452 : : }
1453 : : }
1454 : :
1455 [ + - ]: 4 : if (dev->dev_ops->dev_close == NULL)
1456 : : return -ENOTSUP;
1457 : 4 : retval = dev->dev_ops->dev_close(dev);
1458 : 4 : rte_cryptodev_trace_close(dev_id, retval);
1459 : :
1460 : : if (retval < 0)
1461 : : return retval;
1462 : :
1463 : : return 0;
1464 : : }
1465 : :
1466 : : RTE_EXPORT_SYMBOL(rte_cryptodev_get_qp_status)
1467 : : int
1468 : 0 : rte_cryptodev_get_qp_status(uint8_t dev_id, uint16_t queue_pair_id)
1469 : : {
1470 : : struct rte_cryptodev *dev;
1471 : : int ret = 0;
1472 : :
1473 [ # # ]: 0 : if (!rte_cryptodev_is_valid_dev(dev_id)) {
1474 : 0 : CDEV_LOG_ERR("Invalid dev_id=%" PRIu8, dev_id);
1475 : : ret = -EINVAL;
1476 : 0 : goto done;
1477 : : }
1478 : :
1479 : : dev = &rte_crypto_devices[dev_id];
1480 [ # # ]: 0 : if (queue_pair_id >= dev->data->nb_queue_pairs) {
1481 : 0 : CDEV_LOG_ERR("Invalid queue_pair_id=%d", queue_pair_id);
1482 : : ret = -EINVAL;
1483 : 0 : goto done;
1484 : : }
1485 : 0 : void **qps = dev->data->queue_pairs;
1486 : :
1487 [ # # ]: 0 : if (qps[queue_pair_id]) {
1488 : 0 : CDEV_LOG_DEBUG("qp %d on dev %d is initialised",
1489 : : queue_pair_id, dev_id);
1490 : : ret = 1;
1491 : 0 : goto done;
1492 : : }
1493 : :
1494 : 0 : CDEV_LOG_DEBUG("qp %d on dev %d is not initialised",
1495 : : queue_pair_id, dev_id);
1496 : :
1497 [ # # ]: 0 : done:
1498 : 0 : rte_cryptodev_trace_get_qp_status(dev_id, queue_pair_id, ret);
1499 : :
1500 : 0 : return ret;
1501 : : }
1502 : :
1503 : : static uint8_t
1504 : : rte_cryptodev_sym_is_valid_session_pool(struct rte_mempool *mp,
1505 : : uint32_t sess_priv_size)
1506 : : {
1507 : : struct rte_cryptodev_sym_session_pool_private_data *pool_priv;
1508 : :
1509 [ + - ]: 236 : if (!mp)
1510 : : return 0;
1511 : :
1512 : : pool_priv = rte_mempool_get_priv(mp);
1513 : :
1514 [ + - + - ]: 3741 : if (!pool_priv || mp->private_data_size < sizeof(*pool_priv) ||
1515 [ + - - + ]: 3741 : pool_priv->sess_data_sz < sess_priv_size)
1516 : : return 0;
1517 : :
1518 : : return 1;
1519 : : }
1520 : :
1521 : : RTE_EXPORT_SYMBOL(rte_cryptodev_queue_pair_setup)
1522 : : int
1523 : 3691 : rte_cryptodev_queue_pair_setup(uint8_t dev_id, uint16_t queue_pair_id,
1524 : : const struct rte_cryptodev_qp_conf *qp_conf, int socket_id)
1525 : :
1526 : : {
1527 : : struct rte_cryptodev *dev;
1528 : :
1529 [ - + ]: 3691 : if (!rte_cryptodev_is_valid_dev(dev_id)) {
1530 : 0 : CDEV_LOG_ERR("Invalid dev_id=%" PRIu8, dev_id);
1531 : 0 : return -EINVAL;
1532 : : }
1533 : :
1534 : 3691 : dev = &rte_crypto_devices[dev_id];
1535 [ + + ]: 3691 : if (queue_pair_id >= dev->data->nb_queue_pairs) {
1536 : 2 : CDEV_LOG_ERR("Invalid queue_pair_id=%d", queue_pair_id);
1537 : 2 : return -EINVAL;
1538 : : }
1539 : :
1540 [ - + ]: 3689 : if (!qp_conf) {
1541 : 0 : CDEV_LOG_ERR("qp_conf cannot be NULL");
1542 : 0 : return -EINVAL;
1543 : : }
1544 : :
1545 [ + + ]: 3689 : if (qp_conf->mp_session) {
1546 : : struct rte_cryptodev_sym_session_pool_private_data *pool_priv;
1547 : :
1548 : : pool_priv = rte_mempool_get_priv(qp_conf->mp_session);
1549 [ - + ]: 3505 : if (!pool_priv || qp_conf->mp_session->private_data_size <
1550 : : sizeof(*pool_priv)) {
1551 : 0 : CDEV_LOG_ERR("Invalid mempool");
1552 : 0 : return -EINVAL;
1553 : : }
1554 : :
1555 [ + - ]: 3505 : if (!rte_cryptodev_sym_is_valid_session_pool(qp_conf->mp_session,
1556 : : rte_cryptodev_sym_get_private_session_size(dev_id))) {
1557 : 0 : CDEV_LOG_ERR("Invalid mempool");
1558 : 0 : return -EINVAL;
1559 : : }
1560 : : }
1561 : :
1562 [ - + ]: 3689 : if (dev->data->dev_started) {
1563 : 0 : CDEV_LOG_ERR(
1564 : : "device %d must be stopped to allow configuration", dev_id);
1565 : 0 : return -EBUSY;
1566 : : }
1567 : :
1568 [ + - ]: 3689 : if (dev->dev_ops->queue_pair_setup == NULL)
1569 : : return -ENOTSUP;
1570 : :
1571 [ - + ]: 3689 : rte_cryptodev_trace_queue_pair_setup(dev_id, queue_pair_id, qp_conf);
1572 : 3689 : return dev->dev_ops->queue_pair_setup(dev, queue_pair_id, qp_conf, socket_id);
1573 : : }
1574 : :
1575 : : RTE_EXPORT_SYMBOL(rte_cryptodev_add_enq_callback)
1576 : : struct rte_cryptodev_cb *
1577 : 0 : rte_cryptodev_add_enq_callback(uint8_t dev_id,
1578 : : uint16_t qp_id,
1579 : : rte_cryptodev_callback_fn cb_fn,
1580 : : void *cb_arg)
1581 : : {
1582 : : #ifndef RTE_CRYPTO_CALLBACKS
1583 : : rte_errno = ENOTSUP;
1584 : : return NULL;
1585 : : #endif
1586 : : struct rte_cryptodev *dev;
1587 : : struct rte_cryptodev_cb_rcu *list;
1588 : : struct rte_cryptodev_cb *cb, *tail;
1589 : :
1590 [ # # ]: 0 : if (!cb_fn) {
1591 : 0 : CDEV_LOG_ERR("Callback is NULL on dev_id=%d", dev_id);
1592 : 0 : rte_errno = EINVAL;
1593 : 0 : return NULL;
1594 : : }
1595 : :
1596 [ # # ]: 0 : if (!rte_cryptodev_is_valid_dev(dev_id)) {
1597 : 0 : CDEV_LOG_ERR("Invalid dev_id=%d", dev_id);
1598 : 0 : rte_errno = ENODEV;
1599 : 0 : return NULL;
1600 : : }
1601 : :
1602 : : dev = &rte_crypto_devices[dev_id];
1603 [ # # ]: 0 : if (qp_id >= dev->data->nb_queue_pairs) {
1604 : 0 : CDEV_LOG_ERR("Invalid queue_pair_id=%d", qp_id);
1605 : 0 : rte_errno = ENODEV;
1606 : 0 : return NULL;
1607 : : }
1608 : :
1609 : 0 : cb = rte_zmalloc(NULL, sizeof(*cb), 0);
1610 [ # # ]: 0 : if (cb == NULL) {
1611 : 0 : CDEV_LOG_ERR("Failed to allocate memory for callback on "
1612 : : "dev=%d, queue_pair_id=%d", dev_id, qp_id);
1613 : 0 : rte_errno = ENOMEM;
1614 : 0 : return NULL;
1615 : : }
1616 : :
1617 : : rte_spinlock_lock(&rte_cryptodev_callback_lock);
1618 : :
1619 : 0 : cb->fn = cb_fn;
1620 : 0 : cb->arg = cb_arg;
1621 : :
1622 : : /* Add the callbacks in fifo order. */
1623 : 0 : list = &dev->enq_cbs[qp_id];
1624 : 0 : tail = list->next;
1625 : :
1626 [ # # ]: 0 : if (tail) {
1627 [ # # ]: 0 : while (tail->next)
1628 : : tail = tail->next;
1629 : : /* Stores to cb->fn and cb->param should complete before
1630 : : * cb is visible to data plane.
1631 : : */
1632 : 0 : rte_atomic_store_explicit(&tail->next, cb, rte_memory_order_release);
1633 : : } else {
1634 : : /* Stores to cb->fn and cb->param should complete before
1635 : : * cb is visible to data plane.
1636 : : */
1637 : 0 : rte_atomic_store_explicit(&list->next, cb, rte_memory_order_release);
1638 : : }
1639 : :
1640 : : rte_spinlock_unlock(&rte_cryptodev_callback_lock);
1641 : :
1642 : 0 : rte_cryptodev_trace_add_enq_callback(dev_id, qp_id, cb_fn);
1643 : 0 : return cb;
1644 : : }
1645 : :
1646 : : RTE_EXPORT_SYMBOL(rte_cryptodev_remove_enq_callback)
1647 : : int
1648 : 0 : rte_cryptodev_remove_enq_callback(uint8_t dev_id,
1649 : : uint16_t qp_id,
1650 : : struct rte_cryptodev_cb *cb)
1651 : : {
1652 : : #ifndef RTE_CRYPTO_CALLBACKS
1653 : : return -ENOTSUP;
1654 : : #endif
1655 : : struct rte_cryptodev *dev;
1656 : : RTE_ATOMIC(struct rte_cryptodev_cb *) *prev_cb;
1657 : : struct rte_cryptodev_cb *curr_cb;
1658 : : struct rte_cryptodev_cb_rcu *list;
1659 : : int ret;
1660 : :
1661 : : ret = -EINVAL;
1662 : :
1663 [ # # ]: 0 : if (!cb) {
1664 : 0 : CDEV_LOG_ERR("Callback is NULL");
1665 : 0 : return -EINVAL;
1666 : : }
1667 : :
1668 [ # # ]: 0 : if (!rte_cryptodev_is_valid_dev(dev_id)) {
1669 : 0 : CDEV_LOG_ERR("Invalid dev_id=%d", dev_id);
1670 : 0 : return -ENODEV;
1671 : : }
1672 : :
1673 [ # # ]: 0 : rte_cryptodev_trace_remove_enq_callback(dev_id, qp_id, cb->fn);
1674 : :
1675 : : dev = &rte_crypto_devices[dev_id];
1676 [ # # ]: 0 : if (qp_id >= dev->data->nb_queue_pairs) {
1677 : 0 : CDEV_LOG_ERR("Invalid queue_pair_id=%d", qp_id);
1678 : 0 : return -ENODEV;
1679 : : }
1680 : :
1681 : : rte_spinlock_lock(&rte_cryptodev_callback_lock);
1682 [ # # ]: 0 : if (dev->enq_cbs == NULL) {
1683 : 0 : CDEV_LOG_ERR("Callback not initialized");
1684 : 0 : goto cb_err;
1685 : : }
1686 : :
1687 : 0 : list = &dev->enq_cbs[qp_id];
1688 : : if (list == NULL) {
1689 : : CDEV_LOG_ERR("Callback list is NULL");
1690 : : goto cb_err;
1691 : : }
1692 : :
1693 [ # # ]: 0 : if (list->qsbr == NULL) {
1694 : 0 : CDEV_LOG_ERR("Rcu qsbr is NULL");
1695 : 0 : goto cb_err;
1696 : : }
1697 : :
1698 : 0 : prev_cb = &list->next;
1699 [ # # ]: 0 : for (; *prev_cb != NULL; prev_cb = &curr_cb->next) {
1700 : : curr_cb = *prev_cb;
1701 [ # # ]: 0 : if (curr_cb == cb) {
1702 : : /* Remove the user cb from the callback list. */
1703 : 0 : rte_atomic_store_explicit(prev_cb, curr_cb->next,
1704 : : rte_memory_order_relaxed);
1705 : : ret = 0;
1706 : : break;
1707 : : }
1708 : : }
1709 : :
1710 : : if (!ret) {
1711 : : /* Call sync with invalid thread id as this is part of
1712 : : * control plane API
1713 : : */
1714 : 0 : rte_rcu_qsbr_synchronize(list->qsbr, RTE_QSBR_THRID_INVALID);
1715 : 0 : rte_free(cb);
1716 : : }
1717 : :
1718 : 0 : cb_err:
1719 : : rte_spinlock_unlock(&rte_cryptodev_callback_lock);
1720 : 0 : return ret;
1721 : : }
1722 : :
1723 : : RTE_EXPORT_SYMBOL(rte_cryptodev_add_deq_callback)
1724 : : struct rte_cryptodev_cb *
1725 : 0 : rte_cryptodev_add_deq_callback(uint8_t dev_id,
1726 : : uint16_t qp_id,
1727 : : rte_cryptodev_callback_fn cb_fn,
1728 : : void *cb_arg)
1729 : : {
1730 : : #ifndef RTE_CRYPTO_CALLBACKS
1731 : : rte_errno = ENOTSUP;
1732 : : return NULL;
1733 : : #endif
1734 : : struct rte_cryptodev *dev;
1735 : : struct rte_cryptodev_cb_rcu *list;
1736 : : struct rte_cryptodev_cb *cb, *tail;
1737 : :
1738 [ # # ]: 0 : if (!cb_fn) {
1739 : 0 : CDEV_LOG_ERR("Callback is NULL on dev_id=%d", dev_id);
1740 : 0 : rte_errno = EINVAL;
1741 : 0 : return NULL;
1742 : : }
1743 : :
1744 [ # # ]: 0 : if (!rte_cryptodev_is_valid_dev(dev_id)) {
1745 : 0 : CDEV_LOG_ERR("Invalid dev_id=%d", dev_id);
1746 : 0 : rte_errno = ENODEV;
1747 : 0 : return NULL;
1748 : : }
1749 : :
1750 : : dev = &rte_crypto_devices[dev_id];
1751 [ # # ]: 0 : if (qp_id >= dev->data->nb_queue_pairs) {
1752 : 0 : CDEV_LOG_ERR("Invalid queue_pair_id=%d", qp_id);
1753 : 0 : rte_errno = ENODEV;
1754 : 0 : return NULL;
1755 : : }
1756 : :
1757 : 0 : cb = rte_zmalloc(NULL, sizeof(*cb), 0);
1758 [ # # ]: 0 : if (cb == NULL) {
1759 : 0 : CDEV_LOG_ERR("Failed to allocate memory for callback on "
1760 : : "dev=%d, queue_pair_id=%d", dev_id, qp_id);
1761 : 0 : rte_errno = ENOMEM;
1762 : 0 : return NULL;
1763 : : }
1764 : :
1765 : : rte_spinlock_lock(&rte_cryptodev_callback_lock);
1766 : :
1767 : 0 : cb->fn = cb_fn;
1768 : 0 : cb->arg = cb_arg;
1769 : :
1770 : : /* Add the callbacks in fifo order. */
1771 : 0 : list = &dev->deq_cbs[qp_id];
1772 : 0 : tail = list->next;
1773 : :
1774 [ # # ]: 0 : if (tail) {
1775 [ # # ]: 0 : while (tail->next)
1776 : : tail = tail->next;
1777 : : /* Stores to cb->fn and cb->param should complete before
1778 : : * cb is visible to data plane.
1779 : : */
1780 : 0 : rte_atomic_store_explicit(&tail->next, cb, rte_memory_order_release);
1781 : : } else {
1782 : : /* Stores to cb->fn and cb->param should complete before
1783 : : * cb is visible to data plane.
1784 : : */
1785 : 0 : rte_atomic_store_explicit(&list->next, cb, rte_memory_order_release);
1786 : : }
1787 : :
1788 : : rte_spinlock_unlock(&rte_cryptodev_callback_lock);
1789 : :
1790 : 0 : rte_cryptodev_trace_add_deq_callback(dev_id, qp_id, cb_fn);
1791 : :
1792 : 0 : return cb;
1793 : : }
1794 : :
1795 : : RTE_EXPORT_SYMBOL(rte_cryptodev_remove_deq_callback)
1796 : : int
1797 : 0 : rte_cryptodev_remove_deq_callback(uint8_t dev_id,
1798 : : uint16_t qp_id,
1799 : : struct rte_cryptodev_cb *cb)
1800 : : {
1801 : : #ifndef RTE_CRYPTO_CALLBACKS
1802 : : return -ENOTSUP;
1803 : : #endif
1804 : : struct rte_cryptodev *dev;
1805 : : RTE_ATOMIC(struct rte_cryptodev_cb *) *prev_cb;
1806 : : struct rte_cryptodev_cb *curr_cb;
1807 : : struct rte_cryptodev_cb_rcu *list;
1808 : : int ret;
1809 : :
1810 : : ret = -EINVAL;
1811 : :
1812 [ # # ]: 0 : if (!cb) {
1813 : 0 : CDEV_LOG_ERR("Callback is NULL");
1814 : 0 : return -EINVAL;
1815 : : }
1816 : :
1817 [ # # ]: 0 : if (!rte_cryptodev_is_valid_dev(dev_id)) {
1818 : 0 : CDEV_LOG_ERR("Invalid dev_id=%d", dev_id);
1819 : 0 : return -ENODEV;
1820 : : }
1821 : :
1822 [ # # ]: 0 : rte_cryptodev_trace_remove_deq_callback(dev_id, qp_id, cb->fn);
1823 : :
1824 : : dev = &rte_crypto_devices[dev_id];
1825 [ # # ]: 0 : if (qp_id >= dev->data->nb_queue_pairs) {
1826 : 0 : CDEV_LOG_ERR("Invalid queue_pair_id=%d", qp_id);
1827 : 0 : return -ENODEV;
1828 : : }
1829 : :
1830 : : rte_spinlock_lock(&rte_cryptodev_callback_lock);
1831 [ # # ]: 0 : if (dev->enq_cbs == NULL) {
1832 : 0 : CDEV_LOG_ERR("Callback not initialized");
1833 : 0 : goto cb_err;
1834 : : }
1835 : :
1836 : 0 : list = &dev->deq_cbs[qp_id];
1837 [ # # ]: 0 : if (list == NULL) {
1838 : 0 : CDEV_LOG_ERR("Callback list is NULL");
1839 : 0 : goto cb_err;
1840 : : }
1841 : :
1842 [ # # ]: 0 : if (list->qsbr == NULL) {
1843 : 0 : CDEV_LOG_ERR("Rcu qsbr is NULL");
1844 : 0 : goto cb_err;
1845 : : }
1846 : :
1847 : 0 : prev_cb = &list->next;
1848 [ # # ]: 0 : for (; *prev_cb != NULL; prev_cb = &curr_cb->next) {
1849 : : curr_cb = *prev_cb;
1850 [ # # ]: 0 : if (curr_cb == cb) {
1851 : : /* Remove the user cb from the callback list. */
1852 : 0 : rte_atomic_store_explicit(prev_cb, curr_cb->next,
1853 : : rte_memory_order_relaxed);
1854 : : ret = 0;
1855 : : break;
1856 : : }
1857 : : }
1858 : :
1859 : : if (!ret) {
1860 : : /* Call sync with invalid thread id as this is part of
1861 : : * control plane API
1862 : : */
1863 : 0 : rte_rcu_qsbr_synchronize(list->qsbr, RTE_QSBR_THRID_INVALID);
1864 : 0 : rte_free(cb);
1865 : : }
1866 : :
1867 : 0 : cb_err:
1868 : : rte_spinlock_unlock(&rte_cryptodev_callback_lock);
1869 : 0 : return ret;
1870 : : }
1871 : :
1872 : : RTE_EXPORT_SYMBOL(rte_cryptodev_stats_get)
1873 : : int
1874 : 6 : rte_cryptodev_stats_get(uint8_t dev_id, struct rte_cryptodev_stats *stats)
1875 : : {
1876 : : struct rte_cryptodev *dev;
1877 : :
1878 [ + + ]: 6 : if (!rte_cryptodev_is_valid_dev(dev_id)) {
1879 : 1 : CDEV_LOG_ERR("Invalid dev_id=%d", dev_id);
1880 : 1 : return -ENODEV;
1881 : : }
1882 : :
1883 [ + + ]: 5 : if (stats == NULL) {
1884 : 1 : CDEV_LOG_ERR("Invalid stats ptr");
1885 : 1 : return -EINVAL;
1886 : : }
1887 : :
1888 [ + - ]: 4 : dev = &rte_crypto_devices[dev_id];
1889 : : memset(stats, 0, sizeof(*stats));
1890 : :
1891 [ + - ]: 4 : if (dev->dev_ops->stats_get == NULL)
1892 : : return -ENOTSUP;
1893 : 4 : dev->dev_ops->stats_get(dev, stats);
1894 : :
1895 : 4 : rte_cryptodev_trace_stats_get(dev_id, stats);
1896 : 4 : return 0;
1897 : : }
1898 : :
1899 : : RTE_EXPORT_SYMBOL(rte_cryptodev_stats_reset)
1900 : : void
1901 : 435 : rte_cryptodev_stats_reset(uint8_t dev_id)
1902 : : {
1903 : : struct rte_cryptodev *dev;
1904 : :
1905 [ - + ]: 435 : rte_cryptodev_trace_stats_reset(dev_id);
1906 : :
1907 [ + + ]: 435 : if (!rte_cryptodev_is_valid_dev(dev_id)) {
1908 : 1 : CDEV_LOG_ERR("Invalid dev_id=%" PRIu8, dev_id);
1909 : 1 : return;
1910 : : }
1911 : :
1912 : 434 : dev = &rte_crypto_devices[dev_id];
1913 : :
1914 [ + - ]: 434 : if (dev->dev_ops->stats_reset == NULL)
1915 : : return;
1916 : 434 : dev->dev_ops->stats_reset(dev);
1917 : : }
1918 : :
1919 : : RTE_EXPORT_SYMBOL(rte_cryptodev_info_get)
1920 : : void
1921 : 962 : rte_cryptodev_info_get(uint8_t dev_id, struct rte_cryptodev_info *dev_info)
1922 : : {
1923 : : struct rte_cryptodev *dev;
1924 : :
1925 [ - + ]: 962 : if (!rte_cryptodev_is_valid_dev(dev_id)) {
1926 : 0 : CDEV_LOG_ERR("Invalid dev_id=%d", dev_id);
1927 : 0 : return;
1928 : : }
1929 : :
1930 [ + - ]: 962 : dev = &rte_crypto_devices[dev_id];
1931 : :
1932 : : memset(dev_info, 0, sizeof(struct rte_cryptodev_info));
1933 : :
1934 [ + - ]: 962 : if (dev->dev_ops->dev_infos_get == NULL)
1935 : : return;
1936 : 962 : dev->dev_ops->dev_infos_get(dev, dev_info);
1937 : :
1938 : 962 : dev_info->driver_name = dev->device->driver->name;
1939 [ - + ]: 962 : dev_info->device = dev->device;
1940 : :
1941 : 962 : rte_cryptodev_trace_info_get(dev_id, dev_info->driver_name);
1942 : :
1943 : : }
1944 : :
1945 : : RTE_EXPORT_SYMBOL(rte_cryptodev_callback_register)
1946 : : int
1947 : 0 : rte_cryptodev_callback_register(uint8_t dev_id,
1948 : : enum rte_cryptodev_event_type event,
1949 : : rte_cryptodev_cb_fn cb_fn, void *cb_arg)
1950 : : {
1951 : : struct rte_cryptodev *dev;
1952 : : struct rte_cryptodev_callback *user_cb;
1953 : :
1954 [ # # ]: 0 : if (!cb_fn)
1955 : : return -EINVAL;
1956 : :
1957 [ # # ]: 0 : if (!rte_cryptodev_is_valid_dev(dev_id)) {
1958 : 0 : CDEV_LOG_ERR("Invalid dev_id=%" PRIu8, dev_id);
1959 : 0 : return -EINVAL;
1960 : : }
1961 : :
1962 : : dev = &rte_crypto_devices[dev_id];
1963 : : rte_spinlock_lock(&rte_cryptodev_cb_lock);
1964 : :
1965 [ # # ]: 0 : TAILQ_FOREACH(user_cb, &(dev->link_intr_cbs), next) {
1966 [ # # ]: 0 : if (user_cb->cb_fn == cb_fn &&
1967 [ # # ]: 0 : user_cb->cb_arg == cb_arg &&
1968 [ # # ]: 0 : user_cb->event == event) {
1969 : : break;
1970 : : }
1971 : : }
1972 : :
1973 : : /* create a new callback. */
1974 [ # # ]: 0 : if (user_cb == NULL) {
1975 : 0 : user_cb = rte_zmalloc("INTR_USER_CALLBACK",
1976 : : sizeof(struct rte_cryptodev_callback), 0);
1977 [ # # ]: 0 : if (user_cb != NULL) {
1978 : 0 : user_cb->cb_fn = cb_fn;
1979 : 0 : user_cb->cb_arg = cb_arg;
1980 : 0 : user_cb->event = event;
1981 : 0 : TAILQ_INSERT_TAIL(&(dev->link_intr_cbs), user_cb, next);
1982 : : }
1983 : : }
1984 : :
1985 : : rte_spinlock_unlock(&rte_cryptodev_cb_lock);
1986 : :
1987 : 0 : rte_cryptodev_trace_callback_register(dev_id, event, cb_fn);
1988 [ # # ]: 0 : return (user_cb == NULL) ? -ENOMEM : 0;
1989 : : }
1990 : :
1991 : : RTE_EXPORT_SYMBOL(rte_cryptodev_callback_unregister)
1992 : : int
1993 : 0 : rte_cryptodev_callback_unregister(uint8_t dev_id,
1994 : : enum rte_cryptodev_event_type event,
1995 : : rte_cryptodev_cb_fn cb_fn, void *cb_arg)
1996 : : {
1997 : : int ret;
1998 : : struct rte_cryptodev *dev;
1999 : : struct rte_cryptodev_callback *cb, *next;
2000 : :
2001 [ # # ]: 0 : if (!cb_fn)
2002 : : return -EINVAL;
2003 : :
2004 [ # # ]: 0 : if (!rte_cryptodev_is_valid_dev(dev_id)) {
2005 : 0 : CDEV_LOG_ERR("Invalid dev_id=%" PRIu8, dev_id);
2006 : 0 : return -EINVAL;
2007 : : }
2008 : :
2009 : : dev = &rte_crypto_devices[dev_id];
2010 : : rte_spinlock_lock(&rte_cryptodev_cb_lock);
2011 : :
2012 : : ret = 0;
2013 [ # # ]: 0 : for (cb = TAILQ_FIRST(&dev->link_intr_cbs); cb != NULL; cb = next) {
2014 : :
2015 : 0 : next = TAILQ_NEXT(cb, next);
2016 : :
2017 [ # # # # ]: 0 : if (cb->cb_fn != cb_fn || cb->event != event ||
2018 [ # # # # ]: 0 : (cb->cb_arg != (void *)-1 &&
2019 : : cb->cb_arg != cb_arg))
2020 : 0 : continue;
2021 : :
2022 : : /*
2023 : : * if this callback is not executing right now,
2024 : : * then remove it.
2025 : : */
2026 [ # # ]: 0 : if (cb->active == 0) {
2027 [ # # ]: 0 : TAILQ_REMOVE(&(dev->link_intr_cbs), cb, next);
2028 : 0 : rte_free(cb);
2029 : : } else {
2030 : : ret = -EAGAIN;
2031 : : }
2032 : : }
2033 : :
2034 : : rte_spinlock_unlock(&rte_cryptodev_cb_lock);
2035 : :
2036 : 0 : rte_cryptodev_trace_callback_unregister(dev_id, event, cb_fn);
2037 : 0 : return ret;
2038 : : }
2039 : :
2040 : : RTE_EXPORT_INTERNAL_SYMBOL(rte_cryptodev_pmd_callback_process)
2041 : : void
2042 : 0 : rte_cryptodev_pmd_callback_process(struct rte_cryptodev *dev,
2043 : : enum rte_cryptodev_event_type event)
2044 : : {
2045 : : struct rte_cryptodev_callback *cb_lst;
2046 : : struct rte_cryptodev_callback dev_cb;
2047 : :
2048 : : rte_spinlock_lock(&rte_cryptodev_cb_lock);
2049 [ # # ]: 0 : TAILQ_FOREACH(cb_lst, &(dev->link_intr_cbs), next) {
2050 [ # # # # ]: 0 : if (cb_lst->cb_fn == NULL || cb_lst->event != event)
2051 : 0 : continue;
2052 : 0 : dev_cb = *cb_lst;
2053 : 0 : cb_lst->active = 1;
2054 : : rte_spinlock_unlock(&rte_cryptodev_cb_lock);
2055 : 0 : dev_cb.cb_fn(dev->data->dev_id, dev_cb.event,
2056 : : dev_cb.cb_arg);
2057 : : rte_spinlock_lock(&rte_cryptodev_cb_lock);
2058 : 0 : cb_lst->active = 0;
2059 : : }
2060 : : rte_spinlock_unlock(&rte_cryptodev_cb_lock);
2061 : 0 : }
2062 : :
2063 : : RTE_EXPORT_EXPERIMENTAL_SYMBOL(rte_cryptodev_queue_pair_event_error_query, 23.03)
2064 : : int
2065 : 0 : rte_cryptodev_queue_pair_event_error_query(uint8_t dev_id, uint16_t qp_id)
2066 : : {
2067 : : struct rte_cryptodev *dev;
2068 : :
2069 [ # # ]: 0 : if (!rte_cryptodev_is_valid_dev(dev_id)) {
2070 : 0 : CDEV_LOG_ERR("Invalid dev_id=%" PRIu8, dev_id);
2071 : 0 : return -EINVAL;
2072 : : }
2073 : 0 : dev = &rte_crypto_devices[dev_id];
2074 : :
2075 [ # # ]: 0 : if (qp_id >= dev->data->nb_queue_pairs)
2076 : : return -EINVAL;
2077 [ # # ]: 0 : if (dev->dev_ops->queue_pair_event_error_query == NULL)
2078 : : return -ENOTSUP;
2079 : :
2080 : 0 : return dev->dev_ops->queue_pair_event_error_query(dev, qp_id);
2081 : : }
2082 : :
2083 : : RTE_EXPORT_SYMBOL(rte_cryptodev_sym_session_pool_create)
2084 : : struct rte_mempool *
2085 : 1 : rte_cryptodev_sym_session_pool_create(const char *name, uint32_t nb_elts,
2086 : : uint32_t elt_size, uint32_t cache_size, uint16_t user_data_size,
2087 : : int socket_id)
2088 : : {
2089 : : struct rte_mempool *mp;
2090 : : struct rte_cryptodev_sym_session_pool_private_data *pool_priv;
2091 : : uint32_t obj_sz;
2092 : :
2093 : 1 : obj_sz = sizeof(struct rte_cryptodev_sym_session) + elt_size + user_data_size;
2094 : :
2095 : 1 : obj_sz = RTE_ALIGN_CEIL(obj_sz, RTE_CACHE_LINE_SIZE);
2096 : 1 : mp = rte_mempool_create(name, nb_elts, obj_sz, cache_size,
2097 : : (uint32_t)(sizeof(*pool_priv)), NULL, NULL,
2098 : : NULL, NULL,
2099 : : socket_id, 0);
2100 [ - + ]: 1 : if (mp == NULL) {
2101 : 0 : CDEV_LOG_ERR("%s(name=%s) failed, rte_errno=%d",
2102 : : __func__, name, rte_errno);
2103 : 0 : return NULL;
2104 : : }
2105 : :
2106 : : pool_priv = rte_mempool_get_priv(mp);
2107 : : if (!pool_priv) {
2108 : : CDEV_LOG_ERR("%s(name=%s) failed to get private data",
2109 : : __func__, name);
2110 : : rte_mempool_free(mp);
2111 : : return NULL;
2112 : : }
2113 : :
2114 : 1 : pool_priv->sess_data_sz = elt_size;
2115 [ - + ]: 1 : pool_priv->user_data_sz = user_data_size;
2116 : :
2117 : 1 : rte_cryptodev_trace_sym_session_pool_create(name, nb_elts,
2118 : : elt_size, cache_size, user_data_size, mp);
2119 : 1 : return mp;
2120 : : }
2121 : :
2122 : : RTE_EXPORT_SYMBOL(rte_cryptodev_asym_session_pool_create)
2123 : : struct rte_mempool *
2124 : 1 : rte_cryptodev_asym_session_pool_create(const char *name, uint32_t nb_elts,
2125 : : uint32_t cache_size, uint16_t user_data_size, int socket_id)
2126 : : {
2127 : : struct rte_mempool *mp;
2128 : : struct rte_cryptodev_asym_session_pool_private_data *pool_priv;
2129 : : uint32_t obj_sz, obj_sz_aligned;
2130 : : uint8_t dev_id;
2131 : : unsigned int priv_sz, max_priv_sz = 0;
2132 : :
2133 [ + + ]: 65 : for (dev_id = 0; dev_id < RTE_CRYPTO_MAX_DEVS; dev_id++)
2134 [ + + ]: 64 : if (rte_cryptodev_is_valid_dev(dev_id)) {
2135 : 1 : priv_sz = rte_cryptodev_asym_get_private_session_size(dev_id);
2136 : : if (priv_sz > max_priv_sz)
2137 : : max_priv_sz = priv_sz;
2138 : : }
2139 [ - + ]: 1 : if (max_priv_sz == 0) {
2140 : 0 : CDEV_LOG_INFO("Could not set max private session size");
2141 : 0 : return NULL;
2142 : : }
2143 : :
2144 : 1 : obj_sz = rte_cryptodev_asym_get_header_session_size() + max_priv_sz +
2145 : : user_data_size;
2146 : 1 : obj_sz_aligned = RTE_ALIGN_CEIL(obj_sz, RTE_CACHE_LINE_SIZE);
2147 : :
2148 : 1 : mp = rte_mempool_create(name, nb_elts, obj_sz_aligned, cache_size,
2149 : : (uint32_t)(sizeof(*pool_priv)),
2150 : : NULL, NULL, NULL, NULL,
2151 : : socket_id, 0);
2152 [ - + ]: 1 : if (mp == NULL) {
2153 : 0 : CDEV_LOG_ERR("%s(name=%s) failed, rte_errno=%d",
2154 : : __func__, name, rte_errno);
2155 : 0 : return NULL;
2156 : : }
2157 : :
2158 : : pool_priv = rte_mempool_get_priv(mp);
2159 : : if (!pool_priv) {
2160 : : CDEV_LOG_ERR("%s(name=%s) failed to get private data",
2161 : : __func__, name);
2162 : : rte_mempool_free(mp);
2163 : : return NULL;
2164 : : }
2165 : 1 : pool_priv->max_priv_session_sz = max_priv_sz;
2166 [ - + ]: 1 : pool_priv->user_data_sz = user_data_size;
2167 : :
2168 : 1 : rte_cryptodev_trace_asym_session_pool_create(name, nb_elts,
2169 : : user_data_size, cache_size, mp);
2170 : 1 : return mp;
2171 : : }
2172 : :
2173 : : RTE_EXPORT_SYMBOL(rte_cryptodev_sym_session_create)
2174 : : void *
2175 : 236 : rte_cryptodev_sym_session_create(uint8_t dev_id,
2176 : : struct rte_crypto_sym_xform *xforms,
2177 : : struct rte_mempool *mp)
2178 : : {
2179 : : struct rte_cryptodev *dev;
2180 : : struct rte_cryptodev_sym_session *sess;
2181 : : struct rte_cryptodev_sym_session_pool_private_data *pool_priv;
2182 : : uint32_t sess_priv_sz;
2183 : : int ret;
2184 : :
2185 [ - + ]: 236 : if (!rte_cryptodev_is_valid_dev(dev_id)) {
2186 : 0 : CDEV_LOG_ERR("Invalid dev_id=%" PRIu8, dev_id);
2187 : 0 : rte_errno = EINVAL;
2188 : 0 : return NULL;
2189 : : }
2190 : :
2191 [ - + ]: 236 : if (xforms == NULL) {
2192 : 0 : CDEV_LOG_ERR("Invalid xform");
2193 : 0 : rte_errno = EINVAL;
2194 : 0 : return NULL;
2195 : : }
2196 : :
2197 : 236 : sess_priv_sz = rte_cryptodev_sym_get_private_session_size(dev_id);
2198 : : if (!rte_cryptodev_sym_is_valid_session_pool(mp, sess_priv_sz)) {
2199 : 0 : CDEV_LOG_ERR("Invalid mempool");
2200 : 0 : rte_errno = EINVAL;
2201 : 0 : return NULL;
2202 : : }
2203 : :
2204 : 236 : dev = rte_cryptodev_pmd_get_dev(dev_id);
2205 : :
2206 : : /* Allocate a session structure from the session pool */
2207 [ - + ]: 236 : if (rte_mempool_get(mp, (void **)&sess)) {
2208 : 0 : CDEV_LOG_ERR("couldn't get object from session mempool");
2209 : 0 : rte_errno = ENOMEM;
2210 : 0 : return NULL;
2211 : : }
2212 : :
2213 : : pool_priv = rte_mempool_get_priv(mp);
2214 : 236 : sess->driver_id = dev->driver_id;
2215 : 236 : sess->sess_data_sz = pool_priv->sess_data_sz;
2216 [ - + ]: 236 : sess->user_data_sz = pool_priv->user_data_sz;
2217 : 236 : sess->driver_priv_data_iova = rte_mempool_virt2iova(sess) +
2218 : : offsetof(struct rte_cryptodev_sym_session, driver_priv_data);
2219 : :
2220 [ - + ]: 236 : if (dev->dev_ops->sym_session_configure == NULL) {
2221 : 0 : rte_errno = ENOTSUP;
2222 : 0 : goto error_exit;
2223 : : }
2224 : 236 : memset(sess->driver_priv_data, 0, pool_priv->sess_data_sz + pool_priv->user_data_sz);
2225 : :
2226 : 236 : ret = dev->dev_ops->sym_session_configure(dev, xforms, sess);
2227 [ - + ]: 236 : if (ret < 0) {
2228 : 0 : rte_errno = -ret;
2229 : 0 : goto error_exit;
2230 : : }
2231 [ - + ]: 236 : sess->driver_id = dev->driver_id;
2232 : :
2233 : 236 : rte_cryptodev_trace_sym_session_create(dev_id, sess, xforms, mp);
2234 : :
2235 : 236 : return (void *)sess;
2236 : 0 : error_exit:
2237 [ # # ]: 0 : rte_mempool_put(mp, (void *)sess);
2238 : 0 : return NULL;
2239 : : }
2240 : :
2241 : : RTE_EXPORT_SYMBOL(rte_cryptodev_asym_session_create)
2242 : : int
2243 : 42 : rte_cryptodev_asym_session_create(uint8_t dev_id,
2244 : : struct rte_crypto_asym_xform *xforms, struct rte_mempool *mp,
2245 : : void **session)
2246 : : {
2247 : : struct rte_cryptodev_asym_session *sess;
2248 : : uint32_t session_priv_data_sz;
2249 : : struct rte_cryptodev_asym_session_pool_private_data *pool_priv;
2250 : : unsigned int session_header_size =
2251 : 42 : rte_cryptodev_asym_get_header_session_size();
2252 : : struct rte_cryptodev *dev;
2253 : : int ret;
2254 : :
2255 [ - + ]: 42 : if (!rte_cryptodev_is_valid_dev(dev_id)) {
2256 : 0 : CDEV_LOG_ERR("Invalid dev_id=%" PRIu8, dev_id);
2257 : 0 : return -EINVAL;
2258 : : }
2259 : :
2260 : 42 : dev = rte_cryptodev_pmd_get_dev(dev_id);
2261 : :
2262 [ + - ]: 42 : if (dev == NULL)
2263 : : return -EINVAL;
2264 : :
2265 [ - + ]: 42 : if (!mp) {
2266 : 0 : CDEV_LOG_ERR("invalid mempool");
2267 : 0 : return -EINVAL;
2268 : : }
2269 : :
2270 : 42 : session_priv_data_sz = rte_cryptodev_asym_get_private_session_size(
2271 : : dev_id);
2272 : : pool_priv = rte_mempool_get_priv(mp);
2273 : :
2274 [ - + ]: 42 : if (pool_priv->max_priv_session_sz < session_priv_data_sz) {
2275 : 0 : CDEV_LOG_DEBUG(
2276 : : "The private session data size used when creating the mempool is smaller than this device's private session data.");
2277 : 0 : return -EINVAL;
2278 : : }
2279 : :
2280 : : /* Verify if provided mempool can hold elements big enough. */
2281 [ - + ]: 42 : if (mp->elt_size < session_header_size + session_priv_data_sz) {
2282 : 0 : CDEV_LOG_ERR(
2283 : : "mempool elements too small to hold session objects");
2284 : 0 : return -EINVAL;
2285 : : }
2286 : :
2287 : : /* Allocate a session structure from the session pool */
2288 [ - + ]: 42 : if (rte_mempool_get(mp, session)) {
2289 : 0 : CDEV_LOG_ERR("couldn't get object from session mempool");
2290 : 0 : return -ENOMEM;
2291 : : }
2292 : :
2293 : 42 : sess = *session;
2294 : 42 : sess->driver_id = dev->driver_id;
2295 : 42 : sess->user_data_sz = pool_priv->user_data_sz;
2296 : 42 : sess->max_priv_data_sz = pool_priv->max_priv_session_sz;
2297 : :
2298 : : /* Clear device session pointer.*/
2299 [ + - ]: 42 : memset(sess->sess_private_data, 0, session_priv_data_sz + sess->user_data_sz);
2300 : :
2301 [ + - ]: 42 : if (dev->dev_ops->asym_session_configure == NULL)
2302 : : return -ENOTSUP;
2303 : :
2304 [ + - ]: 42 : if (sess->sess_private_data[0] == 0) {
2305 : 42 : ret = dev->dev_ops->asym_session_configure(dev, xforms, sess);
2306 [ + + ]: 42 : if (ret < 0) {
2307 : 18 : CDEV_LOG_ERR(
2308 : : "dev_id %d failed to configure session details",
2309 : : dev_id);
2310 : 18 : return ret;
2311 : : }
2312 : : }
2313 : :
2314 : 24 : rte_cryptodev_trace_asym_session_create(dev_id, xforms, mp, sess);
2315 : 24 : return 0;
2316 : : }
2317 : :
2318 : : RTE_EXPORT_SYMBOL(rte_cryptodev_sym_session_free)
2319 : : int
2320 : 236 : rte_cryptodev_sym_session_free(uint8_t dev_id, void *_sess)
2321 : : {
2322 : : struct rte_cryptodev *dev;
2323 : : struct rte_mempool *sess_mp;
2324 : : struct rte_cryptodev_sym_session *sess = _sess;
2325 : : struct rte_cryptodev_sym_session_pool_private_data *pool_priv;
2326 : :
2327 [ + - ]: 236 : if (sess == NULL)
2328 : : return -EINVAL;
2329 : :
2330 [ - + ]: 236 : if (!rte_cryptodev_is_valid_dev(dev_id)) {
2331 : 0 : CDEV_LOG_ERR("Invalid dev_id=%" PRIu8, dev_id);
2332 : 0 : return -EINVAL;
2333 : : }
2334 : :
2335 : 236 : dev = rte_cryptodev_pmd_get_dev(dev_id);
2336 : :
2337 [ + - ]: 236 : if (dev == NULL || sess == NULL)
2338 : : return -EINVAL;
2339 : :
2340 : : sess_mp = rte_mempool_from_obj(sess);
2341 [ + - ]: 236 : if (!sess_mp)
2342 : : return -EINVAL;
2343 : : pool_priv = rte_mempool_get_priv(sess_mp);
2344 : :
2345 [ - + ]: 236 : if (sess->driver_id != dev->driver_id) {
2346 : 0 : CDEV_LOG_ERR("Session created by driver %u but freed by %u",
2347 : : sess->driver_id, dev->driver_id);
2348 : 0 : return -EINVAL;
2349 : : }
2350 : :
2351 [ + - ]: 236 : if (dev->dev_ops->sym_session_clear == NULL)
2352 : : return -ENOTSUP;
2353 : :
2354 : 236 : dev->dev_ops->sym_session_clear(dev, sess);
2355 : :
2356 [ - + ]: 236 : memset(sess->driver_priv_data, 0, pool_priv->sess_data_sz + pool_priv->user_data_sz);
2357 : :
2358 : : /* Return session to mempool */
2359 [ - + ]: 236 : rte_mempool_put(sess_mp, sess);
2360 : :
2361 : 236 : rte_cryptodev_trace_sym_session_free(dev_id, sess);
2362 : 236 : return 0;
2363 : : }
2364 : :
2365 : : RTE_EXPORT_SYMBOL(rte_cryptodev_asym_session_free)
2366 : : int
2367 : 42 : rte_cryptodev_asym_session_free(uint8_t dev_id, void *sess)
2368 : : {
2369 : : struct rte_mempool *sess_mp;
2370 : : struct rte_cryptodev *dev;
2371 : :
2372 [ - + ]: 42 : if (!rte_cryptodev_is_valid_dev(dev_id)) {
2373 : 0 : CDEV_LOG_ERR("Invalid dev_id=%" PRIu8, dev_id);
2374 : 0 : return -EINVAL;
2375 : : }
2376 : :
2377 : 42 : dev = rte_cryptodev_pmd_get_dev(dev_id);
2378 : :
2379 [ + - ]: 42 : if (dev == NULL || sess == NULL)
2380 : : return -EINVAL;
2381 : :
2382 [ + - ]: 42 : if (dev->dev_ops->asym_session_clear == NULL)
2383 : : return -ENOTSUP;
2384 : :
2385 : 42 : dev->dev_ops->asym_session_clear(dev, sess);
2386 : :
2387 : 42 : rte_free(((struct rte_cryptodev_asym_session *)sess)->event_mdata);
2388 : :
2389 : : /* Return session to mempool */
2390 : : sess_mp = rte_mempool_from_obj(sess);
2391 [ - + ]: 42 : rte_mempool_put(sess_mp, sess);
2392 : :
2393 : 42 : rte_cryptodev_trace_asym_session_free(dev_id, sess);
2394 : 42 : return 0;
2395 : : }
2396 : :
2397 : : RTE_EXPORT_SYMBOL(rte_cryptodev_asym_get_header_session_size)
2398 : : unsigned int
2399 : 43 : rte_cryptodev_asym_get_header_session_size(void)
2400 : : {
2401 : 43 : return sizeof(struct rte_cryptodev_asym_session);
2402 : : }
2403 : :
2404 : : RTE_EXPORT_SYMBOL(rte_cryptodev_sym_get_private_session_size)
2405 : : unsigned int
2406 : 3742 : rte_cryptodev_sym_get_private_session_size(uint8_t dev_id)
2407 : : {
2408 : : struct rte_cryptodev *dev;
2409 : : unsigned int priv_sess_size;
2410 : :
2411 [ + - ]: 3742 : if (!rte_cryptodev_is_valid_dev(dev_id))
2412 : : return 0;
2413 : :
2414 : 3742 : dev = rte_cryptodev_pmd_get_dev(dev_id);
2415 : :
2416 [ + - ]: 3742 : if (dev->dev_ops->sym_session_get_size == NULL)
2417 : : return 0;
2418 : :
2419 : 3742 : priv_sess_size = dev->dev_ops->sym_session_get_size(dev);
2420 : :
2421 : 3742 : rte_cryptodev_trace_sym_get_private_session_size(dev_id,
2422 : : priv_sess_size);
2423 : :
2424 : 3742 : return priv_sess_size;
2425 : : }
2426 : :
2427 : : RTE_EXPORT_SYMBOL(rte_cryptodev_asym_get_private_session_size)
2428 : : unsigned int
2429 : 43 : rte_cryptodev_asym_get_private_session_size(uint8_t dev_id)
2430 : : {
2431 : : struct rte_cryptodev *dev;
2432 : : unsigned int priv_sess_size;
2433 : :
2434 [ + - ]: 43 : if (!rte_cryptodev_is_valid_dev(dev_id))
2435 : : return 0;
2436 : :
2437 : 43 : dev = rte_cryptodev_pmd_get_dev(dev_id);
2438 : :
2439 [ + - ]: 43 : if (dev->dev_ops->asym_session_get_size == NULL)
2440 : : return 0;
2441 : :
2442 : 43 : priv_sess_size = dev->dev_ops->asym_session_get_size(dev);
2443 : :
2444 : 43 : rte_cryptodev_trace_asym_get_private_session_size(dev_id,
2445 : : priv_sess_size);
2446 : :
2447 : 43 : return priv_sess_size;
2448 : : }
2449 : :
2450 : : RTE_EXPORT_SYMBOL(rte_cryptodev_sym_session_set_user_data)
2451 : : int
2452 : 0 : rte_cryptodev_sym_session_set_user_data(void *_sess, void *data,
2453 : : uint16_t size)
2454 : : {
2455 : : struct rte_cryptodev_sym_session *sess = _sess;
2456 : :
2457 [ # # ]: 0 : if (sess == NULL)
2458 : : return -EINVAL;
2459 : :
2460 [ # # ]: 0 : if (sess->user_data_sz < size)
2461 : : return -ENOMEM;
2462 : :
2463 [ # # ]: 0 : rte_memcpy(sess->driver_priv_data + sess->sess_data_sz, data, size);
2464 : :
2465 : 0 : rte_cryptodev_trace_sym_session_set_user_data(sess, data, size);
2466 : :
2467 : 0 : return 0;
2468 : : }
2469 : :
2470 : : RTE_EXPORT_SYMBOL(rte_cryptodev_sym_session_get_user_data)
2471 : : void *
2472 : 0 : rte_cryptodev_sym_session_get_user_data(void *_sess)
2473 : : {
2474 : : struct rte_cryptodev_sym_session *sess = _sess;
2475 : : void *data = NULL;
2476 : :
2477 [ # # # # ]: 0 : if (sess == NULL || sess->user_data_sz == 0)
2478 : : return NULL;
2479 : :
2480 [ # # ]: 0 : data = (void *)(sess->driver_priv_data + sess->sess_data_sz);
2481 : :
2482 : 0 : rte_cryptodev_trace_sym_session_get_user_data(sess, data);
2483 : :
2484 : 0 : return data;
2485 : : }
2486 : :
2487 : : RTE_EXPORT_SYMBOL(rte_cryptodev_asym_session_set_user_data)
2488 : : int
2489 : 0 : rte_cryptodev_asym_session_set_user_data(void *session, void *data, uint16_t size)
2490 : : {
2491 : : struct rte_cryptodev_asym_session *sess = session;
2492 [ # # ]: 0 : if (sess == NULL)
2493 : : return -EINVAL;
2494 : :
2495 [ # # ]: 0 : if (sess->user_data_sz < size)
2496 : : return -ENOMEM;
2497 : :
2498 : 0 : rte_memcpy(sess->sess_private_data +
2499 [ # # ]: 0 : sess->max_priv_data_sz,
2500 : : data, size);
2501 : :
2502 : 0 : rte_cryptodev_trace_asym_session_set_user_data(sess, data, size);
2503 : :
2504 : 0 : return 0;
2505 : : }
2506 : :
2507 : : RTE_EXPORT_SYMBOL(rte_cryptodev_asym_session_get_user_data)
2508 : : void *
2509 : 0 : rte_cryptodev_asym_session_get_user_data(void *session)
2510 : : {
2511 : : struct rte_cryptodev_asym_session *sess = session;
2512 : : void *data = NULL;
2513 : :
2514 [ # # # # ]: 0 : if (sess == NULL || sess->user_data_sz == 0)
2515 : : return NULL;
2516 : :
2517 [ # # ]: 0 : data = (void *)(sess->sess_private_data + sess->max_priv_data_sz);
2518 : :
2519 : 0 : rte_cryptodev_trace_asym_session_get_user_data(sess, data);
2520 : :
2521 : 0 : return data;
2522 : : }
2523 : :
2524 : : static inline void
2525 : : sym_crypto_fill_status(struct rte_crypto_sym_vec *vec, int32_t errnum)
2526 : : {
2527 : : uint32_t i;
2528 [ # # # # ]: 0 : for (i = 0; i < vec->num; i++)
2529 : 0 : vec->status[i] = errnum;
2530 : : }
2531 : :
2532 : : RTE_EXPORT_SYMBOL(rte_cryptodev_sym_cpu_crypto_process)
2533 : : uint32_t
2534 : 0 : rte_cryptodev_sym_cpu_crypto_process(uint8_t dev_id,
2535 : : void *_sess, union rte_crypto_sym_ofs ofs,
2536 : : struct rte_crypto_sym_vec *vec)
2537 : : {
2538 : : struct rte_cryptodev *dev;
2539 : : struct rte_cryptodev_sym_session *sess = _sess;
2540 : :
2541 [ # # ]: 0 : if (!rte_cryptodev_is_valid_dev(dev_id)) {
2542 : : sym_crypto_fill_status(vec, EINVAL);
2543 : : return 0;
2544 : : }
2545 : :
2546 : 0 : dev = rte_cryptodev_pmd_get_dev(dev_id);
2547 : :
2548 [ # # ]: 0 : if (dev->dev_ops->sym_cpu_process == NULL ||
2549 [ # # ]: 0 : !(dev->feature_flags & RTE_CRYPTODEV_FF_SYM_CPU_CRYPTO)) {
2550 : : sym_crypto_fill_status(vec, ENOTSUP);
2551 : : return 0;
2552 : : }
2553 : :
2554 : 0 : rte_cryptodev_trace_sym_cpu_crypto_process(dev_id, sess);
2555 : :
2556 : 0 : return dev->dev_ops->sym_cpu_process(dev, sess, ofs, vec);
2557 : : }
2558 : :
2559 : : RTE_EXPORT_SYMBOL(rte_cryptodev_get_raw_dp_ctx_size)
2560 : : int
2561 : 0 : rte_cryptodev_get_raw_dp_ctx_size(uint8_t dev_id)
2562 : : {
2563 : : struct rte_cryptodev *dev;
2564 : : int32_t size = sizeof(struct rte_crypto_raw_dp_ctx);
2565 : : int32_t priv_size;
2566 : :
2567 [ # # ]: 0 : if (!rte_cryptodev_is_valid_dev(dev_id))
2568 : : return -EINVAL;
2569 : :
2570 : 0 : dev = rte_cryptodev_pmd_get_dev(dev_id);
2571 : :
2572 [ # # ]: 0 : if (dev->dev_ops->sym_get_raw_dp_ctx_size == NULL ||
2573 [ # # ]: 0 : !(dev->feature_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP)) {
2574 : : return -ENOTSUP;
2575 : : }
2576 : :
2577 : 0 : priv_size = dev->dev_ops->sym_get_raw_dp_ctx_size(dev);
2578 [ # # ]: 0 : if (priv_size < 0)
2579 : : return -ENOTSUP;
2580 : :
2581 : 0 : rte_cryptodev_trace_get_raw_dp_ctx_size(dev_id);
2582 : :
2583 : 0 : return RTE_ALIGN_CEIL((size + priv_size), 8);
2584 : : }
2585 : :
2586 : : RTE_EXPORT_SYMBOL(rte_cryptodev_configure_raw_dp_ctx)
2587 : : int
2588 : 0 : rte_cryptodev_configure_raw_dp_ctx(uint8_t dev_id, uint16_t qp_id,
2589 : : struct rte_crypto_raw_dp_ctx *ctx,
2590 : : enum rte_crypto_op_sess_type sess_type,
2591 : : union rte_cryptodev_session_ctx session_ctx,
2592 : : uint8_t is_update)
2593 : : {
2594 : : struct rte_cryptodev *dev;
2595 : :
2596 [ # # ]: 0 : if (!rte_cryptodev_get_qp_status(dev_id, qp_id))
2597 : : return -EINVAL;
2598 : :
2599 : 0 : dev = rte_cryptodev_pmd_get_dev(dev_id);
2600 [ # # ]: 0 : if (!(dev->feature_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP)
2601 [ # # ]: 0 : || dev->dev_ops->sym_configure_raw_dp_ctx == NULL)
2602 : : return -ENOTSUP;
2603 : :
2604 [ # # ]: 0 : rte_cryptodev_trace_configure_raw_dp_ctx(dev_id, qp_id, sess_type);
2605 : :
2606 : 0 : return dev->dev_ops->sym_configure_raw_dp_ctx(dev, qp_id, ctx,
2607 : : sess_type, session_ctx, is_update);
2608 : : }
2609 : :
2610 : : RTE_EXPORT_SYMBOL(rte_cryptodev_session_event_mdata_set)
2611 : : int
2612 : 0 : rte_cryptodev_session_event_mdata_set(uint8_t dev_id, void *sess,
2613 : : enum rte_crypto_op_type op_type,
2614 : : enum rte_crypto_op_sess_type sess_type,
2615 : : void *ev_mdata,
2616 : : uint16_t size)
2617 : : {
2618 : : struct rte_cryptodev *dev;
2619 : :
2620 [ # # ]: 0 : if (sess == NULL || ev_mdata == NULL)
2621 : : return -EINVAL;
2622 : :
2623 [ # # ]: 0 : if (!rte_cryptodev_is_valid_dev(dev_id))
2624 : 0 : goto skip_pmd_op;
2625 : :
2626 : 0 : dev = rte_cryptodev_pmd_get_dev(dev_id);
2627 [ # # ]: 0 : if (dev->dev_ops->session_ev_mdata_set == NULL)
2628 : 0 : goto skip_pmd_op;
2629 : :
2630 [ # # ]: 0 : rte_cryptodev_trace_session_event_mdata_set(dev_id, sess, op_type,
2631 : : sess_type, ev_mdata, size);
2632 : :
2633 : 0 : return dev->dev_ops->session_ev_mdata_set(dev, sess, op_type, sess_type, ev_mdata);
2634 : :
2635 : 0 : skip_pmd_op:
2636 [ # # ]: 0 : if (op_type == RTE_CRYPTO_OP_TYPE_SYMMETRIC)
2637 : 0 : return rte_cryptodev_sym_session_set_user_data(sess, ev_mdata,
2638 : : size);
2639 [ # # ]: 0 : else if (op_type == RTE_CRYPTO_OP_TYPE_ASYMMETRIC) {
2640 : : struct rte_cryptodev_asym_session *s = sess;
2641 : :
2642 [ # # ]: 0 : if (s->event_mdata == NULL) {
2643 : 0 : s->event_mdata = rte_malloc(NULL, size, 0);
2644 [ # # ]: 0 : if (s->event_mdata == NULL)
2645 : : return -ENOMEM;
2646 : : }
2647 [ # # ]: 0 : rte_memcpy(s->event_mdata, ev_mdata, size);
2648 : :
2649 : 0 : return 0;
2650 : : } else
2651 : : return -ENOTSUP;
2652 : : }
2653 : :
2654 : : RTE_EXPORT_SYMBOL(rte_cryptodev_raw_enqueue_burst)
2655 : : uint32_t
2656 : 0 : rte_cryptodev_raw_enqueue_burst(struct rte_crypto_raw_dp_ctx *ctx,
2657 : : struct rte_crypto_sym_vec *vec, union rte_crypto_sym_ofs ofs,
2658 : : void **user_data, int *enqueue_status)
2659 : : {
2660 : 0 : return ctx->enqueue_burst(ctx->qp_data, ctx->drv_ctx_data, vec,
2661 : : ofs, user_data, enqueue_status);
2662 : : }
2663 : :
2664 : : RTE_EXPORT_SYMBOL(rte_cryptodev_raw_enqueue_done)
2665 : : int
2666 : 0 : rte_cryptodev_raw_enqueue_done(struct rte_crypto_raw_dp_ctx *ctx,
2667 : : uint32_t n)
2668 : : {
2669 : 0 : return ctx->enqueue_done(ctx->qp_data, ctx->drv_ctx_data, n);
2670 : : }
2671 : :
2672 : : RTE_EXPORT_SYMBOL(rte_cryptodev_raw_dequeue_burst)
2673 : : uint32_t
2674 : 0 : rte_cryptodev_raw_dequeue_burst(struct rte_crypto_raw_dp_ctx *ctx,
2675 : : rte_cryptodev_raw_get_dequeue_count_t get_dequeue_count,
2676 : : uint32_t max_nb_to_dequeue,
2677 : : rte_cryptodev_raw_post_dequeue_t post_dequeue,
2678 : : void **out_user_data, uint8_t is_user_data_array,
2679 : : uint32_t *n_success_jobs, int *status)
2680 : : {
2681 : 0 : return ctx->dequeue_burst(ctx->qp_data, ctx->drv_ctx_data,
2682 : : get_dequeue_count, max_nb_to_dequeue, post_dequeue,
2683 : : out_user_data, is_user_data_array, n_success_jobs, status);
2684 : : }
2685 : :
2686 : : RTE_EXPORT_SYMBOL(rte_cryptodev_raw_dequeue_done)
2687 : : int
2688 : 0 : rte_cryptodev_raw_dequeue_done(struct rte_crypto_raw_dp_ctx *ctx,
2689 : : uint32_t n)
2690 : : {
2691 : 0 : return ctx->dequeue_done(ctx->qp_data, ctx->drv_ctx_data, n);
2692 : : }
2693 : :
2694 : : /** Initialise rte_crypto_op mempool element */
2695 : : static void
2696 : 8201 : rte_crypto_op_init(struct rte_mempool *mempool,
2697 : : void *opaque_arg,
2698 : : void *_op_data,
2699 : : __rte_unused unsigned i)
2700 : : {
2701 : : struct rte_crypto_op *op = _op_data;
2702 : 8201 : enum rte_crypto_op_type type = *(enum rte_crypto_op_type *)opaque_arg;
2703 : :
2704 : 8201 : memset(_op_data, 0, mempool->elt_size);
2705 : :
2706 : 8201 : __rte_crypto_op_reset(op, type);
2707 : :
2708 : 8201 : op->phys_addr = rte_mempool_virt2iova(_op_data);
2709 : 8201 : op->mempool = mempool;
2710 : 8201 : }
2711 : :
2712 : :
2713 : : RTE_EXPORT_SYMBOL(rte_crypto_op_pool_create)
2714 : : struct rte_mempool *
2715 : 2 : rte_crypto_op_pool_create(const char *name, enum rte_crypto_op_type type,
2716 : : unsigned nb_elts, unsigned cache_size, uint16_t priv_size,
2717 : : int socket_id)
2718 : : {
2719 : : struct rte_crypto_op_pool_private *priv;
2720 : :
2721 : 2 : unsigned elt_size = sizeof(struct rte_crypto_op) +
2722 : : priv_size;
2723 : :
2724 [ + + ]: 2 : if (type == RTE_CRYPTO_OP_TYPE_SYMMETRIC) {
2725 : 1 : elt_size += sizeof(struct rte_crypto_sym_op);
2726 [ + - ]: 1 : } else if (type == RTE_CRYPTO_OP_TYPE_ASYMMETRIC) {
2727 : 1 : elt_size += sizeof(struct rte_crypto_asym_op);
2728 [ # # ]: 0 : } else if (type == RTE_CRYPTO_OP_TYPE_UNDEFINED) {
2729 : 0 : elt_size += RTE_MAX(sizeof(struct rte_crypto_sym_op),
2730 : : sizeof(struct rte_crypto_asym_op));
2731 : : } else {
2732 : 0 : CDEV_LOG_ERR("Invalid op_type");
2733 : 0 : return NULL;
2734 : : }
2735 : :
2736 : : /* lookup mempool in case already allocated */
2737 : 2 : struct rte_mempool *mp = rte_mempool_lookup(name);
2738 : :
2739 [ - + ]: 2 : if (mp != NULL) {
2740 : : priv = (struct rte_crypto_op_pool_private *)
2741 : : rte_mempool_get_priv(mp);
2742 : :
2743 [ # # # # ]: 0 : if (mp->elt_size != elt_size ||
2744 : 0 : mp->cache_size < cache_size ||
2745 [ # # ]: 0 : mp->size < nb_elts ||
2746 [ # # ]: 0 : priv->priv_size < priv_size) {
2747 : : mp = NULL;
2748 : 0 : CDEV_LOG_ERR("Mempool %s already exists but with "
2749 : : "incompatible parameters", name);
2750 : 0 : return NULL;
2751 : : }
2752 : : return mp;
2753 : : }
2754 : :
2755 : 2 : mp = rte_mempool_create(
2756 : : name,
2757 : : nb_elts,
2758 : : elt_size,
2759 : : cache_size,
2760 : : sizeof(struct rte_crypto_op_pool_private),
2761 : : NULL,
2762 : : NULL,
2763 : : rte_crypto_op_init,
2764 : : &type,
2765 : : socket_id,
2766 : : 0);
2767 : :
2768 [ - + ]: 2 : if (mp == NULL) {
2769 : 0 : CDEV_LOG_ERR("Failed to create mempool %s", name);
2770 : 0 : return NULL;
2771 : : }
2772 : :
2773 : : priv = (struct rte_crypto_op_pool_private *)
2774 : : rte_mempool_get_priv(mp);
2775 : :
2776 : 2 : priv->priv_size = priv_size;
2777 : 2 : priv->type = type;
2778 : :
2779 [ - + ]: 2 : rte_cryptodev_trace_op_pool_create(name, socket_id, type, nb_elts, mp);
2780 : 2 : return mp;
2781 : : }
2782 : :
2783 : : RTE_EXPORT_INTERNAL_SYMBOL(rte_cryptodev_pmd_create_dev_name)
2784 : : int
2785 : 0 : rte_cryptodev_pmd_create_dev_name(char *name, const char *dev_name_prefix)
2786 : : {
2787 : : struct rte_cryptodev *dev = NULL;
2788 : : uint32_t i = 0;
2789 : :
2790 [ # # ]: 0 : if (name == NULL)
2791 : : return -EINVAL;
2792 : :
2793 [ # # ]: 0 : for (i = 0; i < RTE_CRYPTO_MAX_DEVS; i++) {
2794 : : int ret = snprintf(name, RTE_CRYPTODEV_NAME_MAX_LEN,
2795 : : "%s_%u", dev_name_prefix, i);
2796 : :
2797 [ # # ]: 0 : if (ret < 0)
2798 : 0 : return ret;
2799 : :
2800 : 0 : dev = rte_cryptodev_pmd_get_named_dev(name);
2801 [ # # ]: 0 : if (!dev)
2802 : : return 0;
2803 : : }
2804 : :
2805 : : return -1;
2806 : : }
2807 : :
2808 : : TAILQ_HEAD(cryptodev_driver_list, cryptodev_driver);
2809 : :
2810 : : static struct cryptodev_driver_list cryptodev_driver_list =
2811 : : TAILQ_HEAD_INITIALIZER(cryptodev_driver_list);
2812 : :
2813 : : RTE_EXPORT_SYMBOL(rte_cryptodev_driver_id_get)
2814 : : int
2815 : 7 : rte_cryptodev_driver_id_get(const char *name)
2816 : : {
2817 : : struct cryptodev_driver *driver;
2818 : : const char *driver_name;
2819 : : int driver_id = -1;
2820 : :
2821 [ - + ]: 7 : if (name == NULL) {
2822 : 0 : CDEV_LOG_DEBUG("name pointer NULL");
2823 : 0 : return -1;
2824 : : }
2825 : :
2826 [ + + ]: 113 : TAILQ_FOREACH(driver, &cryptodev_driver_list, next) {
2827 : 111 : driver_name = driver->driver->name;
2828 [ + + ]: 111 : if (strncmp(driver_name, name, strlen(driver_name) + 1) == 0) {
2829 : 5 : driver_id = driver->id;
2830 : 5 : break;
2831 : : }
2832 : : }
2833 : :
2834 : 7 : rte_cryptodev_trace_driver_id_get(name, driver_id);
2835 : :
2836 : 7 : return driver_id;
2837 : : }
2838 : :
2839 : : RTE_EXPORT_SYMBOL(rte_cryptodev_name_get)
2840 : : const char *
2841 : 0 : rte_cryptodev_name_get(uint8_t dev_id)
2842 : : {
2843 : : struct rte_cryptodev *dev;
2844 : :
2845 [ # # ]: 0 : if (!rte_cryptodev_is_valid_device_data(dev_id)) {
2846 : 0 : CDEV_LOG_ERR("Invalid dev_id=%" PRIu8, dev_id);
2847 : 0 : return NULL;
2848 : : }
2849 : :
2850 : 0 : dev = rte_cryptodev_pmd_get_dev(dev_id);
2851 [ # # ]: 0 : if (dev == NULL)
2852 : : return NULL;
2853 : :
2854 [ # # ]: 0 : rte_cryptodev_trace_name_get(dev_id, dev->data->name);
2855 : :
2856 : 0 : return dev->data->name;
2857 : : }
2858 : :
2859 : : RTE_EXPORT_SYMBOL(rte_cryptodev_driver_name_get)
2860 : : const char *
2861 : 1 : rte_cryptodev_driver_name_get(uint8_t driver_id)
2862 : : {
2863 : : struct cryptodev_driver *driver;
2864 : :
2865 [ + - ]: 15 : TAILQ_FOREACH(driver, &cryptodev_driver_list, next) {
2866 [ + + ]: 15 : if (driver->id == driver_id) {
2867 : 1 : rte_cryptodev_trace_driver_name_get(driver_id,
2868 [ - + ]: 1 : driver->driver->name);
2869 : 1 : return driver->driver->name;
2870 : : }
2871 : : }
2872 : : return NULL;
2873 : : }
2874 : :
2875 : : RTE_EXPORT_INTERNAL_SYMBOL(rte_cryptodev_allocate_driver)
2876 : : uint8_t
2877 : 4536 : rte_cryptodev_allocate_driver(struct cryptodev_driver *crypto_drv,
2878 : : const struct rte_driver *drv)
2879 : : {
2880 : 4536 : crypto_drv->driver = drv;
2881 : 4536 : crypto_drv->id = nb_drivers;
2882 : :
2883 : 4536 : TAILQ_INSERT_TAIL(&cryptodev_driver_list, crypto_drv, next);
2884 : :
2885 [ - + ]: 4536 : rte_cryptodev_trace_allocate_driver(drv->name);
2886 : :
2887 : 4536 : return nb_drivers++;
2888 : : }
2889 : :
2890 : 252 : RTE_INIT(cryptodev_init_fp_ops)
2891 : : {
2892 : : uint32_t i;
2893 : :
2894 [ + + ]: 16380 : for (i = 0; i != RTE_DIM(rte_crypto_fp_ops); i++)
2895 : 16128 : cryptodev_fp_ops_reset(rte_crypto_fp_ops + i);
2896 : 252 : }
2897 : :
2898 : : static int
2899 : 0 : cryptodev_handle_dev_list(const char *cmd __rte_unused,
2900 : : const char *params __rte_unused,
2901 : : struct rte_tel_data *d)
2902 : : {
2903 : : int dev_id;
2904 : :
2905 [ # # ]: 0 : if (rte_cryptodev_count() < 1)
2906 : : return -EINVAL;
2907 : :
2908 : 0 : rte_tel_data_start_array(d, RTE_TEL_INT_VAL);
2909 [ # # ]: 0 : for (dev_id = 0; dev_id < RTE_CRYPTO_MAX_DEVS; dev_id++)
2910 [ # # ]: 0 : if (rte_cryptodev_is_valid_dev(dev_id))
2911 : 0 : rte_tel_data_add_array_int(d, dev_id);
2912 : :
2913 : : return 0;
2914 : : }
2915 : :
2916 : : static int
2917 : 0 : cryptodev_handle_dev_info(const char *cmd __rte_unused,
2918 : : const char *params, struct rte_tel_data *d)
2919 : : {
2920 : : struct rte_cryptodev_info cryptodev_info;
2921 : : int dev_id;
2922 : : char *end_param;
2923 : :
2924 [ # # # # : 0 : if (params == NULL || strlen(params) == 0 || !isdigit(*params))
# # ]
2925 : : return -EINVAL;
2926 : :
2927 : 0 : dev_id = strtoul(params, &end_param, 0);
2928 [ # # ]: 0 : if (*end_param != '\0')
2929 : 0 : CDEV_LOG_ERR("Extra parameters passed to command, ignoring");
2930 [ # # ]: 0 : if (!rte_cryptodev_is_valid_dev(dev_id))
2931 : : return -EINVAL;
2932 : :
2933 : 0 : rte_cryptodev_info_get(dev_id, &cryptodev_info);
2934 : :
2935 : 0 : rte_tel_data_start_dict(d);
2936 : 0 : rte_tel_data_add_dict_string(d, "device_name",
2937 : 0 : cryptodev_info.device->name);
2938 : 0 : rte_tel_data_add_dict_uint(d, "max_nb_queue_pairs",
2939 : 0 : cryptodev_info.max_nb_queue_pairs);
2940 : :
2941 : 0 : return 0;
2942 : : }
2943 : :
2944 : : #define ADD_DICT_STAT(s) rte_tel_data_add_dict_uint(d, #s, cryptodev_stats.s)
2945 : :
2946 : : static int
2947 : 0 : cryptodev_handle_dev_stats(const char *cmd __rte_unused,
2948 : : const char *params,
2949 : : struct rte_tel_data *d)
2950 : : {
2951 : : struct rte_cryptodev_stats cryptodev_stats;
2952 : : int dev_id, ret;
2953 : : char *end_param;
2954 : :
2955 [ # # # # : 0 : if (params == NULL || strlen(params) == 0 || !isdigit(*params))
# # ]
2956 : : return -EINVAL;
2957 : :
2958 : 0 : dev_id = strtoul(params, &end_param, 0);
2959 [ # # ]: 0 : if (*end_param != '\0')
2960 : 0 : CDEV_LOG_ERR("Extra parameters passed to command, ignoring");
2961 [ # # ]: 0 : if (!rte_cryptodev_is_valid_dev(dev_id))
2962 : : return -EINVAL;
2963 : :
2964 : 0 : ret = rte_cryptodev_stats_get(dev_id, &cryptodev_stats);
2965 [ # # ]: 0 : if (ret < 0)
2966 : : return ret;
2967 : :
2968 : 0 : rte_tel_data_start_dict(d);
2969 : 0 : ADD_DICT_STAT(enqueued_count);
2970 : 0 : ADD_DICT_STAT(dequeued_count);
2971 : 0 : ADD_DICT_STAT(enqueue_err_count);
2972 : 0 : ADD_DICT_STAT(dequeue_err_count);
2973 : :
2974 : 0 : return 0;
2975 : : }
2976 : :
2977 : : #define CRYPTO_CAPS_SZ \
2978 : : (RTE_ALIGN_CEIL(sizeof(struct rte_cryptodev_capabilities), \
2979 : : sizeof(uint64_t)) / \
2980 : : sizeof(uint64_t))
2981 : :
2982 : : static int
2983 : 0 : crypto_caps_array(struct rte_tel_data *d,
2984 : : const struct rte_cryptodev_capabilities *capabilities)
2985 : : {
2986 : : const struct rte_cryptodev_capabilities *dev_caps;
2987 : : uint64_t caps_val[CRYPTO_CAPS_SZ];
2988 : : unsigned int i = 0, j;
2989 : :
2990 : 0 : rte_tel_data_start_array(d, RTE_TEL_UINT_VAL);
2991 : :
2992 [ # # ]: 0 : while ((dev_caps = &capabilities[i++])->op !=
2993 : : RTE_CRYPTO_OP_TYPE_UNDEFINED) {
2994 : : memset(&caps_val, 0, CRYPTO_CAPS_SZ * sizeof(caps_val[0]));
2995 : : rte_memcpy(caps_val, dev_caps, sizeof(capabilities[0]));
2996 [ # # ]: 0 : for (j = 0; j < CRYPTO_CAPS_SZ; j++)
2997 : 0 : rte_tel_data_add_array_uint(d, caps_val[j]);
2998 : : }
2999 : :
3000 : 0 : return i;
3001 : : }
3002 : :
3003 : : static int
3004 : 0 : cryptodev_handle_dev_caps(const char *cmd __rte_unused, const char *params,
3005 : : struct rte_tel_data *d)
3006 : : {
3007 : : struct rte_cryptodev_info dev_info;
3008 : : struct rte_tel_data *crypto_caps;
3009 : : int crypto_caps_n;
3010 : : char *end_param;
3011 : : int dev_id;
3012 : :
3013 [ # # # # : 0 : if (!params || strlen(params) == 0 || !isdigit(*params))
# # ]
3014 : : return -EINVAL;
3015 : :
3016 : 0 : dev_id = strtoul(params, &end_param, 0);
3017 [ # # ]: 0 : if (*end_param != '\0')
3018 : 0 : CDEV_LOG_ERR("Extra parameters passed to command, ignoring");
3019 [ # # ]: 0 : if (!rte_cryptodev_is_valid_dev(dev_id))
3020 : : return -EINVAL;
3021 : :
3022 : 0 : rte_tel_data_start_dict(d);
3023 : 0 : crypto_caps = rte_tel_data_alloc();
3024 [ # # ]: 0 : if (!crypto_caps)
3025 : : return -ENOMEM;
3026 : :
3027 : 0 : rte_cryptodev_info_get(dev_id, &dev_info);
3028 : 0 : crypto_caps_n = crypto_caps_array(crypto_caps, dev_info.capabilities);
3029 : 0 : rte_tel_data_add_dict_container(d, "crypto_caps", crypto_caps, 0);
3030 : 0 : rte_tel_data_add_dict_int(d, "crypto_caps_n", crypto_caps_n);
3031 : :
3032 : 0 : return 0;
3033 : : }
3034 : :
3035 : 252 : RTE_INIT(cryptodev_init_telemetry)
3036 : : {
3037 : 252 : rte_telemetry_register_cmd("/cryptodev/info", cryptodev_handle_dev_info,
3038 : : "Returns information for a cryptodev. Parameters: int dev_id");
3039 : 252 : rte_telemetry_register_cmd("/cryptodev/list",
3040 : : cryptodev_handle_dev_list,
3041 : : "Returns list of available crypto devices by IDs. No parameters.");
3042 : 252 : rte_telemetry_register_cmd("/cryptodev/stats",
3043 : : cryptodev_handle_dev_stats,
3044 : : "Returns the stats for a cryptodev. Parameters: int dev_id");
3045 : 252 : rte_telemetry_register_cmd("/cryptodev/caps",
3046 : : cryptodev_handle_dev_caps,
3047 : : "Returns the capabilities for a cryptodev. Parameters: int dev_id");
3048 : 252 : }
|
