net: add rte prefix to ether structures
[dpdk.git] / lib / librte_ethdev / rte_ethdev.c
index 1ff2368..b868535 100644 (file)
 #include <rte_spinlock.h>
 #include <rte_string_fns.h>
 #include <rte_kvargs.h>
+#include <rte_class.h>
 
 #include "rte_ether.h"
 #include "rte_ethdev.h"
 #include "rte_ethdev_driver.h"
 #include "ethdev_profile.h"
+#include "ethdev_private.h"
 
-static int ethdev_logtype;
-
-#define ethdev_log(level, fmt, ...) \
-       rte_log(RTE_LOG_ ## level, ethdev_logtype, fmt "\n", ## __VA_ARGS__)
+int rte_eth_dev_logtype;
 
 static const char *MZ_RTE_ETH_DEV_DATA = "rte_eth_dev_data";
 struct rte_eth_dev rte_eth_devices[RTE_MAX_ETHPORTS];
-static uint8_t eth_dev_last_created_port;
 
 /* spinlock for eth device callbacks */
 static rte_spinlock_t rte_eth_dev_cb_lock = RTE_SPINLOCK_INITIALIZER;
@@ -125,10 +123,12 @@ static const struct {
        RTE_RX_OFFLOAD_BIT2STR(VLAN_FILTER),
        RTE_RX_OFFLOAD_BIT2STR(VLAN_EXTEND),
        RTE_RX_OFFLOAD_BIT2STR(JUMBO_FRAME),
-       RTE_RX_OFFLOAD_BIT2STR(CRC_STRIP),
        RTE_RX_OFFLOAD_BIT2STR(SCATTER),
        RTE_RX_OFFLOAD_BIT2STR(TIMESTAMP),
        RTE_RX_OFFLOAD_BIT2STR(SECURITY),
+       RTE_RX_OFFLOAD_BIT2STR(KEEP_CRC),
+       RTE_RX_OFFLOAD_BIT2STR(SCTP_CKSUM),
+       RTE_RX_OFFLOAD_BIT2STR(OUTER_UDP_CKSUM),
 };
 
 #undef RTE_RX_OFFLOAD_BIT2STR
@@ -158,6 +158,10 @@ static const struct {
        RTE_TX_OFFLOAD_BIT2STR(MULTI_SEGS),
        RTE_TX_OFFLOAD_BIT2STR(MBUF_FAST_FREE),
        RTE_TX_OFFLOAD_BIT2STR(SECURITY),
+       RTE_TX_OFFLOAD_BIT2STR(UDP_TNL_TSO),
+       RTE_TX_OFFLOAD_BIT2STR(IP_TNL_TSO),
+       RTE_TX_OFFLOAD_BIT2STR(OUTER_UDP_CKSUM),
+       RTE_TX_OFFLOAD_BIT2STR(MATCH_METADATA),
 };
 
 #undef RTE_TX_OFFLOAD_BIT2STR
@@ -182,12 +186,151 @@ enum {
        STAT_QMAP_RX
 };
 
+int
+rte_eth_iterator_init(struct rte_dev_iterator *iter, const char *devargs_str)
+{
+       int ret;
+       struct rte_devargs devargs = {.args = NULL};
+       const char *bus_param_key;
+       char *bus_str = NULL;
+       char *cls_str = NULL;
+       int str_size;
+
+       memset(iter, 0, sizeof(*iter));
+
+       /*
+        * The devargs string may use various syntaxes:
+        *   - 0000:08:00.0,representor=[1-3]
+        *   - pci:0000:06:00.0,representor=[0,5]
+        *   - class=eth,mac=00:11:22:33:44:55
+        * A new syntax is in development (not yet supported):
+        *   - bus=X,paramX=x/class=Y,paramY=y/driver=Z,paramZ=z
+        */
+
+       /*
+        * Handle pure class filter (i.e. without any bus-level argument),
+        * from future new syntax.
+        * rte_devargs_parse() is not yet supporting the new syntax,
+        * that's why this simple case is temporarily parsed here.
+        */
+#define iter_anybus_str "class=eth,"
+       if (strncmp(devargs_str, iter_anybus_str,
+                       strlen(iter_anybus_str)) == 0) {
+               iter->cls_str = devargs_str + strlen(iter_anybus_str);
+               goto end;
+       }
+
+       /* Split bus, device and parameters. */
+       ret = rte_devargs_parse(&devargs, devargs_str);
+       if (ret != 0)
+               goto error;
+
+       /*
+        * Assume parameters of old syntax can match only at ethdev level.
+        * Extra parameters will be ignored, thanks to "+" prefix.
+        */
+       str_size = strlen(devargs.args) + 2;
+       cls_str = malloc(str_size);
+       if (cls_str == NULL) {
+               ret = -ENOMEM;
+               goto error;
+       }
+       ret = snprintf(cls_str, str_size, "+%s", devargs.args);
+       if (ret != str_size - 1) {
+               ret = -EINVAL;
+               goto error;
+       }
+       iter->cls_str = cls_str;
+       free(devargs.args); /* allocated by rte_devargs_parse() */
+       devargs.args = NULL;
+
+       iter->bus = devargs.bus;
+       if (iter->bus->dev_iterate == NULL) {
+               ret = -ENOTSUP;
+               goto error;
+       }
+
+       /* Convert bus args to new syntax for use with new API dev_iterate. */
+       if (strcmp(iter->bus->name, "vdev") == 0) {
+               bus_param_key = "name";
+       } else if (strcmp(iter->bus->name, "pci") == 0) {
+               bus_param_key = "addr";
+       } else {
+               ret = -ENOTSUP;
+               goto error;
+       }
+       str_size = strlen(bus_param_key) + strlen(devargs.name) + 2;
+       bus_str = malloc(str_size);
+       if (bus_str == NULL) {
+               ret = -ENOMEM;
+               goto error;
+       }
+       ret = snprintf(bus_str, str_size, "%s=%s",
+                       bus_param_key, devargs.name);
+       if (ret != str_size - 1) {
+               ret = -EINVAL;
+               goto error;
+       }
+       iter->bus_str = bus_str;
+
+end:
+       iter->cls = rte_class_find_by_name("eth");
+       return 0;
+
+error:
+       if (ret == -ENOTSUP)
+               RTE_LOG(ERR, EAL, "Bus %s does not support iterating.\n",
+                               iter->bus->name);
+       free(devargs.args);
+       free(bus_str);
+       free(cls_str);
+       return ret;
+}
+
+uint16_t
+rte_eth_iterator_next(struct rte_dev_iterator *iter)
+{
+       if (iter->cls == NULL) /* invalid ethdev iterator */
+               return RTE_MAX_ETHPORTS;
+
+       do { /* loop to try all matching rte_device */
+               /* If not pure ethdev filter and */
+               if (iter->bus != NULL &&
+                               /* not in middle of rte_eth_dev iteration, */
+                               iter->class_device == NULL) {
+                       /* get next rte_device to try. */
+                       iter->device = iter->bus->dev_iterate(
+                                       iter->device, iter->bus_str, iter);
+                       if (iter->device == NULL)
+                               break; /* no more rte_device candidate */
+               }
+               /* A device is matching bus part, need to check ethdev part. */
+               iter->class_device = iter->cls->dev_iterate(
+                               iter->class_device, iter->cls_str, iter);
+               if (iter->class_device != NULL)
+                       return eth_dev_to_id(iter->class_device); /* match */
+       } while (iter->bus != NULL); /* need to try next rte_device */
+
+       /* No more ethdev port to iterate. */
+       rte_eth_iterator_cleanup(iter);
+       return RTE_MAX_ETHPORTS;
+}
+
+void
+rte_eth_iterator_cleanup(struct rte_dev_iterator *iter)
+{
+       if (iter->bus_str == NULL)
+               return; /* nothing to free in pure class filter */
+       free(RTE_CAST_FIELD(iter, bus_str, char *)); /* workaround const */
+       free(RTE_CAST_FIELD(iter, cls_str, char *)); /* workaround const */
+       memset(iter, 0, sizeof(*iter));
+}
+
 uint16_t
 rte_eth_find_next(uint16_t port_id)
 {
        while (port_id < RTE_MAX_ETHPORTS &&
-              rte_eth_devices[port_id].state != RTE_ETH_DEV_ATTACHED &&
-              rte_eth_devices[port_id].state != RTE_ETH_DEV_REMOVED)
+                       rte_eth_devices[port_id].state == RTE_ETH_DEV_UNUSED)
                port_id++;
 
        if (port_id >= RTE_MAX_ETHPORTS)
@@ -196,6 +339,34 @@ rte_eth_find_next(uint16_t port_id)
        return port_id;
 }
 
+/*
+ * Macro to iterate over all valid ports for internal usage.
+ * Note: RTE_ETH_FOREACH_DEV is different because filtering owned ports.
+ */
+#define RTE_ETH_FOREACH_VALID_DEV(port_id) \
+       for (port_id = rte_eth_find_next(0); \
+            port_id < RTE_MAX_ETHPORTS; \
+            port_id = rte_eth_find_next(port_id + 1))
+
+uint16_t
+rte_eth_find_next_of(uint16_t port_id, const struct rte_device *parent)
+{
+       port_id = rte_eth_find_next(port_id);
+       while (port_id < RTE_MAX_ETHPORTS &&
+                       rte_eth_devices[port_id].device != parent)
+               port_id = rte_eth_find_next(port_id + 1);
+
+       return port_id;
+}
+
+uint16_t
+rte_eth_find_next_sibling(uint16_t port_id, uint16_t ref_port_id)
+{
+       RTE_ETH_VALID_PORTID_OR_ERR_RET(ref_port_id, RTE_MAX_ETHPORTS);
+       return rte_eth_find_next_of(port_id,
+                       rte_eth_devices[ref_port_id].device);
+}
+
 static void
 rte_eth_dev_shared_data_prepare(void)
 {
@@ -286,8 +457,6 @@ eth_dev_get(uint16_t port_id)
 
        eth_dev->data = &rte_eth_dev_shared_data->data[port_id];
 
-       eth_dev_last_created_port = port_id;
-
        return eth_dev;
 }
 
@@ -296,6 +465,18 @@ rte_eth_dev_allocate(const char *name)
 {
        uint16_t port_id;
        struct rte_eth_dev *eth_dev = NULL;
+       size_t name_len;
+
+       name_len = strnlen(name, RTE_ETH_NAME_MAX_LEN);
+       if (name_len == 0) {
+               RTE_ETHDEV_LOG(ERR, "Zero length Ethernet device name\n");
+               return NULL;
+       }
+
+       if (name_len >= RTE_ETH_NAME_MAX_LEN) {
+               RTE_ETHDEV_LOG(ERR, "Ethernet device name is too long\n");
+               return NULL;
+       }
 
        rte_eth_dev_shared_data_prepare();
 
@@ -303,19 +484,21 @@ rte_eth_dev_allocate(const char *name)
        rte_spinlock_lock(&rte_eth_dev_shared_data->ownership_lock);
 
        if (_rte_eth_dev_allocated(name) != NULL) {
-               ethdev_log(ERR, "Ethernet device with name %s already allocated",
-                               name);
+               RTE_ETHDEV_LOG(ERR,
+                       "Ethernet device with name %s already allocated\n",
+                       name);
                goto unlock;
        }
 
        port_id = rte_eth_dev_find_free_port();
        if (port_id == RTE_MAX_ETHPORTS) {
-               ethdev_log(ERR, "Reached maximum number of Ethernet ports");
+               RTE_ETHDEV_LOG(ERR,
+                       "Reached maximum number of Ethernet ports\n");
                goto unlock;
        }
 
        eth_dev = eth_dev_get(port_id);
-       snprintf(eth_dev->data->name, sizeof(eth_dev->data->name), "%s", name);
+       strlcpy(eth_dev->data->name, name, sizeof(eth_dev->data->name));
        eth_dev->data->port_id = port_id;
        eth_dev->data->mtu = ETHER_MTU;
 
@@ -346,8 +529,8 @@ rte_eth_dev_attach_secondary(const char *name)
                        break;
        }
        if (i == RTE_MAX_ETHPORTS) {
-               RTE_PMD_DEBUG_TRACE(
-                       "device %s is not driven by the primary process\n",
+               RTE_ETHDEV_LOG(ERR,
+                       "Device %s is not driven by the primary process\n",
                        name);
        } else {
                eth_dev = eth_dev_get(i);
@@ -366,16 +549,25 @@ rte_eth_dev_release_port(struct rte_eth_dev *eth_dev)
 
        rte_eth_dev_shared_data_prepare();
 
+       if (eth_dev->state != RTE_ETH_DEV_UNUSED)
+               _rte_eth_dev_callback_process(eth_dev,
+                               RTE_ETH_EVENT_DESTROY, NULL);
+
        rte_spinlock_lock(&rte_eth_dev_shared_data->ownership_lock);
 
        eth_dev->state = RTE_ETH_DEV_UNUSED;
 
-       memset(eth_dev->data, 0, sizeof(struct rte_eth_dev_data));
+       if (rte_eal_process_type() == RTE_PROC_PRIMARY) {
+               rte_free(eth_dev->data->rx_queues);
+               rte_free(eth_dev->data->tx_queues);
+               rte_free(eth_dev->data->mac_addrs);
+               rte_free(eth_dev->data->hash_mac_addrs);
+               rte_free(eth_dev->data->dev_private);
+               memset(eth_dev->data, 0, sizeof(struct rte_eth_dev_data));
+       }
 
        rte_spinlock_unlock(&rte_eth_dev_shared_data->ownership_lock);
 
-       _rte_eth_dev_callback_process(eth_dev, RTE_ETH_EVENT_DESTROY, NULL);
-
        return 0;
 }
 
@@ -393,24 +585,18 @@ static int
 rte_eth_is_valid_owner_id(uint64_t owner_id)
 {
        if (owner_id == RTE_ETH_DEV_NO_OWNER ||
-           rte_eth_dev_shared_data->next_owner_id <= owner_id) {
-               RTE_PMD_DEBUG_TRACE("Invalid owner_id=%016"PRIX64".\n", owner_id);
+           rte_eth_dev_shared_data->next_owner_id <= owner_id)
                return 0;
-       }
        return 1;
 }
 
 uint64_t
 rte_eth_find_next_owned_by(uint16_t port_id, const uint64_t owner_id)
 {
+       port_id = rte_eth_find_next(port_id);
        while (port_id < RTE_MAX_ETHPORTS &&
-              ((rte_eth_devices[port_id].state != RTE_ETH_DEV_ATTACHED &&
-              rte_eth_devices[port_id].state != RTE_ETH_DEV_REMOVED) ||
-              rte_eth_devices[port_id].data->owner.id != owner_id))
-               port_id++;
-
-       if (port_id >= RTE_MAX_ETHPORTS)
-               return RTE_MAX_ETHPORTS;
+                       rte_eth_devices[port_id].data->owner.id != owner_id)
+               port_id = rte_eth_find_next(port_id + 1);
 
        return port_id;
 }
@@ -434,35 +620,36 @@ _rte_eth_dev_owner_set(const uint16_t port_id, const uint64_t old_owner_id,
 {
        struct rte_eth_dev *ethdev = &rte_eth_devices[port_id];
        struct rte_eth_dev_owner *port_owner;
-       int sret;
 
        if (port_id >= RTE_MAX_ETHPORTS || !is_allocated(ethdev)) {
-               RTE_PMD_DEBUG_TRACE("Port id %"PRIu16" is not allocated.\n", port_id);
+               RTE_ETHDEV_LOG(ERR, "Port id %"PRIu16" is not allocated\n",
+                       port_id);
                return -ENODEV;
        }
 
        if (!rte_eth_is_valid_owner_id(new_owner->id) &&
-           !rte_eth_is_valid_owner_id(old_owner_id))
+           !rte_eth_is_valid_owner_id(old_owner_id)) {
+               RTE_ETHDEV_LOG(ERR,
+                       "Invalid owner old_id=%016"PRIx64" new_id=%016"PRIx64"\n",
+                      old_owner_id, new_owner->id);
                return -EINVAL;
+       }
 
        port_owner = &rte_eth_devices[port_id].data->owner;
        if (port_owner->id != old_owner_id) {
-               RTE_PMD_DEBUG_TRACE("Cannot set owner to port %d already owned"
-                                   " by %s_%016"PRIX64".\n", port_id,
-                                   port_owner->name, port_owner->id);
+               RTE_ETHDEV_LOG(ERR,
+                       "Cannot set owner to port %u already owned by %s_%016"PRIX64"\n",
+                       port_id, port_owner->name, port_owner->id);
                return -EPERM;
        }
 
-       sret = snprintf(port_owner->name, RTE_ETH_MAX_OWNER_NAME_LEN, "%s",
-                       new_owner->name);
-       if (sret < 0 || sret >= RTE_ETH_MAX_OWNER_NAME_LEN)
-               RTE_PMD_DEBUG_TRACE("Port %d owner name was truncated.\n",
-                                   port_id);
+       /* can not truncate (same structure) */
+       strlcpy(port_owner->name, new_owner->name, RTE_ETH_MAX_OWNER_NAME_LEN);
 
        port_owner->id = new_owner->id;
 
-       RTE_PMD_DEBUG_TRACE("Port %d owner is %s_%016"PRIX64".\n", port_id,
-                           new_owner->name, new_owner->id);
+       RTE_ETHDEV_LOG(DEBUG, "Port %u owner is %s_%016"PRIx64"\n",
+               port_id, new_owner->name, new_owner->id);
 
        return 0;
 }
@@ -514,8 +701,13 @@ rte_eth_dev_owner_delete(const uint64_t owner_id)
                        if (rte_eth_devices[port_id].data->owner.id == owner_id)
                                memset(&rte_eth_devices[port_id].data->owner, 0,
                                       sizeof(struct rte_eth_dev_owner));
-               RTE_PMD_DEBUG_TRACE("All port owners owned by %016"PRIX64
-                               " identifier have removed.\n", owner_id);
+               RTE_ETHDEV_LOG(NOTICE,
+                       "All port owners owned by %016"PRIx64" identifier have removed\n",
+                       owner_id);
+       } else {
+               RTE_ETHDEV_LOG(ERR,
+                              "Invalid owner id=%016"PRIx64"\n",
+                              owner_id);
        }
 
        rte_spinlock_unlock(&rte_eth_dev_shared_data->ownership_lock);
@@ -532,7 +724,8 @@ rte_eth_dev_owner_get(const uint16_t port_id, struct rte_eth_dev_owner *owner)
        rte_spinlock_lock(&rte_eth_dev_shared_data->ownership_lock);
 
        if (port_id >= RTE_MAX_ETHPORTS || !is_allocated(ethdev)) {
-               RTE_PMD_DEBUG_TRACE("Port id %"PRIu16" is not allocated.\n", port_id);
+               RTE_ETHDEV_LOG(ERR, "Port id %"PRIu16" is not allocated\n",
+                       port_id);
                ret = -ENODEV;
        } else {
                rte_memcpy(owner, &ethdev->data->owner, sizeof(*owner));
@@ -576,14 +769,13 @@ rte_eth_dev_count_avail(void)
        return count;
 }
 
-uint16_t __rte_experimental
+uint16_t
 rte_eth_dev_count_total(void)
 {
        uint16_t port, count = 0;
 
-       for (port = 0; port < RTE_MAX_ETHPORTS; port++)
-               if (rte_eth_devices[port].state != RTE_ETH_DEV_UNUSED)
-                       count++;
+       RTE_ETH_FOREACH_VALID_DEV(port)
+               count++;
 
        return count;
 }
@@ -596,7 +788,7 @@ rte_eth_dev_get_name_by_port(uint16_t port_id, char *name)
        RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -EINVAL);
 
        if (name == NULL) {
-               RTE_PMD_DEBUG_TRACE("Null pointer is specified\n");
+               RTE_ETHDEV_LOG(ERR, "Null pointer is specified\n");
                return -EINVAL;
        }
 
@@ -613,17 +805,15 @@ rte_eth_dev_get_port_by_name(const char *name, uint16_t *port_id)
        uint32_t pid;
 
        if (name == NULL) {
-               RTE_PMD_DEBUG_TRACE("Null pointer is specified\n");
+               RTE_ETHDEV_LOG(ERR, "Null pointer is specified\n");
                return -EINVAL;
        }
 
-       for (pid = 0; pid < RTE_MAX_ETHPORTS; pid++) {
-               if (rte_eth_devices[pid].state != RTE_ETH_DEV_UNUSED &&
-                   !strcmp(name, rte_eth_dev_shared_data->data[pid].name)) {
+       RTE_ETH_FOREACH_VALID_DEV(pid)
+               if (!strcmp(name, rte_eth_dev_shared_data->data[pid].name)) {
                        *port_id = pid;
                        return 0;
                }
-       }
 
        return -ENODEV;
 }
@@ -638,87 +828,6 @@ eth_err(uint16_t port_id, int ret)
        return ret;
 }
 
-/* attach the new device, then store port_id of the device */
-int
-rte_eth_dev_attach(const char *devargs, uint16_t *port_id)
-{
-       int current = rte_eth_dev_count_total();
-       struct rte_devargs da;
-       int ret = -1;
-
-       memset(&da, 0, sizeof(da));
-
-       if ((devargs == NULL) || (port_id == NULL)) {
-               ret = -EINVAL;
-               goto err;
-       }
-
-       /* parse devargs */
-       if (rte_devargs_parse(&da, "%s", devargs))
-               goto err;
-
-       ret = rte_eal_hotplug_add(da.bus->name, da.name, da.args);
-       if (ret < 0)
-               goto err;
-
-       /* no point looking at the port count if no port exists */
-       if (!rte_eth_dev_count_total()) {
-               ethdev_log(ERR, "No port found for device (%s)", da.name);
-               ret = -1;
-               goto err;
-       }
-
-       /* if nothing happened, there is a bug here, since some driver told us
-        * it did attach a device, but did not create a port.
-        * FIXME: race condition in case of plug-out of another device
-        */
-       if (current == rte_eth_dev_count_total()) {
-               ret = -1;
-               goto err;
-       }
-
-       *port_id = eth_dev_last_created_port;
-       ret = 0;
-
-err:
-       free(da.args);
-       return ret;
-}
-
-/* detach the device, then store the name of the device */
-int
-rte_eth_dev_detach(uint16_t port_id, char *name __rte_unused)
-{
-       struct rte_device *dev;
-       struct rte_bus *bus;
-       uint32_t dev_flags;
-       int ret = -1;
-
-       RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -EINVAL);
-
-       dev_flags = rte_eth_devices[port_id].data->dev_flags;
-       if (dev_flags & RTE_ETH_DEV_BONDED_SLAVE) {
-               ethdev_log(ERR,
-                       "Port %" PRIu16 " is bonded, cannot detach", port_id);
-               return -ENOTSUP;
-       }
-
-       dev = rte_eth_devices[port_id].device;
-       if (dev == NULL)
-               return -EINVAL;
-
-       bus = rte_bus_find_by_device(dev);
-       if (bus == NULL)
-               return -ENOENT;
-
-       ret = rte_eal_hotplug_remove(bus->name, dev->name);
-       if (ret < 0)
-               return ret;
-
-       rte_eth_dev_release_port(&rte_eth_devices[port_id]);
-       return 0;
-}
-
 static int
 rte_eth_dev_rx_queue_config(struct rte_eth_dev *dev, uint16_t nb_queues)
 {
@@ -778,21 +887,22 @@ rte_eth_dev_rx_queue_start(uint16_t port_id, uint16_t rx_queue_id)
 
        dev = &rte_eth_devices[port_id];
        if (!dev->data->dev_started) {
-               RTE_PMD_DEBUG_TRACE(
-                   "port %d must be started before start any queue\n", port_id);
+               RTE_ETHDEV_LOG(ERR,
+                       "Port %u must be started before start any queue\n",
+                       port_id);
                return -EINVAL;
        }
 
        if (rx_queue_id >= dev->data->nb_rx_queues) {
-               RTE_PMD_DEBUG_TRACE("Invalid RX queue_id=%d\n", rx_queue_id);
+               RTE_ETHDEV_LOG(ERR, "Invalid RX queue_id=%u\n", rx_queue_id);
                return -EINVAL;
        }
 
        RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->rx_queue_start, -ENOTSUP);
 
        if (dev->data->rx_queue_state[rx_queue_id] != RTE_ETH_QUEUE_STATE_STOPPED) {
-               RTE_PMD_DEBUG_TRACE("Queue %" PRIu16" of device with port_id=%" PRIu8
-                       " already started\n",
+               RTE_ETHDEV_LOG(INFO,
+                       "Queue %"PRIu16" of device with port_id=%"PRIu16" already started\n",
                        rx_queue_id, port_id);
                return 0;
        }
@@ -811,15 +921,15 @@ rte_eth_dev_rx_queue_stop(uint16_t port_id, uint16_t rx_queue_id)
 
        dev = &rte_eth_devices[port_id];
        if (rx_queue_id >= dev->data->nb_rx_queues) {
-               RTE_PMD_DEBUG_TRACE("Invalid RX queue_id=%d\n", rx_queue_id);
+               RTE_ETHDEV_LOG(ERR, "Invalid RX queue_id=%u\n", rx_queue_id);
                return -EINVAL;
        }
 
        RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->rx_queue_stop, -ENOTSUP);
 
        if (dev->data->rx_queue_state[rx_queue_id] == RTE_ETH_QUEUE_STATE_STOPPED) {
-               RTE_PMD_DEBUG_TRACE("Queue %" PRIu16" of device with port_id=%" PRIu8
-                       " already stopped\n",
+               RTE_ETHDEV_LOG(INFO,
+                       "Queue %"PRIu16" of device with port_id=%"PRIu16" already stopped\n",
                        rx_queue_id, port_id);
                return 0;
        }
@@ -837,28 +947,27 @@ rte_eth_dev_tx_queue_start(uint16_t port_id, uint16_t tx_queue_id)
 
        dev = &rte_eth_devices[port_id];
        if (!dev->data->dev_started) {
-               RTE_PMD_DEBUG_TRACE(
-                   "port %d must be started before start any queue\n", port_id);
+               RTE_ETHDEV_LOG(ERR,
+                       "Port %u must be started before start any queue\n",
+                       port_id);
                return -EINVAL;
        }
 
        if (tx_queue_id >= dev->data->nb_tx_queues) {
-               RTE_PMD_DEBUG_TRACE("Invalid TX queue_id=%d\n", tx_queue_id);
+               RTE_ETHDEV_LOG(ERR, "Invalid TX queue_id=%u\n", tx_queue_id);
                return -EINVAL;
        }
 
        RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->tx_queue_start, -ENOTSUP);
 
        if (dev->data->tx_queue_state[tx_queue_id] != RTE_ETH_QUEUE_STATE_STOPPED) {
-               RTE_PMD_DEBUG_TRACE("Queue %" PRIu16" of device with port_id=%" PRIu8
-                       " already started\n",
+               RTE_ETHDEV_LOG(INFO,
+                       "Queue %"PRIu16" of device with port_id=%"PRIu16" already started\n",
                        tx_queue_id, port_id);
                return 0;
        }
 
-       return eth_err(port_id, dev->dev_ops->tx_queue_start(dev,
-                                                            tx_queue_id));
-
+       return eth_err(port_id, dev->dev_ops->tx_queue_start(dev, tx_queue_id));
 }
 
 int
@@ -870,15 +979,15 @@ rte_eth_dev_tx_queue_stop(uint16_t port_id, uint16_t tx_queue_id)
 
        dev = &rte_eth_devices[port_id];
        if (tx_queue_id >= dev->data->nb_tx_queues) {
-               RTE_PMD_DEBUG_TRACE("Invalid TX queue_id=%d\n", tx_queue_id);
+               RTE_ETHDEV_LOG(ERR, "Invalid TX queue_id=%u\n", tx_queue_id);
                return -EINVAL;
        }
 
        RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->tx_queue_stop, -ENOTSUP);
 
        if (dev->data->tx_queue_state[tx_queue_id] == RTE_ETH_QUEUE_STATE_STOPPED) {
-               RTE_PMD_DEBUG_TRACE("Queue %" PRIu16" of device with port_id=%" PRIu8
-                       " already stopped\n",
+               RTE_ETHDEV_LOG(INFO,
+                       "Queue %"PRIu16" of device with port_id=%"PRIu16" already stopped\n",
                        tx_queue_id, port_id);
                return 0;
        }
@@ -970,42 +1079,7 @@ rte_eth_speed_bitflag(uint32_t speed, int duplex)
        }
 }
 
-/**
- * A conversion function from rxmode bitfield API.
- */
-static void
-rte_eth_convert_rx_offload_bitfield(const struct rte_eth_rxmode *rxmode,
-                                   uint64_t *rx_offloads)
-{
-       uint64_t offloads = 0;
-
-       if (rxmode->header_split == 1)
-               offloads |= DEV_RX_OFFLOAD_HEADER_SPLIT;
-       if (rxmode->hw_ip_checksum == 1)
-               offloads |= DEV_RX_OFFLOAD_CHECKSUM;
-       if (rxmode->hw_vlan_filter == 1)
-               offloads |= DEV_RX_OFFLOAD_VLAN_FILTER;
-       if (rxmode->hw_vlan_strip == 1)
-               offloads |= DEV_RX_OFFLOAD_VLAN_STRIP;
-       if (rxmode->hw_vlan_extend == 1)
-               offloads |= DEV_RX_OFFLOAD_VLAN_EXTEND;
-       if (rxmode->jumbo_frame == 1)
-               offloads |= DEV_RX_OFFLOAD_JUMBO_FRAME;
-       if (rxmode->hw_strip_crc == 1)
-               offloads |= DEV_RX_OFFLOAD_CRC_STRIP;
-       if (rxmode->enable_scatter == 1)
-               offloads |= DEV_RX_OFFLOAD_SCATTER;
-       if (rxmode->enable_lro == 1)
-               offloads |= DEV_RX_OFFLOAD_TCP_LRO;
-       if (rxmode->hw_timestamp == 1)
-               offloads |= DEV_RX_OFFLOAD_TIMESTAMP;
-       if (rxmode->security == 1)
-               offloads |= DEV_RX_OFFLOAD_SECURITY;
-
-       *rx_offloads = offloads;
-}
-
-const char * __rte_experimental
+const char *
 rte_eth_dev_rx_offload_name(uint64_t offload)
 {
        const char *name = "UNKNOWN";
@@ -1021,7 +1095,7 @@ rte_eth_dev_rx_offload_name(uint64_t offload)
        return name;
 }
 
-const char * __rte_experimental
+const char *
 rte_eth_dev_tx_offload_name(uint64_t offload)
 {
        const char *name = "UNKNOWN";
@@ -1043,8 +1117,9 @@ rte_eth_dev_configure(uint16_t port_id, uint16_t nb_rx_q, uint16_t nb_tx_q,
 {
        struct rte_eth_dev *dev;
        struct rte_eth_dev_info dev_info;
-       struct rte_eth_conf local_conf = *dev_conf;
+       struct rte_eth_conf orig_conf;
        int diag;
+       int ret;
 
        RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -EINVAL);
 
@@ -1053,6 +1128,22 @@ rte_eth_dev_configure(uint16_t port_id, uint16_t nb_rx_q, uint16_t nb_tx_q,
        RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->dev_infos_get, -ENOTSUP);
        RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->dev_configure, -ENOTSUP);
 
+       if (dev->data->dev_started) {
+               RTE_ETHDEV_LOG(ERR,
+                       "Port %u must be stopped to allow configuration\n",
+                       port_id);
+               return -EBUSY;
+       }
+
+        /* Store original config, as rollback required on failure */
+       memcpy(&orig_conf, &dev->data->dev_conf, sizeof(dev->data->dev_conf));
+
+       /*
+        * Copy the dev_conf parameter into the dev structure.
+        * rte_eth_dev_info_get() requires dev_conf, copy it before dev_info get
+        */
+       memcpy(&dev->data->dev_conf, dev_conf, sizeof(dev->data->dev_conf));
+
        rte_eth_dev_info_get(port_id, &dev_info);
 
        /* If number of queues specified by application for both Rx and Tx is
@@ -1071,87 +1162,75 @@ rte_eth_dev_configure(uint16_t port_id, uint16_t nb_rx_q, uint16_t nb_tx_q,
        }
 
        if (nb_rx_q > RTE_MAX_QUEUES_PER_PORT) {
-               RTE_PMD_DEBUG_TRACE(
+               RTE_ETHDEV_LOG(ERR,
                        "Number of RX queues requested (%u) is greater than max supported(%d)\n",
                        nb_rx_q, RTE_MAX_QUEUES_PER_PORT);
-               return -EINVAL;
+               ret = -EINVAL;
+               goto rollback;
        }
 
        if (nb_tx_q > RTE_MAX_QUEUES_PER_PORT) {
-               RTE_PMD_DEBUG_TRACE(
+               RTE_ETHDEV_LOG(ERR,
                        "Number of TX queues requested (%u) is greater than max supported(%d)\n",
                        nb_tx_q, RTE_MAX_QUEUES_PER_PORT);
-               return -EINVAL;
-       }
-
-       if (dev->data->dev_started) {
-               RTE_PMD_DEBUG_TRACE(
-                   "port %d must be stopped to allow configuration\n", port_id);
-               return -EBUSY;
+               ret = -EINVAL;
+               goto rollback;
        }
 
-       /*
-        * Convert between the offloads API to enable PMDs to support
-        * only one of them.
-        */
-       if (dev_conf->rxmode.ignore_offload_bitfield == 0)
-               rte_eth_convert_rx_offload_bitfield(
-                               &dev_conf->rxmode, &local_conf.rxmode.offloads);
-
-       /* Copy the dev_conf parameter into the dev structure */
-       memcpy(&dev->data->dev_conf, &local_conf, sizeof(dev->data->dev_conf));
-
        /*
         * Check that the numbers of RX and TX queues are not greater
         * than the maximum number of RX and TX queues supported by the
         * configured device.
         */
        if (nb_rx_q > dev_info.max_rx_queues) {
-               RTE_PMD_DEBUG_TRACE("ethdev port_id=%d nb_rx_queues=%d > %d\n",
-                               port_id, nb_rx_q, dev_info.max_rx_queues);
-               return -EINVAL;
+               RTE_ETHDEV_LOG(ERR, "Ethdev port_id=%u nb_rx_queues=%u > %u\n",
+                       port_id, nb_rx_q, dev_info.max_rx_queues);
+               ret = -EINVAL;
+               goto rollback;
        }
 
        if (nb_tx_q > dev_info.max_tx_queues) {
-               RTE_PMD_DEBUG_TRACE("ethdev port_id=%d nb_tx_queues=%d > %d\n",
-                               port_id, nb_tx_q, dev_info.max_tx_queues);
-               return -EINVAL;
+               RTE_ETHDEV_LOG(ERR, "Ethdev port_id=%u nb_tx_queues=%u > %u\n",
+                       port_id, nb_tx_q, dev_info.max_tx_queues);
+               ret = -EINVAL;
+               goto rollback;
        }
 
        /* Check that the device supports requested interrupts */
        if ((dev_conf->intr_conf.lsc == 1) &&
-               (!(dev->data->dev_flags & RTE_ETH_DEV_INTR_LSC))) {
-                       RTE_PMD_DEBUG_TRACE("driver %s does not support lsc\n",
-                                       dev->device->driver->name);
-                       return -EINVAL;
+                       (!(dev->data->dev_flags & RTE_ETH_DEV_INTR_LSC))) {
+               RTE_ETHDEV_LOG(ERR, "Driver %s does not support lsc\n",
+                       dev->device->driver->name);
+               ret = -EINVAL;
+               goto rollback;
        }
        if ((dev_conf->intr_conf.rmv == 1) &&
-           (!(dev->data->dev_flags & RTE_ETH_DEV_INTR_RMV))) {
-               RTE_PMD_DEBUG_TRACE("driver %s does not support rmv\n",
-                                   dev->device->driver->name);
-               return -EINVAL;
+                       (!(dev->data->dev_flags & RTE_ETH_DEV_INTR_RMV))) {
+               RTE_ETHDEV_LOG(ERR, "Driver %s does not support rmv\n",
+                       dev->device->driver->name);
+               ret = -EINVAL;
+               goto rollback;
        }
 
        /*
         * If jumbo frames are enabled, check that the maximum RX packet
         * length is supported by the configured device.
         */
-       if (local_conf.rxmode.offloads & DEV_RX_OFFLOAD_JUMBO_FRAME) {
-               if (dev_conf->rxmode.max_rx_pkt_len >
-                   dev_info.max_rx_pktlen) {
-                       RTE_PMD_DEBUG_TRACE("ethdev port_id=%d max_rx_pkt_len %u"
-                               " > max valid value %u\n",
-                               port_id,
-                               (unsigned)dev_conf->rxmode.max_rx_pkt_len,
-                               (unsigned)dev_info.max_rx_pktlen);
-                       return -EINVAL;
+       if (dev_conf->rxmode.offloads & DEV_RX_OFFLOAD_JUMBO_FRAME) {
+               if (dev_conf->rxmode.max_rx_pkt_len > dev_info.max_rx_pktlen) {
+                       RTE_ETHDEV_LOG(ERR,
+                               "Ethdev port_id=%u max_rx_pkt_len %u > max valid value %u\n",
+                               port_id, dev_conf->rxmode.max_rx_pkt_len,
+                               dev_info.max_rx_pktlen);
+                       ret = -EINVAL;
+                       goto rollback;
                } else if (dev_conf->rxmode.max_rx_pkt_len < ETHER_MIN_LEN) {
-                       RTE_PMD_DEBUG_TRACE("ethdev port_id=%d max_rx_pkt_len %u"
-                               " < min valid value %u\n",
-                               port_id,
-                               (unsigned)dev_conf->rxmode.max_rx_pkt_len,
+                       RTE_ETHDEV_LOG(ERR,
+                               "Ethdev port_id=%u max_rx_pkt_len %u < min valid value %u\n",
+                               port_id, dev_conf->rxmode.max_rx_pkt_len,
                                (unsigned)ETHER_MIN_LEN);
-                       return -EINVAL;
+                       ret = -EINVAL;
+                       goto rollback;
                }
        } else {
                if (dev_conf->rxmode.max_rx_pkt_len < ETHER_MIN_LEN ||
@@ -1162,38 +1241,39 @@ rte_eth_dev_configure(uint16_t port_id, uint16_t nb_rx_q, uint16_t nb_tx_q,
        }
 
        /* Any requested offloading must be within its device capabilities */
-       if ((local_conf.rxmode.offloads & dev_info.rx_offload_capa) !=
-            local_conf.rxmode.offloads) {
-               ethdev_log(ERR, "ethdev port_id=%d requested Rx offloads "
-                               "0x%" PRIx64 " doesn't match Rx offloads "
-                               "capabilities 0x%" PRIx64 " in %s()\n",
-                               port_id,
-                               local_conf.rxmode.offloads,
-                               dev_info.rx_offload_capa,
-                               __func__);
-               /* Will return -EINVAL in the next release */
-       }
-       if ((local_conf.txmode.offloads & dev_info.tx_offload_capa) !=
-            local_conf.txmode.offloads) {
-               ethdev_log(ERR, "ethdev port_id=%d requested Tx offloads "
-                               "0x%" PRIx64 " doesn't match Tx offloads "
-                               "capabilities 0x%" PRIx64 " in %s()\n",
-                               port_id,
-                               local_conf.txmode.offloads,
-                               dev_info.tx_offload_capa,
-                               __func__);
-               /* Will return -EINVAL in the next release */
+       if ((dev_conf->rxmode.offloads & dev_info.rx_offload_capa) !=
+            dev_conf->rxmode.offloads) {
+               RTE_ETHDEV_LOG(ERR,
+                       "Ethdev port_id=%u requested Rx offloads 0x%"PRIx64" doesn't match Rx offloads "
+                       "capabilities 0x%"PRIx64" in %s()\n",
+                       port_id, dev_conf->rxmode.offloads,
+                       dev_info.rx_offload_capa,
+                       __func__);
+               ret = -EINVAL;
+               goto rollback;
+       }
+       if ((dev_conf->txmode.offloads & dev_info.tx_offload_capa) !=
+            dev_conf->txmode.offloads) {
+               RTE_ETHDEV_LOG(ERR,
+                       "Ethdev port_id=%u requested Tx offloads 0x%"PRIx64" doesn't match Tx offloads "
+                       "capabilities 0x%"PRIx64" in %s()\n",
+                       port_id, dev_conf->txmode.offloads,
+                       dev_info.tx_offload_capa,
+                       __func__);
+               ret = -EINVAL;
+               goto rollback;
        }
 
        /* Check that device supports requested rss hash functions. */
        if ((dev_info.flow_type_rss_offloads |
             dev_conf->rx_adv_conf.rss_conf.rss_hf) !=
            dev_info.flow_type_rss_offloads) {
-               RTE_PMD_DEBUG_TRACE("ethdev port_id=%d invalid rss_hf: "
-                                   "0x%"PRIx64", valid value: 0x%"PRIx64"\n",
-                                   port_id,
-                                   dev_conf->rx_adv_conf.rss_conf.rss_hf,
-                                   dev_info.flow_type_rss_offloads);
+               RTE_ETHDEV_LOG(ERR,
+                       "Ethdev port_id=%u invalid rss_hf: 0x%"PRIx64", valid value: 0x%"PRIx64"\n",
+                       port_id, dev_conf->rx_adv_conf.rss_conf.rss_hf,
+                       dev_info.flow_type_rss_offloads);
+               ret = -EINVAL;
+               goto rollback;
        }
 
        /*
@@ -1201,47 +1281,57 @@ rte_eth_dev_configure(uint16_t port_id, uint16_t nb_rx_q, uint16_t nb_tx_q,
         */
        diag = rte_eth_dev_rx_queue_config(dev, nb_rx_q);
        if (diag != 0) {
-               RTE_PMD_DEBUG_TRACE("port%d rte_eth_dev_rx_queue_config = %d\n",
-                               port_id, diag);
-               return diag;
+               RTE_ETHDEV_LOG(ERR,
+                       "Port%u rte_eth_dev_rx_queue_config = %d\n",
+                       port_id, diag);
+               ret = diag;
+               goto rollback;
        }
 
        diag = rte_eth_dev_tx_queue_config(dev, nb_tx_q);
        if (diag != 0) {
-               RTE_PMD_DEBUG_TRACE("port%d rte_eth_dev_tx_queue_config = %d\n",
-                               port_id, diag);
+               RTE_ETHDEV_LOG(ERR,
+                       "Port%u rte_eth_dev_tx_queue_config = %d\n",
+                       port_id, diag);
                rte_eth_dev_rx_queue_config(dev, 0);
-               return diag;
+               ret = diag;
+               goto rollback;
        }
 
        diag = (*dev->dev_ops->dev_configure)(dev);
        if (diag != 0) {
-               RTE_PMD_DEBUG_TRACE("port%d dev_configure = %d\n",
-                               port_id, diag);
+               RTE_ETHDEV_LOG(ERR, "Port%u dev_configure = %d\n",
+                       port_id, diag);
                rte_eth_dev_rx_queue_config(dev, 0);
                rte_eth_dev_tx_queue_config(dev, 0);
-               return eth_err(port_id, diag);
+               ret = eth_err(port_id, diag);
+               goto rollback;
        }
 
        /* Initialize Rx profiling if enabled at compilation time. */
-       diag = __rte_eth_profile_rx_init(port_id, dev);
+       diag = __rte_eth_dev_profile_init(port_id, dev);
        if (diag != 0) {
-               RTE_PMD_DEBUG_TRACE("port%d __rte_eth_profile_rx_init = %d\n",
-                               port_id, diag);
+               RTE_ETHDEV_LOG(ERR, "Port%u __rte_eth_dev_profile_init = %d\n",
+                       port_id, diag);
                rte_eth_dev_rx_queue_config(dev, 0);
                rte_eth_dev_tx_queue_config(dev, 0);
-               return eth_err(port_id, diag);
+               ret = eth_err(port_id, diag);
+               goto rollback;
        }
 
        return 0;
+
+rollback:
+       memcpy(&dev->data->dev_conf, &orig_conf, sizeof(dev->data->dev_conf));
+
+       return ret;
 }
 
 void
 _rte_eth_dev_reset(struct rte_eth_dev *dev)
 {
        if (dev->data->dev_started) {
-               RTE_PMD_DEBUG_TRACE(
-                       "port %d must be stopped to allow reset\n",
+               RTE_ETHDEV_LOG(ERR, "Port %u must be stopped to allow reset\n",
                        dev->data->port_id);
                return;
        }
@@ -1253,19 +1343,14 @@ _rte_eth_dev_reset(struct rte_eth_dev *dev)
 }
 
 static void
-rte_eth_dev_config_restore(uint16_t port_id)
+rte_eth_dev_mac_restore(struct rte_eth_dev *dev,
+                       struct rte_eth_dev_info *dev_info)
 {
-       struct rte_eth_dev *dev;
-       struct rte_eth_dev_info dev_info;
-       struct ether_addr *addr;
+       struct rte_ether_addr *addr;
        uint16_t i;
        uint32_t pool = 0;
        uint64_t pool_mask;
 
-       dev = &rte_eth_devices[port_id];
-
-       rte_eth_dev_info_get(port_id, &dev_info);
-
        /* replay MAC address configuration including default MAC */
        addr = &dev->data->mac_addrs[0];
        if (*dev->dev_ops->mac_addr_set != NULL)
@@ -1274,7 +1359,7 @@ rte_eth_dev_config_restore(uint16_t port_id)
                (*dev->dev_ops->mac_addr_add)(dev, addr, 0, pool);
 
        if (*dev->dev_ops->mac_addr_add != NULL) {
-               for (i = 1; i < dev_info.max_mac_addrs; i++) {
+               for (i = 1; i < dev_info->max_mac_addrs; i++) {
                        addr = &dev->data->mac_addrs[i];
 
                        /* skip zero address */
@@ -1293,6 +1378,14 @@ rte_eth_dev_config_restore(uint16_t port_id)
                        } while (pool_mask);
                }
        }
+}
+
+static void
+rte_eth_dev_config_restore(struct rte_eth_dev *dev,
+                          struct rte_eth_dev_info *dev_info, uint16_t port_id)
+{
+       if (!(*dev_info->dev_flags & RTE_ETH_DEV_NOLIVE_MAC_ADDR))
+               rte_eth_dev_mac_restore(dev, dev_info);
 
        /* replay promiscuous configuration */
        if (rte_eth_promiscuous_get(port_id) == 1)
@@ -1311,6 +1404,7 @@ int
 rte_eth_dev_start(uint16_t port_id)
 {
        struct rte_eth_dev *dev;
+       struct rte_eth_dev_info dev_info;
        int diag;
 
        RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -EINVAL);
@@ -1320,19 +1414,25 @@ rte_eth_dev_start(uint16_t port_id)
        RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->dev_start, -ENOTSUP);
 
        if (dev->data->dev_started != 0) {
-               RTE_PMD_DEBUG_TRACE("Device with port_id=%" PRIu16
-                       " already started\n",
+               RTE_ETHDEV_LOG(INFO,
+                       "Device with port_id=%"PRIu16" already started\n",
                        port_id);
                return 0;
        }
 
+       rte_eth_dev_info_get(port_id, &dev_info);
+
+       /* Lets restore MAC now if device does not support live change */
+       if (*dev_info.dev_flags & RTE_ETH_DEV_NOLIVE_MAC_ADDR)
+               rte_eth_dev_mac_restore(dev, &dev_info);
+
        diag = (*dev->dev_ops->dev_start)(dev);
        if (diag == 0)
                dev->data->dev_started = 1;
        else
                return eth_err(port_id, diag);
 
-       rte_eth_dev_config_restore(port_id);
+       rte_eth_dev_config_restore(dev, &dev_info, port_id);
 
        if (dev->data->dev_conf.intr_conf.lsc == 0) {
                RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->link_update, -ENOTSUP);
@@ -1352,8 +1452,8 @@ rte_eth_dev_stop(uint16_t port_id)
        RTE_FUNC_PTR_OR_RET(*dev->dev_ops->dev_stop);
 
        if (dev->data->dev_started == 0) {
-               RTE_PMD_DEBUG_TRACE("Device with port_id=%" PRIu16
-                       " already stopped\n",
+               RTE_ETHDEV_LOG(INFO,
+                       "Device with port_id=%"PRIu16" already stopped\n",
                        port_id);
                return;
        }
@@ -1400,6 +1500,16 @@ rte_eth_dev_close(uint16_t port_id)
        dev->data->dev_started = 0;
        (*dev->dev_ops->dev_close)(dev);
 
+       /* check behaviour flag - temporary for PMD migration */
+       if ((dev->data->dev_flags & RTE_ETH_DEV_CLOSE_REMOVE) != 0) {
+               /* new behaviour: send event + reset state + free all data */
+               rte_eth_dev_release_port(dev);
+               return;
+       }
+       RTE_ETHDEV_LOG(DEBUG, "Port closing is using an old behaviour.\n"
+                       "The driver %s should migrate to the new behaviour.\n",
+                       dev->device->driver->name);
+       /* old behaviour: only free queue arrays */
        dev->data->nb_rx_queues = 0;
        rte_free(dev->data->rx_queues);
        dev->data->rx_queues = NULL;
@@ -1465,7 +1575,7 @@ rte_eth_rx_queue_setup(uint16_t port_id, uint16_t rx_queue_id,
 
        dev = &rte_eth_devices[port_id];
        if (rx_queue_id >= dev->data->nb_rx_queues) {
-               RTE_PMD_DEBUG_TRACE("Invalid RX queue_id=%d\n", rx_queue_id);
+               RTE_ETHDEV_LOG(ERR, "Invalid RX queue_id=%u\n", rx_queue_id);
                return -EINVAL;
        }
 
@@ -1479,23 +1589,20 @@ rte_eth_rx_queue_setup(uint16_t port_id, uint16_t rx_queue_id,
         */
        rte_eth_dev_info_get(port_id, &dev_info);
        if (mp->private_data_size < sizeof(struct rte_pktmbuf_pool_private)) {
-               RTE_PMD_DEBUG_TRACE("%s private_data_size %d < %d\n",
-                               mp->name, (int) mp->private_data_size,
-                               (int) sizeof(struct rte_pktmbuf_pool_private));
+               RTE_ETHDEV_LOG(ERR, "%s private_data_size %d < %d\n",
+                       mp->name, (int)mp->private_data_size,
+                       (int)sizeof(struct rte_pktmbuf_pool_private));
                return -ENOSPC;
        }
        mbp_buf_size = rte_pktmbuf_data_room_size(mp);
 
        if ((mbp_buf_size - RTE_PKTMBUF_HEADROOM) < dev_info.min_rx_bufsize) {
-               RTE_PMD_DEBUG_TRACE("%s mbuf_data_room_size %d < %d "
-                               "(RTE_PKTMBUF_HEADROOM=%d + min_rx_bufsize(dev)"
-                               "=%d)\n",
-                               mp->name,
-                               (int)mbp_buf_size,
-                               (int)(RTE_PKTMBUF_HEADROOM +
-                                     dev_info.min_rx_bufsize),
-                               (int)RTE_PKTMBUF_HEADROOM,
-                               (int)dev_info.min_rx_bufsize);
+               RTE_ETHDEV_LOG(ERR,
+                       "%s mbuf_data_room_size %d < %d (RTE_PKTMBUF_HEADROOM=%d + min_rx_bufsize(dev)=%d)\n",
+                       mp->name, (int)mbp_buf_size,
+                       (int)(RTE_PKTMBUF_HEADROOM + dev_info.min_rx_bufsize),
+                       (int)RTE_PKTMBUF_HEADROOM,
+                       (int)dev_info.min_rx_bufsize);
                return -EINVAL;
        }
 
@@ -1511,10 +1618,9 @@ rte_eth_rx_queue_setup(uint16_t port_id, uint16_t rx_queue_id,
                        nb_rx_desc < dev_info.rx_desc_lim.nb_min ||
                        nb_rx_desc % dev_info.rx_desc_lim.nb_align != 0) {
 
-               RTE_PMD_DEBUG_TRACE("Invalid value for nb_rx_desc(=%hu), "
-                       "should be: <= %hu, = %hu, and a product of %hu\n",
-                       nb_rx_desc,
-                       dev_info.rx_desc_lim.nb_max,
+               RTE_ETHDEV_LOG(ERR,
+                       "Invalid value for nb_rx_desc(=%hu), should be: <= %hu, >= %hu, and a product of %hu\n",
+                       nb_rx_desc, dev_info.rx_desc_lim.nb_max,
                        dev_info.rx_desc_lim.nb_min,
                        dev_info.rx_desc_lim.nb_align);
                return -EINVAL;
@@ -1525,8 +1631,9 @@ rte_eth_rx_queue_setup(uint16_t port_id, uint16_t rx_queue_id,
                        RTE_ETH_DEV_CAPA_RUNTIME_RX_QUEUE_SETUP))
                return -EBUSY;
 
-       if (dev->data->rx_queue_state[rx_queue_id] !=
-               RTE_ETH_QUEUE_STATE_STOPPED)
+       if (dev->data->dev_started &&
+               (dev->data->rx_queue_state[rx_queue_id] !=
+                       RTE_ETH_QUEUE_STATE_STOPPED))
                return -EBUSY;
 
        rxq = dev->data->rx_queues;
@@ -1541,14 +1648,6 @@ rte_eth_rx_queue_setup(uint16_t port_id, uint16_t rx_queue_id,
                rx_conf = &dev_info.default_rxconf;
 
        local_conf = *rx_conf;
-       if (dev->data->dev_conf.rxmode.ignore_offload_bitfield == 0) {
-               /**
-                * Reflect port offloads to queue offloads in order for
-                * offloads to not be discarded.
-                */
-               rte_eth_convert_rx_offload_bitfield(&dev->data->dev_conf.rxmode,
-                                                   &local_conf.offloads);
-       }
 
        /*
         * If an offloading has already been enabled in
@@ -1570,16 +1669,13 @@ rte_eth_rx_queue_setup(uint16_t port_id, uint16_t rx_queue_id,
         */
        if ((local_conf.offloads & dev_info.rx_queue_offload_capa) !=
             local_conf.offloads) {
-               ethdev_log(ERR, "Ethdev port_id=%d rx_queue_id=%d, new "
-                               "added offloads 0x%" PRIx64 " must be "
-                               "within pre-queue offload capabilities 0x%"
-                               PRIx64 " in %s()\n",
-                               port_id,
-                               rx_queue_id,
-                               local_conf.offloads,
-                               dev_info.rx_queue_offload_capa,
-                               __func__);
-               /* Will return -EINVAL in the next release */
+               RTE_ETHDEV_LOG(ERR,
+                       "Ethdev port_id=%d rx_queue_id=%d, new added offloads 0x%"PRIx64" must be "
+                       "within per-queue offload capabilities 0x%"PRIx64" in %s()\n",
+                       port_id, rx_queue_id, local_conf.offloads,
+                       dev_info.rx_queue_offload_capa,
+                       __func__);
+               return -EINVAL;
        }
 
        ret = (*dev->dev_ops->rx_queue_setup)(dev, rx_queue_id, nb_rx_desc,
@@ -1593,55 +1689,6 @@ rte_eth_rx_queue_setup(uint16_t port_id, uint16_t rx_queue_id,
        return eth_err(port_id, ret);
 }
 
-/**
- * Convert from tx offloads to txq_flags.
- */
-static void
-rte_eth_convert_tx_offload(const uint64_t tx_offloads, uint32_t *txq_flags)
-{
-       uint32_t flags = 0;
-
-       if (!(tx_offloads & DEV_TX_OFFLOAD_MULTI_SEGS))
-               flags |= ETH_TXQ_FLAGS_NOMULTSEGS;
-       if (!(tx_offloads & DEV_TX_OFFLOAD_VLAN_INSERT))
-               flags |= ETH_TXQ_FLAGS_NOVLANOFFL;
-       if (!(tx_offloads & DEV_TX_OFFLOAD_SCTP_CKSUM))
-               flags |= ETH_TXQ_FLAGS_NOXSUMSCTP;
-       if (!(tx_offloads & DEV_TX_OFFLOAD_UDP_CKSUM))
-               flags |= ETH_TXQ_FLAGS_NOXSUMUDP;
-       if (!(tx_offloads & DEV_TX_OFFLOAD_TCP_CKSUM))
-               flags |= ETH_TXQ_FLAGS_NOXSUMTCP;
-       if (tx_offloads & DEV_TX_OFFLOAD_MBUF_FAST_FREE)
-               flags |= ETH_TXQ_FLAGS_NOREFCOUNT | ETH_TXQ_FLAGS_NOMULTMEMP;
-
-       *txq_flags = flags;
-}
-
-/**
- * A conversion function from txq_flags API.
- */
-static void
-rte_eth_convert_txq_flags(const uint32_t txq_flags, uint64_t *tx_offloads)
-{
-       uint64_t offloads = 0;
-
-       if (!(txq_flags & ETH_TXQ_FLAGS_NOMULTSEGS))
-               offloads |= DEV_TX_OFFLOAD_MULTI_SEGS;
-       if (!(txq_flags & ETH_TXQ_FLAGS_NOVLANOFFL))
-               offloads |= DEV_TX_OFFLOAD_VLAN_INSERT;
-       if (!(txq_flags & ETH_TXQ_FLAGS_NOXSUMSCTP))
-               offloads |= DEV_TX_OFFLOAD_SCTP_CKSUM;
-       if (!(txq_flags & ETH_TXQ_FLAGS_NOXSUMUDP))
-               offloads |= DEV_TX_OFFLOAD_UDP_CKSUM;
-       if (!(txq_flags & ETH_TXQ_FLAGS_NOXSUMTCP))
-               offloads |= DEV_TX_OFFLOAD_TCP_CKSUM;
-       if ((txq_flags & ETH_TXQ_FLAGS_NOREFCOUNT) &&
-           (txq_flags & ETH_TXQ_FLAGS_NOMULTMEMP))
-               offloads |= DEV_TX_OFFLOAD_MBUF_FAST_FREE;
-
-       *tx_offloads = offloads;
-}
-
 int
 rte_eth_tx_queue_setup(uint16_t port_id, uint16_t tx_queue_id,
                       uint16_t nb_tx_desc, unsigned int socket_id,
@@ -1656,7 +1703,7 @@ rte_eth_tx_queue_setup(uint16_t port_id, uint16_t tx_queue_id,
 
        dev = &rte_eth_devices[port_id];
        if (tx_queue_id >= dev->data->nb_tx_queues) {
-               RTE_PMD_DEBUG_TRACE("Invalid TX queue_id=%d\n", tx_queue_id);
+               RTE_ETHDEV_LOG(ERR, "Invalid TX queue_id=%u\n", tx_queue_id);
                return -EINVAL;
        }
 
@@ -1675,12 +1722,11 @@ rte_eth_tx_queue_setup(uint16_t port_id, uint16_t tx_queue_id,
        if (nb_tx_desc > dev_info.tx_desc_lim.nb_max ||
            nb_tx_desc < dev_info.tx_desc_lim.nb_min ||
            nb_tx_desc % dev_info.tx_desc_lim.nb_align != 0) {
-               RTE_PMD_DEBUG_TRACE("Invalid value for nb_tx_desc(=%hu), "
-                               "should be: <= %hu, = %hu, and a product of %hu\n",
-                               nb_tx_desc,
-                               dev_info.tx_desc_lim.nb_max,
-                               dev_info.tx_desc_lim.nb_min,
-                               dev_info.tx_desc_lim.nb_align);
+               RTE_ETHDEV_LOG(ERR,
+                       "Invalid value for nb_tx_desc(=%hu), should be: <= %hu, >= %hu, and a product of %hu\n",
+                       nb_tx_desc, dev_info.tx_desc_lim.nb_max,
+                       dev_info.tx_desc_lim.nb_min,
+                       dev_info.tx_desc_lim.nb_align);
                return -EINVAL;
        }
 
@@ -1689,8 +1735,9 @@ rte_eth_tx_queue_setup(uint16_t port_id, uint16_t tx_queue_id,
                        RTE_ETH_DEV_CAPA_RUNTIME_TX_QUEUE_SETUP))
                return -EBUSY;
 
-       if (dev->data->tx_queue_state[tx_queue_id] !=
-               RTE_ETH_QUEUE_STATE_STOPPED)
+       if (dev->data->dev_started &&
+               (dev->data->tx_queue_state[tx_queue_id] !=
+                       RTE_ETH_QUEUE_STATE_STOPPED))
                return -EBUSY;
 
        txq = dev->data->tx_queues;
@@ -1704,15 +1751,7 @@ rte_eth_tx_queue_setup(uint16_t port_id, uint16_t tx_queue_id,
        if (tx_conf == NULL)
                tx_conf = &dev_info.default_txconf;
 
-       /*
-        * Convert between the offloads API to enable PMDs to support
-        * only one of them.
-        */
        local_conf = *tx_conf;
-       if (!(tx_conf->txq_flags & ETH_TXQ_FLAGS_IGNORE)) {
-               rte_eth_convert_txq_flags(tx_conf->txq_flags,
-                                         &local_conf.offloads);
-       }
 
        /*
         * If an offloading has already been enabled in
@@ -1734,16 +1773,13 @@ rte_eth_tx_queue_setup(uint16_t port_id, uint16_t tx_queue_id,
         */
        if ((local_conf.offloads & dev_info.tx_queue_offload_capa) !=
             local_conf.offloads) {
-               ethdev_log(ERR, "Ethdev port_id=%d tx_queue_id=%d, new "
-                               "added offloads 0x%" PRIx64 " must be "
-                               "within pre-queue offload capabilities 0x%"
-                               PRIx64 " in %s()\n",
-                               port_id,
-                               tx_queue_id,
-                               local_conf.offloads,
-                               dev_info.tx_queue_offload_capa,
-                               __func__);
-               /* Will return -EINVAL in the next release */
+               RTE_ETHDEV_LOG(ERR,
+                       "Ethdev port_id=%d tx_queue_id=%d, new added offloads 0x%"PRIx64" must be "
+                       "within per-queue offload capabilities 0x%"PRIx64" in %s()\n",
+                       port_id, tx_queue_id, local_conf.offloads,
+                       dev_info.tx_queue_offload_capa,
+                       __func__);
+               return -EINVAL;
        }
 
        return eth_err(port_id, (*dev->dev_ops->tx_queue_setup)(dev,
@@ -2007,19 +2043,19 @@ rte_eth_xstats_get_id_by_name(uint16_t port_id, const char *xstat_name,
        RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV);
 
        if (!id) {
-               RTE_PMD_DEBUG_TRACE("Error: id pointer is NULL\n");
+               RTE_ETHDEV_LOG(ERR, "Id pointer is NULL\n");
                return -ENOMEM;
        }
 
        if (!xstat_name) {
-               RTE_PMD_DEBUG_TRACE("Error: xstat_name pointer is NULL\n");
+               RTE_ETHDEV_LOG(ERR, "xstat_name pointer is NULL\n");
                return -ENOMEM;
        }
 
        /* Get count */
        cnt_xstats = rte_eth_xstats_get_names_by_id(port_id, NULL, 0, NULL);
        if (cnt_xstats  < 0) {
-               RTE_PMD_DEBUG_TRACE("Error: Cannot get count of xstats\n");
+               RTE_ETHDEV_LOG(ERR, "Cannot get count of xstats\n");
                return -ENODEV;
        }
 
@@ -2028,7 +2064,7 @@ rte_eth_xstats_get_id_by_name(uint16_t port_id, const char *xstat_name,
 
        if (cnt_xstats != rte_eth_xstats_get_names_by_id(
                        port_id, xstats_names, cnt_xstats, NULL)) {
-               RTE_PMD_DEBUG_TRACE("Error: Cannot get xstats lookup\n");
+               RTE_ETHDEV_LOG(ERR, "Cannot get xstats lookup\n");
                return -1;
        }
 
@@ -2052,9 +2088,9 @@ rte_eth_basic_stats_get_names(struct rte_eth_dev *dev,
        uint16_t num_q;
 
        for (idx = 0; idx < RTE_NB_STATS; idx++) {
-               snprintf(xstats_names[cnt_used_entries].name,
-                       sizeof(xstats_names[0].name),
-                       "%s", rte_stats_strings[idx].name);
+               strlcpy(xstats_names[cnt_used_entries].name,
+                       rte_stats_strings[idx].name,
+                       sizeof(xstats_names[0].name));
                cnt_used_entries++;
        }
        num_q = RTE_MIN(dev->data->nb_rx_queues, RTE_ETHDEV_QUEUE_STAT_CNTRS);
@@ -2151,7 +2187,7 @@ rte_eth_xstats_get_names_by_id(uint16_t port_id,
                sizeof(struct rte_eth_xstat_name));
 
        if (!xstats_names_copy) {
-               RTE_PMD_DEBUG_TRACE("ERROR: can't allocate memory");
+               RTE_ETHDEV_LOG(ERR, "Can't allocate memory\n");
                return -ENOMEM;
        }
 
@@ -2179,7 +2215,7 @@ rte_eth_xstats_get_names_by_id(uint16_t port_id,
        /* Filter stats */
        for (i = 0; i < size; i++) {
                if (ids[i] >= expected_entries) {
-                       RTE_PMD_DEBUG_TRACE("ERROR: id value isn't valid\n");
+                       RTE_ETHDEV_LOG(ERR, "Id value isn't valid\n");
                        free(xstats_names_copy);
                        return -1;
                }
@@ -2364,7 +2400,7 @@ rte_eth_xstats_get_by_id(uint16_t port_id, const uint64_t *ids,
        /* Filter stats */
        for (i = 0; i < size; i++) {
                if (ids[i] >= expected_entries) {
-                       RTE_PMD_DEBUG_TRACE("ERROR: id value isn't valid\n");
+                       RTE_ETHDEV_LOG(ERR, "Id value isn't valid\n");
                        return -1;
                }
                values[i] = xstats[ids[i]].value;
@@ -2454,6 +2490,16 @@ set_queue_stats_mapping(uint16_t port_id, uint16_t queue_id, uint8_t stat_idx,
        dev = &rte_eth_devices[port_id];
 
        RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->queue_stats_mapping_set, -ENOTSUP);
+
+       if (is_rx && (queue_id >= dev->data->nb_rx_queues))
+               return -EINVAL;
+
+       if (!is_rx && (queue_id >= dev->data->nb_tx_queues))
+               return -EINVAL;
+
+       if (stat_idx >= RTE_ETHDEV_QUEUE_STAT_CNTRS)
+               return -EINVAL;
+
        return (*dev->dev_ops->queue_stats_mapping_set)
                        (dev, queue_id, stat_idx, is_rx);
 }
@@ -2493,7 +2539,6 @@ void
 rte_eth_dev_info_get(uint16_t port_id, struct rte_eth_dev_info *dev_info)
 {
        struct rte_eth_dev *dev;
-       struct rte_eth_txconf *txconf;
        const struct rte_eth_desc_lim lim = {
                .nb_max = UINT16_MAX,
                .nb_min = 0,
@@ -2507,6 +2552,8 @@ rte_eth_dev_info_get(uint16_t port_id, struct rte_eth_dev_info *dev_info)
        dev_info->rx_desc_lim = lim;
        dev_info->tx_desc_lim = lim;
        dev_info->device = dev->device;
+       dev_info->min_mtu = ETHER_MIN_MTU;
+       dev_info->max_mtu = UINT16_MAX;
 
        RTE_FUNC_PTR_OR_RET(*dev->dev_ops->dev_infos_get);
        (*dev->dev_ops->dev_infos_get)(dev, dev_info);
@@ -2515,9 +2562,6 @@ rte_eth_dev_info_get(uint16_t port_id, struct rte_eth_dev_info *dev_info)
        dev_info->nb_tx_queues = dev->data->nb_tx_queues;
 
        dev_info->dev_flags = &dev->data->dev_flags;
-       txconf = &dev_info->default_txconf;
-       /* convert offload to txq_flags to support legacy app */
-       rte_eth_convert_tx_offload(txconf->offloads, &txconf->txq_flags);
 }
 
 int
@@ -2547,7 +2591,7 @@ rte_eth_dev_get_supported_ptypes(uint16_t port_id, uint32_t ptype_mask,
 }
 
 void
-rte_eth_macaddr_get(uint16_t port_id, struct ether_addr *mac_addr)
+rte_eth_macaddr_get(uint16_t port_id, struct rte_ether_addr *mac_addr)
 {
        struct rte_eth_dev *dev;
 
@@ -2573,12 +2617,25 @@ int
 rte_eth_dev_set_mtu(uint16_t port_id, uint16_t mtu)
 {
        int ret;
+       struct rte_eth_dev_info dev_info;
        struct rte_eth_dev *dev;
 
        RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV);
        dev = &rte_eth_devices[port_id];
        RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->mtu_set, -ENOTSUP);
 
+       /*
+        * Check if the device supports dev_infos_get, if it does not
+        * skip min_mtu/max_mtu validation here as this requires values
+        * that are populated within the call to rte_eth_dev_info_get()
+        * which relies on dev->dev_ops->dev_infos_get.
+        */
+       if (*dev->dev_ops->dev_infos_get != NULL) {
+               rte_eth_dev_info_get(port_id, &dev_info);
+               if (mtu < dev_info.min_mtu || mtu > dev_info.max_mtu)
+                       return -EINVAL;
+       }
+
        ret = (*dev->dev_ops->mtu_set)(dev, mtu);
        if (!ret)
                dev->data->mtu = mtu;
@@ -2596,13 +2653,14 @@ rte_eth_dev_vlan_filter(uint16_t port_id, uint16_t vlan_id, int on)
        dev = &rte_eth_devices[port_id];
        if (!(dev->data->dev_conf.rxmode.offloads &
              DEV_RX_OFFLOAD_VLAN_FILTER)) {
-               RTE_PMD_DEBUG_TRACE("port %d: vlan-filtering disabled\n", port_id);
+               RTE_ETHDEV_LOG(ERR, "Port %u: vlan-filtering disabled\n",
+                       port_id);
                return -ENOSYS;
        }
 
        if (vlan_id > 4095) {
-               RTE_PMD_DEBUG_TRACE("(port_id=%d) invalid vlan_id=%u > 4095\n",
-                               port_id, (unsigned) vlan_id);
+               RTE_ETHDEV_LOG(ERR, "Port_id=%u invalid vlan_id=%u > 4095\n",
+                       port_id, vlan_id);
                return -EINVAL;
        }
        RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->vlan_filter_set, -ENOTSUP);
@@ -2635,7 +2693,7 @@ rte_eth_dev_set_vlan_strip_on_queue(uint16_t port_id, uint16_t rx_queue_id,
        RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV);
        dev = &rte_eth_devices[port_id];
        if (rx_queue_id >= dev->data->nb_rx_queues) {
-               RTE_PMD_DEBUG_TRACE("Invalid rx_queue_id=%d\n", port_id);
+               RTE_ETHDEV_LOG(ERR, "Invalid rx_queue_id=%u\n", rx_queue_id);
                return -EINVAL;
        }
 
@@ -2784,7 +2842,7 @@ rte_eth_dev_flow_ctrl_set(uint16_t port_id, struct rte_eth_fc_conf *fc_conf)
 
        RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV);
        if ((fc_conf->send_xon != 0) && (fc_conf->send_xon != 1)) {
-               RTE_PMD_DEBUG_TRACE("Invalid send_xon, only 0/1 allowed\n");
+               RTE_ETHDEV_LOG(ERR, "Invalid send_xon, only 0/1 allowed\n");
                return -EINVAL;
        }
 
@@ -2801,7 +2859,7 @@ rte_eth_dev_priority_flow_ctrl_set(uint16_t port_id,
 
        RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV);
        if (pfc_conf->priority > (ETH_DCB_NUM_USER_PRIORITIES - 1)) {
-               RTE_PMD_DEBUG_TRACE("Invalid priority, only 0-7 allowed\n");
+               RTE_ETHDEV_LOG(ERR, "Invalid priority, only 0-7 allowed\n");
                return -EINVAL;
        }
 
@@ -2842,7 +2900,7 @@ rte_eth_check_reta_entry(struct rte_eth_rss_reta_entry64 *reta_conf,
                return -EINVAL;
 
        if (max_rxq == 0) {
-               RTE_PMD_DEBUG_TRACE("No receive queue is available\n");
+               RTE_ETHDEV_LOG(ERR, "No receive queue is available\n");
                return -EINVAL;
        }
 
@@ -2851,8 +2909,9 @@ rte_eth_check_reta_entry(struct rte_eth_rss_reta_entry64 *reta_conf,
                shift = i % RTE_RETA_GROUP_SIZE;
                if ((reta_conf[idx].mask & (1ULL << shift)) &&
                        (reta_conf[idx].reta[shift] >= max_rxq)) {
-                       RTE_PMD_DEBUG_TRACE("reta_conf[%u]->reta[%u]: %u exceeds "
-                               "the maximum rxq index: %u\n", idx, shift,
+                       RTE_ETHDEV_LOG(ERR,
+                               "reta_conf[%u]->reta[%u]: %u exceeds the maximum rxq index: %u\n",
+                               idx, shift,
                                reta_conf[idx].reta[shift], max_rxq);
                        return -EINVAL;
                }
@@ -2921,11 +2980,11 @@ rte_eth_dev_rss_hash_update(uint16_t port_id,
        rte_eth_dev_info_get(port_id, &dev_info);
        if ((dev_info.flow_type_rss_offloads | rss_conf->rss_hf) !=
            dev_info.flow_type_rss_offloads) {
-               RTE_PMD_DEBUG_TRACE("ethdev port_id=%d invalid rss_hf: "
-                                   "0x%"PRIx64", valid value: 0x%"PRIx64"\n",
-                                   port_id,
-                                   rss_conf->rss_hf,
-                                   dev_info.flow_type_rss_offloads);
+               RTE_ETHDEV_LOG(ERR,
+                       "Ethdev port_id=%u invalid rss_hf: 0x%"PRIx64", valid value: 0x%"PRIx64"\n",
+                       port_id, rss_conf->rss_hf,
+                       dev_info.flow_type_rss_offloads);
+               return -EINVAL;
        }
        RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->rss_hash_update, -ENOTSUP);
        return eth_err(port_id, (*dev->dev_ops->rss_hash_update)(dev,
@@ -2953,12 +3012,12 @@ rte_eth_dev_udp_tunnel_port_add(uint16_t port_id,
 
        RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV);
        if (udp_tunnel == NULL) {
-               RTE_PMD_DEBUG_TRACE("Invalid udp_tunnel parameter\n");
+               RTE_ETHDEV_LOG(ERR, "Invalid udp_tunnel parameter\n");
                return -EINVAL;
        }
 
        if (udp_tunnel->prot_type >= RTE_TUNNEL_TYPE_MAX) {
-               RTE_PMD_DEBUG_TRACE("Invalid tunnel type\n");
+               RTE_ETHDEV_LOG(ERR, "Invalid tunnel type\n");
                return -EINVAL;
        }
 
@@ -2978,12 +3037,12 @@ rte_eth_dev_udp_tunnel_port_delete(uint16_t port_id,
        dev = &rte_eth_devices[port_id];
 
        if (udp_tunnel == NULL) {
-               RTE_PMD_DEBUG_TRACE("Invalid udp_tunnel parameter\n");
+               RTE_ETHDEV_LOG(ERR, "Invalid udp_tunnel parameter\n");
                return -EINVAL;
        }
 
        if (udp_tunnel->prot_type >= RTE_TUNNEL_TYPE_MAX) {
-               RTE_PMD_DEBUG_TRACE("Invalid tunnel type\n");
+               RTE_ETHDEV_LOG(ERR, "Invalid tunnel type\n");
                return -EINVAL;
        }
 
@@ -3019,7 +3078,7 @@ rte_eth_led_off(uint16_t port_id)
  * an empty spot.
  */
 static int
-get_mac_addr_index(uint16_t port_id, const struct ether_addr *addr)
+get_mac_addr_index(uint16_t port_id, const struct rte_ether_addr *addr)
 {
        struct rte_eth_dev_info dev_info;
        struct rte_eth_dev *dev = &rte_eth_devices[port_id];
@@ -3035,10 +3094,10 @@ get_mac_addr_index(uint16_t port_id, const struct ether_addr *addr)
        return -1;
 }
 
-static const struct ether_addr null_mac_addr;
+static const struct rte_ether_addr null_mac_addr;
 
 int
-rte_eth_dev_mac_addr_add(uint16_t port_id, struct ether_addr *addr,
+rte_eth_dev_mac_addr_add(uint16_t port_id, struct rte_ether_addr *addr,
                        uint32_t pool)
 {
        struct rte_eth_dev *dev;
@@ -3051,12 +3110,12 @@ rte_eth_dev_mac_addr_add(uint16_t port_id, struct ether_addr *addr,
        RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->mac_addr_add, -ENOTSUP);
 
        if (is_zero_ether_addr(addr)) {
-               RTE_PMD_DEBUG_TRACE("port %d: Cannot add NULL MAC address\n",
+               RTE_ETHDEV_LOG(ERR, "Port %u: Cannot add NULL MAC address\n",
                        port_id);
                return -EINVAL;
        }
        if (pool >= ETH_64_POOLS) {
-               RTE_PMD_DEBUG_TRACE("pool id must be 0-%d\n", ETH_64_POOLS - 1);
+               RTE_ETHDEV_LOG(ERR, "Pool id must be 0-%d\n", ETH_64_POOLS - 1);
                return -EINVAL;
        }
 
@@ -3064,7 +3123,7 @@ rte_eth_dev_mac_addr_add(uint16_t port_id, struct ether_addr *addr,
        if (index < 0) {
                index = get_mac_addr_index(port_id, &null_mac_addr);
                if (index < 0) {
-                       RTE_PMD_DEBUG_TRACE("port %d: MAC address array full\n",
+                       RTE_ETHDEV_LOG(ERR, "Port %u: MAC address array full\n",
                                port_id);
                        return -ENOSPC;
                }
@@ -3091,7 +3150,7 @@ rte_eth_dev_mac_addr_add(uint16_t port_id, struct ether_addr *addr,
 }
 
 int
-rte_eth_dev_mac_addr_remove(uint16_t port_id, struct ether_addr *addr)
+rte_eth_dev_mac_addr_remove(uint16_t port_id, struct rte_ether_addr *addr)
 {
        struct rte_eth_dev *dev;
        int index;
@@ -3102,7 +3161,9 @@ rte_eth_dev_mac_addr_remove(uint16_t port_id, struct ether_addr *addr)
 
        index = get_mac_addr_index(port_id, addr);
        if (index == 0) {
-               RTE_PMD_DEBUG_TRACE("port %d: Cannot remove default MAC address\n", port_id);
+               RTE_ETHDEV_LOG(ERR,
+                       "Port %u: Cannot remove default MAC address\n",
+                       port_id);
                return -EADDRINUSE;
        } else if (index < 0)
                return 0;  /* Do nothing if address wasn't found */
@@ -3120,7 +3181,7 @@ rte_eth_dev_mac_addr_remove(uint16_t port_id, struct ether_addr *addr)
 }
 
 int
-rte_eth_dev_default_mac_addr_set(uint16_t port_id, struct ether_addr *addr)
+rte_eth_dev_default_mac_addr_set(uint16_t port_id, struct rte_ether_addr *addr)
 {
        struct rte_eth_dev *dev;
        int ret;
@@ -3149,7 +3210,7 @@ rte_eth_dev_default_mac_addr_set(uint16_t port_id, struct ether_addr *addr)
  * an empty spot.
  */
 static int
-get_hash_mac_addr_index(uint16_t port_id, const struct ether_addr *addr)
+get_hash_mac_addr_index(uint16_t port_id, const struct rte_ether_addr *addr)
 {
        struct rte_eth_dev_info dev_info;
        struct rte_eth_dev *dev = &rte_eth_devices[port_id];
@@ -3168,7 +3229,7 @@ get_hash_mac_addr_index(uint16_t port_id, const struct ether_addr *addr)
 }
 
 int
-rte_eth_dev_uc_hash_table_set(uint16_t port_id, struct ether_addr *addr,
+rte_eth_dev_uc_hash_table_set(uint16_t port_id, struct rte_ether_addr *addr,
                                uint8_t on)
 {
        int index;
@@ -3179,7 +3240,7 @@ rte_eth_dev_uc_hash_table_set(uint16_t port_id, struct ether_addr *addr,
 
        dev = &rte_eth_devices[port_id];
        if (is_zero_ether_addr(addr)) {
-               RTE_PMD_DEBUG_TRACE("port %d: Cannot add NULL MAC address\n",
+               RTE_ETHDEV_LOG(ERR, "Port %u: Cannot add NULL MAC address\n",
                        port_id);
                return -EINVAL;
        }
@@ -3191,15 +3252,16 @@ rte_eth_dev_uc_hash_table_set(uint16_t port_id, struct ether_addr *addr,
 
        if (index < 0) {
                if (!on) {
-                       RTE_PMD_DEBUG_TRACE("port %d: the MAC address was not "
-                               "set in UTA\n", port_id);
+                       RTE_ETHDEV_LOG(ERR,
+                               "Port %u: the MAC address was not set in UTA\n",
+                               port_id);
                        return -EINVAL;
                }
 
                index = get_hash_mac_addr_index(port_id, &null_mac_addr);
                if (index < 0) {
-                       RTE_PMD_DEBUG_TRACE("port %d: MAC address array full\n",
-                                       port_id);
+                       RTE_ETHDEV_LOG(ERR, "Port %u: MAC address array full\n",
+                               port_id);
                        return -ENOSPC;
                }
        }
@@ -3247,14 +3309,15 @@ int rte_eth_set_queue_rate_limit(uint16_t port_id, uint16_t queue_idx,
        link = dev->data->dev_link;
 
        if (queue_idx > dev_info.max_tx_queues) {
-               RTE_PMD_DEBUG_TRACE("set queue rate limit:port %d: "
-                               "invalid queue id=%d\n", port_id, queue_idx);
+               RTE_ETHDEV_LOG(ERR,
+                       "Set queue rate limit:port %u: invalid queue id=%u\n",
+                       port_id, queue_idx);
                return -EINVAL;
        }
 
        if (tx_rate > link.link_speed) {
-               RTE_PMD_DEBUG_TRACE("set queue rate limit:invalid tx_rate=%d, "
-                               "bigger than link speed= %d\n",
+               RTE_ETHDEV_LOG(ERR,
+                       "Set queue rate limit:invalid tx_rate=%u, bigger than link speed= %d\n",
                        tx_rate, link.link_speed);
                return -EINVAL;
        }
@@ -3273,26 +3336,28 @@ rte_eth_mirror_rule_set(uint16_t port_id,
 
        RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV);
        if (mirror_conf->rule_type == 0) {
-               RTE_PMD_DEBUG_TRACE("mirror rule type can not be 0.\n");
+               RTE_ETHDEV_LOG(ERR, "Mirror rule type can not be 0\n");
                return -EINVAL;
        }
 
        if (mirror_conf->dst_pool >= ETH_64_POOLS) {
-               RTE_PMD_DEBUG_TRACE("Invalid dst pool, pool id must be 0-%d\n",
-                               ETH_64_POOLS - 1);
+               RTE_ETHDEV_LOG(ERR, "Invalid dst pool, pool id must be 0-%d\n",
+                       ETH_64_POOLS - 1);
                return -EINVAL;
        }
 
        if ((mirror_conf->rule_type & (ETH_MIRROR_VIRTUAL_POOL_UP |
             ETH_MIRROR_VIRTUAL_POOL_DOWN)) &&
            (mirror_conf->pool_mask == 0)) {
-               RTE_PMD_DEBUG_TRACE("Invalid mirror pool, pool mask can not be 0.\n");
+               RTE_ETHDEV_LOG(ERR,
+                       "Invalid mirror pool, pool mask can not be 0\n");
                return -EINVAL;
        }
 
        if ((mirror_conf->rule_type & ETH_MIRROR_VLAN) &&
            mirror_conf->vlan.vlan_mask == 0) {
-               RTE_PMD_DEBUG_TRACE("Invalid vlan mask, vlan mask can not be 0.\n");
+               RTE_ETHDEV_LOG(ERR,
+                       "Invalid vlan mask, vlan mask can not be 0\n");
                return -EINVAL;
        }
 
@@ -3339,7 +3404,7 @@ rte_eth_dev_callback_register(uint16_t port_id,
                return -EINVAL;
 
        if (!rte_eth_dev_is_valid_port(port_id) && port_id != RTE_ETH_ALL) {
-               ethdev_log(ERR, "Invalid port_id=%d", port_id);
+               RTE_ETHDEV_LOG(ERR, "Invalid port_id=%d\n", port_id);
                return -EINVAL;
        }
 
@@ -3402,7 +3467,7 @@ rte_eth_dev_callback_unregister(uint16_t port_id,
                return -EINVAL;
 
        if (!rte_eth_dev_is_valid_port(port_id) && port_id != RTE_ETH_ALL) {
-               ethdev_log(ERR, "Invalid port_id=%d", port_id);
+               RTE_ETHDEV_LOG(ERR, "Invalid port_id=%d\n", port_id);
                return -EINVAL;
        }
 
@@ -3496,13 +3561,13 @@ rte_eth_dev_rx_intr_ctl(uint16_t port_id, int epfd, int op, void *data)
        dev = &rte_eth_devices[port_id];
 
        if (!dev->intr_handle) {
-               RTE_PMD_DEBUG_TRACE("RX Intr handle unset\n");
+               RTE_ETHDEV_LOG(ERR, "RX Intr handle unset\n");
                return -ENOTSUP;
        }
 
        intr_handle = dev->intr_handle;
        if (!intr_handle->intr_vec) {
-               RTE_PMD_DEBUG_TRACE("RX Intr vector unset\n");
+               RTE_ETHDEV_LOG(ERR, "RX Intr vector unset\n");
                return -EPERM;
        }
 
@@ -3510,15 +3575,52 @@ rte_eth_dev_rx_intr_ctl(uint16_t port_id, int epfd, int op, void *data)
                vec = intr_handle->intr_vec[qid];
                rc = rte_intr_rx_ctl(intr_handle, epfd, op, vec, data);
                if (rc && rc != -EEXIST) {
-                       RTE_PMD_DEBUG_TRACE("p %u q %u rx ctl error"
-                                       " op %d epfd %d vec %u\n",
-                                       port_id, qid, op, epfd, vec);
+                       RTE_ETHDEV_LOG(ERR,
+                               "p %u q %u rx ctl error op %d epfd %d vec %u\n",
+                               port_id, qid, op, epfd, vec);
                }
        }
 
        return 0;
 }
 
+int __rte_experimental
+rte_eth_dev_rx_intr_ctl_q_get_fd(uint16_t port_id, uint16_t queue_id)
+{
+       struct rte_intr_handle *intr_handle;
+       struct rte_eth_dev *dev;
+       unsigned int efd_idx;
+       uint32_t vec;
+       int fd;
+
+       RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -1);
+
+       dev = &rte_eth_devices[port_id];
+
+       if (queue_id >= dev->data->nb_rx_queues) {
+               RTE_ETHDEV_LOG(ERR, "Invalid RX queue_id=%u\n", queue_id);
+               return -1;
+       }
+
+       if (!dev->intr_handle) {
+               RTE_ETHDEV_LOG(ERR, "RX Intr handle unset\n");
+               return -1;
+       }
+
+       intr_handle = dev->intr_handle;
+       if (!intr_handle->intr_vec) {
+               RTE_ETHDEV_LOG(ERR, "RX Intr vector unset\n");
+               return -1;
+       }
+
+       vec = intr_handle->intr_vec[queue_id];
+       efd_idx = (vec >= RTE_INTR_VEC_RXTX_OFFSET) ?
+               (vec - RTE_INTR_VEC_RXTX_OFFSET) : vec;
+       fd = intr_handle->efds[efd_idx];
+
+       return fd;
+}
+
 const struct rte_memzone *
 rte_eth_dma_zone_reserve(const struct rte_eth_dev *dev, const char *ring_name,
                         uint16_t queue_id, size_t size, unsigned align,
@@ -3526,10 +3628,15 @@ rte_eth_dma_zone_reserve(const struct rte_eth_dev *dev, const char *ring_name,
 {
        char z_name[RTE_MEMZONE_NAMESIZE];
        const struct rte_memzone *mz;
+       int rc;
 
-       snprintf(z_name, sizeof(z_name), "%s_%s_%d_%d",
-                dev->device->driver->name, ring_name,
-                dev->data->port_id, queue_id);
+       rc = snprintf(z_name, sizeof(z_name), "eth_p%d_q%d_%s",
+                     dev->data->port_id, queue_id, ring_name);
+       if (rc >= RTE_MEMZONE_NAMESIZE) {
+               RTE_ETHDEV_LOG(ERR, "ring name too long\n");
+               rte_errno = ENAMETOOLONG;
+               return NULL;
+       }
 
        mz = rte_memzone_lookup(z_name);
        if (mz)
@@ -3553,10 +3660,8 @@ rte_eth_dev_create(struct rte_device *device, const char *name,
 
        if (rte_eal_process_type() == RTE_PROC_PRIMARY) {
                ethdev = rte_eth_dev_allocate(name);
-               if (!ethdev) {
-                       retval = -ENODEV;
-                       goto probe_failed;
-               }
+               if (!ethdev)
+                       return -ENODEV;
 
                if (priv_data_size) {
                        ethdev->data->dev_private = rte_zmalloc_socket(
@@ -3574,8 +3679,7 @@ rte_eth_dev_create(struct rte_device *device, const char *name,
                if (!ethdev) {
                        RTE_LOG(ERR, EAL, "secondary process attach failed, "
                                "ethdev doesn't exist");
-                       retval = -ENODEV;
-                       goto probe_failed;
+                       return  -ENODEV;
                }
        }
 
@@ -3599,13 +3703,9 @@ rte_eth_dev_create(struct rte_device *device, const char *name,
        rte_eth_dev_probing_finish(ethdev);
 
        return retval;
-probe_failed:
-       /* free ports private data if primary process */
-       if (rte_eal_process_type() == RTE_PROC_PRIMARY)
-               rte_free(ethdev->data->dev_private);
 
+probe_failed:
        rte_eth_dev_release_port(ethdev);
-
        return retval;
 }
 
@@ -3620,16 +3720,10 @@ rte_eth_dev_destroy(struct rte_eth_dev *ethdev,
                return -ENODEV;
 
        RTE_FUNC_PTR_OR_ERR_RET(*ethdev_uninit, -EINVAL);
-       if (ethdev_uninit) {
-               ret = ethdev_uninit(ethdev);
-               if (ret)
-                       return ret;
-       }
 
-       if (rte_eal_process_type() == RTE_PROC_PRIMARY)
-               rte_free(ethdev->data->dev_private);
-
-       ethdev->data->dev_private = NULL;
+       ret = ethdev_uninit(ethdev);
+       if (ret)
+               return ret;
 
        return rte_eth_dev_release_port(ethdev);
 }
@@ -3647,27 +3741,27 @@ rte_eth_dev_rx_intr_ctl_q(uint16_t port_id, uint16_t queue_id,
 
        dev = &rte_eth_devices[port_id];
        if (queue_id >= dev->data->nb_rx_queues) {
-               RTE_PMD_DEBUG_TRACE("Invalid RX queue_id=%u\n", queue_id);
+               RTE_ETHDEV_LOG(ERR, "Invalid RX queue_id=%u\n", queue_id);
                return -EINVAL;
        }
 
        if (!dev->intr_handle) {
-               RTE_PMD_DEBUG_TRACE("RX Intr handle unset\n");
+               RTE_ETHDEV_LOG(ERR, "RX Intr handle unset\n");
                return -ENOTSUP;
        }
 
        intr_handle = dev->intr_handle;
        if (!intr_handle->intr_vec) {
-               RTE_PMD_DEBUG_TRACE("RX Intr vector unset\n");
+               RTE_ETHDEV_LOG(ERR, "RX Intr vector unset\n");
                return -EPERM;
        }
 
        vec = intr_handle->intr_vec[queue_id];
        rc = rte_intr_rx_ctl(intr_handle, epfd, op, vec, data);
        if (rc && rc != -EEXIST) {
-               RTE_PMD_DEBUG_TRACE("p %u q %u rx ctl error"
-                               " op %d epfd %d vec %u\n",
-                               port_id, queue_id, op, epfd, vec);
+               RTE_ETHDEV_LOG(ERR,
+                       "p %u q %u rx ctl error op %d epfd %d vec %u\n",
+                       port_id, queue_id, op, epfd, vec);
                return rc;
        }
 
@@ -3934,7 +4028,7 @@ rte_eth_rx_queue_info_get(uint16_t port_id, uint16_t queue_id,
 
        dev = &rte_eth_devices[port_id];
        if (queue_id >= dev->data->nb_rx_queues) {
-               RTE_PMD_DEBUG_TRACE("Invalid RX queue_id=%d\n", queue_id);
+               RTE_ETHDEV_LOG(ERR, "Invalid RX queue_id=%u\n", queue_id);
                return -EINVAL;
        }
 
@@ -3950,7 +4044,6 @@ rte_eth_tx_queue_info_get(uint16_t port_id, uint16_t queue_id,
        struct rte_eth_txq_info *qinfo)
 {
        struct rte_eth_dev *dev;
-       struct rte_eth_txconf *txconf = &qinfo->conf;
 
        RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV);
 
@@ -3959,7 +4052,7 @@ rte_eth_tx_queue_info_get(uint16_t port_id, uint16_t queue_id,
 
        dev = &rte_eth_devices[port_id];
        if (queue_id >= dev->data->nb_tx_queues) {
-               RTE_PMD_DEBUG_TRACE("Invalid TX queue_id=%d\n", queue_id);
+               RTE_ETHDEV_LOG(ERR, "Invalid TX queue_id=%u\n", queue_id);
                return -EINVAL;
        }
 
@@ -3967,15 +4060,13 @@ rte_eth_tx_queue_info_get(uint16_t port_id, uint16_t queue_id,
 
        memset(qinfo, 0, sizeof(*qinfo));
        dev->dev_ops->txq_info_get(dev, queue_id, qinfo);
-       /* convert offload to txq_flags to support legacy app */
-       rte_eth_convert_tx_offload(txconf->offloads, &txconf->txq_flags);
 
        return 0;
 }
 
 int
 rte_eth_dev_set_mc_addr_list(uint16_t port_id,
-                            struct ether_addr *mc_addr_set,
+                            struct rte_ether_addr *mc_addr_set,
                             uint32_t nb_mc_addr)
 {
        struct rte_eth_dev *dev;
@@ -4176,12 +4267,12 @@ rte_eth_dev_l2_tunnel_eth_type_conf(uint16_t port_id,
 
        RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV);
        if (l2_tunnel == NULL) {
-               RTE_PMD_DEBUG_TRACE("Invalid l2_tunnel parameter\n");
+               RTE_ETHDEV_LOG(ERR, "Invalid l2_tunnel parameter\n");
                return -EINVAL;
        }
 
        if (l2_tunnel->l2_tunnel_type >= RTE_TUNNEL_TYPE_MAX) {
-               RTE_PMD_DEBUG_TRACE("Invalid tunnel type\n");
+               RTE_ETHDEV_LOG(ERR, "Invalid tunnel type\n");
                return -EINVAL;
        }
 
@@ -4203,17 +4294,17 @@ rte_eth_dev_l2_tunnel_offload_set(uint16_t port_id,
        RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV);
 
        if (l2_tunnel == NULL) {
-               RTE_PMD_DEBUG_TRACE("Invalid l2_tunnel parameter\n");
+               RTE_ETHDEV_LOG(ERR, "Invalid l2_tunnel parameter\n");
                return -EINVAL;
        }
 
        if (l2_tunnel->l2_tunnel_type >= RTE_TUNNEL_TYPE_MAX) {
-               RTE_PMD_DEBUG_TRACE("Invalid tunnel type.\n");
+               RTE_ETHDEV_LOG(ERR, "Invalid tunnel type\n");
                return -EINVAL;
        }
 
        if (mask == 0) {
-               RTE_PMD_DEBUG_TRACE("Mask should have a value.\n");
+               RTE_ETHDEV_LOG(ERR, "Mask should have a value\n");
                return -EINVAL;
        }
 
@@ -4292,7 +4383,7 @@ enum rte_eth_switch_domain_state {
  * RTE_MAX_ETHPORTS elements as there cannot be more active switch domains than
  * ethdev ports in a single process.
  */
-struct rte_eth_dev_switch {
+static struct rte_eth_dev_switch {
        enum rte_eth_switch_domain_state state;
 } rte_eth_switch_domains[RTE_MAX_ETHPORTS];
 
@@ -4333,8 +4424,6 @@ rte_eth_switch_domain_free(uint16_t domain_id)
        return 0;
 }
 
-typedef int (*rte_eth_devargs_callback_t)(char *str, void *data);
-
 static int
 rte_eth_devargs_tokenise(struct rte_kvargs *arglist, const char *str_in)
 {
@@ -4399,89 +4488,6 @@ rte_eth_devargs_tokenise(struct rte_kvargs *arglist, const char *str_in)
        }
 }
 
-static int
-rte_eth_devargs_parse_list(char *str, rte_eth_devargs_callback_t callback,
-       void *data)
-{
-       char *str_start;
-       int state;
-       int result;
-
-       if (*str != '[')
-               /* Single element, not a list */
-               return callback(str, data);
-
-       /* Sanity check, then strip the brackets */
-       str_start = &str[strlen(str) - 1];
-       if (*str_start != ']') {
-               RTE_LOG(ERR, EAL, "(%s): List does not end with ']'", str);
-               return -EINVAL;
-       }
-       str++;
-       *str_start = '\0';
-
-       /* Process list elements */
-       state = 0;
-       while (1) {
-               if (state == 0) {
-                       if (*str == '\0')
-                               break;
-                       if (*str != ',') {
-                               str_start = str;
-                               state = 1;
-                       }
-               } else if (state == 1) {
-                       if (*str == ',' || *str == '\0') {
-                               if (str > str_start) {
-                                       /* Non-empty string fragment */
-                                       *str = '\0';
-                                       result = callback(str_start, data);
-                                       if (result < 0)
-                                               return result;
-                               }
-                               state = 0;
-                       }
-               }
-               str++;
-       }
-       return 0;
-}
-
-static int
-rte_eth_devargs_process_range(char *str, uint16_t *list, uint16_t *len_list,
-       const uint16_t max_list)
-{
-       uint16_t lo, hi, val;
-       int result;
-
-       result = sscanf(str, "%hu-%hu", &lo, &hi);
-       if (result == 1) {
-               if (*len_list >= max_list)
-                       return -ENOMEM;
-               list[(*len_list)++] = lo;
-       } else if (result == 2) {
-               if (lo >= hi || lo > RTE_MAX_ETHPORTS || hi > RTE_MAX_ETHPORTS)
-                       return -EINVAL;
-               for (val = lo; val <= hi; val++) {
-                       if (*len_list >= max_list)
-                               return -ENOMEM;
-                       list[(*len_list)++] = val;
-               }
-       } else
-               return -EINVAL;
-       return 0;
-}
-
-
-static int
-rte_eth_devargs_parse_representor_ports(char *str, void *data)
-{
-       struct rte_eth_devargs *eth_da = data;
-
-       return rte_eth_devargs_process_range(str, eth_da->representor_ports,
-               &eth_da->nb_representor_ports, RTE_MAX_ETHPORTS);
-}
-
 int __rte_experimental
 rte_eth_devargs_parse(const char *dargs, struct rte_eth_devargs *eth_da)
 {
@@ -4514,11 +4520,9 @@ parse_cleanup:
        return result;
 }
 
-RTE_INIT(ethdev_init_log);
-static void
-ethdev_init_log(void)
+RTE_INIT(ethdev_init_log)
 {
-       ethdev_logtype = rte_log_register("lib.ethdev");
-       if (ethdev_logtype >= 0)
-               rte_log_set_level(ethdev_logtype, RTE_LOG_INFO);
+       rte_eth_dev_logtype = rte_log_register("lib.ethdev");
+       if (rte_eth_dev_logtype >= 0)
+               rte_log_set_level(rte_eth_dev_logtype, RTE_LOG_INFO);
 }