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
11 #include "qemu/osdep.h"
12
13 #include "libqtest-single.h"
14 #include "qapi/error.h"
15 #include "qapi/qmp/qdict.h"
16 #include "qemu/config-file.h"
17 #include "qemu/option.h"
18 #include "qemu/range.h"
19 #include "qemu/sockets.h"
20 #include "chardev/char-fe.h"
21 #include "qemu/memfd.h"
22 #include "qemu/module.h"
23 #include "sysemu/sysemu.h"
24 #include "libqos/libqos.h"
25 #include "libqos/pci-pc.h"
26 #include "libqos/virtio-pci.h"
27
28 #include "libqos/malloc-pc.h"
29 #include "libqos/qgraph_internal.h"
30 #include "hw/virtio/virtio-net.h"
31
32 #include "standard-headers/linux/vhost_types.h"
33 #include "standard-headers/linux/virtio_ids.h"
34 #include "standard-headers/linux/virtio_net.h"
35 #include "standard-headers/linux/virtio_gpio.h"
36 #include "standard-headers/linux/virtio_scmi.h"
37
38 #ifdef CONFIG_LINUX
39 #include <sys/vfs.h>
40 #endif
41
42
43 #define QEMU_CMD_MEM " -m %d -object memory-backend-file,id=mem,size=%dM," \
44 "mem-path=%s,share=on -numa node,memdev=mem"
45 #define QEMU_CMD_MEMFD " -m %d -object memory-backend-memfd,id=mem,size=%dM," \
46 " -numa node,memdev=mem"
47 #define QEMU_CMD_SHM " -m %d -object memory-backend-shm,id=mem,size=%dM," \
48 " -numa node,memdev=mem"
49 #define QEMU_CMD_CHR " -chardev socket,id=%s,path=%s%s"
50 #define QEMU_CMD_NETDEV " -netdev vhost-user,id=hs0,chardev=%s,vhostforce=on"
51
52 #define HUGETLBFS_MAGIC 0x958458f6
53
54 /*********** FROM hw/virtio/vhost-user.c *************************************/
55
56 #define VHOST_MEMORY_MAX_NREGIONS 8
57 #define VHOST_MAX_VIRTQUEUES 0x100
58
59 #define VHOST_USER_F_PROTOCOL_FEATURES 30
60 #define VIRTIO_F_VERSION_1 32
61
62 #define VHOST_USER_PROTOCOL_F_MQ 0
63 #define VHOST_USER_PROTOCOL_F_LOG_SHMFD 1
64 #define VHOST_USER_PROTOCOL_F_CROSS_ENDIAN 6
65 #define VHOST_USER_PROTOCOL_F_CONFIG 9
66
67 #define VHOST_LOG_PAGE 0x1000
68
69 typedef enum VhostUserRequest {
70 VHOST_USER_NONE = 0,
71 VHOST_USER_GET_FEATURES = 1,
72 VHOST_USER_SET_FEATURES = 2,
73 VHOST_USER_SET_OWNER = 3,
74 VHOST_USER_RESET_OWNER = 4,
75 VHOST_USER_SET_MEM_TABLE = 5,
76 VHOST_USER_SET_LOG_BASE = 6,
77 VHOST_USER_SET_LOG_FD = 7,
78 VHOST_USER_SET_VRING_NUM = 8,
79 VHOST_USER_SET_VRING_ADDR = 9,
80 VHOST_USER_SET_VRING_BASE = 10,
81 VHOST_USER_GET_VRING_BASE = 11,
82 VHOST_USER_SET_VRING_KICK = 12,
83 VHOST_USER_SET_VRING_CALL = 13,
84 VHOST_USER_SET_VRING_ERR = 14,
85 VHOST_USER_GET_PROTOCOL_FEATURES = 15,
86 VHOST_USER_SET_PROTOCOL_FEATURES = 16,
87 VHOST_USER_GET_QUEUE_NUM = 17,
88 VHOST_USER_SET_VRING_ENABLE = 18,
89 VHOST_USER_GET_CONFIG = 24,
90 VHOST_USER_SET_CONFIG = 25,
91 VHOST_USER_MAX
92 } VhostUserRequest;
93
94 typedef struct VhostUserMemoryRegion {
95 uint64_t guest_phys_addr;
96 uint64_t memory_size;
97 uint64_t userspace_addr;
98 uint64_t mmap_offset;
99 } VhostUserMemoryRegion;
100
101 typedef struct VhostUserMemory {
102 uint32_t nregions;
103 uint32_t padding;
104 VhostUserMemoryRegion regions[VHOST_MEMORY_MAX_NREGIONS];
105 } VhostUserMemory;
106
107 typedef struct VhostUserLog {
108 uint64_t mmap_size;
109 uint64_t mmap_offset;
110 } VhostUserLog;
111
112 typedef struct VhostUserMsg {
113 VhostUserRequest request;
114
115 #define VHOST_USER_VERSION_MASK (0x3)
116 #define VHOST_USER_REPLY_MASK (0x1<<2)
117 uint32_t flags;
118 uint32_t size; /* the following payload size */
119 union {
120 #define VHOST_USER_VRING_IDX_MASK (0xff)
121 #define VHOST_USER_VRING_NOFD_MASK (0x1<<8)
122 uint64_t u64;
123 struct vhost_vring_state state;
124 struct vhost_vring_addr addr;
125 VhostUserMemory memory;
126 VhostUserLog log;
127 } payload;
128 } QEMU_PACKED VhostUserMsg;
129
130 static VhostUserMsg m __attribute__ ((unused));
131 #define VHOST_USER_HDR_SIZE (sizeof(m.request) \
132 + sizeof(m.flags) \
133 + sizeof(m.size))
134
135 #define VHOST_USER_PAYLOAD_SIZE (sizeof(m) - VHOST_USER_HDR_SIZE)
136
137 /* The version of the protocol we support */
138 #define VHOST_USER_VERSION (0x1)
139 /*****************************************************************************/
140
141 enum {
142 TEST_FLAGS_OK,
143 TEST_FLAGS_DISCONNECT,
144 TEST_FLAGS_BAD,
145 TEST_FLAGS_END,
146 };
147
148 enum {
149 VHOST_USER_NET,
150 VHOST_USER_GPIO,
151 VHOST_USER_SCMI,
152 };
153
154 typedef struct TestServer {
155 gchar *socket_path;
156 gchar *mig_path;
157 gchar *chr_name;
158 gchar *tmpfs;
159 CharBackend chr;
160 int fds_num;
161 int fds[VHOST_MEMORY_MAX_NREGIONS];
162 VhostUserMemory memory;
163 GMainContext *context;
164 GMainLoop *loop;
165 GThread *thread;
166 GMutex data_mutex;
167 GCond data_cond;
168 int log_fd;
169 uint64_t rings;
170 bool test_fail;
171 int test_flags;
172 int queues;
173 struct vhost_user_ops *vu_ops;
174 } TestServer;
175
176 struct vhost_user_ops {
177 /* Device types. */
178 int type;
179 void (*append_opts)(TestServer *s, GString *cmd_line,
180 const char *chr_opts);
181
182 /* VHOST-USER commands. */
183 uint64_t (*get_features)(TestServer *s);
184 void (*set_features)(TestServer *s, CharBackend *chr,
185 VhostUserMsg *msg);
186 void (*get_protocol_features)(TestServer *s,
187 CharBackend *chr, VhostUserMsg *msg);
188 };
189
190 static const char *init_hugepagefs(void);
191 static TestServer *test_server_new(const gchar *name,
192 struct vhost_user_ops *ops);
193 static void test_server_free(TestServer *server);
194 static void test_server_listen(TestServer *server);
195
196 enum test_memfd {
197 TEST_MEMFD_AUTO,
198 TEST_MEMFD_YES,
199 TEST_MEMFD_NO,
200 TEST_MEMFD_SHM,
201 };
202
append_vhost_net_opts(TestServer * s,GString * cmd_line,const char * chr_opts)203 static void append_vhost_net_opts(TestServer *s, GString *cmd_line,
204 const char *chr_opts)
205 {
206 g_string_append_printf(cmd_line, QEMU_CMD_CHR QEMU_CMD_NETDEV,
207 s->chr_name, s->socket_path,
208 chr_opts, s->chr_name);
209 }
210
211 /*
212 * For GPIO there are no other magic devices we need to add (like
213 * block or netdev) so all we need to worry about is the vhost-user
214 * chardev socket.
215 */
append_vhost_gpio_opts(TestServer * s,GString * cmd_line,const char * chr_opts)216 static void append_vhost_gpio_opts(TestServer *s, GString *cmd_line,
217 const char *chr_opts)
218 {
219 g_string_append_printf(cmd_line, QEMU_CMD_CHR,
220 s->chr_name, s->socket_path,
221 chr_opts);
222 }
223
append_mem_opts(TestServer * server,GString * cmd_line,int size,enum test_memfd memfd)224 static void append_mem_opts(TestServer *server, GString *cmd_line,
225 int size, enum test_memfd memfd)
226 {
227 if (memfd == TEST_MEMFD_AUTO) {
228 memfd = qemu_memfd_check(MFD_ALLOW_SEALING) ? TEST_MEMFD_YES
229 : TEST_MEMFD_NO;
230 }
231
232 if (memfd == TEST_MEMFD_YES) {
233 g_string_append_printf(cmd_line, QEMU_CMD_MEMFD, size, size);
234 } else if (memfd == TEST_MEMFD_SHM) {
235 g_string_append_printf(cmd_line, QEMU_CMD_SHM, size, size);
236 } else {
237 const char *root = init_hugepagefs() ? : server->tmpfs;
238
239 g_string_append_printf(cmd_line, QEMU_CMD_MEM, size, size, root);
240 }
241 }
242
wait_for_fds(TestServer * s)243 static bool wait_for_fds(TestServer *s)
244 {
245 gint64 end_time;
246 bool got_region;
247 int i;
248
249 g_mutex_lock(&s->data_mutex);
250
251 end_time = g_get_monotonic_time() + 5 * G_TIME_SPAN_SECOND;
252 while (!s->fds_num) {
253 if (!g_cond_wait_until(&s->data_cond, &s->data_mutex, end_time)) {
254 /* timeout has passed */
255 g_assert(s->fds_num);
256 break;
257 }
258 }
259
260 /* check for sanity */
261 g_assert_cmpint(s->fds_num, >, 0);
262 g_assert_cmpint(s->fds_num, ==, s->memory.nregions);
263
264 g_mutex_unlock(&s->data_mutex);
265
266 got_region = false;
267 for (i = 0; i < s->memory.nregions; ++i) {
268 VhostUserMemoryRegion *reg = &s->memory.regions[i];
269 if (reg->guest_phys_addr == 0) {
270 got_region = true;
271 break;
272 }
273 }
274 if (!got_region) {
275 g_test_skip("No memory at address 0x0");
276 }
277 return got_region;
278 }
279
read_guest_mem_server(QTestState * qts,TestServer * s)280 static void read_guest_mem_server(QTestState *qts, TestServer *s)
281 {
282 uint8_t *guest_mem;
283 int i, j;
284 size_t size;
285
286 g_mutex_lock(&s->data_mutex);
287
288 /* iterate all regions */
289 for (i = 0; i < s->fds_num; i++) {
290
291 /* We'll check only the region starting at 0x0 */
292 if (s->memory.regions[i].guest_phys_addr != 0x0) {
293 continue;
294 }
295
296 g_assert_cmpint(s->memory.regions[i].memory_size, >, 1024);
297
298 size = s->memory.regions[i].memory_size +
299 s->memory.regions[i].mmap_offset;
300
301 guest_mem = mmap(0, size, PROT_READ | PROT_WRITE,
302 MAP_SHARED, s->fds[i], 0);
303
304 g_assert(guest_mem != MAP_FAILED);
305 guest_mem += (s->memory.regions[i].mmap_offset / sizeof(*guest_mem));
306
307 for (j = 0; j < 1024; j++) {
308 uint32_t a = qtest_readb(qts, s->memory.regions[i].guest_phys_addr + j);
309 uint32_t b = guest_mem[j];
310
311 g_assert_cmpint(a, ==, b);
312 }
313
314 munmap(guest_mem, s->memory.regions[i].memory_size);
315 }
316
317 g_mutex_unlock(&s->data_mutex);
318 }
319
thread_function(void * data)320 static void *thread_function(void *data)
321 {
322 GMainLoop *loop = data;
323 g_main_loop_run(loop);
324 return NULL;
325 }
326
chr_can_read(void * opaque)327 static int chr_can_read(void *opaque)
328 {
329 return VHOST_USER_HDR_SIZE;
330 }
331
chr_read(void * opaque,const uint8_t * buf,int size)332 static void chr_read(void *opaque, const uint8_t *buf, int size)
333 {
334 g_autoptr(GError) err = NULL;
335 TestServer *s = opaque;
336 CharBackend *chr = &s->chr;
337 VhostUserMsg msg;
338 uint8_t *p = (uint8_t *) &msg;
339 int fd = -1;
340
341 if (s->test_fail) {
342 qemu_chr_fe_disconnect(chr);
343 /* now switch to non-failure */
344 s->test_fail = false;
345 }
346
347 if (size != VHOST_USER_HDR_SIZE) {
348 qos_printf("%s: Wrong message size received %d\n", __func__, size);
349 return;
350 }
351
352 g_mutex_lock(&s->data_mutex);
353 memcpy(p, buf, VHOST_USER_HDR_SIZE);
354
355 if (msg.size) {
356 p += VHOST_USER_HDR_SIZE;
357 size = qemu_chr_fe_read_all(chr, p, msg.size);
358 if (size != msg.size) {
359 qos_printf("%s: Wrong message size received %d != %d\n",
360 __func__, size, msg.size);
361 goto out;
362 }
363 }
364
365 switch (msg.request) {
366 case VHOST_USER_GET_FEATURES:
367 /* Mandatory for tests to define get_features */
368 g_assert(s->vu_ops->get_features);
369
370 /* send back features to qemu */
371 msg.flags |= VHOST_USER_REPLY_MASK;
372 msg.size = sizeof(m.payload.u64);
373
374 if (s->test_flags >= TEST_FLAGS_BAD) {
375 msg.payload.u64 = 0;
376 s->test_flags = TEST_FLAGS_END;
377 } else {
378 msg.payload.u64 = s->vu_ops->get_features(s);
379 }
380
381 qemu_chr_fe_write_all(chr, (uint8_t *) &msg,
382 VHOST_USER_HDR_SIZE + msg.size);
383 break;
384
385 case VHOST_USER_SET_FEATURES:
386 if (s->vu_ops->set_features) {
387 s->vu_ops->set_features(s, chr, &msg);
388 }
389 break;
390
391 case VHOST_USER_SET_OWNER:
392 /*
393 * We don't need to do anything here, the remote is just
394 * letting us know it is in charge. Just log it.
395 */
396 qos_printf("set_owner: start of session\n");
397 break;
398
399 case VHOST_USER_GET_PROTOCOL_FEATURES:
400 if (s->vu_ops->get_protocol_features) {
401 s->vu_ops->get_protocol_features(s, chr, &msg);
402 }
403 break;
404
405 case VHOST_USER_GET_CONFIG:
406 /*
407 * Treat GET_CONFIG as a NOP and just reply and let the guest
408 * consider we have updated its memory. Tests currently don't
409 * require working configs.
410 */
411 msg.flags |= VHOST_USER_REPLY_MASK;
412 p = (uint8_t *) &msg;
413 qemu_chr_fe_write_all(chr, p, VHOST_USER_HDR_SIZE + msg.size);
414 break;
415
416 case VHOST_USER_SET_PROTOCOL_FEATURES:
417 /*
418 * We did set VHOST_USER_F_PROTOCOL_FEATURES so its valid for
419 * the remote end to send this. There is no handshake reply so
420 * just log the details for debugging.
421 */
422 qos_printf("set_protocol_features: 0x%"PRIx64 "\n", msg.payload.u64);
423 break;
424
425 /*
426 * A real vhost-user backend would actually set the size and
427 * address of the vrings but we can simply report them.
428 */
429 case VHOST_USER_SET_VRING_NUM:
430 qos_printf("set_vring_num: %d/%d\n",
431 msg.payload.state.index, msg.payload.state.num);
432 break;
433 case VHOST_USER_SET_VRING_ADDR:
434 qos_printf("set_vring_addr: 0x%"PRIx64"/0x%"PRIx64"/0x%"PRIx64"\n",
435 msg.payload.addr.avail_user_addr,
436 msg.payload.addr.desc_user_addr,
437 msg.payload.addr.used_user_addr);
438 break;
439
440 case VHOST_USER_GET_VRING_BASE:
441 /* send back vring base to qemu */
442 msg.flags |= VHOST_USER_REPLY_MASK;
443 msg.size = sizeof(m.payload.state);
444 msg.payload.state.num = 0;
445 p = (uint8_t *) &msg;
446 qemu_chr_fe_write_all(chr, p, VHOST_USER_HDR_SIZE + msg.size);
447
448 assert(msg.payload.state.index < s->queues * 2);
449 s->rings &= ~(0x1ULL << msg.payload.state.index);
450 g_cond_broadcast(&s->data_cond);
451 break;
452
453 case VHOST_USER_SET_MEM_TABLE:
454 /* received the mem table */
455 memcpy(&s->memory, &msg.payload.memory, sizeof(msg.payload.memory));
456 s->fds_num = qemu_chr_fe_get_msgfds(chr, s->fds,
457 G_N_ELEMENTS(s->fds));
458
459 /* signal the test that it can continue */
460 g_cond_broadcast(&s->data_cond);
461 break;
462
463 case VHOST_USER_SET_VRING_KICK:
464 case VHOST_USER_SET_VRING_CALL:
465 /* consume the fd */
466 if (!qemu_chr_fe_get_msgfds(chr, &fd, 1) && fd < 0) {
467 qos_printf("call fd: %d, do not set non-blocking\n", fd);
468 break;
469 }
470 /*
471 * This is a non-blocking eventfd.
472 * The receive function forces it to be blocking,
473 * so revert it back to non-blocking.
474 */
475 g_unix_set_fd_nonblocking(fd, true, &err);
476 g_assert_no_error(err);
477 break;
478
479 case VHOST_USER_SET_LOG_BASE:
480 if (s->log_fd != -1) {
481 close(s->log_fd);
482 s->log_fd = -1;
483 }
484 qemu_chr_fe_get_msgfds(chr, &s->log_fd, 1);
485 msg.flags |= VHOST_USER_REPLY_MASK;
486 msg.size = 0;
487 p = (uint8_t *) &msg;
488 qemu_chr_fe_write_all(chr, p, VHOST_USER_HDR_SIZE);
489
490 g_cond_broadcast(&s->data_cond);
491 break;
492
493 case VHOST_USER_SET_VRING_BASE:
494 assert(msg.payload.state.index < s->queues * 2);
495 s->rings |= 0x1ULL << msg.payload.state.index;
496 g_cond_broadcast(&s->data_cond);
497 break;
498
499 case VHOST_USER_GET_QUEUE_NUM:
500 msg.flags |= VHOST_USER_REPLY_MASK;
501 msg.size = sizeof(m.payload.u64);
502 msg.payload.u64 = s->queues;
503 p = (uint8_t *) &msg;
504 qemu_chr_fe_write_all(chr, p, VHOST_USER_HDR_SIZE + msg.size);
505 break;
506
507 case VHOST_USER_SET_VRING_ENABLE:
508 /*
509 * Another case we ignore as we don't need to respond. With a
510 * fully functioning vhost-user we would enable/disable the
511 * vring monitoring.
512 */
513 qos_printf("set_vring(%d)=%s\n", msg.payload.state.index,
514 msg.payload.state.num ? "enabled" : "disabled");
515 break;
516
517 default:
518 qos_printf("vhost-user: un-handled message: %d\n", msg.request);
519 break;
520 }
521
522 out:
523 g_mutex_unlock(&s->data_mutex);
524 }
525
init_hugepagefs(void)526 static const char *init_hugepagefs(void)
527 {
528 #ifdef CONFIG_LINUX
529 static const char *hugepagefs;
530 const char *path = getenv("QTEST_HUGETLBFS_PATH");
531 struct statfs fs;
532 int ret;
533
534 if (hugepagefs) {
535 return hugepagefs;
536 }
537 if (!path) {
538 return NULL;
539 }
540
541 if (access(path, R_OK | W_OK | X_OK)) {
542 qos_printf("access on path (%s): %s", path, strerror(errno));
543 g_test_fail();
544 return NULL;
545 }
546
547 do {
548 ret = statfs(path, &fs);
549 } while (ret != 0 && errno == EINTR);
550
551 if (ret != 0) {
552 qos_printf("statfs on path (%s): %s", path, strerror(errno));
553 g_test_fail();
554 return NULL;
555 }
556
557 if (fs.f_type != HUGETLBFS_MAGIC) {
558 qos_printf("Warning: path not on HugeTLBFS: %s", path);
559 g_test_fail();
560 return NULL;
561 }
562
563 hugepagefs = path;
564 return hugepagefs;
565 #else
566 return NULL;
567 #endif
568 }
569
test_server_new(const gchar * name,struct vhost_user_ops * ops)570 static TestServer *test_server_new(const gchar *name,
571 struct vhost_user_ops *ops)
572 {
573 TestServer *server = g_new0(TestServer, 1);
574 g_autofree const char *tmpfs = NULL;
575 GError *err = NULL;
576
577 server->context = g_main_context_new();
578 server->loop = g_main_loop_new(server->context, FALSE);
579
580 /* run the main loop thread so the chardev may operate */
581 server->thread = g_thread_new(NULL, thread_function, server->loop);
582
583 tmpfs = g_dir_make_tmp("vhost-test-XXXXXX", &err);
584 if (!tmpfs) {
585 g_test_message("Can't create temporary directory in %s: %s",
586 g_get_tmp_dir(), err->message);
587 g_error_free(err);
588 }
589 g_assert(tmpfs);
590
591 server->tmpfs = g_strdup(tmpfs);
592 server->socket_path = g_strdup_printf("%s/%s.sock", tmpfs, name);
593 server->mig_path = g_strdup_printf("%s/%s.mig", tmpfs, name);
594 server->chr_name = g_strdup_printf("chr-%s", name);
595
596 g_mutex_init(&server->data_mutex);
597 g_cond_init(&server->data_cond);
598
599 server->log_fd = -1;
600 server->queues = 1;
601 server->vu_ops = ops;
602
603 return server;
604 }
605
chr_event(void * opaque,QEMUChrEvent event)606 static void chr_event(void *opaque, QEMUChrEvent event)
607 {
608 TestServer *s = opaque;
609
610 if (s->test_flags == TEST_FLAGS_END &&
611 event == CHR_EVENT_CLOSED) {
612 s->test_flags = TEST_FLAGS_OK;
613 }
614 }
615
test_server_create_chr(TestServer * server,const gchar * opt)616 static void test_server_create_chr(TestServer *server, const gchar *opt)
617 {
618 g_autofree gchar *chr_path = g_strdup_printf("unix:%s%s",
619 server->socket_path, opt);
620 Chardev *chr;
621
622 chr = qemu_chr_new(server->chr_name, chr_path, server->context);
623 g_assert(chr);
624
625 qemu_chr_fe_init(&server->chr, chr, &error_abort);
626 qemu_chr_fe_set_handlers(&server->chr, chr_can_read, chr_read,
627 chr_event, NULL, server, server->context, true);
628 }
629
test_server_listen(TestServer * server)630 static void test_server_listen(TestServer *server)
631 {
632 test_server_create_chr(server, ",server=on,wait=off");
633 }
634
test_server_free(TestServer * server)635 static void test_server_free(TestServer *server)
636 {
637 int i, ret;
638
639 /* finish the helper thread and dispatch pending sources */
640 g_main_loop_quit(server->loop);
641 g_thread_join(server->thread);
642 while (g_main_context_pending(NULL)) {
643 g_main_context_iteration(NULL, TRUE);
644 }
645
646 unlink(server->socket_path);
647 g_free(server->socket_path);
648
649 unlink(server->mig_path);
650 g_free(server->mig_path);
651
652 ret = rmdir(server->tmpfs);
653 if (ret != 0) {
654 g_test_message("unable to rmdir: path (%s): %s",
655 server->tmpfs, strerror(errno));
656 }
657 g_free(server->tmpfs);
658
659 qemu_chr_fe_deinit(&server->chr, true);
660
661 for (i = 0; i < server->fds_num; i++) {
662 close(server->fds[i]);
663 }
664
665 if (server->log_fd != -1) {
666 close(server->log_fd);
667 }
668
669 g_free(server->chr_name);
670
671 g_main_loop_unref(server->loop);
672 g_main_context_unref(server->context);
673 g_cond_clear(&server->data_cond);
674 g_mutex_clear(&server->data_mutex);
675 g_free(server);
676 }
677
wait_for_log_fd(TestServer * s)678 static void wait_for_log_fd(TestServer *s)
679 {
680 gint64 end_time;
681
682 g_mutex_lock(&s->data_mutex);
683 end_time = g_get_monotonic_time() + 5 * G_TIME_SPAN_SECOND;
684 while (s->log_fd == -1) {
685 if (!g_cond_wait_until(&s->data_cond, &s->data_mutex, end_time)) {
686 /* timeout has passed */
687 g_assert(s->log_fd != -1);
688 break;
689 }
690 }
691
692 g_mutex_unlock(&s->data_mutex);
693 }
694
write_guest_mem(TestServer * s,uint32_t seed)695 static void write_guest_mem(TestServer *s, uint32_t seed)
696 {
697 uint32_t *guest_mem;
698 int i, j;
699 size_t size;
700
701 /* iterate all regions */
702 for (i = 0; i < s->fds_num; i++) {
703
704 /* We'll write only the region statring at 0x0 */
705 if (s->memory.regions[i].guest_phys_addr != 0x0) {
706 continue;
707 }
708
709 g_assert_cmpint(s->memory.regions[i].memory_size, >, 1024);
710
711 size = s->memory.regions[i].memory_size +
712 s->memory.regions[i].mmap_offset;
713
714 guest_mem = mmap(0, size, PROT_READ | PROT_WRITE,
715 MAP_SHARED, s->fds[i], 0);
716
717 g_assert(guest_mem != MAP_FAILED);
718 guest_mem += (s->memory.regions[i].mmap_offset / sizeof(*guest_mem));
719
720 for (j = 0; j < 256; j++) {
721 guest_mem[j] = seed + j;
722 }
723
724 munmap(guest_mem, s->memory.regions[i].memory_size);
725 break;
726 }
727 }
728
get_log_size(TestServer * s)729 static guint64 get_log_size(TestServer *s)
730 {
731 guint64 log_size = 0;
732 int i;
733
734 for (i = 0; i < s->memory.nregions; ++i) {
735 VhostUserMemoryRegion *reg = &s->memory.regions[i];
736 guint64 last = range_get_last(reg->guest_phys_addr,
737 reg->memory_size);
738 log_size = MAX(log_size, last / (8 * VHOST_LOG_PAGE) + 1);
739 }
740
741 return log_size;
742 }
743
744 typedef struct TestMigrateSource {
745 GSource source;
746 TestServer *src;
747 TestServer *dest;
748 } TestMigrateSource;
749
750 static gboolean
test_migrate_source_check(GSource * source)751 test_migrate_source_check(GSource *source)
752 {
753 TestMigrateSource *t = (TestMigrateSource *)source;
754 gboolean overlap = t->src->rings && t->dest->rings;
755
756 g_assert(!overlap);
757
758 return FALSE;
759 }
760
761 GSourceFuncs test_migrate_source_funcs = {
762 .check = test_migrate_source_check,
763 };
764
vhost_user_test_cleanup(void * s)765 static void vhost_user_test_cleanup(void *s)
766 {
767 TestServer *server = s;
768
769 qos_invalidate_command_line();
770 test_server_free(server);
771 }
772
vhost_user_test_setup(GString * cmd_line,void * arg)773 static void *vhost_user_test_setup(GString *cmd_line, void *arg)
774 {
775 TestServer *server = test_server_new("vhost-user-test", arg);
776 test_server_listen(server);
777
778 append_mem_opts(server, cmd_line, 256, TEST_MEMFD_AUTO);
779 server->vu_ops->append_opts(server, cmd_line, "");
780
781 g_test_queue_destroy(vhost_user_test_cleanup, server);
782
783 return server;
784 }
785
vhost_user_test_setup_memfd(GString * cmd_line,void * arg)786 static void *vhost_user_test_setup_memfd(GString *cmd_line, void *arg)
787 {
788 TestServer *server = test_server_new("vhost-user-test", arg);
789 test_server_listen(server);
790
791 append_mem_opts(server, cmd_line, 256, TEST_MEMFD_YES);
792 server->vu_ops->append_opts(server, cmd_line, "");
793
794 g_test_queue_destroy(vhost_user_test_cleanup, server);
795
796 return server;
797 }
798
vhost_user_test_setup_shm(GString * cmd_line,void * arg)799 static void *vhost_user_test_setup_shm(GString *cmd_line, void *arg)
800 {
801 TestServer *server = test_server_new("vhost-user-test", arg);
802 test_server_listen(server);
803
804 append_mem_opts(server, cmd_line, 256, TEST_MEMFD_SHM);
805 server->vu_ops->append_opts(server, cmd_line, "");
806
807 g_test_queue_destroy(vhost_user_test_cleanup, server);
808
809 return server;
810 }
811
test_read_guest_mem(void * obj,void * arg,QGuestAllocator * alloc)812 static void test_read_guest_mem(void *obj, void *arg, QGuestAllocator *alloc)
813 {
814 TestServer *server = arg;
815
816 if (!wait_for_fds(server)) {
817 return;
818 }
819
820 read_guest_mem_server(global_qtest, server);
821 }
822
test_migrate(void * obj,void * arg,QGuestAllocator * alloc)823 static void test_migrate(void *obj, void *arg, QGuestAllocator *alloc)
824 {
825 TestServer *s = arg;
826 TestServer *dest;
827 GString *dest_cmdline;
828 char *uri;
829 QTestState *to;
830 GSource *source;
831 QDict *rsp;
832 guint8 *log;
833 guint64 size;
834
835 if (!wait_for_fds(s)) {
836 return;
837 }
838
839 dest = test_server_new("dest", s->vu_ops);
840 dest_cmdline = g_string_new(qos_get_current_command_line());
841 uri = g_strdup_printf("%s%s", "unix:", dest->mig_path);
842
843 size = get_log_size(s);
844 g_assert_cmpint(size, ==, (256 * 1024 * 1024) / (VHOST_LOG_PAGE * 8));
845
846 test_server_listen(dest);
847 g_string_append_printf(dest_cmdline, " -incoming %s", uri);
848 append_mem_opts(dest, dest_cmdline, 256, TEST_MEMFD_AUTO);
849 dest->vu_ops->append_opts(dest, dest_cmdline, "");
850 to = qtest_init(dest_cmdline->str);
851
852 /* This would be where you call qos_allocate_objects(to, NULL), if you want
853 * to talk to the QVirtioNet object on the destination.
854 */
855
856 source = g_source_new(&test_migrate_source_funcs,
857 sizeof(TestMigrateSource));
858 ((TestMigrateSource *)source)->src = s;
859 ((TestMigrateSource *)source)->dest = dest;
860 g_source_attach(source, s->context);
861
862 /* slow down migration to have time to fiddle with log */
863 /* TODO: qtest could learn to break on some places */
864 rsp = qmp("{ 'execute': 'migrate-set-parameters',"
865 "'arguments': { 'max-bandwidth': 10 } }");
866 g_assert(qdict_haskey(rsp, "return"));
867 qobject_unref(rsp);
868
869 rsp = qmp("{ 'execute': 'migrate', 'arguments': { 'uri': %s } }", uri);
870 g_assert(qdict_haskey(rsp, "return"));
871 qobject_unref(rsp);
872
873 wait_for_log_fd(s);
874
875 log = mmap(0, size, PROT_READ | PROT_WRITE, MAP_SHARED, s->log_fd, 0);
876 g_assert(log != MAP_FAILED);
877
878 /* modify first page */
879 write_guest_mem(s, 0x42);
880 log[0] = 1;
881 munmap(log, size);
882
883 /* speed things up */
884 rsp = qmp("{ 'execute': 'migrate-set-parameters',"
885 "'arguments': { 'max-bandwidth': 0 } }");
886 g_assert(qdict_haskey(rsp, "return"));
887 qobject_unref(rsp);
888
889 qmp_eventwait("STOP");
890 qtest_qmp_eventwait(to, "RESUME");
891
892 g_assert(wait_for_fds(dest));
893 read_guest_mem_server(to, dest);
894
895 g_source_destroy(source);
896 g_source_unref(source);
897
898 qtest_quit(to);
899 test_server_free(dest);
900 g_free(uri);
901 g_string_free(dest_cmdline, true);
902 }
903
wait_for_rings_started(TestServer * s,size_t count)904 static void wait_for_rings_started(TestServer *s, size_t count)
905 {
906 gint64 end_time;
907
908 g_mutex_lock(&s->data_mutex);
909 end_time = g_get_monotonic_time() + 5 * G_TIME_SPAN_SECOND;
910 while (ctpop64(s->rings) != count) {
911 if (!g_cond_wait_until(&s->data_cond, &s->data_mutex, end_time)) {
912 /* timeout has passed */
913 g_assert_cmpint(ctpop64(s->rings), ==, count);
914 break;
915 }
916 }
917
918 g_mutex_unlock(&s->data_mutex);
919 }
920
test_server_connect(TestServer * server)921 static inline void test_server_connect(TestServer *server)
922 {
923 test_server_create_chr(server, ",reconnect=1");
924 }
925
926 static gboolean
reconnect_cb(gpointer user_data)927 reconnect_cb(gpointer user_data)
928 {
929 TestServer *s = user_data;
930
931 qemu_chr_fe_disconnect(&s->chr);
932
933 return FALSE;
934 }
935
936 static gpointer
connect_thread(gpointer data)937 connect_thread(gpointer data)
938 {
939 TestServer *s = data;
940
941 /* wait for qemu to start before first try, to avoid extra warnings */
942 g_usleep(G_USEC_PER_SEC);
943 test_server_connect(s);
944
945 return NULL;
946 }
947
vhost_user_test_setup_reconnect(GString * cmd_line,void * arg)948 static void *vhost_user_test_setup_reconnect(GString *cmd_line, void *arg)
949 {
950 TestServer *s = test_server_new("reconnect", arg);
951
952 g_thread_unref(g_thread_new("connect", connect_thread, s));
953 append_mem_opts(s, cmd_line, 256, TEST_MEMFD_AUTO);
954 s->vu_ops->append_opts(s, cmd_line, ",server=on");
955
956 g_test_queue_destroy(vhost_user_test_cleanup, s);
957
958 return s;
959 }
960
test_reconnect(void * obj,void * arg,QGuestAllocator * alloc)961 static void test_reconnect(void *obj, void *arg, QGuestAllocator *alloc)
962 {
963 TestServer *s = arg;
964 GSource *src;
965
966 if (!wait_for_fds(s)) {
967 return;
968 }
969
970 wait_for_rings_started(s, 2);
971
972 /* reconnect */
973 s->fds_num = 0;
974 s->rings = 0;
975 src = g_idle_source_new();
976 g_source_set_callback(src, reconnect_cb, s, NULL);
977 g_source_attach(src, s->context);
978 g_source_unref(src);
979 g_assert(wait_for_fds(s));
980 wait_for_rings_started(s, 2);
981 }
982
vhost_user_test_setup_connect_fail(GString * cmd_line,void * arg)983 static void *vhost_user_test_setup_connect_fail(GString *cmd_line, void *arg)
984 {
985 TestServer *s = test_server_new("connect-fail", arg);
986
987 s->test_fail = true;
988
989 g_thread_unref(g_thread_new("connect", connect_thread, s));
990 append_mem_opts(s, cmd_line, 256, TEST_MEMFD_AUTO);
991 s->vu_ops->append_opts(s, cmd_line, ",server=on");
992
993 g_test_queue_destroy(vhost_user_test_cleanup, s);
994
995 return s;
996 }
997
vhost_user_test_setup_flags_mismatch(GString * cmd_line,void * arg)998 static void *vhost_user_test_setup_flags_mismatch(GString *cmd_line, void *arg)
999 {
1000 TestServer *s = test_server_new("flags-mismatch", arg);
1001
1002 s->test_flags = TEST_FLAGS_DISCONNECT;
1003
1004 g_thread_unref(g_thread_new("connect", connect_thread, s));
1005 append_mem_opts(s, cmd_line, 256, TEST_MEMFD_AUTO);
1006 s->vu_ops->append_opts(s, cmd_line, ",server=on");
1007
1008 g_test_queue_destroy(vhost_user_test_cleanup, s);
1009
1010 return s;
1011 }
1012
test_vhost_user_started(void * obj,void * arg,QGuestAllocator * alloc)1013 static void test_vhost_user_started(void *obj, void *arg, QGuestAllocator *alloc)
1014 {
1015 TestServer *s = arg;
1016
1017 if (!wait_for_fds(s)) {
1018 return;
1019 }
1020 wait_for_rings_started(s, 2);
1021 }
1022
vhost_user_test_setup_multiqueue(GString * cmd_line,void * arg)1023 static void *vhost_user_test_setup_multiqueue(GString *cmd_line, void *arg)
1024 {
1025 TestServer *s = vhost_user_test_setup(cmd_line, arg);
1026
1027 s->queues = 2;
1028 g_string_append_printf(cmd_line,
1029 " -set netdev.hs0.queues=%d"
1030 " -global virtio-net-pci.vectors=%d",
1031 s->queues, s->queues * 2 + 2);
1032
1033 return s;
1034 }
1035
test_multiqueue(void * obj,void * arg,QGuestAllocator * alloc)1036 static void test_multiqueue(void *obj, void *arg, QGuestAllocator *alloc)
1037 {
1038 TestServer *s = arg;
1039
1040 wait_for_rings_started(s, s->queues * 2);
1041 }
1042
1043
vu_net_get_features(TestServer * s)1044 static uint64_t vu_net_get_features(TestServer *s)
1045 {
1046 uint64_t features = 0x1ULL << VHOST_F_LOG_ALL |
1047 0x1ULL << VHOST_USER_F_PROTOCOL_FEATURES;
1048
1049 if (s->queues > 1) {
1050 features |= 0x1ULL << VIRTIO_NET_F_MQ;
1051 }
1052
1053 return features;
1054 }
1055
vu_net_set_features(TestServer * s,CharBackend * chr,VhostUserMsg * msg)1056 static void vu_net_set_features(TestServer *s, CharBackend *chr,
1057 VhostUserMsg *msg)
1058 {
1059 g_assert(msg->payload.u64 & (0x1ULL << VHOST_USER_F_PROTOCOL_FEATURES));
1060 if (s->test_flags == TEST_FLAGS_DISCONNECT) {
1061 qemu_chr_fe_disconnect(chr);
1062 s->test_flags = TEST_FLAGS_BAD;
1063 }
1064 }
1065
vu_net_get_protocol_features(TestServer * s,CharBackend * chr,VhostUserMsg * msg)1066 static void vu_net_get_protocol_features(TestServer *s, CharBackend *chr,
1067 VhostUserMsg *msg)
1068 {
1069 /* send back features to qemu */
1070 msg->flags |= VHOST_USER_REPLY_MASK;
1071 msg->size = sizeof(m.payload.u64);
1072 msg->payload.u64 = 1 << VHOST_USER_PROTOCOL_F_LOG_SHMFD;
1073 msg->payload.u64 |= 1 << VHOST_USER_PROTOCOL_F_CROSS_ENDIAN;
1074 if (s->queues > 1) {
1075 msg->payload.u64 |= 1 << VHOST_USER_PROTOCOL_F_MQ;
1076 }
1077 qemu_chr_fe_write_all(chr, (uint8_t *)msg, VHOST_USER_HDR_SIZE + msg->size);
1078 }
1079
1080 /* Each VHOST-USER device should have its ops structure defined. */
1081 static struct vhost_user_ops g_vu_net_ops = {
1082 .type = VHOST_USER_NET,
1083
1084 .append_opts = append_vhost_net_opts,
1085
1086 .get_features = vu_net_get_features,
1087 .set_features = vu_net_set_features,
1088 .get_protocol_features = vu_net_get_protocol_features,
1089 };
1090
register_vhost_user_test(void)1091 static void register_vhost_user_test(void)
1092 {
1093 QOSGraphTestOptions opts = {
1094 .before = vhost_user_test_setup,
1095 .subprocess = true,
1096 .arg = &g_vu_net_ops,
1097 };
1098
1099 qemu_add_opts(&qemu_chardev_opts);
1100
1101 qos_add_test("vhost-user/read-guest-mem/memfile",
1102 "virtio-net",
1103 test_read_guest_mem, &opts);
1104
1105 opts.before = vhost_user_test_setup_shm;
1106 qos_add_test("vhost-user/read-guest-mem/shm",
1107 "virtio-net",
1108 test_read_guest_mem, &opts);
1109
1110 if (qemu_memfd_check(MFD_ALLOW_SEALING)) {
1111 opts.before = vhost_user_test_setup_memfd;
1112 qos_add_test("vhost-user/read-guest-mem/memfd",
1113 "virtio-net",
1114 test_read_guest_mem, &opts);
1115 }
1116
1117 qos_add_test("vhost-user/migrate",
1118 "virtio-net",
1119 test_migrate, &opts);
1120
1121 opts.before = vhost_user_test_setup_reconnect;
1122 qos_add_test("vhost-user/reconnect", "virtio-net",
1123 test_reconnect, &opts);
1124
1125 opts.before = vhost_user_test_setup_connect_fail;
1126 qos_add_test("vhost-user/connect-fail", "virtio-net",
1127 test_vhost_user_started, &opts);
1128
1129 opts.before = vhost_user_test_setup_flags_mismatch;
1130 qos_add_test("vhost-user/flags-mismatch", "virtio-net",
1131 test_vhost_user_started, &opts);
1132
1133 opts.before = vhost_user_test_setup_multiqueue;
1134 opts.edge.extra_device_opts = "mq=on";
1135 qos_add_test("vhost-user/multiqueue",
1136 "virtio-net",
1137 test_multiqueue, &opts);
1138 }
1139 libqos_init(register_vhost_user_test);
1140
vu_gpio_get_features(TestServer * s)1141 static uint64_t vu_gpio_get_features(TestServer *s)
1142 {
1143 return 0x1ULL << VIRTIO_F_VERSION_1 |
1144 0x1ULL << VIRTIO_GPIO_F_IRQ |
1145 0x1ULL << VHOST_USER_F_PROTOCOL_FEATURES;
1146 }
1147
1148 /*
1149 * This stub can't handle all the message types but we should reply
1150 * that we support VHOST_USER_PROTOCOL_F_CONFIG as gpio would use it
1151 * talking to a read vhost-user daemon.
1152 */
vu_gpio_get_protocol_features(TestServer * s,CharBackend * chr,VhostUserMsg * msg)1153 static void vu_gpio_get_protocol_features(TestServer *s, CharBackend *chr,
1154 VhostUserMsg *msg)
1155 {
1156 /* send back features to qemu */
1157 msg->flags |= VHOST_USER_REPLY_MASK;
1158 msg->size = sizeof(m.payload.u64);
1159 msg->payload.u64 = 1ULL << VHOST_USER_PROTOCOL_F_CONFIG;
1160
1161 qemu_chr_fe_write_all(chr, (uint8_t *)msg, VHOST_USER_HDR_SIZE + msg->size);
1162 }
1163
1164 static struct vhost_user_ops g_vu_gpio_ops = {
1165 .type = VHOST_USER_GPIO,
1166
1167 .append_opts = append_vhost_gpio_opts,
1168
1169 .get_features = vu_gpio_get_features,
1170 .set_features = vu_net_set_features,
1171 .get_protocol_features = vu_gpio_get_protocol_features,
1172 };
1173
register_vhost_gpio_test(void)1174 static void register_vhost_gpio_test(void)
1175 {
1176 QOSGraphTestOptions opts = {
1177 .before = vhost_user_test_setup,
1178 .subprocess = true,
1179 .arg = &g_vu_gpio_ops,
1180 };
1181
1182 qemu_add_opts(&qemu_chardev_opts);
1183
1184 qos_add_test("read-guest-mem/memfile",
1185 "vhost-user-gpio", test_read_guest_mem, &opts);
1186 }
1187 libqos_init(register_vhost_gpio_test);
1188
vu_scmi_get_features(TestServer * s)1189 static uint64_t vu_scmi_get_features(TestServer *s)
1190 {
1191 return 0x1ULL << VIRTIO_F_VERSION_1 |
1192 0x1ULL << VIRTIO_SCMI_F_P2A_CHANNELS |
1193 0x1ULL << VHOST_USER_F_PROTOCOL_FEATURES;
1194 }
1195
vu_scmi_get_protocol_features(TestServer * s,CharBackend * chr,VhostUserMsg * msg)1196 static void vu_scmi_get_protocol_features(TestServer *s, CharBackend *chr,
1197 VhostUserMsg *msg)
1198 {
1199 msg->flags |= VHOST_USER_REPLY_MASK;
1200 msg->size = sizeof(m.payload.u64);
1201 msg->payload.u64 = 1ULL << VHOST_USER_PROTOCOL_F_MQ;
1202
1203 qemu_chr_fe_write_all(chr, (uint8_t *)msg, VHOST_USER_HDR_SIZE + msg->size);
1204 }
1205
1206 static struct vhost_user_ops g_vu_scmi_ops = {
1207 .type = VHOST_USER_SCMI,
1208
1209 .append_opts = append_vhost_gpio_opts,
1210
1211 .get_features = vu_scmi_get_features,
1212 .set_features = vu_net_set_features,
1213 .get_protocol_features = vu_scmi_get_protocol_features,
1214 };
1215
register_vhost_scmi_test(void)1216 static void register_vhost_scmi_test(void)
1217 {
1218 QOSGraphTestOptions opts = {
1219 .before = vhost_user_test_setup,
1220 .subprocess = true,
1221 .arg = &g_vu_scmi_ops,
1222 };
1223
1224 qemu_add_opts(&qemu_chardev_opts);
1225
1226 qos_add_test("scmi/read-guest-mem/memfile",
1227 "vhost-user-scmi", test_read_guest_mem, &opts);
1228 }
1229 libqos_init(register_vhost_scmi_test);
1230