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