]> git.proxmox.com Git - mirror_qemu.git/blame - tests/vhost-user-test.c
test-cutils: Add missing qemu_strtol()... endptr checks
[mirror_qemu.git] / tests / vhost-user-test.c
CommitLineData
a77e6b14
NN
1/*
2 * QTest testcase for the vhost-user
3 *
4 * Copyright (c) 2014 Virtual Open Systems Sarl.
5 *
6 * This work is licensed under the terms of the GNU GPL, version 2 or later.
7 * See the COPYING file in the top-level directory.
8 *
9 */
10
681c28a3 11#include "qemu/osdep.h"
bd95939f 12
a77e6b14 13#include "libqtest.h"
5345fdb4 14#include "qapi/error.h"
213dcb06 15#include "qemu/config-file.h"
a77e6b14 16#include "qemu/option.h"
b1819747 17#include "qemu/range.h"
a9c94277 18#include "qemu/sockets.h"
a77e6b14
NN
19#include "sysemu/char.h"
20#include "sysemu/sysemu.h"
cdafe929
EH
21#include "libqos/libqos.h"
22#include "libqos/pci-pc.h"
23#include "libqos/virtio-pci.h"
32a6ebec 24#include "qapi/error.h"
a77e6b14 25
ed0a8d92
MAL
26#include "libqos/malloc-pc.h"
27#include "hw/virtio/virtio-net.h"
28
a77e6b14 29#include <linux/vhost.h>
cdafe929
EH
30#include <linux/virtio_ids.h>
31#include <linux/virtio_net.h>
a77e6b14 32#include <sys/vfs.h>
a77e6b14 33
30de46db
GA
34/* GLIB version compatibility flags */
35#if !GLIB_CHECK_VERSION(2, 26, 0)
36#define G_TIME_SPAN_SECOND (G_GINT64_CONSTANT(1000000))
37#endif
38
39#if GLIB_CHECK_VERSION(2, 28, 0)
40#define HAVE_MONOTONIC_TIME
41#endif
42
704b2168 43#define QEMU_CMD_MEM " -m %d -object memory-backend-file,id=mem,size=%dM,"\
a77e6b14 44 "mem-path=%s,share=on -numa node,memdev=mem"
4616e359 45#define QEMU_CMD_CHR " -chardev socket,id=%s,path=%s%s"
704b2168 46#define QEMU_CMD_NETDEV " -netdev vhost-user,id=net0,chardev=%s,vhostforce"
cdafe929 47#define QEMU_CMD_NET " -device virtio-net-pci,netdev=net0"
a77e6b14 48
cdafe929 49#define QEMU_CMD QEMU_CMD_MEM QEMU_CMD_CHR \
b5c6eaf1 50 QEMU_CMD_NETDEV QEMU_CMD_NET
a77e6b14
NN
51
52#define HUGETLBFS_MAGIC 0x958458f6
53
54/*********** FROM hw/virtio/vhost-user.c *************************************/
55
56#define VHOST_MEMORY_MAX_NREGIONS 8
57
8a9b6b37 58#define VHOST_USER_F_PROTOCOL_FEATURES 30
ed0a8d92 59#define VHOST_USER_PROTOCOL_F_MQ 0
b1819747
MAL
60#define VHOST_USER_PROTOCOL_F_LOG_SHMFD 1
61
62#define VHOST_LOG_PAGE 0x1000
8a9b6b37 63
a77e6b14
NN
64typedef enum VhostUserRequest {
65 VHOST_USER_NONE = 0,
66 VHOST_USER_GET_FEATURES = 1,
67 VHOST_USER_SET_FEATURES = 2,
68 VHOST_USER_SET_OWNER = 3,
60915dc4 69 VHOST_USER_RESET_OWNER = 4,
a77e6b14
NN
70 VHOST_USER_SET_MEM_TABLE = 5,
71 VHOST_USER_SET_LOG_BASE = 6,
72 VHOST_USER_SET_LOG_FD = 7,
73 VHOST_USER_SET_VRING_NUM = 8,
74 VHOST_USER_SET_VRING_ADDR = 9,
75 VHOST_USER_SET_VRING_BASE = 10,
76 VHOST_USER_GET_VRING_BASE = 11,
77 VHOST_USER_SET_VRING_KICK = 12,
78 VHOST_USER_SET_VRING_CALL = 13,
79 VHOST_USER_SET_VRING_ERR = 14,
8a9b6b37
MT
80 VHOST_USER_GET_PROTOCOL_FEATURES = 15,
81 VHOST_USER_SET_PROTOCOL_FEATURES = 16,
ed0a8d92 82 VHOST_USER_GET_QUEUE_NUM = 17,
87656d50 83 VHOST_USER_SET_VRING_ENABLE = 18,
a77e6b14
NN
84 VHOST_USER_MAX
85} VhostUserRequest;
86
87typedef struct VhostUserMemoryRegion {
88 uint64_t guest_phys_addr;
89 uint64_t memory_size;
90 uint64_t userspace_addr;
d6970e3b 91 uint64_t mmap_offset;
a77e6b14
NN
92} VhostUserMemoryRegion;
93
94typedef struct VhostUserMemory {
95 uint32_t nregions;
96 uint32_t padding;
97 VhostUserMemoryRegion regions[VHOST_MEMORY_MAX_NREGIONS];
98} VhostUserMemory;
99
2b8819c6
VK
100typedef struct VhostUserLog {
101 uint64_t mmap_size;
102 uint64_t mmap_offset;
103} VhostUserLog;
104
a77e6b14
NN
105typedef struct VhostUserMsg {
106 VhostUserRequest request;
107
108#define VHOST_USER_VERSION_MASK (0x3)
109#define VHOST_USER_REPLY_MASK (0x1<<2)
110 uint32_t flags;
111 uint32_t size; /* the following payload size */
112 union {
2b8819c6
VK
113#define VHOST_USER_VRING_IDX_MASK (0xff)
114#define VHOST_USER_VRING_NOFD_MASK (0x1<<8)
a77e6b14
NN
115 uint64_t u64;
116 struct vhost_vring_state state;
117 struct vhost_vring_addr addr;
118 VhostUserMemory memory;
2b8819c6 119 VhostUserLog log;
12ebf690 120 } payload;
a77e6b14
NN
121} QEMU_PACKED VhostUserMsg;
122
123static VhostUserMsg m __attribute__ ((unused));
124#define VHOST_USER_HDR_SIZE (sizeof(m.request) \
125 + sizeof(m.flags) \
126 + sizeof(m.size))
127
128#define VHOST_USER_PAYLOAD_SIZE (sizeof(m) - VHOST_USER_HDR_SIZE)
129
130/* The version of the protocol we support */
131#define VHOST_USER_VERSION (0x1)
132/*****************************************************************************/
133
9294d76c
MAL
134enum {
135 TEST_FLAGS_OK,
136 TEST_FLAGS_DISCONNECT,
137 TEST_FLAGS_BAD,
138 TEST_FLAGS_END,
139};
140
ae31fb54
MAL
141typedef struct TestServer {
142 gchar *socket_path;
a899b1ea 143 gchar *mig_path;
ae31fb54 144 gchar *chr_name;
32a6ebec 145 CharBackend chr;
ae31fb54
MAL
146 int fds_num;
147 int fds[VHOST_MEMORY_MAX_NREGIONS];
148 VhostUserMemory memory;
634d39b4
PB
149 CompatGMutex data_mutex;
150 CompatGCond data_cond;
b1819747 151 int log_fd;
d08e42a1 152 uint64_t rings;
5d443f5a 153 bool test_fail;
9294d76c 154 int test_flags;
ed0a8d92 155 int queues;
ae31fb54 156} TestServer;
bd95939f 157
704b2168
MAL
158static const char *tmpfs;
159static const char *root;
160
cdafe929
EH
161static void init_virtio_dev(TestServer *s)
162{
163 QPCIBus *bus;
164 QVirtioPCIDevice *dev;
165 uint32_t features;
166
2ecd7e2f 167 bus = qpci_init_pc(NULL);
cdafe929
EH
168 g_assert_nonnull(bus);
169
170 dev = qvirtio_pci_device_find(bus, VIRTIO_ID_NET);
171 g_assert_nonnull(dev);
172
173 qvirtio_pci_device_enable(dev);
6b9cdf4c
LV
174 qvirtio_reset(&dev->vdev);
175 qvirtio_set_acknowledge(&dev->vdev);
176 qvirtio_set_driver(&dev->vdev);
cdafe929 177
6b9cdf4c 178 features = qvirtio_get_features(&dev->vdev);
cdafe929 179 features = features & VIRTIO_NET_F_MAC;
6b9cdf4c 180 qvirtio_set_features(&dev->vdev, features);
cdafe929 181
6b9cdf4c 182 qvirtio_set_driver_ok(&dev->vdev);
cdafe929
EH
183}
184
ae31fb54 185static void wait_for_fds(TestServer *s)
a77e6b14 186{
a77e6b14 187 gint64 end_time;
a77e6b14 188
ae31fb54 189 g_mutex_lock(&s->data_mutex);
a77e6b14 190
ca06d9cc 191 end_time = g_get_monotonic_time() + 5 * G_TIME_SPAN_SECOND;
ae31fb54
MAL
192 while (!s->fds_num) {
193 if (!g_cond_wait_until(&s->data_cond, &s->data_mutex, end_time)) {
a77e6b14 194 /* timeout has passed */
ae31fb54 195 g_assert(s->fds_num);
a77e6b14
NN
196 break;
197 }
198 }
199
200 /* check for sanity */
ae31fb54
MAL
201 g_assert_cmpint(s->fds_num, >, 0);
202 g_assert_cmpint(s->fds_num, ==, s->memory.nregions);
a77e6b14 203
ae31fb54 204 g_mutex_unlock(&s->data_mutex);
cf72b57f
MAL
205}
206
041088c7 207static void read_guest_mem(const void *data)
cf72b57f 208{
041088c7 209 TestServer *s = (void *)data;
cf72b57f
MAL
210 uint32_t *guest_mem;
211 int i, j;
212 size_t size;
213
ae31fb54 214 wait_for_fds(s);
cf72b57f 215
ae31fb54 216 g_mutex_lock(&s->data_mutex);
cf72b57f 217
a77e6b14 218 /* iterate all regions */
ae31fb54 219 for (i = 0; i < s->fds_num; i++) {
a77e6b14
NN
220
221 /* We'll check only the region statring at 0x0*/
ae31fb54 222 if (s->memory.regions[i].guest_phys_addr != 0x0) {
a77e6b14
NN
223 continue;
224 }
225
ae31fb54 226 g_assert_cmpint(s->memory.regions[i].memory_size, >, 1024);
a77e6b14 227
ae31fb54
MAL
228 size = s->memory.regions[i].memory_size +
229 s->memory.regions[i].mmap_offset;
d6970e3b
NN
230
231 guest_mem = mmap(0, size, PROT_READ | PROT_WRITE,
ae31fb54 232 MAP_SHARED, s->fds[i], 0);
d6970e3b
NN
233
234 g_assert(guest_mem != MAP_FAILED);
ae31fb54 235 guest_mem += (s->memory.regions[i].mmap_offset / sizeof(*guest_mem));
a77e6b14
NN
236
237 for (j = 0; j < 256; j++) {
ae31fb54 238 uint32_t a = readl(s->memory.regions[i].guest_phys_addr + j*4);
a77e6b14
NN
239 uint32_t b = guest_mem[j];
240
241 g_assert_cmpint(a, ==, b);
242 }
243
ae31fb54 244 munmap(guest_mem, s->memory.regions[i].memory_size);
a77e6b14
NN
245 }
246
ae31fb54 247 g_mutex_unlock(&s->data_mutex);
a77e6b14
NN
248}
249
250static void *thread_function(void *data)
251{
9732baf6 252 GMainLoop *loop = data;
a77e6b14
NN
253 g_main_loop_run(loop);
254 return NULL;
255}
256
257static int chr_can_read(void *opaque)
258{
259 return VHOST_USER_HDR_SIZE;
260}
261
262static void chr_read(void *opaque, const uint8_t *buf, int size)
263{
ae31fb54 264 TestServer *s = opaque;
32a6ebec 265 CharBackend *chr = &s->chr;
a77e6b14
NN
266 VhostUserMsg msg;
267 uint8_t *p = (uint8_t *) &msg;
268 int fd;
269
5d443f5a 270 if (s->test_fail) {
5345fdb4 271 qemu_chr_fe_disconnect(chr);
5d443f5a
MAL
272 /* now switch to non-failure */
273 s->test_fail = false;
274 }
275
a77e6b14
NN
276 if (size != VHOST_USER_HDR_SIZE) {
277 g_test_message("Wrong message size received %d\n", size);
278 return;
279 }
280
ae31fb54 281 g_mutex_lock(&s->data_mutex);
a77e6b14
NN
282 memcpy(p, buf, VHOST_USER_HDR_SIZE);
283
284 if (msg.size) {
285 p += VHOST_USER_HDR_SIZE;
5345fdb4 286 size = qemu_chr_fe_read_all(chr, p, msg.size);
4616e359
MAL
287 if (size != msg.size) {
288 g_test_message("Wrong message size received %d != %d\n",
289 size, msg.size);
290 return;
291 }
a77e6b14
NN
292 }
293
294 switch (msg.request) {
295 case VHOST_USER_GET_FEATURES:
8a9b6b37
MT
296 /* send back features to qemu */
297 msg.flags |= VHOST_USER_REPLY_MASK;
12ebf690
MT
298 msg.size = sizeof(m.payload.u64);
299 msg.payload.u64 = 0x1ULL << VHOST_F_LOG_ALL |
b1819747 300 0x1ULL << VHOST_USER_F_PROTOCOL_FEATURES;
ed0a8d92
MAL
301 if (s->queues > 1) {
302 msg.payload.u64 |= 0x1ULL << VIRTIO_NET_F_MQ;
303 }
9294d76c
MAL
304 if (s->test_flags >= TEST_FLAGS_BAD) {
305 msg.payload.u64 = 0;
306 s->test_flags = TEST_FLAGS_END;
307 }
8a9b6b37 308 p = (uint8_t *) &msg;
5345fdb4 309 qemu_chr_fe_write_all(chr, p, VHOST_USER_HDR_SIZE + msg.size);
8a9b6b37
MT
310 break;
311
312 case VHOST_USER_SET_FEATURES:
12ebf690 313 g_assert_cmpint(msg.payload.u64 & (0x1ULL << VHOST_USER_F_PROTOCOL_FEATURES),
8a9b6b37 314 !=, 0ULL);
9294d76c 315 if (s->test_flags == TEST_FLAGS_DISCONNECT) {
5345fdb4 316 qemu_chr_fe_disconnect(chr);
9294d76c
MAL
317 s->test_flags = TEST_FLAGS_BAD;
318 }
8a9b6b37
MT
319 break;
320
321 case VHOST_USER_GET_PROTOCOL_FEATURES:
a77e6b14
NN
322 /* send back features to qemu */
323 msg.flags |= VHOST_USER_REPLY_MASK;
12ebf690
MT
324 msg.size = sizeof(m.payload.u64);
325 msg.payload.u64 = 1 << VHOST_USER_PROTOCOL_F_LOG_SHMFD;
ed0a8d92
MAL
326 if (s->queues > 1) {
327 msg.payload.u64 |= 1 << VHOST_USER_PROTOCOL_F_MQ;
328 }
a77e6b14 329 p = (uint8_t *) &msg;
5345fdb4 330 qemu_chr_fe_write_all(chr, p, VHOST_USER_HDR_SIZE + msg.size);
a77e6b14
NN
331 break;
332
333 case VHOST_USER_GET_VRING_BASE:
334 /* send back vring base to qemu */
335 msg.flags |= VHOST_USER_REPLY_MASK;
12ebf690
MT
336 msg.size = sizeof(m.payload.state);
337 msg.payload.state.num = 0;
a77e6b14 338 p = (uint8_t *) &msg;
5345fdb4 339 qemu_chr_fe_write_all(chr, p, VHOST_USER_HDR_SIZE + msg.size);
d08e42a1 340
ed0a8d92 341 assert(msg.payload.state.index < s->queues * 2);
d08e42a1 342 s->rings &= ~(0x1ULL << msg.payload.state.index);
a77e6b14
NN
343 break;
344
345 case VHOST_USER_SET_MEM_TABLE:
346 /* received the mem table */
12ebf690 347 memcpy(&s->memory, &msg.payload.memory, sizeof(msg.payload.memory));
5345fdb4 348 s->fds_num = qemu_chr_fe_get_msgfds(chr, s->fds,
32a6ebec 349 G_N_ELEMENTS(s->fds));
a77e6b14
NN
350
351 /* signal the test that it can continue */
ae31fb54 352 g_cond_signal(&s->data_cond);
a77e6b14
NN
353 break;
354
355 case VHOST_USER_SET_VRING_KICK:
356 case VHOST_USER_SET_VRING_CALL:
357 /* consume the fd */
5345fdb4 358 qemu_chr_fe_get_msgfds(chr, &fd, 1);
a77e6b14
NN
359 /*
360 * This is a non-blocking eventfd.
361 * The receive function forces it to be blocking,
362 * so revert it back to non-blocking.
363 */
364 qemu_set_nonblock(fd);
365 break;
b1819747
MAL
366
367 case VHOST_USER_SET_LOG_BASE:
368 if (s->log_fd != -1) {
369 close(s->log_fd);
370 s->log_fd = -1;
371 }
5345fdb4 372 qemu_chr_fe_get_msgfds(chr, &s->log_fd, 1);
b1819747
MAL
373 msg.flags |= VHOST_USER_REPLY_MASK;
374 msg.size = 0;
375 p = (uint8_t *) &msg;
5345fdb4 376 qemu_chr_fe_write_all(chr, p, VHOST_USER_HDR_SIZE);
b1819747
MAL
377
378 g_cond_signal(&s->data_cond);
379 break;
380
d08e42a1 381 case VHOST_USER_SET_VRING_BASE:
ed0a8d92 382 assert(msg.payload.state.index < s->queues * 2);
d08e42a1 383 s->rings |= 0x1ULL << msg.payload.state.index;
1d9edff7
MAL
384 break;
385
ed0a8d92
MAL
386 case VHOST_USER_GET_QUEUE_NUM:
387 msg.flags |= VHOST_USER_REPLY_MASK;
388 msg.size = sizeof(m.payload.u64);
389 msg.payload.u64 = s->queues;
390 p = (uint8_t *) &msg;
5345fdb4 391 qemu_chr_fe_write_all(chr, p, VHOST_USER_HDR_SIZE + msg.size);
ed0a8d92
MAL
392 break;
393
a77e6b14
NN
394 default:
395 break;
396 }
ae31fb54
MAL
397
398 g_mutex_unlock(&s->data_mutex);
a77e6b14
NN
399}
400
1b7e1e3b 401static const char *init_hugepagefs(const char *path)
a77e6b14 402{
a77e6b14
NN
403 struct statfs fs;
404 int ret;
405
a77e6b14
NN
406 if (access(path, R_OK | W_OK | X_OK)) {
407 g_test_message("access on path (%s): %s\n", path, strerror(errno));
408 return NULL;
409 }
410
411 do {
412 ret = statfs(path, &fs);
413 } while (ret != 0 && errno == EINTR);
414
415 if (ret != 0) {
416 g_test_message("statfs on path (%s): %s\n", path, strerror(errno));
417 return NULL;
418 }
419
420 if (fs.f_type != HUGETLBFS_MAGIC) {
421 g_test_message("Warning: path not on HugeTLBFS: %s\n", path);
422 return NULL;
423 }
424
425 return path;
426}
427
704b2168 428static TestServer *test_server_new(const gchar *name)
ae31fb54
MAL
429{
430 TestServer *server = g_new0(TestServer, 1);
ae31fb54
MAL
431
432 server->socket_path = g_strdup_printf("%s/%s.sock", tmpfs, name);
a899b1ea 433 server->mig_path = g_strdup_printf("%s/%s.mig", tmpfs, name);
ae31fb54 434 server->chr_name = g_strdup_printf("chr-%s", name);
ae31fb54
MAL
435
436 g_mutex_init(&server->data_mutex);
437 g_cond_init(&server->data_cond);
438
b1819747 439 server->log_fd = -1;
ed0a8d92 440 server->queues = 1;
b1819747 441
ae31fb54
MAL
442 return server;
443}
444
9294d76c
MAL
445static void chr_event(void *opaque, int event)
446{
447 TestServer *s = opaque;
448
449 if (s->test_flags == TEST_FLAGS_END &&
450 event == CHR_EVENT_CLOSED) {
451 s->test_flags = TEST_FLAGS_OK;
452 }
453}
454
4616e359
MAL
455static void test_server_create_chr(TestServer *server, const gchar *opt)
456{
457 gchar *chr_path;
0ec7b3e7 458 Chardev *chr;
5345fdb4 459
4616e359 460 chr_path = g_strdup_printf("unix:%s%s", server->socket_path, opt);
32a6ebec 461 chr = qemu_chr_new(server->chr_name, chr_path);
4616e359
MAL
462 g_free(chr_path);
463
5345fdb4
MAL
464 qemu_chr_fe_init(&server->chr, chr, &error_abort);
465 qemu_chr_fe_set_handlers(&server->chr, chr_can_read, chr_read,
39ab61c6 466 chr_event, server, NULL, true);
4616e359
MAL
467}
468
469static void test_server_listen(TestServer *server)
470{
471 test_server_create_chr(server, ",server,nowait");
472}
473
474static inline void test_server_connect(TestServer *server)
475{
476 test_server_create_chr(server, ",reconnect=1");
477}
478
479#define GET_QEMU_CMD(s) \
480 g_strdup_printf(QEMU_CMD, 512, 512, (root), (s)->chr_name, \
481 (s)->socket_path, "", (s)->chr_name)
482
483#define GET_QEMU_CMDE(s, mem, chr_opts, extra, ...) \
484 g_strdup_printf(QEMU_CMD extra, (mem), (mem), (root), (s)->chr_name, \
485 (s)->socket_path, (chr_opts), (s)->chr_name, ##__VA_ARGS__)
ae31fb54 486
9732baf6 487static gboolean _test_server_free(TestServer *server)
ae31fb54
MAL
488{
489 int i;
0ec7b3e7 490 Chardev *chr = qemu_chr_fe_get_driver(&server->chr);
ae31fb54 491
c39860e6 492 qemu_chr_fe_deinit(&server->chr);
5345fdb4 493 qemu_chr_delete(chr);
ae31fb54
MAL
494
495 for (i = 0; i < server->fds_num; i++) {
496 close(server->fds[i]);
497 }
498
b1819747
MAL
499 if (server->log_fd != -1) {
500 close(server->log_fd);
501 }
502
ae31fb54
MAL
503 unlink(server->socket_path);
504 g_free(server->socket_path);
505
a899b1ea
MAL
506 unlink(server->mig_path);
507 g_free(server->mig_path);
508
b1819747 509 g_free(server->chr_name);
ae31fb54 510 g_free(server);
9732baf6
MAL
511
512 return FALSE;
513}
514
515static void test_server_free(TestServer *server)
516{
517 g_idle_add((GSourceFunc)_test_server_free, server);
ae31fb54
MAL
518}
519
b1819747
MAL
520static void wait_for_log_fd(TestServer *s)
521{
522 gint64 end_time;
523
524 g_mutex_lock(&s->data_mutex);
525 end_time = g_get_monotonic_time() + 5 * G_TIME_SPAN_SECOND;
526 while (s->log_fd == -1) {
527 if (!g_cond_wait_until(&s->data_cond, &s->data_mutex, end_time)) {
528 /* timeout has passed */
529 g_assert(s->log_fd != -1);
530 break;
531 }
532 }
533
534 g_mutex_unlock(&s->data_mutex);
535}
536
3a87d009 537static void write_guest_mem(TestServer *s, uint32_t seed)
b1819747
MAL
538{
539 uint32_t *guest_mem;
540 int i, j;
541 size_t size;
542
543 wait_for_fds(s);
544
545 /* iterate all regions */
546 for (i = 0; i < s->fds_num; i++) {
547
548 /* We'll write only the region statring at 0x0 */
549 if (s->memory.regions[i].guest_phys_addr != 0x0) {
550 continue;
551 }
552
553 g_assert_cmpint(s->memory.regions[i].memory_size, >, 1024);
554
555 size = s->memory.regions[i].memory_size +
556 s->memory.regions[i].mmap_offset;
557
558 guest_mem = mmap(0, size, PROT_READ | PROT_WRITE,
559 MAP_SHARED, s->fds[i], 0);
560
561 g_assert(guest_mem != MAP_FAILED);
562 guest_mem += (s->memory.regions[i].mmap_offset / sizeof(*guest_mem));
563
564 for (j = 0; j < 256; j++) {
565 guest_mem[j] = seed + j;
566 }
567
568 munmap(guest_mem, s->memory.regions[i].memory_size);
569 break;
570 }
571}
572
573static guint64 get_log_size(TestServer *s)
574{
575 guint64 log_size = 0;
576 int i;
577
578 for (i = 0; i < s->memory.nregions; ++i) {
579 VhostUserMemoryRegion *reg = &s->memory.regions[i];
580 guint64 last = range_get_last(reg->guest_phys_addr,
581 reg->memory_size);
582 log_size = MAX(log_size, last / (8 * VHOST_LOG_PAGE) + 1);
583 }
584
585 return log_size;
586}
587
1d9edff7
MAL
588typedef struct TestMigrateSource {
589 GSource source;
590 TestServer *src;
591 TestServer *dest;
592} TestMigrateSource;
593
594static gboolean
595test_migrate_source_check(GSource *source)
596{
597 TestMigrateSource *t = (TestMigrateSource *)source;
d08e42a1 598 gboolean overlap = t->src->rings && t->dest->rings;
1d9edff7
MAL
599
600 g_assert(!overlap);
601
602 return FALSE;
603}
604
45ce5126
MAL
605#if !GLIB_CHECK_VERSION(2,36,0)
606/* this callback is unnecessary with glib >2.36, the default
607 * prepare for the source does the same */
608static gboolean
609test_migrate_source_prepare(GSource *source, gint *timeout)
610{
611 *timeout = -1;
612 return FALSE;
613}
614#endif
615
1d9edff7 616GSourceFuncs test_migrate_source_funcs = {
45ce5126
MAL
617#if !GLIB_CHECK_VERSION(2,36,0)
618 .prepare = test_migrate_source_prepare,
619#endif
620 .check = test_migrate_source_check,
1d9edff7
MAL
621};
622
b1819747
MAL
623static void test_migrate(void)
624{
625 TestServer *s = test_server_new("src");
626 TestServer *dest = test_server_new("dest");
a899b1ea 627 char *uri = g_strdup_printf("%s%s", "unix:", dest->mig_path);
b1819747 628 QTestState *global = global_qtest, *from, *to;
1d9edff7 629 GSource *source;
b1819747
MAL
630 gchar *cmd;
631 QDict *rsp;
632 guint8 *log;
633 guint64 size;
634
4616e359
MAL
635 test_server_listen(s);
636 test_server_listen(dest);
637
638 cmd = GET_QEMU_CMDE(s, 2, "", "");
b1819747
MAL
639 from = qtest_start(cmd);
640 g_free(cmd);
641
cdafe929 642 init_virtio_dev(s);
b1819747
MAL
643 wait_for_fds(s);
644 size = get_log_size(s);
645 g_assert_cmpint(size, ==, (2 * 1024 * 1024) / (VHOST_LOG_PAGE * 8));
646
4616e359 647 cmd = GET_QEMU_CMDE(dest, 2, "", " -incoming %s", uri);
b1819747
MAL
648 to = qtest_init(cmd);
649 g_free(cmd);
650
1d9edff7
MAL
651 source = g_source_new(&test_migrate_source_funcs,
652 sizeof(TestMigrateSource));
653 ((TestMigrateSource *)source)->src = s;
654 ((TestMigrateSource *)source)->dest = dest;
655 g_source_attach(source, NULL);
656
b1819747
MAL
657 /* slow down migration to have time to fiddle with log */
658 /* TODO: qtest could learn to break on some places */
659 rsp = qmp("{ 'execute': 'migrate_set_speed',"
660 "'arguments': { 'value': 10 } }");
661 g_assert(qdict_haskey(rsp, "return"));
662 QDECREF(rsp);
663
664 cmd = g_strdup_printf("{ 'execute': 'migrate',"
665 "'arguments': { 'uri': '%s' } }",
666 uri);
667 rsp = qmp(cmd);
668 g_free(cmd);
669 g_assert(qdict_haskey(rsp, "return"));
670 QDECREF(rsp);
671
672 wait_for_log_fd(s);
673
674 log = mmap(0, size, PROT_READ | PROT_WRITE, MAP_SHARED, s->log_fd, 0);
675 g_assert(log != MAP_FAILED);
676
677 /* modify first page */
678 write_guest_mem(s, 0x42);
679 log[0] = 1;
680 munmap(log, size);
681
682 /* speed things up */
683 rsp = qmp("{ 'execute': 'migrate_set_speed',"
684 "'arguments': { 'value': 0 } }");
685 g_assert(qdict_haskey(rsp, "return"));
686 QDECREF(rsp);
687
688 qmp_eventwait("STOP");
689
690 global_qtest = to;
691 qmp_eventwait("RESUME");
692
693 read_guest_mem(dest);
694
1d9edff7
MAL
695 g_source_destroy(source);
696 g_source_unref(source);
697
b1819747
MAL
698 qtest_quit(to);
699 test_server_free(dest);
700 qtest_quit(from);
701 test_server_free(s);
a899b1ea 702 g_free(uri);
b1819747
MAL
703
704 global_qtest = global;
705}
706
4616e359
MAL
707static void wait_for_rings_started(TestServer *s, size_t count)
708{
709 gint64 end_time;
710
711 g_mutex_lock(&s->data_mutex);
712 end_time = g_get_monotonic_time() + 5 * G_TIME_SPAN_SECOND;
713 while (ctpop64(s->rings) != count) {
714 if (!g_cond_wait_until(&s->data_cond, &s->data_mutex, end_time)) {
715 /* timeout has passed */
716 g_assert_cmpint(ctpop64(s->rings), ==, count);
717 break;
718 }
719 }
720
721 g_mutex_unlock(&s->data_mutex);
722}
723
ed0a8d92 724#ifdef CONFIG_HAS_GLIB_SUBPROCESS_TESTS
4616e359
MAL
725static gboolean
726reconnect_cb(gpointer user_data)
727{
728 TestServer *s = user_data;
729
5345fdb4 730 qemu_chr_fe_disconnect(&s->chr);
4616e359
MAL
731
732 return FALSE;
733}
734
735static gpointer
736connect_thread(gpointer data)
737{
738 TestServer *s = data;
739
740 /* wait for qemu to start before first try, to avoid extra warnings */
741 g_usleep(G_USEC_PER_SEC);
742 test_server_connect(s);
743
744 return NULL;
745}
746
747static void test_reconnect_subprocess(void)
748{
749 TestServer *s = test_server_new("reconnect");
750 char *cmd;
751
752 g_thread_new("connect", connect_thread, s);
753 cmd = GET_QEMU_CMDE(s, 2, ",server", "");
754 qtest_start(cmd);
755 g_free(cmd);
756
cdafe929 757 init_virtio_dev(s);
4616e359
MAL
758 wait_for_fds(s);
759 wait_for_rings_started(s, 2);
760
761 /* reconnect */
762 s->fds_num = 0;
763 s->rings = 0;
764 g_idle_add(reconnect_cb, s);
765 wait_for_fds(s);
766 wait_for_rings_started(s, 2);
767
768 qtest_end();
769 test_server_free(s);
770 return;
771}
772
773static void test_reconnect(void)
774{
775 gchar *path = g_strdup_printf("/%s/vhost-user/reconnect/subprocess",
776 qtest_get_arch());
777 g_test_trap_subprocess(path, 0, 0);
778 g_test_trap_assert_passed();
69179fe2 779 g_free(path);
4616e359 780}
5d443f5a
MAL
781
782static void test_connect_fail_subprocess(void)
783{
784 TestServer *s = test_server_new("connect-fail");
785 char *cmd;
786
787 s->test_fail = true;
788 g_thread_new("connect", connect_thread, s);
789 cmd = GET_QEMU_CMDE(s, 2, ",server", "");
790 qtest_start(cmd);
791 g_free(cmd);
792
793 init_virtio_dev(s);
794 wait_for_fds(s);
795 wait_for_rings_started(s, 2);
796
797 qtest_end();
798 test_server_free(s);
799}
800
801static void test_connect_fail(void)
802{
803 gchar *path = g_strdup_printf("/%s/vhost-user/connect-fail/subprocess",
804 qtest_get_arch());
805 g_test_trap_subprocess(path, 0, 0);
806 g_test_trap_assert_passed();
807 g_free(path);
808}
809
9294d76c
MAL
810static void test_flags_mismatch_subprocess(void)
811{
812 TestServer *s = test_server_new("flags-mismatch");
813 char *cmd;
814
815 s->test_flags = TEST_FLAGS_DISCONNECT;
816 g_thread_new("connect", connect_thread, s);
817 cmd = GET_QEMU_CMDE(s, 2, ",server", "");
818 qtest_start(cmd);
819 g_free(cmd);
820
821 init_virtio_dev(s);
822 wait_for_fds(s);
823 wait_for_rings_started(s, 2);
824
825 qtest_end();
826 test_server_free(s);
827}
828
829static void test_flags_mismatch(void)
830{
831 gchar *path = g_strdup_printf("/%s/vhost-user/flags-mismatch/subprocess",
832 qtest_get_arch());
833 g_test_trap_subprocess(path, 0, 0);
834 g_test_trap_assert_passed();
835 g_free(path);
836}
837
4616e359
MAL
838#endif
839
ed0a8d92
MAL
840static QVirtioPCIDevice *virtio_net_pci_init(QPCIBus *bus, int slot)
841{
842 QVirtioPCIDevice *dev;
843
844 dev = qvirtio_pci_device_find(bus, VIRTIO_ID_NET);
845 g_assert(dev != NULL);
846 g_assert_cmphex(dev->vdev.device_type, ==, VIRTIO_ID_NET);
847
848 qvirtio_pci_device_enable(dev);
6b9cdf4c
LV
849 qvirtio_reset(&dev->vdev);
850 qvirtio_set_acknowledge(&dev->vdev);
851 qvirtio_set_driver(&dev->vdev);
ed0a8d92
MAL
852
853 return dev;
854}
855
6b9cdf4c 856static void driver_init(QVirtioDevice *dev)
ed0a8d92
MAL
857{
858 uint32_t features;
859
6b9cdf4c 860 features = qvirtio_get_features(dev);
ed0a8d92
MAL
861 features = features & ~(QVIRTIO_F_BAD_FEATURE |
862 (1u << VIRTIO_RING_F_INDIRECT_DESC) |
863 (1u << VIRTIO_RING_F_EVENT_IDX));
6b9cdf4c 864 qvirtio_set_features(dev, features);
ed0a8d92 865
6b9cdf4c 866 qvirtio_set_driver_ok(dev);
ed0a8d92
MAL
867}
868
869#define PCI_SLOT 0x04
870
871static void test_multiqueue(void)
872{
873 const int queues = 2;
874 TestServer *s = test_server_new("mq");
875 QVirtioPCIDevice *dev;
876 QPCIBus *bus;
877 QVirtQueuePCI *vq[queues * 2];
878 QGuestAllocator *alloc;
879 char *cmd;
880 int i;
881
882 s->queues = queues;
883 test_server_listen(s);
884
885 cmd = g_strdup_printf(QEMU_CMD_MEM QEMU_CMD_CHR QEMU_CMD_NETDEV ",queues=%d "
886 "-device virtio-net-pci,netdev=net0,mq=on,vectors=%d",
887 512, 512, root, s->chr_name,
888 s->socket_path, "", s->chr_name,
889 queues, queues * 2 + 2);
890 qtest_start(cmd);
891 g_free(cmd);
892
2ecd7e2f 893 bus = qpci_init_pc(NULL);
ed0a8d92
MAL
894 dev = virtio_net_pci_init(bus, PCI_SLOT);
895
896 alloc = pc_alloc_init();
897 for (i = 0; i < queues * 2; i++) {
6b9cdf4c 898 vq[i] = (QVirtQueuePCI *)qvirtqueue_setup(&dev->vdev, alloc, i);
ed0a8d92
MAL
899 }
900
6b9cdf4c 901 driver_init(&dev->vdev);
ed0a8d92
MAL
902 wait_for_rings_started(s, queues * 2);
903
904 /* End test */
905 for (i = 0; i < queues * 2; i++) {
6b9cdf4c 906 qvirtqueue_cleanup(dev->vdev.bus, &vq[i]->vq, alloc);
ed0a8d92
MAL
907 }
908 pc_alloc_uninit(alloc);
909 qvirtio_pci_device_disable(dev);
910 g_free(dev->pdev);
911 g_free(dev);
912 qpci_free_pc(bus);
913 qtest_end();
914
915 test_server_free(s);
916}
917
a77e6b14
NN
918int main(int argc, char **argv)
919{
920 QTestState *s = NULL;
ae31fb54 921 TestServer *server = NULL;
1b7e1e3b 922 const char *hugefs;
ae31fb54 923 char *qemu_cmd = NULL;
a77e6b14 924 int ret;
1b7e1e3b 925 char template[] = "/tmp/vhost-test-XXXXXX";
9732baf6
MAL
926 GMainLoop *loop;
927 GThread *thread;
a77e6b14
NN
928
929 g_test_init(&argc, &argv, NULL);
930
931 module_call_init(MODULE_INIT_QOM);
ae31fb54 932 qemu_add_opts(&qemu_chardev_opts);
a77e6b14 933
1b7e1e3b
MT
934 tmpfs = mkdtemp(template);
935 if (!tmpfs) {
ae31fb54 936 g_test_message("mkdtemp on path (%s): %s\n", template, strerror(errno));
1b7e1e3b
MT
937 }
938 g_assert(tmpfs);
939
940 hugefs = getenv("QTEST_HUGETLBFS_PATH");
941 if (hugefs) {
942 root = init_hugepagefs(hugefs);
943 g_assert(root);
944 } else {
945 root = tmpfs;
a77e6b14
NN
946 }
947
704b2168 948 server = test_server_new("test");
4616e359 949 test_server_listen(server);
a77e6b14 950
9732baf6 951 loop = g_main_loop_new(NULL, FALSE);
a77e6b14 952 /* run the main loop thread so the chardev may operate */
9732baf6 953 thread = g_thread_new(NULL, thread_function, loop);
a77e6b14 954
704b2168 955 qemu_cmd = GET_QEMU_CMD(server);
ae31fb54 956
a77e6b14
NN
957 s = qtest_start(qemu_cmd);
958 g_free(qemu_cmd);
cdafe929 959 init_virtio_dev(server);
a77e6b14 960
ae31fb54 961 qtest_add_data_func("/vhost-user/read-guest-mem", server, read_guest_mem);
b1819747 962 qtest_add_func("/vhost-user/migrate", test_migrate);
ed0a8d92 963 qtest_add_func("/vhost-user/multiqueue", test_multiqueue);
4616e359
MAL
964#ifdef CONFIG_HAS_GLIB_SUBPROCESS_TESTS
965 qtest_add_func("/vhost-user/reconnect/subprocess",
966 test_reconnect_subprocess);
967 qtest_add_func("/vhost-user/reconnect", test_reconnect);
5d443f5a
MAL
968 qtest_add_func("/vhost-user/connect-fail/subprocess",
969 test_connect_fail_subprocess);
970 qtest_add_func("/vhost-user/connect-fail", test_connect_fail);
9294d76c
MAL
971 qtest_add_func("/vhost-user/flags-mismatch/subprocess",
972 test_flags_mismatch_subprocess);
973 qtest_add_func("/vhost-user/flags-mismatch", test_flags_mismatch);
4616e359 974#endif
a77e6b14
NN
975
976 ret = g_test_run();
977
978 if (s) {
979 qtest_quit(s);
980 }
981
982 /* cleanup */
ae31fb54 983 test_server_free(server);
a77e6b14 984
9732baf6
MAL
985 /* finish the helper thread and dispatch pending sources */
986 g_main_loop_quit(loop);
987 g_thread_join(thread);
988 while (g_main_context_pending(NULL)) {
989 g_main_context_iteration (NULL, TRUE);
990 }
991 g_main_loop_unref(loop);
992
1b7e1e3b
MT
993 ret = rmdir(tmpfs);
994 if (ret != 0) {
995 g_test_message("unable to rmdir: path (%s): %s\n",
996 tmpfs, strerror(errno));
997 }
998 g_assert_cmpint(ret, ==, 0);
999
a77e6b14
NN
1000 return ret;
1001}