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.
11 #include "qemu/osdep.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>
21 #include <qemu/sockets.h>
23 /* GLIB version compatibility flags */
24 #if !GLIB_CHECK_VERSION(2, 26, 0)
25 #define G_TIME_SPAN_SECOND (G_GINT64_CONSTANT(1000000))
28 #if GLIB_CHECK_VERSION(2, 28, 0)
29 #define HAVE_MONOTONIC_TIME
32 #define QEMU_CMD_ACCEL " -machine accel=tcg"
33 #define QEMU_CMD_MEM " -m %d -object memory-backend-file,id=mem,size=%dM,"\
34 "mem-path=%s,share=on -numa node,memdev=mem"
35 #define QEMU_CMD_CHR " -chardev socket,id=%s,path=%s%s"
36 #define QEMU_CMD_NETDEV " -netdev vhost-user,id=net0,chardev=%s,vhostforce"
37 #define QEMU_CMD_NET " -device virtio-net-pci,netdev=net0,romfile=./pc-bios/pxe-virtio.rom"
39 #define QEMU_CMD QEMU_CMD_ACCEL QEMU_CMD_MEM QEMU_CMD_CHR \
40 QEMU_CMD_NETDEV QEMU_CMD_NET
42 #define HUGETLBFS_MAGIC 0x958458f6
44 /*********** FROM hw/virtio/vhost-user.c *************************************/
46 #define VHOST_MEMORY_MAX_NREGIONS 8
48 #define VHOST_USER_F_PROTOCOL_FEATURES 30
49 #define VHOST_USER_PROTOCOL_F_LOG_SHMFD 1
51 #define VHOST_LOG_PAGE 0x1000
53 typedef enum VhostUserRequest
{
55 VHOST_USER_GET_FEATURES
= 1,
56 VHOST_USER_SET_FEATURES
= 2,
57 VHOST_USER_SET_OWNER
= 3,
58 VHOST_USER_RESET_OWNER
= 4,
59 VHOST_USER_SET_MEM_TABLE
= 5,
60 VHOST_USER_SET_LOG_BASE
= 6,
61 VHOST_USER_SET_LOG_FD
= 7,
62 VHOST_USER_SET_VRING_NUM
= 8,
63 VHOST_USER_SET_VRING_ADDR
= 9,
64 VHOST_USER_SET_VRING_BASE
= 10,
65 VHOST_USER_GET_VRING_BASE
= 11,
66 VHOST_USER_SET_VRING_KICK
= 12,
67 VHOST_USER_SET_VRING_CALL
= 13,
68 VHOST_USER_SET_VRING_ERR
= 14,
69 VHOST_USER_GET_PROTOCOL_FEATURES
= 15,
70 VHOST_USER_SET_PROTOCOL_FEATURES
= 16,
71 VHOST_USER_SET_VRING_ENABLE
= 18,
75 typedef struct VhostUserMemoryRegion
{
76 uint64_t guest_phys_addr
;
78 uint64_t userspace_addr
;
80 } VhostUserMemoryRegion
;
82 typedef struct VhostUserMemory
{
85 VhostUserMemoryRegion regions
[VHOST_MEMORY_MAX_NREGIONS
];
88 typedef struct VhostUserLog
{
93 typedef struct VhostUserMsg
{
94 VhostUserRequest request
;
96 #define VHOST_USER_VERSION_MASK (0x3)
97 #define VHOST_USER_REPLY_MASK (0x1<<2)
99 uint32_t size
; /* the following payload size */
101 #define VHOST_USER_VRING_IDX_MASK (0xff)
102 #define VHOST_USER_VRING_NOFD_MASK (0x1<<8)
104 struct vhost_vring_state state
;
105 struct vhost_vring_addr addr
;
106 VhostUserMemory memory
;
109 } QEMU_PACKED VhostUserMsg
;
111 static VhostUserMsg m
__attribute__ ((unused
));
112 #define VHOST_USER_HDR_SIZE (sizeof(m.request) \
116 #define VHOST_USER_PAYLOAD_SIZE (sizeof(m) - VHOST_USER_HDR_SIZE)
118 /* The version of the protocol we support */
119 #define VHOST_USER_VERSION (0x1)
120 /*****************************************************************************/
122 typedef struct TestServer
{
126 CharDriverState
*chr
;
128 int fds
[VHOST_MEMORY_MAX_NREGIONS
];
129 VhostUserMemory memory
;
136 #if !GLIB_CHECK_VERSION(2, 32, 0)
137 static gboolean
g_cond_wait_until(CompatGCond cond
, CompatGMutex mutex
,
140 gboolean ret
= FALSE
;
141 end_time
-= g_get_monotonic_time();
142 GTimeVal time
= { end_time
/ G_TIME_SPAN_SECOND
,
143 end_time
% G_TIME_SPAN_SECOND
};
144 ret
= g_cond_timed_wait(cond
, mutex
, &time
);
149 static const char *tmpfs
;
150 static const char *root
;
152 static void wait_for_fds(TestServer
*s
)
156 g_mutex_lock(&s
->data_mutex
);
158 end_time
= g_get_monotonic_time() + 5 * G_TIME_SPAN_SECOND
;
159 while (!s
->fds_num
) {
160 if (!g_cond_wait_until(&s
->data_cond
, &s
->data_mutex
, end_time
)) {
161 /* timeout has passed */
162 g_assert(s
->fds_num
);
167 /* check for sanity */
168 g_assert_cmpint(s
->fds_num
, >, 0);
169 g_assert_cmpint(s
->fds_num
, ==, s
->memory
.nregions
);
171 g_mutex_unlock(&s
->data_mutex
);
174 static void read_guest_mem(const void *data
)
176 TestServer
*s
= (void *)data
;
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) {
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
= data
;
220 g_main_loop_run(loop
);
224 static int chr_can_read(void *opaque
)
226 return VHOST_USER_HDR_SIZE
;
229 static void chr_read(void *opaque
, const uint8_t *buf
, int size
)
231 TestServer
*s
= opaque
;
232 CharDriverState
*chr
= s
->chr
;
234 uint8_t *p
= (uint8_t *) &msg
;
237 if (size
!= VHOST_USER_HDR_SIZE
) {
238 g_test_message("Wrong message size received %d\n", size
);
242 g_mutex_lock(&s
->data_mutex
);
243 memcpy(p
, buf
, VHOST_USER_HDR_SIZE
);
246 p
+= VHOST_USER_HDR_SIZE
;
247 size
= qemu_chr_fe_read_all(chr
, p
, msg
.size
);
248 if (size
!= msg
.size
) {
249 g_test_message("Wrong message size received %d != %d\n",
255 switch (msg
.request
) {
256 case VHOST_USER_GET_FEATURES
:
257 /* send back features to qemu */
258 msg
.flags
|= VHOST_USER_REPLY_MASK
;
259 msg
.size
= sizeof(m
.payload
.u64
);
260 msg
.payload
.u64
= 0x1ULL
<< VHOST_F_LOG_ALL
|
261 0x1ULL
<< VHOST_USER_F_PROTOCOL_FEATURES
;
262 p
= (uint8_t *) &msg
;
263 qemu_chr_fe_write_all(chr
, p
, VHOST_USER_HDR_SIZE
+ msg
.size
);
266 case VHOST_USER_SET_FEATURES
:
267 g_assert_cmpint(msg
.payload
.u64
& (0x1ULL
<< VHOST_USER_F_PROTOCOL_FEATURES
),
271 case VHOST_USER_GET_PROTOCOL_FEATURES
:
272 /* send back features to qemu */
273 msg
.flags
|= VHOST_USER_REPLY_MASK
;
274 msg
.size
= sizeof(m
.payload
.u64
);
275 msg
.payload
.u64
= 1 << VHOST_USER_PROTOCOL_F_LOG_SHMFD
;
276 p
= (uint8_t *) &msg
;
277 qemu_chr_fe_write_all(chr
, p
, VHOST_USER_HDR_SIZE
+ msg
.size
);
280 case VHOST_USER_GET_VRING_BASE
:
281 /* send back vring base to qemu */
282 msg
.flags
|= VHOST_USER_REPLY_MASK
;
283 msg
.size
= sizeof(m
.payload
.state
);
284 msg
.payload
.state
.num
= 0;
285 p
= (uint8_t *) &msg
;
286 qemu_chr_fe_write_all(chr
, p
, VHOST_USER_HDR_SIZE
+ msg
.size
);
288 assert(msg
.payload
.state
.index
< 2);
289 s
->rings
&= ~(0x1ULL
<< msg
.payload
.state
.index
);
292 case VHOST_USER_SET_MEM_TABLE
:
293 /* received the mem table */
294 memcpy(&s
->memory
, &msg
.payload
.memory
, sizeof(msg
.payload
.memory
));
295 s
->fds_num
= qemu_chr_fe_get_msgfds(chr
, s
->fds
, G_N_ELEMENTS(s
->fds
));
297 /* signal the test that it can continue */
298 g_cond_signal(&s
->data_cond
);
301 case VHOST_USER_SET_VRING_KICK
:
302 case VHOST_USER_SET_VRING_CALL
:
304 qemu_chr_fe_get_msgfds(chr
, &fd
, 1);
306 * This is a non-blocking eventfd.
307 * The receive function forces it to be blocking,
308 * so revert it back to non-blocking.
310 qemu_set_nonblock(fd
);
313 case VHOST_USER_SET_LOG_BASE
:
314 if (s
->log_fd
!= -1) {
318 qemu_chr_fe_get_msgfds(chr
, &s
->log_fd
, 1);
319 msg
.flags
|= VHOST_USER_REPLY_MASK
;
321 p
= (uint8_t *) &msg
;
322 qemu_chr_fe_write_all(chr
, p
, VHOST_USER_HDR_SIZE
);
324 g_cond_signal(&s
->data_cond
);
327 case VHOST_USER_SET_VRING_BASE
:
328 assert(msg
.payload
.state
.index
< 2);
329 s
->rings
|= 0x1ULL
<< msg
.payload
.state
.index
;
336 g_mutex_unlock(&s
->data_mutex
);
339 static const char *init_hugepagefs(const char *path
)
344 if (access(path
, R_OK
| W_OK
| X_OK
)) {
345 g_test_message("access on path (%s): %s\n", path
, strerror(errno
));
350 ret
= statfs(path
, &fs
);
351 } while (ret
!= 0 && errno
== EINTR
);
354 g_test_message("statfs on path (%s): %s\n", path
, strerror(errno
));
358 if (fs
.f_type
!= HUGETLBFS_MAGIC
) {
359 g_test_message("Warning: path not on HugeTLBFS: %s\n", path
);
366 static TestServer
*test_server_new(const gchar
*name
)
368 TestServer
*server
= g_new0(TestServer
, 1);
370 server
->socket_path
= g_strdup_printf("%s/%s.sock", tmpfs
, name
);
371 server
->mig_path
= g_strdup_printf("%s/%s.mig", tmpfs
, name
);
372 server
->chr_name
= g_strdup_printf("chr-%s", name
);
374 g_mutex_init(&server
->data_mutex
);
375 g_cond_init(&server
->data_cond
);
382 static void test_server_create_chr(TestServer
*server
, const gchar
*opt
)
386 chr_path
= g_strdup_printf("unix:%s%s", server
->socket_path
, opt
);
387 server
->chr
= qemu_chr_new(server
->chr_name
, chr_path
, NULL
);
390 qemu_chr_add_handlers(server
->chr
, chr_can_read
, chr_read
, NULL
, server
);
393 static void test_server_listen(TestServer
*server
)
395 test_server_create_chr(server
, ",server,nowait");
398 static inline void test_server_connect(TestServer
*server
)
400 test_server_create_chr(server
, ",reconnect=1");
403 #define GET_QEMU_CMD(s) \
404 g_strdup_printf(QEMU_CMD, 512, 512, (root), (s)->chr_name, \
405 (s)->socket_path, "", (s)->chr_name)
407 #define GET_QEMU_CMDE(s, mem, chr_opts, extra, ...) \
408 g_strdup_printf(QEMU_CMD extra, (mem), (mem), (root), (s)->chr_name, \
409 (s)->socket_path, (chr_opts), (s)->chr_name, ##__VA_ARGS__)
411 static gboolean
_test_server_free(TestServer
*server
)
415 qemu_chr_delete(server
->chr
);
417 for (i
= 0; i
< server
->fds_num
; i
++) {
418 close(server
->fds
[i
]);
421 if (server
->log_fd
!= -1) {
422 close(server
->log_fd
);
425 unlink(server
->socket_path
);
426 g_free(server
->socket_path
);
428 unlink(server
->mig_path
);
429 g_free(server
->mig_path
);
431 g_free(server
->chr_name
);
437 static void test_server_free(TestServer
*server
)
439 g_idle_add((GSourceFunc
)_test_server_free
, server
);
442 static void wait_for_log_fd(TestServer
*s
)
446 g_mutex_lock(&s
->data_mutex
);
447 end_time
= g_get_monotonic_time() + 5 * G_TIME_SPAN_SECOND
;
448 while (s
->log_fd
== -1) {
449 if (!g_cond_wait_until(&s
->data_cond
, &s
->data_mutex
, end_time
)) {
450 /* timeout has passed */
451 g_assert(s
->log_fd
!= -1);
456 g_mutex_unlock(&s
->data_mutex
);
459 static void write_guest_mem(TestServer
*s
, uint32_t seed
)
467 /* iterate all regions */
468 for (i
= 0; i
< s
->fds_num
; i
++) {
470 /* We'll write only the region statring at 0x0 */
471 if (s
->memory
.regions
[i
].guest_phys_addr
!= 0x0) {
475 g_assert_cmpint(s
->memory
.regions
[i
].memory_size
, >, 1024);
477 size
= s
->memory
.regions
[i
].memory_size
+
478 s
->memory
.regions
[i
].mmap_offset
;
480 guest_mem
= mmap(0, size
, PROT_READ
| PROT_WRITE
,
481 MAP_SHARED
, s
->fds
[i
], 0);
483 g_assert(guest_mem
!= MAP_FAILED
);
484 guest_mem
+= (s
->memory
.regions
[i
].mmap_offset
/ sizeof(*guest_mem
));
486 for (j
= 0; j
< 256; j
++) {
487 guest_mem
[j
] = seed
+ j
;
490 munmap(guest_mem
, s
->memory
.regions
[i
].memory_size
);
495 static guint64
get_log_size(TestServer
*s
)
497 guint64 log_size
= 0;
500 for (i
= 0; i
< s
->memory
.nregions
; ++i
) {
501 VhostUserMemoryRegion
*reg
= &s
->memory
.regions
[i
];
502 guint64 last
= range_get_last(reg
->guest_phys_addr
,
504 log_size
= MAX(log_size
, last
/ (8 * VHOST_LOG_PAGE
) + 1);
510 typedef struct TestMigrateSource
{
517 test_migrate_source_check(GSource
*source
)
519 TestMigrateSource
*t
= (TestMigrateSource
*)source
;
520 gboolean overlap
= t
->src
->rings
&& t
->dest
->rings
;
527 #if !GLIB_CHECK_VERSION(2,36,0)
528 /* this callback is unnecessary with glib >2.36, the default
529 * prepare for the source does the same */
531 test_migrate_source_prepare(GSource
*source
, gint
*timeout
)
538 GSourceFuncs test_migrate_source_funcs
= {
539 #if !GLIB_CHECK_VERSION(2,36,0)
540 .prepare
= test_migrate_source_prepare
,
542 .check
= test_migrate_source_check
,
545 static void test_migrate(void)
547 TestServer
*s
= test_server_new("src");
548 TestServer
*dest
= test_server_new("dest");
549 char *uri
= g_strdup_printf("%s%s", "unix:", dest
->mig_path
);
550 QTestState
*global
= global_qtest
, *from
, *to
;
557 test_server_listen(s
);
558 test_server_listen(dest
);
560 cmd
= GET_QEMU_CMDE(s
, 2, "", "");
561 from
= qtest_start(cmd
);
565 size
= get_log_size(s
);
566 g_assert_cmpint(size
, ==, (2 * 1024 * 1024) / (VHOST_LOG_PAGE
* 8));
568 cmd
= GET_QEMU_CMDE(dest
, 2, "", " -incoming %s", uri
);
569 to
= qtest_init(cmd
);
572 source
= g_source_new(&test_migrate_source_funcs
,
573 sizeof(TestMigrateSource
));
574 ((TestMigrateSource
*)source
)->src
= s
;
575 ((TestMigrateSource
*)source
)->dest
= dest
;
576 g_source_attach(source
, NULL
);
578 /* slow down migration to have time to fiddle with log */
579 /* TODO: qtest could learn to break on some places */
580 rsp
= qmp("{ 'execute': 'migrate_set_speed',"
581 "'arguments': { 'value': 10 } }");
582 g_assert(qdict_haskey(rsp
, "return"));
585 cmd
= g_strdup_printf("{ 'execute': 'migrate',"
586 "'arguments': { 'uri': '%s' } }",
590 g_assert(qdict_haskey(rsp
, "return"));
595 log
= mmap(0, size
, PROT_READ
| PROT_WRITE
, MAP_SHARED
, s
->log_fd
, 0);
596 g_assert(log
!= MAP_FAILED
);
598 /* modify first page */
599 write_guest_mem(s
, 0x42);
603 /* speed things up */
604 rsp
= qmp("{ 'execute': 'migrate_set_speed',"
605 "'arguments': { 'value': 0 } }");
606 g_assert(qdict_haskey(rsp
, "return"));
609 qmp_eventwait("STOP");
612 qmp_eventwait("RESUME");
614 read_guest_mem(dest
);
616 g_source_destroy(source
);
617 g_source_unref(source
);
620 test_server_free(dest
);
625 global_qtest
= global
;
628 #ifdef CONFIG_HAS_GLIB_SUBPROCESS_TESTS
629 static void wait_for_rings_started(TestServer
*s
, size_t count
)
633 g_mutex_lock(&s
->data_mutex
);
634 end_time
= g_get_monotonic_time() + 5 * G_TIME_SPAN_SECOND
;
635 while (ctpop64(s
->rings
) != count
) {
636 if (!g_cond_wait_until(&s
->data_cond
, &s
->data_mutex
, end_time
)) {
637 /* timeout has passed */
638 g_assert_cmpint(ctpop64(s
->rings
), ==, count
);
643 g_mutex_unlock(&s
->data_mutex
);
647 reconnect_cb(gpointer user_data
)
649 TestServer
*s
= user_data
;
651 qemu_chr_disconnect(s
->chr
);
657 connect_thread(gpointer data
)
659 TestServer
*s
= data
;
661 /* wait for qemu to start before first try, to avoid extra warnings */
662 g_usleep(G_USEC_PER_SEC
);
663 test_server_connect(s
);
668 static void test_reconnect_subprocess(void)
670 TestServer
*s
= test_server_new("reconnect");
673 g_thread_new("connect", connect_thread
, s
);
674 cmd
= GET_QEMU_CMDE(s
, 2, ",server", "");
679 wait_for_rings_started(s
, 2);
684 g_idle_add(reconnect_cb
, s
);
686 wait_for_rings_started(s
, 2);
693 static void test_reconnect(void)
695 gchar
*path
= g_strdup_printf("/%s/vhost-user/reconnect/subprocess",
697 g_test_trap_subprocess(path
, 0, 0);
698 g_test_trap_assert_passed();
702 int main(int argc
, char **argv
)
704 QTestState
*s
= NULL
;
705 TestServer
*server
= NULL
;
707 char *qemu_cmd
= NULL
;
709 char template[] = "/tmp/vhost-test-XXXXXX";
713 g_test_init(&argc
, &argv
, NULL
);
715 module_call_init(MODULE_INIT_QOM
);
716 qemu_add_opts(&qemu_chardev_opts
);
718 tmpfs
= mkdtemp(template);
720 g_test_message("mkdtemp on path (%s): %s\n", template, strerror(errno
));
724 hugefs
= getenv("QTEST_HUGETLBFS_PATH");
726 root
= init_hugepagefs(hugefs
);
732 server
= test_server_new("test");
733 test_server_listen(server
);
735 loop
= g_main_loop_new(NULL
, FALSE
);
736 /* run the main loop thread so the chardev may operate */
737 thread
= g_thread_new(NULL
, thread_function
, loop
);
739 qemu_cmd
= GET_QEMU_CMD(server
);
741 s
= qtest_start(qemu_cmd
);
744 qtest_add_data_func("/vhost-user/read-guest-mem", server
, read_guest_mem
);
745 qtest_add_func("/vhost-user/migrate", test_migrate
);
746 #ifdef CONFIG_HAS_GLIB_SUBPROCESS_TESTS
747 qtest_add_func("/vhost-user/reconnect/subprocess",
748 test_reconnect_subprocess
);
749 qtest_add_func("/vhost-user/reconnect", test_reconnect
);
759 test_server_free(server
);
761 /* finish the helper thread and dispatch pending sources */
762 g_main_loop_quit(loop
);
763 g_thread_join(thread
);
764 while (g_main_context_pending(NULL
)) {
765 g_main_context_iteration (NULL
, TRUE
);
767 g_main_loop_unref(loop
);
771 g_test_message("unable to rmdir: path (%s): %s\n",
772 tmpfs
, strerror(errno
));
774 g_assert_cmpint(ret
, ==, 0);