lib/librte_ethdev/rte_ethdev.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright(c) 2010-2017 Intel Corporation
   3  */
   4
   5 #include <sys/types.h>
   6 #include <sys/queue.h>
   7 #include <ctype.h>
   8 #include <stdio.h>
   9 #include <stdlib.h>
  10 #include <string.h>
  11 #include <stdarg.h>
  12 #include <errno.h>
  13 #include <stdbool.h>
  14 #include <stdint.h>
  15 #include <inttypes.h>
  16 #include <netinet/in.h>
  17
  18 #include <rte_byteorder.h>
  19 #include <rte_log.h>
  20 #include <rte_debug.h>
  21 #include <rte_interrupts.h>
  22 #include <rte_memory.h>
  23 #include <rte_memcpy.h>
  24 #include <rte_memzone.h>
  25 #include <rte_launch.h>
  26 #include <rte_eal.h>
  27 #include <rte_per_lcore.h>
  28 #include <rte_lcore.h>
  29 #include <rte_atomic.h>
  30 #include <rte_branch_prediction.h>
  31 #include <rte_common.h>
  32 #include <rte_mempool.h>
  33 #include <rte_malloc.h>
  34 #include <rte_mbuf.h>
  35 #include <rte_errno.h>
  36 #include <rte_spinlock.h>
  37 #include <rte_string_fns.h>
  38 #include <rte_kvargs.h>
  39 #include <rte_class.h>
  40 #include <rte_ether.h>
  41 #include <rte_telemetry.h>
  42
  43 #include "rte_ethdev_trace.h"
  44 #include "rte_ethdev.h"
  45 #include "rte_ethdev_driver.h"
  46 #include "ethdev_profile.h"
  47 #include "ethdev_private.h"
  48
  49 static const char *MZ_RTE_ETH_DEV_DATA = "rte_eth_dev_data";
  50 struct rte_eth_dev rte_eth_devices[RTE_MAX_ETHPORTS];
  51
  52 /* spinlock for eth device callbacks */
  53 static rte_spinlock_t rte_eth_dev_cb_lock = RTE_SPINLOCK_INITIALIZER;
  54
  55 /* spinlock for add/remove rx callbacks */
  56 static rte_spinlock_t rte_eth_rx_cb_lock = RTE_SPINLOCK_INITIALIZER;
  57
  58 /* spinlock for add/remove tx callbacks */
  59 static rte_spinlock_t rte_eth_tx_cb_lock = RTE_SPINLOCK_INITIALIZER;
  60
  61 /* spinlock for shared data allocation */
  62 static rte_spinlock_t rte_eth_shared_data_lock = RTE_SPINLOCK_INITIALIZER;
  63
  64 /* store statistics names and its offset in stats structure  */
  65 struct rte_eth_xstats_name_off {
  66         char name[RTE_ETH_XSTATS_NAME_SIZE];
  67         unsigned offset;
  68 };
  69
  70 /* Shared memory between primary and secondary processes. */
  71 static struct {
  72         uint64_t next_owner_id;
  73         rte_spinlock_t ownership_lock;
  74         struct rte_eth_dev_data data[RTE_MAX_ETHPORTS];
  75 } *rte_eth_dev_shared_data;
  76
  77 static const struct rte_eth_xstats_name_off rte_stats_strings[] = {
  78         {"rx_good_packets", offsetof(struct rte_eth_stats, ipackets)},
  79         {"tx_good_packets", offsetof(struct rte_eth_stats, opackets)},
  80         {"rx_good_bytes", offsetof(struct rte_eth_stats, ibytes)},
  81         {"tx_good_bytes", offsetof(struct rte_eth_stats, obytes)},
  82         {"rx_missed_errors", offsetof(struct rte_eth_stats, imissed)},
  83         {"rx_errors", offsetof(struct rte_eth_stats, ierrors)},
  84         {"tx_errors", offsetof(struct rte_eth_stats, oerrors)},
  85         {"rx_mbuf_allocation_errors", offsetof(struct rte_eth_stats,
  86                 rx_nombuf)},
  87 };
  88
  89 #define RTE_NB_STATS RTE_DIM(rte_stats_strings)
  90
  91 static const struct rte_eth_xstats_name_off rte_rxq_stats_strings[] = {
  92         {"packets", offsetof(struct rte_eth_stats, q_ipackets)},
  93         {"bytes", offsetof(struct rte_eth_stats, q_ibytes)},
  94         {"errors", offsetof(struct rte_eth_stats, q_errors)},
  95 };
  96
  97 #define RTE_NB_RXQ_STATS RTE_DIM(rte_rxq_stats_strings)
  98
  99 static const struct rte_eth_xstats_name_off rte_txq_stats_strings[] = {
 100         {"packets", offsetof(struct rte_eth_stats, q_opackets)},
 101         {"bytes", offsetof(struct rte_eth_stats, q_obytes)},
 102 };
 103 #define RTE_NB_TXQ_STATS RTE_DIM(rte_txq_stats_strings)
 104
 105 #define RTE_RX_OFFLOAD_BIT2STR(_name)   \
 106         { DEV_RX_OFFLOAD_##_name, #_name }
 107
 108 static const struct {
 109         uint64_t offload;
 110         const char *name;
 111 } rte_rx_offload_names[] = {
 112         RTE_RX_OFFLOAD_BIT2STR(VLAN_STRIP),
 113         RTE_RX_OFFLOAD_BIT2STR(IPV4_CKSUM),
 114         RTE_RX_OFFLOAD_BIT2STR(UDP_CKSUM),
 115         RTE_RX_OFFLOAD_BIT2STR(TCP_CKSUM),
 116         RTE_RX_OFFLOAD_BIT2STR(TCP_LRO),
 117         RTE_RX_OFFLOAD_BIT2STR(QINQ_STRIP),
 118         RTE_RX_OFFLOAD_BIT2STR(OUTER_IPV4_CKSUM),
 119         RTE_RX_OFFLOAD_BIT2STR(MACSEC_STRIP),
 120         RTE_RX_OFFLOAD_BIT2STR(HEADER_SPLIT),
 121         RTE_RX_OFFLOAD_BIT2STR(VLAN_FILTER),
 122         RTE_RX_OFFLOAD_BIT2STR(VLAN_EXTEND),
 123         RTE_RX_OFFLOAD_BIT2STR(JUMBO_FRAME),
 124         RTE_RX_OFFLOAD_BIT2STR(SCATTER),
 125         RTE_RX_OFFLOAD_BIT2STR(TIMESTAMP),
 126         RTE_RX_OFFLOAD_BIT2STR(SECURITY),
 127         RTE_RX_OFFLOAD_BIT2STR(KEEP_CRC),
 128         RTE_RX_OFFLOAD_BIT2STR(SCTP_CKSUM),
 129         RTE_RX_OFFLOAD_BIT2STR(OUTER_UDP_CKSUM),
 130         RTE_RX_OFFLOAD_BIT2STR(RSS_HASH),
 131 };
 132
 133 #undef RTE_RX_OFFLOAD_BIT2STR
 134
 135 #define RTE_TX_OFFLOAD_BIT2STR(_name)   \
 136         { DEV_TX_OFFLOAD_##_name, #_name }
 137
 138 static const struct {
 139         uint64_t offload;
 140         const char *name;
 141 } rte_tx_offload_names[] = {
 142         RTE_TX_OFFLOAD_BIT2STR(VLAN_INSERT),
 143         RTE_TX_OFFLOAD_BIT2STR(IPV4_CKSUM),
 144         RTE_TX_OFFLOAD_BIT2STR(UDP_CKSUM),
 145         RTE_TX_OFFLOAD_BIT2STR(TCP_CKSUM),
 146         RTE_TX_OFFLOAD_BIT2STR(SCTP_CKSUM),
 147         RTE_TX_OFFLOAD_BIT2STR(TCP_TSO),
 148         RTE_TX_OFFLOAD_BIT2STR(UDP_TSO),
 149         RTE_TX_OFFLOAD_BIT2STR(OUTER_IPV4_CKSUM),
 150         RTE_TX_OFFLOAD_BIT2STR(QINQ_INSERT),
 151         RTE_TX_OFFLOAD_BIT2STR(VXLAN_TNL_TSO),
 152         RTE_TX_OFFLOAD_BIT2STR(GRE_TNL_TSO),
 153         RTE_TX_OFFLOAD_BIT2STR(IPIP_TNL_TSO),
 154         RTE_TX_OFFLOAD_BIT2STR(GENEVE_TNL_TSO),
 155         RTE_TX_OFFLOAD_BIT2STR(MACSEC_INSERT),
 156         RTE_TX_OFFLOAD_BIT2STR(MT_LOCKFREE),
 157         RTE_TX_OFFLOAD_BIT2STR(MULTI_SEGS),
 158         RTE_TX_OFFLOAD_BIT2STR(MBUF_FAST_FREE),
 159         RTE_TX_OFFLOAD_BIT2STR(SECURITY),
 160         RTE_TX_OFFLOAD_BIT2STR(UDP_TNL_TSO),
 161         RTE_TX_OFFLOAD_BIT2STR(IP_TNL_TSO),
 162         RTE_TX_OFFLOAD_BIT2STR(OUTER_UDP_CKSUM),
 163 };
 164
 165 #undef RTE_TX_OFFLOAD_BIT2STR
 166
 167 /**
 168  * The user application callback description.
 169  *
 170  * It contains callback address to be registered by user application,
 171  * the pointer to the parameters for callback, and the event type.
 172  */
 173 struct rte_eth_dev_callback {
 174         TAILQ_ENTRY(rte_eth_dev_callback) next; /**< Callbacks list */
 175         rte_eth_dev_cb_fn cb_fn;                /**< Callback address */
 176         void *cb_arg;                           /**< Parameter for callback */
 177         void *ret_param;                        /**< Return parameter */
 178         enum rte_eth_event_type event;          /**< Interrupt event type */
 179         uint32_t active;                        /**< Callback is executing */
 180 };
 181
 182 enum {
 183         STAT_QMAP_TX = 0,
 184         STAT_QMAP_RX
 185 };
 186
 187 int
 188 rte_eth_iterator_init(struct rte_dev_iterator *iter, const char *devargs_str)
 189 {
 190         int ret;
 191         struct rte_devargs devargs = {.args = NULL};
 192         const char *bus_param_key;
 193         char *bus_str = NULL;
 194         char *cls_str = NULL;
 195         int str_size;
 196
 197         memset(iter, 0, sizeof(*iter));
 198
 199         /*
 200          * The devargs string may use various syntaxes:
 201          *   - 0000:08:00.0,representor=[1-3]
 202          *   - pci:0000:06:00.0,representor=[0,5]
 203          *   - class=eth,mac=00:11:22:33:44:55
 204          * A new syntax is in development (not yet supported):
 205          *   - bus=X,paramX=x/class=Y,paramY=y/driver=Z,paramZ=z
 206          */
 207
 208         /*
 209          * Handle pure class filter (i.e. without any bus-level argument),
 210          * from future new syntax.
 211          * rte_devargs_parse() is not yet supporting the new syntax,
 212          * that's why this simple case is temporarily parsed here.
 213          */
 214 #define iter_anybus_str "class=eth,"
 215         if (strncmp(devargs_str, iter_anybus_str,
 216                         strlen(iter_anybus_str)) == 0) {
 217                 iter->cls_str = devargs_str + strlen(iter_anybus_str);
 218                 goto end;
 219         }
 220
 221         /* Split bus, device and parameters. */
 222         ret = rte_devargs_parse(&devargs, devargs_str);
 223         if (ret != 0)
 224                 goto error;
 225
 226         /*
 227          * Assume parameters of old syntax can match only at ethdev level.
 228          * Extra parameters will be ignored, thanks to "+" prefix.
 229          */
 230         str_size = strlen(devargs.args) + 2;
 231         cls_str = malloc(str_size);
 232         if (cls_str == NULL) {
 233                 ret = -ENOMEM;
 234                 goto error;
 235         }
 236         ret = snprintf(cls_str, str_size, "+%s", devargs.args);
 237         if (ret != str_size - 1) {
 238                 ret = -EINVAL;
 239                 goto error;
 240         }
 241         iter->cls_str = cls_str;
 242         free(devargs.args); /* allocated by rte_devargs_parse() */
 243         devargs.args = NULL;
 244
 245         iter->bus = devargs.bus;
 246         if (iter->bus->dev_iterate == NULL) {
 247                 ret = -ENOTSUP;
 248                 goto error;
 249         }
 250
 251         /* Convert bus args to new syntax for use with new API dev_iterate. */
 252         if (strcmp(iter->bus->name, "vdev") == 0) {
 253                 bus_param_key = "name";
 254         } else if (strcmp(iter->bus->name, "pci") == 0) {
 255                 bus_param_key = "addr";
 256         } else {
 257                 ret = -ENOTSUP;
 258                 goto error;
 259         }
 260         str_size = strlen(bus_param_key) + strlen(devargs.name) + 2;
 261         bus_str = malloc(str_size);
 262         if (bus_str == NULL) {
 263                 ret = -ENOMEM;
 264                 goto error;
 265         }
 266         ret = snprintf(bus_str, str_size, "%s=%s",
 267                         bus_param_key, devargs.name);
 268         if (ret != str_size - 1) {
 269                 ret = -EINVAL;
 270                 goto error;
 271         }
 272         iter->bus_str = bus_str;
 273
 274 end:
 275         iter->cls = rte_class_find_by_name("eth");
 276         return 0;
 277
 278 error:
 279         if (ret == -ENOTSUP)
 280                 RTE_LOG(ERR, EAL, "Bus %s does not support iterating.\n",
 281                                 iter->bus->name);
 282         free(devargs.args);
 283         free(bus_str);
 284         free(cls_str);
 285         return ret;
 286 }
 287
 288 uint16_t
 289 rte_eth_iterator_next(struct rte_dev_iterator *iter)
 290 {
 291         if (iter->cls == NULL) /* invalid ethdev iterator */
 292                 return RTE_MAX_ETHPORTS;
 293
 294         do { /* loop to try all matching rte_device */
 295                 /* If not pure ethdev filter and */
 296                 if (iter->bus != NULL &&
 297                                 /* not in middle of rte_eth_dev iteration, */
 298                                 iter->class_device == NULL) {
 299                         /* get next rte_device to try. */
 300                         iter->device = iter->bus->dev_iterate(
 301                                         iter->device, iter->bus_str, iter);
 302                         if (iter->device == NULL)
 303                                 break; /* no more rte_device candidate */
 304                 }
 305                 /* A device is matching bus part, need to check ethdev part. */
 306                 iter->class_device = iter->cls->dev_iterate(
 307                                 iter->class_device, iter->cls_str, iter);
 308                 if (iter->class_device != NULL)
 309                         return eth_dev_to_id(iter->class_device); /* match */
 310         } while (iter->bus != NULL); /* need to try next rte_device */
 311
 312         /* No more ethdev port to iterate. */
 313         rte_eth_iterator_cleanup(iter);
 314         return RTE_MAX_ETHPORTS;
 315 }
 316
 317 void
 318 rte_eth_iterator_cleanup(struct rte_dev_iterator *iter)
 319 {
 320         if (iter->bus_str == NULL)
 321                 return; /* nothing to free in pure class filter */
 322         free(RTE_CAST_FIELD(iter, bus_str, char *)); /* workaround const */
 323         free(RTE_CAST_FIELD(iter, cls_str, char *)); /* workaround const */
 324         memset(iter, 0, sizeof(*iter));
 325 }
 326
 327 uint16_t
 328 rte_eth_find_next(uint16_t port_id)
 329 {
 330         while (port_id < RTE_MAX_ETHPORTS &&
 331                         rte_eth_devices[port_id].state == RTE_ETH_DEV_UNUSED)
 332                 port_id++;
 333
 334         if (port_id >= RTE_MAX_ETHPORTS)
 335                 return RTE_MAX_ETHPORTS;
 336
 337         return port_id;
 338 }
 339
 340 /*
 341  * Macro to iterate over all valid ports for internal usage.
 342  * Note: RTE_ETH_FOREACH_DEV is different because filtering owned ports.
 343  */
 344 #define RTE_ETH_FOREACH_VALID_DEV(port_id) \
 345         for (port_id = rte_eth_find_next(0); \
 346              port_id < RTE_MAX_ETHPORTS; \
 347              port_id = rte_eth_find_next(port_id + 1))
 348
 349 uint16_t
 350 rte_eth_find_next_of(uint16_t port_id, const struct rte_device *parent)
 351 {
 352         port_id = rte_eth_find_next(port_id);
 353         while (port_id < RTE_MAX_ETHPORTS &&
 354                         rte_eth_devices[port_id].device != parent)
 355                 port_id = rte_eth_find_next(port_id + 1);
 356
 357         return port_id;
 358 }
 359
 360 uint16_t
 361 rte_eth_find_next_sibling(uint16_t port_id, uint16_t ref_port_id)
 362 {
 363         RTE_ETH_VALID_PORTID_OR_ERR_RET(ref_port_id, RTE_MAX_ETHPORTS);
 364         return rte_eth_find_next_of(port_id,
 365                         rte_eth_devices[ref_port_id].device);
 366 }
 367
 368 static void
 369 rte_eth_dev_shared_data_prepare(void)
 370 {
 371         const unsigned flags = 0;
 372         const struct rte_memzone *mz;
 373
 374         rte_spinlock_lock(&rte_eth_shared_data_lock);
 375
 376         if (rte_eth_dev_shared_data == NULL) {
 377                 if (rte_eal_process_type() == RTE_PROC_PRIMARY) {
 378                         /* Allocate port data and ownership shared memory. */
 379                         mz = rte_memzone_reserve(MZ_RTE_ETH_DEV_DATA,
 380                                         sizeof(*rte_eth_dev_shared_data),
 381                                         rte_socket_id(), flags);
 382                 } else
 383                         mz = rte_memzone_lookup(MZ_RTE_ETH_DEV_DATA);
 384                 if (mz == NULL)
 385                         rte_panic("Cannot allocate ethdev shared data\n");
 386
 387                 rte_eth_dev_shared_data = mz->addr;
 388                 if (rte_eal_process_type() == RTE_PROC_PRIMARY) {
 389                         rte_eth_dev_shared_data->next_owner_id =
 390                                         RTE_ETH_DEV_NO_OWNER + 1;
 391                         rte_spinlock_init(&rte_eth_dev_shared_data->ownership_lock);
 392                         memset(rte_eth_dev_shared_data->data, 0,
 393                                sizeof(rte_eth_dev_shared_data->data));
 394                 }
 395         }
 396
 397         rte_spinlock_unlock(&rte_eth_shared_data_lock);
 398 }
 399
 400 static bool
 401 is_allocated(const struct rte_eth_dev *ethdev)
 402 {
 403         return ethdev->data->name[0] != '\0';
 404 }
 405
 406 static struct rte_eth_dev *
 407 _rte_eth_dev_allocated(const char *name)
 408 {
 409         unsigned i;
 410
 411         for (i = 0; i < RTE_MAX_ETHPORTS; i++) {
 412                 if (rte_eth_devices[i].data != NULL &&
 413                     strcmp(rte_eth_devices[i].data->name, name) == 0)
 414                         return &rte_eth_devices[i];
 415         }
 416         return NULL;
 417 }
 418
 419 struct rte_eth_dev *
 420 rte_eth_dev_allocated(const char *name)
 421 {
 422         struct rte_eth_dev *ethdev;
 423
 424         rte_eth_dev_shared_data_prepare();
 425
 426         rte_spinlock_lock(&rte_eth_dev_shared_data->ownership_lock);
 427
 428         ethdev = _rte_eth_dev_allocated(name);
 429
 430         rte_spinlock_unlock(&rte_eth_dev_shared_data->ownership_lock);
 431
 432         return ethdev;
 433 }
 434
 435 static uint16_t
 436 rte_eth_dev_find_free_port(void)
 437 {
 438         unsigned i;
 439
 440         for (i = 0; i < RTE_MAX_ETHPORTS; i++) {
 441                 /* Using shared name field to find a free port. */
 442                 if (rte_eth_dev_shared_data->data[i].name[0] == '\0') {
 443                         RTE_ASSERT(rte_eth_devices[i].state ==
 444                                    RTE_ETH_DEV_UNUSED);
 445                         return i;
 446                 }
 447         }
 448         return RTE_MAX_ETHPORTS;
 449 }
 450
 451 static struct rte_eth_dev *
 452 eth_dev_get(uint16_t port_id)
 453 {
 454         struct rte_eth_dev *eth_dev = &rte_eth_devices[port_id];
 455
 456         eth_dev->data = &rte_eth_dev_shared_data->data[port_id];
 457
 458         return eth_dev;
 459 }
 460
 461 struct rte_eth_dev *
 462 rte_eth_dev_allocate(const char *name)
 463 {
 464         uint16_t port_id;
 465         struct rte_eth_dev *eth_dev = NULL;
 466         size_t name_len;
 467
 468         name_len = strnlen(name, RTE_ETH_NAME_MAX_LEN);
 469         if (name_len == 0) {
 470                 RTE_ETHDEV_LOG(ERR, "Zero length Ethernet device name\n");
 471                 return NULL;
 472         }
 473
 474         if (name_len >= RTE_ETH_NAME_MAX_LEN) {
 475                 RTE_ETHDEV_LOG(ERR, "Ethernet device name is too long\n");
 476                 return NULL;
 477         }
 478
 479         rte_eth_dev_shared_data_prepare();
 480
 481         /* Synchronize port creation between primary and secondary threads. */
 482         rte_spinlock_lock(&rte_eth_dev_shared_data->ownership_lock);
 483
 484         if (_rte_eth_dev_allocated(name) != NULL) {
 485                 RTE_ETHDEV_LOG(ERR,
 486                         "Ethernet device with name %s already allocated\n",
 487                         name);
 488                 goto unlock;
 489         }
 490
 491         port_id = rte_eth_dev_find_free_port();
 492         if (port_id == RTE_MAX_ETHPORTS) {
 493                 RTE_ETHDEV_LOG(ERR,
 494                         "Reached maximum number of Ethernet ports\n");
 495                 goto unlock;
 496         }
 497
 498         eth_dev = eth_dev_get(port_id);
 499         strlcpy(eth_dev->data->name, name, sizeof(eth_dev->data->name));
 500         eth_dev->data->port_id = port_id;
 501         eth_dev->data->mtu = RTE_ETHER_MTU;
 502
 503 unlock:
 504         rte_spinlock_unlock(&rte_eth_dev_shared_data->ownership_lock);
 505
 506         return eth_dev;
 507 }
 508
 509 /*
 510  * Attach to a port already registered by the primary process, which
 511  * makes sure that the same device would have the same port id both
 512  * in the primary and secondary process.
 513  */
 514 struct rte_eth_dev *
 515 rte_eth_dev_attach_secondary(const char *name)
 516 {
 517         uint16_t i;
 518         struct rte_eth_dev *eth_dev = NULL;
 519
 520         rte_eth_dev_shared_data_prepare();
 521
 522         /* Synchronize port attachment to primary port creation and release. */
 523         rte_spinlock_lock(&rte_eth_dev_shared_data->ownership_lock);
 524
 525         for (i = 0; i < RTE_MAX_ETHPORTS; i++) {
 526                 if (strcmp(rte_eth_dev_shared_data->data[i].name, name) == 0)
 527                         break;
 528         }
 529         if (i == RTE_MAX_ETHPORTS) {
 530                 RTE_ETHDEV_LOG(ERR,
 531                         "Device %s is not driven by the primary process\n",
 532                         name);
 533         } else {
 534                 eth_dev = eth_dev_get(i);
 535                 RTE_ASSERT(eth_dev->data->port_id == i);
 536         }
 537
 538         rte_spinlock_unlock(&rte_eth_dev_shared_data->ownership_lock);
 539         return eth_dev;
 540 }
 541
 542 int
 543 rte_eth_dev_release_port(struct rte_eth_dev *eth_dev)
 544 {
 545         if (eth_dev == NULL)
 546                 return -EINVAL;
 547
 548         rte_eth_dev_shared_data_prepare();
 549
 550         if (eth_dev->state != RTE_ETH_DEV_UNUSED)
 551                 _rte_eth_dev_callback_process(eth_dev,
 552                                 RTE_ETH_EVENT_DESTROY, NULL);
 553
 554         rte_spinlock_lock(&rte_eth_dev_shared_data->ownership_lock);
 555
 556         eth_dev->state = RTE_ETH_DEV_UNUSED;
 557
 558         if (rte_eal_process_type() == RTE_PROC_PRIMARY) {
 559                 rte_free(eth_dev->data->rx_queues);
 560                 rte_free(eth_dev->data->tx_queues);
 561                 rte_free(eth_dev->data->mac_addrs);
 562                 rte_free(eth_dev->data->hash_mac_addrs);
 563                 rte_free(eth_dev->data->dev_private);
 564                 memset(eth_dev->data, 0, sizeof(struct rte_eth_dev_data));
 565         }
 566
 567         rte_spinlock_unlock(&rte_eth_dev_shared_data->ownership_lock);
 568
 569         return 0;
 570 }
 571
 572 int
 573 rte_eth_dev_is_valid_port(uint16_t port_id)
 574 {
 575         if (port_id >= RTE_MAX_ETHPORTS ||
 576             (rte_eth_devices[port_id].state == RTE_ETH_DEV_UNUSED))
 577                 return 0;
 578         else
 579                 return 1;
 580 }
 581
 582 static int
 583 rte_eth_is_valid_owner_id(uint64_t owner_id)
 584 {
 585         if (owner_id == RTE_ETH_DEV_NO_OWNER ||
 586             rte_eth_dev_shared_data->next_owner_id <= owner_id)
 587                 return 0;
 588         return 1;
 589 }
 590
 591 uint64_t
 592 rte_eth_find_next_owned_by(uint16_t port_id, const uint64_t owner_id)
 593 {
 594         port_id = rte_eth_find_next(port_id);
 595         while (port_id < RTE_MAX_ETHPORTS &&
 596                         rte_eth_devices[port_id].data->owner.id != owner_id)
 597                 port_id = rte_eth_find_next(port_id + 1);
 598
 599         return port_id;
 600 }
 601
 602 int
 603 rte_eth_dev_owner_new(uint64_t *owner_id)
 604 {
 605         rte_eth_dev_shared_data_prepare();
 606
 607         rte_spinlock_lock(&rte_eth_dev_shared_data->ownership_lock);
 608
 609         *owner_id = rte_eth_dev_shared_data->next_owner_id++;
 610
 611         rte_spinlock_unlock(&rte_eth_dev_shared_data->ownership_lock);
 612         return 0;
 613 }
 614
 615 static int
 616 _rte_eth_dev_owner_set(const uint16_t port_id, const uint64_t old_owner_id,
 617                        const struct rte_eth_dev_owner *new_owner)
 618 {
 619         struct rte_eth_dev *ethdev = &rte_eth_devices[port_id];
 620         struct rte_eth_dev_owner *port_owner;
 621
 622         if (port_id >= RTE_MAX_ETHPORTS || !is_allocated(ethdev)) {
 623                 RTE_ETHDEV_LOG(ERR, "Port id %"PRIu16" is not allocated\n",
 624                         port_id);
 625                 return -ENODEV;
 626         }
 627
 628         if (!rte_eth_is_valid_owner_id(new_owner->id) &&
 629             !rte_eth_is_valid_owner_id(old_owner_id)) {
 630                 RTE_ETHDEV_LOG(ERR,
 631                         "Invalid owner old_id=%016"PRIx64" new_id=%016"PRIx64"\n",
 632                        old_owner_id, new_owner->id);
 633                 return -EINVAL;
 634         }
 635
 636         port_owner = &rte_eth_devices[port_id].data->owner;
 637         if (port_owner->id != old_owner_id) {
 638                 RTE_ETHDEV_LOG(ERR,
 639                         "Cannot set owner to port %u already owned by %s_%016"PRIX64"\n",
 640                         port_id, port_owner->name, port_owner->id);
 641                 return -EPERM;
 642         }
 643
 644         /* can not truncate (same structure) */
 645         strlcpy(port_owner->name, new_owner->name, RTE_ETH_MAX_OWNER_NAME_LEN);
 646
 647         port_owner->id = new_owner->id;
 648
 649         RTE_ETHDEV_LOG(DEBUG, "Port %u owner is %s_%016"PRIx64"\n",
 650                 port_id, new_owner->name, new_owner->id);
 651
 652         return 0;
 653 }
 654
 655 int
 656 rte_eth_dev_owner_set(const uint16_t port_id,
 657                       const struct rte_eth_dev_owner *owner)
 658 {
 659         int ret;
 660
 661         rte_eth_dev_shared_data_prepare();
 662
 663         rte_spinlock_lock(&rte_eth_dev_shared_data->ownership_lock);
 664
 665         ret = _rte_eth_dev_owner_set(port_id, RTE_ETH_DEV_NO_OWNER, owner);
 666
 667         rte_spinlock_unlock(&rte_eth_dev_shared_data->ownership_lock);
 668         return ret;
 669 }
 670
 671 int
 672 rte_eth_dev_owner_unset(const uint16_t port_id, const uint64_t owner_id)
 673 {
 674         const struct rte_eth_dev_owner new_owner = (struct rte_eth_dev_owner)
 675                         {.id = RTE_ETH_DEV_NO_OWNER, .name = ""};
 676         int ret;
 677
 678         rte_eth_dev_shared_data_prepare();
 679
 680         rte_spinlock_lock(&rte_eth_dev_shared_data->ownership_lock);
 681
 682         ret = _rte_eth_dev_owner_set(port_id, owner_id, &new_owner);
 683
 684         rte_spinlock_unlock(&rte_eth_dev_shared_data->ownership_lock);
 685         return ret;
 686 }
 687
 688 int
 689 rte_eth_dev_owner_delete(const uint64_t owner_id)
 690 {
 691         uint16_t port_id;
 692         int ret = 0;
 693
 694         rte_eth_dev_shared_data_prepare();
 695
 696         rte_spinlock_lock(&rte_eth_dev_shared_data->ownership_lock);
 697
 698         if (rte_eth_is_valid_owner_id(owner_id)) {
 699                 for (port_id = 0; port_id < RTE_MAX_ETHPORTS; port_id++)
 700                         if (rte_eth_devices[port_id].data->owner.id == owner_id)
 701                                 memset(&rte_eth_devices[port_id].data->owner, 0,
 702                                        sizeof(struct rte_eth_dev_owner));
 703                 RTE_ETHDEV_LOG(NOTICE,
 704                         "All port owners owned by %016"PRIx64" identifier have removed\n",
 705                         owner_id);
 706         } else {
 707                 RTE_ETHDEV_LOG(ERR,
 708                                "Invalid owner id=%016"PRIx64"\n",
 709                                owner_id);
 710                 ret = -EINVAL;
 711         }
 712
 713         rte_spinlock_unlock(&rte_eth_dev_shared_data->ownership_lock);
 714
 715         return ret;
 716 }
 717
 718 int
 719 rte_eth_dev_owner_get(const uint16_t port_id, struct rte_eth_dev_owner *owner)
 720 {
 721         int ret = 0;
 722         struct rte_eth_dev *ethdev = &rte_eth_devices[port_id];
 723
 724         rte_eth_dev_shared_data_prepare();
 725
 726         rte_spinlock_lock(&rte_eth_dev_shared_data->ownership_lock);
 727
 728         if (port_id >= RTE_MAX_ETHPORTS || !is_allocated(ethdev)) {
 729                 RTE_ETHDEV_LOG(ERR, "Port id %"PRIu16" is not allocated\n",
 730                         port_id);
 731                 ret = -ENODEV;
 732         } else {
 733                 rte_memcpy(owner, &ethdev->data->owner, sizeof(*owner));
 734         }
 735
 736         rte_spinlock_unlock(&rte_eth_dev_shared_data->ownership_lock);
 737         return ret;
 738 }
 739
 740 int
 741 rte_eth_dev_socket_id(uint16_t port_id)
 742 {
 743         RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -1);
 744         return rte_eth_devices[port_id].data->numa_node;
 745 }
 746
 747 void *
 748 rte_eth_dev_get_sec_ctx(uint16_t port_id)
 749 {
 750         RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, NULL);
 751         return rte_eth_devices[port_id].security_ctx;
 752 }
 753
 754 uint16_t
 755 rte_eth_dev_count_avail(void)
 756 {
 757         uint16_t p;
 758         uint16_t count;
 759
 760         count = 0;
 761
 762         RTE_ETH_FOREACH_DEV(p)
 763                 count++;
 764
 765         return count;
 766 }
 767
 768 uint16_t
 769 rte_eth_dev_count_total(void)
 770 {
 771         uint16_t port, count = 0;
 772
 773         RTE_ETH_FOREACH_VALID_DEV(port)
 774                 count++;
 775
 776         return count;
 777 }
 778
 779 int
 780 rte_eth_dev_get_name_by_port(uint16_t port_id, char *name)
 781 {
 782         char *tmp;
 783
 784         RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -EINVAL);
 785
 786         if (name == NULL) {
 787                 RTE_ETHDEV_LOG(ERR, "Null pointer is specified\n");
 788                 return -EINVAL;
 789         }
 790
 791         /* shouldn't check 'rte_eth_devices[i].data',
 792          * because it might be overwritten by VDEV PMD */
 793         tmp = rte_eth_dev_shared_data->data[port_id].name;
 794         strcpy(name, tmp);
 795         return 0;
 796 }
 797
 798 int
 799 rte_eth_dev_get_port_by_name(const char *name, uint16_t *port_id)
 800 {
 801         uint32_t pid;
 802
 803         if (name == NULL) {
 804                 RTE_ETHDEV_LOG(ERR, "Null pointer is specified\n");
 805                 return -EINVAL;
 806         }
 807
 808         RTE_ETH_FOREACH_VALID_DEV(pid)
 809                 if (!strcmp(name, rte_eth_dev_shared_data->data[pid].name)) {
 810                         *port_id = pid;
 811                         return 0;
 812                 }
 813
 814         return -ENODEV;
 815 }
 816
 817 static int
 818 eth_err(uint16_t port_id, int ret)
 819 {
 820         if (ret == 0)
 821                 return 0;
 822         if (rte_eth_dev_is_removed(port_id))
 823                 return -EIO;
 824         return ret;
 825 }
 826
 827 static int
 828 rte_eth_dev_rx_queue_config(struct rte_eth_dev *dev, uint16_t nb_queues)
 829 {
 830         uint16_t old_nb_queues = dev->data->nb_rx_queues;
 831         void **rxq;
 832         unsigned i;
 833
 834         if (dev->data->rx_queues == NULL && nb_queues != 0) { /* first time configuration */
 835                 dev->data->rx_queues = rte_zmalloc("ethdev->rx_queues",
 836                                 sizeof(dev->data->rx_queues[0]) * nb_queues,
 837                                 RTE_CACHE_LINE_SIZE);
 838                 if (dev->data->rx_queues == NULL) {
 839                         dev->data->nb_rx_queues = 0;
 840                         return -(ENOMEM);
 841                 }
 842         } else if (dev->data->rx_queues != NULL && nb_queues != 0) { /* re-configure */
 843                 RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->rx_queue_release, -ENOTSUP);
 844
 845                 rxq = dev->data->rx_queues;
 846
 847                 for (i = nb_queues; i < old_nb_queues; i++)
 848                         (*dev->dev_ops->rx_queue_release)(rxq[i]);
 849                 rxq = rte_realloc(rxq, sizeof(rxq[0]) * nb_queues,
 850                                 RTE_CACHE_LINE_SIZE);
 851                 if (rxq == NULL)
 852                         return -(ENOMEM);
 853                 if (nb_queues > old_nb_queues) {
 854                         uint16_t new_qs = nb_queues - old_nb_queues;
 855
 856                         memset(rxq + old_nb_queues, 0,
 857                                 sizeof(rxq[0]) * new_qs);
 858                 }
 859
 860                 dev->data->rx_queues = rxq;
 861
 862         } else if (dev->data->rx_queues != NULL && nb_queues == 0) {
 863                 RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->rx_queue_release, -ENOTSUP);
 864
 865                 rxq = dev->data->rx_queues;
 866
 867                 for (i = nb_queues; i < old_nb_queues; i++)
 868                         (*dev->dev_ops->rx_queue_release)(rxq[i]);
 869
 870                 rte_free(dev->data->rx_queues);
 871                 dev->data->rx_queues = NULL;
 872         }
 873         dev->data->nb_rx_queues = nb_queues;
 874         return 0;
 875 }
 876
 877 int
 878 rte_eth_dev_rx_queue_start(uint16_t port_id, uint16_t rx_queue_id)
 879 {
 880         struct rte_eth_dev *dev;
 881
 882         RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -EINVAL);
 883
 884         dev = &rte_eth_devices[port_id];
 885         if (!dev->data->dev_started) {
 886                 RTE_ETHDEV_LOG(ERR,
 887                         "Port %u must be started before start any queue\n",
 888                         port_id);
 889                 return -EINVAL;
 890         }
 891
 892         if (rx_queue_id >= dev->data->nb_rx_queues) {
 893                 RTE_ETHDEV_LOG(ERR, "Invalid RX queue_id=%u\n", rx_queue_id);
 894                 return -EINVAL;
 895         }
 896
 897         RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->rx_queue_start, -ENOTSUP);
 898
 899         if (rte_eth_dev_is_rx_hairpin_queue(dev, rx_queue_id)) {
 900                 RTE_ETHDEV_LOG(INFO,
 901                         "Can't start Rx hairpin queue %"PRIu16" of device with port_id=%"PRIu16"\n",
 902                         rx_queue_id, port_id);
 903                 return -EINVAL;
 904         }
 905
 906         if (dev->data->rx_queue_state[rx_queue_id] != RTE_ETH_QUEUE_STATE_STOPPED) {
 907                 RTE_ETHDEV_LOG(INFO,
 908                         "Queue %"PRIu16" of device with port_id=%"PRIu16" already started\n",
 909                         rx_queue_id, port_id);
 910                 return 0;
 911         }
 912
 913         return eth_err(port_id, dev->dev_ops->rx_queue_start(dev,
 914                                                              rx_queue_id));
 915
 916 }
 917
 918 int
 919 rte_eth_dev_rx_queue_stop(uint16_t port_id, uint16_t rx_queue_id)
 920 {
 921         struct rte_eth_dev *dev;
 922
 923         RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -EINVAL);
 924
 925         dev = &rte_eth_devices[port_id];
 926         if (rx_queue_id >= dev->data->nb_rx_queues) {
 927                 RTE_ETHDEV_LOG(ERR, "Invalid RX queue_id=%u\n", rx_queue_id);
 928                 return -EINVAL;
 929         }
 930
 931         RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->rx_queue_stop, -ENOTSUP);
 932
 933         if (rte_eth_dev_is_rx_hairpin_queue(dev, rx_queue_id)) {
 934                 RTE_ETHDEV_LOG(INFO,
 935                         "Can't stop Rx hairpin queue %"PRIu16" of device with port_id=%"PRIu16"\n",
 936                         rx_queue_id, port_id);
 937                 return -EINVAL;
 938         }
 939
 940         if (dev->data->rx_queue_state[rx_queue_id] == RTE_ETH_QUEUE_STATE_STOPPED) {
 941                 RTE_ETHDEV_LOG(INFO,
 942                         "Queue %"PRIu16" of device with port_id=%"PRIu16" already stopped\n",
 943                         rx_queue_id, port_id);
 944                 return 0;
 945         }
 946
 947         return eth_err(port_id, dev->dev_ops->rx_queue_stop(dev, rx_queue_id));
 948
 949 }
 950
 951 int
 952 rte_eth_dev_tx_queue_start(uint16_t port_id, uint16_t tx_queue_id)
 953 {
 954         struct rte_eth_dev *dev;
 955
 956         RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -EINVAL);
 957
 958         dev = &rte_eth_devices[port_id];
 959         if (!dev->data->dev_started) {
 960                 RTE_ETHDEV_LOG(ERR,
 961                         "Port %u must be started before start any queue\n",
 962                         port_id);
 963                 return -EINVAL;
 964         }
 965
 966         if (tx_queue_id >= dev->data->nb_tx_queues) {
 967                 RTE_ETHDEV_LOG(ERR, "Invalid TX queue_id=%u\n", tx_queue_id);
 968                 return -EINVAL;
 969         }
 970
 971         RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->tx_queue_start, -ENOTSUP);
 972
 973         if (rte_eth_dev_is_tx_hairpin_queue(dev, tx_queue_id)) {
 974                 RTE_ETHDEV_LOG(INFO,
 975                         "Can't start Tx hairpin queue %"PRIu16" of device with port_id=%"PRIu16"\n",
 976                         tx_queue_id, port_id);
 977                 return -EINVAL;
 978         }
 979
 980         if (dev->data->tx_queue_state[tx_queue_id] != RTE_ETH_QUEUE_STATE_STOPPED) {
 981                 RTE_ETHDEV_LOG(INFO,
 982                         "Queue %"PRIu16" of device with port_id=%"PRIu16" already started\n",
 983                         tx_queue_id, port_id);
 984                 return 0;
 985         }
 986
 987         return eth_err(port_id, dev->dev_ops->tx_queue_start(dev, tx_queue_id));
 988 }
 989
 990 int
 991 rte_eth_dev_tx_queue_stop(uint16_t port_id, uint16_t tx_queue_id)
 992 {
 993         struct rte_eth_dev *dev;
 994
 995         RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -EINVAL);
 996
 997         dev = &rte_eth_devices[port_id];
 998         if (tx_queue_id >= dev->data->nb_tx_queues) {
 999                 RTE_ETHDEV_LOG(ERR, "Invalid TX queue_id=%u\n", tx_queue_id);
1000                 return -EINVAL;
1001         }
1002
1003         RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->tx_queue_stop, -ENOTSUP);
1004
1005         if (rte_eth_dev_is_tx_hairpin_queue(dev, tx_queue_id)) {
1006                 RTE_ETHDEV_LOG(INFO,
1007                         "Can't stop Tx hairpin queue %"PRIu16" of device with port_id=%"PRIu16"\n",
1008                         tx_queue_id, port_id);
1009                 return -EINVAL;
1010         }
1011
1012         if (dev->data->tx_queue_state[tx_queue_id] == RTE_ETH_QUEUE_STATE_STOPPED) {
1013                 RTE_ETHDEV_LOG(INFO,
1014                         "Queue %"PRIu16" of device with port_id=%"PRIu16" already stopped\n",
1015                         tx_queue_id, port_id);
1016                 return 0;
1017         }
1018
1019         return eth_err(port_id, dev->dev_ops->tx_queue_stop(dev, tx_queue_id));
1020
1021 }
1022
1023 static int
1024 rte_eth_dev_tx_queue_config(struct rte_eth_dev *dev, uint16_t nb_queues)
1025 {
1026         uint16_t old_nb_queues = dev->data->nb_tx_queues;
1027         void **txq;
1028         unsigned i;
1029
1030         if (dev->data->tx_queues == NULL && nb_queues != 0) { /* first time configuration */
1031                 dev->data->tx_queues = rte_zmalloc("ethdev->tx_queues",
1032                                                    sizeof(dev->data->tx_queues[0]) * nb_queues,
1033                                                    RTE_CACHE_LINE_SIZE);
1034                 if (dev->data->tx_queues == NULL) {
1035                         dev->data->nb_tx_queues = 0;
1036                         return -(ENOMEM);
1037                 }
1038         } else if (dev->data->tx_queues != NULL && nb_queues != 0) { /* re-configure */
1039                 RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->tx_queue_release, -ENOTSUP);
1040
1041                 txq = dev->data->tx_queues;
1042
1043                 for (i = nb_queues; i < old_nb_queues; i++)
1044                         (*dev->dev_ops->tx_queue_release)(txq[i]);
1045                 txq = rte_realloc(txq, sizeof(txq[0]) * nb_queues,
1046                                   RTE_CACHE_LINE_SIZE);
1047                 if (txq == NULL)
1048                         return -ENOMEM;
1049                 if (nb_queues > old_nb_queues) {
1050                         uint16_t new_qs = nb_queues - old_nb_queues;
1051
1052                         memset(txq + old_nb_queues, 0,
1053                                sizeof(txq[0]) * new_qs);
1054                 }
1055
1056                 dev->data->tx_queues = txq;
1057
1058         } else if (dev->data->tx_queues != NULL && nb_queues == 0) {
1059                 RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->tx_queue_release, -ENOTSUP);
1060
1061                 txq = dev->data->tx_queues;
1062
1063                 for (i = nb_queues; i < old_nb_queues; i++)
1064                         (*dev->dev_ops->tx_queue_release)(txq[i]);
1065
1066                 rte_free(dev->data->tx_queues);
1067                 dev->data->tx_queues = NULL;
1068         }
1069         dev->data->nb_tx_queues = nb_queues;
1070         return 0;
1071 }
1072
1073 uint32_t
1074 rte_eth_speed_bitflag(uint32_t speed, int duplex)
1075 {
1076         switch (speed) {
1077         case ETH_SPEED_NUM_10M:
1078                 return duplex ? ETH_LINK_SPEED_10M : ETH_LINK_SPEED_10M_HD;
1079         case ETH_SPEED_NUM_100M:
1080                 return duplex ? ETH_LINK_SPEED_100M : ETH_LINK_SPEED_100M_HD;
1081         case ETH_SPEED_NUM_1G:
1082                 return ETH_LINK_SPEED_1G;
1083         case ETH_SPEED_NUM_2_5G:
1084                 return ETH_LINK_SPEED_2_5G;
1085         case ETH_SPEED_NUM_5G:
1086                 return ETH_LINK_SPEED_5G;
1087         case ETH_SPEED_NUM_10G:
1088                 return ETH_LINK_SPEED_10G;
1089         case ETH_SPEED_NUM_20G:
1090                 return ETH_LINK_SPEED_20G;
1091         case ETH_SPEED_NUM_25G:
1092                 return ETH_LINK_SPEED_25G;
1093         case ETH_SPEED_NUM_40G:
1094                 return ETH_LINK_SPEED_40G;
1095         case ETH_SPEED_NUM_50G:
1096                 return ETH_LINK_SPEED_50G;
1097         case ETH_SPEED_NUM_56G:
1098                 return ETH_LINK_SPEED_56G;
1099         case ETH_SPEED_NUM_100G:
1100                 return ETH_LINK_SPEED_100G;
1101         case ETH_SPEED_NUM_200G:
1102                 return ETH_LINK_SPEED_200G;
1103         default:
1104                 return 0;
1105         }
1106 }
1107
1108 const char *
1109 rte_eth_dev_rx_offload_name(uint64_t offload)
1110 {
1111         const char *name = "UNKNOWN";
1112         unsigned int i;
1113
1114         for (i = 0; i < RTE_DIM(rte_rx_offload_names); ++i) {
1115                 if (offload == rte_rx_offload_names[i].offload) {
1116                         name = rte_rx_offload_names[i].name;
1117                         break;
1118                 }
1119         }
1120
1121         return name;
1122 }
1123
1124 const char *
1125 rte_eth_dev_tx_offload_name(uint64_t offload)
1126 {
1127         const char *name = "UNKNOWN";
1128         unsigned int i;
1129
1130         for (i = 0; i < RTE_DIM(rte_tx_offload_names); ++i) {
1131                 if (offload == rte_tx_offload_names[i].offload) {
1132                         name = rte_tx_offload_names[i].name;
1133                         break;
1134                 }
1135         }
1136
1137         return name;
1138 }
1139
1140 static inline int
1141 check_lro_pkt_size(uint16_t port_id, uint32_t config_size,
1142                    uint32_t max_rx_pkt_len, uint32_t dev_info_size)
1143 {
1144         int ret = 0;
1145
1146         if (dev_info_size == 0) {
1147                 if (config_size != max_rx_pkt_len) {
1148                         RTE_ETHDEV_LOG(ERR, "Ethdev port_id=%d max_lro_pkt_size"
1149                                        " %u != %u is not allowed\n",
1150                                        port_id, config_size, max_rx_pkt_len);
1151                         ret = -EINVAL;
1152                 }
1153         } else if (config_size > dev_info_size) {
1154                 RTE_ETHDEV_LOG(ERR, "Ethdev port_id=%d max_lro_pkt_size %u "
1155                                "> max allowed value %u\n", port_id, config_size,
1156                                dev_info_size);
1157                 ret = -EINVAL;
1158         } else if (config_size < RTE_ETHER_MIN_LEN) {
1159                 RTE_ETHDEV_LOG(ERR, "Ethdev port_id=%d max_lro_pkt_size %u "
1160                                "< min allowed value %u\n", port_id, config_size,
1161                                (unsigned int)RTE_ETHER_MIN_LEN);
1162                 ret = -EINVAL;
1163         }
1164         return ret;
1165 }
1166
1167 /*
1168  * Validate offloads that are requested through rte_eth_dev_configure against
1169  * the offloads successfully set by the ethernet device.
1170  *
1171  * @param port_id
1172  *   The port identifier of the Ethernet device.
1173  * @param req_offloads
1174  *   The offloads that have been requested through `rte_eth_dev_configure`.
1175  * @param set_offloads
1176  *   The offloads successfully set by the ethernet device.
1177  * @param offload_type
1178  *   The offload type i.e. Rx/Tx string.
1179  * @param offload_name
1180  *   The function that prints the offload name.
1181  * @return
1182  *   - (0) if validation successful.
1183  *   - (-EINVAL) if requested offload has been silently disabled.
1184  *
1185  */
1186 static int
1187 validate_offloads(uint16_t port_id, uint64_t req_offloads,
1188                   uint64_t set_offloads, const char *offload_type,
1189                   const char *(*offload_name)(uint64_t))
1190 {
1191         uint64_t offloads_diff = req_offloads ^ set_offloads;
1192         uint64_t offload;
1193         int ret = 0;
1194
1195         while (offloads_diff != 0) {
1196                 /* Check if any offload is requested but not enabled. */
1197                 offload = 1ULL << __builtin_ctzll(offloads_diff);
1198                 if (offload & req_offloads) {
1199                         RTE_ETHDEV_LOG(ERR,
1200                                 "Port %u failed to enable %s offload %s\n",
1201                                 port_id, offload_type, offload_name(offload));
1202                         ret = -EINVAL;
1203                 }
1204
1205                 /* Check if offload couldn't be disabled. */
1206                 if (offload & set_offloads) {
1207                         RTE_ETHDEV_LOG(DEBUG,
1208                                 "Port %u %s offload %s is not requested but enabled\n",
1209                                 port_id, offload_type, offload_name(offload));
1210                 }
1211
1212                 offloads_diff &= ~offload;
1213         }
1214
1215         return ret;
1216 }
1217
1218 int
1219 rte_eth_dev_configure(uint16_t port_id, uint16_t nb_rx_q, uint16_t nb_tx_q,
1220                       const struct rte_eth_conf *dev_conf)
1221 {
1222         struct rte_eth_dev *dev;
1223         struct rte_eth_dev_info dev_info;
1224         struct rte_eth_conf orig_conf;
1225         int diag;
1226         int ret;
1227
1228         RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -EINVAL);
1229
1230         dev = &rte_eth_devices[port_id];
1231
1232         RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->dev_configure, -ENOTSUP);
1233
1234         if (dev->data->dev_started) {
1235                 RTE_ETHDEV_LOG(ERR,
1236                         "Port %u must be stopped to allow configuration\n",
1237                         port_id);
1238                 return -EBUSY;
1239         }
1240
1241          /* Store original config, as rollback required on failure */
1242         memcpy(&orig_conf, &dev->data->dev_conf, sizeof(dev->data->dev_conf));
1243
1244         /*
1245          * Copy the dev_conf parameter into the dev structure.
1246          * rte_eth_dev_info_get() requires dev_conf, copy it before dev_info get
1247          */
1248         if (dev_conf != &dev->data->dev_conf)
1249                 memcpy(&dev->data->dev_conf, dev_conf,
1250                        sizeof(dev->data->dev_conf));
1251
1252         ret = rte_eth_dev_info_get(port_id, &dev_info);
1253         if (ret != 0)
1254                 goto rollback;
1255
1256         /* If number of queues specified by application for both Rx and Tx is
1257          * zero, use driver preferred values. This cannot be done individually
1258          * as it is valid for either Tx or Rx (but not both) to be zero.
1259          * If driver does not provide any preferred valued, fall back on
1260          * EAL defaults.
1261          */
1262         if (nb_rx_q == 0 && nb_tx_q == 0) {
1263                 nb_rx_q = dev_info.default_rxportconf.nb_queues;
1264                 if (nb_rx_q == 0)
1265                         nb_rx_q = RTE_ETH_DEV_FALLBACK_RX_NBQUEUES;
1266                 nb_tx_q = dev_info.default_txportconf.nb_queues;
1267                 if (nb_tx_q == 0)
1268                         nb_tx_q = RTE_ETH_DEV_FALLBACK_TX_NBQUEUES;
1269         }
1270
1271         if (nb_rx_q > RTE_MAX_QUEUES_PER_PORT) {
1272                 RTE_ETHDEV_LOG(ERR,
1273                         "Number of RX queues requested (%u) is greater than max supported(%d)\n",
1274                         nb_rx_q, RTE_MAX_QUEUES_PER_PORT);
1275                 ret = -EINVAL;
1276                 goto rollback;
1277         }
1278
1279         if (nb_tx_q > RTE_MAX_QUEUES_PER_PORT) {
1280                 RTE_ETHDEV_LOG(ERR,
1281                         "Number of TX queues requested (%u) is greater than max supported(%d)\n",
1282                         nb_tx_q, RTE_MAX_QUEUES_PER_PORT);
1283                 ret = -EINVAL;
1284                 goto rollback;
1285         }
1286
1287         /*
1288          * Check that the numbers of RX and TX queues are not greater
1289          * than the maximum number of RX and TX queues supported by the
1290          * configured device.
1291          */
1292         if (nb_rx_q > dev_info.max_rx_queues) {
1293                 RTE_ETHDEV_LOG(ERR, "Ethdev port_id=%u nb_rx_queues=%u > %u\n",
1294                         port_id, nb_rx_q, dev_info.max_rx_queues);
1295                 ret = -EINVAL;
1296                 goto rollback;
1297         }
1298
1299         if (nb_tx_q > dev_info.max_tx_queues) {
1300                 RTE_ETHDEV_LOG(ERR, "Ethdev port_id=%u nb_tx_queues=%u > %u\n",
1301                         port_id, nb_tx_q, dev_info.max_tx_queues);
1302                 ret = -EINVAL;
1303                 goto rollback;
1304         }
1305
1306         /* Check that the device supports requested interrupts */
1307         if ((dev_conf->intr_conf.lsc == 1) &&
1308                         (!(dev->data->dev_flags & RTE_ETH_DEV_INTR_LSC))) {
1309                 RTE_ETHDEV_LOG(ERR, "Driver %s does not support lsc\n",
1310                         dev->device->driver->name);
1311                 ret = -EINVAL;
1312                 goto rollback;
1313         }
1314         if ((dev_conf->intr_conf.rmv == 1) &&
1315                         (!(dev->data->dev_flags & RTE_ETH_DEV_INTR_RMV))) {
1316                 RTE_ETHDEV_LOG(ERR, "Driver %s does not support rmv\n",
1317                         dev->device->driver->name);
1318                 ret = -EINVAL;
1319                 goto rollback;
1320         }
1321
1322         /*
1323          * If jumbo frames are enabled, check that the maximum RX packet
1324          * length is supported by the configured device.
1325          */
1326         if (dev_conf->rxmode.offloads & DEV_RX_OFFLOAD_JUMBO_FRAME) {
1327                 if (dev_conf->rxmode.max_rx_pkt_len > dev_info.max_rx_pktlen) {
1328                         RTE_ETHDEV_LOG(ERR,
1329                                 "Ethdev port_id=%u max_rx_pkt_len %u > max valid value %u\n",
1330                                 port_id, dev_conf->rxmode.max_rx_pkt_len,
1331                                 dev_info.max_rx_pktlen);
1332                         ret = -EINVAL;
1333                         goto rollback;
1334                 } else if (dev_conf->rxmode.max_rx_pkt_len < RTE_ETHER_MIN_LEN) {
1335                         RTE_ETHDEV_LOG(ERR,
1336                                 "Ethdev port_id=%u max_rx_pkt_len %u < min valid value %u\n",
1337                                 port_id, dev_conf->rxmode.max_rx_pkt_len,
1338                                 (unsigned int)RTE_ETHER_MIN_LEN);
1339                         ret = -EINVAL;
1340                         goto rollback;
1341                 }
1342         } else {
1343                 if (dev_conf->rxmode.max_rx_pkt_len < RTE_ETHER_MIN_LEN ||
1344                         dev_conf->rxmode.max_rx_pkt_len > RTE_ETHER_MAX_LEN)
1345                         /* Use default value */
1346                         dev->data->dev_conf.rxmode.max_rx_pkt_len =
1347                                                         RTE_ETHER_MAX_LEN;
1348         }
1349
1350         /*
1351          * If LRO is enabled, check that the maximum aggregated packet
1352          * size is supported by the configured device.
1353          */
1354         if (dev_conf->rxmode.offloads & DEV_RX_OFFLOAD_TCP_LRO) {
1355                 if (dev_conf->rxmode.max_lro_pkt_size == 0)
1356                         dev->data->dev_conf.rxmode.max_lro_pkt_size =
1357                                 dev->data->dev_conf.rxmode.max_rx_pkt_len;
1358                 ret = check_lro_pkt_size(port_id,
1359                                 dev->data->dev_conf.rxmode.max_lro_pkt_size,
1360                                 dev->data->dev_conf.rxmode.max_rx_pkt_len,
1361                                 dev_info.max_lro_pkt_size);
1362                 if (ret != 0)
1363                         goto rollback;
1364         }
1365
1366         /* Any requested offloading must be within its device capabilities */
1367         if ((dev_conf->rxmode.offloads & dev_info.rx_offload_capa) !=
1368              dev_conf->rxmode.offloads) {
1369                 RTE_ETHDEV_LOG(ERR,
1370                         "Ethdev port_id=%u requested Rx offloads 0x%"PRIx64" doesn't match Rx offloads "
1371                         "capabilities 0x%"PRIx64" in %s()\n",
1372                         port_id, dev_conf->rxmode.offloads,
1373                         dev_info.rx_offload_capa,
1374                         __func__);
1375                 ret = -EINVAL;
1376                 goto rollback;
1377         }
1378         if ((dev_conf->txmode.offloads & dev_info.tx_offload_capa) !=
1379              dev_conf->txmode.offloads) {
1380                 RTE_ETHDEV_LOG(ERR,
1381                         "Ethdev port_id=%u requested Tx offloads 0x%"PRIx64" doesn't match Tx offloads "
1382                         "capabilities 0x%"PRIx64" in %s()\n",
1383                         port_id, dev_conf->txmode.offloads,
1384                         dev_info.tx_offload_capa,
1385                         __func__);
1386                 ret = -EINVAL;
1387                 goto rollback;
1388         }
1389
1390         dev->data->dev_conf.rx_adv_conf.rss_conf.rss_hf =
1391                 rte_eth_rss_hf_refine(dev_conf->rx_adv_conf.rss_conf.rss_hf);
1392
1393         /* Check that device supports requested rss hash functions. */
1394         if ((dev_info.flow_type_rss_offloads |
1395              dev_conf->rx_adv_conf.rss_conf.rss_hf) !=
1396             dev_info.flow_type_rss_offloads) {
1397                 RTE_ETHDEV_LOG(ERR,
1398                         "Ethdev port_id=%u invalid rss_hf: 0x%"PRIx64", valid value: 0x%"PRIx64"\n",
1399                         port_id, dev_conf->rx_adv_conf.rss_conf.rss_hf,
1400                         dev_info.flow_type_rss_offloads);
1401                 ret = -EINVAL;
1402                 goto rollback;
1403         }
1404
1405         /* Check if Rx RSS distribution is disabled but RSS hash is enabled. */
1406         if (((dev_conf->rxmode.mq_mode & ETH_MQ_RX_RSS_FLAG) == 0) &&
1407             (dev_conf->rxmode.offloads & DEV_RX_OFFLOAD_RSS_HASH)) {
1408                 RTE_ETHDEV_LOG(ERR,
1409                         "Ethdev port_id=%u config invalid Rx mq_mode without RSS but %s offload is requested\n",
1410                         port_id,
1411                         rte_eth_dev_rx_offload_name(DEV_RX_OFFLOAD_RSS_HASH));
1412                 ret = -EINVAL;
1413                 goto rollback;
1414         }
1415
1416         /*
1417          * Setup new number of RX/TX queues and reconfigure device.
1418          */
1419         diag = rte_eth_dev_rx_queue_config(dev, nb_rx_q);
1420         if (diag != 0) {
1421                 RTE_ETHDEV_LOG(ERR,
1422                         "Port%u rte_eth_dev_rx_queue_config = %d\n",
1423                         port_id, diag);
1424                 ret = diag;
1425                 goto rollback;
1426         }
1427
1428         diag = rte_eth_dev_tx_queue_config(dev, nb_tx_q);
1429         if (diag != 0) {
1430                 RTE_ETHDEV_LOG(ERR,
1431                         "Port%u rte_eth_dev_tx_queue_config = %d\n",
1432                         port_id, diag);
1433                 rte_eth_dev_rx_queue_config(dev, 0);
1434                 ret = diag;
1435                 goto rollback;
1436         }
1437
1438         diag = (*dev->dev_ops->dev_configure)(dev);
1439         if (diag != 0) {
1440                 RTE_ETHDEV_LOG(ERR, "Port%u dev_configure = %d\n",
1441                         port_id, diag);
1442                 ret = eth_err(port_id, diag);
1443                 goto reset_queues;
1444         }
1445
1446         /* Initialize Rx profiling if enabled at compilation time. */
1447         diag = __rte_eth_dev_profile_init(port_id, dev);
1448         if (diag != 0) {
1449                 RTE_ETHDEV_LOG(ERR, "Port%u __rte_eth_dev_profile_init = %d\n",
1450                         port_id, diag);
1451                 ret = eth_err(port_id, diag);
1452                 goto reset_queues;
1453         }
1454
1455         /* Validate Rx offloads. */
1456         diag = validate_offloads(port_id,
1457                         dev_conf->rxmode.offloads,
1458                         dev->data->dev_conf.rxmode.offloads, "Rx",
1459                         rte_eth_dev_rx_offload_name);
1460         if (diag != 0) {
1461                 ret = diag;
1462                 goto reset_queues;
1463         }
1464
1465         /* Validate Tx offloads. */
1466         diag = validate_offloads(port_id,
1467                         dev_conf->txmode.offloads,
1468                         dev->data->dev_conf.txmode.offloads, "Tx",
1469                         rte_eth_dev_tx_offload_name);
1470         if (diag != 0) {
1471                 ret = diag;
1472                 goto reset_queues;
1473         }
1474
1475         rte_ethdev_trace_configure(port_id, nb_rx_q, nb_tx_q, dev_conf, 0);
1476         return 0;
1477 reset_queues:
1478         rte_eth_dev_rx_queue_config(dev, 0);
1479         rte_eth_dev_tx_queue_config(dev, 0);
1480 rollback:
1481         memcpy(&dev->data->dev_conf, &orig_conf, sizeof(dev->data->dev_conf));
1482
1483         rte_ethdev_trace_configure(port_id, nb_rx_q, nb_tx_q, dev_conf, ret);
1484         return ret;
1485 }
1486
1487 void
1488 _rte_eth_dev_reset(struct rte_eth_dev *dev)
1489 {
1490         if (dev->data->dev_started) {
1491                 RTE_ETHDEV_LOG(ERR, "Port %u must be stopped to allow reset\n",
1492                         dev->data->port_id);
1493                 return;
1494         }
1495
1496         rte_eth_dev_rx_queue_config(dev, 0);
1497         rte_eth_dev_tx_queue_config(dev, 0);
1498
1499         memset(&dev->data->dev_conf, 0, sizeof(dev->data->dev_conf));
1500 }
1501
1502 static void
1503 rte_eth_dev_mac_restore(struct rte_eth_dev *dev,
1504                         struct rte_eth_dev_info *dev_info)
1505 {
1506         struct rte_ether_addr *addr;
1507         uint16_t i;
1508         uint32_t pool = 0;
1509         uint64_t pool_mask;
1510
1511         /* replay MAC address configuration including default MAC */
1512         addr = &dev->data->mac_addrs[0];
1513         if (*dev->dev_ops->mac_addr_set != NULL)
1514                 (*dev->dev_ops->mac_addr_set)(dev, addr);
1515         else if (*dev->dev_ops->mac_addr_add != NULL)
1516                 (*dev->dev_ops->mac_addr_add)(dev, addr, 0, pool);
1517
1518         if (*dev->dev_ops->mac_addr_add != NULL) {
1519                 for (i = 1; i < dev_info->max_mac_addrs; i++) {
1520                         addr = &dev->data->mac_addrs[i];
1521
1522                         /* skip zero address */
1523                         if (rte_is_zero_ether_addr(addr))
1524                                 continue;
1525
1526                         pool = 0;
1527                         pool_mask = dev->data->mac_pool_sel[i];
1528
1529                         do {
1530                                 if (pool_mask & 1ULL)
1531                                         (*dev->dev_ops->mac_addr_add)(dev,
1532                                                 addr, i, pool);
1533                                 pool_mask >>= 1;
1534                                 pool++;
1535                         } while (pool_mask);
1536                 }
1537         }
1538 }
1539
1540 static int
1541 rte_eth_dev_config_restore(struct rte_eth_dev *dev,
1542                            struct rte_eth_dev_info *dev_info, uint16_t port_id)
1543 {
1544         int ret;
1545
1546         if (!(*dev_info->dev_flags & RTE_ETH_DEV_NOLIVE_MAC_ADDR))
1547                 rte_eth_dev_mac_restore(dev, dev_info);
1548
1549         /* replay promiscuous configuration */
1550         /*
1551          * use callbacks directly since we don't need port_id check and
1552          * would like to bypass the same value set
1553          */
1554         if (rte_eth_promiscuous_get(port_id) == 1 &&
1555             *dev->dev_ops->promiscuous_enable != NULL) {
1556                 ret = eth_err(port_id,
1557                               (*dev->dev_ops->promiscuous_enable)(dev));
1558                 if (ret != 0 && ret != -ENOTSUP) {
1559                         RTE_ETHDEV_LOG(ERR,
1560                                 "Failed to enable promiscuous mode for device (port %u): %s\n",
1561                                 port_id, rte_strerror(-ret));
1562                         return ret;
1563                 }
1564         } else if (rte_eth_promiscuous_get(port_id) == 0 &&
1565                    *dev->dev_ops->promiscuous_disable != NULL) {
1566                 ret = eth_err(port_id,
1567                               (*dev->dev_ops->promiscuous_disable)(dev));
1568                 if (ret != 0 && ret != -ENOTSUP) {
1569                         RTE_ETHDEV_LOG(ERR,
1570                                 "Failed to disable promiscuous mode for device (port %u): %s\n",
1571                                 port_id, rte_strerror(-ret));
1572                         return ret;
1573                 }
1574         }
1575
1576         /* replay all multicast configuration */
1577         /*
1578          * use callbacks directly since we don't need port_id check and
1579          * would like to bypass the same value set
1580          */
1581         if (rte_eth_allmulticast_get(port_id) == 1 &&
1582             *dev->dev_ops->allmulticast_enable != NULL) {
1583                 ret = eth_err(port_id,
1584                               (*dev->dev_ops->allmulticast_enable)(dev));
1585                 if (ret != 0 && ret != -ENOTSUP) {
1586                         RTE_ETHDEV_LOG(ERR,
1587                                 "Failed to enable allmulticast mode for device (port %u): %s\n",
1588                                 port_id, rte_strerror(-ret));
1589                         return ret;
1590                 }
1591         } else if (rte_eth_allmulticast_get(port_id) == 0 &&
1592                    *dev->dev_ops->allmulticast_disable != NULL) {
1593                 ret = eth_err(port_id,
1594                               (*dev->dev_ops->allmulticast_disable)(dev));
1595                 if (ret != 0 && ret != -ENOTSUP) {
1596                         RTE_ETHDEV_LOG(ERR,
1597                                 "Failed to disable allmulticast mode for device (port %u): %s\n",
1598                                 port_id, rte_strerror(-ret));
1599                         return ret;
1600                 }
1601         }
1602
1603         return 0;
1604 }
1605
1606 int
1607 rte_eth_dev_start(uint16_t port_id)
1608 {
1609         struct rte_eth_dev *dev;
1610         struct rte_eth_dev_info dev_info;
1611         int diag;
1612         int ret;
1613
1614         RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -EINVAL);
1615
1616         dev = &rte_eth_devices[port_id];
1617
1618         RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->dev_start, -ENOTSUP);
1619
1620         if (dev->data->dev_started != 0) {
1621                 RTE_ETHDEV_LOG(INFO,
1622                         "Device with port_id=%"PRIu16" already started\n",
1623                         port_id);
1624                 return 0;
1625         }
1626
1627         ret = rte_eth_dev_info_get(port_id, &dev_info);
1628         if (ret != 0)
1629                 return ret;
1630
1631         /* Lets restore MAC now if device does not support live change */
1632         if (*dev_info.dev_flags & RTE_ETH_DEV_NOLIVE_MAC_ADDR)
1633                 rte_eth_dev_mac_restore(dev, &dev_info);
1634
1635         diag = (*dev->dev_ops->dev_start)(dev);
1636         if (diag == 0)
1637                 dev->data->dev_started = 1;
1638         else
1639                 return eth_err(port_id, diag);
1640
1641         ret = rte_eth_dev_config_restore(dev, &dev_info, port_id);
1642         if (ret != 0) {
1643                 RTE_ETHDEV_LOG(ERR,
1644                         "Error during restoring configuration for device (port %u): %s\n",
1645                         port_id, rte_strerror(-ret));
1646                 rte_eth_dev_stop(port_id);
1647                 return ret;
1648         }
1649
1650         if (dev->data->dev_conf.intr_conf.lsc == 0) {
1651                 RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->link_update, -ENOTSUP);
1652                 (*dev->dev_ops->link_update)(dev, 0);
1653         }
1654
1655         rte_ethdev_trace_start(port_id);
1656         return 0;
1657 }
1658
1659 void
1660 rte_eth_dev_stop(uint16_t port_id)
1661 {
1662         struct rte_eth_dev *dev;
1663
1664         RTE_ETH_VALID_PORTID_OR_RET(port_id);
1665         dev = &rte_eth_devices[port_id];
1666
1667         RTE_FUNC_PTR_OR_RET(*dev->dev_ops->dev_stop);
1668
1669         if (dev->data->dev_started == 0) {
1670                 RTE_ETHDEV_LOG(INFO,
1671                         "Device with port_id=%"PRIu16" already stopped\n",
1672                         port_id);
1673                 return;
1674         }
1675
1676         dev->data->dev_started = 0;
1677         (*dev->dev_ops->dev_stop)(dev);
1678         rte_ethdev_trace_stop(port_id);
1679 }
1680
1681 int
1682 rte_eth_dev_set_link_up(uint16_t port_id)
1683 {
1684         struct rte_eth_dev *dev;
1685
1686         RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -EINVAL);
1687
1688         dev = &rte_eth_devices[port_id];
1689
1690         RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->dev_set_link_up, -ENOTSUP);
1691         return eth_err(port_id, (*dev->dev_ops->dev_set_link_up)(dev));
1692 }
1693
1694 int
1695 rte_eth_dev_set_link_down(uint16_t port_id)
1696 {
1697         struct rte_eth_dev *dev;
1698
1699         RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -EINVAL);
1700
1701         dev = &rte_eth_devices[port_id];
1702
1703         RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->dev_set_link_down, -ENOTSUP);
1704         return eth_err(port_id, (*dev->dev_ops->dev_set_link_down)(dev));
1705 }
1706
1707 void
1708 rte_eth_dev_close(uint16_t port_id)
1709 {
1710         struct rte_eth_dev *dev;
1711
1712         RTE_ETH_VALID_PORTID_OR_RET(port_id);
1713         dev = &rte_eth_devices[port_id];
1714
1715         RTE_FUNC_PTR_OR_RET(*dev->dev_ops->dev_close);
1716         dev->data->dev_started = 0;
1717         (*dev->dev_ops->dev_close)(dev);
1718
1719         rte_ethdev_trace_close(port_id);
1720         /* check behaviour flag - temporary for PMD migration */
1721         if ((dev->data->dev_flags & RTE_ETH_DEV_CLOSE_REMOVE) != 0) {
1722                 /* new behaviour: send event + reset state + free all data */
1723                 rte_eth_dev_release_port(dev);
1724                 return;
1725         }
1726         RTE_ETHDEV_LOG(DEBUG, "Port closing is using an old behaviour.\n"
1727                         "The driver %s should migrate to the new behaviour.\n",
1728                         dev->device->driver->name);
1729         /* old behaviour: only free queue arrays */
1730         dev->data->nb_rx_queues = 0;
1731         rte_free(dev->data->rx_queues);
1732         dev->data->rx_queues = NULL;
1733         dev->data->nb_tx_queues = 0;
1734         rte_free(dev->data->tx_queues);
1735         dev->data->tx_queues = NULL;
1736 }
1737
1738 int
1739 rte_eth_dev_reset(uint16_t port_id)
1740 {
1741         struct rte_eth_dev *dev;
1742         int ret;
1743
1744         RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -EINVAL);
1745         dev = &rte_eth_devices[port_id];
1746
1747         RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->dev_reset, -ENOTSUP);
1748
1749         rte_eth_dev_stop(port_id);
1750         ret = dev->dev_ops->dev_reset(dev);
1751
1752         return eth_err(port_id, ret);
1753 }
1754
1755 int
1756 rte_eth_dev_is_removed(uint16_t port_id)
1757 {
1758         struct rte_eth_dev *dev;
1759         int ret;
1760
1761         RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, 0);
1762
1763         dev = &rte_eth_devices[port_id];
1764
1765         if (dev->state == RTE_ETH_DEV_REMOVED)
1766                 return 1;
1767
1768         RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->is_removed, 0);
1769
1770         ret = dev->dev_ops->is_removed(dev);
1771         if (ret != 0)
1772                 /* Device is physically removed. */
1773                 dev->state = RTE_ETH_DEV_REMOVED;
1774
1775         return ret;
1776 }
1777
1778 int
1779 rte_eth_rx_queue_setup(uint16_t port_id, uint16_t rx_queue_id,
1780                        uint16_t nb_rx_desc, unsigned int socket_id,
1781                        const struct rte_eth_rxconf *rx_conf,
1782                        struct rte_mempool *mp)
1783 {
1784         int ret;
1785         uint32_t mbp_buf_size;
1786         struct rte_eth_dev *dev;
1787         struct rte_eth_dev_info dev_info;
1788         struct rte_eth_rxconf local_conf;
1789         void **rxq;
1790
1791         RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -EINVAL);
1792
1793         dev = &rte_eth_devices[port_id];
1794         if (rx_queue_id >= dev->data->nb_rx_queues) {
1795                 RTE_ETHDEV_LOG(ERR, "Invalid RX queue_id=%u\n", rx_queue_id);
1796                 return -EINVAL;
1797         }
1798
1799         if (mp == NULL) {
1800                 RTE_ETHDEV_LOG(ERR, "Invalid null mempool pointer\n");
1801                 return -EINVAL;
1802         }
1803
1804         RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->rx_queue_setup, -ENOTSUP);
1805
1806         /*
1807          * Check the size of the mbuf data buffer.
1808          * This value must be provided in the private data of the memory pool.
1809          * First check that the memory pool has a valid private data.
1810          */
1811         ret = rte_eth_dev_info_get(port_id, &dev_info);
1812         if (ret != 0)
1813                 return ret;
1814
1815         if (mp->private_data_size < sizeof(struct rte_pktmbuf_pool_private)) {
1816                 RTE_ETHDEV_LOG(ERR, "%s private_data_size %d < %d\n",
1817                         mp->name, (int)mp->private_data_size,
1818                         (int)sizeof(struct rte_pktmbuf_pool_private));
1819                 return -ENOSPC;
1820         }
1821         mbp_buf_size = rte_pktmbuf_data_room_size(mp);
1822
1823         if ((mbp_buf_size - RTE_PKTMBUF_HEADROOM) < dev_info.min_rx_bufsize) {
1824                 RTE_ETHDEV_LOG(ERR,
1825                         "%s mbuf_data_room_size %d < %d (RTE_PKTMBUF_HEADROOM=%d + min_rx_bufsize(dev)=%d)\n",
1826                         mp->name, (int)mbp_buf_size,
1827                         (int)(RTE_PKTMBUF_HEADROOM + dev_info.min_rx_bufsize),
1828                         (int)RTE_PKTMBUF_HEADROOM,
1829                         (int)dev_info.min_rx_bufsize);
1830                 return -EINVAL;
1831         }
1832
1833         /* Use default specified by driver, if nb_rx_desc is zero */
1834         if (nb_rx_desc == 0) {
1835                 nb_rx_desc = dev_info.default_rxportconf.ring_size;
1836                 /* If driver default is also zero, fall back on EAL default */
1837                 if (nb_rx_desc == 0)
1838                         nb_rx_desc = RTE_ETH_DEV_FALLBACK_RX_RINGSIZE;
1839         }
1840
1841         if (nb_rx_desc > dev_info.rx_desc_lim.nb_max ||
1842                         nb_rx_desc < dev_info.rx_desc_lim.nb_min ||
1843                         nb_rx_desc % dev_info.rx_desc_lim.nb_align != 0) {
1844
1845                 RTE_ETHDEV_LOG(ERR,
1846                         "Invalid value for nb_rx_desc(=%hu), should be: <= %hu, >= %hu, and a product of %hu\n",
1847                         nb_rx_desc, dev_info.rx_desc_lim.nb_max,
1848                         dev_info.rx_desc_lim.nb_min,
1849                         dev_info.rx_desc_lim.nb_align);
1850                 return -EINVAL;
1851         }
1852
1853         if (dev->data->dev_started &&
1854                 !(dev_info.dev_capa &
1855                         RTE_ETH_DEV_CAPA_RUNTIME_RX_QUEUE_SETUP))
1856                 return -EBUSY;
1857
1858         if (dev->data->dev_started &&
1859                 (dev->data->rx_queue_state[rx_queue_id] !=
1860                         RTE_ETH_QUEUE_STATE_STOPPED))
1861                 return -EBUSY;
1862
1863         rxq = dev->data->rx_queues;
1864         if (rxq[rx_queue_id]) {
1865                 RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->rx_queue_release,
1866                                         -ENOTSUP);
1867                 (*dev->dev_ops->rx_queue_release)(rxq[rx_queue_id]);
1868                 rxq[rx_queue_id] = NULL;
1869         }
1870
1871         if (rx_conf == NULL)
1872                 rx_conf = &dev_info.default_rxconf;
1873
1874         local_conf = *rx_conf;
1875
1876         /*
1877          * If an offloading has already been enabled in
1878          * rte_eth_dev_configure(), it has been enabled on all queues,
1879          * so there is no need to enable it in this queue again.
1880          * The local_conf.offloads input to underlying PMD only carries
1881          * those offloadings which are only enabled on this queue and
1882          * not enabled on all queues.
1883          */
1884         local_conf.offloads &= ~dev->data->dev_conf.rxmode.offloads;
1885
1886         /*
1887          * New added offloadings for this queue are those not enabled in
1888          * rte_eth_dev_configure() and they must be per-queue type.
1889          * A pure per-port offloading can't be enabled on a queue while
1890          * disabled on another queue. A pure per-port offloading can't
1891          * be enabled for any queue as new added one if it hasn't been
1892          * enabled in rte_eth_dev_configure().
1893          */
1894         if ((local_conf.offloads & dev_info.rx_queue_offload_capa) !=
1895              local_conf.offloads) {
1896                 RTE_ETHDEV_LOG(ERR,
1897                         "Ethdev port_id=%d rx_queue_id=%d, new added offloads 0x%"PRIx64" must be "
1898                         "within per-queue offload capabilities 0x%"PRIx64" in %s()\n",
1899                         port_id, rx_queue_id, local_conf.offloads,
1900                         dev_info.rx_queue_offload_capa,
1901                         __func__);
1902                 return -EINVAL;
1903         }
1904
1905         /*
1906          * If LRO is enabled, check that the maximum aggregated packet
1907          * size is supported by the configured device.
1908          */
1909         if (local_conf.offloads & DEV_RX_OFFLOAD_TCP_LRO) {
1910                 if (dev->data->dev_conf.rxmode.max_lro_pkt_size == 0)
1911                         dev->data->dev_conf.rxmode.max_lro_pkt_size =
1912                                 dev->data->dev_conf.rxmode.max_rx_pkt_len;
1913                 int ret = check_lro_pkt_size(port_id,
1914                                 dev->data->dev_conf.rxmode.max_lro_pkt_size,
1915                                 dev->data->dev_conf.rxmode.max_rx_pkt_len,
1916                                 dev_info.max_lro_pkt_size);
1917                 if (ret != 0)
1918                         return ret;
1919         }
1920
1921         ret = (*dev->dev_ops->rx_queue_setup)(dev, rx_queue_id, nb_rx_desc,
1922                                               socket_id, &local_conf, mp);
1923         if (!ret) {
1924                 if (!dev->data->min_rx_buf_size ||
1925                     dev->data->min_rx_buf_size > mbp_buf_size)
1926                         dev->data->min_rx_buf_size = mbp_buf_size;
1927         }
1928
1929         rte_ethdev_trace_rxq_setup(port_id, rx_queue_id, nb_rx_desc, mp,
1930                 rx_conf, ret);
1931         return eth_err(port_id, ret);
1932 }
1933
1934 int
1935 rte_eth_rx_hairpin_queue_setup(uint16_t port_id, uint16_t rx_queue_id,
1936                                uint16_t nb_rx_desc,
1937                                const struct rte_eth_hairpin_conf *conf)
1938 {
1939         int ret;
1940         struct rte_eth_dev *dev;
1941         struct rte_eth_hairpin_cap cap;
1942         void **rxq;
1943         int i;
1944         int count;
1945
1946         RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -EINVAL);
1947
1948         dev = &rte_eth_devices[port_id];
1949         if (rx_queue_id >= dev->data->nb_rx_queues) {
1950                 RTE_ETHDEV_LOG(ERR, "Invalid RX queue_id=%u\n", rx_queue_id);
1951                 return -EINVAL;
1952         }
1953         ret = rte_eth_dev_hairpin_capability_get(port_id, &cap);
1954         if (ret != 0)
1955                 return ret;
1956         RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->rx_hairpin_queue_setup,
1957                                 -ENOTSUP);
1958         /* if nb_rx_desc is zero use max number of desc from the driver. */
1959         if (nb_rx_desc == 0)
1960                 nb_rx_desc = cap.max_nb_desc;
1961         if (nb_rx_desc > cap.max_nb_desc) {
1962                 RTE_ETHDEV_LOG(ERR,
1963                         "Invalid value for nb_rx_desc(=%hu), should be: <= %hu",
1964                         nb_rx_desc, cap.max_nb_desc);
1965                 return -EINVAL;
1966         }
1967         if (conf->peer_count > cap.max_rx_2_tx) {
1968                 RTE_ETHDEV_LOG(ERR,
1969                         "Invalid value for number of peers for Rx queue(=%hu), should be: <= %hu",
1970                         conf->peer_count, cap.max_rx_2_tx);
1971                 return -EINVAL;
1972         }
1973         if (conf->peer_count == 0) {
1974                 RTE_ETHDEV_LOG(ERR,
1975                         "Invalid value for number of peers for Rx queue(=%hu), should be: > 0",
1976                         conf->peer_count);
1977                 return -EINVAL;
1978         }
1979         for (i = 0, count = 0; i < dev->data->nb_rx_queues &&
1980              cap.max_nb_queues != UINT16_MAX; i++) {
1981                 if (i == rx_queue_id || rte_eth_dev_is_rx_hairpin_queue(dev, i))
1982                         count++;
1983         }
1984         if (count > cap.max_nb_queues) {
1985                 RTE_ETHDEV_LOG(ERR, "To many Rx hairpin queues max is %d",
1986                 cap.max_nb_queues);
1987                 return -EINVAL;
1988         }
1989         if (dev->data->dev_started)
1990                 return -EBUSY;
1991         rxq = dev->data->rx_queues;
1992         if (rxq[rx_queue_id] != NULL) {
1993                 RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->rx_queue_release,
1994                                         -ENOTSUP);
1995                 (*dev->dev_ops->rx_queue_release)(rxq[rx_queue_id]);
1996                 rxq[rx_queue_id] = NULL;
1997         }
1998         ret = (*dev->dev_ops->rx_hairpin_queue_setup)(dev, rx_queue_id,
1999                                                       nb_rx_desc, conf);
2000         if (ret == 0)
2001                 dev->data->rx_queue_state[rx_queue_id] =
2002                         RTE_ETH_QUEUE_STATE_HAIRPIN;
2003         return eth_err(port_id, ret);
2004 }
2005
2006 int
2007 rte_eth_tx_queue_setup(uint16_t port_id, uint16_t tx_queue_id,
2008                        uint16_t nb_tx_desc, unsigned int socket_id,
2009                        const struct rte_eth_txconf *tx_conf)
2010 {
2011         struct rte_eth_dev *dev;
2012         struct rte_eth_dev_info dev_info;
2013         struct rte_eth_txconf local_conf;
2014         void **txq;
2015         int ret;
2016
2017         RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -EINVAL);
2018
2019         dev = &rte_eth_devices[port_id];
2020         if (tx_queue_id >= dev->data->nb_tx_queues) {
2021                 RTE_ETHDEV_LOG(ERR, "Invalid TX queue_id=%u\n", tx_queue_id);
2022                 return -EINVAL;
2023         }
2024
2025         RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->tx_queue_setup, -ENOTSUP);
2026
2027         ret = rte_eth_dev_info_get(port_id, &dev_info);
2028         if (ret != 0)
2029                 return ret;
2030
2031         /* Use default specified by driver, if nb_tx_desc is zero */
2032         if (nb_tx_desc == 0) {
2033                 nb_tx_desc = dev_info.default_txportconf.ring_size;
2034                 /* If driver default is zero, fall back on EAL default */
2035                 if (nb_tx_desc == 0)
2036                         nb_tx_desc = RTE_ETH_DEV_FALLBACK_TX_RINGSIZE;
2037         }
2038         if (nb_tx_desc > dev_info.tx_desc_lim.nb_max ||
2039             nb_tx_desc < dev_info.tx_desc_lim.nb_min ||
2040             nb_tx_desc % dev_info.tx_desc_lim.nb_align != 0) {
2041                 RTE_ETHDEV_LOG(ERR,
2042                         "Invalid value for nb_tx_desc(=%hu), should be: <= %hu, >= %hu, and a product of %hu\n",
2043                         nb_tx_desc, dev_info.tx_desc_lim.nb_max,
2044                         dev_info.tx_desc_lim.nb_min,
2045                         dev_info.tx_desc_lim.nb_align);
2046                 return -EINVAL;
2047         }
2048
2049         if (dev->data->dev_started &&
2050                 !(dev_info.dev_capa &
2051                         RTE_ETH_DEV_CAPA_RUNTIME_TX_QUEUE_SETUP))
2052                 return -EBUSY;
2053
2054         if (dev->data->dev_started &&
2055                 (dev->data->tx_queue_state[tx_queue_id] !=
2056                         RTE_ETH_QUEUE_STATE_STOPPED))
2057                 return -EBUSY;
2058
2059         txq = dev->data->tx_queues;
2060         if (txq[tx_queue_id]) {
2061                 RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->tx_queue_release,
2062                                         -ENOTSUP);
2063                 (*dev->dev_ops->tx_queue_release)(txq[tx_queue_id]);
2064                 txq[tx_queue_id] = NULL;
2065         }
2066
2067         if (tx_conf == NULL)
2068                 tx_conf = &dev_info.default_txconf;
2069
2070         local_conf = *tx_conf;
2071
2072         /*
2073          * If an offloading has already been enabled in
2074          * rte_eth_dev_configure(), it has been enabled on all queues,
2075          * so there is no need to enable it in this queue again.
2076          * The local_conf.offloads input to underlying PMD only carries
2077          * those offloadings which are only enabled on this queue and
2078          * not enabled on all queues.
2079          */
2080         local_conf.offloads &= ~dev->data->dev_conf.txmode.offloads;
2081
2082         /*
2083          * New added offloadings for this queue are those not enabled in
2084          * rte_eth_dev_configure() and they must be per-queue type.
2085          * A pure per-port offloading can't be enabled on a queue while
2086          * disabled on another queue. A pure per-port offloading can't
2087          * be enabled for any queue as new added one if it hasn't been
2088          * enabled in rte_eth_dev_configure().
2089          */
2090         if ((local_conf.offloads & dev_info.tx_queue_offload_capa) !=
2091              local_conf.offloads) {
2092                 RTE_ETHDEV_LOG(ERR,
2093                         "Ethdev port_id=%d tx_queue_id=%d, new added offloads 0x%"PRIx64" must be "
2094                         "within per-queue offload capabilities 0x%"PRIx64" in %s()\n",
2095                         port_id, tx_queue_id, local_conf.offloads,
2096                         dev_info.tx_queue_offload_capa,
2097                         __func__);
2098                 return -EINVAL;
2099         }
2100
2101         rte_ethdev_trace_txq_setup(port_id, tx_queue_id, nb_tx_desc, tx_conf);
2102         return eth_err(port_id, (*dev->dev_ops->tx_queue_setup)(dev,
2103                        tx_queue_id, nb_tx_desc, socket_id, &local_conf));
2104 }
2105
2106 int
2107 rte_eth_tx_hairpin_queue_setup(uint16_t port_id, uint16_t tx_queue_id,
2108                                uint16_t nb_tx_desc,
2109                                const struct rte_eth_hairpin_conf *conf)
2110 {
2111         struct rte_eth_dev *dev;
2112         struct rte_eth_hairpin_cap cap;
2113         void **txq;
2114         int i;
2115         int count;
2116         int ret;
2117
2118         RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -EINVAL);
2119         dev = &rte_eth_devices[port_id];
2120         if (tx_queue_id >= dev->data->nb_tx_queues) {
2121                 RTE_ETHDEV_LOG(ERR, "Invalid TX queue_id=%u\n", tx_queue_id);
2122                 return -EINVAL;
2123         }
2124         ret = rte_eth_dev_hairpin_capability_get(port_id, &cap);
2125         if (ret != 0)
2126                 return ret;
2127         RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->tx_hairpin_queue_setup,
2128                                 -ENOTSUP);
2129         /* if nb_rx_desc is zero use max number of desc from the driver. */
2130         if (nb_tx_desc == 0)
2131                 nb_tx_desc = cap.max_nb_desc;
2132         if (nb_tx_desc > cap.max_nb_desc) {
2133                 RTE_ETHDEV_LOG(ERR,
2134                         "Invalid value for nb_tx_desc(=%hu), should be: <= %hu",
2135                         nb_tx_desc, cap.max_nb_desc);
2136                 return -EINVAL;
2137         }
2138         if (conf->peer_count > cap.max_tx_2_rx) {
2139                 RTE_ETHDEV_LOG(ERR,
2140                         "Invalid value for number of peers for Tx queue(=%hu), should be: <= %hu",
2141                         conf->peer_count, cap.max_tx_2_rx);
2142                 return -EINVAL;
2143         }
2144         if (conf->peer_count == 0) {
2145                 RTE_ETHDEV_LOG(ERR,
2146                         "Invalid value for number of peers for Tx queue(=%hu), should be: > 0",
2147                         conf->peer_count);
2148                 return -EINVAL;
2149         }
2150         for (i = 0, count = 0; i < dev->data->nb_tx_queues &&
2151              cap.max_nb_queues != UINT16_MAX; i++) {
2152                 if (i == tx_queue_id || rte_eth_dev_is_tx_hairpin_queue(dev, i))
2153                         count++;
2154         }
2155         if (count > cap.max_nb_queues) {
2156                 RTE_ETHDEV_LOG(ERR, "To many Tx hairpin queues max is %d",
2157                 cap.max_nb_queues);
2158                 return -EINVAL;
2159         }
2160         if (dev->data->dev_started)
2161                 return -EBUSY;
2162         txq = dev->data->tx_queues;
2163         if (txq[tx_queue_id] != NULL) {
2164                 RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->tx_queue_release,
2165                                         -ENOTSUP);
2166                 (*dev->dev_ops->tx_queue_release)(txq[tx_queue_id]);
2167                 txq[tx_queue_id] = NULL;
2168         }
2169         ret = (*dev->dev_ops->tx_hairpin_queue_setup)
2170                 (dev, tx_queue_id, nb_tx_desc, conf);
2171         if (ret == 0)
2172                 dev->data->tx_queue_state[tx_queue_id] =
2173                         RTE_ETH_QUEUE_STATE_HAIRPIN;
2174         return eth_err(port_id, ret);
2175 }
2176
2177 void
2178 rte_eth_tx_buffer_drop_callback(struct rte_mbuf **pkts, uint16_t unsent,
2179                 void *userdata __rte_unused)
2180 {
2181         unsigned i;
2182
2183         for (i = 0; i < unsent; i++)
2184                 rte_pktmbuf_free(pkts[i]);
2185 }
2186
2187 void
2188 rte_eth_tx_buffer_count_callback(struct rte_mbuf **pkts, uint16_t unsent,
2189                 void *userdata)
2190 {
2191         uint64_t *count = userdata;
2192         unsigned i;
2193
2194         for (i = 0; i < unsent; i++)
2195                 rte_pktmbuf_free(pkts[i]);
2196
2197         *count += unsent;
2198 }
2199
2200 int
2201 rte_eth_tx_buffer_set_err_callback(struct rte_eth_dev_tx_buffer *buffer,
2202                 buffer_tx_error_fn cbfn, void *userdata)
2203 {
2204         buffer->error_callback = cbfn;
2205         buffer->error_userdata = userdata;
2206         return 0;
2207 }
2208
2209 int
2210 rte_eth_tx_buffer_init(struct rte_eth_dev_tx_buffer *buffer, uint16_t size)
2211 {
2212         int ret = 0;
2213
2214         if (buffer == NULL)
2215                 return -EINVAL;
2216
2217         buffer->size = size;
2218         if (buffer->error_callback == NULL) {
2219                 ret = rte_eth_tx_buffer_set_err_callback(
2220                         buffer, rte_eth_tx_buffer_drop_callback, NULL);
2221         }
2222
2223         return ret;
2224 }
2225
2226 int
2227 rte_eth_tx_done_cleanup(uint16_t port_id, uint16_t queue_id, uint32_t free_cnt)
2228 {
2229         struct rte_eth_dev *dev = &rte_eth_devices[port_id];
2230         int ret;
2231
2232         /* Validate Input Data. Bail if not valid or not supported. */
2233         RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV);
2234         RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->tx_done_cleanup, -ENOTSUP);
2235
2236         /* Call driver to free pending mbufs. */
2237         ret = (*dev->dev_ops->tx_done_cleanup)(dev->data->tx_queues[queue_id],
2238                                                free_cnt);
2239         return eth_err(port_id, ret);
2240 }
2241
2242 int
2243 rte_eth_promiscuous_enable(uint16_t port_id)
2244 {
2245         struct rte_eth_dev *dev;
2246         int diag = 0;
2247
2248         RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV);
2249         dev = &rte_eth_devices[port_id];
2250
2251         if (dev->data->promiscuous == 1)
2252                 return 0;
2253
2254         RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->promiscuous_enable, -ENOTSUP);
2255
2256         diag = (*dev->dev_ops->promiscuous_enable)(dev);
2257         dev->data->promiscuous = (diag == 0) ? 1 : 0;
2258
2259         return eth_err(port_id, diag);
2260 }
2261
2262 int
2263 rte_eth_promiscuous_disable(uint16_t port_id)
2264 {
2265         struct rte_eth_dev *dev;
2266         int diag = 0;
2267
2268         RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV);
2269         dev = &rte_eth_devices[port_id];
2270
2271         if (dev->data->promiscuous == 0)
2272                 return 0;
2273
2274         RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->promiscuous_disable, -ENOTSUP);
2275
2276         dev->data->promiscuous = 0;
2277         diag = (*dev->dev_ops->promiscuous_disable)(dev);
2278         if (diag != 0)
2279                 dev->data->promiscuous = 1;
2280
2281         return eth_err(port_id, diag);
2282 }
2283
2284 int
2285 rte_eth_promiscuous_get(uint16_t port_id)
2286 {
2287         struct rte_eth_dev *dev;
2288
2289         RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -EINVAL);
2290
2291         dev = &rte_eth_devices[port_id];
2292         return dev->data->promiscuous;
2293 }
2294
2295 int
2296 rte_eth_allmulticast_enable(uint16_t port_id)
2297 {
2298         struct rte_eth_dev *dev;
2299         int diag;
2300
2301         RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV);
2302         dev = &rte_eth_devices[port_id];
2303
2304         if (dev->data->all_multicast == 1)
2305                 return 0;
2306
2307         RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->allmulticast_enable, -ENOTSUP);
2308         diag = (*dev->dev_ops->allmulticast_enable)(dev);
2309         dev->data->all_multicast = (diag == 0) ? 1 : 0;
2310
2311         return eth_err(port_id, diag);
2312 }
2313
2314 int
2315 rte_eth_allmulticast_disable(uint16_t port_id)
2316 {
2317         struct rte_eth_dev *dev;
2318         int diag;
2319
2320         RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV);
2321         dev = &rte_eth_devices[port_id];
2322
2323         if (dev->data->all_multicast == 0)
2324                 return 0;
2325
2326         RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->allmulticast_disable, -ENOTSUP);
2327         dev->data->all_multicast = 0;
2328         diag = (*dev->dev_ops->allmulticast_disable)(dev);
2329         if (diag != 0)
2330                 dev->data->all_multicast = 1;
2331
2332         return eth_err(port_id, diag);
2333 }
2334
2335 int
2336 rte_eth_allmulticast_get(uint16_t port_id)
2337 {
2338         struct rte_eth_dev *dev;
2339
2340         RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -EINVAL);
2341
2342         dev = &rte_eth_devices[port_id];
2343         return dev->data->all_multicast;
2344 }
2345
2346 int
2347 rte_eth_link_get(uint16_t port_id, struct rte_eth_link *eth_link)
2348 {
2349         struct rte_eth_dev *dev;
2350
2351         RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV);
2352         dev = &rte_eth_devices[port_id];
2353
2354         if (dev->data->dev_conf.intr_conf.lsc &&
2355             dev->data->dev_started)
2356                 rte_eth_linkstatus_get(dev, eth_link);
2357         else {
2358                 RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->link_update, -ENOTSUP);
2359                 (*dev->dev_ops->link_update)(dev, 1);
2360                 *eth_link = dev->data->dev_link;
2361         }
2362
2363         return 0;
2364 }
2365
2366 int
2367 rte_eth_link_get_nowait(uint16_t port_id, struct rte_eth_link *eth_link)
2368 {
2369         struct rte_eth_dev *dev;
2370
2371         RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV);
2372         dev = &rte_eth_devices[port_id];
2373
2374         if (dev->data->dev_conf.intr_conf.lsc &&
2375             dev->data->dev_started)
2376                 rte_eth_linkstatus_get(dev, eth_link);
2377         else {
2378                 RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->link_update, -ENOTSUP);
2379                 (*dev->dev_ops->link_update)(dev, 0);
2380                 *eth_link = dev->data->dev_link;
2381         }
2382
2383         return 0;
2384 }
2385
2386 int
2387 rte_eth_stats_get(uint16_t port_id, struct rte_eth_stats *stats)
2388 {
2389         struct rte_eth_dev *dev;
2390
2391         RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -EINVAL);
2392
2393         dev = &rte_eth_devices[port_id];
2394         memset(stats, 0, sizeof(*stats));
2395
2396         RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->stats_get, -ENOTSUP);
2397         stats->rx_nombuf = dev->data->rx_mbuf_alloc_failed;
2398         return eth_err(port_id, (*dev->dev_ops->stats_get)(dev, stats));
2399 }
2400
2401 int
2402 rte_eth_stats_reset(uint16_t port_id)
2403 {
2404         struct rte_eth_dev *dev;
2405         int ret;
2406
2407         RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV);
2408         dev = &rte_eth_devices[port_id];
2409
2410         RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->stats_reset, -ENOTSUP);
2411         ret = (*dev->dev_ops->stats_reset)(dev);
2412         if (ret != 0)
2413                 return eth_err(port_id, ret);
2414
2415         dev->data->rx_mbuf_alloc_failed = 0;
2416
2417         return 0;
2418 }
2419
2420 static inline int
2421 get_xstats_basic_count(struct rte_eth_dev *dev)
2422 {
2423         uint16_t nb_rxqs, nb_txqs;
2424         int count;
2425
2426         nb_rxqs = RTE_MIN(dev->data->nb_rx_queues, RTE_ETHDEV_QUEUE_STAT_CNTRS);
2427         nb_txqs = RTE_MIN(dev->data->nb_tx_queues, RTE_ETHDEV_QUEUE_STAT_CNTRS);
2428
2429         count = RTE_NB_STATS;
2430         count += nb_rxqs * RTE_NB_RXQ_STATS;
2431         count += nb_txqs * RTE_NB_TXQ_STATS;
2432
2433         return count;
2434 }
2435
2436 static int
2437 get_xstats_count(uint16_t port_id)
2438 {
2439         struct rte_eth_dev *dev;
2440         int count;
2441
2442         RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -EINVAL);
2443         dev = &rte_eth_devices[port_id];
2444         if (dev->dev_ops->xstats_get_names_by_id != NULL) {
2445                 count = (*dev->dev_ops->xstats_get_names_by_id)(dev, NULL,
2446                                 NULL, 0);
2447                 if (count < 0)
2448                         return eth_err(port_id, count);
2449         }
2450         if (dev->dev_ops->xstats_get_names != NULL) {
2451                 count = (*dev->dev_ops->xstats_get_names)(dev, NULL, 0);
2452                 if (count < 0)
2453                         return eth_err(port_id, count);
2454         } else
2455                 count = 0;
2456
2457
2458         count += get_xstats_basic_count(dev);
2459
2460         return count;
2461 }
2462
2463 int
2464 rte_eth_xstats_get_id_by_name(uint16_t port_id, const char *xstat_name,
2465                 uint64_t *id)
2466 {
2467         int cnt_xstats, idx_xstat;
2468
2469         RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV);
2470
2471         if (!id) {
2472                 RTE_ETHDEV_LOG(ERR, "Id pointer is NULL\n");
2473                 return -ENOMEM;
2474         }
2475
2476         if (!xstat_name) {
2477                 RTE_ETHDEV_LOG(ERR, "xstat_name pointer is NULL\n");
2478                 return -ENOMEM;
2479         }
2480
2481         /* Get count */
2482         cnt_xstats = rte_eth_xstats_get_names_by_id(port_id, NULL, 0, NULL);
2483         if (cnt_xstats  < 0) {
2484                 RTE_ETHDEV_LOG(ERR, "Cannot get count of xstats\n");
2485                 return -ENODEV;
2486         }
2487
2488         /* Get id-name lookup table */
2489         struct rte_eth_xstat_name xstats_names[cnt_xstats];
2490
2491         if (cnt_xstats != rte_eth_xstats_get_names_by_id(
2492                         port_id, xstats_names, cnt_xstats, NULL)) {
2493                 RTE_ETHDEV_LOG(ERR, "Cannot get xstats lookup\n");
2494                 return -1;
2495         }
2496
2497         for (idx_xstat = 0; idx_xstat < cnt_xstats; idx_xstat++) {
2498                 if (!strcmp(xstats_names[idx_xstat].name, xstat_name)) {
2499                         *id = idx_xstat;
2500                         return 0;
2501                 };
2502         }
2503
2504         return -EINVAL;
2505 }
2506
2507 /* retrieve basic stats names */
2508 static int
2509 rte_eth_basic_stats_get_names(struct rte_eth_dev *dev,
2510         struct rte_eth_xstat_name *xstats_names)
2511 {
2512         int cnt_used_entries = 0;
2513         uint32_t idx, id_queue;
2514         uint16_t num_q;
2515
2516         for (idx = 0; idx < RTE_NB_STATS; idx++) {
2517                 strlcpy(xstats_names[cnt_used_entries].name,
2518                         rte_stats_strings[idx].name,
2519                         sizeof(xstats_names[0].name));
2520                 cnt_used_entries++;
2521         }
2522         num_q = RTE_MIN(dev->data->nb_rx_queues, RTE_ETHDEV_QUEUE_STAT_CNTRS);
2523         for (id_queue = 0; id_queue < num_q; id_queue++) {
2524                 for (idx = 0; idx < RTE_NB_RXQ_STATS; idx++) {
2525                         snprintf(xstats_names[cnt_used_entries].name,
2526                                 sizeof(xstats_names[0].name),
2527                                 "rx_q%u%s",
2528                                 id_queue, rte_rxq_stats_strings[idx].name);
2529                         cnt_used_entries++;
2530                 }
2531
2532         }
2533         num_q = RTE_MIN(dev->data->nb_tx_queues, RTE_ETHDEV_QUEUE_STAT_CNTRS);
2534         for (id_queue = 0; id_queue < num_q; id_queue++) {
2535                 for (idx = 0; idx < RTE_NB_TXQ_STATS; idx++) {
2536                         snprintf(xstats_names[cnt_used_entries].name,
2537                                 sizeof(xstats_names[0].name),
2538                                 "tx_q%u%s",
2539                                 id_queue, rte_txq_stats_strings[idx].name);
2540                         cnt_used_entries++;
2541                 }
2542         }
2543         return cnt_used_entries;
2544 }
2545
2546 /* retrieve ethdev extended statistics names */
2547 int
2548 rte_eth_xstats_get_names_by_id(uint16_t port_id,
2549         struct rte_eth_xstat_name *xstats_names, unsigned int size,
2550         uint64_t *ids)
2551 {
2552         struct rte_eth_xstat_name *xstats_names_copy;
2553         unsigned int no_basic_stat_requested = 1;
2554         unsigned int no_ext_stat_requested = 1;
2555         unsigned int expected_entries;
2556         unsigned int basic_count;
2557         struct rte_eth_dev *dev;
2558         unsigned int i;
2559         int ret;
2560
2561         RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV);
2562         dev = &rte_eth_devices[port_id];
2563
2564         basic_count = get_xstats_basic_count(dev);
2565         ret = get_xstats_count(port_id);
2566         if (ret < 0)
2567                 return ret;
2568         expected_entries = (unsigned int)ret;
2569
2570         /* Return max number of stats if no ids given */
2571         if (!ids) {
2572                 if (!xstats_names)
2573                         return expected_entries;
2574                 else if (xstats_names && size < expected_entries)
2575                         return expected_entries;
2576         }
2577
2578         if (ids && !xstats_names)
2579                 return -EINVAL;
2580
2581         if (ids && dev->dev_ops->xstats_get_names_by_id != NULL && size > 0) {
2582                 uint64_t ids_copy[size];
2583
2584                 for (i = 0; i < size; i++) {
2585                         if (ids[i] < basic_count) {
2586                                 no_basic_stat_requested = 0;
2587                                 break;
2588                         }
2589
2590                         /*
2591                          * Convert ids to xstats ids that PMD knows.
2592                          * ids known by user are basic + extended stats.
2593                          */
2594                         ids_copy[i] = ids[i] - basic_count;
2595                 }
2596
2597                 if (no_basic_stat_requested)
2598                         return (*dev->dev_ops->xstats_get_names_by_id)(dev,
2599                                         xstats_names, ids_copy, size);
2600         }
2601
2602         /* Retrieve all stats */
2603         if (!ids) {
2604                 int num_stats = rte_eth_xstats_get_names(port_id, xstats_names,
2605                                 expected_entries);
2606                 if (num_stats < 0 || num_stats > (int)expected_entries)
2607                         return num_stats;
2608                 else
2609                         return expected_entries;
2610         }
2611
2612         xstats_names_copy = calloc(expected_entries,
2613                 sizeof(struct rte_eth_xstat_name));
2614
2615         if (!xstats_names_copy) {
2616                 RTE_ETHDEV_LOG(ERR, "Can't allocate memory\n");
2617                 return -ENOMEM;
2618         }
2619
2620         if (ids) {
2621                 for (i = 0; i < size; i++) {
2622                         if (ids[i] >= basic_count) {
2623                                 no_ext_stat_requested = 0;
2624                                 break;
2625                         }
2626                 }
2627         }
2628
2629         /* Fill xstats_names_copy structure */
2630         if (ids && no_ext_stat_requested) {
2631                 rte_eth_basic_stats_get_names(dev, xstats_names_copy);
2632         } else {
2633                 ret = rte_eth_xstats_get_names(port_id, xstats_names_copy,
2634                         expected_entries);
2635                 if (ret < 0) {
2636                         free(xstats_names_copy);
2637                         return ret;
2638                 }
2639         }
2640
2641         /* Filter stats */
2642         for (i = 0; i < size; i++) {
2643                 if (ids[i] >= expected_entries) {
2644                         RTE_ETHDEV_LOG(ERR, "Id value isn't valid\n");
2645                         free(xstats_names_copy);
2646                         return -1;
2647                 }
2648                 xstats_names[i] = xstats_names_copy[ids[i]];
2649         }
2650
2651         free(xstats_names_copy);
2652         return size;
2653 }
2654
2655 int
2656 rte_eth_xstats_get_names(uint16_t port_id,
2657         struct rte_eth_xstat_name *xstats_names,
2658         unsigned int size)
2659 {
2660         struct rte_eth_dev *dev;
2661         int cnt_used_entries;
2662         int cnt_expected_entries;
2663         int cnt_driver_entries;
2664
2665         cnt_expected_entries = get_xstats_count(port_id);
2666         if (xstats_names == NULL || cnt_expected_entries < 0 ||
2667                         (int)size < cnt_expected_entries)
2668                 return cnt_expected_entries;
2669
2670         /* port_id checked in get_xstats_count() */
2671         dev = &rte_eth_devices[port_id];
2672
2673         cnt_used_entries = rte_eth_basic_stats_get_names(
2674                 dev, xstats_names);
2675
2676         if (dev->dev_ops->xstats_get_names != NULL) {
2677                 /* If there are any driver-specific xstats, append them
2678                  * to end of list.
2679                  */
2680                 cnt_driver_entries = (*dev->dev_ops->xstats_get_names)(
2681                         dev,
2682                         xstats_names + cnt_used_entries,
2683                         size - cnt_used_entries);
2684                 if (cnt_driver_entries < 0)
2685                         return eth_err(port_id, cnt_driver_entries);
2686                 cnt_used_entries += cnt_driver_entries;
2687         }
2688
2689         return cnt_used_entries;
2690 }
2691
2692
2693 static int
2694 rte_eth_basic_stats_get(uint16_t port_id, struct rte_eth_xstat *xstats)
2695 {
2696         struct rte_eth_dev *dev;
2697         struct rte_eth_stats eth_stats;
2698         unsigned int count = 0, i, q;
2699         uint64_t val, *stats_ptr;
2700         uint16_t nb_rxqs, nb_txqs;
2701         int ret;
2702
2703         ret = rte_eth_stats_get(port_id, &eth_stats);
2704         if (ret < 0)
2705                 return ret;
2706
2707         dev = &rte_eth_devices[port_id];
2708
2709         nb_rxqs = RTE_MIN(dev->data->nb_rx_queues, RTE_ETHDEV_QUEUE_STAT_CNTRS);
2710         nb_txqs = RTE_MIN(dev->data->nb_tx_queues, RTE_ETHDEV_QUEUE_STAT_CNTRS);
2711
2712         /* global stats */
2713         for (i = 0; i < RTE_NB_STATS; i++) {
2714                 stats_ptr = RTE_PTR_ADD(&eth_stats,
2715                                         rte_stats_strings[i].offset);
2716                 val = *stats_ptr;
2717                 xstats[count++].value = val;
2718         }
2719
2720         /* per-rxq stats */
2721         for (q = 0; q < nb_rxqs; q++) {
2722                 for (i = 0; i < RTE_NB_RXQ_STATS; i++) {
2723                         stats_ptr = RTE_PTR_ADD(&eth_stats,
2724                                         rte_rxq_stats_strings[i].offset +
2725                                         q * sizeof(uint64_t));
2726                         val = *stats_ptr;
2727                         xstats[count++].value = val;
2728                 }
2729         }
2730
2731         /* per-txq stats */
2732         for (q = 0; q < nb_txqs; q++) {
2733                 for (i = 0; i < RTE_NB_TXQ_STATS; i++) {
2734                         stats_ptr = RTE_PTR_ADD(&eth_stats,
2735                                         rte_txq_stats_strings[i].offset +
2736                                         q * sizeof(uint64_t));
2737                         val = *stats_ptr;
2738                         xstats[count++].value = val;
2739                 }
2740         }
2741         return count;
2742 }
2743
2744 /* retrieve ethdev extended statistics */
2745 int
2746 rte_eth_xstats_get_by_id(uint16_t port_id, const uint64_t *ids,
2747                          uint64_t *values, unsigned int size)
2748 {
2749         unsigned int no_basic_stat_requested = 1;
2750         unsigned int no_ext_stat_requested = 1;
2751         unsigned int num_xstats_filled;
2752         unsigned int basic_count;
2753         uint16_t expected_entries;
2754         struct rte_eth_dev *dev;
2755         unsigned int i;
2756         int ret;
2757
2758         RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV);
2759         ret = get_xstats_count(port_id);
2760         if (ret < 0)
2761                 return ret;
2762         expected_entries = (uint16_t)ret;
2763         struct rte_eth_xstat xstats[expected_entries];
2764         dev = &rte_eth_devices[port_id];
2765         basic_count = get_xstats_basic_count(dev);
2766
2767         /* Return max number of stats if no ids given */
2768         if (!ids) {
2769                 if (!values)
2770                         return expected_entries;
2771                 else if (values && size < expected_entries)
2772                         return expected_entries;
2773         }
2774
2775         if (ids && !values)
2776                 return -EINVAL;
2777
2778         if (ids && dev->dev_ops->xstats_get_by_id != NULL && size) {
2779                 unsigned int basic_count = get_xstats_basic_count(dev);
2780                 uint64_t ids_copy[size];
2781
2782                 for (i = 0; i < size; i++) {
2783                         if (ids[i] < basic_count) {
2784                                 no_basic_stat_requested = 0;
2785                                 break;
2786                         }
2787
2788                         /*
2789                          * Convert ids to xstats ids that PMD knows.
2790                          * ids known by user are basic + extended stats.
2791                          */
2792                         ids_copy[i] = ids[i] - basic_count;
2793                 }
2794
2795                 if (no_basic_stat_requested)
2796                         return (*dev->dev_ops->xstats_get_by_id)(dev, ids_copy,
2797                                         values, size);
2798         }
2799
2800         if (ids) {
2801                 for (i = 0; i < size; i++) {
2802                         if (ids[i] >= basic_count) {
2803                                 no_ext_stat_requested = 0;
2804                                 break;
2805                         }
2806                 }
2807         }
2808
2809         /* Fill the xstats structure */
2810         if (ids && no_ext_stat_requested)
2811                 ret = rte_eth_basic_stats_get(port_id, xstats);
2812         else
2813                 ret = rte_eth_xstats_get(port_id, xstats, expected_entries);
2814
2815         if (ret < 0)
2816                 return ret;
2817         num_xstats_filled = (unsigned int)ret;
2818
2819         /* Return all stats */
2820         if (!ids) {
2821                 for (i = 0; i < num_xstats_filled; i++)
2822                         values[i] = xstats[i].value;
2823                 return expected_entries;
2824         }
2825
2826         /* Filter stats */
2827         for (i = 0; i < size; i++) {
2828                 if (ids[i] >= expected_entries) {
2829                         RTE_ETHDEV_LOG(ERR, "Id value isn't valid\n");
2830                         return -1;
2831                 }
2832                 values[i] = xstats[ids[i]].value;
2833         }
2834         return size;
2835 }
2836
2837 int
2838 rte_eth_xstats_get(uint16_t port_id, struct rte_eth_xstat *xstats,
2839         unsigned int n)
2840 {
2841         struct rte_eth_dev *dev;
2842         unsigned int count = 0, i;
2843         signed int xcount = 0;
2844         uint16_t nb_rxqs, nb_txqs;
2845         int ret;
2846
2847         RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -EINVAL);
2848
2849         dev = &rte_eth_devices[port_id];
2850
2851         nb_rxqs = RTE_MIN(dev->data->nb_rx_queues, RTE_ETHDEV_QUEUE_STAT_CNTRS);
2852         nb_txqs = RTE_MIN(dev->data->nb_tx_queues, RTE_ETHDEV_QUEUE_STAT_CNTRS);
2853
2854         /* Return generic statistics */
2855         count = RTE_NB_STATS + (nb_rxqs * RTE_NB_RXQ_STATS) +
2856                 (nb_txqs * RTE_NB_TXQ_STATS);
2857
2858         /* implemented by the driver */
2859         if (dev->dev_ops->xstats_get != NULL) {
2860                 /* Retrieve the xstats from the driver at the end of the
2861                  * xstats struct.
2862                  */
2863                 xcount = (*dev->dev_ops->xstats_get)(dev,
2864                                      xstats ? xstats + count : NULL,
2865                                      (n > count) ? n - count : 0);
2866
2867                 if (xcount < 0)
2868                         return eth_err(port_id, xcount);
2869         }
2870
2871         if (n < count + xcount || xstats == NULL)
2872                 return count + xcount;
2873
2874         /* now fill the xstats structure */
2875         ret = rte_eth_basic_stats_get(port_id, xstats);
2876         if (ret < 0)
2877                 return ret;
2878         count = ret;
2879
2880         for (i = 0; i < count; i++)
2881                 xstats[i].id = i;
2882         /* add an offset to driver-specific stats */
2883         for ( ; i < count + xcount; i++)
2884                 xstats[i].id += count;
2885
2886         return count + xcount;
2887 }
2888
2889 /* reset ethdev extended statistics */
2890 int
2891 rte_eth_xstats_reset(uint16_t port_id)
2892 {
2893         struct rte_eth_dev *dev;
2894
2895         RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV);
2896         dev = &rte_eth_devices[port_id];
2897
2898         /* implemented by the driver */
2899         if (dev->dev_ops->xstats_reset != NULL)
2900                 return eth_err(port_id, (*dev->dev_ops->xstats_reset)(dev));
2901
2902         /* fallback to default */
2903         return rte_eth_stats_reset(port_id);
2904 }
2905
2906 static int
2907 set_queue_stats_mapping(uint16_t port_id, uint16_t queue_id, uint8_t stat_idx,
2908                 uint8_t is_rx)
2909 {
2910         struct rte_eth_dev *dev;
2911
2912         RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV);
2913
2914         dev = &rte_eth_devices[port_id];
2915
2916         RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->queue_stats_mapping_set, -ENOTSUP);
2917
2918         if (is_rx && (queue_id >= dev->data->nb_rx_queues))
2919                 return -EINVAL;
2920
2921         if (!is_rx && (queue_id >= dev->data->nb_tx_queues))
2922                 return -EINVAL;
2923
2924         if (stat_idx >= RTE_ETHDEV_QUEUE_STAT_CNTRS)
2925                 return -EINVAL;
2926
2927         return (*dev->dev_ops->queue_stats_mapping_set)
2928                         (dev, queue_id, stat_idx, is_rx);
2929 }
2930
2931
2932 int
2933 rte_eth_dev_set_tx_queue_stats_mapping(uint16_t port_id, uint16_t tx_queue_id,
2934                 uint8_t stat_idx)
2935 {
2936         return eth_err(port_id, set_queue_stats_mapping(port_id, tx_queue_id,
2937                                                 stat_idx, STAT_QMAP_TX));
2938 }
2939
2940
2941 int
2942 rte_eth_dev_set_rx_queue_stats_mapping(uint16_t port_id, uint16_t rx_queue_id,
2943                 uint8_t stat_idx)
2944 {
2945         return eth_err(port_id, set_queue_stats_mapping(port_id, rx_queue_id,
2946                                                 stat_idx, STAT_QMAP_RX));
2947 }
2948
2949 int
2950 rte_eth_dev_fw_version_get(uint16_t port_id, char *fw_version, size_t fw_size)
2951 {
2952         struct rte_eth_dev *dev;
2953
2954         RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV);
2955         dev = &rte_eth_devices[port_id];
2956
2957         RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->fw_version_get, -ENOTSUP);
2958         return eth_err(port_id, (*dev->dev_ops->fw_version_get)(dev,
2959                                                         fw_version, fw_size));
2960 }
2961
2962 int
2963 rte_eth_dev_info_get(uint16_t port_id, struct rte_eth_dev_info *dev_info)
2964 {
2965         struct rte_eth_dev *dev;
2966         const struct rte_eth_desc_lim lim = {
2967                 .nb_max = UINT16_MAX,
2968                 .nb_min = 0,
2969                 .nb_align = 1,
2970                 .nb_seg_max = UINT16_MAX,
2971                 .nb_mtu_seg_max = UINT16_MAX,
2972         };
2973         int diag;
2974
2975         /*
2976          * Init dev_info before port_id check since caller does not have
2977          * return status and does not know if get is successful or not.
2978          */
2979         memset(dev_info, 0, sizeof(struct rte_eth_dev_info));
2980         dev_info->switch_info.domain_id = RTE_ETH_DEV_SWITCH_DOMAIN_ID_INVALID;
2981
2982         RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV);
2983         dev = &rte_eth_devices[port_id];
2984
2985         dev_info->rx_desc_lim = lim;
2986         dev_info->tx_desc_lim = lim;
2987         dev_info->device = dev->device;
2988         dev_info->min_mtu = RTE_ETHER_MIN_MTU;
2989         dev_info->max_mtu = UINT16_MAX;
2990
2991         RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->dev_infos_get, -ENOTSUP);
2992         diag = (*dev->dev_ops->dev_infos_get)(dev, dev_info);
2993         if (diag != 0) {
2994                 /* Cleanup already filled in device information */
2995                 memset(dev_info, 0, sizeof(struct rte_eth_dev_info));
2996                 return eth_err(port_id, diag);
2997         }
2998
2999         /* Maximum number of queues should be <= RTE_MAX_QUEUES_PER_PORT */
3000         dev_info->max_rx_queues = RTE_MIN(dev_info->max_rx_queues,
3001                         RTE_MAX_QUEUES_PER_PORT);
3002         dev_info->max_tx_queues = RTE_MIN(dev_info->max_tx_queues,
3003                         RTE_MAX_QUEUES_PER_PORT);
3004
3005         dev_info->driver_name = dev->device->driver->name;
3006         dev_info->nb_rx_queues = dev->data->nb_rx_queues;
3007         dev_info->nb_tx_queues = dev->data->nb_tx_queues;
3008
3009         dev_info->dev_flags = &dev->data->dev_flags;
3010
3011         return 0;
3012 }
3013
3014 int
3015 rte_eth_dev_get_supported_ptypes(uint16_t port_id, uint32_t ptype_mask,
3016                                  uint32_t *ptypes, int num)
3017 {
3018         int i, j;
3019         struct rte_eth_dev *dev;
3020         const uint32_t *all_ptypes;
3021
3022         RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV);
3023         dev = &rte_eth_devices[port_id];
3024         RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->dev_supported_ptypes_get, 0);
3025         all_ptypes = (*dev->dev_ops->dev_supported_ptypes_get)(dev);
3026
3027         if (!all_ptypes)
3028                 return 0;
3029
3030         for (i = 0, j = 0; all_ptypes[i] != RTE_PTYPE_UNKNOWN; ++i)
3031                 if (all_ptypes[i] & ptype_mask) {
3032                         if (j < num)
3033                                 ptypes[j] = all_ptypes[i];
3034                         j++;
3035                 }
3036
3037         return j;
3038 }
3039
3040 int
3041 rte_eth_dev_set_ptypes(uint16_t port_id, uint32_t ptype_mask,
3042                                  uint32_t *set_ptypes, unsigned int num)
3043 {
3044         const uint32_t valid_ptype_masks[] = {
3045                 RTE_PTYPE_L2_MASK,
3046                 RTE_PTYPE_L3_MASK,
3047                 RTE_PTYPE_L4_MASK,
3048                 RTE_PTYPE_TUNNEL_MASK,
3049                 RTE_PTYPE_INNER_L2_MASK,
3050                 RTE_PTYPE_INNER_L3_MASK,
3051                 RTE_PTYPE_INNER_L4_MASK,
3052         };
3053         const uint32_t *all_ptypes;
3054         struct rte_eth_dev *dev;
3055         uint32_t unused_mask;
3056         unsigned int i, j;
3057         int ret;
3058
3059         RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV);
3060         dev = &rte_eth_devices[port_id];
3061
3062         if (num > 0 && set_ptypes == NULL)
3063                 return -EINVAL;
3064
3065         if (*dev->dev_ops->dev_supported_ptypes_get == NULL ||
3066                         *dev->dev_ops->dev_ptypes_set == NULL) {
3067                 ret = 0;
3068                 goto ptype_unknown;
3069         }
3070
3071         if (ptype_mask == 0) {
3072                 ret = (*dev->dev_ops->dev_ptypes_set)(dev,
3073                                 ptype_mask);
3074                 goto ptype_unknown;
3075         }
3076
3077         unused_mask = ptype_mask;
3078         for (i = 0; i < RTE_DIM(valid_ptype_masks); i++) {
3079                 uint32_t mask = ptype_mask & valid_ptype_masks[i];
3080                 if (mask && mask != valid_ptype_masks[i]) {
3081                         ret = -EINVAL;
3082                         goto ptype_unknown;
3083                 }
3084                 unused_mask &= ~valid_ptype_masks[i];
3085         }
3086
3087         if (unused_mask) {
3088                 ret = -EINVAL;
3089                 goto ptype_unknown;
3090         }
3091
3092         all_ptypes = (*dev->dev_ops->dev_supported_ptypes_get)(dev);
3093         if (all_ptypes == NULL) {
3094                 ret = 0;
3095                 goto ptype_unknown;
3096         }
3097
3098         /*
3099          * Accommodate as many set_ptypes as possible. If the supplied
3100          * set_ptypes array is insufficient fill it partially.
3101          */
3102         for (i = 0, j = 0; set_ptypes != NULL &&
3103                                 (all_ptypes[i] != RTE_PTYPE_UNKNOWN); ++i) {
3104                 if (ptype_mask & all_ptypes[i]) {
3105                         if (j < num - 1) {
3106                                 set_ptypes[j] = all_ptypes[i];
3107                                 j++;
3108                                 continue;
3109                         }
3110                         break;
3111                 }
3112         }
3113
3114         if (set_ptypes != NULL && j < num)
3115                 set_ptypes[j] = RTE_PTYPE_UNKNOWN;
3116
3117         return (*dev->dev_ops->dev_ptypes_set)(dev, ptype_mask);
3118
3119 ptype_unknown:
3120         if (num > 0)
3121                 set_ptypes[0] = RTE_PTYPE_UNKNOWN;
3122
3123         return ret;
3124 }
3125
3126 int
3127 rte_eth_macaddr_get(uint16_t port_id, struct rte_ether_addr *mac_addr)
3128 {
3129         struct rte_eth_dev *dev;
3130
3131         RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV);
3132         dev = &rte_eth_devices[port_id];
3133         rte_ether_addr_copy(&dev->data->mac_addrs[0], mac_addr);
3134
3135         return 0;
3136 }
3137
3138 int
3139 rte_eth_dev_get_mtu(uint16_t port_id, uint16_t *mtu)
3140 {
3141         struct rte_eth_dev *dev;
3142
3143         RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV);
3144
3145         dev = &rte_eth_devices[port_id];
3146         *mtu = dev->data->mtu;
3147         return 0;
3148 }
3149
3150 int
3151 rte_eth_dev_set_mtu(uint16_t port_id, uint16_t mtu)
3152 {
3153         int ret;
3154         struct rte_eth_dev_info dev_info;
3155         struct rte_eth_dev *dev;
3156
3157         RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV);
3158         dev = &rte_eth_devices[port_id];
3159         RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->mtu_set, -ENOTSUP);
3160
3161         /*
3162          * Check if the device supports dev_infos_get, if it does not
3163          * skip min_mtu/max_mtu validation here as this requires values
3164          * that are populated within the call to rte_eth_dev_info_get()
3165          * which relies on dev->dev_ops->dev_infos_get.
3166          */
3167         if (*dev->dev_ops->dev_infos_get != NULL) {
3168                 ret = rte_eth_dev_info_get(port_id, &dev_info);
3169                 if (ret != 0)
3170                         return ret;
3171
3172                 if (mtu < dev_info.min_mtu || mtu > dev_info.max_mtu)
3173                         return -EINVAL;
3174         }
3175
3176         ret = (*dev->dev_ops->mtu_set)(dev, mtu);
3177         if (!ret)
3178                 dev->data->mtu = mtu;
3179
3180         return eth_err(port_id, ret);
3181 }
3182
3183 int
3184 rte_eth_dev_vlan_filter(uint16_t port_id, uint16_t vlan_id, int on)
3185 {
3186         struct rte_eth_dev *dev;
3187         int ret;
3188
3189         RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV);
3190         dev = &rte_eth_devices[port_id];
3191         if (!(dev->data->dev_conf.rxmode.offloads &
3192               DEV_RX_OFFLOAD_VLAN_FILTER)) {
3193                 RTE_ETHDEV_LOG(ERR, "Port %u: vlan-filtering disabled\n",
3194                         port_id);
3195                 return -ENOSYS;
3196         }
3197
3198         if (vlan_id > 4095) {
3199                 RTE_ETHDEV_LOG(ERR, "Port_id=%u invalid vlan_id=%u > 4095\n",
3200                         port_id, vlan_id);
3201                 return -EINVAL;
3202         }
3203         RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->vlan_filter_set, -ENOTSUP);
3204
3205         ret = (*dev->dev_ops->vlan_filter_set)(dev, vlan_id, on);
3206         if (ret == 0) {
3207                 struct rte_vlan_filter_conf *vfc;
3208                 int vidx;
3209                 int vbit;
3210
3211                 vfc = &dev->data->vlan_filter_conf;
3212                 vidx = vlan_id / 64;
3213                 vbit = vlan_id % 64;
3214
3215                 if (on)
3216                         vfc->ids[vidx] |= UINT64_C(1) << vbit;
3217                 else
3218                         vfc->ids[vidx] &= ~(UINT64_C(1) << vbit);
3219         }
3220
3221         return eth_err(port_id, ret);
3222 }
3223
3224 int
3225 rte_eth_dev_set_vlan_strip_on_queue(uint16_t port_id, uint16_t rx_queue_id,
3226                                     int on)
3227 {
3228         struct rte_eth_dev *dev;
3229
3230         RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV);
3231         dev = &rte_eth_devices[port_id];
3232         if (rx_queue_id >= dev->data->nb_rx_queues) {
3233                 RTE_ETHDEV_LOG(ERR, "Invalid rx_queue_id=%u\n", rx_queue_id);
3234                 return -EINVAL;
3235         }
3236
3237         RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->vlan_strip_queue_set, -ENOTSUP);
3238         (*dev->dev_ops->vlan_strip_queue_set)(dev, rx_queue_id, on);
3239
3240         return 0;
3241 }
3242
3243 int
3244 rte_eth_dev_set_vlan_ether_type(uint16_t port_id,
3245                                 enum rte_vlan_type vlan_type,
3246                                 uint16_t tpid)
3247 {
3248         struct rte_eth_dev *dev;
3249
3250         RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV);
3251         dev = &rte_eth_devices[port_id];
3252         RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->vlan_tpid_set, -ENOTSUP);
3253
3254         return eth_err(port_id, (*dev->dev_ops->vlan_tpid_set)(dev, vlan_type,
3255                                                                tpid));
3256 }
3257
3258 int
3259 rte_eth_dev_set_vlan_offload(uint16_t port_id, int offload_mask)
3260 {
3261         struct rte_eth_dev *dev;
3262         int ret = 0;
3263         int mask = 0;
3264         int cur, org = 0;
3265         uint64_t orig_offloads;
3266         uint64_t dev_offloads;
3267
3268         RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV);
3269         dev = &rte_eth_devices[port_id];
3270
3271         /* save original values in case of failure */
3272         orig_offloads = dev->data->dev_conf.rxmode.offloads;
3273         dev_offloads = orig_offloads;
3274
3275         /* check which option changed by application */
3276         cur = !!(offload_mask & ETH_VLAN_STRIP_OFFLOAD);
3277         org = !!(dev_offloads & DEV_RX_OFFLOAD_VLAN_STRIP);
3278         if (cur != org) {
3279                 if (cur)
3280                         dev_offloads |= DEV_RX_OFFLOAD_VLAN_STRIP;
3281                 else
3282                         dev_offloads &= ~DEV_RX_OFFLOAD_VLAN_STRIP;
3283                 mask |= ETH_VLAN_STRIP_MASK;
3284         }
3285
3286         cur = !!(offload_mask & ETH_VLAN_FILTER_OFFLOAD);
3287         org = !!(dev_offloads & DEV_RX_OFFLOAD_VLAN_FILTER);
3288         if (cur != org) {
3289                 if (cur)
3290                         dev_offloads |= DEV_RX_OFFLOAD_VLAN_FILTER;
3291                 else
3292                         dev_offloads &= ~DEV_RX_OFFLOAD_VLAN_FILTER;
3293                 mask |= ETH_VLAN_FILTER_MASK;
3294         }
3295
3296         cur = !!(offload_mask & ETH_VLAN_EXTEND_OFFLOAD);
3297         org = !!(dev_offloads & DEV_RX_OFFLOAD_VLAN_EXTEND);
3298         if (cur != org) {
3299                 if (cur)
3300                         dev_offloads |= DEV_RX_OFFLOAD_VLAN_EXTEND;
3301                 else
3302                         dev_offloads &= ~DEV_RX_OFFLOAD_VLAN_EXTEND;
3303                 mask |= ETH_VLAN_EXTEND_MASK;
3304         }
3305
3306         cur = !!(offload_mask & ETH_QINQ_STRIP_OFFLOAD);
3307         org = !!(dev_offloads & DEV_RX_OFFLOAD_QINQ_STRIP);
3308         if (cur != org) {
3309                 if (cur)
3310                         dev_offloads |= DEV_RX_OFFLOAD_QINQ_STRIP;
3311                 else
3312                         dev_offloads &= ~DEV_RX_OFFLOAD_QINQ_STRIP;
3313                 mask |= ETH_QINQ_STRIP_MASK;
3314         }
3315
3316         /*no change*/
3317         if (mask == 0)
3318                 return ret;
3319
3320         RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->vlan_offload_set, -ENOTSUP);
3321         dev->data->dev_conf.rxmode.offloads = dev_offloads;
3322         ret = (*dev->dev_ops->vlan_offload_set)(dev, mask);
3323         if (ret) {
3324                 /* hit an error restore  original values */
3325                 dev->data->dev_conf.rxmode.offloads = orig_offloads;
3326         }
3327
3328         return eth_err(port_id, ret);
3329 }
3330
3331 int
3332 rte_eth_dev_get_vlan_offload(uint16_t port_id)
3333 {
3334         struct rte_eth_dev *dev;
3335         uint64_t *dev_offloads;
3336         int ret = 0;
3337
3338         RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV);
3339         dev = &rte_eth_devices[port_id];
3340         dev_offloads = &dev->data->dev_conf.rxmode.offloads;
3341
3342         if (*dev_offloads & DEV_RX_OFFLOAD_VLAN_STRIP)
3343                 ret |= ETH_VLAN_STRIP_OFFLOAD;
3344
3345         if (*dev_offloads & DEV_RX_OFFLOAD_VLAN_FILTER)
3346                 ret |= ETH_VLAN_FILTER_OFFLOAD;
3347
3348         if (*dev_offloads & DEV_RX_OFFLOAD_VLAN_EXTEND)
3349                 ret |= ETH_VLAN_EXTEND_OFFLOAD;
3350
3351         if (*dev_offloads & DEV_RX_OFFLOAD_QINQ_STRIP)
3352                 ret |= ETH_QINQ_STRIP_OFFLOAD;
3353
3354         return ret;
3355 }
3356
3357 int
3358 rte_eth_dev_set_vlan_pvid(uint16_t port_id, uint16_t pvid, int on)
3359 {
3360         struct rte_eth_dev *dev;
3361
3362         RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV);
3363         dev = &rte_eth_devices[port_id];
3364         RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->vlan_pvid_set, -ENOTSUP);
3365
3366         return eth_err(port_id, (*dev->dev_ops->vlan_pvid_set)(dev, pvid, on));
3367 }
3368
3369 int
3370 rte_eth_dev_flow_ctrl_get(uint16_t port_id, struct rte_eth_fc_conf *fc_conf)
3371 {
3372         struct rte_eth_dev *dev;
3373
3374         RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV);
3375         dev = &rte_eth_devices[port_id];
3376         RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->flow_ctrl_get, -ENOTSUP);
3377         memset(fc_conf, 0, sizeof(*fc_conf));
3378         return eth_err(port_id, (*dev->dev_ops->flow_ctrl_get)(dev, fc_conf));
3379 }
3380
3381 int
3382 rte_eth_dev_flow_ctrl_set(uint16_t port_id, struct rte_eth_fc_conf *fc_conf)
3383 {
3384         struct rte_eth_dev *dev;
3385
3386         RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV);
3387         if ((fc_conf->send_xon != 0) && (fc_conf->send_xon != 1)) {
3388                 RTE_ETHDEV_LOG(ERR, "Invalid send_xon, only 0/1 allowed\n");
3389                 return -EINVAL;
3390         }
3391
3392         dev = &rte_eth_devices[port_id];
3393         RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->flow_ctrl_set, -ENOTSUP);
3394         return eth_err(port_id, (*dev->dev_ops->flow_ctrl_set)(dev, fc_conf));
3395 }
3396
3397 int
3398 rte_eth_dev_priority_flow_ctrl_set(uint16_t port_id,
3399                                    struct rte_eth_pfc_conf *pfc_conf)
3400 {
3401         struct rte_eth_dev *dev;
3402
3403         RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV);
3404         if (pfc_conf->priority > (ETH_DCB_NUM_USER_PRIORITIES - 1)) {
3405                 RTE_ETHDEV_LOG(ERR, "Invalid priority, only 0-7 allowed\n");
3406                 return -EINVAL;
3407         }
3408
3409         dev = &rte_eth_devices[port_id];
3410         /* High water, low water validation are device specific */
3411         if  (*dev->dev_ops->priority_flow_ctrl_set)
3412                 return eth_err(port_id, (*dev->dev_ops->priority_flow_ctrl_set)
3413                                         (dev, pfc_conf));
3414         return -ENOTSUP;
3415 }
3416
3417 static int
3418 rte_eth_check_reta_mask(struct rte_eth_rss_reta_entry64 *reta_conf,
3419                         uint16_t reta_size)
3420 {
3421         uint16_t i, num;
3422
3423         if (!reta_conf)
3424                 return -EINVAL;
3425
3426         num = (reta_size + RTE_RETA_GROUP_SIZE - 1) / RTE_RETA_GROUP_SIZE;
3427         for (i = 0; i < num; i++) {
3428                 if (reta_conf[i].mask)
3429                         return 0;
3430         }
3431
3432         return -EINVAL;
3433 }
3434
3435 static int
3436 rte_eth_check_reta_entry(struct rte_eth_rss_reta_entry64 *reta_conf,
3437                          uint16_t reta_size,
3438                          uint16_t max_rxq)
3439 {
3440         uint16_t i, idx, shift;
3441
3442         if (!reta_conf)
3443                 return -EINVAL;
3444
3445         if (max_rxq == 0) {
3446                 RTE_ETHDEV_LOG(ERR, "No receive queue is available\n");
3447                 return -EINVAL;
3448         }
3449
3450         for (i = 0; i < reta_size; i++) {
3451                 idx = i / RTE_RETA_GROUP_SIZE;
3452                 shift = i % RTE_RETA_GROUP_SIZE;
3453                 if ((reta_conf[idx].mask & (1ULL << shift)) &&
3454                         (reta_conf[idx].reta[shift] >= max_rxq)) {
3455                         RTE_ETHDEV_LOG(ERR,
3456                                 "reta_conf[%u]->reta[%u]: %u exceeds the maximum rxq index: %u\n",
3457                                 idx, shift,
3458                                 reta_conf[idx].reta[shift], max_rxq);
3459                         return -EINVAL;
3460                 }
3461         }
3462
3463         return 0;
3464 }
3465
3466 int
3467 rte_eth_dev_rss_reta_update(uint16_t port_id,
3468                             struct rte_eth_rss_reta_entry64 *reta_conf,
3469                             uint16_t reta_size)
3470 {
3471         struct rte_eth_dev *dev;
3472         int ret;
3473
3474         RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV);
3475         /* Check mask bits */
3476         ret = rte_eth_check_reta_mask(reta_conf, reta_size);
3477         if (ret < 0)
3478                 return ret;
3479
3480         dev = &rte_eth_devices[port_id];
3481
3482         /* Check entry value */
3483         ret = rte_eth_check_reta_entry(reta_conf, reta_size,
3484                                 dev->data->nb_rx_queues);
3485         if (ret < 0)
3486                 return ret;
3487
3488         RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->reta_update, -ENOTSUP);
3489         return eth_err(port_id, (*dev->dev_ops->reta_update)(dev, reta_conf,
3490                                                              reta_size));
3491 }
3492
3493 int
3494 rte_eth_dev_rss_reta_query(uint16_t port_id,
3495                            struct rte_eth_rss_reta_entry64 *reta_conf,
3496                            uint16_t reta_size)
3497 {
3498         struct rte_eth_dev *dev;
3499         int ret;
3500
3501         RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV);
3502
3503         /* Check mask bits */
3504         ret = rte_eth_check_reta_mask(reta_conf, reta_size);
3505         if (ret < 0)
3506                 return ret;
3507
3508         dev = &rte_eth_devices[port_id];
3509         RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->reta_query, -ENOTSUP);
3510         return eth_err(port_id, (*dev->dev_ops->reta_query)(dev, reta_conf,
3511                                                             reta_size));
3512 }
3513
3514 int
3515 rte_eth_dev_rss_hash_update(uint16_t port_id,
3516                             struct rte_eth_rss_conf *rss_conf)
3517 {
3518         struct rte_eth_dev *dev;
3519         struct rte_eth_dev_info dev_info = { .flow_type_rss_offloads = 0, };
3520         int ret;
3521
3522         RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV);
3523
3524         ret = rte_eth_dev_info_get(port_id, &dev_info);
3525         if (ret != 0)
3526                 return ret;
3527
3528         rss_conf->rss_hf = rte_eth_rss_hf_refine(rss_conf->rss_hf);
3529
3530         dev = &rte_eth_devices[port_id];
3531         if ((dev_info.flow_type_rss_offloads | rss_conf->rss_hf) !=
3532             dev_info.flow_type_rss_offloads) {
3533                 RTE_ETHDEV_LOG(ERR,
3534                         "Ethdev port_id=%u invalid rss_hf: 0x%"PRIx64", valid value: 0x%"PRIx64"\n",
3535                         port_id, rss_conf->rss_hf,
3536                         dev_info.flow_type_rss_offloads);
3537                 return -EINVAL;
3538         }
3539         RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->rss_hash_update, -ENOTSUP);
3540         return eth_err(port_id, (*dev->dev_ops->rss_hash_update)(dev,
3541                                                                  rss_conf));
3542 }
3543
3544 int
3545 rte_eth_dev_rss_hash_conf_get(uint16_t port_id,
3546                               struct rte_eth_rss_conf *rss_conf)
3547 {
3548         struct rte_eth_dev *dev;
3549
3550         RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV);
3551         dev = &rte_eth_devices[port_id];
3552         RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->rss_hash_conf_get, -ENOTSUP);
3553         return eth_err(port_id, (*dev->dev_ops->rss_hash_conf_get)(dev,
3554                                                                    rss_conf));
3555 }
3556
3557 int
3558 rte_eth_dev_udp_tunnel_port_add(uint16_t port_id,
3559                                 struct rte_eth_udp_tunnel *udp_tunnel)
3560 {
3561         struct rte_eth_dev *dev;
3562
3563         RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV);
3564         if (udp_tunnel == NULL) {
3565                 RTE_ETHDEV_LOG(ERR, "Invalid udp_tunnel parameter\n");
3566                 return -EINVAL;
3567         }
3568
3569         if (udp_tunnel->prot_type >= RTE_TUNNEL_TYPE_MAX) {
3570                 RTE_ETHDEV_LOG(ERR, "Invalid tunnel type\n");
3571                 return -EINVAL;
3572         }
3573
3574         dev = &rte_eth_devices[port_id];
3575         RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->udp_tunnel_port_add, -ENOTSUP);
3576         return eth_err(port_id, (*dev->dev_ops->udp_tunnel_port_add)(dev,
3577                                                                 udp_tunnel));
3578 }
3579
3580 int
3581 rte_eth_dev_udp_tunnel_port_delete(uint16_t port_id,
3582                                    struct rte_eth_udp_tunnel *udp_tunnel)
3583 {
3584         struct rte_eth_dev *dev;
3585
3586         RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV);
3587         dev = &rte_eth_devices[port_id];
3588
3589         if (udp_tunnel == NULL) {
3590                 RTE_ETHDEV_LOG(ERR, "Invalid udp_tunnel parameter\n");
3591                 return -EINVAL;
3592         }
3593
3594         if (udp_tunnel->prot_type >= RTE_TUNNEL_TYPE_MAX) {
3595                 RTE_ETHDEV_LOG(ERR, "Invalid tunnel type\n");
3596                 return -EINVAL;
3597         }
3598
3599         RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->udp_tunnel_port_del, -ENOTSUP);
3600         return eth_err(port_id, (*dev->dev_ops->udp_tunnel_port_del)(dev,
3601                                                                 udp_tunnel));
3602 }
3603
3604 int
3605 rte_eth_led_on(uint16_t port_id)
3606 {
3607         struct rte_eth_dev *dev;
3608
3609         RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV);
3610         dev = &rte_eth_devices[port_id];
3611         RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->dev_led_on, -ENOTSUP);
3612         return eth_err(port_id, (*dev->dev_ops->dev_led_on)(dev));
3613 }
3614
3615 int
3616 rte_eth_led_off(uint16_t port_id)
3617 {
3618         struct rte_eth_dev *dev;
3619
3620         RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV);
3621         dev = &rte_eth_devices[port_id];
3622         RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->dev_led_off, -ENOTSUP);
3623         return eth_err(port_id, (*dev->dev_ops->dev_led_off)(dev));
3624 }
3625
3626 /*
3627  * Returns index into MAC address array of addr. Use 00:00:00:00:00:00 to find
3628  * an empty spot.
3629  */
3630 static int
3631 get_mac_addr_index(uint16_t port_id, const struct rte_ether_addr *addr)
3632 {
3633         struct rte_eth_dev_info dev_info;
3634         struct rte_eth_dev *dev = &rte_eth_devices[port_id];
3635         unsigned i;
3636         int ret;
3637
3638         ret = rte_eth_dev_info_get(port_id, &dev_info);
3639         if (ret != 0)
3640                 return -1;
3641
3642         for (i = 0; i < dev_info.max_mac_addrs; i++)
3643                 if (memcmp(addr, &dev->data->mac_addrs[i],
3644                                 RTE_ETHER_ADDR_LEN) == 0)
3645                         return i;
3646
3647         return -1;
3648 }
3649
3650 static const struct rte_ether_addr null_mac_addr;
3651
3652 int
3653 rte_eth_dev_mac_addr_add(uint16_t port_id, struct rte_ether_addr *addr,
3654                         uint32_t pool)
3655 {
3656         struct rte_eth_dev *dev;
3657         int index;
3658         uint64_t pool_mask;
3659         int ret;
3660
3661         RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV);
3662         dev = &rte_eth_devices[port_id];
3663         RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->mac_addr_add, -ENOTSUP);
3664
3665         if (rte_is_zero_ether_addr(addr)) {
3666                 RTE_ETHDEV_LOG(ERR, "Port %u: Cannot add NULL MAC address\n",
3667                         port_id);
3668                 return -EINVAL;
3669         }
3670         if (pool >= ETH_64_POOLS) {
3671                 RTE_ETHDEV_LOG(ERR, "Pool id must be 0-%d\n", ETH_64_POOLS - 1);
3672                 return -EINVAL;
3673         }
3674
3675         index = get_mac_addr_index(port_id, addr);
3676         if (index < 0) {
3677                 index = get_mac_addr_index(port_id, &null_mac_addr);
3678                 if (index < 0) {
3679                         RTE_ETHDEV_LOG(ERR, "Port %u: MAC address array full\n",
3680                                 port_id);
3681                         return -ENOSPC;
3682                 }
3683         } else {
3684                 pool_mask = dev->data->mac_pool_sel[index];
3685
3686                 /* Check if both MAC address and pool is already there, and do nothing */
3687                 if (pool_mask & (1ULL << pool))
3688                         return 0;
3689         }
3690
3691         /* Update NIC */
3692         ret = (*dev->dev_ops->mac_addr_add)(dev, addr, index, pool);
3693
3694         if (ret == 0) {
3695                 /* Update address in NIC data structure */
3696                 rte_ether_addr_copy(addr, &dev->data->mac_addrs[index]);
3697
3698                 /* Update pool bitmap in NIC data structure */
3699                 dev->data->mac_pool_sel[index] |= (1ULL << pool);
3700         }
3701
3702         return eth_err(port_id, ret);
3703 }
3704
3705 int
3706 rte_eth_dev_mac_addr_remove(uint16_t port_id, struct rte_ether_addr *addr)
3707 {
3708         struct rte_eth_dev *dev;
3709         int index;
3710
3711         RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV);
3712         dev = &rte_eth_devices[port_id];
3713         RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->mac_addr_remove, -ENOTSUP);
3714
3715         index = get_mac_addr_index(port_id, addr);
3716         if (index == 0) {
3717                 RTE_ETHDEV_LOG(ERR,
3718                         "Port %u: Cannot remove default MAC address\n",
3719                         port_id);
3720                 return -EADDRINUSE;
3721         } else if (index < 0)
3722                 return 0;  /* Do nothing if address wasn't found */
3723
3724         /* Update NIC */
3725         (*dev->dev_ops->mac_addr_remove)(dev, index);
3726
3727         /* Update address in NIC data structure */
3728         rte_ether_addr_copy(&null_mac_addr, &dev->data->mac_addrs[index]);
3729
3730         /* reset pool bitmap */
3731         dev->data->mac_pool_sel[index] = 0;
3732
3733         return 0;
3734 }
3735
3736 int
3737 rte_eth_dev_default_mac_addr_set(uint16_t port_id, struct rte_ether_addr *addr)
3738 {
3739         struct rte_eth_dev *dev;
3740         int ret;
3741
3742         RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV);
3743
3744         if (!rte_is_valid_assigned_ether_addr(addr))
3745                 return -EINVAL;
3746
3747         dev = &rte_eth_devices[port_id];
3748         RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->mac_addr_set, -ENOTSUP);
3749
3750         ret = (*dev->dev_ops->mac_addr_set)(dev, addr);
3751         if (ret < 0)
3752                 return ret;
3753
3754         /* Update default address in NIC data structure */
3755         rte_ether_addr_copy(addr, &dev->data->mac_addrs[0]);
3756
3757         return 0;
3758 }
3759
3760
3761 /*
3762  * Returns index into MAC address array of addr. Use 00:00:00:00:00:00 to find
3763  * an empty spot.
3764  */
3765 static int
3766 get_hash_mac_addr_index(uint16_t port_id, const struct rte_ether_addr *addr)
3767 {
3768         struct rte_eth_dev_info dev_info;
3769         struct rte_eth_dev *dev = &rte_eth_devices[port_id];
3770         unsigned i;
3771         int ret;
3772
3773         ret = rte_eth_dev_info_get(port_id, &dev_info);
3774         if (ret != 0)
3775                 return -1;
3776
3777         if (!dev->data->hash_mac_addrs)
3778                 return -1;
3779
3780         for (i = 0; i < dev_info.max_hash_mac_addrs; i++)
3781                 if (memcmp(addr, &dev->data->hash_mac_addrs[i],
3782                         RTE_ETHER_ADDR_LEN) == 0)
3783                         return i;
3784
3785         return -1;
3786 }
3787
3788 int
3789 rte_eth_dev_uc_hash_table_set(uint16_t port_id, struct rte_ether_addr *addr,
3790                                 uint8_t on)
3791 {
3792         int index;
3793         int ret;
3794         struct rte_eth_dev *dev;
3795
3796         RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV);
3797
3798         dev = &rte_eth_devices[port_id];
3799         if (rte_is_zero_ether_addr(addr)) {
3800                 RTE_ETHDEV_LOG(ERR, "Port %u: Cannot add NULL MAC address\n",
3801                         port_id);
3802                 return -EINVAL;
3803         }
3804
3805         index = get_hash_mac_addr_index(port_id, addr);
3806         /* Check if it's already there, and do nothing */
3807         if ((index >= 0) && on)
3808                 return 0;
3809
3810         if (index < 0) {
3811                 if (!on) {
3812                         RTE_ETHDEV_LOG(ERR,
3813                                 "Port %u: the MAC address was not set in UTA\n",
3814                                 port_id);
3815                         return -EINVAL;
3816                 }
3817
3818                 index = get_hash_mac_addr_index(port_id, &null_mac_addr);
3819                 if (index < 0) {
3820                         RTE_ETHDEV_LOG(ERR, "Port %u: MAC address array full\n",
3821                                 port_id);
3822                         return -ENOSPC;
3823                 }
3824         }
3825
3826         RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->uc_hash_table_set, -ENOTSUP);
3827         ret = (*dev->dev_ops->uc_hash_table_set)(dev, addr, on);
3828         if (ret == 0) {
3829                 /* Update address in NIC data structure */
3830                 if (on)
3831                         rte_ether_addr_copy(addr,
3832                                         &dev->data->hash_mac_addrs[index]);
3833                 else
3834                         rte_ether_addr_copy(&null_mac_addr,
3835                                         &dev->data->hash_mac_addrs[index]);
3836         }
3837
3838         return eth_err(port_id, ret);
3839 }
3840
3841 int
3842 rte_eth_dev_uc_all_hash_table_set(uint16_t port_id, uint8_t on)
3843 {
3844         struct rte_eth_dev *dev;
3845
3846         RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV);
3847
3848         dev = &rte_eth_devices[port_id];
3849
3850         RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->uc_all_hash_table_set, -ENOTSUP);
3851         return eth_err(port_id, (*dev->dev_ops->uc_all_hash_table_set)(dev,
3852                                                                        on));
3853 }
3854
3855 int rte_eth_set_queue_rate_limit(uint16_t port_id, uint16_t queue_idx,
3856                                         uint16_t tx_rate)
3857 {
3858         struct rte_eth_dev *dev;
3859         struct rte_eth_dev_info dev_info;
3860         struct rte_eth_link link;
3861         int ret;
3862
3863         RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV);
3864
3865         ret = rte_eth_dev_info_get(port_id, &dev_info);
3866         if (ret != 0)
3867                 return ret;
3868
3869         dev = &rte_eth_devices[port_id];
3870         link = dev->data->dev_link;
3871
3872         if (queue_idx > dev_info.max_tx_queues) {
3873                 RTE_ETHDEV_LOG(ERR,
3874                         "Set queue rate limit:port %u: invalid queue id=%u\n",
3875                         port_id, queue_idx);
3876                 return -EINVAL;
3877         }
3878
3879         if (tx_rate > link.link_speed) {
3880                 RTE_ETHDEV_LOG(ERR,
3881                         "Set queue rate limit:invalid tx_rate=%u, bigger than link speed= %d\n",
3882                         tx_rate, link.link_speed);
3883                 return -EINVAL;
3884         }
3885
3886         RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->set_queue_rate_limit, -ENOTSUP);
3887         return eth_err(port_id, (*dev->dev_ops->set_queue_rate_limit)(dev,
3888                                                         queue_idx, tx_rate));
3889 }
3890
3891 int
3892 rte_eth_mirror_rule_set(uint16_t port_id,
3893                         struct rte_eth_mirror_conf *mirror_conf,
3894                         uint8_t rule_id, uint8_t on)
3895 {
3896         struct rte_eth_dev *dev;
3897
3898         RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV);
3899         if (mirror_conf->rule_type == 0) {
3900                 RTE_ETHDEV_LOG(ERR, "Mirror rule type can not be 0\n");
3901                 return -EINVAL;
3902         }
3903
3904         if (mirror_conf->dst_pool >= ETH_64_POOLS) {
3905                 RTE_ETHDEV_LOG(ERR, "Invalid dst pool, pool id must be 0-%d\n",
3906                         ETH_64_POOLS - 1);
3907                 return -EINVAL;
3908         }
3909
3910         if ((mirror_conf->rule_type & (ETH_MIRROR_VIRTUAL_POOL_UP |
3911              ETH_MIRROR_VIRTUAL_POOL_DOWN)) &&
3912             (mirror_conf->pool_mask == 0)) {
3913                 RTE_ETHDEV_LOG(ERR,
3914                         "Invalid mirror pool, pool mask can not be 0\n");
3915                 return -EINVAL;
3916         }
3917
3918         if ((mirror_conf->rule_type & ETH_MIRROR_VLAN) &&
3919             mirror_conf->vlan.vlan_mask == 0) {
3920                 RTE_ETHDEV_LOG(ERR,
3921                         "Invalid vlan mask, vlan mask can not be 0\n");
3922                 return -EINVAL;
3923         }
3924
3925         dev = &rte_eth_devices[port_id];
3926         RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->mirror_rule_set, -ENOTSUP);
3927
3928         return eth_err(port_id, (*dev->dev_ops->mirror_rule_set)(dev,
3929                                                 mirror_conf, rule_id, on));
3930 }
3931
3932 int
3933 rte_eth_mirror_rule_reset(uint16_t port_id, uint8_t rule_id)
3934 {
3935         struct rte_eth_dev *dev;
3936
3937         RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV);
3938
3939         dev = &rte_eth_devices[port_id];
3940         RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->mirror_rule_reset, -ENOTSUP);
3941
3942         return eth_err(port_id, (*dev->dev_ops->mirror_rule_reset)(dev,
3943                                                                    rule_id));
3944 }
3945
3946 RTE_INIT(eth_dev_init_cb_lists)
3947 {
3948         int i;
3949
3950         for (i = 0; i < RTE_MAX_ETHPORTS; i++)
3951                 TAILQ_INIT(&rte_eth_devices[i].link_intr_cbs);
3952 }
3953
3954 int
3955 rte_eth_dev_callback_register(uint16_t port_id,
3956                         enum rte_eth_event_type event,
3957                         rte_eth_dev_cb_fn cb_fn, void *cb_arg)
3958 {
3959         struct rte_eth_dev *dev;
3960         struct rte_eth_dev_callback *user_cb;
3961         uint32_t next_port; /* size is 32-bit to prevent loop wrap-around */
3962         uint16_t last_port;
3963
3964         if (!cb_fn)
3965                 return -EINVAL;
3966
3967         if (!rte_eth_dev_is_valid_port(port_id) && port_id != RTE_ETH_ALL) {
3968                 RTE_ETHDEV_LOG(ERR, "Invalid port_id=%d\n", port_id);
3969                 return -EINVAL;
3970         }
3971
3972         if (port_id == RTE_ETH_ALL) {
3973                 next_port = 0;
3974                 last_port = RTE_MAX_ETHPORTS - 1;
3975         } else {
3976                 next_port = last_port = port_id;
3977         }
3978
3979         rte_spinlock_lock(&rte_eth_dev_cb_lock);
3980
3981         do {
3982                 dev = &rte_eth_devices[next_port];
3983
3984                 TAILQ_FOREACH(user_cb, &(dev->link_intr_cbs), next) {
3985                         if (user_cb->cb_fn == cb_fn &&
3986                                 user_cb->cb_arg == cb_arg &&
3987                                 user_cb->event == event) {
3988                                 break;
3989                         }
3990                 }
3991
3992                 /* create a new callback. */
3993                 if (user_cb == NULL) {
3994                         user_cb = rte_zmalloc("INTR_USER_CALLBACK",
3995                                 sizeof(struct rte_eth_dev_callback), 0);
3996                         if (user_cb != NULL) {
3997                                 user_cb->cb_fn = cb_fn;
3998                                 user_cb->cb_arg = cb_arg;
3999                                 user_cb->event = event;
4000                                 TAILQ_INSERT_TAIL(&(dev->link_intr_cbs),
4001                                                   user_cb, next);
4002                         } else {
4003                                 rte_spinlock_unlock(&rte_eth_dev_cb_lock);
4004                                 rte_eth_dev_callback_unregister(port_id, event,
4005                                                                 cb_fn, cb_arg);
4006                                 return -ENOMEM;
4007                         }
4008
4009                 }
4010         } while (++next_port <= last_port);
4011
4012         rte_spinlock_unlock(&rte_eth_dev_cb_lock);
4013         return 0;
4014 }
4015
4016 int
4017 rte_eth_dev_callback_unregister(uint16_t port_id,
4018                         enum rte_eth_event_type event,
4019                         rte_eth_dev_cb_fn cb_fn, void *cb_arg)
4020 {
4021         int ret;
4022         struct rte_eth_dev *dev;
4023         struct rte_eth_dev_callback *cb, *next;
4024         uint32_t next_port; /* size is 32-bit to prevent loop wrap-around */
4025         uint16_t last_port;
4026
4027         if (!cb_fn)
4028                 return -EINVAL;
4029
4030         if (!rte_eth_dev_is_valid_port(port_id) && port_id != RTE_ETH_ALL) {
4031                 RTE_ETHDEV_LOG(ERR, "Invalid port_id=%d\n", port_id);
4032                 return -EINVAL;
4033         }
4034
4035         if (port_id == RTE_ETH_ALL) {
4036                 next_port = 0;
4037                 last_port = RTE_MAX_ETHPORTS - 1;
4038         } else {
4039                 next_port = last_port = port_id;
4040         }
4041
4042         rte_spinlock_lock(&rte_eth_dev_cb_lock);
4043
4044         do {
4045                 dev = &rte_eth_devices[next_port];
4046                 ret = 0;
4047                 for (cb = TAILQ_FIRST(&dev->link_intr_cbs); cb != NULL;
4048                      cb = next) {
4049
4050                         next = TAILQ_NEXT(cb, next);
4051
4052                         if (cb->cb_fn != cb_fn || cb->event != event ||
4053                             (cb_arg != (void *)-1 && cb->cb_arg != cb_arg))
4054                                 continue;
4055
4056                         /*
4057                          * if this callback is not executing right now,
4058                          * then remove it.
4059                          */
4060                         if (cb->active == 0) {
4061                                 TAILQ_REMOVE(&(dev->link_intr_cbs), cb, next);
4062                                 rte_free(cb);
4063                         } else {
4064                                 ret = -EAGAIN;
4065                         }
4066                 }
4067         } while (++next_port <= last_port);
4068
4069         rte_spinlock_unlock(&rte_eth_dev_cb_lock);
4070         return ret;
4071 }
4072
4073 int
4074 _rte_eth_dev_callback_process(struct rte_eth_dev *dev,
4075         enum rte_eth_event_type event, void *ret_param)
4076 {
4077         struct rte_eth_dev_callback *cb_lst;
4078         struct rte_eth_dev_callback dev_cb;
4079         int rc = 0;
4080
4081         rte_spinlock_lock(&rte_eth_dev_cb_lock);
4082         TAILQ_FOREACH(cb_lst, &(dev->link_intr_cbs), next) {
4083                 if (cb_lst->cb_fn == NULL || cb_lst->event != event)
4084                         continue;
4085                 dev_cb = *cb_lst;
4086                 cb_lst->active = 1;
4087                 if (ret_param != NULL)
4088                         dev_cb.ret_param = ret_param;
4089
4090                 rte_spinlock_unlock(&rte_eth_dev_cb_lock);
4091                 rc = dev_cb.cb_fn(dev->data->port_id, dev_cb.event,
4092                                 dev_cb.cb_arg, dev_cb.ret_param);
4093                 rte_spinlock_lock(&rte_eth_dev_cb_lock);
4094                 cb_lst->active = 0;
4095         }
4096         rte_spinlock_unlock(&rte_eth_dev_cb_lock);
4097         return rc;
4098 }
4099
4100 void
4101 rte_eth_dev_probing_finish(struct rte_eth_dev *dev)
4102 {
4103         if (dev == NULL)
4104                 return;
4105
4106         _rte_eth_dev_callback_process(dev, RTE_ETH_EVENT_NEW, NULL);
4107
4108         dev->state = RTE_ETH_DEV_ATTACHED;
4109 }
4110
4111 int
4112 rte_eth_dev_rx_intr_ctl(uint16_t port_id, int epfd, int op, void *data)
4113 {
4114         uint32_t vec;
4115         struct rte_eth_dev *dev;
4116         struct rte_intr_handle *intr_handle;
4117         uint16_t qid;
4118         int rc;
4119
4120         RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV);
4121
4122         dev = &rte_eth_devices[port_id];
4123
4124         if (!dev->intr_handle) {
4125                 RTE_ETHDEV_LOG(ERR, "RX Intr handle unset\n");
4126                 return -ENOTSUP;
4127         }
4128
4129         intr_handle = dev->intr_handle;
4130         if (!intr_handle->intr_vec) {
4131                 RTE_ETHDEV_LOG(ERR, "RX Intr vector unset\n");
4132                 return -EPERM;
4133         }
4134
4135         for (qid = 0; qid < dev->data->nb_rx_queues; qid++) {
4136                 vec = intr_handle->intr_vec[qid];
4137                 rc = rte_intr_rx_ctl(intr_handle, epfd, op, vec, data);
4138                 if (rc && rc != -EEXIST) {
4139                         RTE_ETHDEV_LOG(ERR,
4140                                 "p %u q %u rx ctl error op %d epfd %d vec %u\n",
4141                                 port_id, qid, op, epfd, vec);
4142                 }
4143         }
4144
4145         return 0;
4146 }
4147
4148 int
4149 rte_eth_dev_rx_intr_ctl_q_get_fd(uint16_t port_id, uint16_t queue_id)
4150 {
4151         struct rte_intr_handle *intr_handle;
4152         struct rte_eth_dev *dev;
4153         unsigned int efd_idx;
4154         uint32_t vec;
4155         int fd;
4156
4157         RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -1);
4158
4159         dev = &rte_eth_devices[port_id];
4160
4161         if (queue_id >= dev->data->nb_rx_queues) {
4162                 RTE_ETHDEV_LOG(ERR, "Invalid RX queue_id=%u\n", queue_id);
4163                 return -1;
4164         }
4165
4166         if (!dev->intr_handle) {
4167                 RTE_ETHDEV_LOG(ERR, "RX Intr handle unset\n");
4168                 return -1;
4169         }
4170
4171         intr_handle = dev->intr_handle;
4172         if (!intr_handle->intr_vec) {
4173                 RTE_ETHDEV_LOG(ERR, "RX Intr vector unset\n");
4174                 return -1;
4175         }
4176
4177         vec = intr_handle->intr_vec[queue_id];
4178         efd_idx = (vec >= RTE_INTR_VEC_RXTX_OFFSET) ?
4179                 (vec - RTE_INTR_VEC_RXTX_OFFSET) : vec;
4180         fd = intr_handle->efds[efd_idx];
4181
4182         return fd;
4183 }
4184
4185 const struct rte_memzone *
4186 rte_eth_dma_zone_reserve(const struct rte_eth_dev *dev, const char *ring_name,
4187                          uint16_t queue_id, size_t size, unsigned align,
4188                          int socket_id)
4189 {
4190         char z_name[RTE_MEMZONE_NAMESIZE];
4191         const struct rte_memzone *mz;
4192         int rc;
4193
4194         rc = snprintf(z_name, sizeof(z_name), "eth_p%d_q%d_%s",
4195                       dev->data->port_id, queue_id, ring_name);
4196         if (rc >= RTE_MEMZONE_NAMESIZE) {
4197                 RTE_ETHDEV_LOG(ERR, "ring name too long\n");
4198                 rte_errno = ENAMETOOLONG;
4199                 return NULL;
4200         }
4201
4202         mz = rte_memzone_lookup(z_name);
4203         if (mz)
4204                 return mz;
4205
4206         return rte_memzone_reserve_aligned(z_name, size, socket_id,
4207                         RTE_MEMZONE_IOVA_CONTIG, align);
4208 }
4209
4210 int
4211 rte_eth_dev_create(struct rte_device *device, const char *name,
4212         size_t priv_data_size,
4213         ethdev_bus_specific_init ethdev_bus_specific_init,
4214         void *bus_init_params,
4215         ethdev_init_t ethdev_init, void *init_params)
4216 {
4217         struct rte_eth_dev *ethdev;
4218         int retval;
4219
4220         RTE_FUNC_PTR_OR_ERR_RET(*ethdev_init, -EINVAL);
4221
4222         if (rte_eal_process_type() == RTE_PROC_PRIMARY) {
4223                 ethdev = rte_eth_dev_allocate(name);
4224                 if (!ethdev)
4225                         return -ENODEV;
4226
4227                 if (priv_data_size) {
4228                         ethdev->data->dev_private = rte_zmalloc_socket(
4229                                 name, priv_data_size, RTE_CACHE_LINE_SIZE,
4230                                 device->numa_node);
4231
4232                         if (!ethdev->data->dev_private) {
4233                                 RTE_LOG(ERR, EAL, "failed to allocate private data");
4234                                 retval = -ENOMEM;
4235                                 goto probe_failed;
4236                         }
4237                 }
4238         } else {
4239                 ethdev = rte_eth_dev_attach_secondary(name);
4240                 if (!ethdev) {
4241                         RTE_LOG(ERR, EAL, "secondary process attach failed, "
4242                                 "ethdev doesn't exist");
4243                         return  -ENODEV;
4244                 }
4245         }
4246
4247         ethdev->device = device;
4248
4249         if (ethdev_bus_specific_init) {
4250                 retval = ethdev_bus_specific_init(ethdev, bus_init_params);
4251                 if (retval) {
4252                         RTE_LOG(ERR, EAL,
4253                                 "ethdev bus specific initialisation failed");
4254                         goto probe_failed;
4255                 }
4256         }
4257
4258         retval = ethdev_init(ethdev, init_params);
4259         if (retval) {
4260                 RTE_LOG(ERR, EAL, "ethdev initialisation failed");
4261                 goto probe_failed;
4262         }
4263
4264         rte_eth_dev_probing_finish(ethdev);
4265
4266         return retval;
4267
4268 probe_failed:
4269         rte_eth_dev_release_port(ethdev);
4270         return retval;
4271 }
4272
4273 int
4274 rte_eth_dev_destroy(struct rte_eth_dev *ethdev,
4275         ethdev_uninit_t ethdev_uninit)
4276 {
4277         int ret;
4278
4279         ethdev = rte_eth_dev_allocated(ethdev->data->name);
4280         if (!ethdev)
4281                 return -ENODEV;
4282
4283         RTE_FUNC_PTR_OR_ERR_RET(*ethdev_uninit, -EINVAL);
4284
4285         ret = ethdev_uninit(ethdev);
4286         if (ret)
4287                 return ret;
4288
4289         return rte_eth_dev_release_port(ethdev);
4290 }
4291
4292 int
4293 rte_eth_dev_rx_intr_ctl_q(uint16_t port_id, uint16_t queue_id,
4294                           int epfd, int op, void *data)
4295 {
4296         uint32_t vec;
4297         struct rte_eth_dev *dev;
4298         struct rte_intr_handle *intr_handle;
4299         int rc;
4300
4301         RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV);
4302
4303         dev = &rte_eth_devices[port_id];
4304         if (queue_id >= dev->data->nb_rx_queues) {
4305                 RTE_ETHDEV_LOG(ERR, "Invalid RX queue_id=%u\n", queue_id);
4306                 return -EINVAL;
4307         }
4308
4309         if (!dev->intr_handle) {
4310                 RTE_ETHDEV_LOG(ERR, "RX Intr handle unset\n");
4311                 return -ENOTSUP;
4312         }
4313
4314         intr_handle = dev->intr_handle;
4315         if (!intr_handle->intr_vec) {
4316                 RTE_ETHDEV_LOG(ERR, "RX Intr vector unset\n");
4317                 return -EPERM;
4318         }
4319
4320         vec = intr_handle->intr_vec[queue_id];
4321         rc = rte_intr_rx_ctl(intr_handle, epfd, op, vec, data);
4322         if (rc && rc != -EEXIST) {
4323                 RTE_ETHDEV_LOG(ERR,
4324                         "p %u q %u rx ctl error op %d epfd %d vec %u\n",
4325                         port_id, queue_id, op, epfd, vec);
4326                 return rc;
4327         }
4328
4329         return 0;
4330 }
4331
4332 int
4333 rte_eth_dev_rx_intr_enable(uint16_t port_id,
4334                            uint16_t queue_id)
4335 {
4336         struct rte_eth_dev *dev;
4337
4338         RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV);
4339
4340         dev = &rte_eth_devices[port_id];
4341
4342         RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->rx_queue_intr_enable, -ENOTSUP);
4343         return eth_err(port_id, (*dev->dev_ops->rx_queue_intr_enable)(dev,
4344                                                                 queue_id));
4345 }
4346
4347 int
4348 rte_eth_dev_rx_intr_disable(uint16_t port_id,
4349                             uint16_t queue_id)
4350 {
4351         struct rte_eth_dev *dev;
4352
4353         RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV);
4354
4355         dev = &rte_eth_devices[port_id];
4356
4357         RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->rx_queue_intr_disable, -ENOTSUP);
4358         return eth_err(port_id, (*dev->dev_ops->rx_queue_intr_disable)(dev,
4359                                                                 queue_id));
4360 }
4361
4362
4363 int
4364 rte_eth_dev_filter_supported(uint16_t port_id,
4365                              enum rte_filter_type filter_type)
4366 {
4367         struct rte_eth_dev *dev;
4368
4369         RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV);
4370
4371         dev = &rte_eth_devices[port_id];
4372         RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->filter_ctrl, -ENOTSUP);
4373         return (*dev->dev_ops->filter_ctrl)(dev, filter_type,
4374                                 RTE_ETH_FILTER_NOP, NULL);
4375 }
4376
4377 int
4378 rte_eth_dev_filter_ctrl(uint16_t port_id, enum rte_filter_type filter_type,
4379                         enum rte_filter_op filter_op, void *arg)
4380 {
4381         struct rte_eth_dev *dev;
4382
4383         RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV);
4384
4385         dev = &rte_eth_devices[port_id];
4386         RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->filter_ctrl, -ENOTSUP);
4387         return eth_err(port_id, (*dev->dev_ops->filter_ctrl)(dev, filter_type,
4388                                                              filter_op, arg));
4389 }
4390
4391 const struct rte_eth_rxtx_callback *
4392 rte_eth_add_rx_callback(uint16_t port_id, uint16_t queue_id,
4393                 rte_rx_callback_fn fn, void *user_param)
4394 {
4395 #ifndef RTE_ETHDEV_RXTX_CALLBACKS
4396         rte_errno = ENOTSUP;
4397         return NULL;
4398 #endif
4399         struct rte_eth_dev *dev;
4400
4401         /* check input parameters */
4402         if (!rte_eth_dev_is_valid_port(port_id) || fn == NULL ||
4403                     queue_id >= rte_eth_devices[port_id].data->nb_rx_queues) {
4404                 rte_errno = EINVAL;
4405                 return NULL;
4406         }
4407         dev = &rte_eth_devices[port_id];
4408         if (rte_eth_dev_is_rx_hairpin_queue(dev, queue_id)) {
4409                 rte_errno = EINVAL;
4410                 return NULL;
4411         }
4412         struct rte_eth_rxtx_callback *cb = rte_zmalloc(NULL, sizeof(*cb), 0);
4413
4414         if (cb == NULL) {
4415                 rte_errno = ENOMEM;
4416                 return NULL;
4417         }
4418
4419         cb->fn.rx = fn;
4420         cb->param = user_param;
4421
4422         rte_spinlock_lock(&rte_eth_rx_cb_lock);
4423         /* Add the callbacks in fifo order. */
4424         struct rte_eth_rxtx_callback *tail =
4425                 rte_eth_devices[port_id].post_rx_burst_cbs[queue_id];
4426
4427         if (!tail) {
4428                 rte_eth_devices[port_id].post_rx_burst_cbs[queue_id] = cb;
4429
4430         } else {
4431                 while (tail->next)
4432                         tail = tail->next;
4433                 tail->next = cb;
4434         }
4435         rte_spinlock_unlock(&rte_eth_rx_cb_lock);
4436
4437         return cb;
4438 }
4439
4440 const struct rte_eth_rxtx_callback *
4441 rte_eth_add_first_rx_callback(uint16_t port_id, uint16_t queue_id,
4442                 rte_rx_callback_fn fn, void *user_param)
4443 {
4444 #ifndef RTE_ETHDEV_RXTX_CALLBACKS
4445         rte_errno = ENOTSUP;
4446         return NULL;
4447 #endif
4448         /* check input parameters */
4449         if (!rte_eth_dev_is_valid_port(port_id) || fn == NULL ||
4450                 queue_id >= rte_eth_devices[port_id].data->nb_rx_queues) {
4451                 rte_errno = EINVAL;
4452                 return NULL;
4453         }
4454
4455         struct rte_eth_rxtx_callback *cb = rte_zmalloc(NULL, sizeof(*cb), 0);
4456
4457         if (cb == NULL) {
4458                 rte_errno = ENOMEM;
4459                 return NULL;
4460         }
4461
4462         cb->fn.rx = fn;
4463         cb->param = user_param;
4464
4465         rte_spinlock_lock(&rte_eth_rx_cb_lock);
4466         /* Add the callbacks at first position */
4467         cb->next = rte_eth_devices[port_id].post_rx_burst_cbs[queue_id];
4468         rte_smp_wmb();
4469         rte_eth_devices[port_id].post_rx_burst_cbs[queue_id] = cb;
4470         rte_spinlock_unlock(&rte_eth_rx_cb_lock);
4471
4472         return cb;
4473 }
4474
4475 const struct rte_eth_rxtx_callback *
4476 rte_eth_add_tx_callback(uint16_t port_id, uint16_t queue_id,
4477                 rte_tx_callback_fn fn, void *user_param)
4478 {
4479 #ifndef RTE_ETHDEV_RXTX_CALLBACKS
4480         rte_errno = ENOTSUP;
4481         return NULL;
4482 #endif
4483         struct rte_eth_dev *dev;
4484
4485         /* check input parameters */
4486         if (!rte_eth_dev_is_valid_port(port_id) || fn == NULL ||
4487                     queue_id >= rte_eth_devices[port_id].data->nb_tx_queues) {
4488                 rte_errno = EINVAL;
4489                 return NULL;
4490         }
4491
4492         dev = &rte_eth_devices[port_id];
4493         if (rte_eth_dev_is_tx_hairpin_queue(dev, queue_id)) {
4494                 rte_errno = EINVAL;
4495                 return NULL;
4496         }
4497
4498         struct rte_eth_rxtx_callback *cb = rte_zmalloc(NULL, sizeof(*cb), 0);
4499
4500         if (cb == NULL) {
4501                 rte_errno = ENOMEM;
4502                 return NULL;
4503         }
4504
4505         cb->fn.tx = fn;
4506         cb->param = user_param;
4507
4508         rte_spinlock_lock(&rte_eth_tx_cb_lock);
4509         /* Add the callbacks in fifo order. */
4510         struct rte_eth_rxtx_callback *tail =
4511                 rte_eth_devices[port_id].pre_tx_burst_cbs[queue_id];
4512
4513         if (!tail) {
4514                 rte_eth_devices[port_id].pre_tx_burst_cbs[queue_id] = cb;
4515
4516         } else {
4517                 while (tail->next)
4518                         tail = tail->next;
4519                 tail->next = cb;
4520         }
4521         rte_spinlock_unlock(&rte_eth_tx_cb_lock);
4522
4523         return cb;
4524 }
4525
4526 int
4527 rte_eth_remove_rx_callback(uint16_t port_id, uint16_t queue_id,
4528                 const struct rte_eth_rxtx_callback *user_cb)
4529 {
4530 #ifndef RTE_ETHDEV_RXTX_CALLBACKS
4531         return -ENOTSUP;
4532 #endif
4533         /* Check input parameters. */
4534         RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -EINVAL);
4535         if (user_cb == NULL ||
4536                         queue_id >= rte_eth_devices[port_id].data->nb_rx_queues)
4537                 return -EINVAL;
4538
4539         struct rte_eth_dev *dev = &rte_eth_devices[port_id];
4540         struct rte_eth_rxtx_callback *cb;
4541         struct rte_eth_rxtx_callback **prev_cb;
4542         int ret = -EINVAL;
4543
4544         rte_spinlock_lock(&rte_eth_rx_cb_lock);
4545         prev_cb = &dev->post_rx_burst_cbs[queue_id];
4546         for (; *prev_cb != NULL; prev_cb = &cb->next) {
4547                 cb = *prev_cb;
4548                 if (cb == user_cb) {
4549                         /* Remove the user cb from the callback list. */
4550                         *prev_cb = cb->next;
4551                         ret = 0;
4552                         break;
4553                 }
4554         }
4555         rte_spinlock_unlock(&rte_eth_rx_cb_lock);
4556
4557         return ret;
4558 }
4559
4560 int
4561 rte_eth_remove_tx_callback(uint16_t port_id, uint16_t queue_id,
4562                 const struct rte_eth_rxtx_callback *user_cb)
4563 {
4564 #ifndef RTE_ETHDEV_RXTX_CALLBACKS
4565         return -ENOTSUP;
4566 #endif
4567         /* Check input parameters. */
4568         RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -EINVAL);
4569         if (user_cb == NULL ||
4570                         queue_id >= rte_eth_devices[port_id].data->nb_tx_queues)
4571                 return -EINVAL;
4572
4573         struct rte_eth_dev *dev = &rte_eth_devices[port_id];
4574         int ret = -EINVAL;
4575         struct rte_eth_rxtx_callback *cb;
4576         struct rte_eth_rxtx_callback **prev_cb;
4577
4578         rte_spinlock_lock(&rte_eth_tx_cb_lock);
4579         prev_cb = &dev->pre_tx_burst_cbs[queue_id];
4580         for (; *prev_cb != NULL; prev_cb = &cb->next) {
4581                 cb = *prev_cb;
4582                 if (cb == user_cb) {
4583                         /* Remove the user cb from the callback list. */
4584                         *prev_cb = cb->next;
4585                         ret = 0;
4586                         break;
4587                 }
4588         }
4589         rte_spinlock_unlock(&rte_eth_tx_cb_lock);
4590
4591         return ret;
4592 }
4593
4594 int
4595 rte_eth_rx_queue_info_get(uint16_t port_id, uint16_t queue_id,
4596         struct rte_eth_rxq_info *qinfo)
4597 {
4598         struct rte_eth_dev *dev;
4599
4600         RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV);
4601
4602         if (qinfo == NULL)
4603                 return -EINVAL;
4604
4605         dev = &rte_eth_devices[port_id];
4606         if (queue_id >= dev->data->nb_rx_queues) {
4607                 RTE_ETHDEV_LOG(ERR, "Invalid RX queue_id=%u\n", queue_id);
4608                 return -EINVAL;
4609         }
4610
4611         if (rte_eth_dev_is_rx_hairpin_queue(dev, queue_id)) {
4612                 RTE_ETHDEV_LOG(INFO,
4613                         "Can't get hairpin Rx queue %"PRIu16" info of device with port_id=%"PRIu16"\n",
4614                         queue_id, port_id);
4615                 return -EINVAL;
4616         }
4617
4618         RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->rxq_info_get, -ENOTSUP);
4619
4620         memset(qinfo, 0, sizeof(*qinfo));
4621         dev->dev_ops->rxq_info_get(dev, queue_id, qinfo);
4622         return 0;
4623 }
4624
4625 int
4626 rte_eth_tx_queue_info_get(uint16_t port_id, uint16_t queue_id,
4627         struct rte_eth_txq_info *qinfo)
4628 {
4629         struct rte_eth_dev *dev;
4630
4631         RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV);
4632
4633         if (qinfo == NULL)
4634                 return -EINVAL;
4635
4636         dev = &rte_eth_devices[port_id];
4637         if (queue_id >= dev->data->nb_tx_queues) {
4638                 RTE_ETHDEV_LOG(ERR, "Invalid TX queue_id=%u\n", queue_id);
4639                 return -EINVAL;
4640         }
4641
4642         if (rte_eth_dev_is_tx_hairpin_queue(dev, queue_id)) {
4643                 RTE_ETHDEV_LOG(INFO,
4644                         "Can't get hairpin Tx queue %"PRIu16" info of device with port_id=%"PRIu16"\n",
4645                         queue_id, port_id);
4646                 return -EINVAL;
4647         }
4648
4649         RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->txq_info_get, -ENOTSUP);
4650
4651         memset(qinfo, 0, sizeof(*qinfo));
4652         dev->dev_ops->txq_info_get(dev, queue_id, qinfo);
4653
4654         return 0;
4655 }
4656
4657 int
4658 rte_eth_rx_burst_mode_get(uint16_t port_id, uint16_t queue_id,
4659                           struct rte_eth_burst_mode *mode)
4660 {
4661         struct rte_eth_dev *dev;
4662
4663         RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV);
4664
4665         if (mode == NULL)
4666                 return -EINVAL;
4667
4668         dev = &rte_eth_devices[port_id];
4669
4670         if (queue_id >= dev->data->nb_rx_queues) {
4671                 RTE_ETHDEV_LOG(ERR, "Invalid RX queue_id=%u\n", queue_id);
4672                 return -EINVAL;
4673         }
4674
4675         RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->rx_burst_mode_get, -ENOTSUP);
4676         memset(mode, 0, sizeof(*mode));
4677         return eth_err(port_id,
4678                        dev->dev_ops->rx_burst_mode_get(dev, queue_id, mode));
4679 }
4680
4681 int
4682 rte_eth_tx_burst_mode_get(uint16_t port_id, uint16_t queue_id,
4683                           struct rte_eth_burst_mode *mode)
4684 {
4685         struct rte_eth_dev *dev;
4686
4687         RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV);
4688
4689         if (mode == NULL)
4690                 return -EINVAL;
4691
4692         dev = &rte_eth_devices[port_id];
4693
4694         if (queue_id >= dev->data->nb_tx_queues) {
4695                 RTE_ETHDEV_LOG(ERR, "Invalid TX queue_id=%u\n", queue_id);
4696                 return -EINVAL;
4697         }
4698
4699         RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->tx_burst_mode_get, -ENOTSUP);
4700         memset(mode, 0, sizeof(*mode));
4701         return eth_err(port_id,
4702                        dev->dev_ops->tx_burst_mode_get(dev, queue_id, mode));
4703 }
4704
4705 int
4706 rte_eth_dev_set_mc_addr_list(uint16_t port_id,
4707                              struct rte_ether_addr *mc_addr_set,
4708                              uint32_t nb_mc_addr)
4709 {
4710         struct rte_eth_dev *dev;
4711
4712         RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV);
4713
4714         dev = &rte_eth_devices[port_id];
4715         RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->set_mc_addr_list, -ENOTSUP);
4716         return eth_err(port_id, dev->dev_ops->set_mc_addr_list(dev,
4717                                                 mc_addr_set, nb_mc_addr));
4718 }
4719
4720 int
4721 rte_eth_timesync_enable(uint16_t port_id)
4722 {
4723         struct rte_eth_dev *dev;
4724
4725         RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV);
4726         dev = &rte_eth_devices[port_id];
4727
4728         RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->timesync_enable, -ENOTSUP);
4729         return eth_err(port_id, (*dev->dev_ops->timesync_enable)(dev));
4730 }
4731
4732 int
4733 rte_eth_timesync_disable(uint16_t port_id)
4734 {
4735         struct rte_eth_dev *dev;
4736
4737         RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV);
4738         dev = &rte_eth_devices[port_id];
4739
4740         RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->timesync_disable, -ENOTSUP);
4741         return eth_err(port_id, (*dev->dev_ops->timesync_disable)(dev));
4742 }
4743
4744 int
4745 rte_eth_timesync_read_rx_timestamp(uint16_t port_id, struct timespec *timestamp,
4746                                    uint32_t flags)
4747 {
4748         struct rte_eth_dev *dev;
4749
4750         RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV);
4751         dev = &rte_eth_devices[port_id];
4752
4753         RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->timesync_read_rx_timestamp, -ENOTSUP);
4754         return eth_err(port_id, (*dev->dev_ops->timesync_read_rx_timestamp)
4755                                 (dev, timestamp, flags));
4756 }
4757
4758 int
4759 rte_eth_timesync_read_tx_timestamp(uint16_t port_id,
4760                                    struct timespec *timestamp)
4761 {
4762         struct rte_eth_dev *dev;
4763
4764         RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV);
4765         dev = &rte_eth_devices[port_id];
4766
4767         RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->timesync_read_tx_timestamp, -ENOTSUP);
4768         return eth_err(port_id, (*dev->dev_ops->timesync_read_tx_timestamp)
4769                                 (dev, timestamp));
4770 }
4771
4772 int
4773 rte_eth_timesync_adjust_time(uint16_t port_id, int64_t delta)
4774 {
4775         struct rte_eth_dev *dev;
4776
4777         RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV);
4778         dev = &rte_eth_devices[port_id];
4779
4780         RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->timesync_adjust_time, -ENOTSUP);
4781         return eth_err(port_id, (*dev->dev_ops->timesync_adjust_time)(dev,
4782                                                                       delta));
4783 }
4784
4785 int
4786 rte_eth_timesync_read_time(uint16_t port_id, struct timespec *timestamp)
4787 {
4788         struct rte_eth_dev *dev;
4789
4790         RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV);
4791         dev = &rte_eth_devices[port_id];
4792
4793         RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->timesync_read_time, -ENOTSUP);
4794         return eth_err(port_id, (*dev->dev_ops->timesync_read_time)(dev,
4795                                                                 timestamp));
4796 }
4797
4798 int
4799 rte_eth_timesync_write_time(uint16_t port_id, const struct timespec *timestamp)
4800 {
4801         struct rte_eth_dev *dev;
4802
4803         RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV);
4804         dev = &rte_eth_devices[port_id];
4805
4806         RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->timesync_write_time, -ENOTSUP);
4807         return eth_err(port_id, (*dev->dev_ops->timesync_write_time)(dev,
4808                                                                 timestamp));
4809 }
4810
4811 int
4812 rte_eth_read_clock(uint16_t port_id, uint64_t *clock)
4813 {
4814         struct rte_eth_dev *dev;
4815
4816         RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV);
4817         dev = &rte_eth_devices[port_id];
4818
4819         RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->read_clock, -ENOTSUP);
4820         return eth_err(port_id, (*dev->dev_ops->read_clock)(dev, clock));
4821 }
4822
4823 int
4824 rte_eth_dev_get_reg_info(uint16_t port_id, struct rte_dev_reg_info *info)
4825 {
4826         struct rte_eth_dev *dev;
4827
4828         RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV);
4829
4830         dev = &rte_eth_devices[port_id];
4831         RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->get_reg, -ENOTSUP);
4832         return eth_err(port_id, (*dev->dev_ops->get_reg)(dev, info));
4833 }
4834
4835 int
4836 rte_eth_dev_get_eeprom_length(uint16_t port_id)
4837 {
4838         struct rte_eth_dev *dev;
4839
4840         RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV);
4841
4842         dev = &rte_eth_devices[port_id];
4843         RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->get_eeprom_length, -ENOTSUP);
4844         return eth_err(port_id, (*dev->dev_ops->get_eeprom_length)(dev));
4845 }
4846
4847 int
4848 rte_eth_dev_get_eeprom(uint16_t port_id, struct rte_dev_eeprom_info *info)
4849 {
4850         struct rte_eth_dev *dev;
4851
4852         RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV);
4853
4854         dev = &rte_eth_devices[port_id];
4855         RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->get_eeprom, -ENOTSUP);
4856         return eth_err(port_id, (*dev->dev_ops->get_eeprom)(dev, info));
4857 }
4858
4859 int
4860 rte_eth_dev_set_eeprom(uint16_t port_id, struct rte_dev_eeprom_info *info)
4861 {
4862         struct rte_eth_dev *dev;
4863
4864         RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV);
4865
4866         dev = &rte_eth_devices[port_id];
4867         RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->set_eeprom, -ENOTSUP);
4868         return eth_err(port_id, (*dev->dev_ops->set_eeprom)(dev, info));
4869 }
4870
4871 int
4872 rte_eth_dev_get_module_info(uint16_t port_id,
4873                             struct rte_eth_dev_module_info *modinfo)
4874 {
4875         struct rte_eth_dev *dev;
4876
4877         RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV);
4878
4879         dev = &rte_eth_devices[port_id];
4880         RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->get_module_info, -ENOTSUP);
4881         return (*dev->dev_ops->get_module_info)(dev, modinfo);
4882 }
4883
4884 int
4885 rte_eth_dev_get_module_eeprom(uint16_t port_id,
4886                               struct rte_dev_eeprom_info *info)
4887 {
4888         struct rte_eth_dev *dev;
4889
4890         RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV);
4891
4892         dev = &rte_eth_devices[port_id];
4893         RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->get_module_eeprom, -ENOTSUP);
4894         return (*dev->dev_ops->get_module_eeprom)(dev, info);
4895 }
4896
4897 int
4898 rte_eth_dev_get_dcb_info(uint16_t port_id,
4899                              struct rte_eth_dcb_info *dcb_info)
4900 {
4901         struct rte_eth_dev *dev;
4902
4903         RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV);
4904
4905         dev = &rte_eth_devices[port_id];
4906         memset(dcb_info, 0, sizeof(struct rte_eth_dcb_info));
4907
4908         RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->get_dcb_info, -ENOTSUP);
4909         return eth_err(port_id, (*dev->dev_ops->get_dcb_info)(dev, dcb_info));
4910 }
4911
4912 int
4913 rte_eth_dev_l2_tunnel_eth_type_conf(uint16_t port_id,
4914                                     struct rte_eth_l2_tunnel_conf *l2_tunnel)
4915 {
4916         struct rte_eth_dev *dev;
4917
4918         RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV);
4919         if (l2_tunnel == NULL) {
4920                 RTE_ETHDEV_LOG(ERR, "Invalid l2_tunnel parameter\n");
4921                 return -EINVAL;
4922         }
4923
4924         if (l2_tunnel->l2_tunnel_type >= RTE_TUNNEL_TYPE_MAX) {
4925                 RTE_ETHDEV_LOG(ERR, "Invalid tunnel type\n");
4926                 return -EINVAL;
4927         }
4928
4929         dev = &rte_eth_devices[port_id];
4930         RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->l2_tunnel_eth_type_conf,
4931                                 -ENOTSUP);
4932         return eth_err(port_id, (*dev->dev_ops->l2_tunnel_eth_type_conf)(dev,
4933                                                                 l2_tunnel));
4934 }
4935
4936 int
4937 rte_eth_dev_l2_tunnel_offload_set(uint16_t port_id,
4938                                   struct rte_eth_l2_tunnel_conf *l2_tunnel,
4939                                   uint32_t mask,
4940                                   uint8_t en)
4941 {
4942         struct rte_eth_dev *dev;
4943
4944         RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV);
4945
4946         if (l2_tunnel == NULL) {
4947                 RTE_ETHDEV_LOG(ERR, "Invalid l2_tunnel parameter\n");
4948                 return -EINVAL;
4949         }
4950
4951         if (l2_tunnel->l2_tunnel_type >= RTE_TUNNEL_TYPE_MAX) {
4952                 RTE_ETHDEV_LOG(ERR, "Invalid tunnel type\n");
4953                 return -EINVAL;
4954         }
4955
4956         if (mask == 0) {
4957                 RTE_ETHDEV_LOG(ERR, "Mask should have a value\n");
4958                 return -EINVAL;
4959         }
4960
4961         dev = &rte_eth_devices[port_id];
4962         RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->l2_tunnel_offload_set,
4963                                 -ENOTSUP);
4964         return eth_err(port_id, (*dev->dev_ops->l2_tunnel_offload_set)(dev,
4965                                                         l2_tunnel, mask, en));
4966 }
4967
4968 static void
4969 rte_eth_dev_adjust_nb_desc(uint16_t *nb_desc,
4970                            const struct rte_eth_desc_lim *desc_lim)
4971 {
4972         if (desc_lim->nb_align != 0)
4973                 *nb_desc = RTE_ALIGN_CEIL(*nb_desc, desc_lim->nb_align);
4974
4975         if (desc_lim->nb_max != 0)
4976                 *nb_desc = RTE_MIN(*nb_desc, desc_lim->nb_max);
4977
4978         *nb_desc = RTE_MAX(*nb_desc, desc_lim->nb_min);
4979 }
4980
4981 int
4982 rte_eth_dev_adjust_nb_rx_tx_desc(uint16_t port_id,
4983                                  uint16_t *nb_rx_desc,
4984                                  uint16_t *nb_tx_desc)
4985 {
4986         struct rte_eth_dev_info dev_info;
4987         int ret;
4988
4989         RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV);
4990
4991         ret = rte_eth_dev_info_get(port_id, &dev_info);
4992         if (ret != 0)
4993                 return ret;
4994
4995         if (nb_rx_desc != NULL)
4996                 rte_eth_dev_adjust_nb_desc(nb_rx_desc, &dev_info.rx_desc_lim);
4997
4998         if (nb_tx_desc != NULL)
4999                 rte_eth_dev_adjust_nb_desc(nb_tx_desc, &dev_info.tx_desc_lim);
5000
5001         return 0;
5002 }
5003
5004 int
5005 rte_eth_dev_hairpin_capability_get(uint16_t port_id,
5006                                    struct rte_eth_hairpin_cap *cap)
5007 {
5008         struct rte_eth_dev *dev;
5009
5010         RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -EINVAL);
5011
5012         dev = &rte_eth_devices[port_id];
5013         RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->hairpin_cap_get, -ENOTSUP);
5014         memset(cap, 0, sizeof(*cap));
5015         return eth_err(port_id, (*dev->dev_ops->hairpin_cap_get)(dev, cap));
5016 }
5017
5018 int
5019 rte_eth_dev_is_rx_hairpin_queue(struct rte_eth_dev *dev, uint16_t queue_id)
5020 {
5021         if (dev->data->rx_queue_state[queue_id] ==
5022             RTE_ETH_QUEUE_STATE_HAIRPIN)
5023                 return 1;
5024         return 0;
5025 }
5026
5027 int
5028 rte_eth_dev_is_tx_hairpin_queue(struct rte_eth_dev *dev, uint16_t queue_id)
5029 {
5030         if (dev->data->tx_queue_state[queue_id] ==
5031             RTE_ETH_QUEUE_STATE_HAIRPIN)
5032                 return 1;
5033         return 0;
5034 }
5035
5036 int
5037 rte_eth_dev_pool_ops_supported(uint16_t port_id, const char *pool)
5038 {
5039         struct rte_eth_dev *dev;
5040
5041         RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV);
5042
5043         if (pool == NULL)
5044                 return -EINVAL;
5045
5046         dev = &rte_eth_devices[port_id];
5047
5048         if (*dev->dev_ops->pool_ops_supported == NULL)
5049                 return 1; /* all pools are supported */
5050
5051         return (*dev->dev_ops->pool_ops_supported)(dev, pool);
5052 }
5053
5054 /**
5055  * A set of values to describe the possible states of a switch domain.
5056  */
5057 enum rte_eth_switch_domain_state {
5058         RTE_ETH_SWITCH_DOMAIN_UNUSED = 0,
5059         RTE_ETH_SWITCH_DOMAIN_ALLOCATED
5060 };
5061
5062 /**
5063  * Array of switch domains available for allocation. Array is sized to
5064  * RTE_MAX_ETHPORTS elements as there cannot be more active switch domains than
5065  * ethdev ports in a single process.
5066  */
5067 static struct rte_eth_dev_switch {
5068         enum rte_eth_switch_domain_state state;
5069 } rte_eth_switch_domains[RTE_MAX_ETHPORTS];
5070
5071 int
5072 rte_eth_switch_domain_alloc(uint16_t *domain_id)
5073 {
5074         unsigned int i;
5075
5076         *domain_id = RTE_ETH_DEV_SWITCH_DOMAIN_ID_INVALID;
5077
5078         for (i = 0; i < RTE_MAX_ETHPORTS; i++) {
5079                 if (rte_eth_switch_domains[i].state ==
5080                         RTE_ETH_SWITCH_DOMAIN_UNUSED) {
5081                         rte_eth_switch_domains[i].state =
5082                                 RTE_ETH_SWITCH_DOMAIN_ALLOCATED;
5083                         *domain_id = i;
5084                         return 0;
5085                 }
5086         }
5087
5088         return -ENOSPC;
5089 }
5090
5091 int
5092 rte_eth_switch_domain_free(uint16_t domain_id)
5093 {
5094         if (domain_id == RTE_ETH_DEV_SWITCH_DOMAIN_ID_INVALID ||
5095                 domain_id >= RTE_MAX_ETHPORTS)
5096                 return -EINVAL;
5097
5098         if (rte_eth_switch_domains[domain_id].state !=
5099                 RTE_ETH_SWITCH_DOMAIN_ALLOCATED)
5100                 return -EINVAL;
5101
5102         rte_eth_switch_domains[domain_id].state = RTE_ETH_SWITCH_DOMAIN_UNUSED;
5103
5104         return 0;
5105 }
5106
5107 static int
5108 rte_eth_devargs_tokenise(struct rte_kvargs *arglist, const char *str_in)
5109 {
5110         int state;
5111         struct rte_kvargs_pair *pair;
5112         char *letter;
5113
5114         arglist->str = strdup(str_in);
5115         if (arglist->str == NULL)
5116                 return -ENOMEM;
5117
5118         letter = arglist->str;
5119         state = 0;
5120         arglist->count = 0;
5121         pair = &arglist->pairs[0];
5122         while (1) {
5123                 switch (state) {
5124                 case 0: /* Initial */
5125                         if (*letter == '=')
5126                                 return -EINVAL;
5127                         else if (*letter == '\0')
5128                                 return 0;
5129
5130                         state = 1;
5131                         pair->key = letter;
5132                         /* fall-thru */
5133
5134                 case 1: /* Parsing key */
5135                         if (*letter == '=') {
5136                                 *letter = '\0';
5137                                 pair->value = letter + 1;
5138                                 state = 2;
5139                         } else if (*letter == ',' || *letter == '\0')
5140                                 return -EINVAL;
5141                         break;
5142
5143
5144                 case 2: /* Parsing value */
5145                         if (*letter == '[')
5146                                 state = 3;
5147                         else if (*letter == ',') {
5148                                 *letter = '\0';
5149                                 arglist->count++;
5150                                 pair = &arglist->pairs[arglist->count];
5151                                 state = 0;
5152                         } else if (*letter == '\0') {
5153                                 letter--;
5154                                 arglist->count++;
5155                                 pair = &arglist->pairs[arglist->count];
5156                                 state = 0;
5157                         }
5158                         break;
5159
5160                 case 3: /* Parsing list */
5161                         if (*letter == ']')
5162                                 state = 2;
5163                         else if (*letter == '\0')
5164                                 return -EINVAL;
5165                         break;
5166                 }
5167                 letter++;
5168         }
5169 }
5170
5171 int
5172 rte_eth_devargs_parse(const char *dargs, struct rte_eth_devargs *eth_da)
5173 {
5174         struct rte_kvargs args;
5175         struct rte_kvargs_pair *pair;
5176         unsigned int i;
5177         int result = 0;
5178
5179         memset(eth_da, 0, sizeof(*eth_da));
5180
5181         result = rte_eth_devargs_tokenise(&args, dargs);
5182         if (result < 0)
5183                 goto parse_cleanup;
5184
5185         for (i = 0; i < args.count; i++) {
5186                 pair = &args.pairs[i];
5187                 if (strcmp("representor", pair->key) == 0) {
5188                         result = rte_eth_devargs_parse_list(pair->value,
5189                                 rte_eth_devargs_parse_representor_ports,
5190                                 eth_da);
5191                         if (result < 0)
5192                                 goto parse_cleanup;
5193                 }
5194         }
5195
5196 parse_cleanup:
5197         if (args.str)
5198                 free(args.str);
5199
5200         return result;
5201 }
5202
5203 static int
5204 handle_port_list(const char *cmd __rte_unused,
5205                 const char *params __rte_unused,
5206                 struct rte_tel_data *d)
5207 {
5208         int port_id;
5209
5210         rte_tel_data_start_array(d, RTE_TEL_INT_VAL);
5211         RTE_ETH_FOREACH_DEV(port_id)
5212                 rte_tel_data_add_array_int(d, port_id);
5213         return 0;
5214 }
5215
5216 static int
5217 handle_port_xstats(const char *cmd __rte_unused,
5218                 const char *params,
5219                 struct rte_tel_data *d)
5220 {
5221         struct rte_eth_xstat *eth_xstats;
5222         struct rte_eth_xstat_name *xstat_names;
5223         int port_id, num_xstats;
5224         int i, ret;
5225
5226         if (params == NULL || strlen(params) == 0 || !isdigit(*params))
5227                 return -1;
5228
5229         port_id = atoi(params);
5230         if (!rte_eth_dev_is_valid_port(port_id))
5231                 return -1;
5232
5233         num_xstats = rte_eth_xstats_get(port_id, NULL, 0);
5234         if (num_xstats < 0)
5235                 return -1;
5236
5237         /* use one malloc for both names and stats */
5238         eth_xstats = malloc((sizeof(struct rte_eth_xstat) +
5239                         sizeof(struct rte_eth_xstat_name)) * num_xstats);
5240         if (eth_xstats == NULL)
5241                 return -1;
5242         xstat_names = (void *)&eth_xstats[num_xstats];
5243
5244         ret = rte_eth_xstats_get_names(port_id, xstat_names, num_xstats);
5245         if (ret < 0 || ret > num_xstats) {
5246                 free(eth_xstats);
5247                 return -1;
5248         }
5249
5250         ret = rte_eth_xstats_get(port_id, eth_xstats, num_xstats);
5251         if (ret < 0 || ret > num_xstats) {
5252                 free(eth_xstats);
5253                 return -1;
5254         }
5255
5256         rte_tel_data_start_dict(d);
5257         for (i = 0; i < num_xstats; i++)
5258                 rte_tel_data_add_dict_u64(d, xstat_names[i].name,
5259                                 eth_xstats[i].value);
5260         return 0;
5261 }
5262
5263 static int
5264 handle_port_link_status(const char *cmd __rte_unused,
5265                 const char *params,
5266                 struct rte_tel_data *d)
5267 {
5268         static const char *status_str = "status";
5269         int ret, port_id;
5270         struct rte_eth_link link;
5271
5272         if (params == NULL || strlen(params) == 0 || !isdigit(*params))
5273                 return -1;
5274
5275         port_id = atoi(params);
5276         if (!rte_eth_dev_is_valid_port(port_id))
5277                 return -1;
5278
5279         ret = rte_eth_link_get(port_id, &link);
5280         if (ret < 0)
5281                 return -1;
5282
5283         rte_tel_data_start_dict(d);
5284         if (!link.link_status) {
5285                 rte_tel_data_add_dict_string(d, status_str, "DOWN");
5286                 return 0;
5287         }
5288         rte_tel_data_add_dict_string(d, status_str, "UP");
5289         rte_tel_data_add_dict_u64(d, "speed", link.link_speed);
5290         rte_tel_data_add_dict_string(d, "duplex",
5291                         (link.link_duplex == ETH_LINK_FULL_DUPLEX) ?
5292                                 "full-duplex" : "half-duplex");
5293         return 0;
5294 }
5295
5296 RTE_LOG_REGISTER(rte_eth_dev_logtype, lib.ethdev, INFO);
5297
5298 RTE_INIT(ethdev_init_telemetry)
5299 {
5300         rte_telemetry_register_cmd("/ethdev/list", handle_port_list,
5301                         "Returns list of available ethdev ports. Takes no parameters");
5302         rte_telemetry_register_cmd("/ethdev/xstats", handle_port_xstats,
5303                         "Returns the extended stats for a port. Parameters: int port_id");
5304         rte_telemetry_register_cmd("/ethdev/link_status",
5305                         handle_port_link_status,
5306                         "Returns the link status for a port. Parameters: int port_id");
5307 }