tests/migration-test.c

   1 /*
   2  * QTest testcase for migration
   3  *
   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.
   7  *
   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.
  10  *
  11  */
  12
  13 #include "qemu/osdep.h"
  14
  15 #include "libqtest.h"
  16 #include "qapi/qmp/qdict.h"
  17 #include "qapi/qmp/qjson.h"
  18 #include "qemu/option.h"
  19 #include "qemu/range.h"
  20 #include "qemu/sockets.h"
  21 #include "chardev/char.h"
  22 #include "sysemu/sysemu.h"
  23
  24 #include "migration/migration-test.h"
  25
  26 /* TODO actually test the results and get rid of this */
  27 #define qtest_qmp_discard_response(...) qobject_unref(qtest_qmp(__VA_ARGS__))
  28
  29 unsigned start_address;
  30 unsigned end_address;
  31 bool got_stop;
  32 static bool uffd_feature_thread_id;
  33
  34 #if defined(__linux__)
  35 #include <sys/syscall.h>
  36 #include <sys/vfs.h>
  37 #endif
  38
  39 #if defined(__linux__) && defined(__NR_userfaultfd) && defined(CONFIG_EVENTFD)
  40 #include <sys/eventfd.h>
  41 #include <sys/ioctl.h>
  42 #include <linux/userfaultfd.h>
  43
  44 static bool ufd_version_check(void)
  45 {
  46     struct uffdio_api api_struct;
  47     uint64_t ioctl_mask;
  48
  49     int ufd = syscall(__NR_userfaultfd, O_CLOEXEC);
  50
  51     if (ufd == -1) {
  52         g_test_message("Skipping test: userfaultfd not available");
  53         return false;
  54     }
  55
  56     api_struct.api = UFFD_API;
  57     api_struct.features = 0;
  58     if (ioctl(ufd, UFFDIO_API, &api_struct)) {
  59         g_test_message("Skipping test: UFFDIO_API failed");
  60         return false;
  61     }
  62     uffd_feature_thread_id = api_struct.features & UFFD_FEATURE_THREAD_ID;
  63
  64     ioctl_mask = (__u64)1 << _UFFDIO_REGISTER |
  65                  (__u64)1 << _UFFDIO_UNREGISTER;
  66     if ((api_struct.ioctls & ioctl_mask) != ioctl_mask) {
  67         g_test_message("Skipping test: Missing userfault feature");
  68         return false;
  69     }
  70
  71     return true;
  72 }
  73
  74 #else
  75 static bool ufd_version_check(void)
  76 {
  77     g_test_message("Skipping test: Userfault not available (builtdtime)");
  78     return false;
  79 }
  80
  81 #endif
  82
  83 static const char *tmpfs;
  84
  85 /* The boot file modifies memory area in [start_address, end_address)
  86  * repeatedly. It outputs a 'B' at a fixed rate while it's still running.
  87  */
  88 #include "tests/migration/i386/a-b-bootblock.h"
  89 #include "tests/migration/aarch64/a-b-kernel.h"
  90
  91 static void init_bootfile(const char *bootpath, void *content)
  92 {
  93     FILE *bootfile = fopen(bootpath, "wb");
  94
  95     g_assert_cmpint(fwrite(content, 512, 1, bootfile), ==, 1);
  96     fclose(bootfile);
  97 }
  98
  99 #include "tests/migration/s390x/a-b-bios.h"
 100
 101 static void init_bootfile_s390x(const char *bootpath)
 102 {
 103     FILE *bootfile = fopen(bootpath, "wb");
 104     size_t len = sizeof(s390x_elf);
 105
 106     g_assert_cmpint(fwrite(s390x_elf, len, 1, bootfile), ==, 1);
 107     fclose(bootfile);
 108 }
 109
 110 /*
 111  * Wait for some output in the serial output file,
 112  * we get an 'A' followed by an endless string of 'B's
 113  * but on the destination we won't have the A.
 114  */
 115 static void wait_for_serial(const char *side)
 116 {
 117     char *serialpath = g_strdup_printf("%s/%s", tmpfs, side);
 118     FILE *serialfile = fopen(serialpath, "r");
 119     const char *arch = qtest_get_arch();
 120     int started = (strcmp(side, "src_serial") == 0 &&
 121                    strcmp(arch, "ppc64") == 0) ? 0 : 1;
 122
 123     g_free(serialpath);
 124     do {
 125         int readvalue = fgetc(serialfile);
 126
 127         if (!started) {
 128             /* SLOF prints its banner before starting test,
 129              * to ignore it, mark the start of the test with '_',
 130              * ignore all characters until this marker
 131              */
 132             switch (readvalue) {
 133             case '_':
 134                 started = 1;
 135                 break;
 136             case EOF:
 137                 fseek(serialfile, 0, SEEK_SET);
 138                 usleep(1000);
 139                 break;
 140             }
 141             continue;
 142         }
 143         switch (readvalue) {
 144         case 'A':
 145             /* Fine */
 146             break;
 147
 148         case 'B':
 149             /* It's alive! */
 150             fclose(serialfile);
 151             return;
 152
 153         case EOF:
 154             started = (strcmp(side, "src_serial") == 0 &&
 155                        strcmp(arch, "ppc64") == 0) ? 0 : 1;
 156             fseek(serialfile, 0, SEEK_SET);
 157             usleep(1000);
 158             break;
 159
 160         default:
 161             fprintf(stderr, "Unexpected %d on %s serial\n", readvalue, side);
 162             g_assert_not_reached();
 163         }
 164     } while (true);
 165 }
 166
 167 static void stop_cb(void *opaque, const char *name, QDict *data)
 168 {
 169     if (!strcmp(name, "STOP")) {
 170         got_stop = true;
 171     }
 172 }
 173
 174 /*
 175  * Events can get in the way of responses we are actually waiting for.
 176  */
 177 GCC_FMT_ATTR(2, 3)
 178 static QDict *wait_command(QTestState *who, const char *command, ...)
 179 {
 180     va_list ap;
 181
 182     va_start(ap, command);
 183     qtest_qmp_vsend(who, command, ap);
 184     va_end(ap);
 185
 186     return qtest_qmp_receive_success(who, stop_cb, NULL);
 187 }
 188
 189 /*
 190  * Note: caller is responsible to free the returned object via
 191  * qobject_unref() after use
 192  */
 193 static QDict *migrate_query(QTestState *who)
 194 {
 195     return wait_command(who, "{ 'execute': 'query-migrate' }");
 196 }
 197
 198 /*
 199  * Note: caller is responsible to free the returned object via
 200  * g_free() after use
 201  */
 202 static gchar *migrate_query_status(QTestState *who)
 203 {
 204     QDict *rsp_return = migrate_query(who);
 205     gchar *status = g_strdup(qdict_get_str(rsp_return, "status"));
 206
 207     g_assert(status);
 208     qobject_unref(rsp_return);
 209
 210     return status;
 211 }
 212
 213 /*
 214  * It's tricky to use qemu's migration event capability with qtest,
 215  * events suddenly appearing confuse the qmp()/hmp() responses.
 216  */
 217
 218 static uint64_t get_migration_pass(QTestState *who)
 219 {
 220     QDict *rsp_return, *rsp_ram;
 221     uint64_t result;
 222
 223     rsp_return = migrate_query(who);
 224     if (!qdict_haskey(rsp_return, "ram")) {
 225         /* Still in setup */
 226         result = 0;
 227     } else {
 228         rsp_ram = qdict_get_qdict(rsp_return, "ram");
 229         result = qdict_get_try_int(rsp_ram, "dirty-sync-count", 0);
 230     }
 231     qobject_unref(rsp_return);
 232     return result;
 233 }
 234
 235 static void read_blocktime(QTestState *who)
 236 {
 237     QDict *rsp_return;
 238
 239     rsp_return = migrate_query(who);
 240     g_assert(qdict_haskey(rsp_return, "postcopy-blocktime"));
 241     qobject_unref(rsp_return);
 242 }
 243
 244 static void wait_for_migration_status(QTestState *who,
 245                                       const char *goal)
 246 {
 247     while (true) {
 248         bool completed;
 249         char *status;
 250
 251         status = migrate_query_status(who);
 252         completed = strcmp(status, goal) == 0;
 253         g_assert_cmpstr(status, !=,  "failed");
 254         g_free(status);
 255         if (completed) {
 256             return;
 257         }
 258         usleep(1000);
 259     }
 260 }
 261
 262 static void wait_for_migration_complete(QTestState *who)
 263 {
 264     wait_for_migration_status(who, "completed");
 265 }
 266
 267 static void wait_for_migration_pass(QTestState *who)
 268 {
 269     uint64_t initial_pass = get_migration_pass(who);
 270     uint64_t pass;
 271
 272     /* Wait for the 1st sync */
 273     while (!got_stop && !initial_pass) {
 274         usleep(1000);
 275         initial_pass = get_migration_pass(who);
 276     }
 277
 278     do {
 279         usleep(1000);
 280         pass = get_migration_pass(who);
 281     } while (pass == initial_pass && !got_stop);
 282 }
 283
 284 static void check_guests_ram(QTestState *who)
 285 {
 286     /* Our ASM test will have been incrementing one byte from each page from
 287      * start_address to < end_address in order. This gives us a constraint
 288      * that any page's byte should be equal or less than the previous pages
 289      * byte (mod 256); and they should all be equal except for one transition
 290      * at the point where we meet the incrementer. (We're running this with
 291      * the guest stopped).
 292      */
 293     unsigned address;
 294     uint8_t first_byte;
 295     uint8_t last_byte;
 296     bool hit_edge = false;
 297     bool bad = false;
 298
 299     qtest_memread(who, start_address, &first_byte, 1);
 300     last_byte = first_byte;
 301
 302     for (address = start_address + TEST_MEM_PAGE_SIZE; address < end_address;
 303          address += TEST_MEM_PAGE_SIZE)
 304     {
 305         uint8_t b;
 306         qtest_memread(who, address, &b, 1);
 307         if (b != last_byte) {
 308             if (((b + 1) % 256) == last_byte && !hit_edge) {
 309                 /* This is OK, the guest stopped at the point of
 310                  * incrementing the previous page but didn't get
 311                  * to us yet.
 312                  */
 313                 hit_edge = true;
 314                 last_byte = b;
 315             } else {
 316                 fprintf(stderr, "Memory content inconsistency at %x"
 317                                 " first_byte = %x last_byte = %x current = %x"
 318                                 " hit_edge = %x\n",
 319                                 address, first_byte, last_byte, b, hit_edge);
 320                 bad = true;
 321             }
 322         }
 323     }
 324     g_assert_false(bad);
 325 }
 326
 327 static void cleanup(const char *filename)
 328 {
 329     char *path = g_strdup_printf("%s/%s", tmpfs, filename);
 330
 331     unlink(path);
 332     g_free(path);
 333 }
 334
 335 static void migrate_check_parameter(QTestState *who, const char *parameter,
 336                                     long long value)
 337 {
 338     QDict *rsp_return;
 339
 340     rsp_return = wait_command(who,
 341                               "{ 'execute': 'query-migrate-parameters' }");
 342     g_assert_cmpint(qdict_get_int(rsp_return, parameter), ==, value);
 343     qobject_unref(rsp_return);
 344 }
 345
 346 static void migrate_set_parameter(QTestState *who, const char *parameter,
 347                                   long long value)
 348 {
 349     QDict *rsp;
 350
 351     rsp = qtest_qmp(who,
 352                     "{ 'execute': 'migrate-set-parameters',"
 353                     "'arguments': { %s: %lld } }",
 354                     parameter, value);
 355     g_assert(qdict_haskey(rsp, "return"));
 356     qobject_unref(rsp);
 357     migrate_check_parameter(who, parameter, value);
 358 }
 359
 360 static void migrate_pause(QTestState *who)
 361 {
 362     QDict *rsp;
 363
 364     rsp = wait_command(who, "{ 'execute': 'migrate-pause' }");
 365     qobject_unref(rsp);
 366 }
 367
 368 static void migrate_recover(QTestState *who, const char *uri)
 369 {
 370     QDict *rsp;
 371
 372     rsp = wait_command(who,
 373                        "{ 'execute': 'migrate-recover', "
 374                        "  'id': 'recover-cmd', "
 375                        "  'arguments': { 'uri': %s } }",
 376                        uri);
 377     qobject_unref(rsp);
 378 }
 379
 380 static void migrate_set_capability(QTestState *who, const char *capability,
 381                                    bool value)
 382 {
 383     QDict *rsp;
 384
 385     rsp = qtest_qmp(who,
 386                     "{ 'execute': 'migrate-set-capabilities',"
 387                     "'arguments': { "
 388                     "'capabilities': [ { "
 389                     "'capability': %s, 'state': %i } ] } }",
 390                     capability, value);
 391     g_assert(qdict_haskey(rsp, "return"));
 392     qobject_unref(rsp);
 393 }
 394
 395 /*
 396  * Send QMP command "migrate".
 397  * Arguments are built from @fmt... (formatted like
 398  * qobject_from_jsonf_nofail()) with "uri": @uri spliced in.
 399  */
 400 GCC_FMT_ATTR(3, 4)
 401 static void migrate(QTestState *who, const char *uri, const char *fmt, ...)
 402 {
 403     va_list ap;
 404     QDict *args, *rsp;
 405
 406     va_start(ap, fmt);
 407     args = qdict_from_vjsonf_nofail(fmt, ap);
 408     va_end(ap);
 409
 410     g_assert(!qdict_haskey(args, "uri"));
 411     qdict_put_str(args, "uri", uri);
 412
 413     rsp = qmp("{ 'execute': 'migrate', 'arguments': %p}", args);
 414     g_assert(qdict_haskey(rsp, "return"));
 415     qobject_unref(rsp);
 416 }
 417
 418 static void migrate_postcopy_start(QTestState *from, QTestState *to)
 419 {
 420     QDict *rsp;
 421
 422     rsp = wait_command(from, "{ 'execute': 'migrate-start-postcopy' }");
 423     qobject_unref(rsp);
 424
 425     if (!got_stop) {
 426         qtest_qmp_eventwait(from, "STOP");
 427     }
 428
 429     qtest_qmp_eventwait(to, "RESUME");
 430 }
 431
 432 static int test_migrate_start(QTestState **from, QTestState **to,
 433                                const char *uri, bool hide_stderr)
 434 {
 435     gchar *cmd_src, *cmd_dst;
 436     char *bootpath = g_strdup_printf("%s/bootsect", tmpfs);
 437     const char *arch = qtest_get_arch();
 438     const char *accel = "kvm:tcg";
 439
 440     got_stop = false;
 441
 442     if (strcmp(arch, "i386") == 0 || strcmp(arch, "x86_64") == 0) {
 443         init_bootfile(bootpath, x86_bootsect);
 444         cmd_src = g_strdup_printf("-machine accel=%s -m 150M"
 445                                   " -name source,debug-threads=on"
 446                                   " -serial file:%s/src_serial"
 447                                   " -drive file=%s,format=raw",
 448                                   accel, tmpfs, bootpath);
 449         cmd_dst = g_strdup_printf("-machine accel=%s -m 150M"
 450                                   " -name target,debug-threads=on"
 451                                   " -serial file:%s/dest_serial"
 452                                   " -drive file=%s,format=raw"
 453                                   " -incoming %s",
 454                                   accel, tmpfs, bootpath, uri);
 455         start_address = X86_TEST_MEM_START;
 456         end_address = X86_TEST_MEM_END;
 457     } else if (g_str_equal(arch, "s390x")) {
 458         init_bootfile_s390x(bootpath);
 459         cmd_src = g_strdup_printf("-machine accel=%s -m 128M"
 460                                   " -name source,debug-threads=on"
 461                                   " -serial file:%s/src_serial -bios %s",
 462                                   accel, tmpfs, bootpath);
 463         cmd_dst = g_strdup_printf("-machine accel=%s -m 128M"
 464                                   " -name target,debug-threads=on"
 465                                   " -serial file:%s/dest_serial -bios %s"
 466                                   " -incoming %s",
 467                                   accel, tmpfs, bootpath, uri);
 468         start_address = S390_TEST_MEM_START;
 469         end_address = S390_TEST_MEM_END;
 470     } else if (strcmp(arch, "ppc64") == 0) {
 471         cmd_src = g_strdup_printf("-machine accel=%s -m 256M -nodefaults"
 472                                   " -name source,debug-threads=on"
 473                                   " -serial file:%s/src_serial"
 474                                   " -prom-env 'use-nvramrc?=true' -prom-env "
 475                                   "'nvramrc=hex .\" _\" begin %x %x "
 476                                   "do i c@ 1 + i c! 1000 +loop .\" B\" 0 "
 477                                   "until'",  accel, tmpfs, end_address,
 478                                   start_address);
 479         cmd_dst = g_strdup_printf("-machine accel=%s -m 256M"
 480                                   " -name target,debug-threads=on"
 481                                   " -serial file:%s/dest_serial"
 482                                   " -incoming %s",
 483                                   accel, tmpfs, uri);
 484
 485         start_address = PPC_TEST_MEM_START;
 486         end_address = PPC_TEST_MEM_END;
 487     } else if (strcmp(arch, "aarch64") == 0) {
 488         init_bootfile(bootpath, aarch64_kernel);
 489         cmd_src = g_strdup_printf("-machine virt,accel=%s,gic-version=max "
 490                                   "-name vmsource,debug-threads=on -cpu max "
 491                                   "-m 150M -serial file:%s/src_serial "
 492                                   "-kernel %s ",
 493                                   accel, tmpfs, bootpath);
 494         cmd_dst = g_strdup_printf("-machine virt,accel=%s,gic-version=max "
 495                                   "-name vmdest,debug-threads=on -cpu max "
 496                                   "-m 150M -serial file:%s/dest_serial "
 497                                   "-kernel %s "
 498                                   "-incoming %s ",
 499                                   accel, tmpfs, bootpath, uri);
 500
 501         start_address = ARM_TEST_MEM_START;
 502         end_address = ARM_TEST_MEM_END;
 503
 504         g_assert(sizeof(aarch64_kernel) <= ARM_TEST_MAX_KERNEL_SIZE);
 505     } else {
 506         g_assert_not_reached();
 507     }
 508
 509     g_free(bootpath);
 510
 511     if (hide_stderr) {
 512         gchar *tmp;
 513         tmp = g_strdup_printf("%s 2>/dev/null", cmd_src);
 514         g_free(cmd_src);
 515         cmd_src = tmp;
 516
 517         tmp = g_strdup_printf("%s 2>/dev/null", cmd_dst);
 518         g_free(cmd_dst);
 519         cmd_dst = tmp;
 520     }
 521
 522     *from = qtest_start(cmd_src);
 523     g_free(cmd_src);
 524
 525     *to = qtest_init(cmd_dst);
 526     g_free(cmd_dst);
 527     return 0;
 528 }
 529
 530 static void test_migrate_end(QTestState *from, QTestState *to, bool test_dest)
 531 {
 532     unsigned char dest_byte_a, dest_byte_b, dest_byte_c, dest_byte_d;
 533
 534     qtest_quit(from);
 535
 536     if (test_dest) {
 537         qtest_memread(to, start_address, &dest_byte_a, 1);
 538
 539         /* Destination still running, wait for a byte to change */
 540         do {
 541             qtest_memread(to, start_address, &dest_byte_b, 1);
 542             usleep(1000 * 10);
 543         } while (dest_byte_a == dest_byte_b);
 544
 545         qtest_qmp_discard_response(to, "{ 'execute' : 'stop'}");
 546
 547         /* With it stopped, check nothing changes */
 548         qtest_memread(to, start_address, &dest_byte_c, 1);
 549         usleep(1000 * 200);
 550         qtest_memread(to, start_address, &dest_byte_d, 1);
 551         g_assert_cmpint(dest_byte_c, ==, dest_byte_d);
 552
 553         check_guests_ram(to);
 554     }
 555
 556     qtest_quit(to);
 557
 558     cleanup("bootsect");
 559     cleanup("migsocket");
 560     cleanup("src_serial");
 561     cleanup("dest_serial");
 562 }
 563
 564 static void deprecated_set_downtime(QTestState *who, const double value)
 565 {
 566     QDict *rsp;
 567
 568     rsp = qtest_qmp(who,
 569                     "{ 'execute': 'migrate_set_downtime',"
 570                     " 'arguments': { 'value': %f } }", value);
 571     g_assert(qdict_haskey(rsp, "return"));
 572     qobject_unref(rsp);
 573     migrate_check_parameter(who, "downtime-limit", value * 1000);
 574 }
 575
 576 static void deprecated_set_speed(QTestState *who, long long value)
 577 {
 578     QDict *rsp;
 579
 580     rsp = qtest_qmp(who, "{ 'execute': 'migrate_set_speed',"
 581                           "'arguments': { 'value': %lld } }", value);
 582     g_assert(qdict_haskey(rsp, "return"));
 583     qobject_unref(rsp);
 584     migrate_check_parameter(who, "max-bandwidth", value);
 585 }
 586
 587 static void test_deprecated(void)
 588 {
 589     QTestState *from;
 590
 591     from = qtest_start("-machine none");
 592
 593     deprecated_set_downtime(from, 0.12345);
 594     deprecated_set_speed(from, 12345);
 595
 596     qtest_quit(from);
 597 }
 598
 599 static int migrate_postcopy_prepare(QTestState **from_ptr,
 600                                      QTestState **to_ptr,
 601                                      bool hide_error)
 602 {
 603     char *uri = g_strdup_printf("unix:%s/migsocket", tmpfs);
 604     QTestState *from, *to;
 605
 606     if (test_migrate_start(&from, &to, uri, hide_error)) {
 607         return -1;
 608     }
 609
 610     migrate_set_capability(from, "postcopy-ram", true);
 611     migrate_set_capability(to, "postcopy-ram", true);
 612     migrate_set_capability(to, "postcopy-blocktime", true);
 613
 614     /* We want to pick a speed slow enough that the test completes
 615      * quickly, but that it doesn't complete precopy even on a slow
 616      * machine, so also set the downtime.
 617      */
 618     migrate_set_parameter(from, "max-bandwidth", 100000000);
 619     migrate_set_parameter(from, "downtime-limit", 1);
 620
 621     /* Wait for the first serial output from the source */
 622     wait_for_serial("src_serial");
 623
 624     migrate(from, uri, "{}");
 625     g_free(uri);
 626
 627     wait_for_migration_pass(from);
 628
 629     *from_ptr = from;
 630     *to_ptr = to;
 631
 632     return 0;
 633 }
 634
 635 static void migrate_postcopy_complete(QTestState *from, QTestState *to)
 636 {
 637     wait_for_migration_complete(from);
 638
 639     /* Make sure we get at least one "B" on destination */
 640     wait_for_serial("dest_serial");
 641
 642     if (uffd_feature_thread_id) {
 643         read_blocktime(to);
 644     }
 645
 646     test_migrate_end(from, to, true);
 647 }
 648
 649 static void test_postcopy(void)
 650 {
 651     QTestState *from, *to;
 652
 653     if (migrate_postcopy_prepare(&from, &to, false)) {
 654         return;
 655     }
 656     migrate_postcopy_start(from, to);
 657     migrate_postcopy_complete(from, to);
 658 }
 659
 660 static void test_postcopy_recovery(void)
 661 {
 662     QTestState *from, *to;
 663     char *uri;
 664
 665     if (migrate_postcopy_prepare(&from, &to, true)) {
 666         return;
 667     }
 668
 669     /* Turn postcopy speed down, 4K/s is slow enough on any machines */
 670     migrate_set_parameter(from, "max-postcopy-bandwidth", 4096);
 671
 672     /* Now we start the postcopy */
 673     migrate_postcopy_start(from, to);
 674
 675     /*
 676      * Wait until postcopy is really started; we can only run the
 677      * migrate-pause command during a postcopy
 678      */
 679     wait_for_migration_status(from, "postcopy-active");
 680
 681     /*
 682      * Manually stop the postcopy migration. This emulates a network
 683      * failure with the migration socket
 684      */
 685     migrate_pause(from);
 686
 687     /*
 688      * Wait for destination side to reach postcopy-paused state.  The
 689      * migrate-recover command can only succeed if destination machine
 690      * is in the paused state
 691      */
 692     wait_for_migration_status(to, "postcopy-paused");
 693
 694     /*
 695      * Create a new socket to emulate a new channel that is different
 696      * from the broken migration channel; tell the destination to
 697      * listen to the new port
 698      */
 699     uri = g_strdup_printf("unix:%s/migsocket-recover", tmpfs);
 700     migrate_recover(to, uri);
 701
 702     /*
 703      * Try to rebuild the migration channel using the resume flag and
 704      * the newly created channel
 705      */
 706     wait_for_migration_status(from, "postcopy-paused");
 707     migrate(from, uri, "{'resume': true}");
 708     g_free(uri);
 709
 710     /* Restore the postcopy bandwidth to unlimited */
 711     migrate_set_parameter(from, "max-postcopy-bandwidth", 0);
 712
 713     migrate_postcopy_complete(from, to);
 714 }
 715
 716 static void test_baddest(void)
 717 {
 718     QTestState *from, *to;
 719     QDict *rsp_return;
 720     char *status;
 721     bool failed;
 722
 723     if (test_migrate_start(&from, &to, "tcp:0:0", true)) {
 724         return;
 725     }
 726     migrate(from, "tcp:0:0", "{}");
 727     do {
 728         status = migrate_query_status(from);
 729         g_assert(!strcmp(status, "setup") || !(strcmp(status, "failed")));
 730         failed = !strcmp(status, "failed");
 731         g_free(status);
 732     } while (!failed);
 733
 734     /* Is the machine currently running? */
 735     rsp_return = wait_command(from, "{ 'execute': 'query-status' }");
 736     g_assert(qdict_haskey(rsp_return, "running"));
 737     g_assert(qdict_get_bool(rsp_return, "running"));
 738     qobject_unref(rsp_return);
 739
 740     test_migrate_end(from, to, false);
 741 }
 742
 743 static void test_precopy_unix(void)
 744 {
 745     char *uri = g_strdup_printf("unix:%s/migsocket", tmpfs);
 746     QTestState *from, *to;
 747
 748     if (test_migrate_start(&from, &to, uri, false)) {
 749         return;
 750     }
 751
 752     /* We want to pick a speed slow enough that the test completes
 753      * quickly, but that it doesn't complete precopy even on a slow
 754      * machine, so also set the downtime.
 755      */
 756     /* 1 ms should make it not converge*/
 757     migrate_set_parameter(from, "downtime-limit", 1);
 758     /* 1GB/s */
 759     migrate_set_parameter(from, "max-bandwidth", 1000000000);
 760
 761     /* Wait for the first serial output from the source */
 762     wait_for_serial("src_serial");
 763
 764     migrate(from, uri, "{}");
 765
 766     wait_for_migration_pass(from);
 767
 768     /* 300 ms should converge */
 769     migrate_set_parameter(from, "downtime-limit", 300);
 770
 771     if (!got_stop) {
 772         qtest_qmp_eventwait(from, "STOP");
 773     }
 774
 775     qtest_qmp_eventwait(to, "RESUME");
 776
 777     wait_for_serial("dest_serial");
 778     wait_for_migration_complete(from);
 779
 780     test_migrate_end(from, to, true);
 781     g_free(uri);
 782 }
 783
 784 int main(int argc, char **argv)
 785 {
 786     char template[] = "/tmp/migration-test-XXXXXX";
 787     int ret;
 788
 789     g_test_init(&argc, &argv, NULL);
 790
 791     if (!ufd_version_check()) {
 792         return 0;
 793     }
 794
 795     /*
 796      * On ppc64, the test only works with kvm-hv, but not with kvm-pr and TCG
 797      * is touchy due to race conditions on dirty bits (especially on PPC for
 798      * some reason)
 799      */
 800     if (g_str_equal(qtest_get_arch(), "ppc64") &&
 801         access("/sys/module/kvm_hv", F_OK)) {
 802         g_test_message("Skipping test: kvm_hv not available");
 803         return 0;
 804     }
 805
 806     tmpfs = mkdtemp(template);
 807     if (!tmpfs) {
 808         g_test_message("mkdtemp on path (%s): %s\n", template, strerror(errno));
 809     }
 810     g_assert(tmpfs);
 811
 812     module_call_init(MODULE_INIT_QOM);
 813
 814     qtest_add_func("/migration/postcopy/unix", test_postcopy);
 815     qtest_add_func("/migration/postcopy/recovery", test_postcopy_recovery);
 816     qtest_add_func("/migration/deprecated", test_deprecated);
 817     qtest_add_func("/migration/bad_dest", test_baddest);
 818     qtest_add_func("/migration/precopy/unix", test_precopy_unix);
 819
 820     ret = g_test_run();
 821
 822     g_assert_cmpint(ret, ==, 0);
 823
 824     ret = rmdir(tmpfs);
 825     if (ret != 0) {
 826         g_test_message("unable to rmdir: path (%s): %s\n",
 827                        tmpfs, strerror(errno));
 828     }
 829
 830     return ret;
 831 }