Merge remote-tracking branch 'remotes/rth/tags/pull-tcg-20151201' into staging
[qemu/ar7.git] / tests / vhost-user-test.c
blobe4c36afbdab918400bdf9852aa37953229ce35b0
1 /*
2 * QTest testcase for the vhost-user
4 * Copyright (c) 2014 Virtual Open Systems Sarl.
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.
9 */
11 #include <glib.h>
13 #include "libqtest.h"
14 #include "qemu/option.h"
15 #include "qemu/range.h"
16 #include "sysemu/char.h"
17 #include "sysemu/sysemu.h"
19 #include <linux/vhost.h>
20 #include <sys/mman.h>
21 #include <sys/vfs.h>
22 #include <qemu/sockets.h>
24 /* GLIB version compatibility flags */
25 #if !GLIB_CHECK_VERSION(2, 26, 0)
26 #define G_TIME_SPAN_SECOND (G_GINT64_CONSTANT(1000000))
27 #endif
29 #if GLIB_CHECK_VERSION(2, 28, 0)
30 #define HAVE_MONOTONIC_TIME
31 #endif
33 #define QEMU_CMD_ACCEL " -machine accel=tcg"
34 #define QEMU_CMD_MEM " -m %d -object memory-backend-file,id=mem,size=%dM,"\
35 "mem-path=%s,share=on -numa node,memdev=mem"
36 #define QEMU_CMD_CHR " -chardev socket,id=%s,path=%s"
37 #define QEMU_CMD_NETDEV " -netdev vhost-user,id=net0,chardev=%s,vhostforce"
38 #define QEMU_CMD_NET " -device virtio-net-pci,netdev=net0 "
39 #define QEMU_CMD_ROM " -option-rom ../pc-bios/pxe-virtio.rom"
41 #define QEMU_CMD QEMU_CMD_ACCEL QEMU_CMD_MEM QEMU_CMD_CHR \
42 QEMU_CMD_NETDEV QEMU_CMD_NET QEMU_CMD_ROM
44 #define HUGETLBFS_MAGIC 0x958458f6
46 /*********** FROM hw/virtio/vhost-user.c *************************************/
48 #define VHOST_MEMORY_MAX_NREGIONS 8
50 #define VHOST_USER_F_PROTOCOL_FEATURES 30
51 #define VHOST_USER_PROTOCOL_F_LOG_SHMFD 1
53 #define VHOST_LOG_PAGE 0x1000
55 typedef enum VhostUserRequest {
56 VHOST_USER_NONE = 0,
57 VHOST_USER_GET_FEATURES = 1,
58 VHOST_USER_SET_FEATURES = 2,
59 VHOST_USER_SET_OWNER = 3,
60 VHOST_USER_RESET_OWNER = 4,
61 VHOST_USER_SET_MEM_TABLE = 5,
62 VHOST_USER_SET_LOG_BASE = 6,
63 VHOST_USER_SET_LOG_FD = 7,
64 VHOST_USER_SET_VRING_NUM = 8,
65 VHOST_USER_SET_VRING_ADDR = 9,
66 VHOST_USER_SET_VRING_BASE = 10,
67 VHOST_USER_GET_VRING_BASE = 11,
68 VHOST_USER_SET_VRING_KICK = 12,
69 VHOST_USER_SET_VRING_CALL = 13,
70 VHOST_USER_SET_VRING_ERR = 14,
71 VHOST_USER_GET_PROTOCOL_FEATURES = 15,
72 VHOST_USER_SET_PROTOCOL_FEATURES = 16,
73 VHOST_USER_SET_VRING_ENABLE = 18,
74 VHOST_USER_MAX
75 } VhostUserRequest;
77 typedef struct VhostUserMemoryRegion {
78 uint64_t guest_phys_addr;
79 uint64_t memory_size;
80 uint64_t userspace_addr;
81 uint64_t mmap_offset;
82 } VhostUserMemoryRegion;
84 typedef struct VhostUserMemory {
85 uint32_t nregions;
86 uint32_t padding;
87 VhostUserMemoryRegion regions[VHOST_MEMORY_MAX_NREGIONS];
88 } VhostUserMemory;
90 typedef struct VhostUserLog {
91 uint64_t mmap_size;
92 uint64_t mmap_offset;
93 } VhostUserLog;
95 typedef struct VhostUserMsg {
96 VhostUserRequest request;
98 #define VHOST_USER_VERSION_MASK (0x3)
99 #define VHOST_USER_REPLY_MASK (0x1<<2)
100 uint32_t flags;
101 uint32_t size; /* the following payload size */
102 union {
103 #define VHOST_USER_VRING_IDX_MASK (0xff)
104 #define VHOST_USER_VRING_NOFD_MASK (0x1<<8)
105 uint64_t u64;
106 struct vhost_vring_state state;
107 struct vhost_vring_addr addr;
108 VhostUserMemory memory;
109 VhostUserLog log;
110 } payload;
111 } QEMU_PACKED VhostUserMsg;
113 static VhostUserMsg m __attribute__ ((unused));
114 #define VHOST_USER_HDR_SIZE (sizeof(m.request) \
115 + sizeof(m.flags) \
116 + sizeof(m.size))
118 #define VHOST_USER_PAYLOAD_SIZE (sizeof(m) - VHOST_USER_HDR_SIZE)
120 /* The version of the protocol we support */
121 #define VHOST_USER_VERSION (0x1)
122 /*****************************************************************************/
124 typedef struct TestServer {
125 gchar *socket_path;
126 gchar *chr_name;
127 CharDriverState *chr;
128 int fds_num;
129 int fds[VHOST_MEMORY_MAX_NREGIONS];
130 VhostUserMemory memory;
131 GMutex data_mutex;
132 GCond data_cond;
133 int log_fd;
134 uint64_t rings;
135 } TestServer;
137 #if !GLIB_CHECK_VERSION(2, 32, 0)
138 static gboolean g_cond_wait_until(CompatGCond cond, CompatGMutex mutex,
139 gint64 end_time)
141 gboolean ret = FALSE;
142 end_time -= g_get_monotonic_time();
143 GTimeVal time = { end_time / G_TIME_SPAN_SECOND,
144 end_time % G_TIME_SPAN_SECOND };
145 ret = g_cond_timed_wait(cond, mutex, &time);
146 return ret;
148 #endif
150 static const char *tmpfs;
151 static const char *root;
153 static void wait_for_fds(TestServer *s)
155 gint64 end_time;
157 g_mutex_lock(&s->data_mutex);
159 end_time = g_get_monotonic_time() + 5 * G_TIME_SPAN_SECOND;
160 while (!s->fds_num) {
161 if (!g_cond_wait_until(&s->data_cond, &s->data_mutex, end_time)) {
162 /* timeout has passed */
163 g_assert(s->fds_num);
164 break;
168 /* check for sanity */
169 g_assert_cmpint(s->fds_num, >, 0);
170 g_assert_cmpint(s->fds_num, ==, s->memory.nregions);
172 g_mutex_unlock(&s->data_mutex);
175 static void read_guest_mem(TestServer *s)
177 uint32_t *guest_mem;
178 int i, j;
179 size_t size;
181 wait_for_fds(s);
183 g_mutex_lock(&s->data_mutex);
185 /* iterate all regions */
186 for (i = 0; i < s->fds_num; i++) {
188 /* We'll check only the region statring at 0x0*/
189 if (s->memory.regions[i].guest_phys_addr != 0x0) {
190 continue;
193 g_assert_cmpint(s->memory.regions[i].memory_size, >, 1024);
195 size = s->memory.regions[i].memory_size +
196 s->memory.regions[i].mmap_offset;
198 guest_mem = mmap(0, size, PROT_READ | PROT_WRITE,
199 MAP_SHARED, s->fds[i], 0);
201 g_assert(guest_mem != MAP_FAILED);
202 guest_mem += (s->memory.regions[i].mmap_offset / sizeof(*guest_mem));
204 for (j = 0; j < 256; j++) {
205 uint32_t a = readl(s->memory.regions[i].guest_phys_addr + j*4);
206 uint32_t b = guest_mem[j];
208 g_assert_cmpint(a, ==, b);
211 munmap(guest_mem, s->memory.regions[i].memory_size);
214 g_mutex_unlock(&s->data_mutex);
217 static void *thread_function(void *data)
219 GMainLoop *loop;
220 loop = g_main_loop_new(NULL, FALSE);
221 g_main_loop_run(loop);
222 return NULL;
225 static int chr_can_read(void *opaque)
227 return VHOST_USER_HDR_SIZE;
230 static void chr_read(void *opaque, const uint8_t *buf, int size)
232 TestServer *s = opaque;
233 CharDriverState *chr = s->chr;
234 VhostUserMsg msg;
235 uint8_t *p = (uint8_t *) &msg;
236 int fd;
238 if (size != VHOST_USER_HDR_SIZE) {
239 g_test_message("Wrong message size received %d\n", size);
240 return;
243 g_mutex_lock(&s->data_mutex);
244 memcpy(p, buf, VHOST_USER_HDR_SIZE);
246 if (msg.size) {
247 p += VHOST_USER_HDR_SIZE;
248 g_assert_cmpint(qemu_chr_fe_read_all(chr, p, msg.size), ==, msg.size);
251 switch (msg.request) {
252 case VHOST_USER_GET_FEATURES:
253 /* send back features to qemu */
254 msg.flags |= VHOST_USER_REPLY_MASK;
255 msg.size = sizeof(m.payload.u64);
256 msg.payload.u64 = 0x1ULL << VHOST_F_LOG_ALL |
257 0x1ULL << VHOST_USER_F_PROTOCOL_FEATURES;
258 p = (uint8_t *) &msg;
259 qemu_chr_fe_write_all(chr, p, VHOST_USER_HDR_SIZE + msg.size);
260 break;
262 case VHOST_USER_SET_FEATURES:
263 g_assert_cmpint(msg.payload.u64 & (0x1ULL << VHOST_USER_F_PROTOCOL_FEATURES),
264 !=, 0ULL);
265 break;
267 case VHOST_USER_GET_PROTOCOL_FEATURES:
268 /* send back features to qemu */
269 msg.flags |= VHOST_USER_REPLY_MASK;
270 msg.size = sizeof(m.payload.u64);
271 msg.payload.u64 = 1 << VHOST_USER_PROTOCOL_F_LOG_SHMFD;
272 p = (uint8_t *) &msg;
273 qemu_chr_fe_write_all(chr, p, VHOST_USER_HDR_SIZE + msg.size);
274 break;
276 case VHOST_USER_GET_VRING_BASE:
277 /* send back vring base to qemu */
278 msg.flags |= VHOST_USER_REPLY_MASK;
279 msg.size = sizeof(m.payload.state);
280 msg.payload.state.num = 0;
281 p = (uint8_t *) &msg;
282 qemu_chr_fe_write_all(chr, p, VHOST_USER_HDR_SIZE + msg.size);
284 assert(msg.payload.state.index < 2);
285 s->rings &= ~(0x1ULL << msg.payload.state.index);
286 break;
288 case VHOST_USER_SET_MEM_TABLE:
289 /* received the mem table */
290 memcpy(&s->memory, &msg.payload.memory, sizeof(msg.payload.memory));
291 s->fds_num = qemu_chr_fe_get_msgfds(chr, s->fds, G_N_ELEMENTS(s->fds));
293 /* signal the test that it can continue */
294 g_cond_signal(&s->data_cond);
295 break;
297 case VHOST_USER_SET_VRING_KICK:
298 case VHOST_USER_SET_VRING_CALL:
299 /* consume the fd */
300 qemu_chr_fe_get_msgfds(chr, &fd, 1);
302 * This is a non-blocking eventfd.
303 * The receive function forces it to be blocking,
304 * so revert it back to non-blocking.
306 qemu_set_nonblock(fd);
307 break;
309 case VHOST_USER_SET_LOG_BASE:
310 if (s->log_fd != -1) {
311 close(s->log_fd);
312 s->log_fd = -1;
314 qemu_chr_fe_get_msgfds(chr, &s->log_fd, 1);
315 msg.flags |= VHOST_USER_REPLY_MASK;
316 msg.size = 0;
317 p = (uint8_t *) &msg;
318 qemu_chr_fe_write_all(chr, p, VHOST_USER_HDR_SIZE);
320 g_cond_signal(&s->data_cond);
321 break;
323 case VHOST_USER_SET_VRING_BASE:
324 assert(msg.payload.state.index < 2);
325 s->rings |= 0x1ULL << msg.payload.state.index;
326 break;
328 default:
329 break;
332 g_mutex_unlock(&s->data_mutex);
335 static const char *init_hugepagefs(const char *path)
337 struct statfs fs;
338 int ret;
340 if (access(path, R_OK | W_OK | X_OK)) {
341 g_test_message("access on path (%s): %s\n", path, strerror(errno));
342 return NULL;
345 do {
346 ret = statfs(path, &fs);
347 } while (ret != 0 && errno == EINTR);
349 if (ret != 0) {
350 g_test_message("statfs on path (%s): %s\n", path, strerror(errno));
351 return NULL;
354 if (fs.f_type != HUGETLBFS_MAGIC) {
355 g_test_message("Warning: path not on HugeTLBFS: %s\n", path);
356 return NULL;
359 return path;
362 static TestServer *test_server_new(const gchar *name)
364 TestServer *server = g_new0(TestServer, 1);
365 gchar *chr_path;
367 server->socket_path = g_strdup_printf("%s/%s.sock", tmpfs, name);
369 chr_path = g_strdup_printf("unix:%s,server,nowait", server->socket_path);
370 server->chr_name = g_strdup_printf("chr-%s", name);
371 server->chr = qemu_chr_new(server->chr_name, chr_path, NULL);
372 g_free(chr_path);
374 qemu_chr_add_handlers(server->chr, chr_can_read, chr_read, NULL, server);
376 g_mutex_init(&server->data_mutex);
377 g_cond_init(&server->data_cond);
379 server->log_fd = -1;
381 return server;
384 #define GET_QEMU_CMD(s) \
385 g_strdup_printf(QEMU_CMD, 512, 512, (root), (s)->chr_name, \
386 (s)->socket_path, (s)->chr_name)
388 #define GET_QEMU_CMDE(s, mem, extra, ...) \
389 g_strdup_printf(QEMU_CMD extra, (mem), (mem), (root), (s)->chr_name, \
390 (s)->socket_path, (s)->chr_name, ##__VA_ARGS__)
392 static void test_server_free(TestServer *server)
394 int i;
396 qemu_chr_delete(server->chr);
398 for (i = 0; i < server->fds_num; i++) {
399 close(server->fds[i]);
402 if (server->log_fd != -1) {
403 close(server->log_fd);
406 unlink(server->socket_path);
407 g_free(server->socket_path);
410 g_free(server->chr_name);
411 g_free(server);
414 static void wait_for_log_fd(TestServer *s)
416 gint64 end_time;
418 g_mutex_lock(&s->data_mutex);
419 end_time = g_get_monotonic_time() + 5 * G_TIME_SPAN_SECOND;
420 while (s->log_fd == -1) {
421 if (!g_cond_wait_until(&s->data_cond, &s->data_mutex, end_time)) {
422 /* timeout has passed */
423 g_assert(s->log_fd != -1);
424 break;
428 g_mutex_unlock(&s->data_mutex);
431 static void write_guest_mem(TestServer *s, uint32 seed)
433 uint32_t *guest_mem;
434 int i, j;
435 size_t size;
437 wait_for_fds(s);
439 /* iterate all regions */
440 for (i = 0; i < s->fds_num; i++) {
442 /* We'll write only the region statring at 0x0 */
443 if (s->memory.regions[i].guest_phys_addr != 0x0) {
444 continue;
447 g_assert_cmpint(s->memory.regions[i].memory_size, >, 1024);
449 size = s->memory.regions[i].memory_size +
450 s->memory.regions[i].mmap_offset;
452 guest_mem = mmap(0, size, PROT_READ | PROT_WRITE,
453 MAP_SHARED, s->fds[i], 0);
455 g_assert(guest_mem != MAP_FAILED);
456 guest_mem += (s->memory.regions[i].mmap_offset / sizeof(*guest_mem));
458 for (j = 0; j < 256; j++) {
459 guest_mem[j] = seed + j;
462 munmap(guest_mem, s->memory.regions[i].memory_size);
463 break;
467 static guint64 get_log_size(TestServer *s)
469 guint64 log_size = 0;
470 int i;
472 for (i = 0; i < s->memory.nregions; ++i) {
473 VhostUserMemoryRegion *reg = &s->memory.regions[i];
474 guint64 last = range_get_last(reg->guest_phys_addr,
475 reg->memory_size);
476 log_size = MAX(log_size, last / (8 * VHOST_LOG_PAGE) + 1);
479 return log_size;
482 typedef struct TestMigrateSource {
483 GSource source;
484 TestServer *src;
485 TestServer *dest;
486 } TestMigrateSource;
488 static gboolean
489 test_migrate_source_check(GSource *source)
491 TestMigrateSource *t = (TestMigrateSource *)source;
492 gboolean overlap = t->src->rings && t->dest->rings;
494 g_assert(!overlap);
496 return FALSE;
499 GSourceFuncs test_migrate_source_funcs = {
500 NULL,
501 test_migrate_source_check,
502 NULL,
503 NULL
506 static void test_migrate(void)
508 TestServer *s = test_server_new("src");
509 TestServer *dest = test_server_new("dest");
510 const char *uri = "tcp:127.0.0.1:1234";
511 QTestState *global = global_qtest, *from, *to;
512 GSource *source;
513 gchar *cmd;
514 QDict *rsp;
515 guint8 *log;
516 guint64 size;
518 cmd = GET_QEMU_CMDE(s, 2, "");
519 from = qtest_start(cmd);
520 g_free(cmd);
522 wait_for_fds(s);
523 size = get_log_size(s);
524 g_assert_cmpint(size, ==, (2 * 1024 * 1024) / (VHOST_LOG_PAGE * 8));
526 cmd = GET_QEMU_CMDE(dest, 2, " -incoming %s", uri);
527 to = qtest_init(cmd);
528 g_free(cmd);
530 source = g_source_new(&test_migrate_source_funcs,
531 sizeof(TestMigrateSource));
532 ((TestMigrateSource *)source)->src = s;
533 ((TestMigrateSource *)source)->dest = dest;
534 g_source_attach(source, NULL);
536 /* slow down migration to have time to fiddle with log */
537 /* TODO: qtest could learn to break on some places */
538 rsp = qmp("{ 'execute': 'migrate_set_speed',"
539 "'arguments': { 'value': 10 } }");
540 g_assert(qdict_haskey(rsp, "return"));
541 QDECREF(rsp);
543 cmd = g_strdup_printf("{ 'execute': 'migrate',"
544 "'arguments': { 'uri': '%s' } }",
545 uri);
546 rsp = qmp(cmd);
547 g_free(cmd);
548 g_assert(qdict_haskey(rsp, "return"));
549 QDECREF(rsp);
551 wait_for_log_fd(s);
553 log = mmap(0, size, PROT_READ | PROT_WRITE, MAP_SHARED, s->log_fd, 0);
554 g_assert(log != MAP_FAILED);
556 /* modify first page */
557 write_guest_mem(s, 0x42);
558 log[0] = 1;
559 munmap(log, size);
561 /* speed things up */
562 rsp = qmp("{ 'execute': 'migrate_set_speed',"
563 "'arguments': { 'value': 0 } }");
564 g_assert(qdict_haskey(rsp, "return"));
565 QDECREF(rsp);
567 qmp_eventwait("STOP");
569 global_qtest = to;
570 qmp_eventwait("RESUME");
572 read_guest_mem(dest);
574 g_source_destroy(source);
575 g_source_unref(source);
577 qtest_quit(to);
578 test_server_free(dest);
579 qtest_quit(from);
580 test_server_free(s);
582 global_qtest = global;
585 int main(int argc, char **argv)
587 QTestState *s = NULL;
588 TestServer *server = NULL;
589 const char *hugefs;
590 char *qemu_cmd = NULL;
591 int ret;
592 char template[] = "/tmp/vhost-test-XXXXXX";
594 g_test_init(&argc, &argv, NULL);
596 module_call_init(MODULE_INIT_QOM);
597 qemu_add_opts(&qemu_chardev_opts);
599 tmpfs = mkdtemp(template);
600 if (!tmpfs) {
601 g_test_message("mkdtemp on path (%s): %s\n", template, strerror(errno));
603 g_assert(tmpfs);
605 hugefs = getenv("QTEST_HUGETLBFS_PATH");
606 if (hugefs) {
607 root = init_hugepagefs(hugefs);
608 g_assert(root);
609 } else {
610 root = tmpfs;
613 server = test_server_new("test");
615 /* run the main loop thread so the chardev may operate */
616 g_thread_new(NULL, thread_function, NULL);
618 qemu_cmd = GET_QEMU_CMD(server);
620 s = qtest_start(qemu_cmd);
621 g_free(qemu_cmd);
623 qtest_add_data_func("/vhost-user/read-guest-mem", server, read_guest_mem);
624 qtest_add_func("/vhost-user/migrate", test_migrate);
626 ret = g_test_run();
628 if (s) {
629 qtest_quit(s);
632 /* cleanup */
633 test_server_free(server);
635 ret = rmdir(tmpfs);
636 if (ret != 0) {
637 g_test_message("unable to rmdir: path (%s): %s\n",
638 tmpfs, strerror(errno));
640 g_assert_cmpint(ret, ==, 0);
642 return ret;