Branch data Line data Source code
1 : : /* SPDX-License-Identifier: BSD-3-Clause
2 : : * Copyright 2017 NXP.
3 : : * Copyright(c) 2017 Intel Corporation.
4 : : * Copyright (c) 2020 Samsung Electronics Co., Ltd All Rights Reserved
5 : : */
6 : :
7 : : #include <stdalign.h>
8 : : #include <ctype.h>
9 : : #include <stdlib.h>
10 : :
11 : : #include <eal_export.h>
12 : : #include <rte_cryptodev.h>
13 : : #include <dev_driver.h>
14 : : #include <rte_telemetry.h>
15 : : #include "rte_security.h"
16 : : #include "rte_security_driver.h"
17 : :
18 : : /* Macro to check for invalid pointers */
19 : : #define RTE_PTR_OR_ERR_RET(ptr, retval) do { \
20 : : if ((ptr) == NULL) \
21 : : return retval; \
22 : : } while (0)
23 : :
24 : : /* Macro to check for invalid pointers chains */
25 : : #define RTE_PTR_CHAIN3_OR_ERR_RET(p1, p2, p3, retval, last_retval) do { \
26 : : RTE_PTR_OR_ERR_RET(p1, retval); \
27 : : RTE_PTR_OR_ERR_RET(p1->p2, retval); \
28 : : RTE_PTR_OR_ERR_RET(p1->p2->p3, last_retval); \
29 : : } while (0)
30 : :
31 : : #define RTE_SECURITY_DYNFIELD_NAME "rte_security_dynfield_metadata"
32 : : #define RTE_SECURITY_OOP_DYNFIELD_NAME "rte_security_oop_dynfield_metadata"
33 : :
34 : : RTE_EXPORT_SYMBOL(rte_security_dynfield_offset)
35 : : int rte_security_dynfield_offset = -1;
36 : : RTE_EXPORT_EXPERIMENTAL_SYMBOL(rte_security_oop_dynfield_offset, 23.11)
37 : : int rte_security_oop_dynfield_offset = -1;
38 : :
39 : : RTE_EXPORT_INTERNAL_SYMBOL(rte_security_dynfield_register)
40 : : int
41 : 0 : rte_security_dynfield_register(void)
42 : : {
43 : : static const struct rte_mbuf_dynfield dynfield_desc = {
44 : : .name = RTE_SECURITY_DYNFIELD_NAME,
45 : : .size = sizeof(rte_security_dynfield_t),
46 : : .align = alignof(rte_security_dynfield_t),
47 : : };
48 : 0 : rte_security_dynfield_offset =
49 : 0 : rte_mbuf_dynfield_register(&dynfield_desc);
50 : 0 : return rte_security_dynfield_offset;
51 : : }
52 : :
53 : : RTE_EXPORT_INTERNAL_SYMBOL(rte_security_oop_dynfield_register)
54 : : int
55 : 0 : rte_security_oop_dynfield_register(void)
56 : : {
57 : : static const struct rte_mbuf_dynfield dynfield_desc = {
58 : : .name = RTE_SECURITY_OOP_DYNFIELD_NAME,
59 : : .size = sizeof(rte_security_oop_dynfield_t),
60 : : .align = alignof(rte_security_oop_dynfield_t),
61 : : };
62 : :
63 : 0 : rte_security_oop_dynfield_offset =
64 : 0 : rte_mbuf_dynfield_register(&dynfield_desc);
65 : 0 : return rte_security_oop_dynfield_offset;
66 : : }
67 : :
68 : : RTE_EXPORT_SYMBOL(rte_security_session_create)
69 : : void *
70 : 59 : rte_security_session_create(void *ctx,
71 : : struct rte_security_session_conf *conf,
72 : : struct rte_mempool *mp)
73 : : {
74 : 59 : struct rte_security_session *sess = NULL;
75 : : struct rte_security_ctx *instance = ctx;
76 : : uint32_t sess_priv_size;
77 : :
78 [ + + + + : 59 : RTE_PTR_CHAIN3_OR_ERR_RET(instance, ops, session_create, NULL, NULL);
+ + ]
79 [ + + ]: 56 : RTE_PTR_OR_ERR_RET(conf, NULL);
80 [ + + ]: 55 : RTE_PTR_OR_ERR_RET(mp, NULL);
81 : :
82 : 54 : sess_priv_size = instance->ops->session_get_size(instance->device);
83 [ + - ]: 54 : if (mp->elt_size < (sizeof(struct rte_security_session) + sess_priv_size))
84 : : return NULL;
85 : :
86 [ + + ]: 54 : if (rte_mempool_get(mp, (void **)&sess))
87 : : return NULL;
88 : :
89 : : /* Clear session priv data */
90 : 53 : memset(sess->driver_priv_data, 0, sess_priv_size);
91 : :
92 : 53 : sess->driver_priv_data_iova = rte_mempool_virt2iova(sess) +
93 : : offsetof(struct rte_security_session, driver_priv_data);
94 [ + + ]: 53 : if (instance->ops->session_create(instance->device, conf, sess)) {
95 [ - + ]: 1 : rte_mempool_put(mp, (void *)sess);
96 : 1 : return NULL;
97 : : }
98 : 52 : instance->sess_cnt++;
99 : :
100 : 52 : return (void *)sess;
101 : : }
102 : :
103 : : RTE_EXPORT_SYMBOL(rte_security_session_update)
104 : : int
105 : 7 : rte_security_session_update(void *ctx, void *sess, struct rte_security_session_conf *conf)
106 : : {
107 : : struct rte_security_ctx *instance = ctx;
108 : :
109 [ + + + + : 7 : RTE_PTR_CHAIN3_OR_ERR_RET(instance, ops, session_update, -EINVAL,
+ + ]
110 : : -ENOTSUP);
111 [ + + ]: 4 : RTE_PTR_OR_ERR_RET(sess, -EINVAL);
112 [ + + ]: 3 : RTE_PTR_OR_ERR_RET(conf, -EINVAL);
113 : :
114 : 2 : return instance->ops->session_update(instance->device, sess, conf);
115 : : }
116 : :
117 : : RTE_EXPORT_SYMBOL(rte_security_session_get_size)
118 : : unsigned int
119 : 6 : rte_security_session_get_size(void *ctx)
120 : : {
121 : : struct rte_security_ctx *instance = ctx;
122 : :
123 [ + + + + : 6 : RTE_PTR_CHAIN3_OR_ERR_RET(instance, ops, session_get_size, 0, 0);
+ + ]
124 : :
125 : 2 : return (sizeof(struct rte_security_session) +
126 : 2 : instance->ops->session_get_size(instance->device));
127 : : }
128 : :
129 : : RTE_EXPORT_SYMBOL(rte_security_session_stats_get)
130 : : int
131 : 6 : rte_security_session_stats_get(void *ctx, void *sess, struct rte_security_stats *stats)
132 : : {
133 : : struct rte_security_ctx *instance = ctx;
134 : :
135 [ + + + + : 6 : RTE_PTR_CHAIN3_OR_ERR_RET(instance, ops, session_stats_get, -EINVAL,
+ + ]
136 : : -ENOTSUP);
137 : : /* Parameter sess can be NULL in case of getting global statistics. */
138 [ + + ]: 3 : RTE_PTR_OR_ERR_RET(stats, -EINVAL);
139 : :
140 : 2 : return instance->ops->session_stats_get(instance->device, sess, stats);
141 : : }
142 : :
143 : : RTE_EXPORT_SYMBOL(rte_security_session_destroy)
144 : : int
145 : 57 : rte_security_session_destroy(void *ctx, void *sess)
146 : : {
147 : : struct rte_security_ctx *instance = ctx;
148 : : int ret;
149 : :
150 [ + + + + : 57 : RTE_PTR_CHAIN3_OR_ERR_RET(instance, ops, session_destroy, -EINVAL,
+ + ]
151 : : -ENOTSUP);
152 [ + + ]: 54 : RTE_PTR_OR_ERR_RET(sess, -EINVAL);
153 : :
154 : 53 : ret = instance->ops->session_destroy(instance->device, sess);
155 [ + + ]: 53 : if (ret != 0)
156 : : return ret;
157 : :
158 : 52 : rte_mempool_put(rte_mempool_from_obj(sess), (void *)sess);
159 : :
160 [ + - ]: 52 : if (instance->sess_cnt)
161 : 52 : instance->sess_cnt--;
162 : :
163 : : return 0;
164 : : }
165 : :
166 : : RTE_EXPORT_SYMBOL(rte_security_macsec_sc_create)
167 : : int
168 : 0 : rte_security_macsec_sc_create(void *ctx, struct rte_security_macsec_sc *conf)
169 : : {
170 : : struct rte_security_ctx *instance = ctx;
171 : : int sc_id;
172 : :
173 [ # # # # : 0 : RTE_PTR_CHAIN3_OR_ERR_RET(instance, ops, macsec_sc_create, -EINVAL, -ENOTSUP);
# # ]
174 [ # # ]: 0 : RTE_PTR_OR_ERR_RET(conf, -EINVAL);
175 : :
176 : 0 : sc_id = instance->ops->macsec_sc_create(instance->device, conf);
177 [ # # ]: 0 : if (sc_id >= 0)
178 : 0 : instance->macsec_sc_cnt++;
179 : :
180 : : return sc_id;
181 : : }
182 : :
183 : : RTE_EXPORT_SYMBOL(rte_security_macsec_sa_create)
184 : : int
185 : 0 : rte_security_macsec_sa_create(void *ctx, struct rte_security_macsec_sa *conf)
186 : : {
187 : : struct rte_security_ctx *instance = ctx;
188 : : int sa_id;
189 : :
190 [ # # # # : 0 : RTE_PTR_CHAIN3_OR_ERR_RET(instance, ops, macsec_sa_create, -EINVAL, -ENOTSUP);
# # ]
191 [ # # ]: 0 : RTE_PTR_OR_ERR_RET(conf, -EINVAL);
192 : :
193 : 0 : sa_id = instance->ops->macsec_sa_create(instance->device, conf);
194 [ # # ]: 0 : if (sa_id >= 0)
195 : 0 : instance->macsec_sa_cnt++;
196 : :
197 : : return sa_id;
198 : : }
199 : :
200 : : RTE_EXPORT_SYMBOL(rte_security_macsec_sc_destroy)
201 : : int
202 : 0 : rte_security_macsec_sc_destroy(void *ctx, uint16_t sc_id,
203 : : enum rte_security_macsec_direction dir)
204 : : {
205 : : struct rte_security_ctx *instance = ctx;
206 : : int ret;
207 : :
208 [ # # # # : 0 : RTE_PTR_CHAIN3_OR_ERR_RET(instance, ops, macsec_sc_destroy, -EINVAL, -ENOTSUP);
# # ]
209 : :
210 : 0 : ret = instance->ops->macsec_sc_destroy(instance->device, sc_id, dir);
211 [ # # ]: 0 : if (ret != 0)
212 : : return ret;
213 : :
214 [ # # ]: 0 : if (instance->macsec_sc_cnt)
215 : 0 : instance->macsec_sc_cnt--;
216 : :
217 : : return 0;
218 : : }
219 : :
220 : : RTE_EXPORT_SYMBOL(rte_security_macsec_sa_destroy)
221 : : int
222 : 0 : rte_security_macsec_sa_destroy(void *ctx, uint16_t sa_id,
223 : : enum rte_security_macsec_direction dir)
224 : : {
225 : : struct rte_security_ctx *instance = ctx;
226 : : int ret;
227 : :
228 [ # # # # : 0 : RTE_PTR_CHAIN3_OR_ERR_RET(instance, ops, macsec_sa_destroy, -EINVAL, -ENOTSUP);
# # ]
229 : :
230 : 0 : ret = instance->ops->macsec_sa_destroy(instance->device, sa_id, dir);
231 [ # # ]: 0 : if (ret != 0)
232 : : return ret;
233 : :
234 [ # # ]: 0 : if (instance->macsec_sa_cnt)
235 : 0 : instance->macsec_sa_cnt--;
236 : :
237 : : return 0;
238 : : }
239 : :
240 : : RTE_EXPORT_SYMBOL(rte_security_macsec_sc_stats_get)
241 : : int
242 : 0 : rte_security_macsec_sc_stats_get(void *ctx, uint16_t sc_id,
243 : : enum rte_security_macsec_direction dir,
244 : : struct rte_security_macsec_sc_stats *stats)
245 : : {
246 : : struct rte_security_ctx *instance = ctx;
247 : :
248 [ # # # # : 0 : RTE_PTR_CHAIN3_OR_ERR_RET(instance, ops, macsec_sc_stats_get, -EINVAL, -ENOTSUP);
# # ]
249 [ # # ]: 0 : RTE_PTR_OR_ERR_RET(stats, -EINVAL);
250 : :
251 : 0 : return instance->ops->macsec_sc_stats_get(instance->device, sc_id, dir, stats);
252 : : }
253 : :
254 : : RTE_EXPORT_SYMBOL(rte_security_macsec_sa_stats_get)
255 : : int
256 : 0 : rte_security_macsec_sa_stats_get(void *ctx, uint16_t sa_id,
257 : : enum rte_security_macsec_direction dir,
258 : : struct rte_security_macsec_sa_stats *stats)
259 : : {
260 : : struct rte_security_ctx *instance = ctx;
261 : :
262 [ # # # # : 0 : RTE_PTR_CHAIN3_OR_ERR_RET(instance, ops, macsec_sa_stats_get, -EINVAL, -ENOTSUP);
# # ]
263 [ # # ]: 0 : RTE_PTR_OR_ERR_RET(stats, -EINVAL);
264 : :
265 : 0 : return instance->ops->macsec_sa_stats_get(instance->device, sa_id, dir, stats);
266 : : }
267 : :
268 : : RTE_EXPORT_SYMBOL(__rte_security_set_pkt_metadata)
269 : : int
270 : 3 : __rte_security_set_pkt_metadata(void *ctx, void *sess, struct rte_mbuf *m, void *params)
271 : : {
272 : : struct rte_security_ctx *instance = ctx;
273 : : #ifdef RTE_DEBUG
274 : : RTE_PTR_OR_ERR_RET(sess, -EINVAL);
275 : : RTE_PTR_OR_ERR_RET(instance, -EINVAL);
276 : : RTE_PTR_OR_ERR_RET(instance->ops, -EINVAL);
277 : : #endif
278 [ + + ]: 3 : if (instance->ops->set_pkt_metadata == NULL)
279 : : return -ENOTSUP;
280 : 2 : return instance->ops->set_pkt_metadata(instance->device, sess, m, params);
281 : : }
282 : :
283 : : RTE_EXPORT_SYMBOL(rte_security_capabilities_get)
284 : : const struct rte_security_capability *
285 : 5 : rte_security_capabilities_get(void *ctx)
286 : : {
287 : : struct rte_security_ctx *instance = ctx;
288 : :
289 [ + + + + : 5 : RTE_PTR_CHAIN3_OR_ERR_RET(instance, ops, capabilities_get, NULL, NULL);
+ + ]
290 : :
291 : 2 : return instance->ops->capabilities_get(instance->device);
292 : : }
293 : :
294 : : RTE_EXPORT_SYMBOL(rte_security_capability_get)
295 : : const struct rte_security_capability *
296 : 16 : rte_security_capability_get(void *ctx, struct rte_security_capability_idx *idx)
297 : : {
298 : : const struct rte_security_capability *capabilities;
299 : : const struct rte_security_capability *capability;
300 : : struct rte_security_ctx *instance = ctx;
301 : : uint16_t i = 0;
302 : :
303 [ + + + + : 16 : RTE_PTR_CHAIN3_OR_ERR_RET(instance, ops, capabilities_get, NULL, NULL);
+ + ]
304 [ + + ]: 13 : RTE_PTR_OR_ERR_RET(idx, NULL);
305 : :
306 : 12 : capabilities = instance->ops->capabilities_get(instance->device);
307 : :
308 [ + + ]: 12 : if (capabilities == NULL)
309 : : return NULL;
310 : :
311 : 23 : while ((capability = &capabilities[i++])->action
312 [ + + ]: 23 : != RTE_SECURITY_ACTION_TYPE_NONE) {
313 [ + + ]: 15 : if (capability->action == idx->action &&
314 [ + + ]: 10 : capability->protocol == idx->protocol) {
315 : : if (idx->protocol == RTE_SECURITY_PROTOCOL_IPSEC) {
316 : 4 : if (capability->ipsec.proto ==
317 [ + + ]: 4 : idx->ipsec.proto &&
318 : 3 : capability->ipsec.mode ==
319 [ + + ]: 3 : idx->ipsec.mode &&
320 : 2 : capability->ipsec.direction ==
321 [ + + ]: 2 : idx->ipsec.direction)
322 : 1 : return capability;
323 : : } else if (idx->protocol == RTE_SECURITY_PROTOCOL_PDCP) {
324 : 2 : if (capability->pdcp.domain ==
325 [ + + ]: 2 : idx->pdcp.domain)
326 : 1 : return capability;
327 : : } else if (idx->protocol ==
328 : : RTE_SECURITY_PROTOCOL_DOCSIS) {
329 : 2 : if (capability->docsis.direction ==
330 [ + + ]: 2 : idx->docsis.direction)
331 : 1 : return capability;
332 : : } else if (idx->protocol ==
333 : : RTE_SECURITY_PROTOCOL_MACSEC) {
334 [ # # ]: 0 : if (idx->macsec.alg == capability->macsec.alg)
335 : 0 : return capability;
336 : : } else if (idx->protocol == RTE_SECURITY_PROTOCOL_TLS_RECORD) {
337 [ # # ]: 0 : if (capability->tls_record.ver == idx->tls_record.ver &&
338 [ # # ]: 0 : capability->tls_record.type == idx->tls_record.type)
339 : 0 : return capability;
340 : : }
341 : : }
342 : : }
343 : :
344 : : return NULL;
345 : : }
346 : :
347 : : RTE_EXPORT_EXPERIMENTAL_SYMBOL(rte_security_rx_inject_configure, 23.11)
348 : : int
349 : 0 : rte_security_rx_inject_configure(void *ctx, uint16_t port_id, bool enable)
350 : : {
351 : : struct rte_security_ctx *instance = ctx;
352 : :
353 [ # # ]: 0 : RTE_PTR_OR_ERR_RET(instance, -EINVAL);
354 [ # # ]: 0 : RTE_PTR_OR_ERR_RET(instance->ops, -ENOTSUP);
355 [ # # ]: 0 : RTE_PTR_OR_ERR_RET(instance->ops->rx_inject_configure, -ENOTSUP);
356 : :
357 : 0 : return instance->ops->rx_inject_configure(instance->device, port_id, enable);
358 : : }
359 : :
360 : : RTE_EXPORT_EXPERIMENTAL_SYMBOL(rte_security_inb_pkt_rx_inject, 23.11)
361 : : uint16_t
362 : 0 : rte_security_inb_pkt_rx_inject(void *ctx, struct rte_mbuf **pkts, void **sess,
363 : : uint16_t nb_pkts)
364 : : {
365 : : struct rte_security_ctx *instance = ctx;
366 : :
367 : 0 : return instance->ops->inb_pkt_rx_inject(instance->device, pkts,
368 : : (struct rte_security_session **)sess, nb_pkts);
369 : : }
370 : :
371 : : static int
372 : 0 : security_handle_cryptodev_list(const char *cmd __rte_unused,
373 : : const char *params __rte_unused,
374 : : struct rte_tel_data *d)
375 : : {
376 : : int dev_id;
377 : :
378 [ # # ]: 0 : if (rte_cryptodev_count() < 1)
379 : : return -1;
380 : :
381 : 0 : rte_tel_data_start_array(d, RTE_TEL_INT_VAL);
382 [ # # ]: 0 : for (dev_id = 0; dev_id < RTE_CRYPTO_MAX_DEVS; dev_id++)
383 [ # # # # ]: 0 : if (rte_cryptodev_is_valid_dev(dev_id) &&
384 : 0 : rte_cryptodev_get_sec_ctx(dev_id))
385 : 0 : rte_tel_data_add_array_int(d, dev_id);
386 : :
387 : : return 0;
388 : : }
389 : :
390 : : #define CRYPTO_CAPS_SZ \
391 : : (RTE_ALIGN_CEIL(sizeof(struct rte_cryptodev_capabilities), \
392 : : sizeof(uint64_t)) / sizeof(uint64_t))
393 : :
394 : : static int
395 : 0 : crypto_caps_array(struct rte_tel_data *d,
396 : : const struct rte_cryptodev_capabilities *capabilities)
397 : : {
398 : : const struct rte_cryptodev_capabilities *dev_caps;
399 : : uint64_t caps_val[CRYPTO_CAPS_SZ];
400 : : unsigned int i = 0, j;
401 : :
402 : 0 : rte_tel_data_start_array(d, RTE_TEL_UINT_VAL);
403 : :
404 [ # # ]: 0 : while ((dev_caps = &capabilities[i++])->op !=
405 : : RTE_CRYPTO_OP_TYPE_UNDEFINED) {
406 : : memset(&caps_val, 0, CRYPTO_CAPS_SZ * sizeof(caps_val[0]));
407 : : rte_memcpy(caps_val, dev_caps, sizeof(capabilities[0]));
408 [ # # ]: 0 : for (j = 0; j < CRYPTO_CAPS_SZ; j++)
409 : 0 : rte_tel_data_add_array_uint(d, caps_val[j]);
410 : : }
411 : :
412 : 0 : return (i - 1);
413 : : }
414 : :
415 : : #define SEC_CAPS_SZ \
416 : : (RTE_ALIGN_CEIL(sizeof(struct rte_security_capability), \
417 : : sizeof(uint64_t)) / sizeof(uint64_t))
418 : :
419 : : static int
420 : 0 : sec_caps_array(struct rte_tel_data *d,
421 : : const struct rte_security_capability *capabilities)
422 : : {
423 : : const struct rte_security_capability *dev_caps;
424 : : uint64_t caps_val[SEC_CAPS_SZ];
425 : : unsigned int i = 0, j;
426 : :
427 : 0 : rte_tel_data_start_array(d, RTE_TEL_UINT_VAL);
428 : :
429 [ # # ]: 0 : while ((dev_caps = &capabilities[i++])->action !=
430 : : RTE_SECURITY_ACTION_TYPE_NONE) {
431 : : memset(&caps_val, 0, SEC_CAPS_SZ * sizeof(caps_val[0]));
432 : : rte_memcpy(caps_val, dev_caps, sizeof(capabilities[0]));
433 [ # # ]: 0 : for (j = 0; j < SEC_CAPS_SZ; j++)
434 : 0 : rte_tel_data_add_array_uint(d, caps_val[j]);
435 : : }
436 : :
437 : 0 : return i - 1;
438 : : }
439 : :
440 : : static const struct rte_security_capability *
441 : : security_capability_by_index(const struct rte_security_capability *capabilities,
442 : : int index)
443 : : {
444 : : const struct rte_security_capability *dev_caps = NULL;
445 : : int i = 0;
446 : :
447 [ # # ]: 0 : while ((dev_caps = &capabilities[i])->action !=
448 : : RTE_SECURITY_ACTION_TYPE_NONE) {
449 [ # # ]: 0 : if (i == index)
450 : : return dev_caps;
451 : :
452 : 0 : ++i;
453 : : }
454 : :
455 : : return NULL;
456 : : }
457 : :
458 : : static int
459 : 0 : security_capabilities_from_dev_id(int dev_id, const void **caps)
460 : : {
461 : : const struct rte_security_capability *capabilities;
462 : : void *sec_ctx;
463 : :
464 [ # # ]: 0 : if (rte_cryptodev_is_valid_dev(dev_id) == 0)
465 : : return -EINVAL;
466 : :
467 : 0 : sec_ctx = rte_cryptodev_get_sec_ctx(dev_id);
468 [ # # ]: 0 : RTE_PTR_OR_ERR_RET(sec_ctx, -EINVAL);
469 : :
470 : 0 : capabilities = rte_security_capabilities_get(sec_ctx);
471 [ # # ]: 0 : RTE_PTR_OR_ERR_RET(capabilities, -EINVAL);
472 : :
473 : 0 : *caps = capabilities;
474 : 0 : return 0;
475 : : }
476 : :
477 : : static int
478 : 0 : security_handle_cryptodev_sec_caps(const char *cmd __rte_unused, const char *params,
479 : : struct rte_tel_data *d)
480 : : {
481 : : const struct rte_security_capability *capabilities;
482 : : struct rte_tel_data *sec_caps;
483 : : char *end_param;
484 : : int sec_caps_n;
485 : : int dev_id;
486 : : int rc;
487 : :
488 [ # # # # : 0 : if (!params || strlen(params) == 0 || !isdigit(*params))
# # ]
489 : : return -EINVAL;
490 : :
491 : 0 : dev_id = strtoul(params, &end_param, 0);
492 [ # # ]: 0 : if (*end_param != '\0')
493 : 0 : CDEV_LOG_ERR("Extra parameters passed to command, ignoring");
494 : :
495 : 0 : rc = security_capabilities_from_dev_id(dev_id, (void *)&capabilities);
496 [ # # ]: 0 : if (rc < 0)
497 : : return rc;
498 : :
499 : 0 : sec_caps = rte_tel_data_alloc();
500 [ # # ]: 0 : RTE_PTR_OR_ERR_RET(sec_caps, -ENOMEM);
501 : :
502 : 0 : rte_tel_data_start_dict(d);
503 : 0 : sec_caps_n = sec_caps_array(sec_caps, capabilities);
504 : 0 : rte_tel_data_add_dict_container(d, "sec_caps", sec_caps, 0);
505 : 0 : rte_tel_data_add_dict_int(d, "sec_caps_n", sec_caps_n);
506 : :
507 : 0 : return 0;
508 : : }
509 : :
510 : : static int
511 : 0 : security_handle_cryptodev_crypto_caps(const char *cmd __rte_unused, const char *params,
512 : : struct rte_tel_data *d)
513 : : {
514 : : const struct rte_security_capability *capabilities;
515 : : struct rte_tel_data *crypto_caps;
516 : : const char *capa_param;
517 : : int dev_id, capa_id;
518 : : int crypto_caps_n;
519 : : char *end_param;
520 : : int rc;
521 : :
522 [ # # # # : 0 : if (!params || strlen(params) == 0 || !isdigit(*params))
# # ]
523 : : return -EINVAL;
524 : :
525 : 0 : dev_id = strtoul(params, &end_param, 0);
526 : 0 : capa_param = strtok(end_param, ",");
527 [ # # # # : 0 : if (!capa_param || strlen(capa_param) == 0 || !isdigit(*capa_param))
# # ]
528 : : return -EINVAL;
529 : :
530 : 0 : capa_id = strtoul(capa_param, &end_param, 0);
531 [ # # ]: 0 : if (*end_param != '\0')
532 : 0 : CDEV_LOG_ERR("Extra parameters passed to command, ignoring");
533 : :
534 : 0 : rc = security_capabilities_from_dev_id(dev_id, (void *)&capabilities);
535 [ # # ]: 0 : if (rc < 0)
536 : : return rc;
537 : :
538 : 0 : capabilities = security_capability_by_index(capabilities, capa_id);
539 [ # # ]: 0 : RTE_PTR_OR_ERR_RET(capabilities, -EINVAL);
540 : :
541 : 0 : crypto_caps = rte_tel_data_alloc();
542 [ # # ]: 0 : RTE_PTR_OR_ERR_RET(crypto_caps, -ENOMEM);
543 : :
544 : 0 : rte_tel_data_start_dict(d);
545 : 0 : crypto_caps_n = crypto_caps_array(crypto_caps, capabilities->crypto_capabilities);
546 : :
547 : 0 : rte_tel_data_add_dict_container(d, "crypto_caps", crypto_caps, 0);
548 : 0 : rte_tel_data_add_dict_int(d, "crypto_caps_n", crypto_caps_n);
549 : :
550 : 0 : return 0;
551 : : }
552 : :
553 : 252 : RTE_INIT(security_init_telemetry)
554 : : {
555 : 252 : rte_telemetry_register_cmd("/security/cryptodev/list",
556 : : security_handle_cryptodev_list,
557 : : "Returns list of available crypto devices by IDs. No parameters.");
558 : :
559 : 252 : rte_telemetry_register_cmd("/security/cryptodev/sec_caps",
560 : : security_handle_cryptodev_sec_caps,
561 : : "Returns security capabilities for a cryptodev. Parameters: int dev_id");
562 : :
563 : 252 : rte_telemetry_register_cmd("/security/cryptodev/crypto_caps",
564 : : security_handle_cryptodev_crypto_caps,
565 : : "Returns crypto capabilities for a security capability. Parameters: int dev_id, sec_cap_id");
566 : 252 : }
|
