#include <string.h>
#include <errno.h>
+#include <rte_alarm.h>
#include <rte_string_fns.h>
#include <rte_fbarray.h>
-#include <rte_eal_memconfig.h>
#include "vhost.h"
#include "virtio_user_dev.h"
+struct vhost_user_data {
+ int vhostfd;
+ int listenfd;
+ uint64_t protocol_features;
+};
+
+#ifndef VHOST_USER_F_PROTOCOL_FEATURES
+#define VHOST_USER_F_PROTOCOL_FEATURES 30
+#endif
+
+/** Protocol features. */
+#ifndef VHOST_USER_PROTOCOL_F_MQ
+#define VHOST_USER_PROTOCOL_F_MQ 0
+#endif
+
+#ifndef VHOST_USER_PROTOCOL_F_REPLY_ACK
+#define VHOST_USER_PROTOCOL_F_REPLY_ACK 3
+#endif
+
+#ifndef VHOST_USER_PROTOCOL_F_STATUS
+#define VHOST_USER_PROTOCOL_F_STATUS 16
+#endif
+
+#define VHOST_USER_SUPPORTED_PROTOCOL_FEATURES \
+ (1ULL << VHOST_USER_PROTOCOL_F_MQ | \
+ 1ULL << VHOST_USER_PROTOCOL_F_REPLY_ACK | \
+ 1ULL << VHOST_USER_PROTOCOL_F_STATUS)
+
/* The version of the protocol we support */
#define VHOST_USER_VERSION 0x1
struct vhost_memory_region regions[VHOST_MEMORY_MAX_NREGIONS];
};
+enum vhost_user_request {
+ VHOST_USER_NONE = 0,
+ VHOST_USER_GET_FEATURES = 1,
+ VHOST_USER_SET_FEATURES = 2,
+ VHOST_USER_SET_OWNER = 3,
+ VHOST_USER_RESET_OWNER = 4,
+ VHOST_USER_SET_MEM_TABLE = 5,
+ VHOST_USER_SET_LOG_BASE = 6,
+ VHOST_USER_SET_LOG_FD = 7,
+ VHOST_USER_SET_VRING_NUM = 8,
+ VHOST_USER_SET_VRING_ADDR = 9,
+ VHOST_USER_SET_VRING_BASE = 10,
+ VHOST_USER_GET_VRING_BASE = 11,
+ VHOST_USER_SET_VRING_KICK = 12,
+ VHOST_USER_SET_VRING_CALL = 13,
+ VHOST_USER_SET_VRING_ERR = 14,
+ VHOST_USER_GET_PROTOCOL_FEATURES = 15,
+ VHOST_USER_SET_PROTOCOL_FEATURES = 16,
+ VHOST_USER_GET_QUEUE_NUM = 17,
+ VHOST_USER_SET_VRING_ENABLE = 18,
+ VHOST_USER_SET_STATUS = 39,
+ VHOST_USER_GET_STATUS = 40,
+ VHOST_USER_MAX
+};
+
struct vhost_user_msg {
enum vhost_user_request request;
#define VHOST_USER_VERSION_MASK 0x3
#define VHOST_USER_REPLY_MASK (0x1 << 2)
+#define VHOST_USER_NEED_REPLY_MASK (0x1 << 3)
uint32_t flags;
uint32_t size; /* the following payload size */
union {
struct vhost_memory memory;
} payload;
int fds[VHOST_MEMORY_MAX_NREGIONS];
-} __attribute((packed));
+} __rte_packed;
#define VHOST_USER_HDR_SIZE offsetof(struct vhost_user_msg, payload.u64)
#define VHOST_USER_PAYLOAD_SIZE \
(sizeof(struct vhost_user_msg) - VHOST_USER_HDR_SIZE)
static int
-vhost_user_write(int fd, void *buf, int len, int *fds, int fd_num)
+vhost_user_write(int fd, struct vhost_user_msg *msg, int *fds, int fd_num)
{
int r;
struct msghdr msgh;
memset(&msgh, 0, sizeof(msgh));
memset(control, 0, sizeof(control));
- iov.iov_base = (uint8_t *)buf;
- iov.iov_len = len;
+ iov.iov_base = (uint8_t *)msg;
+ iov.iov_len = VHOST_USER_HDR_SIZE + msg->size;
msgh.msg_iov = &iov;
msgh.msg_iovlen = 1;
r = sendmsg(fd, &msgh, 0);
} while (r < 0 && errno == EINTR);
+ if (r < 0)
+ PMD_DRV_LOG(ERR, "Failed to send msg: %s", strerror(errno));
+
return r;
}
int ret, sz_hdr = VHOST_USER_HDR_SIZE, sz_payload;
ret = recv(fd, (void *)msg, sz_hdr, 0);
- if (ret < sz_hdr) {
+ if (ret < 0) {
+ PMD_DRV_LOG(ERR, "Failed to recv msg header: %s", strerror(errno));
+ return -1;
+ } else if (ret < sz_hdr) {
PMD_DRV_LOG(ERR, "Failed to recv msg hdr: %d instead of %d.",
ret, sz_hdr);
- goto fail;
+ return -1;
}
/* validate msg flags */
if (msg->flags != (valid_flags)) {
- PMD_DRV_LOG(ERR, "Failed to recv msg: flags %x instead of %x.",
+ PMD_DRV_LOG(ERR, "Failed to recv msg: flags 0x%x instead of 0x%x.",
msg->flags, valid_flags);
- goto fail;
+ return -1;
}
sz_payload = msg->size;
- if ((size_t)sz_payload > sizeof(msg->payload))
- goto fail;
+ if ((size_t)sz_payload > sizeof(msg->payload)) {
+ PMD_DRV_LOG(ERR, "Payload size overflow, header says %d but max %zu\n",
+ sz_payload, sizeof(msg->payload));
+ return -1;
+ }
if (sz_payload) {
ret = recv(fd, (void *)((char *)msg + sz_hdr), sz_payload, 0);
- if (ret < sz_payload) {
- PMD_DRV_LOG(ERR,
- "Failed to recv msg payload: %d instead of %d.",
+ if (ret < 0) {
+ PMD_DRV_LOG(ERR, "Failed to recv msg payload: %s", strerror(errno));
+ return -1;
+ } else if (ret < sz_payload) {
+ PMD_DRV_LOG(ERR, "Failed to recv msg payload: %d instead of %u.",
ret, msg->size);
- goto fail;
+ return -1;
}
}
return 0;
+}
+
+static int
+vhost_user_check_reply_ack(struct virtio_user_dev *dev, struct vhost_user_msg *msg)
+{
+ struct vhost_user_data *data = dev->backend_data;
+ enum vhost_user_request req = msg->request;
+ int ret;
+
+ if (!(msg->flags & VHOST_USER_NEED_REPLY_MASK))
+ return 0;
+
+ ret = vhost_user_read(data->vhostfd, msg);
+ if (ret < 0) {
+ PMD_DRV_LOG(ERR, "Failed to read reply-ack");
+ return -1;
+ }
+
+ if (req != msg->request) {
+ PMD_DRV_LOG(ERR, "Unexpected reply-ack request type (%d)", msg->request);
+ return -1;
+ }
+
+ if (msg->size != sizeof(msg->payload.u64)) {
+ PMD_DRV_LOG(ERR, "Unexpected reply-ack payload size (%u)", msg->size);
+ return -1;
+ }
+
+ if (msg->payload.u64) {
+ PMD_DRV_LOG(ERR, "Slave replied NACK to request type (%d)", msg->request);
+ return -1;
+ }
+
+ return 0;
+}
+
+static int
+vhost_user_set_owner(struct virtio_user_dev *dev)
+{
+ int ret;
+ struct vhost_user_data *data = dev->backend_data;
+ struct vhost_user_msg msg = {
+ .request = VHOST_USER_SET_OWNER,
+ .flags = VHOST_USER_VERSION,
+ };
+
+ ret = vhost_user_write(data->vhostfd, &msg, NULL, 0);
+ if (ret < 0) {
+ PMD_DRV_LOG(ERR, "Failed to set owner");
+ return -1;
+ }
+
+ return 0;
+}
+
+static int
+vhost_user_get_protocol_features(struct virtio_user_dev *dev, uint64_t *features)
+{
+ int ret;
+ struct vhost_user_data *data = dev->backend_data;
+ struct vhost_user_msg msg = {
+ .request = VHOST_USER_GET_PROTOCOL_FEATURES,
+ .flags = VHOST_USER_VERSION,
+ };
+
+ ret = vhost_user_write(data->vhostfd, &msg, NULL, 0);
+ if (ret < 0)
+ goto err;
+
+ ret = vhost_user_read(data->vhostfd, &msg);
+ if (ret < 0)
+ goto err;
+
+ if (msg.request != VHOST_USER_GET_PROTOCOL_FEATURES) {
+ PMD_DRV_LOG(ERR, "Unexpected request type (%d)", msg.request);
+ goto err;
+ }
+
+ if (msg.size != sizeof(*features)) {
+ PMD_DRV_LOG(ERR, "Unexpected payload size (%u)", msg.size);
+ goto err;
+ }
+
+ *features = msg.payload.u64;
+
+ return 0;
+err:
+ PMD_DRV_LOG(ERR, "Failed to get backend protocol features");
+
+ return -1;
+}
+
+static int
+vhost_user_set_protocol_features(struct virtio_user_dev *dev, uint64_t features)
+{
+ int ret;
+ struct vhost_user_data *data = dev->backend_data;
+ struct vhost_user_msg msg = {
+ .request = VHOST_USER_SET_PROTOCOL_FEATURES,
+ .flags = VHOST_USER_VERSION,
+ .size = sizeof(features),
+ .payload.u64 = features,
+ };
+
+ ret = vhost_user_write(data->vhostfd, &msg, NULL, 0);
+ if (ret < 0) {
+ PMD_DRV_LOG(ERR, "Failed to set protocol features");
+ return -1;
+ }
+
+ return 0;
+}
+
+static int
+vhost_user_get_features(struct virtio_user_dev *dev, uint64_t *features)
+{
+ int ret;
+ struct vhost_user_data *data = dev->backend_data;
+ struct vhost_user_msg msg = {
+ .request = VHOST_USER_GET_FEATURES,
+ .flags = VHOST_USER_VERSION,
+ };
+
+ ret = vhost_user_write(data->vhostfd, &msg, NULL, 0);
+ if (ret < 0)
+ goto err;
+
+ ret = vhost_user_read(data->vhostfd, &msg);
+ if (ret < 0)
+ goto err;
+
+ if (msg.request != VHOST_USER_GET_FEATURES) {
+ PMD_DRV_LOG(ERR, "Unexpected request type (%d)", msg.request);
+ goto err;
+ }
+
+ if (msg.size != sizeof(*features)) {
+ PMD_DRV_LOG(ERR, "Unexpected payload size (%u)", msg.size);
+ goto err;
+ }
+
+ *features = msg.payload.u64;
+
+ if (!(*features & (1ULL << VHOST_USER_F_PROTOCOL_FEATURES)))
+ return 0;
+
+ /* Negotiate protocol features */
+ ret = vhost_user_get_protocol_features(dev, &data->protocol_features);
+ if (ret < 0)
+ goto err;
+
+ data->protocol_features &= VHOST_USER_SUPPORTED_PROTOCOL_FEATURES;
+
+ ret = vhost_user_set_protocol_features(dev, data->protocol_features);
+ if (ret < 0)
+ goto err;
+
+ if (!(data->protocol_features & (1ULL << VHOST_USER_PROTOCOL_F_MQ)))
+ dev->unsupported_features |= (1ull << VIRTIO_NET_F_MQ);
+
+ return 0;
+err:
+ PMD_DRV_LOG(ERR, "Failed to get backend features");
-fail:
return -1;
}
+static int
+vhost_user_set_features(struct virtio_user_dev *dev, uint64_t features)
+{
+ int ret;
+ struct vhost_user_data *data = dev->backend_data;
+ struct vhost_user_msg msg = {
+ .request = VHOST_USER_SET_FEATURES,
+ .flags = VHOST_USER_VERSION,
+ .size = sizeof(features),
+ .payload.u64 = features,
+ };
+
+ msg.payload.u64 |= dev->device_features & (1ULL << VHOST_USER_F_PROTOCOL_FEATURES);
+
+ ret = vhost_user_write(data->vhostfd, &msg, NULL, 0);
+ if (ret < 0) {
+ PMD_DRV_LOG(ERR, "Failed to set features");
+ return -1;
+ }
+
+ return 0;
+}
+
struct walk_arg {
struct vhost_memory *vm;
int *fds;
}
static int
-prepare_vhost_memory_user(struct vhost_user_msg *msg, int fds[])
+vhost_user_set_memory_table(struct virtio_user_dev *dev)
{
struct walk_arg wa;
+ int fds[VHOST_MEMORY_MAX_NREGIONS];
+ int ret, fd_num;
+ struct vhost_user_data *data = dev->backend_data;
+ struct vhost_user_msg msg = {
+ .request = VHOST_USER_SET_MEM_TABLE,
+ .flags = VHOST_USER_VERSION,
+ };
+
+ if (data->protocol_features & (1ULL << VHOST_USER_PROTOCOL_F_REPLY_ACK))
+ msg.flags |= VHOST_USER_NEED_REPLY_MASK;
wa.region_nr = 0;
- wa.vm = &msg->payload.memory;
+ wa.vm = &msg.payload.memory;
wa.fds = fds;
/*
* The memory lock has already been taken by memory subsystem
* or virtio_user_start_device().
*/
- if (rte_memseg_walk_thread_unsafe(update_memory_region, &wa) < 0)
- return -1;
+ ret = rte_memseg_walk_thread_unsafe(update_memory_region, &wa);
+ if (ret < 0)
+ goto err;
+
+ fd_num = wa.region_nr;
+ msg.payload.memory.nregions = wa.region_nr;
+ msg.payload.memory.padding = 0;
+
+ msg.size = sizeof(msg.payload.memory.nregions);
+ msg.size += sizeof(msg.payload.memory.padding);
+ msg.size += fd_num * sizeof(struct vhost_memory_region);
+
+ ret = vhost_user_write(data->vhostfd, &msg, fds, fd_num);
+ if (ret < 0)
+ goto err;
- msg->payload.memory.nregions = wa.region_nr;
- msg->payload.memory.padding = 0;
+ return vhost_user_check_reply_ack(dev, &msg);
+err:
+ PMD_DRV_LOG(ERR, "Failed to set memory table");
+ return -1;
+}
+
+static int
+vhost_user_set_vring(struct virtio_user_dev *dev, enum vhost_user_request req,
+ struct vhost_vring_state *state)
+{
+ int ret;
+ struct vhost_user_data *data = dev->backend_data;
+ struct vhost_user_msg msg = {
+ .request = req,
+ .flags = VHOST_USER_VERSION,
+ .size = sizeof(*state),
+ .payload.state = *state,
+ };
+
+ ret = vhost_user_write(data->vhostfd, &msg, NULL, 0);
+ if (ret < 0) {
+ PMD_DRV_LOG(ERR, "Failed to set vring state (request %d)", req);
+ return -1;
+ }
return 0;
}
-static struct vhost_user_msg m;
-
-const char * const vhost_msg_strings[] = {
- [VHOST_USER_SET_OWNER] = "VHOST_SET_OWNER",
- [VHOST_USER_RESET_OWNER] = "VHOST_RESET_OWNER",
- [VHOST_USER_SET_FEATURES] = "VHOST_SET_FEATURES",
- [VHOST_USER_GET_FEATURES] = "VHOST_GET_FEATURES",
- [VHOST_USER_SET_VRING_CALL] = "VHOST_SET_VRING_CALL",
- [VHOST_USER_SET_VRING_NUM] = "VHOST_SET_VRING_NUM",
- [VHOST_USER_SET_VRING_BASE] = "VHOST_SET_VRING_BASE",
- [VHOST_USER_GET_VRING_BASE] = "VHOST_GET_VRING_BASE",
- [VHOST_USER_SET_VRING_ADDR] = "VHOST_SET_VRING_ADDR",
- [VHOST_USER_SET_VRING_KICK] = "VHOST_SET_VRING_KICK",
- [VHOST_USER_SET_MEM_TABLE] = "VHOST_SET_MEM_TABLE",
- [VHOST_USER_SET_VRING_ENABLE] = "VHOST_SET_VRING_ENABLE",
-};
+static int
+vhost_user_set_vring_enable(struct virtio_user_dev *dev, struct vhost_vring_state *state)
+{
+ return vhost_user_set_vring(dev, VHOST_USER_SET_VRING_ENABLE, state);
+}
+
+static int
+vhost_user_set_vring_num(struct virtio_user_dev *dev, struct vhost_vring_state *state)
+{
+ return vhost_user_set_vring(dev, VHOST_USER_SET_VRING_NUM, state);
+}
+
+static int
+vhost_user_set_vring_base(struct virtio_user_dev *dev, struct vhost_vring_state *state)
+{
+ return vhost_user_set_vring(dev, VHOST_USER_SET_VRING_BASE, state);
+}
static int
-vhost_user_sock(struct virtio_user_dev *dev,
- enum vhost_user_request req,
- void *arg)
+vhost_user_get_vring_base(struct virtio_user_dev *dev, struct vhost_vring_state *state)
{
+ int ret;
struct vhost_user_msg msg;
- struct vhost_vring_file *file = 0;
- int need_reply = 0;
- int fds[VHOST_MEMORY_MAX_NREGIONS];
- int fd_num = 0;
- int len;
- int vhostfd = dev->vhostfd;
+ struct vhost_user_data *data = dev->backend_data;
+ unsigned int index = state->index;
+
+ ret = vhost_user_set_vring(dev, VHOST_USER_GET_VRING_BASE, state);
+ if (ret < 0) {
+ PMD_DRV_LOG(ERR, "Failed to send request");
+ goto err;
+ }
+
+ ret = vhost_user_read(data->vhostfd, &msg);
+ if (ret < 0) {
+ PMD_DRV_LOG(ERR, "Failed to read reply");
+ goto err;
+ }
+
+ if (msg.request != VHOST_USER_GET_VRING_BASE) {
+ PMD_DRV_LOG(ERR, "Unexpected request type (%d)", msg.request);
+ goto err;
+ }
+
+ if (msg.size != sizeof(*state)) {
+ PMD_DRV_LOG(ERR, "Unexpected payload size (%u)", msg.size);
+ goto err;
+ }
- RTE_SET_USED(m);
+ if (msg.payload.state.index != index) {
+ PMD_DRV_LOG(ERR, "Unexpected ring index (%u)", state->index);
+ goto err;
+ }
- PMD_DRV_LOG(INFO, "%s", vhost_msg_strings[req]);
+ *state = msg.payload.state;
- if (dev->is_server && vhostfd < 0)
+ return 0;
+err:
+ PMD_DRV_LOG(ERR, "Failed to get vring base");
+ return -1;
+}
+
+static int
+vhost_user_set_vring_file(struct virtio_user_dev *dev, enum vhost_user_request req,
+ struct vhost_vring_file *file)
+{
+ int ret;
+ int fd = file->fd;
+ int num_fd = 0;
+ struct vhost_user_data *data = dev->backend_data;
+ struct vhost_user_msg msg = {
+ .request = req,
+ .flags = VHOST_USER_VERSION,
+ .size = sizeof(msg.payload.u64),
+ .payload.u64 = file->index & VHOST_USER_VRING_IDX_MASK,
+ };
+
+ if (fd >= 0)
+ num_fd++;
+ else
+ msg.payload.u64 |= VHOST_USER_VRING_NOFD_MASK;
+
+ ret = vhost_user_write(data->vhostfd, &msg, &fd, num_fd);
+ if (ret < 0) {
+ PMD_DRV_LOG(ERR, "Failed to set vring file (request %d)", req);
return -1;
+ }
- msg.request = req;
- msg.flags = VHOST_USER_VERSION;
- msg.size = 0;
+ return 0;
+}
- switch (req) {
- case VHOST_USER_GET_FEATURES:
- need_reply = 1;
- break;
+static int
+vhost_user_set_vring_call(struct virtio_user_dev *dev, struct vhost_vring_file *file)
+{
+ return vhost_user_set_vring_file(dev, VHOST_USER_SET_VRING_CALL, file);
+}
- case VHOST_USER_SET_FEATURES:
- case VHOST_USER_SET_LOG_BASE:
- msg.payload.u64 = *((__u64 *)arg);
- msg.size = sizeof(m.payload.u64);
- break;
+static int
+vhost_user_set_vring_kick(struct virtio_user_dev *dev, struct vhost_vring_file *file)
+{
+ return vhost_user_set_vring_file(dev, VHOST_USER_SET_VRING_KICK, file);
+}
- case VHOST_USER_SET_OWNER:
- case VHOST_USER_RESET_OWNER:
- break;
- case VHOST_USER_SET_MEM_TABLE:
- if (prepare_vhost_memory_user(&msg, fds) < 0)
- return -1;
- fd_num = msg.payload.memory.nregions;
- msg.size = sizeof(m.payload.memory.nregions);
- msg.size += sizeof(m.payload.memory.padding);
- msg.size += fd_num * sizeof(struct vhost_memory_region);
- break;
-
- case VHOST_USER_SET_LOG_FD:
- fds[fd_num++] = *((int *)arg);
- break;
-
- case VHOST_USER_SET_VRING_NUM:
- case VHOST_USER_SET_VRING_BASE:
- case VHOST_USER_SET_VRING_ENABLE:
- memcpy(&msg.payload.state, arg, sizeof(msg.payload.state));
- msg.size = sizeof(m.payload.state);
- break;
-
- case VHOST_USER_GET_VRING_BASE:
- memcpy(&msg.payload.state, arg, sizeof(msg.payload.state));
- msg.size = sizeof(m.payload.state);
- need_reply = 1;
- break;
-
- case VHOST_USER_SET_VRING_ADDR:
- memcpy(&msg.payload.addr, arg, sizeof(msg.payload.addr));
- msg.size = sizeof(m.payload.addr);
- break;
-
- case VHOST_USER_SET_VRING_KICK:
- case VHOST_USER_SET_VRING_CALL:
- case VHOST_USER_SET_VRING_ERR:
- file = arg;
- msg.payload.u64 = file->index & VHOST_USER_VRING_IDX_MASK;
- msg.size = sizeof(m.payload.u64);
- if (file->fd > 0)
- fds[fd_num++] = file->fd;
- else
- msg.payload.u64 |= VHOST_USER_VRING_NOFD_MASK;
- break;
-
- default:
- PMD_DRV_LOG(ERR, "trying to send unhandled msg type");
+static int
+vhost_user_set_vring_addr(struct virtio_user_dev *dev, struct vhost_vring_addr *addr)
+{
+ int ret;
+ struct vhost_user_data *data = dev->backend_data;
+ struct vhost_user_msg msg = {
+ .request = VHOST_USER_SET_VRING_ADDR,
+ .flags = VHOST_USER_VERSION,
+ .size = sizeof(*addr),
+ .payload.addr = *addr,
+ };
+
+ ret = vhost_user_write(data->vhostfd, &msg, NULL, 0);
+ if (ret < 0) {
+ PMD_DRV_LOG(ERR, "Failed to send vring addresses");
return -1;
}
- len = VHOST_USER_HDR_SIZE + msg.size;
- if (vhost_user_write(vhostfd, &msg, len, fds, fd_num) < 0) {
- PMD_DRV_LOG(ERR, "%s failed: %s",
- vhost_msg_strings[req], strerror(errno));
- return -1;
+ return 0;
+}
+
+static int
+vhost_user_get_status(struct virtio_user_dev *dev, uint8_t *status)
+{
+ int ret;
+ struct vhost_user_data *data = dev->backend_data;
+ struct vhost_user_msg msg = {
+ .request = VHOST_USER_GET_STATUS,
+ .flags = VHOST_USER_VERSION,
+ };
+
+ /*
+ * If features have not been negotiated, we don't know if the backend
+ * supports protocol features
+ */
+ if (!(dev->status & VIRTIO_CONFIG_STATUS_FEATURES_OK))
+ return -ENOTSUP;
+
+ /* Status protocol feature requires protocol features support */
+ if (!(dev->device_features & (1ULL << VHOST_USER_F_PROTOCOL_FEATURES)))
+ return -ENOTSUP;
+
+ if (!(data->protocol_features & (1ULL << VHOST_USER_PROTOCOL_F_STATUS)))
+ return -ENOTSUP;
+
+ ret = vhost_user_write(data->vhostfd, &msg, NULL, 0);
+ if (ret < 0) {
+ PMD_DRV_LOG(ERR, "Failed to send request");
+ goto err;
}
- if (need_reply) {
- if (vhost_user_read(vhostfd, &msg) < 0) {
- PMD_DRV_LOG(ERR, "Received msg failed: %s",
- strerror(errno));
- return -1;
- }
+ ret = vhost_user_read(data->vhostfd, &msg);
+ if (ret < 0) {
+ PMD_DRV_LOG(ERR, "Failed to recv request");
+ goto err;
+ }
- if (req != msg.request) {
- PMD_DRV_LOG(ERR, "Received unexpected msg type");
- return -1;
- }
+ if (msg.request != VHOST_USER_GET_STATUS) {
+ PMD_DRV_LOG(ERR, "Unexpected request type (%d)", msg.request);
+ goto err;
+ }
- switch (req) {
- case VHOST_USER_GET_FEATURES:
- if (msg.size != sizeof(m.payload.u64)) {
- PMD_DRV_LOG(ERR, "Received bad msg size");
- return -1;
- }
- *((__u64 *)arg) = msg.payload.u64;
- break;
- case VHOST_USER_GET_VRING_BASE:
- if (msg.size != sizeof(m.payload.state)) {
- PMD_DRV_LOG(ERR, "Received bad msg size");
- return -1;
- }
- memcpy(arg, &msg.payload.state,
- sizeof(struct vhost_vring_state));
- break;
- default:
- PMD_DRV_LOG(ERR, "Received unexpected msg type");
- return -1;
- }
+ if (msg.size != sizeof(msg.payload.u64)) {
+ PMD_DRV_LOG(ERR, "Unexpected payload size (%u)", msg.size);
+ goto err;
}
+ *status = (uint8_t)msg.payload.u64;
+
return 0;
+err:
+ PMD_DRV_LOG(ERR, "Failed to get device status");
+ return -1;
+}
+
+static int
+vhost_user_set_status(struct virtio_user_dev *dev, uint8_t status)
+{
+ int ret;
+ struct vhost_user_data *data = dev->backend_data;
+ struct vhost_user_msg msg = {
+ .request = VHOST_USER_SET_STATUS,
+ .flags = VHOST_USER_VERSION,
+ .size = sizeof(msg.payload.u64),
+ .payload.u64 = status,
+ };
+
+ /*
+ * If features have not been negotiated, we don't know if the backend
+ * supports protocol features
+ */
+ if (!(dev->status & VIRTIO_CONFIG_STATUS_FEATURES_OK))
+ return -ENOTSUP;
+
+ /* Status protocol feature requires protocol features support */
+ if (!(dev->device_features & (1ULL << VHOST_USER_F_PROTOCOL_FEATURES)))
+ return -ENOTSUP;
+
+ if (!(data->protocol_features & (1ULL << VHOST_USER_PROTOCOL_F_STATUS)))
+ return -ENOTSUP;
+
+ if (data->protocol_features & (1ULL << VHOST_USER_PROTOCOL_F_REPLY_ACK))
+ msg.flags |= VHOST_USER_NEED_REPLY_MASK;
+
+ ret = vhost_user_write(data->vhostfd, &msg, NULL, 0);
+ if (ret < 0) {
+ PMD_DRV_LOG(ERR, "Failed to send get status request");
+ return -1;
+ }
+
+ return vhost_user_check_reply_ack(dev, &msg);
}
#define MAX_VIRTIO_USER_BACKLOG 1
static int
-virtio_user_start_server(struct virtio_user_dev *dev, struct sockaddr_un *un)
+vhost_user_start_server(struct virtio_user_dev *dev, struct sockaddr_un *un)
{
int ret;
int flag;
- int fd = dev->listenfd;
+ struct vhost_user_data *data = dev->backend_data;
+ int fd = data->listenfd;
ret = bind(fd, (struct sockaddr *)un, sizeof(*un));
if (ret < 0) {
if (ret < 0)
return -1;
+ PMD_DRV_LOG(NOTICE, "(%s) waiting for client connection...", dev->path);
+ data->vhostfd = accept(fd, NULL, NULL);
+ if (data->vhostfd < 0) {
+ PMD_DRV_LOG(ERR, "Failed to accept initial client connection (%s)",
+ strerror(errno));
+ return -1;
+ }
+
flag = fcntl(fd, F_GETFL);
if (fcntl(fd, F_SETFL, flag | O_NONBLOCK) < 0) {
PMD_DRV_LOG(ERR, "fcntl failed, %s", strerror(errno));
return 0;
}
+static int
+vhost_user_server_disconnect(struct virtio_user_dev *dev)
+{
+ struct vhost_user_data *data = dev->backend_data;
+
+ if (data->vhostfd < 0) {
+ PMD_DRV_LOG(ERR, "(%s) Expected valid Vhost FD", dev->path);
+ return -1;
+ }
+
+ close(data->vhostfd);
+ data->vhostfd = -1;
+
+ return 0;
+}
+
+static int
+vhost_user_server_reconnect(struct virtio_user_dev *dev)
+{
+ struct vhost_user_data *data = dev->backend_data;
+ int fd;
+
+ fd = accept(data->listenfd, NULL, NULL);
+ if (fd < 0)
+ return -1;
+
+ data->vhostfd = fd;
+
+ return 0;
+}
+
/**
* Set up environment to talk with a vhost user backend.
*
int fd;
int flag;
struct sockaddr_un un;
+ struct vhost_user_data *data;
+
+ data = malloc(sizeof(*data));
+ if (!data) {
+ PMD_DRV_LOG(ERR, "(%s) Failed to allocate Vhost-user data\n", dev->path);
+ return -1;
+ }
+
+ memset(data, 0, sizeof(*data));
+
+ dev->backend_data = data;
+
+ data->vhostfd = -1;
+ data->listenfd = -1;
fd = socket(AF_UNIX, SOCK_STREAM, 0);
if (fd < 0) {
PMD_DRV_LOG(ERR, "socket() error, %s", strerror(errno));
- return -1;
+ goto err_data;
}
flag = fcntl(fd, F_GETFD);
strlcpy(un.sun_path, dev->path, sizeof(un.sun_path));
if (dev->is_server) {
- dev->listenfd = fd;
- if (virtio_user_start_server(dev, &un) < 0) {
+ data->listenfd = fd;
+ if (vhost_user_start_server(dev, &un) < 0) {
PMD_DRV_LOG(ERR, "virtio-user startup fails in server mode");
- close(fd);
- return -1;
+ goto err_socket;
}
- dev->vhostfd = -1;
} else {
if (connect(fd, (struct sockaddr *)&un, sizeof(un)) < 0) {
PMD_DRV_LOG(ERR, "connect error, %s", strerror(errno));
- close(fd);
- return -1;
+ goto err_socket;
}
- dev->vhostfd = fd;
+ data->vhostfd = fd;
}
+ return 0;
+
+err_socket:
+ close(fd);
+err_data:
+ free(data);
+ dev->backend_data = NULL;
+
+ return -1;
+}
+
+static int
+vhost_user_destroy(struct virtio_user_dev *dev)
+{
+ struct vhost_user_data *data = dev->backend_data;
+
+ if (!data)
+ return 0;
+
+ if (data->vhostfd >= 0) {
+ close(data->vhostfd);
+ data->vhostfd = -1;
+ }
+
+ if (data->listenfd >= 0) {
+ close(data->listenfd);
+ data->listenfd = -1;
+ }
+
+ free(data);
+ dev->backend_data = NULL;
+
return 0;
}
uint16_t pair_idx,
int enable)
{
+ struct vhost_user_data *data = dev->backend_data;
int i;
+ if (data->vhostfd < 0)
+ return 0;
+
+ if (dev->qp_enabled[pair_idx] == enable)
+ return 0;
+
for (i = 0; i < 2; ++i) {
struct vhost_vring_state state = {
.index = pair_idx * 2 + i,
- .num = enable,
+ .num = enable,
};
- if (vhost_user_sock(dev, VHOST_USER_SET_VRING_ENABLE, &state))
+ if (vhost_user_set_vring_enable(dev, &state))
return -1;
}
+ dev->qp_enabled[pair_idx] = enable;
return 0;
}
+static int
+vhost_user_get_backend_features(uint64_t *features)
+{
+ *features = 1ULL << VHOST_USER_F_PROTOCOL_FEATURES;
+
+ return 0;
+}
+
+static int
+vhost_user_update_link_state(struct virtio_user_dev *dev)
+{
+ struct vhost_user_data *data = dev->backend_data;
+ char buf[128];
+
+ if (data->vhostfd >= 0) {
+ int r;
+ int flags;
+
+ flags = fcntl(data->vhostfd, F_GETFL);
+ if (fcntl(data->vhostfd, F_SETFL, flags | O_NONBLOCK) == -1) {
+ PMD_DRV_LOG(ERR, "error setting O_NONBLOCK flag");
+ return -1;
+ }
+
+ r = recv(data->vhostfd, buf, 128, MSG_PEEK);
+ if (r == 0 || (r < 0 && errno != EAGAIN)) {
+ dev->net_status &= (~VIRTIO_NET_S_LINK_UP);
+ PMD_DRV_LOG(ERR, "virtio-user port %u is down", dev->port_id);
+
+ /* This function could be called in the process
+ * of interrupt handling, callback cannot be
+ * unregistered here, set an alarm to do it.
+ */
+ rte_eal_alarm_set(1, virtio_user_dev_delayed_handler, (void *)dev);
+ } else {
+ dev->net_status |= VIRTIO_NET_S_LINK_UP;
+ }
+
+ if (fcntl(data->vhostfd, F_SETFL,
+ flags & ~O_NONBLOCK) == -1) {
+ PMD_DRV_LOG(ERR, "error clearing O_NONBLOCK flag");
+ return -1;
+ }
+ } else if (dev->is_server) {
+ dev->net_status &= (~VIRTIO_NET_S_LINK_UP);
+ if (virtio_user_dev_server_reconnect(dev) >= 0)
+ dev->net_status |= VIRTIO_NET_S_LINK_UP;
+ }
+
+ return 0;
+}
+
+static int
+vhost_user_get_intr_fd(struct virtio_user_dev *dev)
+{
+ struct vhost_user_data *data = dev->backend_data;
+
+ if (dev->is_server && data->vhostfd == -1)
+ return data->listenfd;
+
+ return data->vhostfd;
+}
+
struct virtio_user_backend_ops virtio_ops_user = {
.setup = vhost_user_setup,
- .send_request = vhost_user_sock,
- .enable_qp = vhost_user_enable_queue_pair
+ .destroy = vhost_user_destroy,
+ .get_backend_features = vhost_user_get_backend_features,
+ .set_owner = vhost_user_set_owner,
+ .get_features = vhost_user_get_features,
+ .set_features = vhost_user_set_features,
+ .set_memory_table = vhost_user_set_memory_table,
+ .set_vring_num = vhost_user_set_vring_num,
+ .set_vring_base = vhost_user_set_vring_base,
+ .get_vring_base = vhost_user_get_vring_base,
+ .set_vring_call = vhost_user_set_vring_call,
+ .set_vring_kick = vhost_user_set_vring_kick,
+ .set_vring_addr = vhost_user_set_vring_addr,
+ .get_status = vhost_user_get_status,
+ .set_status = vhost_user_set_status,
+ .enable_qp = vhost_user_enable_queue_pair,
+ .update_link_state = vhost_user_update_link_state,
+ .server_disconnect = vhost_user_server_disconnect,
+ .server_reconnect = vhost_user_server_reconnect,
+ .get_intr_fd = vhost_user_get_intr_fd,
};