Something went wrong. Try again.
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
Something went wrong. Try again.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380// SPDX-License-Identifier: GPL-2.0-only/* Copyright (C) 2009 Red Hat, Inc. * Author: Michael S. Tsirkin <mst@redhat.com> * * test virtio server in host kernel. */
#include <linux/compat.h>#include <linux/eventfd.h>#include <linux/vhost.h>#include <linux/miscdevice.h>#include <linux/module.h>#include <linux/mutex.h>#include <linux/workqueue.h>#include <linux/file.h>#include <linux/slab.h>
#include "test.h"#include "vhost.h"
/* Max number of bytes transferred before requeueing the job. * Using this limit prevents one virtqueue from starving others. */#define VHOST_TEST_WEIGHT 0x80000
/* Max number of packets transferred before requeueing the job. * Using this limit prevents one virtqueue from starving others with * pkts. */#define VHOST_TEST_PKT_WEIGHT 256
static const int vhost_test_bits[] = { VHOST_FEATURES};
#define VHOST_TEST_FEATURES VHOST_FEATURES_U64(vhost_test_bits, 0)
enum { VHOST_TEST_VQ = 0, VHOST_TEST_VQ_MAX = 1,};
struct vhost_test { struct vhost_dev dev; struct vhost_virtqueue vqs[VHOST_TEST_VQ_MAX];};
/* Expects to be always run from workqueue - which acts as * read-size critical section for our kind of RCU. */static void handle_vq(struct vhost_test *n){ struct vhost_virtqueue *vq = &n->vqs[VHOST_TEST_VQ]; unsigned out, in; int head; size_t len, total_len = 0; void *private;
mutex_lock(&vq->mutex); private = vhost_vq_get_backend(vq); if (!private) { mutex_unlock(&vq->mutex); return; }
vhost_disable_notify(&n->dev, vq);
for (;;) { head = vhost_get_vq_desc(vq, vq->iov, ARRAY_SIZE(vq->iov), &out, &in, NULL, NULL); /* On error, stop handling until the next kick. */ if (unlikely(head < 0)) break; /* Nothing new? Wait for eventfd to tell us they refilled. */ if (head == vq->num) { if (unlikely(vhost_enable_notify(&n->dev, vq))) { vhost_disable_notify(&n->dev, vq); continue; } break; } if (in) { vq_err(vq, "Unexpected descriptor format for TX: " "out %d, int %d\n", out, in); break; } len = iov_length(vq->iov, out); /* Sanity check */ if (!len) { vq_err(vq, "Unexpected 0 len for TX\n"); break; } vhost_add_used_and_signal(&n->dev, vq, head, 0); total_len += len; if (unlikely(vhost_exceeds_weight(vq, 0, total_len))) break; }
mutex_unlock(&vq->mutex);}
static void handle_vq_kick(struct vhost_work *work){ struct vhost_virtqueue *vq = container_of(work, struct vhost_virtqueue, poll.work); struct vhost_test *n = container_of(vq->dev, struct vhost_test, dev);
handle_vq(n);}
static int vhost_test_open(struct inode *inode, struct file *f){ struct vhost_test *n = kmalloc_obj(*n); struct vhost_dev *dev; struct vhost_virtqueue **vqs;
if (!n) return -ENOMEM; vqs = kmalloc_objs(*vqs, VHOST_TEST_VQ_MAX); if (!vqs) { kfree(n); return -ENOMEM; }
dev = &n->dev; vqs[VHOST_TEST_VQ] = &n->vqs[VHOST_TEST_VQ]; n->vqs[VHOST_TEST_VQ].handle_kick = handle_vq_kick; vhost_dev_init(dev, vqs, VHOST_TEST_VQ_MAX, UIO_MAXIOV, VHOST_TEST_PKT_WEIGHT, VHOST_TEST_WEIGHT, true, NULL);
f->private_data = n;
return 0;}
static void *vhost_test_stop_vq(struct vhost_test *n, struct vhost_virtqueue *vq){ void *private;
mutex_lock(&vq->mutex); private = vhost_vq_get_backend(vq); vhost_vq_set_backend(vq, NULL); mutex_unlock(&vq->mutex); return private;}
static void vhost_test_stop(struct vhost_test *n, void **privatep){ *privatep = vhost_test_stop_vq(n, n->vqs + VHOST_TEST_VQ);}
static void vhost_test_flush(struct vhost_test *n){ vhost_dev_flush(&n->dev);}
static int vhost_test_release(struct inode *inode, struct file *f){ struct vhost_test *n = f->private_data; void *private;
vhost_test_stop(n, &private); vhost_test_flush(n); vhost_dev_stop(&n->dev); vhost_dev_cleanup(&n->dev); kfree(n->dev.vqs); kfree(n); return 0;}
static long vhost_test_run(struct vhost_test *n, int test){ void *priv, *oldpriv; struct vhost_virtqueue *vq; int r, index;
if (test < 0 || test > 1) return -EINVAL;
mutex_lock(&n->dev.mutex); r = vhost_dev_check_owner(&n->dev); if (r) goto err;
for (index = 0; index < n->dev.nvqs; ++index) { /* Verify that ring has been setup correctly. */ if (!vhost_vq_access_ok(&n->vqs[index])) { r = -EFAULT; goto err; } }
for (index = 0; index < n->dev.nvqs; ++index) { vq = n->vqs + index; mutex_lock(&vq->mutex); priv = test ? n : NULL;
/* start polling new socket */ oldpriv = vhost_vq_get_backend(vq); vhost_vq_set_backend(vq, priv);
r = vhost_vq_init_access(&n->vqs[index]);
mutex_unlock(&vq->mutex);
if (r) goto err;
if (oldpriv) { vhost_test_flush(n); } }
mutex_unlock(&n->dev.mutex); return 0;
err: mutex_unlock(&n->dev.mutex); return r;}
static long vhost_test_reset_owner(struct vhost_test *n){ void *priv = NULL; long err; struct vhost_iotlb *umem;
mutex_lock(&n->dev.mutex); err = vhost_dev_check_owner(&n->dev); if (err) goto done; umem = vhost_dev_reset_owner_prepare(); if (!umem) { err = -ENOMEM; goto done; } vhost_test_stop(n, &priv); vhost_test_flush(n); vhost_dev_stop(&n->dev); vhost_dev_reset_owner(&n->dev, umem);done: mutex_unlock(&n->dev.mutex); return err;}
static int vhost_test_set_features(struct vhost_test *n, u64 features){ struct vhost_virtqueue *vq;
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; } vq = &n->vqs[VHOST_TEST_VQ]; mutex_lock(&vq->mutex); vq->acked_features = features; mutex_unlock(&vq->mutex); mutex_unlock(&n->dev.mutex); return 0;}
static long vhost_test_set_backend(struct vhost_test *n, unsigned index, int fd){ static void *backend;
const bool enable = fd != -1; 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_TEST_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_vq; } if (!enable) { vhost_poll_stop(&vq->poll); backend = vhost_vq_get_backend(vq); vhost_vq_set_backend(vq, NULL); } else { vhost_vq_set_backend(vq, backend); r = vhost_vq_init_access(vq); if (r == 0) r = vhost_poll_start(&vq->poll, vq->kick); }
mutex_unlock(&vq->mutex);
if (enable) { vhost_test_flush(n); }
mutex_unlock(&n->dev.mutex); return 0;
err_vq: mutex_unlock(&vq->mutex);err: mutex_unlock(&n->dev.mutex); return r;}
static long vhost_test_ioctl(struct file *f, unsigned int ioctl, unsigned long arg){ struct vhost_vring_file backend; struct vhost_test *n = f->private_data; void __user *argp = (void __user *)arg; u64 __user *featurep = argp; int test; u64 features; int r; switch (ioctl) { case VHOST_TEST_RUN: if (copy_from_user(&test, argp, sizeof test)) return -EFAULT; return vhost_test_run(n, test); case VHOST_TEST_SET_BACKEND: if (copy_from_user(&backend, argp, sizeof backend)) return -EFAULT; return vhost_test_set_backend(n, backend.index, backend.fd); case VHOST_GET_FEATURES: features = VHOST_TEST_FEATURES; if (copy_to_user(featurep, &features, sizeof features)) return -EFAULT; return 0; case VHOST_SET_FEATURES: if (copy_from_user(&features, featurep, sizeof features)) return -EFAULT; if (features & ~VHOST_TEST_FEATURES) return -EOPNOTSUPP; return vhost_test_set_features(n, features); case VHOST_RESET_OWNER: return vhost_test_reset_owner(n); default: mutex_lock(&n->dev.mutex); r = vhost_dev_ioctl(&n->dev, ioctl, argp); if (r == -ENOIOCTLCMD) r = vhost_vring_ioctl(&n->dev, ioctl, argp); vhost_test_flush(n); mutex_unlock(&n->dev.mutex); return r; }}
static const struct file_operations vhost_test_fops = { .owner = THIS_MODULE, .release = vhost_test_release, .unlocked_ioctl = vhost_test_ioctl, .compat_ioctl = compat_ptr_ioctl, .open = vhost_test_open, .llseek = noop_llseek,};
static struct miscdevice vhost_test_misc = { MISC_DYNAMIC_MINOR, "vhost-test", &vhost_test_fops,};module_misc_device(vhost_test_misc);
MODULE_VERSION("0.0.1");MODULE_LICENSE("GPL v2");MODULE_AUTHOR("Michael S. Tsirkin");MODULE_DESCRIPTION("Host kernel side for virtio simulator");