2 * QTest testcase for migration
4 * Copyright (c) 2016-2018 Red Hat, Inc. and/or its affiliates
5 * based on the vhost-user-test.c that is:
6 * Copyright (c) 2014 Virtual Open Systems Sarl.
8 * This work is licensed under the terms of the GNU GPL, version 2 or later.
9 * See the COPYING file in the top-level directory.
13 #include "qemu/osdep.h"
16 #include "qapi/qmp/qdict.h"
17 #include "qapi/qmp/qjson.h"
18 #include "qemu/module.h"
19 #include "qemu/option.h"
20 #include "qemu/range.h"
21 #include "qemu/sockets.h"
22 #include "chardev/char.h"
23 #include "qapi/qapi-visit-sockets.h"
24 #include "qapi/qobject-input-visitor.h"
25 #include "qapi/qobject-output-visitor.h"
27 #include "migration/migration-test.h"
29 /* TODO actually test the results and get rid of this */
30 #define qtest_qmp_discard_response(...) qobject_unref(qtest_qmp(__VA_ARGS__))
32 unsigned start_address
;
35 static bool uffd_feature_thread_id
;
37 #if defined(__linux__)
38 #include <sys/syscall.h>
42 #if defined(__linux__) && defined(__NR_userfaultfd) && defined(CONFIG_EVENTFD)
43 #include <sys/eventfd.h>
44 #include <sys/ioctl.h>
45 #include <linux/userfaultfd.h>
47 static bool ufd_version_check(void)
49 struct uffdio_api api_struct
;
52 int ufd
= syscall(__NR_userfaultfd
, O_CLOEXEC
);
55 g_test_message("Skipping test: userfaultfd not available");
59 api_struct
.api
= UFFD_API
;
60 api_struct
.features
= 0;
61 if (ioctl(ufd
, UFFDIO_API
, &api_struct
)) {
62 g_test_message("Skipping test: UFFDIO_API failed");
65 uffd_feature_thread_id
= api_struct
.features
& UFFD_FEATURE_THREAD_ID
;
67 ioctl_mask
= (__u64
)1 << _UFFDIO_REGISTER
|
68 (__u64
)1 << _UFFDIO_UNREGISTER
;
69 if ((api_struct
.ioctls
& ioctl_mask
) != ioctl_mask
) {
70 g_test_message("Skipping test: Missing userfault feature");
78 static bool ufd_version_check(void)
80 g_test_message("Skipping test: Userfault not available (builtdtime)");
86 static const char *tmpfs
;
88 /* The boot file modifies memory area in [start_address, end_address)
89 * repeatedly. It outputs a 'B' at a fixed rate while it's still running.
91 #include "tests/migration/i386/a-b-bootblock.h"
92 #include "tests/migration/aarch64/a-b-kernel.h"
93 #include "tests/migration/s390x/a-b-bios.h"
95 static void init_bootfile(const char *bootpath
, void *content
, size_t len
)
97 FILE *bootfile
= fopen(bootpath
, "wb");
99 g_assert_cmpint(fwrite(content
, len
, 1, bootfile
), ==, 1);
104 * Wait for some output in the serial output file,
105 * we get an 'A' followed by an endless string of 'B's
106 * but on the destination we won't have the A.
108 static void wait_for_serial(const char *side
)
110 char *serialpath
= g_strdup_printf("%s/%s", tmpfs
, side
);
111 FILE *serialfile
= fopen(serialpath
, "r");
112 const char *arch
= qtest_get_arch();
113 int started
= (strcmp(side
, "src_serial") == 0 &&
114 strcmp(arch
, "ppc64") == 0) ? 0 : 1;
118 int readvalue
= fgetc(serialfile
);
121 /* SLOF prints its banner before starting test,
122 * to ignore it, mark the start of the test with '_',
123 * ignore all characters until this marker
130 fseek(serialfile
, 0, SEEK_SET
);
147 started
= (strcmp(side
, "src_serial") == 0 &&
148 strcmp(arch
, "ppc64") == 0) ? 0 : 1;
149 fseek(serialfile
, 0, SEEK_SET
);
154 fprintf(stderr
, "Unexpected %d on %s serial\n", readvalue
, side
);
155 g_assert_not_reached();
160 static void stop_cb(void *opaque
, const char *name
, QDict
*data
)
162 if (!strcmp(name
, "STOP")) {
168 * Events can get in the way of responses we are actually waiting for.
171 static QDict
*wait_command_fd(QTestState
*who
, int fd
, const char *command
, ...)
175 va_start(ap
, command
);
176 qtest_qmp_vsend_fds(who
, &fd
, 1, command
, ap
);
179 return qtest_qmp_receive_success(who
, stop_cb
, NULL
);
183 * Events can get in the way of responses we are actually waiting for.
186 static QDict
*wait_command(QTestState
*who
, const char *command
, ...)
190 va_start(ap
, command
);
191 qtest_qmp_vsend(who
, command
, ap
);
194 return qtest_qmp_receive_success(who
, stop_cb
, NULL
);
198 * Note: caller is responsible to free the returned object via
199 * qobject_unref() after use
201 static QDict
*migrate_query(QTestState
*who
)
203 return wait_command(who
, "{ 'execute': 'query-migrate' }");
207 * Note: caller is responsible to free the returned object via
210 static gchar
*migrate_query_status(QTestState
*who
)
212 QDict
*rsp_return
= migrate_query(who
);
213 gchar
*status
= g_strdup(qdict_get_str(rsp_return
, "status"));
216 qobject_unref(rsp_return
);
222 * It's tricky to use qemu's migration event capability with qtest,
223 * events suddenly appearing confuse the qmp()/hmp() responses.
226 static int64_t read_ram_property_int(QTestState
*who
, const char *property
)
228 QDict
*rsp_return
, *rsp_ram
;
231 rsp_return
= migrate_query(who
);
232 if (!qdict_haskey(rsp_return
, "ram")) {
236 rsp_ram
= qdict_get_qdict(rsp_return
, "ram");
237 result
= qdict_get_try_int(rsp_ram
, property
, 0);
239 qobject_unref(rsp_return
);
243 static int64_t read_migrate_property_int(QTestState
*who
, const char *property
)
248 rsp_return
= migrate_query(who
);
249 result
= qdict_get_try_int(rsp_return
, property
, 0);
250 qobject_unref(rsp_return
);
254 static uint64_t get_migration_pass(QTestState
*who
)
256 return read_ram_property_int(who
, "dirty-sync-count");
259 static void read_blocktime(QTestState
*who
)
263 rsp_return
= migrate_query(who
);
264 g_assert(qdict_haskey(rsp_return
, "postcopy-blocktime"));
265 qobject_unref(rsp_return
);
268 static bool check_migration_status(QTestState
*who
, const char *goal
,
269 const char **ungoals
)
272 char *current_status
;
275 current_status
= migrate_query_status(who
);
276 ready
= strcmp(current_status
, goal
) == 0;
278 g_assert_cmpstr(current_status
, !=, "failed");
280 * If looking for a state other than completed,
281 * completion of migration would cause the test to
284 if (strcmp(goal
, "completed") != 0) {
285 g_assert_cmpstr(current_status
, !=, "completed");
288 for (ungoal
= ungoals
; *ungoal
; ungoal
++) {
289 g_assert_cmpstr(current_status
, !=, *ungoal
);
292 g_free(current_status
);
296 static void wait_for_migration_status(QTestState
*who
,
298 const char **ungoals
)
300 while (!check_migration_status(who
, goal
, ungoals
)) {
305 static void wait_for_migration_complete(QTestState
*who
)
307 wait_for_migration_status(who
, "completed", NULL
);
310 static void wait_for_migration_pass(QTestState
*who
)
312 uint64_t initial_pass
= get_migration_pass(who
);
315 /* Wait for the 1st sync */
316 while (!got_stop
&& !initial_pass
) {
318 initial_pass
= get_migration_pass(who
);
323 pass
= get_migration_pass(who
);
324 } while (pass
== initial_pass
&& !got_stop
);
327 static void check_guests_ram(QTestState
*who
)
329 /* Our ASM test will have been incrementing one byte from each page from
330 * start_address to < end_address in order. This gives us a constraint
331 * that any page's byte should be equal or less than the previous pages
332 * byte (mod 256); and they should all be equal except for one transition
333 * at the point where we meet the incrementer. (We're running this with
334 * the guest stopped).
339 bool hit_edge
= false;
342 qtest_memread(who
, start_address
, &first_byte
, 1);
343 last_byte
= first_byte
;
345 for (address
= start_address
+ TEST_MEM_PAGE_SIZE
; address
< end_address
;
346 address
+= TEST_MEM_PAGE_SIZE
)
349 qtest_memread(who
, address
, &b
, 1);
350 if (b
!= last_byte
) {
351 if (((b
+ 1) % 256) == last_byte
&& !hit_edge
) {
352 /* This is OK, the guest stopped at the point of
353 * incrementing the previous page but didn't get
361 fprintf(stderr
, "Memory content inconsistency at %x"
362 " first_byte = %x last_byte = %x current = %x"
364 address
, first_byte
, last_byte
, b
, hit_edge
);
370 fprintf(stderr
, "and in another %d pages", bad
- 10);
375 static void cleanup(const char *filename
)
377 char *path
= g_strdup_printf("%s/%s", tmpfs
, filename
);
383 static char *get_shmem_opts(const char *mem_size
, const char *shmem_path
)
385 return g_strdup_printf("-object memory-backend-file,id=mem0,size=%s"
386 ",mem-path=%s,share=on -numa node,memdev=mem0",
387 mem_size
, shmem_path
);
390 static char *SocketAddress_to_str(SocketAddress
*addr
)
392 switch (addr
->type
) {
393 case SOCKET_ADDRESS_TYPE_INET
:
394 return g_strdup_printf("tcp:%s:%s",
397 case SOCKET_ADDRESS_TYPE_UNIX
:
398 return g_strdup_printf("unix:%s",
399 addr
->u
.q_unix
.path
);
400 case SOCKET_ADDRESS_TYPE_FD
:
401 return g_strdup_printf("fd:%s", addr
->u
.fd
.str
);
402 case SOCKET_ADDRESS_TYPE_VSOCK
:
403 return g_strdup_printf("tcp:%s:%s",
407 return g_strdup("unknown address type");
411 static char *migrate_get_socket_address(QTestState
*who
, const char *parameter
)
415 Error
*local_err
= NULL
;
416 SocketAddressList
*addrs
;
420 rsp
= migrate_query(who
);
421 object
= qdict_get(rsp
, parameter
);
423 iv
= qobject_input_visitor_new(object
);
424 visit_type_SocketAddressList(iv
, NULL
, &addrs
, &local_err
);
427 /* we are only using a single address */
428 result
= SocketAddress_to_str(addrs
->value
);
430 qapi_free_SocketAddressList(addrs
);
435 static long long migrate_get_parameter_int(QTestState
*who
,
436 const char *parameter
)
441 rsp
= wait_command(who
, "{ 'execute': 'query-migrate-parameters' }");
442 result
= qdict_get_int(rsp
, parameter
);
447 static void migrate_check_parameter_int(QTestState
*who
, const char *parameter
,
452 result
= migrate_get_parameter_int(who
, parameter
);
453 g_assert_cmpint(result
, ==, value
);
456 static void migrate_set_parameter_int(QTestState
*who
, const char *parameter
,
462 "{ 'execute': 'migrate-set-parameters',"
463 "'arguments': { %s: %lld } }",
465 g_assert(qdict_haskey(rsp
, "return"));
467 migrate_check_parameter_int(who
, parameter
, value
);
470 static void migrate_pause(QTestState
*who
)
474 rsp
= wait_command(who
, "{ 'execute': 'migrate-pause' }");
478 static void migrate_continue(QTestState
*who
, const char *state
)
482 rsp
= wait_command(who
,
483 "{ 'execute': 'migrate-continue',"
484 " 'arguments': { 'state': %s } }",
489 static void migrate_recover(QTestState
*who
, const char *uri
)
493 rsp
= wait_command(who
,
494 "{ 'execute': 'migrate-recover', "
495 " 'id': 'recover-cmd', "
496 " 'arguments': { 'uri': %s } }",
501 static void migrate_set_capability(QTestState
*who
, const char *capability
,
507 "{ 'execute': 'migrate-set-capabilities',"
509 "'capabilities': [ { "
510 "'capability': %s, 'state': %i } ] } }",
512 g_assert(qdict_haskey(rsp
, "return"));
517 * Send QMP command "migrate".
518 * Arguments are built from @fmt... (formatted like
519 * qobject_from_jsonf_nofail()) with "uri": @uri spliced in.
522 static void migrate(QTestState
*who
, const char *uri
, const char *fmt
, ...)
528 args
= qdict_from_vjsonf_nofail(fmt
, ap
);
531 g_assert(!qdict_haskey(args
, "uri"));
532 qdict_put_str(args
, "uri", uri
);
534 rsp
= qtest_qmp(who
, "{ 'execute': 'migrate', 'arguments': %p}", args
);
536 g_assert(qdict_haskey(rsp
, "return"));
540 static void migrate_postcopy_start(QTestState
*from
, QTestState
*to
)
544 rsp
= wait_command(from
, "{ 'execute': 'migrate-start-postcopy' }");
548 qtest_qmp_eventwait(from
, "STOP");
551 qtest_qmp_eventwait(to
, "RESUME");
554 static int test_migrate_start(QTestState
**from
, QTestState
**to
,
555 const char *uri
, bool hide_stderr
,
556 bool use_shmem
, const char *opts_src
,
557 const char *opts_dst
)
559 gchar
*cmd_src
, *cmd_dst
;
560 char *bootpath
= NULL
;
561 char *extra_opts
= NULL
;
562 char *shmem_path
= NULL
;
563 const char *arch
= qtest_get_arch();
564 const char *accel
= "kvm:tcg";
566 opts_src
= opts_src
? opts_src
: "";
567 opts_dst
= opts_dst
? opts_dst
: "";
570 if (!g_file_test("/dev/shm", G_FILE_TEST_IS_DIR
)) {
571 g_test_skip("/dev/shm is not supported");
574 shmem_path
= g_strdup_printf("/dev/shm/qemu-%d", getpid());
578 bootpath
= g_strdup_printf("%s/bootsect", tmpfs
);
579 if (strcmp(arch
, "i386") == 0 || strcmp(arch
, "x86_64") == 0) {
580 /* the assembled x86 boot sector should be exactly one sector large */
581 assert(sizeof(x86_bootsect
) == 512);
582 init_bootfile(bootpath
, x86_bootsect
, sizeof(x86_bootsect
));
583 extra_opts
= use_shmem
? get_shmem_opts("150M", shmem_path
) : NULL
;
584 cmd_src
= g_strdup_printf("-machine accel=%s -m 150M"
585 " -name source,debug-threads=on"
586 " -serial file:%s/src_serial"
587 " -drive file=%s,format=raw %s %s",
588 accel
, tmpfs
, bootpath
,
589 extra_opts
? extra_opts
: "", opts_src
);
590 cmd_dst
= g_strdup_printf("-machine accel=%s -m 150M"
591 " -name target,debug-threads=on"
592 " -serial file:%s/dest_serial"
593 " -drive file=%s,format=raw"
594 " -incoming %s %s %s",
595 accel
, tmpfs
, bootpath
, uri
,
596 extra_opts
? extra_opts
: "", opts_dst
);
597 start_address
= X86_TEST_MEM_START
;
598 end_address
= X86_TEST_MEM_END
;
599 } else if (g_str_equal(arch
, "s390x")) {
600 init_bootfile(bootpath
, s390x_elf
, sizeof(s390x_elf
));
601 extra_opts
= use_shmem
? get_shmem_opts("128M", shmem_path
) : NULL
;
602 cmd_src
= g_strdup_printf("-machine accel=%s -m 128M"
603 " -name source,debug-threads=on"
604 " -serial file:%s/src_serial -bios %s %s %s",
605 accel
, tmpfs
, bootpath
,
606 extra_opts
? extra_opts
: "", opts_src
);
607 cmd_dst
= g_strdup_printf("-machine accel=%s -m 128M"
608 " -name target,debug-threads=on"
609 " -serial file:%s/dest_serial -bios %s"
610 " -incoming %s %s %s",
611 accel
, tmpfs
, bootpath
, uri
,
612 extra_opts
? extra_opts
: "", opts_dst
);
613 start_address
= S390_TEST_MEM_START
;
614 end_address
= S390_TEST_MEM_END
;
615 } else if (strcmp(arch
, "ppc64") == 0) {
616 extra_opts
= use_shmem
? get_shmem_opts("256M", shmem_path
) : NULL
;
617 cmd_src
= g_strdup_printf("-machine accel=%s,vsmt=8 -m 256M -nodefaults"
618 " -name source,debug-threads=on"
619 " -serial file:%s/src_serial"
620 " -prom-env 'use-nvramrc?=true' -prom-env "
621 "'nvramrc=hex .\" _\" begin %x %x "
622 "do i c@ 1 + i c! 1000 +loop .\" B\" 0 "
623 "until' %s %s", accel
, tmpfs
, end_address
,
624 start_address
, extra_opts
? extra_opts
: "",
626 cmd_dst
= g_strdup_printf("-machine accel=%s,vsmt=8 -m 256M"
627 " -name target,debug-threads=on"
628 " -serial file:%s/dest_serial"
629 " -incoming %s %s %s",
631 extra_opts
? extra_opts
: "", opts_dst
);
633 start_address
= PPC_TEST_MEM_START
;
634 end_address
= PPC_TEST_MEM_END
;
635 } else if (strcmp(arch
, "aarch64") == 0) {
636 init_bootfile(bootpath
, aarch64_kernel
, sizeof(aarch64_kernel
));
637 extra_opts
= use_shmem
? get_shmem_opts("150M", shmem_path
) : NULL
;
638 cmd_src
= g_strdup_printf("-machine virt,accel=%s,gic-version=max "
639 "-name vmsource,debug-threads=on -cpu max "
640 "-m 150M -serial file:%s/src_serial "
642 accel
, tmpfs
, bootpath
,
643 extra_opts
? extra_opts
: "", opts_src
);
644 cmd_dst
= g_strdup_printf("-machine virt,accel=%s,gic-version=max "
645 "-name vmdest,debug-threads=on -cpu max "
646 "-m 150M -serial file:%s/dest_serial "
648 "-incoming %s %s %s",
649 accel
, tmpfs
, bootpath
, uri
,
650 extra_opts
? extra_opts
: "", opts_dst
);
652 start_address
= ARM_TEST_MEM_START
;
653 end_address
= ARM_TEST_MEM_END
;
655 g_assert(sizeof(aarch64_kernel
) <= ARM_TEST_MAX_KERNEL_SIZE
);
657 g_assert_not_reached();
665 tmp
= g_strdup_printf("%s 2>/dev/null", cmd_src
);
669 tmp
= g_strdup_printf("%s 2>/dev/null", cmd_dst
);
674 *from
= qtest_init(cmd_src
);
677 *to
= qtest_init(cmd_dst
);
681 * Remove shmem file immediately to avoid memory leak in test failed case.
682 * It's valid becase QEMU has already opened this file
692 static void test_migrate_end(QTestState
*from
, QTestState
*to
, bool test_dest
)
694 unsigned char dest_byte_a
, dest_byte_b
, dest_byte_c
, dest_byte_d
;
699 qtest_memread(to
, start_address
, &dest_byte_a
, 1);
701 /* Destination still running, wait for a byte to change */
703 qtest_memread(to
, start_address
, &dest_byte_b
, 1);
705 } while (dest_byte_a
== dest_byte_b
);
707 qtest_qmp_discard_response(to
, "{ 'execute' : 'stop'}");
709 /* With it stopped, check nothing changes */
710 qtest_memread(to
, start_address
, &dest_byte_c
, 1);
712 qtest_memread(to
, start_address
, &dest_byte_d
, 1);
713 g_assert_cmpint(dest_byte_c
, ==, dest_byte_d
);
715 check_guests_ram(to
);
721 cleanup("migsocket");
722 cleanup("src_serial");
723 cleanup("dest_serial");
726 static void deprecated_set_downtime(QTestState
*who
, const double value
)
731 "{ 'execute': 'migrate_set_downtime',"
732 " 'arguments': { 'value': %f } }", value
);
733 g_assert(qdict_haskey(rsp
, "return"));
735 migrate_check_parameter_int(who
, "downtime-limit", value
* 1000);
738 static void deprecated_set_speed(QTestState
*who
, long long value
)
742 rsp
= qtest_qmp(who
, "{ 'execute': 'migrate_set_speed',"
743 "'arguments': { 'value': %lld } }", value
);
744 g_assert(qdict_haskey(rsp
, "return"));
746 migrate_check_parameter_int(who
, "max-bandwidth", value
);
749 static void deprecated_set_cache_size(QTestState
*who
, long long value
)
753 rsp
= qtest_qmp(who
, "{ 'execute': 'migrate-set-cache-size',"
754 "'arguments': { 'value': %lld } }", value
);
755 g_assert(qdict_haskey(rsp
, "return"));
757 migrate_check_parameter_int(who
, "xbzrle-cache-size", value
);
760 static void test_deprecated(void)
764 from
= qtest_init("-machine none");
766 deprecated_set_downtime(from
, 0.12345);
767 deprecated_set_speed(from
, 12345);
768 deprecated_set_cache_size(from
, 4096);
773 static int migrate_postcopy_prepare(QTestState
**from_ptr
,
777 char *uri
= g_strdup_printf("unix:%s/migsocket", tmpfs
);
778 QTestState
*from
, *to
;
780 if (test_migrate_start(&from
, &to
, uri
, hide_error
, false, NULL
, NULL
)) {
784 migrate_set_capability(from
, "postcopy-ram", true);
785 migrate_set_capability(to
, "postcopy-ram", true);
786 migrate_set_capability(to
, "postcopy-blocktime", true);
788 /* We want to pick a speed slow enough that the test completes
789 * quickly, but that it doesn't complete precopy even on a slow
790 * machine, so also set the downtime.
792 migrate_set_parameter_int(from
, "max-bandwidth", 30000000);
793 migrate_set_parameter_int(from
, "downtime-limit", 1);
795 /* Wait for the first serial output from the source */
796 wait_for_serial("src_serial");
798 migrate(from
, uri
, "{}");
801 wait_for_migration_pass(from
);
809 static void migrate_postcopy_complete(QTestState
*from
, QTestState
*to
)
811 wait_for_migration_complete(from
);
813 /* Make sure we get at least one "B" on destination */
814 wait_for_serial("dest_serial");
816 if (uffd_feature_thread_id
) {
820 test_migrate_end(from
, to
, true);
823 static void test_postcopy(void)
825 QTestState
*from
, *to
;
827 if (migrate_postcopy_prepare(&from
, &to
, false)) {
830 migrate_postcopy_start(from
, to
);
831 migrate_postcopy_complete(from
, to
);
834 static void test_postcopy_recovery(void)
836 QTestState
*from
, *to
;
839 if (migrate_postcopy_prepare(&from
, &to
, true)) {
843 /* Turn postcopy speed down, 4K/s is slow enough on any machines */
844 migrate_set_parameter_int(from
, "max-postcopy-bandwidth", 4096);
846 /* Now we start the postcopy */
847 migrate_postcopy_start(from
, to
);
850 * Wait until postcopy is really started; we can only run the
851 * migrate-pause command during a postcopy
853 wait_for_migration_status(from
, "postcopy-active", NULL
);
856 * Manually stop the postcopy migration. This emulates a network
857 * failure with the migration socket
862 * Wait for destination side to reach postcopy-paused state. The
863 * migrate-recover command can only succeed if destination machine
864 * is in the paused state
866 wait_for_migration_status(to
, "postcopy-paused",
867 (const char * []) { "failed", "active",
868 "completed", NULL
});
871 * Create a new socket to emulate a new channel that is different
872 * from the broken migration channel; tell the destination to
873 * listen to the new port
875 uri
= g_strdup_printf("unix:%s/migsocket-recover", tmpfs
);
876 migrate_recover(to
, uri
);
879 * Try to rebuild the migration channel using the resume flag and
880 * the newly created channel
882 wait_for_migration_status(from
, "postcopy-paused",
883 (const char * []) { "failed", "active",
884 "completed", NULL
});
885 migrate(from
, uri
, "{'resume': true}");
888 /* Restore the postcopy bandwidth to unlimited */
889 migrate_set_parameter_int(from
, "max-postcopy-bandwidth", 0);
891 migrate_postcopy_complete(from
, to
);
894 static void wait_for_migration_fail(QTestState
*from
, bool allow_active
)
901 status
= migrate_query_status(from
);
902 bool result
= !strcmp(status
, "setup") || !strcmp(status
, "failed") ||
903 (allow_active
&& !strcmp(status
, "active"));
905 fprintf(stderr
, "%s: unexpected status status=%s allow_active=%d\n",
906 __func__
, status
, allow_active
);
909 failed
= !strcmp(status
, "failed");
913 /* Is the machine currently running? */
914 rsp_return
= wait_command(from
, "{ 'execute': 'query-status' }");
915 g_assert(qdict_haskey(rsp_return
, "running"));
916 g_assert(qdict_get_bool(rsp_return
, "running"));
917 qobject_unref(rsp_return
);
920 static void test_baddest(void)
922 QTestState
*from
, *to
;
924 if (test_migrate_start(&from
, &to
, "tcp:0:0", true, false, NULL
, NULL
)) {
927 migrate(from
, "tcp:0:0", "{}");
928 wait_for_migration_fail(from
, false);
929 test_migrate_end(from
, to
, false);
932 static void test_precopy_unix(void)
934 char *uri
= g_strdup_printf("unix:%s/migsocket", tmpfs
);
935 QTestState
*from
, *to
;
937 if (test_migrate_start(&from
, &to
, uri
, false, false, NULL
, NULL
)) {
941 /* We want to pick a speed slow enough that the test completes
942 * quickly, but that it doesn't complete precopy even on a slow
943 * machine, so also set the downtime.
945 /* 1 ms should make it not converge*/
946 migrate_set_parameter_int(from
, "downtime-limit", 1);
948 migrate_set_parameter_int(from
, "max-bandwidth", 1000000000);
950 /* Wait for the first serial output from the source */
951 wait_for_serial("src_serial");
953 migrate(from
, uri
, "{}");
955 wait_for_migration_pass(from
);
957 /* 300 ms should converge */
958 migrate_set_parameter_int(from
, "downtime-limit", 300);
961 qtest_qmp_eventwait(from
, "STOP");
964 qtest_qmp_eventwait(to
, "RESUME");
966 wait_for_serial("dest_serial");
967 wait_for_migration_complete(from
);
969 test_migrate_end(from
, to
, true);
974 /* Currently upset on aarch64 TCG */
975 static void test_ignore_shared(void)
977 char *uri
= g_strdup_printf("unix:%s/migsocket", tmpfs
);
978 QTestState
*from
, *to
;
980 if (test_migrate_start(&from
, &to
, uri
, false, true, NULL
, NULL
)) {
984 migrate_set_capability(from
, "x-ignore-shared", true);
985 migrate_set_capability(to
, "x-ignore-shared", true);
987 /* Wait for the first serial output from the source */
988 wait_for_serial("src_serial");
990 migrate(from
, uri
, "{}");
992 wait_for_migration_pass(from
);
995 qtest_qmp_eventwait(from
, "STOP");
998 qtest_qmp_eventwait(to
, "RESUME");
1000 wait_for_serial("dest_serial");
1001 wait_for_migration_complete(from
);
1003 /* Check whether shared RAM has been really skipped */
1004 g_assert_cmpint(read_ram_property_int(from
, "transferred"), <, 1024 * 1024);
1006 test_migrate_end(from
, to
, true);
1011 static void test_xbzrle(const char *uri
)
1013 QTestState
*from
, *to
;
1015 if (test_migrate_start(&from
, &to
, uri
, false, false, NULL
, NULL
)) {
1020 * We want to pick a speed slow enough that the test completes
1021 * quickly, but that it doesn't complete precopy even on a slow
1022 * machine, so also set the downtime.
1024 /* 1 ms should make it not converge*/
1025 migrate_set_parameter_int(from
, "downtime-limit", 1);
1027 migrate_set_parameter_int(from
, "max-bandwidth", 1000000000);
1029 migrate_set_parameter_int(from
, "xbzrle-cache-size", 33554432);
1031 migrate_set_capability(from
, "xbzrle", "true");
1032 migrate_set_capability(to
, "xbzrle", "true");
1033 /* Wait for the first serial output from the source */
1034 wait_for_serial("src_serial");
1036 migrate(from
, uri
, "{}");
1038 wait_for_migration_pass(from
);
1040 /* 300ms should converge */
1041 migrate_set_parameter_int(from
, "downtime-limit", 300);
1044 qtest_qmp_eventwait(from
, "STOP");
1046 qtest_qmp_eventwait(to
, "RESUME");
1048 wait_for_serial("dest_serial");
1049 wait_for_migration_complete(from
);
1051 test_migrate_end(from
, to
, true);
1054 static void test_xbzrle_unix(void)
1056 char *uri
= g_strdup_printf("unix:%s/migsocket", tmpfs
);
1062 static void test_precopy_tcp(void)
1065 QTestState
*from
, *to
;
1067 if (test_migrate_start(&from
, &to
, "tcp:127.0.0.1:0", false, false,
1073 * We want to pick a speed slow enough that the test completes
1074 * quickly, but that it doesn't complete precopy even on a slow
1075 * machine, so also set the downtime.
1077 /* 1 ms should make it not converge*/
1078 migrate_set_parameter_int(from
, "downtime-limit", 1);
1080 migrate_set_parameter_int(from
, "max-bandwidth", 1000000000);
1082 /* Wait for the first serial output from the source */
1083 wait_for_serial("src_serial");
1085 uri
= migrate_get_socket_address(to
, "socket-address");
1087 migrate(from
, uri
, "{}");
1089 wait_for_migration_pass(from
);
1091 /* 300ms should converge */
1092 migrate_set_parameter_int(from
, "downtime-limit", 300);
1095 qtest_qmp_eventwait(from
, "STOP");
1097 qtest_qmp_eventwait(to
, "RESUME");
1099 wait_for_serial("dest_serial");
1100 wait_for_migration_complete(from
);
1102 test_migrate_end(from
, to
, true);
1106 static void test_migrate_fd_proto(void)
1108 QTestState
*from
, *to
;
1112 const char *error_desc
;
1114 if (test_migrate_start(&from
, &to
, "defer", false, false, NULL
, NULL
)) {
1119 * We want to pick a speed slow enough that the test completes
1120 * quickly, but that it doesn't complete precopy even on a slow
1121 * machine, so also set the downtime.
1123 /* 1 ms should make it not converge */
1124 migrate_set_parameter_int(from
, "downtime-limit", 1);
1126 migrate_set_parameter_int(from
, "max-bandwidth", 1000000000);
1128 /* Wait for the first serial output from the source */
1129 wait_for_serial("src_serial");
1131 /* Create two connected sockets for migration */
1132 ret
= socketpair(PF_LOCAL
, SOCK_STREAM
, 0, pair
);
1133 g_assert_cmpint(ret
, ==, 0);
1135 /* Send the 1st socket to the target */
1136 rsp
= wait_command_fd(to
, pair
[0],
1137 "{ 'execute': 'getfd',"
1138 " 'arguments': { 'fdname': 'fd-mig' }}");
1142 /* Start incoming migration from the 1st socket */
1143 rsp
= wait_command(to
, "{ 'execute': 'migrate-incoming',"
1144 " 'arguments': { 'uri': 'fd:fd-mig' }}");
1147 /* Send the 2nd socket to the target */
1148 rsp
= wait_command_fd(from
, pair
[1],
1149 "{ 'execute': 'getfd',"
1150 " 'arguments': { 'fdname': 'fd-mig' }}");
1154 /* Start migration to the 2nd socket*/
1155 migrate(from
, "fd:fd-mig", "{}");
1157 wait_for_migration_pass(from
);
1159 /* 300ms should converge */
1160 migrate_set_parameter_int(from
, "downtime-limit", 300);
1163 qtest_qmp_eventwait(from
, "STOP");
1165 qtest_qmp_eventwait(to
, "RESUME");
1167 /* Test closing fds */
1168 /* We assume, that QEMU removes named fd from its list,
1169 * so this should fail */
1170 rsp
= qtest_qmp(from
, "{ 'execute': 'closefd',"
1171 " 'arguments': { 'fdname': 'fd-mig' }}");
1172 g_assert_true(qdict_haskey(rsp
, "error"));
1173 error_desc
= qdict_get_str(qdict_get_qdict(rsp
, "error"), "desc");
1174 g_assert_cmpstr(error_desc
, ==, "File descriptor named 'fd-mig' not found");
1177 rsp
= qtest_qmp(to
, "{ 'execute': 'closefd',"
1178 " 'arguments': { 'fdname': 'fd-mig' }}");
1179 g_assert_true(qdict_haskey(rsp
, "error"));
1180 error_desc
= qdict_get_str(qdict_get_qdict(rsp
, "error"), "desc");
1181 g_assert_cmpstr(error_desc
, ==, "File descriptor named 'fd-mig' not found");
1184 /* Complete migration */
1185 wait_for_serial("dest_serial");
1186 wait_for_migration_complete(from
);
1187 test_migrate_end(from
, to
, true);
1190 static void do_test_validate_uuid(const char *uuid_arg_src
,
1191 const char *uuid_arg_dst
,
1192 bool should_fail
, bool hide_stderr
)
1194 char *uri
= g_strdup_printf("unix:%s/migsocket", tmpfs
);
1195 QTestState
*from
, *to
;
1197 if (test_migrate_start(&from
, &to
, uri
, hide_stderr
, false,
1198 uuid_arg_src
, uuid_arg_dst
)) {
1203 * UUID validation is at the begin of migration. So, the main process of
1204 * migration is not interesting for us here. Thus, set huge downtime for
1205 * very fast migration.
1207 migrate_set_parameter_int(from
, "downtime-limit", 1000000);
1208 migrate_set_capability(from
, "validate-uuid", true);
1210 /* Wait for the first serial output from the source */
1211 wait_for_serial("src_serial");
1213 migrate(from
, uri
, "{}");
1216 qtest_set_expected_status(to
, 1);
1217 wait_for_migration_fail(from
, true);
1219 wait_for_migration_complete(from
);
1222 test_migrate_end(from
, to
, false);
1226 static void test_validate_uuid(void)
1228 do_test_validate_uuid("-uuid 11111111-1111-1111-1111-111111111111",
1229 "-uuid 11111111-1111-1111-1111-111111111111",
1233 static void test_validate_uuid_error(void)
1235 do_test_validate_uuid("-uuid 11111111-1111-1111-1111-111111111111",
1236 "-uuid 22222222-2222-2222-2222-222222222222",
1240 static void test_validate_uuid_src_not_set(void)
1242 do_test_validate_uuid(NULL
, "-uuid 11111111-1111-1111-1111-111111111111",
1246 static void test_validate_uuid_dst_not_set(void)
1248 do_test_validate_uuid("-uuid 11111111-1111-1111-1111-111111111111", NULL
,
1252 static void test_migrate_auto_converge(void)
1254 char *uri
= g_strdup_printf("unix:%s/migsocket", tmpfs
);
1255 QTestState
*from
, *to
;
1256 int64_t remaining
, percentage
;
1259 * We want the test to be stable and as fast as possible.
1260 * E.g., with 1Gb/s bandwith migration may pass without throttling,
1261 * so we need to decrease a bandwidth.
1263 const int64_t init_pct
= 5, inc_pct
= 50, max_pct
= 95;
1264 const int64_t max_bandwidth
= 400000000; /* ~400Mb/s */
1265 const int64_t downtime_limit
= 250; /* 250ms */
1267 * We migrate through unix-socket (> 500Mb/s).
1268 * Thus, expected migration speed ~= bandwidth limit (< 500Mb/s).
1269 * So, we can predict expected_threshold
1271 const int64_t expected_threshold
= max_bandwidth
* downtime_limit
/ 1000;
1273 if (test_migrate_start(&from
, &to
, uri
, false, false, NULL
, NULL
)) {
1277 migrate_set_capability(from
, "auto-converge", true);
1278 migrate_set_parameter_int(from
, "cpu-throttle-initial", init_pct
);
1279 migrate_set_parameter_int(from
, "cpu-throttle-increment", inc_pct
);
1280 migrate_set_parameter_int(from
, "max-cpu-throttle", max_pct
);
1283 * Set the initial parameters so that the migration could not converge
1284 * without throttling.
1286 migrate_set_parameter_int(from
, "downtime-limit", 1);
1287 migrate_set_parameter_int(from
, "max-bandwidth", 100000000); /* ~100Mb/s */
1289 /* To check remaining size after precopy */
1290 migrate_set_capability(from
, "pause-before-switchover", true);
1292 /* Wait for the first serial output from the source */
1293 wait_for_serial("src_serial");
1295 migrate(from
, uri
, "{}");
1297 /* Wait for throttling begins */
1299 while (percentage
== 0) {
1300 percentage
= read_migrate_property_int(from
, "cpu-throttle-percentage");
1302 g_assert_false(got_stop
);
1304 /* The first percentage of throttling should be equal to init_pct */
1305 g_assert_cmpint(percentage
, ==, init_pct
);
1306 /* Now, when we tested that throttling works, let it converge */
1307 migrate_set_parameter_int(from
, "downtime-limit", downtime_limit
);
1308 migrate_set_parameter_int(from
, "max-bandwidth", max_bandwidth
);
1311 * Wait for pre-switchover status to check last throttle percentage
1312 * and remaining. These values will be zeroed later
1314 wait_for_migration_status(from
, "pre-switchover", NULL
);
1316 /* The final percentage of throttling shouldn't be greater than max_pct */
1317 percentage
= read_migrate_property_int(from
, "cpu-throttle-percentage");
1318 g_assert_cmpint(percentage
, <=, max_pct
);
1320 remaining
= read_ram_property_int(from
, "remaining");
1321 g_assert_cmpint(remaining
, <, expected_threshold
);
1323 migrate_continue(from
, "pre-switchover");
1325 qtest_qmp_eventwait(to
, "RESUME");
1327 wait_for_serial("dest_serial");
1328 wait_for_migration_complete(from
);
1332 test_migrate_end(from
, to
, true);
1335 int main(int argc
, char **argv
)
1337 char template[] = "/tmp/migration-test-XXXXXX";
1340 g_test_init(&argc
, &argv
, NULL
);
1342 if (!ufd_version_check()) {
1343 return g_test_run();
1347 * On ppc64, the test only works with kvm-hv, but not with kvm-pr and TCG
1348 * is touchy due to race conditions on dirty bits (especially on PPC for
1351 if (g_str_equal(qtest_get_arch(), "ppc64") &&
1352 (access("/sys/module/kvm_hv", F_OK
) ||
1353 access("/dev/kvm", R_OK
| W_OK
))) {
1354 g_test_message("Skipping test: kvm_hv not available");
1355 return g_test_run();
1359 * Similar to ppc64, s390x seems to be touchy with TCG, so disable it
1360 * there until the problems are resolved
1362 if (g_str_equal(qtest_get_arch(), "s390x")) {
1363 #if defined(HOST_S390X)
1364 if (access("/dev/kvm", R_OK
| W_OK
)) {
1365 g_test_message("Skipping test: kvm not available");
1366 return g_test_run();
1369 g_test_message("Skipping test: Need s390x host to work properly");
1370 return g_test_run();
1374 tmpfs
= mkdtemp(template);
1376 g_test_message("mkdtemp on path (%s): %s", template, strerror(errno
));
1380 module_call_init(MODULE_INIT_QOM
);
1382 qtest_add_func("/migration/postcopy/unix", test_postcopy
);
1383 qtest_add_func("/migration/postcopy/recovery", test_postcopy_recovery
);
1384 qtest_add_func("/migration/deprecated", test_deprecated
);
1385 qtest_add_func("/migration/bad_dest", test_baddest
);
1386 qtest_add_func("/migration/precopy/unix", test_precopy_unix
);
1387 qtest_add_func("/migration/precopy/tcp", test_precopy_tcp
);
1388 /* qtest_add_func("/migration/ignore_shared", test_ignore_shared); */
1389 qtest_add_func("/migration/xbzrle/unix", test_xbzrle_unix
);
1390 qtest_add_func("/migration/fd_proto", test_migrate_fd_proto
);
1391 qtest_add_func("/migration/validate_uuid", test_validate_uuid
);
1392 qtest_add_func("/migration/validate_uuid_error", test_validate_uuid_error
);
1393 qtest_add_func("/migration/validate_uuid_src_not_set",
1394 test_validate_uuid_src_not_set
);
1395 qtest_add_func("/migration/validate_uuid_dst_not_set",
1396 test_validate_uuid_dst_not_set
);
1398 qtest_add_func("/migration/auto_converge", test_migrate_auto_converge
);
1402 g_assert_cmpint(ret
, ==, 0);
1406 g_test_message("unable to rmdir: path (%s): %s",
1407 tmpfs
, strerror(errno
));