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 "config-host.h"
  30 #include "qemu-common.h"
  31 #include "hw/boards.h"
  32 #include "hw/hw.h"
  33 #include "hw/qdev.h"
  34 #include "net/net.h"
  35 #include "monitor/monitor.h"
  36 #include "sysemu/sysemu.h"
  37 #include "qemu/timer.h"
  38 #include "audio/audio.h"
  39 #include "migration/migration.h"
  40 #include "qapi/qmp/qerror.h"
  41 #include "qemu/error-report.h"
  42 #include "qemu/sockets.h"
  43 #include "qemu/queue.h"
  44 #include "sysemu/cpus.h"
  45 #include "exec/memory.h"
  46 #include "qmp-commands.h"
  47 #include "trace.h"
  48 #include "qemu/iov.h"
  49 #include "block/snapshot.h"
  50 #include "block/qapi.h"
  51
  52
  53 #ifndef ETH_P_RARP
  54 #define ETH_P_RARP 0x8035
  55 #endif
  56 #define ARP_HTYPE_ETH 0x0001
  57 #define ARP_PTYPE_IP 0x0800
  58 #define ARP_OP_REQUEST_REV 0x3
  59
  60 static bool skip_section_footers;
  61
  62 static int announce_self_create(uint8_t *buf,
  63                                 uint8_t *mac_addr)
  64 {
  65     /* Ethernet header. */
  66     memset(buf, 0xff, 6);         /* destination MAC addr */
  67     memcpy(buf + 6, mac_addr, 6); /* source MAC addr */
  68     *(uint16_t *)(buf + 12) = htons(ETH_P_RARP); /* ethertype */
  69
  70     /* RARP header. */
  71     *(uint16_t *)(buf + 14) = htons(ARP_HTYPE_ETH); /* hardware addr space */
  72     *(uint16_t *)(buf + 16) = htons(ARP_PTYPE_IP); /* protocol addr space */
  73     *(buf + 18) = 6; /* hardware addr length (ethernet) */
  74     *(buf + 19) = 4; /* protocol addr length (IPv4) */
  75     *(uint16_t *)(buf + 20) = htons(ARP_OP_REQUEST_REV); /* opcode */
  76     memcpy(buf + 22, mac_addr, 6); /* source hw addr */
  77     memset(buf + 28, 0x00, 4);     /* source protocol addr */
  78     memcpy(buf + 32, mac_addr, 6); /* target hw addr */
  79     memset(buf + 38, 0x00, 4);     /* target protocol addr */
  80
  81     /* Padding to get up to 60 bytes (ethernet min packet size, minus FCS). */
  82     memset(buf + 42, 0x00, 18);
  83
  84     return 60; /* len (FCS will be added by hardware) */
  85 }
  86
  87 static void qemu_announce_self_iter(NICState *nic, void *opaque)
  88 {
  89     uint8_t buf[60];
  90     int len;
  91
  92     trace_qemu_announce_self_iter(qemu_ether_ntoa(&nic->conf->macaddr));
  93     len = announce_self_create(buf, nic->conf->macaddr.a);
  94
  95     qemu_send_packet_raw(qemu_get_queue(nic), buf, len);
  96 }
  97
  98
  99 static void qemu_announce_self_once(void *opaque)
 100 {
 101     static int count = SELF_ANNOUNCE_ROUNDS;
 102     QEMUTimer *timer = *(QEMUTimer **)opaque;
 103
 104     qemu_foreach_nic(qemu_announce_self_iter, NULL);
 105
 106     if (--count) {
 107         /* delay 50ms, 150ms, 250ms, ... */
 108         timer_mod(timer, qemu_clock_get_ms(QEMU_CLOCK_REALTIME) +
 109                   self_announce_delay(count));
 110     } else {
 111             timer_del(timer);
 112             timer_free(timer);
 113     }
 114 }
 115
 116 void qemu_announce_self(void)
 117 {
 118     static QEMUTimer *timer;
 119     timer = timer_new_ms(QEMU_CLOCK_REALTIME, qemu_announce_self_once, &timer);
 120     qemu_announce_self_once(&timer);
 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)
 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 int block_put_buffer(void *opaque, const uint8_t *buf,
 142                            int64_t pos, int size)
 143 {
 144     bdrv_save_vmstate(opaque, buf, pos, size);
 145     return size;
 146 }
 147
 148 static int block_get_buffer(void *opaque, uint8_t *buf, int64_t pos, int size)
 149 {
 150     return bdrv_load_vmstate(opaque, buf, pos, size);
 151 }
 152
 153 static int bdrv_fclose(void *opaque)
 154 {
 155     return bdrv_flush(opaque);
 156 }
 157
 158 static const QEMUFileOps bdrv_read_ops = {
 159     .get_buffer = block_get_buffer,
 160     .close =      bdrv_fclose
 161 };
 162
 163 static const QEMUFileOps bdrv_write_ops = {
 164     .put_buffer     = block_put_buffer,
 165     .writev_buffer  = block_writev_buffer,
 166     .close          = bdrv_fclose
 167 };
 168
 169 static QEMUFile *qemu_fopen_bdrv(BlockDriverState *bs, int is_writable)
 170 {
 171     if (is_writable) {
 172         return qemu_fopen_ops(bs, &bdrv_write_ops);
 173     }
 174     return qemu_fopen_ops(bs, &bdrv_read_ops);
 175 }
 176
 177
 178 /* QEMUFile timer support.
 179  * Not in qemu-file.c to not add qemu-timer.c as dependency to qemu-file.c
 180  */
 181
 182 void timer_put(QEMUFile *f, QEMUTimer *ts)
 183 {
 184     uint64_t expire_time;
 185
 186     expire_time = timer_expire_time_ns(ts);
 187     qemu_put_be64(f, expire_time);
 188 }
 189
 190 void timer_get(QEMUFile *f, QEMUTimer *ts)
 191 {
 192     uint64_t expire_time;
 193
 194     expire_time = qemu_get_be64(f);
 195     if (expire_time != -1) {
 196         timer_mod_ns(ts, expire_time);
 197     } else {
 198         timer_del(ts);
 199     }
 200 }
 201
 202
 203 /* VMState timer support.
 204  * Not in vmstate.c to not add qemu-timer.c as dependency to vmstate.c
 205  */
 206
 207 static int get_timer(QEMUFile *f, void *pv, size_t size)
 208 {
 209     QEMUTimer *v = pv;
 210     timer_get(f, v);
 211     return 0;
 212 }
 213
 214 static void put_timer(QEMUFile *f, void *pv, size_t size)
 215 {
 216     QEMUTimer *v = pv;
 217     timer_put(f, v);
 218 }
 219
 220 const VMStateInfo vmstate_info_timer = {
 221     .name = "timer",
 222     .get  = get_timer,
 223     .put  = put_timer,
 224 };
 225
 226
 227 typedef struct CompatEntry {
 228     char idstr[256];
 229     int instance_id;
 230 } CompatEntry;
 231
 232 typedef struct SaveStateEntry {
 233     QTAILQ_ENTRY(SaveStateEntry) entry;
 234     char idstr[256];
 235     int instance_id;
 236     int alias_id;
 237     int version_id;
 238     int section_id;
 239     SaveVMHandlers *ops;
 240     const VMStateDescription *vmsd;
 241     void *opaque;
 242     CompatEntry *compat;
 243     int is_ram;
 244 } SaveStateEntry;
 245
 246 typedef struct SaveState {
 247     QTAILQ_HEAD(, SaveStateEntry) handlers;
 248     int global_section_id;
 249 } SaveState;
 250
 251 static SaveState savevm_state = {
 252     .handlers = QTAILQ_HEAD_INITIALIZER(savevm_state.handlers),
 253     .global_section_id = 0,
 254 };
 255
 256 static void dump_vmstate_vmsd(FILE *out_file,
 257                               const VMStateDescription *vmsd, int indent,
 258                               bool is_subsection);
 259
 260 static void dump_vmstate_vmsf(FILE *out_file, const VMStateField *field,
 261                               int indent)
 262 {
 263     fprintf(out_file, "%*s{\n", indent, "");
 264     indent += 2;
 265     fprintf(out_file, "%*s\"field\": \"%s\",\n", indent, "", field->name);
 266     fprintf(out_file, "%*s\"version_id\": %d,\n", indent, "",
 267             field->version_id);
 268     fprintf(out_file, "%*s\"field_exists\": %s,\n", indent, "",
 269             field->field_exists ? "true" : "false");
 270     fprintf(out_file, "%*s\"size\": %zu", indent, "", field->size);
 271     if (field->vmsd != NULL) {
 272         fprintf(out_file, ",\n");
 273         dump_vmstate_vmsd(out_file, field->vmsd, indent, false);
 274     }
 275     fprintf(out_file, "\n%*s}", indent - 2, "");
 276 }
 277
 278 static void dump_vmstate_vmss(FILE *out_file,
 279                               const VMStateDescription **subsection,
 280                               int indent)
 281 {
 282     if (*subsection != NULL) {
 283         dump_vmstate_vmsd(out_file, *subsection, indent, true);
 284     }
 285 }
 286
 287 static void dump_vmstate_vmsd(FILE *out_file,
 288                               const VMStateDescription *vmsd, int indent,
 289                               bool is_subsection)
 290 {
 291     if (is_subsection) {
 292         fprintf(out_file, "%*s{\n", indent, "");
 293     } else {
 294         fprintf(out_file, "%*s\"%s\": {\n", indent, "", "Description");
 295     }
 296     indent += 2;
 297     fprintf(out_file, "%*s\"name\": \"%s\",\n", indent, "", vmsd->name);
 298     fprintf(out_file, "%*s\"version_id\": %d,\n", indent, "",
 299             vmsd->version_id);
 300     fprintf(out_file, "%*s\"minimum_version_id\": %d", indent, "",
 301             vmsd->minimum_version_id);
 302     if (vmsd->fields != NULL) {
 303         const VMStateField *field = vmsd->fields;
 304         bool first;
 305
 306         fprintf(out_file, ",\n%*s\"Fields\": [\n", indent, "");
 307         first = true;
 308         while (field->name != NULL) {
 309             if (field->flags & VMS_MUST_EXIST) {
 310                 /* Ignore VMSTATE_VALIDATE bits; these don't get migrated */
 311                 field++;
 312                 continue;
 313             }
 314             if (!first) {
 315                 fprintf(out_file, ",\n");
 316             }
 317             dump_vmstate_vmsf(out_file, field, indent + 2);
 318             field++;
 319             first = false;
 320         }
 321         fprintf(out_file, "\n%*s]", indent, "");
 322     }
 323     if (vmsd->subsections != NULL) {
 324         const VMStateDescription **subsection = vmsd->subsections;
 325         bool first;
 326
 327         fprintf(out_file, ",\n%*s\"Subsections\": [\n", indent, "");
 328         first = true;
 329         while (*subsection != NULL) {
 330             if (!first) {
 331                 fprintf(out_file, ",\n");
 332             }
 333             dump_vmstate_vmss(out_file, subsection, indent + 2);
 334             subsection++;
 335             first = false;
 336         }
 337         fprintf(out_file, "\n%*s]", indent, "");
 338     }
 339     fprintf(out_file, "\n%*s}", indent - 2, "");
 340 }
 341
 342 static void dump_machine_type(FILE *out_file)
 343 {
 344     MachineClass *mc;
 345
 346     mc = MACHINE_GET_CLASS(current_machine);
 347
 348     fprintf(out_file, "  \"vmschkmachine\": {\n");
 349     fprintf(out_file, "    \"Name\": \"%s\"\n", mc->name);
 350     fprintf(out_file, "  },\n");
 351 }
 352
 353 void dump_vmstate_json_to_file(FILE *out_file)
 354 {
 355     GSList *list, *elt;
 356     bool first;
 357
 358     fprintf(out_file, "{\n");
 359     dump_machine_type(out_file);
 360
 361     first = true;
 362     list = object_class_get_list(TYPE_DEVICE, true);
 363     for (elt = list; elt; elt = elt->next) {
 364         DeviceClass *dc = OBJECT_CLASS_CHECK(DeviceClass, elt->data,
 365                                              TYPE_DEVICE);
 366         const char *name;
 367         int indent = 2;
 368
 369         if (!dc->vmsd) {
 370             continue;
 371         }
 372
 373         if (!first) {
 374             fprintf(out_file, ",\n");
 375         }
 376         name = object_class_get_name(OBJECT_CLASS(dc));
 377         fprintf(out_file, "%*s\"%s\": {\n", indent, "", name);
 378         indent += 2;
 379         fprintf(out_file, "%*s\"Name\": \"%s\",\n", indent, "", name);
 380         fprintf(out_file, "%*s\"version_id\": %d,\n", indent, "",
 381                 dc->vmsd->version_id);
 382         fprintf(out_file, "%*s\"minimum_version_id\": %d,\n", indent, "",
 383                 dc->vmsd->minimum_version_id);
 384
 385         dump_vmstate_vmsd(out_file, dc->vmsd, indent, false);
 386
 387         fprintf(out_file, "\n%*s}", indent - 2, "");
 388         first = false;
 389     }
 390     fprintf(out_file, "\n}\n");
 391     fclose(out_file);
 392 }
 393
 394 static int calculate_new_instance_id(const char *idstr)
 395 {
 396     SaveStateEntry *se;
 397     int instance_id = 0;
 398
 399     QTAILQ_FOREACH(se, &savevm_state.handlers, entry) {
 400         if (strcmp(idstr, se->idstr) == 0
 401             && instance_id <= se->instance_id) {
 402             instance_id = se->instance_id + 1;
 403         }
 404     }
 405     return instance_id;
 406 }
 407
 408 static int calculate_compat_instance_id(const char *idstr)
 409 {
 410     SaveStateEntry *se;
 411     int instance_id = 0;
 412
 413     QTAILQ_FOREACH(se, &savevm_state.handlers, entry) {
 414         if (!se->compat) {
 415             continue;
 416         }
 417
 418         if (strcmp(idstr, se->compat->idstr) == 0
 419             && instance_id <= se->compat->instance_id) {
 420             instance_id = se->compat->instance_id + 1;
 421         }
 422     }
 423     return instance_id;
 424 }
 425
 426 /* TODO: Individual devices generally have very little idea about the rest
 427    of the system, so instance_id should be removed/replaced.
 428    Meanwhile pass -1 as instance_id if you do not already have a clearly
 429    distinguishing id for all instances of your device class. */
 430 int register_savevm_live(DeviceState *dev,
 431                          const char *idstr,
 432                          int instance_id,
 433                          int version_id,
 434                          SaveVMHandlers *ops,
 435                          void *opaque)
 436 {
 437     SaveStateEntry *se;
 438
 439     se = g_malloc0(sizeof(SaveStateEntry));
 440     se->version_id = version_id;
 441     se->section_id = savevm_state.global_section_id++;
 442     se->ops = ops;
 443     se->opaque = opaque;
 444     se->vmsd = NULL;
 445     /* if this is a live_savem then set is_ram */
 446     if (ops->save_live_setup != NULL) {
 447         se->is_ram = 1;
 448     }
 449
 450     if (dev) {
 451         char *id = qdev_get_dev_path(dev);
 452         if (id) {
 453             pstrcpy(se->idstr, sizeof(se->idstr), id);
 454             pstrcat(se->idstr, sizeof(se->idstr), "/");
 455             g_free(id);
 456
 457             se->compat = g_malloc0(sizeof(CompatEntry));
 458             pstrcpy(se->compat->idstr, sizeof(se->compat->idstr), idstr);
 459             se->compat->instance_id = instance_id == -1 ?
 460                          calculate_compat_instance_id(idstr) : instance_id;
 461             instance_id = -1;
 462         }
 463     }
 464     pstrcat(se->idstr, sizeof(se->idstr), idstr);
 465
 466     if (instance_id == -1) {
 467         se->instance_id = calculate_new_instance_id(se->idstr);
 468     } else {
 469         se->instance_id = instance_id;
 470     }
 471     assert(!se->compat || se->instance_id == 0);
 472     /* add at the end of list */
 473     QTAILQ_INSERT_TAIL(&savevm_state.handlers, se, entry);
 474     return 0;
 475 }
 476
 477 int register_savevm(DeviceState *dev,
 478                     const char *idstr,
 479                     int instance_id,
 480                     int version_id,
 481                     SaveStateHandler *save_state,
 482                     LoadStateHandler *load_state,
 483                     void *opaque)
 484 {
 485     SaveVMHandlers *ops = g_malloc0(sizeof(SaveVMHandlers));
 486     ops->save_state = save_state;
 487     ops->load_state = load_state;
 488     return register_savevm_live(dev, idstr, instance_id, version_id,
 489                                 ops, opaque);
 490 }
 491
 492 void unregister_savevm(DeviceState *dev, const char *idstr, void *opaque)
 493 {
 494     SaveStateEntry *se, *new_se;
 495     char id[256] = "";
 496
 497     if (dev) {
 498         char *path = qdev_get_dev_path(dev);
 499         if (path) {
 500             pstrcpy(id, sizeof(id), path);
 501             pstrcat(id, sizeof(id), "/");
 502             g_free(path);
 503         }
 504     }
 505     pstrcat(id, sizeof(id), idstr);
 506
 507     QTAILQ_FOREACH_SAFE(se, &savevm_state.handlers, entry, new_se) {
 508         if (strcmp(se->idstr, id) == 0 && se->opaque == opaque) {
 509             QTAILQ_REMOVE(&savevm_state.handlers, se, entry);
 510             if (se->compat) {
 511                 g_free(se->compat);
 512             }
 513             g_free(se->ops);
 514             g_free(se);
 515         }
 516     }
 517 }
 518
 519 int vmstate_register_with_alias_id(DeviceState *dev, int instance_id,
 520                                    const VMStateDescription *vmsd,
 521                                    void *opaque, int alias_id,
 522                                    int required_for_version)
 523 {
 524     SaveStateEntry *se;
 525
 526     /* If this triggers, alias support can be dropped for the vmsd. */
 527     assert(alias_id == -1 || required_for_version >= vmsd->minimum_version_id);
 528
 529     se = g_malloc0(sizeof(SaveStateEntry));
 530     se->version_id = vmsd->version_id;
 531     se->section_id = savevm_state.global_section_id++;
 532     se->opaque = opaque;
 533     se->vmsd = vmsd;
 534     se->alias_id = alias_id;
 535
 536     if (dev) {
 537         char *id = qdev_get_dev_path(dev);
 538         if (id) {
 539             pstrcpy(se->idstr, sizeof(se->idstr), id);
 540             pstrcat(se->idstr, sizeof(se->idstr), "/");
 541             g_free(id);
 542
 543             se->compat = g_malloc0(sizeof(CompatEntry));
 544             pstrcpy(se->compat->idstr, sizeof(se->compat->idstr), vmsd->name);
 545             se->compat->instance_id = instance_id == -1 ?
 546                          calculate_compat_instance_id(vmsd->name) : instance_id;
 547             instance_id = -1;
 548         }
 549     }
 550     pstrcat(se->idstr, sizeof(se->idstr), vmsd->name);
 551
 552     if (instance_id == -1) {
 553         se->instance_id = calculate_new_instance_id(se->idstr);
 554     } else {
 555         se->instance_id = instance_id;
 556     }
 557     assert(!se->compat || se->instance_id == 0);
 558     /* add at the end of list */
 559     QTAILQ_INSERT_TAIL(&savevm_state.handlers, se, entry);
 560     return 0;
 561 }
 562
 563 void vmstate_unregister(DeviceState *dev, const VMStateDescription *vmsd,
 564                         void *opaque)
 565 {
 566     SaveStateEntry *se, *new_se;
 567
 568     QTAILQ_FOREACH_SAFE(se, &savevm_state.handlers, entry, new_se) {
 569         if (se->vmsd == vmsd && se->opaque == opaque) {
 570             QTAILQ_REMOVE(&savevm_state.handlers, se, entry);
 571             if (se->compat) {
 572                 g_free(se->compat);
 573             }
 574             g_free(se);
 575         }
 576     }
 577 }
 578
 579 static int vmstate_load(QEMUFile *f, SaveStateEntry *se, int version_id)
 580 {
 581     trace_vmstate_load(se->idstr, se->vmsd ? se->vmsd->name : "(old)");
 582     if (!se->vmsd) {         /* Old style */
 583         return se->ops->load_state(f, se->opaque, version_id);
 584     }
 585     return vmstate_load_state(f, se->vmsd, se->opaque, version_id);
 586 }
 587
 588 static void vmstate_save_old_style(QEMUFile *f, SaveStateEntry *se, QJSON *vmdesc)
 589 {
 590     int64_t old_offset, size;
 591
 592     old_offset = qemu_ftell_fast(f);
 593     se->ops->save_state(f, se->opaque);
 594     size = qemu_ftell_fast(f) - old_offset;
 595
 596     if (vmdesc) {
 597         json_prop_int(vmdesc, "size", size);
 598         json_start_array(vmdesc, "fields");
 599         json_start_object(vmdesc, NULL);
 600         json_prop_str(vmdesc, "name", "data");
 601         json_prop_int(vmdesc, "size", size);
 602         json_prop_str(vmdesc, "type", "buffer");
 603         json_end_object(vmdesc);
 604         json_end_array(vmdesc);
 605     }
 606 }
 607
 608 static void vmstate_save(QEMUFile *f, SaveStateEntry *se, QJSON *vmdesc)
 609 {
 610     trace_vmstate_save(se->idstr, se->vmsd ? se->vmsd->name : "(old)");
 611     if (!se->vmsd) {
 612         vmstate_save_old_style(f, se, vmdesc);
 613         return;
 614     }
 615     vmstate_save_state(f, se->vmsd, se->opaque, vmdesc);
 616 }
 617
 618 void savevm_skip_section_footers(void)
 619 {
 620     skip_section_footers = true;
 621 }
 622
 623 /*
 624  * Write the header for device section (QEMU_VM_SECTION START/END/PART/FULL)
 625  */
 626 static void save_section_header(QEMUFile *f, SaveStateEntry *se,
 627                                 uint8_t section_type)
 628 {
 629     qemu_put_byte(f, section_type);
 630     qemu_put_be32(f, se->section_id);
 631
 632     if (section_type == QEMU_VM_SECTION_FULL ||
 633         section_type == QEMU_VM_SECTION_START) {
 634         /* ID string */
 635         size_t len = strlen(se->idstr);
 636         qemu_put_byte(f, len);
 637         qemu_put_buffer(f, (uint8_t *)se->idstr, len);
 638
 639         qemu_put_be32(f, se->instance_id);
 640         qemu_put_be32(f, se->version_id);
 641     }
 642 }
 643
 644 /*
 645  * Write a footer onto device sections that catches cases misformatted device
 646  * sections.
 647  */
 648 static void save_section_footer(QEMUFile *f, SaveStateEntry *se)
 649 {
 650     if (!skip_section_footers) {
 651         qemu_put_byte(f, QEMU_VM_SECTION_FOOTER);
 652         qemu_put_be32(f, se->section_id);
 653     }
 654 }
 655
 656 /*
 657  * Read a footer off the wire and check that it matches the expected section
 658  *
 659  * Returns: true if the footer was good
 660  *          false if there is a problem (and calls error_report to say why)
 661  */
 662 static bool check_section_footer(QEMUFile *f, SaveStateEntry *se)
 663 {
 664     uint8_t read_mark;
 665     uint32_t read_section_id;
 666
 667     if (skip_section_footers) {
 668         /* No footer to check */
 669         return true;
 670     }
 671
 672     read_mark = qemu_get_byte(f);
 673
 674     if (read_mark != QEMU_VM_SECTION_FOOTER) {
 675         error_report("Missing section footer for %s", se->idstr);
 676         return false;
 677     }
 678
 679     read_section_id = qemu_get_be32(f);
 680     if (read_section_id != se->section_id) {
 681         error_report("Mismatched section id in footer for %s -"
 682                      " read 0x%x expected 0x%x",
 683                      se->idstr, read_section_id, se->section_id);
 684         return false;
 685     }
 686
 687     /* All good */
 688     return true;
 689 }
 690
 691 bool qemu_savevm_state_blocked(Error **errp)
 692 {
 693     SaveStateEntry *se;
 694
 695     QTAILQ_FOREACH(se, &savevm_state.handlers, entry) {
 696         if (se->vmsd && se->vmsd->unmigratable) {
 697             error_setg(errp, "State blocked by non-migratable device '%s'",
 698                        se->idstr);
 699             return true;
 700         }
 701     }
 702     return false;
 703 }
 704
 705 void qemu_savevm_state_header(QEMUFile *f)
 706 {
 707     trace_savevm_state_header();
 708     qemu_put_be32(f, QEMU_VM_FILE_MAGIC);
 709     qemu_put_be32(f, QEMU_VM_FILE_VERSION);
 710 }
 711
 712 void qemu_savevm_state_begin(QEMUFile *f,
 713                              const MigrationParams *params)
 714 {
 715     SaveStateEntry *se;
 716     int ret;
 717
 718     trace_savevm_state_begin();
 719     QTAILQ_FOREACH(se, &savevm_state.handlers, entry) {
 720         if (!se->ops || !se->ops->set_params) {
 721             continue;
 722         }
 723         se->ops->set_params(params, se->opaque);
 724     }
 725
 726     QTAILQ_FOREACH(se, &savevm_state.handlers, entry) {
 727         if (!se->ops || !se->ops->save_live_setup) {
 728             continue;
 729         }
 730         if (se->ops && se->ops->is_active) {
 731             if (!se->ops->is_active(se->opaque)) {
 732                 continue;
 733             }
 734         }
 735         save_section_header(f, se, QEMU_VM_SECTION_START);
 736
 737         ret = se->ops->save_live_setup(f, se->opaque);
 738         save_section_footer(f, se);
 739         if (ret < 0) {
 740             qemu_file_set_error(f, ret);
 741             break;
 742         }
 743     }
 744 }
 745
 746 /*
 747  * this function has three return values:
 748  *   negative: there was one error, and we have -errno.
 749  *   0 : We haven't finished, caller have to go again
 750  *   1 : We have finished, we can go to complete phase
 751  */
 752 int qemu_savevm_state_iterate(QEMUFile *f)
 753 {
 754     SaveStateEntry *se;
 755     int ret = 1;
 756
 757     trace_savevm_state_iterate();
 758     QTAILQ_FOREACH(se, &savevm_state.handlers, entry) {
 759         if (!se->ops || !se->ops->save_live_iterate) {
 760             continue;
 761         }
 762         if (se->ops && se->ops->is_active) {
 763             if (!se->ops->is_active(se->opaque)) {
 764                 continue;
 765             }
 766         }
 767         if (qemu_file_rate_limit(f)) {
 768             return 0;
 769         }
 770         trace_savevm_section_start(se->idstr, se->section_id);
 771
 772         save_section_header(f, se, QEMU_VM_SECTION_PART);
 773
 774         ret = se->ops->save_live_iterate(f, se->opaque);
 775         trace_savevm_section_end(se->idstr, se->section_id, ret);
 776         save_section_footer(f, se);
 777
 778         if (ret < 0) {
 779             qemu_file_set_error(f, ret);
 780         }
 781         if (ret <= 0) {
 782             /* Do not proceed to the next vmstate before this one reported
 783                completion of the current stage. This serializes the migration
 784                and reduces the probability that a faster changing state is
 785                synchronized over and over again. */
 786             break;
 787         }
 788     }
 789     return ret;
 790 }
 791
 792 static bool should_send_vmdesc(void)
 793 {
 794     MachineState *machine = MACHINE(qdev_get_machine());
 795     return !machine->suppress_vmdesc;
 796 }
 797
 798 void qemu_savevm_state_complete(QEMUFile *f)
 799 {
 800     QJSON *vmdesc;
 801     int vmdesc_len;
 802     SaveStateEntry *se;
 803     int ret;
 804
 805     trace_savevm_state_complete();
 806
 807     cpu_synchronize_all_states();
 808
 809     QTAILQ_FOREACH(se, &savevm_state.handlers, entry) {
 810         if (!se->ops || !se->ops->save_live_complete) {
 811             continue;
 812         }
 813         if (se->ops && se->ops->is_active) {
 814             if (!se->ops->is_active(se->opaque)) {
 815                 continue;
 816             }
 817         }
 818         trace_savevm_section_start(se->idstr, se->section_id);
 819
 820         save_section_header(f, se, QEMU_VM_SECTION_END);
 821
 822         ret = se->ops->save_live_complete(f, se->opaque);
 823         trace_savevm_section_end(se->idstr, se->section_id, ret);
 824         save_section_footer(f, se);
 825         if (ret < 0) {
 826             qemu_file_set_error(f, ret);
 827             return;
 828         }
 829     }
 830
 831     vmdesc = qjson_new();
 832     json_prop_int(vmdesc, "page_size", TARGET_PAGE_SIZE);
 833     json_start_array(vmdesc, "devices");
 834     QTAILQ_FOREACH(se, &savevm_state.handlers, entry) {
 835
 836         if ((!se->ops || !se->ops->save_state) && !se->vmsd) {
 837             continue;
 838         }
 839         trace_savevm_section_start(se->idstr, se->section_id);
 840
 841         json_start_object(vmdesc, NULL);
 842         json_prop_str(vmdesc, "name", se->idstr);
 843         json_prop_int(vmdesc, "instance_id", se->instance_id);
 844
 845         save_section_header(f, se, QEMU_VM_SECTION_FULL);
 846
 847         vmstate_save(f, se, vmdesc);
 848
 849         json_end_object(vmdesc);
 850         trace_savevm_section_end(se->idstr, se->section_id, 0);
 851         save_section_footer(f, se);
 852     }
 853
 854     qemu_put_byte(f, QEMU_VM_EOF);
 855
 856     json_end_array(vmdesc);
 857     qjson_finish(vmdesc);
 858     vmdesc_len = strlen(qjson_get_str(vmdesc));
 859
 860     if (should_send_vmdesc()) {
 861         qemu_put_byte(f, QEMU_VM_VMDESCRIPTION);
 862         qemu_put_be32(f, vmdesc_len);
 863         qemu_put_buffer(f, (uint8_t *)qjson_get_str(vmdesc), vmdesc_len);
 864     }
 865     object_unref(OBJECT(vmdesc));
 866
 867     qemu_fflush(f);
 868 }
 869
 870 uint64_t qemu_savevm_state_pending(QEMUFile *f, uint64_t max_size)
 871 {
 872     SaveStateEntry *se;
 873     uint64_t ret = 0;
 874
 875     QTAILQ_FOREACH(se, &savevm_state.handlers, entry) {
 876         if (!se->ops || !se->ops->save_live_pending) {
 877             continue;
 878         }
 879         if (se->ops && se->ops->is_active) {
 880             if (!se->ops->is_active(se->opaque)) {
 881                 continue;
 882             }
 883         }
 884         ret += se->ops->save_live_pending(f, se->opaque, max_size);
 885     }
 886     return ret;
 887 }
 888
 889 void qemu_savevm_state_cancel(void)
 890 {
 891     SaveStateEntry *se;
 892
 893     trace_savevm_state_cancel();
 894     QTAILQ_FOREACH(se, &savevm_state.handlers, entry) {
 895         if (se->ops && se->ops->cancel) {
 896             se->ops->cancel(se->opaque);
 897         }
 898     }
 899 }
 900
 901 static int qemu_savevm_state(QEMUFile *f, Error **errp)
 902 {
 903     int ret;
 904     MigrationParams params = {
 905         .blk = 0,
 906         .shared = 0
 907     };
 908
 909     if (qemu_savevm_state_blocked(errp)) {
 910         return -EINVAL;
 911     }
 912
 913     qemu_mutex_unlock_iothread();
 914     qemu_savevm_state_header(f);
 915     qemu_savevm_state_begin(f, &params);
 916     qemu_mutex_lock_iothread();
 917
 918     while (qemu_file_get_error(f) == 0) {
 919         if (qemu_savevm_state_iterate(f) > 0) {
 920             break;
 921         }
 922     }
 923
 924     ret = qemu_file_get_error(f);
 925     if (ret == 0) {
 926         qemu_savevm_state_complete(f);
 927         ret = qemu_file_get_error(f);
 928     }
 929     if (ret != 0) {
 930         qemu_savevm_state_cancel();
 931         error_setg_errno(errp, -ret, "Error while writing VM state");
 932     }
 933     return ret;
 934 }
 935
 936 static int qemu_save_device_state(QEMUFile *f)
 937 {
 938     SaveStateEntry *se;
 939
 940     qemu_put_be32(f, QEMU_VM_FILE_MAGIC);
 941     qemu_put_be32(f, QEMU_VM_FILE_VERSION);
 942
 943     cpu_synchronize_all_states();
 944
 945     QTAILQ_FOREACH(se, &savevm_state.handlers, entry) {
 946         if (se->is_ram) {
 947             continue;
 948         }
 949         if ((!se->ops || !se->ops->save_state) && !se->vmsd) {
 950             continue;
 951         }
 952
 953         save_section_header(f, se, QEMU_VM_SECTION_FULL);
 954
 955         vmstate_save(f, se, NULL);
 956
 957         save_section_footer(f, se);
 958     }
 959
 960     qemu_put_byte(f, QEMU_VM_EOF);
 961
 962     return qemu_file_get_error(f);
 963 }
 964
 965 static SaveStateEntry *find_se(const char *idstr, int instance_id)
 966 {
 967     SaveStateEntry *se;
 968
 969     QTAILQ_FOREACH(se, &savevm_state.handlers, entry) {
 970         if (!strcmp(se->idstr, idstr) &&
 971             (instance_id == se->instance_id ||
 972              instance_id == se->alias_id))
 973             return se;
 974         /* Migrating from an older version? */
 975         if (strstr(se->idstr, idstr) && se->compat) {
 976             if (!strcmp(se->compat->idstr, idstr) &&
 977                 (instance_id == se->compat->instance_id ||
 978                  instance_id == se->alias_id))
 979                 return se;
 980         }
 981     }
 982     return NULL;
 983 }
 984
 985 struct LoadStateEntry {
 986     QLIST_ENTRY(LoadStateEntry) entry;
 987     SaveStateEntry *se;
 988     int section_id;
 989     int version_id;
 990 };
 991
 992 void loadvm_free_handlers(MigrationIncomingState *mis)
 993 {
 994     LoadStateEntry *le, *new_le;
 995
 996     QLIST_FOREACH_SAFE(le, &mis->loadvm_handlers, entry, new_le) {
 997         QLIST_REMOVE(le, entry);
 998         g_free(le);
 999     }
1000 }
1001
1002 int qemu_loadvm_state(QEMUFile *f)
1003 {
1004     MigrationIncomingState *mis = migration_incoming_get_current();
1005     Error *local_err = NULL;
1006     uint8_t section_type;
1007     unsigned int v;
1008     int ret;
1009     int file_error_after_eof = -1;
1010
1011     if (qemu_savevm_state_blocked(&local_err)) {
1012         error_report_err(local_err);
1013         return -EINVAL;
1014     }
1015
1016     v = qemu_get_be32(f);
1017     if (v != QEMU_VM_FILE_MAGIC) {
1018         error_report("Not a migration stream");
1019         return -EINVAL;
1020     }
1021
1022     v = qemu_get_be32(f);
1023     if (v == QEMU_VM_FILE_VERSION_COMPAT) {
1024         error_report("SaveVM v2 format is obsolete and don't work anymore");
1025         return -ENOTSUP;
1026     }
1027     if (v != QEMU_VM_FILE_VERSION) {
1028         error_report("Unsupported migration stream version");
1029         return -ENOTSUP;
1030     }
1031
1032     while ((section_type = qemu_get_byte(f)) != QEMU_VM_EOF) {
1033         uint32_t instance_id, version_id, section_id;
1034         SaveStateEntry *se;
1035         LoadStateEntry *le;
1036         char idstr[256];
1037
1038         trace_qemu_loadvm_state_section(section_type);
1039         switch (section_type) {
1040         case QEMU_VM_SECTION_START:
1041         case QEMU_VM_SECTION_FULL:
1042             /* Read section start */
1043             section_id = qemu_get_be32(f);
1044             if (!qemu_get_counted_string(f, idstr)) {
1045                 error_report("Unable to read ID string for section %u",
1046                             section_id);
1047                 return -EINVAL;
1048             }
1049             instance_id = qemu_get_be32(f);
1050             version_id = qemu_get_be32(f);
1051
1052             trace_qemu_loadvm_state_section_startfull(section_id, idstr,
1053                                                       instance_id, version_id);
1054             /* Find savevm section */
1055             se = find_se(idstr, instance_id);
1056             if (se == NULL) {
1057                 error_report("Unknown savevm section or instance '%s' %d",
1058                              idstr, instance_id);
1059                 ret = -EINVAL;
1060                 goto out;
1061             }
1062
1063             /* Validate version */
1064             if (version_id > se->version_id) {
1065                 error_report("savevm: unsupported version %d for '%s' v%d",
1066                              version_id, idstr, se->version_id);
1067                 ret = -EINVAL;
1068                 goto out;
1069             }
1070
1071             /* Add entry */
1072             le = g_malloc0(sizeof(*le));
1073
1074             le->se = se;
1075             le->section_id = section_id;
1076             le->version_id = version_id;
1077             QLIST_INSERT_HEAD(&mis->loadvm_handlers, le, entry);
1078
1079             ret = vmstate_load(f, le->se, le->version_id);
1080             if (ret < 0) {
1081                 error_report("error while loading state for instance 0x%x of"
1082                              " device '%s'", instance_id, idstr);
1083                 goto out;
1084             }
1085             if (!check_section_footer(f, le->se)) {
1086                 ret = -EINVAL;
1087                 goto out;
1088             }
1089             break;
1090         case QEMU_VM_SECTION_PART:
1091         case QEMU_VM_SECTION_END:
1092             section_id = qemu_get_be32(f);
1093
1094             trace_qemu_loadvm_state_section_partend(section_id);
1095             QLIST_FOREACH(le, &mis->loadvm_handlers, entry) {
1096                 if (le->section_id == section_id) {
1097                     break;
1098                 }
1099             }
1100             if (le == NULL) {
1101                 error_report("Unknown savevm section %d", section_id);
1102                 ret = -EINVAL;
1103                 goto out;
1104             }
1105
1106             ret = vmstate_load(f, le->se, le->version_id);
1107             if (ret < 0) {
1108                 error_report("error while loading state section id %d(%s)",
1109                              section_id, le->se->idstr);
1110                 goto out;
1111             }
1112             if (!check_section_footer(f, le->se)) {
1113                 ret = -EINVAL;
1114                 goto out;
1115             }
1116             break;
1117         default:
1118             error_report("Unknown savevm section type %d", section_type);
1119             ret = -EINVAL;
1120             goto out;
1121         }
1122     }
1123
1124     file_error_after_eof = qemu_file_get_error(f);
1125
1126     /*
1127      * Try to read in the VMDESC section as well, so that dumping tools that
1128      * intercept our migration stream have the chance to see it.
1129      */
1130
1131     /* We've got to be careful; if we don't read the data and just shut the fd
1132      * then the sender can error if we close while it's still sending.
1133      * We also mustn't read data that isn't there; some transports (RDMA)
1134      * will stall waiting for that data when the source has already closed.
1135      */
1136     if (should_send_vmdesc()) {
1137         uint8_t *buf;
1138         uint32_t size;
1139         section_type = qemu_get_byte(f);
1140
1141         if (section_type != QEMU_VM_VMDESCRIPTION) {
1142             error_report("Expected vmdescription section, but got %d",
1143                          section_type);
1144             /*
1145              * It doesn't seem worth failing at this point since
1146              * we apparently have an otherwise valid VM state
1147              */
1148         } else {
1149             buf = g_malloc(0x1000);
1150             size = qemu_get_be32(f);
1151
1152             while (size > 0) {
1153                 uint32_t read_chunk = MIN(size, 0x1000);
1154                 qemu_get_buffer(f, buf, read_chunk);
1155                 size -= read_chunk;
1156             }
1157             g_free(buf);
1158         }
1159     }
1160
1161     cpu_synchronize_all_post_init();
1162
1163     ret = 0;
1164
1165 out:
1166     if (ret == 0) {
1167         /* We may not have a VMDESC section, so ignore relative errors */
1168         ret = file_error_after_eof;
1169     }
1170
1171     return ret;
1172 }
1173
1174 static BlockDriverState *find_vmstate_bs(void)
1175 {
1176     BlockDriverState *bs = NULL;
1177     while ((bs = bdrv_next(bs))) {
1178         if (bdrv_can_snapshot(bs)) {
1179             return bs;
1180         }
1181     }
1182     return NULL;
1183 }
1184
1185 /*
1186  * Deletes snapshots of a given name in all opened images.
1187  */
1188 static int del_existing_snapshots(Monitor *mon, const char *name)
1189 {
1190     BlockDriverState *bs;
1191     QEMUSnapshotInfo sn1, *snapshot = &sn1;
1192     Error *err = NULL;
1193
1194     bs = NULL;
1195     while ((bs = bdrv_next(bs))) {
1196         if (bdrv_can_snapshot(bs) &&
1197             bdrv_snapshot_find(bs, snapshot, name) >= 0) {
1198             bdrv_snapshot_delete_by_id_or_name(bs, name, &err);
1199             if (err) {
1200                 monitor_printf(mon,
1201                                "Error while deleting snapshot on device '%s':"
1202                                " %s\n",
1203                                bdrv_get_device_name(bs),
1204                                error_get_pretty(err));
1205                 error_free(err);
1206                 return -1;
1207             }
1208         }
1209     }
1210
1211     return 0;
1212 }
1213
1214 void hmp_savevm(Monitor *mon, const QDict *qdict)
1215 {
1216     BlockDriverState *bs, *bs1;
1217     QEMUSnapshotInfo sn1, *sn = &sn1, old_sn1, *old_sn = &old_sn1;
1218     int ret;
1219     QEMUFile *f;
1220     int saved_vm_running;
1221     uint64_t vm_state_size;
1222     qemu_timeval tv;
1223     struct tm tm;
1224     const char *name = qdict_get_try_str(qdict, "name");
1225     Error *local_err = NULL;
1226
1227     /* Verify if there is a device that doesn't support snapshots and is writable */
1228     bs = NULL;
1229     while ((bs = bdrv_next(bs))) {
1230
1231         if (!bdrv_is_inserted(bs) || bdrv_is_read_only(bs)) {
1232             continue;
1233         }
1234
1235         if (!bdrv_can_snapshot(bs)) {
1236             monitor_printf(mon, "Device '%s' is writable but does not support snapshots.\n",
1237                                bdrv_get_device_name(bs));
1238             return;
1239         }
1240     }
1241
1242     bs = find_vmstate_bs();
1243     if (!bs) {
1244         monitor_printf(mon, "No block device can accept snapshots\n");
1245         return;
1246     }
1247
1248     saved_vm_running = runstate_is_running();
1249     vm_stop(RUN_STATE_SAVE_VM);
1250
1251     memset(sn, 0, sizeof(*sn));
1252
1253     /* fill auxiliary fields */
1254     qemu_gettimeofday(&tv);
1255     sn->date_sec = tv.tv_sec;
1256     sn->date_nsec = tv.tv_usec * 1000;
1257     sn->vm_clock_nsec = qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL);
1258
1259     if (name) {
1260         ret = bdrv_snapshot_find(bs, old_sn, name);
1261         if (ret >= 0) {
1262             pstrcpy(sn->name, sizeof(sn->name), old_sn->name);
1263             pstrcpy(sn->id_str, sizeof(sn->id_str), old_sn->id_str);
1264         } else {
1265             pstrcpy(sn->name, sizeof(sn->name), name);
1266         }
1267     } else {
1268         /* cast below needed for OpenBSD where tv_sec is still 'long' */
1269         localtime_r((const time_t *)&tv.tv_sec, &tm);
1270         strftime(sn->name, sizeof(sn->name), "vm-%Y%m%d%H%M%S", &tm);
1271     }
1272
1273     /* Delete old snapshots of the same name */
1274     if (name && del_existing_snapshots(mon, name) < 0) {
1275         goto the_end;
1276     }
1277
1278     /* save the VM state */
1279     f = qemu_fopen_bdrv(bs, 1);
1280     if (!f) {
1281         monitor_printf(mon, "Could not open VM state file\n");
1282         goto the_end;
1283     }
1284     ret = qemu_savevm_state(f, &local_err);
1285     vm_state_size = qemu_ftell(f);
1286     qemu_fclose(f);
1287     if (ret < 0) {
1288         monitor_printf(mon, "%s\n", error_get_pretty(local_err));
1289         error_free(local_err);
1290         goto the_end;
1291     }
1292
1293     /* create the snapshots */
1294
1295     bs1 = NULL;
1296     while ((bs1 = bdrv_next(bs1))) {
1297         if (bdrv_can_snapshot(bs1)) {
1298             /* Write VM state size only to the image that contains the state */
1299             sn->vm_state_size = (bs == bs1 ? vm_state_size : 0);
1300             ret = bdrv_snapshot_create(bs1, sn);
1301             if (ret < 0) {
1302                 monitor_printf(mon, "Error while creating snapshot on '%s'\n",
1303                                bdrv_get_device_name(bs1));
1304             }
1305         }
1306     }
1307
1308  the_end:
1309     if (saved_vm_running) {
1310         vm_start();
1311     }
1312 }
1313
1314 void qmp_xen_save_devices_state(const char *filename, Error **errp)
1315 {
1316     QEMUFile *f;
1317     int saved_vm_running;
1318     int ret;
1319
1320     saved_vm_running = runstate_is_running();
1321     vm_stop(RUN_STATE_SAVE_VM);
1322
1323     f = qemu_fopen(filename, "wb");
1324     if (!f) {
1325         error_setg_file_open(errp, errno, filename);
1326         goto the_end;
1327     }
1328     ret = qemu_save_device_state(f);
1329     qemu_fclose(f);
1330     if (ret < 0) {
1331         error_setg(errp, QERR_IO_ERROR);
1332     }
1333
1334  the_end:
1335     if (saved_vm_running) {
1336         vm_start();
1337     }
1338 }
1339
1340 int load_vmstate(const char *name)
1341 {
1342     BlockDriverState *bs, *bs_vm_state;
1343     QEMUSnapshotInfo sn;
1344     QEMUFile *f;
1345     int ret;
1346
1347     bs_vm_state = find_vmstate_bs();
1348     if (!bs_vm_state) {
1349         error_report("No block device supports snapshots");
1350         return -ENOTSUP;
1351     }
1352
1353     /* Don't even try to load empty VM states */
1354     ret = bdrv_snapshot_find(bs_vm_state, &sn, name);
1355     if (ret < 0) {
1356         return ret;
1357     } else if (sn.vm_state_size == 0) {
1358         error_report("This is a disk-only snapshot. Revert to it offline "
1359             "using qemu-img.");
1360         return -EINVAL;
1361     }
1362
1363     /* Verify if there is any device that doesn't support snapshots and is
1364     writable and check if the requested snapshot is available too. */
1365     bs = NULL;
1366     while ((bs = bdrv_next(bs))) {
1367
1368         if (!bdrv_is_inserted(bs) || bdrv_is_read_only(bs)) {
1369             continue;
1370         }
1371
1372         if (!bdrv_can_snapshot(bs)) {
1373             error_report("Device '%s' is writable but does not support snapshots.",
1374                                bdrv_get_device_name(bs));
1375             return -ENOTSUP;
1376         }
1377
1378         ret = bdrv_snapshot_find(bs, &sn, name);
1379         if (ret < 0) {
1380             error_report("Device '%s' does not have the requested snapshot '%s'",
1381                            bdrv_get_device_name(bs), name);
1382             return ret;
1383         }
1384     }
1385
1386     /* Flush all IO requests so they don't interfere with the new state.  */
1387     bdrv_drain_all();
1388
1389     bs = NULL;
1390     while ((bs = bdrv_next(bs))) {
1391         if (bdrv_can_snapshot(bs)) {
1392             ret = bdrv_snapshot_goto(bs, name);
1393             if (ret < 0) {
1394                 error_report("Error %d while activating snapshot '%s' on '%s'",
1395                              ret, name, bdrv_get_device_name(bs));
1396                 return ret;
1397             }
1398         }
1399     }
1400
1401     /* restore the VM state */
1402     f = qemu_fopen_bdrv(bs_vm_state, 0);
1403     if (!f) {
1404         error_report("Could not open VM state file");
1405         return -EINVAL;
1406     }
1407
1408     qemu_system_reset(VMRESET_SILENT);
1409     migration_incoming_state_new(f);
1410     ret = qemu_loadvm_state(f);
1411
1412     qemu_fclose(f);
1413     migration_incoming_state_destroy();
1414     if (ret < 0) {
1415         error_report("Error %d while loading VM state", ret);
1416         return ret;
1417     }
1418
1419     return 0;
1420 }
1421
1422 void hmp_delvm(Monitor *mon, const QDict *qdict)
1423 {
1424     BlockDriverState *bs;
1425     Error *err;
1426     const char *name = qdict_get_str(qdict, "name");
1427
1428     if (!find_vmstate_bs()) {
1429         monitor_printf(mon, "No block device supports snapshots\n");
1430         return;
1431     }
1432
1433     bs = NULL;
1434     while ((bs = bdrv_next(bs))) {
1435         if (bdrv_can_snapshot(bs)) {
1436             err = NULL;
1437             bdrv_snapshot_delete_by_id_or_name(bs, name, &err);
1438             if (err) {
1439                 monitor_printf(mon,
1440                                "Error while deleting snapshot on device '%s':"
1441                                " %s\n",
1442                                bdrv_get_device_name(bs),
1443                                error_get_pretty(err));
1444                 error_free(err);
1445             }
1446         }
1447     }
1448 }
1449
1450 void hmp_info_snapshots(Monitor *mon, const QDict *qdict)
1451 {
1452     BlockDriverState *bs, *bs1;
1453     QEMUSnapshotInfo *sn_tab, *sn, s, *sn_info = &s;
1454     int nb_sns, i, ret, available;
1455     int total;
1456     int *available_snapshots;
1457
1458     bs = find_vmstate_bs();
1459     if (!bs) {
1460         monitor_printf(mon, "No available block device supports snapshots\n");
1461         return;
1462     }
1463
1464     nb_sns = bdrv_snapshot_list(bs, &sn_tab);
1465     if (nb_sns < 0) {
1466         monitor_printf(mon, "bdrv_snapshot_list: error %d\n", nb_sns);
1467         return;
1468     }
1469
1470     if (nb_sns == 0) {
1471         monitor_printf(mon, "There is no snapshot available.\n");
1472         return;
1473     }
1474
1475     available_snapshots = g_malloc0(sizeof(int) * nb_sns);
1476     total = 0;
1477     for (i = 0; i < nb_sns; i++) {
1478         sn = &sn_tab[i];
1479         available = 1;
1480         bs1 = NULL;
1481
1482         while ((bs1 = bdrv_next(bs1))) {
1483             if (bdrv_can_snapshot(bs1) && bs1 != bs) {
1484                 ret = bdrv_snapshot_find(bs1, sn_info, sn->id_str);
1485                 if (ret < 0) {
1486                     available = 0;
1487                     break;
1488                 }
1489             }
1490         }
1491
1492         if (available) {
1493             available_snapshots[total] = i;
1494             total++;
1495         }
1496     }
1497
1498     if (total > 0) {
1499         bdrv_snapshot_dump((fprintf_function)monitor_printf, mon, NULL);
1500         monitor_printf(mon, "\n");
1501         for (i = 0; i < total; i++) {
1502             sn = &sn_tab[available_snapshots[i]];
1503             bdrv_snapshot_dump((fprintf_function)monitor_printf, mon, sn);
1504             monitor_printf(mon, "\n");
1505         }
1506     } else {
1507         monitor_printf(mon, "There is no suitable snapshot available\n");
1508     }
1509
1510     g_free(sn_tab);
1511     g_free(available_snapshots);
1512
1513 }
1514
1515 void vmstate_register_ram(MemoryRegion *mr, DeviceState *dev)
1516 {
1517     qemu_ram_set_idstr(memory_region_get_ram_addr(mr) & TARGET_PAGE_MASK,
1518                        memory_region_name(mr), dev);
1519 }
1520
1521 void vmstate_unregister_ram(MemoryRegion *mr, DeviceState *dev)
1522 {
1523     qemu_ram_unset_idstr(memory_region_get_ram_addr(mr) & TARGET_PAGE_MASK);
1524 }
1525
1526 void vmstate_register_ram_global(MemoryRegion *mr)
1527 {
1528     vmstate_register_ram(mr, NULL);
1529 }