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