vhost: use new APIs to handle features

[dpdk.git] / lib / librte_vhost / vhost_user.c

diff --git a/lib/librte_vhost/vhost_user.c b/lib/librte_vhost/vhost_user.c
index ab7f3fc..65fd0fc 100644 (file)
--- a/lib/librte_vhost/vhost_user.c
+++ b/lib/librte_vhost/vhost_user.c
@@ -51,6 +51,9 @@
 #include "vhost.h"
 #include "vhost_user.h"
 
+#define VIRTIO_MIN_MTU 68
+#define VIRTIO_MAX_MTU 65535
+
 static const char *vhost_message_str[VHOST_USER_MAX] = {
        [VHOST_USER_NONE] = "VHOST_USER_NONE",
        [VHOST_USER_GET_FEATURES] = "VHOST_USER_GET_FEATURES",
@@ -72,6 +75,7 @@ static const char *vhost_message_str[VHOST_USER_MAX] = {
        [VHOST_USER_GET_QUEUE_NUM]  = "VHOST_USER_GET_QUEUE_NUM",
        [VHOST_USER_SET_VRING_ENABLE]  = "VHOST_USER_SET_VRING_ENABLE",
        [VHOST_USER_SEND_RARP]  = "VHOST_USER_SEND_RARP",
+       [VHOST_USER_NET_SET_MTU]  = "VHOST_USER_NET_SET_MTU",
 };
 
 static uint64_t
@@ -143,9 +147,12 @@ vhost_user_reset_owner(struct virtio_net *dev)
  * The features that we support are requested.
  */
 static uint64_t
-vhost_user_get_features(void)
+vhost_user_get_features(struct virtio_net *dev)
 {
-       return VHOST_FEATURES;
+       uint64_t features = 0;
+
+       rte_vhost_driver_get_features(dev->ifname, &features);
+       return features;
 }
 
 /*
@@ -154,7 +161,10 @@ vhost_user_get_features(void)
 static int
 vhost_user_set_features(struct virtio_net *dev, uint64_t features)
 {
-       if (features & ~VHOST_FEATURES)
+       uint64_t vhost_features = 0;
+
+       rte_vhost_driver_get_features(dev->ifname, &vhost_features);
+       if (features & ~vhost_features)
                return -1;
 
        dev->features = features;
@@ -635,7 +645,6 @@ vhost_user_set_vring_call(struct virtio_net *dev, struct VhostUserMsg *pmsg)
 {
        struct vhost_vring_file file;
        struct vhost_virtqueue *vq;
-       uint32_t cur_qp_idx;
 
        file.index = pmsg->payload.u64 & VHOST_USER_VRING_IDX_MASK;
        if (pmsg->payload.u64 & VHOST_USER_VRING_NOFD_MASK)
@@ -645,19 +654,7 @@ vhost_user_set_vring_call(struct virtio_net *dev, struct VhostUserMsg *pmsg)
        RTE_LOG(INFO, VHOST_CONFIG,
                "vring call idx:%d file:%d\n", file.index, file.fd);
 
-       /*
-        * FIXME: VHOST_SET_VRING_CALL is the first per-vring message
-        * we get, so we do vring queue pair allocation here.
-        */
-       cur_qp_idx = file.index / VIRTIO_QNUM;
-       if (cur_qp_idx + 1 > dev->virt_qp_nb) {
-               if (alloc_vring_queue_pair(dev, cur_qp_idx) < 0)
-                       return;
-       }
-
        vq = dev->virtqueue[file.index];
-       assert(vq != NULL);
-
        if (vq->callfd >= 0)
                close(vq->callfd);
 
@@ -687,14 +684,18 @@ vhost_user_set_vring_kick(struct virtio_net *dev, struct VhostUserMsg *pmsg)
                close(vq->kickfd);
        vq->kickfd = file.fd;
 
-       if (virtio_is_ready(dev) && !(dev->flags & VIRTIO_DEV_RUNNING)) {
-               if (dev->dequeue_zero_copy) {
-                       RTE_LOG(INFO, VHOST_CONFIG,
-                               "dequeue zero copy is enabled\n");
-               }
+       if (virtio_is_ready(dev)) {
+               dev->flags |= VIRTIO_DEV_READY;
+
+               if (!(dev->flags & VIRTIO_DEV_RUNNING)) {
+                       if (dev->dequeue_zero_copy) {
+                               RTE_LOG(INFO, VHOST_CONFIG,
+                                               "dequeue zero copy is enabled\n");
+                       }
 
-               if (notify_ops->new_device(dev->vid) == 0)
-                       dev->flags |= VIRTIO_DEV_RUNNING;
+                       if (notify_ops->new_device(dev->vid) == 0)
+                               dev->flags |= VIRTIO_DEV_RUNNING;
+               }
        }
 }
 
@@ -729,6 +730,8 @@ vhost_user_get_vring_base(struct virtio_net *dev,
                notify_ops->destroy_device(dev->vid);
        }
 
+       dev->flags &= ~VIRTIO_DEV_READY;
+
        /* Here we are safe to get the last used index */
        state->num = vq->last_used_idx;
 
@@ -865,6 +868,22 @@ vhost_user_send_rarp(struct virtio_net *dev, struct VhostUserMsg *msg)
        return 0;
 }
 
+static int
+vhost_user_net_set_mtu(struct virtio_net *dev, struct VhostUserMsg *msg)
+{
+       if (msg->payload.u64 < VIRTIO_MIN_MTU ||
+                       msg->payload.u64 > VIRTIO_MAX_MTU) {
+               RTE_LOG(ERR, VHOST_CONFIG, "Invalid MTU size (%"PRIu64")\n",
+                               msg->payload.u64);
+
+               return -1;
+       }
+
+       dev->mtu = msg->payload.u64;
+
+       return 0;
+}
+
 /* return bytes# of read on success or negative val on failure. */
 static int
 read_vhost_message(int sockfd, struct VhostUserMsg *msg)
@@ -914,6 +933,46 @@ send_vhost_message(int sockfd, struct VhostUserMsg *msg)
        return ret;
 }
 
+/*
+ * Allocate a queue pair if it hasn't been allocated yet
+ */
+static int
+vhost_user_check_and_alloc_queue_pair(struct virtio_net *dev, VhostUserMsg *msg)
+{
+       uint16_t vring_idx;
+       uint16_t qp_idx;
+
+       switch (msg->request) {
+       case VHOST_USER_SET_VRING_KICK:
+       case VHOST_USER_SET_VRING_CALL:
+       case VHOST_USER_SET_VRING_ERR:
+               vring_idx = msg->payload.u64 & VHOST_USER_VRING_IDX_MASK;
+               break;
+       case VHOST_USER_SET_VRING_NUM:
+       case VHOST_USER_SET_VRING_BASE:
+       case VHOST_USER_SET_VRING_ENABLE:
+               vring_idx = msg->payload.state.index;
+               break;
+       case VHOST_USER_SET_VRING_ADDR:
+               vring_idx = msg->payload.addr.index;
+               break;
+       default:
+               return 0;
+       }
+
+       qp_idx = vring_idx / VIRTIO_QNUM;
+       if (qp_idx >= VHOST_MAX_QUEUE_PAIRS) {
+               RTE_LOG(ERR, VHOST_CONFIG,
+                       "invalid vring index: %u\n", vring_idx);
+               return -1;
+       }
+
+       if (dev->virtqueue[qp_idx * VIRTIO_QNUM])
+               return 0;
+
+       return alloc_vring_queue_pair(dev, qp_idx);
+}
+
 int
 vhost_user_msg_handler(int vid, int fd)
 {
@@ -943,9 +1002,17 @@ vhost_user_msg_handler(int vid, int fd)
        ret = 0;
        RTE_LOG(INFO, VHOST_CONFIG, "read message %s\n",
                vhost_message_str[msg.request]);
+
+       ret = vhost_user_check_and_alloc_queue_pair(dev, &msg);
+       if (ret < 0) {
+               RTE_LOG(ERR, VHOST_CONFIG,
+                       "failed to alloc queue\n");
+               return -1;
+       }
+
        switch (msg.request) {
        case VHOST_USER_GET_FEATURES:
-               msg.payload.u64 = vhost_user_get_features();
+               msg.payload.u64 = vhost_user_get_features(dev);
                msg.size = sizeof(msg.payload.u64);
                send_vhost_message(fd, &msg);
                break;
@@ -996,7 +1063,7 @@ vhost_user_msg_handler(int vid, int fd)
                break;
 
        case VHOST_USER_GET_VRING_BASE:
-               ret = vhost_user_get_vring_base(dev, &msg.payload.state);
+               vhost_user_get_vring_base(dev, &msg.payload.state);
                msg.size = sizeof(msg.payload.state);
                send_vhost_message(fd, &msg);
                break;
@@ -1027,6 +1094,10 @@ vhost_user_msg_handler(int vid, int fd)
                vhost_user_send_rarp(dev, &msg);
                break;
 
+       case VHOST_USER_NET_SET_MTU:
+               ret = vhost_user_net_set_mtu(dev, &msg);
+               break;
+
        default:
                ret = -1;
                break;