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.
14 #include "qemu/option.h"
15 #include "sysemu/char.h"
16 #include "sysemu/sysemu.h"
18 #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 512 -object memory-backend-file,id=mem,size=512M,"\
34 "mem-path=%s,share=on -numa node,memdev=mem"
35 #define QEMU_CMD_CHR " -chardev socket,id=chr0,path=%s"
36 #define QEMU_CMD_NETDEV " -netdev vhost-user,id=net0,chardev=chr0,vhostforce"
37 #define QEMU_CMD_NET " -device virtio-net-pci,netdev=net0 "
38 #define QEMU_CMD_ROM " -option-rom ../pc-bios/pxe-virtio.rom"
40 #define QEMU_CMD QEMU_CMD_ACCEL QEMU_CMD_MEM QEMU_CMD_CHR \
41 QEMU_CMD_NETDEV QEMU_CMD_NET QEMU_CMD_ROM
43 #define HUGETLBFS_MAGIC 0x958458f6
45 /*********** FROM hw/virtio/vhost-user.c *************************************/
47 #define VHOST_MEMORY_MAX_NREGIONS 8
49 #define VHOST_USER_F_PROTOCOL_FEATURES 30
51 typedef enum VhostUserRequest
{
53 VHOST_USER_GET_FEATURES
= 1,
54 VHOST_USER_SET_FEATURES
= 2,
55 VHOST_USER_SET_OWNER
= 3,
56 VHOST_USER_RESET_DEVICE
= 4,
57 VHOST_USER_SET_MEM_TABLE
= 5,
58 VHOST_USER_SET_LOG_BASE
= 6,
59 VHOST_USER_SET_LOG_FD
= 7,
60 VHOST_USER_SET_VRING_NUM
= 8,
61 VHOST_USER_SET_VRING_ADDR
= 9,
62 VHOST_USER_SET_VRING_BASE
= 10,
63 VHOST_USER_GET_VRING_BASE
= 11,
64 VHOST_USER_SET_VRING_KICK
= 12,
65 VHOST_USER_SET_VRING_CALL
= 13,
66 VHOST_USER_SET_VRING_ERR
= 14,
67 VHOST_USER_GET_PROTOCOL_FEATURES
= 15,
68 VHOST_USER_SET_PROTOCOL_FEATURES
= 16,
72 typedef struct VhostUserMemoryRegion
{
73 uint64_t guest_phys_addr
;
75 uint64_t userspace_addr
;
77 } VhostUserMemoryRegion
;
79 typedef struct VhostUserMemory
{
82 VhostUserMemoryRegion regions
[VHOST_MEMORY_MAX_NREGIONS
];
85 typedef struct VhostUserMsg
{
86 VhostUserRequest request
;
88 #define VHOST_USER_VERSION_MASK (0x3)
89 #define VHOST_USER_REPLY_MASK (0x1<<2)
91 uint32_t size
; /* the following payload size */
94 struct vhost_vring_state state
;
95 struct vhost_vring_addr addr
;
96 VhostUserMemory memory
;
98 } QEMU_PACKED VhostUserMsg
;
100 static VhostUserMsg m
__attribute__ ((unused
));
101 #define VHOST_USER_HDR_SIZE (sizeof(m.request) \
105 #define VHOST_USER_PAYLOAD_SIZE (sizeof(m) - VHOST_USER_HDR_SIZE)
107 /* The version of the protocol we support */
108 #define VHOST_USER_VERSION (0x1)
109 /*****************************************************************************/
111 int fds_num
= 0, fds
[VHOST_MEMORY_MAX_NREGIONS
];
112 static VhostUserMemory memory
;
113 static CompatGMutex data_mutex
;
114 static CompatGCond data_cond
;
116 #if !GLIB_CHECK_VERSION(2, 32, 0)
117 static gboolean
g_cond_wait_until(CompatGCond cond
, CompatGMutex mutex
,
120 gboolean ret
= FALSE
;
121 end_time
-= g_get_monotonic_time();
122 GTimeVal time
= { end_time
/ G_TIME_SPAN_SECOND
,
123 end_time
% G_TIME_SPAN_SECOND
};
124 ret
= g_cond_timed_wait(cond
, mutex
, &time
);
129 static void read_guest_mem(void)
136 g_mutex_lock(&data_mutex
);
138 end_time
= g_get_monotonic_time() + 5 * G_TIME_SPAN_SECOND
;
140 if (!g_cond_wait_until(&data_cond
, &data_mutex
, end_time
)) {
141 /* timeout has passed */
147 /* check for sanity */
148 g_assert_cmpint(fds_num
, >, 0);
149 g_assert_cmpint(fds_num
, ==, memory
.nregions
);
151 /* iterate all regions */
152 for (i
= 0; i
< fds_num
; i
++) {
154 /* We'll check only the region statring at 0x0*/
155 if (memory
.regions
[i
].guest_phys_addr
!= 0x0) {
159 g_assert_cmpint(memory
.regions
[i
].memory_size
, >, 1024);
161 size
= memory
.regions
[i
].memory_size
+ memory
.regions
[i
].mmap_offset
;
163 guest_mem
= mmap(0, size
, PROT_READ
| PROT_WRITE
,
164 MAP_SHARED
, fds
[i
], 0);
166 g_assert(guest_mem
!= MAP_FAILED
);
167 guest_mem
+= (memory
.regions
[i
].mmap_offset
/ sizeof(*guest_mem
));
169 for (j
= 0; j
< 256; j
++) {
170 uint32_t a
= readl(memory
.regions
[i
].guest_phys_addr
+ j
*4);
171 uint32_t b
= guest_mem
[j
];
173 g_assert_cmpint(a
, ==, b
);
176 munmap(guest_mem
, memory
.regions
[i
].memory_size
);
179 g_assert_cmpint(1, ==, 1);
180 g_mutex_unlock(&data_mutex
);
183 static void *thread_function(void *data
)
186 loop
= g_main_loop_new(NULL
, FALSE
);
187 g_main_loop_run(loop
);
191 static int chr_can_read(void *opaque
)
193 return VHOST_USER_HDR_SIZE
;
196 static void chr_read(void *opaque
, const uint8_t *buf
, int size
)
198 CharDriverState
*chr
= opaque
;
200 uint8_t *p
= (uint8_t *) &msg
;
203 if (size
!= VHOST_USER_HDR_SIZE
) {
204 g_test_message("Wrong message size received %d\n", size
);
208 g_mutex_lock(&data_mutex
);
209 memcpy(p
, buf
, VHOST_USER_HDR_SIZE
);
212 p
+= VHOST_USER_HDR_SIZE
;
213 qemu_chr_fe_read_all(chr
, p
, msg
.size
);
216 switch (msg
.request
) {
217 case VHOST_USER_GET_FEATURES
:
218 /* send back features to qemu */
219 msg
.flags
|= VHOST_USER_REPLY_MASK
;
220 msg
.size
= sizeof(m
.u64
);
221 msg
.u64
= 0x1ULL
<< VHOST_USER_F_PROTOCOL_FEATURES
;
222 p
= (uint8_t *) &msg
;
223 qemu_chr_fe_write_all(chr
, p
, VHOST_USER_HDR_SIZE
+ msg
.size
);
226 case VHOST_USER_SET_FEATURES
:
227 g_assert_cmpint(msg
.u64
& (0x1ULL
<< VHOST_USER_F_PROTOCOL_FEATURES
),
231 case VHOST_USER_GET_PROTOCOL_FEATURES
:
232 /* send back features to qemu */
233 msg
.flags
|= VHOST_USER_REPLY_MASK
;
234 msg
.size
= sizeof(m
.u64
);
236 p
= (uint8_t *) &msg
;
237 qemu_chr_fe_write_all(chr
, p
, VHOST_USER_HDR_SIZE
+ msg
.size
);
240 case VHOST_USER_GET_VRING_BASE
:
241 /* send back vring base to qemu */
242 msg
.flags
|= VHOST_USER_REPLY_MASK
;
243 msg
.size
= sizeof(m
.state
);
245 p
= (uint8_t *) &msg
;
246 qemu_chr_fe_write_all(chr
, p
, VHOST_USER_HDR_SIZE
+ msg
.size
);
249 case VHOST_USER_SET_MEM_TABLE
:
250 /* received the mem table */
251 memcpy(&memory
, &msg
.memory
, sizeof(msg
.memory
));
252 fds_num
= qemu_chr_fe_get_msgfds(chr
, fds
, sizeof(fds
) / sizeof(int));
254 /* signal the test that it can continue */
255 g_cond_signal(&data_cond
);
258 case VHOST_USER_SET_VRING_KICK
:
259 case VHOST_USER_SET_VRING_CALL
:
261 qemu_chr_fe_get_msgfds(chr
, &fd
, 1);
263 * This is a non-blocking eventfd.
264 * The receive function forces it to be blocking,
265 * so revert it back to non-blocking.
267 qemu_set_nonblock(fd
);
272 g_mutex_unlock(&data_mutex
);
275 static const char *init_hugepagefs(const char *path
)
280 if (access(path
, R_OK
| W_OK
| X_OK
)) {
281 g_test_message("access on path (%s): %s\n", path
, strerror(errno
));
286 ret
= statfs(path
, &fs
);
287 } while (ret
!= 0 && errno
== EINTR
);
290 g_test_message("statfs on path (%s): %s\n", path
, strerror(errno
));
294 if (fs
.f_type
!= HUGETLBFS_MAGIC
) {
295 g_test_message("Warning: path not on HugeTLBFS: %s\n", path
);
302 int main(int argc
, char **argv
)
304 QTestState
*s
= NULL
;
305 CharDriverState
*chr
= NULL
;
307 char *socket_path
= 0;
311 char template[] = "/tmp/vhost-test-XXXXXX";
315 g_test_init(&argc
, &argv
, NULL
);
317 module_call_init(MODULE_INIT_QOM
);
319 tmpfs
= mkdtemp(template);
321 g_test_message("mkdtemp on path (%s): %s\n", template, strerror(errno
));
325 hugefs
= getenv("QTEST_HUGETLBFS_PATH");
327 root
= init_hugepagefs(hugefs
);
333 socket_path
= g_strdup_printf("%s/vhost.sock", tmpfs
);
335 /* create char dev and add read handlers */
336 qemu_add_opts(&qemu_chardev_opts
);
337 chr_path
= g_strdup_printf("unix:%s,server,nowait", socket_path
);
338 chr
= qemu_chr_new("chr0", chr_path
, NULL
);
340 qemu_chr_add_handlers(chr
, chr_can_read
, chr_read
, NULL
, chr
);
342 /* run the main loop thread so the chardev may operate */
343 g_mutex_init(&data_mutex
);
344 g_cond_init(&data_cond
);
345 g_thread_new(NULL
, thread_function
, NULL
);
347 qemu_cmd
= g_strdup_printf(QEMU_CMD
, root
, socket_path
);
348 s
= qtest_start(qemu_cmd
);
351 qtest_add_func("/vhost-user/read-guest-mem", read_guest_mem
);
365 g_test_message("unable to rmdir: path (%s): %s\n",
366 tmpfs
, strerror(errno
));
368 g_assert_cmpint(ret
, ==, 0);