1 // SPDX-License-Identifier: GPL-2.0
7 #include <sys/eventfd.h>
11 #include <sys/ioctl.h>
13 #include <sys/types.h>
16 #include <linux/virtio_types.h>
17 #include <linux/vhost.h>
18 #include <linux/virtio.h>
19 #include <linux/virtio_ring.h>
20 #include "../../drivers/vhost/test.h"
22 #define RANDOM_BATCH -1
25 void *__kmalloc_fake, *__kfree_ignore_start, *__kfree_ignore_end;
33 /* copy used for control */
39 struct virtio_device vdev;
42 struct vq_info vqs[1];
46 struct vhost_memory *mem;
49 static const struct vhost_vring_file no_backend = { .fd = -1 },
50 backend = { .fd = 1 };
51 static const struct vhost_vring_state null_state = {};
53 bool vq_notify(struct virtqueue *vq)
55 struct vq_info *info = vq->priv;
56 unsigned long long v = 1;
58 r = write(info->kick, &v, sizeof v);
59 assert(r == sizeof v);
63 void vq_callback(struct virtqueue *vq)
68 void vhost_vq_setup(struct vdev_info *dev, struct vq_info *info)
70 struct vhost_vring_state state = { .index = info->idx };
71 struct vhost_vring_file file = { .index = info->idx };
72 unsigned long long features = dev->vdev.features;
73 struct vhost_vring_addr addr = {
75 .desc_user_addr = (uint64_t)(unsigned long)info->vring.desc,
76 .avail_user_addr = (uint64_t)(unsigned long)info->vring.avail,
77 .used_user_addr = (uint64_t)(unsigned long)info->vring.used,
80 r = ioctl(dev->control, VHOST_SET_FEATURES, &features);
82 state.num = info->vring.num;
83 r = ioctl(dev->control, VHOST_SET_VRING_NUM, &state);
86 r = ioctl(dev->control, VHOST_SET_VRING_BASE, &state);
88 r = ioctl(dev->control, VHOST_SET_VRING_ADDR, &addr);
91 r = ioctl(dev->control, VHOST_SET_VRING_KICK, &file);
94 r = ioctl(dev->control, VHOST_SET_VRING_CALL, &file);
98 static void vq_reset(struct vq_info *info, int num, struct virtio_device *vdev)
101 vring_del_virtqueue(info->vq);
103 memset(info->ring, 0, vring_size(num, 4096));
104 vring_init(&info->vring, num, info->ring, 4096);
105 info->vq = __vring_new_virtqueue(info->idx, info->vring, vdev, true,
106 false, vq_notify, vq_callback, "test");
108 info->vq->priv = info;
111 static void vq_info_add(struct vdev_info *dev, int num)
113 struct vq_info *info = &dev->vqs[dev->nvqs];
115 info->idx = dev->nvqs;
116 info->kick = eventfd(0, EFD_NONBLOCK);
117 info->call = eventfd(0, EFD_NONBLOCK);
118 r = posix_memalign(&info->ring, 4096, vring_size(num, 4096));
120 vq_reset(info, num, &dev->vdev);
121 vhost_vq_setup(dev, info);
122 dev->fds[info->idx].fd = info->call;
123 dev->fds[info->idx].events = POLLIN;
127 static void vdev_info_init(struct vdev_info* dev, unsigned long long features)
130 memset(dev, 0, sizeof *dev);
131 dev->vdev.features = features;
132 INIT_LIST_HEAD(&dev->vdev.vqs);
133 dev->buf_size = 1024;
134 dev->buf = malloc(dev->buf_size);
136 dev->control = open("/dev/vhost-test", O_RDWR);
137 assert(dev->control >= 0);
138 r = ioctl(dev->control, VHOST_SET_OWNER, NULL);
140 dev->mem = malloc(offsetof(struct vhost_memory, regions) +
141 sizeof dev->mem->regions[0]);
143 memset(dev->mem, 0, offsetof(struct vhost_memory, regions) +
144 sizeof dev->mem->regions[0]);
145 dev->mem->nregions = 1;
146 dev->mem->regions[0].guest_phys_addr = (long)dev->buf;
147 dev->mem->regions[0].userspace_addr = (long)dev->buf;
148 dev->mem->regions[0].memory_size = dev->buf_size;
149 r = ioctl(dev->control, VHOST_SET_MEM_TABLE, dev->mem);
153 /* TODO: this is pretty bad: we get a cache line bounce
154 * for the wait queue on poll and another one on read,
155 * plus the read which is there just to clear the
157 static void wait_for_interrupt(struct vdev_info *dev)
160 unsigned long long val;
161 poll(dev->fds, dev->nvqs, -1);
162 for (i = 0; i < dev->nvqs; ++i)
163 if (dev->fds[i].revents & POLLIN) {
164 read(dev->fds[i].fd, &val, sizeof val);
168 static void run_test(struct vdev_info *dev, struct vq_info *vq,
169 bool delayed, int batch, int reset_n, int bufs)
171 struct scatterlist sl;
172 long started = 0, completed = 0, next_reset = reset_n;
173 long completed_before, started_before;
176 long long spurious = 0;
177 const bool random_batch = batch == RANDOM_BATCH;
179 r = ioctl(dev->control, VHOST_TEST_RUN, &test);
182 next_reset = INT_MAX;
186 virtqueue_disable_cb(vq->vq);
187 completed_before = completed;
188 started_before = started;
190 const bool reset = completed > next_reset;
192 batch = (random() % vq->vring.num) + 1;
194 while (started < bufs &&
195 (started - completed) < batch) {
196 sg_init_one(&sl, dev->buf, dev->buf_size);
197 r = virtqueue_add_outbuf(vq->vq, &sl, 1,
200 if (unlikely(r != 0)) {
202 started > started_before)
211 if (unlikely(!virtqueue_kick(vq->vq))) {
221 r = ioctl(dev->control, VHOST_TEST_SET_BACKEND,
226 /* Flush out completed bufs if any */
227 while (virtqueue_get_buf(vq->vq, &len)) {
233 struct vhost_vring_state s = { .index = 0 };
235 vq_reset(vq, vq->vring.num, &dev->vdev);
237 r = ioctl(dev->control, VHOST_GET_VRING_BASE,
242 r = ioctl(dev->control, VHOST_SET_VRING_BASE,
246 r = ioctl(dev->control, VHOST_TEST_SET_BACKEND,
251 while (completed > next_reset)
252 next_reset += completed;
255 if (completed == completed_before && started == started_before)
257 assert(completed <= bufs);
258 assert(started <= bufs);
259 if (completed == bufs)
262 if (virtqueue_enable_cb_delayed(vq->vq))
263 wait_for_interrupt(dev);
265 if (virtqueue_enable_cb(vq->vq))
266 wait_for_interrupt(dev);
270 r = ioctl(dev->control, VHOST_TEST_RUN, &test);
273 "spurious wakeups: 0x%llx started=0x%lx completed=0x%lx\n",
274 spurious, started, completed);
277 const char optstring[] = "h";
278 const struct option longopts[] = {
288 .name = "no-event-idx",
296 .name = "no-indirect",
304 .name = "no-virtio-1",
308 .name = "delayed-interrupt",
312 .name = "no-delayed-interrupt",
318 .has_arg = required_argument,
323 .has_arg = optional_argument,
329 static void help(void)
331 fprintf(stderr, "Usage: virtio_test [--help]"
335 " [--delayed-interrupt]"
336 " [--batch=random/N]"
341 int main(int argc, char **argv)
343 struct vdev_info dev;
344 unsigned long long features = (1ULL << VIRTIO_RING_F_INDIRECT_DESC) |
345 (1ULL << VIRTIO_RING_F_EVENT_IDX) | (1ULL << VIRTIO_F_VERSION_1);
346 long batch = 1, reset = 0;
348 bool delayed = false;
351 o = getopt_long(argc, argv, optstring, longopts, NULL);
359 features &= ~(1ULL << VIRTIO_RING_F_EVENT_IDX);
365 features &= ~(1ULL << VIRTIO_RING_F_INDIRECT_DESC);
368 features &= ~(1ULL << VIRTIO_F_VERSION_1);
374 if (0 == strcmp(optarg, "random")) {
375 batch = RANDOM_BATCH;
377 batch = strtol(optarg, NULL, 10);
379 assert(batch < (long)INT_MAX + 1);
386 reset = strtol(optarg, NULL, 10);
388 assert(reset < (long)INT_MAX + 1);
398 vdev_info_init(&dev, features);
399 vq_info_add(&dev, 256);
400 run_test(&dev, &dev.vqs[0], delayed, batch, reset, 0x100000);