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