vhost_net: a kernel-level virtio server
What it is: vhost net is a character device that can be used to reduce the number of system calls involved in virtio networking. Existing virtio net code is used in the guest without modification. There's similarity with vringfd, with some differences and reduced scope - uses eventfd for signalling - structures can be moved around in memory at any time (good for migration, bug work-arounds in userspace) - write logging is supported (good for migration) - support memory table and not just an offset (needed for kvm) common virtio related code has been put in a separate file vhost.c and can be made into a separate module if/when more backends appear. I used Rusty's lguest.c as the source for developing this part : this supplied me with witty comments I wouldn't be able to write myself. What it is not: vhost net is not a bus, and not a generic new system call. No assumptions are made on how guest performs hypercalls. Userspace hypervisors are supported as well as kvm. How it works: Basically, we connect virtio frontend (configured by userspace) to a backend. The backend could be a network device, or a tap device. Backend is also configured by userspace, including vlan/mac etc. Status: This works for me, and I haven't see any crashes. Compared to userspace, people reported improved latency (as I save up to 4 system calls per packet), as well as better bandwidth and CPU utilization. Features that I plan to look at in the future: - mergeable buffers - zero copy - scalability tuning: figure out the best threading model to use Note on RCU usage (this is also documented in vhost.h, near private_pointer which is the value protected by this variant of RCU): what is happening is that the rcu_dereference() is being used in a workqueue item. The role of rcu_read_lock() is taken on by the start of execution of the workqueue item, of rcu_read_unlock() by the end of execution of the workqueue item, and of synchronize_rcu() by flush_workqueue()/flush_work(). In the future we might need to apply some gcc attribute or sparse annotation to the function passed to INIT_WORK(). Paul's ack below is for this RCU usage. (Includes fixes by Alan Cox <alan@linux.intel.com>, David L Stevens <dlstevens@us.ibm.com>, Chris Wright <chrisw@redhat.com>) Acked-by: Rusty Russell <rusty@rustcorp.com.au> Acked-by: Arnd Bergmann <arnd@arndb.de> Acked-by: "Paul E. McKenney" <paulmck@linux.vnet.ibm.com> Signed-off-by: Michael S. Tsirkin <mst@redhat.com> Signed-off-by: David S. Miller <davem@davemloft.net>hifive-unleashed-5.1
Michael S. Tsirkin
David S. Miller
parent
5da779c34c
commit
3a4d5c94e9
|
|
@ -5803,6 +5803,15 @@ S: Maintained
|
|||
F: Documentation/filesystems/vfat.txt
|
||||
F: fs/fat/
|
||||
|
||||
VIRTIO HOST (VHOST)
|
||||
M: "Michael S. Tsirkin" <mst@redhat.com>
|
||||
L: kvm@vger.kernel.org
|
||||
L: virtualization@lists.osdl.org
|
||||
L: netdev@vger.kernel.org
|
||||
S: Maintained
|
||||
F: drivers/vhost/
|
||||
F: include/linux/vhost.h
|
||||
|
||||
VIA RHINE NETWORK DRIVER
|
||||
M: Roger Luethi <rl@hellgate.ch>
|
||||
S: Maintained
|
||||
|
|
|
|||
|
|
@ -47,6 +47,7 @@ config KVM_INTEL
|
|||
Provides support for KVM on Itanium 2 processors equipped with the VT
|
||||
extensions.
|
||||
|
||||
source drivers/vhost/Kconfig
|
||||
source drivers/virtio/Kconfig
|
||||
|
||||
endif # VIRTUALIZATION
|
||||
|
|
|
|||
|
|
@ -75,6 +75,7 @@ config KVM_E500
|
|||
|
||||
If unsure, say N.
|
||||
|
||||
source drivers/vhost/Kconfig
|
||||
source drivers/virtio/Kconfig
|
||||
|
||||
endif # VIRTUALIZATION
|
||||
|
|
|
|||
|
|
@ -35,6 +35,7 @@ config KVM
|
|||
|
||||
# OK, it's a little counter-intuitive to do this, but it puts it neatly under
|
||||
# the virtualization menu.
|
||||
source drivers/vhost/Kconfig
|
||||
source drivers/virtio/Kconfig
|
||||
|
||||
endif # VIRTUALIZATION
|
||||
|
|
|
|||
|
|
@ -65,6 +65,7 @@ config KVM_AMD
|
|||
|
||||
# OK, it's a little counter-intuitive to do this, but it puts it neatly under
|
||||
# the virtualization menu.
|
||||
source drivers/vhost/Kconfig
|
||||
source drivers/lguest/Kconfig
|
||||
source drivers/virtio/Kconfig
|
||||
|
||||
|
|
|
|||
|
|
@ -106,6 +106,7 @@ obj-$(CONFIG_HID) += hid/
|
|||
obj-$(CONFIG_PPC_PS3) += ps3/
|
||||
obj-$(CONFIG_OF) += of/
|
||||
obj-$(CONFIG_SSB) += ssb/
|
||||
obj-$(CONFIG_VHOST_NET) += vhost/
|
||||
obj-$(CONFIG_VIRTIO) += virtio/
|
||||
obj-$(CONFIG_VLYNQ) += vlynq/
|
||||
obj-$(CONFIG_STAGING) += staging/
|
||||
|
|
|
|||
|
|
@ -0,0 +1,11 @@
|
|||
config VHOST_NET
|
||||
tristate "Host kernel accelerator for virtio net (EXPERIMENTAL)"
|
||||
depends on NET && EVENTFD && EXPERIMENTAL
|
||||
---help---
|
||||
This kernel module can be loaded in host kernel to accelerate
|
||||
guest networking with virtio_net. Not to be confused with virtio_net
|
||||
module itself which needs to be loaded in guest kernel.
|
||||
|
||||
To compile this driver as a module, choose M here: the module will
|
||||
be called vhost_net.
|
||||
|
||||
|
|
@ -0,0 +1,2 @@
|
|||
obj-$(CONFIG_VHOST_NET) += vhost_net.o
|
||||
vhost_net-y := vhost.o net.o
|
||||
|
|
@ -0,0 +1,661 @@
|
|||
/* Copyright (C) 2009 Red Hat, Inc.
|
||||
* Author: Michael S. Tsirkin <mst@redhat.com>
|
||||
*
|
||||
* This work is licensed under the terms of the GNU GPL, version 2.
|
||||
*
|
||||
* virtio-net server in host kernel.
|
||||
*/
|
||||
|
||||
#include <linux/compat.h>
|
||||
#include <linux/eventfd.h>
|
||||
#include <linux/vhost.h>
|
||||
#include <linux/virtio_net.h>
|
||||
#include <linux/mmu_context.h>
|
||||
#include <linux/miscdevice.h>
|
||||
#include <linux/module.h>
|
||||
#include <linux/mutex.h>
|
||||
#include <linux/workqueue.h>
|
||||
#include <linux/rcupdate.h>
|
||||
#include <linux/file.h>
|
||||
|
||||
#include <linux/net.h>
|
||||
#include <linux/if_packet.h>
|
||||
#include <linux/if_arp.h>
|
||||
#include <linux/if_tun.h>
|
||||
|
||||
#include <net/sock.h>
|
||||
|
||||
#include "vhost.h"
|
||||
|
||||
/* Max number of bytes transferred before requeueing the job.
|
||||
* Using this limit prevents one virtqueue from starving others. */
|
||||
#define VHOST_NET_WEIGHT 0x80000
|
||||
|
||||
enum {
|
||||
VHOST_NET_VQ_RX = 0,
|
||||
VHOST_NET_VQ_TX = 1,
|
||||
VHOST_NET_VQ_MAX = 2,
|
||||
};
|
||||
|
||||
enum vhost_net_poll_state {
|
||||
VHOST_NET_POLL_DISABLED = 0,
|
||||
VHOST_NET_POLL_STARTED = 1,
|
||||
VHOST_NET_POLL_STOPPED = 2,
|
||||
};
|
||||
|
||||
struct vhost_net {
|
||||
struct vhost_dev dev;
|
||||
struct vhost_virtqueue vqs[VHOST_NET_VQ_MAX];
|
||||
struct vhost_poll poll[VHOST_NET_VQ_MAX];
|
||||
/* Tells us whether we are polling a socket for TX.
|
||||
* We only do this when socket buffer fills up.
|
||||
* Protected by tx vq lock. */
|
||||
enum vhost_net_poll_state tx_poll_state;
|
||||
};
|
||||
|
||||
/* Pop first len bytes from iovec. Return number of segments used. */
|
||||
static int move_iovec_hdr(struct iovec *from, struct iovec *to,
|
||||
size_t len, int iov_count)
|
||||
{
|
||||
int seg = 0;
|
||||
size_t size;
|
||||
while (len && seg < iov_count) {
|
||||
size = min(from->iov_len, len);
|
||||
to->iov_base = from->iov_base;
|
||||
to->iov_len = size;
|
||||
from->iov_len -= size;
|
||||
from->iov_base += size;
|
||||
len -= size;
|
||||
++from;
|
||||
++to;
|
||||
++seg;
|
||||
}
|
||||
return seg;
|
||||
}
|
||||
|
||||
/* Caller must have TX VQ lock */
|
||||
static void tx_poll_stop(struct vhost_net *net)
|
||||
{
|
||||
if (likely(net->tx_poll_state != VHOST_NET_POLL_STARTED))
|
||||
return;
|
||||
vhost_poll_stop(net->poll + VHOST_NET_VQ_TX);
|
||||
net->tx_poll_state = VHOST_NET_POLL_STOPPED;
|
||||
}
|
||||
|
||||
/* Caller must have TX VQ lock */
|
||||
static void tx_poll_start(struct vhost_net *net, struct socket *sock)
|
||||
{
|
||||
if (unlikely(net->tx_poll_state != VHOST_NET_POLL_STOPPED))
|
||||
return;
|
||||
vhost_poll_start(net->poll + VHOST_NET_VQ_TX, sock->file);
|
||||
net->tx_poll_state = VHOST_NET_POLL_STARTED;
|
||||
}
|
||||
|
||||
/* Expects to be always run from workqueue - which acts as
|
||||
* read-size critical section for our kind of RCU. */
|
||||
static void handle_tx(struct vhost_net *net)
|
||||
{
|
||||
struct vhost_virtqueue *vq = &net->dev.vqs[VHOST_NET_VQ_TX];
|
||||
unsigned head, out, in, s;
|
||||
struct msghdr msg = {
|
||||
.msg_name = NULL,
|
||||
.msg_namelen = 0,
|
||||
.msg_control = NULL,
|
||||
.msg_controllen = 0,
|
||||
.msg_iov = vq->iov,
|
||||
.msg_flags = MSG_DONTWAIT,
|
||||
};
|
||||
size_t len, total_len = 0;
|
||||
int err, wmem;
|
||||
size_t hdr_size;
|
||||
struct socket *sock = rcu_dereference(vq->private_data);
|
||||
if (!sock)
|
||||
return;
|
||||
|
||||
wmem = atomic_read(&sock->sk->sk_wmem_alloc);
|
||||
if (wmem >= sock->sk->sk_sndbuf)
|
||||
return;
|
||||
|
||||
use_mm(net->dev.mm);
|
||||
mutex_lock(&vq->mutex);
|
||||
vhost_disable_notify(vq);
|
||||
|
||||
if (wmem < sock->sk->sk_sndbuf * 2)
|
||||
tx_poll_stop(net);
|
||||
hdr_size = vq->hdr_size;
|
||||
|
||||
for (;;) {
|
||||
head = vhost_get_vq_desc(&net->dev, vq, vq->iov,
|
||||
ARRAY_SIZE(vq->iov),
|
||||
&out, &in,
|
||||
NULL, NULL);
|
||||
/* Nothing new? Wait for eventfd to tell us they refilled. */
|
||||
if (head == vq->num) {
|
||||
wmem = atomic_read(&sock->sk->sk_wmem_alloc);
|
||||
if (wmem >= sock->sk->sk_sndbuf * 3 / 4) {
|
||||
tx_poll_start(net, sock);
|
||||
set_bit(SOCK_ASYNC_NOSPACE, &sock->flags);
|
||||
break;
|
||||
}
|
||||
if (unlikely(vhost_enable_notify(vq))) {
|
||||
vhost_disable_notify(vq);
|
||||
continue;
|
||||
}
|
||||
break;
|
||||
}
|
||||
if (in) {
|
||||
vq_err(vq, "Unexpected descriptor format for TX: "
|
||||
"out %d, int %d\n", out, in);
|
||||
break;
|
||||
}
|
||||
/* Skip header. TODO: support TSO. */
|
||||
s = move_iovec_hdr(vq->iov, vq->hdr, hdr_size, out);
|
||||
msg.msg_iovlen = out;
|
||||
len = iov_length(vq->iov, out);
|
||||
/* Sanity check */
|
||||
if (!len) {
|
||||
vq_err(vq, "Unexpected header len for TX: "
|
||||
"%zd expected %zd\n",
|
||||
iov_length(vq->hdr, s), hdr_size);
|
||||
break;
|
||||
}
|
||||
/* TODO: Check specific error and bomb out unless ENOBUFS? */
|
||||
err = sock->ops->sendmsg(NULL, sock, &msg, len);
|
||||
if (unlikely(err < 0)) {
|
||||
vhost_discard_vq_desc(vq);
|
||||
tx_poll_start(net, sock);
|
||||
break;
|
||||
}
|
||||
if (err != len)
|
||||
pr_err("Truncated TX packet: "
|
||||
" len %d != %zd\n", err, len);
|
||||
vhost_add_used_and_signal(&net->dev, vq, head, 0);
|
||||
total_len += len;
|
||||
if (unlikely(total_len >= VHOST_NET_WEIGHT)) {
|
||||
vhost_poll_queue(&vq->poll);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
mutex_unlock(&vq->mutex);
|
||||
unuse_mm(net->dev.mm);
|
||||
}
|
||||
|
||||
/* Expects to be always run from workqueue - which acts as
|
||||
* read-size critical section for our kind of RCU. */
|
||||
static void handle_rx(struct vhost_net *net)
|
||||
{
|
||||
struct vhost_virtqueue *vq = &net->dev.vqs[VHOST_NET_VQ_RX];
|
||||
unsigned head, out, in, log, s;
|
||||
struct vhost_log *vq_log;
|
||||
struct msghdr msg = {
|
||||
.msg_name = NULL,
|
||||
.msg_namelen = 0,
|
||||
.msg_control = NULL, /* FIXME: get and handle RX aux data. */
|
||||
.msg_controllen = 0,
|
||||
.msg_iov = vq->iov,
|
||||
.msg_flags = MSG_DONTWAIT,
|
||||
};
|
||||
|
||||
struct virtio_net_hdr hdr = {
|
||||
.flags = 0,
|
||||
.gso_type = VIRTIO_NET_HDR_GSO_NONE
|
||||
};
|
||||
|
||||
size_t len, total_len = 0;
|
||||
int err;
|
||||
size_t hdr_size;
|
||||
struct socket *sock = rcu_dereference(vq->private_data);
|
||||
if (!sock || skb_queue_empty(&sock->sk->sk_receive_queue))
|
||||
return;
|
||||
|
||||
use_mm(net->dev.mm);
|
||||
mutex_lock(&vq->mutex);
|
||||
vhost_disable_notify(vq);
|
||||
hdr_size = vq->hdr_size;
|
||||
|
||||
vq_log = unlikely(vhost_has_feature(&net->dev, VHOST_F_LOG_ALL)) ?
|
||||
vq->log : NULL;
|
||||
|
||||
for (;;) {
|
||||
head = vhost_get_vq_desc(&net->dev, vq, vq->iov,
|
||||
ARRAY_SIZE(vq->iov),
|
||||
&out, &in,
|
||||
vq_log, &log);
|
||||
/* OK, now we need to know about added descriptors. */
|
||||
if (head == vq->num) {
|
||||
if (unlikely(vhost_enable_notify(vq))) {
|
||||
/* They have slipped one in as we were
|
||||
* doing that: check again. */
|
||||
vhost_disable_notify(vq);
|
||||
continue;
|
||||
}
|
||||
/* Nothing new? Wait for eventfd to tell us
|
||||
* they refilled. */
|
||||
break;
|
||||
}
|
||||
/* We don't need to be notified again. */
|
||||
if (out) {
|
||||
vq_err(vq, "Unexpected descriptor format for RX: "
|
||||
"out %d, int %d\n",
|
||||
out, in);
|
||||
break;
|
||||
}
|
||||
/* Skip header. TODO: support TSO/mergeable rx buffers. */
|
||||
s = move_iovec_hdr(vq->iov, vq->hdr, hdr_size, in);
|
||||
msg.msg_iovlen = in;
|
||||
len = iov_length(vq->iov, in);
|
||||
/* Sanity check */
|
||||
if (!len) {
|
||||
vq_err(vq, "Unexpected header len for RX: "
|
||||
"%zd expected %zd\n",
|
||||
iov_length(vq->hdr, s), hdr_size);
|
||||
break;
|
||||
}
|
||||
err = sock->ops->recvmsg(NULL, sock, &msg,
|
||||
len, MSG_DONTWAIT | MSG_TRUNC);
|
||||
/* TODO: Check specific error and bomb out unless EAGAIN? */
|
||||
if (err < 0) {
|
||||
vhost_discard_vq_desc(vq);
|
||||
break;
|
||||
}
|
||||
/* TODO: Should check and handle checksum. */
|
||||
if (err > len) {
|
||||
pr_err("Discarded truncated rx packet: "
|
||||
" len %d > %zd\n", err, len);
|
||||
vhost_discard_vq_desc(vq);
|
||||
continue;
|
||||
}
|
||||
len = err;
|
||||
err = memcpy_toiovec(vq->hdr, (unsigned char *)&hdr, hdr_size);
|
||||
if (err) {
|
||||
vq_err(vq, "Unable to write vnet_hdr at addr %p: %d\n",
|
||||
vq->iov->iov_base, err);
|
||||
break;
|
||||
}
|
||||
len += hdr_size;
|
||||
vhost_add_used_and_signal(&net->dev, vq, head, len);
|
||||
if (unlikely(vq_log))
|
||||
vhost_log_write(vq, vq_log, log, len);
|
||||
total_len += len;
|
||||
if (unlikely(total_len >= VHOST_NET_WEIGHT)) {
|
||||
vhost_poll_queue(&vq->poll);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
mutex_unlock(&vq->mutex);
|
||||
unuse_mm(net->dev.mm);
|
||||
}
|
||||
|
||||
static void handle_tx_kick(struct work_struct *work)
|
||||
{
|
||||
struct vhost_virtqueue *vq;
|
||||
struct vhost_net *net;
|
||||
vq = container_of(work, struct vhost_virtqueue, poll.work);
|
||||
net = container_of(vq->dev, struct vhost_net, dev);
|
||||
handle_tx(net);
|
||||
}
|
||||
|
||||
static void handle_rx_kick(struct work_struct *work)
|
||||
{
|
||||
struct vhost_virtqueue *vq;
|
||||
struct vhost_net *net;
|
||||
vq = container_of(work, struct vhost_virtqueue, poll.work);
|
||||
net = container_of(vq->dev, struct vhost_net, dev);
|
||||
handle_rx(net);
|
||||
}
|
||||
|
||||
static void handle_tx_net(struct work_struct *work)
|
||||
{
|
||||
struct vhost_net *net;
|
||||
net = container_of(work, struct vhost_net, poll[VHOST_NET_VQ_TX].work);
|
||||
handle_tx(net);
|
||||
}
|
||||
|
||||
static void handle_rx_net(struct work_struct *work)
|
||||
{
|
||||
struct vhost_net *net;
|
||||
net = container_of(work, struct vhost_net, poll[VHOST_NET_VQ_RX].work);
|
||||
handle_rx(net);
|
||||
}
|
||||
|
||||
static int vhost_net_open(struct inode *inode, struct file *f)
|
||||
{
|
||||
struct vhost_net *n = kmalloc(sizeof *n, GFP_KERNEL);
|
||||
int r;
|
||||
if (!n)
|
||||
return -ENOMEM;
|
||||
n->vqs[VHOST_NET_VQ_TX].handle_kick = handle_tx_kick;
|
||||
n->vqs[VHOST_NET_VQ_RX].handle_kick = handle_rx_kick;
|
||||
r = vhost_dev_init(&n->dev, n->vqs, VHOST_NET_VQ_MAX);
|
||||
if (r < 0) {
|
||||
kfree(n);
|
||||
return r;
|
||||
}
|
||||
|
||||
vhost_poll_init(n->poll + VHOST_NET_VQ_TX, handle_tx_net, POLLOUT);
|
||||
vhost_poll_init(n->poll + VHOST_NET_VQ_RX, handle_rx_net, POLLIN);
|
||||
n->tx_poll_state = VHOST_NET_POLL_DISABLED;
|
||||
|
||||
f->private_data = n;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void vhost_net_disable_vq(struct vhost_net *n,
|
||||
struct vhost_virtqueue *vq)
|
||||
{
|
||||
if (!vq->private_data)
|
||||
return;
|
||||
if (vq == n->vqs + VHOST_NET_VQ_TX) {
|
||||
tx_poll_stop(n);
|
||||
n->tx_poll_state = VHOST_NET_POLL_DISABLED;
|
||||
} else
|
||||
vhost_poll_stop(n->poll + VHOST_NET_VQ_RX);
|
||||
}
|
||||
|
||||
static void vhost_net_enable_vq(struct vhost_net *n,
|
||||
struct vhost_virtqueue *vq)
|
||||
{
|
||||
struct socket *sock = vq->private_data;
|
||||
if (!sock)
|
||||
return;
|
||||
if (vq == n->vqs + VHOST_NET_VQ_TX) {
|
||||
n->tx_poll_state = VHOST_NET_POLL_STOPPED;
|
||||
tx_poll_start(n, sock);
|
||||
} else
|
||||
vhost_poll_start(n->poll + VHOST_NET_VQ_RX, sock->file);
|
||||
}
|
||||
|
||||
static struct socket *vhost_net_stop_vq(struct vhost_net *n,
|
||||
struct vhost_virtqueue *vq)
|
||||
{
|
||||
struct socket *sock;
|
||||
|
||||
mutex_lock(&vq->mutex);
|
||||
sock = vq->private_data;
|
||||
vhost_net_disable_vq(n, vq);
|
||||
rcu_assign_pointer(vq->private_data, NULL);
|
||||
mutex_unlock(&vq->mutex);
|
||||
return sock;
|
||||
}
|
||||
|
||||
static void vhost_net_stop(struct vhost_net *n, struct socket **tx_sock,
|
||||
struct socket **rx_sock)
|
||||
{
|
||||
*tx_sock = vhost_net_stop_vq(n, n->vqs + VHOST_NET_VQ_TX);
|
||||
*rx_sock = vhost_net_stop_vq(n, n->vqs + VHOST_NET_VQ_RX);
|
||||
}
|
||||
|
||||
static void vhost_net_flush_vq(struct vhost_net *n, int index)
|
||||
{
|
||||
vhost_poll_flush(n->poll + index);
|
||||
vhost_poll_flush(&n->dev.vqs[index].poll);
|
||||
}
|
||||
|
||||
static void vhost_net_flush(struct vhost_net *n)
|
||||
{
|
||||
vhost_net_flush_vq(n, VHOST_NET_VQ_TX);
|
||||
vhost_net_flush_vq(n, VHOST_NET_VQ_RX);
|
||||
}
|
||||
|
||||
static int vhost_net_release(struct inode *inode, struct file *f)
|
||||
{
|
||||
struct vhost_net *n = f->private_data;
|
||||
struct socket *tx_sock;
|
||||
struct socket *rx_sock;
|
||||
|
||||
vhost_net_stop(n, &tx_sock, &rx_sock);
|
||||
vhost_net_flush(n);
|
||||
vhost_dev_cleanup(&n->dev);
|
||||
if (tx_sock)
|
||||
fput(tx_sock->file);
|
||||
if (rx_sock)
|
||||
fput(rx_sock->file);
|
||||
/* We do an extra flush before freeing memory,
|
||||
* since jobs can re-queue themselves. */
|
||||
vhost_net_flush(n);
|
||||
kfree(n);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static struct socket *get_raw_socket(int fd)
|
||||
{
|
||||
struct {
|
||||
struct sockaddr_ll sa;
|
||||
char buf[MAX_ADDR_LEN];
|
||||
} uaddr;
|
||||
int uaddr_len = sizeof uaddr, r;
|
||||
struct socket *sock = sockfd_lookup(fd, &r);
|
||||
if (!sock)
|
||||
return ERR_PTR(-ENOTSOCK);
|
||||
|
||||
/* Parameter checking */
|
||||
if (sock->sk->sk_type != SOCK_RAW) {
|
||||
r = -ESOCKTNOSUPPORT;
|
||||
goto err;
|
||||
}
|
||||
|
||||
r = sock->ops->getname(sock, (struct sockaddr *)&uaddr.sa,
|
||||
&uaddr_len, 0);
|
||||
if (r)
|
||||
goto err;
|
||||
|
||||
if (uaddr.sa.sll_family != AF_PACKET) {
|
||||
r = -EPFNOSUPPORT;
|
||||
goto err;
|
||||
}
|
||||
return sock;
|
||||
err:
|
||||
fput(sock->file);
|
||||
return ERR_PTR(r);
|
||||
}
|
||||
|
||||
static struct socket *get_tun_socket(int fd)
|
||||
{
|
||||
struct file *file = fget(fd);
|
||||
struct socket *sock;
|
||||
if (!file)
|
||||
return ERR_PTR(-EBADF);
|
||||
sock = tun_get_socket(file);
|
||||
if (IS_ERR(sock))
|
||||
fput(file);
|
||||
return sock;
|
||||
}
|
||||
|
||||
static struct socket *get_socket(int fd)
|
||||
{
|
||||
struct socket *sock;
|
||||
/* special case to disable backend */
|
||||
if (fd == -1)
|
||||
return NULL;
|
||||
sock = get_raw_socket(fd);
|
||||
if (!IS_ERR(sock))
|
||||
return sock;
|
||||
sock = get_tun_socket(fd);
|
||||
if (!IS_ERR(sock))
|
||||
return sock;
|
||||
return ERR_PTR(-ENOTSOCK);
|
||||
}
|
||||
|
||||
static long vhost_net_set_backend(struct vhost_net *n, unsigned index, int fd)
|
||||
{
|
||||
struct socket *sock, *oldsock;
|
||||
struct vhost_virtqueue *vq;
|
||||
int r;
|
||||
|
||||
mutex_lock(&n->dev.mutex);
|
||||
r = vhost_dev_check_owner(&n->dev);
|
||||
if (r)
|
||||
goto err;
|
||||
|
||||
if (index >= VHOST_NET_VQ_MAX) {
|
||||
r = -ENOBUFS;
|
||||
goto err;
|
||||
}
|
||||
vq = n->vqs + index;
|
||||
mutex_lock(&vq->mutex);
|
||||
|
||||
/* Verify that ring has been setup correctly. */
|
||||
if (!vhost_vq_access_ok(vq)) {
|
||||
r = -EFAULT;
|
||||
goto err;
|
||||
}
|
||||
sock = get_socket(fd);
|
||||
if (IS_ERR(sock)) {
|
||||
r = PTR_ERR(sock);
|
||||
goto err;
|
||||
}
|
||||
|
||||
/* start polling new socket */
|
||||
oldsock = vq->private_data;
|
||||
if (sock == oldsock)
|
||||
goto done;
|
||||
|
||||
vhost_net_disable_vq(n, vq);
|
||||
rcu_assign_pointer(vq->private_data, sock);
|
||||
vhost_net_enable_vq(n, vq);
|
||||
mutex_unlock(&vq->mutex);
|
||||
done:
|
||||
if (oldsock) {
|
||||
vhost_net_flush_vq(n, index);
|
||||
fput(oldsock->file);
|
||||
}
|
||||
err:
|
||||
mutex_unlock(&n->dev.mutex);
|
||||
return r;
|
||||
}
|
||||
|
||||
static long vhost_net_reset_owner(struct vhost_net *n)
|
||||
{
|
||||
struct socket *tx_sock = NULL;
|
||||
struct socket *rx_sock = NULL;
|
||||
long err;
|
||||
mutex_lock(&n->dev.mutex);
|
||||
err = vhost_dev_check_owner(&n->dev);
|
||||
if (err)
|
||||
goto done;
|
||||
vhost_net_stop(n, &tx_sock, &rx_sock);
|
||||
vhost_net_flush(n);
|
||||
err = vhost_dev_reset_owner(&n->dev);
|
||||
done:
|
||||
mutex_unlock(&n->dev.mutex);
|
||||
if (tx_sock)
|
||||
fput(tx_sock->file);
|
||||
if (rx_sock)
|
||||
fput(rx_sock->file);
|
||||
return err;
|
||||
}
|
||||
|
||||
static int vhost_net_set_features(struct vhost_net *n, u64 features)
|
||||
{
|
||||
size_t hdr_size = features & (1 << VHOST_NET_F_VIRTIO_NET_HDR) ?
|
||||
sizeof(struct virtio_net_hdr) : 0;
|
||||
int i;
|
||||
mutex_lock(&n->dev.mutex);
|
||||
if ((features & (1 << VHOST_F_LOG_ALL)) &&
|
||||
!vhost_log_access_ok(&n->dev)) {
|
||||
mutex_unlock(&n->dev.mutex);
|
||||
return -EFAULT;
|
||||
}
|
||||
n->dev.acked_features = features;
|
||||
smp_wmb();
|
||||
for (i = 0; i < VHOST_NET_VQ_MAX; ++i) {
|
||||
mutex_lock(&n->vqs[i].mutex);
|
||||
n->vqs[i].hdr_size = hdr_size;
|
||||
mutex_unlock(&n->vqs[i].mutex);
|
||||
}
|
||||
vhost_net_flush(n);
|
||||
mutex_unlock(&n->dev.mutex);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static long vhost_net_ioctl(struct file *f, unsigned int ioctl,
|
||||
unsigned long arg)
|
||||
{
|
||||
struct vhost_net *n = f->private_data;
|
||||
void __user *argp = (void __user *)arg;
|
||||
u64 __user *featurep = argp;
|
||||
struct vhost_vring_file backend;
|
||||
u64 features;
|
||||
int r;
|
||||
switch (ioctl) {
|
||||
case VHOST_NET_SET_BACKEND:
|
||||
r = copy_from_user(&backend, argp, sizeof backend);
|
||||
if (r < 0)
|
||||
return r;
|
||||
return vhost_net_set_backend(n, backend.index, backend.fd);
|
||||
case VHOST_GET_FEATURES:
|
||||
features = VHOST_FEATURES;
|
||||
return copy_to_user(featurep, &features, sizeof features);
|
||||
case VHOST_SET_FEATURES:
|
||||
r = copy_from_user(&features, featurep, sizeof features);
|
||||
if (r < 0)
|
||||
return r;
|
||||
if (features & ~VHOST_FEATURES)
|
||||
return -EOPNOTSUPP;
|
||||
return vhost_net_set_features(n, features);
|
||||
case VHOST_RESET_OWNER:
|
||||
return vhost_net_reset_owner(n);
|
||||
default:
|
||||
mutex_lock(&n->dev.mutex);
|
||||
r = vhost_dev_ioctl(&n->dev, ioctl, arg);
|
||||
vhost_net_flush(n);
|
||||
mutex_unlock(&n->dev.mutex);
|
||||
return r;
|
||||
}
|
||||
}
|
||||
|
||||
#ifdef CONFIG_COMPAT
|
||||
static long vhost_net_compat_ioctl(struct file *f, unsigned int ioctl,
|
||||
unsigned long arg)
|
||||
{
|
||||
return vhost_net_ioctl(f, ioctl, (unsigned long)compat_ptr(arg));
|
||||
}
|
||||
#endif
|
||||
|
||||
const static struct file_operations vhost_net_fops = {
|
||||
.owner = THIS_MODULE,
|
||||
.release = vhost_net_release,
|
||||
.unlocked_ioctl = vhost_net_ioctl,
|
||||
#ifdef CONFIG_COMPAT
|
||||
.compat_ioctl = vhost_net_compat_ioctl,
|
||||
#endif
|
||||
.open = vhost_net_open,
|
||||
};
|
||||
|
||||
static struct miscdevice vhost_net_misc = {
|
||||
VHOST_NET_MINOR,
|
||||
"vhost-net",
|
||||
&vhost_net_fops,
|
||||
};
|
||||
|
||||
int vhost_net_init(void)
|
||||
{
|
||||
int r = vhost_init();
|
||||
if (r)
|
||||
goto err_init;
|
||||
r = misc_register(&vhost_net_misc);
|
||||
if (r)
|
||||
goto err_reg;
|
||||
return 0;
|
||||
err_reg:
|
||||
vhost_cleanup();
|
||||
err_init:
|
||||
return r;
|
||||
|
||||
}
|
||||
module_init(vhost_net_init);
|
||||
|
||||
void vhost_net_exit(void)
|
||||
{
|
||||
misc_deregister(&vhost_net_misc);
|
||||
vhost_cleanup();
|
||||
}
|
||||
module_exit(vhost_net_exit);
|
||||
|
||||
MODULE_VERSION("0.0.1");
|
||||
MODULE_LICENSE("GPL v2");
|
||||
MODULE_AUTHOR("Michael S. Tsirkin");
|
||||
MODULE_DESCRIPTION("Host kernel accelerator for virtio net");
|
||||
File diff suppressed because it is too large
Load Diff
|
|
@ -0,0 +1,161 @@
|
|||
#ifndef _VHOST_H
|
||||
#define _VHOST_H
|
||||
|
||||
#include <linux/eventfd.h>
|
||||
#include <linux/vhost.h>
|
||||
#include <linux/mm.h>
|
||||
#include <linux/mutex.h>
|
||||
#include <linux/workqueue.h>
|
||||
#include <linux/poll.h>
|
||||
#include <linux/file.h>
|
||||
#include <linux/skbuff.h>
|
||||
#include <linux/uio.h>
|
||||
#include <linux/virtio_config.h>
|
||||
#include <linux/virtio_ring.h>
|
||||
|
||||
struct vhost_device;
|
||||
|
||||
enum {
|
||||
/* Enough place for all fragments, head, and virtio net header. */
|
||||
VHOST_NET_MAX_SG = MAX_SKB_FRAGS + 2,
|
||||
};
|
||||
|
||||
/* Poll a file (eventfd or socket) */
|
||||
/* Note: there's nothing vhost specific about this structure. */
|
||||
struct vhost_poll {
|
||||
poll_table table;
|
||||
wait_queue_head_t *wqh;
|
||||
wait_queue_t wait;
|
||||
/* struct which will handle all actual work. */
|
||||
struct work_struct work;
|
||||
unsigned long mask;
|
||||
};
|
||||
|
||||
void vhost_poll_init(struct vhost_poll *poll, work_func_t func,
|
||||
unsigned long mask);
|
||||
void vhost_poll_start(struct vhost_poll *poll, struct file *file);
|
||||
void vhost_poll_stop(struct vhost_poll *poll);
|
||||
void vhost_poll_flush(struct vhost_poll *poll);
|
||||
void vhost_poll_queue(struct vhost_poll *poll);
|
||||
|
||||
struct vhost_log {
|
||||
u64 addr;
|
||||
u64 len;
|
||||
};
|
||||
|
||||
/* The virtqueue structure describes a queue attached to a device. */
|
||||
struct vhost_virtqueue {
|
||||
struct vhost_dev *dev;
|
||||
|
||||
/* The actual ring of buffers. */
|
||||
struct mutex mutex;
|
||||
unsigned int num;
|
||||
struct vring_desc __user *desc;
|
||||
struct vring_avail __user *avail;
|
||||
struct vring_used __user *used;
|
||||
struct file *kick;
|
||||
struct file *call;
|
||||
struct file *error;
|
||||
struct eventfd_ctx *call_ctx;
|
||||
struct eventfd_ctx *error_ctx;
|
||||
struct eventfd_ctx *log_ctx;
|
||||
|
||||
struct vhost_poll poll;
|
||||
|
||||
/* The routine to call when the Guest pings us, or timeout. */
|
||||
work_func_t handle_kick;
|
||||
|
||||
/* Last available index we saw. */
|
||||
u16 last_avail_idx;
|
||||
|
||||
/* Caches available index value from user. */
|
||||
u16 avail_idx;
|
||||
|
||||
/* Last index we used. */
|
||||
u16 last_used_idx;
|
||||
|
||||
/* Used flags */
|
||||
u16 used_flags;
|
||||
|
||||
/* Log writes to used structure. */
|
||||
bool log_used;
|
||||
u64 log_addr;
|
||||
|
||||
struct iovec indirect[VHOST_NET_MAX_SG];
|
||||
struct iovec iov[VHOST_NET_MAX_SG];
|
||||
struct iovec hdr[VHOST_NET_MAX_SG];
|
||||
size_t hdr_size;
|
||||
/* We use a kind of RCU to access private pointer.
|
||||
* All readers access it from workqueue, which makes it possible to
|
||||
* flush the workqueue instead of synchronize_rcu. Therefore readers do
|
||||
* not need to call rcu_read_lock/rcu_read_unlock: the beginning of
|
||||
* work item execution acts instead of rcu_read_lock() and the end of
|
||||
* work item execution acts instead of rcu_read_lock().
|
||||
* Writers use virtqueue mutex. */
|
||||
void *private_data;
|
||||
/* Log write descriptors */
|
||||
void __user *log_base;
|
||||
struct vhost_log log[VHOST_NET_MAX_SG];
|
||||
};
|
||||
|
||||
struct vhost_dev {
|
||||
/* Readers use RCU to access memory table pointer
|
||||
* log base pointer and features.
|
||||
* Writers use mutex below.*/
|
||||
struct vhost_memory *memory;
|
||||
struct mm_struct *mm;
|
||||
struct mutex mutex;
|
||||
unsigned acked_features;
|
||||
struct vhost_virtqueue *vqs;
|
||||
int nvqs;
|
||||
struct file *log_file;
|
||||
struct eventfd_ctx *log_ctx;
|
||||
};
|
||||
|
||||
long vhost_dev_init(struct vhost_dev *, struct vhost_virtqueue *vqs, int nvqs);
|
||||
long vhost_dev_check_owner(struct vhost_dev *);
|
||||
long vhost_dev_reset_owner(struct vhost_dev *);
|
||||
void vhost_dev_cleanup(struct vhost_dev *);
|
||||
long vhost_dev_ioctl(struct vhost_dev *, unsigned int ioctl, unsigned long arg);
|
||||
int vhost_vq_access_ok(struct vhost_virtqueue *vq);
|
||||
int vhost_log_access_ok(struct vhost_dev *);
|
||||
|
||||
unsigned vhost_get_vq_desc(struct vhost_dev *, struct vhost_virtqueue *,
|
||||
struct iovec iov[], unsigned int iov_count,
|
||||
unsigned int *out_num, unsigned int *in_num,
|
||||
struct vhost_log *log, unsigned int *log_num);
|
||||
void vhost_discard_vq_desc(struct vhost_virtqueue *);
|
||||
|
||||
int vhost_add_used(struct vhost_virtqueue *, unsigned int head, int len);
|
||||
void vhost_signal(struct vhost_dev *, struct vhost_virtqueue *);
|
||||
void vhost_add_used_and_signal(struct vhost_dev *, struct vhost_virtqueue *,
|
||||
unsigned int head, int len);
|
||||
void vhost_disable_notify(struct vhost_virtqueue *);
|
||||
bool vhost_enable_notify(struct vhost_virtqueue *);
|
||||
|
||||
int vhost_log_write(struct vhost_virtqueue *vq, struct vhost_log *log,
|
||||
unsigned int log_num, u64 len);
|
||||
|
||||
int vhost_init(void);
|
||||
void vhost_cleanup(void);
|
||||
|
||||
#define vq_err(vq, fmt, ...) do { \
|
||||
pr_debug(pr_fmt(fmt), ##__VA_ARGS__); \
|
||||
if ((vq)->error_ctx) \
|
||||
eventfd_signal((vq)->error_ctx, 1);\
|
||||
} while (0)
|
||||
|
||||
enum {
|
||||
VHOST_FEATURES = (1 << VIRTIO_F_NOTIFY_ON_EMPTY) |
|
||||
(1 << VIRTIO_RING_F_INDIRECT_DESC) |
|
||||
(1 << VHOST_F_LOG_ALL) |
|
||||
(1 << VHOST_NET_F_VIRTIO_NET_HDR),
|
||||
};
|
||||
|
||||
static inline int vhost_has_feature(struct vhost_dev *dev, int bit)
|
||||
{
|
||||
unsigned acked_features = rcu_dereference(dev->acked_features);
|
||||
return acked_features & (1 << bit);
|
||||
}
|
||||
|
||||
#endif
|
||||
|
|
@ -362,6 +362,7 @@ unifdef-y += uio.h
|
|||
unifdef-y += unistd.h
|
||||
unifdef-y += usbdevice_fs.h
|
||||
unifdef-y += utsname.h
|
||||
unifdef-y += vhost.h
|
||||
unifdef-y += videodev2.h
|
||||
unifdef-y += videodev.h
|
||||
unifdef-y += virtio_config.h
|
||||
|
|
|
|||
|
|
@ -30,6 +30,7 @@
|
|||
#define HPET_MINOR 228
|
||||
#define FUSE_MINOR 229
|
||||
#define KVM_MINOR 232
|
||||
#define VHOST_NET_MINOR 233
|
||||
#define MISC_DYNAMIC_MINOR 255
|
||||
|
||||
struct device;
|
||||
|
|
|
|||
|
|
@ -0,0 +1,130 @@
|
|||
#ifndef _LINUX_VHOST_H
|
||||
#define _LINUX_VHOST_H
|
||||
/* Userspace interface for in-kernel virtio accelerators. */
|
||||
|
||||
/* vhost is used to reduce the number of system calls involved in virtio.
|
||||
*
|
||||
* Existing virtio net code is used in the guest without modification.
|
||||
*
|
||||
* This header includes interface used by userspace hypervisor for
|
||||
* device configuration.
|
||||
*/
|
||||
|
||||
#include <linux/types.h>
|
||||
#include <linux/compiler.h>
|
||||
#include <linux/ioctl.h>
|
||||
#include <linux/virtio_config.h>
|
||||
#include <linux/virtio_ring.h>
|
||||
|
||||
struct vhost_vring_state {
|
||||
unsigned int index;
|
||||
unsigned int num;
|
||||
};
|
||||
|
||||
struct vhost_vring_file {
|
||||
unsigned int index;
|
||||
int fd; /* Pass -1 to unbind from file. */
|
||||
|
||||
};
|
||||
|
||||
struct vhost_vring_addr {
|
||||
unsigned int index;
|
||||
/* Option flags. */
|
||||
unsigned int flags;
|
||||
/* Flag values: */
|
||||
/* Whether log address is valid. If set enables logging. */
|
||||
#define VHOST_VRING_F_LOG 0
|
||||
|
||||
/* Start of array of descriptors (virtually contiguous) */
|
||||
__u64 desc_user_addr;
|
||||
/* Used structure address. Must be 32 bit aligned */
|
||||
__u64 used_user_addr;
|
||||
/* Available structure address. Must be 16 bit aligned */
|
||||
__u64 avail_user_addr;
|
||||
/* Logging support. */
|
||||
/* Log writes to used structure, at offset calculated from specified
|
||||
* address. Address must be 32 bit aligned. */
|
||||
__u64 log_guest_addr;
|
||||
};
|
||||
|
||||
struct vhost_memory_region {
|
||||
__u64 guest_phys_addr;
|
||||
__u64 memory_size; /* bytes */
|
||||
__u64 userspace_addr;
|
||||
__u64 flags_padding; /* No flags are currently specified. */
|
||||
};
|
||||
|
||||
/* All region addresses and sizes must be 4K aligned. */
|
||||
#define VHOST_PAGE_SIZE 0x1000
|
||||
|
||||
struct vhost_memory {
|
||||
__u32 nregions;
|
||||
__u32 padding;
|
||||
struct vhost_memory_region regions[0];
|
||||
};
|
||||
|
||||
/* ioctls */
|
||||
|
||||
#define VHOST_VIRTIO 0xAF
|
||||
|
||||
/* Features bitmask for forward compatibility. Transport bits are used for
|
||||
* vhost specific features. */
|
||||
#define VHOST_GET_FEATURES _IOR(VHOST_VIRTIO, 0x00, __u64)
|
||||
#define VHOST_SET_FEATURES _IOW(VHOST_VIRTIO, 0x00, __u64)
|
||||
|
||||
/* Set current process as the (exclusive) owner of this file descriptor. This
|
||||
* must be called before any other vhost command. Further calls to
|
||||
* VHOST_OWNER_SET fail until VHOST_OWNER_RESET is called. */
|
||||
#define VHOST_SET_OWNER _IO(VHOST_VIRTIO, 0x01)
|
||||
/* Give up ownership, and reset the device to default values.
|
||||
* Allows subsequent call to VHOST_OWNER_SET to succeed. */
|
||||
#define VHOST_RESET_OWNER _IO(VHOST_VIRTIO, 0x02)
|
||||
|
||||
/* Set up/modify memory layout */
|
||||
#define VHOST_SET_MEM_TABLE _IOW(VHOST_VIRTIO, 0x03, struct vhost_memory)
|
||||
|
||||
/* Write logging setup. */
|
||||
/* Memory writes can optionally be logged by setting bit at an offset
|
||||
* (calculated from the physical address) from specified log base.
|
||||
* The bit is set using an atomic 32 bit operation. */
|
||||
/* Set base address for logging. */
|
||||
#define VHOST_SET_LOG_BASE _IOW(VHOST_VIRTIO, 0x04, __u64)
|
||||
/* Specify an eventfd file descriptor to signal on log write. */
|
||||
#define VHOST_SET_LOG_FD _IOW(VHOST_VIRTIO, 0x07, int)
|
||||
|
||||
/* Ring setup. */
|
||||
/* Set number of descriptors in ring. This parameter can not
|
||||
* be modified while ring is running (bound to a device). */
|
||||
#define VHOST_SET_VRING_NUM _IOW(VHOST_VIRTIO, 0x10, struct vhost_vring_state)
|
||||
/* Set addresses for the ring. */
|
||||
#define VHOST_SET_VRING_ADDR _IOW(VHOST_VIRTIO, 0x11, struct vhost_vring_addr)
|
||||
/* Base value where queue looks for available descriptors */
|
||||
#define VHOST_SET_VRING_BASE _IOW(VHOST_VIRTIO, 0x12, struct vhost_vring_state)
|
||||
/* Get accessor: reads index, writes value in num */
|
||||
#define VHOST_GET_VRING_BASE _IOWR(VHOST_VIRTIO, 0x12, struct vhost_vring_state)
|
||||
|
||||
/* The following ioctls use eventfd file descriptors to signal and poll
|
||||
* for events. */
|
||||
|
||||
/* Set eventfd to poll for added buffers */
|
||||
#define VHOST_SET_VRING_KICK _IOW(VHOST_VIRTIO, 0x20, struct vhost_vring_file)
|
||||
/* Set eventfd to signal when buffers have beed used */
|
||||
#define VHOST_SET_VRING_CALL _IOW(VHOST_VIRTIO, 0x21, struct vhost_vring_file)
|
||||
/* Set eventfd to signal an error */
|
||||
#define VHOST_SET_VRING_ERR _IOW(VHOST_VIRTIO, 0x22, struct vhost_vring_file)
|
||||
|
||||
/* VHOST_NET specific defines */
|
||||
|
||||
/* Attach virtio net ring to a raw socket, or tap device.
|
||||
* The socket must be already bound to an ethernet device, this device will be
|
||||
* used for transmit. Pass fd -1 to unbind from the socket and the transmit
|
||||
* device. This can be used to stop the ring (e.g. for migration). */
|
||||
#define VHOST_NET_SET_BACKEND _IOW(VHOST_VIRTIO, 0x30, struct vhost_vring_file)
|
||||
|
||||
/* Feature bits */
|
||||
/* Log all write descriptors. Can be changed while device is active. */
|
||||
#define VHOST_F_LOG_ALL 26
|
||||
/* vhost-net should add virtio_net_hdr for RX, and strip for TX packets. */
|
||||
#define VHOST_NET_F_VIRTIO_NET_HDR 27
|
||||
|
||||
#endif
|
||||
Loading…
Reference in New Issue