#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
+#include <getopt.h>
#include "dirs.h"
#include "dp-packet.h"
#include "dpif-netdev.h"
#include "fatal-signal.h"
-#include "openvswitch/list.h"
#include "netdev-dpdk.h"
#include "netdev-provider.h"
#include "netdev-vport.h"
#include "odp-util.h"
-#include "ofp-print.h"
+#include "openvswitch/dynamic-string.h"
+#include "openvswitch/list.h"
+#include "openvswitch/ofp-print.h"
+#include "openvswitch/vlog.h"
#include "ovs-numa.h"
#include "ovs-thread.h"
#include "ovs-rcu.h"
#include "packets.h"
-#include "shash.h"
+#include "openvswitch/shash.h"
#include "smap.h"
#include "sset.h"
#include "unaligned.h"
#include "timeval.h"
#include "unixctl.h"
-#include "openvswitch/vlog.h"
#include "rte_config.h"
#include "rte_mbuf.h"
#include "rte_meter.h"
+#ifdef DPDK_PDUMP
+#include "rte_pdump.h"
+#endif
#include "rte_virtio_net.h"
VLOG_DEFINE_THIS_MODULE(dpdk);
+ sizeof(struct dp_packet) \
+ RTE_PKTMBUF_HEADROOM)
#define NETDEV_DPDK_MBUF_ALIGN 1024
+#define NETDEV_DPDK_MAX_PKT_LEN 9728
/* Max and min number of packets in the mempool. OVS tries to allocate a
* mempool with MAX_NB_MBUF: if this fails (because the system doesn't have
BUILD_ASSERT_DECL((MAX_NB_MBUF / ROUND_DOWN_POW2(MAX_NB_MBUF/MIN_NB_MBUF))
% MP_CACHE_SZ == 0);
+/*
+ * DPDK XSTATS Counter names definition
+ */
+#define XSTAT_RX_64_PACKETS "rx_size_64_packets"
+#define XSTAT_RX_65_TO_127_PACKETS "rx_size_65_to_127_packets"
+#define XSTAT_RX_128_TO_255_PACKETS "rx_size_128_to_255_packets"
+#define XSTAT_RX_256_TO_511_PACKETS "rx_size_256_to_511_packets"
+#define XSTAT_RX_512_TO_1023_PACKETS "rx_size_512_to_1023_packets"
+#define XSTAT_RX_1024_TO_1522_PACKETS "rx_size_1024_to_1522_packets"
+#define XSTAT_RX_1523_TO_MAX_PACKETS "rx_size_1523_to_max_packets"
+
+#define XSTAT_TX_64_PACKETS "tx_size_64_packets"
+#define XSTAT_TX_65_TO_127_PACKETS "tx_size_65_to_127_packets"
+#define XSTAT_TX_128_TO_255_PACKETS "tx_size_128_to_255_packets"
+#define XSTAT_TX_256_TO_511_PACKETS "tx_size_256_to_511_packets"
+#define XSTAT_TX_512_TO_1023_PACKETS "tx_size_512_to_1023_packets"
+#define XSTAT_TX_1024_TO_1522_PACKETS "tx_size_1024_to_1522_packets"
+#define XSTAT_TX_1523_TO_MAX_PACKETS "tx_size_1523_to_max_packets"
+
+#define XSTAT_TX_MULTICAST_PACKETS "tx_multicast_packets"
+#define XSTAT_RX_BROADCAST_PACKETS "rx_broadcast_packets"
+#define XSTAT_TX_BROADCAST_PACKETS "tx_broadcast_packets"
+#define XSTAT_RX_UNDERSIZED_ERRORS "rx_undersized_errors"
+#define XSTAT_RX_OVERSIZE_ERRORS "rx_oversize_errors"
+#define XSTAT_RX_FRAGMENTED_ERRORS "rx_fragmented_errors"
+#define XSTAT_RX_JABBER_ERRORS "rx_jabber_errors"
+
#define SOCKET0 0
#define NIC_PORT_RX_Q_SIZE 2048 /* Size of Physical NIC RX Queue, Max (n+32<=4096)*/
#define OVS_VHOST_QUEUE_DISABLED (-2) /* Queue was disabled by guest and not
* yet mapped to another queue. */
-static char *cuse_dev_name = NULL; /* Character device cuse_dev_name. */
static char *vhost_sock_dir = NULL; /* Location of vhost-user sockets */
-/*
- * Maximum amount of time in micro seconds to try and enqueue to vhost.
- */
-#define VHOST_ENQ_RETRY_USECS 100
+#define VHOST_ENQ_RETRY_NUM 8
+#define IF_NAME_SZ (PATH_MAX > IFNAMSIZ ? PATH_MAX : IFNAMSIZ)
static const struct rte_eth_conf port_conf = {
.rxmode = {
},
};
-enum { MAX_TX_QUEUE_LEN = 384 };
enum { DPDK_RING_SIZE = 256 };
BUILD_ASSERT_DECL(IS_POW2(DPDK_RING_SIZE));
enum { DRAIN_TSC = 200000ULL };
= OVS_LIST_INITIALIZER(&dpdk_mp_list);
/* This mutex must be used by non pmd threads when allocating or freeing
- * mbufs through mempools. Since dpdk_queue_pkts() and dpdk_queue_flush() may
- * use mempools, a non pmd thread should hold this mutex while calling them */
+ * mbufs through mempools. */
static struct ovs_mutex nonpmd_mempool_mutex = OVS_MUTEX_INITIALIZER;
struct dpdk_mp {
/* There should be one 'struct dpdk_tx_queue' created for
* each cpu core. */
struct dpdk_tx_queue {
- bool flush_tx; /* Set to true to flush queue everytime */
- /* pkts are queued. */
- int count;
rte_spinlock_t tx_lock; /* Protects the members and the NIC queue
* from concurrent access. It is used only
* if the queue is shared among different
- * pmd threads (see 'txq_needs_locking'). */
+ * pmd threads (see 'concurrent_txq'). */
int map; /* Mapping of configured vhost-user queues
* to enabled by guest. */
- uint64_t tsc;
- struct rte_mbuf *burst_pkts[MAX_TX_QUEUE_LEN];
};
/* dpdk has no way to remove dpdk ring ethernet devices
struct ovs_list list_node OVS_GUARDED_BY(dpdk_mutex);
};
+struct ingress_policer {
+ struct rte_meter_srtcm_params app_srtcm_params;
+ struct rte_meter_srtcm in_policer;
+ rte_spinlock_t policer_lock;
+};
+
struct netdev_dpdk {
struct netdev up;
int port_id;
struct rte_eth_link link;
int link_reset_cnt;
- /* The user might request more txqs than the NIC has. We remap those
- * ('up.n_txq') on these ('real_n_txq').
- * If the numbers match, 'txq_needs_locking' is false, otherwise it is
- * true and we will take a spinlock on transmission */
- int real_n_txq;
- int real_n_rxq;
- bool txq_needs_locking;
+ /* virtio identifier for vhost devices */
+ ovsrcu_index vid;
- /* virtio-net structure for vhost device */
- OVSRCU_TYPE(struct virtio_net *) virtio_dev;
+ /* True if vHost device is 'up' and has been reconfigured at least once */
+ bool vhost_reconfigured;
- /* Identifier used to distinguish vhost devices from each other */
- char vhost_id[PATH_MAX];
+ /* Identifier used to distinguish vhost devices from each other. It does
+ * not change during the lifetime of a struct netdev_dpdk. It can be read
+ * without holding any mutex. */
+ const char vhost_id[PATH_MAX];
/* In dpdk_list. */
struct ovs_list list_node OVS_GUARDED_BY(dpdk_mutex);
struct qos_conf *qos_conf;
rte_spinlock_t qos_lock;
+ /* The following properties cannot be changed when a device is running,
+ * so we remember the request and update them next time
+ * netdev_dpdk*_reconfigure() is called */
+ int requested_mtu;
+ int requested_n_txq;
+ int requested_n_rxq;
+
+ /* Socket ID detected when vHost device is brought up */
+ int requested_socket_id;
+
+ /* Ingress Policer */
+ OVSRCU_TYPE(struct ingress_policer *) ingress_policer;
+ uint32_t policer_rate;
+ uint32_t policer_burst;
+
+ /* DPDK-ETH Flow control */
+ struct rte_eth_fc_conf fc_conf;
};
struct netdev_rxq_dpdk {
static int netdev_dpdk_construct(struct netdev *);
-struct virtio_net * netdev_dpdk_get_virtio(const struct netdev_dpdk *dev);
+int netdev_dpdk_get_vid(const struct netdev_dpdk *dev);
+
+struct ingress_policer *
+netdev_dpdk_get_ingress_policer(const struct netdev_dpdk *dev);
static bool
is_dpdk_class(const struct netdev_class *class)
dmp->mtu = mtu;
dmp->refcount = 1;
mbp_priv.mbuf_data_room_size = MBUF_SIZE(mtu) - sizeof(struct dp_packet);
- mbp_priv.mbuf_priv_size = sizeof (struct dp_packet) - sizeof (struct rte_mbuf);
+ mbp_priv.mbuf_priv_size = sizeof (struct dp_packet)
+ - sizeof (struct rte_mbuf);
+ /* XXX: this is a really rough method of provisioning memory.
+ * It's impossible to determine what the exact memory requirements are when
+ * the number of ports and rxqs that utilize a particular mempool can change
+ * dynamically at runtime. For the moment, use this rough heurisitic.
+ */
+ if (mtu >= ETHER_MTU) {
+ mp_size = MAX_NB_MBUF;
+ } else {
+ mp_size = MIN_NB_MBUF;
+ }
- mp_size = MAX_NB_MBUF;
do {
if (snprintf(mp_name, RTE_MEMPOOL_NAMESIZE, "ovs_mp_%d_%d_%u",
dmp->mtu, dmp->socket_id, mp_size) < 0) {
}
static void
-dpdk_mp_put(struct dpdk_mp *dmp)
+dpdk_mp_put(struct dpdk_mp *dmp) OVS_REQUIRES(dpdk_mutex)
{
-
if (!dmp) {
return;
}
- dmp->refcount--;
- ovs_assert(dmp->refcount >= 0);
+ ovs_assert(dmp->refcount);
-#if 0
- /* I could not find any API to destroy mp. */
- if (dmp->refcount == 0) {
- list_delete(dmp->list_node);
- /* destroy mp-pool. */
+ if (!--dmp->refcount) {
+ ovs_list_remove(&dmp->list_node);
+ rte_mempool_free(dmp->mp);
}
-#endif
+}
+
+/* Tries to allocate new mempool on requested_socket_id with
+ * mbuf size corresponding to requested_mtu.
+ * On success new configuration will be applied.
+ * On error, device will be left unchanged. */
+static int
+netdev_dpdk_mempool_configure(struct netdev_dpdk *dev)
+ OVS_REQUIRES(dpdk_mutex)
+ OVS_REQUIRES(dev->mutex)
+{
+ uint32_t buf_size = dpdk_buf_size(dev->requested_mtu);
+ struct dpdk_mp *mp;
+
+ mp = dpdk_mp_get(dev->requested_socket_id, FRAME_LEN_TO_MTU(buf_size));
+ if (!mp) {
+ VLOG_ERR("Insufficient memory to create memory pool for netdev "
+ "%s, with MTU %d on socket %d\n",
+ dev->up.name, dev->requested_mtu, dev->requested_socket_id);
+ return ENOMEM;
+ } else {
+ dpdk_mp_put(dev->dpdk_mp);
+ dev->dpdk_mp = mp;
+ dev->mtu = dev->requested_mtu;
+ dev->socket_id = dev->requested_socket_id;
+ dev->max_packet_len = MTU_TO_FRAME_LEN(dev->mtu);
+ }
+
+ return 0;
}
static void
ovs_mutex_lock(&dpdk_mutex);
LIST_FOR_EACH (dev, list_node, &dpdk_list) {
ovs_mutex_lock(&dev->mutex);
- check_link_status(dev);
+ if (dev->type == DPDK_DEV_ETH) {
+ check_link_status(dev);
+ }
ovs_mutex_unlock(&dev->mutex);
}
ovs_mutex_unlock(&dpdk_mutex);
{
int diag = 0;
int i;
+ struct rte_eth_conf conf = port_conf;
+ if (dev->mtu > ETHER_MTU) {
+ conf.rxmode.jumbo_frame = 1;
+ conf.rxmode.max_rx_pkt_len = dev->max_packet_len;
+ } else {
+ conf.rxmode.jumbo_frame = 0;
+ conf.rxmode.max_rx_pkt_len = 0;
+ }
/* A device may report more queues than it makes available (this has
* been observed for Intel xl710, which reserves some of them for
* SRIOV): rte_eth_*_queue_setup will fail if a queue is not
VLOG_INFO("Retrying setup with (rxq:%d txq:%d)", n_rxq, n_txq);
}
- diag = rte_eth_dev_configure(dev->port_id, n_rxq, n_txq, &port_conf);
+ diag = rte_eth_dev_configure(dev->port_id, n_rxq, n_txq, &conf);
if (diag) {
+ VLOG_WARN("Interface %s eth_dev setup error %s\n",
+ dev->up.name, rte_strerror(-diag));
break;
}
}
dev->up.n_rxq = n_rxq;
- dev->real_n_txq = n_txq;
+ dev->up.n_txq = n_txq;
return 0;
}
return diag;
}
+static void
+dpdk_eth_flow_ctrl_setup(struct netdev_dpdk *dev) OVS_REQUIRES(dev->mutex)
+{
+ if (rte_eth_dev_flow_ctrl_set(dev->port_id, &dev->fc_conf)) {
+ VLOG_WARN("Failed to enable flow control on device %d", dev->port_id);
+ }
+}
static int
dpdk_eth_dev_init(struct netdev_dpdk *dev) OVS_REQUIRES(dpdk_mutex)
int diag;
int n_rxq, n_txq;
- if (dev->port_id < 0 || dev->port_id >= rte_eth_dev_count()) {
+ if (!rte_eth_dev_is_valid_port(dev->port_id)) {
return ENODEV;
}
dev->buf_size = mbp_priv->mbuf_data_room_size - RTE_PKTMBUF_HEADROOM;
dev->flags = NETDEV_UP | NETDEV_PROMISC;
+
+ /* Get the Flow control configuration for DPDK-ETH */
+ diag = rte_eth_dev_flow_ctrl_get(dev->port_id, &dev->fc_conf);
+ if (diag) {
+ VLOG_DBG("cannot get flow control parameters on port=%d, err=%d",
+ dev->port_id, diag);
+ }
+
return 0;
}
static struct netdev *
netdev_dpdk_alloc(void)
{
- struct netdev_dpdk *netdev = dpdk_rte_mzalloc(sizeof *netdev);
- return &netdev->up;
+ struct netdev_dpdk *dev;
+
+ if (!rte_eal_init_ret) { /* Only after successful initialization */
+ dev = dpdk_rte_mzalloc(sizeof *dev);
+ if (dev) {
+ return &dev->up;
+ }
+ }
+ return NULL;
}
static void
-netdev_dpdk_alloc_txq(struct netdev_dpdk *netdev, unsigned int n_txqs)
+netdev_dpdk_alloc_txq(struct netdev_dpdk *dev, unsigned int n_txqs)
{
unsigned i;
- netdev->tx_q = dpdk_rte_mzalloc(n_txqs * sizeof *netdev->tx_q);
+ dev->tx_q = dpdk_rte_mzalloc(n_txqs * sizeof *dev->tx_q);
for (i = 0; i < n_txqs; i++) {
- int numa_id = ovs_numa_get_numa_id(i);
-
- if (!netdev->txq_needs_locking) {
- /* Each index is considered as a cpu core id, since there should
- * be one tx queue for each cpu core. If the corresponding core
- * is not on the same numa node as 'netdev', flags the
- * 'flush_tx'. */
- netdev->tx_q[i].flush_tx = netdev->socket_id == numa_id;
- } else {
- /* Queues are shared among CPUs. Always flush */
- netdev->tx_q[i].flush_tx = true;
- }
-
/* Initialize map for vhost devices. */
- netdev->tx_q[i].map = OVS_VHOST_QUEUE_MAP_UNKNOWN;
- rte_spinlock_init(&netdev->tx_q[i].tx_lock);
+ dev->tx_q[i].map = OVS_VHOST_QUEUE_MAP_UNKNOWN;
+ rte_spinlock_init(&dev->tx_q[i].tx_lock);
}
}
static int
-netdev_dpdk_init(struct netdev *netdev_, unsigned int port_no,
+netdev_dpdk_init(struct netdev *netdev, unsigned int port_no,
enum dpdk_dev_type type)
OVS_REQUIRES(dpdk_mutex)
{
- struct netdev_dpdk *netdev = netdev_dpdk_cast(netdev_);
+ struct netdev_dpdk *dev = netdev_dpdk_cast(netdev);
int sid;
int err = 0;
- uint32_t buf_size;
- ovs_mutex_init(&netdev->mutex);
- ovs_mutex_lock(&netdev->mutex);
+ ovs_mutex_init(&dev->mutex);
+ ovs_mutex_lock(&dev->mutex);
- rte_spinlock_init(&netdev->stats_lock);
+ rte_spinlock_init(&dev->stats_lock);
/* If the 'sid' is negative, it means that the kernel fails
* to obtain the pci numa info. In that situation, always
sid = rte_lcore_to_socket_id(rte_get_master_lcore());
}
- netdev->socket_id = sid < 0 ? SOCKET0 : sid;
- netdev->port_id = port_no;
- netdev->type = type;
- netdev->flags = 0;
- netdev->mtu = ETHER_MTU;
- netdev->max_packet_len = MTU_TO_FRAME_LEN(netdev->mtu);
+ dev->socket_id = sid < 0 ? SOCKET0 : sid;
+ dev->requested_socket_id = dev->socket_id;
+ dev->port_id = port_no;
+ dev->type = type;
+ dev->flags = 0;
+ dev->requested_mtu = dev->mtu = ETHER_MTU;
+ dev->max_packet_len = MTU_TO_FRAME_LEN(dev->mtu);
+ ovsrcu_index_init(&dev->vid, -1);
+ dev->vhost_reconfigured = false;
- buf_size = dpdk_buf_size(netdev->mtu);
- netdev->dpdk_mp = dpdk_mp_get(netdev->socket_id, FRAME_LEN_TO_MTU(buf_size));
- if (!netdev->dpdk_mp) {
- err = ENOMEM;
+ err = netdev_dpdk_mempool_configure(dev);
+ if (err) {
goto unlock;
}
/* Initialise QoS configuration to NULL and qos lock to unlocked */
- netdev->qos_conf = NULL;
- rte_spinlock_init(&netdev->qos_lock);
+ dev->qos_conf = NULL;
+ rte_spinlock_init(&dev->qos_lock);
+
+ /* Initialise rcu pointer for ingress policer to NULL */
+ ovsrcu_init(&dev->ingress_policer, NULL);
+ dev->policer_rate = 0;
+ dev->policer_burst = 0;
- netdev_->n_txq = NR_QUEUE;
- netdev_->n_rxq = NR_QUEUE;
- netdev_->requested_n_rxq = NR_QUEUE;
- netdev->real_n_txq = NR_QUEUE;
+ netdev->n_rxq = NR_QUEUE;
+ netdev->n_txq = NR_QUEUE;
+ dev->requested_n_rxq = netdev->n_rxq;
+ dev->requested_n_txq = netdev->n_txq;
+ /* Initialize the flow control to NULL */
+ memset(&dev->fc_conf, 0, sizeof dev->fc_conf);
if (type == DPDK_DEV_ETH) {
- netdev_dpdk_alloc_txq(netdev, NR_QUEUE);
- err = dpdk_eth_dev_init(netdev);
+ err = dpdk_eth_dev_init(dev);
if (err) {
goto unlock;
}
+ netdev_dpdk_alloc_txq(dev, netdev->n_txq);
} else {
- netdev_dpdk_alloc_txq(netdev, OVS_VHOST_MAX_QUEUE_NUM);
+ netdev_dpdk_alloc_txq(dev, OVS_VHOST_MAX_QUEUE_NUM);
+ /* Enable DPDK_DEV_VHOST device and set promiscuous mode flag. */
+ dev->flags = NETDEV_UP | NETDEV_PROMISC;
}
- ovs_list_push_back(&dpdk_list, &netdev->list_node);
+ ovs_list_push_back(&dpdk_list, &dev->list_node);
unlock:
- if (err) {
- rte_free(netdev->tx_q);
- }
- ovs_mutex_unlock(&netdev->mutex);
+ ovs_mutex_unlock(&dev->mutex);
return err;
}
}
static int
-vhost_construct_helper(struct netdev *netdev_) OVS_REQUIRES(dpdk_mutex)
-{
- if (rte_eal_init_ret) {
- return rte_eal_init_ret;
- }
-
- return netdev_dpdk_init(netdev_, -1, DPDK_DEV_VHOST);
-}
-
-static int
-netdev_dpdk_vhost_cuse_construct(struct netdev *netdev_)
-{
- struct netdev_dpdk *netdev = netdev_dpdk_cast(netdev_);
- int err;
-
- ovs_mutex_lock(&dpdk_mutex);
- strncpy(netdev->vhost_id, netdev->up.name, sizeof(netdev->vhost_id));
- err = vhost_construct_helper(netdev_);
- ovs_mutex_unlock(&dpdk_mutex);
- return err;
-}
-
-static int
-netdev_dpdk_vhost_user_construct(struct netdev *netdev_)
+netdev_dpdk_vhost_user_construct(struct netdev *netdev)
{
- struct netdev_dpdk *netdev = netdev_dpdk_cast(netdev_);
- const char *name = netdev_->name;
+ struct netdev_dpdk *dev = netdev_dpdk_cast(netdev);
+ const char *name = netdev->name;
int err;
+ uint64_t flags = 0;
/* 'name' is appended to 'vhost_sock_dir' and used to create a socket in
* the file system. '/' or '\' would traverse directories, so they're not
return EINVAL;
}
+ if (rte_eal_init_ret) {
+ return rte_eal_init_ret;
+ }
+
ovs_mutex_lock(&dpdk_mutex);
/* Take the name of the vhost-user port and append it to the location where
* the socket is to be created, then register the socket.
*/
- snprintf(netdev->vhost_id, sizeof(netdev->vhost_id), "%s/%s",
+ snprintf(CONST_CAST(char *, dev->vhost_id), sizeof dev->vhost_id, "%s/%s",
vhost_sock_dir, name);
- err = rte_vhost_driver_register(netdev->vhost_id);
+ err = rte_vhost_driver_register(dev->vhost_id, flags);
if (err) {
VLOG_ERR("vhost-user socket device setup failure for socket %s\n",
- netdev->vhost_id);
+ dev->vhost_id);
} else {
- fatal_signal_add_file_to_unlink(netdev->vhost_id);
+ fatal_signal_add_file_to_unlink(dev->vhost_id);
VLOG_INFO("Socket %s created for vhost-user port %s\n",
- netdev->vhost_id, name);
- err = vhost_construct_helper(netdev_);
+ dev->vhost_id, name);
+ err = netdev_dpdk_init(netdev, -1, DPDK_DEV_VHOST);
}
ovs_mutex_unlock(&dpdk_mutex);
}
static void
-netdev_dpdk_destruct(struct netdev *netdev_)
+netdev_dpdk_destruct(struct netdev *netdev)
{
- struct netdev_dpdk *dev = netdev_dpdk_cast(netdev_);
+ struct netdev_dpdk *dev = netdev_dpdk_cast(netdev);
+ ovs_mutex_lock(&dpdk_mutex);
ovs_mutex_lock(&dev->mutex);
+
rte_eth_dev_stop(dev->port_id);
- ovs_mutex_unlock(&dev->mutex);
+ free(ovsrcu_get_protected(struct ingress_policer *,
+ &dev->ingress_policer));
- ovs_mutex_lock(&dpdk_mutex);
rte_free(dev->tx_q);
ovs_list_remove(&dev->list_node);
dpdk_mp_put(dev->dpdk_mp);
+
+ ovs_mutex_unlock(&dev->mutex);
ovs_mutex_unlock(&dpdk_mutex);
}
+/* rte_vhost_driver_unregister() can call back destroy_device(), which will
+ * try to acquire 'dpdk_mutex' and possibly 'dev->mutex'. To avoid a
+ * deadlock, none of the mutexes must be held while calling this function. */
+static int
+dpdk_vhost_driver_unregister(struct netdev_dpdk *dev)
+ OVS_EXCLUDED(dpdk_mutex)
+ OVS_EXCLUDED(dev->mutex)
+{
+ return rte_vhost_driver_unregister(dev->vhost_id);
+}
+
static void
-netdev_dpdk_vhost_destruct(struct netdev *netdev_)
+netdev_dpdk_vhost_destruct(struct netdev *netdev)
{
- struct netdev_dpdk *dev = netdev_dpdk_cast(netdev_);
+ struct netdev_dpdk *dev = netdev_dpdk_cast(netdev);
+
+ ovs_mutex_lock(&dpdk_mutex);
+ ovs_mutex_lock(&dev->mutex);
/* Guest becomes an orphan if still attached. */
- if (netdev_dpdk_get_virtio(dev) != NULL) {
+ if (netdev_dpdk_get_vid(dev) >= 0) {
VLOG_ERR("Removing port '%s' while vhost device still attached.",
- netdev_->name);
+ netdev->name);
VLOG_ERR("To restore connectivity after re-adding of port, VM on socket"
" '%s' must be restarted.",
dev->vhost_id);
}
- if (rte_vhost_driver_unregister(dev->vhost_id)) {
- VLOG_ERR("Unable to remove vhost-user socket %s", dev->vhost_id);
- } else {
- fatal_signal_remove_file_to_unlink(dev->vhost_id);
- }
+ free(ovsrcu_get_protected(struct ingress_policer *,
+ &dev->ingress_policer));
- ovs_mutex_lock(&dpdk_mutex);
rte_free(dev->tx_q);
ovs_list_remove(&dev->list_node);
dpdk_mp_put(dev->dpdk_mp);
+
+ ovs_mutex_unlock(&dev->mutex);
ovs_mutex_unlock(&dpdk_mutex);
+
+ if (dpdk_vhost_driver_unregister(dev)) {
+ VLOG_ERR("Unable to remove vhost-user socket %s", dev->vhost_id);
+ } else {
+ fatal_signal_remove_file_to_unlink(dev->vhost_id);
+ }
}
static void
-netdev_dpdk_dealloc(struct netdev *netdev_)
+netdev_dpdk_dealloc(struct netdev *netdev)
{
- struct netdev_dpdk *netdev = netdev_dpdk_cast(netdev_);
+ struct netdev_dpdk *dev = netdev_dpdk_cast(netdev);
- rte_free(netdev);
+ rte_free(dev);
}
static int
ovs_mutex_lock(&dev->mutex);
- smap_add_format(args, "requested_rx_queues", "%d", netdev->requested_n_rxq);
+ smap_add_format(args, "requested_rx_queues", "%d", dev->requested_n_rxq);
smap_add_format(args, "configured_rx_queues", "%d", netdev->n_rxq);
- smap_add_format(args, "requested_tx_queues", "%d", netdev->n_txq);
- smap_add_format(args, "configured_tx_queues", "%d", dev->real_n_txq);
- ovs_mutex_unlock(&dev->mutex);
-
- return 0;
-}
-
-static int
-netdev_dpdk_set_config(struct netdev *netdev, const struct smap *args)
-{
- struct netdev_dpdk *dev = netdev_dpdk_cast(netdev);
-
- ovs_mutex_lock(&dev->mutex);
- netdev->requested_n_rxq = MAX(smap_get_int(args, "n_rxq",
- netdev->requested_n_rxq), 1);
- netdev_change_seq_changed(netdev);
+ smap_add_format(args, "requested_tx_queues", "%d", dev->requested_n_txq);
+ smap_add_format(args, "configured_tx_queues", "%d", netdev->n_txq);
+ smap_add_format(args, "mtu", "%d", dev->mtu);
ovs_mutex_unlock(&dev->mutex);
return 0;
}
-static int
-netdev_dpdk_get_numa_id(const struct netdev *netdev_)
+static void
+dpdk_set_rxq_config(struct netdev_dpdk *dev, const struct smap *args)
{
- struct netdev_dpdk *netdev = netdev_dpdk_cast(netdev_);
+ int new_n_rxq;
- return netdev->socket_id;
+ new_n_rxq = MAX(smap_get_int(args, "n_rxq", dev->requested_n_rxq), 1);
+ if (new_n_rxq != dev->requested_n_rxq) {
+ dev->requested_n_rxq = new_n_rxq;
+ netdev_request_reconfigure(&dev->up);
+ }
}
-/* Sets the number of tx queues and rx queues for the dpdk interface.
- * If the configuration fails, do not try restoring its old configuration
- * and just returns the error. */
static int
-netdev_dpdk_set_multiq(struct netdev *netdev_, unsigned int n_txq,
- unsigned int n_rxq)
+netdev_dpdk_set_config(struct netdev *netdev, const struct smap *args)
{
- struct netdev_dpdk *netdev = netdev_dpdk_cast(netdev_);
- int err = 0;
- int old_rxq, old_txq;
-
- if (netdev->up.n_txq == n_txq && netdev->up.n_rxq == n_rxq) {
- return err;
- }
-
- ovs_mutex_lock(&dpdk_mutex);
- ovs_mutex_lock(&netdev->mutex);
+ struct netdev_dpdk *dev = netdev_dpdk_cast(netdev);
- rte_eth_dev_stop(netdev->port_id);
+ ovs_mutex_lock(&dev->mutex);
- old_txq = netdev->up.n_txq;
- old_rxq = netdev->up.n_rxq;
- netdev->up.n_txq = n_txq;
- netdev->up.n_rxq = n_rxq;
+ dpdk_set_rxq_config(dev, args);
- rte_free(netdev->tx_q);
- err = dpdk_eth_dev_init(netdev);
- netdev_dpdk_alloc_txq(netdev, netdev->real_n_txq);
- if (err) {
- /* If there has been an error, it means that the requested queues
- * have not been created. Restore the old numbers. */
- netdev->up.n_txq = old_txq;
- netdev->up.n_rxq = old_rxq;
- }
+ /* Flow control support is only available for DPDK Ethernet ports. */
+ bool rx_fc_en = false;
+ bool tx_fc_en = false;
+ enum rte_eth_fc_mode fc_mode_set[2][2] =
+ {{RTE_FC_NONE, RTE_FC_TX_PAUSE},
+ {RTE_FC_RX_PAUSE, RTE_FC_FULL}
+ };
+ rx_fc_en = smap_get_bool(args, "rx-flow-ctrl", false);
+ tx_fc_en = smap_get_bool(args, "tx-flow-ctrl", false);
+ dev->fc_conf.autoneg = smap_get_bool(args, "flow-ctrl-autoneg", false);
+ dev->fc_conf.mode = fc_mode_set[tx_fc_en][rx_fc_en];
- netdev->txq_needs_locking = netdev->real_n_txq != netdev->up.n_txq;
+ dpdk_eth_flow_ctrl_setup(dev);
- ovs_mutex_unlock(&netdev->mutex);
- ovs_mutex_unlock(&dpdk_mutex);
+ ovs_mutex_unlock(&dev->mutex);
- return err;
+ return 0;
}
static int
-netdev_dpdk_vhost_cuse_set_multiq(struct netdev *netdev_, unsigned int n_txq,
- unsigned int n_rxq)
+netdev_dpdk_ring_set_config(struct netdev *netdev, const struct smap *args)
{
- struct netdev_dpdk *netdev = netdev_dpdk_cast(netdev_);
- int err = 0;
-
- if (netdev->up.n_txq == n_txq && netdev->up.n_rxq == n_rxq) {
- return err;
- }
+ struct netdev_dpdk *dev = netdev_dpdk_cast(netdev);
- ovs_mutex_lock(&dpdk_mutex);
- ovs_mutex_lock(&netdev->mutex);
+ ovs_mutex_lock(&dev->mutex);
+ dpdk_set_rxq_config(dev, args);
+ ovs_mutex_unlock(&dev->mutex);
- netdev->up.n_txq = n_txq;
- netdev->real_n_txq = 1;
- netdev->up.n_rxq = 1;
- netdev->txq_needs_locking = netdev->real_n_txq != netdev->up.n_txq;
+ return 0;
+}
- ovs_mutex_unlock(&netdev->mutex);
- ovs_mutex_unlock(&dpdk_mutex);
+static int
+netdev_dpdk_get_numa_id(const struct netdev *netdev)
+{
+ struct netdev_dpdk *dev = netdev_dpdk_cast(netdev);
- return err;
+ return dev->socket_id;
}
+/* Sets the number of tx queues for the dpdk interface. */
static int
-netdev_dpdk_vhost_set_multiq(struct netdev *netdev_, unsigned int n_txq,
- unsigned int n_rxq)
+netdev_dpdk_set_tx_multiq(struct netdev *netdev, unsigned int n_txq)
{
- struct netdev_dpdk *netdev = netdev_dpdk_cast(netdev_);
- int err = 0;
-
- if (netdev->up.n_txq == n_txq && netdev->up.n_rxq == n_rxq) {
- return err;
- }
+ struct netdev_dpdk *dev = netdev_dpdk_cast(netdev);
- ovs_mutex_lock(&dpdk_mutex);
- ovs_mutex_lock(&netdev->mutex);
+ ovs_mutex_lock(&dev->mutex);
- netdev->up.n_txq = n_txq;
- netdev->up.n_rxq = n_rxq;
+ if (dev->requested_n_txq == n_txq) {
+ goto out;
+ }
- ovs_mutex_unlock(&netdev->mutex);
- ovs_mutex_unlock(&dpdk_mutex);
+ dev->requested_n_txq = n_txq;
+ netdev_request_reconfigure(netdev);
- return err;
+out:
+ ovs_mutex_unlock(&dev->mutex);
+ return 0;
}
static struct netdev_rxq *
}
static struct netdev_rxq_dpdk *
-netdev_rxq_dpdk_cast(const struct netdev_rxq *rx)
+netdev_rxq_dpdk_cast(const struct netdev_rxq *rxq)
{
- return CONTAINER_OF(rx, struct netdev_rxq_dpdk, up);
+ return CONTAINER_OF(rxq, struct netdev_rxq_dpdk, up);
}
static int
-netdev_dpdk_rxq_construct(struct netdev_rxq *rxq_)
+netdev_dpdk_rxq_construct(struct netdev_rxq *rxq)
{
- struct netdev_rxq_dpdk *rx = netdev_rxq_dpdk_cast(rxq_);
- struct netdev_dpdk *netdev = netdev_dpdk_cast(rx->up.netdev);
+ struct netdev_rxq_dpdk *rx = netdev_rxq_dpdk_cast(rxq);
+ struct netdev_dpdk *dev = netdev_dpdk_cast(rxq->netdev);
- ovs_mutex_lock(&netdev->mutex);
- rx->port_id = netdev->port_id;
- ovs_mutex_unlock(&netdev->mutex);
+ ovs_mutex_lock(&dev->mutex);
+ rx->port_id = dev->port_id;
+ ovs_mutex_unlock(&dev->mutex);
return 0;
}
static void
-netdev_dpdk_rxq_destruct(struct netdev_rxq *rxq_ OVS_UNUSED)
+netdev_dpdk_rxq_destruct(struct netdev_rxq *rxq OVS_UNUSED)
{
}
static void
-netdev_dpdk_rxq_dealloc(struct netdev_rxq *rxq_)
+netdev_dpdk_rxq_dealloc(struct netdev_rxq *rxq)
{
- struct netdev_rxq_dpdk *rx = netdev_rxq_dpdk_cast(rxq_);
+ struct netdev_rxq_dpdk *rx = netdev_rxq_dpdk_cast(rxq);
rte_free(rx);
}
static inline void
-dpdk_queue_flush__(struct netdev_dpdk *dev, int qid)
+netdev_dpdk_eth_tx_burst(struct netdev_dpdk *dev, int qid,
+ struct rte_mbuf **pkts, int cnt)
{
- struct dpdk_tx_queue *txq = &dev->tx_q[qid];
uint32_t nb_tx = 0;
- while (nb_tx != txq->count) {
+ while (nb_tx != cnt) {
uint32_t ret;
- ret = rte_eth_tx_burst(dev->port_id, qid, txq->burst_pkts + nb_tx,
- txq->count - nb_tx);
+ ret = rte_eth_tx_burst(dev->port_id, qid, pkts + nb_tx, cnt - nb_tx);
if (!ret) {
break;
}
nb_tx += ret;
}
- if (OVS_UNLIKELY(nb_tx != txq->count)) {
+ if (OVS_UNLIKELY(nb_tx != cnt)) {
/* free buffers, which we couldn't transmit, one at a time (each
* packet could come from a different mempool) */
int i;
- for (i = nb_tx; i < txq->count; i++) {
- rte_pktmbuf_free(txq->burst_pkts[i]);
+ for (i = nb_tx; i < cnt; i++) {
+ rte_pktmbuf_free(pkts[i]);
}
rte_spinlock_lock(&dev->stats_lock);
- dev->stats.tx_dropped += txq->count-nb_tx;
+ dev->stats.tx_dropped += cnt - nb_tx;
rte_spinlock_unlock(&dev->stats_lock);
}
+}
+
+static inline bool
+netdev_dpdk_policer_pkt_handle(struct rte_meter_srtcm *meter,
+ struct rte_mbuf *pkt, uint64_t time)
+{
+ uint32_t pkt_len = rte_pktmbuf_pkt_len(pkt) - sizeof(struct ether_hdr);
- txq->count = 0;
- txq->tsc = rte_get_timer_cycles();
+ return rte_meter_srtcm_color_blind_check(meter, time, pkt_len) ==
+ e_RTE_METER_GREEN;
}
-static inline void
-dpdk_queue_flush(struct netdev_dpdk *dev, int qid)
+static int
+netdev_dpdk_policer_run(struct rte_meter_srtcm *meter,
+ struct rte_mbuf **pkts, int pkt_cnt)
{
- struct dpdk_tx_queue *txq = &dev->tx_q[qid];
+ int i = 0;
+ int cnt = 0;
+ struct rte_mbuf *pkt = NULL;
+ uint64_t current_time = rte_rdtsc();
- if (txq->count == 0) {
- return;
+ for (i = 0; i < pkt_cnt; i++) {
+ pkt = pkts[i];
+ /* Handle current packet */
+ if (netdev_dpdk_policer_pkt_handle(meter, pkt, current_time)) {
+ if (cnt != i) {
+ pkts[cnt] = pkt;
+ }
+ cnt++;
+ } else {
+ rte_pktmbuf_free(pkt);
+ }
}
- dpdk_queue_flush__(dev, qid);
+
+ return cnt;
+}
+
+static int
+ingress_policer_run(struct ingress_policer *policer, struct rte_mbuf **pkts,
+ int pkt_cnt)
+{
+ int cnt = 0;
+
+ rte_spinlock_lock(&policer->policer_lock);
+ cnt = netdev_dpdk_policer_run(&policer->in_policer, pkts, pkt_cnt);
+ rte_spinlock_unlock(&policer->policer_lock);
+
+ return cnt;
}
static bool
-is_vhost_running(struct virtio_net *dev)
+is_vhost_running(struct netdev_dpdk *dev)
{
- return (dev != NULL && (dev->flags & VIRTIO_DEV_RUNNING));
+ return (netdev_dpdk_get_vid(dev) >= 0 && dev->vhost_reconfigured);
+}
+
+static inline void
+netdev_dpdk_vhost_update_rx_size_counters(struct netdev_stats *stats,
+ unsigned int packet_size)
+{
+ /* Hard-coded search for the size bucket. */
+ if (packet_size < 256) {
+ if (packet_size >= 128) {
+ stats->rx_128_to_255_packets++;
+ } else if (packet_size <= 64) {
+ stats->rx_1_to_64_packets++;
+ } else {
+ stats->rx_65_to_127_packets++;
+ }
+ } else {
+ if (packet_size >= 1523) {
+ stats->rx_1523_to_max_packets++;
+ } else if (packet_size >= 1024) {
+ stats->rx_1024_to_1522_packets++;
+ } else if (packet_size < 512) {
+ stats->rx_256_to_511_packets++;
+ } else {
+ stats->rx_512_to_1023_packets++;
+ }
+ }
}
static inline void
netdev_dpdk_vhost_update_rx_counters(struct netdev_stats *stats,
- struct dp_packet **packets, int count)
+ struct dp_packet **packets, int count,
+ int dropped)
{
int i;
+ unsigned int packet_size;
struct dp_packet *packet;
stats->rx_packets += count;
+ stats->rx_dropped += dropped;
for (i = 0; i < count; i++) {
packet = packets[i];
+ packet_size = dp_packet_size(packet);
- if (OVS_UNLIKELY(dp_packet_size(packet) < ETH_HEADER_LEN)) {
+ if (OVS_UNLIKELY(packet_size < ETH_HEADER_LEN)) {
/* This only protects the following multicast counting from
* too short packets, but it does not stop the packet from
* further processing. */
continue;
}
+ netdev_dpdk_vhost_update_rx_size_counters(stats, packet_size);
+
struct eth_header *eh = (struct eth_header *) dp_packet_data(packet);
if (OVS_UNLIKELY(eth_addr_is_multicast(eh->eth_dst))) {
stats->multicast++;
}
- stats->rx_bytes += dp_packet_size(packet);
+ stats->rx_bytes += packet_size;
}
}
* The receive path for the vhost port is the TX path out from guest.
*/
static int
-netdev_dpdk_vhost_rxq_recv(struct netdev_rxq *rxq_,
- struct dp_packet **packets, int *c)
-{
- struct netdev_rxq_dpdk *rx = netdev_rxq_dpdk_cast(rxq_);
- struct netdev *netdev = rx->up.netdev;
- struct netdev_dpdk *vhost_dev = netdev_dpdk_cast(netdev);
- struct virtio_net *virtio_dev = netdev_dpdk_get_virtio(vhost_dev);
- int qid = rxq_->queue_id;
+netdev_dpdk_vhost_rxq_recv(struct netdev_rxq *rxq,
+ struct dp_packet_batch *batch)
+{
+ struct netdev_dpdk *dev = netdev_dpdk_cast(rxq->netdev);
+ int qid = rxq->queue_id;
+ struct ingress_policer *policer = netdev_dpdk_get_ingress_policer(dev);
uint16_t nb_rx = 0;
+ uint16_t dropped = 0;
- if (OVS_UNLIKELY(!is_vhost_running(virtio_dev))) {
+ if (OVS_UNLIKELY(!is_vhost_running(dev)
+ || !(dev->flags & NETDEV_UP))) {
return EAGAIN;
}
- if (rxq_->queue_id >= vhost_dev->real_n_rxq) {
- return EOPNOTSUPP;
- }
-
- nb_rx = rte_vhost_dequeue_burst(virtio_dev, qid * VIRTIO_QNUM + VIRTIO_TXQ,
- vhost_dev->dpdk_mp->mp,
- (struct rte_mbuf **)packets,
+ nb_rx = rte_vhost_dequeue_burst(netdev_dpdk_get_vid(dev),
+ qid * VIRTIO_QNUM + VIRTIO_TXQ,
+ dev->dpdk_mp->mp,
+ (struct rte_mbuf **) batch->packets,
NETDEV_MAX_BURST);
if (!nb_rx) {
return EAGAIN;
}
- rte_spinlock_lock(&vhost_dev->stats_lock);
- netdev_dpdk_vhost_update_rx_counters(&vhost_dev->stats, packets, nb_rx);
- rte_spinlock_unlock(&vhost_dev->stats_lock);
+ if (policer) {
+ dropped = nb_rx;
+ nb_rx = ingress_policer_run(policer,
+ (struct rte_mbuf **) batch->packets,
+ nb_rx);
+ dropped -= nb_rx;
+ }
+
+ rte_spinlock_lock(&dev->stats_lock);
+ netdev_dpdk_vhost_update_rx_counters(&dev->stats, batch->packets,
+ nb_rx, dropped);
+ rte_spinlock_unlock(&dev->stats_lock);
- *c = (int) nb_rx;
+ batch->count = (int) nb_rx;
return 0;
}
static int
-netdev_dpdk_rxq_recv(struct netdev_rxq *rxq_, struct dp_packet **packets,
- int *c)
+netdev_dpdk_rxq_recv(struct netdev_rxq *rxq, struct dp_packet_batch *batch)
{
- struct netdev_rxq_dpdk *rx = netdev_rxq_dpdk_cast(rxq_);
- struct netdev *netdev = rx->up.netdev;
- struct netdev_dpdk *dev = netdev_dpdk_cast(netdev);
+ struct netdev_rxq_dpdk *rx = netdev_rxq_dpdk_cast(rxq);
+ struct netdev_dpdk *dev = netdev_dpdk_cast(rxq->netdev);
+ struct ingress_policer *policer = netdev_dpdk_get_ingress_policer(dev);
int nb_rx;
+ int dropped = 0;
- /* There is only one tx queue for this core. Do not flush other
- * queues.
- * Do not flush tx queue which is shared among CPUs
- * since it is always flushed */
- if (rxq_->queue_id == rte_lcore_id() &&
- OVS_LIKELY(!dev->txq_needs_locking)) {
- dpdk_queue_flush(dev, rxq_->queue_id);
- }
-
- nb_rx = rte_eth_rx_burst(rx->port_id, rxq_->queue_id,
- (struct rte_mbuf **) packets,
+ nb_rx = rte_eth_rx_burst(rx->port_id, rxq->queue_id,
+ (struct rte_mbuf **) batch->packets,
NETDEV_MAX_BURST);
if (!nb_rx) {
return EAGAIN;
}
- *c = nb_rx;
+ if (policer) {
+ dropped = nb_rx;
+ nb_rx = ingress_policer_run(policer,
+ (struct rte_mbuf **)batch->packets,
+ nb_rx);
+ dropped -= nb_rx;
+ }
+
+ /* Update stats to reflect dropped packets */
+ if (OVS_UNLIKELY(dropped)) {
+ rte_spinlock_lock(&dev->stats_lock);
+ dev->stats.rx_dropped += dropped;
+ rte_spinlock_unlock(&dev->stats_lock);
+ }
+
+ batch->count = nb_rx;
return 0;
}
static void
__netdev_dpdk_vhost_send(struct netdev *netdev, int qid,
- struct dp_packet **pkts, int cnt,
- bool may_steal)
+ struct dp_packet **pkts, int cnt)
{
- struct netdev_dpdk *vhost_dev = netdev_dpdk_cast(netdev);
- struct virtio_net *virtio_dev = netdev_dpdk_get_virtio(vhost_dev);
+ struct netdev_dpdk *dev = netdev_dpdk_cast(netdev);
struct rte_mbuf **cur_pkts = (struct rte_mbuf **) pkts;
unsigned int total_pkts = cnt;
- unsigned int qos_pkts = cnt;
- uint64_t start = 0;
+ unsigned int qos_pkts = 0;
+ unsigned int mtu_dropped = 0;
+ int i, retries = 0;
- qid = vhost_dev->tx_q[qid % vhost_dev->real_n_txq].map;
+ qid = dev->tx_q[qid % netdev->n_txq].map;
- if (OVS_UNLIKELY(!is_vhost_running(virtio_dev) || qid < 0)) {
- rte_spinlock_lock(&vhost_dev->stats_lock);
- vhost_dev->stats.tx_dropped+= cnt;
- rte_spinlock_unlock(&vhost_dev->stats_lock);
+ if (OVS_UNLIKELY(!is_vhost_running(dev) || qid < 0
+ || !(dev->flags & NETDEV_UP))) {
+ rte_spinlock_lock(&dev->stats_lock);
+ dev->stats.tx_dropped+= cnt;
+ rte_spinlock_unlock(&dev->stats_lock);
goto out;
}
- rte_spinlock_lock(&vhost_dev->tx_q[qid].tx_lock);
+ rte_spinlock_lock(&dev->tx_q[qid].tx_lock);
/* Check has QoS has been configured for the netdev */
- cnt = netdev_dpdk_qos_run__(vhost_dev, cur_pkts, cnt);
- qos_pkts -= cnt;
+ cnt = netdev_dpdk_qos_run__(dev, cur_pkts, cnt);
+ qos_pkts = total_pkts - cnt;
do {
int vhost_qid = qid * VIRTIO_QNUM + VIRTIO_RXQ;
unsigned int tx_pkts;
+ unsigned int try_tx_pkts = cnt;
- tx_pkts = rte_vhost_enqueue_burst(virtio_dev, vhost_qid,
- cur_pkts, cnt);
+ for (i = 0; i < cnt; i++) {
+ if (cur_pkts[i]->pkt_len > dev->max_packet_len) {
+ try_tx_pkts = i;
+ break;
+ }
+ }
+ if (!try_tx_pkts) {
+ cur_pkts++;
+ mtu_dropped++;
+ cnt--;
+ continue;
+ }
+ tx_pkts = rte_vhost_enqueue_burst(netdev_dpdk_get_vid(dev),
+ vhost_qid, cur_pkts, try_tx_pkts);
if (OVS_LIKELY(tx_pkts)) {
/* Packets have been sent.*/
cnt -= tx_pkts;
- /* Prepare for possible next iteration.*/
+ /* Prepare for possible retry.*/
cur_pkts = &cur_pkts[tx_pkts];
+ if (tx_pkts != try_tx_pkts) {
+ retries++;
+ }
} else {
- uint64_t timeout = VHOST_ENQ_RETRY_USECS * rte_get_timer_hz() / 1E6;
- unsigned int expired = 0;
+ /* No packets sent - do not retry.*/
+ break;
+ }
+ } while (cnt && (retries <= VHOST_ENQ_RETRY_NUM));
- if (!start) {
- start = rte_get_timer_cycles();
- }
+ rte_spinlock_unlock(&dev->tx_q[qid].tx_lock);
- /*
- * Unable to enqueue packets to vhost interface.
- * Check available entries before retrying.
- */
- while (!rte_vring_available_entries(virtio_dev, vhost_qid)) {
- if (OVS_UNLIKELY((rte_get_timer_cycles() - start) > timeout)) {
- expired = 1;
- break;
- }
- }
- if (expired) {
- /* break out of main loop. */
- break;
- }
- }
- } while (cnt);
-
- rte_spinlock_unlock(&vhost_dev->tx_q[qid].tx_lock);
-
- rte_spinlock_lock(&vhost_dev->stats_lock);
- cnt += qos_pkts;
- netdev_dpdk_vhost_update_tx_counters(&vhost_dev->stats, pkts, total_pkts,
- cnt);
- rte_spinlock_unlock(&vhost_dev->stats_lock);
+ rte_spinlock_lock(&dev->stats_lock);
+ netdev_dpdk_vhost_update_tx_counters(&dev->stats, pkts, total_pkts,
+ cnt + mtu_dropped + qos_pkts);
+ rte_spinlock_unlock(&dev->stats_lock);
out:
- if (may_steal) {
- int i;
-
- for (i = 0; i < total_pkts; i++) {
- dp_packet_delete(pkts[i]);
- }
- }
-}
-
-inline static void
-dpdk_queue_pkts(struct netdev_dpdk *dev, int qid,
- struct rte_mbuf **pkts, int cnt)
-{
- struct dpdk_tx_queue *txq = &dev->tx_q[qid];
- uint64_t diff_tsc;
-
- int i = 0;
-
- while (i < cnt) {
- int freeslots = MAX_TX_QUEUE_LEN - txq->count;
- int tocopy = MIN(freeslots, cnt-i);
-
- memcpy(&txq->burst_pkts[txq->count], &pkts[i],
- tocopy * sizeof (struct rte_mbuf *));
-
- txq->count += tocopy;
- i += tocopy;
-
- if (txq->count == MAX_TX_QUEUE_LEN || txq->flush_tx) {
- dpdk_queue_flush__(dev, qid);
- }
- diff_tsc = rte_get_timer_cycles() - txq->tsc;
- if (diff_tsc >= DRAIN_TSC) {
- dpdk_queue_flush__(dev, qid);
- }
+ for (i = 0; i < total_pkts - qos_pkts; i++) {
+ dp_packet_delete(pkts[i]);
}
}
/* Tx function. Transmit packets indefinitely */
static void
-dpdk_do_tx_copy(struct netdev *netdev, int qid, struct dp_packet **pkts,
- int cnt)
+dpdk_do_tx_copy(struct netdev *netdev, int qid, struct dp_packet_batch *batch)
OVS_NO_THREAD_SAFETY_ANALYSIS
{
#if !defined(__CHECKER__) && !defined(_WIN32)
- const size_t PKT_ARRAY_SIZE = cnt;
+ const size_t PKT_ARRAY_SIZE = batch->count;
#else
/* Sparse or MSVC doesn't like variable length array. */
enum { PKT_ARRAY_SIZE = NETDEV_MAX_BURST };
ovs_mutex_lock(&nonpmd_mempool_mutex);
}
- for (i = 0; i < cnt; i++) {
- int size = dp_packet_size(pkts[i]);
+ dp_packet_batch_apply_cutlen(batch);
+
+ for (i = 0; i < batch->count; i++) {
+ int size = dp_packet_size(batch->packets[i]);
if (OVS_UNLIKELY(size > dev->max_packet_len)) {
VLOG_WARN_RL(&rl, "Too big size %d max_packet_len %d",
mbufs[newcnt] = rte_pktmbuf_alloc(dev->dpdk_mp->mp);
if (!mbufs[newcnt]) {
- dropped += cnt - i;
+ dropped += batch->count - i;
break;
}
/* We have to do a copy for now */
- memcpy(rte_pktmbuf_mtod(mbufs[newcnt], void *), dp_packet_data(pkts[i]), size);
+ memcpy(rte_pktmbuf_mtod(mbufs[newcnt], void *),
+ dp_packet_data(batch->packets[i]), size);
rte_pktmbuf_data_len(mbufs[newcnt]) = size;
rte_pktmbuf_pkt_len(mbufs[newcnt]) = size;
}
if (dev->type == DPDK_DEV_VHOST) {
- __netdev_dpdk_vhost_send(netdev, qid, (struct dp_packet **) mbufs, newcnt, true);
+ __netdev_dpdk_vhost_send(netdev, qid, (struct dp_packet **) mbufs,
+ newcnt);
} else {
unsigned int qos_pkts = newcnt;
newcnt = netdev_dpdk_qos_run__(dev, mbufs, newcnt);
dropped += qos_pkts - newcnt;
- dpdk_queue_pkts(dev, qid, mbufs, newcnt);
- dpdk_queue_flush(dev, qid);
+ netdev_dpdk_eth_tx_burst(dev, qid, mbufs, newcnt);
}
if (OVS_UNLIKELY(dropped)) {
}
static int
-netdev_dpdk_vhost_send(struct netdev *netdev, int qid, struct dp_packet **pkts,
- int cnt, bool may_steal)
+netdev_dpdk_vhost_send(struct netdev *netdev, int qid,
+ struct dp_packet_batch *batch,
+ bool may_steal, bool concurrent_txq OVS_UNUSED)
{
- if (OVS_UNLIKELY(pkts[0]->source != DPBUF_DPDK)) {
- int i;
- dpdk_do_tx_copy(netdev, qid, pkts, cnt);
- if (may_steal) {
- for (i = 0; i < cnt; i++) {
- dp_packet_delete(pkts[i]);
- }
- }
+ if (OVS_UNLIKELY(!may_steal || batch->packets[0]->source != DPBUF_DPDK)) {
+ dpdk_do_tx_copy(netdev, qid, batch);
+ dp_packet_delete_batch(batch, may_steal);
} else {
- __netdev_dpdk_vhost_send(netdev, qid, pkts, cnt, may_steal);
+ dp_packet_batch_apply_cutlen(batch);
+ __netdev_dpdk_vhost_send(netdev, qid, batch->packets, batch->count);
}
return 0;
}
static inline void
netdev_dpdk_send__(struct netdev_dpdk *dev, int qid,
- struct dp_packet **pkts, int cnt, bool may_steal)
+ struct dp_packet_batch *batch, bool may_steal,
+ bool concurrent_txq)
{
- int i;
-
- if (OVS_UNLIKELY(dev->txq_needs_locking)) {
- qid = qid % dev->real_n_txq;
+ if (OVS_UNLIKELY(concurrent_txq)) {
+ qid = qid % dev->up.n_txq;
rte_spinlock_lock(&dev->tx_q[qid].tx_lock);
}
if (OVS_UNLIKELY(!may_steal ||
- pkts[0]->source != DPBUF_DPDK)) {
+ batch->packets[0]->source != DPBUF_DPDK)) {
struct netdev *netdev = &dev->up;
- dpdk_do_tx_copy(netdev, qid, pkts, cnt);
-
- if (may_steal) {
- for (i = 0; i < cnt; i++) {
- dp_packet_delete(pkts[i]);
- }
- }
+ dpdk_do_tx_copy(netdev, qid, batch);
+ dp_packet_delete_batch(batch, may_steal);
} else {
int next_tx_idx = 0;
int dropped = 0;
unsigned int qos_pkts = 0;
unsigned int temp_cnt = 0;
+ int cnt = batch->count;
- for (i = 0; i < cnt; i++) {
- int size = dp_packet_size(pkts[i]);
+ dp_packet_batch_apply_cutlen(batch);
+
+ for (int i = 0; i < cnt; i++) {
+ int size = dp_packet_size(batch->packets[i]);
if (OVS_UNLIKELY(size > dev->max_packet_len)) {
if (next_tx_idx != i) {
temp_cnt = i - next_tx_idx;
qos_pkts = temp_cnt;
- temp_cnt = netdev_dpdk_qos_run__(dev, (struct rte_mbuf**)pkts,
- temp_cnt);
+ temp_cnt = netdev_dpdk_qos_run__(dev,
+ (struct rte_mbuf**)batch->packets,
+ temp_cnt);
dropped += qos_pkts - temp_cnt;
- dpdk_queue_pkts(dev, qid,
- (struct rte_mbuf **)&pkts[next_tx_idx],
- temp_cnt);
+ netdev_dpdk_eth_tx_burst(dev, qid,
+ (struct rte_mbuf **)&batch->packets[next_tx_idx],
+ temp_cnt);
}
VLOG_WARN_RL(&rl, "Too big size %d max_packet_len %d",
(int)size , dev->max_packet_len);
- dp_packet_delete(pkts[i]);
+ dp_packet_delete(batch->packets[i]);
dropped++;
next_tx_idx = i + 1;
}
cnt -= next_tx_idx;
qos_pkts = cnt;
- cnt = netdev_dpdk_qos_run__(dev, (struct rte_mbuf**)pkts, cnt);
+ cnt = netdev_dpdk_qos_run__(dev,
+ (struct rte_mbuf**)batch->packets, cnt);
dropped += qos_pkts - cnt;
- dpdk_queue_pkts(dev, qid, (struct rte_mbuf **)&pkts[next_tx_idx],
- cnt);
+ netdev_dpdk_eth_tx_burst(dev, qid,
+ (struct rte_mbuf **)&batch->packets[next_tx_idx],
+ cnt);
}
if (OVS_UNLIKELY(dropped)) {
}
}
- if (OVS_UNLIKELY(dev->txq_needs_locking)) {
+ if (OVS_UNLIKELY(concurrent_txq)) {
rte_spinlock_unlock(&dev->tx_q[qid].tx_lock);
}
}
static int
netdev_dpdk_eth_send(struct netdev *netdev, int qid,
- struct dp_packet **pkts, int cnt, bool may_steal)
+ struct dp_packet_batch *batch, bool may_steal,
+ bool concurrent_txq)
{
struct netdev_dpdk *dev = netdev_dpdk_cast(netdev);
- netdev_dpdk_send__(dev, qid, pkts, cnt, may_steal);
+ netdev_dpdk_send__(dev, qid, batch, may_steal, concurrent_txq);
return 0;
}
}
static int
-netdev_dpdk_set_mtu(const struct netdev *netdev, int mtu)
+netdev_dpdk_set_mtu(struct netdev *netdev, int mtu)
{
struct netdev_dpdk *dev = netdev_dpdk_cast(netdev);
- int old_mtu, err, dpdk_mtu;
- struct dpdk_mp *old_mp;
- struct dpdk_mp *mp;
- uint32_t buf_size;
-
- ovs_mutex_lock(&dpdk_mutex);
- ovs_mutex_lock(&dev->mutex);
- if (dev->mtu == mtu) {
- err = 0;
- goto out;
- }
-
- buf_size = dpdk_buf_size(mtu);
- dpdk_mtu = FRAME_LEN_TO_MTU(buf_size);
- mp = dpdk_mp_get(dev->socket_id, dpdk_mtu);
- if (!mp) {
- err = ENOMEM;
- goto out;
+ if (MTU_TO_FRAME_LEN(mtu) > NETDEV_DPDK_MAX_PKT_LEN
+ || mtu < ETHER_MIN_MTU) {
+ VLOG_WARN("%s: unsupported MTU %d\n", dev->up.name, mtu);
+ return EINVAL;
}
- rte_eth_dev_stop(dev->port_id);
-
- old_mtu = dev->mtu;
- old_mp = dev->dpdk_mp;
- dev->dpdk_mp = mp;
- dev->mtu = mtu;
- dev->max_packet_len = MTU_TO_FRAME_LEN(dev->mtu);
-
- err = dpdk_eth_dev_init(dev);
- if (err) {
- dpdk_mp_put(mp);
- dev->mtu = old_mtu;
- dev->dpdk_mp = old_mp;
- dev->max_packet_len = MTU_TO_FRAME_LEN(dev->mtu);
- dpdk_eth_dev_init(dev);
- goto out;
+ ovs_mutex_lock(&dev->mutex);
+ if (dev->requested_mtu != mtu) {
+ dev->requested_mtu = mtu;
+ netdev_request_reconfigure(netdev);
}
-
- dpdk_mp_put(old_mp);
- netdev_change_seq_changed(netdev);
-out:
ovs_mutex_unlock(&dev->mutex);
- ovs_mutex_unlock(&dpdk_mutex);
- return err;
+
+ return 0;
}
static int
-netdev_dpdk_get_carrier(const struct netdev *netdev_, bool *carrier);
+netdev_dpdk_get_carrier(const struct netdev *netdev, bool *carrier);
static int
netdev_dpdk_vhost_get_stats(const struct netdev *netdev,
struct netdev_dpdk *dev = netdev_dpdk_cast(netdev);
ovs_mutex_lock(&dev->mutex);
- memset(stats, 0, sizeof(*stats));
- /* Unsupported Stats */
- stats->collisions = UINT64_MAX;
- stats->rx_crc_errors = UINT64_MAX;
- stats->rx_fifo_errors = UINT64_MAX;
- stats->rx_frame_errors = UINT64_MAX;
- stats->rx_missed_errors = UINT64_MAX;
- stats->rx_over_errors = UINT64_MAX;
- stats->tx_aborted_errors = UINT64_MAX;
- stats->tx_carrier_errors = UINT64_MAX;
- stats->tx_errors = UINT64_MAX;
- stats->tx_fifo_errors = UINT64_MAX;
- stats->tx_heartbeat_errors = UINT64_MAX;
- stats->tx_window_errors = UINT64_MAX;
- stats->rx_dropped += UINT64_MAX;
rte_spinlock_lock(&dev->stats_lock);
/* Supported Stats */
stats->rx_packets += dev->stats.rx_packets;
stats->tx_packets += dev->stats.tx_packets;
+ stats->rx_dropped = dev->stats.rx_dropped;
stats->tx_dropped += dev->stats.tx_dropped;
stats->multicast = dev->stats.multicast;
stats->rx_bytes = dev->stats.rx_bytes;
stats->tx_bytes = dev->stats.tx_bytes;
stats->rx_errors = dev->stats.rx_errors;
stats->rx_length_errors = dev->stats.rx_length_errors;
+
+ stats->rx_1_to_64_packets = dev->stats.rx_1_to_64_packets;
+ stats->rx_65_to_127_packets = dev->stats.rx_65_to_127_packets;
+ stats->rx_128_to_255_packets = dev->stats.rx_128_to_255_packets;
+ stats->rx_256_to_511_packets = dev->stats.rx_256_to_511_packets;
+ stats->rx_512_to_1023_packets = dev->stats.rx_512_to_1023_packets;
+ stats->rx_1024_to_1522_packets = dev->stats.rx_1024_to_1522_packets;
+ stats->rx_1523_to_max_packets = dev->stats.rx_1523_to_max_packets;
+
rte_spinlock_unlock(&dev->stats_lock);
ovs_mutex_unlock(&dev->mutex);
return 0;
}
+static void
+netdev_dpdk_convert_xstats(struct netdev_stats *stats,
+ const struct rte_eth_xstat *xstats,
+ const struct rte_eth_xstat_name *names,
+ const unsigned int size)
+{
+ for (unsigned int i = 0; i < size; i++) {
+ if (strcmp(XSTAT_RX_64_PACKETS, names[i].name) == 0) {
+ stats->rx_1_to_64_packets = xstats[i].value;
+ } else if (strcmp(XSTAT_RX_65_TO_127_PACKETS, names[i].name) == 0) {
+ stats->rx_65_to_127_packets = xstats[i].value;
+ } else if (strcmp(XSTAT_RX_128_TO_255_PACKETS, names[i].name) == 0) {
+ stats->rx_128_to_255_packets = xstats[i].value;
+ } else if (strcmp(XSTAT_RX_256_TO_511_PACKETS, names[i].name) == 0) {
+ stats->rx_256_to_511_packets = xstats[i].value;
+ } else if (strcmp(XSTAT_RX_512_TO_1023_PACKETS, names[i].name) == 0) {
+ stats->rx_512_to_1023_packets = xstats[i].value;
+ } else if (strcmp(XSTAT_RX_1024_TO_1522_PACKETS, names[i].name) == 0) {
+ stats->rx_1024_to_1522_packets = xstats[i].value;
+ } else if (strcmp(XSTAT_RX_1523_TO_MAX_PACKETS, names[i].name) == 0) {
+ stats->rx_1523_to_max_packets = xstats[i].value;
+ } else if (strcmp(XSTAT_TX_64_PACKETS, names[i].name) == 0) {
+ stats->tx_1_to_64_packets = xstats[i].value;
+ } else if (strcmp(XSTAT_TX_65_TO_127_PACKETS, names[i].name) == 0) {
+ stats->tx_65_to_127_packets = xstats[i].value;
+ } else if (strcmp(XSTAT_TX_128_TO_255_PACKETS, names[i].name) == 0) {
+ stats->tx_128_to_255_packets = xstats[i].value;
+ } else if (strcmp(XSTAT_TX_256_TO_511_PACKETS, names[i].name) == 0) {
+ stats->tx_256_to_511_packets = xstats[i].value;
+ } else if (strcmp(XSTAT_TX_512_TO_1023_PACKETS, names[i].name) == 0) {
+ stats->tx_512_to_1023_packets = xstats[i].value;
+ } else if (strcmp(XSTAT_TX_1024_TO_1522_PACKETS, names[i].name) == 0) {
+ stats->tx_1024_to_1522_packets = xstats[i].value;
+ } else if (strcmp(XSTAT_TX_1523_TO_MAX_PACKETS, names[i].name) == 0) {
+ stats->tx_1523_to_max_packets = xstats[i].value;
+ } else if (strcmp(XSTAT_TX_MULTICAST_PACKETS, names[i].name) == 0) {
+ stats->tx_multicast_packets = xstats[i].value;
+ } else if (strcmp(XSTAT_RX_BROADCAST_PACKETS, names[i].name) == 0) {
+ stats->rx_broadcast_packets = xstats[i].value;
+ } else if (strcmp(XSTAT_TX_BROADCAST_PACKETS, names[i].name) == 0) {
+ stats->tx_broadcast_packets = xstats[i].value;
+ } else if (strcmp(XSTAT_RX_UNDERSIZED_ERRORS, names[i].name) == 0) {
+ stats->rx_undersized_errors = xstats[i].value;
+ } else if (strcmp(XSTAT_RX_FRAGMENTED_ERRORS, names[i].name) == 0) {
+ stats->rx_fragmented_errors = xstats[i].value;
+ } else if (strcmp(XSTAT_RX_JABBER_ERRORS, names[i].name) == 0) {
+ stats->rx_jabber_errors = xstats[i].value;
+ }
+ }
+}
+
static int
netdev_dpdk_get_stats(const struct netdev *netdev, struct netdev_stats *stats)
{
netdev_dpdk_get_carrier(netdev, &gg);
ovs_mutex_lock(&dev->mutex);
- rte_eth_stats_get(dev->port_id, &rte_stats);
- memset(stats, 0, sizeof(*stats));
+ struct rte_eth_xstat *rte_xstats = NULL;
+ struct rte_eth_xstat_name *rte_xstats_names = NULL;
+ int rte_xstats_len, rte_xstats_new_len, rte_xstats_ret;
+
+ if (rte_eth_stats_get(dev->port_id, &rte_stats)) {
+ VLOG_ERR("Can't get ETH statistics for port: %i.", dev->port_id);
+ ovs_mutex_unlock(&dev->mutex);
+ return EPROTO;
+ }
+
+ /* Get length of statistics */
+ rte_xstats_len = rte_eth_xstats_get_names(dev->port_id, NULL, 0);
+ if (rte_xstats_len < 0) {
+ VLOG_WARN("Cannot get XSTATS values for port: %i", dev->port_id);
+ goto out;
+ }
+ /* Reserve memory for xstats names and values */
+ rte_xstats_names = xcalloc(rte_xstats_len, sizeof *rte_xstats_names);
+ rte_xstats = xcalloc(rte_xstats_len, sizeof *rte_xstats);
+
+ /* Retreive xstats names */
+ rte_xstats_new_len = rte_eth_xstats_get_names(dev->port_id,
+ rte_xstats_names,
+ rte_xstats_len);
+ if (rte_xstats_new_len != rte_xstats_len) {
+ VLOG_WARN("Cannot get XSTATS names for port: %i.", dev->port_id);
+ goto out;
+ }
+ /* Retreive xstats values */
+ memset(rte_xstats, 0xff, sizeof *rte_xstats * rte_xstats_len);
+ rte_xstats_ret = rte_eth_xstats_get(dev->port_id, rte_xstats,
+ rte_xstats_len);
+ if (rte_xstats_ret > 0 && rte_xstats_ret <= rte_xstats_len) {
+ netdev_dpdk_convert_xstats(stats, rte_xstats, rte_xstats_names,
+ rte_xstats_len);
+ } else {
+ VLOG_WARN("Cannot get XSTATS values for port: %i.", dev->port_id);
+ }
+
+out:
+ free(rte_xstats);
+ free(rte_xstats_names);
stats->rx_packets = rte_stats.ipackets;
stats->tx_packets = rte_stats.opackets;
/* DPDK counts imissed as errors, but count them here as dropped instead */
stats->rx_errors = rte_stats.ierrors - rte_stats.imissed;
stats->tx_errors = rte_stats.oerrors;
- stats->multicast = rte_stats.imcasts;
rte_spinlock_lock(&dev->stats_lock);
stats->tx_dropped = dev->stats.tx_dropped;
+ stats->rx_dropped = dev->stats.rx_dropped;
rte_spinlock_unlock(&dev->stats_lock);
/* These are the available DPDK counters for packets not received due to
* local resource constraints in DPDK and NIC respectively. */
- stats->rx_dropped = rte_stats.rx_nombuf + rte_stats.imissed;
- stats->collisions = UINT64_MAX;
-
- stats->rx_length_errors = UINT64_MAX;
- stats->rx_over_errors = UINT64_MAX;
- stats->rx_crc_errors = UINT64_MAX;
- stats->rx_frame_errors = UINT64_MAX;
- stats->rx_fifo_errors = UINT64_MAX;
+ stats->rx_dropped += rte_stats.rx_nombuf + rte_stats.imissed;
stats->rx_missed_errors = rte_stats.imissed;
- stats->tx_aborted_errors = UINT64_MAX;
- stats->tx_carrier_errors = UINT64_MAX;
- stats->tx_fifo_errors = UINT64_MAX;
- stats->tx_heartbeat_errors = UINT64_MAX;
- stats->tx_window_errors = UINT64_MAX;
-
ovs_mutex_unlock(&dev->mutex);
return 0;
}
static int
-netdev_dpdk_get_features(const struct netdev *netdev_,
+netdev_dpdk_get_features(const struct netdev *netdev,
enum netdev_features *current,
enum netdev_features *advertised OVS_UNUSED,
enum netdev_features *supported OVS_UNUSED,
enum netdev_features *peer OVS_UNUSED)
{
- struct netdev_dpdk *dev = netdev_dpdk_cast(netdev_);
+ struct netdev_dpdk *dev = netdev_dpdk_cast(netdev);
struct rte_eth_link link;
ovs_mutex_lock(&dev->mutex);
link = dev->link;
ovs_mutex_unlock(&dev->mutex);
- if (link.link_duplex == ETH_LINK_AUTONEG_DUPLEX) {
- if (link.link_speed == ETH_LINK_SPEED_AUTONEG) {
- *current = NETDEV_F_AUTONEG;
- }
- } else if (link.link_duplex == ETH_LINK_HALF_DUPLEX) {
- if (link.link_speed == ETH_LINK_SPEED_10) {
+ if (link.link_duplex == ETH_LINK_HALF_DUPLEX) {
+ if (link.link_speed == ETH_SPEED_NUM_10M) {
*current = NETDEV_F_10MB_HD;
}
- if (link.link_speed == ETH_LINK_SPEED_100) {
+ if (link.link_speed == ETH_SPEED_NUM_100M) {
*current = NETDEV_F_100MB_HD;
}
- if (link.link_speed == ETH_LINK_SPEED_1000) {
+ if (link.link_speed == ETH_SPEED_NUM_1G) {
*current = NETDEV_F_1GB_HD;
}
} else if (link.link_duplex == ETH_LINK_FULL_DUPLEX) {
- if (link.link_speed == ETH_LINK_SPEED_10) {
+ if (link.link_speed == ETH_SPEED_NUM_10M) {
*current = NETDEV_F_10MB_FD;
}
- if (link.link_speed == ETH_LINK_SPEED_100) {
+ if (link.link_speed == ETH_SPEED_NUM_100M) {
*current = NETDEV_F_100MB_FD;
}
- if (link.link_speed == ETH_LINK_SPEED_1000) {
+ if (link.link_speed == ETH_SPEED_NUM_1G) {
*current = NETDEV_F_1GB_FD;
}
- if (link.link_speed == ETH_LINK_SPEED_10000) {
+ if (link.link_speed == ETH_SPEED_NUM_10G) {
*current = NETDEV_F_10GB_FD;
}
}
+ if (link.link_autoneg) {
+ *current |= NETDEV_F_AUTONEG;
+ }
+
+ return 0;
+}
+
+static struct ingress_policer *
+netdev_dpdk_policer_construct(uint32_t rate, uint32_t burst)
+{
+ struct ingress_policer *policer = NULL;
+ uint64_t rate_bytes;
+ uint64_t burst_bytes;
+ int err = 0;
+
+ policer = xmalloc(sizeof *policer);
+ rte_spinlock_init(&policer->policer_lock);
+
+ /* rte_meter requires bytes so convert kbits rate and burst to bytes. */
+ rate_bytes = rate * 1000/8;
+ burst_bytes = burst * 1000/8;
+
+ policer->app_srtcm_params.cir = rate_bytes;
+ policer->app_srtcm_params.cbs = burst_bytes;
+ policer->app_srtcm_params.ebs = 0;
+ err = rte_meter_srtcm_config(&policer->in_policer,
+ &policer->app_srtcm_params);
+ if(err) {
+ VLOG_ERR("Could not create rte meter for ingress policer");
+ return NULL;
+ }
+
+ return policer;
+}
+
+static int
+netdev_dpdk_set_policing(struct netdev* netdev, uint32_t policer_rate,
+ uint32_t policer_burst)
+{
+ struct netdev_dpdk *dev = netdev_dpdk_cast(netdev);
+ struct ingress_policer *policer;
+
+ /* Force to 0 if no rate specified,
+ * default to 8000 kbits if burst is 0,
+ * else stick with user-specified value.
+ */
+ policer_burst = (!policer_rate ? 0
+ : !policer_burst ? 8000
+ : policer_burst);
+
+ ovs_mutex_lock(&dev->mutex);
+
+ policer = ovsrcu_get_protected(struct ingress_policer *,
+ &dev->ingress_policer);
+
+ if (dev->policer_rate == policer_rate &&
+ dev->policer_burst == policer_burst) {
+ /* Assume that settings haven't changed since we last set them. */
+ ovs_mutex_unlock(&dev->mutex);
+ return 0;
+ }
+
+ /* Destroy any existing ingress policer for the device if one exists */
+ if (policer) {
+ ovsrcu_postpone(free, policer);
+ }
+
+ if (policer_rate != 0) {
+ policer = netdev_dpdk_policer_construct(policer_rate, policer_burst);
+ } else {
+ policer = NULL;
+ }
+ ovsrcu_set(&dev->ingress_policer, policer);
+ dev->policer_rate = policer_rate;
+ dev->policer_burst = policer_burst;
+ ovs_mutex_unlock(&dev->mutex);
+
return 0;
}
}
static int
-netdev_dpdk_get_carrier(const struct netdev *netdev_, bool *carrier)
+netdev_dpdk_get_carrier(const struct netdev *netdev, bool *carrier)
{
- struct netdev_dpdk *dev = netdev_dpdk_cast(netdev_);
+ struct netdev_dpdk *dev = netdev_dpdk_cast(netdev);
ovs_mutex_lock(&dev->mutex);
check_link_status(dev);
}
static int
-netdev_dpdk_vhost_get_carrier(const struct netdev *netdev_, bool *carrier)
+netdev_dpdk_vhost_get_carrier(const struct netdev *netdev, bool *carrier)
{
- struct netdev_dpdk *dev = netdev_dpdk_cast(netdev_);
- struct virtio_net *virtio_dev = netdev_dpdk_get_virtio(dev);
+ struct netdev_dpdk *dev = netdev_dpdk_cast(netdev);
ovs_mutex_lock(&dev->mutex);
- if (is_vhost_running(virtio_dev)) {
+ if (is_vhost_running(dev)) {
*carrier = 1;
} else {
*carrier = 0;
}
static long long int
-netdev_dpdk_get_carrier_resets(const struct netdev *netdev_)
+netdev_dpdk_get_carrier_resets(const struct netdev *netdev)
{
- struct netdev_dpdk *dev = netdev_dpdk_cast(netdev_);
+ struct netdev_dpdk *dev = netdev_dpdk_cast(netdev);
long long int carrier_resets;
ovs_mutex_lock(&dev->mutex);
}
static int
-netdev_dpdk_set_miimon(struct netdev *netdev_ OVS_UNUSED,
+netdev_dpdk_set_miimon(struct netdev *netdev OVS_UNUSED,
long long int interval OVS_UNUSED)
{
return EOPNOTSUPP;
static int
netdev_dpdk_update_flags__(struct netdev_dpdk *dev,
enum netdev_flags off, enum netdev_flags on,
- enum netdev_flags *old_flagsp) OVS_REQUIRES(dev->mutex)
+ enum netdev_flags *old_flagsp)
+ OVS_REQUIRES(dev->mutex)
{
int err;
if (!(dev->flags & NETDEV_UP)) {
rte_eth_dev_stop(dev->port_id);
}
+ } else {
+ /* If DPDK_DEV_VHOST device's NETDEV_UP flag was changed and vhost is
+ * running then change netdev's change_seq to trigger link state
+ * update. */
+
+ if ((NETDEV_UP & ((*old_flagsp ^ on) | (*old_flagsp ^ off)))
+ && is_vhost_running(dev)) {
+ netdev_change_seq_changed(&dev->up);
+
+ /* Clear statistics if device is getting up. */
+ if (NETDEV_UP & on) {
+ rte_spinlock_lock(&dev->stats_lock);
+ memset(&dev->stats, 0, sizeof(dev->stats));
+ rte_spinlock_unlock(&dev->stats_lock);
+ }
+ }
}
return 0;
}
static int
-netdev_dpdk_update_flags(struct netdev *netdev_,
+netdev_dpdk_update_flags(struct netdev *netdev,
enum netdev_flags off, enum netdev_flags on,
enum netdev_flags *old_flagsp)
{
- struct netdev_dpdk *netdev = netdev_dpdk_cast(netdev_);
+ struct netdev_dpdk *dev = netdev_dpdk_cast(netdev);
int error;
- ovs_mutex_lock(&netdev->mutex);
- error = netdev_dpdk_update_flags__(netdev, off, on, old_flagsp);
- ovs_mutex_unlock(&netdev->mutex);
+ ovs_mutex_lock(&dev->mutex);
+ error = netdev_dpdk_update_flags__(dev, off, on, old_flagsp);
+ ovs_mutex_unlock(&dev->mutex);
return error;
}
static int
-netdev_dpdk_get_status(const struct netdev *netdev_, struct smap *args)
+netdev_dpdk_get_status(const struct netdev *netdev, struct smap *args)
{
- struct netdev_dpdk *dev = netdev_dpdk_cast(netdev_);
+ struct netdev_dpdk *dev = netdev_dpdk_cast(netdev);
struct rte_eth_dev_info dev_info;
- if (dev->port_id < 0)
+ if (!rte_eth_dev_is_valid_port(dev->port_id)) {
return ENODEV;
+ }
ovs_mutex_lock(&dev->mutex);
rte_eth_dev_info_get(dev->port_id, &dev_info);
ovs_mutex_unlock(&dev->mutex);
- smap_add_format(args, "driver_name", "%s", dev_info.driver_name);
-
smap_add_format(args, "port_no", "%d", dev->port_id);
smap_add_format(args, "numa_id", "%d", rte_eth_dev_socket_id(dev->port_id));
smap_add_format(args, "driver_name", "%s", dev_info.driver_name);
* Set virtqueue flags so that we do not receive interrupts.
*/
static void
-set_irq_status(struct virtio_net *dev)
+set_irq_status(int vid)
{
uint32_t i;
uint64_t idx;
- for (i = 0; i < dev->virt_qp_nb; i++) {
+ for (i = 0; i < rte_vhost_get_queue_num(vid); i++) {
idx = i * VIRTIO_QNUM;
- rte_vhost_enable_guest_notification(dev, idx + VIRTIO_RXQ, 0);
- rte_vhost_enable_guest_notification(dev, idx + VIRTIO_TXQ, 0);
+ rte_vhost_enable_guest_notification(vid, idx + VIRTIO_RXQ, 0);
+ rte_vhost_enable_guest_notification(vid, idx + VIRTIO_TXQ, 0);
}
}
/*
* Fixes mapping for vhost-user tx queues. Must be called after each
- * enabling/disabling of queues and real_n_txq modifications.
+ * enabling/disabling of queues and n_txq modifications.
*/
static void
-netdev_dpdk_remap_txqs(struct netdev_dpdk *netdev)
- OVS_REQUIRES(netdev->mutex)
+netdev_dpdk_remap_txqs(struct netdev_dpdk *dev)
+ OVS_REQUIRES(dev->mutex)
{
int *enabled_queues, n_enabled = 0;
- int i, k, total_txqs = netdev->real_n_txq;
+ int i, k, total_txqs = dev->up.n_txq;
enabled_queues = dpdk_rte_mzalloc(total_txqs * sizeof *enabled_queues);
for (i = 0; i < total_txqs; i++) {
/* Enabled queues always mapped to themselves. */
- if (netdev->tx_q[i].map == i) {
+ if (dev->tx_q[i].map == i) {
enabled_queues[n_enabled++] = i;
}
}
k = 0;
for (i = 0; i < total_txqs; i++) {
- if (netdev->tx_q[i].map != i) {
- netdev->tx_q[i].map = enabled_queues[k];
+ if (dev->tx_q[i].map != i) {
+ dev->tx_q[i].map = enabled_queues[k];
k = (k + 1) % n_enabled;
}
}
- VLOG_DBG("TX queue mapping for %s\n", netdev->vhost_id);
+ VLOG_DBG("TX queue mapping for %s\n", dev->vhost_id);
for (i = 0; i < total_txqs; i++) {
- VLOG_DBG("%2d --> %2d", i, netdev->tx_q[i].map);
+ VLOG_DBG("%2d --> %2d", i, dev->tx_q[i].map);
}
rte_free(enabled_queues);
}
-static int
-netdev_dpdk_vhost_set_queues(struct netdev_dpdk *netdev, struct virtio_net *dev)
- OVS_REQUIRES(netdev->mutex)
-{
- uint32_t qp_num;
-
- qp_num = dev->virt_qp_nb;
- if (qp_num > netdev->up.n_rxq) {
- VLOG_ERR("vHost Device '%s' %"PRIu64" can't be added - "
- "too many queues %d > %d", dev->ifname, dev->device_fh,
- qp_num, netdev->up.n_rxq);
- return -1;
- }
-
- netdev->real_n_rxq = qp_num;
- netdev->real_n_txq = qp_num;
- netdev->txq_needs_locking = true;
- /* Enable TX queue 0 by default if it wasn't disabled. */
- if (netdev->tx_q[0].map == OVS_VHOST_QUEUE_MAP_UNKNOWN) {
- netdev->tx_q[0].map = 0;
- }
-
- netdev_dpdk_remap_txqs(netdev);
-
- return 0;
-}
-
/*
* A new virtio-net device is added to a vhost port.
*/
static int
-new_device(struct virtio_net *dev)
+new_device(int vid)
{
- struct netdev_dpdk *netdev;
+ struct netdev_dpdk *dev;
bool exists = false;
+ int newnode = 0;
+ char ifname[IF_NAME_SZ];
+
+ rte_vhost_get_ifname(vid, ifname, sizeof(ifname));
ovs_mutex_lock(&dpdk_mutex);
/* Add device to the vhost port with the same name as that passed down. */
- LIST_FOR_EACH(netdev, list_node, &dpdk_list) {
- if (strncmp(dev->ifname, netdev->vhost_id, IF_NAME_SZ) == 0) {
- ovs_mutex_lock(&netdev->mutex);
- if (netdev_dpdk_vhost_set_queues(netdev, dev)) {
- ovs_mutex_unlock(&netdev->mutex);
- ovs_mutex_unlock(&dpdk_mutex);
- return -1;
+ LIST_FOR_EACH(dev, list_node, &dpdk_list) {
+ if (strncmp(ifname, dev->vhost_id, IF_NAME_SZ) == 0) {
+ uint32_t qp_num = rte_vhost_get_queue_num(vid);
+
+ ovs_mutex_lock(&dev->mutex);
+ /* Get NUMA information */
+ newnode = rte_vhost_get_numa_node(vid);
+ if (newnode == -1) {
+ VLOG_INFO("Error getting NUMA info for vHost Device '%s'",
+ ifname);
+ newnode = dev->socket_id;
}
- ovsrcu_set(&netdev->virtio_dev, dev);
+
+ if (dev->requested_n_txq != qp_num
+ || dev->requested_n_rxq != qp_num
+ || dev->requested_socket_id != newnode) {
+ dev->requested_socket_id = newnode;
+ dev->requested_n_rxq = qp_num;
+ dev->requested_n_txq = qp_num;
+ netdev_request_reconfigure(&dev->up);
+ } else {
+ /* Reconfiguration not required. */
+ dev->vhost_reconfigured = true;
+ }
+
+ ovsrcu_index_set(&dev->vid, vid);
exists = true;
- dev->flags |= VIRTIO_DEV_RUNNING;
+
/* Disable notifications. */
- set_irq_status(dev);
- ovs_mutex_unlock(&netdev->mutex);
+ set_irq_status(vid);
+ netdev_change_seq_changed(&dev->up);
+ ovs_mutex_unlock(&dev->mutex);
break;
}
}
ovs_mutex_unlock(&dpdk_mutex);
if (!exists) {
- VLOG_INFO("vHost Device '%s' %"PRIu64" can't be added - name not "
- "found", dev->ifname, dev->device_fh);
+ VLOG_INFO("vHost Device '%s' can't be added - name not found", ifname);
return -1;
}
- VLOG_INFO("vHost Device '%s' %"PRIu64" has been added", dev->ifname,
- dev->device_fh);
+ VLOG_INFO("vHost Device '%s' has been added on numa node %i",
+ ifname, newnode);
+
return 0;
}
{
int i;
- for (i = 0; i < dev->real_n_txq; i++) {
+ for (i = 0; i < dev->up.n_txq; i++) {
dev->tx_q[i].map = OVS_VHOST_QUEUE_MAP_UNKNOWN;
}
}
* the device.
*/
static void
-destroy_device(volatile struct virtio_net *dev)
+destroy_device(int vid)
{
- struct netdev_dpdk *vhost_dev;
+ struct netdev_dpdk *dev;
bool exists = false;
+ char ifname[IF_NAME_SZ];
+
+ rte_vhost_get_ifname(vid, ifname, sizeof(ifname));
ovs_mutex_lock(&dpdk_mutex);
- LIST_FOR_EACH (vhost_dev, list_node, &dpdk_list) {
- if (netdev_dpdk_get_virtio(vhost_dev) == dev) {
+ LIST_FOR_EACH (dev, list_node, &dpdk_list) {
+ if (netdev_dpdk_get_vid(dev) == vid) {
+
+ ovs_mutex_lock(&dev->mutex);
+ dev->vhost_reconfigured = false;
+ ovsrcu_index_set(&dev->vid, -1);
+ netdev_dpdk_txq_map_clear(dev);
- ovs_mutex_lock(&vhost_dev->mutex);
- dev->flags &= ~VIRTIO_DEV_RUNNING;
- ovsrcu_set(&vhost_dev->virtio_dev, NULL);
- netdev_dpdk_txq_map_clear(vhost_dev);
+ netdev_change_seq_changed(&dev->up);
+ ovs_mutex_unlock(&dev->mutex);
exists = true;
- ovs_mutex_unlock(&vhost_dev->mutex);
break;
}
}
ovs_mutex_unlock(&dpdk_mutex);
- if (exists == true) {
+ if (exists) {
/*
* Wait for other threads to quiesce after setting the 'virtio_dev'
* to NULL, before returning.
* put thread back into quiescent state before returning.
*/
ovsrcu_quiesce_start();
- VLOG_INFO("vHost Device '%s' %"PRIu64" has been removed", dev->ifname,
- dev->device_fh);
+ VLOG_INFO("vHost Device '%s' has been removed", ifname);
} else {
- VLOG_INFO("vHost Device '%s' %"PRIu64" not found", dev->ifname,
- dev->device_fh);
+ VLOG_INFO("vHost Device '%s' not found", ifname);
}
-
}
static int
-vring_state_changed(struct virtio_net *dev, uint16_t queue_id, int enable)
+vring_state_changed(int vid, uint16_t queue_id, int enable)
{
- struct netdev_dpdk *vhost_dev;
+ struct netdev_dpdk *dev;
bool exists = false;
int qid = queue_id / VIRTIO_QNUM;
+ char ifname[IF_NAME_SZ];
+
+ rte_vhost_get_ifname(vid, ifname, sizeof(ifname));
if (queue_id % VIRTIO_QNUM == VIRTIO_TXQ) {
return 0;
}
ovs_mutex_lock(&dpdk_mutex);
- LIST_FOR_EACH (vhost_dev, list_node, &dpdk_list) {
- if (strncmp(dev->ifname, vhost_dev->vhost_id, IF_NAME_SZ) == 0) {
- ovs_mutex_lock(&vhost_dev->mutex);
+ LIST_FOR_EACH (dev, list_node, &dpdk_list) {
+ if (strncmp(ifname, dev->vhost_id, IF_NAME_SZ) == 0) {
+ ovs_mutex_lock(&dev->mutex);
if (enable) {
- vhost_dev->tx_q[qid].map = qid;
+ dev->tx_q[qid].map = qid;
} else {
- vhost_dev->tx_q[qid].map = OVS_VHOST_QUEUE_DISABLED;
+ dev->tx_q[qid].map = OVS_VHOST_QUEUE_DISABLED;
}
- netdev_dpdk_remap_txqs(vhost_dev);
+ netdev_dpdk_remap_txqs(dev);
exists = true;
- ovs_mutex_unlock(&vhost_dev->mutex);
+ ovs_mutex_unlock(&dev->mutex);
break;
}
}
ovs_mutex_unlock(&dpdk_mutex);
if (exists) {
- VLOG_INFO("State of queue %d ( tx_qid %d ) of vhost device '%s' %"
- PRIu64" changed to \'%s\'", queue_id, qid, dev->ifname,
- dev->device_fh, (enable == 1) ? "enabled" : "disabled");
+ VLOG_INFO("State of queue %d ( tx_qid %d ) of vhost device '%s'"
+ "changed to \'%s\'", queue_id, qid, ifname,
+ (enable == 1) ? "enabled" : "disabled");
} else {
- VLOG_INFO("vHost Device '%s' %"PRIu64" not found", dev->ifname,
- dev->device_fh);
+ VLOG_INFO("vHost Device '%s' not found", ifname);
return -1;
}
return 0;
}
-struct virtio_net *
-netdev_dpdk_get_virtio(const struct netdev_dpdk *dev)
+int
+netdev_dpdk_get_vid(const struct netdev_dpdk *dev)
{
- return ovsrcu_get(struct virtio_net *, &dev->virtio_dev);
+ return ovsrcu_index_get(&dev->vid);
+}
+
+struct ingress_policer *
+netdev_dpdk_get_ingress_policer(const struct netdev_dpdk *dev)
+{
+ return ovsrcu_get(struct ingress_policer *, &dev->ingress_policer);
}
/*
start_vhost_loop(void *dummy OVS_UNUSED)
{
pthread_detach(pthread_self());
- /* Put the cuse thread into quiescent state. */
+ /* Put the vhost thread into quiescent state. */
ovsrcu_quiesce_start();
rte_vhost_driver_session_start();
return NULL;
dpdk_vhost_class_init(void)
{
rte_vhost_driver_callback_register(&virtio_net_device_ops);
- ovs_thread_create("vhost_thread", start_vhost_loop, NULL);
- return 0;
-}
-
-static int
-dpdk_vhost_cuse_class_init(void)
-{
- int err = -1;
-
-
- /* Register CUSE device to handle IOCTLs.
- * Unless otherwise specified on the vswitchd command line, cuse_dev_name
- * is set to vhost-net.
- */
- err = rte_vhost_driver_register(cuse_dev_name);
+ rte_vhost_feature_disable(1ULL << VIRTIO_NET_F_HOST_TSO4
+ | 1ULL << VIRTIO_NET_F_HOST_TSO6
+ | 1ULL << VIRTIO_NET_F_CSUM);
- if (err != 0) {
- VLOG_ERR("CUSE device setup failure.");
- return -1;
- }
-
- dpdk_vhost_class_init();
+ ovs_thread_create("vhost_thread", start_vhost_loop, NULL);
return 0;
}
static int
dpdk_vhost_user_class_init(void)
{
- dpdk_vhost_class_init();
return 0;
}
"[netdev] up|down", 1, 2,
netdev_dpdk_set_admin_state, NULL);
- ovs_thread_create("dpdk_watchdog", dpdk_watchdog, NULL);
}
/* Client Rings */
}
static int
-dpdk_ring_open(const char dev_name[], unsigned int *eth_port_id) OVS_REQUIRES(dpdk_mutex)
+dpdk_ring_open(const char dev_name[], unsigned int *eth_port_id)
+ OVS_REQUIRES(dpdk_mutex)
{
struct dpdk_ring *ivshmem;
unsigned int port_no;
}
static int
-netdev_dpdk_ring_send(struct netdev *netdev_, int qid,
- struct dp_packet **pkts, int cnt, bool may_steal)
+netdev_dpdk_ring_send(struct netdev *netdev, int qid,
+ struct dp_packet_batch *batch, bool may_steal,
+ bool concurrent_txq)
{
- struct netdev_dpdk *netdev = netdev_dpdk_cast(netdev_);
+ struct netdev_dpdk *dev = netdev_dpdk_cast(netdev);
unsigned i;
/* When using 'dpdkr' and sending to a DPDK ring, we want to ensure that the
* rss hash field is clear. This is because the same mbuf may be modified by
* the consumer of the ring and return into the datapath without recalculating
* the RSS hash. */
- for (i = 0; i < cnt; i++) {
- dp_packet_rss_invalidate(pkts[i]);
+ for (i = 0; i < batch->count; i++) {
+ dp_packet_rss_invalidate(batch->packets[i]);
}
- netdev_dpdk_send__(netdev, qid, pkts, cnt, may_steal);
+ netdev_dpdk_send__(dev, qid, batch, may_steal, concurrent_txq);
return 0;
}
* qos_conf. Set netdevs qos_conf to NULL.
*/
static void
-qos_delete_conf(struct netdev *netdev_)
+qos_delete_conf(struct netdev *netdev)
{
- struct netdev_dpdk *netdev = netdev_dpdk_cast(netdev_);
+ struct netdev_dpdk *dev = netdev_dpdk_cast(netdev);
- rte_spinlock_lock(&netdev->qos_lock);
- if (netdev->qos_conf) {
- if (netdev->qos_conf->ops->qos_destruct) {
- netdev->qos_conf->ops->qos_destruct(netdev_, netdev->qos_conf);
+ rte_spinlock_lock(&dev->qos_lock);
+ if (dev->qos_conf) {
+ if (dev->qos_conf->ops->qos_destruct) {
+ dev->qos_conf->ops->qos_destruct(netdev, dev->qos_conf);
}
- netdev->qos_conf = NULL;
+ dev->qos_conf = NULL;
}
- rte_spinlock_unlock(&netdev->qos_lock);
+ rte_spinlock_unlock(&dev->qos_lock);
}
static int
}
static int
-netdev_dpdk_get_qos(const struct netdev *netdev_,
+netdev_dpdk_get_qos(const struct netdev *netdev,
const char **typep, struct smap *details)
{
- struct netdev_dpdk *netdev = netdev_dpdk_cast(netdev_);
+ struct netdev_dpdk *dev = netdev_dpdk_cast(netdev);
int error = 0;
- ovs_mutex_lock(&netdev->mutex);
- if(netdev->qos_conf) {
- *typep = netdev->qos_conf->ops->qos_name;
- error = (netdev->qos_conf->ops->qos_get
- ? netdev->qos_conf->ops->qos_get(netdev_, details): 0);
+ ovs_mutex_lock(&dev->mutex);
+ if(dev->qos_conf) {
+ *typep = dev->qos_conf->ops->qos_name;
+ error = (dev->qos_conf->ops->qos_get
+ ? dev->qos_conf->ops->qos_get(netdev, details): 0);
+ } else {
+ /* No QoS configuration set, return an empty string */
+ *typep = "";
}
- ovs_mutex_unlock(&netdev->mutex);
+ ovs_mutex_unlock(&dev->mutex);
return error;
}
static int
-netdev_dpdk_set_qos(struct netdev *netdev_,
+netdev_dpdk_set_qos(struct netdev *netdev,
const char *type, const struct smap *details)
{
- struct netdev_dpdk *netdev = netdev_dpdk_cast(netdev_);
+ struct netdev_dpdk *dev = netdev_dpdk_cast(netdev);
const struct dpdk_qos_ops *new_ops = NULL;
int error = 0;
new_ops = qos_lookup_name(type);
if (type[0] == '\0' || !new_ops || !new_ops->qos_construct) {
- qos_delete_conf(netdev_);
+ qos_delete_conf(netdev);
return EOPNOTSUPP;
}
- ovs_mutex_lock(&netdev->mutex);
+ ovs_mutex_lock(&dev->mutex);
- if (netdev->qos_conf) {
- if (new_ops == netdev->qos_conf->ops) {
- error = new_ops->qos_set ? new_ops->qos_set(netdev_, details) : 0;
+ if (dev->qos_conf) {
+ if (new_ops == dev->qos_conf->ops) {
+ error = new_ops->qos_set ? new_ops->qos_set(netdev, details) : 0;
} else {
/* Delete existing QoS configuration. */
- qos_delete_conf(netdev_);
- ovs_assert(netdev->qos_conf == NULL);
+ qos_delete_conf(netdev);
+ ovs_assert(dev->qos_conf == NULL);
/* Install new QoS configuration. */
- error = new_ops->qos_construct(netdev_, details);
- ovs_assert((error == 0) == (netdev->qos_conf != NULL));
+ error = new_ops->qos_construct(netdev, details);
}
} else {
- error = new_ops->qos_construct(netdev_, details);
- ovs_assert((error == 0) == (netdev->qos_conf != NULL));
+ error = new_ops->qos_construct(netdev, details);
+ }
+
+ ovs_assert((error == 0) == (dev->qos_conf != NULL));
+ if (error) {
+ VLOG_ERR("Failed to set QoS type %s on port %s, returned error: %s",
+ type, netdev->name, rte_strerror(-error));
}
- ovs_mutex_unlock(&netdev->mutex);
+ ovs_mutex_unlock(&dev->mutex);
return error;
}
};
static struct egress_policer *
-egress_policer_get__(const struct netdev *netdev_)
+egress_policer_get__(const struct netdev *netdev)
{
- struct netdev_dpdk *netdev = netdev_dpdk_cast(netdev_);
- return CONTAINER_OF(netdev->qos_conf, struct egress_policer, qos_conf);
+ struct netdev_dpdk *dev = netdev_dpdk_cast(netdev);
+ return CONTAINER_OF(dev->qos_conf, struct egress_policer, qos_conf);
}
static int
-egress_policer_qos_construct(struct netdev *netdev_,
- const struct smap *details)
+egress_policer_qos_construct(struct netdev *netdev,
+ const struct smap *details)
{
- struct netdev_dpdk *netdev = netdev_dpdk_cast(netdev_);
+ struct netdev_dpdk *dev = netdev_dpdk_cast(netdev);
struct egress_policer *policer;
- const char *cir_s;
- const char *cbs_s;
int err = 0;
- rte_spinlock_lock(&netdev->qos_lock);
+ rte_spinlock_lock(&dev->qos_lock);
policer = xmalloc(sizeof *policer);
qos_conf_init(&policer->qos_conf, &egress_policer_ops);
- netdev->qos_conf = &policer->qos_conf;
- cir_s = smap_get(details, "cir");
- cbs_s = smap_get(details, "cbs");
- policer->app_srtcm_params.cir = cir_s ? strtoull(cir_s, NULL, 10) : 0;
- policer->app_srtcm_params.cbs = cbs_s ? strtoull(cbs_s, NULL, 10) : 0;
+ dev->qos_conf = &policer->qos_conf;
+ policer->app_srtcm_params.cir = smap_get_ullong(details, "cir", 0);
+ policer->app_srtcm_params.cbs = smap_get_ullong(details, "cbs", 0);
policer->app_srtcm_params.ebs = 0;
err = rte_meter_srtcm_config(&policer->egress_meter,
&policer->app_srtcm_params);
- rte_spinlock_unlock(&netdev->qos_lock);
+
+ if (err < 0) {
+ /* Error occurred during rte_meter creation, destroy the policer
+ * and set the qos configuration for the netdev dpdk to NULL
+ */
+ free(policer);
+ dev->qos_conf = NULL;
+ err = -err;
+ }
+ rte_spinlock_unlock(&dev->qos_lock);
return err;
}
static void
-egress_policer_qos_destruct(struct netdev *netdev_ OVS_UNUSED,
+egress_policer_qos_destruct(struct netdev *netdev OVS_UNUSED,
struct qos_conf *conf)
{
struct egress_policer *policer = CONTAINER_OF(conf, struct egress_policer,
1ULL * policer->app_srtcm_params.cir);
smap_add_format(details, "cbs", "%llu",
1ULL * policer->app_srtcm_params.cbs);
+
return 0;
}
static int
-egress_policer_qos_set(struct netdev *netdev_, const struct smap *details)
+egress_policer_qos_set(struct netdev *netdev, const struct smap *details)
{
struct egress_policer *policer;
- const char *cir_s;
- const char *cbs_s;
+ struct netdev_dpdk *dev = netdev_dpdk_cast(netdev);
int err = 0;
- policer = egress_policer_get__(netdev_);
- cir_s = smap_get(details, "cir");
- cbs_s = smap_get(details, "cbs");
- policer->app_srtcm_params.cir = cir_s ? strtoull(cir_s, NULL, 10) : 0;
- policer->app_srtcm_params.cbs = cbs_s ? strtoull(cbs_s, NULL, 10) : 0;
+ policer = egress_policer_get__(netdev);
+ rte_spinlock_lock(&dev->qos_lock);
+ policer->app_srtcm_params.cir = smap_get_ullong(details, "cir", 0);
+ policer->app_srtcm_params.cbs = smap_get_ullong(details, "cbs", 0);
policer->app_srtcm_params.ebs = 0;
err = rte_meter_srtcm_config(&policer->egress_meter,
&policer->app_srtcm_params);
- return err;
-}
-
-static inline bool
-egress_policer_pkt_handle__(struct rte_meter_srtcm *meter,
- struct rte_mbuf *pkt, uint64_t time)
-{
- uint32_t pkt_len = rte_pktmbuf_pkt_len(pkt) - sizeof(struct ether_hdr);
+ if (err < 0) {
+ /* Error occurred during rte_meter creation, destroy the policer
+ * and set the qos configuration for the netdev dpdk to NULL
+ */
+ free(policer);
+ dev->qos_conf = NULL;
+ err = -err;
+ }
+ rte_spinlock_unlock(&dev->qos_lock);
- return rte_meter_srtcm_color_blind_check(meter, time, pkt_len) ==
- e_RTE_METER_GREEN;
+ return err;
}
static int
-egress_policer_run(struct netdev *netdev_, struct rte_mbuf **pkts,
- int pkt_cnt)
+egress_policer_run(struct netdev *netdev, struct rte_mbuf **pkts, int pkt_cnt)
{
- int i = 0;
int cnt = 0;
- struct egress_policer *policer = egress_policer_get__(netdev_);
- struct rte_mbuf *pkt = NULL;
- uint64_t current_time = rte_rdtsc();
+ struct egress_policer *policer = egress_policer_get__(netdev);
- for(i = 0; i < pkt_cnt; i++) {
- pkt = pkts[i];
- /* Handle current packet */
- if (egress_policer_pkt_handle__(&policer->egress_meter, pkt,
- current_time)) {
- if (cnt != i) {
- pkts[cnt] = pkt;
- }
- cnt++;
- } else {
- rte_pktmbuf_free(pkt);
- }
- }
+ cnt = netdev_dpdk_policer_run(&policer->egress_meter, pkts, pkt_cnt);
return cnt;
}
egress_policer_run
};
-#define NETDEV_DPDK_CLASS(NAME, INIT, CONSTRUCT, DESTRUCT, MULTIQ, SEND, \
- GET_CARRIER, GET_STATS, GET_FEATURES, GET_STATUS, RXQ_RECV) \
+static int
+netdev_dpdk_reconfigure(struct netdev *netdev)
+{
+ struct netdev_dpdk *dev = netdev_dpdk_cast(netdev);
+ int err = 0;
+
+ ovs_mutex_lock(&dpdk_mutex);
+ ovs_mutex_lock(&dev->mutex);
+
+ if (netdev->n_txq == dev->requested_n_txq
+ && netdev->n_rxq == dev->requested_n_rxq
+ && dev->mtu == dev->requested_mtu) {
+ /* Reconfiguration is unnecessary */
+
+ goto out;
+ }
+
+ rte_eth_dev_stop(dev->port_id);
+
+ if (dev->mtu != dev->requested_mtu) {
+ netdev_dpdk_mempool_configure(dev);
+ }
+
+ netdev->n_txq = dev->requested_n_txq;
+ netdev->n_rxq = dev->requested_n_rxq;
+
+ rte_free(dev->tx_q);
+ err = dpdk_eth_dev_init(dev);
+ netdev_dpdk_alloc_txq(dev, netdev->n_txq);
+
+ netdev_change_seq_changed(netdev);
+
+out:
+
+ ovs_mutex_unlock(&dev->mutex);
+ ovs_mutex_unlock(&dpdk_mutex);
+
+ return err;
+}
+
+static int
+netdev_dpdk_vhost_user_reconfigure(struct netdev *netdev)
+{
+ struct netdev_dpdk *dev = netdev_dpdk_cast(netdev);
+
+ ovs_mutex_lock(&dpdk_mutex);
+ ovs_mutex_lock(&dev->mutex);
+
+ netdev->n_txq = dev->requested_n_txq;
+ netdev->n_rxq = dev->requested_n_rxq;
+
+ /* Enable TX queue 0 by default if it wasn't disabled. */
+ if (dev->tx_q[0].map == OVS_VHOST_QUEUE_MAP_UNKNOWN) {
+ dev->tx_q[0].map = 0;
+ }
+
+ netdev_dpdk_remap_txqs(dev);
+
+ if (dev->requested_socket_id != dev->socket_id
+ || dev->requested_mtu != dev->mtu) {
+ if (!netdev_dpdk_mempool_configure(dev)) {
+ netdev_change_seq_changed(netdev);
+ }
+ }
+
+ if (netdev_dpdk_get_vid(dev) >= 0) {
+ dev->vhost_reconfigured = true;
+ }
+
+ ovs_mutex_unlock(&dev->mutex);
+ ovs_mutex_unlock(&dpdk_mutex);
+
+ return 0;
+}
+
+#define NETDEV_DPDK_CLASS(NAME, INIT, CONSTRUCT, DESTRUCT, \
+ SET_CONFIG, SET_TX_MULTIQ, SEND, \
+ GET_CARRIER, GET_STATS, \
+ GET_FEATURES, GET_STATUS, \
+ RECONFIGURE, RXQ_RECV) \
{ \
NAME, \
true, /* is_pmd */ \
DESTRUCT, \
netdev_dpdk_dealloc, \
netdev_dpdk_get_config, \
- netdev_dpdk_set_config, \
+ SET_CONFIG, \
NULL, /* get_tunnel_config */ \
NULL, /* build header */ \
NULL, /* push header */ \
NULL, /* pop header */ \
netdev_dpdk_get_numa_id, /* get_numa_id */ \
- MULTIQ, /* set_multiq */ \
+ SET_TX_MULTIQ, \
\
SEND, /* send */ \
NULL, /* send_wait */ \
GET_FEATURES, \
NULL, /* set_advertisements */ \
\
- NULL, /* set_policing */ \
+ netdev_dpdk_set_policing, \
netdev_dpdk_get_qos_types, \
NULL, /* get_qos_capabilities */ \
netdev_dpdk_get_qos, \
NULL, /* arp_lookup */ \
\
netdev_dpdk_update_flags, \
+ RECONFIGURE, \
\
netdev_dpdk_rxq_alloc, \
netdev_dpdk_rxq_construct, \
static int
process_vhost_flags(char *flag, char *default_val, int size,
- char **argv, char **new_val)
+ const struct smap *ovs_other_config,
+ char **new_val)
{
+ const char *val;
int changed = 0;
- /* Depending on which version of vhost is in use, process the vhost-specific
- * flag if it is provided on the vswitchd command line, otherwise resort to
- * a default value.
- *
- * For vhost-user: Process "-vhost_sock_dir" to set the custom location of
- * the vhost-user socket(s).
- * For vhost-cuse: Process "-cuse_dev_name" to set the custom name of the
- * vhost-cuse character device.
+ val = smap_get(ovs_other_config, flag);
+
+ /* Process the vhost-sock-dir flag if it is provided, otherwise resort to
+ * default value.
*/
- if (!strcmp(argv[1], flag) && (strlen(argv[2]) <= size)) {
+ if (val && (strlen(val) <= size)) {
changed = 1;
- *new_val = xstrdup(argv[2]);
+ *new_val = xstrdup(val);
VLOG_INFO("User-provided %s in use: %s", flag, *new_val);
} else {
VLOG_INFO("No %s provided - defaulting to %s", flag, default_val);
return changed;
}
-int
-dpdk_init(int argc, char **argv)
+static char **
+grow_argv(char ***argv, size_t cur_siz, size_t grow_by)
{
- int result;
- int base = 0;
- char *pragram_name = argv[0];
+ return xrealloc(*argv, sizeof(char *) * (cur_siz + grow_by));
+}
- if (argc < 2 || strcmp(argv[1], "--dpdk"))
- return 0;
+static void
+dpdk_option_extend(char ***argv, int argc, const char *option,
+ const char *value)
+{
+ char **newargv = grow_argv(argv, argc, 2);
+ *argv = newargv;
+ newargv[argc] = xstrdup(option);
+ newargv[argc+1] = xstrdup(value);
+}
+
+static char **
+move_argv(char ***argv, size_t cur_size, char **src_argv, size_t src_argc)
+{
+ char **newargv = grow_argv(argv, cur_size, src_argc);
+ while (src_argc--) {
+ newargv[cur_size+src_argc] = src_argv[src_argc];
+ src_argv[src_argc] = NULL;
+ }
+ return newargv;
+}
- /* Remove the --dpdk argument from arg list.*/
- argc--;
- argv++;
+static int
+extra_dpdk_args(const char *ovs_extra_config, char ***argv, int argc)
+{
+ int ret = argc;
+ char *release_tok = xstrdup(ovs_extra_config);
+ char *tok, *endptr = NULL;
- /* Reject --user option */
- int i;
- for (i = 0; i < argc; i++) {
- if (!strcmp(argv[i], "--user")) {
- VLOG_ERR("Can not mix --dpdk and --user options, aborting.");
+ for (tok = strtok_r(release_tok, " ", &endptr); tok != NULL;
+ tok = strtok_r(NULL, " ", &endptr)) {
+ char **newarg = grow_argv(argv, ret, 1);
+ *argv = newarg;
+ newarg[ret++] = xstrdup(tok);
+ }
+ free(release_tok);
+ return ret;
+}
+
+static bool
+argv_contains(char **argv_haystack, const size_t argc_haystack,
+ const char *needle)
+{
+ for (size_t i = 0; i < argc_haystack; ++i) {
+ if (!strcmp(argv_haystack[i], needle))
+ return true;
+ }
+ return false;
+}
+
+static int
+construct_dpdk_options(const struct smap *ovs_other_config,
+ char ***argv, const int initial_size,
+ char **extra_args, const size_t extra_argc)
+{
+ struct dpdk_options_map {
+ const char *ovs_configuration;
+ const char *dpdk_option;
+ bool default_enabled;
+ const char *default_value;
+ } opts[] = {
+ {"dpdk-lcore-mask", "-c", false, NULL},
+ {"dpdk-hugepage-dir", "--huge-dir", false, NULL},
+ };
+
+ int i, ret = initial_size;
+
+ /*First, construct from the flat-options (non-mutex)*/
+ for (i = 0; i < ARRAY_SIZE(opts); ++i) {
+ const char *lookup = smap_get(ovs_other_config,
+ opts[i].ovs_configuration);
+ if (!lookup && opts[i].default_enabled) {
+ lookup = opts[i].default_value;
+ }
+
+ if (lookup) {
+ if (!argv_contains(extra_args, extra_argc, opts[i].dpdk_option)) {
+ dpdk_option_extend(argv, ret, opts[i].dpdk_option, lookup);
+ ret += 2;
+ } else {
+ VLOG_WARN("Ignoring database defined option '%s' due to "
+ "dpdk_extras config", opts[i].dpdk_option);
+ }
}
}
-#ifdef VHOST_CUSE
- if (process_vhost_flags("-cuse_dev_name", xstrdup("vhost-net"),
- PATH_MAX, argv, &cuse_dev_name)) {
-#else
- if (process_vhost_flags("-vhost_sock_dir", xstrdup(ovs_rundir()),
- NAME_MAX, argv, &vhost_sock_dir)) {
+ return ret;
+}
+
+#define MAX_DPDK_EXCL_OPTS 10
+
+static int
+construct_dpdk_mutex_options(const struct smap *ovs_other_config,
+ char ***argv, const int initial_size,
+ char **extra_args, const size_t extra_argc)
+{
+ struct dpdk_exclusive_options_map {
+ const char *category;
+ const char *ovs_dpdk_options[MAX_DPDK_EXCL_OPTS];
+ const char *eal_dpdk_options[MAX_DPDK_EXCL_OPTS];
+ const char *default_value;
+ int default_option;
+ } excl_opts[] = {
+ {"memory type",
+ {"dpdk-alloc-mem", "dpdk-socket-mem", NULL,},
+ {"-m", "--socket-mem", NULL,},
+ "1024,0", 1
+ },
+ };
+
+ int i, ret = initial_size;
+ for (i = 0; i < ARRAY_SIZE(excl_opts); ++i) {
+ int found_opts = 0, scan, found_pos = -1;
+ const char *found_value;
+ struct dpdk_exclusive_options_map *popt = &excl_opts[i];
+
+ for (scan = 0; scan < MAX_DPDK_EXCL_OPTS
+ && popt->ovs_dpdk_options[scan]; ++scan) {
+ const char *lookup = smap_get(ovs_other_config,
+ popt->ovs_dpdk_options[scan]);
+ if (lookup && strlen(lookup)) {
+ found_opts++;
+ found_pos = scan;
+ found_value = lookup;
+ }
+ }
+
+ if (!found_opts) {
+ if (popt->default_option) {
+ found_pos = popt->default_option;
+ found_value = popt->default_value;
+ } else {
+ continue;
+ }
+ }
+
+ if (found_opts > 1) {
+ VLOG_ERR("Multiple defined options for %s. Please check your"
+ " database settings and reconfigure if necessary.",
+ popt->category);
+ }
+
+ if (!argv_contains(extra_args, extra_argc,
+ popt->eal_dpdk_options[found_pos])) {
+ dpdk_option_extend(argv, ret, popt->eal_dpdk_options[found_pos],
+ found_value);
+ ret += 2;
+ } else {
+ VLOG_WARN("Ignoring database defined option '%s' due to "
+ "dpdk_extras config", popt->eal_dpdk_options[found_pos]);
+ }
+ }
+
+ return ret;
+}
+
+static int
+get_dpdk_args(const struct smap *ovs_other_config, char ***argv,
+ int argc)
+{
+ const char *extra_configuration;
+ char **extra_args = NULL;
+ int i;
+ size_t extra_argc = 0;
+
+ extra_configuration = smap_get(ovs_other_config, "dpdk-extra");
+ if (extra_configuration) {
+ extra_argc = extra_dpdk_args(extra_configuration, &extra_args, 0);
+ }
+
+ i = construct_dpdk_options(ovs_other_config, argv, argc, extra_args,
+ extra_argc);
+ i = construct_dpdk_mutex_options(ovs_other_config, argv, i, extra_args,
+ extra_argc);
+
+ if (extra_configuration) {
+ *argv = move_argv(argv, i, extra_args, extra_argc);
+ }
+
+ return i + extra_argc;
+}
+
+static char **dpdk_argv;
+static int dpdk_argc;
+
+static void
+deferred_argv_release(void)
+{
+ int result;
+ for (result = 0; result < dpdk_argc; ++result) {
+ free(dpdk_argv[result]);
+ }
+
+ free(dpdk_argv);
+}
+
+static void
+dpdk_init__(const struct smap *ovs_other_config)
+{
+ char **argv = NULL;
+ int result;
+ int argc, argc_tmp;
+ bool auto_determine = true;
+ int err = 0;
+ cpu_set_t cpuset;
+ char *sock_dir_subcomponent;
+
+ if (!smap_get_bool(ovs_other_config, "dpdk-init", false)) {
+ VLOG_INFO("DPDK Disabled - to change this requires a restart.\n");
+ return;
+ }
+
+ VLOG_INFO("DPDK Enabled, initializing");
+ if (process_vhost_flags("vhost-sock-dir", xstrdup(ovs_rundir()),
+ NAME_MAX, ovs_other_config,
+ &sock_dir_subcomponent)) {
struct stat s;
- int err;
+ if (!strstr(sock_dir_subcomponent, "..")) {
+ vhost_sock_dir = xasprintf("%s/%s", ovs_rundir(),
+ sock_dir_subcomponent);
+
+ err = stat(vhost_sock_dir, &s);
+ if (err) {
+ VLOG_ERR("vhost-user sock directory '%s' does not exist.",
+ vhost_sock_dir);
+ }
+ } else {
+ vhost_sock_dir = xstrdup(ovs_rundir());
+ VLOG_ERR("vhost-user sock directory request '%s/%s' has invalid"
+ "characters '..' - using %s instead.",
+ ovs_rundir(), sock_dir_subcomponent, ovs_rundir());
+ }
+ free(sock_dir_subcomponent);
+ } else {
+ vhost_sock_dir = sock_dir_subcomponent;
+ }
- err = stat(vhost_sock_dir, &s);
- if (err) {
- VLOG_ERR("vHostUser socket DIR '%s' does not exist.",
- vhost_sock_dir);
- return err;
+ argv = grow_argv(&argv, 0, 1);
+ argc = 1;
+ argv[0] = xstrdup(ovs_get_program_name());
+ argc_tmp = get_dpdk_args(ovs_other_config, &argv, argc);
+
+ while (argc_tmp != argc) {
+ if (!strcmp("-c", argv[argc]) || !strcmp("-l", argv[argc])) {
+ auto_determine = false;
+ break;
}
-#endif
- /* Remove the vhost flag configuration parameters from the argument
- * list, so that the correct elements are passed to the DPDK
- * initialization function
- */
- argc -= 2;
- argv += 2; /* Increment by two to bypass the vhost flag arguments */
- base = 2;
+ argc++;
}
+ argc = argc_tmp;
- /* Keep the program name argument as this is needed for call to
- * rte_eal_init()
+ /**
+ * NOTE: This is an unsophisticated mechanism for determining the DPDK
+ * lcore for the DPDK Master.
*/
- argv[0] = pragram_name;
+ if (auto_determine) {
+ int i;
+ /* Get the main thread affinity */
+ CPU_ZERO(&cpuset);
+ err = pthread_getaffinity_np(pthread_self(), sizeof(cpu_set_t),
+ &cpuset);
+ if (!err) {
+ for (i = 0; i < CPU_SETSIZE; i++) {
+ if (CPU_ISSET(i, &cpuset)) {
+ argv = grow_argv(&argv, argc, 2);
+ argv[argc++] = xstrdup("-c");
+ argv[argc++] = xasprintf("0x%08llX", (1ULL<<i));
+ i = CPU_SETSIZE;
+ }
+ }
+ } else {
+ VLOG_ERR("Thread getaffinity error %d. Using core 0x1", err);
+ /* User did not set dpdk-lcore-mask and unable to get current
+ * thread affintity - default to core 0x1 */
+ argv = grow_argv(&argv, argc, 2);
+ argv[argc++] = xstrdup("-c");
+ argv[argc++] = xasprintf("0x%X", 1);
+ }
+ }
+
+ argv = grow_argv(&argv, argc, 1);
+ argv[argc] = NULL;
+
+ optind = 1;
+
+ if (VLOG_IS_INFO_ENABLED()) {
+ struct ds eal_args;
+ int opt;
+ ds_init(&eal_args);
+ ds_put_cstr(&eal_args, "EAL ARGS:");
+ for (opt = 0; opt < argc; ++opt) {
+ ds_put_cstr(&eal_args, " ");
+ ds_put_cstr(&eal_args, argv[opt]);
+ }
+ VLOG_INFO("%s", ds_cstr_ro(&eal_args));
+ ds_destroy(&eal_args);
+ }
/* Make sure things are initialized ... */
result = rte_eal_init(argc, argv);
ovs_abort(result, "Cannot init EAL");
}
+ /* Set the main thread affinity back to pre rte_eal_init() value */
+ if (auto_determine && !err) {
+ err = pthread_setaffinity_np(pthread_self(), sizeof(cpu_set_t),
+ &cpuset);
+ if (err) {
+ VLOG_ERR("Thread setaffinity error %d", err);
+ }
+ }
+
+ dpdk_argv = argv;
+ dpdk_argc = argc;
+
+ atexit(deferred_argv_release);
+
rte_memzone_dump(stdout);
rte_eal_init_ret = 0;
- if (argc > result) {
- argv[result] = argv[0];
- }
-
/* We are called from the main thread here */
RTE_PER_LCORE(_lcore_id) = NON_PMD_CORE_ID;
- return result + 1 + base;
+ ovs_thread_create("dpdk_watchdog", dpdk_watchdog, NULL);
+
+ dpdk_vhost_class_init();
+
+#ifdef DPDK_PDUMP
+ VLOG_INFO("DPDK pdump packet capture enabled");
+ err = rte_pdump_init(ovs_rundir());
+ if (err) {
+ VLOG_INFO("Error initialising DPDK pdump");
+ rte_pdump_uninit();
+ } else {
+ char *server_socket_path;
+
+ server_socket_path = xasprintf("%s/%s", ovs_rundir(),
+ "pdump_server_socket");
+ fatal_signal_add_file_to_unlink(server_socket_path);
+ free(server_socket_path);
+ }
+#endif
+
+ /* Finally, register the dpdk classes */
+ netdev_dpdk_register();
+}
+
+void
+dpdk_init(const struct smap *ovs_other_config)
+{
+ static struct ovsthread_once once = OVSTHREAD_ONCE_INITIALIZER;
+
+ if (ovs_other_config && ovsthread_once_start(&once)) {
+ dpdk_init__(ovs_other_config);
+ ovsthread_once_done(&once);
+ }
}
static const struct netdev_class dpdk_class =
NULL,
netdev_dpdk_construct,
netdev_dpdk_destruct,
- netdev_dpdk_set_multiq,
+ netdev_dpdk_set_config,
+ netdev_dpdk_set_tx_multiq,
netdev_dpdk_eth_send,
netdev_dpdk_get_carrier,
netdev_dpdk_get_stats,
netdev_dpdk_get_features,
netdev_dpdk_get_status,
+ netdev_dpdk_reconfigure,
netdev_dpdk_rxq_recv);
static const struct netdev_class dpdk_ring_class =
NULL,
netdev_dpdk_ring_construct,
netdev_dpdk_destruct,
- netdev_dpdk_set_multiq,
+ netdev_dpdk_ring_set_config,
+ netdev_dpdk_set_tx_multiq,
netdev_dpdk_ring_send,
netdev_dpdk_get_carrier,
netdev_dpdk_get_stats,
netdev_dpdk_get_features,
netdev_dpdk_get_status,
+ netdev_dpdk_reconfigure,
netdev_dpdk_rxq_recv);
-static const struct netdev_class OVS_UNUSED dpdk_vhost_cuse_class =
- NETDEV_DPDK_CLASS(
- "dpdkvhostcuse",
- dpdk_vhost_cuse_class_init,
- netdev_dpdk_vhost_cuse_construct,
- netdev_dpdk_vhost_destruct,
- netdev_dpdk_vhost_cuse_set_multiq,
- netdev_dpdk_vhost_send,
- netdev_dpdk_vhost_get_carrier,
- netdev_dpdk_vhost_get_stats,
- NULL,
- NULL,
- netdev_dpdk_vhost_rxq_recv);
-
-static const struct netdev_class OVS_UNUSED dpdk_vhost_user_class =
+static const struct netdev_class dpdk_vhost_user_class =
NETDEV_DPDK_CLASS(
"dpdkvhostuser",
dpdk_vhost_user_class_init,
netdev_dpdk_vhost_user_construct,
netdev_dpdk_vhost_destruct,
- netdev_dpdk_vhost_set_multiq,
+ NULL,
+ NULL,
netdev_dpdk_vhost_send,
netdev_dpdk_vhost_get_carrier,
netdev_dpdk_vhost_get_stats,
NULL,
NULL,
+ netdev_dpdk_vhost_user_reconfigure,
netdev_dpdk_vhost_rxq_recv);
void
netdev_dpdk_register(void)
{
- static struct ovsthread_once once = OVSTHREAD_ONCE_INITIALIZER;
-
- if (rte_eal_init_ret) {
- return;
- }
-
- if (ovsthread_once_start(&once)) {
- dpdk_common_init();
- netdev_register_provider(&dpdk_class);
- netdev_register_provider(&dpdk_ring_class);
-#ifdef VHOST_CUSE
- netdev_register_provider(&dpdk_vhost_cuse_class);
-#else
- netdev_register_provider(&dpdk_vhost_user_class);
-#endif
- ovsthread_once_done(&once);
- }
+ dpdk_common_init();
+ netdev_register_provider(&dpdk_class);
+ netdev_register_provider(&dpdk_ring_class);
+ netdev_register_provider(&dpdk_vhost_user_class);
}
-int
-pmd_thread_setaffinity_cpu(unsigned cpu)
+void
+dpdk_set_lcore_id(unsigned cpu)
{
- cpu_set_t cpuset;
- int err;
-
- CPU_ZERO(&cpuset);
- CPU_SET(cpu, &cpuset);
- err = pthread_setaffinity_np(pthread_self(), sizeof(cpu_set_t), &cpuset);
- if (err) {
- VLOG_ERR("Thread affinity error %d",err);
- return err;
- }
/* NON_PMD_CORE_ID is reserved for use by non pmd threads. */
ovs_assert(cpu != NON_PMD_CORE_ID);
RTE_PER_LCORE(_lcore_id) = cpu;
-
- return 0;
}
static bool
projects / ovs.git / blobdiff