X-Git-Url: http://git.cascardo.eti.br/?a=blobdiff_plain;f=lib%2Fnetdev-dpdk.c;h=f94e0d4b0a6743407f37c337cb9f0527e33a5fa8;hb=b83a2df1c519108bfff96f599ea91e4ba129c716;hp=97689dd3dcc508e965f7d6b40f66f59923d9f3e2;hpb=dc6ba5dc8b996210f85d4bc6884af469a5244b96;p=cascardo%2Fovs.git diff --git a/lib/netdev-dpdk.c b/lib/netdev-dpdk.c index 97689dd3d..f94e0d4b0 100644 --- a/lib/netdev-dpdk.c +++ b/lib/netdev-dpdk.c @@ -1,5 +1,5 @@ /* - * Copyright (c) 2014 Nicira, Inc. + * Copyright (c) 2014, 2015, 2016 Nicira, Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -33,6 +33,7 @@ #include "dirs.h" #include "dp-packet.h" #include "dpif-netdev.h" +#include "fatal-signal.h" #include "list.h" #include "netdev-dpdk.h" #include "netdev-provider.h" @@ -65,11 +66,17 @@ static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(5, 20); /* * need to reserve tons of extra space in the mbufs so we can align the * DMA addresses to 4KB. + * The minimum mbuf size is limited to avoid scatter behaviour and drop in + * performance for standard Ethernet MTU. */ - #define MTU_TO_MAX_LEN(mtu) ((mtu) + ETHER_HDR_LEN + ETHER_CRC_LEN) -#define MBUF_SIZE(mtu) (MTU_TO_MAX_LEN(mtu) + (512) + \ - sizeof(struct rte_mbuf) + RTE_PKTMBUF_HEADROOM) +#define MBUF_SIZE_MTU(mtu) (MTU_TO_MAX_LEN(mtu) \ + + sizeof(struct dp_packet) \ + + RTE_PKTMBUF_HEADROOM) +#define MBUF_SIZE_DRIVER (2048 \ + + sizeof (struct rte_mbuf) \ + + RTE_PKTMBUF_HEADROOM) +#define MBUF_SIZE(mtu) MAX(MBUF_SIZE_MTU(mtu), MBUF_SIZE_DRIVER) /* 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 @@ -93,8 +100,8 @@ BUILD_ASSERT_DECL((MAX_NB_MBUF / ROUND_DOWN_POW2(MAX_NB_MBUF/MIN_NB_MBUF)) #define NIC_PORT_RX_Q_SIZE 2048 /* Size of Physical NIC RX Queue, Max (n+32<=4096)*/ #define NIC_PORT_TX_Q_SIZE 2048 /* Size of Physical NIC TX Queue, Max (n+32<=4096)*/ -char *cuse_dev_name = NULL; /* Character device cuse_dev_name. */ -char *vhost_sock_dir = NULL; /* Location of vhost-user sockets */ +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. @@ -181,7 +188,7 @@ struct dpdk_ring { /* For the client rings */ struct rte_ring *cring_tx; struct rte_ring *cring_rx; - int user_port_id; /* User given port no, parsed from port name */ + unsigned int user_port_id; /* User given port no, parsed from port name */ int eth_port_id; /* ethernet device port id */ struct ovs_list list_node OVS_GUARDED_BY(dpdk_mutex); }; @@ -204,7 +211,7 @@ struct netdev_dpdk { /* Protects stats */ rte_spinlock_t stats_lock; - uint8_t hwaddr[ETH_ADDR_LEN]; + struct eth_addr hwaddr; enum netdev_flags flags; struct rte_eth_link link; @@ -215,12 +222,9 @@ struct netdev_dpdk { * 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; - /* Spinlock for vhost transmission. Other DPDK devices use spinlocks in - * dpdk_tx_queue */ - rte_spinlock_t vhost_tx_lock; - /* virtio-net structure for vhost device */ OVSRCU_TYPE(struct virtio_net *) virtio_dev; @@ -236,7 +240,7 @@ struct netdev_rxq_dpdk { int port_id; }; -static bool thread_is_pmd(void); +static bool dpdk_thread_is_pmd(void); static int netdev_dpdk_construct(struct netdev *); @@ -422,6 +426,70 @@ dpdk_watchdog(void *dummy OVS_UNUSED) return NULL; } +static int +dpdk_eth_dev_queue_setup(struct netdev_dpdk *dev, int n_rxq, int n_txq) +{ + int diag = 0; + int i; + + /* 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 + * available. When this happens we can retry the configuration + * and request less queues */ + while (n_rxq && n_txq) { + if (diag) { + 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); + if (diag) { + break; + } + + for (i = 0; i < n_txq; i++) { + diag = rte_eth_tx_queue_setup(dev->port_id, i, NIC_PORT_TX_Q_SIZE, + dev->socket_id, NULL); + if (diag) { + VLOG_INFO("Interface %s txq(%d) setup error: %s", + dev->up.name, i, rte_strerror(-diag)); + break; + } + } + + if (i != n_txq) { + /* Retry with less tx queues */ + n_txq = i; + continue; + } + + for (i = 0; i < n_rxq; i++) { + diag = rte_eth_rx_queue_setup(dev->port_id, i, NIC_PORT_RX_Q_SIZE, + dev->socket_id, NULL, + dev->dpdk_mp->mp); + if (diag) { + VLOG_INFO("Interface %s rxq(%d) setup error: %s", + dev->up.name, i, rte_strerror(-diag)); + break; + } + } + + if (i != n_rxq) { + /* Retry with less rx queues */ + n_rxq = i; + continue; + } + + dev->up.n_rxq = n_rxq; + dev->real_n_txq = n_txq; + + return 0; + } + + return diag; +} + + static int dpdk_eth_dev_init(struct netdev_dpdk *dev) OVS_REQUIRES(dpdk_mutex) { @@ -429,46 +497,28 @@ dpdk_eth_dev_init(struct netdev_dpdk *dev) OVS_REQUIRES(dpdk_mutex) struct rte_eth_dev_info info; struct ether_addr eth_addr; int diag; - int i; + int n_rxq, n_txq; if (dev->port_id < 0 || dev->port_id >= rte_eth_dev_count()) { return ENODEV; } rte_eth_dev_info_get(dev->port_id, &info); - dev->up.n_rxq = MIN(info.max_rx_queues, dev->up.n_rxq); - dev->real_n_txq = MIN(info.max_tx_queues, dev->up.n_txq); - diag = rte_eth_dev_configure(dev->port_id, dev->up.n_rxq, dev->real_n_txq, - &port_conf); + n_rxq = MIN(info.max_rx_queues, dev->up.n_rxq); + n_txq = MIN(info.max_tx_queues, dev->up.n_txq); + + diag = dpdk_eth_dev_queue_setup(dev, n_rxq, n_txq); if (diag) { - VLOG_ERR("eth dev config error %d. rxq:%d txq:%d", diag, dev->up.n_rxq, - dev->real_n_txq); + VLOG_ERR("Interface %s(rxq:%d txq:%d) configure error: %s", + dev->up.name, n_rxq, n_txq, rte_strerror(-diag)); return -diag; } - for (i = 0; i < dev->real_n_txq; i++) { - diag = rte_eth_tx_queue_setup(dev->port_id, i, NIC_PORT_TX_Q_SIZE, - dev->socket_id, NULL); - if (diag) { - VLOG_ERR("eth dev tx queue setup error %d",diag); - return -diag; - } - } - - for (i = 0; i < dev->up.n_rxq; i++) { - diag = rte_eth_rx_queue_setup(dev->port_id, i, NIC_PORT_RX_Q_SIZE, - dev->socket_id, - NULL, dev->dpdk_mp->mp); - if (diag) { - VLOG_ERR("eth dev rx queue setup error %d",diag); - return -diag; - } - } - diag = rte_eth_dev_start(dev->port_id); if (diag) { - VLOG_ERR("eth dev start error %d",diag); + VLOG_ERR("Interface %s start error: %s", dev->up.name, + rte_strerror(-diag)); return -diag; } @@ -478,9 +528,9 @@ dpdk_eth_dev_init(struct netdev_dpdk *dev) OVS_REQUIRES(dpdk_mutex) memset(ð_addr, 0x0, sizeof(eth_addr)); rte_eth_macaddr_get(dev->port_id, ð_addr); VLOG_INFO_RL(&rl, "Port %d: "ETH_ADDR_FMT"", - dev->port_id, ETH_ADDR_ARGS(eth_addr.addr_bytes)); + dev->port_id, ETH_ADDR_BYTES_ARGS(eth_addr.addr_bytes)); - memcpy(dev->hwaddr, eth_addr.addr_bytes, ETH_ADDR_LEN); + memcpy(dev->hwaddr.ea, eth_addr.addr_bytes, ETH_ADDR_LEN); rte_eth_link_get_nowait(dev->port_id, &dev->link); mbp_priv = rte_mempool_get_priv(dev->dpdk_mp->mp); @@ -564,6 +614,7 @@ netdev_dpdk_init(struct netdev *netdev_, unsigned int port_no, netdev_->n_txq = NR_QUEUE; netdev_->n_rxq = NR_QUEUE; + netdev_->requested_n_rxq = NR_QUEUE; netdev->real_n_txq = NR_QUEUE; if (type == DPDK_DEV_ETH) { @@ -584,6 +635,8 @@ unlock: return err; } +/* dev_name must be the prefix followed by a positive decimal number. + * (no leading + or - signs are allowed) */ static int dpdk_dev_parse_name(const char dev_name[], const char prefix[], unsigned int *port_no) @@ -595,20 +648,21 @@ dpdk_dev_parse_name(const char dev_name[], const char prefix[], } cport = dev_name + strlen(prefix); - *port_no = strtol(cport, NULL, 0); /* string must be null terminated */ - return 0; + + if (str_to_uint(cport, 10, port_no)) { + return 0; + } else { + return ENODEV; + } } static int -vhost_construct_helper(struct netdev *netdev_) +vhost_construct_helper(struct netdev *netdev_) OVS_REQUIRES(dpdk_mutex) { - struct netdev_dpdk *netdev = netdev_dpdk_cast(netdev_); - if (rte_eal_init_ret) { return rte_eal_init_ret; } - rte_spinlock_init(&netdev->vhost_tx_lock); return netdev_dpdk_init(netdev_, -1, DPDK_DEV_VHOST); } @@ -641,9 +695,13 @@ netdev_dpdk_vhost_user_construct(struct netdev *netdev_) if (err) { VLOG_ERR("vhost-user socket device setup failure for socket %s\n", netdev->vhost_id); + } else { + fatal_signal_add_file_to_unlink(netdev->vhost_id); + VLOG_INFO("Socket %s created for vhost-user port %s\n", + netdev->vhost_id, netdev_->name); + err = vhost_construct_helper(netdev_); } - VLOG_INFO("Socket %s created for vhost-user port %s\n", netdev->vhost_id, netdev_->name); - err = vhost_construct_helper(netdev_); + ovs_mutex_unlock(&dpdk_mutex); return err; } @@ -697,6 +755,12 @@ netdev_dpdk_vhost_destruct(struct netdev *netdev_) return; } + 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); + } + ovs_mutex_lock(&dpdk_mutex); list_remove(&dev->list_node); dpdk_mp_put(dev->dpdk_mp); @@ -712,20 +776,35 @@ netdev_dpdk_dealloc(struct netdev *netdev_) } static int -netdev_dpdk_get_config(const struct netdev *netdev_, struct smap *args) +netdev_dpdk_get_config(const struct netdev *netdev, struct smap *args) { - struct netdev_dpdk *dev = netdev_dpdk_cast(netdev_); + struct netdev_dpdk *dev = netdev_dpdk_cast(netdev); ovs_mutex_lock(&dev->mutex); - 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, "requested_rx_queues", "%d", netdev->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); + ovs_mutex_unlock(&dev->mutex); + + return 0; +} + static int netdev_dpdk_get_numa_id(const struct netdev *netdev_) { @@ -743,6 +822,7 @@ netdev_dpdk_set_multiq(struct netdev *netdev_, unsigned int n_txq, { 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; @@ -753,12 +833,20 @@ netdev_dpdk_set_multiq(struct netdev *netdev_, unsigned int n_txq, rte_eth_dev_stop(netdev->port_id); + old_txq = netdev->up.n_txq; + old_rxq = netdev->up.n_rxq; netdev->up.n_txq = n_txq; netdev->up.n_rxq = n_rxq; 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; + } netdev->txq_needs_locking = netdev->real_n_txq != netdev->up.n_txq; @@ -769,7 +857,7 @@ netdev_dpdk_set_multiq(struct netdev *netdev_, unsigned int n_txq, } static int -netdev_dpdk_vhost_set_multiq(struct netdev *netdev_, unsigned int n_txq, +netdev_dpdk_vhost_cuse_set_multiq(struct netdev *netdev_, unsigned int n_txq, unsigned int n_rxq) { struct netdev_dpdk *netdev = netdev_dpdk_cast(netdev_); @@ -785,6 +873,32 @@ netdev_dpdk_vhost_set_multiq(struct netdev *netdev_, unsigned int n_txq, 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; + + ovs_mutex_unlock(&netdev->mutex); + ovs_mutex_unlock(&dpdk_mutex); + + return err; +} + +static int +netdev_dpdk_vhost_set_multiq(struct netdev *netdev_, unsigned int n_txq, + unsigned int n_rxq) +{ + 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; + } + + ovs_mutex_lock(&dpdk_mutex); + ovs_mutex_lock(&netdev->mutex); + + rte_free(netdev->tx_q); + netdev->up.n_txq = n_txq; + netdev->up.n_rxq = n_rxq; + netdev_dpdk_alloc_txq(netdev, netdev->up.n_txq); ovs_mutex_unlock(&netdev->mutex); ovs_mutex_unlock(&dpdk_mutex); @@ -884,6 +998,35 @@ is_vhost_running(struct virtio_net *dev) return (dev != NULL && (dev->flags & VIRTIO_DEV_RUNNING)); } +static inline void +netdev_dpdk_vhost_update_rx_counters(struct netdev_stats *stats, + struct dp_packet **packets, int count) +{ + int i; + struct dp_packet *packet; + + stats->rx_packets += count; + for (i = 0; i < count; i++) { + packet = packets[i]; + + if (OVS_UNLIKELY(dp_packet_size(packet) < ETH_HEADER_LEN)) { + /* This only protects the following multicast counting from + * too short packets, but it does not stop the packet from + * further processing. */ + stats->rx_errors++; + stats->rx_length_errors++; + continue; + } + + 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); + } +} + /* * The receive path for the vhost port is the TX path out from guest. */ @@ -895,14 +1038,18 @@ netdev_dpdk_vhost_rxq_recv(struct netdev_rxq *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 = 1; + int qid = rxq_->queue_id; uint16_t nb_rx = 0; if (OVS_UNLIKELY(!is_vhost_running(virtio_dev))) { return EAGAIN; } - nb_rx = rte_vhost_dequeue_burst(virtio_dev, qid, + 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, NETDEV_MAX_BURST); @@ -911,7 +1058,7 @@ netdev_dpdk_vhost_rxq_recv(struct netdev_rxq *rxq_, } rte_spinlock_lock(&vhost_dev->stats_lock); - vhost_dev->stats.rx_packets += (uint64_t)nb_rx; + netdev_dpdk_vhost_update_rx_counters(&vhost_dev->stats, packets, nb_rx); rte_spinlock_unlock(&vhost_dev->stats_lock); *c = (int) nb_rx; @@ -948,9 +1095,27 @@ netdev_dpdk_rxq_recv(struct netdev_rxq *rxq_, struct dp_packet **packets, return 0; } +static inline void +netdev_dpdk_vhost_update_tx_counters(struct netdev_stats *stats, + struct dp_packet **packets, + int attempted, + int dropped) +{ + int i; + int sent = attempted - dropped; + + stats->tx_packets += sent; + stats->tx_dropped += dropped; + + for (i = 0; i < sent; i++) { + stats->tx_bytes += dp_packet_size(packets[i]); + } +} + static void -__netdev_dpdk_vhost_send(struct netdev *netdev, struct dp_packet **pkts, - int cnt, bool may_steal) +__netdev_dpdk_vhost_send(struct netdev *netdev, int qid, + struct dp_packet **pkts, int cnt, + bool may_steal) { struct netdev_dpdk *vhost_dev = netdev_dpdk_cast(netdev); struct virtio_net *virtio_dev = netdev_dpdk_get_virtio(vhost_dev); @@ -965,13 +1130,16 @@ __netdev_dpdk_vhost_send(struct netdev *netdev, struct dp_packet **pkts, goto out; } - /* There is vHost TX single queue, So we need to lock it for TX. */ - rte_spinlock_lock(&vhost_dev->vhost_tx_lock); + if (vhost_dev->txq_needs_locking) { + qid = qid % vhost_dev->real_n_txq; + rte_spinlock_lock(&vhost_dev->tx_q[qid].tx_lock); + } do { + int vhost_qid = qid * VIRTIO_QNUM + VIRTIO_RXQ; unsigned int tx_pkts; - tx_pkts = rte_vhost_enqueue_burst(virtio_dev, VIRTIO_RXQ, + tx_pkts = rte_vhost_enqueue_burst(virtio_dev, vhost_qid, cur_pkts, cnt); if (OVS_LIKELY(tx_pkts)) { /* Packets have been sent.*/ @@ -990,7 +1158,7 @@ __netdev_dpdk_vhost_send(struct netdev *netdev, struct dp_packet **pkts, * Unable to enqueue packets to vhost interface. * Check available entries before retrying. */ - while (!rte_vring_available_entries(virtio_dev, VIRTIO_RXQ)) { + while (!rte_vring_available_entries(virtio_dev, vhost_qid)) { if (OVS_UNLIKELY((rte_get_timer_cycles() - start) > timeout)) { expired = 1; break; @@ -1002,11 +1170,14 @@ __netdev_dpdk_vhost_send(struct netdev *netdev, struct dp_packet **pkts, } } } while (cnt); - rte_spinlock_unlock(&vhost_dev->vhost_tx_lock); + + if (vhost_dev->txq_needs_locking) { + rte_spinlock_unlock(&vhost_dev->tx_q[qid].tx_lock); + } rte_spinlock_lock(&vhost_dev->stats_lock); - vhost_dev->stats.tx_packets += (total_pkts - cnt); - vhost_dev->stats.tx_dropped += cnt; + netdev_dpdk_vhost_update_tx_counters(&vhost_dev->stats, pkts, total_pkts, + cnt); rte_spinlock_unlock(&vhost_dev->stats_lock); out: @@ -1069,7 +1240,7 @@ dpdk_do_tx_copy(struct netdev *netdev, int qid, struct dp_packet **pkts, /* If we are on a non pmd thread we have to use the mempool mutex, because * every non pmd thread shares the same mempool cache */ - if (!thread_is_pmd()) { + if (!dpdk_thread_is_pmd()) { ovs_mutex_lock(&nonpmd_mempool_mutex); } @@ -1107,19 +1278,19 @@ dpdk_do_tx_copy(struct netdev *netdev, int qid, struct dp_packet **pkts, } if (dev->type == DPDK_DEV_VHOST) { - __netdev_dpdk_vhost_send(netdev, (struct dp_packet **) mbufs, newcnt, true); + __netdev_dpdk_vhost_send(netdev, qid, (struct dp_packet **) mbufs, newcnt, true); } else { dpdk_queue_pkts(dev, qid, mbufs, newcnt); dpdk_queue_flush(dev, qid); } - if (!thread_is_pmd()) { + if (!dpdk_thread_is_pmd()) { ovs_mutex_unlock(&nonpmd_mempool_mutex); } } static int -netdev_dpdk_vhost_send(struct netdev *netdev, int qid OVS_UNUSED, struct dp_packet **pkts, +netdev_dpdk_vhost_send(struct netdev *netdev, int qid, struct dp_packet **pkts, int cnt, bool may_steal) { if (OVS_UNLIKELY(pkts[0]->source != DPBUF_DPDK)) { @@ -1132,7 +1303,7 @@ netdev_dpdk_vhost_send(struct netdev *netdev, int qid OVS_UNUSED, struct dp_pack } } } else { - __netdev_dpdk_vhost_send(netdev, pkts, cnt, may_steal); + __netdev_dpdk_vhost_send(netdev, qid, pkts, cnt, may_steal); } return 0; } @@ -1210,14 +1381,13 @@ netdev_dpdk_eth_send(struct netdev *netdev, int qid, } static int -netdev_dpdk_set_etheraddr(struct netdev *netdev, - const uint8_t mac[ETH_ADDR_LEN]) +netdev_dpdk_set_etheraddr(struct netdev *netdev, const struct eth_addr mac) { struct netdev_dpdk *dev = netdev_dpdk_cast(netdev); ovs_mutex_lock(&dev->mutex); if (!eth_addr_equals(dev->hwaddr, mac)) { - memcpy(dev->hwaddr, mac, ETH_ADDR_LEN); + dev->hwaddr = mac; netdev_change_seq_changed(netdev); } ovs_mutex_unlock(&dev->mutex); @@ -1226,13 +1396,12 @@ netdev_dpdk_set_etheraddr(struct netdev *netdev, } static int -netdev_dpdk_get_etheraddr(const struct netdev *netdev, - uint8_t mac[ETH_ADDR_LEN]) +netdev_dpdk_get_etheraddr(const struct netdev *netdev, struct eth_addr *mac) { struct netdev_dpdk *dev = netdev_dpdk_cast(netdev); ovs_mutex_lock(&dev->mutex); - memcpy(mac, dev->hwaddr, ETH_ADDR_LEN); + *mac = dev->hwaddr; ovs_mutex_unlock(&dev->mutex); return 0; @@ -1309,14 +1478,10 @@ netdev_dpdk_vhost_get_stats(const struct netdev *netdev, ovs_mutex_lock(&dev->mutex); memset(stats, 0, sizeof(*stats)); /* Unsupported Stats */ - stats->rx_errors = UINT64_MAX; - stats->tx_errors = UINT64_MAX; - stats->multicast = UINT64_MAX; stats->collisions = UINT64_MAX; stats->rx_crc_errors = UINT64_MAX; stats->rx_fifo_errors = UINT64_MAX; stats->rx_frame_errors = UINT64_MAX; - stats->rx_length_errors = UINT64_MAX; stats->rx_missed_errors = UINT64_MAX; stats->rx_over_errors = UINT64_MAX; stats->tx_aborted_errors = UINT64_MAX; @@ -1325,16 +1490,20 @@ netdev_dpdk_vhost_get_stats(const struct netdev *netdev, stats->tx_fifo_errors = UINT64_MAX; stats->tx_heartbeat_errors = UINT64_MAX; stats->tx_window_errors = UINT64_MAX; - stats->rx_bytes += UINT64_MAX; stats->rx_dropped += UINT64_MAX; - stats->tx_bytes += 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->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; rte_spinlock_unlock(&dev->stats_lock); + ovs_mutex_unlock(&dev->mutex); return 0; @@ -1357,13 +1526,33 @@ netdev_dpdk_get_stats(const struct netdev *netdev, struct netdev_stats *stats) stats->tx_packets = rte_stats.opackets; stats->rx_bytes = rte_stats.ibytes; stats->tx_bytes = rte_stats.obytes; - stats->rx_errors = rte_stats.ierrors; + /* 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; 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_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; @@ -1561,8 +1750,12 @@ netdev_dpdk_get_status(const struct netdev *netdev_, struct smap *args) smap_add_format(args, "max_vfs", "%u", dev_info.max_vfs); smap_add_format(args, "max_vmdq_pools", "%u", dev_info.max_vmdq_pools); - smap_add_format(args, "pci-vendor_id", "0x%u", dev_info.pci_dev->id.vendor_id); - smap_add_format(args, "pci-device_id", "0x%x", dev_info.pci_dev->id.device_id); + if (dev_info.pci_dev) { + smap_add_format(args, "pci-vendor_id", "0x%u", + dev_info.pci_dev->id.vendor_id); + smap_add_format(args, "pci-device_id", "0x%x", + dev_info.pci_dev->id.device_id); + } return 0; } @@ -1630,8 +1823,39 @@ netdev_dpdk_set_admin_state(struct unixctl_conn *conn, int argc, static void set_irq_status(struct virtio_net *dev) { - dev->virtqueue[VIRTIO_RXQ]->used->flags = VRING_USED_F_NO_NOTIFY; - dev->virtqueue[VIRTIO_TXQ]->used->flags = VRING_USED_F_NO_NOTIFY; + uint32_t i; + uint64_t idx; + + for (i = 0; i < dev->virt_qp_nb; 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); + } +} + + +static int +netdev_dpdk_vhost_set_queues(struct netdev_dpdk *netdev, struct virtio_net *dev) +{ + 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; + if (netdev->up.n_txq > netdev->real_n_txq) { + netdev->txq_needs_locking = true; + } else { + netdev->txq_needs_locking = false; + } + + return 0; } /* @@ -1648,26 +1872,31 @@ new_device(struct virtio_net *dev) 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; + } ovsrcu_set(&netdev->virtio_dev, dev); - ovs_mutex_unlock(&netdev->mutex); exists = true; dev->flags |= VIRTIO_DEV_RUNNING; /* Disable notifications. */ set_irq_status(dev); + ovs_mutex_unlock(&netdev->mutex); break; } } ovs_mutex_unlock(&dpdk_mutex); if (!exists) { - VLOG_INFO("vHost Device '%s' (%ld) can't be added - name not found", - dev->ifname, dev->device_fh); + VLOG_INFO("vHost Device '%s' %"PRIu64" can't be added - name not " + "found", dev->ifname, dev->device_fh); return -1; } - VLOG_INFO("vHost Device '%s' (%ld) has been added", - dev->ifname, dev->device_fh); + VLOG_INFO("vHost Device '%s' %"PRIu64" has been added", dev->ifname, + dev->device_fh); return 0; } @@ -1681,6 +1910,7 @@ static void destroy_device(volatile struct virtio_net *dev) { struct netdev_dpdk *vhost_dev; + bool exists = false; ovs_mutex_lock(&dpdk_mutex); LIST_FOR_EACH (vhost_dev, list_node, &dpdk_list) { @@ -1689,24 +1919,32 @@ destroy_device(volatile struct virtio_net *dev) ovs_mutex_lock(&vhost_dev->mutex); dev->flags &= ~VIRTIO_DEV_RUNNING; ovsrcu_set(&vhost_dev->virtio_dev, NULL); + exists = true; ovs_mutex_unlock(&vhost_dev->mutex); - - /* - * Wait for other threads to quiesce before - * setting the virtio_dev to NULL. - */ - ovsrcu_synchronize(); - /* - * As call to ovsrcu_synchronize() will end the quiescent state, - * put thread back into quiescent state before returning. - */ - ovsrcu_quiesce_start(); + break; } } + ovs_mutex_unlock(&dpdk_mutex); - VLOG_INFO("vHost Device '%s' (%ld) has been removed", - dev->ifname, dev->device_fh); + if (exists == true) { + /* + * Wait for other threads to quiesce after setting the 'virtio_dev' + * to NULL, before returning. + */ + ovsrcu_synchronize(); + /* + * As call to ovsrcu_synchronize() will end the quiescent state, + * 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); + } else { + VLOG_INFO("vHost Device '%s' %"PRIu64" not found", dev->ifname, + dev->device_fh); + } + } struct virtio_net * @@ -1788,7 +2026,7 @@ dpdk_ring_create(const char dev_name[], unsigned int port_no, unsigned int *eth_port_id) { struct dpdk_ring *ivshmem; - char ring_name[10]; + char ring_name[RTE_RING_NAMESIZE]; int err; ivshmem = dpdk_rte_mzalloc(sizeof *ivshmem); @@ -1797,27 +2035,27 @@ dpdk_ring_create(const char dev_name[], unsigned int port_no, } /* XXX: Add support for multiquque ring. */ - err = snprintf(ring_name, 10, "%s_tx", dev_name); + err = snprintf(ring_name, sizeof(ring_name), "%s_tx", dev_name); if (err < 0) { return -err; } - /* Create single consumer/producer rings, netdev does explicit locking. */ + /* Create single producer tx ring, netdev does explicit locking. */ ivshmem->cring_tx = rte_ring_create(ring_name, DPDK_RING_SIZE, SOCKET0, - RING_F_SP_ENQ | RING_F_SC_DEQ); + RING_F_SP_ENQ); if (ivshmem->cring_tx == NULL) { rte_free(ivshmem); return ENOMEM; } - err = snprintf(ring_name, 10, "%s_rx", dev_name); + err = snprintf(ring_name, sizeof(ring_name), "%s_rx", dev_name); if (err < 0) { return -err; } - /* Create single consumer/producer rings, netdev does explicit locking. */ + /* Create single consumer rx ring, netdev does explicit locking. */ ivshmem->cring_rx = rte_ring_create(ring_name, DPDK_RING_SIZE, SOCKET0, - RING_F_SP_ENQ | RING_F_SC_DEQ); + RING_F_SC_DEQ); if (ivshmem->cring_rx == NULL) { rte_free(ivshmem); return ENOMEM; @@ -1876,7 +2114,7 @@ netdev_dpdk_ring_send(struct netdev *netdev_, int qid, * the consumer of the ring and return into the datapath without recalculating * the RSS hash. */ for (i = 0; i < cnt; i++) { - dp_packet_set_rss_hash(pkts[i], 0); + dp_packet_rss_invalidate(pkts[i]); } netdev_dpdk_send__(netdev, qid, pkts, cnt, may_steal); @@ -1920,7 +2158,7 @@ unlock_dpdk: DESTRUCT, \ netdev_dpdk_dealloc, \ netdev_dpdk_get_config, \ - NULL, /* netdev_dpdk_set_config */ \ + netdev_dpdk_set_config, \ NULL, /* get_tunnel_config */ \ NULL, /* build header */ \ NULL, /* push header */ \ @@ -1986,14 +2224,14 @@ process_vhost_flags(char *flag, char *default_val, int size, * flag if it is provided on the vswitchd command line, otherwise resort to * a default value. * - * For vhost-user: Process "-cuse_dev_name" to set the custom location of + * For vhost-user: Process "-vhost_sock_dir" to set the custom location of * the vhost-user socket(s). - * For vhost-cuse: Process "-vhost_sock_dir" to set the custom name of the + * For vhost-cuse: Process "-cuse_dev_name" to set the custom name of the * vhost-cuse character device. */ if (!strcmp(argv[1], flag) && (strlen(argv[2]) <= size)) { changed = 1; - *new_val = strdup(argv[2]); + *new_val = xstrdup(argv[2]); VLOG_INFO("User-provided %s in use: %s", flag, *new_val); } else { VLOG_INFO("No %s provided - defaulting to %s", flag, default_val); @@ -2017,11 +2255,19 @@ dpdk_init(int argc, char **argv) argc--; argv++; + /* 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."); + } + } + #ifdef VHOST_CUSE - if (process_vhost_flags("-cuse_dev_name", strdup("vhost-net"), + if (process_vhost_flags("-cuse_dev_name", xstrdup("vhost-net"), PATH_MAX, argv, &cuse_dev_name)) { #else - if (process_vhost_flags("-vhost_sock_dir", strdup(ovs_rundir()), + if (process_vhost_flags("-vhost_sock_dir", xstrdup(ovs_rundir()), NAME_MAX, argv, &vhost_sock_dir)) { struct stat s; int err; @@ -2094,13 +2340,13 @@ static const struct netdev_class dpdk_ring_class = netdev_dpdk_get_status, netdev_dpdk_rxq_recv); -static const struct netdev_class dpdk_vhost_cuse_class = +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_set_multiq, + netdev_dpdk_vhost_cuse_set_multiq, netdev_dpdk_vhost_send, netdev_dpdk_vhost_get_carrier, netdev_dpdk_vhost_get_stats, @@ -2108,7 +2354,7 @@ static const struct netdev_class dpdk_vhost_cuse_class = NULL, netdev_dpdk_vhost_rxq_recv); -const struct netdev_class dpdk_vhost_user_class = +static const struct netdev_class OVS_UNUSED dpdk_vhost_user_class = NETDEV_DPDK_CLASS( "dpdkvhostuser", dpdk_vhost_user_class_init, @@ -2165,7 +2411,7 @@ pmd_thread_setaffinity_cpu(unsigned cpu) } static bool -thread_is_pmd(void) +dpdk_thread_is_pmd(void) { return rte_lcore_id() != NON_PMD_CORE_ID; }