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