static struct rte_eth_link pmd_link = {
.link_speed = 10000,
- .link_duplex = ETH_LINK_FULL_DUPLEX,
- .link_status = ETH_LINK_DOWN
+ .link_duplex = RTE_ETH_LINK_FULL_DUPLEX,
+ .link_status = RTE_ETH_LINK_DOWN
};
struct rte_vhost_vring_state {
}
}
-static void
-vhost_update_packet_xstats(struct vhost_queue *vq, struct rte_mbuf **bufs,
- uint16_t count, uint64_t nb_bytes,
- uint64_t nb_missed)
+static __rte_always_inline void
+vhost_update_single_packet_xstats(struct vhost_queue *vq, struct rte_mbuf *buf)
{
uint32_t pkt_len = 0;
- uint64_t i = 0;
uint64_t index;
struct vhost_stats *pstats = &vq->stats;
- pstats->xstats[VHOST_BYTE] += nb_bytes;
- pstats->xstats[VHOST_MISSED_PKT] += nb_missed;
- pstats->xstats[VHOST_UNICAST_PKT] += nb_missed;
-
- for (i = 0; i < count ; i++) {
- pstats->xstats[VHOST_PKT]++;
- pkt_len = bufs[i]->pkt_len;
- if (pkt_len == 64) {
- pstats->xstats[VHOST_64_PKT]++;
- } else if (pkt_len > 64 && pkt_len < 1024) {
- index = (sizeof(pkt_len) * 8)
- - __builtin_clz(pkt_len) - 5;
- pstats->xstats[index]++;
- } else {
- if (pkt_len < 64)
- pstats->xstats[VHOST_UNDERSIZE_PKT]++;
- else if (pkt_len <= 1522)
- pstats->xstats[VHOST_1024_TO_1522_PKT]++;
- else if (pkt_len > 1522)
- pstats->xstats[VHOST_1523_TO_MAX_PKT]++;
- }
- vhost_count_xcast_packets(vq, bufs[i]);
+ pstats->xstats[VHOST_PKT]++;
+ pkt_len = buf->pkt_len;
+ if (pkt_len == 64) {
+ pstats->xstats[VHOST_64_PKT]++;
+ } else if (pkt_len > 64 && pkt_len < 1024) {
+ index = (sizeof(pkt_len) * 8)
+ - __builtin_clz(pkt_len) - 5;
+ pstats->xstats[index]++;
+ } else {
+ if (pkt_len < 64)
+ pstats->xstats[VHOST_UNDERSIZE_PKT]++;
+ else if (pkt_len <= 1522)
+ pstats->xstats[VHOST_1024_TO_1522_PKT]++;
+ else if (pkt_len > 1522)
+ pstats->xstats[VHOST_1523_TO_MAX_PKT]++;
}
+ vhost_count_xcast_packets(vq, buf);
}
static uint16_t
struct vhost_queue *r = q;
uint16_t i, nb_rx = 0;
uint16_t nb_receive = nb_bufs;
- uint64_t nb_bytes = 0;
if (unlikely(rte_atomic32_read(&r->allow_queuing) == 0))
return 0;
if (r->internal->vlan_strip)
rte_vlan_strip(bufs[i]);
- nb_bytes += bufs[i]->pkt_len;
- }
+ r->stats.bytes += bufs[i]->pkt_len;
+ r->stats.xstats[VHOST_BYTE] += bufs[i]->pkt_len;
- r->stats.bytes += nb_bytes;
- vhost_update_packet_xstats(r, bufs, nb_rx, nb_bytes, 0);
+ vhost_update_single_packet_xstats(r, bufs[i]);
+ }
out:
rte_atomic32_set(&r->while_queuing, 0);
struct rte_mbuf *m = bufs[i];
/* Do VLAN tag insertion */
- if (m->ol_flags & PKT_TX_VLAN_PKT) {
+ if (m->ol_flags & RTE_MBUF_F_TX_VLAN) {
int error = rte_vlan_insert(&m);
if (unlikely(error)) {
rte_pktmbuf_free(m);
break;
}
- for (i = 0; likely(i < nb_tx); i++)
+ for (i = 0; likely(i < nb_tx); i++) {
nb_bytes += bufs[i]->pkt_len;
+ vhost_update_single_packet_xstats(r, bufs[i]);
+ }
nb_missed = nb_bufs - nb_tx;
r->stats.pkts += nb_tx;
r->stats.bytes += nb_bytes;
- r->stats.missed_pkts += nb_bufs - nb_tx;
+ r->stats.missed_pkts += nb_missed;
- vhost_update_packet_xstats(r, bufs, nb_tx, nb_bytes, nb_missed);
+ r->stats.xstats[VHOST_BYTE] += nb_bytes;
+ r->stats.xstats[VHOST_MISSED_PKT] += nb_missed;
+ r->stats.xstats[VHOST_UNICAST_PKT] += nb_missed;
/* According to RFC2863, ifHCOutUcastPkts, ifHCOutMulticastPkts and
* ifHCOutBroadcastPkts counters are increased when packets are not
eth_vhost_update_intr(struct rte_eth_dev *eth_dev, uint16_t rxq_idx)
{
struct rte_intr_handle *handle = eth_dev->intr_handle;
- struct rte_epoll_event rev;
+ struct rte_epoll_event rev, *elist;
int epfd, ret;
- if (!handle)
+ if (handle == NULL)
return 0;
- if (handle->efds[rxq_idx] == handle->elist[rxq_idx].fd)
+ elist = rte_intr_elist_index_get(handle, rxq_idx);
+ if (rte_intr_efds_index_get(handle, rxq_idx) == elist->fd)
return 0;
VHOST_LOG(INFO, "kickfd for rxq-%d was changed, updating handler.\n",
rxq_idx);
- if (handle->elist[rxq_idx].fd != -1)
+ if (elist->fd != -1)
VHOST_LOG(ERR, "Unexpected previous kickfd value (Got %d, expected -1).\n",
- handle->elist[rxq_idx].fd);
+ elist->fd);
/*
* First remove invalid epoll event, and then install
* the new one. May be solved with a proper API in the
* future.
*/
- epfd = handle->elist[rxq_idx].epfd;
- rev = handle->elist[rxq_idx];
+ epfd = elist->epfd;
+ rev = *elist;
ret = rte_epoll_ctl(epfd, EPOLL_CTL_DEL, rev.fd,
- &handle->elist[rxq_idx]);
+ elist);
if (ret) {
VHOST_LOG(ERR, "Delete epoll event failed.\n");
return ret;
}
- rev.fd = handle->efds[rxq_idx];
- handle->elist[rxq_idx] = rev;
- ret = rte_epoll_ctl(epfd, EPOLL_CTL_ADD, rev.fd,
- &handle->elist[rxq_idx]);
+ rev.fd = rte_intr_efds_index_get(handle, rxq_idx);
+ if (rte_intr_elist_index_set(handle, rxq_idx, rev))
+ return -rte_errno;
+
+ elist = rte_intr_elist_index_get(handle, rxq_idx);
+ ret = rte_epoll_ctl(epfd, EPOLL_CTL_ADD, rev.fd, elist);
if (ret) {
VHOST_LOG(ERR, "Add epoll event failed.\n");
return ret;
{
struct rte_intr_handle *intr_handle = dev->intr_handle;
- if (intr_handle) {
- if (intr_handle->intr_vec)
- free(intr_handle->intr_vec);
- free(intr_handle);
+ if (intr_handle != NULL) {
+ rte_intr_vec_list_free(intr_handle);
+ rte_intr_instance_free(intr_handle);
}
-
dev->intr_handle = NULL;
}
int ret;
/* uninstall firstly if we are reconnecting */
- if (dev->intr_handle)
+ if (dev->intr_handle != NULL)
eth_vhost_uninstall_intr(dev);
- dev->intr_handle = malloc(sizeof(*dev->intr_handle));
- if (!dev->intr_handle) {
+ dev->intr_handle = rte_intr_instance_alloc(RTE_INTR_INSTANCE_F_PRIVATE);
+ if (dev->intr_handle == NULL) {
VHOST_LOG(ERR, "Fail to allocate intr_handle\n");
return -ENOMEM;
}
- memset(dev->intr_handle, 0, sizeof(*dev->intr_handle));
-
- dev->intr_handle->efd_counter_size = sizeof(uint64_t);
+ if (rte_intr_efd_counter_size_set(dev->intr_handle, sizeof(uint64_t)))
+ return -rte_errno;
- dev->intr_handle->intr_vec =
- malloc(nb_rxq * sizeof(dev->intr_handle->intr_vec[0]));
-
- if (!dev->intr_handle->intr_vec) {
+ if (rte_intr_vec_list_alloc(dev->intr_handle, NULL, nb_rxq)) {
VHOST_LOG(ERR,
"Failed to allocate memory for interrupt vector\n");
- free(dev->intr_handle);
+ rte_intr_instance_free(dev->intr_handle);
return -ENOMEM;
}
+
VHOST_LOG(INFO, "Prepare intr vec\n");
for (i = 0; i < nb_rxq; i++) {
- dev->intr_handle->intr_vec[i] = RTE_INTR_VEC_RXTX_OFFSET + i;
- dev->intr_handle->efds[i] = -1;
+ if (rte_intr_vec_list_index_set(dev->intr_handle, i, RTE_INTR_VEC_RXTX_OFFSET + i))
+ return -rte_errno;
+ if (rte_intr_efds_index_set(dev->intr_handle, i, -1))
+ return -rte_errno;
vq = dev->data->rx_queues[i];
if (!vq) {
VHOST_LOG(INFO, "rxq-%d not setup yet, skip!\n", i);
"rxq-%d's kickfd is invalid, skip!\n", i);
continue;
}
- dev->intr_handle->efds[i] = vring.kickfd;
+
+ if (rte_intr_efds_index_set(dev->intr_handle, i, vring.kickfd))
+ continue;
VHOST_LOG(INFO, "Installed intr vec for rxq-%d\n", i);
}
- dev->intr_handle->nb_efd = nb_rxq;
- dev->intr_handle->max_intr = nb_rxq + 1;
- dev->intr_handle->type = RTE_INTR_HANDLE_VDEV;
+ if (rte_intr_nb_efd_set(dev->intr_handle, nb_rxq))
+ return -rte_errno;
+
+ if (rte_intr_max_intr_set(dev->intr_handle, nb_rxq + 1))
+ return -rte_errno;
+
+ if (rte_intr_type_set(dev->intr_handle, RTE_INTR_HANDLE_VDEV))
+ return -rte_errno;
return 0;
}
rte_vhost_get_mtu(vid, ð_dev->data->mtu);
- eth_dev->data->dev_link.link_status = ETH_LINK_UP;
+ eth_dev->data->dev_link.link_status = RTE_ETH_LINK_UP;
rte_atomic32_set(&internal->dev_attached, 1);
update_queuing_status(eth_dev);
rte_atomic32_set(&internal->dev_attached, 0);
update_queuing_status(eth_dev);
- eth_dev->data->dev_link.link_status = ETH_LINK_DOWN;
+ eth_dev->data->dev_link.link_status = RTE_ETH_LINK_DOWN;
if (eth_dev->data->rx_queues && eth_dev->data->tx_queues) {
for (i = 0; i < eth_dev->data->nb_rx_queues; i++) {
vring_id);
return ret;
}
- eth_dev->intr_handle->efds[rx_idx] = vring.kickfd;
+
+ if (rte_intr_efds_index_set(eth_dev->intr_handle, rx_idx,
+ vring.kickfd))
+ return -rte_errno;
vq = eth_dev->data->rx_queues[rx_idx];
if (!vq) {
if (vhost_driver_setup(dev) < 0)
return -1;
- internal->vlan_strip = !!(rxmode->offloads & DEV_RX_OFFLOAD_VLAN_STRIP);
+ internal->vlan_strip = !!(rxmode->offloads & RTE_ETH_RX_OFFLOAD_VLAN_STRIP);
return 0;
}
dev_info->max_tx_queues = internal->max_queues;
dev_info->min_rx_bufsize = 0;
- dev_info->tx_offload_capa = DEV_TX_OFFLOAD_MULTI_SEGS |
- DEV_TX_OFFLOAD_VLAN_INSERT;
- dev_info->rx_offload_capa = DEV_RX_OFFLOAD_VLAN_STRIP;
+ dev_info->tx_offload_capa = RTE_ETH_TX_OFFLOAD_MULTI_SEGS |
+ RTE_ETH_TX_OFFLOAD_VLAN_INSERT;
+ dev_info->rx_offload_capa = RTE_ETH_RX_OFFLOAD_VLAN_STRIP;
return 0;
}
}
static void
-eth_queue_release(void *q)
+eth_rx_queue_release(struct rte_eth_dev *dev, uint16_t qid)
+{
+ rte_free(dev->data->rx_queues[qid]);
+}
+
+static void
+eth_tx_queue_release(struct rte_eth_dev *dev, uint16_t qid)
{
- rte_free(q);
+ rte_free(dev->data->tx_queues[qid]);
}
static int
}
static uint32_t
-eth_rx_queue_count(struct rte_eth_dev *dev, uint16_t rx_queue_id)
+eth_rx_queue_count(void *rx_queue)
{
struct vhost_queue *vq;
- vq = dev->data->rx_queues[rx_queue_id];
+ vq = rx_queue;
if (vq == NULL)
return 0;
return rte_vhost_rx_queue_count(vq->vid, vq->virtqueue_id);
}
+#define CLB_VAL_IDX 0
+#define CLB_MSK_IDX 1
+#define CLB_MATCH_IDX 2
+static int
+vhost_monitor_callback(const uint64_t value,
+ const uint64_t opaque[RTE_POWER_MONITOR_OPAQUE_SZ])
+{
+ const uint64_t m = opaque[CLB_MSK_IDX];
+ const uint64_t v = opaque[CLB_VAL_IDX];
+ const uint64_t c = opaque[CLB_MATCH_IDX];
+
+ if (c)
+ return (value & m) == v ? -1 : 0;
+ else
+ return (value & m) == v ? 0 : -1;
+}
+
+static int
+vhost_get_monitor_addr(void *rx_queue, struct rte_power_monitor_cond *pmc)
+{
+ struct vhost_queue *vq = rx_queue;
+ struct rte_vhost_power_monitor_cond vhost_pmc;
+ int ret;
+ if (vq == NULL)
+ return -EINVAL;
+ ret = rte_vhost_get_monitor_addr(vq->vid, vq->virtqueue_id,
+ &vhost_pmc);
+ if (ret < 0)
+ return -EINVAL;
+ pmc->addr = vhost_pmc.addr;
+ pmc->opaque[CLB_VAL_IDX] = vhost_pmc.val;
+ pmc->opaque[CLB_MSK_IDX] = vhost_pmc.mask;
+ pmc->opaque[CLB_MATCH_IDX] = vhost_pmc.match;
+ pmc->size = vhost_pmc.size;
+ pmc->fn = vhost_monitor_callback;
+
+ return 0;
+}
+
static const struct eth_dev_ops ops = {
.dev_start = eth_dev_start,
.dev_stop = eth_dev_stop,
.dev_infos_get = eth_dev_info,
.rx_queue_setup = eth_rx_queue_setup,
.tx_queue_setup = eth_tx_queue_setup,
- .rx_queue_release = eth_queue_release,
- .tx_queue_release = eth_queue_release,
+ .rx_queue_release = eth_rx_queue_release,
+ .tx_queue_release = eth_tx_queue_release,
.tx_done_cleanup = eth_tx_done_cleanup,
.link_update = eth_link_update,
.stats_get = eth_stats_get,
.xstats_get_names = vhost_dev_xstats_get_names,
.rx_queue_intr_enable = eth_rxq_intr_enable,
.rx_queue_intr_disable = eth_rxq_intr_disable,
+ .get_monitor_addr = vhost_get_monitor_addr,
};
static int