#include <rte_memcpy.h>
#include <rte_memzone.h>
#include <rte_launch.h>
-#include <rte_tailq.h>
#include <rte_eal.h>
#include <rte_per_lcore.h>
#include <rte_lcore.h>
unsigned offset;
};
-static struct rte_eth_xstats_name_off rte_stats_strings[] = {
- {"rx_packets", offsetof(struct rte_eth_stats, ipackets)},
- {"tx_packets", offsetof(struct rte_eth_stats, opackets)},
- {"rx_bytes", offsetof(struct rte_eth_stats, ibytes)},
- {"tx_bytes", offsetof(struct rte_eth_stats, obytes)},
- {"tx_errors", offsetof(struct rte_eth_stats, oerrors)},
- {"rx_missed_errors", offsetof(struct rte_eth_stats, imissed)},
- {"rx_crc_errors", offsetof(struct rte_eth_stats, ibadcrc)},
- {"rx_bad_length_errors", offsetof(struct rte_eth_stats, ibadlen)},
- {"rx_errors", offsetof(struct rte_eth_stats, ierrors)},
- {"alloc_rx_buff_failed", offsetof(struct rte_eth_stats, rx_nombuf)},
- {"fdir_match", offsetof(struct rte_eth_stats, fdirmatch)},
- {"fdir_miss", offsetof(struct rte_eth_stats, fdirmiss)},
- {"tx_flow_control_xon", offsetof(struct rte_eth_stats, tx_pause_xon)},
- {"rx_flow_control_xon", offsetof(struct rte_eth_stats, rx_pause_xon)},
- {"tx_flow_control_xoff", offsetof(struct rte_eth_stats, tx_pause_xoff)},
- {"rx_flow_control_xoff", offsetof(struct rte_eth_stats, rx_pause_xoff)},
+static const struct rte_eth_xstats_name_off rte_stats_strings[] = {
+ {"rx_packets", offsetof(struct rte_eth_stats, ipackets)},
+ {"tx_packets", offsetof(struct rte_eth_stats, opackets)},
+ {"rx_bytes", offsetof(struct rte_eth_stats, ibytes)},
+ {"tx_bytes", offsetof(struct rte_eth_stats, obytes)},
+ {"tx_errors", offsetof(struct rte_eth_stats, oerrors)},
+ {"rx_missed_errors", offsetof(struct rte_eth_stats, imissed)},
+ {"rx_crc_errors", offsetof(struct rte_eth_stats, ibadcrc)},
+ {"rx_bad_length_errors", offsetof(struct rte_eth_stats, ibadlen)},
+ {"rx_errors", offsetof(struct rte_eth_stats, ierrors)},
+ {"alloc_rx_buff_failed", offsetof(struct rte_eth_stats, rx_nombuf)},
+ {"fdir_match", offsetof(struct rte_eth_stats, fdirmatch)},
+ {"fdir_miss", offsetof(struct rte_eth_stats, fdirmiss)},
+ {"tx_flow_control_xon", offsetof(struct rte_eth_stats, tx_pause_xon)},
+ {"rx_flow_control_xon", offsetof(struct rte_eth_stats, rx_pause_xon)},
+ {"tx_flow_control_xoff", offsetof(struct rte_eth_stats, tx_pause_xoff)},
+ {"rx_flow_control_xoff", offsetof(struct rte_eth_stats, rx_pause_xoff)},
};
#define RTE_NB_STATS (sizeof(rte_stats_strings) / sizeof(rte_stats_strings[0]))
-static struct rte_eth_xstats_name_off rte_rxq_stats_strings[] = {
+static const struct rte_eth_xstats_name_off rte_rxq_stats_strings[] = {
{"rx_packets", offsetof(struct rte_eth_stats, q_ipackets)},
{"rx_bytes", offsetof(struct rte_eth_stats, q_ibytes)},
};
#define RTE_NB_RXQ_STATS (sizeof(rte_rxq_stats_strings) / \
sizeof(rte_rxq_stats_strings[0]))
-static struct rte_eth_xstats_name_off rte_txq_stats_strings[] = {
+static const struct rte_eth_xstats_name_off rte_txq_stats_strings[] = {
{"tx_packets", offsetof(struct rte_eth_stats, q_opackets)},
{"tx_bytes", offsetof(struct rte_eth_stats, q_obytes)},
{"tx_errors", offsetof(struct rte_eth_stats, q_errors)},
DEV_ATTACHED
};
-static inline void
+static void
rte_eth_dev_data_alloc(void)
{
const unsigned flags = 0;
RTE_MAX_ETHPORTS * sizeof(*rte_eth_dev_data));
}
-static struct rte_eth_dev *
+struct rte_eth_dev *
rte_eth_dev_allocated(const char *name)
{
unsigned i;
}
struct rte_eth_dev *
-rte_eth_dev_allocate(const char *name)
+rte_eth_dev_allocate(const char *name, enum rte_eth_dev_type type)
{
uint8_t port_id;
struct rte_eth_dev *eth_dev;
snprintf(eth_dev->data->name, sizeof(eth_dev->data->name), "%s", name);
eth_dev->data->port_id = port_id;
eth_dev->attached = DEV_ATTACHED;
+ eth_dev->dev_type = type;
nb_ports++;
return eth_dev;
}
-static inline int
+static int
rte_eth_dev_create_unique_device_name(char *name, size_t size,
struct rte_pci_device *pci_dev)
{
pci_dev->addr.function);
if (ret < 0)
return ret;
-
return 0;
}
rte_eth_dev_create_unique_device_name(ethdev_name,
sizeof(ethdev_name), pci_dev);
- eth_dev = rte_eth_dev_allocate(ethdev_name);
+ eth_dev = rte_eth_dev_allocate(ethdev_name, RTE_ETH_DEV_PCI);
if (eth_dev == NULL)
return -ENOMEM;
eth_dev->data->mtu = ETHER_MTU;
/* Invoke PMD device initialization function */
- diag = (*eth_drv->eth_dev_init)(eth_drv, eth_dev);
+ diag = (*eth_drv->eth_dev_init)(eth_dev);
if (diag == 0)
- return (0);
+ return 0;
PMD_DEBUG_TRACE("driver %s: eth_dev_init(vendor_id=0x%u device_id=0x%x)"
" failed\n", pci_drv->name,
/* Invoke PMD device uninit function */
if (*eth_drv->eth_dev_uninit) {
- ret = (*eth_drv->eth_dev_uninit)(eth_drv, eth_dev);
+ ret = (*eth_drv->eth_dev_uninit)(eth_dev);
if (ret)
return ret;
}
uint8_t
rte_eth_dev_count(void)
{
- return (nb_ports);
+ return nb_ports;
+}
+
+/* So far, DPDK hotplug function only supports linux */
+#ifdef RTE_LIBRTE_EAL_HOTPLUG
+
+static enum rte_eth_dev_type
+rte_eth_dev_get_device_type(uint8_t port_id)
+{
+ if (!rte_eth_dev_is_valid_port(port_id))
+ return RTE_ETH_DEV_UNKNOWN;
+ return rte_eth_devices[port_id].dev_type;
+}
+
+static int
+rte_eth_dev_save(struct rte_eth_dev *devs, size_t size)
+{
+ if ((devs == NULL) ||
+ (size != sizeof(struct rte_eth_dev) * RTE_MAX_ETHPORTS))
+ return -EINVAL;
+
+ /* save current rte_eth_devices */
+ memcpy(devs, rte_eth_devices, size);
+ return 0;
+}
+
+static int
+rte_eth_dev_get_changed_port(struct rte_eth_dev *devs, uint8_t *port_id)
+{
+ if ((devs == NULL) || (port_id == NULL))
+ return -EINVAL;
+
+ /* check which port was attached or detached */
+ for (*port_id = 0; *port_id < RTE_MAX_ETHPORTS; (*port_id)++, devs++) {
+ if (rte_eth_devices[*port_id].attached ^ devs->attached)
+ return 0;
+ }
+ return -ENODEV;
+}
+
+static int
+rte_eth_dev_get_addr_by_port(uint8_t port_id, struct rte_pci_addr *addr)
+{
+ if (!rte_eth_dev_is_valid_port(port_id)) {
+ PMD_DEBUG_TRACE("Invalid port_id=%d\n", port_id);
+ return -EINVAL;
+ }
+
+ if (addr == NULL) {
+ PMD_DEBUG_TRACE("Null pointer is specified\n");
+ return -EINVAL;
+ }
+
+ *addr = rte_eth_devices[port_id].pci_dev->addr;
+ return 0;
+}
+
+static int
+rte_eth_dev_get_name_by_port(uint8_t port_id, char *name)
+{
+ char *tmp;
+
+ if (!rte_eth_dev_is_valid_port(port_id)) {
+ PMD_DEBUG_TRACE("Invalid port_id=%d\n", port_id);
+ return -EINVAL;
+ }
+
+ if (name == NULL) {
+ PMD_DEBUG_TRACE("Null pointer is specified\n");
+ return -EINVAL;
+ }
+
+ /* shouldn't check 'rte_eth_devices[i].data',
+ * because it might be overwritten by VDEV PMD */
+ tmp = rte_eth_dev_data[port_id].name;
+ strcpy(name, tmp);
+ return 0;
+}
+
+static int
+rte_eth_dev_is_detachable(uint8_t port_id)
+{
+ uint32_t drv_flags;
+
+ if (port_id >= RTE_MAX_ETHPORTS) {
+ PMD_DEBUG_TRACE("Invalid port_id=%d\n", port_id);
+ return -EINVAL;
+ }
+
+ if (rte_eth_devices[port_id].dev_type == RTE_ETH_DEV_PCI) {
+ switch (rte_eth_devices[port_id].pci_dev->kdrv) {
+ case RTE_KDRV_IGB_UIO:
+ case RTE_KDRV_UIO_GENERIC:
+ break;
+ case RTE_KDRV_VFIO:
+ default:
+ return -ENOTSUP;
+ }
+ }
+
+ drv_flags = rte_eth_devices[port_id].driver->pci_drv.drv_flags;
+ return !(drv_flags & RTE_PCI_DRV_DETACHABLE);
+}
+
+/* attach the new physical device, then store port_id of the device */
+static int
+rte_eth_dev_attach_pdev(struct rte_pci_addr *addr, uint8_t *port_id)
+{
+ uint8_t new_port_id;
+ struct rte_eth_dev devs[RTE_MAX_ETHPORTS];
+
+ if ((addr == NULL) || (port_id == NULL))
+ goto err;
+
+ /* save current port status */
+ if (rte_eth_dev_save(devs, sizeof(devs)))
+ goto err;
+ /* re-construct pci_device_list */
+ if (rte_eal_pci_scan())
+ goto err;
+ /* invoke probe func of the driver can handle the new device.
+ * TODO:
+ * rte_eal_pci_probe_one() should return port_id.
+ * And rte_eth_dev_save() and rte_eth_dev_get_changed_port()
+ * should be removed. */
+ if (rte_eal_pci_probe_one(addr))
+ goto err;
+ /* get port_id enabled by above procedures */
+ if (rte_eth_dev_get_changed_port(devs, &new_port_id))
+ goto err;
+
+ *port_id = new_port_id;
+ return 0;
+err:
+ RTE_LOG(ERR, EAL, "Driver, cannot attach the device\n");
+ return -1;
+}
+
+/* detach the new physical device, then store pci_addr of the device */
+static int
+rte_eth_dev_detach_pdev(uint8_t port_id, struct rte_pci_addr *addr)
+{
+ struct rte_pci_addr freed_addr;
+ struct rte_pci_addr vp;
+
+ if (addr == NULL)
+ goto err;
+
+ /* check whether the driver supports detach feature, or not */
+ if (rte_eth_dev_is_detachable(port_id))
+ goto err;
+
+ /* get pci address by port id */
+ if (rte_eth_dev_get_addr_by_port(port_id, &freed_addr))
+ goto err;
+
+ /* Zerod pci addr means the port comes from virtual device */
+ vp.domain = vp.bus = vp.devid = vp.function = 0;
+ if (rte_eal_compare_pci_addr(&vp, &freed_addr) == 0)
+ goto err;
+
+ /* invoke close func of the driver,
+ * also remove the device from pci_device_list */
+ if (rte_eal_pci_close_one(&freed_addr))
+ goto err;
+
+ *addr = freed_addr;
+ return 0;
+err:
+ RTE_LOG(ERR, EAL, "Driver, cannot detach the device\n");
+ return -1;
}
+/* attach the new virtual device, then store port_id of the device */
+static int
+rte_eth_dev_attach_vdev(const char *vdevargs, uint8_t *port_id)
+{
+ char *name = NULL, *args = NULL;
+ uint8_t new_port_id;
+ struct rte_eth_dev devs[RTE_MAX_ETHPORTS];
+ int ret = -1;
+
+ if ((vdevargs == NULL) || (port_id == NULL))
+ goto end;
+
+ /* parse vdevargs, then retrieve device name and args */
+ if (rte_eal_parse_devargs_str(vdevargs, &name, &args))
+ goto end;
+
+ /* save current port status */
+ if (rte_eth_dev_save(devs, sizeof(devs)))
+ goto end;
+ /* walk around dev_driver_list to find the driver of the device,
+ * then invoke probe function o the driver.
+ * TODO:
+ * rte_eal_vdev_init() should return port_id,
+ * And rte_eth_dev_save() and rte_eth_dev_get_changed_port()
+ * should be removed. */
+ if (rte_eal_vdev_init(name, args))
+ goto end;
+ /* get port_id enabled by above procedures */
+ if (rte_eth_dev_get_changed_port(devs, &new_port_id))
+ goto end;
+ ret = 0;
+ *port_id = new_port_id;
+end:
+ if (name)
+ free(name);
+ if (args)
+ free(args);
+
+ if (ret < 0)
+ RTE_LOG(ERR, EAL, "Driver, cannot attach the device\n");
+ return ret;
+}
+
+/* detach the new virtual device, then store the name of the device */
+static int
+rte_eth_dev_detach_vdev(uint8_t port_id, char *vdevname)
+{
+ char name[RTE_ETH_NAME_MAX_LEN];
+
+ if (vdevname == NULL)
+ goto err;
+
+ /* check whether the driver supports detach feature, or not */
+ if (rte_eth_dev_is_detachable(port_id))
+ goto err;
+
+ /* get device name by port id */
+ if (rte_eth_dev_get_name_by_port(port_id, name))
+ goto err;
+ /* walk around dev_driver_list to find the driver of the device,
+ * then invoke close function o the driver */
+ if (rte_eal_vdev_uninit(name))
+ goto err;
+
+ strncpy(vdevname, name, sizeof(name));
+ return 0;
+err:
+ RTE_LOG(ERR, EAL, "Driver, cannot detach the device\n");
+ return -1;
+}
+
+/* attach the new device, then store port_id of the device */
+int
+rte_eth_dev_attach(const char *devargs, uint8_t *port_id)
+{
+ struct rte_pci_addr addr;
+
+ if ((devargs == NULL) || (port_id == NULL))
+ return -EINVAL;
+
+ if (eal_parse_pci_DomBDF(devargs, &addr) == 0)
+ return rte_eth_dev_attach_pdev(&addr, port_id);
+ else
+ return rte_eth_dev_attach_vdev(devargs, port_id);
+}
+
+/* detach the device, then store the name of the device */
+int
+rte_eth_dev_detach(uint8_t port_id, char *name)
+{
+ struct rte_pci_addr addr;
+ int ret;
+
+ if (name == NULL)
+ return -EINVAL;
+
+ if (rte_eth_dev_get_device_type(port_id) == RTE_ETH_DEV_PCI) {
+ ret = rte_eth_dev_get_addr_by_port(port_id, &addr);
+ if (ret < 0)
+ return ret;
+
+ ret = rte_eth_dev_detach_pdev(port_id, &addr);
+ if (ret == 0)
+ snprintf(name, RTE_ETH_NAME_MAX_LEN,
+ "%04x:%02x:%02x.%d",
+ addr.domain, addr.bus,
+ addr.devid, addr.function);
+
+ return ret;
+ } else
+ return rte_eth_dev_detach_vdev(port_id, name);
+}
+#else /* RTE_LIBRTE_EAL_HOTPLUG */
+int
+rte_eth_dev_attach(const char *devargs __rte_unused,
+ uint8_t *port_id __rte_unused)
+{
+ RTE_LOG(ERR, EAL, "Hotplug support isn't enabled\n");
+ return -1;
+}
+
+/* detach the device, then store the name of the device */
+int
+rte_eth_dev_detach(uint8_t port_id __rte_unused,
+ char *name __rte_unused)
+{
+ RTE_LOG(ERR, EAL, "Hotplug support isn't enabled\n");
+ return -1;
+}
+#endif /* RTE_LIBRTE_EAL_HOTPLUG */
+
static int
rte_eth_dev_rx_queue_config(struct rte_eth_dev *dev, uint16_t nb_queues)
{
dev->data->nb_rx_queues = 0;
return -(ENOMEM);
}
-#ifdef RTE_ETHDEV_RXTX_CALLBACKS
- dev->post_rx_burst_cbs = rte_zmalloc(
- "ethdev->post_rx_burst_cbs",
- sizeof(*dev->post_rx_burst_cbs) * nb_queues,
- RTE_CACHE_LINE_SIZE);
- if (dev->post_rx_burst_cbs == NULL) {
- rte_free(dev->data->rx_queues);
- dev->data->rx_queues = NULL;
- dev->data->nb_rx_queues = 0;
- return -ENOMEM;
- }
-#endif
-
} else { /* re-configure */
FUNC_PTR_OR_ERR_RET(*dev->dev_ops->rx_queue_release, -ENOTSUP);
RTE_CACHE_LINE_SIZE);
if (rxq == NULL)
return -(ENOMEM);
-#ifdef RTE_ETHDEV_RXTX_CALLBACKS
- dev->post_rx_burst_cbs = rte_realloc(
- dev->post_rx_burst_cbs,
- sizeof(*dev->post_rx_burst_cbs) *
- nb_queues, RTE_CACHE_LINE_SIZE);
- if (dev->post_rx_burst_cbs == NULL)
- return -ENOMEM;
-#endif
if (nb_queues > old_nb_queues) {
uint16_t new_qs = nb_queues - old_nb_queues;
memset(rxq + old_nb_queues, 0,
sizeof(rxq[0]) * new_qs);
-#ifdef RTE_ETHDEV_RXTX_CALLBACKS
- memset(dev->post_rx_burst_cbs + old_nb_queues, 0,
- sizeof(dev->post_rx_burst_cbs[0]) * new_qs);
-#endif
}
dev->data->rx_queues = rxq;
}
dev->data->nb_rx_queues = nb_queues;
- return (0);
+ return 0;
}
int
dev->data->nb_tx_queues = 0;
return -(ENOMEM);
}
-#ifdef RTE_ETHDEV_RXTX_CALLBACKS
- dev->pre_tx_burst_cbs = rte_zmalloc(
- "ethdev->pre_tx_burst_cbs",
- sizeof(*dev->pre_tx_burst_cbs) * nb_queues,
- RTE_CACHE_LINE_SIZE);
- if (dev->pre_tx_burst_cbs == NULL) {
- rte_free(dev->data->tx_queues);
- dev->data->tx_queues = NULL;
- dev->data->nb_tx_queues = 0;
- return -ENOMEM;
- }
-#endif
-
} else { /* re-configure */
FUNC_PTR_OR_ERR_RET(*dev->dev_ops->tx_queue_release, -ENOTSUP);
RTE_CACHE_LINE_SIZE);
if (txq == NULL)
return -ENOMEM;
-#ifdef RTE_ETHDEV_RXTX_CALLBACKS
- dev->pre_tx_burst_cbs = rte_realloc(
- dev->pre_tx_burst_cbs,
- sizeof(*dev->pre_tx_burst_cbs) *
- nb_queues, RTE_CACHE_LINE_SIZE);
- if (dev->pre_tx_burst_cbs == NULL)
- return -ENOMEM;
-#endif
if (nb_queues > old_nb_queues) {
uint16_t new_qs = nb_queues - old_nb_queues;
memset(txq + old_nb_queues, 0,
sizeof(txq[0]) * new_qs);
-#ifdef RTE_ETHDEV_RXTX_CALLBACKS
- memset(dev->pre_tx_burst_cbs + old_nb_queues, 0,
- sizeof(dev->pre_tx_burst_cbs[0]) * new_qs);
-#endif
}
dev->data->tx_queues = txq;
}
dev->data->nb_tx_queues = nb_queues;
- return (0);
+ return 0;
}
static int
port_id,
dev_conf->rxmode.mq_mode,
dev_conf->txmode.mq_mode);
- return (-EINVAL);
+ return -EINVAL;
}
switch (dev_conf->rxmode.mq_mode) {
" SRIOV active, "
"unsupported VMDQ mq_mode rx %u\n",
port_id, dev_conf->rxmode.mq_mode);
- return (-EINVAL);
+ return -EINVAL;
case ETH_MQ_RX_RSS:
PMD_DEBUG_TRACE("ethdev port_id=%" PRIu8
" SRIOV active, "
" SRIOV active, "
"unsupported VMDQ mq_mode tx %u\n",
port_id, dev_conf->txmode.mq_mode);
- return (-EINVAL);
+ return -EINVAL;
default: /* ETH_MQ_TX_VMDQ_ONLY or ETH_MQ_TX_NONE */
/* if nothing mq mode configure, use default scheme */
dev->data->dev_conf.txmode.mq_mode = ETH_MQ_TX_VMDQ_ONLY;
PMD_DEBUG_TRACE("ethdev port_id=%d SRIOV active, "
"queue number must less equal to %d\n",
port_id, RTE_ETH_DEV_SRIOV(dev).nb_q_per_pool);
- return (-EINVAL);
+ return -EINVAL;
}
} else {
/* For vmdb+dcb mode check our configuration before we go further */
PMD_DEBUG_TRACE("ethdev port_id=%d VMDQ+DCB, nb_rx_q "
"!= %d\n",
port_id, ETH_VMDQ_DCB_NUM_QUEUES);
- return (-EINVAL);
+ return -EINVAL;
}
conf = &(dev_conf->rx_adv_conf.vmdq_dcb_conf);
if (! (conf->nb_queue_pools == ETH_16_POOLS ||
PMD_DEBUG_TRACE("ethdev port_id=%d VMDQ+DCB selected, "
"nb_queue_pools must be %d or %d\n",
port_id, ETH_16_POOLS, ETH_32_POOLS);
- return (-EINVAL);
+ return -EINVAL;
}
}
if (dev_conf->txmode.mq_mode == ETH_MQ_TX_VMDQ_DCB) {
PMD_DEBUG_TRACE("ethdev port_id=%d VMDQ+DCB, nb_tx_q "
"!= %d\n",
port_id, ETH_VMDQ_DCB_NUM_QUEUES);
- return (-EINVAL);
+ return -EINVAL;
}
conf = &(dev_conf->tx_adv_conf.vmdq_dcb_tx_conf);
if (! (conf->nb_queue_pools == ETH_16_POOLS ||
"nb_queue_pools != %d or nb_queue_pools "
"!= %d\n",
port_id, ETH_16_POOLS, ETH_32_POOLS);
- return (-EINVAL);
+ return -EINVAL;
}
}
PMD_DEBUG_TRACE("ethdev port_id=%d DCB, nb_rx_q "
"!= %d\n",
port_id, ETH_DCB_NUM_QUEUES);
- return (-EINVAL);
+ return -EINVAL;
}
conf = &(dev_conf->rx_adv_conf.dcb_rx_conf);
if (! (conf->nb_tcs == ETH_4_TCS ||
"nb_tcs != %d or nb_tcs "
"!= %d\n",
port_id, ETH_4_TCS, ETH_8_TCS);
- return (-EINVAL);
+ return -EINVAL;
}
}
PMD_DEBUG_TRACE("ethdev port_id=%d DCB, nb_tx_q "
"!= %d\n",
port_id, ETH_DCB_NUM_QUEUES);
- return (-EINVAL);
+ return -EINVAL;
}
conf = &(dev_conf->tx_adv_conf.dcb_tx_conf);
if (! (conf->nb_tcs == ETH_4_TCS ||
"nb_tcs != %d or nb_tcs "
"!= %d\n",
port_id, ETH_4_TCS, ETH_8_TCS);
- return (-EINVAL);
+ return -EINVAL;
}
}
}
if (!rte_eth_dev_is_valid_port(port_id)) {
PMD_DEBUG_TRACE("Invalid port_id=%d\n", port_id);
- return (-EINVAL);
+ return -EINVAL;
+ }
+
+ if (nb_rx_q > RTE_MAX_QUEUES_PER_PORT) {
+ PMD_DEBUG_TRACE(
+ "Number of RX queues requested (%u) is greater than max supported(%d)\n",
+ nb_rx_q, RTE_MAX_QUEUES_PER_PORT);
+ return -EINVAL;
+ }
+
+ if (nb_tx_q > RTE_MAX_QUEUES_PER_PORT) {
+ PMD_DEBUG_TRACE(
+ "Number of TX queues requested (%u) is greater than max supported(%d)\n",
+ nb_tx_q, RTE_MAX_QUEUES_PER_PORT);
+ return -EINVAL;
}
dev = &rte_eth_devices[port_id];
if (dev->data->dev_started) {
PMD_DEBUG_TRACE(
"port %d must be stopped to allow configuration\n", port_id);
- return (-EBUSY);
+ return -EBUSY;
}
/*
if (nb_rx_q > dev_info.max_rx_queues) {
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);
+ return -EINVAL;
}
if (nb_rx_q == 0) {
PMD_DEBUG_TRACE("ethdev port_id=%d nb_rx_q == 0\n", port_id);
- return (-EINVAL);
+ return -EINVAL;
}
if (nb_tx_q > dev_info.max_tx_queues) {
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);
+ return -EINVAL;
}
if (nb_tx_q == 0) {
PMD_DEBUG_TRACE("ethdev port_id=%d nb_tx_q == 0\n", port_id);
- return (-EINVAL);
+ return -EINVAL;
}
/* Copy the dev_conf parameter into the dev structure */
if (!(pci_drv->drv_flags & RTE_PCI_DRV_INTR_LSC)) {
PMD_DEBUG_TRACE("driver %s does not support lsc\n",
pci_drv->name);
- return (-EINVAL);
+ return -EINVAL;
}
}
port_id,
(unsigned)dev_conf->rxmode.max_rx_pkt_len,
(unsigned)dev_info.max_rx_pktlen);
- return (-EINVAL);
+ return -EINVAL;
}
else if (dev_conf->rxmode.max_rx_pkt_len < ETHER_MIN_LEN) {
PMD_DEBUG_TRACE("ethdev port_id=%d max_rx_pkt_len %u"
port_id,
(unsigned)dev_conf->rxmode.max_rx_pkt_len,
(unsigned)ETHER_MIN_LEN);
- return (-EINVAL);
+ return -EINVAL;
}
} else {
if (dev_conf->rxmode.max_rx_pkt_len < ETHER_MIN_LEN ||
if (!rte_eth_dev_is_valid_port(port_id)) {
PMD_DEBUG_TRACE("Invalid port_id=%d\n", port_id);
- return (-EINVAL);
+ return -EINVAL;
}
dev = &rte_eth_devices[port_id];
PMD_DEBUG_TRACE("Device with port_id=%" PRIu8
" already started\n",
port_id);
- return (0);
+ return 0;
}
diag = (*dev->dev_ops->dev_start)(dev);
int ret;
uint32_t mbp_buf_size;
struct rte_eth_dev *dev;
- struct rte_pktmbuf_pool_private *mbp_priv;
struct rte_eth_dev_info dev_info;
/* This function is only safe when called from the primary process
if (!rte_eth_dev_is_valid_port(port_id)) {
PMD_DEBUG_TRACE("Invalid port_id=%d\n", port_id);
- return (-EINVAL);
+ return -EINVAL;
}
dev = &rte_eth_devices[port_id];
if (rx_queue_id >= dev->data->nb_rx_queues) {
PMD_DEBUG_TRACE("Invalid RX queue_id=%d\n", rx_queue_id);
- return (-EINVAL);
+ return -EINVAL;
}
if (dev->data->dev_started) {
PMD_DEBUG_TRACE("%s private_data_size %d < %d\n",
mp->name, (int) mp->private_data_size,
(int) sizeof(struct rte_pktmbuf_pool_private));
- return (-ENOSPC);
+ return -ENOSPC;
}
- mbp_priv = rte_mempool_get_priv(mp);
- mbp_buf_size = mbp_priv->mbuf_data_room_size;
+ mbp_buf_size = rte_pktmbuf_data_room_size(mp);
if ((mbp_buf_size - RTE_PKTMBUF_HEADROOM) < dev_info.min_rx_bufsize) {
PMD_DEBUG_TRACE("%s mbuf_data_room_size %d < %d "
dev_info.min_rx_bufsize),
(int)RTE_PKTMBUF_HEADROOM,
(int)dev_info.min_rx_bufsize);
- return (-EINVAL);
+ return -EINVAL;
}
if (rx_conf == NULL)
if (!rte_eth_dev_is_valid_port(port_id)) {
PMD_DEBUG_TRACE("Invalid port_id=%d\n", port_id);
- return (-EINVAL);
+ return -EINVAL;
}
dev = &rte_eth_devices[port_id];
if (tx_queue_id >= dev->data->nb_tx_queues) {
PMD_DEBUG_TRACE("Invalid TX queue_id=%d\n", tx_queue_id);
- return (-EINVAL);
+ return -EINVAL;
}
if (dev->data->dev_started) {
if (!rte_eth_dev_is_valid_port(port_id)) {
PMD_DEBUG_TRACE("Invalid port_id=%d\n", port_id);
- return (-ENODEV);
+ return -ENODEV;
}
dev = &rte_eth_devices[port_id];
if (!rte_eth_dev_is_valid_port(port_id)) {
PMD_DEBUG_TRACE("Invalid port_id=%d\n", port_id);
- return (-ENODEV);
+ return -ENODEV;
}
dev = &rte_eth_devices[port_id];
if (!rte_eth_dev_is_valid_port(port_id)) {
PMD_DEBUG_TRACE("Invalid port_id=%d\n", port_id);
- return (-ENODEV);
+ return -ENODEV;
}
dev = &rte_eth_devices[port_id];
if (!rte_eth_dev_is_valid_port(port_id)) {
PMD_DEBUG_TRACE("Invalid port_id=%d\n", port_id);
- return (-ENODEV);
+ return -ENODEV;
}
dev = &rte_eth_devices[port_id];
if (! (dev->data->dev_conf.rxmode.hw_vlan_filter)) {
PMD_DEBUG_TRACE("port %d: vlan-filtering disabled\n", port_id);
- return (-ENOSYS);
+ return -ENOSYS;
}
if (vlan_id > 4095) {
PMD_DEBUG_TRACE("(port_id=%d) invalid vlan_id=%u > 4095\n",
port_id, (unsigned) vlan_id);
- return (-EINVAL);
+ return -EINVAL;
}
FUNC_PTR_OR_ERR_RET(*dev->dev_ops->vlan_filter_set, -ENOTSUP);
- (*dev->dev_ops->vlan_filter_set)(dev, vlan_id, on);
- return (0);
+
+ return (*dev->dev_ops->vlan_filter_set)(dev, vlan_id, on);
}
int
if (!rte_eth_dev_is_valid_port(port_id)) {
PMD_DEBUG_TRACE("Invalid port_id=%d\n", port_id);
- return (-ENODEV);
+ return -ENODEV;
}
dev = &rte_eth_devices[port_id];
if (rx_queue_id >= dev->data->nb_rx_queues) {
PMD_DEBUG_TRACE("Invalid rx_queue_id=%d\n", port_id);
- return (-EINVAL);
+ return -EINVAL;
}
FUNC_PTR_OR_ERR_RET(*dev->dev_ops->vlan_strip_queue_set, -ENOTSUP);
(*dev->dev_ops->vlan_strip_queue_set)(dev, rx_queue_id, on);
- return (0);
+ return 0;
}
int
if (!rte_eth_dev_is_valid_port(port_id)) {
PMD_DEBUG_TRACE("Invalid port_id=%d\n", port_id);
- return (-ENODEV);
+ return -ENODEV;
}
dev = &rte_eth_devices[port_id];
FUNC_PTR_OR_ERR_RET(*dev->dev_ops->vlan_tpid_set, -ENOTSUP);
(*dev->dev_ops->vlan_tpid_set)(dev, tpid);
- return (0);
+ return 0;
}
int
if (!rte_eth_dev_is_valid_port(port_id)) {
PMD_DEBUG_TRACE("Invalid port_id=%d\n", port_id);
- return (-ENODEV);
+ return -ENODEV;
}
dev = &rte_eth_devices[port_id];
if (!rte_eth_dev_is_valid_port(port_id)) {
PMD_DEBUG_TRACE("Invalid port_id=%d\n", port_id);
- return (-ENODEV);
+ return -ENODEV;
}
dev = &rte_eth_devices[port_id];
if (!rte_eth_dev_is_valid_port(port_id)) {
PMD_DEBUG_TRACE("Invalid port_id=%d\n", port_id);
- return (-ENODEV);
+ return -ENODEV;
}
dev = &rte_eth_devices[port_id];
if (!rte_eth_dev_is_valid_port(port_id)) {
PMD_DEBUG_TRACE("Invalid port_id=%d\n", port_id);
- return (-ENODEV);
+ return -ENODEV;
}
dev = &rte_eth_devices[port_id];
if (dev->data->dev_conf.fdir_conf.mode != RTE_FDIR_MODE_SIGNATURE) {
PMD_DEBUG_TRACE("port %d: invalid FDIR mode=%u\n",
port_id, dev->data->dev_conf.fdir_conf.mode);
- return (-ENOSYS);
+ return -ENOSYS;
}
if ((fdir_filter->l4type == RTE_FDIR_L4TYPE_SCTP
PMD_DEBUG_TRACE(" Port are meaningless for SCTP and " \
"None l4type, source & destinations ports " \
"should be null!\n");
- return (-EINVAL);
+ return -EINVAL;
}
FUNC_PTR_OR_ERR_RET(*dev->dev_ops->fdir_add_signature_filter, -ENOTSUP);
if (!rte_eth_dev_is_valid_port(port_id)) {
PMD_DEBUG_TRACE("Invalid port_id=%d\n", port_id);
- return (-ENODEV);
+ return -ENODEV;
}
dev = &rte_eth_devices[port_id];
if (dev->data->dev_conf.fdir_conf.mode != RTE_FDIR_MODE_SIGNATURE) {
PMD_DEBUG_TRACE("port %d: invalid FDIR mode=%u\n",
port_id, dev->data->dev_conf.fdir_conf.mode);
- return (-ENOSYS);
+ return -ENOSYS;
}
if ((fdir_filter->l4type == RTE_FDIR_L4TYPE_SCTP
PMD_DEBUG_TRACE(" Port are meaningless for SCTP and " \
"None l4type, source & destinations ports " \
"should be null!\n");
- return (-EINVAL);
+ return -EINVAL;
}
FUNC_PTR_OR_ERR_RET(*dev->dev_ops->fdir_update_signature_filter, -ENOTSUP);
if (!rte_eth_dev_is_valid_port(port_id)) {
PMD_DEBUG_TRACE("Invalid port_id=%d\n", port_id);
- return (-ENODEV);
+ return -ENODEV;
}
dev = &rte_eth_devices[port_id];
if (dev->data->dev_conf.fdir_conf.mode != RTE_FDIR_MODE_SIGNATURE) {
PMD_DEBUG_TRACE("port %d: invalid FDIR mode=%u\n",
port_id, dev->data->dev_conf.fdir_conf.mode);
- return (-ENOSYS);
+ return -ENOSYS;
}
if ((fdir_filter->l4type == RTE_FDIR_L4TYPE_SCTP
PMD_DEBUG_TRACE(" Port are meaningless for SCTP and " \
"None l4type source & destinations ports " \
"should be null!\n");
- return (-EINVAL);
+ return -EINVAL;
}
FUNC_PTR_OR_ERR_RET(*dev->dev_ops->fdir_remove_signature_filter, -ENOTSUP);
if (!rte_eth_dev_is_valid_port(port_id)) {
PMD_DEBUG_TRACE("Invalid port_id=%d\n", port_id);
- return (-ENODEV);
+ return -ENODEV;
}
dev = &rte_eth_devices[port_id];
if (! (dev->data->dev_conf.fdir_conf.mode)) {
PMD_DEBUG_TRACE("port %d: pkt-filter disabled\n", port_id);
- return (-ENOSYS);
+ return -ENOSYS;
}
FUNC_PTR_OR_ERR_RET(*dev->dev_ops->fdir_infos_get, -ENOTSUP);
(*dev->dev_ops->fdir_infos_get)(dev, fdir);
- return (0);
+ return 0;
}
int
if (!rte_eth_dev_is_valid_port(port_id)) {
PMD_DEBUG_TRACE("Invalid port_id=%d\n", port_id);
- return (-ENODEV);
+ return -ENODEV;
}
dev = &rte_eth_devices[port_id];
if (dev->data->dev_conf.fdir_conf.mode != RTE_FDIR_MODE_PERFECT) {
PMD_DEBUG_TRACE("port %d: invalid FDIR mode=%u\n",
port_id, dev->data->dev_conf.fdir_conf.mode);
- return (-ENOSYS);
+ return -ENOSYS;
}
if ((fdir_filter->l4type == RTE_FDIR_L4TYPE_SCTP
PMD_DEBUG_TRACE(" Port are meaningless for SCTP and " \
"None l4type, source & destinations ports " \
"should be null!\n");
- return (-EINVAL);
+ return -EINVAL;
}
/* For now IPv6 is not supported with perfect filter */
if (fdir_filter->iptype == RTE_FDIR_IPTYPE_IPV6)
- return (-ENOTSUP);
+ return -ENOTSUP;
FUNC_PTR_OR_ERR_RET(*dev->dev_ops->fdir_add_perfect_filter, -ENOTSUP);
return (*dev->dev_ops->fdir_add_perfect_filter)(dev, fdir_filter,
if (!rte_eth_dev_is_valid_port(port_id)) {
PMD_DEBUG_TRACE("Invalid port_id=%d\n", port_id);
- return (-ENODEV);
+ return -ENODEV;
}
dev = &rte_eth_devices[port_id];
if (dev->data->dev_conf.fdir_conf.mode != RTE_FDIR_MODE_PERFECT) {
PMD_DEBUG_TRACE("port %d: invalid FDIR mode=%u\n",
port_id, dev->data->dev_conf.fdir_conf.mode);
- return (-ENOSYS);
+ return -ENOSYS;
}
if ((fdir_filter->l4type == RTE_FDIR_L4TYPE_SCTP
PMD_DEBUG_TRACE(" Port are meaningless for SCTP and " \
"None l4type, source & destinations ports " \
"should be null!\n");
- return (-EINVAL);
+ return -EINVAL;
}
/* For now IPv6 is not supported with perfect filter */
if (fdir_filter->iptype == RTE_FDIR_IPTYPE_IPV6)
- return (-ENOTSUP);
+ return -ENOTSUP;
FUNC_PTR_OR_ERR_RET(*dev->dev_ops->fdir_update_perfect_filter, -ENOTSUP);
return (*dev->dev_ops->fdir_update_perfect_filter)(dev, fdir_filter,
if (!rte_eth_dev_is_valid_port(port_id)) {
PMD_DEBUG_TRACE("Invalid port_id=%d\n", port_id);
- return (-ENODEV);
+ return -ENODEV;
}
dev = &rte_eth_devices[port_id];
if (dev->data->dev_conf.fdir_conf.mode != RTE_FDIR_MODE_PERFECT) {
PMD_DEBUG_TRACE("port %d: invalid FDIR mode=%u\n",
port_id, dev->data->dev_conf.fdir_conf.mode);
- return (-ENOSYS);
+ return -ENOSYS;
}
if ((fdir_filter->l4type == RTE_FDIR_L4TYPE_SCTP
PMD_DEBUG_TRACE(" Port are meaningless for SCTP and " \
"None l4type, source & destinations ports " \
"should be null!\n");
- return (-EINVAL);
+ return -EINVAL;
}
/* For now IPv6 is not supported with perfect filter */
if (fdir_filter->iptype == RTE_FDIR_IPTYPE_IPV6)
- return (-ENOTSUP);
+ return -ENOTSUP;
FUNC_PTR_OR_ERR_RET(*dev->dev_ops->fdir_remove_perfect_filter, -ENOTSUP);
return (*dev->dev_ops->fdir_remove_perfect_filter)(dev, fdir_filter,
if (!rte_eth_dev_is_valid_port(port_id)) {
PMD_DEBUG_TRACE("Invalid port_id=%d\n", port_id);
- return (-ENODEV);
+ return -ENODEV;
}
dev = &rte_eth_devices[port_id];
if (! (dev->data->dev_conf.fdir_conf.mode)) {
PMD_DEBUG_TRACE("port %d: pkt-filter disabled\n", port_id);
- return (-ENOSYS);
+ return -ENOSYS;
}
FUNC_PTR_OR_ERR_RET(*dev->dev_ops->fdir_set_masks, -ENOTSUP);
if (!rte_eth_dev_is_valid_port(port_id)) {
PMD_DEBUG_TRACE("Invalid port_id=%d\n", port_id);
- return (-ENODEV);
+ return -ENODEV;
}
dev = &rte_eth_devices[port_id];
if (!rte_eth_dev_is_valid_port(port_id)) {
PMD_DEBUG_TRACE("Invalid port_id=%d\n", port_id);
- return (-ENODEV);
+ return -ENODEV;
}
if ((fc_conf->send_xon != 0) && (fc_conf->send_xon != 1)) {
PMD_DEBUG_TRACE("Invalid send_xon, only 0/1 allowed\n");
- return (-EINVAL);
+ return -EINVAL;
}
dev = &rte_eth_devices[port_id];
if (!rte_eth_dev_is_valid_port(port_id)) {
PMD_DEBUG_TRACE("Invalid port_id=%d\n", port_id);
- return (-ENODEV);
+ return -ENODEV;
}
if (pfc_conf->priority > (ETH_DCB_NUM_USER_PRIORITIES - 1)) {
PMD_DEBUG_TRACE("Invalid priority, only 0-7 allowed\n");
- return (-EINVAL);
+ return -EINVAL;
}
dev = &rte_eth_devices[port_id];
/* High water, low water validation are device specific */
if (*dev->dev_ops->priority_flow_ctrl_set)
return (*dev->dev_ops->priority_flow_ctrl_set)(dev, pfc_conf);
- return (-ENOTSUP);
+ return -ENOTSUP;
}
-static inline int
+static int
rte_eth_check_reta_mask(struct rte_eth_rss_reta_entry64 *reta_conf,
uint16_t reta_size)
{
return -EINVAL;
}
-static inline int
+static int
rte_eth_check_reta_entry(struct rte_eth_rss_reta_entry64 *reta_conf,
uint16_t reta_size,
uint8_t max_rxq)
if (!rte_eth_dev_is_valid_port(port_id)) {
PMD_DEBUG_TRACE("Invalid port_id=%d\n", port_id);
- return (-ENODEV);
+ return -ENODEV;
}
rss_hash_protos = rss_conf->rss_hf;
((rss_hash_protos & ETH_RSS_PROTO_MASK) == 0)) {
PMD_DEBUG_TRACE("Invalid rss_hash_protos=0x%x\n",
rss_hash_protos);
- return (-EINVAL);
+ return -EINVAL;
}
dev = &rte_eth_devices[port_id];
FUNC_PTR_OR_ERR_RET(*dev->dev_ops->rss_hash_update, -ENOTSUP);
if (!rte_eth_dev_is_valid_port(port_id)) {
PMD_DEBUG_TRACE("Invalid port_id=%d\n", port_id);
- return (-ENODEV);
+ return -ENODEV;
}
dev = &rte_eth_devices[port_id];
if (!rte_eth_dev_is_valid_port(port_id)) {
PMD_DEBUG_TRACE("Invalid port_id=%d\n", port_id);
- return (-ENODEV);
+ return -ENODEV;
}
dev = &rte_eth_devices[port_id];
FUNC_PTR_OR_ERR_RET(*dev->dev_ops->dev_led_on, -ENOTSUP);
- return ((*dev->dev_ops->dev_led_on)(dev));
+ return (*dev->dev_ops->dev_led_on)(dev);
}
int
if (!rte_eth_dev_is_valid_port(port_id)) {
PMD_DEBUG_TRACE("Invalid port_id=%d\n", port_id);
- return (-ENODEV);
+ return -ENODEV;
}
dev = &rte_eth_devices[port_id];
FUNC_PTR_OR_ERR_RET(*dev->dev_ops->dev_led_off, -ENOTSUP);
- return ((*dev->dev_ops->dev_led_off)(dev));
+ return (*dev->dev_ops->dev_led_off)(dev);
}
/*
* Returns index into MAC address array of addr. Use 00:00:00:00:00:00 to find
* an empty spot.
*/
-static inline int
-get_mac_addr_index(uint8_t port_id, struct ether_addr *addr)
+static int
+get_mac_addr_index(uint8_t port_id, const struct ether_addr *addr)
{
struct rte_eth_dev_info dev_info;
struct rte_eth_dev *dev = &rte_eth_devices[port_id];
return -1;
}
-static struct ether_addr null_mac_addr = {{0, 0, 0, 0, 0, 0}};
+static const struct ether_addr null_mac_addr;
int
rte_eth_dev_mac_addr_add(uint8_t port_id, struct ether_addr *addr,
if (!rte_eth_dev_is_valid_port(port_id)) {
PMD_DEBUG_TRACE("Invalid port_id=%d\n", port_id);
- return (-ENODEV);
+ return -ENODEV;
}
dev = &rte_eth_devices[port_id];
if (is_zero_ether_addr(addr)) {
PMD_DEBUG_TRACE("port %d: Cannot add NULL MAC address\n",
port_id);
- return (-EINVAL);
+ return -EINVAL;
}
if (pool >= ETH_64_POOLS) {
PMD_DEBUG_TRACE("pool id must be 0-%d\n",ETH_64_POOLS - 1);
- return (-EINVAL);
+ return -EINVAL;
}
index = get_mac_addr_index(port_id, addr);
if (index < 0) {
PMD_DEBUG_TRACE("port %d: MAC address array full\n",
port_id);
- return (-ENOSPC);
+ return -ENOSPC;
}
} else {
pool_mask = dev->data->mac_pool_sel[index];
if (!rte_eth_dev_is_valid_port(port_id)) {
PMD_DEBUG_TRACE("Invalid port_id=%d\n", port_id);
- return (-ENODEV);
+ return -ENODEV;
}
dev = &rte_eth_devices[port_id];
index = get_mac_addr_index(port_id, addr);
if (index == 0) {
PMD_DEBUG_TRACE("port %d: Cannot remove default MAC address\n", port_id);
- return (-EADDRINUSE);
+ return -EADDRINUSE;
} else if (index < 0)
return 0; /* Do nothing if address wasn't found */
if (!rte_eth_dev_is_valid_port(port_id)) {
PMD_DEBUG_TRACE("set VF RX mode:Invalid port_id=%d\n",
port_id);
- return (-ENODEV);
+ return -ENODEV;
}
dev = &rte_eth_devices[port_id];
if (vf > num_vfs)
{
PMD_DEBUG_TRACE("set VF RX mode:invalid VF id %d\n", vf);
- return (-EINVAL);
+ return -EINVAL;
}
if (rx_mode == 0)
{
PMD_DEBUG_TRACE("set VF RX mode:mode mask ca not be zero\n");
- return (-EINVAL);
+ return -EINVAL;
}
FUNC_PTR_OR_ERR_RET(*dev->dev_ops->set_vf_rx_mode, -ENOTSUP);
return (*dev->dev_ops->set_vf_rx_mode)(dev, vf, rx_mode, on);
* Returns index into MAC address array of addr. Use 00:00:00:00:00:00 to find
* an empty spot.
*/
-static inline int
-get_hash_mac_addr_index(uint8_t port_id, struct ether_addr *addr)
+static int
+get_hash_mac_addr_index(uint8_t port_id, const struct ether_addr *addr)
{
struct rte_eth_dev_info dev_info;
struct rte_eth_dev *dev = &rte_eth_devices[port_id];
if (!rte_eth_dev_is_valid_port(port_id)) {
PMD_DEBUG_TRACE("unicast hash setting:Invalid port_id=%d\n",
port_id);
- return (-ENODEV);
+ return -ENODEV;
}
dev = &rte_eth_devices[port_id];
if (is_zero_ether_addr(addr)) {
PMD_DEBUG_TRACE("port %d: Cannot add NULL MAC address\n",
port_id);
- return (-EINVAL);
+ return -EINVAL;
}
index = get_hash_mac_addr_index(port_id, addr);
if (!on) {
PMD_DEBUG_TRACE("port %d: the MAC address was not"
"set in UTA\n", port_id);
- return (-EINVAL);
+ return -EINVAL;
}
index = get_hash_mac_addr_index(port_id, &null_mac_addr);
if (index < 0) {
PMD_DEBUG_TRACE("port %d: MAC address array full\n",
port_id);
- return (-ENOSPC);
+ return -ENOSPC;
}
}
if (!rte_eth_dev_is_valid_port(port_id)) {
PMD_DEBUG_TRACE("unicast hash setting:Invalid port_id=%d\n",
port_id);
- return (-ENODEV);
+ return -ENODEV;
}
dev = &rte_eth_devices[port_id];
if (!rte_eth_dev_is_valid_port(port_id)) {
PMD_DEBUG_TRACE("Invalid port_id=%d\n", port_id);
- return (-ENODEV);
+ return -ENODEV;
}
dev = &rte_eth_devices[port_id];
if (vf > num_vfs)
{
PMD_DEBUG_TRACE("port %d: invalid vf id\n", port_id);
- return (-EINVAL);
+ return -EINVAL;
}
FUNC_PTR_OR_ERR_RET(*dev->dev_ops->set_vf_rx, -ENOTSUP);
if (!rte_eth_dev_is_valid_port(port_id)) {
PMD_DEBUG_TRACE("set pool tx:Invalid port_id=%d\n", port_id);
- return (-ENODEV);
+ return -ENODEV;
}
dev = &rte_eth_devices[port_id];
if (vf > num_vfs)
{
PMD_DEBUG_TRACE("set pool tx:invalid pool id=%d\n", vf);
- return (-EINVAL);
+ return -EINVAL;
}
FUNC_PTR_OR_ERR_RET(*dev->dev_ops->set_vf_tx, -ENOTSUP);
if (!rte_eth_dev_is_valid_port(port_id)) {
PMD_DEBUG_TRACE("VF VLAN filter:invalid port id=%d\n",
port_id);
- return (-ENODEV);
+ return -ENODEV;
}
dev = &rte_eth_devices[port_id];
{
PMD_DEBUG_TRACE("VF VLAN filter:invalid VLAN id=%d\n",
vlan_id);
- return (-EINVAL);
+ return -EINVAL;
}
if (vf_mask == 0)
{
PMD_DEBUG_TRACE("VF VLAN filter:pool_mask can not be 0\n");
- return (-EINVAL);
+ return -EINVAL;
}
FUNC_PTR_OR_ERR_RET(*dev->dev_ops->set_vf_vlan_filter, -ENOTSUP);
if (!rte_eth_dev_is_valid_port(port_id)) {
PMD_DEBUG_TRACE("Invalid port_id=%d\n", port_id);
- return (-ENODEV);
+ return -ENODEV;
}
if (mirror_conf->rule_type_mask == 0) {
PMD_DEBUG_TRACE("mirror rule type can not be 0.\n");
- return (-EINVAL);
+ return -EINVAL;
}
if (mirror_conf->dst_pool >= ETH_64_POOLS) {
PMD_DEBUG_TRACE("Invalid dst pool, pool id must"
"be 0-%d\n",ETH_64_POOLS - 1);
- return (-EINVAL);
+ return -EINVAL;
}
if ((mirror_conf->rule_type_mask & ETH_VMDQ_POOL_MIRROR) &&
(mirror_conf->pool_mask == 0)) {
PMD_DEBUG_TRACE("Invalid mirror pool, pool mask can not"
"be 0.\n");
- return (-EINVAL);
+ return -EINVAL;
}
if(rule_id >= ETH_VMDQ_NUM_MIRROR_RULE)
{
PMD_DEBUG_TRACE("Invalid rule_id, rule_id must be 0-%d\n",
ETH_VMDQ_NUM_MIRROR_RULE - 1);
- return (-EINVAL);
+ return -EINVAL;
}
dev = &rte_eth_devices[port_id];
if (!rte_eth_dev_is_valid_port(port_id)) {
PMD_DEBUG_TRACE("Invalid port_id=%d\n", port_id);
- return (-ENODEV);
+ return -ENODEV;
}
if(rule_id >= ETH_VMDQ_NUM_MIRROR_RULE)
{
PMD_DEBUG_TRACE("Invalid rule_id, rule_id must be 0-%d\n",
ETH_VMDQ_NUM_MIRROR_RULE-1);
- return (-EINVAL);
+ return -EINVAL;
}
dev = &rte_eth_devices[port_id];
if (!rte_eth_dev_is_valid_port(port_id)) {
PMD_DEBUG_TRACE("Invalid port_id=%d\n", port_id);
- return (-ENODEV);
+ return -ENODEV;
}
dev = &rte_eth_devices[port_id];
struct rte_eth_dev_callback *user_cb;
if (!cb_fn)
- return (-EINVAL);
+ return -EINVAL;
if (!rte_eth_dev_is_valid_port(port_id)) {
PMD_DEBUG_TRACE("Invalid port_id=%d\n", port_id);
- return (-EINVAL);
+ return -EINVAL;
}
dev = &rte_eth_devices[port_id];
}
rte_spinlock_unlock(&rte_eth_dev_cb_lock);
- return ((user_cb == NULL) ? -ENOMEM : 0);
+ return (user_cb == NULL) ? -ENOMEM : 0;
}
int
struct rte_eth_dev_callback *cb, *next;
if (!cb_fn)
- return (-EINVAL);
+ return -EINVAL;
if (!rte_eth_dev_is_valid_port(port_id)) {
PMD_DEBUG_TRACE("Invalid port_id=%d\n", port_id);
- return (-EINVAL);
+ return -EINVAL;
}
dev = &rte_eth_devices[port_id];
}
rte_spinlock_unlock(&rte_eth_dev_cb_lock);
- return (ret);
+ return ret;
}
void
if (!rte_eth_dev_is_valid_port(port_id)) {
PMD_DEBUG_TRACE("Invalid port_id=%d\n", port_id);
- return (-ENODEV);
+ return -ENODEV;
}
if ((dev= &rte_eth_devices[port_id]) == NULL) {
PMD_DEBUG_TRACE("Invalid port device\n");
- return (-ENODEV);
+ return -ENODEV;
}
FUNC_PTR_OR_ERR_RET(*dev->dev_ops->bypass_init, -ENOTSUP);
if (!rte_eth_dev_is_valid_port(port_id)) {
PMD_DEBUG_TRACE("Invalid port_id=%d\n", port_id);
- return (-ENODEV);
+ return -ENODEV;
}
if ((dev= &rte_eth_devices[port_id]) == NULL) {
PMD_DEBUG_TRACE("Invalid port device\n");
- return (-ENODEV);
+ return -ENODEV;
}
FUNC_PTR_OR_ERR_RET(*dev->dev_ops->bypass_state_show, -ENOTSUP);
(*dev->dev_ops->bypass_state_show)(dev, state);
if (!rte_eth_dev_is_valid_port(port_id)) {
PMD_DEBUG_TRACE("Invalid port_id=%d\n", port_id);
- return (-ENODEV);
+ return -ENODEV;
}
if ((dev= &rte_eth_devices[port_id]) == NULL) {
PMD_DEBUG_TRACE("Invalid port device\n");
- return (-ENODEV);
+ return -ENODEV;
}
FUNC_PTR_OR_ERR_RET(*dev->dev_ops->bypass_state_set, -ENOTSUP);
if (!rte_eth_dev_is_valid_port(port_id)) {
PMD_DEBUG_TRACE("Invalid port_id=%d\n", port_id);
- return (-ENODEV);
+ return -ENODEV;
}
if ((dev= &rte_eth_devices[port_id]) == NULL) {
PMD_DEBUG_TRACE("Invalid port device\n");
- return (-ENODEV);
+ return -ENODEV;
}
FUNC_PTR_OR_ERR_RET(*dev->dev_ops->bypass_state_show, -ENOTSUP);
if (!rte_eth_dev_is_valid_port(port_id)) {
PMD_DEBUG_TRACE("Invalid port_id=%d\n", port_id);
- return (-ENODEV);
+ return -ENODEV;
}
if ((dev= &rte_eth_devices[port_id]) == NULL) {
PMD_DEBUG_TRACE("Invalid port device\n");
- return (-ENODEV);
+ return -ENODEV;
}
FUNC_PTR_OR_ERR_RET(*dev->dev_ops->bypass_event_set, -ENOTSUP);
if (!rte_eth_dev_is_valid_port(port_id)) {
PMD_DEBUG_TRACE("Invalid port_id=%d\n", port_id);
- return (-ENODEV);
+ return -ENODEV;
}
if ((dev= &rte_eth_devices[port_id]) == NULL) {
PMD_DEBUG_TRACE("Invalid port device\n");
- return (-ENODEV);
+ return -ENODEV;
}
FUNC_PTR_OR_ERR_RET(*dev->dev_ops->bypass_wd_timeout_set, -ENOTSUP);
if (!rte_eth_dev_is_valid_port(port_id)) {
PMD_DEBUG_TRACE("Invalid port_id=%d\n", port_id);
- return (-ENODEV);
+ return -ENODEV;
}
if ((dev= &rte_eth_devices[port_id]) == NULL) {
PMD_DEBUG_TRACE("Invalid port device\n");
- return (-ENODEV);
+ return -ENODEV;
}
FUNC_PTR_OR_ERR_RET(*dev->dev_ops->bypass_ver_show, -ENOTSUP);
if (!rte_eth_dev_is_valid_port(port_id)) {
PMD_DEBUG_TRACE("Invalid port_id=%d\n", port_id);
- return (-ENODEV);
+ return -ENODEV;
}
if ((dev= &rte_eth_devices[port_id]) == NULL) {
PMD_DEBUG_TRACE("Invalid port device\n");
- return (-ENODEV);
+ return -ENODEV;
}
FUNC_PTR_OR_ERR_RET(*dev->dev_ops->bypass_wd_timeout_show, -ENOTSUP);
if (!rte_eth_dev_is_valid_port(port_id)) {
PMD_DEBUG_TRACE("Invalid port_id=%d\n", port_id);
- return (-ENODEV);
+ return -ENODEV;
}
if ((dev= &rte_eth_devices[port_id]) == NULL) {
PMD_DEBUG_TRACE("Invalid port device\n");
- return (-ENODEV);
+ return -ENODEV;
}
FUNC_PTR_OR_ERR_RET(*dev->dev_ops->bypass_wd_reset, -ENOTSUP);
void *
rte_eth_add_rx_callback(uint8_t port_id, uint16_t queue_id,
- rte_rxtx_callback_fn fn, void *user_param)
+ rte_rx_callback_fn fn, void *user_param)
{
#ifndef RTE_ETHDEV_RXTX_CALLBACKS
rte_errno = ENOTSUP;
return NULL;
#endif
/* check input parameters */
- if (port_id >= nb_ports || fn == NULL ||
+ if (!rte_eth_dev_is_valid_port(port_id) || fn == NULL ||
queue_id >= rte_eth_devices[port_id].data->nb_rx_queues) {
rte_errno = EINVAL;
return NULL;
return NULL;
}
- cb->fn = fn;
+ cb->fn.rx = fn;
cb->param = user_param;
cb->next = rte_eth_devices[port_id].post_rx_burst_cbs[queue_id];
rte_eth_devices[port_id].post_rx_burst_cbs[queue_id] = cb;
void *
rte_eth_add_tx_callback(uint8_t port_id, uint16_t queue_id,
- rte_rxtx_callback_fn fn, void *user_param)
+ rte_tx_callback_fn fn, void *user_param)
{
#ifndef RTE_ETHDEV_RXTX_CALLBACKS
rte_errno = ENOTSUP;
return NULL;
#endif
/* check input parameters */
- if (port_id >= nb_ports || fn == NULL ||
+ if (!rte_eth_dev_is_valid_port(port_id) || fn == NULL ||
queue_id >= rte_eth_devices[port_id].data->nb_tx_queues) {
rte_errno = EINVAL;
return NULL;
return NULL;
}
- cb->fn = fn;
+ cb->fn.tx = fn;
cb->param = user_param;
cb->next = rte_eth_devices[port_id].pre_tx_burst_cbs[queue_id];
rte_eth_devices[port_id].pre_tx_burst_cbs[queue_id] = cb;
struct rte_eth_rxtx_callback *user_cb)
{
#ifndef RTE_ETHDEV_RXTX_CALLBACKS
- return (-ENOTSUP);
+ return -ENOTSUP;
#endif
/* Check input parameters. */
- if (port_id >= nb_ports || user_cb == NULL ||
+ if (!rte_eth_dev_is_valid_port(port_id) || user_cb == NULL ||
queue_id >= rte_eth_devices[port_id].data->nb_rx_queues) {
- return (-EINVAL);
+ return -EINVAL;
}
struct rte_eth_dev *dev = &rte_eth_devices[port_id];
} while (cb != NULL);
/* Callback wasn't found. */
- return (-EINVAL);
+ return -EINVAL;
}
int
struct rte_eth_rxtx_callback *user_cb)
{
#ifndef RTE_ETHDEV_RXTX_CALLBACKS
- return (-ENOTSUP);
+ return -ENOTSUP;
#endif
/* Check input parameters. */
- if (port_id >= nb_ports || user_cb == NULL ||
+ if (!rte_eth_dev_is_valid_port(port_id) || user_cb == NULL ||
queue_id >= rte_eth_devices[port_id].data->nb_tx_queues) {
- return (-EINVAL);
+ return -EINVAL;
}
struct rte_eth_dev *dev = &rte_eth_devices[port_id];
} while (cb != NULL);
/* Callback wasn't found. */
- return (-EINVAL);
+ return -EINVAL;
}
git.droids-corp.org / dpdk.git / blobdiff