Branch data Line data Source code
1 : : /* SPDX-License-Identifier: BSD-3-Clause
2 : : * Copyright 2017 NXP
3 : : */
4 : :
5 : : #include <ctype.h>
6 : : #include <stdio.h>
7 : : #include <stdlib.h>
8 : : #include <string.h>
9 : : #include <errno.h>
10 : : #include <stdint.h>
11 : : #include <inttypes.h>
12 : :
13 : : #include <rte_string_fns.h>
14 : : #include <rte_log.h>
15 : : #include <dev_driver.h>
16 : : #include <rte_common.h>
17 : : #include <rte_malloc.h>
18 : : #include <rte_telemetry.h>
19 : :
20 : : #include "rte_rawdev.h"
21 : : #include "rte_rawdev_pmd.h"
22 : :
23 : : static struct rte_rawdev rte_rawdevices[RTE_RAWDEV_MAX_DEVS];
24 : :
25 : : struct rte_rawdev *rte_rawdevs = rte_rawdevices;
26 : :
27 : : static struct rte_rawdev_global rawdev_globals = {
28 : : .nb_devs = 0
29 : : };
30 : :
31 : : /* Raw device, northbound API implementation */
32 : : uint8_t
33 : 3 : rte_rawdev_count(void)
34 : : {
35 : 3 : return rawdev_globals.nb_devs;
36 : : }
37 : :
38 : : uint16_t
39 : 2 : rte_rawdev_get_dev_id(const char *name)
40 : : {
41 : : uint16_t i;
42 : :
43 [ + - ]: 2 : if (!name)
44 : : return -EINVAL;
45 : :
46 [ + + ]: 3 : for (i = 0; i < rawdev_globals.nb_devs; i++)
47 [ + + ]: 2 : if ((strcmp(rte_rawdevices[i].name, name)
48 : 1 : == 0) &&
49 [ + - ]: 1 : (rte_rawdevices[i].attached ==
50 : : RTE_RAWDEV_ATTACHED))
51 : 1 : return i;
52 : : return -ENODEV;
53 : : }
54 : :
55 : : int
56 : 2 : rte_rawdev_socket_id(uint16_t dev_id)
57 : : {
58 : : struct rte_rawdev *dev;
59 : :
60 [ + + ]: 2 : RTE_RAWDEV_VALID_DEVID_OR_ERR_RET(dev_id, -EINVAL);
61 : 1 : dev = &rte_rawdevs[dev_id];
62 : :
63 : 1 : return dev->socket_id;
64 : : }
65 : :
66 : : int
67 : 11 : rte_rawdev_info_get(uint16_t dev_id, struct rte_rawdev_info *dev_info,
68 : : size_t dev_private_size)
69 : : {
70 : : struct rte_rawdev *rawdev;
71 : : int ret = 0;
72 : :
73 [ + - ]: 11 : RTE_RAWDEV_VALID_DEVID_OR_ERR_RET(dev_id, -EINVAL);
74 [ + + ]: 11 : if (dev_info == NULL)
75 : : return -EINVAL;
76 : :
77 : 10 : rawdev = &rte_rawdevs[dev_id];
78 : :
79 [ + - ]: 10 : if (dev_info->dev_private != NULL) {
80 [ + - ]: 10 : if (rawdev->dev_ops->dev_info_get == NULL)
81 : : return -ENOTSUP;
82 : 10 : ret = rawdev->dev_ops->dev_info_get(rawdev,
83 : : dev_info->dev_private,
84 : : dev_private_size);
85 : : }
86 : :
87 : 10 : dev_info->driver_name = rawdev->driver_name;
88 : 10 : dev_info->device = rawdev->device;
89 : 10 : dev_info->socket_id = rawdev->socket_id;
90 : :
91 : 10 : return ret;
92 : : }
93 : :
94 : : int
95 : 6 : rte_rawdev_configure(uint16_t dev_id, struct rte_rawdev_info *dev_conf,
96 : : size_t dev_private_size)
97 : : {
98 : : struct rte_rawdev *dev;
99 : : int diag;
100 : :
101 [ + - ]: 6 : RTE_RAWDEV_VALID_DEVID_OR_ERR_RET(dev_id, -EINVAL);
102 [ + + ]: 6 : if (dev_conf == NULL)
103 : : return -EINVAL;
104 : :
105 : 3 : dev = &rte_rawdevs[dev_id];
106 : :
107 [ + - ]: 3 : if (dev->dev_ops->dev_configure == NULL)
108 : : return -ENOTSUP;
109 : :
110 [ - + ]: 3 : if (dev->started) {
111 : 0 : RTE_RDEV_ERR(
112 : : "device %d must be stopped to allow configuration", dev_id);
113 : 0 : return -EBUSY;
114 : : }
115 : :
116 : : /* Configure the device */
117 : 3 : diag = dev->dev_ops->dev_configure(dev, dev_conf->dev_private, dev_private_size);
118 [ - + ]: 3 : if (diag != 0)
119 : 0 : RTE_RDEV_ERR("dev%d dev_configure = %d", dev_id, diag);
120 : : else
121 : 3 : dev->attached = 1;
122 : :
123 : : return diag;
124 : : }
125 : :
126 : : int
127 : 5 : rte_rawdev_queue_conf_get(uint16_t dev_id,
128 : : uint16_t queue_id,
129 : : rte_rawdev_obj_t queue_conf,
130 : : size_t queue_conf_size)
131 : : {
132 : : struct rte_rawdev *dev;
133 : :
134 [ + - ]: 5 : RTE_RAWDEV_VALID_DEVID_OR_ERR_RET(dev_id, -EINVAL);
135 : 5 : dev = &rte_rawdevs[dev_id];
136 : :
137 [ + - ]: 5 : if (dev->dev_ops->queue_def_conf == NULL)
138 : : return -ENOTSUP;
139 : 5 : return dev->dev_ops->queue_def_conf(dev, queue_id, queue_conf, queue_conf_size);
140 : : }
141 : :
142 : : int
143 : 3 : rte_rawdev_queue_setup(uint16_t dev_id,
144 : : uint16_t queue_id,
145 : : rte_rawdev_obj_t queue_conf,
146 : : size_t queue_conf_size)
147 : : {
148 : : struct rte_rawdev *dev;
149 : :
150 [ + - ]: 3 : RTE_RAWDEV_VALID_DEVID_OR_ERR_RET(dev_id, -EINVAL);
151 : 3 : dev = &rte_rawdevs[dev_id];
152 : :
153 [ + - ]: 3 : if (dev->dev_ops->queue_setup == NULL)
154 : : return -ENOTSUP;
155 : 3 : return dev->dev_ops->queue_setup(dev, queue_id, queue_conf, queue_conf_size);
156 : : }
157 : :
158 : : int
159 : 1 : rte_rawdev_queue_release(uint16_t dev_id, uint16_t queue_id)
160 : : {
161 : : struct rte_rawdev *dev;
162 : :
163 [ + - ]: 1 : RTE_RAWDEV_VALID_DEVID_OR_ERR_RET(dev_id, -EINVAL);
164 : 1 : dev = &rte_rawdevs[dev_id];
165 : :
166 [ + - ]: 1 : if (dev->dev_ops->queue_release == NULL)
167 : : return -ENOTSUP;
168 : 1 : return dev->dev_ops->queue_release(dev, queue_id);
169 : : }
170 : :
171 : : uint16_t
172 : 1 : rte_rawdev_queue_count(uint16_t dev_id)
173 : : {
174 : : struct rte_rawdev *dev;
175 : :
176 [ + - ]: 1 : RTE_RAWDEV_VALID_DEVID_OR_ERR_RET(dev_id, -EINVAL);
177 : 1 : dev = &rte_rawdevs[dev_id];
178 : :
179 [ + - ]: 1 : if (dev->dev_ops->queue_count == NULL)
180 : : return -ENOTSUP;
181 : 1 : return dev->dev_ops->queue_count(dev);
182 : : }
183 : :
184 : : int
185 : 2 : rte_rawdev_get_attr(uint16_t dev_id,
186 : : const char *attr_name,
187 : : uint64_t *attr_value)
188 : : {
189 : : struct rte_rawdev *dev;
190 : :
191 [ + - ]: 2 : RTE_RAWDEV_VALID_DEVID_OR_ERR_RET(dev_id, -EINVAL);
192 : 2 : dev = &rte_rawdevs[dev_id];
193 : :
194 [ + - ]: 2 : if (dev->dev_ops->attr_get == NULL)
195 : : return -ENOTSUP;
196 : 2 : return dev->dev_ops->attr_get(dev, attr_name, attr_value);
197 : : }
198 : :
199 : : int
200 : 2 : rte_rawdev_set_attr(uint16_t dev_id,
201 : : const char *attr_name,
202 : : const uint64_t attr_value)
203 : : {
204 : : struct rte_rawdev *dev;
205 : :
206 [ + - ]: 2 : RTE_RAWDEV_VALID_DEVID_OR_ERR_RET(dev_id, -EINVAL);
207 : 2 : dev = &rte_rawdevs[dev_id];
208 : :
209 [ + - ]: 2 : if (dev->dev_ops->attr_set == NULL)
210 : : return -ENOTSUP;
211 : 2 : return dev->dev_ops->attr_set(dev, attr_name, attr_value);
212 : : }
213 : :
214 : : int
215 : 1 : rte_rawdev_enqueue_buffers(uint16_t dev_id,
216 : : struct rte_rawdev_buf **buffers,
217 : : unsigned int count,
218 : : rte_rawdev_obj_t context)
219 : : {
220 : : struct rte_rawdev *dev;
221 : :
222 [ + - ]: 1 : RTE_RAWDEV_VALID_DEVID_OR_ERR_RET(dev_id, -EINVAL);
223 : 1 : dev = &rte_rawdevs[dev_id];
224 : :
225 [ + - ]: 1 : if (dev->dev_ops->enqueue_bufs == NULL)
226 : : return -ENOTSUP;
227 : 1 : return dev->dev_ops->enqueue_bufs(dev, buffers, count, context);
228 : : }
229 : :
230 : : int
231 : 1 : rte_rawdev_dequeue_buffers(uint16_t dev_id,
232 : : struct rte_rawdev_buf **buffers,
233 : : unsigned int count,
234 : : rte_rawdev_obj_t context)
235 : : {
236 : : struct rte_rawdev *dev;
237 : :
238 [ + - ]: 1 : RTE_RAWDEV_VALID_DEVID_OR_ERR_RET(dev_id, -EINVAL);
239 : 1 : dev = &rte_rawdevs[dev_id];
240 : :
241 [ + - ]: 1 : if (dev->dev_ops->dequeue_bufs == NULL)
242 : : return -ENOTSUP;
243 : 1 : return dev->dev_ops->dequeue_bufs(dev, buffers, count, context);
244 : : }
245 : :
246 : : int
247 : 0 : rte_rawdev_dump(uint16_t dev_id, FILE *f)
248 : : {
249 : : struct rte_rawdev *dev;
250 : :
251 [ # # ]: 0 : RTE_RAWDEV_VALID_DEVID_OR_ERR_RET(dev_id, -EINVAL);
252 : 0 : dev = &rte_rawdevs[dev_id];
253 : :
254 [ # # ]: 0 : if (dev->dev_ops->dump == NULL)
255 : : return -ENOTSUP;
256 : 0 : return dev->dev_ops->dump(dev, f);
257 : : }
258 : :
259 : : static int
260 : : xstats_get_count(uint16_t dev_id)
261 : : {
262 : 0 : struct rte_rawdev *dev = &rte_rawdevs[dev_id];
263 : :
264 [ # # ]: 0 : if (dev->dev_ops->xstats_get_names == NULL)
265 : : return -ENOTSUP;
266 : 0 : return dev->dev_ops->xstats_get_names(dev, NULL, 0);
267 : : }
268 : :
269 : : int
270 : 0 : rte_rawdev_xstats_names_get(uint16_t dev_id,
271 : : struct rte_rawdev_xstats_name *xstats_names,
272 : : unsigned int size)
273 : : {
274 : : const struct rte_rawdev *dev;
275 : : int cnt_expected_entries;
276 : :
277 [ # # ]: 0 : RTE_RAWDEV_VALID_DEVID_OR_ERR_RET(dev_id, -ENODEV);
278 : :
279 : : cnt_expected_entries = xstats_get_count(dev_id);
280 : :
281 [ # # ]: 0 : if (xstats_names == NULL || cnt_expected_entries < 0 ||
282 [ # # ]: 0 : (int)size < cnt_expected_entries || size <= 0)
283 : : return cnt_expected_entries;
284 : :
285 : 0 : dev = &rte_rawdevs[dev_id];
286 : :
287 [ # # ]: 0 : if (dev->dev_ops->xstats_get_names == NULL)
288 : : return -ENOTSUP;
289 : 0 : return dev->dev_ops->xstats_get_names(dev, xstats_names, size);
290 : : }
291 : :
292 : : /* retrieve rawdev extended statistics */
293 : : int
294 : 0 : rte_rawdev_xstats_get(uint16_t dev_id,
295 : : const unsigned int ids[],
296 : : uint64_t values[],
297 : : unsigned int n)
298 : : {
299 [ # # ]: 0 : RTE_RAWDEV_VALID_DEVID_OR_ERR_RET(dev_id, -ENODEV);
300 : 0 : const struct rte_rawdev *dev = &rte_rawdevs[dev_id];
301 : :
302 [ # # ]: 0 : if (dev->dev_ops->xstats_get == NULL)
303 : : return -ENOTSUP;
304 : 0 : return dev->dev_ops->xstats_get(dev, ids, values, n);
305 : : }
306 : :
307 : : uint64_t
308 : 0 : rte_rawdev_xstats_by_name_get(uint16_t dev_id,
309 : : const char *name,
310 : : unsigned int *id)
311 : : {
312 [ # # ]: 0 : RTE_RAWDEV_VALID_DEVID_OR_ERR_RET(dev_id, 0);
313 : 0 : const struct rte_rawdev *dev = &rte_rawdevs[dev_id];
314 : 0 : unsigned int temp = -1;
315 : :
316 [ # # ]: 0 : if (id != NULL)
317 : 0 : *id = (unsigned int)-1;
318 : : else
319 : : id = &temp; /* driver never gets a NULL value */
320 : :
321 : : /* implemented by driver */
322 [ # # ]: 0 : if (dev->dev_ops->xstats_get_by_name == NULL)
323 : : return -ENOTSUP;
324 : 0 : return dev->dev_ops->xstats_get_by_name(dev, name, id);
325 : : }
326 : :
327 : : int
328 : 0 : rte_rawdev_xstats_reset(uint16_t dev_id,
329 : : const uint32_t ids[], uint32_t nb_ids)
330 : : {
331 [ # # ]: 0 : RTE_RAWDEV_VALID_DEVID_OR_ERR_RET(dev_id, -EINVAL);
332 : 0 : struct rte_rawdev *dev = &rte_rawdevs[dev_id];
333 : :
334 [ # # ]: 0 : if (dev->dev_ops->xstats_reset == NULL)
335 : : return -ENOTSUP;
336 : 0 : return dev->dev_ops->xstats_reset(dev, ids, nb_ids);
337 : : }
338 : :
339 : : int
340 : 0 : rte_rawdev_firmware_status_get(uint16_t dev_id, rte_rawdev_obj_t status_info)
341 : : {
342 [ # # ]: 0 : RTE_RAWDEV_VALID_DEVID_OR_ERR_RET(dev_id, -EINVAL);
343 : 0 : struct rte_rawdev *dev = &rte_rawdevs[dev_id];
344 : :
345 [ # # ]: 0 : if (dev->dev_ops->firmware_status_get == NULL)
346 : : return -ENOTSUP;
347 : 0 : return dev->dev_ops->firmware_status_get(dev, status_info);
348 : : }
349 : :
350 : : int
351 : 0 : rte_rawdev_firmware_version_get(uint16_t dev_id, rte_rawdev_obj_t version_info)
352 : : {
353 [ # # ]: 0 : RTE_RAWDEV_VALID_DEVID_OR_ERR_RET(dev_id, -EINVAL);
354 : 0 : struct rte_rawdev *dev = &rte_rawdevs[dev_id];
355 : :
356 [ # # ]: 0 : if (dev->dev_ops->firmware_version_get == NULL)
357 : : return -ENOTSUP;
358 : 0 : return dev->dev_ops->firmware_version_get(dev, version_info);
359 : : }
360 : :
361 : : int
362 : 1 : rte_rawdev_firmware_load(uint16_t dev_id, rte_rawdev_obj_t firmware_image)
363 : : {
364 [ + - ]: 1 : RTE_RAWDEV_VALID_DEVID_OR_ERR_RET(dev_id, -EINVAL);
365 : 1 : struct rte_rawdev *dev = &rte_rawdevs[dev_id];
366 : :
367 [ + - ]: 1 : if (!firmware_image)
368 : : return -EINVAL;
369 : :
370 [ + - ]: 1 : if (dev->dev_ops->firmware_load == NULL)
371 : : return -ENOTSUP;
372 : 1 : return dev->dev_ops->firmware_load(dev, firmware_image);
373 : : }
374 : :
375 : : int
376 : 1 : rte_rawdev_firmware_unload(uint16_t dev_id)
377 : : {
378 [ + - ]: 1 : RTE_RAWDEV_VALID_DEVID_OR_ERR_RET(dev_id, -EINVAL);
379 : 1 : struct rte_rawdev *dev = &rte_rawdevs[dev_id];
380 : :
381 [ + - ]: 1 : if (dev->dev_ops->firmware_load == NULL)
382 : : return -ENOTSUP;
383 : 1 : return dev->dev_ops->firmware_unload(dev);
384 : : }
385 : :
386 : : int
387 : 1 : rte_rawdev_selftest(uint16_t dev_id)
388 : : {
389 [ + - ]: 1 : RTE_RAWDEV_VALID_DEVID_OR_ERR_RET(dev_id, -EINVAL);
390 : 1 : struct rte_rawdev *dev = &rte_rawdevs[dev_id];
391 : :
392 [ + - ]: 1 : if (dev->dev_ops->dev_selftest == NULL)
393 : : return -ENOTSUP;
394 : 1 : return dev->dev_ops->dev_selftest(dev_id);
395 : : }
396 : :
397 : : int
398 : 1 : rte_rawdev_start(uint16_t dev_id)
399 : : {
400 : : struct rte_rawdev *dev;
401 : : int diag;
402 : :
403 : 1 : RTE_RDEV_DEBUG("Start dev_id=%" PRIu8, dev_id);
404 : :
405 [ + - ]: 1 : RTE_RAWDEV_VALID_DEVID_OR_ERR_RET(dev_id, -EINVAL);
406 : 1 : dev = &rte_rawdevs[dev_id];
407 [ - + ]: 1 : if (dev->started != 0) {
408 : 0 : RTE_RDEV_ERR("Device with dev_id=%" PRIu8 "already started",
409 : : dev_id);
410 : 0 : return 0;
411 : : }
412 : :
413 [ - + ]: 1 : if (dev->dev_ops->dev_start == NULL)
414 : 0 : goto mark_started;
415 : :
416 : 1 : diag = dev->dev_ops->dev_start(dev);
417 [ + - ]: 1 : if (diag != 0)
418 : : return diag;
419 : :
420 : 1 : mark_started:
421 : 1 : dev->started = 1;
422 : 1 : return 0;
423 : : }
424 : :
425 : : void
426 : 1 : rte_rawdev_stop(uint16_t dev_id)
427 : : {
428 : : struct rte_rawdev *dev;
429 : :
430 : 1 : RTE_RDEV_DEBUG("Stop dev_id=%" PRIu8, dev_id);
431 : :
432 [ + - ]: 1 : RTE_RAWDEV_VALID_DEVID_OR_RET(dev_id);
433 : 1 : dev = &rte_rawdevs[dev_id];
434 : :
435 [ - + ]: 1 : if (dev->started == 0) {
436 : 0 : RTE_RDEV_ERR("Device with dev_id=%" PRIu8 "already stopped",
437 : : dev_id);
438 : 0 : return;
439 : : }
440 : :
441 [ - + ]: 1 : if (dev->dev_ops->dev_stop == NULL)
442 : 0 : goto mark_stopped;
443 : :
444 : 1 : dev->dev_ops->dev_stop(dev);
445 : :
446 : 1 : mark_stopped:
447 : 1 : dev->started = 0;
448 : : }
449 : :
450 : : int
451 : 2 : rte_rawdev_close(uint16_t dev_id)
452 : : {
453 : : struct rte_rawdev *dev;
454 : :
455 [ + - ]: 2 : RTE_RAWDEV_VALID_DEVID_OR_ERR_RET(dev_id, -EINVAL);
456 : 2 : dev = &rte_rawdevs[dev_id];
457 : :
458 [ + - ]: 2 : if (dev->dev_ops->dev_close == NULL)
459 : : return -ENOTSUP;
460 : : /* Device must be stopped before it can be closed */
461 [ - + ]: 2 : if (dev->started == 1) {
462 : 0 : RTE_RDEV_ERR("Device %u must be stopped before closing",
463 : : dev_id);
464 : 0 : return -EBUSY;
465 : : }
466 : :
467 : 2 : return dev->dev_ops->dev_close(dev);
468 : : }
469 : :
470 : : int
471 : 0 : rte_rawdev_reset(uint16_t dev_id)
472 : : {
473 : : struct rte_rawdev *dev;
474 : :
475 [ # # ]: 0 : RTE_RAWDEV_VALID_DEVID_OR_ERR_RET(dev_id, -EINVAL);
476 : 0 : dev = &rte_rawdevs[dev_id];
477 : :
478 [ # # ]: 0 : if (dev->dev_ops->dev_reset == NULL)
479 : : return -ENOTSUP;
480 : : /* Reset is not dependent on state of the device */
481 : 0 : return dev->dev_ops->dev_reset(dev);
482 : : }
483 : :
484 : : static inline uint8_t
485 : : rte_rawdev_find_free_device_index(void)
486 : : {
487 : : uint16_t dev_id;
488 : :
489 [ + - ]: 2 : for (dev_id = 0; dev_id < RTE_RAWDEV_MAX_DEVS; dev_id++) {
490 [ + - ]: 2 : if (rte_rawdevs[dev_id].attached ==
491 : : RTE_RAWDEV_DETACHED)
492 : 2 : return dev_id;
493 : : }
494 : :
495 : : return RTE_RAWDEV_MAX_DEVS;
496 : : }
497 : :
498 : : struct rte_rawdev *
499 : 2 : rte_rawdev_pmd_allocate(const char *name, size_t dev_priv_size, int socket_id)
500 : : {
501 : : struct rte_rawdev *rawdev;
502 : : uint16_t dev_id;
503 : :
504 [ - + ]: 2 : if (rte_rawdev_pmd_get_named_dev(name) != NULL) {
505 : 0 : RTE_RDEV_ERR("Raw device with name %s already allocated!", name);
506 : 0 : return NULL;
507 : : }
508 : :
509 : 2 : dev_id = rte_rawdev_find_free_device_index();
510 [ - + ]: 2 : if (dev_id == RTE_RAWDEV_MAX_DEVS) {
511 : 0 : RTE_RDEV_ERR("Reached maximum number of raw devices");
512 : 0 : return NULL;
513 : : }
514 : :
515 : 2 : rawdev = &rte_rawdevs[dev_id];
516 : :
517 [ + - ]: 2 : if (dev_priv_size > 0) {
518 : 2 : rawdev->dev_private = rte_zmalloc_socket("rawdev private",
519 : : dev_priv_size,
520 : : RTE_CACHE_LINE_SIZE,
521 : : socket_id);
522 [ - + ]: 2 : if (!rawdev->dev_private) {
523 : 0 : RTE_RDEV_ERR("Unable to allocate memory for rawdev");
524 : 0 : return NULL;
525 : : }
526 : : }
527 : :
528 : 2 : rawdev->dev_id = dev_id;
529 : 2 : rawdev->socket_id = socket_id;
530 : 2 : rawdev->started = 0;
531 : 2 : strlcpy(rawdev->name, name, RTE_RAWDEV_NAME_MAX_LEN);
532 : :
533 : 2 : rawdev->attached = RTE_RAWDEV_ATTACHED;
534 : 2 : rawdev_globals.nb_devs++;
535 : :
536 : 2 : return rawdev;
537 : : }
538 : :
539 : : int
540 : 2 : rte_rawdev_pmd_release(struct rte_rawdev *rawdev)
541 : : {
542 : : int ret;
543 : :
544 [ + - ]: 2 : if (rawdev == NULL)
545 : : return -EINVAL;
546 : :
547 : 2 : ret = rte_rawdev_close(rawdev->dev_id);
548 [ + - ]: 2 : if (ret < 0)
549 : : return ret;
550 : :
551 : 2 : rawdev->attached = RTE_RAWDEV_DETACHED;
552 : 2 : rawdev_globals.nb_devs--;
553 : :
554 : 2 : rawdev->dev_id = 0;
555 : 2 : rawdev->socket_id = 0;
556 : 2 : rawdev->dev_ops = NULL;
557 [ + - ]: 2 : if (rawdev->dev_private) {
558 : 2 : rte_free(rawdev->dev_private);
559 : 2 : rawdev->dev_private = NULL;
560 : : }
561 : :
562 : : return 0;
563 : : }
564 : :
565 : : static int
566 : 0 : handle_dev_list(const char *cmd __rte_unused,
567 : : const char *params __rte_unused,
568 : : struct rte_tel_data *d)
569 : : {
570 : : int i;
571 : :
572 : 0 : rte_tel_data_start_array(d, RTE_TEL_INT_VAL);
573 [ # # ]: 0 : for (i = 0; i < rawdev_globals.nb_devs; i++)
574 [ # # ]: 0 : if (rte_rawdevices[i].attached == RTE_RAWDEV_ATTACHED)
575 : 0 : rte_tel_data_add_array_int(d, i);
576 : 0 : return 0;
577 : : }
578 : :
579 : : static int
580 : 0 : handle_dev_xstats(const char *cmd __rte_unused,
581 : : const char *params,
582 : : struct rte_tel_data *d)
583 : : {
584 : : uint64_t *rawdev_xstats;
585 : : struct rte_rawdev_xstats_name *xstat_names;
586 : : int dev_id, num_xstats, i, ret;
587 : : unsigned int *ids;
588 : : char *end_param;
589 : :
590 [ # # # # : 0 : if (params == NULL || strlen(params) == 0 || !isdigit(*params))
# # ]
591 : : return -1;
592 : :
593 : 0 : dev_id = strtoul(params, &end_param, 0);
594 [ # # ]: 0 : if (*end_param != '\0')
595 : 0 : RTE_RDEV_LOG(NOTICE,
596 : : "Extra parameters passed to rawdev telemetry command, ignoring");
597 [ # # ]: 0 : if (!rte_rawdev_pmd_is_valid_dev(dev_id))
598 : : return -1;
599 : :
600 [ # # ]: 0 : num_xstats = xstats_get_count(dev_id);
601 [ # # ]: 0 : if (num_xstats < 0)
602 : 0 : return -1;
603 : :
604 : : /* use one malloc for names, stats and ids */
605 : 0 : rawdev_xstats = malloc((sizeof(uint64_t) +
606 : : sizeof(struct rte_rawdev_xstats_name) +
607 : : sizeof(unsigned int)) * num_xstats);
608 [ # # ]: 0 : if (rawdev_xstats == NULL)
609 : : return -1;
610 : 0 : xstat_names = (void *)&rawdev_xstats[num_xstats];
611 : 0 : ids = (void *)&xstat_names[num_xstats];
612 : :
613 : 0 : ret = rte_rawdev_xstats_names_get(dev_id, xstat_names, num_xstats);
614 [ # # ]: 0 : if (ret < 0 || ret > num_xstats) {
615 : 0 : free(rawdev_xstats);
616 : 0 : return -1;
617 : : }
618 : :
619 [ # # ]: 0 : for (i = 0; i < num_xstats; i++)
620 : 0 : ids[i] = i;
621 : :
622 : 0 : ret = rte_rawdev_xstats_get(dev_id, ids, rawdev_xstats, num_xstats);
623 [ # # ]: 0 : if (ret < 0 || ret > num_xstats) {
624 : 0 : free(rawdev_xstats);
625 : 0 : return -1;
626 : : }
627 : :
628 : 0 : rte_tel_data_start_dict(d);
629 [ # # ]: 0 : for (i = 0; i < num_xstats; i++)
630 : 0 : rte_tel_data_add_dict_uint(d, xstat_names[i].name,
631 : 0 : rawdev_xstats[i]);
632 : :
633 : 0 : free(rawdev_xstats);
634 : 0 : return 0;
635 : : }
636 : :
637 : : static int
638 : 0 : handle_dev_dump(const char *cmd __rte_unused,
639 : : const char *params,
640 : : struct rte_tel_data *d)
641 : : {
642 : : char *buf, *end_param;
643 : : int dev_id, ret;
644 : : FILE *f;
645 : :
646 [ # # # # : 0 : if (params == NULL || strlen(params) == 0 || !isdigit(*params))
# # ]
647 : : return -EINVAL;
648 : :
649 : 0 : dev_id = strtoul(params, &end_param, 0);
650 [ # # ]: 0 : if (*end_param != '\0')
651 : 0 : RTE_RDEV_LOG(NOTICE,
652 : : "Extra parameters passed to rawdev telemetry command, ignoring");
653 [ # # ]: 0 : if (!rte_rawdev_pmd_is_valid_dev(dev_id))
654 : : return -EINVAL;
655 : :
656 : 0 : buf = calloc(RTE_TEL_MAX_SINGLE_STRING_LEN, sizeof(char));
657 [ # # ]: 0 : if (buf == NULL)
658 : : return -ENOMEM;
659 : :
660 : 0 : f = fmemopen(buf, RTE_TEL_MAX_SINGLE_STRING_LEN - 1, "w+");
661 [ # # ]: 0 : if (f == NULL) {
662 : 0 : free(buf);
663 : 0 : return -EINVAL;
664 : : }
665 : :
666 : 0 : ret = rte_rawdev_dump(dev_id, f);
667 : 0 : fclose(f);
668 [ # # ]: 0 : if (ret == 0) {
669 : 0 : rte_tel_data_start_dict(d);
670 : 0 : rte_tel_data_string(d, buf);
671 : : }
672 : :
673 : 0 : free(buf);
674 : 0 : return 0;
675 : : }
676 : :
677 [ - + ]: 252 : RTE_LOG_REGISTER_DEFAULT(librawdev_logtype, INFO);
678 : :
679 : 252 : RTE_INIT(librawdev_init_telemetry)
680 : : {
681 : 252 : rte_telemetry_register_cmd("/rawdev/list", handle_dev_list,
682 : : "Returns list of available rawdev ports. Takes no parameters");
683 : 252 : rte_telemetry_register_cmd("/rawdev/xstats", handle_dev_xstats,
684 : : "Returns the xstats for a rawdev port. Parameters: int port_id");
685 : 252 : rte_telemetry_register_cmd("/rawdev/dump", handle_dev_dump,
686 : : "Returns dump information for a rawdev port. Parameters: int port_id");
687 : 252 : }
|
