migration/savevm.c

   1 /*
   2  * QEMU System Emulator
   3  *
   4  * Copyright (c) 2003-2008 Fabrice Bellard
   5  * Copyright (c) 2009-2015 Red Hat Inc
   6  *
   7  * Authors:
   8  *  Juan Quintela <[email protected]>
   9  *
  10  * Permission is hereby granted, free of charge, to any person obtaining a copy
  11  * of this software and associated documentation files (the "Software"), to deal
  12  * in the Software without restriction, including without limitation the rights
  13  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  14  * copies of the Software, and to permit persons to whom the Software is
  15  * furnished to do so, subject to the following conditions:
  16  *
  17  * The above copyright notice and this permission notice shall be included in
  18  * all copies or substantial portions of the Software.
  19  *
  20  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  21  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  22  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
  23  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  24  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  25  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  26  * THE SOFTWARE.
  27  */
  28
  29 #include "qemu/osdep.h"
  30 #include "hw/boards.h"
  31 #include "hw/xen/xen.h"
  32 #include "net/net.h"
  33 #include "migration.h"
  34 #include "migration/snapshot.h"
  35 #include "migration/misc.h"
  36 #include "migration/register.h"
  37 #include "migration/global_state.h"
  38 #include "ram.h"
  39 #include "qemu-file-channel.h"
  40 #include "qemu-file.h"
  41 #include "savevm.h"
  42 #include "postcopy-ram.h"
  43 #include "qapi/error.h"
  44 #include "qapi/qapi-commands-migration.h"
  45 #include "qapi/qapi-commands-misc.h"
  46 #include "qapi/qmp/qerror.h"
  47 #include "qemu/error-report.h"
  48 #include "sysemu/cpus.h"
  49 #include "exec/memory.h"
  50 #include "exec/target_page.h"
  51 #include "trace.h"
  52 #include "qemu/iov.h"
  53 #include "block/snapshot.h"
  54 #include "qemu/cutils.h"
  55 #include "io/channel-buffer.h"
  56 #include "io/channel-file.h"
  57 #include "sysemu/replay.h"
  58 #include "qjson.h"
  59 #include "migration/colo.h"
  60 #include "qemu/bitmap.h"
  61 #include "net/announce.h"
  62
  63 const unsigned int postcopy_ram_discard_version = 0;
  64
  65 /* Subcommands for QEMU_VM_COMMAND */
  66 enum qemu_vm_cmd {
  67     MIG_CMD_INVALID = 0,   /* Must be 0 */
  68     MIG_CMD_OPEN_RETURN_PATH,  /* Tell the dest to open the Return path */
  69     MIG_CMD_PING,              /* Request a PONG on the RP */
  70
  71     MIG_CMD_POSTCOPY_ADVISE,       /* Prior to any page transfers, just
  72                                       warn we might want to do PC */
  73     MIG_CMD_POSTCOPY_LISTEN,       /* Start listening for incoming
  74                                       pages as it's running. */
  75     MIG_CMD_POSTCOPY_RUN,          /* Start execution */
  76
  77     MIG_CMD_POSTCOPY_RAM_DISCARD,  /* A list of pages to discard that
  78                                       were previously sent during
  79                                       precopy but are dirty. */
  80     MIG_CMD_PACKAGED,          /* Send a wrapped stream within this stream */
  81     MIG_CMD_ENABLE_COLO,       /* Enable COLO */
  82     MIG_CMD_POSTCOPY_RESUME,   /* resume postcopy on dest */
  83     MIG_CMD_RECV_BITMAP,       /* Request for recved bitmap on dst */
  84     MIG_CMD_MAX
  85 };
  86
  87 #define MAX_VM_CMD_PACKAGED_SIZE UINT32_MAX
  88 static struct mig_cmd_args {
  89     ssize_t     len; /* -1 = variable */
  90     const char *name;
  91 } mig_cmd_args[] = {
  92     [MIG_CMD_INVALID]          = { .len = -1, .name = "INVALID" },
  93     [MIG_CMD_OPEN_RETURN_PATH] = { .len =  0, .name = "OPEN_RETURN_PATH" },
  94     [MIG_CMD_PING]             = { .len = sizeof(uint32_t), .name = "PING" },
  95     [MIG_CMD_POSTCOPY_ADVISE]  = { .len = -1, .name = "POSTCOPY_ADVISE" },
  96     [MIG_CMD_POSTCOPY_LISTEN]  = { .len =  0, .name = "POSTCOPY_LISTEN" },
  97     [MIG_CMD_POSTCOPY_RUN]     = { .len =  0, .name = "POSTCOPY_RUN" },
  98     [MIG_CMD_POSTCOPY_RAM_DISCARD] = {
  99                                    .len = -1, .name = "POSTCOPY_RAM_DISCARD" },
 100     [MIG_CMD_POSTCOPY_RESUME]  = { .len =  0, .name = "POSTCOPY_RESUME" },
 101     [MIG_CMD_PACKAGED]         = { .len =  4, .name = "PACKAGED" },
 102     [MIG_CMD_RECV_BITMAP]      = { .len = -1, .name = "RECV_BITMAP" },
 103     [MIG_CMD_MAX]              = { .len = -1, .name = "MAX" },
 104 };
 105
 106 /* Note for MIG_CMD_POSTCOPY_ADVISE:
 107  * The format of arguments is depending on postcopy mode:
 108  * - postcopy RAM only
 109  *   uint64_t host page size
 110  *   uint64_t taget page size
 111  *
 112  * - postcopy RAM and postcopy dirty bitmaps
 113  *   format is the same as for postcopy RAM only
 114  *
 115  * - postcopy dirty bitmaps only
 116  *   Nothing. Command length field is 0.
 117  *
 118  * Be careful: adding a new postcopy entity with some other parameters should
 119  * not break format self-description ability. Good way is to introduce some
 120  * generic extendable format with an exception for two old entities.
 121  */
 122
 123 /***********************************************************/
 124 /* savevm/loadvm support */
 125
 126 static ssize_t block_writev_buffer(void *opaque, struct iovec *iov, int iovcnt,
 127                                    int64_t pos, Error **errp)
 128 {
 129     int ret;
 130     QEMUIOVector qiov;
 131
 132     qemu_iovec_init_external(&qiov, iov, iovcnt);
 133     ret = bdrv_writev_vmstate(opaque, &qiov, pos);
 134     if (ret < 0) {
 135         return ret;
 136     }
 137
 138     return qiov.size;
 139 }
 140
 141 static ssize_t block_get_buffer(void *opaque, uint8_t *buf, int64_t pos,
 142                                 size_t size, Error **errp)
 143 {
 144     return bdrv_load_vmstate(opaque, buf, pos, size);
 145 }
 146
 147 static int bdrv_fclose(void *opaque, Error **errp)
 148 {
 149     return bdrv_flush(opaque);
 150 }
 151
 152 static const QEMUFileOps bdrv_read_ops = {
 153     .get_buffer = block_get_buffer,
 154     .close =      bdrv_fclose
 155 };
 156
 157 static const QEMUFileOps bdrv_write_ops = {
 158     .writev_buffer  = block_writev_buffer,
 159     .close          = bdrv_fclose
 160 };
 161
 162 static QEMUFile *qemu_fopen_bdrv(BlockDriverState *bs, int is_writable)
 163 {
 164     if (is_writable) {
 165         return qemu_fopen_ops(bs, &bdrv_write_ops);
 166     }
 167     return qemu_fopen_ops(bs, &bdrv_read_ops);
 168 }
 169
 170
 171 /* QEMUFile timer support.
 172  * Not in qemu-file.c to not add qemu-timer.c as dependency to qemu-file.c
 173  */
 174
 175 void timer_put(QEMUFile *f, QEMUTimer *ts)
 176 {
 177     uint64_t expire_time;
 178
 179     expire_time = timer_expire_time_ns(ts);
 180     qemu_put_be64(f, expire_time);
 181 }
 182
 183 void timer_get(QEMUFile *f, QEMUTimer *ts)
 184 {
 185     uint64_t expire_time;
 186
 187     expire_time = qemu_get_be64(f);
 188     if (expire_time != -1) {
 189         timer_mod_ns(ts, expire_time);
 190     } else {
 191         timer_del(ts);
 192     }
 193 }
 194
 195
 196 /* VMState timer support.
 197  * Not in vmstate.c to not add qemu-timer.c as dependency to vmstate.c
 198  */
 199
 200 static int get_timer(QEMUFile *f, void *pv, size_t size,
 201                      const VMStateField *field)
 202 {
 203     QEMUTimer *v = pv;
 204     timer_get(f, v);
 205     return 0;
 206 }
 207
 208 static int put_timer(QEMUFile *f, void *pv, size_t size,
 209                      const VMStateField *field, QJSON *vmdesc)
 210 {
 211     QEMUTimer *v = pv;
 212     timer_put(f, v);
 213
 214     return 0;
 215 }
 216
 217 const VMStateInfo vmstate_info_timer = {
 218     .name = "timer",
 219     .get  = get_timer,
 220     .put  = put_timer,
 221 };
 222
 223
 224 typedef struct CompatEntry {
 225     char idstr[256];
 226     int instance_id;
 227 } CompatEntry;
 228
 229 typedef struct SaveStateEntry {
 230     QTAILQ_ENTRY(SaveStateEntry) entry;
 231     char idstr[256];
 232     int instance_id;
 233     int alias_id;
 234     int version_id;
 235     /* version id read from the stream */
 236     int load_version_id;
 237     int section_id;
 238     /* section id read from the stream */
 239     int load_section_id;
 240     const SaveVMHandlers *ops;
 241     const VMStateDescription *vmsd;
 242     void *opaque;
 243     CompatEntry *compat;
 244     int is_ram;
 245 } SaveStateEntry;
 246
 247 typedef struct SaveState {
 248     QTAILQ_HEAD(, SaveStateEntry) handlers;
 249     int global_section_id;
 250     uint32_t len;
 251     const char *name;
 252     uint32_t target_page_bits;
 253     uint32_t caps_count;
 254     MigrationCapability *capabilities;
 255 } SaveState;
 256
 257 static SaveState savevm_state = {
 258     .handlers = QTAILQ_HEAD_INITIALIZER(savevm_state.handlers),
 259     .global_section_id = 0,
 260 };
 261
 262 static bool should_validate_capability(int capability)
 263 {
 264     assert(capability >= 0 && capability < MIGRATION_CAPABILITY__MAX);
 265     /* Validate only new capabilities to keep compatibility. */
 266     switch (capability) {
 267     case MIGRATION_CAPABILITY_X_IGNORE_SHARED:
 268         return true;
 269     default:
 270         return false;
 271     }
 272 }
 273
 274 static uint32_t get_validatable_capabilities_count(void)
 275 {
 276     MigrationState *s = migrate_get_current();
 277     uint32_t result = 0;
 278     int i;
 279     for (i = 0; i < MIGRATION_CAPABILITY__MAX; i++) {
 280         if (should_validate_capability(i) && s->enabled_capabilities[i]) {
 281             result++;
 282         }
 283     }
 284     return result;
 285 }
 286
 287 static int configuration_pre_save(void *opaque)
 288 {
 289     SaveState *state = opaque;
 290     const char *current_name = MACHINE_GET_CLASS(current_machine)->name;
 291     MigrationState *s = migrate_get_current();
 292     int i, j;
 293
 294     state->len = strlen(current_name);
 295     state->name = current_name;
 296     state->target_page_bits = qemu_target_page_bits();
 297
 298     state->caps_count = get_validatable_capabilities_count();
 299     state->capabilities = g_renew(MigrationCapability, state->capabilities,
 300                                   state->caps_count);
 301     for (i = j = 0; i < MIGRATION_CAPABILITY__MAX; i++) {
 302         if (should_validate_capability(i) && s->enabled_capabilities[i]) {
 303             state->capabilities[j++] = i;
 304         }
 305     }
 306
 307     return 0;
 308 }
 309
 310 static int configuration_pre_load(void *opaque)
 311 {
 312     SaveState *state = opaque;
 313
 314     /* If there is no target-page-bits subsection it means the source
 315      * predates the variable-target-page-bits support and is using the
 316      * minimum possible value for this CPU.
 317      */
 318     state->target_page_bits = qemu_target_page_bits_min();
 319     return 0;
 320 }
 321
 322 static bool configuration_validate_capabilities(SaveState *state)
 323 {
 324     bool ret = true;
 325     MigrationState *s = migrate_get_current();
 326     unsigned long *source_caps_bm;
 327     int i;
 328
 329     source_caps_bm = bitmap_new(MIGRATION_CAPABILITY__MAX);
 330     for (i = 0; i < state->caps_count; i++) {
 331         MigrationCapability capability = state->capabilities[i];
 332         set_bit(capability, source_caps_bm);
 333     }
 334
 335     for (i = 0; i < MIGRATION_CAPABILITY__MAX; i++) {
 336         bool source_state, target_state;
 337         if (!should_validate_capability(i)) {
 338             continue;
 339         }
 340         source_state = test_bit(i, source_caps_bm);
 341         target_state = s->enabled_capabilities[i];
 342         if (source_state != target_state) {
 343             error_report("Capability %s is %s, but received capability is %s",
 344                          MigrationCapability_str(i),
 345                          target_state ? "on" : "off",
 346                          source_state ? "on" : "off");
 347             ret = false;
 348             /* Don't break here to report all failed capabilities */
 349         }
 350     }
 351
 352     g_free(source_caps_bm);
 353     return ret;
 354 }
 355
 356 static int configuration_post_load(void *opaque, int version_id)
 357 {
 358     SaveState *state = opaque;
 359     const char *current_name = MACHINE_GET_CLASS(current_machine)->name;
 360
 361     if (strncmp(state->name, current_name, state->len) != 0) {
 362         error_report("Machine type received is '%.*s' and local is '%s'",
 363                      (int) state->len, state->name, current_name);
 364         return -EINVAL;
 365     }
 366
 367     if (state->target_page_bits != qemu_target_page_bits()) {
 368         error_report("Received TARGET_PAGE_BITS is %d but local is %d",
 369                      state->target_page_bits, qemu_target_page_bits());
 370         return -EINVAL;
 371     }
 372
 373     if (!configuration_validate_capabilities(state)) {
 374         return -EINVAL;
 375     }
 376
 377     return 0;
 378 }
 379
 380 static int get_capability(QEMUFile *f, void *pv, size_t size,
 381                           const VMStateField *field)
 382 {
 383     MigrationCapability *capability = pv;
 384     char capability_str[UINT8_MAX + 1];
 385     uint8_t len;
 386     int i;
 387
 388     len = qemu_get_byte(f);
 389     qemu_get_buffer(f, (uint8_t *)capability_str, len);
 390     capability_str[len] = '\0';
 391     for (i = 0; i < MIGRATION_CAPABILITY__MAX; i++) {
 392         if (!strcmp(MigrationCapability_str(i), capability_str)) {
 393             *capability = i;
 394             return 0;
 395         }
 396     }
 397     error_report("Received unknown capability %s", capability_str);
 398     return -EINVAL;
 399 }
 400
 401 static int put_capability(QEMUFile *f, void *pv, size_t size,
 402                           const VMStateField *field, QJSON *vmdesc)
 403 {
 404     MigrationCapability *capability = pv;
 405     const char *capability_str = MigrationCapability_str(*capability);
 406     size_t len = strlen(capability_str);
 407     assert(len <= UINT8_MAX);
 408
 409     qemu_put_byte(f, len);
 410     qemu_put_buffer(f, (uint8_t *)capability_str, len);
 411     return 0;
 412 }
 413
 414 static const VMStateInfo vmstate_info_capability = {
 415     .name = "capability",
 416     .get  = get_capability,
 417     .put  = put_capability,
 418 };
 419
 420 /* The target-page-bits subsection is present only if the
 421  * target page size is not the same as the default (ie the
 422  * minimum page size for a variable-page-size guest CPU).
 423  * If it is present then it contains the actual target page
 424  * bits for the machine, and migration will fail if the
 425  * two ends don't agree about it.
 426  */
 427 static bool vmstate_target_page_bits_needed(void *opaque)
 428 {
 429     return qemu_target_page_bits()
 430         > qemu_target_page_bits_min();
 431 }
 432
 433 static const VMStateDescription vmstate_target_page_bits = {
 434     .name = "configuration/target-page-bits",
 435     .version_id = 1,
 436     .minimum_version_id = 1,
 437     .needed = vmstate_target_page_bits_needed,
 438     .fields = (VMStateField[]) {
 439         VMSTATE_UINT32(target_page_bits, SaveState),
 440         VMSTATE_END_OF_LIST()
 441     }
 442 };
 443
 444 static bool vmstate_capabilites_needed(void *opaque)
 445 {
 446     return get_validatable_capabilities_count() > 0;
 447 }
 448
 449 static const VMStateDescription vmstate_capabilites = {
 450     .name = "configuration/capabilities",
 451     .version_id = 1,
 452     .minimum_version_id = 1,
 453     .needed = vmstate_capabilites_needed,
 454     .fields = (VMStateField[]) {
 455         VMSTATE_UINT32_V(caps_count, SaveState, 1),
 456         VMSTATE_VARRAY_UINT32_ALLOC(capabilities, SaveState, caps_count, 1,
 457                                     vmstate_info_capability,
 458                                     MigrationCapability),
 459         VMSTATE_END_OF_LIST()
 460     }
 461 };
 462
 463 static const VMStateDescription vmstate_configuration = {
 464     .name = "configuration",
 465     .version_id = 1,
 466     .pre_load = configuration_pre_load,
 467     .post_load = configuration_post_load,
 468     .pre_save = configuration_pre_save,
 469     .fields = (VMStateField[]) {
 470         VMSTATE_UINT32(len, SaveState),
 471         VMSTATE_VBUFFER_ALLOC_UINT32(name, SaveState, 0, NULL, len),
 472         VMSTATE_END_OF_LIST()
 473     },
 474     .subsections = (const VMStateDescription*[]) {
 475         &vmstate_target_page_bits,
 476         &vmstate_capabilites,
 477         NULL
 478     }
 479 };
 480
 481 static void dump_vmstate_vmsd(FILE *out_file,
 482                               const VMStateDescription *vmsd, int indent,
 483                               bool is_subsection);
 484
 485 static void dump_vmstate_vmsf(FILE *out_file, const VMStateField *field,
 486                               int indent)
 487 {
 488     fprintf(out_file, "%*s{\n", indent, "");
 489     indent += 2;
 490     fprintf(out_file, "%*s\"field\": \"%s\",\n", indent, "", field->name);
 491     fprintf(out_file, "%*s\"version_id\": %d,\n", indent, "",
 492             field->version_id);
 493     fprintf(out_file, "%*s\"field_exists\": %s,\n", indent, "",
 494             field->field_exists ? "true" : "false");
 495     fprintf(out_file, "%*s\"size\": %zu", indent, "", field->size);
 496     if (field->vmsd != NULL) {
 497         fprintf(out_file, ",\n");
 498         dump_vmstate_vmsd(out_file, field->vmsd, indent, false);
 499     }
 500     fprintf(out_file, "\n%*s}", indent - 2, "");
 501 }
 502
 503 static void dump_vmstate_vmss(FILE *out_file,
 504                               const VMStateDescription **subsection,
 505                               int indent)
 506 {
 507     if (*subsection != NULL) {
 508         dump_vmstate_vmsd(out_file, *subsection, indent, true);
 509     }
 510 }
 511
 512 static void dump_vmstate_vmsd(FILE *out_file,
 513                               const VMStateDescription *vmsd, int indent,
 514                               bool is_subsection)
 515 {
 516     if (is_subsection) {
 517         fprintf(out_file, "%*s{\n", indent, "");
 518     } else {
 519         fprintf(out_file, "%*s\"%s\": {\n", indent, "", "Description");
 520     }
 521     indent += 2;
 522     fprintf(out_file, "%*s\"name\": \"%s\",\n", indent, "", vmsd->name);
 523     fprintf(out_file, "%*s\"version_id\": %d,\n", indent, "",
 524             vmsd->version_id);
 525     fprintf(out_file, "%*s\"minimum_version_id\": %d", indent, "",
 526             vmsd->minimum_version_id);
 527     if (vmsd->fields != NULL) {
 528         const VMStateField *field = vmsd->fields;
 529         bool first;
 530
 531         fprintf(out_file, ",\n%*s\"Fields\": [\n", indent, "");
 532         first = true;
 533         while (field->name != NULL) {
 534             if (field->flags & VMS_MUST_EXIST) {
 535                 /* Ignore VMSTATE_VALIDATE bits; these don't get migrated */
 536                 field++;
 537                 continue;
 538             }
 539             if (!first) {
 540                 fprintf(out_file, ",\n");
 541             }
 542             dump_vmstate_vmsf(out_file, field, indent + 2);
 543             field++;
 544             first = false;
 545         }
 546         fprintf(out_file, "\n%*s]", indent, "");
 547     }
 548     if (vmsd->subsections != NULL) {
 549         const VMStateDescription **subsection = vmsd->subsections;
 550         bool first;
 551
 552         fprintf(out_file, ",\n%*s\"Subsections\": [\n", indent, "");
 553         first = true;
 554         while (*subsection != NULL) {
 555             if (!first) {
 556                 fprintf(out_file, ",\n");
 557             }
 558             dump_vmstate_vmss(out_file, subsection, indent + 2);
 559             subsection++;
 560             first = false;
 561         }
 562         fprintf(out_file, "\n%*s]", indent, "");
 563     }
 564     fprintf(out_file, "\n%*s}", indent - 2, "");
 565 }
 566
 567 static void dump_machine_type(FILE *out_file)
 568 {
 569     MachineClass *mc;
 570
 571     mc = MACHINE_GET_CLASS(current_machine);
 572
 573     fprintf(out_file, "  \"vmschkmachine\": {\n");
 574     fprintf(out_file, "    \"Name\": \"%s\"\n", mc->name);
 575     fprintf(out_file, "  },\n");
 576 }
 577
 578 void dump_vmstate_json_to_file(FILE *out_file)
 579 {
 580     GSList *list, *elt;
 581     bool first;
 582
 583     fprintf(out_file, "{\n");
 584     dump_machine_type(out_file);
 585
 586     first = true;
 587     list = object_class_get_list(TYPE_DEVICE, true);
 588     for (elt = list; elt; elt = elt->next) {
 589         DeviceClass *dc = OBJECT_CLASS_CHECK(DeviceClass, elt->data,
 590                                              TYPE_DEVICE);
 591         const char *name;
 592         int indent = 2;
 593
 594         if (!dc->vmsd) {
 595             continue;
 596         }
 597
 598         if (!first) {
 599             fprintf(out_file, ",\n");
 600         }
 601         name = object_class_get_name(OBJECT_CLASS(dc));
 602         fprintf(out_file, "%*s\"%s\": {\n", indent, "", name);
 603         indent += 2;
 604         fprintf(out_file, "%*s\"Name\": \"%s\",\n", indent, "", name);
 605         fprintf(out_file, "%*s\"version_id\": %d,\n", indent, "",
 606                 dc->vmsd->version_id);
 607         fprintf(out_file, "%*s\"minimum_version_id\": %d,\n", indent, "",
 608                 dc->vmsd->minimum_version_id);
 609
 610         dump_vmstate_vmsd(out_file, dc->vmsd, indent, false);
 611
 612         fprintf(out_file, "\n%*s}", indent - 2, "");
 613         first = false;
 614     }
 615     fprintf(out_file, "\n}\n");
 616     fclose(out_file);
 617 }
 618
 619 static int calculate_new_instance_id(const char *idstr)
 620 {
 621     SaveStateEntry *se;
 622     int instance_id = 0;
 623
 624     QTAILQ_FOREACH(se, &savevm_state.handlers, entry) {
 625         if (strcmp(idstr, se->idstr) == 0
 626             && instance_id <= se->instance_id) {
 627             instance_id = se->instance_id + 1;
 628         }
 629     }
 630     return instance_id;
 631 }
 632
 633 static int calculate_compat_instance_id(const char *idstr)
 634 {
 635     SaveStateEntry *se;
 636     int instance_id = 0;
 637
 638     QTAILQ_FOREACH(se, &savevm_state.handlers, entry) {
 639         if (!se->compat) {
 640             continue;
 641         }
 642
 643         if (strcmp(idstr, se->compat->idstr) == 0
 644             && instance_id <= se->compat->instance_id) {
 645             instance_id = se->compat->instance_id + 1;
 646         }
 647     }
 648     return instance_id;
 649 }
 650
 651 static inline MigrationPriority save_state_priority(SaveStateEntry *se)
 652 {
 653     if (se->vmsd) {
 654         return se->vmsd->priority;
 655     }
 656     return MIG_PRI_DEFAULT;
 657 }
 658
 659 static void savevm_state_handler_insert(SaveStateEntry *nse)
 660 {
 661     MigrationPriority priority = save_state_priority(nse);
 662     SaveStateEntry *se;
 663
 664     assert(priority <= MIG_PRI_MAX);
 665
 666     QTAILQ_FOREACH(se, &savevm_state.handlers, entry) {
 667         if (save_state_priority(se) < priority) {
 668             break;
 669         }
 670     }
 671
 672     if (se) {
 673         QTAILQ_INSERT_BEFORE(se, nse, entry);
 674     } else {
 675         QTAILQ_INSERT_TAIL(&savevm_state.handlers, nse, entry);
 676     }
 677 }
 678
 679 /* TODO: Individual devices generally have very little idea about the rest
 680    of the system, so instance_id should be removed/replaced.
 681    Meanwhile pass -1 as instance_id if you do not already have a clearly
 682    distinguishing id for all instances of your device class. */
 683 int register_savevm_live(DeviceState *dev,
 684                          const char *idstr,
 685                          int instance_id,
 686                          int version_id,
 687                          const SaveVMHandlers *ops,
 688                          void *opaque)
 689 {
 690     SaveStateEntry *se;
 691
 692     se = g_new0(SaveStateEntry, 1);
 693     se->version_id = version_id;
 694     se->section_id = savevm_state.global_section_id++;
 695     se->ops = ops;
 696     se->opaque = opaque;
 697     se->vmsd = NULL;
 698     /* if this is a live_savem then set is_ram */
 699     if (ops->save_setup != NULL) {
 700         se->is_ram = 1;
 701     }
 702
 703     if (dev) {
 704         char *id = qdev_get_dev_path(dev);
 705         if (id) {
 706             if (snprintf(se->idstr, sizeof(se->idstr), "%s/", id) >=
 707                 sizeof(se->idstr)) {
 708                 error_report("Path too long for VMState (%s)", id);
 709                 g_free(id);
 710                 g_free(se);
 711
 712                 return -1;
 713             }
 714             g_free(id);
 715
 716             se->compat = g_new0(CompatEntry, 1);
 717             pstrcpy(se->compat->idstr, sizeof(se->compat->idstr), idstr);
 718             se->compat->instance_id = instance_id == -1 ?
 719                          calculate_compat_instance_id(idstr) : instance_id;
 720             instance_id = -1;
 721         }
 722     }
 723     pstrcat(se->idstr, sizeof(se->idstr), idstr);
 724
 725     if (instance_id == -1) {
 726         se->instance_id = calculate_new_instance_id(se->idstr);
 727     } else {
 728         se->instance_id = instance_id;
 729     }
 730     assert(!se->compat || se->instance_id == 0);
 731     savevm_state_handler_insert(se);
 732     return 0;
 733 }
 734
 735 void unregister_savevm(DeviceState *dev, const char *idstr, void *opaque)
 736 {
 737     SaveStateEntry *se, *new_se;
 738     char id[256] = "";
 739
 740     if (dev) {
 741         char *path = qdev_get_dev_path(dev);
 742         if (path) {
 743             pstrcpy(id, sizeof(id), path);
 744             pstrcat(id, sizeof(id), "/");
 745             g_free(path);
 746         }
 747     }
 748     pstrcat(id, sizeof(id), idstr);
 749
 750     QTAILQ_FOREACH_SAFE(se, &savevm_state.handlers, entry, new_se) {
 751         if (strcmp(se->idstr, id) == 0 && se->opaque == opaque) {
 752             QTAILQ_REMOVE(&savevm_state.handlers, se, entry);
 753             g_free(se->compat);
 754             g_free(se);
 755         }
 756     }
 757 }
 758
 759 int vmstate_register_with_alias_id(DeviceState *dev, int instance_id,
 760                                    const VMStateDescription *vmsd,
 761                                    void *opaque, int alias_id,
 762                                    int required_for_version,
 763                                    Error **errp)
 764 {
 765     SaveStateEntry *se;
 766
 767     /* If this triggers, alias support can be dropped for the vmsd. */
 768     assert(alias_id == -1 || required_for_version >= vmsd->minimum_version_id);
 769
 770     se = g_new0(SaveStateEntry, 1);
 771     se->version_id = vmsd->version_id;
 772     se->section_id = savevm_state.global_section_id++;
 773     se->opaque = opaque;
 774     se->vmsd = vmsd;
 775     se->alias_id = alias_id;
 776
 777     if (dev) {
 778         char *id = qdev_get_dev_path(dev);
 779         if (id) {
 780             if (snprintf(se->idstr, sizeof(se->idstr), "%s/", id) >=
 781                 sizeof(se->idstr)) {
 782                 error_setg(errp, "Path too long for VMState (%s)", id);
 783                 g_free(id);
 784                 g_free(se);
 785
 786                 return -1;
 787             }
 788             g_free(id);
 789
 790             se->compat = g_new0(CompatEntry, 1);
 791             pstrcpy(se->compat->idstr, sizeof(se->compat->idstr), vmsd->name);
 792             se->compat->instance_id = instance_id == -1 ?
 793                          calculate_compat_instance_id(vmsd->name) : instance_id;
 794             instance_id = -1;
 795         }
 796     }
 797     pstrcat(se->idstr, sizeof(se->idstr), vmsd->name);
 798
 799     if (instance_id == -1) {
 800         se->instance_id = calculate_new_instance_id(se->idstr);
 801     } else {
 802         se->instance_id = instance_id;
 803     }
 804     assert(!se->compat || se->instance_id == 0);
 805     savevm_state_handler_insert(se);
 806     return 0;
 807 }
 808
 809 void vmstate_unregister(DeviceState *dev, const VMStateDescription *vmsd,
 810                         void *opaque)
 811 {
 812     SaveStateEntry *se, *new_se;
 813
 814     QTAILQ_FOREACH_SAFE(se, &savevm_state.handlers, entry, new_se) {
 815         if (se->vmsd == vmsd && se->opaque == opaque) {
 816             QTAILQ_REMOVE(&savevm_state.handlers, se, entry);
 817             g_free(se->compat);
 818             g_free(se);
 819         }
 820     }
 821 }
 822
 823 static int vmstate_load(QEMUFile *f, SaveStateEntry *se)
 824 {
 825     trace_vmstate_load(se->idstr, se->vmsd ? se->vmsd->name : "(old)");
 826     if (!se->vmsd) {         /* Old style */
 827         return se->ops->load_state(f, se->opaque, se->load_version_id);
 828     }
 829     return vmstate_load_state(f, se->vmsd, se->opaque, se->load_version_id);
 830 }
 831
 832 static void vmstate_save_old_style(QEMUFile *f, SaveStateEntry *se, QJSON *vmdesc)
 833 {
 834     int64_t old_offset, size;
 835
 836     old_offset = qemu_ftell_fast(f);
 837     se->ops->save_state(f, se->opaque);
 838     size = qemu_ftell_fast(f) - old_offset;
 839
 840     if (vmdesc) {
 841         json_prop_int(vmdesc, "size", size);
 842         json_start_array(vmdesc, "fields");
 843         json_start_object(vmdesc, NULL);
 844         json_prop_str(vmdesc, "name", "data");
 845         json_prop_int(vmdesc, "size", size);
 846         json_prop_str(vmdesc, "type", "buffer");
 847         json_end_object(vmdesc);
 848         json_end_array(vmdesc);
 849     }
 850 }
 851
 852 static int vmstate_save(QEMUFile *f, SaveStateEntry *se, QJSON *vmdesc)
 853 {
 854     trace_vmstate_save(se->idstr, se->vmsd ? se->vmsd->name : "(old)");
 855     if (!se->vmsd) {
 856         vmstate_save_old_style(f, se, vmdesc);
 857         return 0;
 858     }
 859     return vmstate_save_state(f, se->vmsd, se->opaque, vmdesc);
 860 }
 861
 862 /*
 863  * Write the header for device section (QEMU_VM_SECTION START/END/PART/FULL)
 864  */
 865 static void save_section_header(QEMUFile *f, SaveStateEntry *se,
 866                                 uint8_t section_type)
 867 {
 868     qemu_put_byte(f, section_type);
 869     qemu_put_be32(f, se->section_id);
 870
 871     if (section_type == QEMU_VM_SECTION_FULL ||
 872         section_type == QEMU_VM_SECTION_START) {
 873         /* ID string */
 874         size_t len = strlen(se->idstr);
 875         qemu_put_byte(f, len);
 876         qemu_put_buffer(f, (uint8_t *)se->idstr, len);
 877
 878         qemu_put_be32(f, se->instance_id);
 879         qemu_put_be32(f, se->version_id);
 880     }
 881 }
 882
 883 /*
 884  * Write a footer onto device sections that catches cases misformatted device
 885  * sections.
 886  */
 887 static void save_section_footer(QEMUFile *f, SaveStateEntry *se)
 888 {
 889     if (migrate_get_current()->send_section_footer) {
 890         qemu_put_byte(f, QEMU_VM_SECTION_FOOTER);
 891         qemu_put_be32(f, se->section_id);
 892     }
 893 }
 894
 895 /**
 896  * qemu_savevm_command_send: Send a 'QEMU_VM_COMMAND' type element with the
 897  *                           command and associated data.
 898  *
 899  * @f: File to send command on
 900  * @command: Command type to send
 901  * @len: Length of associated data
 902  * @data: Data associated with command.
 903  */
 904 static void qemu_savevm_command_send(QEMUFile *f,
 905                                      enum qemu_vm_cmd command,
 906                                      uint16_t len,
 907                                      uint8_t *data)
 908 {
 909     trace_savevm_command_send(command, len);
 910     qemu_put_byte(f, QEMU_VM_COMMAND);
 911     qemu_put_be16(f, (uint16_t)command);
 912     qemu_put_be16(f, len);
 913     qemu_put_buffer(f, data, len);
 914     qemu_fflush(f);
 915 }
 916
 917 void qemu_savevm_send_colo_enable(QEMUFile *f)
 918 {
 919     trace_savevm_send_colo_enable();
 920     qemu_savevm_command_send(f, MIG_CMD_ENABLE_COLO, 0, NULL);
 921 }
 922
 923 void qemu_savevm_send_ping(QEMUFile *f, uint32_t value)
 924 {
 925     uint32_t buf;
 926
 927     trace_savevm_send_ping(value);
 928     buf = cpu_to_be32(value);
 929     qemu_savevm_command_send(f, MIG_CMD_PING, sizeof(value), (uint8_t *)&buf);
 930 }
 931
 932 void qemu_savevm_send_open_return_path(QEMUFile *f)
 933 {
 934     trace_savevm_send_open_return_path();
 935     qemu_savevm_command_send(f, MIG_CMD_OPEN_RETURN_PATH, 0, NULL);
 936 }
 937
 938 /* We have a buffer of data to send; we don't want that all to be loaded
 939  * by the command itself, so the command contains just the length of the
 940  * extra buffer that we then send straight after it.
 941  * TODO: Must be a better way to organise that
 942  *
 943  * Returns:
 944  *    0 on success
 945  *    -ve on error
 946  */
 947 int qemu_savevm_send_packaged(QEMUFile *f, const uint8_t *buf, size_t len)
 948 {
 949     uint32_t tmp;
 950
 951     if (len > MAX_VM_CMD_PACKAGED_SIZE) {
 952         error_report("%s: Unreasonably large packaged state: %zu",
 953                      __func__, len);
 954         return -1;
 955     }
 956
 957     tmp = cpu_to_be32(len);
 958
 959     trace_qemu_savevm_send_packaged();
 960     qemu_savevm_command_send(f, MIG_CMD_PACKAGED, 4, (uint8_t *)&tmp);
 961
 962     qemu_put_buffer(f, buf, len);
 963
 964     return 0;
 965 }
 966
 967 /* Send prior to any postcopy transfer */
 968 void qemu_savevm_send_postcopy_advise(QEMUFile *f)
 969 {
 970     if (migrate_postcopy_ram()) {
 971         uint64_t tmp[2];
 972         tmp[0] = cpu_to_be64(ram_pagesize_summary());
 973         tmp[1] = cpu_to_be64(qemu_target_page_size());
 974
 975         trace_qemu_savevm_send_postcopy_advise();
 976         qemu_savevm_command_send(f, MIG_CMD_POSTCOPY_ADVISE,
 977                                  16, (uint8_t *)tmp);
 978     } else {
 979         qemu_savevm_command_send(f, MIG_CMD_POSTCOPY_ADVISE, 0, NULL);
 980     }
 981 }
 982
 983 /* Sent prior to starting the destination running in postcopy, discard pages
 984  * that have already been sent but redirtied on the source.
 985  * CMD_POSTCOPY_RAM_DISCARD consist of:
 986  *      byte   version (0)
 987  *      byte   Length of name field (not including 0)
 988  *  n x byte   RAM block name
 989  *      byte   0 terminator (just for safety)
 990  *  n x        Byte ranges within the named RAMBlock
 991  *      be64   Start of the range
 992  *      be64   Length
 993  *
 994  *  name:  RAMBlock name that these entries are part of
 995  *  len: Number of page entries
 996  *  start_list: 'len' addresses
 997  *  length_list: 'len' addresses
 998  *
 999  */
1000 void qemu_savevm_send_postcopy_ram_discard(QEMUFile *f, const char *name,
1001                                            uint16_t len,
1002                                            uint64_t *start_list,
1003                                            uint64_t *length_list)
1004 {
1005     uint8_t *buf;
1006     uint16_t tmplen;
1007     uint16_t t;
1008     size_t name_len = strlen(name);
1009
1010     trace_qemu_savevm_send_postcopy_ram_discard(name, len);
1011     assert(name_len < 256);
1012     buf = g_malloc0(1 + 1 + name_len + 1 + (8 + 8) * len);
1013     buf[0] = postcopy_ram_discard_version;
1014     buf[1] = name_len;
1015     memcpy(buf + 2, name, name_len);
1016     tmplen = 2 + name_len;
1017     buf[tmplen++] = '\0';
1018
1019     for (t = 0; t < len; t++) {
1020         stq_be_p(buf + tmplen, start_list[t]);
1021         tmplen += 8;
1022         stq_be_p(buf + tmplen, length_list[t]);
1023         tmplen += 8;
1024     }
1025     qemu_savevm_command_send(f, MIG_CMD_POSTCOPY_RAM_DISCARD, tmplen, buf);
1026     g_free(buf);
1027 }
1028
1029 /* Get the destination into a state where it can receive postcopy data. */
1030 void qemu_savevm_send_postcopy_listen(QEMUFile *f)
1031 {
1032     trace_savevm_send_postcopy_listen();
1033     qemu_savevm_command_send(f, MIG_CMD_POSTCOPY_LISTEN, 0, NULL);
1034 }
1035
1036 /* Kick the destination into running */
1037 void qemu_savevm_send_postcopy_run(QEMUFile *f)
1038 {
1039     trace_savevm_send_postcopy_run();
1040     qemu_savevm_command_send(f, MIG_CMD_POSTCOPY_RUN, 0, NULL);
1041 }
1042
1043 void qemu_savevm_send_postcopy_resume(QEMUFile *f)
1044 {
1045     trace_savevm_send_postcopy_resume();
1046     qemu_savevm_command_send(f, MIG_CMD_POSTCOPY_RESUME, 0, NULL);
1047 }
1048
1049 void qemu_savevm_send_recv_bitmap(QEMUFile *f, char *block_name)
1050 {
1051     size_t len;
1052     char buf[256];
1053
1054     trace_savevm_send_recv_bitmap(block_name);
1055
1056     buf[0] = len = strlen(block_name);
1057     memcpy(buf + 1, block_name, len);
1058
1059     qemu_savevm_command_send(f, MIG_CMD_RECV_BITMAP, len + 1, (uint8_t *)buf);
1060 }
1061
1062 bool qemu_savevm_state_blocked(Error **errp)
1063 {
1064     SaveStateEntry *se;
1065
1066     QTAILQ_FOREACH(se, &savevm_state.handlers, entry) {
1067         if (se->vmsd && se->vmsd->unmigratable) {
1068             error_setg(errp, "State blocked by non-migratable device '%s'",
1069                        se->idstr);
1070             return true;
1071         }
1072     }
1073     return false;
1074 }
1075
1076 void qemu_savevm_state_header(QEMUFile *f)
1077 {
1078     trace_savevm_state_header();
1079     qemu_put_be32(f, QEMU_VM_FILE_MAGIC);
1080     qemu_put_be32(f, QEMU_VM_FILE_VERSION);
1081
1082     if (migrate_get_current()->send_configuration) {
1083         qemu_put_byte(f, QEMU_VM_CONFIGURATION);
1084         vmstate_save_state(f, &vmstate_configuration, &savevm_state, 0);
1085     }
1086 }
1087
1088 void qemu_savevm_state_setup(QEMUFile *f)
1089 {
1090     SaveStateEntry *se;
1091     Error *local_err = NULL;
1092     int ret;
1093
1094     trace_savevm_state_setup();
1095     QTAILQ_FOREACH(se, &savevm_state.handlers, entry) {
1096         if (!se->ops || !se->ops->save_setup) {
1097             continue;
1098         }
1099         if (se->ops && se->ops->is_active) {
1100             if (!se->ops->is_active(se->opaque)) {
1101                 continue;
1102             }
1103         }
1104         save_section_header(f, se, QEMU_VM_SECTION_START);
1105
1106         ret = se->ops->save_setup(f, se->opaque);
1107         save_section_footer(f, se);
1108         if (ret < 0) {
1109             qemu_file_set_error(f, ret);
1110             break;
1111         }
1112     }
1113
1114     if (precopy_notify(PRECOPY_NOTIFY_SETUP, &local_err)) {
1115         error_report_err(local_err);
1116     }
1117 }
1118
1119 int qemu_savevm_state_resume_prepare(MigrationState *s)
1120 {
1121     SaveStateEntry *se;
1122     int ret;
1123
1124     trace_savevm_state_resume_prepare();
1125
1126     QTAILQ_FOREACH(se, &savevm_state.handlers, entry) {
1127         if (!se->ops || !se->ops->resume_prepare) {
1128             continue;
1129         }
1130         if (se->ops && se->ops->is_active) {
1131             if (!se->ops->is_active(se->opaque)) {
1132                 continue;
1133             }
1134         }
1135         ret = se->ops->resume_prepare(s, se->opaque);
1136         if (ret < 0) {
1137             return ret;
1138         }
1139     }
1140
1141     return 0;
1142 }
1143
1144 /*
1145  * this function has three return values:
1146  *   negative: there was one error, and we have -errno.
1147  *   0 : We haven't finished, caller have to go again
1148  *   1 : We have finished, we can go to complete phase
1149  */
1150 int qemu_savevm_state_iterate(QEMUFile *f, bool postcopy)
1151 {
1152     SaveStateEntry *se;
1153     int ret = 1;
1154
1155     trace_savevm_state_iterate();
1156     QTAILQ_FOREACH(se, &savevm_state.handlers, entry) {
1157         if (!se->ops || !se->ops->save_live_iterate) {
1158             continue;
1159         }
1160         if (se->ops->is_active &&
1161             !se->ops->is_active(se->opaque)) {
1162             continue;
1163         }
1164         if (se->ops->is_active_iterate &&
1165             !se->ops->is_active_iterate(se->opaque)) {
1166             continue;
1167         }
1168         /*
1169          * In the postcopy phase, any device that doesn't know how to
1170          * do postcopy should have saved it's state in the _complete
1171          * call that's already run, it might get confused if we call
1172          * iterate afterwards.
1173          */
1174         if (postcopy &&
1175             !(se->ops->has_postcopy && se->ops->has_postcopy(se->opaque))) {
1176             continue;
1177         }
1178         if (qemu_file_rate_limit(f)) {
1179             return 0;
1180         }
1181         trace_savevm_section_start(se->idstr, se->section_id);
1182
1183         save_section_header(f, se, QEMU_VM_SECTION_PART);
1184
1185         ret = se->ops->save_live_iterate(f, se->opaque);
1186         trace_savevm_section_end(se->idstr, se->section_id, ret);
1187         save_section_footer(f, se);
1188
1189         if (ret < 0) {
1190             qemu_file_set_error(f, ret);
1191         }
1192         if (ret <= 0) {
1193             /* Do not proceed to the next vmstate before this one reported
1194                completion of the current stage. This serializes the migration
1195                and reduces the probability that a faster changing state is
1196                synchronized over and over again. */
1197             break;
1198         }
1199     }
1200     return ret;
1201 }
1202
1203 static bool should_send_vmdesc(void)
1204 {
1205     MachineState *machine = MACHINE(qdev_get_machine());
1206     bool in_postcopy = migration_in_postcopy();
1207     return !machine->suppress_vmdesc && !in_postcopy;
1208 }
1209
1210 /*
1211  * Calls the save_live_complete_postcopy methods
1212  * causing the last few pages to be sent immediately and doing any associated
1213  * cleanup.
1214  * Note postcopy also calls qemu_savevm_state_complete_precopy to complete
1215  * all the other devices, but that happens at the point we switch to postcopy.
1216  */
1217 void qemu_savevm_state_complete_postcopy(QEMUFile *f)
1218 {
1219     SaveStateEntry *se;
1220     int ret;
1221
1222     QTAILQ_FOREACH(se, &savevm_state.handlers, entry) {
1223         if (!se->ops || !se->ops->save_live_complete_postcopy) {
1224             continue;
1225         }
1226         if (se->ops && se->ops->is_active) {
1227             if (!se->ops->is_active(se->opaque)) {
1228                 continue;
1229             }
1230         }
1231         trace_savevm_section_start(se->idstr, se->section_id);
1232         /* Section type */
1233         qemu_put_byte(f, QEMU_VM_SECTION_END);
1234         qemu_put_be32(f, se->section_id);
1235
1236         ret = se->ops->save_live_complete_postcopy(f, se->opaque);
1237         trace_savevm_section_end(se->idstr, se->section_id, ret);
1238         save_section_footer(f, se);
1239         if (ret < 0) {
1240             qemu_file_set_error(f, ret);
1241             return;
1242         }
1243     }
1244
1245     qemu_put_byte(f, QEMU_VM_EOF);
1246     qemu_fflush(f);
1247 }
1248
1249 static
1250 int qemu_savevm_state_complete_precopy_iterable(QEMUFile *f, bool in_postcopy)
1251 {
1252     SaveStateEntry *se;
1253     int ret;
1254
1255     QTAILQ_FOREACH(se, &savevm_state.handlers, entry) {
1256         if (!se->ops ||
1257             (in_postcopy && se->ops->has_postcopy &&
1258              se->ops->has_postcopy(se->opaque)) ||
1259             !se->ops->save_live_complete_precopy) {
1260             continue;
1261         }
1262
1263         if (se->ops && se->ops->is_active) {
1264             if (!se->ops->is_active(se->opaque)) {
1265                 continue;
1266             }
1267         }
1268         trace_savevm_section_start(se->idstr, se->section_id);
1269
1270         save_section_header(f, se, QEMU_VM_SECTION_END);
1271
1272         ret = se->ops->save_live_complete_precopy(f, se->opaque);
1273         trace_savevm_section_end(se->idstr, se->section_id, ret);
1274         save_section_footer(f, se);
1275         if (ret < 0) {
1276             qemu_file_set_error(f, ret);
1277             return -1;
1278         }
1279     }
1280
1281     return 0;
1282 }
1283
1284 static
1285 int qemu_savevm_state_complete_precopy_non_iterable(QEMUFile *f,
1286                                                     bool in_postcopy,
1287                                                     bool inactivate_disks)
1288 {
1289     QJSON *vmdesc;
1290     int vmdesc_len;
1291     SaveStateEntry *se;
1292     int ret;
1293
1294     vmdesc = qjson_new();
1295     json_prop_int(vmdesc, "page_size", qemu_target_page_size());
1296     json_start_array(vmdesc, "devices");
1297     QTAILQ_FOREACH(se, &savevm_state.handlers, entry) {
1298
1299         if ((!se->ops || !se->ops->save_state) && !se->vmsd) {
1300             continue;
1301         }
1302         if (se->vmsd && !vmstate_save_needed(se->vmsd, se->opaque)) {
1303             trace_savevm_section_skip(se->idstr, se->section_id);
1304             continue;
1305         }
1306
1307         trace_savevm_section_start(se->idstr, se->section_id);
1308
1309         json_start_object(vmdesc, NULL);
1310         json_prop_str(vmdesc, "name", se->idstr);
1311         json_prop_int(vmdesc, "instance_id", se->instance_id);
1312
1313         save_section_header(f, se, QEMU_VM_SECTION_FULL);
1314         ret = vmstate_save(f, se, vmdesc);
1315         if (ret) {
1316             qemu_file_set_error(f, ret);
1317             return ret;
1318         }
1319         trace_savevm_section_end(se->idstr, se->section_id, 0);
1320         save_section_footer(f, se);
1321
1322         json_end_object(vmdesc);
1323     }
1324
1325     if (inactivate_disks) {
1326         /* Inactivate before sending QEMU_VM_EOF so that the
1327          * bdrv_invalidate_cache_all() on the other end won't fail. */
1328         ret = bdrv_inactivate_all();
1329         if (ret) {
1330             error_report("%s: bdrv_inactivate_all() failed (%d)",
1331                          __func__, ret);
1332             qemu_file_set_error(f, ret);
1333             return ret;
1334         }
1335     }
1336     if (!in_postcopy) {
1337         /* Postcopy stream will still be going */
1338         qemu_put_byte(f, QEMU_VM_EOF);
1339     }
1340
1341     json_end_array(vmdesc);
1342     qjson_finish(vmdesc);
1343     vmdesc_len = strlen(qjson_get_str(vmdesc));
1344
1345     if (should_send_vmdesc()) {
1346         qemu_put_byte(f, QEMU_VM_VMDESCRIPTION);
1347         qemu_put_be32(f, vmdesc_len);
1348         qemu_put_buffer(f, (uint8_t *)qjson_get_str(vmdesc), vmdesc_len);
1349     }
1350     qjson_destroy(vmdesc);
1351
1352     return 0;
1353 }
1354
1355 int qemu_savevm_state_complete_precopy(QEMUFile *f, bool iterable_only,
1356                                        bool inactivate_disks)
1357 {
1358     int ret;
1359     Error *local_err = NULL;
1360     bool in_postcopy = migration_in_postcopy();
1361
1362     if (precopy_notify(PRECOPY_NOTIFY_COMPLETE, &local_err)) {
1363         error_report_err(local_err);
1364     }
1365
1366     trace_savevm_state_complete_precopy();
1367
1368     cpu_synchronize_all_states();
1369
1370     if (!in_postcopy || iterable_only) {
1371         ret = qemu_savevm_state_complete_precopy_iterable(f, in_postcopy);
1372         if (ret) {
1373             return ret;
1374         }
1375     }
1376
1377     if (iterable_only) {
1378         goto flush;
1379     }
1380
1381     ret = qemu_savevm_state_complete_precopy_non_iterable(f, in_postcopy,
1382                                                           inactivate_disks);
1383     if (ret) {
1384         return ret;
1385     }
1386
1387 flush:
1388     qemu_fflush(f);
1389     return 0;
1390 }
1391
1392 /* Give an estimate of the amount left to be transferred,
1393  * the result is split into the amount for units that can and
1394  * for units that can't do postcopy.
1395  */
1396 void qemu_savevm_state_pending(QEMUFile *f, uint64_t threshold_size,
1397                                uint64_t *res_precopy_only,
1398                                uint64_t *res_compatible,
1399                                uint64_t *res_postcopy_only)
1400 {
1401     SaveStateEntry *se;
1402
1403     *res_precopy_only = 0;
1404     *res_compatible = 0;
1405     *res_postcopy_only = 0;
1406
1407
1408     QTAILQ_FOREACH(se, &savevm_state.handlers, entry) {
1409         if (!se->ops || !se->ops->save_live_pending) {
1410             continue;
1411         }
1412         if (se->ops && se->ops->is_active) {
1413             if (!se->ops->is_active(se->opaque)) {
1414                 continue;
1415             }
1416         }
1417         se->ops->save_live_pending(f, se->opaque, threshold_size,
1418                                    res_precopy_only, res_compatible,
1419                                    res_postcopy_only);
1420     }
1421 }
1422
1423 void qemu_savevm_state_cleanup(void)
1424 {
1425     SaveStateEntry *se;
1426     Error *local_err = NULL;
1427
1428     if (precopy_notify(PRECOPY_NOTIFY_CLEANUP, &local_err)) {
1429         error_report_err(local_err);
1430     }
1431
1432     trace_savevm_state_cleanup();
1433     QTAILQ_FOREACH(se, &savevm_state.handlers, entry) {
1434         if (se->ops && se->ops->save_cleanup) {
1435             se->ops->save_cleanup(se->opaque);
1436         }
1437     }
1438 }
1439
1440 static int qemu_savevm_state(QEMUFile *f, Error **errp)
1441 {
1442     int ret;
1443     MigrationState *ms = migrate_get_current();
1444     MigrationStatus status;
1445
1446     if (migration_is_setup_or_active(ms->state) ||
1447         ms->state == MIGRATION_STATUS_CANCELLING ||
1448         ms->state == MIGRATION_STATUS_COLO) {
1449         error_setg(errp, QERR_MIGRATION_ACTIVE);
1450         return -EINVAL;
1451     }
1452
1453     if (migrate_use_block()) {
1454         error_setg(errp, "Block migration and snapshots are incompatible");
1455         return -EINVAL;
1456     }
1457
1458     migrate_init(ms);
1459     ms->to_dst_file = f;
1460
1461     qemu_mutex_unlock_iothread();
1462     qemu_savevm_state_header(f);
1463     qemu_savevm_state_setup(f);
1464     qemu_mutex_lock_iothread();
1465
1466     while (qemu_file_get_error(f) == 0) {
1467         if (qemu_savevm_state_iterate(f, false) > 0) {
1468             break;
1469         }
1470     }
1471
1472     ret = qemu_file_get_error(f);
1473     if (ret == 0) {
1474         qemu_savevm_state_complete_precopy(f, false, false);
1475         ret = qemu_file_get_error(f);
1476     }
1477     qemu_savevm_state_cleanup();
1478     if (ret != 0) {
1479         error_setg_errno(errp, -ret, "Error while writing VM state");
1480     }
1481
1482     if (ret != 0) {
1483         status = MIGRATION_STATUS_FAILED;
1484     } else {
1485         status = MIGRATION_STATUS_COMPLETED;
1486     }
1487     migrate_set_state(&ms->state, MIGRATION_STATUS_SETUP, status);
1488
1489     /* f is outer parameter, it should not stay in global migration state after
1490      * this function finished */
1491     ms->to_dst_file = NULL;
1492
1493     return ret;
1494 }
1495
1496 void qemu_savevm_live_state(QEMUFile *f)
1497 {
1498     /* save QEMU_VM_SECTION_END section */
1499     qemu_savevm_state_complete_precopy(f, true, false);
1500     qemu_put_byte(f, QEMU_VM_EOF);
1501 }
1502
1503 int qemu_save_device_state(QEMUFile *f)
1504 {
1505     SaveStateEntry *se;
1506
1507     if (!migration_in_colo_state()) {
1508         qemu_put_be32(f, QEMU_VM_FILE_MAGIC);
1509         qemu_put_be32(f, QEMU_VM_FILE_VERSION);
1510     }
1511     cpu_synchronize_all_states();
1512
1513     QTAILQ_FOREACH(se, &savevm_state.handlers, entry) {
1514         int ret;
1515
1516         if (se->is_ram) {
1517             continue;
1518         }
1519         if ((!se->ops || !se->ops->save_state) && !se->vmsd) {
1520             continue;
1521         }
1522         if (se->vmsd && !vmstate_save_needed(se->vmsd, se->opaque)) {
1523             continue;
1524         }
1525
1526         save_section_header(f, se, QEMU_VM_SECTION_FULL);
1527
1528         ret = vmstate_save(f, se, NULL);
1529         if (ret) {
1530             return ret;
1531         }
1532
1533         save_section_footer(f, se);
1534     }
1535
1536     qemu_put_byte(f, QEMU_VM_EOF);
1537
1538     return qemu_file_get_error(f);
1539 }
1540
1541 static SaveStateEntry *find_se(const char *idstr, int instance_id)
1542 {
1543     SaveStateEntry *se;
1544
1545     QTAILQ_FOREACH(se, &savevm_state.handlers, entry) {
1546         if (!strcmp(se->idstr, idstr) &&
1547             (instance_id == se->instance_id ||
1548              instance_id == se->alias_id))
1549             return se;
1550         /* Migrating from an older version? */
1551         if (strstr(se->idstr, idstr) && se->compat) {
1552             if (!strcmp(se->compat->idstr, idstr) &&
1553                 (instance_id == se->compat->instance_id ||
1554                  instance_id == se->alias_id))
1555                 return se;
1556         }
1557     }
1558     return NULL;
1559 }
1560
1561 enum LoadVMExitCodes {
1562     /* Allow a command to quit all layers of nested loadvm loops */
1563     LOADVM_QUIT     =  1,
1564 };
1565
1566 /* ------ incoming postcopy messages ------ */
1567 /* 'advise' arrives before any transfers just to tell us that a postcopy
1568  * *might* happen - it might be skipped if precopy transferred everything
1569  * quickly.
1570  */
1571 static int loadvm_postcopy_handle_advise(MigrationIncomingState *mis,
1572                                          uint16_t len)
1573 {
1574     PostcopyState ps = postcopy_state_set(POSTCOPY_INCOMING_ADVISE);
1575     uint64_t remote_pagesize_summary, local_pagesize_summary, remote_tps;
1576     Error *local_err = NULL;
1577
1578     trace_loadvm_postcopy_handle_advise();
1579     if (ps != POSTCOPY_INCOMING_NONE) {
1580         error_report("CMD_POSTCOPY_ADVISE in wrong postcopy state (%d)", ps);
1581         return -1;
1582     }
1583
1584     switch (len) {
1585     case 0:
1586         if (migrate_postcopy_ram()) {
1587             error_report("RAM postcopy is enabled but have 0 byte advise");
1588             return -EINVAL;
1589         }
1590         return 0;
1591     case 8 + 8:
1592         if (!migrate_postcopy_ram()) {
1593             error_report("RAM postcopy is disabled but have 16 byte advise");
1594             return -EINVAL;
1595         }
1596         break;
1597     default:
1598         error_report("CMD_POSTCOPY_ADVISE invalid length (%d)", len);
1599         return -EINVAL;
1600     }
1601
1602     if (!postcopy_ram_supported_by_host(mis)) {
1603         postcopy_state_set(POSTCOPY_INCOMING_NONE);
1604         return -1;
1605     }
1606
1607     remote_pagesize_summary = qemu_get_be64(mis->from_src_file);
1608     local_pagesize_summary = ram_pagesize_summary();
1609
1610     if (remote_pagesize_summary != local_pagesize_summary)  {
1611         /*
1612          * This detects two potential causes of mismatch:
1613          *   a) A mismatch in host page sizes
1614          *      Some combinations of mismatch are probably possible but it gets
1615          *      a bit more complicated.  In particular we need to place whole
1616          *      host pages on the dest at once, and we need to ensure that we
1617          *      handle dirtying to make sure we never end up sending part of
1618          *      a hostpage on it's own.
1619          *   b) The use of different huge page sizes on source/destination
1620          *      a more fine grain test is performed during RAM block migration
1621          *      but this test here causes a nice early clear failure, and
1622          *      also fails when passed to an older qemu that doesn't
1623          *      do huge pages.
1624          */
1625         error_report("Postcopy needs matching RAM page sizes (s=%" PRIx64
1626                                                              " d=%" PRIx64 ")",
1627                      remote_pagesize_summary, local_pagesize_summary);
1628         return -1;
1629     }
1630
1631     remote_tps = qemu_get_be64(mis->from_src_file);
1632     if (remote_tps != qemu_target_page_size()) {
1633         /*
1634          * Again, some differences could be dealt with, but for now keep it
1635          * simple.
1636          */
1637         error_report("Postcopy needs matching target page sizes (s=%d d=%zd)",
1638                      (int)remote_tps, qemu_target_page_size());
1639         return -1;
1640     }
1641
1642     if (postcopy_notify(POSTCOPY_NOTIFY_INBOUND_ADVISE, &local_err)) {
1643         error_report_err(local_err);
1644         return -1;
1645     }
1646
1647     if (ram_postcopy_incoming_init(mis)) {
1648         return -1;
1649     }
1650
1651     return 0;
1652 }
1653
1654 /* After postcopy we will be told to throw some pages away since they're
1655  * dirty and will have to be demand fetched.  Must happen before CPU is
1656  * started.
1657  * There can be 0..many of these messages, each encoding multiple pages.
1658  */
1659 static int loadvm_postcopy_ram_handle_discard(MigrationIncomingState *mis,
1660                                               uint16_t len)
1661 {
1662     int tmp;
1663     char ramid[256];
1664     PostcopyState ps = postcopy_state_get();
1665
1666     trace_loadvm_postcopy_ram_handle_discard();
1667
1668     switch (ps) {
1669     case POSTCOPY_INCOMING_ADVISE:
1670         /* 1st discard */
1671         tmp = postcopy_ram_prepare_discard(mis);
1672         if (tmp) {
1673             return tmp;
1674         }
1675         break;
1676
1677     case POSTCOPY_INCOMING_DISCARD:
1678         /* Expected state */
1679         break;
1680
1681     default:
1682         error_report("CMD_POSTCOPY_RAM_DISCARD in wrong postcopy state (%d)",
1683                      ps);
1684         return -1;
1685     }
1686     /* We're expecting a
1687      *    Version (0)
1688      *    a RAM ID string (length byte, name, 0 term)
1689      *    then at least 1 16 byte chunk
1690     */
1691     if (len < (1 + 1 + 1 + 1 + 2 * 8)) {
1692         error_report("CMD_POSTCOPY_RAM_DISCARD invalid length (%d)", len);
1693         return -1;
1694     }
1695
1696     tmp = qemu_get_byte(mis->from_src_file);
1697     if (tmp != postcopy_ram_discard_version) {
1698         error_report("CMD_POSTCOPY_RAM_DISCARD invalid version (%d)", tmp);
1699         return -1;
1700     }
1701
1702     if (!qemu_get_counted_string(mis->from_src_file, ramid)) {
1703         error_report("CMD_POSTCOPY_RAM_DISCARD Failed to read RAMBlock ID");
1704         return -1;
1705     }
1706     tmp = qemu_get_byte(mis->from_src_file);
1707     if (tmp != 0) {
1708         error_report("CMD_POSTCOPY_RAM_DISCARD missing nil (%d)", tmp);
1709         return -1;
1710     }
1711
1712     len -= 3 + strlen(ramid);
1713     if (len % 16) {
1714         error_report("CMD_POSTCOPY_RAM_DISCARD invalid length (%d)", len);
1715         return -1;
1716     }
1717     trace_loadvm_postcopy_ram_handle_discard_header(ramid, len);
1718     while (len) {
1719         uint64_t start_addr, block_length;
1720         start_addr = qemu_get_be64(mis->from_src_file);
1721         block_length = qemu_get_be64(mis->from_src_file);
1722
1723         len -= 16;
1724         int ret = ram_discard_range(ramid, start_addr, block_length);
1725         if (ret) {
1726             return ret;
1727         }
1728     }
1729     trace_loadvm_postcopy_ram_handle_discard_end();
1730
1731     return 0;
1732 }
1733
1734 /*
1735  * Triggered by a postcopy_listen command; this thread takes over reading
1736  * the input stream, leaving the main thread free to carry on loading the rest
1737  * of the device state (from RAM).
1738  * (TODO:This could do with being in a postcopy file - but there again it's
1739  * just another input loop, not that postcopy specific)
1740  */
1741 static void *postcopy_ram_listen_thread(void *opaque)
1742 {
1743     MigrationIncomingState *mis = migration_incoming_get_current();
1744     QEMUFile *f = mis->from_src_file;
1745     int load_res;
1746
1747     migrate_set_state(&mis->state, MIGRATION_STATUS_ACTIVE,
1748                                    MIGRATION_STATUS_POSTCOPY_ACTIVE);
1749     qemu_sem_post(&mis->listen_thread_sem);
1750     trace_postcopy_ram_listen_thread_start();
1751
1752     rcu_register_thread();
1753     /*
1754      * Because we're a thread and not a coroutine we can't yield
1755      * in qemu_file, and thus we must be blocking now.
1756      */
1757     qemu_file_set_blocking(f, true);
1758     load_res = qemu_loadvm_state_main(f, mis);
1759
1760     /*
1761      * This is tricky, but, mis->from_src_file can change after it
1762      * returns, when postcopy recovery happened. In the future, we may
1763      * want a wrapper for the QEMUFile handle.
1764      */
1765     f = mis->from_src_file;
1766
1767     /* And non-blocking again so we don't block in any cleanup */
1768     qemu_file_set_blocking(f, false);
1769
1770     trace_postcopy_ram_listen_thread_exit();
1771     if (load_res < 0) {
1772         error_report("%s: loadvm failed: %d", __func__, load_res);
1773         qemu_file_set_error(f, load_res);
1774         migrate_set_state(&mis->state, MIGRATION_STATUS_POSTCOPY_ACTIVE,
1775                                        MIGRATION_STATUS_FAILED);
1776     } else {
1777         /*
1778          * This looks good, but it's possible that the device loading in the
1779          * main thread hasn't finished yet, and so we might not be in 'RUN'
1780          * state yet; wait for the end of the main thread.
1781          */
1782         qemu_event_wait(&mis->main_thread_load_event);
1783     }
1784     postcopy_ram_incoming_cleanup(mis);
1785
1786     if (load_res < 0) {
1787         /*
1788          * If something went wrong then we have a bad state so exit;
1789          * depending how far we got it might be possible at this point
1790          * to leave the guest running and fire MCEs for pages that never
1791          * arrived as a desperate recovery step.
1792          */
1793         rcu_unregister_thread();
1794         exit(EXIT_FAILURE);
1795     }
1796
1797     migrate_set_state(&mis->state, MIGRATION_STATUS_POSTCOPY_ACTIVE,
1798                                    MIGRATION_STATUS_COMPLETED);
1799     /*
1800      * If everything has worked fine, then the main thread has waited
1801      * for us to start, and we're the last use of the mis.
1802      * (If something broke then qemu will have to exit anyway since it's
1803      * got a bad migration state).
1804      */
1805     migration_incoming_state_destroy();
1806     qemu_loadvm_state_cleanup();
1807
1808     rcu_unregister_thread();
1809     mis->have_listen_thread = false;
1810     return NULL;
1811 }
1812
1813 /* After this message we must be able to immediately receive postcopy data */
1814 static int loadvm_postcopy_handle_listen(MigrationIncomingState *mis)
1815 {
1816     PostcopyState ps = postcopy_state_set(POSTCOPY_INCOMING_LISTENING);
1817     trace_loadvm_postcopy_handle_listen();
1818     Error *local_err = NULL;
1819
1820     if (ps != POSTCOPY_INCOMING_ADVISE && ps != POSTCOPY_INCOMING_DISCARD) {
1821         error_report("CMD_POSTCOPY_LISTEN in wrong postcopy state (%d)", ps);
1822         return -1;
1823     }
1824     if (ps == POSTCOPY_INCOMING_ADVISE) {
1825         /*
1826          * A rare case, we entered listen without having to do any discards,
1827          * so do the setup that's normally done at the time of the 1st discard.
1828          */
1829         if (migrate_postcopy_ram()) {
1830             postcopy_ram_prepare_discard(mis);
1831         }
1832     }
1833
1834     /*
1835      * Sensitise RAM - can now generate requests for blocks that don't exist
1836      * However, at this point the CPU shouldn't be running, and the IO
1837      * shouldn't be doing anything yet so don't actually expect requests
1838      */
1839     if (migrate_postcopy_ram()) {
1840         if (postcopy_ram_enable_notify(mis)) {
1841             postcopy_ram_incoming_cleanup(mis);
1842             return -1;
1843         }
1844     }
1845
1846     if (postcopy_notify(POSTCOPY_NOTIFY_INBOUND_LISTEN, &local_err)) {
1847         error_report_err(local_err);
1848         return -1;
1849     }
1850
1851     if (mis->have_listen_thread) {
1852         error_report("CMD_POSTCOPY_RAM_LISTEN already has a listen thread");
1853         return -1;
1854     }
1855
1856     mis->have_listen_thread = true;
1857     /* Start up the listening thread and wait for it to signal ready */
1858     qemu_sem_init(&mis->listen_thread_sem, 0);
1859     qemu_thread_create(&mis->listen_thread, "postcopy/listen",
1860                        postcopy_ram_listen_thread, NULL,
1861                        QEMU_THREAD_DETACHED);
1862     qemu_sem_wait(&mis->listen_thread_sem);
1863     qemu_sem_destroy(&mis->listen_thread_sem);
1864
1865     return 0;
1866 }
1867
1868
1869 typedef struct {
1870     QEMUBH *bh;
1871 } HandleRunBhData;
1872
1873 static void loadvm_postcopy_handle_run_bh(void *opaque)
1874 {
1875     Error *local_err = NULL;
1876     HandleRunBhData *data = opaque;
1877     MigrationIncomingState *mis = migration_incoming_get_current();
1878
1879     /* TODO we should move all of this lot into postcopy_ram.c or a shared code
1880      * in migration.c
1881      */
1882     cpu_synchronize_all_post_init();
1883
1884     qemu_announce_self(&mis->announce_timer, migrate_announce_params());
1885
1886     /* Make sure all file formats flush their mutable metadata.
1887      * If we get an error here, just don't restart the VM yet. */
1888     bdrv_invalidate_cache_all(&local_err);
1889     if (local_err) {
1890         error_report_err(local_err);
1891         local_err = NULL;
1892         autostart = false;
1893     }
1894
1895     trace_loadvm_postcopy_handle_run_cpu_sync();
1896
1897     trace_loadvm_postcopy_handle_run_vmstart();
1898
1899     dirty_bitmap_mig_before_vm_start();
1900
1901     if (autostart) {
1902         /* Hold onto your hats, starting the CPU */
1903         vm_start();
1904     } else {
1905         /* leave it paused and let management decide when to start the CPU */
1906         runstate_set(RUN_STATE_PAUSED);
1907     }
1908
1909     qemu_bh_delete(data->bh);
1910     g_free(data);
1911 }
1912
1913 /* After all discards we can start running and asking for pages */
1914 static int loadvm_postcopy_handle_run(MigrationIncomingState *mis)
1915 {
1916     PostcopyState ps = postcopy_state_set(POSTCOPY_INCOMING_RUNNING);
1917     HandleRunBhData *data;
1918
1919     trace_loadvm_postcopy_handle_run();
1920     if (ps != POSTCOPY_INCOMING_LISTENING) {
1921         error_report("CMD_POSTCOPY_RUN in wrong postcopy state (%d)", ps);
1922         return -1;
1923     }
1924
1925     data = g_new(HandleRunBhData, 1);
1926     data->bh = qemu_bh_new(loadvm_postcopy_handle_run_bh, data);
1927     qemu_bh_schedule(data->bh);
1928
1929     /* We need to finish reading the stream from the package
1930      * and also stop reading anything more from the stream that loaded the
1931      * package (since it's now being read by the listener thread).
1932      * LOADVM_QUIT will quit all the layers of nested loadvm loops.
1933      */
1934     return LOADVM_QUIT;
1935 }
1936
1937 static int loadvm_postcopy_handle_resume(MigrationIncomingState *mis)
1938 {
1939     if (mis->state != MIGRATION_STATUS_POSTCOPY_RECOVER) {
1940         error_report("%s: illegal resume received", __func__);
1941         /* Don't fail the load, only for this. */
1942         return 0;
1943     }
1944
1945     /*
1946      * This means source VM is ready to resume the postcopy migration.
1947      * It's time to switch state and release the fault thread to
1948      * continue service page faults.
1949      */
1950     migrate_set_state(&mis->state, MIGRATION_STATUS_POSTCOPY_RECOVER,
1951                       MIGRATION_STATUS_POSTCOPY_ACTIVE);
1952     qemu_sem_post(&mis->postcopy_pause_sem_fault);
1953
1954     trace_loadvm_postcopy_handle_resume();
1955
1956     /* Tell source that "we are ready" */
1957     migrate_send_rp_resume_ack(mis, MIGRATION_RESUME_ACK_VALUE);
1958
1959     return 0;
1960 }
1961
1962 /**
1963  * Immediately following this command is a blob of data containing an embedded
1964  * chunk of migration stream; read it and load it.
1965  *
1966  * @mis: Incoming state
1967  * @length: Length of packaged data to read
1968  *
1969  * Returns: Negative values on error
1970  *
1971  */
1972 static int loadvm_handle_cmd_packaged(MigrationIncomingState *mis)
1973 {
1974     int ret;
1975     size_t length;
1976     QIOChannelBuffer *bioc;
1977
1978     length = qemu_get_be32(mis->from_src_file);
1979     trace_loadvm_handle_cmd_packaged(length);
1980
1981     if (length > MAX_VM_CMD_PACKAGED_SIZE) {
1982         error_report("Unreasonably large packaged state: %zu", length);
1983         return -1;
1984     }
1985
1986     bioc = qio_channel_buffer_new(length);
1987     qio_channel_set_name(QIO_CHANNEL(bioc), "migration-loadvm-buffer");
1988     ret = qemu_get_buffer(mis->from_src_file,
1989                           bioc->data,
1990                           length);
1991     if (ret != length) {
1992         object_unref(OBJECT(bioc));
1993         error_report("CMD_PACKAGED: Buffer receive fail ret=%d length=%zu",
1994                      ret, length);
1995         return (ret < 0) ? ret : -EAGAIN;
1996     }
1997     bioc->usage += length;
1998     trace_loadvm_handle_cmd_packaged_received(ret);
1999
2000     QEMUFile *packf = qemu_fopen_channel_input(QIO_CHANNEL(bioc));
2001
2002     ret = qemu_loadvm_state_main(packf, mis);
2003     trace_loadvm_handle_cmd_packaged_main(ret);
2004     qemu_fclose(packf);
2005     object_unref(OBJECT(bioc));
2006
2007     return ret;
2008 }
2009
2010 /*
2011  * Handle request that source requests for recved_bitmap on
2012  * destination. Payload format:
2013  *
2014  * len (1 byte) + ramblock_name (<255 bytes)
2015  */
2016 static int loadvm_handle_recv_bitmap(MigrationIncomingState *mis,
2017                                      uint16_t len)
2018 {
2019     QEMUFile *file = mis->from_src_file;
2020     RAMBlock *rb;
2021     char block_name[256];
2022     size_t cnt;
2023
2024     cnt = qemu_get_counted_string(file, block_name);
2025     if (!cnt) {
2026         error_report("%s: failed to read block name", __func__);
2027         return -EINVAL;
2028     }
2029
2030     /* Validate before using the data */
2031     if (qemu_file_get_error(file)) {
2032         return qemu_file_get_error(file);
2033     }
2034
2035     if (len != cnt + 1) {
2036         error_report("%s: invalid payload length (%d)", __func__, len);
2037         return -EINVAL;
2038     }
2039
2040     rb = qemu_ram_block_by_name(block_name);
2041     if (!rb) {
2042         error_report("%s: block '%s' not found", __func__, block_name);
2043         return -EINVAL;
2044     }
2045
2046     migrate_send_rp_recv_bitmap(mis, block_name);
2047
2048     trace_loadvm_handle_recv_bitmap(block_name);
2049
2050     return 0;
2051 }
2052
2053 static int loadvm_process_enable_colo(MigrationIncomingState *mis)
2054 {
2055     migration_incoming_enable_colo();
2056     return colo_init_ram_cache();
2057 }
2058
2059 /*
2060  * Process an incoming 'QEMU_VM_COMMAND'
2061  * 0           just a normal return
2062  * LOADVM_QUIT All good, but exit the loop
2063  * <0          Error
2064  */
2065 static int loadvm_process_command(QEMUFile *f)
2066 {
2067     MigrationIncomingState *mis = migration_incoming_get_current();
2068     uint16_t cmd;
2069     uint16_t len;
2070     uint32_t tmp32;
2071
2072     cmd = qemu_get_be16(f);
2073     len = qemu_get_be16(f);
2074
2075     /* Check validity before continue processing of cmds */
2076     if (qemu_file_get_error(f)) {
2077         return qemu_file_get_error(f);
2078     }
2079
2080     trace_loadvm_process_command(cmd, len);
2081     if (cmd >= MIG_CMD_MAX || cmd == MIG_CMD_INVALID) {
2082         error_report("MIG_CMD 0x%x unknown (len 0x%x)", cmd, len);
2083         return -EINVAL;
2084     }
2085
2086     if (mig_cmd_args[cmd].len != -1 && mig_cmd_args[cmd].len != len) {
2087         error_report("%s received with bad length - expecting %zu, got %d",
2088                      mig_cmd_args[cmd].name,
2089                      (size_t)mig_cmd_args[cmd].len, len);
2090         return -ERANGE;
2091     }
2092
2093     switch (cmd) {
2094     case MIG_CMD_OPEN_RETURN_PATH:
2095         if (mis->to_src_file) {
2096             error_report("CMD_OPEN_RETURN_PATH called when RP already open");
2097             /* Not really a problem, so don't give up */
2098             return 0;
2099         }
2100         mis->to_src_file = qemu_file_get_return_path(f);
2101         if (!mis->to_src_file) {
2102             error_report("CMD_OPEN_RETURN_PATH failed");
2103             return -1;
2104         }
2105         break;
2106
2107     case MIG_CMD_PING:
2108         tmp32 = qemu_get_be32(f);
2109         trace_loadvm_process_command_ping(tmp32);
2110         if (!mis->to_src_file) {
2111             error_report("CMD_PING (0x%x) received with no return path",
2112                          tmp32);
2113             return -1;
2114         }
2115         migrate_send_rp_pong(mis, tmp32);
2116         break;
2117
2118     case MIG_CMD_PACKAGED:
2119         return loadvm_handle_cmd_packaged(mis);
2120
2121     case MIG_CMD_POSTCOPY_ADVISE:
2122         return loadvm_postcopy_handle_advise(mis, len);
2123
2124     case MIG_CMD_POSTCOPY_LISTEN:
2125         return loadvm_postcopy_handle_listen(mis);
2126
2127     case MIG_CMD_POSTCOPY_RUN:
2128         return loadvm_postcopy_handle_run(mis);
2129
2130     case MIG_CMD_POSTCOPY_RAM_DISCARD:
2131         return loadvm_postcopy_ram_handle_discard(mis, len);
2132
2133     case MIG_CMD_POSTCOPY_RESUME:
2134         return loadvm_postcopy_handle_resume(mis);
2135
2136     case MIG_CMD_RECV_BITMAP:
2137         return loadvm_handle_recv_bitmap(mis, len);
2138
2139     case MIG_CMD_ENABLE_COLO:
2140         return loadvm_process_enable_colo(mis);
2141     }
2142
2143     return 0;
2144 }
2145
2146 /*
2147  * Read a footer off the wire and check that it matches the expected section
2148  *
2149  * Returns: true if the footer was good
2150  *          false if there is a problem (and calls error_report to say why)
2151  */
2152 static bool check_section_footer(QEMUFile *f, SaveStateEntry *se)
2153 {
2154     int ret;
2155     uint8_t read_mark;
2156     uint32_t read_section_id;
2157
2158     if (!migrate_get_current()->send_section_footer) {
2159         /* No footer to check */
2160         return true;
2161     }
2162
2163     read_mark = qemu_get_byte(f);
2164
2165     ret = qemu_file_get_error(f);
2166     if (ret) {
2167         error_report("%s: Read section footer failed: %d",
2168                      __func__, ret);
2169         return false;
2170     }
2171
2172     if (read_mark != QEMU_VM_SECTION_FOOTER) {
2173         error_report("Missing section footer for %s", se->idstr);
2174         return false;
2175     }
2176
2177     read_section_id = qemu_get_be32(f);
2178     if (read_section_id != se->load_section_id) {
2179         error_report("Mismatched section id in footer for %s -"
2180                      " read 0x%x expected 0x%x",
2181                      se->idstr, read_section_id, se->load_section_id);
2182         return false;
2183     }
2184
2185     /* All good */
2186     return true;
2187 }
2188
2189 static int
2190 qemu_loadvm_section_start_full(QEMUFile *f, MigrationIncomingState *mis)
2191 {
2192     uint32_t instance_id, version_id, section_id;
2193     SaveStateEntry *se;
2194     char idstr[256];
2195     int ret;
2196
2197     /* Read section start */
2198     section_id = qemu_get_be32(f);
2199     if (!qemu_get_counted_string(f, idstr)) {
2200         error_report("Unable to read ID string for section %u",
2201                      section_id);
2202         return -EINVAL;
2203     }
2204     instance_id = qemu_get_be32(f);
2205     version_id = qemu_get_be32(f);
2206
2207     ret = qemu_file_get_error(f);
2208     if (ret) {
2209         error_report("%s: Failed to read instance/version ID: %d",
2210                      __func__, ret);
2211         return ret;
2212     }
2213
2214     trace_qemu_loadvm_state_section_startfull(section_id, idstr,
2215             instance_id, version_id);
2216     /* Find savevm section */
2217     se = find_se(idstr, instance_id);
2218     if (se == NULL) {
2219         error_report("Unknown savevm section or instance '%s' %d. "
2220                      "Make sure that your current VM setup matches your "
2221                      "saved VM setup, including any hotplugged devices",
2222                      idstr, instance_id);
2223         return -EINVAL;
2224     }
2225
2226     /* Validate version */
2227     if (version_id > se->version_id) {
2228         error_report("savevm: unsupported version %d for '%s' v%d",
2229                      version_id, idstr, se->version_id);
2230         return -EINVAL;
2231     }
2232     se->load_version_id = version_id;
2233     se->load_section_id = section_id;
2234
2235     /* Validate if it is a device's state */
2236     if (xen_enabled() && se->is_ram) {
2237         error_report("loadvm: %s RAM loading not allowed on Xen", idstr);
2238         return -EINVAL;
2239     }
2240
2241     ret = vmstate_load(f, se);
2242     if (ret < 0) {
2243         error_report("error while loading state for instance 0x%x of"
2244                      " device '%s'", instance_id, idstr);
2245         return ret;
2246     }
2247     if (!check_section_footer(f, se)) {
2248         return -EINVAL;
2249     }
2250
2251     return 0;
2252 }
2253
2254 static int
2255 qemu_loadvm_section_part_end(QEMUFile *f, MigrationIncomingState *mis)
2256 {
2257     uint32_t section_id;
2258     SaveStateEntry *se;
2259     int ret;
2260
2261     section_id = qemu_get_be32(f);
2262
2263     ret = qemu_file_get_error(f);
2264     if (ret) {
2265         error_report("%s: Failed to read section ID: %d",
2266                      __func__, ret);
2267         return ret;
2268     }
2269
2270     trace_qemu_loadvm_state_section_partend(section_id);
2271     QTAILQ_FOREACH(se, &savevm_state.handlers, entry) {
2272         if (se->load_section_id == section_id) {
2273             break;
2274         }
2275     }
2276     if (se == NULL) {
2277         error_report("Unknown savevm section %d", section_id);
2278         return -EINVAL;
2279     }
2280
2281     ret = vmstate_load(f, se);
2282     if (ret < 0) {
2283         error_report("error while loading state section id %d(%s)",
2284                      section_id, se->idstr);
2285         return ret;
2286     }
2287     if (!check_section_footer(f, se)) {
2288         return -EINVAL;
2289     }
2290
2291     return 0;
2292 }
2293
2294 static int qemu_loadvm_state_header(QEMUFile *f)
2295 {
2296     unsigned int v;
2297     int ret;
2298
2299     v = qemu_get_be32(f);
2300     if (v != QEMU_VM_FILE_MAGIC) {
2301         error_report("Not a migration stream");
2302         return -EINVAL;
2303     }
2304
2305     v = qemu_get_be32(f);
2306     if (v == QEMU_VM_FILE_VERSION_COMPAT) {
2307         error_report("SaveVM v2 format is obsolete and don't work anymore");
2308         return -ENOTSUP;
2309     }
2310     if (v != QEMU_VM_FILE_VERSION) {
2311         error_report("Unsupported migration stream version");
2312         return -ENOTSUP;
2313     }
2314
2315     if (migrate_get_current()->send_configuration) {
2316         if (qemu_get_byte(f) != QEMU_VM_CONFIGURATION) {
2317             error_report("Configuration section missing");
2318             qemu_loadvm_state_cleanup();
2319             return -EINVAL;
2320         }
2321         ret = vmstate_load_state(f, &vmstate_configuration, &savevm_state, 0);
2322
2323         if (ret) {
2324             qemu_loadvm_state_cleanup();
2325             return ret;
2326         }
2327     }
2328     return 0;
2329 }
2330
2331 static int qemu_loadvm_state_setup(QEMUFile *f)
2332 {
2333     SaveStateEntry *se;
2334     int ret;
2335
2336     trace_loadvm_state_setup();
2337     QTAILQ_FOREACH(se, &savevm_state.handlers, entry) {
2338         if (!se->ops || !se->ops->load_setup) {
2339             continue;
2340         }
2341         if (se->ops && se->ops->is_active) {
2342             if (!se->ops->is_active(se->opaque)) {
2343                 continue;
2344             }
2345         }
2346
2347         ret = se->ops->load_setup(f, se->opaque);
2348         if (ret < 0) {
2349             qemu_file_set_error(f, ret);
2350             error_report("Load state of device %s failed", se->idstr);
2351             return ret;
2352         }
2353     }
2354     return 0;
2355 }
2356
2357 void qemu_loadvm_state_cleanup(void)
2358 {
2359     SaveStateEntry *se;
2360
2361     trace_loadvm_state_cleanup();
2362     QTAILQ_FOREACH(se, &savevm_state.handlers, entry) {
2363         if (se->ops && se->ops->load_cleanup) {
2364             se->ops->load_cleanup(se->opaque);
2365         }
2366     }
2367 }
2368
2369 /* Return true if we should continue the migration, or false. */
2370 static bool postcopy_pause_incoming(MigrationIncomingState *mis)
2371 {
2372     trace_postcopy_pause_incoming();
2373
2374     /* Clear the triggered bit to allow one recovery */
2375     mis->postcopy_recover_triggered = false;
2376
2377     assert(mis->from_src_file);
2378     qemu_file_shutdown(mis->from_src_file);
2379     qemu_fclose(mis->from_src_file);
2380     mis->from_src_file = NULL;
2381
2382     assert(mis->to_src_file);
2383     qemu_file_shutdown(mis->to_src_file);
2384     qemu_mutex_lock(&mis->rp_mutex);
2385     qemu_fclose(mis->to_src_file);
2386     mis->to_src_file = NULL;
2387     qemu_mutex_unlock(&mis->rp_mutex);
2388
2389     migrate_set_state(&mis->state, MIGRATION_STATUS_POSTCOPY_ACTIVE,
2390                       MIGRATION_STATUS_POSTCOPY_PAUSED);
2391
2392     /* Notify the fault thread for the invalidated file handle */
2393     postcopy_fault_thread_notify(mis);
2394
2395     error_report("Detected IO failure for postcopy. "
2396                  "Migration paused.");
2397
2398     while (mis->state == MIGRATION_STATUS_POSTCOPY_PAUSED) {
2399         qemu_sem_wait(&mis->postcopy_pause_sem_dst);
2400     }
2401
2402     trace_postcopy_pause_incoming_continued();
2403
2404     return true;
2405 }
2406
2407 int qemu_loadvm_state_main(QEMUFile *f, MigrationIncomingState *mis)
2408 {
2409     uint8_t section_type;
2410     int ret = 0;
2411
2412 retry:
2413     while (true) {
2414         section_type = qemu_get_byte(f);
2415
2416         if (qemu_file_get_error(f)) {
2417             ret = qemu_file_get_error(f);
2418             break;
2419         }
2420
2421         trace_qemu_loadvm_state_section(section_type);
2422         switch (section_type) {
2423         case QEMU_VM_SECTION_START:
2424         case QEMU_VM_SECTION_FULL:
2425             ret = qemu_loadvm_section_start_full(f, mis);
2426             if (ret < 0) {
2427                 goto out;
2428             }
2429             break;
2430         case QEMU_VM_SECTION_PART:
2431         case QEMU_VM_SECTION_END:
2432             ret = qemu_loadvm_section_part_end(f, mis);
2433             if (ret < 0) {
2434                 goto out;
2435             }
2436             break;
2437         case QEMU_VM_COMMAND:
2438             ret = loadvm_process_command(f);
2439             trace_qemu_loadvm_state_section_command(ret);
2440             if ((ret < 0) || (ret == LOADVM_QUIT)) {
2441                 goto out;
2442             }
2443             break;
2444         case QEMU_VM_EOF:
2445             /* This is the end of migration */
2446             goto out;
2447         default:
2448             error_report("Unknown savevm section type %d", section_type);
2449             ret = -EINVAL;
2450             goto out;
2451         }
2452     }
2453
2454 out:
2455     if (ret < 0) {
2456         qemu_file_set_error(f, ret);
2457
2458         /*
2459          * If we are during an active postcopy, then we pause instead
2460          * of bail out to at least keep the VM's dirty data.  Note
2461          * that POSTCOPY_INCOMING_LISTENING stage is still not enough,
2462          * during which we're still receiving device states and we
2463          * still haven't yet started the VM on destination.
2464          */
2465         if (postcopy_state_get() == POSTCOPY_INCOMING_RUNNING &&
2466             postcopy_pause_incoming(mis)) {
2467             /* Reset f to point to the newly created channel */
2468             f = mis->from_src_file;
2469             goto retry;
2470         }
2471     }
2472     return ret;
2473 }
2474
2475 int qemu_loadvm_state(QEMUFile *f)
2476 {
2477     MigrationIncomingState *mis = migration_incoming_get_current();
2478     Error *local_err = NULL;
2479     int ret;
2480
2481     if (qemu_savevm_state_blocked(&local_err)) {
2482         error_report_err(local_err);
2483         return -EINVAL;
2484     }
2485
2486     ret = qemu_loadvm_state_header(f);
2487     if (ret) {
2488         return ret;
2489     }
2490
2491     if (qemu_loadvm_state_setup(f) != 0) {
2492         return -EINVAL;
2493     }
2494
2495     cpu_synchronize_all_pre_loadvm();
2496
2497     ret = qemu_loadvm_state_main(f, mis);
2498     qemu_event_set(&mis->main_thread_load_event);
2499
2500     trace_qemu_loadvm_state_post_main(ret);
2501
2502     if (mis->have_listen_thread) {
2503         /* Listen thread still going, can't clean up yet */
2504         return ret;
2505     }
2506
2507     if (ret == 0) {
2508         ret = qemu_file_get_error(f);
2509     }
2510
2511     /*
2512      * Try to read in the VMDESC section as well, so that dumping tools that
2513      * intercept our migration stream have the chance to see it.
2514      */
2515
2516     /* We've got to be careful; if we don't read the data and just shut the fd
2517      * then the sender can error if we close while it's still sending.
2518      * We also mustn't read data that isn't there; some transports (RDMA)
2519      * will stall waiting for that data when the source has already closed.
2520      */
2521     if (ret == 0 && should_send_vmdesc()) {
2522         uint8_t *buf;
2523         uint32_t size;
2524         uint8_t  section_type = qemu_get_byte(f);
2525
2526         if (section_type != QEMU_VM_VMDESCRIPTION) {
2527             error_report("Expected vmdescription section, but got %d",
2528                          section_type);
2529             /*
2530              * It doesn't seem worth failing at this point since
2531              * we apparently have an otherwise valid VM state
2532              */
2533         } else {
2534             buf = g_malloc(0x1000);
2535             size = qemu_get_be32(f);
2536
2537             while (size > 0) {
2538                 uint32_t read_chunk = MIN(size, 0x1000);
2539                 qemu_get_buffer(f, buf, read_chunk);
2540                 size -= read_chunk;
2541             }
2542             g_free(buf);
2543         }
2544     }
2545
2546     qemu_loadvm_state_cleanup();
2547     cpu_synchronize_all_post_init();
2548
2549     return ret;
2550 }
2551
2552 int qemu_load_device_state(QEMUFile *f)
2553 {
2554     MigrationIncomingState *mis = migration_incoming_get_current();
2555     int ret;
2556
2557     /* Load QEMU_VM_SECTION_FULL section */
2558     ret = qemu_loadvm_state_main(f, mis);
2559     if (ret < 0) {
2560         error_report("Failed to load device state: %d", ret);
2561         return ret;
2562     }
2563
2564     cpu_synchronize_all_post_init();
2565     return 0;
2566 }
2567
2568 int save_snapshot(const char *name, Error **errp)
2569 {
2570     BlockDriverState *bs, *bs1;
2571     QEMUSnapshotInfo sn1, *sn = &sn1, old_sn1, *old_sn = &old_sn1;
2572     int ret = -1;
2573     QEMUFile *f;
2574     int saved_vm_running;
2575     uint64_t vm_state_size;
2576     qemu_timeval tv;
2577     struct tm tm;
2578     AioContext *aio_context;
2579
2580     if (migration_is_blocked(errp)) {
2581         return ret;
2582     }
2583
2584     if (!replay_can_snapshot()) {
2585         error_setg(errp, "Record/replay does not allow making snapshot "
2586                    "right now. Try once more later.");
2587         return ret;
2588     }
2589
2590     if (!bdrv_all_can_snapshot(&bs)) {
2591         error_setg(errp, "Device '%s' is writable but does not support "
2592                    "snapshots", bdrv_get_device_name(bs));
2593         return ret;
2594     }
2595
2596     /* Delete old snapshots of the same name */
2597     if (name) {
2598         ret = bdrv_all_delete_snapshot(name, &bs1, errp);
2599         if (ret < 0) {
2600             error_prepend(errp, "Error while deleting snapshot on device "
2601                           "'%s': ", bdrv_get_device_name(bs1));
2602             return ret;
2603         }
2604     }
2605
2606     bs = bdrv_all_find_vmstate_bs();
2607     if (bs == NULL) {
2608         error_setg(errp, "No block device can accept snapshots");
2609         return ret;
2610     }
2611     aio_context = bdrv_get_aio_context(bs);
2612
2613     saved_vm_running = runstate_is_running();
2614
2615     ret = global_state_store();
2616     if (ret) {
2617         error_setg(errp, "Error saving global state");
2618         return ret;
2619     }
2620     vm_stop(RUN_STATE_SAVE_VM);
2621
2622     bdrv_drain_all_begin();
2623
2624     aio_context_acquire(aio_context);
2625
2626     memset(sn, 0, sizeof(*sn));
2627
2628     /* fill auxiliary fields */
2629     qemu_gettimeofday(&tv);
2630     sn->date_sec = tv.tv_sec;
2631     sn->date_nsec = tv.tv_usec * 1000;
2632     sn->vm_clock_nsec = qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL);
2633
2634     if (name) {
2635         ret = bdrv_snapshot_find(bs, old_sn, name);
2636         if (ret >= 0) {
2637             pstrcpy(sn->name, sizeof(sn->name), old_sn->name);
2638             pstrcpy(sn->id_str, sizeof(sn->id_str), old_sn->id_str);
2639         } else {
2640             pstrcpy(sn->name, sizeof(sn->name), name);
2641         }
2642     } else {
2643         /* cast below needed for OpenBSD where tv_sec is still 'long' */
2644         localtime_r((const time_t *)&tv.tv_sec, &tm);
2645         strftime(sn->name, sizeof(sn->name), "vm-%Y%m%d%H%M%S", &tm);
2646     }
2647
2648     /* save the VM state */
2649     f = qemu_fopen_bdrv(bs, 1);
2650     if (!f) {
2651         error_setg(errp, "Could not open VM state file");
2652         goto the_end;
2653     }
2654     ret = qemu_savevm_state(f, errp);
2655     vm_state_size = qemu_ftell(f);
2656     qemu_fclose(f);
2657     if (ret < 0) {
2658         goto the_end;
2659     }
2660
2661     /* The bdrv_all_create_snapshot() call that follows acquires the AioContext
2662      * for itself.  BDRV_POLL_WHILE() does not support nested locking because
2663      * it only releases the lock once.  Therefore synchronous I/O will deadlock
2664      * unless we release the AioContext before bdrv_all_create_snapshot().
2665      */
2666     aio_context_release(aio_context);
2667     aio_context = NULL;
2668
2669     ret = bdrv_all_create_snapshot(sn, bs, vm_state_size, &bs);
2670     if (ret < 0) {
2671         error_setg(errp, "Error while creating snapshot on '%s'",
2672                    bdrv_get_device_name(bs));
2673         goto the_end;
2674     }
2675
2676     ret = 0;
2677
2678  the_end:
2679     if (aio_context) {
2680         aio_context_release(aio_context);
2681     }
2682
2683     bdrv_drain_all_end();
2684
2685     if (saved_vm_running) {
2686         vm_start();
2687     }
2688     return ret;
2689 }
2690
2691 void qmp_xen_save_devices_state(const char *filename, bool has_live, bool live,
2692                                 Error **errp)
2693 {
2694     QEMUFile *f;
2695     QIOChannelFile *ioc;
2696     int saved_vm_running;
2697     int ret;
2698
2699     if (!has_live) {
2700         /* live default to true so old version of Xen tool stack can have a
2701          * successfull live migration */
2702         live = true;
2703     }
2704
2705     saved_vm_running = runstate_is_running();
2706     vm_stop(RUN_STATE_SAVE_VM);
2707     global_state_store_running();
2708
2709     ioc = qio_channel_file_new_path(filename, O_WRONLY | O_CREAT, 0660, errp);
2710     if (!ioc) {
2711         goto the_end;
2712     }
2713     qio_channel_set_name(QIO_CHANNEL(ioc), "migration-xen-save-state");
2714     f = qemu_fopen_channel_output(QIO_CHANNEL(ioc));
2715     object_unref(OBJECT(ioc));
2716     ret = qemu_save_device_state(f);
2717     if (ret < 0 || qemu_fclose(f) < 0) {
2718         error_setg(errp, QERR_IO_ERROR);
2719     } else {
2720         /* libxl calls the QMP command "stop" before calling
2721          * "xen-save-devices-state" and in case of migration failure, libxl
2722          * would call "cont".
2723          * So call bdrv_inactivate_all (release locks) here to let the other
2724          * side of the migration take controle of the images.
2725          */
2726         if (live && !saved_vm_running) {
2727             ret = bdrv_inactivate_all();
2728             if (ret) {
2729                 error_setg(errp, "%s: bdrv_inactivate_all() failed (%d)",
2730                            __func__, ret);
2731             }
2732         }
2733     }
2734
2735  the_end:
2736     if (saved_vm_running) {
2737         vm_start();
2738     }
2739 }
2740
2741 void qmp_xen_load_devices_state(const char *filename, Error **errp)
2742 {
2743     QEMUFile *f;
2744     QIOChannelFile *ioc;
2745     int ret;
2746
2747     /* Guest must be paused before loading the device state; the RAM state
2748      * will already have been loaded by xc
2749      */
2750     if (runstate_is_running()) {
2751         error_setg(errp, "Cannot update device state while vm is running");
2752         return;
2753     }
2754     vm_stop(RUN_STATE_RESTORE_VM);
2755
2756     ioc = qio_channel_file_new_path(filename, O_RDONLY | O_BINARY, 0, errp);
2757     if (!ioc) {
2758         return;
2759     }
2760     qio_channel_set_name(QIO_CHANNEL(ioc), "migration-xen-load-state");
2761     f = qemu_fopen_channel_input(QIO_CHANNEL(ioc));
2762     object_unref(OBJECT(ioc));
2763
2764     ret = qemu_loadvm_state(f);
2765     qemu_fclose(f);
2766     if (ret < 0) {
2767         error_setg(errp, QERR_IO_ERROR);
2768     }
2769     migration_incoming_state_destroy();
2770 }
2771
2772 int load_snapshot(const char *name, Error **errp)
2773 {
2774     BlockDriverState *bs, *bs_vm_state;
2775     QEMUSnapshotInfo sn;
2776     QEMUFile *f;
2777     int ret;
2778     AioContext *aio_context;
2779     MigrationIncomingState *mis = migration_incoming_get_current();
2780
2781     if (!replay_can_snapshot()) {
2782         error_setg(errp, "Record/replay does not allow loading snapshot "
2783                    "right now. Try once more later.");
2784         return -EINVAL;
2785     }
2786
2787     if (!bdrv_all_can_snapshot(&bs)) {
2788         error_setg(errp,
2789                    "Device '%s' is writable but does not support snapshots",
2790                    bdrv_get_device_name(bs));
2791         return -ENOTSUP;
2792     }
2793     ret = bdrv_all_find_snapshot(name, &bs);
2794     if (ret < 0) {
2795         error_setg(errp,
2796                    "Device '%s' does not have the requested snapshot '%s'",
2797                    bdrv_get_device_name(bs), name);
2798         return ret;
2799     }
2800
2801     bs_vm_state = bdrv_all_find_vmstate_bs();
2802     if (!bs_vm_state) {
2803         error_setg(errp, "No block device supports snapshots");
2804         return -ENOTSUP;
2805     }
2806     aio_context = bdrv_get_aio_context(bs_vm_state);
2807
2808     /* Don't even try to load empty VM states */
2809     aio_context_acquire(aio_context);
2810     ret = bdrv_snapshot_find(bs_vm_state, &sn, name);
2811     aio_context_release(aio_context);
2812     if (ret < 0) {
2813         return ret;
2814     } else if (sn.vm_state_size == 0) {
2815         error_setg(errp, "This is a disk-only snapshot. Revert to it "
2816                    " offline using qemu-img");
2817         return -EINVAL;
2818     }
2819
2820     /* Flush all IO requests so they don't interfere with the new state.  */
2821     bdrv_drain_all_begin();
2822
2823     ret = bdrv_all_goto_snapshot(name, &bs, errp);
2824     if (ret < 0) {
2825         error_prepend(errp, "Could not load snapshot '%s' on '%s': ",
2826                       name, bdrv_get_device_name(bs));
2827         goto err_drain;
2828     }
2829
2830     /* restore the VM state */
2831     f = qemu_fopen_bdrv(bs_vm_state, 0);
2832     if (!f) {
2833         error_setg(errp, "Could not open VM state file");
2834         ret = -EINVAL;
2835         goto err_drain;
2836     }
2837
2838     qemu_system_reset(SHUTDOWN_CAUSE_NONE);
2839     mis->from_src_file = f;
2840
2841     aio_context_acquire(aio_context);
2842     ret = qemu_loadvm_state(f);
2843     migration_incoming_state_destroy();
2844     aio_context_release(aio_context);
2845
2846     bdrv_drain_all_end();
2847
2848     if (ret < 0) {
2849         error_setg(errp, "Error %d while loading VM state", ret);
2850         return ret;
2851     }
2852
2853     return 0;
2854
2855 err_drain:
2856     bdrv_drain_all_end();
2857     return ret;
2858 }
2859
2860 void vmstate_register_ram(MemoryRegion *mr, DeviceState *dev)
2861 {
2862     qemu_ram_set_idstr(mr->ram_block,
2863                        memory_region_name(mr), dev);
2864     qemu_ram_set_migratable(mr->ram_block);
2865 }
2866
2867 void vmstate_unregister_ram(MemoryRegion *mr, DeviceState *dev)
2868 {
2869     qemu_ram_unset_idstr(mr->ram_block);
2870     qemu_ram_unset_migratable(mr->ram_block);
2871 }
2872
2873 void vmstate_register_ram_global(MemoryRegion *mr)
2874 {
2875     vmstate_register_ram(mr, NULL);
2876 }
2877
2878 bool vmstate_check_only_migratable(const VMStateDescription *vmsd)
2879 {
2880     /* check needed if --only-migratable is specified */
2881     if (!only_migratable) {
2882         return true;
2883     }
2884
2885     return !(vmsd && vmsd->unmigratable);
2886 }