migration/migration.c

   1 /*
   2  * QEMU live migration
   3  *
   4  * Copyright IBM, Corp. 2008
   5  *
   6  * Authors:
   7  *  Anthony Liguori   <aliguori@us.ibm.com>
   8  *
   9  * This work is licensed under the terms of the GNU GPL, version 2.  See
  10  * the COPYING file in the top-level directory.
  11  *
  12  * Contributions after 2012-01-13 are licensed under the terms of the
  13  * GNU GPL, version 2 or (at your option) any later version.
  14  */
  15
  16 #include "qemu/osdep.h"
  17 #include "qemu/cutils.h"
  18 #include "qemu/error-report.h"
  19 #include "migration/blocker.h"
  20 #include "exec.h"
  21 #include "fd.h"
  22 #include "socket.h"
  23 #include "rdma.h"
  24 #include "ram.h"
  25 #include "migration/global_state.h"
  26 #include "migration/misc.h"
  27 #include "migration.h"
  28 #include "savevm.h"
  29 #include "qemu-file-channel.h"
  30 #include "qemu-file.h"
  31 #include "migration/vmstate.h"
  32 #include "block/block.h"
  33 #include "qapi/error.h"
  34 #include "qapi/qapi-commands-migration.h"
  35 #include "qapi/qapi-events-migration.h"
  36 #include "qapi/qmp/qerror.h"
  37 #include "qapi/qmp/qnull.h"
  38 #include "qemu/rcu.h"
  39 #include "block.h"
  40 #include "postcopy-ram.h"
  41 #include "qemu/thread.h"
  42 #include "trace.h"
  43 #include "exec/target_page.h"
  44 #include "io/channel-buffer.h"
  45 #include "migration/colo.h"
  46 #include "hw/boards.h"
  47 #include "monitor/monitor.h"
  48
  49 #define MAX_THROTTLE  (32 << 20)      /* Migration transfer speed throttling */
  50
  51 /* Amount of time to allocate to each "chunk" of bandwidth-throttled
  52  * data. */
  53 #define BUFFER_DELAY     100
  54 #define XFER_LIMIT_RATIO (1000 / BUFFER_DELAY)
  55
  56 /* Time in milliseconds we are allowed to stop the source,
  57  * for sending the last part */
  58 #define DEFAULT_MIGRATE_SET_DOWNTIME 300
  59
  60 /* Maximum migrate downtime set to 2000 seconds */
  61 #define MAX_MIGRATE_DOWNTIME_SECONDS 2000
  62 #define MAX_MIGRATE_DOWNTIME (MAX_MIGRATE_DOWNTIME_SECONDS * 1000)
  63
  64 /* Default compression thread count */
  65 #define DEFAULT_MIGRATE_COMPRESS_THREAD_COUNT 8
  66 /* Default decompression thread count, usually decompression is at
  67  * least 4 times as fast as compression.*/
  68 #define DEFAULT_MIGRATE_DECOMPRESS_THREAD_COUNT 2
  69 /*0: means nocompress, 1: best speed, ... 9: best compress ratio */
  70 #define DEFAULT_MIGRATE_COMPRESS_LEVEL 1
  71 /* Define default autoconverge cpu throttle migration parameters */
  72 #define DEFAULT_MIGRATE_CPU_THROTTLE_INITIAL 20
  73 #define DEFAULT_MIGRATE_CPU_THROTTLE_INCREMENT 10
  74
  75 /* Migration XBZRLE default cache size */
  76 #define DEFAULT_MIGRATE_XBZRLE_CACHE_SIZE (64 * 1024 * 1024)
  77
  78 /* The delay time (in ms) between two COLO checkpoints
  79  * Note: Please change this default value to 10000 when we support hybrid mode.
  80  */
  81 #define DEFAULT_MIGRATE_X_CHECKPOINT_DELAY 200
  82 #define DEFAULT_MIGRATE_MULTIFD_CHANNELS 2
  83 #define DEFAULT_MIGRATE_MULTIFD_PAGE_COUNT 16
  84
  85 static NotifierList migration_state_notifiers =
  86     NOTIFIER_LIST_INITIALIZER(migration_state_notifiers);
  87
  88 static bool deferred_incoming;
  89
  90 /* Messages sent on the return path from destination to source */
  91 enum mig_rp_message_type {
  92     MIG_RP_MSG_INVALID = 0,  /* Must be 0 */
  93     MIG_RP_MSG_SHUT,         /* sibling will not send any more RP messages */
  94     MIG_RP_MSG_PONG,         /* Response to a PING; data (seq: be32 ) */
  95
  96     MIG_RP_MSG_REQ_PAGES_ID, /* data (start: be64, len: be32, id: string) */
  97     MIG_RP_MSG_REQ_PAGES,    /* data (start: be64, len: be32) */
  98
  99     MIG_RP_MSG_MAX
 100 };
 101
 102 /* When we add fault tolerance, we could have several
 103    migrations at once.  For now we don't need to add
 104    dynamic creation of migration */
 105
 106 static MigrationState *current_migration;
 107
 108 static bool migration_object_check(MigrationState *ms, Error **errp);
 109 static int migration_maybe_pause(MigrationState *s,
 110                                  int *current_active_state,
 111                                  int new_state);
 112
 113 void migration_object_init(void)
 114 {
 115     MachineState *ms = MACHINE(qdev_get_machine());
 116     Error *err = NULL;
 117
 118     /* This can only be called once. */
 119     assert(!current_migration);
 120     current_migration = MIGRATION_OBJ(object_new(TYPE_MIGRATION));
 121
 122     if (!migration_object_check(current_migration, &err)) {
 123         error_report_err(err);
 124         exit(1);
 125     }
 126
 127     /*
 128      * We cannot really do this in migration_instance_init() since at
 129      * that time global properties are not yet applied, then this
 130      * value will be definitely replaced by something else.
 131      */
 132     if (ms->enforce_config_section) {
 133         current_migration->send_configuration = true;
 134     }
 135 }
 136
 137 void migration_object_finalize(void)
 138 {
 139     object_unref(OBJECT(current_migration));
 140 }
 141
 142 /* For outgoing */
 143 MigrationState *migrate_get_current(void)
 144 {
 145     /* This can only be called after the object created. */
 146     assert(current_migration);
 147     return current_migration;
 148 }
 149
 150 MigrationIncomingState *migration_incoming_get_current(void)
 151 {
 152     static bool once;
 153     static MigrationIncomingState mis_current;
 154
 155     if (!once) {
 156         mis_current.state = MIGRATION_STATUS_NONE;
 157         memset(&mis_current, 0, sizeof(MigrationIncomingState));
 158         mis_current.postcopy_remote_fds = g_array_new(FALSE, TRUE,
 159                                                    sizeof(struct PostCopyFD));
 160         qemu_mutex_init(&mis_current.rp_mutex);
 161         qemu_event_init(&mis_current.main_thread_load_event, false);
 162
 163         init_dirty_bitmap_incoming_migration();
 164
 165         once = true;
 166     }
 167     return &mis_current;
 168 }
 169
 170 void migration_incoming_state_destroy(void)
 171 {
 172     struct MigrationIncomingState *mis = migration_incoming_get_current();
 173
 174     if (mis->to_src_file) {
 175         /* Tell source that we are done */
 176         migrate_send_rp_shut(mis, qemu_file_get_error(mis->from_src_file) != 0);
 177         qemu_fclose(mis->to_src_file);
 178         mis->to_src_file = NULL;
 179     }
 180
 181     if (mis->from_src_file) {
 182         qemu_fclose(mis->from_src_file);
 183         mis->from_src_file = NULL;
 184     }
 185     if (mis->postcopy_remote_fds) {
 186         g_array_free(mis->postcopy_remote_fds, TRUE);
 187         mis->postcopy_remote_fds = NULL;
 188     }
 189
 190     qemu_event_reset(&mis->main_thread_load_event);
 191 }
 192
 193 static void migrate_generate_event(int new_state)
 194 {
 195     if (migrate_use_events()) {
 196         qapi_event_send_migration(new_state, &error_abort);
 197     }
 198 }
 199
 200 /*
 201  * Called on -incoming with a defer: uri.
 202  * The migration can be started later after any parameters have been
 203  * changed.
 204  */
 205 static void deferred_incoming_migration(Error **errp)
 206 {
 207     if (deferred_incoming) {
 208         error_setg(errp, "Incoming migration already deferred");
 209     }
 210     deferred_incoming = true;
 211 }
 212
 213 /*
 214  * Send a message on the return channel back to the source
 215  * of the migration.
 216  */
 217 static int migrate_send_rp_message(MigrationIncomingState *mis,
 218                                    enum mig_rp_message_type message_type,
 219                                    uint16_t len, void *data)
 220 {
 221     int ret = 0;
 222
 223     trace_migrate_send_rp_message((int)message_type, len);
 224     qemu_mutex_lock(&mis->rp_mutex);
 225
 226     /*
 227      * It's possible that the file handle got lost due to network
 228      * failures.
 229      */
 230     if (!mis->to_src_file) {
 231         ret = -EIO;
 232         goto error;
 233     }
 234
 235     qemu_put_be16(mis->to_src_file, (unsigned int)message_type);
 236     qemu_put_be16(mis->to_src_file, len);
 237     qemu_put_buffer(mis->to_src_file, data, len);
 238     qemu_fflush(mis->to_src_file);
 239
 240     /* It's possible that qemu file got error during sending */
 241     ret = qemu_file_get_error(mis->to_src_file);
 242
 243 error:
 244     qemu_mutex_unlock(&mis->rp_mutex);
 245     return ret;
 246 }
 247
 248 /* Request a range of pages from the source VM at the given
 249  * start address.
 250  *   rbname: Name of the RAMBlock to request the page in, if NULL it's the same
 251  *           as the last request (a name must have been given previously)
 252  *   Start: Address offset within the RB
 253  *   Len: Length in bytes required - must be a multiple of pagesize
 254  */
 255 int migrate_send_rp_req_pages(MigrationIncomingState *mis, const char *rbname,
 256                               ram_addr_t start, size_t len)
 257 {
 258     uint8_t bufc[12 + 1 + 255]; /* start (8), len (4), rbname up to 256 */
 259     size_t msglen = 12; /* start + len */
 260     enum mig_rp_message_type msg_type;
 261
 262     *(uint64_t *)bufc = cpu_to_be64((uint64_t)start);
 263     *(uint32_t *)(bufc + 8) = cpu_to_be32((uint32_t)len);
 264
 265     if (rbname) {
 266         int rbname_len = strlen(rbname);
 267         assert(rbname_len < 256);
 268
 269         bufc[msglen++] = rbname_len;
 270         memcpy(bufc + msglen, rbname, rbname_len);
 271         msglen += rbname_len;
 272         msg_type = MIG_RP_MSG_REQ_PAGES_ID;
 273     } else {
 274         msg_type = MIG_RP_MSG_REQ_PAGES;
 275     }
 276
 277     return migrate_send_rp_message(mis, msg_type, msglen, bufc);
 278 }
 279
 280 void qemu_start_incoming_migration(const char *uri, Error **errp)
 281 {
 282     const char *p;
 283
 284     qapi_event_send_migration(MIGRATION_STATUS_SETUP, &error_abort);
 285     if (!strcmp(uri, "defer")) {
 286         deferred_incoming_migration(errp);
 287     } else if (strstart(uri, "tcp:", &p)) {
 288         tcp_start_incoming_migration(p, errp);
 289 #ifdef CONFIG_RDMA
 290     } else if (strstart(uri, "rdma:", &p)) {
 291         rdma_start_incoming_migration(p, errp);
 292 #endif
 293     } else if (strstart(uri, "exec:", &p)) {
 294         exec_start_incoming_migration(p, errp);
 295     } else if (strstart(uri, "unix:", &p)) {
 296         unix_start_incoming_migration(p, errp);
 297     } else if (strstart(uri, "fd:", &p)) {
 298         fd_start_incoming_migration(p, errp);
 299     } else {
 300         error_setg(errp, "unknown migration protocol: %s", uri);
 301     }
 302 }
 303
 304 static void process_incoming_migration_bh(void *opaque)
 305 {
 306     Error *local_err = NULL;
 307     MigrationIncomingState *mis = opaque;
 308
 309     /* Only fire up the block code now if we're going to restart the
 310      * VM, else 'cont' will do it.
 311      * This causes file locking to happen; so we don't want it to happen
 312      * unless we really are starting the VM.
 313      */
 314     if (autostart && (!global_state_received() ||
 315         global_state_get_runstate() == RUN_STATE_RUNNING)) {
 316         /* Make sure all file formats flush their mutable metadata.
 317          * If we get an error here, just don't restart the VM yet. */
 318         bdrv_invalidate_cache_all(&local_err);
 319         if (local_err) {
 320             error_report_err(local_err);
 321             local_err = NULL;
 322             autostart = false;
 323         }
 324     }
 325
 326     /*
 327      * This must happen after all error conditions are dealt with and
 328      * we're sure the VM is going to be running on this host.
 329      */
 330     qemu_announce_self();
 331
 332     if (multifd_load_cleanup(&local_err) != 0) {
 333         error_report_err(local_err);
 334         autostart = false;
 335     }
 336     /* If global state section was not received or we are in running
 337        state, we need to obey autostart. Any other state is set with
 338        runstate_set. */
 339
 340     dirty_bitmap_mig_before_vm_start();
 341
 342     if (!global_state_received() ||
 343         global_state_get_runstate() == RUN_STATE_RUNNING) {
 344         if (autostart) {
 345             vm_start();
 346         } else {
 347             runstate_set(RUN_STATE_PAUSED);
 348         }
 349     } else {
 350         runstate_set(global_state_get_runstate());
 351     }
 352     /*
 353      * This must happen after any state changes since as soon as an external
 354      * observer sees this event they might start to prod at the VM assuming
 355      * it's ready to use.
 356      */
 357     migrate_set_state(&mis->state, MIGRATION_STATUS_ACTIVE,
 358                       MIGRATION_STATUS_COMPLETED);
 359     qemu_bh_delete(mis->bh);
 360     migration_incoming_state_destroy();
 361 }
 362
 363 static void process_incoming_migration_co(void *opaque)
 364 {
 365     MigrationIncomingState *mis = migration_incoming_get_current();
 366     PostcopyState ps;
 367     int ret;
 368
 369     assert(mis->from_src_file);
 370     mis->largest_page_size = qemu_ram_pagesize_largest();
 371     postcopy_state_set(POSTCOPY_INCOMING_NONE);
 372     migrate_set_state(&mis->state, MIGRATION_STATUS_NONE,
 373                       MIGRATION_STATUS_ACTIVE);
 374     ret = qemu_loadvm_state(mis->from_src_file);
 375
 376     ps = postcopy_state_get();
 377     trace_process_incoming_migration_co_end(ret, ps);
 378     if (ps != POSTCOPY_INCOMING_NONE) {
 379         if (ps == POSTCOPY_INCOMING_ADVISE) {
 380             /*
 381              * Where a migration had postcopy enabled (and thus went to advise)
 382              * but managed to complete within the precopy period, we can use
 383              * the normal exit.
 384              */
 385             postcopy_ram_incoming_cleanup(mis);
 386         } else if (ret >= 0) {
 387             /*
 388              * Postcopy was started, cleanup should happen at the end of the
 389              * postcopy thread.
 390              */
 391             trace_process_incoming_migration_co_postcopy_end_main();
 392             return;
 393         }
 394         /* Else if something went wrong then just fall out of the normal exit */
 395     }
 396
 397     /* we get COLO info, and know if we are in COLO mode */
 398     if (!ret && migration_incoming_enable_colo()) {
 399         mis->migration_incoming_co = qemu_coroutine_self();
 400         qemu_thread_create(&mis->colo_incoming_thread, "COLO incoming",
 401              colo_process_incoming_thread, mis, QEMU_THREAD_JOINABLE);
 402         mis->have_colo_incoming_thread = true;
 403         qemu_coroutine_yield();
 404
 405         /* Wait checkpoint incoming thread exit before free resource */
 406         qemu_thread_join(&mis->colo_incoming_thread);
 407     }
 408
 409     if (ret < 0) {
 410         Error *local_err = NULL;
 411
 412         migrate_set_state(&mis->state, MIGRATION_STATUS_ACTIVE,
 413                           MIGRATION_STATUS_FAILED);
 414         error_report("load of migration failed: %s", strerror(-ret));
 415         qemu_fclose(mis->from_src_file);
 416         if (multifd_load_cleanup(&local_err) != 0) {
 417             error_report_err(local_err);
 418         }
 419         exit(EXIT_FAILURE);
 420     }
 421     mis->bh = qemu_bh_new(process_incoming_migration_bh, mis);
 422     qemu_bh_schedule(mis->bh);
 423 }
 424
 425 static void migration_incoming_setup(QEMUFile *f)
 426 {
 427     MigrationIncomingState *mis = migration_incoming_get_current();
 428
 429     if (multifd_load_setup() != 0) {
 430         /* We haven't been able to create multifd threads
 431            nothing better to do */
 432         exit(EXIT_FAILURE);
 433     }
 434
 435     if (!mis->from_src_file) {
 436         mis->from_src_file = f;
 437     }
 438     qemu_file_set_blocking(f, false);
 439 }
 440
 441 static void migration_incoming_process(void)
 442 {
 443     Coroutine *co = qemu_coroutine_create(process_incoming_migration_co, NULL);
 444     qemu_coroutine_enter(co);
 445 }
 446
 447 void migration_fd_process_incoming(QEMUFile *f)
 448 {
 449     migration_incoming_setup(f);
 450     migration_incoming_process();
 451 }
 452
 453 void migration_ioc_process_incoming(QIOChannel *ioc)
 454 {
 455     MigrationIncomingState *mis = migration_incoming_get_current();
 456
 457     if (!mis->from_src_file) {
 458         QEMUFile *f = qemu_fopen_channel_input(ioc);
 459         migration_fd_process_incoming(f);
 460     }
 461     /* We still only have a single channel.  Nothing to do here yet */
 462 }
 463
 464 /**
 465  * @migration_has_all_channels: We have received all channels that we need
 466  *
 467  * Returns true when we have got connections to all the channels that
 468  * we need for migration.
 469  */
 470 bool migration_has_all_channels(void)
 471 {
 472     return true;
 473 }
 474
 475 /*
 476  * Send a 'SHUT' message on the return channel with the given value
 477  * to indicate that we've finished with the RP.  Non-0 value indicates
 478  * error.
 479  */
 480 void migrate_send_rp_shut(MigrationIncomingState *mis,
 481                           uint32_t value)
 482 {
 483     uint32_t buf;
 484
 485     buf = cpu_to_be32(value);
 486     migrate_send_rp_message(mis, MIG_RP_MSG_SHUT, sizeof(buf), &buf);
 487 }
 488
 489 /*
 490  * Send a 'PONG' message on the return channel with the given value
 491  * (normally in response to a 'PING')
 492  */
 493 void migrate_send_rp_pong(MigrationIncomingState *mis,
 494                           uint32_t value)
 495 {
 496     uint32_t buf;
 497
 498     buf = cpu_to_be32(value);
 499     migrate_send_rp_message(mis, MIG_RP_MSG_PONG, sizeof(buf), &buf);
 500 }
 501
 502 MigrationCapabilityStatusList *qmp_query_migrate_capabilities(Error **errp)
 503 {
 504     MigrationCapabilityStatusList *head = NULL;
 505     MigrationCapabilityStatusList *caps;
 506     MigrationState *s = migrate_get_current();
 507     int i;
 508
 509     caps = NULL; /* silence compiler warning */
 510     for (i = 0; i < MIGRATION_CAPABILITY__MAX; i++) {
 511 #ifndef CONFIG_LIVE_BLOCK_MIGRATION
 512         if (i == MIGRATION_CAPABILITY_BLOCK) {
 513             continue;
 514         }
 515 #endif
 516         if (head == NULL) {
 517             head = g_malloc0(sizeof(*caps));
 518             caps = head;
 519         } else {
 520             caps->next = g_malloc0(sizeof(*caps));
 521             caps = caps->next;
 522         }
 523         caps->value =
 524             g_malloc(sizeof(*caps->value));
 525         caps->value->capability = i;
 526         caps->value->state = s->enabled_capabilities[i];
 527     }
 528
 529     return head;
 530 }
 531
 532 MigrationParameters *qmp_query_migrate_parameters(Error **errp)
 533 {
 534     MigrationParameters *params;
 535     MigrationState *s = migrate_get_current();
 536
 537     /* TODO use QAPI_CLONE() instead of duplicating it inline */
 538     params = g_malloc0(sizeof(*params));
 539     params->has_compress_level = true;
 540     params->compress_level = s->parameters.compress_level;
 541     params->has_compress_threads = true;
 542     params->compress_threads = s->parameters.compress_threads;
 543     params->has_decompress_threads = true;
 544     params->decompress_threads = s->parameters.decompress_threads;
 545     params->has_cpu_throttle_initial = true;
 546     params->cpu_throttle_initial = s->parameters.cpu_throttle_initial;
 547     params->has_cpu_throttle_increment = true;
 548     params->cpu_throttle_increment = s->parameters.cpu_throttle_increment;
 549     params->has_tls_creds = true;
 550     params->tls_creds = g_strdup(s->parameters.tls_creds);
 551     params->has_tls_hostname = true;
 552     params->tls_hostname = g_strdup(s->parameters.tls_hostname);
 553     params->has_max_bandwidth = true;
 554     params->max_bandwidth = s->parameters.max_bandwidth;
 555     params->has_downtime_limit = true;
 556     params->downtime_limit = s->parameters.downtime_limit;
 557     params->has_x_checkpoint_delay = true;
 558     params->x_checkpoint_delay = s->parameters.x_checkpoint_delay;
 559     params->has_block_incremental = true;
 560     params->block_incremental = s->parameters.block_incremental;
 561     params->has_x_multifd_channels = true;
 562     params->x_multifd_channels = s->parameters.x_multifd_channels;
 563     params->has_x_multifd_page_count = true;
 564     params->x_multifd_page_count = s->parameters.x_multifd_page_count;
 565     params->has_xbzrle_cache_size = true;
 566     params->xbzrle_cache_size = s->parameters.xbzrle_cache_size;
 567
 568     return params;
 569 }
 570
 571 /*
 572  * Return true if we're already in the middle of a migration
 573  * (i.e. any of the active or setup states)
 574  */
 575 static bool migration_is_setup_or_active(int state)
 576 {
 577     switch (state) {
 578     case MIGRATION_STATUS_ACTIVE:
 579     case MIGRATION_STATUS_POSTCOPY_ACTIVE:
 580     case MIGRATION_STATUS_SETUP:
 581     case MIGRATION_STATUS_PRE_SWITCHOVER:
 582     case MIGRATION_STATUS_DEVICE:
 583         return true;
 584
 585     default:
 586         return false;
 587
 588     }
 589 }
 590
 591 static void populate_ram_info(MigrationInfo *info, MigrationState *s)
 592 {
 593     info->has_ram = true;
 594     info->ram = g_malloc0(sizeof(*info->ram));
 595     info->ram->transferred = ram_counters.transferred;
 596     info->ram->total = ram_bytes_total();
 597     info->ram->duplicate = ram_counters.duplicate;
 598     /* legacy value.  It is not used anymore */
 599     info->ram->skipped = 0;
 600     info->ram->normal = ram_counters.normal;
 601     info->ram->normal_bytes = ram_counters.normal *
 602         qemu_target_page_size();
 603     info->ram->mbps = s->mbps;
 604     info->ram->dirty_sync_count = ram_counters.dirty_sync_count;
 605     info->ram->postcopy_requests = ram_counters.postcopy_requests;
 606     info->ram->page_size = qemu_target_page_size();
 607
 608     if (migrate_use_xbzrle()) {
 609         info->has_xbzrle_cache = true;
 610         info->xbzrle_cache = g_malloc0(sizeof(*info->xbzrle_cache));
 611         info->xbzrle_cache->cache_size = migrate_xbzrle_cache_size();
 612         info->xbzrle_cache->bytes = xbzrle_counters.bytes;
 613         info->xbzrle_cache->pages = xbzrle_counters.pages;
 614         info->xbzrle_cache->cache_miss = xbzrle_counters.cache_miss;
 615         info->xbzrle_cache->cache_miss_rate = xbzrle_counters.cache_miss_rate;
 616         info->xbzrle_cache->overflow = xbzrle_counters.overflow;
 617     }
 618
 619     if (cpu_throttle_active()) {
 620         info->has_cpu_throttle_percentage = true;
 621         info->cpu_throttle_percentage = cpu_throttle_get_percentage();
 622     }
 623
 624     if (s->state != MIGRATION_STATUS_COMPLETED) {
 625         info->ram->remaining = ram_bytes_remaining();
 626         info->ram->dirty_pages_rate = ram_counters.dirty_pages_rate;
 627     }
 628 }
 629
 630 static void populate_disk_info(MigrationInfo *info)
 631 {
 632     if (blk_mig_active()) {
 633         info->has_disk = true;
 634         info->disk = g_malloc0(sizeof(*info->disk));
 635         info->disk->transferred = blk_mig_bytes_transferred();
 636         info->disk->remaining = blk_mig_bytes_remaining();
 637         info->disk->total = blk_mig_bytes_total();
 638     }
 639 }
 640
 641 MigrationInfo *qmp_query_migrate(Error **errp)
 642 {
 643     MigrationInfo *info = g_malloc0(sizeof(*info));
 644     MigrationState *s = migrate_get_current();
 645
 646     switch (s->state) {
 647     case MIGRATION_STATUS_NONE:
 648         /* no migration has happened ever */
 649         break;
 650     case MIGRATION_STATUS_SETUP:
 651         info->has_status = true;
 652         info->has_total_time = false;
 653         break;
 654     case MIGRATION_STATUS_ACTIVE:
 655     case MIGRATION_STATUS_CANCELLING:
 656     case MIGRATION_STATUS_POSTCOPY_ACTIVE:
 657     case MIGRATION_STATUS_PRE_SWITCHOVER:
 658     case MIGRATION_STATUS_DEVICE:
 659          /* TODO add some postcopy stats */
 660         info->has_status = true;
 661         info->has_total_time = true;
 662         info->total_time = qemu_clock_get_ms(QEMU_CLOCK_REALTIME)
 663             - s->start_time;
 664         info->has_expected_downtime = true;
 665         info->expected_downtime = s->expected_downtime;
 666         info->has_setup_time = true;
 667         info->setup_time = s->setup_time;
 668
 669         populate_ram_info(info, s);
 670         populate_disk_info(info);
 671         break;
 672     case MIGRATION_STATUS_COLO:
 673         info->has_status = true;
 674         /* TODO: display COLO specific information (checkpoint info etc.) */
 675         break;
 676     case MIGRATION_STATUS_COMPLETED:
 677         info->has_status = true;
 678         info->has_total_time = true;
 679         info->total_time = s->total_time;
 680         info->has_downtime = true;
 681         info->downtime = s->downtime;
 682         info->has_setup_time = true;
 683         info->setup_time = s->setup_time;
 684
 685         populate_ram_info(info, s);
 686         break;
 687     case MIGRATION_STATUS_FAILED:
 688         info->has_status = true;
 689         if (s->error) {
 690             info->has_error_desc = true;
 691             info->error_desc = g_strdup(error_get_pretty(s->error));
 692         }
 693         break;
 694     case MIGRATION_STATUS_CANCELLED:
 695         info->has_status = true;
 696         break;
 697     }
 698     info->status = s->state;
 699
 700     return info;
 701 }
 702
 703 /**
 704  * @migration_caps_check - check capability validity
 705  *
 706  * @cap_list: old capability list, array of bool
 707  * @params: new capabilities to be applied soon
 708  * @errp: set *errp if the check failed, with reason
 709  *
 710  * Returns true if check passed, otherwise false.
 711  */
 712 static bool migrate_caps_check(bool *cap_list,
 713                                MigrationCapabilityStatusList *params,
 714                                Error **errp)
 715 {
 716     MigrationCapabilityStatusList *cap;
 717     bool old_postcopy_cap;
 718     MigrationIncomingState *mis = migration_incoming_get_current();
 719
 720     old_postcopy_cap = cap_list[MIGRATION_CAPABILITY_POSTCOPY_RAM];
 721
 722     for (cap = params; cap; cap = cap->next) {
 723         cap_list[cap->value->capability] = cap->value->state;
 724     }
 725
 726 #ifndef CONFIG_LIVE_BLOCK_MIGRATION
 727     if (cap_list[MIGRATION_CAPABILITY_BLOCK]) {
 728         error_setg(errp, "QEMU compiled without old-style (blk/-b, inc/-i) "
 729                    "block migration");
 730         error_append_hint(errp, "Use drive_mirror+NBD instead.\n");
 731         return false;
 732     }
 733 #endif
 734
 735     if (cap_list[MIGRATION_CAPABILITY_POSTCOPY_RAM]) {
 736         if (cap_list[MIGRATION_CAPABILITY_COMPRESS]) {
 737             /* The decompression threads asynchronously write into RAM
 738              * rather than use the atomic copies needed to avoid
 739              * userfaulting.  It should be possible to fix the decompression
 740              * threads for compatibility in future.
 741              */
 742             error_setg(errp, "Postcopy is not currently compatible "
 743                        "with compression");
 744             return false;
 745         }
 746
 747         /* This check is reasonably expensive, so only when it's being
 748          * set the first time, also it's only the destination that needs
 749          * special support.
 750          */
 751         if (!old_postcopy_cap && runstate_check(RUN_STATE_INMIGRATE) &&
 752             !postcopy_ram_supported_by_host(mis)) {
 753             /* postcopy_ram_supported_by_host will have emitted a more
 754              * detailed message
 755              */
 756             error_setg(errp, "Postcopy is not supported");
 757             return false;
 758         }
 759     }
 760
 761     return true;
 762 }
 763
 764 void qmp_migrate_set_capabilities(MigrationCapabilityStatusList *params,
 765                                   Error **errp)
 766 {
 767     MigrationState *s = migrate_get_current();
 768     MigrationCapabilityStatusList *cap;
 769     bool cap_list[MIGRATION_CAPABILITY__MAX];
 770
 771     if (migration_is_setup_or_active(s->state)) {
 772         error_setg(errp, QERR_MIGRATION_ACTIVE);
 773         return;
 774     }
 775
 776     memcpy(cap_list, s->enabled_capabilities, sizeof(cap_list));
 777     if (!migrate_caps_check(cap_list, params, errp)) {
 778         return;
 779     }
 780
 781     for (cap = params; cap; cap = cap->next) {
 782         s->enabled_capabilities[cap->value->capability] = cap->value->state;
 783     }
 784 }
 785
 786 /*
 787  * Check whether the parameters are valid. Error will be put into errp
 788  * (if provided). Return true if valid, otherwise false.
 789  */
 790 static bool migrate_params_check(MigrationParameters *params, Error **errp)
 791 {
 792     if (params->has_compress_level &&
 793         (params->compress_level > 9)) {
 794         error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "compress_level",
 795                    "is invalid, it should be in the range of 0 to 9");
 796         return false;
 797     }
 798
 799     if (params->has_compress_threads && (params->compress_threads < 1)) {
 800         error_setg(errp, QERR_INVALID_PARAMETER_VALUE,
 801                    "compress_threads",
 802                    "is invalid, it should be in the range of 1 to 255");
 803         return false;
 804     }
 805
 806     if (params->has_decompress_threads && (params->decompress_threads < 1)) {
 807         error_setg(errp, QERR_INVALID_PARAMETER_VALUE,
 808                    "decompress_threads",
 809                    "is invalid, it should be in the range of 1 to 255");
 810         return false;
 811     }
 812
 813     if (params->has_cpu_throttle_initial &&
 814         (params->cpu_throttle_initial < 1 ||
 815          params->cpu_throttle_initial > 99)) {
 816         error_setg(errp, QERR_INVALID_PARAMETER_VALUE,
 817                    "cpu_throttle_initial",
 818                    "an integer in the range of 1 to 99");
 819         return false;
 820     }
 821
 822     if (params->has_cpu_throttle_increment &&
 823         (params->cpu_throttle_increment < 1 ||
 824          params->cpu_throttle_increment > 99)) {
 825         error_setg(errp, QERR_INVALID_PARAMETER_VALUE,
 826                    "cpu_throttle_increment",
 827                    "an integer in the range of 1 to 99");
 828         return false;
 829     }
 830
 831     if (params->has_max_bandwidth && (params->max_bandwidth > SIZE_MAX)) {
 832         error_setg(errp, "Parameter 'max_bandwidth' expects an integer in the"
 833                          " range of 0 to %zu bytes/second", SIZE_MAX);
 834         return false;
 835     }
 836
 837     if (params->has_downtime_limit &&
 838         (params->downtime_limit > MAX_MIGRATE_DOWNTIME)) {
 839         error_setg(errp, "Parameter 'downtime_limit' expects an integer in "
 840                          "the range of 0 to %d milliseconds",
 841                          MAX_MIGRATE_DOWNTIME);
 842         return false;
 843     }
 844
 845     /* x_checkpoint_delay is now always positive */
 846
 847     if (params->has_x_multifd_channels && (params->x_multifd_channels < 1)) {
 848         error_setg(errp, QERR_INVALID_PARAMETER_VALUE,
 849                    "multifd_channels",
 850                    "is invalid, it should be in the range of 1 to 255");
 851         return false;
 852     }
 853     if (params->has_x_multifd_page_count &&
 854         (params->x_multifd_page_count < 1 ||
 855          params->x_multifd_page_count > 10000)) {
 856         error_setg(errp, QERR_INVALID_PARAMETER_VALUE,
 857                    "multifd_page_count",
 858                    "is invalid, it should be in the range of 1 to 10000");
 859         return false;
 860     }
 861
 862     if (params->has_xbzrle_cache_size &&
 863         (params->xbzrle_cache_size < qemu_target_page_size() ||
 864          !is_power_of_2(params->xbzrle_cache_size))) {
 865         error_setg(errp, QERR_INVALID_PARAMETER_VALUE,
 866                    "xbzrle_cache_size",
 867                    "is invalid, it should be bigger than target page size"
 868                    " and a power of two");
 869         return false;
 870     }
 871
 872     return true;
 873 }
 874
 875 static void migrate_params_test_apply(MigrateSetParameters *params,
 876                                       MigrationParameters *dest)
 877 {
 878     *dest = migrate_get_current()->parameters;
 879
 880     /* TODO use QAPI_CLONE() instead of duplicating it inline */
 881
 882     if (params->has_compress_level) {
 883         dest->compress_level = params->compress_level;
 884     }
 885
 886     if (params->has_compress_threads) {
 887         dest->compress_threads = params->compress_threads;
 888     }
 889
 890     if (params->has_decompress_threads) {
 891         dest->decompress_threads = params->decompress_threads;
 892     }
 893
 894     if (params->has_cpu_throttle_initial) {
 895         dest->cpu_throttle_initial = params->cpu_throttle_initial;
 896     }
 897
 898     if (params->has_cpu_throttle_increment) {
 899         dest->cpu_throttle_increment = params->cpu_throttle_increment;
 900     }
 901
 902     if (params->has_tls_creds) {
 903         assert(params->tls_creds->type == QTYPE_QSTRING);
 904         dest->tls_creds = g_strdup(params->tls_creds->u.s);
 905     }
 906
 907     if (params->has_tls_hostname) {
 908         assert(params->tls_hostname->type == QTYPE_QSTRING);
 909         dest->tls_hostname = g_strdup(params->tls_hostname->u.s);
 910     }
 911
 912     if (params->has_max_bandwidth) {
 913         dest->max_bandwidth = params->max_bandwidth;
 914     }
 915
 916     if (params->has_downtime_limit) {
 917         dest->downtime_limit = params->downtime_limit;
 918     }
 919
 920     if (params->has_x_checkpoint_delay) {
 921         dest->x_checkpoint_delay = params->x_checkpoint_delay;
 922     }
 923
 924     if (params->has_block_incremental) {
 925         dest->block_incremental = params->block_incremental;
 926     }
 927     if (params->has_x_multifd_channels) {
 928         dest->x_multifd_channels = params->x_multifd_channels;
 929     }
 930     if (params->has_x_multifd_page_count) {
 931         dest->x_multifd_page_count = params->x_multifd_page_count;
 932     }
 933     if (params->has_xbzrle_cache_size) {
 934         dest->xbzrle_cache_size = params->xbzrle_cache_size;
 935     }
 936 }
 937
 938 static void migrate_params_apply(MigrateSetParameters *params, Error **errp)
 939 {
 940     MigrationState *s = migrate_get_current();
 941
 942     /* TODO use QAPI_CLONE() instead of duplicating it inline */
 943
 944     if (params->has_compress_level) {
 945         s->parameters.compress_level = params->compress_level;
 946     }
 947
 948     if (params->has_compress_threads) {
 949         s->parameters.compress_threads = params->compress_threads;
 950     }
 951
 952     if (params->has_decompress_threads) {
 953         s->parameters.decompress_threads = params->decompress_threads;
 954     }
 955
 956     if (params->has_cpu_throttle_initial) {
 957         s->parameters.cpu_throttle_initial = params->cpu_throttle_initial;
 958     }
 959
 960     if (params->has_cpu_throttle_increment) {
 961         s->parameters.cpu_throttle_increment = params->cpu_throttle_increment;
 962     }
 963
 964     if (params->has_tls_creds) {
 965         g_free(s->parameters.tls_creds);
 966         assert(params->tls_creds->type == QTYPE_QSTRING);
 967         s->parameters.tls_creds = g_strdup(params->tls_creds->u.s);
 968     }
 969
 970     if (params->has_tls_hostname) {
 971         g_free(s->parameters.tls_hostname);
 972         assert(params->tls_hostname->type == QTYPE_QSTRING);
 973         s->parameters.tls_hostname = g_strdup(params->tls_hostname->u.s);
 974     }
 975
 976     if (params->has_max_bandwidth) {
 977         s->parameters.max_bandwidth = params->max_bandwidth;
 978         if (s->to_dst_file) {
 979             qemu_file_set_rate_limit(s->to_dst_file,
 980                                 s->parameters.max_bandwidth / XFER_LIMIT_RATIO);
 981         }
 982     }
 983
 984     if (params->has_downtime_limit) {
 985         s->parameters.downtime_limit = params->downtime_limit;
 986     }
 987
 988     if (params->has_x_checkpoint_delay) {
 989         s->parameters.x_checkpoint_delay = params->x_checkpoint_delay;
 990         if (migration_in_colo_state()) {
 991             colo_checkpoint_notify(s);
 992         }
 993     }
 994
 995     if (params->has_block_incremental) {
 996         s->parameters.block_incremental = params->block_incremental;
 997     }
 998     if (params->has_x_multifd_channels) {
 999         s->parameters.x_multifd_channels = params->x_multifd_channels;
1000     }
1001     if (params->has_x_multifd_page_count) {
1002         s->parameters.x_multifd_page_count = params->x_multifd_page_count;
1003     }
1004     if (params->has_xbzrle_cache_size) {
1005         s->parameters.xbzrle_cache_size = params->xbzrle_cache_size;
1006         xbzrle_cache_resize(params->xbzrle_cache_size, errp);
1007     }
1008 }
1009
1010 void qmp_migrate_set_parameters(MigrateSetParameters *params, Error **errp)
1011 {
1012     MigrationParameters tmp;
1013
1014     /* TODO Rewrite "" to null instead */
1015     if (params->has_tls_creds
1016         && params->tls_creds->type == QTYPE_QNULL) {
1017         QDECREF(params->tls_creds->u.n);
1018         params->tls_creds->type = QTYPE_QSTRING;
1019         params->tls_creds->u.s = strdup("");
1020     }
1021     /* TODO Rewrite "" to null instead */
1022     if (params->has_tls_hostname
1023         && params->tls_hostname->type == QTYPE_QNULL) {
1024         QDECREF(params->tls_hostname->u.n);
1025         params->tls_hostname->type = QTYPE_QSTRING;
1026         params->tls_hostname->u.s = strdup("");
1027     }
1028
1029     migrate_params_test_apply(params, &tmp);
1030
1031     if (!migrate_params_check(&tmp, errp)) {
1032         /* Invalid parameter */
1033         return;
1034     }
1035
1036     migrate_params_apply(params, errp);
1037 }
1038
1039
1040 void qmp_migrate_start_postcopy(Error **errp)
1041 {
1042     MigrationState *s = migrate_get_current();
1043
1044     if (!migrate_postcopy()) {
1045         error_setg(errp, "Enable postcopy with migrate_set_capability before"
1046                          " the start of migration");
1047         return;
1048     }
1049
1050     if (s->state == MIGRATION_STATUS_NONE) {
1051         error_setg(errp, "Postcopy must be started after migration has been"
1052                          " started");
1053         return;
1054     }
1055     /*
1056      * we don't error if migration has finished since that would be racy
1057      * with issuing this command.
1058      */
1059     atomic_set(&s->start_postcopy, true);
1060 }
1061
1062 /* shared migration helpers */
1063
1064 void migrate_set_state(int *state, int old_state, int new_state)
1065 {
1066     assert(new_state < MIGRATION_STATUS__MAX);
1067     if (atomic_cmpxchg(state, old_state, new_state) == old_state) {
1068         trace_migrate_set_state(MigrationStatus_str(new_state));
1069         migrate_generate_event(new_state);
1070     }
1071 }
1072
1073 static MigrationCapabilityStatusList *migrate_cap_add(
1074     MigrationCapabilityStatusList *list,
1075     MigrationCapability index,
1076     bool state)
1077 {
1078     MigrationCapabilityStatusList *cap;
1079
1080     cap = g_new0(MigrationCapabilityStatusList, 1);
1081     cap->value = g_new0(MigrationCapabilityStatus, 1);
1082     cap->value->capability = index;
1083     cap->value->state = state;
1084     cap->next = list;
1085
1086     return cap;
1087 }
1088
1089 void migrate_set_block_enabled(bool value, Error **errp)
1090 {
1091     MigrationCapabilityStatusList *cap;
1092
1093     cap = migrate_cap_add(NULL, MIGRATION_CAPABILITY_BLOCK, value);
1094     qmp_migrate_set_capabilities(cap, errp);
1095     qapi_free_MigrationCapabilityStatusList(cap);
1096 }
1097
1098 static void migrate_set_block_incremental(MigrationState *s, bool value)
1099 {
1100     s->parameters.block_incremental = value;
1101 }
1102
1103 static void block_cleanup_parameters(MigrationState *s)
1104 {
1105     if (s->must_remove_block_options) {
1106         /* setting to false can never fail */
1107         migrate_set_block_enabled(false, &error_abort);
1108         migrate_set_block_incremental(s, false);
1109         s->must_remove_block_options = false;
1110     }
1111 }
1112
1113 static void migrate_fd_cleanup(void *opaque)
1114 {
1115     MigrationState *s = opaque;
1116
1117     qemu_bh_delete(s->cleanup_bh);
1118     s->cleanup_bh = NULL;
1119
1120     qemu_savevm_state_cleanup();
1121
1122     if (s->to_dst_file) {
1123         Error *local_err = NULL;
1124
1125         trace_migrate_fd_cleanup();
1126         qemu_mutex_unlock_iothread();
1127         if (s->migration_thread_running) {
1128             qemu_thread_join(&s->thread);
1129             s->migration_thread_running = false;
1130         }
1131         qemu_mutex_lock_iothread();
1132
1133         if (multifd_save_cleanup(&local_err) != 0) {
1134             error_report_err(local_err);
1135         }
1136         qemu_fclose(s->to_dst_file);
1137         s->to_dst_file = NULL;
1138     }
1139
1140     assert((s->state != MIGRATION_STATUS_ACTIVE) &&
1141            (s->state != MIGRATION_STATUS_POSTCOPY_ACTIVE));
1142
1143     if (s->state == MIGRATION_STATUS_CANCELLING) {
1144         migrate_set_state(&s->state, MIGRATION_STATUS_CANCELLING,
1145                           MIGRATION_STATUS_CANCELLED);
1146     }
1147
1148     if (s->error) {
1149         /* It is used on info migrate.  We can't free it */
1150         error_report_err(error_copy(s->error));
1151     }
1152     notifier_list_notify(&migration_state_notifiers, s);
1153     block_cleanup_parameters(s);
1154 }
1155
1156 void migrate_set_error(MigrationState *s, const Error *error)
1157 {
1158     qemu_mutex_lock(&s->error_mutex);
1159     if (!s->error) {
1160         s->error = error_copy(error);
1161     }
1162     qemu_mutex_unlock(&s->error_mutex);
1163 }
1164
1165 void migrate_fd_error(MigrationState *s, const Error *error)
1166 {
1167     trace_migrate_fd_error(error_get_pretty(error));
1168     assert(s->to_dst_file == NULL);
1169     migrate_set_state(&s->state, MIGRATION_STATUS_SETUP,
1170                       MIGRATION_STATUS_FAILED);
1171     migrate_set_error(s, error);
1172 }
1173
1174 static void migrate_fd_cancel(MigrationState *s)
1175 {
1176     int old_state ;
1177     QEMUFile *f = migrate_get_current()->to_dst_file;
1178     trace_migrate_fd_cancel();
1179
1180     if (s->rp_state.from_dst_file) {
1181         /* shutdown the rp socket, so causing the rp thread to shutdown */
1182         qemu_file_shutdown(s->rp_state.from_dst_file);
1183     }
1184
1185     do {
1186         old_state = s->state;
1187         if (!migration_is_setup_or_active(old_state)) {
1188             break;
1189         }
1190         /* If the migration is paused, kick it out of the pause */
1191         if (old_state == MIGRATION_STATUS_PRE_SWITCHOVER) {
1192             qemu_sem_post(&s->pause_sem);
1193         }
1194         migrate_set_state(&s->state, old_state, MIGRATION_STATUS_CANCELLING);
1195     } while (s->state != MIGRATION_STATUS_CANCELLING);
1196
1197     /*
1198      * If we're unlucky the migration code might be stuck somewhere in a
1199      * send/write while the network has failed and is waiting to timeout;
1200      * if we've got shutdown(2) available then we can force it to quit.
1201      * The outgoing qemu file gets closed in migrate_fd_cleanup that is
1202      * called in a bh, so there is no race against this cancel.
1203      */
1204     if (s->state == MIGRATION_STATUS_CANCELLING && f) {
1205         qemu_file_shutdown(f);
1206     }
1207     if (s->state == MIGRATION_STATUS_CANCELLING && s->block_inactive) {
1208         Error *local_err = NULL;
1209
1210         bdrv_invalidate_cache_all(&local_err);
1211         if (local_err) {
1212             error_report_err(local_err);
1213         } else {
1214             s->block_inactive = false;
1215         }
1216     }
1217 }
1218
1219 void add_migration_state_change_notifier(Notifier *notify)
1220 {
1221     notifier_list_add(&migration_state_notifiers, notify);
1222 }
1223
1224 void remove_migration_state_change_notifier(Notifier *notify)
1225 {
1226     notifier_remove(notify);
1227 }
1228
1229 bool migration_in_setup(MigrationState *s)
1230 {
1231     return s->state == MIGRATION_STATUS_SETUP;
1232 }
1233
1234 bool migration_has_finished(MigrationState *s)
1235 {
1236     return s->state == MIGRATION_STATUS_COMPLETED;
1237 }
1238
1239 bool migration_has_failed(MigrationState *s)
1240 {
1241     return (s->state == MIGRATION_STATUS_CANCELLED ||
1242             s->state == MIGRATION_STATUS_FAILED);
1243 }
1244
1245 bool migration_in_postcopy(void)
1246 {
1247     MigrationState *s = migrate_get_current();
1248
1249     return (s->state == MIGRATION_STATUS_POSTCOPY_ACTIVE);
1250 }
1251
1252 bool migration_in_postcopy_after_devices(MigrationState *s)
1253 {
1254     return migration_in_postcopy() && s->postcopy_after_devices;
1255 }
1256
1257 bool migration_is_idle(void)
1258 {
1259     MigrationState *s = migrate_get_current();
1260
1261     switch (s->state) {
1262     case MIGRATION_STATUS_NONE:
1263     case MIGRATION_STATUS_CANCELLED:
1264     case MIGRATION_STATUS_COMPLETED:
1265     case MIGRATION_STATUS_FAILED:
1266         return true;
1267     case MIGRATION_STATUS_SETUP:
1268     case MIGRATION_STATUS_CANCELLING:
1269     case MIGRATION_STATUS_ACTIVE:
1270     case MIGRATION_STATUS_POSTCOPY_ACTIVE:
1271     case MIGRATION_STATUS_COLO:
1272     case MIGRATION_STATUS_PRE_SWITCHOVER:
1273     case MIGRATION_STATUS_DEVICE:
1274         return false;
1275     case MIGRATION_STATUS__MAX:
1276         g_assert_not_reached();
1277     }
1278
1279     return false;
1280 }
1281
1282 void migrate_init(MigrationState *s)
1283 {
1284     /*
1285      * Reinitialise all migration state, except
1286      * parameters/capabilities that the user set, and
1287      * locks.
1288      */
1289     s->bytes_xfer = 0;
1290     s->xfer_limit = 0;
1291     s->cleanup_bh = 0;
1292     s->to_dst_file = NULL;
1293     s->state = MIGRATION_STATUS_NONE;
1294     s->rp_state.from_dst_file = NULL;
1295     s->rp_state.error = false;
1296     s->mbps = 0.0;
1297     s->downtime = 0;
1298     s->expected_downtime = 0;
1299     s->setup_time = 0;
1300     s->start_postcopy = false;
1301     s->postcopy_after_devices = false;
1302     s->migration_thread_running = false;
1303     error_free(s->error);
1304     s->error = NULL;
1305
1306     migrate_set_state(&s->state, MIGRATION_STATUS_NONE, MIGRATION_STATUS_SETUP);
1307
1308     s->start_time = qemu_clock_get_ms(QEMU_CLOCK_REALTIME);
1309     s->total_time = 0;
1310     s->vm_was_running = false;
1311     s->iteration_initial_bytes = 0;
1312     s->threshold_size = 0;
1313 }
1314
1315 static GSList *migration_blockers;
1316
1317 int migrate_add_blocker(Error *reason, Error **errp)
1318 {
1319     if (migrate_get_current()->only_migratable) {
1320         error_propagate(errp, error_copy(reason));
1321         error_prepend(errp, "disallowing migration blocker "
1322                           "(--only_migratable) for: ");
1323         return -EACCES;
1324     }
1325
1326     if (migration_is_idle()) {
1327         migration_blockers = g_slist_prepend(migration_blockers, reason);
1328         return 0;
1329     }
1330
1331     error_propagate(errp, error_copy(reason));
1332     error_prepend(errp, "disallowing migration blocker (migration in "
1333                       "progress) for: ");
1334     return -EBUSY;
1335 }
1336
1337 void migrate_del_blocker(Error *reason)
1338 {
1339     migration_blockers = g_slist_remove(migration_blockers, reason);
1340 }
1341
1342 void qmp_migrate_incoming(const char *uri, Error **errp)
1343 {
1344     Error *local_err = NULL;
1345     static bool once = true;
1346
1347     if (!deferred_incoming) {
1348         error_setg(errp, "For use with '-incoming defer'");
1349         return;
1350     }
1351     if (!once) {
1352         error_setg(errp, "The incoming migration has already been started");
1353     }
1354
1355     qemu_start_incoming_migration(uri, &local_err);
1356
1357     if (local_err) {
1358         error_propagate(errp, local_err);
1359         return;
1360     }
1361
1362     once = false;
1363 }
1364
1365 bool migration_is_blocked(Error **errp)
1366 {
1367     if (qemu_savevm_state_blocked(errp)) {
1368         return true;
1369     }
1370
1371     if (migration_blockers) {
1372         error_propagate(errp, error_copy(migration_blockers->data));
1373         return true;
1374     }
1375
1376     return false;
1377 }
1378
1379 void qmp_migrate(const char *uri, bool has_blk, bool blk,
1380                  bool has_inc, bool inc, bool has_detach, bool detach,
1381                  Error **errp)
1382 {
1383     Error *local_err = NULL;
1384     MigrationState *s = migrate_get_current();
1385     const char *p;
1386
1387     if (migration_is_setup_or_active(s->state) ||
1388         s->state == MIGRATION_STATUS_CANCELLING ||
1389         s->state == MIGRATION_STATUS_COLO) {
1390         error_setg(errp, QERR_MIGRATION_ACTIVE);
1391         return;
1392     }
1393     if (runstate_check(RUN_STATE_INMIGRATE)) {
1394         error_setg(errp, "Guest is waiting for an incoming migration");
1395         return;
1396     }
1397
1398     if (migration_is_blocked(errp)) {
1399         return;
1400     }
1401
1402     if ((has_blk && blk) || (has_inc && inc)) {
1403         if (migrate_use_block() || migrate_use_block_incremental()) {
1404             error_setg(errp, "Command options are incompatible with "
1405                        "current migration capabilities");
1406             return;
1407         }
1408         migrate_set_block_enabled(true, &local_err);
1409         if (local_err) {
1410             error_propagate(errp, local_err);
1411             return;
1412         }
1413         s->must_remove_block_options = true;
1414     }
1415
1416     if (has_inc && inc) {
1417         migrate_set_block_incremental(s, true);
1418     }
1419
1420     migrate_init(s);
1421
1422     if (strstart(uri, "tcp:", &p)) {
1423         tcp_start_outgoing_migration(s, p, &local_err);
1424 #ifdef CONFIG_RDMA
1425     } else if (strstart(uri, "rdma:", &p)) {
1426         rdma_start_outgoing_migration(s, p, &local_err);
1427 #endif
1428     } else if (strstart(uri, "exec:", &p)) {
1429         exec_start_outgoing_migration(s, p, &local_err);
1430     } else if (strstart(uri, "unix:", &p)) {
1431         unix_start_outgoing_migration(s, p, &local_err);
1432     } else if (strstart(uri, "fd:", &p)) {
1433         fd_start_outgoing_migration(s, p, &local_err);
1434     } else {
1435         error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "uri",
1436                    "a valid migration protocol");
1437         migrate_set_state(&s->state, MIGRATION_STATUS_SETUP,
1438                           MIGRATION_STATUS_FAILED);
1439         block_cleanup_parameters(s);
1440         return;
1441     }
1442
1443     if (local_err) {
1444         migrate_fd_error(s, local_err);
1445         error_propagate(errp, local_err);
1446         return;
1447     }
1448 }
1449
1450 void qmp_migrate_cancel(Error **errp)
1451 {
1452     migrate_fd_cancel(migrate_get_current());
1453 }
1454
1455 void qmp_migrate_continue(MigrationStatus state, Error **errp)
1456 {
1457     MigrationState *s = migrate_get_current();
1458     if (s->state != state) {
1459         error_setg(errp,  "Migration not in expected state: %s",
1460                    MigrationStatus_str(s->state));
1461         return;
1462     }
1463     qemu_sem_post(&s->pause_sem);
1464 }
1465
1466 void qmp_migrate_set_cache_size(int64_t value, Error **errp)
1467 {
1468     MigrateSetParameters p = {
1469         .has_xbzrle_cache_size = true,
1470         .xbzrle_cache_size = value,
1471     };
1472
1473     qmp_migrate_set_parameters(&p, errp);
1474 }
1475
1476 int64_t qmp_query_migrate_cache_size(Error **errp)
1477 {
1478     return migrate_xbzrle_cache_size();
1479 }
1480
1481 void qmp_migrate_set_speed(int64_t value, Error **errp)
1482 {
1483     MigrateSetParameters p = {
1484         .has_max_bandwidth = true,
1485         .max_bandwidth = value,
1486     };
1487
1488     qmp_migrate_set_parameters(&p, errp);
1489 }
1490
1491 void qmp_migrate_set_downtime(double value, Error **errp)
1492 {
1493     if (value < 0 || value > MAX_MIGRATE_DOWNTIME_SECONDS) {
1494         error_setg(errp, "Parameter 'downtime_limit' expects an integer in "
1495                          "the range of 0 to %d seconds",
1496                          MAX_MIGRATE_DOWNTIME_SECONDS);
1497         return;
1498     }
1499
1500     value *= 1000; /* Convert to milliseconds */
1501     value = MAX(0, MIN(INT64_MAX, value));
1502
1503     MigrateSetParameters p = {
1504         .has_downtime_limit = true,
1505         .downtime_limit = value,
1506     };
1507
1508     qmp_migrate_set_parameters(&p, errp);
1509 }
1510
1511 bool migrate_release_ram(void)
1512 {
1513     MigrationState *s;
1514
1515     s = migrate_get_current();
1516
1517     return s->enabled_capabilities[MIGRATION_CAPABILITY_RELEASE_RAM];
1518 }
1519
1520 bool migrate_postcopy_ram(void)
1521 {
1522     MigrationState *s;
1523
1524     s = migrate_get_current();
1525
1526     return s->enabled_capabilities[MIGRATION_CAPABILITY_POSTCOPY_RAM];
1527 }
1528
1529 bool migrate_postcopy(void)
1530 {
1531     return migrate_postcopy_ram() || migrate_dirty_bitmaps();
1532 }
1533
1534 bool migrate_auto_converge(void)
1535 {
1536     MigrationState *s;
1537
1538     s = migrate_get_current();
1539
1540     return s->enabled_capabilities[MIGRATION_CAPABILITY_AUTO_CONVERGE];
1541 }
1542
1543 bool migrate_zero_blocks(void)
1544 {
1545     MigrationState *s;
1546
1547     s = migrate_get_current();
1548
1549     return s->enabled_capabilities[MIGRATION_CAPABILITY_ZERO_BLOCKS];
1550 }
1551
1552 bool migrate_use_compression(void)
1553 {
1554     MigrationState *s;
1555
1556     s = migrate_get_current();
1557
1558     return s->enabled_capabilities[MIGRATION_CAPABILITY_COMPRESS];
1559 }
1560
1561 int migrate_compress_level(void)
1562 {
1563     MigrationState *s;
1564
1565     s = migrate_get_current();
1566
1567     return s->parameters.compress_level;
1568 }
1569
1570 int migrate_compress_threads(void)
1571 {
1572     MigrationState *s;
1573
1574     s = migrate_get_current();
1575
1576     return s->parameters.compress_threads;
1577 }
1578
1579 int migrate_decompress_threads(void)
1580 {
1581     MigrationState *s;
1582
1583     s = migrate_get_current();
1584
1585     return s->parameters.decompress_threads;
1586 }
1587
1588 bool migrate_dirty_bitmaps(void)
1589 {
1590     MigrationState *s;
1591
1592     s = migrate_get_current();
1593
1594     return s->enabled_capabilities[MIGRATION_CAPABILITY_DIRTY_BITMAPS];
1595 }
1596
1597 bool migrate_use_events(void)
1598 {
1599     MigrationState *s;
1600
1601     s = migrate_get_current();
1602
1603     return s->enabled_capabilities[MIGRATION_CAPABILITY_EVENTS];
1604 }
1605
1606 bool migrate_use_multifd(void)
1607 {
1608     MigrationState *s;
1609
1610     s = migrate_get_current();
1611
1612     return s->enabled_capabilities[MIGRATION_CAPABILITY_X_MULTIFD];
1613 }
1614
1615 bool migrate_pause_before_switchover(void)
1616 {
1617     MigrationState *s;
1618
1619     s = migrate_get_current();
1620
1621     return s->enabled_capabilities[
1622         MIGRATION_CAPABILITY_PAUSE_BEFORE_SWITCHOVER];
1623 }
1624
1625 int migrate_multifd_channels(void)
1626 {
1627     MigrationState *s;
1628
1629     s = migrate_get_current();
1630
1631     return s->parameters.x_multifd_channels;
1632 }
1633
1634 int migrate_multifd_page_count(void)
1635 {
1636     MigrationState *s;
1637
1638     s = migrate_get_current();
1639
1640     return s->parameters.x_multifd_page_count;
1641 }
1642
1643 int migrate_use_xbzrle(void)
1644 {
1645     MigrationState *s;
1646
1647     s = migrate_get_current();
1648
1649     return s->enabled_capabilities[MIGRATION_CAPABILITY_XBZRLE];
1650 }
1651
1652 int64_t migrate_xbzrle_cache_size(void)
1653 {
1654     MigrationState *s;
1655
1656     s = migrate_get_current();
1657
1658     return s->parameters.xbzrle_cache_size;
1659 }
1660
1661 bool migrate_use_block(void)
1662 {
1663     MigrationState *s;
1664
1665     s = migrate_get_current();
1666
1667     return s->enabled_capabilities[MIGRATION_CAPABILITY_BLOCK];
1668 }
1669
1670 bool migrate_use_return_path(void)
1671 {
1672     MigrationState *s;
1673
1674     s = migrate_get_current();
1675
1676     return s->enabled_capabilities[MIGRATION_CAPABILITY_RETURN_PATH];
1677 }
1678
1679 bool migrate_use_block_incremental(void)
1680 {
1681     MigrationState *s;
1682
1683     s = migrate_get_current();
1684
1685     return s->parameters.block_incremental;
1686 }
1687
1688 /* migration thread support */
1689 /*
1690  * Something bad happened to the RP stream, mark an error
1691  * The caller shall print or trace something to indicate why
1692  */
1693 static void mark_source_rp_bad(MigrationState *s)
1694 {
1695     s->rp_state.error = true;
1696 }
1697
1698 static struct rp_cmd_args {
1699     ssize_t     len; /* -1 = variable */
1700     const char *name;
1701 } rp_cmd_args[] = {
1702     [MIG_RP_MSG_INVALID]        = { .len = -1, .name = "INVALID" },
1703     [MIG_RP_MSG_SHUT]           = { .len =  4, .name = "SHUT" },
1704     [MIG_RP_MSG_PONG]           = { .len =  4, .name = "PONG" },
1705     [MIG_RP_MSG_REQ_PAGES]      = { .len = 12, .name = "REQ_PAGES" },
1706     [MIG_RP_MSG_REQ_PAGES_ID]   = { .len = -1, .name = "REQ_PAGES_ID" },
1707     [MIG_RP_MSG_MAX]            = { .len = -1, .name = "MAX" },
1708 };
1709
1710 /*
1711  * Process a request for pages received on the return path,
1712  * We're allowed to send more than requested (e.g. to round to our page size)
1713  * and we don't need to send pages that have already been sent.
1714  */
1715 static void migrate_handle_rp_req_pages(MigrationState *ms, const char* rbname,
1716                                        ram_addr_t start, size_t len)
1717 {
1718     long our_host_ps = getpagesize();
1719
1720     trace_migrate_handle_rp_req_pages(rbname, start, len);
1721
1722     /*
1723      * Since we currently insist on matching page sizes, just sanity check
1724      * we're being asked for whole host pages.
1725      */
1726     if (start & (our_host_ps-1) ||
1727        (len & (our_host_ps-1))) {
1728         error_report("%s: Misaligned page request, start: " RAM_ADDR_FMT
1729                      " len: %zd", __func__, start, len);
1730         mark_source_rp_bad(ms);
1731         return;
1732     }
1733
1734     if (ram_save_queue_pages(rbname, start, len)) {
1735         mark_source_rp_bad(ms);
1736     }
1737 }
1738
1739 /*
1740  * Handles messages sent on the return path towards the source VM
1741  *
1742  */
1743 static void *source_return_path_thread(void *opaque)
1744 {
1745     MigrationState *ms = opaque;
1746     QEMUFile *rp = ms->rp_state.from_dst_file;
1747     uint16_t header_len, header_type;
1748     uint8_t buf[512];
1749     uint32_t tmp32, sibling_error;
1750     ram_addr_t start = 0; /* =0 to silence warning */
1751     size_t  len = 0, expected_len;
1752     int res;
1753
1754     trace_source_return_path_thread_entry();
1755     while (!ms->rp_state.error && !qemu_file_get_error(rp) &&
1756            migration_is_setup_or_active(ms->state)) {
1757         trace_source_return_path_thread_loop_top();
1758         header_type = qemu_get_be16(rp);
1759         header_len = qemu_get_be16(rp);
1760
1761         if (qemu_file_get_error(rp)) {
1762             mark_source_rp_bad(ms);
1763             goto out;
1764         }
1765
1766         if (header_type >= MIG_RP_MSG_MAX ||
1767             header_type == MIG_RP_MSG_INVALID) {
1768             error_report("RP: Received invalid message 0x%04x length 0x%04x",
1769                     header_type, header_len);
1770             mark_source_rp_bad(ms);
1771             goto out;
1772         }
1773
1774         if ((rp_cmd_args[header_type].len != -1 &&
1775             header_len != rp_cmd_args[header_type].len) ||
1776             header_len > sizeof(buf)) {
1777             error_report("RP: Received '%s' message (0x%04x) with"
1778                     "incorrect length %d expecting %zu",
1779                     rp_cmd_args[header_type].name, header_type, header_len,
1780                     (size_t)rp_cmd_args[header_type].len);
1781             mark_source_rp_bad(ms);
1782             goto out;
1783         }
1784
1785         /* We know we've got a valid header by this point */
1786         res = qemu_get_buffer(rp, buf, header_len);
1787         if (res != header_len) {
1788             error_report("RP: Failed reading data for message 0x%04x"
1789                          " read %d expected %d",
1790                          header_type, res, header_len);
1791             mark_source_rp_bad(ms);
1792             goto out;
1793         }
1794
1795         /* OK, we have the message and the data */
1796         switch (header_type) {
1797         case MIG_RP_MSG_SHUT:
1798             sibling_error = ldl_be_p(buf);
1799             trace_source_return_path_thread_shut(sibling_error);
1800             if (sibling_error) {
1801                 error_report("RP: Sibling indicated error %d", sibling_error);
1802                 mark_source_rp_bad(ms);
1803             }
1804             /*
1805              * We'll let the main thread deal with closing the RP
1806              * we could do a shutdown(2) on it, but we're the only user
1807              * anyway, so there's nothing gained.
1808              */
1809             goto out;
1810
1811         case MIG_RP_MSG_PONG:
1812             tmp32 = ldl_be_p(buf);
1813             trace_source_return_path_thread_pong(tmp32);
1814             break;
1815
1816         case MIG_RP_MSG_REQ_PAGES:
1817             start = ldq_be_p(buf);
1818             len = ldl_be_p(buf + 8);
1819             migrate_handle_rp_req_pages(ms, NULL, start, len);
1820             break;
1821
1822         case MIG_RP_MSG_REQ_PAGES_ID:
1823             expected_len = 12 + 1; /* header + termination */
1824
1825             if (header_len >= expected_len) {
1826                 start = ldq_be_p(buf);
1827                 len = ldl_be_p(buf + 8);
1828                 /* Now we expect an idstr */
1829                 tmp32 = buf[12]; /* Length of the following idstr */
1830                 buf[13 + tmp32] = '\0';
1831                 expected_len += tmp32;
1832             }
1833             if (header_len != expected_len) {
1834                 error_report("RP: Req_Page_id with length %d expecting %zd",
1835                         header_len, expected_len);
1836                 mark_source_rp_bad(ms);
1837                 goto out;
1838             }
1839             migrate_handle_rp_req_pages(ms, (char *)&buf[13], start, len);
1840             break;
1841
1842         default:
1843             break;
1844         }
1845     }
1846     if (qemu_file_get_error(rp)) {
1847         trace_source_return_path_thread_bad_end();
1848         mark_source_rp_bad(ms);
1849     }
1850
1851     trace_source_return_path_thread_end();
1852 out:
1853     ms->rp_state.from_dst_file = NULL;
1854     qemu_fclose(rp);
1855     return NULL;
1856 }
1857
1858 static int open_return_path_on_source(MigrationState *ms)
1859 {
1860
1861     ms->rp_state.from_dst_file = qemu_file_get_return_path(ms->to_dst_file);
1862     if (!ms->rp_state.from_dst_file) {
1863         return -1;
1864     }
1865
1866     trace_open_return_path_on_source();
1867     qemu_thread_create(&ms->rp_state.rp_thread, "return path",
1868                        source_return_path_thread, ms, QEMU_THREAD_JOINABLE);
1869
1870     trace_open_return_path_on_source_continue();
1871
1872     return 0;
1873 }
1874
1875 /* Returns 0 if the RP was ok, otherwise there was an error on the RP */
1876 static int await_return_path_close_on_source(MigrationState *ms)
1877 {
1878     /*
1879      * If this is a normal exit then the destination will send a SHUT and the
1880      * rp_thread will exit, however if there's an error we need to cause
1881      * it to exit.
1882      */
1883     if (qemu_file_get_error(ms->to_dst_file) && ms->rp_state.from_dst_file) {
1884         /*
1885          * shutdown(2), if we have it, will cause it to unblock if it's stuck
1886          * waiting for the destination.
1887          */
1888         qemu_file_shutdown(ms->rp_state.from_dst_file);
1889         mark_source_rp_bad(ms);
1890     }
1891     trace_await_return_path_close_on_source_joining();
1892     qemu_thread_join(&ms->rp_state.rp_thread);
1893     trace_await_return_path_close_on_source_close();
1894     return ms->rp_state.error;
1895 }
1896
1897 /*
1898  * Switch from normal iteration to postcopy
1899  * Returns non-0 on error
1900  */
1901 static int postcopy_start(MigrationState *ms)
1902 {
1903     int ret;
1904     QIOChannelBuffer *bioc;
1905     QEMUFile *fb;
1906     int64_t time_at_stop = qemu_clock_get_ms(QEMU_CLOCK_REALTIME);
1907     bool restart_block = false;
1908     int cur_state = MIGRATION_STATUS_ACTIVE;
1909     if (!migrate_pause_before_switchover()) {
1910         migrate_set_state(&ms->state, MIGRATION_STATUS_ACTIVE,
1911                           MIGRATION_STATUS_POSTCOPY_ACTIVE);
1912     }
1913
1914     trace_postcopy_start();
1915     qemu_mutex_lock_iothread();
1916     trace_postcopy_start_set_run();
1917
1918     qemu_system_wakeup_request(QEMU_WAKEUP_REASON_OTHER);
1919     global_state_store();
1920     ret = vm_stop_force_state(RUN_STATE_FINISH_MIGRATE);
1921     if (ret < 0) {
1922         goto fail;
1923     }
1924
1925     ret = migration_maybe_pause(ms, &cur_state,
1926                                 MIGRATION_STATUS_POSTCOPY_ACTIVE);
1927     if (ret < 0) {
1928         goto fail;
1929     }
1930
1931     ret = bdrv_inactivate_all();
1932     if (ret < 0) {
1933         goto fail;
1934     }
1935     restart_block = true;
1936
1937     /*
1938      * Cause any non-postcopiable, but iterative devices to
1939      * send out their final data.
1940      */
1941     qemu_savevm_state_complete_precopy(ms->to_dst_file, true, false);
1942
1943     /*
1944      * in Finish migrate and with the io-lock held everything should
1945      * be quiet, but we've potentially still got dirty pages and we
1946      * need to tell the destination to throw any pages it's already received
1947      * that are dirty
1948      */
1949     if (migrate_postcopy_ram()) {
1950         if (ram_postcopy_send_discard_bitmap(ms)) {
1951             error_report("postcopy send discard bitmap failed");
1952             goto fail;
1953         }
1954     }
1955
1956     /*
1957      * send rest of state - note things that are doing postcopy
1958      * will notice we're in POSTCOPY_ACTIVE and not actually
1959      * wrap their state up here
1960      */
1961     qemu_file_set_rate_limit(ms->to_dst_file, INT64_MAX);
1962     if (migrate_postcopy_ram()) {
1963         /* Ping just for debugging, helps line traces up */
1964         qemu_savevm_send_ping(ms->to_dst_file, 2);
1965     }
1966
1967     /*
1968      * While loading the device state we may trigger page transfer
1969      * requests and the fd must be free to process those, and thus
1970      * the destination must read the whole device state off the fd before
1971      * it starts processing it.  Unfortunately the ad-hoc migration format
1972      * doesn't allow the destination to know the size to read without fully
1973      * parsing it through each devices load-state code (especially the open
1974      * coded devices that use get/put).
1975      * So we wrap the device state up in a package with a length at the start;
1976      * to do this we use a qemu_buf to hold the whole of the device state.
1977      */
1978     bioc = qio_channel_buffer_new(4096);
1979     qio_channel_set_name(QIO_CHANNEL(bioc), "migration-postcopy-buffer");
1980     fb = qemu_fopen_channel_output(QIO_CHANNEL(bioc));
1981     object_unref(OBJECT(bioc));
1982
1983     /*
1984      * Make sure the receiver can get incoming pages before we send the rest
1985      * of the state
1986      */
1987     qemu_savevm_send_postcopy_listen(fb);
1988
1989     qemu_savevm_state_complete_precopy(fb, false, false);
1990     if (migrate_postcopy_ram()) {
1991         qemu_savevm_send_ping(fb, 3);
1992     }
1993
1994     qemu_savevm_send_postcopy_run(fb);
1995
1996     /* <><> end of stuff going into the package */
1997
1998     /* Last point of recovery; as soon as we send the package the destination
1999      * can open devices and potentially start running.
2000      * Lets just check again we've not got any errors.
2001      */
2002     ret = qemu_file_get_error(ms->to_dst_file);
2003     if (ret) {
2004         error_report("postcopy_start: Migration stream errored (pre package)");
2005         goto fail_closefb;
2006     }
2007
2008     restart_block = false;
2009
2010     /* Now send that blob */
2011     if (qemu_savevm_send_packaged(ms->to_dst_file, bioc->data, bioc->usage)) {
2012         goto fail_closefb;
2013     }
2014     qemu_fclose(fb);
2015
2016     /* Send a notify to give a chance for anything that needs to happen
2017      * at the transition to postcopy and after the device state; in particular
2018      * spice needs to trigger a transition now
2019      */
2020     ms->postcopy_after_devices = true;
2021     notifier_list_notify(&migration_state_notifiers, ms);
2022
2023     ms->downtime =  qemu_clock_get_ms(QEMU_CLOCK_REALTIME) - time_at_stop;
2024
2025     qemu_mutex_unlock_iothread();
2026
2027     if (migrate_postcopy_ram()) {
2028         /*
2029          * Although this ping is just for debug, it could potentially be
2030          * used for getting a better measurement of downtime at the source.
2031          */
2032         qemu_savevm_send_ping(ms->to_dst_file, 4);
2033     }
2034
2035     if (migrate_release_ram()) {
2036         ram_postcopy_migrated_memory_release(ms);
2037     }
2038
2039     ret = qemu_file_get_error(ms->to_dst_file);
2040     if (ret) {
2041         error_report("postcopy_start: Migration stream errored");
2042         migrate_set_state(&ms->state, MIGRATION_STATUS_POSTCOPY_ACTIVE,
2043                               MIGRATION_STATUS_FAILED);
2044     }
2045
2046     return ret;
2047
2048 fail_closefb:
2049     qemu_fclose(fb);
2050 fail:
2051     migrate_set_state(&ms->state, MIGRATION_STATUS_POSTCOPY_ACTIVE,
2052                           MIGRATION_STATUS_FAILED);
2053     if (restart_block) {
2054         /* A failure happened early enough that we know the destination hasn't
2055          * accessed block devices, so we're safe to recover.
2056          */
2057         Error *local_err = NULL;
2058
2059         bdrv_invalidate_cache_all(&local_err);
2060         if (local_err) {
2061             error_report_err(local_err);
2062         }
2063     }
2064     qemu_mutex_unlock_iothread();
2065     return -1;
2066 }
2067
2068 /**
2069  * migration_maybe_pause: Pause if required to by
2070  * migrate_pause_before_switchover called with the iothread locked
2071  * Returns: 0 on success
2072  */
2073 static int migration_maybe_pause(MigrationState *s,
2074                                  int *current_active_state,
2075                                  int new_state)
2076 {
2077     if (!migrate_pause_before_switchover()) {
2078         return 0;
2079     }
2080
2081     /* Since leaving this state is not atomic with posting the semaphore
2082      * it's possible that someone could have issued multiple migrate_continue
2083      * and the semaphore is incorrectly positive at this point;
2084      * the docs say it's undefined to reinit a semaphore that's already
2085      * init'd, so use timedwait to eat up any existing posts.
2086      */
2087     while (qemu_sem_timedwait(&s->pause_sem, 1) == 0) {
2088         /* This block intentionally left blank */
2089     }
2090
2091     qemu_mutex_unlock_iothread();
2092     migrate_set_state(&s->state, *current_active_state,
2093                       MIGRATION_STATUS_PRE_SWITCHOVER);
2094     qemu_sem_wait(&s->pause_sem);
2095     migrate_set_state(&s->state, MIGRATION_STATUS_PRE_SWITCHOVER,
2096                       new_state);
2097     *current_active_state = new_state;
2098     qemu_mutex_lock_iothread();
2099
2100     return s->state == new_state ? 0 : -EINVAL;
2101 }
2102
2103 /**
2104  * migration_completion: Used by migration_thread when there's not much left.
2105  *   The caller 'breaks' the loop when this returns.
2106  *
2107  * @s: Current migration state
2108  */
2109 static void migration_completion(MigrationState *s)
2110 {
2111     int ret;
2112     int current_active_state = s->state;
2113
2114     if (s->state == MIGRATION_STATUS_ACTIVE) {
2115         qemu_mutex_lock_iothread();
2116         s->downtime_start = qemu_clock_get_ms(QEMU_CLOCK_REALTIME);
2117         qemu_system_wakeup_request(QEMU_WAKEUP_REASON_OTHER);
2118         s->vm_was_running = runstate_is_running();
2119         ret = global_state_store();
2120
2121         if (!ret) {
2122             bool inactivate = !migrate_colo_enabled();
2123             ret = vm_stop_force_state(RUN_STATE_FINISH_MIGRATE);
2124             if (ret >= 0) {
2125                 ret = migration_maybe_pause(s, &current_active_state,
2126                                             MIGRATION_STATUS_DEVICE);
2127             }
2128             if (ret >= 0) {
2129                 qemu_file_set_rate_limit(s->to_dst_file, INT64_MAX);
2130                 ret = qemu_savevm_state_complete_precopy(s->to_dst_file, false,
2131                                                          inactivate);
2132             }
2133             if (inactivate && ret >= 0) {
2134                 s->block_inactive = true;
2135             }
2136         }
2137         qemu_mutex_unlock_iothread();
2138
2139         if (ret < 0) {
2140             goto fail;
2141         }
2142     } else if (s->state == MIGRATION_STATUS_POSTCOPY_ACTIVE) {
2143         trace_migration_completion_postcopy_end();
2144
2145         qemu_savevm_state_complete_postcopy(s->to_dst_file);
2146         trace_migration_completion_postcopy_end_after_complete();
2147     }
2148
2149     /*
2150      * If rp was opened we must clean up the thread before
2151      * cleaning everything else up (since if there are no failures
2152      * it will wait for the destination to send it's status in
2153      * a SHUT command).
2154      */
2155     if (s->rp_state.from_dst_file) {
2156         int rp_error;
2157         trace_migration_return_path_end_before();
2158         rp_error = await_return_path_close_on_source(s);
2159         trace_migration_return_path_end_after(rp_error);
2160         if (rp_error) {
2161             goto fail_invalidate;
2162         }
2163     }
2164
2165     if (qemu_file_get_error(s->to_dst_file)) {
2166         trace_migration_completion_file_err();
2167         goto fail_invalidate;
2168     }
2169
2170     if (!migrate_colo_enabled()) {
2171         migrate_set_state(&s->state, current_active_state,
2172                           MIGRATION_STATUS_COMPLETED);
2173     }
2174
2175     return;
2176
2177 fail_invalidate:
2178     /* If not doing postcopy, vm_start() will be called: let's regain
2179      * control on images.
2180      */
2181     if (s->state == MIGRATION_STATUS_ACTIVE ||
2182         s->state == MIGRATION_STATUS_DEVICE) {
2183         Error *local_err = NULL;
2184
2185         qemu_mutex_lock_iothread();
2186         bdrv_invalidate_cache_all(&local_err);
2187         if (local_err) {
2188             error_report_err(local_err);
2189         } else {
2190             s->block_inactive = false;
2191         }
2192         qemu_mutex_unlock_iothread();
2193     }
2194
2195 fail:
2196     migrate_set_state(&s->state, current_active_state,
2197                       MIGRATION_STATUS_FAILED);
2198 }
2199
2200 bool migrate_colo_enabled(void)
2201 {
2202     MigrationState *s = migrate_get_current();
2203     return s->enabled_capabilities[MIGRATION_CAPABILITY_X_COLO];
2204 }
2205
2206 static void migration_calculate_complete(MigrationState *s)
2207 {
2208     uint64_t bytes = qemu_ftell(s->to_dst_file);
2209     int64_t end_time = qemu_clock_get_ms(QEMU_CLOCK_REALTIME);
2210
2211     s->total_time = end_time - s->start_time;
2212     if (!s->downtime) {
2213         /*
2214          * It's still not set, so we are precopy migration.  For
2215          * postcopy, downtime is calculated during postcopy_start().
2216          */
2217         s->downtime = end_time - s->downtime_start;
2218     }
2219
2220     if (s->total_time) {
2221         s->mbps = ((double) bytes * 8.0) / s->total_time / 1000;
2222     }
2223 }
2224
2225 static void migration_update_counters(MigrationState *s,
2226                                       int64_t current_time)
2227 {
2228     uint64_t transferred, time_spent;
2229     double bandwidth;
2230
2231     if (current_time < s->iteration_start_time + BUFFER_DELAY) {
2232         return;
2233     }
2234
2235     transferred = qemu_ftell(s->to_dst_file) - s->iteration_initial_bytes;
2236     time_spent = current_time - s->iteration_start_time;
2237     bandwidth = (double)transferred / time_spent;
2238     s->threshold_size = bandwidth * s->parameters.downtime_limit;
2239
2240     s->mbps = (((double) transferred * 8.0) /
2241                ((double) time_spent / 1000.0)) / 1000.0 / 1000.0;
2242
2243     /*
2244      * if we haven't sent anything, we don't want to
2245      * recalculate. 10000 is a small enough number for our purposes
2246      */
2247     if (ram_counters.dirty_pages_rate && transferred > 10000) {
2248         s->expected_downtime = ram_counters.dirty_pages_rate *
2249             qemu_target_page_size() / bandwidth;
2250     }
2251
2252     qemu_file_reset_rate_limit(s->to_dst_file);
2253
2254     s->iteration_start_time = current_time;
2255     s->iteration_initial_bytes = qemu_ftell(s->to_dst_file);
2256
2257     trace_migrate_transferred(transferred, time_spent,
2258                               bandwidth, s->threshold_size);
2259 }
2260
2261 /* Migration thread iteration status */
2262 typedef enum {
2263     MIG_ITERATE_RESUME,         /* Resume current iteration */
2264     MIG_ITERATE_SKIP,           /* Skip current iteration */
2265     MIG_ITERATE_BREAK,          /* Break the loop */
2266 } MigIterateState;
2267
2268 /*
2269  * Return true if continue to the next iteration directly, false
2270  * otherwise.
2271  */
2272 static MigIterateState migration_iteration_run(MigrationState *s)
2273 {
2274     uint64_t pending_size, pend_pre, pend_compat, pend_post;
2275     bool in_postcopy = s->state == MIGRATION_STATUS_POSTCOPY_ACTIVE;
2276
2277     qemu_savevm_state_pending(s->to_dst_file, s->threshold_size, &pend_pre,
2278                               &pend_compat, &pend_post);
2279     pending_size = pend_pre + pend_compat + pend_post;
2280
2281     trace_migrate_pending(pending_size, s->threshold_size,
2282                           pend_pre, pend_compat, pend_post);
2283
2284     if (pending_size && pending_size >= s->threshold_size) {
2285         /* Still a significant amount to transfer */
2286         if (migrate_postcopy() && !in_postcopy &&
2287             pend_pre <= s->threshold_size &&
2288             atomic_read(&s->start_postcopy)) {
2289             if (postcopy_start(s)) {
2290                 error_report("%s: postcopy failed to start", __func__);
2291             }
2292             return MIG_ITERATE_SKIP;
2293         }
2294         /* Just another iteration step */
2295         qemu_savevm_state_iterate(s->to_dst_file,
2296             s->state == MIGRATION_STATUS_POSTCOPY_ACTIVE);
2297     } else {
2298         trace_migration_thread_low_pending(pending_size);
2299         migration_completion(s);
2300         return MIG_ITERATE_BREAK;
2301     }
2302
2303     return MIG_ITERATE_RESUME;
2304 }
2305
2306 static void migration_iteration_finish(MigrationState *s)
2307 {
2308     /* If we enabled cpu throttling for auto-converge, turn it off. */
2309     cpu_throttle_stop();
2310
2311     qemu_mutex_lock_iothread();
2312     switch (s->state) {
2313     case MIGRATION_STATUS_COMPLETED:
2314         migration_calculate_complete(s);
2315         runstate_set(RUN_STATE_POSTMIGRATE);
2316         break;
2317
2318     case MIGRATION_STATUS_ACTIVE:
2319         /*
2320          * We should really assert here, but since it's during
2321          * migration, let's try to reduce the usage of assertions.
2322          */
2323         if (!migrate_colo_enabled()) {
2324             error_report("%s: critical error: calling COLO code without "
2325                          "COLO enabled", __func__);
2326         }
2327         migrate_start_colo_process(s);
2328         /*
2329          * Fixme: we will run VM in COLO no matter its old running state.
2330          * After exited COLO, we will keep running.
2331          */
2332         s->vm_was_running = true;
2333         /* Fallthrough */
2334     case MIGRATION_STATUS_FAILED:
2335     case MIGRATION_STATUS_CANCELLED:
2336         if (s->vm_was_running) {
2337             vm_start();
2338         } else {
2339             if (runstate_check(RUN_STATE_FINISH_MIGRATE)) {
2340                 runstate_set(RUN_STATE_POSTMIGRATE);
2341             }
2342         }
2343         break;
2344
2345     default:
2346         /* Should not reach here, but if so, forgive the VM. */
2347         error_report("%s: Unknown ending state %d", __func__, s->state);
2348         break;
2349     }
2350     qemu_bh_schedule(s->cleanup_bh);
2351     qemu_mutex_unlock_iothread();
2352 }
2353
2354 /*
2355  * Master migration thread on the source VM.
2356  * It drives the migration and pumps the data down the outgoing channel.
2357  */
2358 static void *migration_thread(void *opaque)
2359 {
2360     MigrationState *s = opaque;
2361     int64_t setup_start = qemu_clock_get_ms(QEMU_CLOCK_HOST);
2362
2363     rcu_register_thread();
2364
2365     s->iteration_start_time = qemu_clock_get_ms(QEMU_CLOCK_REALTIME);
2366
2367     qemu_savevm_state_header(s->to_dst_file);
2368
2369     /*
2370      * If we opened the return path, we need to make sure dst has it
2371      * opened as well.
2372      */
2373     if (s->rp_state.from_dst_file) {
2374         /* Now tell the dest that it should open its end so it can reply */
2375         qemu_savevm_send_open_return_path(s->to_dst_file);
2376
2377         /* And do a ping that will make stuff easier to debug */
2378         qemu_savevm_send_ping(s->to_dst_file, 1);
2379     }
2380
2381     if (migrate_postcopy()) {
2382         /*
2383          * Tell the destination that we *might* want to do postcopy later;
2384          * if the other end can't do postcopy it should fail now, nice and
2385          * early.
2386          */
2387         qemu_savevm_send_postcopy_advise(s->to_dst_file);
2388     }
2389
2390     qemu_savevm_state_setup(s->to_dst_file);
2391
2392     s->setup_time = qemu_clock_get_ms(QEMU_CLOCK_HOST) - setup_start;
2393     migrate_set_state(&s->state, MIGRATION_STATUS_SETUP,
2394                       MIGRATION_STATUS_ACTIVE);
2395
2396     trace_migration_thread_setup_complete();
2397
2398     while (s->state == MIGRATION_STATUS_ACTIVE ||
2399            s->state == MIGRATION_STATUS_POSTCOPY_ACTIVE) {
2400         int64_t current_time;
2401
2402         if (!qemu_file_rate_limit(s->to_dst_file)) {
2403             MigIterateState iter_state = migration_iteration_run(s);
2404             if (iter_state == MIG_ITERATE_SKIP) {
2405                 continue;
2406             } else if (iter_state == MIG_ITERATE_BREAK) {
2407                 break;
2408             }
2409         }
2410
2411         if (qemu_file_get_error(s->to_dst_file)) {
2412             if (migration_is_setup_or_active(s->state)) {
2413                 migrate_set_state(&s->state, s->state,
2414                                   MIGRATION_STATUS_FAILED);
2415             }
2416             trace_migration_thread_file_err();
2417             break;
2418         }
2419
2420         current_time = qemu_clock_get_ms(QEMU_CLOCK_REALTIME);
2421
2422         migration_update_counters(s, current_time);
2423
2424         if (qemu_file_rate_limit(s->to_dst_file)) {
2425             /* usleep expects microseconds */
2426             g_usleep((s->iteration_start_time + BUFFER_DELAY -
2427                       current_time) * 1000);
2428         }
2429     }
2430
2431     trace_migration_thread_after_loop();
2432     migration_iteration_finish(s);
2433     rcu_unregister_thread();
2434     return NULL;
2435 }
2436
2437 void migrate_fd_connect(MigrationState *s, Error *error_in)
2438 {
2439     s->expected_downtime = s->parameters.downtime_limit;
2440     s->cleanup_bh = qemu_bh_new(migrate_fd_cleanup, s);
2441     if (error_in) {
2442         migrate_fd_error(s, error_in);
2443         migrate_fd_cleanup(s);
2444         return;
2445     }
2446
2447     qemu_file_set_blocking(s->to_dst_file, true);
2448     qemu_file_set_rate_limit(s->to_dst_file,
2449                              s->parameters.max_bandwidth / XFER_LIMIT_RATIO);
2450
2451     /* Notify before starting migration thread */
2452     notifier_list_notify(&migration_state_notifiers, s);
2453
2454     /*
2455      * Open the return path. For postcopy, it is used exclusively. For
2456      * precopy, only if user specified "return-path" capability would
2457      * QEMU uses the return path.
2458      */
2459     if (migrate_postcopy_ram() || migrate_use_return_path()) {
2460         if (open_return_path_on_source(s)) {
2461             error_report("Unable to open return-path for postcopy");
2462             migrate_set_state(&s->state, MIGRATION_STATUS_SETUP,
2463                               MIGRATION_STATUS_FAILED);
2464             migrate_fd_cleanup(s);
2465             return;
2466         }
2467     }
2468
2469     if (multifd_save_setup() != 0) {
2470         migrate_set_state(&s->state, MIGRATION_STATUS_SETUP,
2471                           MIGRATION_STATUS_FAILED);
2472         migrate_fd_cleanup(s);
2473         return;
2474     }
2475     qemu_thread_create(&s->thread, "live_migration", migration_thread, s,
2476                        QEMU_THREAD_JOINABLE);
2477     s->migration_thread_running = true;
2478 }
2479
2480 void migration_global_dump(Monitor *mon)
2481 {
2482     MigrationState *ms = migrate_get_current();
2483
2484     monitor_printf(mon, "globals:\n");
2485     monitor_printf(mon, "store-global-state: %s\n",
2486                    ms->store_global_state ? "on" : "off");
2487     monitor_printf(mon, "only-migratable: %s\n",
2488                    ms->only_migratable ? "on" : "off");
2489     monitor_printf(mon, "send-configuration: %s\n",
2490                    ms->send_configuration ? "on" : "off");
2491     monitor_printf(mon, "send-section-footer: %s\n",
2492                    ms->send_section_footer ? "on" : "off");
2493 }
2494
2495 #define DEFINE_PROP_MIG_CAP(name, x)             \
2496     DEFINE_PROP_BOOL(name, MigrationState, enabled_capabilities[x], false)
2497
2498 static Property migration_properties[] = {
2499     DEFINE_PROP_BOOL("store-global-state", MigrationState,
2500                      store_global_state, true),
2501     DEFINE_PROP_BOOL("only-migratable", MigrationState, only_migratable, false),
2502     DEFINE_PROP_BOOL("send-configuration", MigrationState,
2503                      send_configuration, true),
2504     DEFINE_PROP_BOOL("send-section-footer", MigrationState,
2505                      send_section_footer, true),
2506
2507     /* Migration parameters */
2508     DEFINE_PROP_UINT8("x-compress-level", MigrationState,
2509                       parameters.compress_level,
2510                       DEFAULT_MIGRATE_COMPRESS_LEVEL),
2511     DEFINE_PROP_UINT8("x-compress-threads", MigrationState,
2512                       parameters.compress_threads,
2513                       DEFAULT_MIGRATE_COMPRESS_THREAD_COUNT),
2514     DEFINE_PROP_UINT8("x-decompress-threads", MigrationState,
2515                       parameters.decompress_threads,
2516                       DEFAULT_MIGRATE_DECOMPRESS_THREAD_COUNT),
2517     DEFINE_PROP_UINT8("x-cpu-throttle-initial", MigrationState,
2518                       parameters.cpu_throttle_initial,
2519                       DEFAULT_MIGRATE_CPU_THROTTLE_INITIAL),
2520     DEFINE_PROP_UINT8("x-cpu-throttle-increment", MigrationState,
2521                       parameters.cpu_throttle_increment,
2522                       DEFAULT_MIGRATE_CPU_THROTTLE_INCREMENT),
2523     DEFINE_PROP_SIZE("x-max-bandwidth", MigrationState,
2524                       parameters.max_bandwidth, MAX_THROTTLE),
2525     DEFINE_PROP_UINT64("x-downtime-limit", MigrationState,
2526                       parameters.downtime_limit,
2527                       DEFAULT_MIGRATE_SET_DOWNTIME),
2528     DEFINE_PROP_UINT32("x-checkpoint-delay", MigrationState,
2529                       parameters.x_checkpoint_delay,
2530                       DEFAULT_MIGRATE_X_CHECKPOINT_DELAY),
2531     DEFINE_PROP_UINT8("x-multifd-channels", MigrationState,
2532                       parameters.x_multifd_channels,
2533                       DEFAULT_MIGRATE_MULTIFD_CHANNELS),
2534     DEFINE_PROP_UINT32("x-multifd-page-count", MigrationState,
2535                       parameters.x_multifd_page_count,
2536                       DEFAULT_MIGRATE_MULTIFD_PAGE_COUNT),
2537     DEFINE_PROP_SIZE("xbzrle-cache-size", MigrationState,
2538                       parameters.xbzrle_cache_size,
2539                       DEFAULT_MIGRATE_XBZRLE_CACHE_SIZE),
2540
2541     /* Migration capabilities */
2542     DEFINE_PROP_MIG_CAP("x-xbzrle", MIGRATION_CAPABILITY_XBZRLE),
2543     DEFINE_PROP_MIG_CAP("x-rdma-pin-all", MIGRATION_CAPABILITY_RDMA_PIN_ALL),
2544     DEFINE_PROP_MIG_CAP("x-auto-converge", MIGRATION_CAPABILITY_AUTO_CONVERGE),
2545     DEFINE_PROP_MIG_CAP("x-zero-blocks", MIGRATION_CAPABILITY_ZERO_BLOCKS),
2546     DEFINE_PROP_MIG_CAP("x-compress", MIGRATION_CAPABILITY_COMPRESS),
2547     DEFINE_PROP_MIG_CAP("x-events", MIGRATION_CAPABILITY_EVENTS),
2548     DEFINE_PROP_MIG_CAP("x-postcopy-ram", MIGRATION_CAPABILITY_POSTCOPY_RAM),
2549     DEFINE_PROP_MIG_CAP("x-colo", MIGRATION_CAPABILITY_X_COLO),
2550     DEFINE_PROP_MIG_CAP("x-release-ram", MIGRATION_CAPABILITY_RELEASE_RAM),
2551     DEFINE_PROP_MIG_CAP("x-block", MIGRATION_CAPABILITY_BLOCK),
2552     DEFINE_PROP_MIG_CAP("x-return-path", MIGRATION_CAPABILITY_RETURN_PATH),
2553     DEFINE_PROP_MIG_CAP("x-multifd", MIGRATION_CAPABILITY_X_MULTIFD),
2554
2555     DEFINE_PROP_END_OF_LIST(),
2556 };
2557
2558 static void migration_class_init(ObjectClass *klass, void *data)
2559 {
2560     DeviceClass *dc = DEVICE_CLASS(klass);
2561
2562     dc->user_creatable = false;
2563     dc->props = migration_properties;
2564 }
2565
2566 static void migration_instance_finalize(Object *obj)
2567 {
2568     MigrationState *ms = MIGRATION_OBJ(obj);
2569     MigrationParameters *params = &ms->parameters;
2570
2571     qemu_mutex_destroy(&ms->error_mutex);
2572     g_free(params->tls_hostname);
2573     g_free(params->tls_creds);
2574     qemu_sem_destroy(&ms->pause_sem);
2575     error_free(ms->error);
2576 }
2577
2578 static void migration_instance_init(Object *obj)
2579 {
2580     MigrationState *ms = MIGRATION_OBJ(obj);
2581     MigrationParameters *params = &ms->parameters;
2582
2583     ms->state = MIGRATION_STATUS_NONE;
2584     ms->mbps = -1;
2585     qemu_sem_init(&ms->pause_sem, 0);
2586     qemu_mutex_init(&ms->error_mutex);
2587
2588     params->tls_hostname = g_strdup("");
2589     params->tls_creds = g_strdup("");
2590
2591     /* Set has_* up only for parameter checks */
2592     params->has_compress_level = true;
2593     params->has_compress_threads = true;
2594     params->has_decompress_threads = true;
2595     params->has_cpu_throttle_initial = true;
2596     params->has_cpu_throttle_increment = true;
2597     params->has_max_bandwidth = true;
2598     params->has_downtime_limit = true;
2599     params->has_x_checkpoint_delay = true;
2600     params->has_block_incremental = true;
2601     params->has_x_multifd_channels = true;
2602     params->has_x_multifd_page_count = true;
2603     params->has_xbzrle_cache_size = true;
2604 }
2605
2606 /*
2607  * Return true if check pass, false otherwise. Error will be put
2608  * inside errp if provided.
2609  */
2610 static bool migration_object_check(MigrationState *ms, Error **errp)
2611 {
2612     MigrationCapabilityStatusList *head = NULL;
2613     /* Assuming all off */
2614     bool cap_list[MIGRATION_CAPABILITY__MAX] = { 0 }, ret;
2615     int i;
2616
2617     if (!migrate_params_check(&ms->parameters, errp)) {
2618         return false;
2619     }
2620
2621     for (i = 0; i < MIGRATION_CAPABILITY__MAX; i++) {
2622         if (ms->enabled_capabilities[i]) {
2623             head = migrate_cap_add(head, i, true);
2624         }
2625     }
2626
2627     ret = migrate_caps_check(cap_list, head, errp);
2628
2629     /* It works with head == NULL */
2630     qapi_free_MigrationCapabilityStatusList(head);
2631
2632     return ret;
2633 }
2634
2635 static const TypeInfo migration_type = {
2636     .name = TYPE_MIGRATION,
2637     /*
2638      * NOTE: TYPE_MIGRATION is not really a device, as the object is
2639      * not created using qdev_create(), it is not attached to the qdev
2640      * device tree, and it is never realized.
2641      *
2642      * TODO: Make this TYPE_OBJECT once QOM provides something like
2643      * TYPE_DEVICE's "-global" properties.
2644      */
2645     .parent = TYPE_DEVICE,
2646     .class_init = migration_class_init,
2647     .class_size = sizeof(MigrationClass),
2648     .instance_size = sizeof(MigrationState),
2649     .instance_init = migration_instance_init,
2650     .instance_finalize = migration_instance_finalize,
2651 };
2652
2653 static void register_migration_types(void)
2654 {
2655     type_register_static(&migration_type);
2656 }
2657
2658 type_init(register_migration_types);