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/qmp/qerror.h"
  44 #include "qemu/error-report.h"
  45 #include "sysemu/cpus.h"
  46 #include "exec/memory.h"
  47 #include "exec/target_page.h"
  48 #include "qmp-commands.h"
  49 #include "trace.h"
  50 #include "qemu/iov.h"
  51 #include "block/snapshot.h"
  52 #include "qemu/cutils.h"
  53 #include "io/channel-buffer.h"
  54 #include "io/channel-file.h"
  55
  56 #ifndef ETH_P_RARP
  57 #define ETH_P_RARP 0x8035
  58 #endif
  59 #define ARP_HTYPE_ETH 0x0001
  60 #define ARP_PTYPE_IP 0x0800
  61 #define ARP_OP_REQUEST_REV 0x3
  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_MAX
  82 };
  83
  84 #define MAX_VM_CMD_PACKAGED_SIZE (1ul << 24)
  85 static struct mig_cmd_args {
  86     ssize_t     len; /* -1 = variable */
  87     const char *name;
  88 } mig_cmd_args[] = {
  89     [MIG_CMD_INVALID]          = { .len = -1, .name = "INVALID" },
  90     [MIG_CMD_OPEN_RETURN_PATH] = { .len =  0, .name = "OPEN_RETURN_PATH" },
  91     [MIG_CMD_PING]             = { .len = sizeof(uint32_t), .name = "PING" },
  92     [MIG_CMD_POSTCOPY_ADVISE]  = { .len = 16, .name = "POSTCOPY_ADVISE" },
  93     [MIG_CMD_POSTCOPY_LISTEN]  = { .len =  0, .name = "POSTCOPY_LISTEN" },
  94     [MIG_CMD_POSTCOPY_RUN]     = { .len =  0, .name = "POSTCOPY_RUN" },
  95     [MIG_CMD_POSTCOPY_RAM_DISCARD] = {
  96                                    .len = -1, .name = "POSTCOPY_RAM_DISCARD" },
  97     [MIG_CMD_PACKAGED]         = { .len =  4, .name = "PACKAGED" },
  98     [MIG_CMD_MAX]              = { .len = -1, .name = "MAX" },
  99 };
 100
 101 static int announce_self_create(uint8_t *buf,
 102                                 uint8_t *mac_addr)
 103 {
 104     /* Ethernet header. */
 105     memset(buf, 0xff, 6);         /* destination MAC addr */
 106     memcpy(buf + 6, mac_addr, 6); /* source MAC addr */
 107     *(uint16_t *)(buf + 12) = htons(ETH_P_RARP); /* ethertype */
 108
 109     /* RARP header. */
 110     *(uint16_t *)(buf + 14) = htons(ARP_HTYPE_ETH); /* hardware addr space */
 111     *(uint16_t *)(buf + 16) = htons(ARP_PTYPE_IP); /* protocol addr space */
 112     *(buf + 18) = 6; /* hardware addr length (ethernet) */
 113     *(buf + 19) = 4; /* protocol addr length (IPv4) */
 114     *(uint16_t *)(buf + 20) = htons(ARP_OP_REQUEST_REV); /* opcode */
 115     memcpy(buf + 22, mac_addr, 6); /* source hw addr */
 116     memset(buf + 28, 0x00, 4);     /* source protocol addr */
 117     memcpy(buf + 32, mac_addr, 6); /* target hw addr */
 118     memset(buf + 38, 0x00, 4);     /* target protocol addr */
 119
 120     /* Padding to get up to 60 bytes (ethernet min packet size, minus FCS). */
 121     memset(buf + 42, 0x00, 18);
 122
 123     return 60; /* len (FCS will be added by hardware) */
 124 }
 125
 126 static void qemu_announce_self_iter(NICState *nic, void *opaque)
 127 {
 128     uint8_t buf[60];
 129     int len;
 130
 131     trace_qemu_announce_self_iter(qemu_ether_ntoa(&nic->conf->macaddr));
 132     len = announce_self_create(buf, nic->conf->macaddr.a);
 133
 134     qemu_send_packet_raw(qemu_get_queue(nic), buf, len);
 135 }
 136
 137
 138 static void qemu_announce_self_once(void *opaque)
 139 {
 140     static int count = SELF_ANNOUNCE_ROUNDS;
 141     QEMUTimer *timer = *(QEMUTimer **)opaque;
 142
 143     qemu_foreach_nic(qemu_announce_self_iter, NULL);
 144
 145     if (--count) {
 146         /* delay 50ms, 150ms, 250ms, ... */
 147         timer_mod(timer, qemu_clock_get_ms(QEMU_CLOCK_REALTIME) +
 148                   self_announce_delay(count));
 149     } else {
 150             timer_del(timer);
 151             timer_free(timer);
 152     }
 153 }
 154
 155 void qemu_announce_self(void)
 156 {
 157     static QEMUTimer *timer;
 158     timer = timer_new_ms(QEMU_CLOCK_REALTIME, qemu_announce_self_once, &timer);
 159     qemu_announce_self_once(&timer);
 160 }
 161
 162 /***********************************************************/
 163 /* savevm/loadvm support */
 164
 165 static ssize_t block_writev_buffer(void *opaque, struct iovec *iov, int iovcnt,
 166                                    int64_t pos)
 167 {
 168     int ret;
 169     QEMUIOVector qiov;
 170
 171     qemu_iovec_init_external(&qiov, iov, iovcnt);
 172     ret = bdrv_writev_vmstate(opaque, &qiov, pos);
 173     if (ret < 0) {
 174         return ret;
 175     }
 176
 177     return qiov.size;
 178 }
 179
 180 static ssize_t block_get_buffer(void *opaque, uint8_t *buf, int64_t pos,
 181                                 size_t size)
 182 {
 183     return bdrv_load_vmstate(opaque, buf, pos, size);
 184 }
 185
 186 static int bdrv_fclose(void *opaque)
 187 {
 188     return bdrv_flush(opaque);
 189 }
 190
 191 static const QEMUFileOps bdrv_read_ops = {
 192     .get_buffer = block_get_buffer,
 193     .close =      bdrv_fclose
 194 };
 195
 196 static const QEMUFileOps bdrv_write_ops = {
 197     .writev_buffer  = block_writev_buffer,
 198     .close          = bdrv_fclose
 199 };
 200
 201 static QEMUFile *qemu_fopen_bdrv(BlockDriverState *bs, int is_writable)
 202 {
 203     if (is_writable) {
 204         return qemu_fopen_ops(bs, &bdrv_write_ops);
 205     }
 206     return qemu_fopen_ops(bs, &bdrv_read_ops);
 207 }
 208
 209
 210 /* QEMUFile timer support.
 211  * Not in qemu-file.c to not add qemu-timer.c as dependency to qemu-file.c
 212  */
 213
 214 void timer_put(QEMUFile *f, QEMUTimer *ts)
 215 {
 216     uint64_t expire_time;
 217
 218     expire_time = timer_expire_time_ns(ts);
 219     qemu_put_be64(f, expire_time);
 220 }
 221
 222 void timer_get(QEMUFile *f, QEMUTimer *ts)
 223 {
 224     uint64_t expire_time;
 225
 226     expire_time = qemu_get_be64(f);
 227     if (expire_time != -1) {
 228         timer_mod_ns(ts, expire_time);
 229     } else {
 230         timer_del(ts);
 231     }
 232 }
 233
 234
 235 /* VMState timer support.
 236  * Not in vmstate.c to not add qemu-timer.c as dependency to vmstate.c
 237  */
 238
 239 static int get_timer(QEMUFile *f, void *pv, size_t size, VMStateField *field)
 240 {
 241     QEMUTimer *v = pv;
 242     timer_get(f, v);
 243     return 0;
 244 }
 245
 246 static int put_timer(QEMUFile *f, void *pv, size_t size, VMStateField *field,
 247                      QJSON *vmdesc)
 248 {
 249     QEMUTimer *v = pv;
 250     timer_put(f, v);
 251
 252     return 0;
 253 }
 254
 255 const VMStateInfo vmstate_info_timer = {
 256     .name = "timer",
 257     .get  = get_timer,
 258     .put  = put_timer,
 259 };
 260
 261
 262 typedef struct CompatEntry {
 263     char idstr[256];
 264     int instance_id;
 265 } CompatEntry;
 266
 267 typedef struct SaveStateEntry {
 268     QTAILQ_ENTRY(SaveStateEntry) entry;
 269     char idstr[256];
 270     int instance_id;
 271     int alias_id;
 272     int version_id;
 273     /* version id read from the stream */
 274     int load_version_id;
 275     int section_id;
 276     /* section id read from the stream */
 277     int load_section_id;
 278     SaveVMHandlers *ops;
 279     const VMStateDescription *vmsd;
 280     void *opaque;
 281     CompatEntry *compat;
 282     int is_ram;
 283 } SaveStateEntry;
 284
 285 typedef struct SaveState {
 286     QTAILQ_HEAD(, SaveStateEntry) handlers;
 287     int global_section_id;
 288     uint32_t len;
 289     const char *name;
 290     uint32_t target_page_bits;
 291 } SaveState;
 292
 293 static SaveState savevm_state = {
 294     .handlers = QTAILQ_HEAD_INITIALIZER(savevm_state.handlers),
 295     .global_section_id = 0,
 296 };
 297
 298 static void configuration_pre_save(void *opaque)
 299 {
 300     SaveState *state = opaque;
 301     const char *current_name = MACHINE_GET_CLASS(current_machine)->name;
 302
 303     state->len = strlen(current_name);
 304     state->name = current_name;
 305     state->target_page_bits = qemu_target_page_bits();
 306 }
 307
 308 static int configuration_pre_load(void *opaque)
 309 {
 310     SaveState *state = opaque;
 311
 312     /* If there is no target-page-bits subsection it means the source
 313      * predates the variable-target-page-bits support and is using the
 314      * minimum possible value for this CPU.
 315      */
 316     state->target_page_bits = qemu_target_page_bits_min();
 317     return 0;
 318 }
 319
 320 static int configuration_post_load(void *opaque, int version_id)
 321 {
 322     SaveState *state = opaque;
 323     const char *current_name = MACHINE_GET_CLASS(current_machine)->name;
 324
 325     if (strncmp(state->name, current_name, state->len) != 0) {
 326         error_report("Machine type received is '%.*s' and local is '%s'",
 327                      (int) state->len, state->name, current_name);
 328         return -EINVAL;
 329     }
 330
 331     if (state->target_page_bits != qemu_target_page_bits()) {
 332         error_report("Received TARGET_PAGE_BITS is %d but local is %d",
 333                      state->target_page_bits, qemu_target_page_bits());
 334         return -EINVAL;
 335     }
 336
 337     return 0;
 338 }
 339
 340 /* The target-page-bits subsection is present only if the
 341  * target page size is not the same as the default (ie the
 342  * minimum page size for a variable-page-size guest CPU).
 343  * If it is present then it contains the actual target page
 344  * bits for the machine, and migration will fail if the
 345  * two ends don't agree about it.
 346  */
 347 static bool vmstate_target_page_bits_needed(void *opaque)
 348 {
 349     return qemu_target_page_bits()
 350         > qemu_target_page_bits_min();
 351 }
 352
 353 static const VMStateDescription vmstate_target_page_bits = {
 354     .name = "configuration/target-page-bits",
 355     .version_id = 1,
 356     .minimum_version_id = 1,
 357     .needed = vmstate_target_page_bits_needed,
 358     .fields = (VMStateField[]) {
 359         VMSTATE_UINT32(target_page_bits, SaveState),
 360         VMSTATE_END_OF_LIST()
 361     }
 362 };
 363
 364 static const VMStateDescription vmstate_configuration = {
 365     .name = "configuration",
 366     .version_id = 1,
 367     .pre_load = configuration_pre_load,
 368     .post_load = configuration_post_load,
 369     .pre_save = configuration_pre_save,
 370     .fields = (VMStateField[]) {
 371         VMSTATE_UINT32(len, SaveState),
 372         VMSTATE_VBUFFER_ALLOC_UINT32(name, SaveState, 0, NULL, len),
 373         VMSTATE_END_OF_LIST()
 374     },
 375     .subsections = (const VMStateDescription*[]) {
 376         &vmstate_target_page_bits,
 377         NULL
 378     }
 379 };
 380
 381 static void dump_vmstate_vmsd(FILE *out_file,
 382                               const VMStateDescription *vmsd, int indent,
 383                               bool is_subsection);
 384
 385 static void dump_vmstate_vmsf(FILE *out_file, const VMStateField *field,
 386                               int indent)
 387 {
 388     fprintf(out_file, "%*s{\n", indent, "");
 389     indent += 2;
 390     fprintf(out_file, "%*s\"field\": \"%s\",\n", indent, "", field->name);
 391     fprintf(out_file, "%*s\"version_id\": %d,\n", indent, "",
 392             field->version_id);
 393     fprintf(out_file, "%*s\"field_exists\": %s,\n", indent, "",
 394             field->field_exists ? "true" : "false");
 395     fprintf(out_file, "%*s\"size\": %zu", indent, "", field->size);
 396     if (field->vmsd != NULL) {
 397         fprintf(out_file, ",\n");
 398         dump_vmstate_vmsd(out_file, field->vmsd, indent, false);
 399     }
 400     fprintf(out_file, "\n%*s}", indent - 2, "");
 401 }
 402
 403 static void dump_vmstate_vmss(FILE *out_file,
 404                               const VMStateDescription **subsection,
 405                               int indent)
 406 {
 407     if (*subsection != NULL) {
 408         dump_vmstate_vmsd(out_file, *subsection, indent, true);
 409     }
 410 }
 411
 412 static void dump_vmstate_vmsd(FILE *out_file,
 413                               const VMStateDescription *vmsd, int indent,
 414                               bool is_subsection)
 415 {
 416     if (is_subsection) {
 417         fprintf(out_file, "%*s{\n", indent, "");
 418     } else {
 419         fprintf(out_file, "%*s\"%s\": {\n", indent, "", "Description");
 420     }
 421     indent += 2;
 422     fprintf(out_file, "%*s\"name\": \"%s\",\n", indent, "", vmsd->name);
 423     fprintf(out_file, "%*s\"version_id\": %d,\n", indent, "",
 424             vmsd->version_id);
 425     fprintf(out_file, "%*s\"minimum_version_id\": %d", indent, "",
 426             vmsd->minimum_version_id);
 427     if (vmsd->fields != NULL) {
 428         const VMStateField *field = vmsd->fields;
 429         bool first;
 430
 431         fprintf(out_file, ",\n%*s\"Fields\": [\n", indent, "");
 432         first = true;
 433         while (field->name != NULL) {
 434             if (field->flags & VMS_MUST_EXIST) {
 435                 /* Ignore VMSTATE_VALIDATE bits; these don't get migrated */
 436                 field++;
 437                 continue;
 438             }
 439             if (!first) {
 440                 fprintf(out_file, ",\n");
 441             }
 442             dump_vmstate_vmsf(out_file, field, indent + 2);
 443             field++;
 444             first = false;
 445         }
 446         fprintf(out_file, "\n%*s]", indent, "");
 447     }
 448     if (vmsd->subsections != NULL) {
 449         const VMStateDescription **subsection = vmsd->subsections;
 450         bool first;
 451
 452         fprintf(out_file, ",\n%*s\"Subsections\": [\n", indent, "");
 453         first = true;
 454         while (*subsection != NULL) {
 455             if (!first) {
 456                 fprintf(out_file, ",\n");
 457             }
 458             dump_vmstate_vmss(out_file, subsection, indent + 2);
 459             subsection++;
 460             first = false;
 461         }
 462         fprintf(out_file, "\n%*s]", indent, "");
 463     }
 464     fprintf(out_file, "\n%*s}", indent - 2, "");
 465 }
 466
 467 static void dump_machine_type(FILE *out_file)
 468 {
 469     MachineClass *mc;
 470
 471     mc = MACHINE_GET_CLASS(current_machine);
 472
 473     fprintf(out_file, "  \"vmschkmachine\": {\n");
 474     fprintf(out_file, "    \"Name\": \"%s\"\n", mc->name);
 475     fprintf(out_file, "  },\n");
 476 }
 477
 478 void dump_vmstate_json_to_file(FILE *out_file)
 479 {
 480     GSList *list, *elt;
 481     bool first;
 482
 483     fprintf(out_file, "{\n");
 484     dump_machine_type(out_file);
 485
 486     first = true;
 487     list = object_class_get_list(TYPE_DEVICE, true);
 488     for (elt = list; elt; elt = elt->next) {
 489         DeviceClass *dc = OBJECT_CLASS_CHECK(DeviceClass, elt->data,
 490                                              TYPE_DEVICE);
 491         const char *name;
 492         int indent = 2;
 493
 494         if (!dc->vmsd) {
 495             continue;
 496         }
 497
 498         if (!first) {
 499             fprintf(out_file, ",\n");
 500         }
 501         name = object_class_get_name(OBJECT_CLASS(dc));
 502         fprintf(out_file, "%*s\"%s\": {\n", indent, "", name);
 503         indent += 2;
 504         fprintf(out_file, "%*s\"Name\": \"%s\",\n", indent, "", name);
 505         fprintf(out_file, "%*s\"version_id\": %d,\n", indent, "",
 506                 dc->vmsd->version_id);
 507         fprintf(out_file, "%*s\"minimum_version_id\": %d,\n", indent, "",
 508                 dc->vmsd->minimum_version_id);
 509
 510         dump_vmstate_vmsd(out_file, dc->vmsd, indent, false);
 511
 512         fprintf(out_file, "\n%*s}", indent - 2, "");
 513         first = false;
 514     }
 515     fprintf(out_file, "\n}\n");
 516     fclose(out_file);
 517 }
 518
 519 static int calculate_new_instance_id(const char *idstr)
 520 {
 521     SaveStateEntry *se;
 522     int instance_id = 0;
 523
 524     QTAILQ_FOREACH(se, &savevm_state.handlers, entry) {
 525         if (strcmp(idstr, se->idstr) == 0
 526             && instance_id <= se->instance_id) {
 527             instance_id = se->instance_id + 1;
 528         }
 529     }
 530     return instance_id;
 531 }
 532
 533 static int calculate_compat_instance_id(const char *idstr)
 534 {
 535     SaveStateEntry *se;
 536     int instance_id = 0;
 537
 538     QTAILQ_FOREACH(se, &savevm_state.handlers, entry) {
 539         if (!se->compat) {
 540             continue;
 541         }
 542
 543         if (strcmp(idstr, se->compat->idstr) == 0
 544             && instance_id <= se->compat->instance_id) {
 545             instance_id = se->compat->instance_id + 1;
 546         }
 547     }
 548     return instance_id;
 549 }
 550
 551 static inline MigrationPriority save_state_priority(SaveStateEntry *se)
 552 {
 553     if (se->vmsd) {
 554         return se->vmsd->priority;
 555     }
 556     return MIG_PRI_DEFAULT;
 557 }
 558
 559 static void savevm_state_handler_insert(SaveStateEntry *nse)
 560 {
 561     MigrationPriority priority = save_state_priority(nse);
 562     SaveStateEntry *se;
 563
 564     assert(priority <= MIG_PRI_MAX);
 565
 566     QTAILQ_FOREACH(se, &savevm_state.handlers, entry) {
 567         if (save_state_priority(se) < priority) {
 568             break;
 569         }
 570     }
 571
 572     if (se) {
 573         QTAILQ_INSERT_BEFORE(se, nse, entry);
 574     } else {
 575         QTAILQ_INSERT_TAIL(&savevm_state.handlers, nse, entry);
 576     }
 577 }
 578
 579 /* TODO: Individual devices generally have very little idea about the rest
 580    of the system, so instance_id should be removed/replaced.
 581    Meanwhile pass -1 as instance_id if you do not already have a clearly
 582    distinguishing id for all instances of your device class. */
 583 int register_savevm_live(DeviceState *dev,
 584                          const char *idstr,
 585                          int instance_id,
 586                          int version_id,
 587                          SaveVMHandlers *ops,
 588                          void *opaque)
 589 {
 590     SaveStateEntry *se;
 591
 592     se = g_new0(SaveStateEntry, 1);
 593     se->version_id = version_id;
 594     se->section_id = savevm_state.global_section_id++;
 595     se->ops = ops;
 596     se->opaque = opaque;
 597     se->vmsd = NULL;
 598     /* if this is a live_savem then set is_ram */
 599     if (ops->save_live_setup != NULL) {
 600         se->is_ram = 1;
 601     }
 602
 603     if (dev) {
 604         char *id = qdev_get_dev_path(dev);
 605         if (id) {
 606             if (snprintf(se->idstr, sizeof(se->idstr), "%s/", id) >=
 607                 sizeof(se->idstr)) {
 608                 error_report("Path too long for VMState (%s)", id);
 609                 g_free(id);
 610                 g_free(se);
 611
 612                 return -1;
 613             }
 614             g_free(id);
 615
 616             se->compat = g_new0(CompatEntry, 1);
 617             pstrcpy(se->compat->idstr, sizeof(se->compat->idstr), idstr);
 618             se->compat->instance_id = instance_id == -1 ?
 619                          calculate_compat_instance_id(idstr) : instance_id;
 620             instance_id = -1;
 621         }
 622     }
 623     pstrcat(se->idstr, sizeof(se->idstr), idstr);
 624
 625     if (instance_id == -1) {
 626         se->instance_id = calculate_new_instance_id(se->idstr);
 627     } else {
 628         se->instance_id = instance_id;
 629     }
 630     assert(!se->compat || se->instance_id == 0);
 631     savevm_state_handler_insert(se);
 632     return 0;
 633 }
 634
 635 void unregister_savevm(DeviceState *dev, const char *idstr, void *opaque)
 636 {
 637     SaveStateEntry *se, *new_se;
 638     char id[256] = "";
 639
 640     if (dev) {
 641         char *path = qdev_get_dev_path(dev);
 642         if (path) {
 643             pstrcpy(id, sizeof(id), path);
 644             pstrcat(id, sizeof(id), "/");
 645             g_free(path);
 646         }
 647     }
 648     pstrcat(id, sizeof(id), idstr);
 649
 650     QTAILQ_FOREACH_SAFE(se, &savevm_state.handlers, entry, new_se) {
 651         if (strcmp(se->idstr, id) == 0 && se->opaque == opaque) {
 652             QTAILQ_REMOVE(&savevm_state.handlers, se, entry);
 653             g_free(se->compat);
 654             g_free(se);
 655         }
 656     }
 657 }
 658
 659 int vmstate_register_with_alias_id(DeviceState *dev, int instance_id,
 660                                    const VMStateDescription *vmsd,
 661                                    void *opaque, int alias_id,
 662                                    int required_for_version,
 663                                    Error **errp)
 664 {
 665     SaveStateEntry *se;
 666
 667     /* If this triggers, alias support can be dropped for the vmsd. */
 668     assert(alias_id == -1 || required_for_version >= vmsd->minimum_version_id);
 669
 670     se = g_new0(SaveStateEntry, 1);
 671     se->version_id = vmsd->version_id;
 672     se->section_id = savevm_state.global_section_id++;
 673     se->opaque = opaque;
 674     se->vmsd = vmsd;
 675     se->alias_id = alias_id;
 676
 677     if (dev) {
 678         char *id = qdev_get_dev_path(dev);
 679         if (id) {
 680             if (snprintf(se->idstr, sizeof(se->idstr), "%s/", id) >=
 681                 sizeof(se->idstr)) {
 682                 error_setg(errp, "Path too long for VMState (%s)", id);
 683                 g_free(id);
 684                 g_free(se);
 685
 686                 return -1;
 687             }
 688             g_free(id);
 689
 690             se->compat = g_new0(CompatEntry, 1);
 691             pstrcpy(se->compat->idstr, sizeof(se->compat->idstr), vmsd->name);
 692             se->compat->instance_id = instance_id == -1 ?
 693                          calculate_compat_instance_id(vmsd->name) : instance_id;
 694             instance_id = -1;
 695         }
 696     }
 697     pstrcat(se->idstr, sizeof(se->idstr), vmsd->name);
 698
 699     if (instance_id == -1) {
 700         se->instance_id = calculate_new_instance_id(se->idstr);
 701     } else {
 702         se->instance_id = instance_id;
 703     }
 704     assert(!se->compat || se->instance_id == 0);
 705     savevm_state_handler_insert(se);
 706     return 0;
 707 }
 708
 709 void vmstate_unregister(DeviceState *dev, const VMStateDescription *vmsd,
 710                         void *opaque)
 711 {
 712     SaveStateEntry *se, *new_se;
 713
 714     QTAILQ_FOREACH_SAFE(se, &savevm_state.handlers, entry, new_se) {
 715         if (se->vmsd == vmsd && se->opaque == opaque) {
 716             QTAILQ_REMOVE(&savevm_state.handlers, se, entry);
 717             g_free(se->compat);
 718             g_free(se);
 719         }
 720     }
 721 }
 722
 723 static int vmstate_load(QEMUFile *f, SaveStateEntry *se)
 724 {
 725     trace_vmstate_load(se->idstr, se->vmsd ? se->vmsd->name : "(old)");
 726     if (!se->vmsd) {         /* Old style */
 727         return se->ops->load_state(f, se->opaque, se->load_version_id);
 728     }
 729     return vmstate_load_state(f, se->vmsd, se->opaque, se->load_version_id);
 730 }
 731
 732 static void vmstate_save_old_style(QEMUFile *f, SaveStateEntry *se, QJSON *vmdesc)
 733 {
 734     int64_t old_offset, size;
 735
 736     old_offset = qemu_ftell_fast(f);
 737     se->ops->save_state(f, se->opaque);
 738     size = qemu_ftell_fast(f) - old_offset;
 739
 740     if (vmdesc) {
 741         json_prop_int(vmdesc, "size", size);
 742         json_start_array(vmdesc, "fields");
 743         json_start_object(vmdesc, NULL);
 744         json_prop_str(vmdesc, "name", "data");
 745         json_prop_int(vmdesc, "size", size);
 746         json_prop_str(vmdesc, "type", "buffer");
 747         json_end_object(vmdesc);
 748         json_end_array(vmdesc);
 749     }
 750 }
 751
 752 static void vmstate_save(QEMUFile *f, SaveStateEntry *se, QJSON *vmdesc)
 753 {
 754     trace_vmstate_save(se->idstr, se->vmsd ? se->vmsd->name : "(old)");
 755     if (!se->vmsd) {
 756         vmstate_save_old_style(f, se, vmdesc);
 757         return;
 758     }
 759     vmstate_save_state(f, se->vmsd, se->opaque, vmdesc);
 760 }
 761
 762 /*
 763  * Write the header for device section (QEMU_VM_SECTION START/END/PART/FULL)
 764  */
 765 static void save_section_header(QEMUFile *f, SaveStateEntry *se,
 766                                 uint8_t section_type)
 767 {
 768     qemu_put_byte(f, section_type);
 769     qemu_put_be32(f, se->section_id);
 770
 771     if (section_type == QEMU_VM_SECTION_FULL ||
 772         section_type == QEMU_VM_SECTION_START) {
 773         /* ID string */
 774         size_t len = strlen(se->idstr);
 775         qemu_put_byte(f, len);
 776         qemu_put_buffer(f, (uint8_t *)se->idstr, len);
 777
 778         qemu_put_be32(f, se->instance_id);
 779         qemu_put_be32(f, se->version_id);
 780     }
 781 }
 782
 783 /*
 784  * Write a footer onto device sections that catches cases misformatted device
 785  * sections.
 786  */
 787 static void save_section_footer(QEMUFile *f, SaveStateEntry *se)
 788 {
 789     if (migrate_get_current()->send_section_footer) {
 790         qemu_put_byte(f, QEMU_VM_SECTION_FOOTER);
 791         qemu_put_be32(f, se->section_id);
 792     }
 793 }
 794
 795 /**
 796  * qemu_savevm_command_send: Send a 'QEMU_VM_COMMAND' type element with the
 797  *                           command and associated data.
 798  *
 799  * @f: File to send command on
 800  * @command: Command type to send
 801  * @len: Length of associated data
 802  * @data: Data associated with command.
 803  */
 804 static void qemu_savevm_command_send(QEMUFile *f,
 805                                      enum qemu_vm_cmd command,
 806                                      uint16_t len,
 807                                      uint8_t *data)
 808 {
 809     trace_savevm_command_send(command, len);
 810     qemu_put_byte(f, QEMU_VM_COMMAND);
 811     qemu_put_be16(f, (uint16_t)command);
 812     qemu_put_be16(f, len);
 813     qemu_put_buffer(f, data, len);
 814     qemu_fflush(f);
 815 }
 816
 817 void qemu_savevm_send_ping(QEMUFile *f, uint32_t value)
 818 {
 819     uint32_t buf;
 820
 821     trace_savevm_send_ping(value);
 822     buf = cpu_to_be32(value);
 823     qemu_savevm_command_send(f, MIG_CMD_PING, sizeof(value), (uint8_t *)&buf);
 824 }
 825
 826 void qemu_savevm_send_open_return_path(QEMUFile *f)
 827 {
 828     trace_savevm_send_open_return_path();
 829     qemu_savevm_command_send(f, MIG_CMD_OPEN_RETURN_PATH, 0, NULL);
 830 }
 831
 832 /* We have a buffer of data to send; we don't want that all to be loaded
 833  * by the command itself, so the command contains just the length of the
 834  * extra buffer that we then send straight after it.
 835  * TODO: Must be a better way to organise that
 836  *
 837  * Returns:
 838  *    0 on success
 839  *    -ve on error
 840  */
 841 int qemu_savevm_send_packaged(QEMUFile *f, const uint8_t *buf, size_t len)
 842 {
 843     uint32_t tmp;
 844
 845     if (len > MAX_VM_CMD_PACKAGED_SIZE) {
 846         error_report("%s: Unreasonably large packaged state: %zu",
 847                      __func__, len);
 848         return -1;
 849     }
 850
 851     tmp = cpu_to_be32(len);
 852
 853     trace_qemu_savevm_send_packaged();
 854     qemu_savevm_command_send(f, MIG_CMD_PACKAGED, 4, (uint8_t *)&tmp);
 855
 856     qemu_put_buffer(f, buf, len);
 857
 858     return 0;
 859 }
 860
 861 /* Send prior to any postcopy transfer */
 862 void qemu_savevm_send_postcopy_advise(QEMUFile *f)
 863 {
 864     uint64_t tmp[2];
 865     tmp[0] = cpu_to_be64(ram_pagesize_summary());
 866     tmp[1] = cpu_to_be64(qemu_target_page_size());
 867
 868     trace_qemu_savevm_send_postcopy_advise();
 869     qemu_savevm_command_send(f, MIG_CMD_POSTCOPY_ADVISE, 16, (uint8_t *)tmp);
 870 }
 871
 872 /* Sent prior to starting the destination running in postcopy, discard pages
 873  * that have already been sent but redirtied on the source.
 874  * CMD_POSTCOPY_RAM_DISCARD consist of:
 875  *      byte   version (0)
 876  *      byte   Length of name field (not including 0)
 877  *  n x byte   RAM block name
 878  *      byte   0 terminator (just for safety)
 879  *  n x        Byte ranges within the named RAMBlock
 880  *      be64   Start of the range
 881  *      be64   Length
 882  *
 883  *  name:  RAMBlock name that these entries are part of
 884  *  len: Number of page entries
 885  *  start_list: 'len' addresses
 886  *  length_list: 'len' addresses
 887  *
 888  */
 889 void qemu_savevm_send_postcopy_ram_discard(QEMUFile *f, const char *name,
 890                                            uint16_t len,
 891                                            uint64_t *start_list,
 892                                            uint64_t *length_list)
 893 {
 894     uint8_t *buf;
 895     uint16_t tmplen;
 896     uint16_t t;
 897     size_t name_len = strlen(name);
 898
 899     trace_qemu_savevm_send_postcopy_ram_discard(name, len);
 900     assert(name_len < 256);
 901     buf = g_malloc0(1 + 1 + name_len + 1 + (8 + 8) * len);
 902     buf[0] = postcopy_ram_discard_version;
 903     buf[1] = name_len;
 904     memcpy(buf + 2, name, name_len);
 905     tmplen = 2 + name_len;
 906     buf[tmplen++] = '\0';
 907
 908     for (t = 0; t < len; t++) {
 909         stq_be_p(buf + tmplen, start_list[t]);
 910         tmplen += 8;
 911         stq_be_p(buf + tmplen, length_list[t]);
 912         tmplen += 8;
 913     }
 914     qemu_savevm_command_send(f, MIG_CMD_POSTCOPY_RAM_DISCARD, tmplen, buf);
 915     g_free(buf);
 916 }
 917
 918 /* Get the destination into a state where it can receive postcopy data. */
 919 void qemu_savevm_send_postcopy_listen(QEMUFile *f)
 920 {
 921     trace_savevm_send_postcopy_listen();
 922     qemu_savevm_command_send(f, MIG_CMD_POSTCOPY_LISTEN, 0, NULL);
 923 }
 924
 925 /* Kick the destination into running */
 926 void qemu_savevm_send_postcopy_run(QEMUFile *f)
 927 {
 928     trace_savevm_send_postcopy_run();
 929     qemu_savevm_command_send(f, MIG_CMD_POSTCOPY_RUN, 0, NULL);
 930 }
 931
 932 bool qemu_savevm_state_blocked(Error **errp)
 933 {
 934     SaveStateEntry *se;
 935
 936     QTAILQ_FOREACH(se, &savevm_state.handlers, entry) {
 937         if (se->vmsd && se->vmsd->unmigratable) {
 938             error_setg(errp, "State blocked by non-migratable device '%s'",
 939                        se->idstr);
 940             return true;
 941         }
 942     }
 943     return false;
 944 }
 945
 946 void qemu_savevm_state_header(QEMUFile *f)
 947 {
 948     trace_savevm_state_header();
 949     qemu_put_be32(f, QEMU_VM_FILE_MAGIC);
 950     qemu_put_be32(f, QEMU_VM_FILE_VERSION);
 951
 952     if (migrate_get_current()->send_configuration) {
 953         qemu_put_byte(f, QEMU_VM_CONFIGURATION);
 954         vmstate_save_state(f, &vmstate_configuration, &savevm_state, 0);
 955     }
 956 }
 957
 958 void qemu_savevm_state_begin(QEMUFile *f)
 959 {
 960     SaveStateEntry *se;
 961     int ret;
 962
 963     trace_savevm_state_begin();
 964     QTAILQ_FOREACH(se, &savevm_state.handlers, entry) {
 965         if (!se->ops || !se->ops->save_live_setup) {
 966             continue;
 967         }
 968         if (se->ops && se->ops->is_active) {
 969             if (!se->ops->is_active(se->opaque)) {
 970                 continue;
 971             }
 972         }
 973         save_section_header(f, se, QEMU_VM_SECTION_START);
 974
 975         ret = se->ops->save_live_setup(f, se->opaque);
 976         save_section_footer(f, se);
 977         if (ret < 0) {
 978             qemu_file_set_error(f, ret);
 979             break;
 980         }
 981     }
 982 }
 983
 984 /*
 985  * this function has three return values:
 986  *   negative: there was one error, and we have -errno.
 987  *   0 : We haven't finished, caller have to go again
 988  *   1 : We have finished, we can go to complete phase
 989  */
 990 int qemu_savevm_state_iterate(QEMUFile *f, bool postcopy)
 991 {
 992     SaveStateEntry *se;
 993     int ret = 1;
 994
 995     trace_savevm_state_iterate();
 996     QTAILQ_FOREACH(se, &savevm_state.handlers, entry) {
 997         if (!se->ops || !se->ops->save_live_iterate) {
 998             continue;
 999         }
1000         if (se->ops && se->ops->is_active) {
1001             if (!se->ops->is_active(se->opaque)) {
1002                 continue;
1003             }
1004         }
1005         /*
1006          * In the postcopy phase, any device that doesn't know how to
1007          * do postcopy should have saved it's state in the _complete
1008          * call that's already run, it might get confused if we call
1009          * iterate afterwards.
1010          */
1011         if (postcopy && !se->ops->save_live_complete_postcopy) {
1012             continue;
1013         }
1014         if (qemu_file_rate_limit(f)) {
1015             return 0;
1016         }
1017         trace_savevm_section_start(se->idstr, se->section_id);
1018
1019         save_section_header(f, se, QEMU_VM_SECTION_PART);
1020
1021         ret = se->ops->save_live_iterate(f, se->opaque);
1022         trace_savevm_section_end(se->idstr, se->section_id, ret);
1023         save_section_footer(f, se);
1024
1025         if (ret < 0) {
1026             qemu_file_set_error(f, ret);
1027         }
1028         if (ret <= 0) {
1029             /* Do not proceed to the next vmstate before this one reported
1030                completion of the current stage. This serializes the migration
1031                and reduces the probability that a faster changing state is
1032                synchronized over and over again. */
1033             break;
1034         }
1035     }
1036     return ret;
1037 }
1038
1039 static bool should_send_vmdesc(void)
1040 {
1041     MachineState *machine = MACHINE(qdev_get_machine());
1042     bool in_postcopy = migration_in_postcopy();
1043     return !machine->suppress_vmdesc && !in_postcopy;
1044 }
1045
1046 /*
1047  * Calls the save_live_complete_postcopy methods
1048  * causing the last few pages to be sent immediately and doing any associated
1049  * cleanup.
1050  * Note postcopy also calls qemu_savevm_state_complete_precopy to complete
1051  * all the other devices, but that happens at the point we switch to postcopy.
1052  */
1053 void qemu_savevm_state_complete_postcopy(QEMUFile *f)
1054 {
1055     SaveStateEntry *se;
1056     int ret;
1057
1058     QTAILQ_FOREACH(se, &savevm_state.handlers, entry) {
1059         if (!se->ops || !se->ops->save_live_complete_postcopy) {
1060             continue;
1061         }
1062         if (se->ops && se->ops->is_active) {
1063             if (!se->ops->is_active(se->opaque)) {
1064                 continue;
1065             }
1066         }
1067         trace_savevm_section_start(se->idstr, se->section_id);
1068         /* Section type */
1069         qemu_put_byte(f, QEMU_VM_SECTION_END);
1070         qemu_put_be32(f, se->section_id);
1071
1072         ret = se->ops->save_live_complete_postcopy(f, se->opaque);
1073         trace_savevm_section_end(se->idstr, se->section_id, ret);
1074         save_section_footer(f, se);
1075         if (ret < 0) {
1076             qemu_file_set_error(f, ret);
1077             return;
1078         }
1079     }
1080
1081     qemu_put_byte(f, QEMU_VM_EOF);
1082     qemu_fflush(f);
1083 }
1084
1085 int qemu_savevm_state_complete_precopy(QEMUFile *f, bool iterable_only,
1086                                        bool inactivate_disks)
1087 {
1088     QJSON *vmdesc;
1089     int vmdesc_len;
1090     SaveStateEntry *se;
1091     int ret;
1092     bool in_postcopy = migration_in_postcopy();
1093
1094     trace_savevm_state_complete_precopy();
1095
1096     cpu_synchronize_all_states();
1097
1098     QTAILQ_FOREACH(se, &savevm_state.handlers, entry) {
1099         if (!se->ops ||
1100             (in_postcopy && se->ops->save_live_complete_postcopy) ||
1101             (in_postcopy && !iterable_only) ||
1102             !se->ops->save_live_complete_precopy) {
1103             continue;
1104         }
1105
1106         if (se->ops && se->ops->is_active) {
1107             if (!se->ops->is_active(se->opaque)) {
1108                 continue;
1109             }
1110         }
1111         trace_savevm_section_start(se->idstr, se->section_id);
1112
1113         save_section_header(f, se, QEMU_VM_SECTION_END);
1114
1115         ret = se->ops->save_live_complete_precopy(f, se->opaque);
1116         trace_savevm_section_end(se->idstr, se->section_id, ret);
1117         save_section_footer(f, se);
1118         if (ret < 0) {
1119             qemu_file_set_error(f, ret);
1120             return -1;
1121         }
1122     }
1123
1124     if (iterable_only) {
1125         return 0;
1126     }
1127
1128     vmdesc = qjson_new();
1129     json_prop_int(vmdesc, "page_size", qemu_target_page_size());
1130     json_start_array(vmdesc, "devices");
1131     QTAILQ_FOREACH(se, &savevm_state.handlers, entry) {
1132
1133         if ((!se->ops || !se->ops->save_state) && !se->vmsd) {
1134             continue;
1135         }
1136         if (se->vmsd && !vmstate_save_needed(se->vmsd, se->opaque)) {
1137             trace_savevm_section_skip(se->idstr, se->section_id);
1138             continue;
1139         }
1140
1141         trace_savevm_section_start(se->idstr, se->section_id);
1142
1143         json_start_object(vmdesc, NULL);
1144         json_prop_str(vmdesc, "name", se->idstr);
1145         json_prop_int(vmdesc, "instance_id", se->instance_id);
1146
1147         save_section_header(f, se, QEMU_VM_SECTION_FULL);
1148         vmstate_save(f, se, vmdesc);
1149         trace_savevm_section_end(se->idstr, se->section_id, 0);
1150         save_section_footer(f, se);
1151
1152         json_end_object(vmdesc);
1153     }
1154
1155     if (inactivate_disks) {
1156         /* Inactivate before sending QEMU_VM_EOF so that the
1157          * bdrv_invalidate_cache_all() on the other end won't fail. */
1158         ret = bdrv_inactivate_all();
1159         if (ret) {
1160             qemu_file_set_error(f, ret);
1161             return ret;
1162         }
1163     }
1164     if (!in_postcopy) {
1165         /* Postcopy stream will still be going */
1166         qemu_put_byte(f, QEMU_VM_EOF);
1167     }
1168
1169     json_end_array(vmdesc);
1170     qjson_finish(vmdesc);
1171     vmdesc_len = strlen(qjson_get_str(vmdesc));
1172
1173     if (should_send_vmdesc()) {
1174         qemu_put_byte(f, QEMU_VM_VMDESCRIPTION);
1175         qemu_put_be32(f, vmdesc_len);
1176         qemu_put_buffer(f, (uint8_t *)qjson_get_str(vmdesc), vmdesc_len);
1177     }
1178     qjson_destroy(vmdesc);
1179
1180     qemu_fflush(f);
1181     return 0;
1182 }
1183
1184 /* Give an estimate of the amount left to be transferred,
1185  * the result is split into the amount for units that can and
1186  * for units that can't do postcopy.
1187  */
1188 void qemu_savevm_state_pending(QEMUFile *f, uint64_t threshold_size,
1189                                uint64_t *res_non_postcopiable,
1190                                uint64_t *res_postcopiable)
1191 {
1192     SaveStateEntry *se;
1193
1194     *res_non_postcopiable = 0;
1195     *res_postcopiable = 0;
1196
1197
1198     QTAILQ_FOREACH(se, &savevm_state.handlers, entry) {
1199         if (!se->ops || !se->ops->save_live_pending) {
1200             continue;
1201         }
1202         if (se->ops && se->ops->is_active) {
1203             if (!se->ops->is_active(se->opaque)) {
1204                 continue;
1205             }
1206         }
1207         se->ops->save_live_pending(f, se->opaque, threshold_size,
1208                                    res_non_postcopiable, res_postcopiable);
1209     }
1210 }
1211
1212 void qemu_savevm_state_cleanup(void)
1213 {
1214     SaveStateEntry *se;
1215
1216     trace_savevm_state_cleanup();
1217     QTAILQ_FOREACH(se, &savevm_state.handlers, entry) {
1218         if (se->ops && se->ops->cleanup) {
1219             se->ops->cleanup(se->opaque);
1220         }
1221     }
1222 }
1223
1224 static int qemu_savevm_state(QEMUFile *f, Error **errp)
1225 {
1226     int ret;
1227     MigrationState *ms = migrate_init();
1228     MigrationStatus status;
1229     ms->to_dst_file = f;
1230
1231     if (migration_is_blocked(errp)) {
1232         ret = -EINVAL;
1233         goto done;
1234     }
1235
1236     if (migrate_use_block()) {
1237         error_setg(errp, "Block migration and snapshots are incompatible");
1238         ret = -EINVAL;
1239         goto done;
1240     }
1241
1242     qemu_mutex_unlock_iothread();
1243     qemu_savevm_state_header(f);
1244     qemu_savevm_state_begin(f);
1245     qemu_mutex_lock_iothread();
1246
1247     while (qemu_file_get_error(f) == 0) {
1248         if (qemu_savevm_state_iterate(f, false) > 0) {
1249             break;
1250         }
1251     }
1252
1253     ret = qemu_file_get_error(f);
1254     if (ret == 0) {
1255         qemu_savevm_state_complete_precopy(f, false, false);
1256         ret = qemu_file_get_error(f);
1257     }
1258     qemu_savevm_state_cleanup();
1259     if (ret != 0) {
1260         error_setg_errno(errp, -ret, "Error while writing VM state");
1261     }
1262
1263 done:
1264     if (ret != 0) {
1265         status = MIGRATION_STATUS_FAILED;
1266     } else {
1267         status = MIGRATION_STATUS_COMPLETED;
1268     }
1269     migrate_set_state(&ms->state, MIGRATION_STATUS_SETUP, status);
1270
1271     /* f is outer parameter, it should not stay in global migration state after
1272      * this function finished */
1273     ms->to_dst_file = NULL;
1274
1275     return ret;
1276 }
1277
1278 static int qemu_save_device_state(QEMUFile *f)
1279 {
1280     SaveStateEntry *se;
1281
1282     qemu_put_be32(f, QEMU_VM_FILE_MAGIC);
1283     qemu_put_be32(f, QEMU_VM_FILE_VERSION);
1284
1285     cpu_synchronize_all_states();
1286
1287     QTAILQ_FOREACH(se, &savevm_state.handlers, entry) {
1288         if (se->is_ram) {
1289             continue;
1290         }
1291         if ((!se->ops || !se->ops->save_state) && !se->vmsd) {
1292             continue;
1293         }
1294         if (se->vmsd && !vmstate_save_needed(se->vmsd, se->opaque)) {
1295             continue;
1296         }
1297
1298         save_section_header(f, se, QEMU_VM_SECTION_FULL);
1299
1300         vmstate_save(f, se, NULL);
1301
1302         save_section_footer(f, se);
1303     }
1304
1305     qemu_put_byte(f, QEMU_VM_EOF);
1306
1307     return qemu_file_get_error(f);
1308 }
1309
1310 static SaveStateEntry *find_se(const char *idstr, int instance_id)
1311 {
1312     SaveStateEntry *se;
1313
1314     QTAILQ_FOREACH(se, &savevm_state.handlers, entry) {
1315         if (!strcmp(se->idstr, idstr) &&
1316             (instance_id == se->instance_id ||
1317              instance_id == se->alias_id))
1318             return se;
1319         /* Migrating from an older version? */
1320         if (strstr(se->idstr, idstr) && se->compat) {
1321             if (!strcmp(se->compat->idstr, idstr) &&
1322                 (instance_id == se->compat->instance_id ||
1323                  instance_id == se->alias_id))
1324                 return se;
1325         }
1326     }
1327     return NULL;
1328 }
1329
1330 enum LoadVMExitCodes {
1331     /* Allow a command to quit all layers of nested loadvm loops */
1332     LOADVM_QUIT     =  1,
1333 };
1334
1335 static int qemu_loadvm_state_main(QEMUFile *f, MigrationIncomingState *mis);
1336
1337 /* ------ incoming postcopy messages ------ */
1338 /* 'advise' arrives before any transfers just to tell us that a postcopy
1339  * *might* happen - it might be skipped if precopy transferred everything
1340  * quickly.
1341  */
1342 static int loadvm_postcopy_handle_advise(MigrationIncomingState *mis)
1343 {
1344     PostcopyState ps = postcopy_state_set(POSTCOPY_INCOMING_ADVISE);
1345     uint64_t remote_pagesize_summary, local_pagesize_summary, remote_tps;
1346
1347     trace_loadvm_postcopy_handle_advise();
1348     if (ps != POSTCOPY_INCOMING_NONE) {
1349         error_report("CMD_POSTCOPY_ADVISE in wrong postcopy state (%d)", ps);
1350         return -1;
1351     }
1352
1353     if (!postcopy_ram_supported_by_host()) {
1354         postcopy_state_set(POSTCOPY_INCOMING_NONE);
1355         return -1;
1356     }
1357
1358     remote_pagesize_summary = qemu_get_be64(mis->from_src_file);
1359     local_pagesize_summary = ram_pagesize_summary();
1360
1361     if (remote_pagesize_summary != local_pagesize_summary)  {
1362         /*
1363          * This detects two potential causes of mismatch:
1364          *   a) A mismatch in host page sizes
1365          *      Some combinations of mismatch are probably possible but it gets
1366          *      a bit more complicated.  In particular we need to place whole
1367          *      host pages on the dest at once, and we need to ensure that we
1368          *      handle dirtying to make sure we never end up sending part of
1369          *      a hostpage on it's own.
1370          *   b) The use of different huge page sizes on source/destination
1371          *      a more fine grain test is performed during RAM block migration
1372          *      but this test here causes a nice early clear failure, and
1373          *      also fails when passed to an older qemu that doesn't
1374          *      do huge pages.
1375          */
1376         error_report("Postcopy needs matching RAM page sizes (s=%" PRIx64
1377                                                              " d=%" PRIx64 ")",
1378                      remote_pagesize_summary, local_pagesize_summary);
1379         return -1;
1380     }
1381
1382     remote_tps = qemu_get_be64(mis->from_src_file);
1383     if (remote_tps != qemu_target_page_size()) {
1384         /*
1385          * Again, some differences could be dealt with, but for now keep it
1386          * simple.
1387          */
1388         error_report("Postcopy needs matching target page sizes (s=%d d=%zd)",
1389                      (int)remote_tps, qemu_target_page_size());
1390         return -1;
1391     }
1392
1393     if (ram_postcopy_incoming_init(mis)) {
1394         return -1;
1395     }
1396
1397     postcopy_state_set(POSTCOPY_INCOMING_ADVISE);
1398
1399     return 0;
1400 }
1401
1402 /* After postcopy we will be told to throw some pages away since they're
1403  * dirty and will have to be demand fetched.  Must happen before CPU is
1404  * started.
1405  * There can be 0..many of these messages, each encoding multiple pages.
1406  */
1407 static int loadvm_postcopy_ram_handle_discard(MigrationIncomingState *mis,
1408                                               uint16_t len)
1409 {
1410     int tmp;
1411     char ramid[256];
1412     PostcopyState ps = postcopy_state_get();
1413
1414     trace_loadvm_postcopy_ram_handle_discard();
1415
1416     switch (ps) {
1417     case POSTCOPY_INCOMING_ADVISE:
1418         /* 1st discard */
1419         tmp = postcopy_ram_prepare_discard(mis);
1420         if (tmp) {
1421             return tmp;
1422         }
1423         break;
1424
1425     case POSTCOPY_INCOMING_DISCARD:
1426         /* Expected state */
1427         break;
1428
1429     default:
1430         error_report("CMD_POSTCOPY_RAM_DISCARD in wrong postcopy state (%d)",
1431                      ps);
1432         return -1;
1433     }
1434     /* We're expecting a
1435      *    Version (0)
1436      *    a RAM ID string (length byte, name, 0 term)
1437      *    then at least 1 16 byte chunk
1438     */
1439     if (len < (1 + 1 + 1 + 1 + 2 * 8)) {
1440         error_report("CMD_POSTCOPY_RAM_DISCARD invalid length (%d)", len);
1441         return -1;
1442     }
1443
1444     tmp = qemu_get_byte(mis->from_src_file);
1445     if (tmp != postcopy_ram_discard_version) {
1446         error_report("CMD_POSTCOPY_RAM_DISCARD invalid version (%d)", tmp);
1447         return -1;
1448     }
1449
1450     if (!qemu_get_counted_string(mis->from_src_file, ramid)) {
1451         error_report("CMD_POSTCOPY_RAM_DISCARD Failed to read RAMBlock ID");
1452         return -1;
1453     }
1454     tmp = qemu_get_byte(mis->from_src_file);
1455     if (tmp != 0) {
1456         error_report("CMD_POSTCOPY_RAM_DISCARD missing nil (%d)", tmp);
1457         return -1;
1458     }
1459
1460     len -= 3 + strlen(ramid);
1461     if (len % 16) {
1462         error_report("CMD_POSTCOPY_RAM_DISCARD invalid length (%d)", len);
1463         return -1;
1464     }
1465     trace_loadvm_postcopy_ram_handle_discard_header(ramid, len);
1466     while (len) {
1467         uint64_t start_addr, block_length;
1468         start_addr = qemu_get_be64(mis->from_src_file);
1469         block_length = qemu_get_be64(mis->from_src_file);
1470
1471         len -= 16;
1472         int ret = ram_discard_range(ramid, start_addr, block_length);
1473         if (ret) {
1474             return ret;
1475         }
1476     }
1477     trace_loadvm_postcopy_ram_handle_discard_end();
1478
1479     return 0;
1480 }
1481
1482 /*
1483  * Triggered by a postcopy_listen command; this thread takes over reading
1484  * the input stream, leaving the main thread free to carry on loading the rest
1485  * of the device state (from RAM).
1486  * (TODO:This could do with being in a postcopy file - but there again it's
1487  * just another input loop, not that postcopy specific)
1488  */
1489 static void *postcopy_ram_listen_thread(void *opaque)
1490 {
1491     QEMUFile *f = opaque;
1492     MigrationIncomingState *mis = migration_incoming_get_current();
1493     int load_res;
1494
1495     migrate_set_state(&mis->state, MIGRATION_STATUS_ACTIVE,
1496                                    MIGRATION_STATUS_POSTCOPY_ACTIVE);
1497     qemu_sem_post(&mis->listen_thread_sem);
1498     trace_postcopy_ram_listen_thread_start();
1499
1500     /*
1501      * Because we're a thread and not a coroutine we can't yield
1502      * in qemu_file, and thus we must be blocking now.
1503      */
1504     qemu_file_set_blocking(f, true);
1505     load_res = qemu_loadvm_state_main(f, mis);
1506     /* And non-blocking again so we don't block in any cleanup */
1507     qemu_file_set_blocking(f, false);
1508
1509     trace_postcopy_ram_listen_thread_exit();
1510     if (load_res < 0) {
1511         error_report("%s: loadvm failed: %d", __func__, load_res);
1512         qemu_file_set_error(f, load_res);
1513         migrate_set_state(&mis->state, MIGRATION_STATUS_POSTCOPY_ACTIVE,
1514                                        MIGRATION_STATUS_FAILED);
1515     } else {
1516         /*
1517          * This looks good, but it's possible that the device loading in the
1518          * main thread hasn't finished yet, and so we might not be in 'RUN'
1519          * state yet; wait for the end of the main thread.
1520          */
1521         qemu_event_wait(&mis->main_thread_load_event);
1522     }
1523     postcopy_ram_incoming_cleanup(mis);
1524
1525     if (load_res < 0) {
1526         /*
1527          * If something went wrong then we have a bad state so exit;
1528          * depending how far we got it might be possible at this point
1529          * to leave the guest running and fire MCEs for pages that never
1530          * arrived as a desperate recovery step.
1531          */
1532         exit(EXIT_FAILURE);
1533     }
1534
1535     migrate_set_state(&mis->state, MIGRATION_STATUS_POSTCOPY_ACTIVE,
1536                                    MIGRATION_STATUS_COMPLETED);
1537     /*
1538      * If everything has worked fine, then the main thread has waited
1539      * for us to start, and we're the last use of the mis.
1540      * (If something broke then qemu will have to exit anyway since it's
1541      * got a bad migration state).
1542      */
1543     migration_incoming_state_destroy();
1544
1545
1546     return NULL;
1547 }
1548
1549 /* After this message we must be able to immediately receive postcopy data */
1550 static int loadvm_postcopy_handle_listen(MigrationIncomingState *mis)
1551 {
1552     PostcopyState ps = postcopy_state_set(POSTCOPY_INCOMING_LISTENING);
1553     trace_loadvm_postcopy_handle_listen();
1554     if (ps != POSTCOPY_INCOMING_ADVISE && ps != POSTCOPY_INCOMING_DISCARD) {
1555         error_report("CMD_POSTCOPY_LISTEN in wrong postcopy state (%d)", ps);
1556         return -1;
1557     }
1558     if (ps == POSTCOPY_INCOMING_ADVISE) {
1559         /*
1560          * A rare case, we entered listen without having to do any discards,
1561          * so do the setup that's normally done at the time of the 1st discard.
1562          */
1563         postcopy_ram_prepare_discard(mis);
1564     }
1565
1566     /*
1567      * Sensitise RAM - can now generate requests for blocks that don't exist
1568      * However, at this point the CPU shouldn't be running, and the IO
1569      * shouldn't be doing anything yet so don't actually expect requests
1570      */
1571     if (postcopy_ram_enable_notify(mis)) {
1572         return -1;
1573     }
1574
1575     if (mis->have_listen_thread) {
1576         error_report("CMD_POSTCOPY_RAM_LISTEN already has a listen thread");
1577         return -1;
1578     }
1579
1580     mis->have_listen_thread = true;
1581     /* Start up the listening thread and wait for it to signal ready */
1582     qemu_sem_init(&mis->listen_thread_sem, 0);
1583     qemu_thread_create(&mis->listen_thread, "postcopy/listen",
1584                        postcopy_ram_listen_thread, mis->from_src_file,
1585                        QEMU_THREAD_DETACHED);
1586     qemu_sem_wait(&mis->listen_thread_sem);
1587     qemu_sem_destroy(&mis->listen_thread_sem);
1588
1589     return 0;
1590 }
1591
1592
1593 typedef struct {
1594     QEMUBH *bh;
1595 } HandleRunBhData;
1596
1597 static void loadvm_postcopy_handle_run_bh(void *opaque)
1598 {
1599     Error *local_err = NULL;
1600     HandleRunBhData *data = opaque;
1601
1602     /* TODO we should move all of this lot into postcopy_ram.c or a shared code
1603      * in migration.c
1604      */
1605     cpu_synchronize_all_post_init();
1606
1607     qemu_announce_self();
1608
1609     /* Make sure all file formats flush their mutable metadata.
1610      * If we get an error here, just don't restart the VM yet. */
1611     bdrv_invalidate_cache_all(&local_err);
1612     if (local_err) {
1613         error_report_err(local_err);
1614         local_err = NULL;
1615         autostart = false;
1616     }
1617
1618     trace_loadvm_postcopy_handle_run_cpu_sync();
1619     cpu_synchronize_all_post_init();
1620
1621     trace_loadvm_postcopy_handle_run_vmstart();
1622
1623     if (autostart) {
1624         /* Hold onto your hats, starting the CPU */
1625         vm_start();
1626     } else {
1627         /* leave it paused and let management decide when to start the CPU */
1628         runstate_set(RUN_STATE_PAUSED);
1629     }
1630
1631     qemu_bh_delete(data->bh);
1632     g_free(data);
1633 }
1634
1635 /* After all discards we can start running and asking for pages */
1636 static int loadvm_postcopy_handle_run(MigrationIncomingState *mis)
1637 {
1638     PostcopyState ps = postcopy_state_set(POSTCOPY_INCOMING_RUNNING);
1639     HandleRunBhData *data;
1640
1641     trace_loadvm_postcopy_handle_run();
1642     if (ps != POSTCOPY_INCOMING_LISTENING) {
1643         error_report("CMD_POSTCOPY_RUN in wrong postcopy state (%d)", ps);
1644         return -1;
1645     }
1646
1647     data = g_new(HandleRunBhData, 1);
1648     data->bh = qemu_bh_new(loadvm_postcopy_handle_run_bh, data);
1649     qemu_bh_schedule(data->bh);
1650
1651     /* We need to finish reading the stream from the package
1652      * and also stop reading anything more from the stream that loaded the
1653      * package (since it's now being read by the listener thread).
1654      * LOADVM_QUIT will quit all the layers of nested loadvm loops.
1655      */
1656     return LOADVM_QUIT;
1657 }
1658
1659 /**
1660  * Immediately following this command is a blob of data containing an embedded
1661  * chunk of migration stream; read it and load it.
1662  *
1663  * @mis: Incoming state
1664  * @length: Length of packaged data to read
1665  *
1666  * Returns: Negative values on error
1667  *
1668  */
1669 static int loadvm_handle_cmd_packaged(MigrationIncomingState *mis)
1670 {
1671     int ret;
1672     size_t length;
1673     QIOChannelBuffer *bioc;
1674
1675     length = qemu_get_be32(mis->from_src_file);
1676     trace_loadvm_handle_cmd_packaged(length);
1677
1678     if (length > MAX_VM_CMD_PACKAGED_SIZE) {
1679         error_report("Unreasonably large packaged state: %zu", length);
1680         return -1;
1681     }
1682
1683     bioc = qio_channel_buffer_new(length);
1684     qio_channel_set_name(QIO_CHANNEL(bioc), "migration-loadvm-buffer");
1685     ret = qemu_get_buffer(mis->from_src_file,
1686                           bioc->data,
1687                           length);
1688     if (ret != length) {
1689         object_unref(OBJECT(bioc));
1690         error_report("CMD_PACKAGED: Buffer receive fail ret=%d length=%zu",
1691                      ret, length);
1692         return (ret < 0) ? ret : -EAGAIN;
1693     }
1694     bioc->usage += length;
1695     trace_loadvm_handle_cmd_packaged_received(ret);
1696
1697     QEMUFile *packf = qemu_fopen_channel_input(QIO_CHANNEL(bioc));
1698
1699     ret = qemu_loadvm_state_main(packf, mis);
1700     trace_loadvm_handle_cmd_packaged_main(ret);
1701     qemu_fclose(packf);
1702     object_unref(OBJECT(bioc));
1703
1704     return ret;
1705 }
1706
1707 /*
1708  * Process an incoming 'QEMU_VM_COMMAND'
1709  * 0           just a normal return
1710  * LOADVM_QUIT All good, but exit the loop
1711  * <0          Error
1712  */
1713 static int loadvm_process_command(QEMUFile *f)
1714 {
1715     MigrationIncomingState *mis = migration_incoming_get_current();
1716     uint16_t cmd;
1717     uint16_t len;
1718     uint32_t tmp32;
1719
1720     cmd = qemu_get_be16(f);
1721     len = qemu_get_be16(f);
1722
1723     trace_loadvm_process_command(cmd, len);
1724     if (cmd >= MIG_CMD_MAX || cmd == MIG_CMD_INVALID) {
1725         error_report("MIG_CMD 0x%x unknown (len 0x%x)", cmd, len);
1726         return -EINVAL;
1727     }
1728
1729     if (mig_cmd_args[cmd].len != -1 && mig_cmd_args[cmd].len != len) {
1730         error_report("%s received with bad length - expecting %zu, got %d",
1731                      mig_cmd_args[cmd].name,
1732                      (size_t)mig_cmd_args[cmd].len, len);
1733         return -ERANGE;
1734     }
1735
1736     switch (cmd) {
1737     case MIG_CMD_OPEN_RETURN_PATH:
1738         if (mis->to_src_file) {
1739             error_report("CMD_OPEN_RETURN_PATH called when RP already open");
1740             /* Not really a problem, so don't give up */
1741             return 0;
1742         }
1743         mis->to_src_file = qemu_file_get_return_path(f);
1744         if (!mis->to_src_file) {
1745             error_report("CMD_OPEN_RETURN_PATH failed");
1746             return -1;
1747         }
1748         break;
1749
1750     case MIG_CMD_PING:
1751         tmp32 = qemu_get_be32(f);
1752         trace_loadvm_process_command_ping(tmp32);
1753         if (!mis->to_src_file) {
1754             error_report("CMD_PING (0x%x) received with no return path",
1755                          tmp32);
1756             return -1;
1757         }
1758         migrate_send_rp_pong(mis, tmp32);
1759         break;
1760
1761     case MIG_CMD_PACKAGED:
1762         return loadvm_handle_cmd_packaged(mis);
1763
1764     case MIG_CMD_POSTCOPY_ADVISE:
1765         return loadvm_postcopy_handle_advise(mis);
1766
1767     case MIG_CMD_POSTCOPY_LISTEN:
1768         return loadvm_postcopy_handle_listen(mis);
1769
1770     case MIG_CMD_POSTCOPY_RUN:
1771         return loadvm_postcopy_handle_run(mis);
1772
1773     case MIG_CMD_POSTCOPY_RAM_DISCARD:
1774         return loadvm_postcopy_ram_handle_discard(mis, len);
1775     }
1776
1777     return 0;
1778 }
1779
1780 /*
1781  * Read a footer off the wire and check that it matches the expected section
1782  *
1783  * Returns: true if the footer was good
1784  *          false if there is a problem (and calls error_report to say why)
1785  */
1786 static bool check_section_footer(QEMUFile *f, SaveStateEntry *se)
1787 {
1788     uint8_t read_mark;
1789     uint32_t read_section_id;
1790
1791     if (!migrate_get_current()->send_section_footer) {
1792         /* No footer to check */
1793         return true;
1794     }
1795
1796     read_mark = qemu_get_byte(f);
1797
1798     if (read_mark != QEMU_VM_SECTION_FOOTER) {
1799         error_report("Missing section footer for %s", se->idstr);
1800         return false;
1801     }
1802
1803     read_section_id = qemu_get_be32(f);
1804     if (read_section_id != se->load_section_id) {
1805         error_report("Mismatched section id in footer for %s -"
1806                      " read 0x%x expected 0x%x",
1807                      se->idstr, read_section_id, se->load_section_id);
1808         return false;
1809     }
1810
1811     /* All good */
1812     return true;
1813 }
1814
1815 static int
1816 qemu_loadvm_section_start_full(QEMUFile *f, MigrationIncomingState *mis)
1817 {
1818     uint32_t instance_id, version_id, section_id;
1819     SaveStateEntry *se;
1820     char idstr[256];
1821     int ret;
1822
1823     /* Read section start */
1824     section_id = qemu_get_be32(f);
1825     if (!qemu_get_counted_string(f, idstr)) {
1826         error_report("Unable to read ID string for section %u",
1827                      section_id);
1828         return -EINVAL;
1829     }
1830     instance_id = qemu_get_be32(f);
1831     version_id = qemu_get_be32(f);
1832
1833     trace_qemu_loadvm_state_section_startfull(section_id, idstr,
1834             instance_id, version_id);
1835     /* Find savevm section */
1836     se = find_se(idstr, instance_id);
1837     if (se == NULL) {
1838         error_report("Unknown savevm section or instance '%s' %d",
1839                      idstr, instance_id);
1840         return -EINVAL;
1841     }
1842
1843     /* Validate version */
1844     if (version_id > se->version_id) {
1845         error_report("savevm: unsupported version %d for '%s' v%d",
1846                      version_id, idstr, se->version_id);
1847         return -EINVAL;
1848     }
1849     se->load_version_id = version_id;
1850     se->load_section_id = section_id;
1851
1852     /* Validate if it is a device's state */
1853     if (xen_enabled() && se->is_ram) {
1854         error_report("loadvm: %s RAM loading not allowed on Xen", idstr);
1855         return -EINVAL;
1856     }
1857
1858     ret = vmstate_load(f, se);
1859     if (ret < 0) {
1860         error_report("error while loading state for instance 0x%x of"
1861                      " device '%s'", instance_id, idstr);
1862         return ret;
1863     }
1864     if (!check_section_footer(f, se)) {
1865         return -EINVAL;
1866     }
1867
1868     return 0;
1869 }
1870
1871 static int
1872 qemu_loadvm_section_part_end(QEMUFile *f, MigrationIncomingState *mis)
1873 {
1874     uint32_t section_id;
1875     SaveStateEntry *se;
1876     int ret;
1877
1878     section_id = qemu_get_be32(f);
1879
1880     trace_qemu_loadvm_state_section_partend(section_id);
1881     QTAILQ_FOREACH(se, &savevm_state.handlers, entry) {
1882         if (se->load_section_id == section_id) {
1883             break;
1884         }
1885     }
1886     if (se == NULL) {
1887         error_report("Unknown savevm section %d", section_id);
1888         return -EINVAL;
1889     }
1890
1891     ret = vmstate_load(f, se);
1892     if (ret < 0) {
1893         error_report("error while loading state section id %d(%s)",
1894                      section_id, se->idstr);
1895         return ret;
1896     }
1897     if (!check_section_footer(f, se)) {
1898         return -EINVAL;
1899     }
1900
1901     return 0;
1902 }
1903
1904 static int qemu_loadvm_state_main(QEMUFile *f, MigrationIncomingState *mis)
1905 {
1906     uint8_t section_type;
1907     int ret = 0;
1908
1909     while ((section_type = qemu_get_byte(f)) != QEMU_VM_EOF) {
1910         ret = 0;
1911         trace_qemu_loadvm_state_section(section_type);
1912         switch (section_type) {
1913         case QEMU_VM_SECTION_START:
1914         case QEMU_VM_SECTION_FULL:
1915             ret = qemu_loadvm_section_start_full(f, mis);
1916             if (ret < 0) {
1917                 goto out;
1918             }
1919             break;
1920         case QEMU_VM_SECTION_PART:
1921         case QEMU_VM_SECTION_END:
1922             ret = qemu_loadvm_section_part_end(f, mis);
1923             if (ret < 0) {
1924                 goto out;
1925             }
1926             break;
1927         case QEMU_VM_COMMAND:
1928             ret = loadvm_process_command(f);
1929             trace_qemu_loadvm_state_section_command(ret);
1930             if ((ret < 0) || (ret & LOADVM_QUIT)) {
1931                 goto out;
1932             }
1933             break;
1934         default:
1935             error_report("Unknown savevm section type %d", section_type);
1936             ret = -EINVAL;
1937             goto out;
1938         }
1939     }
1940
1941 out:
1942     if (ret < 0) {
1943         qemu_file_set_error(f, ret);
1944     }
1945     return ret;
1946 }
1947
1948 int qemu_loadvm_state(QEMUFile *f)
1949 {
1950     MigrationIncomingState *mis = migration_incoming_get_current();
1951     Error *local_err = NULL;
1952     unsigned int v;
1953     int ret;
1954
1955     if (qemu_savevm_state_blocked(&local_err)) {
1956         error_report_err(local_err);
1957         return -EINVAL;
1958     }
1959
1960     v = qemu_get_be32(f);
1961     if (v != QEMU_VM_FILE_MAGIC) {
1962         error_report("Not a migration stream");
1963         return -EINVAL;
1964     }
1965
1966     v = qemu_get_be32(f);
1967     if (v == QEMU_VM_FILE_VERSION_COMPAT) {
1968         error_report("SaveVM v2 format is obsolete and don't work anymore");
1969         return -ENOTSUP;
1970     }
1971     if (v != QEMU_VM_FILE_VERSION) {
1972         error_report("Unsupported migration stream version");
1973         return -ENOTSUP;
1974     }
1975
1976     if (migrate_get_current()->send_configuration) {
1977         if (qemu_get_byte(f) != QEMU_VM_CONFIGURATION) {
1978             error_report("Configuration section missing");
1979             return -EINVAL;
1980         }
1981         ret = vmstate_load_state(f, &vmstate_configuration, &savevm_state, 0);
1982
1983         if (ret) {
1984             return ret;
1985         }
1986     }
1987
1988     cpu_synchronize_all_pre_loadvm();
1989
1990     ret = qemu_loadvm_state_main(f, mis);
1991     qemu_event_set(&mis->main_thread_load_event);
1992
1993     trace_qemu_loadvm_state_post_main(ret);
1994
1995     if (mis->have_listen_thread) {
1996         /* Listen thread still going, can't clean up yet */
1997         return ret;
1998     }
1999
2000     if (ret == 0) {
2001         ret = qemu_file_get_error(f);
2002     }
2003
2004     /*
2005      * Try to read in the VMDESC section as well, so that dumping tools that
2006      * intercept our migration stream have the chance to see it.
2007      */
2008
2009     /* We've got to be careful; if we don't read the data and just shut the fd
2010      * then the sender can error if we close while it's still sending.
2011      * We also mustn't read data that isn't there; some transports (RDMA)
2012      * will stall waiting for that data when the source has already closed.
2013      */
2014     if (ret == 0 && should_send_vmdesc()) {
2015         uint8_t *buf;
2016         uint32_t size;
2017         uint8_t  section_type = qemu_get_byte(f);
2018
2019         if (section_type != QEMU_VM_VMDESCRIPTION) {
2020             error_report("Expected vmdescription section, but got %d",
2021                          section_type);
2022             /*
2023              * It doesn't seem worth failing at this point since
2024              * we apparently have an otherwise valid VM state
2025              */
2026         } else {
2027             buf = g_malloc(0x1000);
2028             size = qemu_get_be32(f);
2029
2030             while (size > 0) {
2031                 uint32_t read_chunk = MIN(size, 0x1000);
2032                 qemu_get_buffer(f, buf, read_chunk);
2033                 size -= read_chunk;
2034             }
2035             g_free(buf);
2036         }
2037     }
2038
2039     cpu_synchronize_all_post_init();
2040
2041     return ret;
2042 }
2043
2044 int save_snapshot(const char *name, Error **errp)
2045 {
2046     BlockDriverState *bs, *bs1;
2047     QEMUSnapshotInfo sn1, *sn = &sn1, old_sn1, *old_sn = &old_sn1;
2048     int ret = -1;
2049     QEMUFile *f;
2050     int saved_vm_running;
2051     uint64_t vm_state_size;
2052     qemu_timeval tv;
2053     struct tm tm;
2054     AioContext *aio_context;
2055
2056     if (!bdrv_all_can_snapshot(&bs)) {
2057         error_setg(errp, "Device '%s' is writable but does not support "
2058                    "snapshots", bdrv_get_device_name(bs));
2059         return ret;
2060     }
2061
2062     /* Delete old snapshots of the same name */
2063     if (name) {
2064         ret = bdrv_all_delete_snapshot(name, &bs1, errp);
2065         if (ret < 0) {
2066             error_prepend(errp, "Error while deleting snapshot on device "
2067                           "'%s': ", bdrv_get_device_name(bs1));
2068             return ret;
2069         }
2070     }
2071
2072     bs = bdrv_all_find_vmstate_bs();
2073     if (bs == NULL) {
2074         error_setg(errp, "No block device can accept snapshots");
2075         return ret;
2076     }
2077     aio_context = bdrv_get_aio_context(bs);
2078
2079     saved_vm_running = runstate_is_running();
2080
2081     ret = global_state_store();
2082     if (ret) {
2083         error_setg(errp, "Error saving global state");
2084         return ret;
2085     }
2086     vm_stop(RUN_STATE_SAVE_VM);
2087
2088     bdrv_drain_all_begin();
2089
2090     aio_context_acquire(aio_context);
2091
2092     memset(sn, 0, sizeof(*sn));
2093
2094     /* fill auxiliary fields */
2095     qemu_gettimeofday(&tv);
2096     sn->date_sec = tv.tv_sec;
2097     sn->date_nsec = tv.tv_usec * 1000;
2098     sn->vm_clock_nsec = qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL);
2099
2100     if (name) {
2101         ret = bdrv_snapshot_find(bs, old_sn, name);
2102         if (ret >= 0) {
2103             pstrcpy(sn->name, sizeof(sn->name), old_sn->name);
2104             pstrcpy(sn->id_str, sizeof(sn->id_str), old_sn->id_str);
2105         } else {
2106             pstrcpy(sn->name, sizeof(sn->name), name);
2107         }
2108     } else {
2109         /* cast below needed for OpenBSD where tv_sec is still 'long' */
2110         localtime_r((const time_t *)&tv.tv_sec, &tm);
2111         strftime(sn->name, sizeof(sn->name), "vm-%Y%m%d%H%M%S", &tm);
2112     }
2113
2114     /* save the VM state */
2115     f = qemu_fopen_bdrv(bs, 1);
2116     if (!f) {
2117         error_setg(errp, "Could not open VM state file");
2118         goto the_end;
2119     }
2120     ret = qemu_savevm_state(f, errp);
2121     vm_state_size = qemu_ftell(f);
2122     qemu_fclose(f);
2123     if (ret < 0) {
2124         goto the_end;
2125     }
2126
2127     /* The bdrv_all_create_snapshot() call that follows acquires the AioContext
2128      * for itself.  BDRV_POLL_WHILE() does not support nested locking because
2129      * it only releases the lock once.  Therefore synchronous I/O will deadlock
2130      * unless we release the AioContext before bdrv_all_create_snapshot().
2131      */
2132     aio_context_release(aio_context);
2133     aio_context = NULL;
2134
2135     ret = bdrv_all_create_snapshot(sn, bs, vm_state_size, &bs);
2136     if (ret < 0) {
2137         error_setg(errp, "Error while creating snapshot on '%s'",
2138                    bdrv_get_device_name(bs));
2139         goto the_end;
2140     }
2141
2142     ret = 0;
2143
2144  the_end:
2145     if (aio_context) {
2146         aio_context_release(aio_context);
2147     }
2148
2149     bdrv_drain_all_end();
2150
2151     if (saved_vm_running) {
2152         vm_start();
2153     }
2154     return ret;
2155 }
2156
2157 void qmp_xen_save_devices_state(const char *filename, Error **errp)
2158 {
2159     QEMUFile *f;
2160     QIOChannelFile *ioc;
2161     int saved_vm_running;
2162     int ret;
2163
2164     saved_vm_running = runstate_is_running();
2165     vm_stop(RUN_STATE_SAVE_VM);
2166     global_state_store_running();
2167
2168     ioc = qio_channel_file_new_path(filename, O_WRONLY | O_CREAT, 0660, errp);
2169     if (!ioc) {
2170         goto the_end;
2171     }
2172     qio_channel_set_name(QIO_CHANNEL(ioc), "migration-xen-save-state");
2173     f = qemu_fopen_channel_output(QIO_CHANNEL(ioc));
2174     ret = qemu_save_device_state(f);
2175     qemu_fclose(f);
2176     if (ret < 0) {
2177         error_setg(errp, QERR_IO_ERROR);
2178     }
2179
2180  the_end:
2181     if (saved_vm_running) {
2182         vm_start();
2183     }
2184 }
2185
2186 void qmp_xen_load_devices_state(const char *filename, Error **errp)
2187 {
2188     QEMUFile *f;
2189     QIOChannelFile *ioc;
2190     int ret;
2191
2192     /* Guest must be paused before loading the device state; the RAM state
2193      * will already have been loaded by xc
2194      */
2195     if (runstate_is_running()) {
2196         error_setg(errp, "Cannot update device state while vm is running");
2197         return;
2198     }
2199     vm_stop(RUN_STATE_RESTORE_VM);
2200
2201     ioc = qio_channel_file_new_path(filename, O_RDONLY | O_BINARY, 0, errp);
2202     if (!ioc) {
2203         return;
2204     }
2205     qio_channel_set_name(QIO_CHANNEL(ioc), "migration-xen-load-state");
2206     f = qemu_fopen_channel_input(QIO_CHANNEL(ioc));
2207
2208     ret = qemu_loadvm_state(f);
2209     qemu_fclose(f);
2210     if (ret < 0) {
2211         error_setg(errp, QERR_IO_ERROR);
2212     }
2213     migration_incoming_state_destroy();
2214 }
2215
2216 int load_snapshot(const char *name, Error **errp)
2217 {
2218     BlockDriverState *bs, *bs_vm_state;
2219     QEMUSnapshotInfo sn;
2220     QEMUFile *f;
2221     int ret;
2222     AioContext *aio_context;
2223     MigrationIncomingState *mis = migration_incoming_get_current();
2224
2225     if (!bdrv_all_can_snapshot(&bs)) {
2226         error_setg(errp,
2227                    "Device '%s' is writable but does not support snapshots",
2228                    bdrv_get_device_name(bs));
2229         return -ENOTSUP;
2230     }
2231     ret = bdrv_all_find_snapshot(name, &bs);
2232     if (ret < 0) {
2233         error_setg(errp,
2234                    "Device '%s' does not have the requested snapshot '%s'",
2235                    bdrv_get_device_name(bs), name);
2236         return ret;
2237     }
2238
2239     bs_vm_state = bdrv_all_find_vmstate_bs();
2240     if (!bs_vm_state) {
2241         error_setg(errp, "No block device supports snapshots");
2242         return -ENOTSUP;
2243     }
2244     aio_context = bdrv_get_aio_context(bs_vm_state);
2245
2246     /* Don't even try to load empty VM states */
2247     aio_context_acquire(aio_context);
2248     ret = bdrv_snapshot_find(bs_vm_state, &sn, name);
2249     aio_context_release(aio_context);
2250     if (ret < 0) {
2251         return ret;
2252     } else if (sn.vm_state_size == 0) {
2253         error_setg(errp, "This is a disk-only snapshot. Revert to it "
2254                    " offline using qemu-img");
2255         return -EINVAL;
2256     }
2257
2258     /* Flush all IO requests so they don't interfere with the new state.  */
2259     bdrv_drain_all_begin();
2260
2261     ret = bdrv_all_goto_snapshot(name, &bs);
2262     if (ret < 0) {
2263         error_setg(errp, "Error %d while activating snapshot '%s' on '%s'",
2264                      ret, name, bdrv_get_device_name(bs));
2265         goto err_drain;
2266     }
2267
2268     /* restore the VM state */
2269     f = qemu_fopen_bdrv(bs_vm_state, 0);
2270     if (!f) {
2271         error_setg(errp, "Could not open VM state file");
2272         ret = -EINVAL;
2273         goto err_drain;
2274     }
2275
2276     qemu_system_reset(SHUTDOWN_CAUSE_NONE);
2277     mis->from_src_file = f;
2278
2279     aio_context_acquire(aio_context);
2280     ret = qemu_loadvm_state(f);
2281     migration_incoming_state_destroy();
2282     aio_context_release(aio_context);
2283
2284     bdrv_drain_all_end();
2285
2286     if (ret < 0) {
2287         error_setg(errp, "Error %d while loading VM state", ret);
2288         return ret;
2289     }
2290
2291     return 0;
2292
2293 err_drain:
2294     bdrv_drain_all_end();
2295     return ret;
2296 }
2297
2298 void vmstate_register_ram(MemoryRegion *mr, DeviceState *dev)
2299 {
2300     qemu_ram_set_idstr(mr->ram_block,
2301                        memory_region_name(mr), dev);
2302 }
2303
2304 void vmstate_unregister_ram(MemoryRegion *mr, DeviceState *dev)
2305 {
2306     qemu_ram_unset_idstr(mr->ram_block);
2307 }
2308
2309 void vmstate_register_ram_global(MemoryRegion *mr)
2310 {
2311     vmstate_register_ram(mr, NULL);
2312 }
2313
2314 bool vmstate_check_only_migratable(const VMStateDescription *vmsd)
2315 {
2316     /* check needed if --only-migratable is specified */
2317     if (!migrate_get_current()->only_migratable) {
2318         return true;
2319     }
2320
2321     return !(vmsd && vmsd->unmigratable);
2322 }