lib/librte_rawdev/rte_rawdev.c

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