Branch data Line data Source code
1 : : /* SPDX-License-Identifier: BSD-3-Clause
2 : : * Copyright(c) 2021 HiSilicon Limited
3 : : * Copyright(c) 2021 Intel Corporation
4 : : */
5 : :
6 : : #include <ctype.h>
7 : : #include <inttypes.h>
8 : : #include <stdlib.h>
9 : :
10 : : #include <rte_eal.h>
11 : : #include <rte_lcore.h>
12 : : #include <rte_log.h>
13 : : #include <rte_malloc.h>
14 : : #include <rte_memzone.h>
15 : : #include <rte_string_fns.h>
16 : : #include <rte_telemetry.h>
17 : :
18 : : #include "rte_dmadev.h"
19 : : #include "rte_dmadev_pmd.h"
20 : : #include "rte_dmadev_trace.h"
21 : :
22 : : static int16_t dma_devices_max;
23 : :
24 : : struct rte_dma_fp_object *rte_dma_fp_objs;
25 : : static struct rte_dma_dev *rte_dma_devices;
26 : : static struct {
27 : : /* Hold the dev_max information of the primary process. This field is
28 : : * set by the primary process and is read by the secondary process.
29 : : */
30 : : int16_t dev_max;
31 : : struct rte_dma_dev_data data[0];
32 : : } *dma_devices_shared_data;
33 : :
34 [ - + ]: 252 : RTE_LOG_REGISTER_DEFAULT(rte_dma_logtype, INFO);
35 : : #define RTE_LOGTYPE_DMADEV rte_dma_logtype
36 : :
37 : : #define RTE_DMA_LOG(level, ...) \
38 : : RTE_LOG_LINE(level, DMADEV, "" __VA_ARGS__)
39 : :
40 : : int
41 : 0 : rte_dma_dev_max(size_t dev_max)
42 : : {
43 : : /* This function may be called before rte_eal_init(), so no rte library
44 : : * function can be called in this function.
45 : : */
46 [ # # ]: 0 : if (dev_max == 0 || dev_max > INT16_MAX)
47 : : return -EINVAL;
48 : :
49 [ # # ]: 0 : if (dma_devices_max > 0)
50 : : return -EINVAL;
51 : :
52 : 0 : dma_devices_max = dev_max;
53 : :
54 : 0 : return 0;
55 : : }
56 : :
57 : : int16_t
58 : 0 : rte_dma_next_dev(int16_t start_dev_id)
59 : : {
60 : : int16_t dev_id = start_dev_id;
61 [ # # # # ]: 0 : while (dev_id < dma_devices_max && rte_dma_devices[dev_id].state == RTE_DMA_DEV_UNUSED)
62 : 0 : dev_id++;
63 : :
64 [ # # ]: 0 : if (dev_id < dma_devices_max)
65 : 0 : return dev_id;
66 : :
67 : : return -1;
68 : : }
69 : :
70 : : static int
71 : 2 : dma_check_name(const char *name)
72 : : {
73 : : size_t name_len;
74 : :
75 [ - + ]: 2 : if (name == NULL) {
76 : 0 : RTE_DMA_LOG(ERR, "Name can't be NULL");
77 : 0 : return -EINVAL;
78 : : }
79 : :
80 : 2 : name_len = strnlen(name, RTE_DEV_NAME_MAX_LEN);
81 [ - + ]: 2 : if (name_len == 0) {
82 : 0 : RTE_DMA_LOG(ERR, "Zero length DMA device name");
83 : 0 : return -EINVAL;
84 : : }
85 [ - + ]: 2 : if (name_len >= RTE_DEV_NAME_MAX_LEN) {
86 : 0 : RTE_DMA_LOG(ERR, "DMA device name is too long");
87 : 0 : return -EINVAL;
88 : : }
89 : :
90 : : return 0;
91 : : }
92 : :
93 : : static int16_t
94 : : dma_find_free_id(void)
95 : : {
96 : : int16_t i;
97 : :
98 [ + - + - ]: 1 : if (rte_dma_devices == NULL || dma_devices_shared_data == NULL)
99 : : return -1;
100 : :
101 [ + - ]: 1 : for (i = 0; i < dma_devices_max; i++) {
102 [ - + ]: 1 : if (dma_devices_shared_data->data[i].dev_name[0] == '\0')
103 : : return i;
104 : : }
105 : :
106 : : return -1;
107 : : }
108 : :
109 : : static struct rte_dma_dev*
110 : 2 : dma_find_by_name(const char *name)
111 : : {
112 : : int16_t i;
113 : :
114 [ + - ]: 2 : if (rte_dma_devices == NULL)
115 : : return NULL;
116 : :
117 [ + + ]: 66 : for (i = 0; i < dma_devices_max; i++) {
118 [ + + ]: 65 : if ((rte_dma_devices[i].state != RTE_DMA_DEV_UNUSED) &&
119 [ + - ]: 1 : (!strcmp(name, rte_dma_devices[i].data->dev_name)))
120 : 1 : return &rte_dma_devices[i];
121 : : }
122 : :
123 : : return NULL;
124 : : }
125 : :
126 : : static void dma_fp_object_dummy(struct rte_dma_fp_object *obj);
127 : :
128 : : static int
129 : 1 : dma_fp_data_prepare(void)
130 : : {
131 : : size_t size;
132 : : void *ptr;
133 : : int i;
134 : :
135 [ + - ]: 1 : if (rte_dma_fp_objs != NULL)
136 : : return 0;
137 : :
138 : : /* Fast-path object must align cacheline, but the return value of malloc
139 : : * may not be aligned to the cache line. Therefore, extra memory is
140 : : * applied for realignment.
141 : : * note: We do not call posix_memalign/aligned_alloc because it is
142 : : * version dependent on libc.
143 : : */
144 : 1 : size = dma_devices_max * sizeof(struct rte_dma_fp_object) +
145 : : RTE_CACHE_LINE_SIZE;
146 : 1 : ptr = malloc(size);
147 [ + - ]: 1 : if (ptr == NULL)
148 : : return -ENOMEM;
149 : : memset(ptr, 0, size);
150 : :
151 : 1 : rte_dma_fp_objs = RTE_PTR_ALIGN(ptr, RTE_CACHE_LINE_SIZE);
152 [ + + ]: 65 : for (i = 0; i < dma_devices_max; i++)
153 : 64 : dma_fp_object_dummy(&rte_dma_fp_objs[i]);
154 : :
155 : : return 0;
156 : : }
157 : :
158 : : static int
159 : 1 : dma_dev_data_prepare(void)
160 : : {
161 : : size_t size;
162 : : void *ptr;
163 : :
164 [ + - ]: 1 : if (rte_dma_devices != NULL)
165 : : return 0;
166 : :
167 : : /* The DMA device object is expected to align cacheline,
168 : : * but the return value of malloc may not be aligned to the cache line.
169 : : * Therefore, extra memory is applied for realignment.
170 : : * Note: posix_memalign/aligned_alloc are not used
171 : : * because not always available, depending on libc.
172 : : */
173 : 1 : size = dma_devices_max * sizeof(struct rte_dma_dev) + RTE_CACHE_LINE_SIZE;
174 : 1 : ptr = malloc(size);
175 [ + - ]: 1 : if (ptr == NULL)
176 : : return -ENOMEM;
177 : : memset(ptr, 0, size);
178 : :
179 : 1 : rte_dma_devices = RTE_PTR_ALIGN(ptr, RTE_CACHE_LINE_SIZE);
180 : :
181 : 1 : return 0;
182 : : }
183 : :
184 : : static int
185 : 1 : dma_shared_data_prepare(void)
186 : : {
187 : : const char *mz_name = "rte_dma_dev_data";
188 : : const struct rte_memzone *mz;
189 : : size_t size;
190 : :
191 [ + - ]: 1 : if (dma_devices_shared_data != NULL)
192 : : return 0;
193 : :
194 : 1 : size = sizeof(*dma_devices_shared_data) +
195 : 1 : sizeof(struct rte_dma_dev_data) * dma_devices_max;
196 : :
197 [ + - ]: 1 : if (rte_eal_process_type() == RTE_PROC_PRIMARY)
198 : 1 : mz = rte_memzone_reserve(mz_name, size, rte_socket_id(), 0);
199 : : else
200 : 0 : mz = rte_memzone_lookup(mz_name);
201 [ + - ]: 1 : if (mz == NULL)
202 : : return -ENOMEM;
203 : :
204 : 1 : dma_devices_shared_data = mz->addr;
205 [ + - ]: 1 : if (rte_eal_process_type() == RTE_PROC_PRIMARY) {
206 : 1 : memset(dma_devices_shared_data, 0, size);
207 : 1 : dma_devices_shared_data->dev_max = dma_devices_max;
208 : : } else {
209 : 0 : dma_devices_max = dma_devices_shared_data->dev_max;
210 : : }
211 : :
212 : : return 0;
213 : : }
214 : :
215 : : static int
216 : 1 : dma_data_prepare(void)
217 : : {
218 : : int ret;
219 : :
220 [ + - ]: 1 : if (rte_eal_process_type() == RTE_PROC_PRIMARY) {
221 [ + - ]: 1 : if (dma_devices_max == 0)
222 : 1 : dma_devices_max = RTE_DMADEV_DEFAULT_MAX;
223 : 1 : ret = dma_fp_data_prepare();
224 [ + - ]: 1 : if (ret)
225 : : return ret;
226 : 1 : ret = dma_dev_data_prepare();
227 [ + - ]: 1 : if (ret)
228 : : return ret;
229 : 1 : ret = dma_shared_data_prepare();
230 [ - + ]: 1 : if (ret)
231 : 0 : return ret;
232 : : } else {
233 : 0 : ret = dma_shared_data_prepare();
234 [ # # ]: 0 : if (ret)
235 : : return ret;
236 : 0 : ret = dma_fp_data_prepare();
237 [ # # ]: 0 : if (ret)
238 : : return ret;
239 : 0 : ret = dma_dev_data_prepare();
240 [ # # ]: 0 : if (ret)
241 : 0 : return ret;
242 : : }
243 : :
244 : : return 0;
245 : : }
246 : :
247 : : static struct rte_dma_dev *
248 : 1 : dma_allocate_primary(const char *name, int numa_node, size_t private_data_size)
249 : : {
250 : : struct rte_dma_dev *dev;
251 : : void *dev_private;
252 : : int16_t dev_id;
253 : : int ret;
254 : :
255 : 1 : ret = dma_data_prepare();
256 [ - + ]: 1 : if (ret < 0) {
257 : 0 : RTE_DMA_LOG(ERR, "Cannot initialize dmadevs data");
258 : 0 : return NULL;
259 : : }
260 : :
261 : 1 : dev = dma_find_by_name(name);
262 [ - + ]: 1 : if (dev != NULL) {
263 : 0 : RTE_DMA_LOG(ERR, "DMA device already allocated");
264 : 0 : return NULL;
265 : : }
266 : :
267 : 1 : dev_private = rte_zmalloc_socket(name, private_data_size,
268 : : RTE_CACHE_LINE_SIZE, numa_node);
269 [ - + ]: 1 : if (dev_private == NULL) {
270 : 0 : RTE_DMA_LOG(ERR, "Cannot allocate private data");
271 : 0 : return NULL;
272 : : }
273 : :
274 : : dev_id = dma_find_free_id();
275 [ - + ]: 1 : if (dev_id < 0) {
276 : 0 : RTE_DMA_LOG(ERR, "Reached maximum number of DMA devices");
277 : 0 : rte_free(dev_private);
278 : 0 : return NULL;
279 : : }
280 : :
281 : 1 : dev = &rte_dma_devices[dev_id];
282 : 1 : dev->data = &dma_devices_shared_data->data[dev_id];
283 : 1 : rte_strscpy(dev->data->dev_name, name, sizeof(dev->data->dev_name));
284 : 1 : dev->data->dev_id = dev_id;
285 : 1 : dev->data->numa_node = numa_node;
286 : 1 : dev->data->dev_private = dev_private;
287 : :
288 : 1 : return dev;
289 : : }
290 : :
291 : : static struct rte_dma_dev *
292 : 0 : dma_attach_secondary(const char *name)
293 : : {
294 : : struct rte_dma_dev *dev;
295 : : int16_t i;
296 : : int ret;
297 : :
298 : 0 : ret = dma_data_prepare();
299 [ # # ]: 0 : if (ret < 0) {
300 : 0 : RTE_DMA_LOG(ERR, "Cannot initialize dmadevs data");
301 : 0 : return NULL;
302 : : }
303 : :
304 [ # # ]: 0 : for (i = 0; i < dma_devices_max; i++) {
305 [ # # ]: 0 : if (!strcmp(dma_devices_shared_data->data[i].dev_name, name))
306 : : break;
307 : : }
308 [ # # ]: 0 : if (i == dma_devices_max) {
309 : 0 : RTE_DMA_LOG(ERR,
310 : : "Device %s is not driven by the primary process",
311 : : name);
312 : 0 : return NULL;
313 : : }
314 : :
315 : 0 : dev = &rte_dma_devices[i];
316 : 0 : dev->data = &dma_devices_shared_data->data[i];
317 : :
318 : 0 : return dev;
319 : : }
320 : :
321 : : static struct rte_dma_dev *
322 : 1 : dma_allocate(const char *name, int numa_node, size_t private_data_size)
323 : : {
324 : : struct rte_dma_dev *dev;
325 : :
326 [ + - ]: 1 : if (rte_eal_process_type() == RTE_PROC_PRIMARY)
327 : 1 : dev = dma_allocate_primary(name, numa_node, private_data_size);
328 : : else
329 : 0 : dev = dma_attach_secondary(name);
330 : :
331 [ + - ]: 1 : if (dev) {
332 : 1 : dev->fp_obj = &rte_dma_fp_objs[dev->data->dev_id];
333 : : dma_fp_object_dummy(dev->fp_obj);
334 : : }
335 : :
336 : 1 : return dev;
337 : : }
338 : :
339 : : static void
340 : 1 : dma_release(struct rte_dma_dev *dev)
341 : : {
342 [ + - ]: 1 : if (rte_eal_process_type() == RTE_PROC_PRIMARY) {
343 : 1 : rte_free(dev->data->dev_private);
344 : 1 : memset(dev->data, 0, sizeof(struct rte_dma_dev_data));
345 : : }
346 : :
347 : 1 : dma_fp_object_dummy(dev->fp_obj);
348 : : memset(dev, 0, sizeof(struct rte_dma_dev));
349 : 1 : }
350 : :
351 : : struct rte_dma_dev *
352 : 1 : rte_dma_pmd_allocate(const char *name, int numa_node, size_t private_data_size)
353 : : {
354 : : struct rte_dma_dev *dev;
355 : :
356 [ + - + - ]: 1 : if (dma_check_name(name) != 0 || private_data_size == 0)
357 : : return NULL;
358 : :
359 : 1 : dev = dma_allocate(name, numa_node, private_data_size);
360 [ + - ]: 1 : if (dev == NULL)
361 : : return NULL;
362 : :
363 : 1 : dev->state = RTE_DMA_DEV_REGISTERED;
364 : :
365 : 1 : return dev;
366 : : }
367 : :
368 : : int
369 : 1 : rte_dma_pmd_release(const char *name)
370 : : {
371 : : struct rte_dma_dev *dev;
372 : :
373 [ + - ]: 1 : if (dma_check_name(name) != 0)
374 : : return -EINVAL;
375 : :
376 : 1 : dev = dma_find_by_name(name);
377 [ + - ]: 1 : if (dev == NULL)
378 : : return -EINVAL;
379 : :
380 [ + - ]: 1 : if (dev->state == RTE_DMA_DEV_READY)
381 : 1 : return rte_dma_close(dev->data->dev_id);
382 : :
383 : 0 : dma_release(dev);
384 : 0 : return 0;
385 : : }
386 : :
387 : : int
388 : 0 : rte_dma_get_dev_id_by_name(const char *name)
389 : : {
390 : : struct rte_dma_dev *dev;
391 : :
392 [ # # ]: 0 : if (dma_check_name(name) != 0)
393 : : return -EINVAL;
394 : :
395 : 0 : dev = dma_find_by_name(name);
396 [ # # ]: 0 : if (dev == NULL)
397 : : return -EINVAL;
398 : :
399 : 0 : return dev->data->dev_id;
400 : : }
401 : :
402 : : bool
403 : 1 : rte_dma_is_valid(int16_t dev_id)
404 : : {
405 [ + - ]: 1 : return (dev_id >= 0) && (dev_id < dma_devices_max) &&
406 [ + - + - ]: 2 : rte_dma_devices != NULL &&
407 [ - + ]: 1 : rte_dma_devices[dev_id].state != RTE_DMA_DEV_UNUSED;
408 : : }
409 : :
410 : : struct rte_dma_dev *
411 : 0 : rte_dma_pmd_get_dev_by_id(int16_t dev_id)
412 : : {
413 [ # # ]: 0 : if (!rte_dma_is_valid(dev_id))
414 : : return NULL;
415 : :
416 : 0 : return &rte_dma_devices[dev_id];
417 : : }
418 : :
419 : : uint16_t
420 : 0 : rte_dma_count_avail(void)
421 : : {
422 : : uint16_t count = 0;
423 : : uint16_t i;
424 : :
425 [ # # ]: 0 : if (rte_dma_devices == NULL)
426 : : return count;
427 : :
428 [ # # ]: 0 : for (i = 0; i < dma_devices_max; i++) {
429 [ # # ]: 0 : if (rte_dma_devices[i].state != RTE_DMA_DEV_UNUSED)
430 : 0 : count++;
431 : : }
432 : :
433 : : return count;
434 : : }
435 : :
436 : : int
437 : 0 : rte_dma_info_get(int16_t dev_id, struct rte_dma_info *dev_info)
438 : : {
439 : : const struct rte_dma_dev *dev;
440 : : int ret;
441 : :
442 [ # # # # ]: 0 : if (!rte_dma_is_valid(dev_id) || dev_info == NULL)
443 : : return -EINVAL;
444 : 0 : dev = &rte_dma_devices[dev_id];
445 : :
446 [ # # ]: 0 : if (dev->dev_ops->dev_info_get == NULL)
447 : : return -ENOTSUP;
448 : : memset(dev_info, 0, sizeof(struct rte_dma_info));
449 : 0 : ret = dev->dev_ops->dev_info_get(dev, dev_info, sizeof(struct rte_dma_info));
450 [ # # ]: 0 : if (ret != 0)
451 : : return ret;
452 : :
453 [ # # # # ]: 0 : if ((dev_info->dev_capa & RTE_DMA_CAPA_PRI_POLICY_SP) && (dev_info->nb_priorities <= 1)) {
454 : 0 : RTE_DMA_LOG(ERR, "Num of priorities must be > 1 for Device %d", dev_id);
455 : 0 : return -EINVAL;
456 : : }
457 : :
458 : 0 : dev_info->dev_name = dev->data->dev_name;
459 : 0 : dev_info->numa_node = dev->device->numa_node;
460 [ # # ]: 0 : dev_info->nb_vchans = dev->data->dev_conf.nb_vchans;
461 : :
462 : 0 : rte_dma_trace_info_get(dev_id, dev_info);
463 : :
464 : 0 : return 0;
465 : : }
466 : :
467 : : int
468 : 0 : rte_dma_configure(int16_t dev_id, const struct rte_dma_conf *dev_conf)
469 : : {
470 : : struct rte_dma_info dev_info;
471 : : struct rte_dma_dev *dev;
472 : : int ret;
473 : :
474 [ # # # # ]: 0 : if (!rte_dma_is_valid(dev_id) || dev_conf == NULL)
475 : : return -EINVAL;
476 : 0 : dev = &rte_dma_devices[dev_id];
477 : :
478 [ # # ]: 0 : if (dev->data->dev_started != 0) {
479 : 0 : RTE_DMA_LOG(ERR,
480 : : "Device %d must be stopped to allow configuration",
481 : : dev_id);
482 : 0 : return -EBUSY;
483 : : }
484 : :
485 : 0 : ret = rte_dma_info_get(dev_id, &dev_info);
486 [ # # ]: 0 : if (ret != 0) {
487 : 0 : RTE_DMA_LOG(ERR, "Device %d get device info fail", dev_id);
488 : 0 : return -EINVAL;
489 : : }
490 [ # # ]: 0 : if (dev_conf->nb_vchans == 0) {
491 : 0 : RTE_DMA_LOG(ERR,
492 : : "Device %d configure zero vchans", dev_id);
493 : 0 : return -EINVAL;
494 : : }
495 [ # # ]: 0 : if (dev_conf->nb_vchans > dev_info.max_vchans) {
496 : 0 : RTE_DMA_LOG(ERR,
497 : : "Device %d configure too many vchans", dev_id);
498 : 0 : return -EINVAL;
499 : : }
500 [ # # ]: 0 : if (dev_conf->enable_silent &&
501 [ # # ]: 0 : !(dev_info.dev_capa & RTE_DMA_CAPA_SILENT)) {
502 : 0 : RTE_DMA_LOG(ERR, "Device %d don't support silent", dev_id);
503 : 0 : return -EINVAL;
504 : : }
505 : :
506 [ # # ]: 0 : if ((dev_info.dev_capa & RTE_DMA_CAPA_PRI_POLICY_SP) &&
507 [ # # ]: 0 : (dev_conf->priority >= dev_info.nb_priorities)) {
508 : 0 : RTE_DMA_LOG(ERR, "Device %d configure invalid priority", dev_id);
509 : 0 : return -EINVAL;
510 : : }
511 : :
512 [ # # ]: 0 : if (dev->dev_ops->dev_configure == NULL)
513 : : return -ENOTSUP;
514 : 0 : ret = dev->dev_ops->dev_configure(dev, dev_conf, sizeof(struct rte_dma_conf));
515 [ # # ]: 0 : if (ret == 0)
516 : 0 : memcpy(&dev->data->dev_conf, dev_conf,
517 : : sizeof(struct rte_dma_conf));
518 : :
519 : 0 : rte_dma_trace_configure(dev_id, dev_conf, ret);
520 : :
521 : 0 : return ret;
522 : : }
523 : :
524 : : int
525 : 0 : rte_dma_start(int16_t dev_id)
526 : : {
527 : : struct rte_dma_dev *dev;
528 : : int ret;
529 : :
530 [ # # ]: 0 : if (!rte_dma_is_valid(dev_id))
531 : : return -EINVAL;
532 : 0 : dev = &rte_dma_devices[dev_id];
533 : :
534 [ # # ]: 0 : if (dev->data->dev_conf.nb_vchans == 0) {
535 : 0 : RTE_DMA_LOG(ERR, "Device %d must be configured first", dev_id);
536 : 0 : return -EINVAL;
537 : : }
538 : :
539 [ # # ]: 0 : if (dev->data->dev_started != 0) {
540 : 0 : RTE_DMA_LOG(WARNING, "Device %d already started", dev_id);
541 : 0 : return 0;
542 : : }
543 : :
544 [ # # ]: 0 : if (dev->dev_ops->dev_start == NULL)
545 : 0 : goto mark_started;
546 : :
547 : 0 : ret = dev->dev_ops->dev_start(dev);
548 : 0 : rte_dma_trace_start(dev_id, ret);
549 [ # # ]: 0 : if (ret != 0)
550 : : return ret;
551 : :
552 : 0 : mark_started:
553 : 0 : dev->data->dev_started = 1;
554 : 0 : return 0;
555 : : }
556 : :
557 : : int
558 : 0 : rte_dma_stop(int16_t dev_id)
559 : : {
560 : : struct rte_dma_dev *dev;
561 : : int ret;
562 : :
563 [ # # ]: 0 : if (!rte_dma_is_valid(dev_id))
564 : : return -EINVAL;
565 : 0 : dev = &rte_dma_devices[dev_id];
566 : :
567 [ # # ]: 0 : if (dev->data->dev_started == 0) {
568 : 0 : RTE_DMA_LOG(WARNING, "Device %d already stopped", dev_id);
569 : 0 : return 0;
570 : : }
571 : :
572 [ # # ]: 0 : if (dev->dev_ops->dev_stop == NULL)
573 : 0 : goto mark_stopped;
574 : :
575 : 0 : ret = dev->dev_ops->dev_stop(dev);
576 : 0 : rte_dma_trace_stop(dev_id, ret);
577 [ # # ]: 0 : if (ret != 0)
578 : : return ret;
579 : :
580 : 0 : mark_stopped:
581 : 0 : dev->data->dev_started = 0;
582 : 0 : return 0;
583 : : }
584 : :
585 : : int
586 : 1 : rte_dma_close(int16_t dev_id)
587 : : {
588 : : struct rte_dma_dev *dev;
589 : : int ret;
590 : :
591 [ + - ]: 1 : if (!rte_dma_is_valid(dev_id))
592 : : return -EINVAL;
593 : 1 : dev = &rte_dma_devices[dev_id];
594 : :
595 : : /* Device must be stopped before it can be closed */
596 [ - + ]: 1 : if (dev->data->dev_started == 1) {
597 : 0 : RTE_DMA_LOG(ERR,
598 : : "Device %d must be stopped before closing", dev_id);
599 : 0 : return -EBUSY;
600 : : }
601 : :
602 [ + - ]: 1 : if (dev->dev_ops->dev_close == NULL)
603 : : return -ENOTSUP;
604 : 1 : ret = dev->dev_ops->dev_close(dev);
605 [ + - ]: 1 : if (ret == 0)
606 : 1 : dma_release(dev);
607 : :
608 : 1 : rte_dma_trace_close(dev_id, ret);
609 : :
610 : 1 : return ret;
611 : : }
612 : :
613 : : int
614 : 0 : rte_dma_vchan_setup(int16_t dev_id, uint16_t vchan,
615 : : const struct rte_dma_vchan_conf *conf)
616 : : {
617 : : struct rte_dma_info dev_info;
618 : : bool src_is_dev, dst_is_dev;
619 : : struct rte_dma_dev *dev;
620 : : int ret;
621 : :
622 [ # # # # ]: 0 : if (!rte_dma_is_valid(dev_id) || conf == NULL)
623 : : return -EINVAL;
624 : 0 : dev = &rte_dma_devices[dev_id];
625 : :
626 [ # # ]: 0 : if (dev->data->dev_started != 0) {
627 : 0 : RTE_DMA_LOG(ERR,
628 : : "Device %d must be stopped to allow configuration",
629 : : dev_id);
630 : 0 : return -EBUSY;
631 : : }
632 : :
633 : 0 : ret = rte_dma_info_get(dev_id, &dev_info);
634 [ # # ]: 0 : if (ret != 0) {
635 : 0 : RTE_DMA_LOG(ERR, "Device %d get device info fail", dev_id);
636 : 0 : return -EINVAL;
637 : : }
638 [ # # ]: 0 : if (dev->data->dev_conf.nb_vchans == 0) {
639 : 0 : RTE_DMA_LOG(ERR, "Device %d must be configured first", dev_id);
640 : 0 : return -EINVAL;
641 : : }
642 [ # # ]: 0 : if (vchan >= dev_info.nb_vchans) {
643 : 0 : RTE_DMA_LOG(ERR, "Device %d vchan out range!", dev_id);
644 : 0 : return -EINVAL;
645 : : }
646 [ # # ]: 0 : if (conf->direction != RTE_DMA_DIR_MEM_TO_MEM &&
647 : : conf->direction != RTE_DMA_DIR_MEM_TO_DEV &&
648 : : conf->direction != RTE_DMA_DIR_DEV_TO_MEM &&
649 : : conf->direction != RTE_DMA_DIR_DEV_TO_DEV) {
650 : 0 : RTE_DMA_LOG(ERR, "Device %d direction invalid!", dev_id);
651 : 0 : return -EINVAL;
652 : : }
653 [ # # ]: 0 : if (conf->direction == RTE_DMA_DIR_MEM_TO_MEM &&
654 [ # # ]: 0 : !(dev_info.dev_capa & RTE_DMA_CAPA_MEM_TO_MEM)) {
655 : 0 : RTE_DMA_LOG(ERR,
656 : : "Device %d don't support mem2mem transfer", dev_id);
657 : 0 : return -EINVAL;
658 : : }
659 [ # # ]: 0 : if (conf->direction == RTE_DMA_DIR_MEM_TO_DEV &&
660 [ # # ]: 0 : !(dev_info.dev_capa & RTE_DMA_CAPA_MEM_TO_DEV)) {
661 : 0 : RTE_DMA_LOG(ERR,
662 : : "Device %d don't support mem2dev transfer", dev_id);
663 : 0 : return -EINVAL;
664 : : }
665 [ # # ]: 0 : if (conf->direction == RTE_DMA_DIR_DEV_TO_MEM &&
666 [ # # ]: 0 : !(dev_info.dev_capa & RTE_DMA_CAPA_DEV_TO_MEM)) {
667 : 0 : RTE_DMA_LOG(ERR,
668 : : "Device %d don't support dev2mem transfer", dev_id);
669 : 0 : return -EINVAL;
670 : : }
671 [ # # ]: 0 : if (conf->direction == RTE_DMA_DIR_DEV_TO_DEV &&
672 [ # # ]: 0 : !(dev_info.dev_capa & RTE_DMA_CAPA_DEV_TO_DEV)) {
673 : 0 : RTE_DMA_LOG(ERR,
674 : : "Device %d don't support dev2dev transfer", dev_id);
675 : 0 : return -EINVAL;
676 : : }
677 [ # # ]: 0 : if (conf->nb_desc < dev_info.min_desc ||
678 [ # # ]: 0 : conf->nb_desc > dev_info.max_desc) {
679 : 0 : RTE_DMA_LOG(ERR,
680 : : "Device %d number of descriptors invalid", dev_id);
681 : 0 : return -EINVAL;
682 : : }
683 : 0 : src_is_dev = conf->direction == RTE_DMA_DIR_DEV_TO_MEM ||
684 : : conf->direction == RTE_DMA_DIR_DEV_TO_DEV;
685 [ # # # # : 0 : if ((conf->src_port.port_type == RTE_DMA_PORT_NONE && src_is_dev) ||
# # ]
686 [ # # ]: 0 : (conf->src_port.port_type != RTE_DMA_PORT_NONE && !src_is_dev)) {
687 : 0 : RTE_DMA_LOG(ERR, "Device %d source port type invalid", dev_id);
688 : 0 : return -EINVAL;
689 : : }
690 : 0 : dst_is_dev = conf->direction == RTE_DMA_DIR_MEM_TO_DEV ||
691 : : conf->direction == RTE_DMA_DIR_DEV_TO_DEV;
692 [ # # # # : 0 : if ((conf->dst_port.port_type == RTE_DMA_PORT_NONE && dst_is_dev) ||
# # ]
693 [ # # ]: 0 : (conf->dst_port.port_type != RTE_DMA_PORT_NONE && !dst_is_dev)) {
694 : 0 : RTE_DMA_LOG(ERR,
695 : : "Device %d destination port type invalid", dev_id);
696 : 0 : return -EINVAL;
697 : : }
698 : :
699 [ # # ]: 0 : if (dev->dev_ops->vchan_setup == NULL)
700 : : return -ENOTSUP;
701 : 0 : ret = dev->dev_ops->vchan_setup(dev, vchan, conf, sizeof(struct rte_dma_vchan_conf));
702 : 0 : rte_dma_trace_vchan_setup(dev_id, vchan, conf, ret);
703 : :
704 : 0 : return ret;
705 : : }
706 : :
707 : : int
708 : 0 : rte_dma_stats_get(int16_t dev_id, uint16_t vchan, struct rte_dma_stats *stats)
709 : : {
710 : : const struct rte_dma_dev *dev;
711 : :
712 [ # # # # ]: 0 : if (!rte_dma_is_valid(dev_id) || stats == NULL)
713 : : return -EINVAL;
714 : 0 : dev = &rte_dma_devices[dev_id];
715 : :
716 [ # # # # ]: 0 : if (vchan >= dev->data->dev_conf.nb_vchans &&
717 : : vchan != RTE_DMA_ALL_VCHAN) {
718 : 0 : RTE_DMA_LOG(ERR,
719 : : "Device %d vchan %u out of range", dev_id, vchan);
720 : 0 : return -EINVAL;
721 : : }
722 : :
723 [ # # ]: 0 : if (dev->dev_ops->stats_get == NULL)
724 : : return -ENOTSUP;
725 : : memset(stats, 0, sizeof(struct rte_dma_stats));
726 : 0 : return dev->dev_ops->stats_get(dev, vchan, stats, sizeof(struct rte_dma_stats));
727 : : }
728 : :
729 : : int
730 : 0 : rte_dma_stats_reset(int16_t dev_id, uint16_t vchan)
731 : : {
732 : : struct rte_dma_dev *dev;
733 : : int ret;
734 : :
735 [ # # ]: 0 : if (!rte_dma_is_valid(dev_id))
736 : : return -EINVAL;
737 : 0 : dev = &rte_dma_devices[dev_id];
738 : :
739 [ # # # # ]: 0 : if (vchan >= dev->data->dev_conf.nb_vchans &&
740 : : vchan != RTE_DMA_ALL_VCHAN) {
741 : 0 : RTE_DMA_LOG(ERR,
742 : : "Device %d vchan %u out of range", dev_id, vchan);
743 : 0 : return -EINVAL;
744 : : }
745 : :
746 [ # # ]: 0 : if (dev->dev_ops->stats_reset == NULL)
747 : : return -ENOTSUP;
748 : 0 : ret = dev->dev_ops->stats_reset(dev, vchan);
749 : 0 : rte_dma_trace_stats_reset(dev_id, vchan, ret);
750 : :
751 : 0 : return ret;
752 : : }
753 : :
754 : : int
755 : 0 : rte_dma_vchan_status(int16_t dev_id, uint16_t vchan, enum rte_dma_vchan_status *status)
756 : : {
757 : : struct rte_dma_dev *dev;
758 : :
759 [ # # # # ]: 0 : if (!rte_dma_is_valid(dev_id) || status == NULL)
760 : : return -EINVAL;
761 : 0 : dev = &rte_dma_devices[dev_id];
762 : :
763 [ # # ]: 0 : if (vchan >= dev->data->dev_conf.nb_vchans) {
764 : 0 : RTE_DMA_LOG(ERR, "Device %u vchan %u out of range", dev_id, vchan);
765 : 0 : return -EINVAL;
766 : : }
767 : :
768 [ # # ]: 0 : if (dev->dev_ops->vchan_status == NULL)
769 : : return -ENOTSUP;
770 : 0 : return dev->dev_ops->vchan_status(dev, vchan, status);
771 : : }
772 : :
773 : : static const char *
774 : : dma_capability_name(uint64_t capability)
775 : : {
776 : : static const struct {
777 : : uint64_t capability;
778 : : const char *name;
779 : : } capa_names[] = {
780 : : { RTE_DMA_CAPA_MEM_TO_MEM, "mem2mem" },
781 : : { RTE_DMA_CAPA_MEM_TO_DEV, "mem2dev" },
782 : : { RTE_DMA_CAPA_DEV_TO_MEM, "dev2mem" },
783 : : { RTE_DMA_CAPA_DEV_TO_DEV, "dev2dev" },
784 : : { RTE_DMA_CAPA_SVA, "sva" },
785 : : { RTE_DMA_CAPA_SILENT, "silent" },
786 : : { RTE_DMA_CAPA_HANDLES_ERRORS, "handles_errors" },
787 : : { RTE_DMA_CAPA_M2D_AUTO_FREE, "m2d_auto_free" },
788 : : { RTE_DMA_CAPA_PRI_POLICY_SP, "pri_policy_sp" },
789 : : { RTE_DMA_CAPA_OPS_COPY, "copy" },
790 : : { RTE_DMA_CAPA_OPS_COPY_SG, "copy_sg" },
791 : : { RTE_DMA_CAPA_OPS_FILL, "fill" },
792 : : };
793 : :
794 : : const char *name = "unknown";
795 : : uint32_t i;
796 : :
797 [ # # # # : 0 : for (i = 0; i < RTE_DIM(capa_names); i++) {
# # # # #
# # # # #
# # # # #
# # # #
# ]
798 [ # # # # : 0 : if (capability == capa_names[i].capability) {
# # # # #
# # # # #
# # # # #
# # # #
# ]
799 : 0 : name = capa_names[i].name;
800 : 0 : break;
801 : : }
802 : : }
803 : :
804 : : return name;
805 : : }
806 : :
807 : : static void
808 : 0 : dma_dump_capability(FILE *f, uint64_t dev_capa)
809 : : {
810 : : uint64_t capa;
811 : :
812 : : (void)fprintf(f, " dev_capa: 0x%" PRIx64 " -", dev_capa);
813 [ # # ]: 0 : while (dev_capa > 0) {
814 : 0 : capa = 1ull << rte_ctz64(dev_capa);
815 : : (void)fprintf(f, " %s", dma_capability_name(capa));
816 : 0 : dev_capa &= ~capa;
817 : : }
818 : : (void)fprintf(f, "\n");
819 : 0 : }
820 : :
821 : : int
822 : 0 : rte_dma_dump(int16_t dev_id, FILE *f)
823 : : {
824 : : const struct rte_dma_dev *dev;
825 : : struct rte_dma_info dev_info;
826 : : int ret;
827 : :
828 [ # # # # ]: 0 : if (!rte_dma_is_valid(dev_id) || f == NULL)
829 : : return -EINVAL;
830 : 0 : dev = &rte_dma_devices[dev_id];
831 : :
832 : 0 : ret = rte_dma_info_get(dev_id, &dev_info);
833 [ # # ]: 0 : if (ret != 0) {
834 : 0 : RTE_DMA_LOG(ERR, "Device %d get device info fail", dev_id);
835 : 0 : return -EINVAL;
836 : : }
837 : :
838 : 0 : (void)fprintf(f, "DMA Dev %d, '%s' [%s]\n",
839 : 0 : dev->data->dev_id,
840 : 0 : dev->data->dev_name,
841 [ # # ]: 0 : dev->data->dev_started ? "started" : "stopped");
842 : 0 : dma_dump_capability(f, dev_info.dev_capa);
843 : 0 : (void)fprintf(f, " max_vchans_supported: %u\n", dev_info.max_vchans);
844 : 0 : (void)fprintf(f, " nb_vchans_configured: %u\n", dev_info.nb_vchans);
845 : 0 : (void)fprintf(f, " silent_mode: %s\n",
846 [ # # ]: 0 : dev->data->dev_conf.enable_silent ? "on" : "off");
847 : :
848 [ # # ]: 0 : if (dev->dev_ops->dev_dump != NULL)
849 : 0 : ret = dev->dev_ops->dev_dump(dev, f);
850 : 0 : rte_dma_trace_dump(dev_id, f, ret);
851 : :
852 : 0 : return ret;
853 : : }
854 : :
855 : : static int
856 : 0 : dummy_copy(__rte_unused void *dev_private, __rte_unused uint16_t vchan,
857 : : __rte_unused rte_iova_t src, __rte_unused rte_iova_t dst,
858 : : __rte_unused uint32_t length, __rte_unused uint64_t flags)
859 : : {
860 : 0 : RTE_DMA_LOG(ERR, "copy is not configured or not supported.");
861 : 0 : return -EINVAL;
862 : : }
863 : :
864 : : static int
865 : 0 : dummy_copy_sg(__rte_unused void *dev_private, __rte_unused uint16_t vchan,
866 : : __rte_unused const struct rte_dma_sge *src,
867 : : __rte_unused const struct rte_dma_sge *dst,
868 : : __rte_unused uint16_t nb_src, __rte_unused uint16_t nb_dst,
869 : : __rte_unused uint64_t flags)
870 : : {
871 : 0 : RTE_DMA_LOG(ERR, "copy_sg is not configured or not supported.");
872 : 0 : return -EINVAL;
873 : : }
874 : :
875 : : static int
876 : 0 : dummy_fill(__rte_unused void *dev_private, __rte_unused uint16_t vchan,
877 : : __rte_unused uint64_t pattern, __rte_unused rte_iova_t dst,
878 : : __rte_unused uint32_t length, __rte_unused uint64_t flags)
879 : : {
880 : 0 : RTE_DMA_LOG(ERR, "fill is not configured or not supported.");
881 : 0 : return -EINVAL;
882 : : }
883 : :
884 : : static int
885 : 0 : dummy_submit(__rte_unused void *dev_private, __rte_unused uint16_t vchan)
886 : : {
887 : 0 : RTE_DMA_LOG(ERR, "submit is not configured or not supported.");
888 : 0 : return -EINVAL;
889 : : }
890 : :
891 : : static uint16_t
892 : 0 : dummy_completed(__rte_unused void *dev_private, __rte_unused uint16_t vchan,
893 : : __rte_unused const uint16_t nb_cpls,
894 : : __rte_unused uint16_t *last_idx, __rte_unused bool *has_error)
895 : : {
896 : 0 : RTE_DMA_LOG(ERR, "completed is not configured or not supported.");
897 : 0 : return 0;
898 : : }
899 : :
900 : : static uint16_t
901 : 0 : dummy_completed_status(__rte_unused void *dev_private,
902 : : __rte_unused uint16_t vchan,
903 : : __rte_unused const uint16_t nb_cpls,
904 : : __rte_unused uint16_t *last_idx,
905 : : __rte_unused enum rte_dma_status_code *status)
906 : : {
907 : 0 : RTE_DMA_LOG(ERR,
908 : : "completed_status is not configured or not supported.");
909 : 0 : return 0;
910 : : }
911 : :
912 : : static uint16_t
913 : 0 : dummy_burst_capacity(__rte_unused const void *dev_private,
914 : : __rte_unused uint16_t vchan)
915 : : {
916 : 0 : RTE_DMA_LOG(ERR, "burst_capacity is not configured or not supported.");
917 : 0 : return 0;
918 : : }
919 : :
920 : : static void
921 : : dma_fp_object_dummy(struct rte_dma_fp_object *obj)
922 : : {
923 : 66 : obj->dev_private = NULL;
924 : 66 : obj->copy = dummy_copy;
925 : 66 : obj->copy_sg = dummy_copy_sg;
926 : 66 : obj->fill = dummy_fill;
927 : 66 : obj->submit = dummy_submit;
928 : 66 : obj->completed = dummy_completed;
929 : 66 : obj->completed_status = dummy_completed_status;
930 : 64 : obj->burst_capacity = dummy_burst_capacity;
931 : 1 : }
932 : :
933 : : static int
934 : 0 : dmadev_handle_dev_list(const char *cmd __rte_unused,
935 : : const char *params __rte_unused,
936 : : struct rte_tel_data *d)
937 : : {
938 : : int dev_id;
939 : :
940 : 0 : rte_tel_data_start_array(d, RTE_TEL_INT_VAL);
941 [ # # ]: 0 : for (dev_id = 0; dev_id < dma_devices_max; dev_id++)
942 [ # # ]: 0 : if (rte_dma_is_valid(dev_id))
943 : 0 : rte_tel_data_add_array_int(d, dev_id);
944 : :
945 : 0 : return 0;
946 : : }
947 : :
948 : : #define ADD_CAPA(td, dc, c) rte_tel_data_add_dict_int(td, dma_capability_name(c), !!(dc & c))
949 : :
950 : : static int
951 : 0 : dmadev_handle_dev_info(const char *cmd __rte_unused,
952 : : const char *params, struct rte_tel_data *d)
953 : : {
954 : : struct rte_dma_info dma_info;
955 : : struct rte_tel_data *dma_caps;
956 : : int dev_id, ret;
957 : : uint64_t dev_capa;
958 : : char *end_param;
959 : :
960 [ # # # # : 0 : if (params == NULL || strlen(params) == 0 || !isdigit(*params))
# # ]
961 : : return -EINVAL;
962 : :
963 : 0 : dev_id = strtoul(params, &end_param, 0);
964 [ # # ]: 0 : if (*end_param != '\0')
965 : 0 : RTE_DMA_LOG(WARNING, "Extra parameters passed to dmadev telemetry command, ignoring");
966 : :
967 : : /* Function info_get validates dev_id so we don't need to. */
968 : 0 : ret = rte_dma_info_get(dev_id, &dma_info);
969 [ # # ]: 0 : if (ret < 0)
970 : : return -EINVAL;
971 : 0 : dev_capa = dma_info.dev_capa;
972 : :
973 : 0 : rte_tel_data_start_dict(d);
974 : 0 : rte_tel_data_add_dict_string(d, "name", dma_info.dev_name);
975 : 0 : rte_tel_data_add_dict_int(d, "nb_vchans", dma_info.nb_vchans);
976 : 0 : rte_tel_data_add_dict_int(d, "nb_priorities", dma_info.nb_priorities);
977 : 0 : rte_tel_data_add_dict_int(d, "numa_node", dma_info.numa_node);
978 : 0 : rte_tel_data_add_dict_int(d, "max_vchans", dma_info.max_vchans);
979 : 0 : rte_tel_data_add_dict_int(d, "max_desc", dma_info.max_desc);
980 : 0 : rte_tel_data_add_dict_int(d, "min_desc", dma_info.min_desc);
981 : 0 : rte_tel_data_add_dict_int(d, "max_sges", dma_info.max_sges);
982 : :
983 : 0 : dma_caps = rte_tel_data_alloc();
984 [ # # ]: 0 : if (!dma_caps)
985 : : return -ENOMEM;
986 : :
987 : 0 : rte_tel_data_start_dict(dma_caps);
988 : 0 : ADD_CAPA(dma_caps, dev_capa, RTE_DMA_CAPA_MEM_TO_MEM);
989 : 0 : ADD_CAPA(dma_caps, dev_capa, RTE_DMA_CAPA_MEM_TO_DEV);
990 : 0 : ADD_CAPA(dma_caps, dev_capa, RTE_DMA_CAPA_DEV_TO_MEM);
991 : 0 : ADD_CAPA(dma_caps, dev_capa, RTE_DMA_CAPA_DEV_TO_DEV);
992 : 0 : ADD_CAPA(dma_caps, dev_capa, RTE_DMA_CAPA_SVA);
993 : 0 : ADD_CAPA(dma_caps, dev_capa, RTE_DMA_CAPA_SILENT);
994 : 0 : ADD_CAPA(dma_caps, dev_capa, RTE_DMA_CAPA_HANDLES_ERRORS);
995 : 0 : ADD_CAPA(dma_caps, dev_capa, RTE_DMA_CAPA_M2D_AUTO_FREE);
996 : 0 : ADD_CAPA(dma_caps, dev_capa, RTE_DMA_CAPA_PRI_POLICY_SP);
997 : 0 : ADD_CAPA(dma_caps, dev_capa, RTE_DMA_CAPA_OPS_COPY);
998 : 0 : ADD_CAPA(dma_caps, dev_capa, RTE_DMA_CAPA_OPS_COPY_SG);
999 : 0 : ADD_CAPA(dma_caps, dev_capa, RTE_DMA_CAPA_OPS_FILL);
1000 : 0 : rte_tel_data_add_dict_container(d, "capabilities", dma_caps, 0);
1001 : :
1002 : 0 : return 0;
1003 : : }
1004 : :
1005 : : #define ADD_DICT_STAT(s) rte_tel_data_add_dict_uint(d, #s, dma_stats.s)
1006 : :
1007 : : static int
1008 : 0 : dmadev_handle_dev_stats(const char *cmd __rte_unused,
1009 : : const char *params,
1010 : : struct rte_tel_data *d)
1011 : : {
1012 : : struct rte_dma_info dma_info;
1013 : : struct rte_dma_stats dma_stats;
1014 : : int dev_id, ret, vchan_id;
1015 : : char *end_param;
1016 : : const char *vchan_param;
1017 : :
1018 [ # # # # : 0 : if (params == NULL || strlen(params) == 0 || !isdigit(*params))
# # ]
1019 : : return -EINVAL;
1020 : :
1021 : 0 : dev_id = strtoul(params, &end_param, 0);
1022 : :
1023 : : /* Function info_get validates dev_id so we don't need to. */
1024 : 0 : ret = rte_dma_info_get(dev_id, &dma_info);
1025 [ # # ]: 0 : if (ret < 0)
1026 : : return -EINVAL;
1027 : :
1028 : : /* If the device has one vchan the user does not need to supply the
1029 : : * vchan id and only the device id is needed, no extra parameters.
1030 : : */
1031 [ # # # # ]: 0 : if (dma_info.nb_vchans == 1 && *end_param == '\0')
1032 : : vchan_id = 0;
1033 : : else {
1034 : 0 : vchan_param = strtok(end_param, ",");
1035 [ # # # # : 0 : if (!vchan_param || strlen(vchan_param) == 0 || !isdigit(*vchan_param))
# # ]
1036 : : return -EINVAL;
1037 : :
1038 : 0 : vchan_id = strtoul(vchan_param, &end_param, 0);
1039 : : }
1040 [ # # ]: 0 : if (*end_param != '\0')
1041 : 0 : RTE_DMA_LOG(WARNING, "Extra parameters passed to dmadev telemetry command, ignoring");
1042 : :
1043 : 0 : ret = rte_dma_stats_get(dev_id, vchan_id, &dma_stats);
1044 [ # # ]: 0 : if (ret < 0)
1045 : : return -EINVAL;
1046 : :
1047 : 0 : rte_tel_data_start_dict(d);
1048 : 0 : ADD_DICT_STAT(submitted);
1049 : 0 : ADD_DICT_STAT(completed);
1050 : 0 : ADD_DICT_STAT(errors);
1051 : :
1052 : 0 : return 0;
1053 : : }
1054 : :
1055 : : #ifndef RTE_EXEC_ENV_WINDOWS
1056 : : static int
1057 : 0 : dmadev_handle_dev_dump(const char *cmd __rte_unused,
1058 : : const char *params,
1059 : : struct rte_tel_data *d)
1060 : : {
1061 : : char *buf, *end_param;
1062 : : int dev_id, ret;
1063 : : FILE *f;
1064 : :
1065 [ # # # # : 0 : if (params == NULL || strlen(params) == 0 || !isdigit(*params))
# # ]
1066 : : return -EINVAL;
1067 : :
1068 : 0 : dev_id = strtoul(params, &end_param, 0);
1069 [ # # ]: 0 : if (*end_param != '\0')
1070 : 0 : RTE_DMA_LOG(WARNING, "Extra parameters passed to dmadev telemetry command, ignoring");
1071 : :
1072 : 0 : buf = calloc(RTE_TEL_MAX_SINGLE_STRING_LEN, sizeof(char));
1073 [ # # ]: 0 : if (buf == NULL)
1074 : : return -ENOMEM;
1075 : :
1076 : 0 : f = fmemopen(buf, RTE_TEL_MAX_SINGLE_STRING_LEN - 1, "w+");
1077 [ # # ]: 0 : if (f == NULL) {
1078 : 0 : free(buf);
1079 : 0 : return -EINVAL;
1080 : : }
1081 : :
1082 : 0 : ret = rte_dma_dump(dev_id, f);
1083 : 0 : fclose(f);
1084 [ # # ]: 0 : if (ret == 0) {
1085 : 0 : rte_tel_data_start_dict(d);
1086 : 0 : rte_tel_data_string(d, buf);
1087 : : }
1088 : :
1089 : 0 : free(buf);
1090 : 0 : return ret;
1091 : : }
1092 : : #endif /* !RTE_EXEC_ENV_WINDOWS */
1093 : :
1094 : 252 : RTE_INIT(dmadev_init_telemetry)
1095 : : {
1096 : 252 : rte_telemetry_register_cmd("/dmadev/list", dmadev_handle_dev_list,
1097 : : "Returns list of available dmadev devices by IDs. No parameters.");
1098 : 252 : rte_telemetry_register_cmd("/dmadev/info", dmadev_handle_dev_info,
1099 : : "Returns information for a dmadev. Parameters: int dev_id");
1100 : 252 : rte_telemetry_register_cmd("/dmadev/stats", dmadev_handle_dev_stats,
1101 : : "Returns the stats for a dmadev vchannel. Parameters: int dev_id, vchan_id (Optional if only one vchannel)");
1102 : : #ifndef RTE_EXEC_ENV_WINDOWS
1103 : 252 : rte_telemetry_register_cmd("/dmadev/dump", dmadev_handle_dev_dump,
1104 : : "Returns dump information for a dmadev. Parameters: int dev_id");
1105 : : #endif
1106 : 252 : }
|
