1
2
3
4
5
6
7
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 "hw/virtio/virtio-net.h"
30
31#include "standard-headers/linux/vhost_types.h"
32#include "standard-headers/linux/virtio_ids.h"
33#include "standard-headers/linux/virtio_net.h"
34
35#ifdef CONFIG_LINUX
36#include <sys/vfs.h>
37#endif
38
39
40#define QEMU_CMD_MEM " -m %d -object memory-backend-file,id=mem,size=%dM," \
41 "mem-path=%s,share=on -numa node,memdev=mem"
42#define QEMU_CMD_MEMFD " -m %d -object memory-backend-memfd,id=mem,size=%dM," \
43 " -numa node,memdev=mem"
44#define QEMU_CMD_CHR " -chardev socket,id=%s,path=%s%s"
45#define QEMU_CMD_NETDEV " -netdev vhost-user,id=hs0,chardev=%s,vhostforce=on"
46
47#define HUGETLBFS_MAGIC 0x958458f6
48
49
50
51#define VHOST_MEMORY_MAX_NREGIONS 8
52#define VHOST_MAX_VIRTQUEUES 0x100
53
54#define VHOST_USER_F_PROTOCOL_FEATURES 30
55#define VHOST_USER_PROTOCOL_F_MQ 0
56#define VHOST_USER_PROTOCOL_F_LOG_SHMFD 1
57#define VHOST_USER_PROTOCOL_F_CROSS_ENDIAN 6
58
59#define VHOST_LOG_PAGE 0x1000
60
61typedef enum VhostUserRequest {
62 VHOST_USER_NONE = 0,
63 VHOST_USER_GET_FEATURES = 1,
64 VHOST_USER_SET_FEATURES = 2,
65 VHOST_USER_SET_OWNER = 3,
66 VHOST_USER_RESET_OWNER = 4,
67 VHOST_USER_SET_MEM_TABLE = 5,
68 VHOST_USER_SET_LOG_BASE = 6,
69 VHOST_USER_SET_LOG_FD = 7,
70 VHOST_USER_SET_VRING_NUM = 8,
71 VHOST_USER_SET_VRING_ADDR = 9,
72 VHOST_USER_SET_VRING_BASE = 10,
73 VHOST_USER_GET_VRING_BASE = 11,
74 VHOST_USER_SET_VRING_KICK = 12,
75 VHOST_USER_SET_VRING_CALL = 13,
76 VHOST_USER_SET_VRING_ERR = 14,
77 VHOST_USER_GET_PROTOCOL_FEATURES = 15,
78 VHOST_USER_SET_PROTOCOL_FEATURES = 16,
79 VHOST_USER_GET_QUEUE_NUM = 17,
80 VHOST_USER_SET_VRING_ENABLE = 18,
81 VHOST_USER_MAX
82} VhostUserRequest;
83
84typedef struct VhostUserMemoryRegion {
85 uint64_t guest_phys_addr;
86 uint64_t memory_size;
87 uint64_t userspace_addr;
88 uint64_t mmap_offset;
89} VhostUserMemoryRegion;
90
91typedef struct VhostUserMemory {
92 uint32_t nregions;
93 uint32_t padding;
94 VhostUserMemoryRegion regions[VHOST_MEMORY_MAX_NREGIONS];
95} VhostUserMemory;
96
97typedef struct VhostUserLog {
98 uint64_t mmap_size;
99 uint64_t mmap_offset;
100} VhostUserLog;
101
102typedef struct VhostUserMsg {
103 VhostUserRequest request;
104
105#define VHOST_USER_VERSION_MASK (0x3)
106#define VHOST_USER_REPLY_MASK (0x1<<2)
107 uint32_t flags;
108 uint32_t size;
109 union {
110#define VHOST_USER_VRING_IDX_MASK (0xff)
111#define VHOST_USER_VRING_NOFD_MASK (0x1<<8)
112 uint64_t u64;
113 struct vhost_vring_state state;
114 struct vhost_vring_addr addr;
115 VhostUserMemory memory;
116 VhostUserLog log;
117 } payload;
118} QEMU_PACKED VhostUserMsg;
119
120static VhostUserMsg m __attribute__ ((unused));
121#define VHOST_USER_HDR_SIZE (sizeof(m.request) \
122 + sizeof(m.flags) \
123 + sizeof(m.size))
124
125#define VHOST_USER_PAYLOAD_SIZE (sizeof(m) - VHOST_USER_HDR_SIZE)
126
127
128#define VHOST_USER_VERSION (0x1)
129
130
131enum {
132 TEST_FLAGS_OK,
133 TEST_FLAGS_DISCONNECT,
134 TEST_FLAGS_BAD,
135 TEST_FLAGS_END,
136};
137
138enum {
139 VHOST_USER_NET,
140};
141
142typedef struct TestServer {
143 gchar *socket_path;
144 gchar *mig_path;
145 gchar *chr_name;
146 gchar *tmpfs;
147 CharBackend chr;
148 int fds_num;
149 int fds[VHOST_MEMORY_MAX_NREGIONS];
150 VhostUserMemory memory;
151 GMainContext *context;
152 GMainLoop *loop;
153 GThread *thread;
154 GMutex data_mutex;
155 GCond data_cond;
156 int log_fd;
157 uint64_t rings;
158 bool test_fail;
159 int test_flags;
160 int queues;
161 struct vhost_user_ops *vu_ops;
162} TestServer;
163
164struct vhost_user_ops {
165
166 int type;
167 void (*append_opts)(TestServer *s, GString *cmd_line,
168 const char *chr_opts);
169
170
171 void (*set_features)(TestServer *s, CharBackend *chr,
172 VhostUserMsg *msg);
173 void (*get_protocol_features)(TestServer *s,
174 CharBackend *chr, VhostUserMsg *msg);
175};
176
177static const char *init_hugepagefs(void);
178static TestServer *test_server_new(const gchar *name,
179 struct vhost_user_ops *ops);
180static void test_server_free(TestServer *server);
181static void test_server_listen(TestServer *server);
182
183enum test_memfd {
184 TEST_MEMFD_AUTO,
185 TEST_MEMFD_YES,
186 TEST_MEMFD_NO,
187};
188
189static void append_vhost_net_opts(TestServer *s, GString *cmd_line,
190 const char *chr_opts)
191{
192 g_string_append_printf(cmd_line, QEMU_CMD_CHR QEMU_CMD_NETDEV,
193 s->chr_name, s->socket_path,
194 chr_opts, s->chr_name);
195}
196
197static void append_mem_opts(TestServer *server, GString *cmd_line,
198 int size, enum test_memfd memfd)
199{
200 if (memfd == TEST_MEMFD_AUTO) {
201 memfd = qemu_memfd_check(MFD_ALLOW_SEALING) ? TEST_MEMFD_YES
202 : TEST_MEMFD_NO;
203 }
204
205 if (memfd == TEST_MEMFD_YES) {
206 g_string_append_printf(cmd_line, QEMU_CMD_MEMFD, size, size);
207 } else {
208 const char *root = init_hugepagefs() ? : server->tmpfs;
209
210 g_string_append_printf(cmd_line, QEMU_CMD_MEM, size, size, root);
211 }
212}
213
214static bool wait_for_fds(TestServer *s)
215{
216 gint64 end_time;
217 bool got_region;
218 int i;
219
220 g_mutex_lock(&s->data_mutex);
221
222 end_time = g_get_monotonic_time() + 5 * G_TIME_SPAN_SECOND;
223 while (!s->fds_num) {
224 if (!g_cond_wait_until(&s->data_cond, &s->data_mutex, end_time)) {
225
226 g_assert(s->fds_num);
227 break;
228 }
229 }
230
231
232 g_assert_cmpint(s->fds_num, >, 0);
233 g_assert_cmpint(s->fds_num, ==, s->memory.nregions);
234
235 g_mutex_unlock(&s->data_mutex);
236
237 got_region = false;
238 for (i = 0; i < s->memory.nregions; ++i) {
239 VhostUserMemoryRegion *reg = &s->memory.regions[i];
240 if (reg->guest_phys_addr == 0) {
241 got_region = true;
242 break;
243 }
244 }
245 if (!got_region) {
246 g_test_skip("No memory at address 0x0");
247 }
248 return got_region;
249}
250
251static void read_guest_mem_server(QTestState *qts, TestServer *s)
252{
253 uint8_t *guest_mem;
254 int i, j;
255 size_t size;
256
257 g_mutex_lock(&s->data_mutex);
258
259
260 for (i = 0; i < s->fds_num; i++) {
261
262
263 if (s->memory.regions[i].guest_phys_addr != 0x0) {
264 continue;
265 }
266
267 g_assert_cmpint(s->memory.regions[i].memory_size, >, 1024);
268
269 size = s->memory.regions[i].memory_size +
270 s->memory.regions[i].mmap_offset;
271
272 guest_mem = mmap(0, size, PROT_READ | PROT_WRITE,
273 MAP_SHARED, s->fds[i], 0);
274
275 g_assert(guest_mem != MAP_FAILED);
276 guest_mem += (s->memory.regions[i].mmap_offset / sizeof(*guest_mem));
277
278 for (j = 0; j < 1024; j++) {
279 uint32_t a = qtest_readb(qts, s->memory.regions[i].guest_phys_addr + j);
280 uint32_t b = guest_mem[j];
281
282 g_assert_cmpint(a, ==, b);
283 }
284
285 munmap(guest_mem, s->memory.regions[i].memory_size);
286 }
287
288 g_mutex_unlock(&s->data_mutex);
289}
290
291static void *thread_function(void *data)
292{
293 GMainLoop *loop = data;
294 g_main_loop_run(loop);
295 return NULL;
296}
297
298static int chr_can_read(void *opaque)
299{
300 return VHOST_USER_HDR_SIZE;
301}
302
303static void chr_read(void *opaque, const uint8_t *buf, int size)
304{
305 g_autoptr(GError) err = NULL;
306 TestServer *s = opaque;
307 CharBackend *chr = &s->chr;
308 VhostUserMsg msg;
309 uint8_t *p = (uint8_t *) &msg;
310 int fd = -1;
311
312 if (s->test_fail) {
313 qemu_chr_fe_disconnect(chr);
314
315 s->test_fail = false;
316 }
317
318 if (size != VHOST_USER_HDR_SIZE) {
319 g_test_message("Wrong message size received %d", size);
320 return;
321 }
322
323 g_mutex_lock(&s->data_mutex);
324 memcpy(p, buf, VHOST_USER_HDR_SIZE);
325
326 if (msg.size) {
327 p += VHOST_USER_HDR_SIZE;
328 size = qemu_chr_fe_read_all(chr, p, msg.size);
329 if (size != msg.size) {
330 g_test_message("Wrong message size received %d != %d",
331 size, msg.size);
332 return;
333 }
334 }
335
336 switch (msg.request) {
337 case VHOST_USER_GET_FEATURES:
338
339 msg.flags |= VHOST_USER_REPLY_MASK;
340 msg.size = sizeof(m.payload.u64);
341 msg.payload.u64 = 0x1ULL << VHOST_F_LOG_ALL |
342 0x1ULL << VHOST_USER_F_PROTOCOL_FEATURES;
343 if (s->queues > 1) {
344 msg.payload.u64 |= 0x1ULL << VIRTIO_NET_F_MQ;
345 }
346 if (s->test_flags >= TEST_FLAGS_BAD) {
347 msg.payload.u64 = 0;
348 s->test_flags = TEST_FLAGS_END;
349 }
350 p = (uint8_t *) &msg;
351 qemu_chr_fe_write_all(chr, p, VHOST_USER_HDR_SIZE + msg.size);
352 break;
353
354 case VHOST_USER_SET_FEATURES:
355 if (s->vu_ops->set_features) {
356 s->vu_ops->set_features(s, chr, &msg);
357 }
358 break;
359
360 case VHOST_USER_GET_PROTOCOL_FEATURES:
361 if (s->vu_ops->get_protocol_features) {
362 s->vu_ops->get_protocol_features(s, chr, &msg);
363 }
364 break;
365
366 case VHOST_USER_GET_VRING_BASE:
367
368 msg.flags |= VHOST_USER_REPLY_MASK;
369 msg.size = sizeof(m.payload.state);
370 msg.payload.state.num = 0;
371 p = (uint8_t *) &msg;
372 qemu_chr_fe_write_all(chr, p, VHOST_USER_HDR_SIZE + msg.size);
373
374 assert(msg.payload.state.index < s->queues * 2);
375 s->rings &= ~(0x1ULL << msg.payload.state.index);
376 g_cond_broadcast(&s->data_cond);
377 break;
378
379 case VHOST_USER_SET_MEM_TABLE:
380
381 memcpy(&s->memory, &msg.payload.memory, sizeof(msg.payload.memory));
382 s->fds_num = qemu_chr_fe_get_msgfds(chr, s->fds,
383 G_N_ELEMENTS(s->fds));
384
385
386 g_cond_broadcast(&s->data_cond);
387 break;
388
389 case VHOST_USER_SET_VRING_KICK:
390 case VHOST_USER_SET_VRING_CALL:
391
392 qemu_chr_fe_get_msgfds(chr, &fd, 1);
393
394
395
396
397
398 g_unix_set_fd_nonblocking(fd, true, &err);
399 g_assert_no_error(err);
400 break;
401
402 case VHOST_USER_SET_LOG_BASE:
403 if (s->log_fd != -1) {
404 close(s->log_fd);
405 s->log_fd = -1;
406 }
407 qemu_chr_fe_get_msgfds(chr, &s->log_fd, 1);
408 msg.flags |= VHOST_USER_REPLY_MASK;
409 msg.size = 0;
410 p = (uint8_t *) &msg;
411 qemu_chr_fe_write_all(chr, p, VHOST_USER_HDR_SIZE);
412
413 g_cond_broadcast(&s->data_cond);
414 break;
415
416 case VHOST_USER_SET_VRING_BASE:
417 assert(msg.payload.state.index < s->queues * 2);
418 s->rings |= 0x1ULL << msg.payload.state.index;
419 g_cond_broadcast(&s->data_cond);
420 break;
421
422 case VHOST_USER_GET_QUEUE_NUM:
423 msg.flags |= VHOST_USER_REPLY_MASK;
424 msg.size = sizeof(m.payload.u64);
425 msg.payload.u64 = s->queues;
426 p = (uint8_t *) &msg;
427 qemu_chr_fe_write_all(chr, p, VHOST_USER_HDR_SIZE + msg.size);
428 break;
429
430 default:
431 break;
432 }
433
434 g_mutex_unlock(&s->data_mutex);
435}
436
437static const char *init_hugepagefs(void)
438{
439#ifdef CONFIG_LINUX
440 static const char *hugepagefs;
441 const char *path = getenv("QTEST_HUGETLBFS_PATH");
442 struct statfs fs;
443 int ret;
444
445 if (hugepagefs) {
446 return hugepagefs;
447 }
448 if (!path) {
449 return NULL;
450 }
451
452 if (access(path, R_OK | W_OK | X_OK)) {
453 g_test_message("access on path (%s): %s", path, strerror(errno));
454 g_test_fail();
455 return NULL;
456 }
457
458 do {
459 ret = statfs(path, &fs);
460 } while (ret != 0 && errno == EINTR);
461
462 if (ret != 0) {
463 g_test_message("statfs on path (%s): %s", path, strerror(errno));
464 g_test_fail();
465 return NULL;
466 }
467
468 if (fs.f_type != HUGETLBFS_MAGIC) {
469 g_test_message("Warning: path not on HugeTLBFS: %s", path);
470 g_test_fail();
471 return NULL;
472 }
473
474 hugepagefs = path;
475 return hugepagefs;
476#else
477 return NULL;
478#endif
479}
480
481static TestServer *test_server_new(const gchar *name,
482 struct vhost_user_ops *ops)
483{
484 TestServer *server = g_new0(TestServer, 1);
485 char template[] = "/tmp/vhost-test-XXXXXX";
486 const char *tmpfs;
487
488 server->context = g_main_context_new();
489 server->loop = g_main_loop_new(server->context, FALSE);
490
491
492 server->thread = g_thread_new(NULL, thread_function, server->loop);
493
494 tmpfs = mkdtemp(template);
495 if (!tmpfs) {
496 g_test_message("mkdtemp on path (%s): %s", template, strerror(errno));
497 }
498 g_assert(tmpfs);
499
500 server->tmpfs = g_strdup(tmpfs);
501 server->socket_path = g_strdup_printf("%s/%s.sock", tmpfs, name);
502 server->mig_path = g_strdup_printf("%s/%s.mig", tmpfs, name);
503 server->chr_name = g_strdup_printf("chr-%s", name);
504
505 g_mutex_init(&server->data_mutex);
506 g_cond_init(&server->data_cond);
507
508 server->log_fd = -1;
509 server->queues = 1;
510 server->vu_ops = ops;
511
512 return server;
513}
514
515static void chr_event(void *opaque, QEMUChrEvent event)
516{
517 TestServer *s = opaque;
518
519 if (s->test_flags == TEST_FLAGS_END &&
520 event == CHR_EVENT_CLOSED) {
521 s->test_flags = TEST_FLAGS_OK;
522 }
523}
524
525static void test_server_create_chr(TestServer *server, const gchar *opt)
526{
527 g_autofree gchar *chr_path = g_strdup_printf("unix:%s%s",
528 server->socket_path, opt);
529 Chardev *chr;
530
531 chr = qemu_chr_new(server->chr_name, chr_path, server->context);
532 g_assert(chr);
533
534 qemu_chr_fe_init(&server->chr, chr, &error_abort);
535 qemu_chr_fe_set_handlers(&server->chr, chr_can_read, chr_read,
536 chr_event, NULL, server, server->context, true);
537}
538
539static void test_server_listen(TestServer *server)
540{
541 test_server_create_chr(server, ",server=on,wait=off");
542}
543
544static void test_server_free(TestServer *server)
545{
546 int i, ret;
547
548
549 g_main_loop_quit(server->loop);
550 g_thread_join(server->thread);
551 while (g_main_context_pending(NULL)) {
552 g_main_context_iteration(NULL, TRUE);
553 }
554
555 unlink(server->socket_path);
556 g_free(server->socket_path);
557
558 unlink(server->mig_path);
559 g_free(server->mig_path);
560
561 ret = rmdir(server->tmpfs);
562 if (ret != 0) {
563 g_test_message("unable to rmdir: path (%s): %s",
564 server->tmpfs, strerror(errno));
565 }
566 g_free(server->tmpfs);
567
568 qemu_chr_fe_deinit(&server->chr, true);
569
570 for (i = 0; i < server->fds_num; i++) {
571 close(server->fds[i]);
572 }
573
574 if (server->log_fd != -1) {
575 close(server->log_fd);
576 }
577
578 g_free(server->chr_name);
579
580 g_main_loop_unref(server->loop);
581 g_main_context_unref(server->context);
582 g_cond_clear(&server->data_cond);
583 g_mutex_clear(&server->data_mutex);
584 g_free(server);
585}
586
587static void wait_for_log_fd(TestServer *s)
588{
589 gint64 end_time;
590
591 g_mutex_lock(&s->data_mutex);
592 end_time = g_get_monotonic_time() + 5 * G_TIME_SPAN_SECOND;
593 while (s->log_fd == -1) {
594 if (!g_cond_wait_until(&s->data_cond, &s->data_mutex, end_time)) {
595
596 g_assert(s->log_fd != -1);
597 break;
598 }
599 }
600
601 g_mutex_unlock(&s->data_mutex);
602}
603
604static void write_guest_mem(TestServer *s, uint32_t seed)
605{
606 uint32_t *guest_mem;
607 int i, j;
608 size_t size;
609
610
611 for (i = 0; i < s->fds_num; i++) {
612
613
614 if (s->memory.regions[i].guest_phys_addr != 0x0) {
615 continue;
616 }
617
618 g_assert_cmpint(s->memory.regions[i].memory_size, >, 1024);
619
620 size = s->memory.regions[i].memory_size +
621 s->memory.regions[i].mmap_offset;
622
623 guest_mem = mmap(0, size, PROT_READ | PROT_WRITE,
624 MAP_SHARED, s->fds[i], 0);
625
626 g_assert(guest_mem != MAP_FAILED);
627 guest_mem += (s->memory.regions[i].mmap_offset / sizeof(*guest_mem));
628
629 for (j = 0; j < 256; j++) {
630 guest_mem[j] = seed + j;
631 }
632
633 munmap(guest_mem, s->memory.regions[i].memory_size);
634 break;
635 }
636}
637
638static guint64 get_log_size(TestServer *s)
639{
640 guint64 log_size = 0;
641 int i;
642
643 for (i = 0; i < s->memory.nregions; ++i) {
644 VhostUserMemoryRegion *reg = &s->memory.regions[i];
645 guint64 last = range_get_last(reg->guest_phys_addr,
646 reg->memory_size);
647 log_size = MAX(log_size, last / (8 * VHOST_LOG_PAGE) + 1);
648 }
649
650 return log_size;
651}
652
653typedef struct TestMigrateSource {
654 GSource source;
655 TestServer *src;
656 TestServer *dest;
657} TestMigrateSource;
658
659static gboolean
660test_migrate_source_check(GSource *source)
661{
662 TestMigrateSource *t = (TestMigrateSource *)source;
663 gboolean overlap = t->src->rings && t->dest->rings;
664
665 g_assert(!overlap);
666
667 return FALSE;
668}
669
670GSourceFuncs test_migrate_source_funcs = {
671 .check = test_migrate_source_check,
672};
673
674static void vhost_user_test_cleanup(void *s)
675{
676 TestServer *server = s;
677
678 qos_invalidate_command_line();
679 test_server_free(server);
680}
681
682static void *vhost_user_test_setup(GString *cmd_line, void *arg)
683{
684 TestServer *server = test_server_new("vhost-user-test", arg);
685 test_server_listen(server);
686
687 append_mem_opts(server, cmd_line, 256, TEST_MEMFD_AUTO);
688 server->vu_ops->append_opts(server, cmd_line, "");
689
690 g_test_queue_destroy(vhost_user_test_cleanup, server);
691
692 return server;
693}
694
695static void *vhost_user_test_setup_memfd(GString *cmd_line, void *arg)
696{
697 TestServer *server = test_server_new("vhost-user-test", arg);
698 test_server_listen(server);
699
700 append_mem_opts(server, cmd_line, 256, TEST_MEMFD_YES);
701 server->vu_ops->append_opts(server, cmd_line, "");
702
703 g_test_queue_destroy(vhost_user_test_cleanup, server);
704
705 return server;
706}
707
708static void test_read_guest_mem(void *obj, void *arg, QGuestAllocator *alloc)
709{
710 TestServer *server = arg;
711
712 if (!wait_for_fds(server)) {
713 return;
714 }
715
716 read_guest_mem_server(global_qtest, server);
717}
718
719static void test_migrate(void *obj, void *arg, QGuestAllocator *alloc)
720{
721 TestServer *s = arg;
722 TestServer *dest;
723 GString *dest_cmdline;
724 char *uri;
725 QTestState *to;
726 GSource *source;
727 QDict *rsp;
728 guint8 *log;
729 guint64 size;
730
731 if (!wait_for_fds(s)) {
732 return;
733 }
734
735 dest = test_server_new("dest", s->vu_ops);
736 dest_cmdline = g_string_new(qos_get_current_command_line());
737 uri = g_strdup_printf("%s%s", "unix:", dest->mig_path);
738
739 size = get_log_size(s);
740 g_assert_cmpint(size, ==, (256 * 1024 * 1024) / (VHOST_LOG_PAGE * 8));
741
742 test_server_listen(dest);
743 g_string_append_printf(dest_cmdline, " -incoming %s", uri);
744 append_mem_opts(dest, dest_cmdline, 256, TEST_MEMFD_AUTO);
745 dest->vu_ops->append_opts(dest, dest_cmdline, "");
746 to = qtest_init(dest_cmdline->str);
747
748
749
750
751
752 source = g_source_new(&test_migrate_source_funcs,
753 sizeof(TestMigrateSource));
754 ((TestMigrateSource *)source)->src = s;
755 ((TestMigrateSource *)source)->dest = dest;
756 g_source_attach(source, s->context);
757
758
759
760 rsp = qmp("{ 'execute': 'migrate-set-parameters',"
761 "'arguments': { 'max-bandwidth': 10 } }");
762 g_assert(qdict_haskey(rsp, "return"));
763 qobject_unref(rsp);
764
765 rsp = qmp("{ 'execute': 'migrate', 'arguments': { 'uri': %s } }", uri);
766 g_assert(qdict_haskey(rsp, "return"));
767 qobject_unref(rsp);
768
769 wait_for_log_fd(s);
770
771 log = mmap(0, size, PROT_READ | PROT_WRITE, MAP_SHARED, s->log_fd, 0);
772 g_assert(log != MAP_FAILED);
773
774
775 write_guest_mem(s, 0x42);
776 log[0] = 1;
777 munmap(log, size);
778
779
780 rsp = qmp("{ 'execute': 'migrate-set-parameters',"
781 "'arguments': { 'max-bandwidth': 0 } }");
782 g_assert(qdict_haskey(rsp, "return"));
783 qobject_unref(rsp);
784
785 qmp_eventwait("STOP");
786 qtest_qmp_eventwait(to, "RESUME");
787
788 g_assert(wait_for_fds(dest));
789 read_guest_mem_server(to, dest);
790
791 g_source_destroy(source);
792 g_source_unref(source);
793
794 qtest_quit(to);
795 test_server_free(dest);
796 g_free(uri);
797 g_string_free(dest_cmdline, true);
798}
799
800static void wait_for_rings_started(TestServer *s, size_t count)
801{
802 gint64 end_time;
803
804 g_mutex_lock(&s->data_mutex);
805 end_time = g_get_monotonic_time() + 5 * G_TIME_SPAN_SECOND;
806 while (ctpop64(s->rings) != count) {
807 if (!g_cond_wait_until(&s->data_cond, &s->data_mutex, end_time)) {
808
809 g_assert_cmpint(ctpop64(s->rings), ==, count);
810 break;
811 }
812 }
813
814 g_mutex_unlock(&s->data_mutex);
815}
816
817static inline void test_server_connect(TestServer *server)
818{
819 test_server_create_chr(server, ",reconnect=1");
820}
821
822static gboolean
823reconnect_cb(gpointer user_data)
824{
825 TestServer *s = user_data;
826
827 qemu_chr_fe_disconnect(&s->chr);
828
829 return FALSE;
830}
831
832static gpointer
833connect_thread(gpointer data)
834{
835 TestServer *s = data;
836
837
838 g_usleep(G_USEC_PER_SEC);
839 test_server_connect(s);
840
841 return NULL;
842}
843
844static void *vhost_user_test_setup_reconnect(GString *cmd_line, void *arg)
845{
846 TestServer *s = test_server_new("reconnect", arg);
847
848 g_thread_new("connect", connect_thread, s);
849 append_mem_opts(s, cmd_line, 256, TEST_MEMFD_AUTO);
850 s->vu_ops->append_opts(s, cmd_line, ",server=on");
851
852 g_test_queue_destroy(vhost_user_test_cleanup, s);
853
854 return s;
855}
856
857static void test_reconnect(void *obj, void *arg, QGuestAllocator *alloc)
858{
859 TestServer *s = arg;
860 GSource *src;
861
862 if (!wait_for_fds(s)) {
863 return;
864 }
865
866 wait_for_rings_started(s, 2);
867
868
869 s->fds_num = 0;
870 s->rings = 0;
871 src = g_idle_source_new();
872 g_source_set_callback(src, reconnect_cb, s, NULL);
873 g_source_attach(src, s->context);
874 g_source_unref(src);
875 g_assert(wait_for_fds(s));
876 wait_for_rings_started(s, 2);
877}
878
879static void *vhost_user_test_setup_connect_fail(GString *cmd_line, void *arg)
880{
881 TestServer *s = test_server_new("connect-fail", arg);
882
883 s->test_fail = true;
884
885 g_thread_new("connect", connect_thread, s);
886 append_mem_opts(s, cmd_line, 256, TEST_MEMFD_AUTO);
887 s->vu_ops->append_opts(s, cmd_line, ",server=on");
888
889 g_test_queue_destroy(vhost_user_test_cleanup, s);
890
891 return s;
892}
893
894static void *vhost_user_test_setup_flags_mismatch(GString *cmd_line, void *arg)
895{
896 TestServer *s = test_server_new("flags-mismatch", arg);
897
898 s->test_flags = TEST_FLAGS_DISCONNECT;
899
900 g_thread_new("connect", connect_thread, s);
901 append_mem_opts(s, cmd_line, 256, TEST_MEMFD_AUTO);
902 s->vu_ops->append_opts(s, cmd_line, ",server=on");
903
904 g_test_queue_destroy(vhost_user_test_cleanup, s);
905
906 return s;
907}
908
909static void test_vhost_user_started(void *obj, void *arg, QGuestAllocator *alloc)
910{
911 TestServer *s = arg;
912
913 if (!wait_for_fds(s)) {
914 return;
915 }
916 wait_for_rings_started(s, 2);
917}
918
919static void *vhost_user_test_setup_multiqueue(GString *cmd_line, void *arg)
920{
921 TestServer *s = vhost_user_test_setup(cmd_line, arg);
922
923 s->queues = 2;
924 g_string_append_printf(cmd_line,
925 " -set netdev.hs0.queues=%d"
926 " -global virtio-net-pci.vectors=%d",
927 s->queues, s->queues * 2 + 2);
928
929 return s;
930}
931
932static void test_multiqueue(void *obj, void *arg, QGuestAllocator *alloc)
933{
934 TestServer *s = arg;
935
936 wait_for_rings_started(s, s->queues * 2);
937}
938
939static void vu_net_set_features(TestServer *s, CharBackend *chr,
940 VhostUserMsg *msg)
941{
942 g_assert_cmpint(msg->payload.u64 &
943 (0x1ULL << VHOST_USER_F_PROTOCOL_FEATURES), !=, 0ULL);
944 if (s->test_flags == TEST_FLAGS_DISCONNECT) {
945 qemu_chr_fe_disconnect(chr);
946 s->test_flags = TEST_FLAGS_BAD;
947 }
948}
949
950static void vu_net_get_protocol_features(TestServer *s, CharBackend *chr,
951 VhostUserMsg *msg)
952{
953
954 msg->flags |= VHOST_USER_REPLY_MASK;
955 msg->size = sizeof(m.payload.u64);
956 msg->payload.u64 = 1 << VHOST_USER_PROTOCOL_F_LOG_SHMFD;
957 msg->payload.u64 |= 1 << VHOST_USER_PROTOCOL_F_CROSS_ENDIAN;
958 if (s->queues > 1) {
959 msg->payload.u64 |= 1 << VHOST_USER_PROTOCOL_F_MQ;
960 }
961 qemu_chr_fe_write_all(chr, (uint8_t *)msg, VHOST_USER_HDR_SIZE + msg->size);
962}
963
964
965static struct vhost_user_ops g_vu_net_ops = {
966 .type = VHOST_USER_NET,
967
968 .append_opts = append_vhost_net_opts,
969
970 .set_features = vu_net_set_features,
971 .get_protocol_features = vu_net_get_protocol_features,
972};
973
974static void register_vhost_user_test(void)
975{
976 QOSGraphTestOptions opts = {
977 .before = vhost_user_test_setup,
978 .subprocess = true,
979 .arg = &g_vu_net_ops,
980 };
981
982 qemu_add_opts(&qemu_chardev_opts);
983
984 qos_add_test("vhost-user/read-guest-mem/memfile",
985 "virtio-net",
986 test_read_guest_mem, &opts);
987
988 if (qemu_memfd_check(MFD_ALLOW_SEALING)) {
989 opts.before = vhost_user_test_setup_memfd;
990 qos_add_test("vhost-user/read-guest-mem/memfd",
991 "virtio-net",
992 test_read_guest_mem, &opts);
993 }
994
995 qos_add_test("vhost-user/migrate",
996 "virtio-net",
997 test_migrate, &opts);
998
999 opts.before = vhost_user_test_setup_reconnect;
1000 qos_add_test("vhost-user/reconnect", "virtio-net",
1001 test_reconnect, &opts);
1002
1003 opts.before = vhost_user_test_setup_connect_fail;
1004 qos_add_test("vhost-user/connect-fail", "virtio-net",
1005 test_vhost_user_started, &opts);
1006
1007 opts.before = vhost_user_test_setup_flags_mismatch;
1008 qos_add_test("vhost-user/flags-mismatch", "virtio-net",
1009 test_vhost_user_started, &opts);
1010
1011 opts.before = vhost_user_test_setup_multiqueue;
1012 opts.edge.extra_device_opts = "mq=on";
1013 qos_add_test("vhost-user/multiqueue",
1014 "virtio-net",
1015 test_multiqueue, &opts);
1016}
1017libqos_init(register_vhost_user_test);
1018
