savevm.c

   1 /*
   2  * QEMU System Emulator
   3  *
   4  * Copyright (c) 2003-2008 Fabrice Bellard
   5  *
   6  * Permission is hereby granted, free of charge, to any person obtaining a copy
   7  * of this software and associated documentation files (the "Software"), to deal
   8  * in the Software without restriction, including without limitation the rights
   9  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  10  * copies of the Software, and to permit persons to whom the Software is
  11  * furnished to do so, subject to the following conditions:
  12  *
  13  * The above copyright notice and this permission notice shall be included in
  14  * all copies or substantial portions of the Software.
  15  *
  16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  17  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  18  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
  19  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  20  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  21  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  22  * THE SOFTWARE.
  23  */
  24
  25 #include "config-host.h"
  26 #include "qemu-common.h"
  27 #include "hw/hw.h"
  28 #include "hw/qdev.h"
  29 #include "net/net.h"
  30 #include "monitor/monitor.h"
  31 #include "sysemu/sysemu.h"
  32 #include "qemu/timer.h"
  33 #include "audio/audio.h"
  34 #include "migration/migration.h"
  35 #include "qemu/sockets.h"
  36 #include "qemu/queue.h"
  37 #include "sysemu/cpus.h"
  38 #include "exec/memory.h"
  39 #include "qmp-commands.h"
  40 #include "trace.h"
  41 #include "qemu/bitops.h"
  42 #include "qemu/iov.h"
  43 #include "block/snapshot.h"
  44 #include "block/qapi.h"
  45
  46 #define SELF_ANNOUNCE_ROUNDS 5
  47
  48 #ifndef ETH_P_RARP
  49 #define ETH_P_RARP 0x8035
  50 #endif
  51 #define ARP_HTYPE_ETH 0x0001
  52 #define ARP_PTYPE_IP 0x0800
  53 #define ARP_OP_REQUEST_REV 0x3
  54
  55 static int announce_self_create(uint8_t *buf,
  56                                 uint8_t *mac_addr)
  57 {
  58     /* Ethernet header. */
  59     memset(buf, 0xff, 6);         /* destination MAC addr */
  60     memcpy(buf + 6, mac_addr, 6); /* source MAC addr */
  61     *(uint16_t *)(buf + 12) = htons(ETH_P_RARP); /* ethertype */
  62
  63     /* RARP header. */
  64     *(uint16_t *)(buf + 14) = htons(ARP_HTYPE_ETH); /* hardware addr space */
  65     *(uint16_t *)(buf + 16) = htons(ARP_PTYPE_IP); /* protocol addr space */
  66     *(buf + 18) = 6; /* hardware addr length (ethernet) */
  67     *(buf + 19) = 4; /* protocol addr length (IPv4) */
  68     *(uint16_t *)(buf + 20) = htons(ARP_OP_REQUEST_REV); /* opcode */
  69     memcpy(buf + 22, mac_addr, 6); /* source hw addr */
  70     memset(buf + 28, 0x00, 4);     /* source protocol addr */
  71     memcpy(buf + 32, mac_addr, 6); /* target hw addr */
  72     memset(buf + 38, 0x00, 4);     /* target protocol addr */
  73
  74     /* Padding to get up to 60 bytes (ethernet min packet size, minus FCS). */
  75     memset(buf + 42, 0x00, 18);
  76
  77     return 60; /* len (FCS will be added by hardware) */
  78 }
  79
  80 static void qemu_announce_self_iter(NICState *nic, void *opaque)
  81 {
  82     uint8_t buf[60];
  83     int len;
  84
  85     len = announce_self_create(buf, nic->conf->macaddr.a);
  86
  87     qemu_send_packet_raw(qemu_get_queue(nic), buf, len);
  88 }
  89
  90
  91 static void qemu_announce_self_once(void *opaque)
  92 {
  93     static int count = SELF_ANNOUNCE_ROUNDS;
  94     QEMUTimer *timer = *(QEMUTimer **)opaque;
  95
  96     qemu_foreach_nic(qemu_announce_self_iter, NULL);
  97
  98     if (--count) {
  99         /* delay 50ms, 150ms, 250ms, ... */
 100         timer_mod(timer, qemu_clock_get_ms(QEMU_CLOCK_REALTIME) +
 101                        50 + (SELF_ANNOUNCE_ROUNDS - count - 1) * 100);
 102     } else {
 103             timer_del(timer);
 104             timer_free(timer);
 105     }
 106 }
 107
 108 void qemu_announce_self(void)
 109 {
 110         static QEMUTimer *timer;
 111         timer = timer_new_ms(QEMU_CLOCK_REALTIME, qemu_announce_self_once, &timer);
 112         qemu_announce_self_once(&timer);
 113 }
 114
 115 /***********************************************************/
 116 /* savevm/loadvm support */
 117
 118 #define IO_BUF_SIZE 32768
 119 #define MAX_IOV_SIZE MIN(IOV_MAX, 64)
 120
 121 struct QEMUFile {
 122     const QEMUFileOps *ops;
 123     void *opaque;
 124
 125     int64_t bytes_xfer;
 126     int64_t xfer_limit;
 127
 128     int64_t pos; /* start of buffer when writing, end of buffer
 129                     when reading */
 130     int buf_index;
 131     int buf_size; /* 0 when writing */
 132     uint8_t buf[IO_BUF_SIZE];
 133
 134     struct iovec iov[MAX_IOV_SIZE];
 135     unsigned int iovcnt;
 136
 137     int last_error;
 138 };
 139
 140 typedef struct QEMUFileStdio
 141 {
 142     FILE *stdio_file;
 143     QEMUFile *file;
 144 } QEMUFileStdio;
 145
 146 typedef struct QEMUFileSocket
 147 {
 148     int fd;
 149     QEMUFile *file;
 150 } QEMUFileSocket;
 151
 152 static ssize_t socket_writev_buffer(void *opaque, struct iovec *iov, int iovcnt,
 153                                     int64_t pos)
 154 {
 155     QEMUFileSocket *s = opaque;
 156     ssize_t len;
 157     ssize_t size = iov_size(iov, iovcnt);
 158
 159     len = iov_send(s->fd, iov, iovcnt, 0, size);
 160     if (len < size) {
 161         len = -socket_error();
 162     }
 163     return len;
 164 }
 165
 166 static int socket_get_fd(void *opaque)
 167 {
 168     QEMUFileSocket *s = opaque;
 169
 170     return s->fd;
 171 }
 172
 173 static int socket_get_buffer(void *opaque, uint8_t *buf, int64_t pos, int size)
 174 {
 175     QEMUFileSocket *s = opaque;
 176     ssize_t len;
 177
 178     for (;;) {
 179         len = qemu_recv(s->fd, buf, size, 0);
 180         if (len != -1) {
 181             break;
 182         }
 183         if (socket_error() == EAGAIN) {
 184             yield_until_fd_readable(s->fd);
 185         } else if (socket_error() != EINTR) {
 186             break;
 187         }
 188     }
 189
 190     if (len == -1) {
 191         len = -socket_error();
 192     }
 193     return len;
 194 }
 195
 196 static int socket_close(void *opaque)
 197 {
 198     QEMUFileSocket *s = opaque;
 199     closesocket(s->fd);
 200     g_free(s);
 201     return 0;
 202 }
 203
 204 static int stdio_get_fd(void *opaque)
 205 {
 206     QEMUFileStdio *s = opaque;
 207
 208     return fileno(s->stdio_file);
 209 }
 210
 211 static int stdio_put_buffer(void *opaque, const uint8_t *buf, int64_t pos, int size)
 212 {
 213     QEMUFileStdio *s = opaque;
 214     return fwrite(buf, 1, size, s->stdio_file);
 215 }
 216
 217 static int stdio_get_buffer(void *opaque, uint8_t *buf, int64_t pos, int size)
 218 {
 219     QEMUFileStdio *s = opaque;
 220     FILE *fp = s->stdio_file;
 221     int bytes;
 222
 223     for (;;) {
 224         clearerr(fp);
 225         bytes = fread(buf, 1, size, fp);
 226         if (bytes != 0 || !ferror(fp)) {
 227             break;
 228         }
 229         if (errno == EAGAIN) {
 230             yield_until_fd_readable(fileno(fp));
 231         } else if (errno != EINTR) {
 232             break;
 233         }
 234     }
 235     return bytes;
 236 }
 237
 238 static int stdio_pclose(void *opaque)
 239 {
 240     QEMUFileStdio *s = opaque;
 241     int ret;
 242     ret = pclose(s->stdio_file);
 243     if (ret == -1) {
 244         ret = -errno;
 245     } else if (!WIFEXITED(ret) || WEXITSTATUS(ret) != 0) {
 246         /* close succeeded, but non-zero exit code: */
 247         ret = -EIO; /* fake errno value */
 248     }
 249     g_free(s);
 250     return ret;
 251 }
 252
 253 static int stdio_fclose(void *opaque)
 254 {
 255     QEMUFileStdio *s = opaque;
 256     int ret = 0;
 257
 258     if (s->file->ops->put_buffer || s->file->ops->writev_buffer) {
 259         int fd = fileno(s->stdio_file);
 260         struct stat st;
 261
 262         ret = fstat(fd, &st);
 263         if (ret == 0 && S_ISREG(st.st_mode)) {
 264             /*
 265              * If the file handle is a regular file make sure the
 266              * data is flushed to disk before signaling success.
 267              */
 268             ret = fsync(fd);
 269             if (ret != 0) {
 270                 ret = -errno;
 271                 return ret;
 272             }
 273         }
 274     }
 275     if (fclose(s->stdio_file) == EOF) {
 276         ret = -errno;
 277     }
 278     g_free(s);
 279     return ret;
 280 }
 281
 282 static const QEMUFileOps stdio_pipe_read_ops = {
 283     .get_fd =     stdio_get_fd,
 284     .get_buffer = stdio_get_buffer,
 285     .close =      stdio_pclose
 286 };
 287
 288 static const QEMUFileOps stdio_pipe_write_ops = {
 289     .get_fd =     stdio_get_fd,
 290     .put_buffer = stdio_put_buffer,
 291     .close =      stdio_pclose
 292 };
 293
 294 QEMUFile *qemu_popen_cmd(const char *command, const char *mode)
 295 {
 296     FILE *stdio_file;
 297     QEMUFileStdio *s;
 298
 299     if (mode == NULL || (mode[0] != 'r' && mode[0] != 'w') || mode[1] != 0) {
 300         fprintf(stderr, "qemu_popen: Argument validity check failed\n");
 301         return NULL;
 302     }
 303
 304     stdio_file = popen(command, mode);
 305     if (stdio_file == NULL) {
 306         return NULL;
 307     }
 308
 309     s = g_malloc0(sizeof(QEMUFileStdio));
 310
 311     s->stdio_file = stdio_file;
 312
 313     if(mode[0] == 'r') {
 314         s->file = qemu_fopen_ops(s, &stdio_pipe_read_ops);
 315     } else {
 316         s->file = qemu_fopen_ops(s, &stdio_pipe_write_ops);
 317     }
 318     return s->file;
 319 }
 320
 321 static const QEMUFileOps stdio_file_read_ops = {
 322     .get_fd =     stdio_get_fd,
 323     .get_buffer = stdio_get_buffer,
 324     .close =      stdio_fclose
 325 };
 326
 327 static const QEMUFileOps stdio_file_write_ops = {
 328     .get_fd =     stdio_get_fd,
 329     .put_buffer = stdio_put_buffer,
 330     .close =      stdio_fclose
 331 };
 332
 333 static ssize_t unix_writev_buffer(void *opaque, struct iovec *iov, int iovcnt,
 334                                   int64_t pos)
 335 {
 336     QEMUFileSocket *s = opaque;
 337     ssize_t len, offset;
 338     ssize_t size = iov_size(iov, iovcnt);
 339     ssize_t total = 0;
 340
 341     assert(iovcnt > 0);
 342     offset = 0;
 343     while (size > 0) {
 344         /* Find the next start position; skip all full-sized vector elements  */
 345         while (offset >= iov[0].iov_len) {
 346             offset -= iov[0].iov_len;
 347             iov++, iovcnt--;
 348         }
 349
 350         /* skip `offset' bytes from the (now) first element, undo it on exit */
 351         assert(iovcnt > 0);
 352         iov[0].iov_base += offset;
 353         iov[0].iov_len -= offset;
 354
 355         do {
 356             len = writev(s->fd, iov, iovcnt);
 357         } while (len == -1 && errno == EINTR);
 358         if (len == -1) {
 359             return -errno;
 360         }
 361
 362         /* Undo the changes above */
 363         iov[0].iov_base -= offset;
 364         iov[0].iov_len += offset;
 365
 366         /* Prepare for the next iteration */
 367         offset += len;
 368         total += len;
 369         size -= len;
 370     }
 371
 372     return total;
 373 }
 374
 375 static int unix_get_buffer(void *opaque, uint8_t *buf, int64_t pos, int size)
 376 {
 377     QEMUFileSocket *s = opaque;
 378     ssize_t len;
 379
 380     for (;;) {
 381         len = read(s->fd, buf, size);
 382         if (len != -1) {
 383             break;
 384         }
 385         if (errno == EAGAIN) {
 386             yield_until_fd_readable(s->fd);
 387         } else if (errno != EINTR) {
 388             break;
 389         }
 390     }
 391
 392     if (len == -1) {
 393         len = -errno;
 394     }
 395     return len;
 396 }
 397
 398 static int unix_close(void *opaque)
 399 {
 400     QEMUFileSocket *s = opaque;
 401     close(s->fd);
 402     g_free(s);
 403     return 0;
 404 }
 405
 406 static const QEMUFileOps unix_read_ops = {
 407     .get_fd =     socket_get_fd,
 408     .get_buffer = unix_get_buffer,
 409     .close =      unix_close
 410 };
 411
 412 static const QEMUFileOps unix_write_ops = {
 413     .get_fd =     socket_get_fd,
 414     .writev_buffer = unix_writev_buffer,
 415     .close =      unix_close
 416 };
 417
 418 QEMUFile *qemu_fdopen(int fd, const char *mode)
 419 {
 420     QEMUFileSocket *s;
 421
 422     if (mode == NULL ||
 423         (mode[0] != 'r' && mode[0] != 'w') ||
 424         mode[1] != 'b' || mode[2] != 0) {
 425         fprintf(stderr, "qemu_fdopen: Argument validity check failed\n");
 426         return NULL;
 427     }
 428
 429     s = g_malloc0(sizeof(QEMUFileSocket));
 430     s->fd = fd;
 431
 432     if(mode[0] == 'r') {
 433         s->file = qemu_fopen_ops(s, &unix_read_ops);
 434     } else {
 435         s->file = qemu_fopen_ops(s, &unix_write_ops);
 436     }
 437     return s->file;
 438 }
 439
 440 static const QEMUFileOps socket_read_ops = {
 441     .get_fd =     socket_get_fd,
 442     .get_buffer = socket_get_buffer,
 443     .close =      socket_close
 444 };
 445
 446 static const QEMUFileOps socket_write_ops = {
 447     .get_fd =     socket_get_fd,
 448     .writev_buffer = socket_writev_buffer,
 449     .close =      socket_close
 450 };
 451
 452 bool qemu_file_mode_is_not_valid(const char *mode)
 453 {
 454     if (mode == NULL ||
 455         (mode[0] != 'r' && mode[0] != 'w') ||
 456         mode[1] != 'b' || mode[2] != 0) {
 457         fprintf(stderr, "qemu_fopen: Argument validity check failed\n");
 458         return true;
 459     }
 460
 461     return false;
 462 }
 463
 464 QEMUFile *qemu_fopen_socket(int fd, const char *mode)
 465 {
 466     QEMUFileSocket *s;
 467
 468     if (qemu_file_mode_is_not_valid(mode)) {
 469         return NULL;
 470     }
 471
 472     s = g_malloc0(sizeof(QEMUFileSocket));
 473     s->fd = fd;
 474     if (mode[0] == 'w') {
 475         qemu_set_block(s->fd);
 476         s->file = qemu_fopen_ops(s, &socket_write_ops);
 477     } else {
 478         s->file = qemu_fopen_ops(s, &socket_read_ops);
 479     }
 480     return s->file;
 481 }
 482
 483 QEMUFile *qemu_fopen(const char *filename, const char *mode)
 484 {
 485     QEMUFileStdio *s;
 486
 487     if (qemu_file_mode_is_not_valid(mode)) {
 488         return NULL;
 489     }
 490
 491     s = g_malloc0(sizeof(QEMUFileStdio));
 492
 493     s->stdio_file = fopen(filename, mode);
 494     if (!s->stdio_file)
 495         goto fail;
 496
 497     if(mode[0] == 'w') {
 498         s->file = qemu_fopen_ops(s, &stdio_file_write_ops);
 499     } else {
 500         s->file = qemu_fopen_ops(s, &stdio_file_read_ops);
 501     }
 502     return s->file;
 503 fail:
 504     g_free(s);
 505     return NULL;
 506 }
 507
 508 static ssize_t block_writev_buffer(void *opaque, struct iovec *iov, int iovcnt,
 509                                    int64_t pos)
 510 {
 511     int ret;
 512     QEMUIOVector qiov;
 513
 514     qemu_iovec_init_external(&qiov, iov, iovcnt);
 515     ret = bdrv_writev_vmstate(opaque, &qiov, pos);
 516     if (ret < 0) {
 517         return ret;
 518     }
 519
 520     return qiov.size;
 521 }
 522
 523 static int block_put_buffer(void *opaque, const uint8_t *buf,
 524                            int64_t pos, int size)
 525 {
 526     bdrv_save_vmstate(opaque, buf, pos, size);
 527     return size;
 528 }
 529
 530 static int block_get_buffer(void *opaque, uint8_t *buf, int64_t pos, int size)
 531 {
 532     return bdrv_load_vmstate(opaque, buf, pos, size);
 533 }
 534
 535 static int bdrv_fclose(void *opaque)
 536 {
 537     return bdrv_flush(opaque);
 538 }
 539
 540 static const QEMUFileOps bdrv_read_ops = {
 541     .get_buffer = block_get_buffer,
 542     .close =      bdrv_fclose
 543 };
 544
 545 static const QEMUFileOps bdrv_write_ops = {
 546     .put_buffer     = block_put_buffer,
 547     .writev_buffer  = block_writev_buffer,
 548     .close          = bdrv_fclose
 549 };
 550
 551 static QEMUFile *qemu_fopen_bdrv(BlockDriverState *bs, int is_writable)
 552 {
 553     if (is_writable)
 554         return qemu_fopen_ops(bs, &bdrv_write_ops);
 555     return qemu_fopen_ops(bs, &bdrv_read_ops);
 556 }
 557
 558 QEMUFile *qemu_fopen_ops(void *opaque, const QEMUFileOps *ops)
 559 {
 560     QEMUFile *f;
 561
 562     f = g_malloc0(sizeof(QEMUFile));
 563
 564     f->opaque = opaque;
 565     f->ops = ops;
 566     return f;
 567 }
 568
 569 int qemu_file_get_error(QEMUFile *f)
 570 {
 571     return f->last_error;
 572 }
 573
 574 static void qemu_file_set_error(QEMUFile *f, int ret)
 575 {
 576     if (f->last_error == 0) {
 577         f->last_error = ret;
 578     }
 579 }
 580
 581 static inline bool qemu_file_is_writable(QEMUFile *f)
 582 {
 583     return f->ops->writev_buffer || f->ops->put_buffer;
 584 }
 585
 586 /**
 587  * Flushes QEMUFile buffer
 588  *
 589  * If there is writev_buffer QEMUFileOps it uses it otherwise uses
 590  * put_buffer ops.
 591  */
 592 void qemu_fflush(QEMUFile *f)
 593 {
 594     ssize_t ret = 0;
 595
 596     if (!qemu_file_is_writable(f)) {
 597         return;
 598     }
 599
 600     if (f->ops->writev_buffer) {
 601         if (f->iovcnt > 0) {
 602             ret = f->ops->writev_buffer(f->opaque, f->iov, f->iovcnt, f->pos);
 603         }
 604     } else {
 605         if (f->buf_index > 0) {
 606             ret = f->ops->put_buffer(f->opaque, f->buf, f->pos, f->buf_index);
 607         }
 608     }
 609     if (ret >= 0) {
 610         f->pos += ret;
 611     }
 612     f->buf_index = 0;
 613     f->iovcnt = 0;
 614     if (ret < 0) {
 615         qemu_file_set_error(f, ret);
 616     }
 617 }
 618
 619 void ram_control_before_iterate(QEMUFile *f, uint64_t flags)
 620 {
 621     int ret = 0;
 622
 623     if (f->ops->before_ram_iterate) {
 624         ret = f->ops->before_ram_iterate(f, f->opaque, flags);
 625         if (ret < 0) {
 626             qemu_file_set_error(f, ret);
 627         }
 628     }
 629 }
 630
 631 void ram_control_after_iterate(QEMUFile *f, uint64_t flags)
 632 {
 633     int ret = 0;
 634
 635     if (f->ops->after_ram_iterate) {
 636         ret = f->ops->after_ram_iterate(f, f->opaque, flags);
 637         if (ret < 0) {
 638             qemu_file_set_error(f, ret);
 639         }
 640     }
 641 }
 642
 643 void ram_control_load_hook(QEMUFile *f, uint64_t flags)
 644 {
 645     int ret = 0;
 646
 647     if (f->ops->hook_ram_load) {
 648         ret = f->ops->hook_ram_load(f, f->opaque, flags);
 649         if (ret < 0) {
 650             qemu_file_set_error(f, ret);
 651         }
 652     } else {
 653         qemu_file_set_error(f, ret);
 654     }
 655 }
 656
 657 size_t ram_control_save_page(QEMUFile *f, ram_addr_t block_offset,
 658                          ram_addr_t offset, size_t size, int *bytes_sent)
 659 {
 660     if (f->ops->save_page) {
 661         int ret = f->ops->save_page(f, f->opaque, block_offset,
 662                                     offset, size, bytes_sent);
 663
 664         if (ret != RAM_SAVE_CONTROL_DELAYED) {
 665             if (bytes_sent && *bytes_sent > 0) {
 666                 qemu_update_position(f, *bytes_sent);
 667             } else if (ret < 0) {
 668                 qemu_file_set_error(f, ret);
 669             }
 670         }
 671
 672         return ret;
 673     }
 674
 675     return RAM_SAVE_CONTROL_NOT_SUPP;
 676 }
 677
 678 static void qemu_fill_buffer(QEMUFile *f)
 679 {
 680     int len;
 681     int pending;
 682
 683     assert(!qemu_file_is_writable(f));
 684
 685     pending = f->buf_size - f->buf_index;
 686     if (pending > 0) {
 687         memmove(f->buf, f->buf + f->buf_index, pending);
 688     }
 689     f->buf_index = 0;
 690     f->buf_size = pending;
 691
 692     len = f->ops->get_buffer(f->opaque, f->buf + pending, f->pos,
 693                         IO_BUF_SIZE - pending);
 694     if (len > 0) {
 695         f->buf_size += len;
 696         f->pos += len;
 697     } else if (len == 0) {
 698         qemu_file_set_error(f, -EIO);
 699     } else if (len != -EAGAIN)
 700         qemu_file_set_error(f, len);
 701 }
 702
 703 int qemu_get_fd(QEMUFile *f)
 704 {
 705     if (f->ops->get_fd) {
 706         return f->ops->get_fd(f->opaque);
 707     }
 708     return -1;
 709 }
 710
 711 void qemu_update_position(QEMUFile *f, size_t size)
 712 {
 713     f->pos += size;
 714 }
 715
 716 /** Closes the file
 717  *
 718  * Returns negative error value if any error happened on previous operations or
 719  * while closing the file. Returns 0 or positive number on success.
 720  *
 721  * The meaning of return value on success depends on the specific backend
 722  * being used.
 723  */
 724 int qemu_fclose(QEMUFile *f)
 725 {
 726     int ret;
 727     qemu_fflush(f);
 728     ret = qemu_file_get_error(f);
 729
 730     if (f->ops->close) {
 731         int ret2 = f->ops->close(f->opaque);
 732         if (ret >= 0) {
 733             ret = ret2;
 734         }
 735     }
 736     /* If any error was spotted before closing, we should report it
 737      * instead of the close() return value.
 738      */
 739     if (f->last_error) {
 740         ret = f->last_error;
 741     }
 742     g_free(f);
 743     return ret;
 744 }
 745
 746 static void add_to_iovec(QEMUFile *f, const uint8_t *buf, int size)
 747 {
 748     /* check for adjacent buffer and coalesce them */
 749     if (f->iovcnt > 0 && buf == f->iov[f->iovcnt - 1].iov_base +
 750         f->iov[f->iovcnt - 1].iov_len) {
 751         f->iov[f->iovcnt - 1].iov_len += size;
 752     } else {
 753         f->iov[f->iovcnt].iov_base = (uint8_t *)buf;
 754         f->iov[f->iovcnt++].iov_len = size;
 755     }
 756
 757     if (f->iovcnt >= MAX_IOV_SIZE) {
 758         qemu_fflush(f);
 759     }
 760 }
 761
 762 void qemu_put_buffer_async(QEMUFile *f, const uint8_t *buf, int size)
 763 {
 764     if (!f->ops->writev_buffer) {
 765         qemu_put_buffer(f, buf, size);
 766         return;
 767     }
 768
 769     if (f->last_error) {
 770         return;
 771     }
 772
 773     f->bytes_xfer += size;
 774     add_to_iovec(f, buf, size);
 775 }
 776
 777 void qemu_put_buffer(QEMUFile *f, const uint8_t *buf, int size)
 778 {
 779     int l;
 780
 781     if (f->last_error) {
 782         return;
 783     }
 784
 785     while (size > 0) {
 786         l = IO_BUF_SIZE - f->buf_index;
 787         if (l > size)
 788             l = size;
 789         memcpy(f->buf + f->buf_index, buf, l);
 790         f->bytes_xfer += size;
 791         if (f->ops->writev_buffer) {
 792             add_to_iovec(f, f->buf + f->buf_index, l);
 793         }
 794         f->buf_index += l;
 795         if (f->buf_index == IO_BUF_SIZE) {
 796             qemu_fflush(f);
 797         }
 798         if (qemu_file_get_error(f)) {
 799             break;
 800         }
 801         buf += l;
 802         size -= l;
 803     }
 804 }
 805
 806 void qemu_put_byte(QEMUFile *f, int v)
 807 {
 808     if (f->last_error) {
 809         return;
 810     }
 811
 812     f->buf[f->buf_index] = v;
 813     f->bytes_xfer++;
 814     if (f->ops->writev_buffer) {
 815         add_to_iovec(f, f->buf + f->buf_index, 1);
 816     }
 817     f->buf_index++;
 818     if (f->buf_index == IO_BUF_SIZE) {
 819         qemu_fflush(f);
 820     }
 821 }
 822
 823 static void qemu_file_skip(QEMUFile *f, int size)
 824 {
 825     if (f->buf_index + size <= f->buf_size) {
 826         f->buf_index += size;
 827     }
 828 }
 829
 830 static int qemu_peek_buffer(QEMUFile *f, uint8_t *buf, int size, size_t offset)
 831 {
 832     int pending;
 833     int index;
 834
 835     assert(!qemu_file_is_writable(f));
 836
 837     index = f->buf_index + offset;
 838     pending = f->buf_size - index;
 839     if (pending < size) {
 840         qemu_fill_buffer(f);
 841         index = f->buf_index + offset;
 842         pending = f->buf_size - index;
 843     }
 844
 845     if (pending <= 0) {
 846         return 0;
 847     }
 848     if (size > pending) {
 849         size = pending;
 850     }
 851
 852     memcpy(buf, f->buf + index, size);
 853     return size;
 854 }
 855
 856 int qemu_get_buffer(QEMUFile *f, uint8_t *buf, int size)
 857 {
 858     int pending = size;
 859     int done = 0;
 860
 861     while (pending > 0) {
 862         int res;
 863
 864         res = qemu_peek_buffer(f, buf, pending, 0);
 865         if (res == 0) {
 866             return done;
 867         }
 868         qemu_file_skip(f, res);
 869         buf += res;
 870         pending -= res;
 871         done += res;
 872     }
 873     return done;
 874 }
 875
 876 static int qemu_peek_byte(QEMUFile *f, int offset)
 877 {
 878     int index = f->buf_index + offset;
 879
 880     assert(!qemu_file_is_writable(f));
 881
 882     if (index >= f->buf_size) {
 883         qemu_fill_buffer(f);
 884         index = f->buf_index + offset;
 885         if (index >= f->buf_size) {
 886             return 0;
 887         }
 888     }
 889     return f->buf[index];
 890 }
 891
 892 int qemu_get_byte(QEMUFile *f)
 893 {
 894     int result;
 895
 896     result = qemu_peek_byte(f, 0);
 897     qemu_file_skip(f, 1);
 898     return result;
 899 }
 900
 901 int64_t qemu_ftell(QEMUFile *f)
 902 {
 903     qemu_fflush(f);
 904     return f->pos;
 905 }
 906
 907 int qemu_file_rate_limit(QEMUFile *f)
 908 {
 909     if (qemu_file_get_error(f)) {
 910         return 1;
 911     }
 912     if (f->xfer_limit > 0 && f->bytes_xfer > f->xfer_limit) {
 913         return 1;
 914     }
 915     return 0;
 916 }
 917
 918 int64_t qemu_file_get_rate_limit(QEMUFile *f)
 919 {
 920     return f->xfer_limit;
 921 }
 922
 923 void qemu_file_set_rate_limit(QEMUFile *f, int64_t limit)
 924 {
 925     f->xfer_limit = limit;
 926 }
 927
 928 void qemu_file_reset_rate_limit(QEMUFile *f)
 929 {
 930     f->bytes_xfer = 0;
 931 }
 932
 933 void qemu_put_be16(QEMUFile *f, unsigned int v)
 934 {
 935     qemu_put_byte(f, v >> 8);
 936     qemu_put_byte(f, v);
 937 }
 938
 939 void qemu_put_be32(QEMUFile *f, unsigned int v)
 940 {
 941     qemu_put_byte(f, v >> 24);
 942     qemu_put_byte(f, v >> 16);
 943     qemu_put_byte(f, v >> 8);
 944     qemu_put_byte(f, v);
 945 }
 946
 947 void qemu_put_be64(QEMUFile *f, uint64_t v)
 948 {
 949     qemu_put_be32(f, v >> 32);
 950     qemu_put_be32(f, v);
 951 }
 952
 953 unsigned int qemu_get_be16(QEMUFile *f)
 954 {
 955     unsigned int v;
 956     v = qemu_get_byte(f) << 8;
 957     v |= qemu_get_byte(f);
 958     return v;
 959 }
 960
 961 unsigned int qemu_get_be32(QEMUFile *f)
 962 {
 963     unsigned int v;
 964     v = qemu_get_byte(f) << 24;
 965     v |= qemu_get_byte(f) << 16;
 966     v |= qemu_get_byte(f) << 8;
 967     v |= qemu_get_byte(f);
 968     return v;
 969 }
 970
 971 uint64_t qemu_get_be64(QEMUFile *f)
 972 {
 973     uint64_t v;
 974     v = (uint64_t)qemu_get_be32(f) << 32;
 975     v |= qemu_get_be32(f);
 976     return v;
 977 }
 978
 979
 980 /* timer */
 981
 982 void timer_put(QEMUFile *f, QEMUTimer *ts)
 983 {
 984     uint64_t expire_time;
 985
 986     expire_time = timer_expire_time_ns(ts);
 987     qemu_put_be64(f, expire_time);
 988 }
 989
 990 void timer_get(QEMUFile *f, QEMUTimer *ts)
 991 {
 992     uint64_t expire_time;
 993
 994     expire_time = qemu_get_be64(f);
 995     if (expire_time != -1) {
 996         timer_mod_ns(ts, expire_time);
 997     } else {
 998         timer_del(ts);
 999     }
1000 }
1001
1002
1003 /* bool */
1004
1005 static int get_bool(QEMUFile *f, void *pv, size_t size)
1006 {
1007     bool *v = pv;
1008     *v = qemu_get_byte(f);
1009     return 0;
1010 }
1011
1012 static void put_bool(QEMUFile *f, void *pv, size_t size)
1013 {
1014     bool *v = pv;
1015     qemu_put_byte(f, *v);
1016 }
1017
1018 const VMStateInfo vmstate_info_bool = {
1019     .name = "bool",
1020     .get  = get_bool,
1021     .put  = put_bool,
1022 };
1023
1024 /* 8 bit int */
1025
1026 static int get_int8(QEMUFile *f, void *pv, size_t size)
1027 {
1028     int8_t *v = pv;
1029     qemu_get_s8s(f, v);
1030     return 0;
1031 }
1032
1033 static void put_int8(QEMUFile *f, void *pv, size_t size)
1034 {
1035     int8_t *v = pv;
1036     qemu_put_s8s(f, v);
1037 }
1038
1039 const VMStateInfo vmstate_info_int8 = {
1040     .name = "int8",
1041     .get  = get_int8,
1042     .put  = put_int8,
1043 };
1044
1045 /* 16 bit int */
1046
1047 static int get_int16(QEMUFile *f, void *pv, size_t size)
1048 {
1049     int16_t *v = pv;
1050     qemu_get_sbe16s(f, v);
1051     return 0;
1052 }
1053
1054 static void put_int16(QEMUFile *f, void *pv, size_t size)
1055 {
1056     int16_t *v = pv;
1057     qemu_put_sbe16s(f, v);
1058 }
1059
1060 const VMStateInfo vmstate_info_int16 = {
1061     .name = "int16",
1062     .get  = get_int16,
1063     .put  = put_int16,
1064 };
1065
1066 /* 32 bit int */
1067
1068 static int get_int32(QEMUFile *f, void *pv, size_t size)
1069 {
1070     int32_t *v = pv;
1071     qemu_get_sbe32s(f, v);
1072     return 0;
1073 }
1074
1075 static void put_int32(QEMUFile *f, void *pv, size_t size)
1076 {
1077     int32_t *v = pv;
1078     qemu_put_sbe32s(f, v);
1079 }
1080
1081 const VMStateInfo vmstate_info_int32 = {
1082     .name = "int32",
1083     .get  = get_int32,
1084     .put  = put_int32,
1085 };
1086
1087 /* 32 bit int. See that the received value is the same than the one
1088    in the field */
1089
1090 static int get_int32_equal(QEMUFile *f, void *pv, size_t size)
1091 {
1092     int32_t *v = pv;
1093     int32_t v2;
1094     qemu_get_sbe32s(f, &v2);
1095
1096     if (*v == v2)
1097         return 0;
1098     return -EINVAL;
1099 }
1100
1101 const VMStateInfo vmstate_info_int32_equal = {
1102     .name = "int32 equal",
1103     .get  = get_int32_equal,
1104     .put  = put_int32,
1105 };
1106
1107 /* 32 bit int. See that the received value is the less or the same
1108    than the one in the field */
1109
1110 static int get_int32_le(QEMUFile *f, void *pv, size_t size)
1111 {
1112     int32_t *old = pv;
1113     int32_t new;
1114     qemu_get_sbe32s(f, &new);
1115
1116     if (*old <= new)
1117         return 0;
1118     return -EINVAL;
1119 }
1120
1121 const VMStateInfo vmstate_info_int32_le = {
1122     .name = "int32 equal",
1123     .get  = get_int32_le,
1124     .put  = put_int32,
1125 };
1126
1127 /* 64 bit int */
1128
1129 static int get_int64(QEMUFile *f, void *pv, size_t size)
1130 {
1131     int64_t *v = pv;
1132     qemu_get_sbe64s(f, v);
1133     return 0;
1134 }
1135
1136 static void put_int64(QEMUFile *f, void *pv, size_t size)
1137 {
1138     int64_t *v = pv;
1139     qemu_put_sbe64s(f, v);
1140 }
1141
1142 const VMStateInfo vmstate_info_int64 = {
1143     .name = "int64",
1144     .get  = get_int64,
1145     .put  = put_int64,
1146 };
1147
1148 /* 8 bit unsigned int */
1149
1150 static int get_uint8(QEMUFile *f, void *pv, size_t size)
1151 {
1152     uint8_t *v = pv;
1153     qemu_get_8s(f, v);
1154     return 0;
1155 }
1156
1157 static void put_uint8(QEMUFile *f, void *pv, size_t size)
1158 {
1159     uint8_t *v = pv;
1160     qemu_put_8s(f, v);
1161 }
1162
1163 const VMStateInfo vmstate_info_uint8 = {
1164     .name = "uint8",
1165     .get  = get_uint8,
1166     .put  = put_uint8,
1167 };
1168
1169 /* 16 bit unsigned int */
1170
1171 static int get_uint16(QEMUFile *f, void *pv, size_t size)
1172 {
1173     uint16_t *v = pv;
1174     qemu_get_be16s(f, v);
1175     return 0;
1176 }
1177
1178 static void put_uint16(QEMUFile *f, void *pv, size_t size)
1179 {
1180     uint16_t *v = pv;
1181     qemu_put_be16s(f, v);
1182 }
1183
1184 const VMStateInfo vmstate_info_uint16 = {
1185     .name = "uint16",
1186     .get  = get_uint16,
1187     .put  = put_uint16,
1188 };
1189
1190 /* 32 bit unsigned int */
1191
1192 static int get_uint32(QEMUFile *f, void *pv, size_t size)
1193 {
1194     uint32_t *v = pv;
1195     qemu_get_be32s(f, v);
1196     return 0;
1197 }
1198
1199 static void put_uint32(QEMUFile *f, void *pv, size_t size)
1200 {
1201     uint32_t *v = pv;
1202     qemu_put_be32s(f, v);
1203 }
1204
1205 const VMStateInfo vmstate_info_uint32 = {
1206     .name = "uint32",
1207     .get  = get_uint32,
1208     .put  = put_uint32,
1209 };
1210
1211 /* 32 bit uint. See that the received value is the same than the one
1212    in the field */
1213
1214 static int get_uint32_equal(QEMUFile *f, void *pv, size_t size)
1215 {
1216     uint32_t *v = pv;
1217     uint32_t v2;
1218     qemu_get_be32s(f, &v2);
1219
1220     if (*v == v2) {
1221         return 0;
1222     }
1223     return -EINVAL;
1224 }
1225
1226 const VMStateInfo vmstate_info_uint32_equal = {
1227     .name = "uint32 equal",
1228     .get  = get_uint32_equal,
1229     .put  = put_uint32,
1230 };
1231
1232 /* 64 bit unsigned int */
1233
1234 static int get_uint64(QEMUFile *f, void *pv, size_t size)
1235 {
1236     uint64_t *v = pv;
1237     qemu_get_be64s(f, v);
1238     return 0;
1239 }
1240
1241 static void put_uint64(QEMUFile *f, void *pv, size_t size)
1242 {
1243     uint64_t *v = pv;
1244     qemu_put_be64s(f, v);
1245 }
1246
1247 const VMStateInfo vmstate_info_uint64 = {
1248     .name = "uint64",
1249     .get  = get_uint64,
1250     .put  = put_uint64,
1251 };
1252
1253 /* 64 bit unsigned int. See that the received value is the same than the one
1254    in the field */
1255
1256 static int get_uint64_equal(QEMUFile *f, void *pv, size_t size)
1257 {
1258     uint64_t *v = pv;
1259     uint64_t v2;
1260     qemu_get_be64s(f, &v2);
1261
1262     if (*v == v2) {
1263         return 0;
1264     }
1265     return -EINVAL;
1266 }
1267
1268 const VMStateInfo vmstate_info_uint64_equal = {
1269     .name = "int64 equal",
1270     .get  = get_uint64_equal,
1271     .put  = put_uint64,
1272 };
1273
1274 /* 8 bit int. See that the received value is the same than the one
1275    in the field */
1276
1277 static int get_uint8_equal(QEMUFile *f, void *pv, size_t size)
1278 {
1279     uint8_t *v = pv;
1280     uint8_t v2;
1281     qemu_get_8s(f, &v2);
1282
1283     if (*v == v2)
1284         return 0;
1285     return -EINVAL;
1286 }
1287
1288 const VMStateInfo vmstate_info_uint8_equal = {
1289     .name = "uint8 equal",
1290     .get  = get_uint8_equal,
1291     .put  = put_uint8,
1292 };
1293
1294 /* 16 bit unsigned int int. See that the received value is the same than the one
1295    in the field */
1296
1297 static int get_uint16_equal(QEMUFile *f, void *pv, size_t size)
1298 {
1299     uint16_t *v = pv;
1300     uint16_t v2;
1301     qemu_get_be16s(f, &v2);
1302
1303     if (*v == v2)
1304         return 0;
1305     return -EINVAL;
1306 }
1307
1308 const VMStateInfo vmstate_info_uint16_equal = {
1309     .name = "uint16 equal",
1310     .get  = get_uint16_equal,
1311     .put  = put_uint16,
1312 };
1313
1314 /* floating point */
1315
1316 static int get_float64(QEMUFile *f, void *pv, size_t size)
1317 {
1318     float64 *v = pv;
1319
1320     *v = make_float64(qemu_get_be64(f));
1321     return 0;
1322 }
1323
1324 static void put_float64(QEMUFile *f, void *pv, size_t size)
1325 {
1326     uint64_t *v = pv;
1327
1328     qemu_put_be64(f, float64_val(*v));
1329 }
1330
1331 const VMStateInfo vmstate_info_float64 = {
1332     .name = "float64",
1333     .get  = get_float64,
1334     .put  = put_float64,
1335 };
1336
1337 /* timers  */
1338
1339 static int get_timer(QEMUFile *f, void *pv, size_t size)
1340 {
1341     QEMUTimer *v = pv;
1342     timer_get(f, v);
1343     return 0;
1344 }
1345
1346 static void put_timer(QEMUFile *f, void *pv, size_t size)
1347 {
1348     QEMUTimer *v = pv;
1349     timer_put(f, v);
1350 }
1351
1352 const VMStateInfo vmstate_info_timer = {
1353     .name = "timer",
1354     .get  = get_timer,
1355     .put  = put_timer,
1356 };
1357
1358 /* uint8_t buffers */
1359
1360 static int get_buffer(QEMUFile *f, void *pv, size_t size)
1361 {
1362     uint8_t *v = pv;
1363     qemu_get_buffer(f, v, size);
1364     return 0;
1365 }
1366
1367 static void put_buffer(QEMUFile *f, void *pv, size_t size)
1368 {
1369     uint8_t *v = pv;
1370     qemu_put_buffer(f, v, size);
1371 }
1372
1373 const VMStateInfo vmstate_info_buffer = {
1374     .name = "buffer",
1375     .get  = get_buffer,
1376     .put  = put_buffer,
1377 };
1378
1379 /* unused buffers: space that was used for some fields that are
1380    not useful anymore */
1381
1382 static int get_unused_buffer(QEMUFile *f, void *pv, size_t size)
1383 {
1384     uint8_t buf[1024];
1385     int block_len;
1386
1387     while (size > 0) {
1388         block_len = MIN(sizeof(buf), size);
1389         size -= block_len;
1390         qemu_get_buffer(f, buf, block_len);
1391     }
1392    return 0;
1393 }
1394
1395 static void put_unused_buffer(QEMUFile *f, void *pv, size_t size)
1396 {
1397     static const uint8_t buf[1024];
1398     int block_len;
1399
1400     while (size > 0) {
1401         block_len = MIN(sizeof(buf), size);
1402         size -= block_len;
1403         qemu_put_buffer(f, buf, block_len);
1404     }
1405 }
1406
1407 const VMStateInfo vmstate_info_unused_buffer = {
1408     .name = "unused_buffer",
1409     .get  = get_unused_buffer,
1410     .put  = put_unused_buffer,
1411 };
1412
1413 /* bitmaps (as defined by bitmap.h). Note that size here is the size
1414  * of the bitmap in bits. The on-the-wire format of a bitmap is 64
1415  * bit words with the bits in big endian order. The in-memory format
1416  * is an array of 'unsigned long', which may be either 32 or 64 bits.
1417  */
1418 /* This is the number of 64 bit words sent over the wire */
1419 #define BITS_TO_U64S(nr) DIV_ROUND_UP(nr, 64)
1420 static int get_bitmap(QEMUFile *f, void *pv, size_t size)
1421 {
1422     unsigned long *bmp = pv;
1423     int i, idx = 0;
1424     for (i = 0; i < BITS_TO_U64S(size); i++) {
1425         uint64_t w = qemu_get_be64(f);
1426         bmp[idx++] = w;
1427         if (sizeof(unsigned long) == 4 && idx < BITS_TO_LONGS(size)) {
1428             bmp[idx++] = w >> 32;
1429         }
1430     }
1431     return 0;
1432 }
1433
1434 static void put_bitmap(QEMUFile *f, void *pv, size_t size)
1435 {
1436     unsigned long *bmp = pv;
1437     int i, idx = 0;
1438     for (i = 0; i < BITS_TO_U64S(size); i++) {
1439         uint64_t w = bmp[idx++];
1440         if (sizeof(unsigned long) == 4 && idx < BITS_TO_LONGS(size)) {
1441             w |= ((uint64_t)bmp[idx++]) << 32;
1442         }
1443         qemu_put_be64(f, w);
1444     }
1445 }
1446
1447 const VMStateInfo vmstate_info_bitmap = {
1448     .name = "bitmap",
1449     .get = get_bitmap,
1450     .put = put_bitmap,
1451 };
1452
1453 typedef struct CompatEntry {
1454     char idstr[256];
1455     int instance_id;
1456 } CompatEntry;
1457
1458 typedef struct SaveStateEntry {
1459     QTAILQ_ENTRY(SaveStateEntry) entry;
1460     char idstr[256];
1461     int instance_id;
1462     int alias_id;
1463     int version_id;
1464     int section_id;
1465     SaveVMHandlers *ops;
1466     const VMStateDescription *vmsd;
1467     void *opaque;
1468     CompatEntry *compat;
1469     int no_migrate;
1470     int is_ram;
1471 } SaveStateEntry;
1472
1473
1474 static QTAILQ_HEAD(savevm_handlers, SaveStateEntry) savevm_handlers =
1475     QTAILQ_HEAD_INITIALIZER(savevm_handlers);
1476 static int global_section_id;
1477
1478 static int calculate_new_instance_id(const char *idstr)
1479 {
1480     SaveStateEntry *se;
1481     int instance_id = 0;
1482
1483     QTAILQ_FOREACH(se, &savevm_handlers, entry) {
1484         if (strcmp(idstr, se->idstr) == 0
1485             && instance_id <= se->instance_id) {
1486             instance_id = se->instance_id + 1;
1487         }
1488     }
1489     return instance_id;
1490 }
1491
1492 static int calculate_compat_instance_id(const char *idstr)
1493 {
1494     SaveStateEntry *se;
1495     int instance_id = 0;
1496
1497     QTAILQ_FOREACH(se, &savevm_handlers, entry) {
1498         if (!se->compat)
1499             continue;
1500
1501         if (strcmp(idstr, se->compat->idstr) == 0
1502             && instance_id <= se->compat->instance_id) {
1503             instance_id = se->compat->instance_id + 1;
1504         }
1505     }
1506     return instance_id;
1507 }
1508
1509 /* TODO: Individual devices generally have very little idea about the rest
1510    of the system, so instance_id should be removed/replaced.
1511    Meanwhile pass -1 as instance_id if you do not already have a clearly
1512    distinguishing id for all instances of your device class. */
1513 int register_savevm_live(DeviceState *dev,
1514                          const char *idstr,
1515                          int instance_id,
1516                          int version_id,
1517                          SaveVMHandlers *ops,
1518                          void *opaque)
1519 {
1520     SaveStateEntry *se;
1521
1522     se = g_malloc0(sizeof(SaveStateEntry));
1523     se->version_id = version_id;
1524     se->section_id = global_section_id++;
1525     se->ops = ops;
1526     se->opaque = opaque;
1527     se->vmsd = NULL;
1528     se->no_migrate = 0;
1529     /* if this is a live_savem then set is_ram */
1530     if (ops->save_live_setup != NULL) {
1531         se->is_ram = 1;
1532     }
1533
1534     if (dev) {
1535         char *id = qdev_get_dev_path(dev);
1536         if (id) {
1537             pstrcpy(se->idstr, sizeof(se->idstr), id);
1538             pstrcat(se->idstr, sizeof(se->idstr), "/");
1539             g_free(id);
1540
1541             se->compat = g_malloc0(sizeof(CompatEntry));
1542             pstrcpy(se->compat->idstr, sizeof(se->compat->idstr), idstr);
1543             se->compat->instance_id = instance_id == -1 ?
1544                          calculate_compat_instance_id(idstr) : instance_id;
1545             instance_id = -1;
1546         }
1547     }
1548     pstrcat(se->idstr, sizeof(se->idstr), idstr);
1549
1550     if (instance_id == -1) {
1551         se->instance_id = calculate_new_instance_id(se->idstr);
1552     } else {
1553         se->instance_id = instance_id;
1554     }
1555     assert(!se->compat || se->instance_id == 0);
1556     /* add at the end of list */
1557     QTAILQ_INSERT_TAIL(&savevm_handlers, se, entry);
1558     return 0;
1559 }
1560
1561 int register_savevm(DeviceState *dev,
1562                     const char *idstr,
1563                     int instance_id,
1564                     int version_id,
1565                     SaveStateHandler *save_state,
1566                     LoadStateHandler *load_state,
1567                     void *opaque)
1568 {
1569     SaveVMHandlers *ops = g_malloc0(sizeof(SaveVMHandlers));
1570     ops->save_state = save_state;
1571     ops->load_state = load_state;
1572     return register_savevm_live(dev, idstr, instance_id, version_id,
1573                                 ops, opaque);
1574 }
1575
1576 void unregister_savevm(DeviceState *dev, const char *idstr, void *opaque)
1577 {
1578     SaveStateEntry *se, *new_se;
1579     char id[256] = "";
1580
1581     if (dev) {
1582         char *path = qdev_get_dev_path(dev);
1583         if (path) {
1584             pstrcpy(id, sizeof(id), path);
1585             pstrcat(id, sizeof(id), "/");
1586             g_free(path);
1587         }
1588     }
1589     pstrcat(id, sizeof(id), idstr);
1590
1591     QTAILQ_FOREACH_SAFE(se, &savevm_handlers, entry, new_se) {
1592         if (strcmp(se->idstr, id) == 0 && se->opaque == opaque) {
1593             QTAILQ_REMOVE(&savevm_handlers, se, entry);
1594             if (se->compat) {
1595                 g_free(se->compat);
1596             }
1597             g_free(se->ops);
1598             g_free(se);
1599         }
1600     }
1601 }
1602
1603 int vmstate_register_with_alias_id(DeviceState *dev, int instance_id,
1604                                    const VMStateDescription *vmsd,
1605                                    void *opaque, int alias_id,
1606                                    int required_for_version)
1607 {
1608     SaveStateEntry *se;
1609
1610     /* If this triggers, alias support can be dropped for the vmsd. */
1611     assert(alias_id == -1 || required_for_version >= vmsd->minimum_version_id);
1612
1613     se = g_malloc0(sizeof(SaveStateEntry));
1614     se->version_id = vmsd->version_id;
1615     se->section_id = global_section_id++;
1616     se->opaque = opaque;
1617     se->vmsd = vmsd;
1618     se->alias_id = alias_id;
1619     se->no_migrate = vmsd->unmigratable;
1620
1621     if (dev) {
1622         char *id = qdev_get_dev_path(dev);
1623         if (id) {
1624             pstrcpy(se->idstr, sizeof(se->idstr), id);
1625             pstrcat(se->idstr, sizeof(se->idstr), "/");
1626             g_free(id);
1627
1628             se->compat = g_malloc0(sizeof(CompatEntry));
1629             pstrcpy(se->compat->idstr, sizeof(se->compat->idstr), vmsd->name);
1630             se->compat->instance_id = instance_id == -1 ?
1631                          calculate_compat_instance_id(vmsd->name) : instance_id;
1632             instance_id = -1;
1633         }
1634     }
1635     pstrcat(se->idstr, sizeof(se->idstr), vmsd->name);
1636
1637     if (instance_id == -1) {
1638         se->instance_id = calculate_new_instance_id(se->idstr);
1639     } else {
1640         se->instance_id = instance_id;
1641     }
1642     assert(!se->compat || se->instance_id == 0);
1643     /* add at the end of list */
1644     QTAILQ_INSERT_TAIL(&savevm_handlers, se, entry);
1645     return 0;
1646 }
1647
1648 void vmstate_unregister(DeviceState *dev, const VMStateDescription *vmsd,
1649                         void *opaque)
1650 {
1651     SaveStateEntry *se, *new_se;
1652
1653     QTAILQ_FOREACH_SAFE(se, &savevm_handlers, entry, new_se) {
1654         if (se->vmsd == vmsd && se->opaque == opaque) {
1655             QTAILQ_REMOVE(&savevm_handlers, se, entry);
1656             if (se->compat) {
1657                 g_free(se->compat);
1658             }
1659             g_free(se);
1660         }
1661     }
1662 }
1663
1664 static void vmstate_subsection_save(QEMUFile *f, const VMStateDescription *vmsd,
1665                                     void *opaque);
1666 static int vmstate_subsection_load(QEMUFile *f, const VMStateDescription *vmsd,
1667                                    void *opaque);
1668
1669 int vmstate_load_state(QEMUFile *f, const VMStateDescription *vmsd,
1670                        void *opaque, int version_id)
1671 {
1672     VMStateField *field = vmsd->fields;
1673     int ret;
1674
1675     if (version_id > vmsd->version_id) {
1676         return -EINVAL;
1677     }
1678     if (version_id < vmsd->minimum_version_id_old) {
1679         return -EINVAL;
1680     }
1681     if  (version_id < vmsd->minimum_version_id) {
1682         return vmsd->load_state_old(f, opaque, version_id);
1683     }
1684     if (vmsd->pre_load) {
1685         int ret = vmsd->pre_load(opaque);
1686         if (ret)
1687             return ret;
1688     }
1689     while(field->name) {
1690         if ((field->field_exists &&
1691              field->field_exists(opaque, version_id)) ||
1692             (!field->field_exists &&
1693              field->version_id <= version_id)) {
1694             void *base_addr = opaque + field->offset;
1695             int i, n_elems = 1;
1696             int size = field->size;
1697
1698             if (field->flags & VMS_VBUFFER) {
1699                 size = *(int32_t *)(opaque+field->size_offset);
1700                 if (field->flags & VMS_MULTIPLY) {
1701                     size *= field->size;
1702                 }
1703             }
1704             if (field->flags & VMS_ARRAY) {
1705                 n_elems = field->num;
1706             } else if (field->flags & VMS_VARRAY_INT32) {
1707                 n_elems = *(int32_t *)(opaque+field->num_offset);
1708             } else if (field->flags & VMS_VARRAY_UINT32) {
1709                 n_elems = *(uint32_t *)(opaque+field->num_offset);
1710             } else if (field->flags & VMS_VARRAY_UINT16) {
1711                 n_elems = *(uint16_t *)(opaque+field->num_offset);
1712             } else if (field->flags & VMS_VARRAY_UINT8) {
1713                 n_elems = *(uint8_t *)(opaque+field->num_offset);
1714             }
1715             if (field->flags & VMS_POINTER) {
1716                 base_addr = *(void **)base_addr + field->start;
1717             }
1718             for (i = 0; i < n_elems; i++) {
1719                 void *addr = base_addr + size * i;
1720
1721                 if (field->flags & VMS_ARRAY_OF_POINTER) {
1722                     addr = *(void **)addr;
1723                 }
1724                 if (field->flags & VMS_STRUCT) {
1725                     ret = vmstate_load_state(f, field->vmsd, addr, field->vmsd->version_id);
1726                 } else {
1727                     ret = field->info->get(f, addr, size);
1728
1729                 }
1730                 if (ret < 0) {
1731                     return ret;
1732                 }
1733             }
1734         }
1735         field++;
1736     }
1737     ret = vmstate_subsection_load(f, vmsd, opaque);
1738     if (ret != 0) {
1739         return ret;
1740     }
1741     if (vmsd->post_load) {
1742         return vmsd->post_load(opaque, version_id);
1743     }
1744     return 0;
1745 }
1746
1747 void vmstate_save_state(QEMUFile *f, const VMStateDescription *vmsd,
1748                         void *opaque)
1749 {
1750     VMStateField *field = vmsd->fields;
1751
1752     if (vmsd->pre_save) {
1753         vmsd->pre_save(opaque);
1754     }
1755     while(field->name) {
1756         if (!field->field_exists ||
1757             field->field_exists(opaque, vmsd->version_id)) {
1758             void *base_addr = opaque + field->offset;
1759             int i, n_elems = 1;
1760             int size = field->size;
1761
1762             if (field->flags & VMS_VBUFFER) {
1763                 size = *(int32_t *)(opaque+field->size_offset);
1764                 if (field->flags & VMS_MULTIPLY) {
1765                     size *= field->size;
1766                 }
1767             }
1768             if (field->flags & VMS_ARRAY) {
1769                 n_elems = field->num;
1770             } else if (field->flags & VMS_VARRAY_INT32) {
1771                 n_elems = *(int32_t *)(opaque+field->num_offset);
1772             } else if (field->flags & VMS_VARRAY_UINT32) {
1773                 n_elems = *(uint32_t *)(opaque+field->num_offset);
1774             } else if (field->flags & VMS_VARRAY_UINT16) {
1775                 n_elems = *(uint16_t *)(opaque+field->num_offset);
1776             } else if (field->flags & VMS_VARRAY_UINT8) {
1777                 n_elems = *(uint8_t *)(opaque+field->num_offset);
1778             }
1779             if (field->flags & VMS_POINTER) {
1780                 base_addr = *(void **)base_addr + field->start;
1781             }
1782             for (i = 0; i < n_elems; i++) {
1783                 void *addr = base_addr + size * i;
1784
1785                 if (field->flags & VMS_ARRAY_OF_POINTER) {
1786                     addr = *(void **)addr;
1787                 }
1788                 if (field->flags & VMS_STRUCT) {
1789                     vmstate_save_state(f, field->vmsd, addr);
1790                 } else {
1791                     field->info->put(f, addr, size);
1792                 }
1793             }
1794         }
1795         field++;
1796     }
1797     vmstate_subsection_save(f, vmsd, opaque);
1798 }
1799
1800 static int vmstate_load(QEMUFile *f, SaveStateEntry *se, int version_id)
1801 {
1802     if (!se->vmsd) {         /* Old style */
1803         return se->ops->load_state(f, se->opaque, version_id);
1804     }
1805     return vmstate_load_state(f, se->vmsd, se->opaque, version_id);
1806 }
1807
1808 static void vmstate_save(QEMUFile *f, SaveStateEntry *se)
1809 {
1810     if (!se->vmsd) {         /* Old style */
1811         se->ops->save_state(f, se->opaque);
1812         return;
1813     }
1814     vmstate_save_state(f,se->vmsd, se->opaque);
1815 }
1816
1817 #define QEMU_VM_FILE_MAGIC           0x5145564d
1818 #define QEMU_VM_FILE_VERSION_COMPAT  0x00000002
1819 #define QEMU_VM_FILE_VERSION         0x00000003
1820
1821 #define QEMU_VM_EOF                  0x00
1822 #define QEMU_VM_SECTION_START        0x01
1823 #define QEMU_VM_SECTION_PART         0x02
1824 #define QEMU_VM_SECTION_END          0x03
1825 #define QEMU_VM_SECTION_FULL         0x04
1826 #define QEMU_VM_SUBSECTION           0x05
1827
1828 bool qemu_savevm_state_blocked(Error **errp)
1829 {
1830     SaveStateEntry *se;
1831
1832     QTAILQ_FOREACH(se, &savevm_handlers, entry) {
1833         if (se->no_migrate) {
1834             error_set(errp, QERR_MIGRATION_NOT_SUPPORTED, se->idstr);
1835             return true;
1836         }
1837     }
1838     return false;
1839 }
1840
1841 void qemu_savevm_state_begin(QEMUFile *f,
1842                              const MigrationParams *params)
1843 {
1844     SaveStateEntry *se;
1845     int ret;
1846
1847     QTAILQ_FOREACH(se, &savevm_handlers, entry) {
1848         if (!se->ops || !se->ops->set_params) {
1849             continue;
1850         }
1851         se->ops->set_params(params, se->opaque);
1852     }
1853
1854     qemu_put_be32(f, QEMU_VM_FILE_MAGIC);
1855     qemu_put_be32(f, QEMU_VM_FILE_VERSION);
1856
1857     QTAILQ_FOREACH(se, &savevm_handlers, entry) {
1858         int len;
1859
1860         if (!se->ops || !se->ops->save_live_setup) {
1861             continue;
1862         }
1863         if (se->ops && se->ops->is_active) {
1864             if (!se->ops->is_active(se->opaque)) {
1865                 continue;
1866             }
1867         }
1868         /* Section type */
1869         qemu_put_byte(f, QEMU_VM_SECTION_START);
1870         qemu_put_be32(f, se->section_id);
1871
1872         /* ID string */
1873         len = strlen(se->idstr);
1874         qemu_put_byte(f, len);
1875         qemu_put_buffer(f, (uint8_t *)se->idstr, len);
1876
1877         qemu_put_be32(f, se->instance_id);
1878         qemu_put_be32(f, se->version_id);
1879
1880         ret = se->ops->save_live_setup(f, se->opaque);
1881         if (ret < 0) {
1882             qemu_file_set_error(f, ret);
1883             break;
1884         }
1885     }
1886 }
1887
1888 /*
1889  * this function has three return values:
1890  *   negative: there was one error, and we have -errno.
1891  *   0 : We haven't finished, caller have to go again
1892  *   1 : We have finished, we can go to complete phase
1893  */
1894 int qemu_savevm_state_iterate(QEMUFile *f)
1895 {
1896     SaveStateEntry *se;
1897     int ret = 1;
1898
1899     QTAILQ_FOREACH(se, &savevm_handlers, entry) {
1900         if (!se->ops || !se->ops->save_live_iterate) {
1901             continue;
1902         }
1903         if (se->ops && se->ops->is_active) {
1904             if (!se->ops->is_active(se->opaque)) {
1905                 continue;
1906             }
1907         }
1908         if (qemu_file_rate_limit(f)) {
1909             return 0;
1910         }
1911         trace_savevm_section_start();
1912         /* Section type */
1913         qemu_put_byte(f, QEMU_VM_SECTION_PART);
1914         qemu_put_be32(f, se->section_id);
1915
1916         ret = se->ops->save_live_iterate(f, se->opaque);
1917         trace_savevm_section_end(se->section_id);
1918
1919         if (ret < 0) {
1920             qemu_file_set_error(f, ret);
1921         }
1922         if (ret <= 0) {
1923             /* Do not proceed to the next vmstate before this one reported
1924                completion of the current stage. This serializes the migration
1925                and reduces the probability that a faster changing state is
1926                synchronized over and over again. */
1927             break;
1928         }
1929     }
1930     return ret;
1931 }
1932
1933 void qemu_savevm_state_complete(QEMUFile *f)
1934 {
1935     SaveStateEntry *se;
1936     int ret;
1937
1938     cpu_synchronize_all_states();
1939
1940     QTAILQ_FOREACH(se, &savevm_handlers, entry) {
1941         if (!se->ops || !se->ops->save_live_complete) {
1942             continue;
1943         }
1944         if (se->ops && se->ops->is_active) {
1945             if (!se->ops->is_active(se->opaque)) {
1946                 continue;
1947             }
1948         }
1949         trace_savevm_section_start();
1950         /* Section type */
1951         qemu_put_byte(f, QEMU_VM_SECTION_END);
1952         qemu_put_be32(f, se->section_id);
1953
1954         ret = se->ops->save_live_complete(f, se->opaque);
1955         trace_savevm_section_end(se->section_id);
1956         if (ret < 0) {
1957             qemu_file_set_error(f, ret);
1958             return;
1959         }
1960     }
1961
1962     QTAILQ_FOREACH(se, &savevm_handlers, entry) {
1963         int len;
1964
1965         if ((!se->ops || !se->ops->save_state) && !se->vmsd) {
1966             continue;
1967         }
1968         trace_savevm_section_start();
1969         /* Section type */
1970         qemu_put_byte(f, QEMU_VM_SECTION_FULL);
1971         qemu_put_be32(f, se->section_id);
1972
1973         /* ID string */
1974         len = strlen(se->idstr);
1975         qemu_put_byte(f, len);
1976         qemu_put_buffer(f, (uint8_t *)se->idstr, len);
1977
1978         qemu_put_be32(f, se->instance_id);
1979         qemu_put_be32(f, se->version_id);
1980
1981         vmstate_save(f, se);
1982         trace_savevm_section_end(se->section_id);
1983     }
1984
1985     qemu_put_byte(f, QEMU_VM_EOF);
1986     qemu_fflush(f);
1987 }
1988
1989 uint64_t qemu_savevm_state_pending(QEMUFile *f, uint64_t max_size)
1990 {
1991     SaveStateEntry *se;
1992     uint64_t ret = 0;
1993
1994     QTAILQ_FOREACH(se, &savevm_handlers, entry) {
1995         if (!se->ops || !se->ops->save_live_pending) {
1996             continue;
1997         }
1998         if (se->ops && se->ops->is_active) {
1999             if (!se->ops->is_active(se->opaque)) {
2000                 continue;
2001             }
2002         }
2003         ret += se->ops->save_live_pending(f, se->opaque, max_size);
2004     }
2005     return ret;
2006 }
2007
2008 void qemu_savevm_state_cancel(void)
2009 {
2010     SaveStateEntry *se;
2011
2012     QTAILQ_FOREACH(se, &savevm_handlers, entry) {
2013         if (se->ops && se->ops->cancel) {
2014             se->ops->cancel(se->opaque);
2015         }
2016     }
2017 }
2018
2019 static int qemu_savevm_state(QEMUFile *f)
2020 {
2021     int ret;
2022     MigrationParams params = {
2023         .blk = 0,
2024         .shared = 0
2025     };
2026
2027     if (qemu_savevm_state_blocked(NULL)) {
2028         return -EINVAL;
2029     }
2030
2031     qemu_mutex_unlock_iothread();
2032     qemu_savevm_state_begin(f, &params);
2033     qemu_mutex_lock_iothread();
2034
2035     while (qemu_file_get_error(f) == 0) {
2036         if (qemu_savevm_state_iterate(f) > 0) {
2037             break;
2038         }
2039     }
2040
2041     ret = qemu_file_get_error(f);
2042     if (ret == 0) {
2043         qemu_savevm_state_complete(f);
2044         ret = qemu_file_get_error(f);
2045     }
2046     if (ret != 0) {
2047         qemu_savevm_state_cancel();
2048     }
2049     return ret;
2050 }
2051
2052 static int qemu_save_device_state(QEMUFile *f)
2053 {
2054     SaveStateEntry *se;
2055
2056     qemu_put_be32(f, QEMU_VM_FILE_MAGIC);
2057     qemu_put_be32(f, QEMU_VM_FILE_VERSION);
2058
2059     cpu_synchronize_all_states();
2060
2061     QTAILQ_FOREACH(se, &savevm_handlers, entry) {
2062         int len;
2063
2064         if (se->is_ram) {
2065             continue;
2066         }
2067         if ((!se->ops || !se->ops->save_state) && !se->vmsd) {
2068             continue;
2069         }
2070
2071         /* Section type */
2072         qemu_put_byte(f, QEMU_VM_SECTION_FULL);
2073         qemu_put_be32(f, se->section_id);
2074
2075         /* ID string */
2076         len = strlen(se->idstr);
2077         qemu_put_byte(f, len);
2078         qemu_put_buffer(f, (uint8_t *)se->idstr, len);
2079
2080         qemu_put_be32(f, se->instance_id);
2081         qemu_put_be32(f, se->version_id);
2082
2083         vmstate_save(f, se);
2084     }
2085
2086     qemu_put_byte(f, QEMU_VM_EOF);
2087
2088     return qemu_file_get_error(f);
2089 }
2090
2091 static SaveStateEntry *find_se(const char *idstr, int instance_id)
2092 {
2093     SaveStateEntry *se;
2094
2095     QTAILQ_FOREACH(se, &savevm_handlers, entry) {
2096         if (!strcmp(se->idstr, idstr) &&
2097             (instance_id == se->instance_id ||
2098              instance_id == se->alias_id))
2099             return se;
2100         /* Migrating from an older version? */
2101         if (strstr(se->idstr, idstr) && se->compat) {
2102             if (!strcmp(se->compat->idstr, idstr) &&
2103                 (instance_id == se->compat->instance_id ||
2104                  instance_id == se->alias_id))
2105                 return se;
2106         }
2107     }
2108     return NULL;
2109 }
2110
2111 static const VMStateDescription *vmstate_get_subsection(const VMStateSubsection *sub, char *idstr)
2112 {
2113     while(sub && sub->needed) {
2114         if (strcmp(idstr, sub->vmsd->name) == 0) {
2115             return sub->vmsd;
2116         }
2117         sub++;
2118     }
2119     return NULL;
2120 }
2121
2122 static int vmstate_subsection_load(QEMUFile *f, const VMStateDescription *vmsd,
2123                                    void *opaque)
2124 {
2125     while (qemu_peek_byte(f, 0) == QEMU_VM_SUBSECTION) {
2126         char idstr[256];
2127         int ret;
2128         uint8_t version_id, len, size;
2129         const VMStateDescription *sub_vmsd;
2130
2131         len = qemu_peek_byte(f, 1);
2132         if (len < strlen(vmsd->name) + 1) {
2133             /* subsection name has be be "section_name/a" */
2134             return 0;
2135         }
2136         size = qemu_peek_buffer(f, (uint8_t *)idstr, len, 2);
2137         if (size != len) {
2138             return 0;
2139         }
2140         idstr[size] = 0;
2141
2142         if (strncmp(vmsd->name, idstr, strlen(vmsd->name)) != 0) {
2143             /* it don't have a valid subsection name */
2144             return 0;
2145         }
2146         sub_vmsd = vmstate_get_subsection(vmsd->subsections, idstr);
2147         if (sub_vmsd == NULL) {
2148             return -ENOENT;
2149         }
2150         qemu_file_skip(f, 1); /* subsection */
2151         qemu_file_skip(f, 1); /* len */
2152         qemu_file_skip(f, len); /* idstr */
2153         version_id = qemu_get_be32(f);
2154
2155         ret = vmstate_load_state(f, sub_vmsd, opaque, version_id);
2156         if (ret) {
2157             return ret;
2158         }
2159     }
2160     return 0;
2161 }
2162
2163 static void vmstate_subsection_save(QEMUFile *f, const VMStateDescription *vmsd,
2164                                     void *opaque)
2165 {
2166     const VMStateSubsection *sub = vmsd->subsections;
2167
2168     while (sub && sub->needed) {
2169         if (sub->needed(opaque)) {
2170             const VMStateDescription *vmsd = sub->vmsd;
2171             uint8_t len;
2172
2173             qemu_put_byte(f, QEMU_VM_SUBSECTION);
2174             len = strlen(vmsd->name);
2175             qemu_put_byte(f, len);
2176             qemu_put_buffer(f, (uint8_t *)vmsd->name, len);
2177             qemu_put_be32(f, vmsd->version_id);
2178             vmstate_save_state(f, vmsd, opaque);
2179         }
2180         sub++;
2181     }
2182 }
2183
2184 typedef struct LoadStateEntry {
2185     QLIST_ENTRY(LoadStateEntry) entry;
2186     SaveStateEntry *se;
2187     int section_id;
2188     int version_id;
2189 } LoadStateEntry;
2190
2191 int qemu_loadvm_state(QEMUFile *f)
2192 {
2193     QLIST_HEAD(, LoadStateEntry) loadvm_handlers =
2194         QLIST_HEAD_INITIALIZER(loadvm_handlers);
2195     LoadStateEntry *le, *new_le;
2196     uint8_t section_type;
2197     unsigned int v;
2198     int ret;
2199
2200     if (qemu_savevm_state_blocked(NULL)) {
2201         return -EINVAL;
2202     }
2203
2204     v = qemu_get_be32(f);
2205     if (v != QEMU_VM_FILE_MAGIC)
2206         return -EINVAL;
2207
2208     v = qemu_get_be32(f);
2209     if (v == QEMU_VM_FILE_VERSION_COMPAT) {
2210         fprintf(stderr, "SaveVM v2 format is obsolete and don't work anymore\n");
2211         return -ENOTSUP;
2212     }
2213     if (v != QEMU_VM_FILE_VERSION)
2214         return -ENOTSUP;
2215
2216     while ((section_type = qemu_get_byte(f)) != QEMU_VM_EOF) {
2217         uint32_t instance_id, version_id, section_id;
2218         SaveStateEntry *se;
2219         char idstr[257];
2220         int len;
2221
2222         switch (section_type) {
2223         case QEMU_VM_SECTION_START:
2224         case QEMU_VM_SECTION_FULL:
2225             /* Read section start */
2226             section_id = qemu_get_be32(f);
2227             len = qemu_get_byte(f);
2228             qemu_get_buffer(f, (uint8_t *)idstr, len);
2229             idstr[len] = 0;
2230             instance_id = qemu_get_be32(f);
2231             version_id = qemu_get_be32(f);
2232
2233             /* Find savevm section */
2234             se = find_se(idstr, instance_id);
2235             if (se == NULL) {
2236                 fprintf(stderr, "Unknown savevm section or instance '%s' %d\n", idstr, instance_id);
2237                 ret = -EINVAL;
2238                 goto out;
2239             }
2240
2241             /* Validate version */
2242             if (version_id > se->version_id) {
2243                 fprintf(stderr, "savevm: unsupported version %d for '%s' v%d\n",
2244                         version_id, idstr, se->version_id);
2245                 ret = -EINVAL;
2246                 goto out;
2247             }
2248
2249             /* Add entry */
2250             le = g_malloc0(sizeof(*le));
2251
2252             le->se = se;
2253             le->section_id = section_id;
2254             le->version_id = version_id;
2255             QLIST_INSERT_HEAD(&loadvm_handlers, le, entry);
2256
2257             ret = vmstate_load(f, le->se, le->version_id);
2258             if (ret < 0) {
2259                 fprintf(stderr, "qemu: warning: error while loading state for instance 0x%x of device '%s'\n",
2260                         instance_id, idstr);
2261                 goto out;
2262             }
2263             break;
2264         case QEMU_VM_SECTION_PART:
2265         case QEMU_VM_SECTION_END:
2266             section_id = qemu_get_be32(f);
2267
2268             QLIST_FOREACH(le, &loadvm_handlers, entry) {
2269                 if (le->section_id == section_id) {
2270                     break;
2271                 }
2272             }
2273             if (le == NULL) {
2274                 fprintf(stderr, "Unknown savevm section %d\n", section_id);
2275                 ret = -EINVAL;
2276                 goto out;
2277             }
2278
2279             ret = vmstate_load(f, le->se, le->version_id);
2280             if (ret < 0) {
2281                 fprintf(stderr, "qemu: warning: error while loading state section id %d\n",
2282                         section_id);
2283                 goto out;
2284             }
2285             break;
2286         default:
2287             fprintf(stderr, "Unknown savevm section type %d\n", section_type);
2288             ret = -EINVAL;
2289             goto out;
2290         }
2291     }
2292
2293     cpu_synchronize_all_post_init();
2294
2295     ret = 0;
2296
2297 out:
2298     QLIST_FOREACH_SAFE(le, &loadvm_handlers, entry, new_le) {
2299         QLIST_REMOVE(le, entry);
2300         g_free(le);
2301     }
2302
2303     if (ret == 0) {
2304         ret = qemu_file_get_error(f);
2305     }
2306
2307     return ret;
2308 }
2309
2310 static BlockDriverState *find_vmstate_bs(void)
2311 {
2312     BlockDriverState *bs = NULL;
2313     while ((bs = bdrv_next(bs))) {
2314         if (bdrv_can_snapshot(bs)) {
2315             return bs;
2316         }
2317     }
2318     return NULL;
2319 }
2320
2321 /*
2322  * Deletes snapshots of a given name in all opened images.
2323  */
2324 static int del_existing_snapshots(Monitor *mon, const char *name)
2325 {
2326     BlockDriverState *bs;
2327     QEMUSnapshotInfo sn1, *snapshot = &sn1;
2328     Error *err = NULL;
2329
2330     bs = NULL;
2331     while ((bs = bdrv_next(bs))) {
2332         if (bdrv_can_snapshot(bs) &&
2333             bdrv_snapshot_find(bs, snapshot, name) >= 0)
2334         {
2335             bdrv_snapshot_delete_by_id_or_name(bs, name, &err);
2336             if (error_is_set(&err)) {
2337                 monitor_printf(mon,
2338                                "Error while deleting snapshot on device '%s':"
2339                                " %s\n",
2340                                bdrv_get_device_name(bs),
2341                                error_get_pretty(err));
2342                 error_free(err);
2343                 return -1;
2344             }
2345         }
2346     }
2347
2348     return 0;
2349 }
2350
2351 void do_savevm(Monitor *mon, const QDict *qdict)
2352 {
2353     BlockDriverState *bs, *bs1;
2354     QEMUSnapshotInfo sn1, *sn = &sn1, old_sn1, *old_sn = &old_sn1;
2355     int ret;
2356     QEMUFile *f;
2357     int saved_vm_running;
2358     uint64_t vm_state_size;
2359     qemu_timeval tv;
2360     struct tm tm;
2361     const char *name = qdict_get_try_str(qdict, "name");
2362
2363     /* Verify if there is a device that doesn't support snapshots and is writable */
2364     bs = NULL;
2365     while ((bs = bdrv_next(bs))) {
2366
2367         if (!bdrv_is_inserted(bs) || bdrv_is_read_only(bs)) {
2368             continue;
2369         }
2370
2371         if (!bdrv_can_snapshot(bs)) {
2372             monitor_printf(mon, "Device '%s' is writable but does not support snapshots.\n",
2373                                bdrv_get_device_name(bs));
2374             return;
2375         }
2376     }
2377
2378     bs = find_vmstate_bs();
2379     if (!bs) {
2380         monitor_printf(mon, "No block device can accept snapshots\n");
2381         return;
2382     }
2383
2384     saved_vm_running = runstate_is_running();
2385     vm_stop(RUN_STATE_SAVE_VM);
2386
2387     memset(sn, 0, sizeof(*sn));
2388
2389     /* fill auxiliary fields */
2390     qemu_gettimeofday(&tv);
2391     sn->date_sec = tv.tv_sec;
2392     sn->date_nsec = tv.tv_usec * 1000;
2393     sn->vm_clock_nsec = qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL);
2394
2395     if (name) {
2396         ret = bdrv_snapshot_find(bs, old_sn, name);
2397         if (ret >= 0) {
2398             pstrcpy(sn->name, sizeof(sn->name), old_sn->name);
2399             pstrcpy(sn->id_str, sizeof(sn->id_str), old_sn->id_str);
2400         } else {
2401             pstrcpy(sn->name, sizeof(sn->name), name);
2402         }
2403     } else {
2404         /* cast below needed for OpenBSD where tv_sec is still 'long' */
2405         localtime_r((const time_t *)&tv.tv_sec, &tm);
2406         strftime(sn->name, sizeof(sn->name), "vm-%Y%m%d%H%M%S", &tm);
2407     }
2408
2409     /* Delete old snapshots of the same name */
2410     if (name && del_existing_snapshots(mon, name) < 0) {
2411         goto the_end;
2412     }
2413
2414     /* save the VM state */
2415     f = qemu_fopen_bdrv(bs, 1);
2416     if (!f) {
2417         monitor_printf(mon, "Could not open VM state file\n");
2418         goto the_end;
2419     }
2420     ret = qemu_savevm_state(f);
2421     vm_state_size = qemu_ftell(f);
2422     qemu_fclose(f);
2423     if (ret < 0) {
2424         monitor_printf(mon, "Error %d while writing VM\n", ret);
2425         goto the_end;
2426     }
2427
2428     /* create the snapshots */
2429
2430     bs1 = NULL;
2431     while ((bs1 = bdrv_next(bs1))) {
2432         if (bdrv_can_snapshot(bs1)) {
2433             /* Write VM state size only to the image that contains the state */
2434             sn->vm_state_size = (bs == bs1 ? vm_state_size : 0);
2435             ret = bdrv_snapshot_create(bs1, sn);
2436             if (ret < 0) {
2437                 monitor_printf(mon, "Error while creating snapshot on '%s'\n",
2438                                bdrv_get_device_name(bs1));
2439             }
2440         }
2441     }
2442
2443  the_end:
2444     if (saved_vm_running)
2445         vm_start();
2446 }
2447
2448 void qmp_xen_save_devices_state(const char *filename, Error **errp)
2449 {
2450     QEMUFile *f;
2451     int saved_vm_running;
2452     int ret;
2453
2454     saved_vm_running = runstate_is_running();
2455     vm_stop(RUN_STATE_SAVE_VM);
2456
2457     f = qemu_fopen(filename, "wb");
2458     if (!f) {
2459         error_setg_file_open(errp, errno, filename);
2460         goto the_end;
2461     }
2462     ret = qemu_save_device_state(f);
2463     qemu_fclose(f);
2464     if (ret < 0) {
2465         error_set(errp, QERR_IO_ERROR);
2466     }
2467
2468  the_end:
2469     if (saved_vm_running)
2470         vm_start();
2471 }
2472
2473 int load_vmstate(const char *name)
2474 {
2475     BlockDriverState *bs, *bs_vm_state;
2476     QEMUSnapshotInfo sn;
2477     QEMUFile *f;
2478     int ret;
2479
2480     bs_vm_state = find_vmstate_bs();
2481     if (!bs_vm_state) {
2482         error_report("No block device supports snapshots");
2483         return -ENOTSUP;
2484     }
2485
2486     /* Don't even try to load empty VM states */
2487     ret = bdrv_snapshot_find(bs_vm_state, &sn, name);
2488     if (ret < 0) {
2489         return ret;
2490     } else if (sn.vm_state_size == 0) {
2491         error_report("This is a disk-only snapshot. Revert to it offline "
2492             "using qemu-img.");
2493         return -EINVAL;
2494     }
2495
2496     /* Verify if there is any device that doesn't support snapshots and is
2497     writable and check if the requested snapshot is available too. */
2498     bs = NULL;
2499     while ((bs = bdrv_next(bs))) {
2500
2501         if (!bdrv_is_inserted(bs) || bdrv_is_read_only(bs)) {
2502             continue;
2503         }
2504
2505         if (!bdrv_can_snapshot(bs)) {
2506             error_report("Device '%s' is writable but does not support snapshots.",
2507                                bdrv_get_device_name(bs));
2508             return -ENOTSUP;
2509         }
2510
2511         ret = bdrv_snapshot_find(bs, &sn, name);
2512         if (ret < 0) {
2513             error_report("Device '%s' does not have the requested snapshot '%s'",
2514                            bdrv_get_device_name(bs), name);
2515             return ret;
2516         }
2517     }
2518
2519     /* Flush all IO requests so they don't interfere with the new state.  */
2520     bdrv_drain_all();
2521
2522     bs = NULL;
2523     while ((bs = bdrv_next(bs))) {
2524         if (bdrv_can_snapshot(bs)) {
2525             ret = bdrv_snapshot_goto(bs, name);
2526             if (ret < 0) {
2527                 error_report("Error %d while activating snapshot '%s' on '%s'",
2528                              ret, name, bdrv_get_device_name(bs));
2529                 return ret;
2530             }
2531         }
2532     }
2533
2534     /* restore the VM state */
2535     f = qemu_fopen_bdrv(bs_vm_state, 0);
2536     if (!f) {
2537         error_report("Could not open VM state file");
2538         return -EINVAL;
2539     }
2540
2541     qemu_system_reset(VMRESET_SILENT);
2542     ret = qemu_loadvm_state(f);
2543
2544     qemu_fclose(f);
2545     if (ret < 0) {
2546         error_report("Error %d while loading VM state", ret);
2547         return ret;
2548     }
2549
2550     return 0;
2551 }
2552
2553 void do_delvm(Monitor *mon, const QDict *qdict)
2554 {
2555     BlockDriverState *bs, *bs1;
2556     Error *err = NULL;
2557     const char *name = qdict_get_str(qdict, "name");
2558
2559     bs = find_vmstate_bs();
2560     if (!bs) {
2561         monitor_printf(mon, "No block device supports snapshots\n");
2562         return;
2563     }
2564
2565     bs1 = NULL;
2566     while ((bs1 = bdrv_next(bs1))) {
2567         if (bdrv_can_snapshot(bs1)) {
2568             bdrv_snapshot_delete_by_id_or_name(bs, name, &err);
2569             if (error_is_set(&err)) {
2570                 monitor_printf(mon,
2571                                "Error while deleting snapshot on device '%s':"
2572                                " %s\n",
2573                                bdrv_get_device_name(bs),
2574                                error_get_pretty(err));
2575                 error_free(err);
2576             }
2577         }
2578     }
2579 }
2580
2581 void do_info_snapshots(Monitor *mon, const QDict *qdict)
2582 {
2583     BlockDriverState *bs, *bs1;
2584     QEMUSnapshotInfo *sn_tab, *sn, s, *sn_info = &s;
2585     int nb_sns, i, ret, available;
2586     int total;
2587     int *available_snapshots;
2588
2589     bs = find_vmstate_bs();
2590     if (!bs) {
2591         monitor_printf(mon, "No available block device supports snapshots\n");
2592         return;
2593     }
2594
2595     nb_sns = bdrv_snapshot_list(bs, &sn_tab);
2596     if (nb_sns < 0) {
2597         monitor_printf(mon, "bdrv_snapshot_list: error %d\n", nb_sns);
2598         return;
2599     }
2600
2601     if (nb_sns == 0) {
2602         monitor_printf(mon, "There is no snapshot available.\n");
2603         return;
2604     }
2605
2606     available_snapshots = g_malloc0(sizeof(int) * nb_sns);
2607     total = 0;
2608     for (i = 0; i < nb_sns; i++) {
2609         sn = &sn_tab[i];
2610         available = 1;
2611         bs1 = NULL;
2612
2613         while ((bs1 = bdrv_next(bs1))) {
2614             if (bdrv_can_snapshot(bs1) && bs1 != bs) {
2615                 ret = bdrv_snapshot_find(bs1, sn_info, sn->id_str);
2616                 if (ret < 0) {
2617                     available = 0;
2618                     break;
2619                 }
2620             }
2621         }
2622
2623         if (available) {
2624             available_snapshots[total] = i;
2625             total++;
2626         }
2627     }
2628
2629     if (total > 0) {
2630         bdrv_snapshot_dump((fprintf_function)monitor_printf, mon, NULL);
2631         monitor_printf(mon, "\n");
2632         for (i = 0; i < total; i++) {
2633             sn = &sn_tab[available_snapshots[i]];
2634             bdrv_snapshot_dump((fprintf_function)monitor_printf, mon, sn);
2635             monitor_printf(mon, "\n");
2636         }
2637     } else {
2638         monitor_printf(mon, "There is no suitable snapshot available\n");
2639     }
2640
2641     g_free(sn_tab);
2642     g_free(available_snapshots);
2643
2644 }
2645
2646 void vmstate_register_ram(MemoryRegion *mr, DeviceState *dev)
2647 {
2648     qemu_ram_set_idstr(memory_region_get_ram_addr(mr) & TARGET_PAGE_MASK,
2649                        memory_region_name(mr), dev);
2650 }
2651
2652 void vmstate_unregister_ram(MemoryRegion *mr, DeviceState *dev)
2653 {
2654     /* Nothing do to while the implementation is in RAMBlock */
2655 }
2656
2657 void vmstate_register_ram_global(MemoryRegion *mr)
2658 {
2659     vmstate_register_ram(mr, NULL);
2660 }