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/error.h"
17 #include "qapi/qmp/qdict.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"
26 #include "crypto/tlscredspsk.h"
27 #include "qapi/qmp/qlist.h"
29 #include "migration-helpers.h"
30 #include "tests/migration/migration-test.h"
32 # include "tests/unit/crypto-tls-psk-helpers.h"
34 # include "tests/unit/crypto-tls-x509-helpers.h"
35 # endif /* CONFIG_TASN1 */
36 #endif /* CONFIG_GNUTLS */
38 /* For dirty ring test; so far only x86_64 is supported */
39 #if defined(__linux__) && defined(HOST_X86_64)
40 #include "linux/kvm.h"
43 unsigned start_address
;
45 static bool uffd_feature_thread_id
;
46 static QTestMigrationState src_state
;
47 static QTestMigrationState dst_state
;
50 * An initial 3 MB offset is used as that corresponds
51 * to ~1 sec of data transfer with our bandwidth setting.
53 #define MAGIC_OFFSET_BASE (3 * 1024 * 1024)
55 * A further 1k is added to ensure we're not a multiple
56 * of TEST_MEM_PAGE_SIZE, thus avoid clash with writes
57 * from the migration guest workload.
59 #define MAGIC_OFFSET_SHUFFLE 1024
60 #define MAGIC_OFFSET (MAGIC_OFFSET_BASE + MAGIC_OFFSET_SHUFFLE)
61 #define MAGIC_MARKER 0xFEED12345678CAFEULL
64 * Dirtylimit stop working if dirty page rate error
65 * value less than DIRTYLIMIT_TOLERANCE_RANGE
67 #define DIRTYLIMIT_TOLERANCE_RANGE 25 /* MB/s */
69 #define ANALYZE_SCRIPT "scripts/analyze-migration.py"
71 #define QEMU_VM_FILE_MAGIC 0x5145564d
72 #define FILE_TEST_FILENAME "migfile"
73 #define FILE_TEST_OFFSET 0x1000
74 #define QEMU_ENV_SRC "QTEST_QEMU_BINARY_SRC"
75 #define QEMU_ENV_DST "QTEST_QEMU_BINARY_DST"
77 #if defined(__linux__)
78 #include <sys/syscall.h>
82 #if defined(__linux__) && defined(__NR_userfaultfd) && defined(CONFIG_EVENTFD)
83 #include <sys/eventfd.h>
84 #include <sys/ioctl.h>
85 #include "qemu/userfaultfd.h"
87 static bool ufd_version_check(void)
89 struct uffdio_api api_struct
;
92 int ufd
= uffd_open(O_CLOEXEC
);
95 g_test_message("Skipping test: userfaultfd not available");
99 api_struct
.api
= UFFD_API
;
100 api_struct
.features
= 0;
101 if (ioctl(ufd
, UFFDIO_API
, &api_struct
)) {
102 g_test_message("Skipping test: UFFDIO_API failed");
105 uffd_feature_thread_id
= api_struct
.features
& UFFD_FEATURE_THREAD_ID
;
107 ioctl_mask
= (__u64
)1 << _UFFDIO_REGISTER
|
108 (__u64
)1 << _UFFDIO_UNREGISTER
;
109 if ((api_struct
.ioctls
& ioctl_mask
) != ioctl_mask
) {
110 g_test_message("Skipping test: Missing userfault feature");
118 static bool ufd_version_check(void)
120 g_test_message("Skipping test: Userfault not available (builtdtime)");
127 static char *bootpath
;
129 /* The boot file modifies memory area in [start_address, end_address)
130 * repeatedly. It outputs a 'B' at a fixed rate while it's still running.
132 #include "tests/migration/i386/a-b-bootblock.h"
133 #include "tests/migration/aarch64/a-b-kernel.h"
134 #include "tests/migration/s390x/a-b-bios.h"
136 static void bootfile_create(char *dir
, bool suspend_me
)
138 const char *arch
= qtest_get_arch();
139 unsigned char *content
;
142 bootpath
= g_strdup_printf("%s/bootsect", dir
);
143 if (strcmp(arch
, "i386") == 0 || strcmp(arch
, "x86_64") == 0) {
144 /* the assembled x86 boot sector should be exactly one sector large */
145 g_assert(sizeof(x86_bootsect
) == 512);
146 x86_bootsect
[SYM_suspend_me
- SYM_start
] = suspend_me
;
147 content
= x86_bootsect
;
148 len
= sizeof(x86_bootsect
);
149 } else if (g_str_equal(arch
, "s390x")) {
151 len
= sizeof(s390x_elf
);
152 } else if (strcmp(arch
, "ppc64") == 0) {
154 * sane architectures can be programmed at the boot prompt
157 } else if (strcmp(arch
, "aarch64") == 0) {
158 content
= aarch64_kernel
;
159 len
= sizeof(aarch64_kernel
);
160 g_assert(sizeof(aarch64_kernel
) <= ARM_TEST_MAX_KERNEL_SIZE
);
162 g_assert_not_reached();
165 FILE *bootfile
= fopen(bootpath
, "wb");
167 g_assert_cmpint(fwrite(content
, len
, 1, bootfile
), ==, 1);
171 static void bootfile_delete(void)
179 * Wait for some output in the serial output file,
180 * we get an 'A' followed by an endless string of 'B's
181 * but on the destination we won't have the A (unless we enabled suspend/resume)
183 static void wait_for_serial(const char *side
)
185 g_autofree
char *serialpath
= g_strdup_printf("%s/%s", tmpfs
, side
);
186 FILE *serialfile
= fopen(serialpath
, "r");
187 const char *arch
= qtest_get_arch();
188 int started
= (strcmp(side
, "src_serial") == 0 &&
189 strcmp(arch
, "ppc64") == 0) ? 0 : 1;
192 int readvalue
= fgetc(serialfile
);
195 /* SLOF prints its banner before starting test,
196 * to ignore it, mark the start of the test with '_',
197 * ignore all characters until this marker
204 fseek(serialfile
, 0, SEEK_SET
);
221 started
= (strcmp(side
, "src_serial") == 0 &&
222 strcmp(arch
, "ppc64") == 0) ? 0 : 1;
223 fseek(serialfile
, 0, SEEK_SET
);
228 fprintf(stderr
, "Unexpected %d on %s serial\n", readvalue
, side
);
229 g_assert_not_reached();
234 static void wait_for_stop(QTestState
*who
, QTestMigrationState
*state
)
236 if (!state
->stop_seen
) {
237 qtest_qmp_eventwait(who
, "STOP");
241 static void wait_for_resume(QTestState
*who
, QTestMigrationState
*state
)
243 if (!state
->resume_seen
) {
244 qtest_qmp_eventwait(who
, "RESUME");
248 static void wait_for_suspend(QTestState
*who
, QTestMigrationState
*state
)
250 if (state
->suspend_me
&& !state
->suspend_seen
) {
251 qtest_qmp_eventwait(who
, "SUSPEND");
256 * It's tricky to use qemu's migration event capability with qtest,
257 * events suddenly appearing confuse the qmp()/hmp() responses.
260 static int64_t read_ram_property_int(QTestState
*who
, const char *property
)
262 QDict
*rsp_return
, *rsp_ram
;
265 rsp_return
= migrate_query_not_failed(who
);
266 if (!qdict_haskey(rsp_return
, "ram")) {
270 rsp_ram
= qdict_get_qdict(rsp_return
, "ram");
271 result
= qdict_get_try_int(rsp_ram
, property
, 0);
273 qobject_unref(rsp_return
);
277 static int64_t read_migrate_property_int(QTestState
*who
, const char *property
)
282 rsp_return
= migrate_query_not_failed(who
);
283 result
= qdict_get_try_int(rsp_return
, property
, 0);
284 qobject_unref(rsp_return
);
288 static uint64_t get_migration_pass(QTestState
*who
)
290 return read_ram_property_int(who
, "dirty-sync-count");
293 static void read_blocktime(QTestState
*who
)
297 rsp_return
= migrate_query_not_failed(who
);
298 g_assert(qdict_haskey(rsp_return
, "postcopy-blocktime"));
299 qobject_unref(rsp_return
);
303 * Wait for two changes in the migration pass count, but bail if we stop.
305 static void wait_for_migration_pass(QTestState
*who
)
307 uint64_t pass
, prev_pass
= 0, changes
= 0;
309 while (changes
< 2 && !src_state
.stop_seen
&& !src_state
.suspend_seen
) {
311 pass
= get_migration_pass(who
);
312 changes
+= (pass
!= prev_pass
);
317 static void check_guests_ram(QTestState
*who
)
319 /* Our ASM test will have been incrementing one byte from each page from
320 * start_address to < end_address in order. This gives us a constraint
321 * that any page's byte should be equal or less than the previous pages
322 * byte (mod 256); and they should all be equal except for one transition
323 * at the point where we meet the incrementer. (We're running this with
324 * the guest stopped).
329 bool hit_edge
= false;
332 qtest_memread(who
, start_address
, &first_byte
, 1);
333 last_byte
= first_byte
;
335 for (address
= start_address
+ TEST_MEM_PAGE_SIZE
; address
< end_address
;
336 address
+= TEST_MEM_PAGE_SIZE
)
339 qtest_memread(who
, address
, &b
, 1);
340 if (b
!= last_byte
) {
341 if (((b
+ 1) % 256) == last_byte
&& !hit_edge
) {
342 /* This is OK, the guest stopped at the point of
343 * incrementing the previous page but didn't get
351 fprintf(stderr
, "Memory content inconsistency at %x"
352 " first_byte = %x last_byte = %x current = %x"
354 address
, first_byte
, last_byte
, b
, hit_edge
);
360 fprintf(stderr
, "and in another %d pages", bad
- 10);
365 static void cleanup(const char *filename
)
367 g_autofree
char *path
= g_strdup_printf("%s/%s", tmpfs
, filename
);
372 static char *SocketAddress_to_str(SocketAddress
*addr
)
374 switch (addr
->type
) {
375 case SOCKET_ADDRESS_TYPE_INET
:
376 return g_strdup_printf("tcp:%s:%s",
379 case SOCKET_ADDRESS_TYPE_UNIX
:
380 return g_strdup_printf("unix:%s",
381 addr
->u
.q_unix
.path
);
382 case SOCKET_ADDRESS_TYPE_FD
:
383 return g_strdup_printf("fd:%s", addr
->u
.fd
.str
);
384 case SOCKET_ADDRESS_TYPE_VSOCK
:
385 return g_strdup_printf("tcp:%s:%s",
389 return g_strdup("unknown address type");
393 static char *migrate_get_socket_address(QTestState
*who
, const char *parameter
)
397 SocketAddressList
*addrs
;
401 rsp
= migrate_query(who
);
402 object
= qdict_get(rsp
, parameter
);
404 iv
= qobject_input_visitor_new(object
);
405 visit_type_SocketAddressList(iv
, NULL
, &addrs
, &error_abort
);
408 /* we are only using a single address */
409 result
= SocketAddress_to_str(addrs
->value
);
411 qapi_free_SocketAddressList(addrs
);
416 static long long migrate_get_parameter_int(QTestState
*who
,
417 const char *parameter
)
422 rsp
= qtest_qmp_assert_success_ref(
423 who
, "{ 'execute': 'query-migrate-parameters' }");
424 result
= qdict_get_int(rsp
, parameter
);
429 static void migrate_check_parameter_int(QTestState
*who
, const char *parameter
,
434 result
= migrate_get_parameter_int(who
, parameter
);
435 g_assert_cmpint(result
, ==, value
);
438 static void migrate_set_parameter_int(QTestState
*who
, const char *parameter
,
441 qtest_qmp_assert_success(who
,
442 "{ 'execute': 'migrate-set-parameters',"
443 "'arguments': { %s: %lld } }",
445 migrate_check_parameter_int(who
, parameter
, value
);
448 static char *migrate_get_parameter_str(QTestState
*who
,
449 const char *parameter
)
454 rsp
= qtest_qmp_assert_success_ref(
455 who
, "{ 'execute': 'query-migrate-parameters' }");
456 result
= g_strdup(qdict_get_str(rsp
, parameter
));
461 static void migrate_check_parameter_str(QTestState
*who
, const char *parameter
,
464 g_autofree
char *result
= migrate_get_parameter_str(who
, parameter
);
465 g_assert_cmpstr(result
, ==, value
);
468 static void migrate_set_parameter_str(QTestState
*who
, const char *parameter
,
471 qtest_qmp_assert_success(who
,
472 "{ 'execute': 'migrate-set-parameters',"
473 "'arguments': { %s: %s } }",
475 migrate_check_parameter_str(who
, parameter
, value
);
478 static long long migrate_get_parameter_bool(QTestState
*who
,
479 const char *parameter
)
484 rsp
= qtest_qmp_assert_success_ref(
485 who
, "{ 'execute': 'query-migrate-parameters' }");
486 result
= qdict_get_bool(rsp
, parameter
);
491 static void migrate_check_parameter_bool(QTestState
*who
, const char *parameter
,
496 result
= migrate_get_parameter_bool(who
, parameter
);
497 g_assert_cmpint(result
, ==, value
);
500 static void migrate_set_parameter_bool(QTestState
*who
, const char *parameter
,
503 qtest_qmp_assert_success(who
,
504 "{ 'execute': 'migrate-set-parameters',"
505 "'arguments': { %s: %i } }",
507 migrate_check_parameter_bool(who
, parameter
, value
);
510 static void migrate_ensure_non_converge(QTestState
*who
)
512 /* Can't converge with 1ms downtime + 3 mbs bandwidth limit */
513 migrate_set_parameter_int(who
, "max-bandwidth", 3 * 1000 * 1000);
514 migrate_set_parameter_int(who
, "downtime-limit", 1);
517 static void migrate_ensure_converge(QTestState
*who
)
519 /* Should converge with 30s downtime + 1 gbs bandwidth limit */
520 migrate_set_parameter_int(who
, "max-bandwidth", 1 * 1000 * 1000 * 1000);
521 migrate_set_parameter_int(who
, "downtime-limit", 30 * 1000);
525 * Our goal is to ensure that we run a single full migration
526 * iteration, and also dirty memory, ensuring that at least
527 * one further iteration is required.
529 * We can't directly synchronize with the start of a migration
530 * so we have to apply some tricks monitoring memory that is
533 * Initially we set the migration bandwidth to an insanely
534 * low value, with tiny max downtime too. This basically
535 * guarantees migration will never complete.
537 * This will result in a test that is unacceptably slow though,
538 * so we can't let the entire migration pass run at this speed.
539 * Our intent is to let it run just long enough that we can
540 * prove data prior to the marker has been transferred *AND*
541 * also prove this transferred data is dirty again.
543 * Before migration starts, we write a 64-bit magic marker
544 * into a fixed location in the src VM RAM.
546 * Then watch dst memory until the marker appears. This is
547 * proof that start_address -> MAGIC_OFFSET_BASE has been
550 * Finally we go back to the source and read a byte just
551 * before the marker until we see it flip in value. This
552 * is proof that start_address -> MAGIC_OFFSET_BASE
553 * is now dirty again.
555 * IOW, we're guaranteed at least a 2nd migration pass
558 * We can now let migration run at full speed to finish
561 static void migrate_prepare_for_dirty_mem(QTestState
*from
)
564 * The guest workflow iterates from start_address to
565 * end_address, writing 1 byte every TEST_MEM_PAGE_SIZE
568 * IOW, if we write to mem at a point which is NOT
569 * a multiple of TEST_MEM_PAGE_SIZE, our write won't
570 * conflict with the migration workflow.
572 * We put in a marker here, that we'll use to determine
573 * when the data has been transferred to the dst.
575 qtest_writeq(from
, start_address
+ MAGIC_OFFSET
, MAGIC_MARKER
);
578 static void migrate_wait_for_dirty_mem(QTestState
*from
,
581 uint64_t watch_address
= start_address
+ MAGIC_OFFSET_BASE
;
582 uint64_t marker_address
= start_address
+ MAGIC_OFFSET
;
586 * Wait for the MAGIC_MARKER to get transferred, as an
587 * indicator that a migration pass has made some known
588 * amount of progress.
592 } while (qtest_readq(to
, marker_address
) != MAGIC_MARKER
);
595 /* If suspended, src only iterates once, and watch_byte may never change */
596 if (src_state
.suspend_me
) {
601 * Now ensure that already transferred bytes are
602 * dirty again from the guest workload. Note the
603 * guest byte value will wrap around and by chance
604 * match the original watch_byte. This is harmless
605 * as we'll eventually see a different value if we
608 watch_byte
= qtest_readb(from
, watch_address
);
611 } while (qtest_readb(from
, watch_address
) == watch_byte
);
615 static void migrate_pause(QTestState
*who
)
617 qtest_qmp_assert_success(who
, "{ 'execute': 'migrate-pause' }");
620 static void migrate_continue(QTestState
*who
, const char *state
)
622 qtest_qmp_assert_success(who
,
623 "{ 'execute': 'migrate-continue',"
624 " 'arguments': { 'state': %s } }",
628 static void migrate_recover(QTestState
*who
, const char *uri
)
630 qtest_qmp_assert_success(who
,
631 "{ 'execute': 'migrate-recover', "
632 " 'id': 'recover-cmd', "
633 " 'arguments': { 'uri': %s } }",
637 static void migrate_cancel(QTestState
*who
)
639 qtest_qmp_assert_success(who
, "{ 'execute': 'migrate_cancel' }");
642 static void migrate_postcopy_start(QTestState
*from
, QTestState
*to
)
644 qtest_qmp_assert_success(from
, "{ 'execute': 'migrate-start-postcopy' }");
646 wait_for_stop(from
, &src_state
);
647 qtest_qmp_eventwait(to
, "RESUME");
652 * QTEST_LOG=1 may override this. When QTEST_LOG=1, we always dump errors
653 * unconditionally, because it means the user would like to be verbose.
657 /* only launch the target process */
659 /* Use dirty ring if true; dirty logging otherwise */
661 const char *opts_source
;
662 const char *opts_target
;
663 /* suspend the src before migrating to dest. */
668 * A hook that runs after the src and dst QEMUs have been
669 * created, but before the migration is started. This can
670 * be used to set migration parameters and capabilities.
672 * Returns: NULL, or a pointer to opaque state to be
673 * later passed to the TestMigrateFinishHook
675 typedef void * (*TestMigrateStartHook
)(QTestState
*from
,
679 * A hook that runs after the migration has finished,
680 * regardless of whether it succeeded or failed, but
681 * before QEMU has terminated (unless it self-terminated
682 * due to migration error)
684 * @opaque is a pointer to state previously returned
685 * by the TestMigrateStartHook if any, or NULL.
687 typedef void (*TestMigrateFinishHook
)(QTestState
*from
,
692 /* Optional: fine tune start parameters */
695 /* Required: the URI for the dst QEMU to listen on */
696 const char *listen_uri
;
699 * Optional: the URI for the src QEMU to connect to
700 * If NULL, then it will query the dst QEMU for its actual
701 * listening address and use that as the connect address.
702 * This allows for dynamically picking a free TCP port.
704 const char *connect_uri
;
706 /* Optional: callback to run at start to set migration parameters */
707 TestMigrateStartHook start_hook
;
708 /* Optional: callback to run at finish to cleanup */
709 TestMigrateFinishHook finish_hook
;
712 * Optional: normally we expect the migration process to complete.
714 * There can be a variety of reasons and stages in which failure
715 * can happen during tests.
717 * If a failure is expected to happen at time of establishing
718 * the connection, then MIG_TEST_FAIL will indicate that the dst
719 * QEMU is expected to stay running and accept future migration
722 * If a failure is expected to happen while processing the
723 * migration stream, then MIG_TEST_FAIL_DEST_QUIT_ERR will indicate
724 * that the dst QEMU is expected to quit with non-zero exit status
727 /* This test should succeed, the default */
728 MIG_TEST_SUCCEED
= 0,
729 /* This test should fail, dest qemu should keep alive */
731 /* This test should fail, dest qemu should fail with abnormal status */
732 MIG_TEST_FAIL_DEST_QUIT_ERR
,
733 /* The QMP command for this migration should fail with an error */
738 * Optional: set number of migration passes to wait for, if live==true.
739 * If zero, then merely wait for a few MB of dirty data
741 unsigned int iterations
;
744 * Optional: whether the guest CPUs should be running during a precopy
745 * migration test. We used to always run with live but it took much
746 * longer so we reduced live tests to only the ones that have solid
747 * reason to be tested live-only. For each of the new test cases for
748 * precopy please provide justifications to use live explicitly (please
749 * refer to existing ones with live=true), or use live=off by default.
753 /* Postcopy specific fields */
755 bool postcopy_preempt
;
756 bool postcopy_recovery_test_fail
;
759 static int test_migrate_start(QTestState
**from
, QTestState
**to
,
760 const char *uri
, MigrateStart
*args
)
762 g_autofree gchar
*arch_source
= NULL
;
763 g_autofree gchar
*arch_target
= NULL
;
764 /* options for source and target */
765 g_autofree gchar
*arch_opts
= NULL
;
766 g_autofree gchar
*cmd_source
= NULL
;
767 g_autofree gchar
*cmd_target
= NULL
;
768 const gchar
*ignore_stderr
;
769 g_autofree
char *shmem_opts
= NULL
;
770 g_autofree
char *shmem_path
= NULL
;
771 const char *kvm_opts
= NULL
;
772 const char *arch
= qtest_get_arch();
773 const char *memory_size
;
774 const char *machine_alias
, *machine_opts
= "";
775 g_autofree
char *machine
= NULL
;
777 if (args
->use_shmem
) {
778 if (!g_file_test("/dev/shm", G_FILE_TEST_IS_DIR
)) {
779 g_test_skip("/dev/shm is not supported");
784 dst_state
= (QTestMigrationState
) { };
785 src_state
= (QTestMigrationState
) { };
786 bootfile_create(tmpfs
, args
->suspend_me
);
787 src_state
.suspend_me
= args
->suspend_me
;
789 if (strcmp(arch
, "i386") == 0 || strcmp(arch
, "x86_64") == 0) {
790 memory_size
= "150M";
792 if (g_str_equal(arch
, "i386")) {
793 machine_alias
= "pc";
795 machine_alias
= "q35";
797 arch_opts
= g_strdup_printf(
798 "-drive if=none,id=d0,file=%s,format=raw "
799 "-device ide-hd,drive=d0,secs=1,cyls=1,heads=1", bootpath
);
800 start_address
= X86_TEST_MEM_START
;
801 end_address
= X86_TEST_MEM_END
;
802 } else if (g_str_equal(arch
, "s390x")) {
803 memory_size
= "128M";
804 machine_alias
= "s390-ccw-virtio";
805 arch_opts
= g_strdup_printf("-bios %s", bootpath
);
806 start_address
= S390_TEST_MEM_START
;
807 end_address
= S390_TEST_MEM_END
;
808 } else if (strcmp(arch
, "ppc64") == 0) {
809 memory_size
= "256M";
810 start_address
= PPC_TEST_MEM_START
;
811 end_address
= PPC_TEST_MEM_END
;
812 arch_source
= g_strdup_printf("-prom-env 'use-nvramrc?=true' -prom-env "
813 "'nvramrc=hex .\" _\" begin %x %x "
814 "do i c@ 1 + i c! 1000 +loop .\" B\" 0 "
815 "until'", end_address
, start_address
);
816 machine_alias
= "pseries";
817 machine_opts
= "vsmt=8";
818 arch_opts
= g_strdup("-nodefaults");
819 } else if (strcmp(arch
, "aarch64") == 0) {
820 memory_size
= "150M";
821 machine_alias
= "virt";
822 machine_opts
= "gic-version=max";
823 arch_opts
= g_strdup_printf("-cpu max -kernel %s", bootpath
);
824 start_address
= ARM_TEST_MEM_START
;
825 end_address
= ARM_TEST_MEM_END
;
827 g_assert_not_reached();
830 if (!getenv("QTEST_LOG") && args
->hide_stderr
) {
832 ignore_stderr
= "2>/dev/null";
835 * On Windows the QEMU executable is created via CreateProcess() and
836 * IO redirection does not work, so don't bother adding IO redirection
837 * to the command line.
845 if (args
->use_shmem
) {
846 shmem_path
= g_strdup_printf("/dev/shm/qemu-%d", getpid());
847 shmem_opts
= g_strdup_printf(
848 "-object memory-backend-file,id=mem0,size=%s"
849 ",mem-path=%s,share=on -numa node,memdev=mem0",
850 memory_size
, shmem_path
);
853 if (args
->use_dirty_ring
) {
854 kvm_opts
= ",dirty-ring-size=4096";
857 machine
= resolve_machine_version(machine_alias
, QEMU_ENV_SRC
,
860 g_test_message("Using machine type: %s", machine
);
862 cmd_source
= g_strdup_printf("-accel kvm%s -accel tcg "
864 "-name source,debug-threads=on "
866 "-serial file:%s/src_serial "
868 kvm_opts
? kvm_opts
: "",
869 machine
, machine_opts
,
871 arch_opts
? arch_opts
: "",
872 arch_source
? arch_source
: "",
873 shmem_opts
? shmem_opts
: "",
874 args
->opts_source
? args
->opts_source
: "",
876 if (!args
->only_target
) {
877 *from
= qtest_init_with_env(QEMU_ENV_SRC
, cmd_source
);
878 qtest_qmp_set_event_callback(*from
,
879 migrate_watch_for_events
,
883 cmd_target
= g_strdup_printf("-accel kvm%s -accel tcg "
885 "-name target,debug-threads=on "
887 "-serial file:%s/dest_serial "
890 kvm_opts
? kvm_opts
: "",
891 machine
, machine_opts
,
892 memory_size
, tmpfs
, uri
,
893 arch_opts
? arch_opts
: "",
894 arch_target
? arch_target
: "",
895 shmem_opts
? shmem_opts
: "",
896 args
->opts_target
? args
->opts_target
: "",
898 *to
= qtest_init_with_env(QEMU_ENV_DST
, cmd_target
);
899 qtest_qmp_set_event_callback(*to
,
900 migrate_watch_for_events
,
904 * Remove shmem file immediately to avoid memory leak in test failed case.
905 * It's valid because QEMU has already opened this file
907 if (args
->use_shmem
) {
914 static void test_migrate_end(QTestState
*from
, QTestState
*to
, bool test_dest
)
916 unsigned char dest_byte_a
, dest_byte_b
, dest_byte_c
, dest_byte_d
;
921 qtest_memread(to
, start_address
, &dest_byte_a
, 1);
923 /* Destination still running, wait for a byte to change */
925 qtest_memread(to
, start_address
, &dest_byte_b
, 1);
927 } while (dest_byte_a
== dest_byte_b
);
929 qtest_qmp_assert_success(to
, "{ 'execute' : 'stop'}");
931 /* With it stopped, check nothing changes */
932 qtest_memread(to
, start_address
, &dest_byte_c
, 1);
934 qtest_memread(to
, start_address
, &dest_byte_d
, 1);
935 g_assert_cmpint(dest_byte_c
, ==, dest_byte_d
);
937 check_guests_ram(to
);
942 cleanup("migsocket");
943 cleanup("src_serial");
944 cleanup("dest_serial");
945 cleanup(FILE_TEST_FILENAME
);
949 struct TestMigrateTLSPSKData
{
957 test_migrate_tls_psk_start_common(QTestState
*from
,
961 struct TestMigrateTLSPSKData
*data
=
962 g_new0(struct TestMigrateTLSPSKData
, 1);
964 data
->workdir
= g_strdup_printf("%s/tlscredspsk0", tmpfs
);
965 data
->pskfile
= g_strdup_printf("%s/%s", data
->workdir
,
966 QCRYPTO_TLS_CREDS_PSKFILE
);
967 g_mkdir_with_parents(data
->workdir
, 0700);
968 test_tls_psk_init(data
->pskfile
);
971 data
->workdiralt
= g_strdup_printf("%s/tlscredspskalt0", tmpfs
);
972 data
->pskfilealt
= g_strdup_printf("%s/%s", data
->workdiralt
,
973 QCRYPTO_TLS_CREDS_PSKFILE
);
974 g_mkdir_with_parents(data
->workdiralt
, 0700);
975 test_tls_psk_init_alt(data
->pskfilealt
);
978 qtest_qmp_assert_success(from
,
979 "{ 'execute': 'object-add',"
980 " 'arguments': { 'qom-type': 'tls-creds-psk',"
981 " 'id': 'tlscredspsk0',"
982 " 'endpoint': 'client',"
984 " 'username': 'qemu'} }",
987 qtest_qmp_assert_success(to
,
988 "{ 'execute': 'object-add',"
989 " 'arguments': { 'qom-type': 'tls-creds-psk',"
990 " 'id': 'tlscredspsk0',"
991 " 'endpoint': 'server',"
993 mismatch
? data
->workdiralt
: data
->workdir
);
995 migrate_set_parameter_str(from
, "tls-creds", "tlscredspsk0");
996 migrate_set_parameter_str(to
, "tls-creds", "tlscredspsk0");
1002 test_migrate_tls_psk_start_match(QTestState
*from
,
1005 return test_migrate_tls_psk_start_common(from
, to
, false);
1009 test_migrate_tls_psk_start_mismatch(QTestState
*from
,
1012 return test_migrate_tls_psk_start_common(from
, to
, true);
1016 test_migrate_tls_psk_finish(QTestState
*from
,
1020 struct TestMigrateTLSPSKData
*data
= opaque
;
1022 test_tls_psk_cleanup(data
->pskfile
);
1023 if (data
->pskfilealt
) {
1024 test_tls_psk_cleanup(data
->pskfilealt
);
1026 rmdir(data
->workdir
);
1027 if (data
->workdiralt
) {
1028 rmdir(data
->workdiralt
);
1031 g_free(data
->workdiralt
);
1032 g_free(data
->pskfilealt
);
1033 g_free(data
->workdir
);
1034 g_free(data
->pskfile
);
1047 } TestMigrateTLSX509Data
;
1054 const char *certhostname
;
1055 const char *certipaddr
;
1056 } TestMigrateTLSX509
;
1059 test_migrate_tls_x509_start_common(QTestState
*from
,
1061 TestMigrateTLSX509
*args
)
1063 TestMigrateTLSX509Data
*data
= g_new0(TestMigrateTLSX509Data
, 1);
1065 data
->workdir
= g_strdup_printf("%s/tlscredsx5090", tmpfs
);
1066 data
->keyfile
= g_strdup_printf("%s/key.pem", data
->workdir
);
1068 data
->cacert
= g_strdup_printf("%s/ca-cert.pem", data
->workdir
);
1069 data
->serverkey
= g_strdup_printf("%s/server-key.pem", data
->workdir
);
1070 data
->servercert
= g_strdup_printf("%s/server-cert.pem", data
->workdir
);
1071 if (args
->clientcert
) {
1072 data
->clientkey
= g_strdup_printf("%s/client-key.pem", data
->workdir
);
1073 data
->clientcert
= g_strdup_printf("%s/client-cert.pem", data
->workdir
);
1076 g_mkdir_with_parents(data
->workdir
, 0700);
1078 test_tls_init(data
->keyfile
);
1080 g_assert(link(data
->keyfile
, data
->serverkey
) == 0);
1082 g_assert(CreateHardLink(data
->serverkey
, data
->keyfile
, NULL
) != 0);
1084 if (args
->clientcert
) {
1086 g_assert(link(data
->keyfile
, data
->clientkey
) == 0);
1088 g_assert(CreateHardLink(data
->clientkey
, data
->keyfile
, NULL
) != 0);
1092 TLS_ROOT_REQ_SIMPLE(cacertreq
, data
->cacert
);
1093 if (args
->clientcert
) {
1094 TLS_CERT_REQ_SIMPLE_CLIENT(servercertreq
, cacertreq
,
1095 args
->hostileclient
?
1096 QCRYPTO_TLS_TEST_CLIENT_HOSTILE_NAME
:
1097 QCRYPTO_TLS_TEST_CLIENT_NAME
,
1101 TLS_CERT_REQ_SIMPLE_SERVER(clientcertreq
, cacertreq
,
1106 qtest_qmp_assert_success(from
,
1107 "{ 'execute': 'object-add',"
1108 " 'arguments': { 'qom-type': 'tls-creds-x509',"
1109 " 'id': 'tlscredsx509client0',"
1110 " 'endpoint': 'client',"
1112 " 'sanity-check': true,"
1113 " 'verify-peer': true} }",
1115 migrate_set_parameter_str(from
, "tls-creds", "tlscredsx509client0");
1116 if (args
->certhostname
) {
1117 migrate_set_parameter_str(from
, "tls-hostname", args
->certhostname
);
1120 qtest_qmp_assert_success(to
,
1121 "{ 'execute': 'object-add',"
1122 " 'arguments': { 'qom-type': 'tls-creds-x509',"
1123 " 'id': 'tlscredsx509server0',"
1124 " 'endpoint': 'server',"
1126 " 'sanity-check': true,"
1127 " 'verify-peer': %i} }",
1128 data
->workdir
, args
->verifyclient
);
1129 migrate_set_parameter_str(to
, "tls-creds", "tlscredsx509server0");
1131 if (args
->authzclient
) {
1132 qtest_qmp_assert_success(to
,
1133 "{ 'execute': 'object-add',"
1134 " 'arguments': { 'qom-type': 'authz-simple',"
1135 " 'id': 'tlsauthz0',"
1136 " 'identity': %s} }",
1137 "CN=" QCRYPTO_TLS_TEST_CLIENT_NAME
);
1138 migrate_set_parameter_str(to
, "tls-authz", "tlsauthz0");
1145 * The normal case: match server's cert hostname against
1146 * whatever host we were telling QEMU to connect to (if any)
1149 test_migrate_tls_x509_start_default_host(QTestState
*from
,
1152 TestMigrateTLSX509 args
= {
1153 .verifyclient
= true,
1155 .certipaddr
= "127.0.0.1"
1157 return test_migrate_tls_x509_start_common(from
, to
, &args
);
1161 * The unusual case: the server's cert is different from
1162 * the address we're telling QEMU to connect to (if any),
1163 * so we must give QEMU an explicit hostname to validate
1166 test_migrate_tls_x509_start_override_host(QTestState
*from
,
1169 TestMigrateTLSX509 args
= {
1170 .verifyclient
= true,
1172 .certhostname
= "qemu.org",
1174 return test_migrate_tls_x509_start_common(from
, to
, &args
);
1178 * The unusual case: the server's cert is different from
1179 * the address we're telling QEMU to connect to, and so we
1180 * expect the client to reject the server
1183 test_migrate_tls_x509_start_mismatch_host(QTestState
*from
,
1186 TestMigrateTLSX509 args
= {
1187 .verifyclient
= true,
1189 .certipaddr
= "10.0.0.1",
1191 return test_migrate_tls_x509_start_common(from
, to
, &args
);
1195 test_migrate_tls_x509_start_friendly_client(QTestState
*from
,
1198 TestMigrateTLSX509 args
= {
1199 .verifyclient
= true,
1201 .authzclient
= true,
1202 .certipaddr
= "127.0.0.1",
1204 return test_migrate_tls_x509_start_common(from
, to
, &args
);
1208 test_migrate_tls_x509_start_hostile_client(QTestState
*from
,
1211 TestMigrateTLSX509 args
= {
1212 .verifyclient
= true,
1214 .hostileclient
= true,
1215 .authzclient
= true,
1216 .certipaddr
= "127.0.0.1",
1218 return test_migrate_tls_x509_start_common(from
, to
, &args
);
1222 * The case with no client certificate presented,
1223 * and no server verification
1226 test_migrate_tls_x509_start_allow_anon_client(QTestState
*from
,
1229 TestMigrateTLSX509 args
= {
1230 .certipaddr
= "127.0.0.1",
1232 return test_migrate_tls_x509_start_common(from
, to
, &args
);
1236 * The case with no client certificate presented,
1237 * and server verification rejecting
1240 test_migrate_tls_x509_start_reject_anon_client(QTestState
*from
,
1243 TestMigrateTLSX509 args
= {
1244 .verifyclient
= true,
1245 .certipaddr
= "127.0.0.1",
1247 return test_migrate_tls_x509_start_common(from
, to
, &args
);
1251 test_migrate_tls_x509_finish(QTestState
*from
,
1255 TestMigrateTLSX509Data
*data
= opaque
;
1257 test_tls_cleanup(data
->keyfile
);
1258 g_free(data
->keyfile
);
1260 unlink(data
->cacert
);
1261 g_free(data
->cacert
);
1262 unlink(data
->servercert
);
1263 g_free(data
->servercert
);
1264 unlink(data
->serverkey
);
1265 g_free(data
->serverkey
);
1267 if (data
->clientcert
) {
1268 unlink(data
->clientcert
);
1269 g_free(data
->clientcert
);
1271 if (data
->clientkey
) {
1272 unlink(data
->clientkey
);
1273 g_free(data
->clientkey
);
1276 rmdir(data
->workdir
);
1277 g_free(data
->workdir
);
1281 #endif /* CONFIG_TASN1 */
1282 #endif /* CONFIG_GNUTLS */
1285 test_migrate_compress_start(QTestState
*from
,
1288 migrate_set_parameter_int(from
, "compress-level", 1);
1289 migrate_set_parameter_int(from
, "compress-threads", 4);
1290 migrate_set_parameter_bool(from
, "compress-wait-thread", true);
1291 migrate_set_parameter_int(to
, "decompress-threads", 4);
1293 migrate_set_capability(from
, "compress", true);
1294 migrate_set_capability(to
, "compress", true);
1300 test_migrate_compress_nowait_start(QTestState
*from
,
1303 migrate_set_parameter_int(from
, "compress-level", 9);
1304 migrate_set_parameter_int(from
, "compress-threads", 1);
1305 migrate_set_parameter_bool(from
, "compress-wait-thread", false);
1306 migrate_set_parameter_int(to
, "decompress-threads", 1);
1308 migrate_set_capability(from
, "compress", true);
1309 migrate_set_capability(to
, "compress", true);
1314 static int migrate_postcopy_prepare(QTestState
**from_ptr
,
1315 QTestState
**to_ptr
,
1316 MigrateCommon
*args
)
1318 QTestState
*from
, *to
;
1320 if (test_migrate_start(&from
, &to
, "defer", &args
->start
)) {
1324 if (args
->start_hook
) {
1325 args
->postcopy_data
= args
->start_hook(from
, to
);
1328 migrate_set_capability(from
, "postcopy-ram", true);
1329 migrate_set_capability(to
, "postcopy-ram", true);
1330 migrate_set_capability(to
, "postcopy-blocktime", true);
1332 if (args
->postcopy_preempt
) {
1333 migrate_set_capability(from
, "postcopy-preempt", true);
1334 migrate_set_capability(to
, "postcopy-preempt", true);
1337 migrate_ensure_non_converge(from
);
1339 migrate_prepare_for_dirty_mem(from
);
1340 qtest_qmp_assert_success(to
, "{ 'execute': 'migrate-incoming',"
1342 " 'channels': [ { 'channel-type': 'main',"
1343 " 'addr': { 'transport': 'socket',"
1345 " 'host': '127.0.0.1',"
1346 " 'port': '0' } } ] } }");
1348 /* Wait for the first serial output from the source */
1349 wait_for_serial("src_serial");
1350 wait_for_suspend(from
, &src_state
);
1352 g_autofree
char *uri
= migrate_get_socket_address(to
, "socket-address");
1353 migrate_qmp(from
, uri
, "{}");
1355 migrate_wait_for_dirty_mem(from
, to
);
1363 static void migrate_postcopy_complete(QTestState
*from
, QTestState
*to
,
1364 MigrateCommon
*args
)
1366 wait_for_migration_complete(from
);
1368 if (args
->start
.suspend_me
) {
1369 /* wakeup succeeds only if guest is suspended */
1370 qtest_qmp_assert_success(to
, "{'execute': 'system_wakeup'}");
1373 /* Make sure we get at least one "B" on destination */
1374 wait_for_serial("dest_serial");
1376 if (uffd_feature_thread_id
) {
1380 if (args
->finish_hook
) {
1381 args
->finish_hook(from
, to
, args
->postcopy_data
);
1382 args
->postcopy_data
= NULL
;
1385 test_migrate_end(from
, to
, true);
1388 static void test_postcopy_common(MigrateCommon
*args
)
1390 QTestState
*from
, *to
;
1392 if (migrate_postcopy_prepare(&from
, &to
, args
)) {
1395 migrate_postcopy_start(from
, to
);
1396 migrate_postcopy_complete(from
, to
, args
);
1399 static void test_postcopy(void)
1401 MigrateCommon args
= { };
1403 test_postcopy_common(&args
);
1406 static void test_postcopy_suspend(void)
1408 MigrateCommon args
= {
1409 .start
.suspend_me
= true,
1412 test_postcopy_common(&args
);
1415 static void test_postcopy_compress(void)
1417 MigrateCommon args
= {
1418 .start_hook
= test_migrate_compress_start
1421 test_postcopy_common(&args
);
1424 static void test_postcopy_preempt(void)
1426 MigrateCommon args
= {
1427 .postcopy_preempt
= true,
1430 test_postcopy_common(&args
);
1433 #ifdef CONFIG_GNUTLS
1434 static void test_postcopy_tls_psk(void)
1436 MigrateCommon args
= {
1437 .start_hook
= test_migrate_tls_psk_start_match
,
1438 .finish_hook
= test_migrate_tls_psk_finish
,
1441 test_postcopy_common(&args
);
1444 static void test_postcopy_preempt_tls_psk(void)
1446 MigrateCommon args
= {
1447 .postcopy_preempt
= true,
1448 .start_hook
= test_migrate_tls_psk_start_match
,
1449 .finish_hook
= test_migrate_tls_psk_finish
,
1452 test_postcopy_common(&args
);
1456 static void wait_for_postcopy_status(QTestState
*one
, const char *status
)
1458 wait_for_migration_status(one
, status
,
1459 (const char * []) { "failed", "active",
1460 "completed", NULL
});
1464 static void postcopy_recover_fail(QTestState
*from
, QTestState
*to
)
1466 int ret
, pair1
[2], pair2
[2];
1469 /* Create two unrelated socketpairs */
1470 ret
= qemu_socketpair(PF_LOCAL
, SOCK_STREAM
, 0, pair1
);
1471 g_assert_cmpint(ret
, ==, 0);
1473 ret
= qemu_socketpair(PF_LOCAL
, SOCK_STREAM
, 0, pair2
);
1474 g_assert_cmpint(ret
, ==, 0);
1477 * Give the guests unpaired ends of the sockets, so they'll all blocked
1478 * at reading. This mimics a wrong channel established.
1480 qtest_qmp_fds_assert_success(from
, &pair1
[0], 1,
1481 "{ 'execute': 'getfd',"
1482 " 'arguments': { 'fdname': 'fd-mig' }}");
1483 qtest_qmp_fds_assert_success(to
, &pair2
[0], 1,
1484 "{ 'execute': 'getfd',"
1485 " 'arguments': { 'fdname': 'fd-mig' }}");
1488 * Write the 1st byte as QEMU_VM_COMMAND (0x8) for the dest socket, to
1489 * emulate the 1st byte of a real recovery, but stops from there to
1490 * keep dest QEMU in RECOVER. This is needed so that we can kick off
1491 * the recover process on dest QEMU (by triggering the G_IO_IN event).
1493 * NOTE: this trick is not needed on src QEMUs, because src doesn't
1494 * rely on an pre-existing G_IO_IN event, so it will always trigger the
1495 * upcoming recovery anyway even if it can read nothing.
1497 #define QEMU_VM_COMMAND 0x08
1498 c
= QEMU_VM_COMMAND
;
1499 ret
= send(pair2
[1], &c
, 1, 0);
1500 g_assert_cmpint(ret
, ==, 1);
1502 migrate_recover(to
, "fd:fd-mig");
1503 migrate_qmp(from
, "fd:fd-mig", "{'resume': true}");
1506 * Make sure both QEMU instances will go into RECOVER stage, then test
1507 * kicking them out using migrate-pause.
1509 wait_for_postcopy_status(from
, "postcopy-recover");
1510 wait_for_postcopy_status(to
, "postcopy-recover");
1513 * This would be issued by the admin upon noticing the hang, we should
1514 * make sure we're able to kick this out.
1516 migrate_pause(from
);
1517 wait_for_postcopy_status(from
, "postcopy-paused");
1519 /* Do the same test on dest */
1521 wait_for_postcopy_status(to
, "postcopy-paused");
1530 static void test_postcopy_recovery_common(MigrateCommon
*args
)
1532 QTestState
*from
, *to
;
1533 g_autofree
char *uri
= NULL
;
1535 /* Always hide errors for postcopy recover tests since they're expected */
1536 args
->start
.hide_stderr
= true;
1538 if (migrate_postcopy_prepare(&from
, &to
, args
)) {
1542 /* Turn postcopy speed down, 4K/s is slow enough on any machines */
1543 migrate_set_parameter_int(from
, "max-postcopy-bandwidth", 4096);
1545 /* Now we start the postcopy */
1546 migrate_postcopy_start(from
, to
);
1549 * Wait until postcopy is really started; we can only run the
1550 * migrate-pause command during a postcopy
1552 wait_for_migration_status(from
, "postcopy-active", NULL
);
1555 * Manually stop the postcopy migration. This emulates a network
1556 * failure with the migration socket
1558 migrate_pause(from
);
1561 * Wait for destination side to reach postcopy-paused state. The
1562 * migrate-recover command can only succeed if destination machine
1563 * is in the paused state
1565 wait_for_postcopy_status(to
, "postcopy-paused");
1566 wait_for_postcopy_status(from
, "postcopy-paused");
1569 if (args
->postcopy_recovery_test_fail
) {
1571 * Test when a wrong socket specified for recover, and then the
1572 * ability to kick it out, and continue with a correct socket.
1574 postcopy_recover_fail(from
, to
);
1575 /* continue with a good recovery */
1580 * Create a new socket to emulate a new channel that is different
1581 * from the broken migration channel; tell the destination to
1582 * listen to the new port
1584 uri
= g_strdup_printf("unix:%s/migsocket-recover", tmpfs
);
1585 migrate_recover(to
, uri
);
1588 * Try to rebuild the migration channel using the resume flag and
1589 * the newly created channel
1591 migrate_qmp(from
, uri
, "{'resume': true}");
1593 /* Restore the postcopy bandwidth to unlimited */
1594 migrate_set_parameter_int(from
, "max-postcopy-bandwidth", 0);
1596 migrate_postcopy_complete(from
, to
, args
);
1599 static void test_postcopy_recovery(void)
1601 MigrateCommon args
= { };
1603 test_postcopy_recovery_common(&args
);
1606 static void test_postcopy_recovery_compress(void)
1608 MigrateCommon args
= {
1609 .start_hook
= test_migrate_compress_start
1612 test_postcopy_recovery_common(&args
);
1616 static void test_postcopy_recovery_double_fail(void)
1618 MigrateCommon args
= {
1619 .postcopy_recovery_test_fail
= true,
1622 test_postcopy_recovery_common(&args
);
1626 #ifdef CONFIG_GNUTLS
1627 static void test_postcopy_recovery_tls_psk(void)
1629 MigrateCommon args
= {
1630 .start_hook
= test_migrate_tls_psk_start_match
,
1631 .finish_hook
= test_migrate_tls_psk_finish
,
1634 test_postcopy_recovery_common(&args
);
1638 static void test_postcopy_preempt_recovery(void)
1640 MigrateCommon args
= {
1641 .postcopy_preempt
= true,
1644 test_postcopy_recovery_common(&args
);
1647 #ifdef CONFIG_GNUTLS
1648 /* This contains preempt+recovery+tls test altogether */
1649 static void test_postcopy_preempt_all(void)
1651 MigrateCommon args
= {
1652 .postcopy_preempt
= true,
1653 .start_hook
= test_migrate_tls_psk_start_match
,
1654 .finish_hook
= test_migrate_tls_psk_finish
,
1657 test_postcopy_recovery_common(&args
);
1662 static void test_baddest(void)
1664 MigrateStart args
= {
1667 QTestState
*from
, *to
;
1669 if (test_migrate_start(&from
, &to
, "tcp:127.0.0.1:0", &args
)) {
1672 migrate_qmp(from
, "tcp:127.0.0.1:0", "{}");
1673 wait_for_migration_fail(from
, false);
1674 test_migrate_end(from
, to
, false);
1678 static void test_analyze_script(void)
1680 MigrateStart args
= {
1681 .opts_source
= "-uuid 11111111-1111-1111-1111-111111111111",
1683 QTestState
*from
, *to
;
1684 g_autofree
char *uri
= NULL
;
1685 g_autofree
char *file
= NULL
;
1687 const char *python
= g_getenv("PYTHON");
1690 g_test_skip("PYTHON variable not set");
1695 if (test_migrate_start(&from
, &to
, "tcp:127.0.0.1:0", &args
)) {
1700 * Setting these two capabilities causes the "configuration"
1701 * vmstate to include subsections for them. The script needs to
1702 * parse those subsections properly.
1704 migrate_set_capability(from
, "validate-uuid", true);
1705 migrate_set_capability(from
, "x-ignore-shared", true);
1707 file
= g_strdup_printf("%s/migfile", tmpfs
);
1708 uri
= g_strdup_printf("exec:cat > %s", file
);
1710 migrate_ensure_converge(from
);
1711 migrate_qmp(from
, uri
, "{}");
1712 wait_for_migration_complete(from
);
1717 open("/dev/null", O_WRONLY
);
1718 execl(python
, python
, ANALYZE_SCRIPT
, "-f", file
, NULL
);
1719 g_assert_not_reached();
1722 g_assert(waitpid(pid
, &wstatus
, 0) == pid
);
1723 if (WIFEXITED(wstatus
) && WEXITSTATUS(wstatus
) != 0) {
1724 g_test_message("Failed to analyze the migration stream");
1727 test_migrate_end(from
, to
, false);
1732 static void test_precopy_common(MigrateCommon
*args
)
1734 QTestState
*from
, *to
;
1735 void *data_hook
= NULL
;
1736 g_autofree
char *connect_uri
= NULL
;
1738 if (test_migrate_start(&from
, &to
, args
->listen_uri
, &args
->start
)) {
1742 if (args
->start_hook
) {
1743 data_hook
= args
->start_hook(from
, to
);
1746 /* Wait for the first serial output from the source */
1747 if (args
->result
== MIG_TEST_SUCCEED
) {
1748 wait_for_serial("src_serial");
1749 wait_for_suspend(from
, &src_state
);
1753 migrate_ensure_non_converge(from
);
1754 migrate_prepare_for_dirty_mem(from
);
1757 * Testing non-live migration, we allow it to run at
1758 * full speed to ensure short test case duration.
1759 * For tests expected to fail, we don't need to
1762 if (args
->result
== MIG_TEST_SUCCEED
) {
1763 qtest_qmp_assert_success(from
, "{ 'execute' : 'stop'}");
1764 wait_for_stop(from
, &src_state
);
1765 migrate_ensure_converge(from
);
1769 if (!args
->connect_uri
) {
1770 connect_uri
= migrate_get_socket_address(to
, "socket-address");
1772 connect_uri
= g_strdup(args
->connect_uri
);
1775 if (args
->result
== MIG_TEST_QMP_ERROR
) {
1776 migrate_qmp_fail(from
, connect_uri
, "{}");
1780 migrate_qmp(from
, connect_uri
, "{}");
1782 if (args
->result
!= MIG_TEST_SUCCEED
) {
1783 bool allow_active
= args
->result
== MIG_TEST_FAIL
;
1784 wait_for_migration_fail(from
, allow_active
);
1786 if (args
->result
== MIG_TEST_FAIL_DEST_QUIT_ERR
) {
1787 qtest_set_expected_status(to
, EXIT_FAILURE
);
1792 * For initial iteration(s) we must do a full pass,
1793 * but for the final iteration, we need only wait
1794 * for some dirty mem before switching to converge
1796 while (args
->iterations
> 1) {
1797 wait_for_migration_pass(from
);
1800 migrate_wait_for_dirty_mem(from
, to
);
1802 migrate_ensure_converge(from
);
1805 * We do this first, as it has a timeout to stop us
1806 * hanging forever if migration didn't converge
1808 wait_for_migration_complete(from
);
1810 wait_for_stop(from
, &src_state
);
1813 wait_for_migration_complete(from
);
1815 * Must wait for dst to finish reading all incoming
1816 * data on the socket before issuing 'cont' otherwise
1819 wait_for_migration_complete(to
);
1821 qtest_qmp_assert_success(to
, "{ 'execute' : 'cont'}");
1824 wait_for_resume(to
, &dst_state
);
1826 if (args
->start
.suspend_me
) {
1827 /* wakeup succeeds only if guest is suspended */
1828 qtest_qmp_assert_success(to
, "{'execute': 'system_wakeup'}");
1831 wait_for_serial("dest_serial");
1835 if (args
->finish_hook
) {
1836 args
->finish_hook(from
, to
, data_hook
);
1839 test_migrate_end(from
, to
, args
->result
== MIG_TEST_SUCCEED
);
1842 static void test_file_common(MigrateCommon
*args
, bool stop_src
)
1844 QTestState
*from
, *to
;
1845 void *data_hook
= NULL
;
1846 g_autofree
char *connect_uri
= g_strdup(args
->connect_uri
);
1848 if (test_migrate_start(&from
, &to
, args
->listen_uri
, &args
->start
)) {
1853 * File migration is never live. We can keep the source VM running
1854 * during migration, but the destination will not be running
1857 g_assert_false(args
->live
);
1859 if (args
->start_hook
) {
1860 data_hook
= args
->start_hook(from
, to
);
1863 migrate_ensure_converge(from
);
1864 wait_for_serial("src_serial");
1867 qtest_qmp_assert_success(from
, "{ 'execute' : 'stop'}");
1868 wait_for_stop(from
, &src_state
);
1871 if (args
->result
== MIG_TEST_QMP_ERROR
) {
1872 migrate_qmp_fail(from
, connect_uri
, "{}");
1876 migrate_qmp(from
, connect_uri
, "{}");
1877 wait_for_migration_complete(from
);
1880 * We need to wait for the source to finish before starting the
1883 migrate_incoming_qmp(to
, connect_uri
, "{}");
1884 wait_for_migration_complete(to
);
1887 qtest_qmp_assert_success(to
, "{ 'execute' : 'cont'}");
1889 wait_for_resume(to
, &dst_state
);
1891 wait_for_serial("dest_serial");
1894 if (args
->finish_hook
) {
1895 args
->finish_hook(from
, to
, data_hook
);
1898 test_migrate_end(from
, to
, args
->result
== MIG_TEST_SUCCEED
);
1901 static void test_precopy_unix_plain(void)
1903 g_autofree
char *uri
= g_strdup_printf("unix:%s/migsocket", tmpfs
);
1904 MigrateCommon args
= {
1908 * The simplest use case of precopy, covering smoke tests of
1909 * get-dirty-log dirty tracking.
1914 test_precopy_common(&args
);
1917 static void test_precopy_unix_suspend_live(void)
1919 g_autofree
char *uri
= g_strdup_printf("unix:%s/migsocket", tmpfs
);
1920 MigrateCommon args
= {
1924 * despite being live, the test is fast because the src
1925 * suspends immediately.
1928 .start
.suspend_me
= true,
1931 test_precopy_common(&args
);
1934 static void test_precopy_unix_suspend_notlive(void)
1936 g_autofree
char *uri
= g_strdup_printf("unix:%s/migsocket", tmpfs
);
1937 MigrateCommon args
= {
1940 .start
.suspend_me
= true,
1943 test_precopy_common(&args
);
1946 static void test_precopy_unix_dirty_ring(void)
1948 g_autofree
char *uri
= g_strdup_printf("unix:%s/migsocket", tmpfs
);
1949 MigrateCommon args
= {
1951 .use_dirty_ring
= true,
1956 * Besides the precopy/unix basic test, cover dirty ring interface
1957 * rather than get-dirty-log.
1962 test_precopy_common(&args
);
1965 #ifdef CONFIG_GNUTLS
1966 static void test_precopy_unix_tls_psk(void)
1968 g_autofree
char *uri
= g_strdup_printf("unix:%s/migsocket", tmpfs
);
1969 MigrateCommon args
= {
1972 .start_hook
= test_migrate_tls_psk_start_match
,
1973 .finish_hook
= test_migrate_tls_psk_finish
,
1976 test_precopy_common(&args
);
1980 static void test_precopy_unix_tls_x509_default_host(void)
1982 g_autofree
char *uri
= g_strdup_printf("unix:%s/migsocket", tmpfs
);
1983 MigrateCommon args
= {
1985 .hide_stderr
= true,
1989 .start_hook
= test_migrate_tls_x509_start_default_host
,
1990 .finish_hook
= test_migrate_tls_x509_finish
,
1991 .result
= MIG_TEST_FAIL_DEST_QUIT_ERR
,
1994 test_precopy_common(&args
);
1997 static void test_precopy_unix_tls_x509_override_host(void)
1999 g_autofree
char *uri
= g_strdup_printf("unix:%s/migsocket", tmpfs
);
2000 MigrateCommon args
= {
2003 .start_hook
= test_migrate_tls_x509_start_override_host
,
2004 .finish_hook
= test_migrate_tls_x509_finish
,
2007 test_precopy_common(&args
);
2009 #endif /* CONFIG_TASN1 */
2010 #endif /* CONFIG_GNUTLS */
2013 /* Currently upset on aarch64 TCG */
2014 static void test_ignore_shared(void)
2016 g_autofree
char *uri
= g_strdup_printf("unix:%s/migsocket", tmpfs
);
2017 QTestState
*from
, *to
;
2019 if (test_migrate_start(&from
, &to
, uri
, false, true, NULL
, NULL
)) {
2023 migrate_ensure_non_converge(from
);
2024 migrate_prepare_for_dirty_mem(from
);
2026 migrate_set_capability(from
, "x-ignore-shared", true);
2027 migrate_set_capability(to
, "x-ignore-shared", true);
2029 /* Wait for the first serial output from the source */
2030 wait_for_serial("src_serial");
2032 migrate_qmp(from
, uri
, "{}");
2034 migrate_wait_for_dirty_mem(from
, to
);
2036 wait_for_stop(from
, &src_state
);
2038 qtest_qmp_eventwait(to
, "RESUME");
2040 wait_for_serial("dest_serial");
2041 wait_for_migration_complete(from
);
2043 /* Check whether shared RAM has been really skipped */
2044 g_assert_cmpint(read_ram_property_int(from
, "transferred"), <, 1024 * 1024);
2046 test_migrate_end(from
, to
, true);
2051 test_migrate_xbzrle_start(QTestState
*from
,
2054 migrate_set_parameter_int(from
, "xbzrle-cache-size", 33554432);
2056 migrate_set_capability(from
, "xbzrle", true);
2057 migrate_set_capability(to
, "xbzrle", true);
2062 static void test_precopy_unix_xbzrle(void)
2064 g_autofree
char *uri
= g_strdup_printf("unix:%s/migsocket", tmpfs
);
2065 MigrateCommon args
= {
2068 .start_hook
= test_migrate_xbzrle_start
,
2071 * XBZRLE needs pages to be modified when doing the 2nd+ round
2072 * iteration to have real data pushed to the stream.
2077 test_precopy_common(&args
);
2080 static void test_precopy_unix_compress(void)
2082 g_autofree
char *uri
= g_strdup_printf("unix:%s/migsocket", tmpfs
);
2083 MigrateCommon args
= {
2086 .start_hook
= test_migrate_compress_start
,
2088 * Test that no invalid thread state is left over from
2089 * the previous iteration.
2093 * We make sure the compressor can always work well even if guest
2094 * memory is changing. See commit 34ab9e9743 where we used to fix
2095 * a bug when only trigger-able with guest memory changing.
2100 test_precopy_common(&args
);
2103 static void test_precopy_unix_compress_nowait(void)
2105 g_autofree
char *uri
= g_strdup_printf("unix:%s/migsocket", tmpfs
);
2106 MigrateCommon args
= {
2109 .start_hook
= test_migrate_compress_nowait_start
,
2111 * Test that no invalid thread state is left over from
2112 * the previous iteration.
2115 /* Same reason for the wait version of precopy compress test */
2119 test_precopy_common(&args
);
2122 static void test_precopy_file(void)
2124 g_autofree
char *uri
= g_strdup_printf("file:%s/%s", tmpfs
,
2125 FILE_TEST_FILENAME
);
2126 MigrateCommon args
= {
2128 .listen_uri
= "defer",
2131 test_file_common(&args
, true);
2134 static void file_offset_finish_hook(QTestState
*from
, QTestState
*to
,
2137 #if defined(__linux__)
2138 g_autofree
char *path
= g_strdup_printf("%s/%s", tmpfs
, FILE_TEST_FILENAME
);
2139 size_t size
= FILE_TEST_OFFSET
+ sizeof(QEMU_VM_FILE_MAGIC
);
2140 uintptr_t *addr
, *p
;
2143 fd
= open(path
, O_RDONLY
);
2145 addr
= mmap(NULL
, size
, PROT_READ
, MAP_SHARED
, fd
, 0);
2146 g_assert(addr
!= MAP_FAILED
);
2149 * Ensure the skipped offset contains zeros and the migration
2150 * stream starts at the right place.
2153 while (p
< addr
+ FILE_TEST_OFFSET
/ sizeof(uintptr_t)) {
2157 g_assert_cmpint(cpu_to_be64(*p
) >> 32, ==, QEMU_VM_FILE_MAGIC
);
2164 static void test_precopy_file_offset(void)
2166 g_autofree
char *uri
= g_strdup_printf("file:%s/%s,offset=%d", tmpfs
,
2169 MigrateCommon args
= {
2171 .listen_uri
= "defer",
2172 .finish_hook
= file_offset_finish_hook
,
2175 test_file_common(&args
, false);
2178 static void test_precopy_file_offset_bad(void)
2180 /* using a value not supported by qemu_strtosz() */
2181 g_autofree
char *uri
= g_strdup_printf("file:%s/%s,offset=0x20M",
2182 tmpfs
, FILE_TEST_FILENAME
);
2183 MigrateCommon args
= {
2185 .listen_uri
= "defer",
2186 .result
= MIG_TEST_QMP_ERROR
,
2189 test_file_common(&args
, false);
2192 static void *test_mode_reboot_start(QTestState
*from
, QTestState
*to
)
2194 migrate_set_parameter_str(from
, "mode", "cpr-reboot");
2195 migrate_set_parameter_str(to
, "mode", "cpr-reboot");
2197 migrate_set_capability(from
, "x-ignore-shared", true);
2198 migrate_set_capability(to
, "x-ignore-shared", true);
2203 static void test_mode_reboot(void)
2205 g_autofree
char *uri
= g_strdup_printf("file:%s/%s", tmpfs
,
2206 FILE_TEST_FILENAME
);
2207 MigrateCommon args
= {
2208 .start
.use_shmem
= true,
2210 .listen_uri
= "defer",
2211 .start_hook
= test_mode_reboot_start
2214 test_file_common(&args
, true);
2217 static void test_precopy_tcp_plain(void)
2219 MigrateCommon args
= {
2220 .listen_uri
= "tcp:127.0.0.1:0",
2223 test_precopy_common(&args
);
2226 static void *test_migrate_switchover_ack_start(QTestState
*from
, QTestState
*to
)
2229 migrate_set_capability(from
, "return-path", true);
2230 migrate_set_capability(to
, "return-path", true);
2232 migrate_set_capability(from
, "switchover-ack", true);
2233 migrate_set_capability(to
, "switchover-ack", true);
2238 static void test_precopy_tcp_switchover_ack(void)
2240 MigrateCommon args
= {
2241 .listen_uri
= "tcp:127.0.0.1:0",
2242 .start_hook
= test_migrate_switchover_ack_start
,
2244 * Source VM must be running in order to consider the switchover ACK
2245 * when deciding to do switchover or not.
2250 test_precopy_common(&args
);
2253 #ifdef CONFIG_GNUTLS
2254 static void test_precopy_tcp_tls_psk_match(void)
2256 MigrateCommon args
= {
2257 .listen_uri
= "tcp:127.0.0.1:0",
2258 .start_hook
= test_migrate_tls_psk_start_match
,
2259 .finish_hook
= test_migrate_tls_psk_finish
,
2262 test_precopy_common(&args
);
2265 static void test_precopy_tcp_tls_psk_mismatch(void)
2267 MigrateCommon args
= {
2269 .hide_stderr
= true,
2271 .listen_uri
= "tcp:127.0.0.1:0",
2272 .start_hook
= test_migrate_tls_psk_start_mismatch
,
2273 .finish_hook
= test_migrate_tls_psk_finish
,
2274 .result
= MIG_TEST_FAIL
,
2277 test_precopy_common(&args
);
2281 static void test_precopy_tcp_tls_x509_default_host(void)
2283 MigrateCommon args
= {
2284 .listen_uri
= "tcp:127.0.0.1:0",
2285 .start_hook
= test_migrate_tls_x509_start_default_host
,
2286 .finish_hook
= test_migrate_tls_x509_finish
,
2289 test_precopy_common(&args
);
2292 static void test_precopy_tcp_tls_x509_override_host(void)
2294 MigrateCommon args
= {
2295 .listen_uri
= "tcp:127.0.0.1:0",
2296 .start_hook
= test_migrate_tls_x509_start_override_host
,
2297 .finish_hook
= test_migrate_tls_x509_finish
,
2300 test_precopy_common(&args
);
2303 static void test_precopy_tcp_tls_x509_mismatch_host(void)
2305 MigrateCommon args
= {
2307 .hide_stderr
= true,
2309 .listen_uri
= "tcp:127.0.0.1:0",
2310 .start_hook
= test_migrate_tls_x509_start_mismatch_host
,
2311 .finish_hook
= test_migrate_tls_x509_finish
,
2312 .result
= MIG_TEST_FAIL_DEST_QUIT_ERR
,
2315 test_precopy_common(&args
);
2318 static void test_precopy_tcp_tls_x509_friendly_client(void)
2320 MigrateCommon args
= {
2321 .listen_uri
= "tcp:127.0.0.1:0",
2322 .start_hook
= test_migrate_tls_x509_start_friendly_client
,
2323 .finish_hook
= test_migrate_tls_x509_finish
,
2326 test_precopy_common(&args
);
2329 static void test_precopy_tcp_tls_x509_hostile_client(void)
2331 MigrateCommon args
= {
2333 .hide_stderr
= true,
2335 .listen_uri
= "tcp:127.0.0.1:0",
2336 .start_hook
= test_migrate_tls_x509_start_hostile_client
,
2337 .finish_hook
= test_migrate_tls_x509_finish
,
2338 .result
= MIG_TEST_FAIL
,
2341 test_precopy_common(&args
);
2344 static void test_precopy_tcp_tls_x509_allow_anon_client(void)
2346 MigrateCommon args
= {
2347 .listen_uri
= "tcp:127.0.0.1:0",
2348 .start_hook
= test_migrate_tls_x509_start_allow_anon_client
,
2349 .finish_hook
= test_migrate_tls_x509_finish
,
2352 test_precopy_common(&args
);
2355 static void test_precopy_tcp_tls_x509_reject_anon_client(void)
2357 MigrateCommon args
= {
2359 .hide_stderr
= true,
2361 .listen_uri
= "tcp:127.0.0.1:0",
2362 .start_hook
= test_migrate_tls_x509_start_reject_anon_client
,
2363 .finish_hook
= test_migrate_tls_x509_finish
,
2364 .result
= MIG_TEST_FAIL
,
2367 test_precopy_common(&args
);
2369 #endif /* CONFIG_TASN1 */
2370 #endif /* CONFIG_GNUTLS */
2373 static void *test_migrate_fd_start_hook(QTestState
*from
,
2379 /* Create two connected sockets for migration */
2380 ret
= qemu_socketpair(PF_LOCAL
, SOCK_STREAM
, 0, pair
);
2381 g_assert_cmpint(ret
, ==, 0);
2383 /* Send the 1st socket to the target */
2384 qtest_qmp_fds_assert_success(to
, &pair
[0], 1,
2385 "{ 'execute': 'getfd',"
2386 " 'arguments': { 'fdname': 'fd-mig' }}");
2389 /* Start incoming migration from the 1st socket */
2390 migrate_incoming_qmp(to
, "fd:fd-mig", "{}");
2392 /* Send the 2nd socket to the target */
2393 qtest_qmp_fds_assert_success(from
, &pair
[1], 1,
2394 "{ 'execute': 'getfd',"
2395 " 'arguments': { 'fdname': 'fd-mig' }}");
2401 static void test_migrate_fd_finish_hook(QTestState
*from
,
2406 const char *error_desc
;
2408 /* Test closing fds */
2409 /* We assume, that QEMU removes named fd from its list,
2410 * so this should fail */
2411 rsp
= qtest_qmp(from
, "{ 'execute': 'closefd',"
2412 " 'arguments': { 'fdname': 'fd-mig' }}");
2413 g_assert_true(qdict_haskey(rsp
, "error"));
2414 error_desc
= qdict_get_str(qdict_get_qdict(rsp
, "error"), "desc");
2415 g_assert_cmpstr(error_desc
, ==, "File descriptor named 'fd-mig' not found");
2418 rsp
= qtest_qmp(to
, "{ 'execute': 'closefd',"
2419 " 'arguments': { 'fdname': 'fd-mig' }}");
2420 g_assert_true(qdict_haskey(rsp
, "error"));
2421 error_desc
= qdict_get_str(qdict_get_qdict(rsp
, "error"), "desc");
2422 g_assert_cmpstr(error_desc
, ==, "File descriptor named 'fd-mig' not found");
2426 static void test_migrate_fd_proto(void)
2428 MigrateCommon args
= {
2429 .listen_uri
= "defer",
2430 .connect_uri
= "fd:fd-mig",
2431 .start_hook
= test_migrate_fd_start_hook
,
2432 .finish_hook
= test_migrate_fd_finish_hook
2434 test_precopy_common(&args
);
2438 static void do_test_validate_uuid(MigrateStart
*args
, bool should_fail
)
2440 g_autofree
char *uri
= g_strdup_printf("unix:%s/migsocket", tmpfs
);
2441 QTestState
*from
, *to
;
2443 if (test_migrate_start(&from
, &to
, uri
, args
)) {
2448 * UUID validation is at the begin of migration. So, the main process of
2449 * migration is not interesting for us here. Thus, set huge downtime for
2450 * very fast migration.
2452 migrate_set_parameter_int(from
, "downtime-limit", 1000000);
2453 migrate_set_capability(from
, "validate-uuid", true);
2455 /* Wait for the first serial output from the source */
2456 wait_for_serial("src_serial");
2458 migrate_qmp(from
, uri
, "{}");
2461 qtest_set_expected_status(to
, EXIT_FAILURE
);
2462 wait_for_migration_fail(from
, true);
2464 wait_for_migration_complete(from
);
2467 test_migrate_end(from
, to
, false);
2470 static void test_validate_uuid(void)
2472 MigrateStart args
= {
2473 .opts_source
= "-uuid 11111111-1111-1111-1111-111111111111",
2474 .opts_target
= "-uuid 11111111-1111-1111-1111-111111111111",
2477 do_test_validate_uuid(&args
, false);
2480 static void test_validate_uuid_error(void)
2482 MigrateStart args
= {
2483 .opts_source
= "-uuid 11111111-1111-1111-1111-111111111111",
2484 .opts_target
= "-uuid 22222222-2222-2222-2222-222222222222",
2485 .hide_stderr
= true,
2488 do_test_validate_uuid(&args
, true);
2491 static void test_validate_uuid_src_not_set(void)
2493 MigrateStart args
= {
2494 .opts_target
= "-uuid 22222222-2222-2222-2222-222222222222",
2495 .hide_stderr
= true,
2498 do_test_validate_uuid(&args
, false);
2501 static void test_validate_uuid_dst_not_set(void)
2503 MigrateStart args
= {
2504 .opts_source
= "-uuid 11111111-1111-1111-1111-111111111111",
2505 .hide_stderr
= true,
2508 do_test_validate_uuid(&args
, false);
2512 * The way auto_converge works, we need to do too many passes to
2513 * run this test. Auto_converge logic is only run once every
2514 * three iterations, so:
2516 * - 3 iterations without auto_converge enabled
2517 * - 3 iterations with pct = 5
2518 * - 3 iterations with pct = 30
2519 * - 3 iterations with pct = 55
2520 * - 3 iterations with pct = 80
2521 * - 3 iterations with pct = 95 (max(95, 80 + 25))
2523 * To make things even worse, we need to run the initial stage at
2524 * 3MB/s so we enter autoconverge even when host is (over)loaded.
2526 static void test_migrate_auto_converge(void)
2528 g_autofree
char *uri
= g_strdup_printf("unix:%s/migsocket", tmpfs
);
2529 MigrateStart args
= {};
2530 QTestState
*from
, *to
;
2534 * We want the test to be stable and as fast as possible.
2535 * E.g., with 1Gb/s bandwidth migration may pass without throttling,
2536 * so we need to decrease a bandwidth.
2538 const int64_t init_pct
= 5, inc_pct
= 25, max_pct
= 95;
2540 if (test_migrate_start(&from
, &to
, uri
, &args
)) {
2544 migrate_set_capability(from
, "auto-converge", true);
2545 migrate_set_parameter_int(from
, "cpu-throttle-initial", init_pct
);
2546 migrate_set_parameter_int(from
, "cpu-throttle-increment", inc_pct
);
2547 migrate_set_parameter_int(from
, "max-cpu-throttle", max_pct
);
2550 * Set the initial parameters so that the migration could not converge
2551 * without throttling.
2553 migrate_ensure_non_converge(from
);
2555 /* To check remaining size after precopy */
2556 migrate_set_capability(from
, "pause-before-switchover", true);
2558 /* Wait for the first serial output from the source */
2559 wait_for_serial("src_serial");
2561 migrate_qmp(from
, uri
, "{}");
2563 /* Wait for throttling begins */
2566 percentage
= read_migrate_property_int(from
, "cpu-throttle-percentage");
2567 if (percentage
!= 0) {
2571 g_assert_false(src_state
.stop_seen
);
2573 /* The first percentage of throttling should be at least init_pct */
2574 g_assert_cmpint(percentage
, >=, init_pct
);
2575 /* Now, when we tested that throttling works, let it converge */
2576 migrate_ensure_converge(from
);
2579 * Wait for pre-switchover status to check last throttle percentage
2580 * and remaining. These values will be zeroed later
2582 wait_for_migration_status(from
, "pre-switchover", NULL
);
2584 /* The final percentage of throttling shouldn't be greater than max_pct */
2585 percentage
= read_migrate_property_int(from
, "cpu-throttle-percentage");
2586 g_assert_cmpint(percentage
, <=, max_pct
);
2587 migrate_continue(from
, "pre-switchover");
2589 qtest_qmp_eventwait(to
, "RESUME");
2591 wait_for_serial("dest_serial");
2592 wait_for_migration_complete(from
);
2594 test_migrate_end(from
, to
, true);
2598 test_migrate_precopy_tcp_multifd_start_common(QTestState
*from
,
2602 migrate_set_parameter_int(from
, "multifd-channels", 16);
2603 migrate_set_parameter_int(to
, "multifd-channels", 16);
2605 migrate_set_parameter_str(from
, "multifd-compression", method
);
2606 migrate_set_parameter_str(to
, "multifd-compression", method
);
2608 migrate_set_capability(from
, "multifd", true);
2609 migrate_set_capability(to
, "multifd", true);
2611 /* Start incoming migration from the 1st socket */
2612 migrate_incoming_qmp(to
, "tcp:127.0.0.1:0", "{}");
2618 test_migrate_precopy_tcp_multifd_start(QTestState
*from
,
2621 return test_migrate_precopy_tcp_multifd_start_common(from
, to
, "none");
2625 test_migrate_precopy_tcp_multifd_zlib_start(QTestState
*from
,
2628 return test_migrate_precopy_tcp_multifd_start_common(from
, to
, "zlib");
2633 test_migrate_precopy_tcp_multifd_zstd_start(QTestState
*from
,
2636 return test_migrate_precopy_tcp_multifd_start_common(from
, to
, "zstd");
2638 #endif /* CONFIG_ZSTD */
2640 static void test_multifd_tcp_none(void)
2642 MigrateCommon args
= {
2643 .listen_uri
= "defer",
2644 .start_hook
= test_migrate_precopy_tcp_multifd_start
,
2646 * Multifd is more complicated than most of the features, it
2647 * directly takes guest page buffers when sending, make sure
2648 * everything will work alright even if guest page is changing.
2652 test_precopy_common(&args
);
2655 static void test_multifd_tcp_zlib(void)
2657 MigrateCommon args
= {
2658 .listen_uri
= "defer",
2659 .start_hook
= test_migrate_precopy_tcp_multifd_zlib_start
,
2661 test_precopy_common(&args
);
2665 static void test_multifd_tcp_zstd(void)
2667 MigrateCommon args
= {
2668 .listen_uri
= "defer",
2669 .start_hook
= test_migrate_precopy_tcp_multifd_zstd_start
,
2671 test_precopy_common(&args
);
2675 #ifdef CONFIG_GNUTLS
2677 test_migrate_multifd_tcp_tls_psk_start_match(QTestState
*from
,
2680 test_migrate_precopy_tcp_multifd_start_common(from
, to
, "none");
2681 return test_migrate_tls_psk_start_match(from
, to
);
2685 test_migrate_multifd_tcp_tls_psk_start_mismatch(QTestState
*from
,
2688 test_migrate_precopy_tcp_multifd_start_common(from
, to
, "none");
2689 return test_migrate_tls_psk_start_mismatch(from
, to
);
2694 test_migrate_multifd_tls_x509_start_default_host(QTestState
*from
,
2697 test_migrate_precopy_tcp_multifd_start_common(from
, to
, "none");
2698 return test_migrate_tls_x509_start_default_host(from
, to
);
2702 test_migrate_multifd_tls_x509_start_override_host(QTestState
*from
,
2705 test_migrate_precopy_tcp_multifd_start_common(from
, to
, "none");
2706 return test_migrate_tls_x509_start_override_host(from
, to
);
2710 test_migrate_multifd_tls_x509_start_mismatch_host(QTestState
*from
,
2713 test_migrate_precopy_tcp_multifd_start_common(from
, to
, "none");
2714 return test_migrate_tls_x509_start_mismatch_host(from
, to
);
2718 test_migrate_multifd_tls_x509_start_allow_anon_client(QTestState
*from
,
2721 test_migrate_precopy_tcp_multifd_start_common(from
, to
, "none");
2722 return test_migrate_tls_x509_start_allow_anon_client(from
, to
);
2726 test_migrate_multifd_tls_x509_start_reject_anon_client(QTestState
*from
,
2729 test_migrate_precopy_tcp_multifd_start_common(from
, to
, "none");
2730 return test_migrate_tls_x509_start_reject_anon_client(from
, to
);
2732 #endif /* CONFIG_TASN1 */
2734 static void test_multifd_tcp_tls_psk_match(void)
2736 MigrateCommon args
= {
2737 .listen_uri
= "defer",
2738 .start_hook
= test_migrate_multifd_tcp_tls_psk_start_match
,
2739 .finish_hook
= test_migrate_tls_psk_finish
,
2741 test_precopy_common(&args
);
2744 static void test_multifd_tcp_tls_psk_mismatch(void)
2746 MigrateCommon args
= {
2748 .hide_stderr
= true,
2750 .listen_uri
= "defer",
2751 .start_hook
= test_migrate_multifd_tcp_tls_psk_start_mismatch
,
2752 .finish_hook
= test_migrate_tls_psk_finish
,
2753 .result
= MIG_TEST_FAIL
,
2755 test_precopy_common(&args
);
2759 static void test_multifd_tcp_tls_x509_default_host(void)
2761 MigrateCommon args
= {
2762 .listen_uri
= "defer",
2763 .start_hook
= test_migrate_multifd_tls_x509_start_default_host
,
2764 .finish_hook
= test_migrate_tls_x509_finish
,
2766 test_precopy_common(&args
);
2769 static void test_multifd_tcp_tls_x509_override_host(void)
2771 MigrateCommon args
= {
2772 .listen_uri
= "defer",
2773 .start_hook
= test_migrate_multifd_tls_x509_start_override_host
,
2774 .finish_hook
= test_migrate_tls_x509_finish
,
2776 test_precopy_common(&args
);
2779 static void test_multifd_tcp_tls_x509_mismatch_host(void)
2782 * This has different behaviour to the non-multifd case.
2784 * In non-multifd case when client aborts due to mismatched
2785 * cert host, the server has already started trying to load
2786 * migration state, and so it exits with I/O failure.
2788 * In multifd case when client aborts due to mismatched
2789 * cert host, the server is still waiting for the other
2790 * multifd connections to arrive so hasn't started trying
2791 * to load migration state, and thus just aborts the migration
2794 MigrateCommon args
= {
2796 .hide_stderr
= true,
2798 .listen_uri
= "defer",
2799 .start_hook
= test_migrate_multifd_tls_x509_start_mismatch_host
,
2800 .finish_hook
= test_migrate_tls_x509_finish
,
2801 .result
= MIG_TEST_FAIL
,
2803 test_precopy_common(&args
);
2806 static void test_multifd_tcp_tls_x509_allow_anon_client(void)
2808 MigrateCommon args
= {
2809 .listen_uri
= "defer",
2810 .start_hook
= test_migrate_multifd_tls_x509_start_allow_anon_client
,
2811 .finish_hook
= test_migrate_tls_x509_finish
,
2813 test_precopy_common(&args
);
2816 static void test_multifd_tcp_tls_x509_reject_anon_client(void)
2818 MigrateCommon args
= {
2820 .hide_stderr
= true,
2822 .listen_uri
= "defer",
2823 .start_hook
= test_migrate_multifd_tls_x509_start_reject_anon_client
,
2824 .finish_hook
= test_migrate_tls_x509_finish
,
2825 .result
= MIG_TEST_FAIL
,
2827 test_precopy_common(&args
);
2829 #endif /* CONFIG_TASN1 */
2830 #endif /* CONFIG_GNUTLS */
2838 * launch another target
2841 * And see that it works
2843 static void test_multifd_tcp_cancel(void)
2845 MigrateStart args
= {
2846 .hide_stderr
= true,
2848 QTestState
*from
, *to
, *to2
;
2849 g_autofree
char *uri
= NULL
;
2851 if (test_migrate_start(&from
, &to
, "defer", &args
)) {
2855 migrate_ensure_non_converge(from
);
2856 migrate_prepare_for_dirty_mem(from
);
2858 migrate_set_parameter_int(from
, "multifd-channels", 16);
2859 migrate_set_parameter_int(to
, "multifd-channels", 16);
2861 migrate_set_capability(from
, "multifd", true);
2862 migrate_set_capability(to
, "multifd", true);
2864 /* Start incoming migration from the 1st socket */
2865 migrate_incoming_qmp(to
, "tcp:127.0.0.1:0", "{}");
2867 /* Wait for the first serial output from the source */
2868 wait_for_serial("src_serial");
2870 uri
= migrate_get_socket_address(to
, "socket-address");
2872 migrate_qmp(from
, uri
, "{}");
2874 migrate_wait_for_dirty_mem(from
, to
);
2876 migrate_cancel(from
);
2878 /* Make sure QEMU process "to" exited */
2879 qtest_set_expected_status(to
, EXIT_FAILURE
);
2880 qtest_wait_qemu(to
);
2882 args
= (MigrateStart
){
2883 .only_target
= true,
2886 if (test_migrate_start(&from
, &to2
, "defer", &args
)) {
2890 migrate_set_parameter_int(to2
, "multifd-channels", 16);
2892 migrate_set_capability(to2
, "multifd", true);
2894 /* Start incoming migration from the 1st socket */
2895 migrate_incoming_qmp(to2
, "tcp:127.0.0.1:0", "{}");
2898 uri
= migrate_get_socket_address(to2
, "socket-address");
2900 wait_for_migration_status(from
, "cancelled", NULL
);
2902 migrate_ensure_non_converge(from
);
2904 migrate_qmp(from
, uri
, "{}");
2906 migrate_wait_for_dirty_mem(from
, to2
);
2908 migrate_ensure_converge(from
);
2910 wait_for_stop(from
, &src_state
);
2911 qtest_qmp_eventwait(to2
, "RESUME");
2913 wait_for_serial("dest_serial");
2914 wait_for_migration_complete(from
);
2915 test_migrate_end(from
, to2
, true);
2918 static void calc_dirty_rate(QTestState
*who
, uint64_t calc_time
)
2920 qtest_qmp_assert_success(who
,
2921 "{ 'execute': 'calc-dirty-rate',"
2923 "'calc-time': %" PRIu64
","
2924 "'mode': 'dirty-ring' }}",
2928 static QDict
*query_dirty_rate(QTestState
*who
)
2930 return qtest_qmp_assert_success_ref(who
,
2931 "{ 'execute': 'query-dirty-rate' }");
2934 static void dirtylimit_set_all(QTestState
*who
, uint64_t dirtyrate
)
2936 qtest_qmp_assert_success(who
,
2937 "{ 'execute': 'set-vcpu-dirty-limit',"
2939 "'dirty-rate': %" PRIu64
" } }",
2943 static void cancel_vcpu_dirty_limit(QTestState
*who
)
2945 qtest_qmp_assert_success(who
,
2946 "{ 'execute': 'cancel-vcpu-dirty-limit' }");
2949 static QDict
*query_vcpu_dirty_limit(QTestState
*who
)
2953 rsp
= qtest_qmp(who
, "{ 'execute': 'query-vcpu-dirty-limit' }");
2954 g_assert(!qdict_haskey(rsp
, "error"));
2955 g_assert(qdict_haskey(rsp
, "return"));
2960 static bool calc_dirtyrate_ready(QTestState
*who
)
2965 rsp_return
= query_dirty_rate(who
);
2966 g_assert(rsp_return
);
2968 status
= g_strdup(qdict_get_str(rsp_return
, "status"));
2971 return g_strcmp0(status
, "measuring");
2974 static void wait_for_calc_dirtyrate_complete(QTestState
*who
,
2977 int max_try_count
= 10000;
2978 usleep(time_s
* 1000000);
2980 while (!calc_dirtyrate_ready(who
) && max_try_count
--) {
2985 * Set the timeout with 10 s(max_try_count * 1000us),
2986 * if dirtyrate measurement not complete, fail test.
2988 g_assert_cmpint(max_try_count
, !=, 0);
2991 static int64_t get_dirty_rate(QTestState
*who
)
2996 const QListEntry
*entry
;
3000 rsp_return
= query_dirty_rate(who
);
3001 g_assert(rsp_return
);
3003 status
= g_strdup(qdict_get_str(rsp_return
, "status"));
3005 g_assert_cmpstr(status
, ==, "measured");
3007 rates
= qdict_get_qlist(rsp_return
, "vcpu-dirty-rate");
3008 g_assert(rates
&& !qlist_empty(rates
));
3010 entry
= qlist_first(rates
);
3013 rate
= qobject_to(QDict
, qlist_entry_obj(entry
));
3016 dirtyrate
= qdict_get_try_int(rate
, "dirty-rate", -1);
3018 qobject_unref(rsp_return
);
3022 static int64_t get_limit_rate(QTestState
*who
)
3026 const QListEntry
*entry
;
3030 rsp_return
= query_vcpu_dirty_limit(who
);
3031 g_assert(rsp_return
);
3033 rates
= qdict_get_qlist(rsp_return
, "return");
3034 g_assert(rates
&& !qlist_empty(rates
));
3036 entry
= qlist_first(rates
);
3039 rate
= qobject_to(QDict
, qlist_entry_obj(entry
));
3042 dirtyrate
= qdict_get_try_int(rate
, "limit-rate", -1);
3044 qobject_unref(rsp_return
);
3048 static QTestState
*dirtylimit_start_vm(void)
3050 QTestState
*vm
= NULL
;
3051 g_autofree gchar
*cmd
= NULL
;
3053 bootfile_create(tmpfs
, false);
3054 cmd
= g_strdup_printf("-accel kvm,dirty-ring-size=4096 "
3055 "-name dirtylimit-test,debug-threads=on "
3057 "-serial file:%s/vm_serial "
3058 "-drive file=%s,format=raw ",
3061 vm
= qtest_init(cmd
);
3065 static void dirtylimit_stop_vm(QTestState
*vm
)
3068 cleanup("vm_serial");
3071 static void test_vcpu_dirty_limit(void)
3074 int64_t origin_rate
;
3077 int max_try_count
= 20;
3080 /* Start vm for vcpu dirtylimit test */
3081 vm
= dirtylimit_start_vm();
3083 /* Wait for the first serial output from the vm*/
3084 wait_for_serial("vm_serial");
3086 /* Do dirtyrate measurement with calc time equals 1s */
3087 calc_dirty_rate(vm
, 1);
3089 /* Sleep calc time and wait for calc dirtyrate complete */
3090 wait_for_calc_dirtyrate_complete(vm
, 1);
3092 /* Query original dirty page rate */
3093 origin_rate
= get_dirty_rate(vm
);
3095 /* VM booted from bootsect should dirty memory steadily */
3096 assert(origin_rate
!= 0);
3098 /* Setup quota dirty page rate at half of origin */
3099 quota_rate
= origin_rate
/ 2;
3101 /* Set dirtylimit */
3102 dirtylimit_set_all(vm
, quota_rate
);
3105 * Check if set-vcpu-dirty-limit and query-vcpu-dirty-limit
3108 g_assert_cmpint(quota_rate
, ==, get_limit_rate(vm
));
3110 /* Sleep a bit to check if it take effect */
3114 * Check if dirtylimit take effect realistically, set the
3115 * timeout with 20 s(max_try_count * 1s), if dirtylimit
3116 * doesn't take effect, fail test.
3118 while (--max_try_count
) {
3119 calc_dirty_rate(vm
, 1);
3120 wait_for_calc_dirtyrate_complete(vm
, 1);
3121 rate
= get_dirty_rate(vm
);
3124 * Assume hitting if current rate is less
3125 * than quota rate (within accepting error)
3127 if (rate
< (quota_rate
+ DIRTYLIMIT_TOLERANCE_RANGE
)) {
3133 g_assert_cmpint(hit
, ==, 1);
3138 /* Check if dirtylimit cancellation take effect */
3139 cancel_vcpu_dirty_limit(vm
);
3140 while (--max_try_count
) {
3141 calc_dirty_rate(vm
, 1);
3142 wait_for_calc_dirtyrate_complete(vm
, 1);
3143 rate
= get_dirty_rate(vm
);
3146 * Assume dirtylimit be canceled if current rate is
3147 * greater than quota rate (within accepting error)
3149 if (rate
> (quota_rate
+ DIRTYLIMIT_TOLERANCE_RANGE
)) {
3155 g_assert_cmpint(hit
, ==, 1);
3156 dirtylimit_stop_vm(vm
);
3159 static void migrate_dirty_limit_wait_showup(QTestState
*from
,
3160 const int64_t period
,
3161 const int64_t value
)
3163 /* Enable dirty limit capability */
3164 migrate_set_capability(from
, "dirty-limit", true);
3166 /* Set dirty limit parameters */
3167 migrate_set_parameter_int(from
, "x-vcpu-dirty-limit-period", period
);
3168 migrate_set_parameter_int(from
, "vcpu-dirty-limit", value
);
3170 /* Make sure migrate can't converge */
3171 migrate_ensure_non_converge(from
);
3173 /* To check limit rate after precopy */
3174 migrate_set_capability(from
, "pause-before-switchover", true);
3176 /* Wait for the serial output from the source */
3177 wait_for_serial("src_serial");
3182 * source destination
3186 * wait dirty limit to begin
3188 * cancellation check
3189 * restart incoming vm
3191 * wait dirty limit to begin
3192 * wait pre-switchover event
3193 * convergence condition check
3195 * And see if dirty limit migration works correctly.
3196 * This test case involves many passes, so it runs in slow mode only.
3198 static void test_migrate_dirty_limit(void)
3200 g_autofree
char *uri
= g_strdup_printf("unix:%s/migsocket", tmpfs
);
3201 QTestState
*from
, *to
;
3203 uint64_t throttle_us_per_full
;
3205 * We want the test to be stable and as fast as possible.
3206 * E.g., with 1Gb/s bandwidth migration may pass without dirty limit,
3207 * so we need to decrease a bandwidth.
3209 const int64_t dirtylimit_period
= 1000, dirtylimit_value
= 50;
3210 const int64_t max_bandwidth
= 400000000; /* ~400Mb/s */
3211 const int64_t downtime_limit
= 250; /* 250ms */
3213 * We migrate through unix-socket (> 500Mb/s).
3214 * Thus, expected migration speed ~= bandwidth limit (< 500Mb/s).
3215 * So, we can predict expected_threshold
3217 const int64_t expected_threshold
= max_bandwidth
* downtime_limit
/ 1000;
3218 int max_try_count
= 10;
3219 MigrateCommon args
= {
3221 .hide_stderr
= true,
3222 .use_dirty_ring
= true,
3228 /* Start src, dst vm */
3229 if (test_migrate_start(&from
, &to
, args
.listen_uri
, &args
.start
)) {
3233 /* Prepare for dirty limit migration and wait src vm show up */
3234 migrate_dirty_limit_wait_showup(from
, dirtylimit_period
, dirtylimit_value
);
3237 migrate_qmp(from
, uri
, "{}");
3239 /* Wait for dirty limit throttle begin */
3240 throttle_us_per_full
= 0;
3241 while (throttle_us_per_full
== 0) {
3242 throttle_us_per_full
=
3243 read_migrate_property_int(from
, "dirty-limit-throttle-time-per-round");
3245 g_assert_false(src_state
.stop_seen
);
3248 /* Now cancel migrate and wait for dirty limit throttle switch off */
3249 migrate_cancel(from
);
3250 wait_for_migration_status(from
, "cancelled", NULL
);
3252 /* Check if dirty limit throttle switched off, set timeout 1ms */
3254 throttle_us_per_full
=
3255 read_migrate_property_int(from
, "dirty-limit-throttle-time-per-round");
3257 g_assert_false(src_state
.stop_seen
);
3258 } while (throttle_us_per_full
!= 0 && --max_try_count
);
3260 /* Assert dirty limit is not in service */
3261 g_assert_cmpint(throttle_us_per_full
, ==, 0);
3263 args
= (MigrateCommon
) {
3265 .only_target
= true,
3266 .use_dirty_ring
= true,
3272 /* Restart dst vm, src vm already show up so we needn't wait anymore */
3273 if (test_migrate_start(&from
, &to
, args
.listen_uri
, &args
.start
)) {
3278 migrate_qmp(from
, uri
, "{}");
3280 /* Wait for dirty limit throttle begin */
3281 throttle_us_per_full
= 0;
3282 while (throttle_us_per_full
== 0) {
3283 throttle_us_per_full
=
3284 read_migrate_property_int(from
, "dirty-limit-throttle-time-per-round");
3286 g_assert_false(src_state
.stop_seen
);
3290 * The dirty limit rate should equals the return value of
3291 * query-vcpu-dirty-limit if dirty limit cap set
3293 g_assert_cmpint(dirtylimit_value
, ==, get_limit_rate(from
));
3295 /* Now, we have tested if dirty limit works, let it converge */
3296 migrate_set_parameter_int(from
, "downtime-limit", downtime_limit
);
3297 migrate_set_parameter_int(from
, "max-bandwidth", max_bandwidth
);
3300 * Wait for pre-switchover status to check if migration
3301 * satisfy the convergence condition
3303 wait_for_migration_status(from
, "pre-switchover", NULL
);
3305 remaining
= read_ram_property_int(from
, "remaining");
3306 g_assert_cmpint(remaining
, <,
3307 (expected_threshold
+ expected_threshold
/ 100));
3309 migrate_continue(from
, "pre-switchover");
3311 qtest_qmp_eventwait(to
, "RESUME");
3313 wait_for_serial("dest_serial");
3314 wait_for_migration_complete(from
);
3316 test_migrate_end(from
, to
, true);
3319 static bool kvm_dirty_ring_supported(void)
3321 #if defined(__linux__) && defined(HOST_X86_64)
3322 int ret
, kvm_fd
= open("/dev/kvm", O_RDONLY
);
3328 ret
= ioctl(kvm_fd
, KVM_CHECK_EXTENSION
, KVM_CAP_DIRTY_LOG_RING
);
3331 /* We test with 4096 slots */
3342 int main(int argc
, char **argv
)
3344 bool has_kvm
, has_tcg
;
3345 bool has_uffd
, is_x86
;
3347 g_autoptr(GError
) err
= NULL
;
3348 const char *qemu_src
= getenv(QEMU_ENV_SRC
);
3349 const char *qemu_dst
= getenv(QEMU_ENV_DST
);
3352 g_test_init(&argc
, &argv
, NULL
);
3355 * The default QTEST_QEMU_BINARY must always be provided because
3356 * that is what helpers use to query the accel type and
3359 if (qemu_src
&& qemu_dst
) {
3360 g_test_message("Only one of %s, %s is allowed",
3361 QEMU_ENV_SRC
, QEMU_ENV_DST
);
3365 has_kvm
= qtest_has_accel("kvm");
3366 has_tcg
= qtest_has_accel("tcg");
3368 if (!has_tcg
&& !has_kvm
) {
3369 g_test_skip("No KVM or TCG accelerator available");
3373 has_uffd
= ufd_version_check();
3374 arch
= qtest_get_arch();
3375 is_x86
= !strcmp(arch
, "i386") || !strcmp(arch
, "x86_64");
3378 * On ppc64, the test only works with kvm-hv, but not with kvm-pr and TCG
3379 * is touchy due to race conditions on dirty bits (especially on PPC for
3382 if (g_str_equal(arch
, "ppc64") &&
3383 (!has_kvm
|| access("/sys/module/kvm_hv", F_OK
))) {
3384 g_test_message("Skipping test: kvm_hv not available");
3385 return g_test_run();
3389 * Similar to ppc64, s390x seems to be touchy with TCG, so disable it
3390 * there until the problems are resolved
3392 if (g_str_equal(arch
, "s390x") && !has_kvm
) {
3393 g_test_message("Skipping test: s390x host with KVM is required");
3394 return g_test_run();
3397 tmpfs
= g_dir_make_tmp("migration-test-XXXXXX", &err
);
3399 g_test_message("Can't create temporary directory in %s: %s",
3400 g_get_tmp_dir(), err
->message
);
3404 module_call_init(MODULE_INIT_QOM
);
3407 migration_test_add("/migration/precopy/unix/suspend/live",
3408 test_precopy_unix_suspend_live
);
3409 migration_test_add("/migration/precopy/unix/suspend/notlive",
3410 test_precopy_unix_suspend_notlive
);
3414 migration_test_add("/migration/postcopy/plain", test_postcopy
);
3415 migration_test_add("/migration/postcopy/recovery/plain",
3416 test_postcopy_recovery
);
3417 migration_test_add("/migration/postcopy/preempt/plain",
3418 test_postcopy_preempt
);
3419 migration_test_add("/migration/postcopy/preempt/recovery/plain",
3420 test_postcopy_preempt_recovery
);
3421 if (getenv("QEMU_TEST_FLAKY_TESTS")) {
3422 migration_test_add("/migration/postcopy/compress/plain",
3423 test_postcopy_compress
);
3424 migration_test_add("/migration/postcopy/recovery/compress/plain",
3425 test_postcopy_recovery_compress
);
3428 migration_test_add("/migration/postcopy/recovery/double-failures",
3429 test_postcopy_recovery_double_fail
);
3432 migration_test_add("/migration/postcopy/suspend",
3433 test_postcopy_suspend
);
3437 migration_test_add("/migration/bad_dest", test_baddest
);
3439 if (!g_str_equal(arch
, "s390x")) {
3440 migration_test_add("/migration/analyze-script", test_analyze_script
);
3443 migration_test_add("/migration/precopy/unix/plain",
3444 test_precopy_unix_plain
);
3445 migration_test_add("/migration/precopy/unix/xbzrle",
3446 test_precopy_unix_xbzrle
);
3448 * Compression fails from time to time.
3449 * Put test here but don't enable it until everything is fixed.
3451 if (getenv("QEMU_TEST_FLAKY_TESTS")) {
3452 migration_test_add("/migration/precopy/unix/compress/wait",
3453 test_precopy_unix_compress
);
3454 migration_test_add("/migration/precopy/unix/compress/nowait",
3455 test_precopy_unix_compress_nowait
);
3458 migration_test_add("/migration/precopy/file",
3460 migration_test_add("/migration/precopy/file/offset",
3461 test_precopy_file_offset
);
3462 migration_test_add("/migration/precopy/file/offset/bad",
3463 test_precopy_file_offset_bad
);
3466 * Our CI system has problems with shared memory.
3467 * Don't run this test until we find a workaround.
3469 if (getenv("QEMU_TEST_FLAKY_TESTS")) {
3470 migration_test_add("/migration/mode/reboot", test_mode_reboot
);
3473 #ifdef CONFIG_GNUTLS
3474 migration_test_add("/migration/precopy/unix/tls/psk",
3475 test_precopy_unix_tls_psk
);
3479 * NOTE: psk test is enough for postcopy, as other types of TLS
3480 * channels are tested under precopy. Here what we want to test is the
3481 * general postcopy path that has TLS channel enabled.
3483 migration_test_add("/migration/postcopy/tls/psk",
3484 test_postcopy_tls_psk
);
3485 migration_test_add("/migration/postcopy/recovery/tls/psk",
3486 test_postcopy_recovery_tls_psk
);
3487 migration_test_add("/migration/postcopy/preempt/tls/psk",
3488 test_postcopy_preempt_tls_psk
);
3489 migration_test_add("/migration/postcopy/preempt/recovery/tls/psk",
3490 test_postcopy_preempt_all
);
3493 migration_test_add("/migration/precopy/unix/tls/x509/default-host",
3494 test_precopy_unix_tls_x509_default_host
);
3495 migration_test_add("/migration/precopy/unix/tls/x509/override-host",
3496 test_precopy_unix_tls_x509_override_host
);
3497 #endif /* CONFIG_TASN1 */
3498 #endif /* CONFIG_GNUTLS */
3500 migration_test_add("/migration/precopy/tcp/plain", test_precopy_tcp_plain
);
3502 migration_test_add("/migration/precopy/tcp/plain/switchover-ack",
3503 test_precopy_tcp_switchover_ack
);
3505 #ifdef CONFIG_GNUTLS
3506 migration_test_add("/migration/precopy/tcp/tls/psk/match",
3507 test_precopy_tcp_tls_psk_match
);
3508 migration_test_add("/migration/precopy/tcp/tls/psk/mismatch",
3509 test_precopy_tcp_tls_psk_mismatch
);
3511 migration_test_add("/migration/precopy/tcp/tls/x509/default-host",
3512 test_precopy_tcp_tls_x509_default_host
);
3513 migration_test_add("/migration/precopy/tcp/tls/x509/override-host",
3514 test_precopy_tcp_tls_x509_override_host
);
3515 migration_test_add("/migration/precopy/tcp/tls/x509/mismatch-host",
3516 test_precopy_tcp_tls_x509_mismatch_host
);
3517 migration_test_add("/migration/precopy/tcp/tls/x509/friendly-client",
3518 test_precopy_tcp_tls_x509_friendly_client
);
3519 migration_test_add("/migration/precopy/tcp/tls/x509/hostile-client",
3520 test_precopy_tcp_tls_x509_hostile_client
);
3521 migration_test_add("/migration/precopy/tcp/tls/x509/allow-anon-client",
3522 test_precopy_tcp_tls_x509_allow_anon_client
);
3523 migration_test_add("/migration/precopy/tcp/tls/x509/reject-anon-client",
3524 test_precopy_tcp_tls_x509_reject_anon_client
);
3525 #endif /* CONFIG_TASN1 */
3526 #endif /* CONFIG_GNUTLS */
3528 /* migration_test_add("/migration/ignore_shared", test_ignore_shared); */
3530 migration_test_add("/migration/fd_proto", test_migrate_fd_proto
);
3532 migration_test_add("/migration/validate_uuid", test_validate_uuid
);
3533 migration_test_add("/migration/validate_uuid_error",
3534 test_validate_uuid_error
);
3535 migration_test_add("/migration/validate_uuid_src_not_set",
3536 test_validate_uuid_src_not_set
);
3537 migration_test_add("/migration/validate_uuid_dst_not_set",
3538 test_validate_uuid_dst_not_set
);
3540 * See explanation why this test is slow on function definition
3542 if (g_test_slow()) {
3543 migration_test_add("/migration/auto_converge",
3544 test_migrate_auto_converge
);
3545 if (g_str_equal(arch
, "x86_64") &&
3546 has_kvm
&& kvm_dirty_ring_supported()) {
3547 migration_test_add("/migration/dirty_limit",
3548 test_migrate_dirty_limit
);
3551 migration_test_add("/migration/multifd/tcp/plain/none",
3552 test_multifd_tcp_none
);
3553 migration_test_add("/migration/multifd/tcp/plain/cancel",
3554 test_multifd_tcp_cancel
);
3555 migration_test_add("/migration/multifd/tcp/plain/zlib",
3556 test_multifd_tcp_zlib
);
3558 migration_test_add("/migration/multifd/tcp/plain/zstd",
3559 test_multifd_tcp_zstd
);
3561 #ifdef CONFIG_GNUTLS
3562 migration_test_add("/migration/multifd/tcp/tls/psk/match",
3563 test_multifd_tcp_tls_psk_match
);
3564 migration_test_add("/migration/multifd/tcp/tls/psk/mismatch",
3565 test_multifd_tcp_tls_psk_mismatch
);
3567 migration_test_add("/migration/multifd/tcp/tls/x509/default-host",
3568 test_multifd_tcp_tls_x509_default_host
);
3569 migration_test_add("/migration/multifd/tcp/tls/x509/override-host",
3570 test_multifd_tcp_tls_x509_override_host
);
3571 migration_test_add("/migration/multifd/tcp/tls/x509/mismatch-host",
3572 test_multifd_tcp_tls_x509_mismatch_host
);
3573 migration_test_add("/migration/multifd/tcp/tls/x509/allow-anon-client",
3574 test_multifd_tcp_tls_x509_allow_anon_client
);
3575 migration_test_add("/migration/multifd/tcp/tls/x509/reject-anon-client",
3576 test_multifd_tcp_tls_x509_reject_anon_client
);
3577 #endif /* CONFIG_TASN1 */
3578 #endif /* CONFIG_GNUTLS */
3580 if (g_str_equal(arch
, "x86_64") && has_kvm
&& kvm_dirty_ring_supported()) {
3581 migration_test_add("/migration/dirty_ring",
3582 test_precopy_unix_dirty_ring
);
3583 migration_test_add("/migration/vcpu_dirty_limit",
3584 test_vcpu_dirty_limit
);
3589 g_assert_cmpint(ret
, ==, 0);
3594 g_test_message("unable to rmdir: path (%s): %s",
3595 tmpfs
, strerror(errno
));