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 static 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 static 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 int 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             return ret;
1624         }
1625     }
1626     ret = qemu_file_get_error(f);
1627     return ret;
1628 }
1629
1630 /*
1631  * this function has three return values:
1632  *   negative: there was one error, and we have -errno.
1633  *   0 : We haven't finished, caller have to go again
1634  *   1 : We have finished, we can go to complete phase
1635  */
1636 int qemu_savevm_state_iterate(QEMUFile *f)
1637 {
1638     SaveStateEntry *se;
1639     int ret = 1;
1640
1641     QTAILQ_FOREACH(se, &savevm_handlers, entry) {
1642         if (!se->ops || !se->ops->save_live_iterate) {
1643             continue;
1644         }
1645         if (se->ops && se->ops->is_active) {
1646             if (!se->ops->is_active(se->opaque)) {
1647                 continue;
1648             }
1649         }
1650         if (qemu_file_rate_limit(f)) {
1651             return 0;
1652         }
1653         trace_savevm_section_start();
1654         /* Section type */
1655         qemu_put_byte(f, QEMU_VM_SECTION_PART);
1656         qemu_put_be32(f, se->section_id);
1657
1658         ret = se->ops->save_live_iterate(f, se->opaque);
1659         trace_savevm_section_end(se->section_id);
1660
1661         if (ret <= 0) {
1662             /* Do not proceed to the next vmstate before this one reported
1663                completion of the current stage. This serializes the migration
1664                and reduces the probability that a faster changing state is
1665                synchronized over and over again. */
1666             break;
1667         }
1668     }
1669     if (ret != 0) {
1670         return ret;
1671     }
1672     ret = qemu_file_get_error(f);
1673     return ret;
1674 }
1675
1676 int qemu_savevm_state_complete(QEMUFile *f)
1677 {
1678     SaveStateEntry *se;
1679     int ret;
1680
1681     cpu_synchronize_all_states();
1682
1683     QTAILQ_FOREACH(se, &savevm_handlers, entry) {
1684         if (!se->ops || !se->ops->save_live_complete) {
1685             continue;
1686         }
1687         if (se->ops && se->ops->is_active) {
1688             if (!se->ops->is_active(se->opaque)) {
1689                 continue;
1690             }
1691         }
1692         trace_savevm_section_start();
1693         /* Section type */
1694         qemu_put_byte(f, QEMU_VM_SECTION_END);
1695         qemu_put_be32(f, se->section_id);
1696
1697         ret = se->ops->save_live_complete(f, se->opaque);
1698         trace_savevm_section_end(se->section_id);
1699         if (ret < 0) {
1700             return ret;
1701         }
1702     }
1703
1704     QTAILQ_FOREACH(se, &savevm_handlers, entry) {
1705         int len;
1706
1707         if ((!se->ops || !se->ops->save_state) && !se->vmsd) {
1708             continue;
1709         }
1710         trace_savevm_section_start();
1711         /* Section type */
1712         qemu_put_byte(f, QEMU_VM_SECTION_FULL);
1713         qemu_put_be32(f, se->section_id);
1714
1715         /* ID string */
1716         len = strlen(se->idstr);
1717         qemu_put_byte(f, len);
1718         qemu_put_buffer(f, (uint8_t *)se->idstr, len);
1719
1720         qemu_put_be32(f, se->instance_id);
1721         qemu_put_be32(f, se->version_id);
1722
1723         vmstate_save(f, se);
1724         trace_savevm_section_end(se->section_id);
1725     }
1726
1727     qemu_put_byte(f, QEMU_VM_EOF);
1728
1729     return qemu_file_get_error(f);
1730 }
1731
1732 uint64_t qemu_savevm_state_pending(QEMUFile *f, uint64_t max_size)
1733 {
1734     SaveStateEntry *se;
1735     uint64_t ret = 0;
1736
1737     QTAILQ_FOREACH(se, &savevm_handlers, entry) {
1738         if (!se->ops || !se->ops->save_live_pending) {
1739             continue;
1740         }
1741         if (se->ops && se->ops->is_active) {
1742             if (!se->ops->is_active(se->opaque)) {
1743                 continue;
1744             }
1745         }
1746         ret += se->ops->save_live_pending(f, se->opaque, max_size);
1747     }
1748     return ret;
1749 }
1750
1751 void qemu_savevm_state_cancel(void)
1752 {
1753     SaveStateEntry *se;
1754
1755     QTAILQ_FOREACH(se, &savevm_handlers, entry) {
1756         if (se->ops && se->ops->cancel) {
1757             se->ops->cancel(se->opaque);
1758         }
1759     }
1760 }
1761
1762 static int qemu_savevm_state(QEMUFile *f)
1763 {
1764     int ret;
1765     MigrationParams params = {
1766         .blk = 0,
1767         .shared = 0
1768     };
1769
1770     if (qemu_savevm_state_blocked(NULL)) {
1771         return -EINVAL;
1772     }
1773
1774     ret = qemu_savevm_state_begin(f, &params);
1775     if (ret < 0)
1776         goto out;
1777
1778     do {
1779         ret = qemu_savevm_state_iterate(f);
1780         if (ret < 0)
1781             goto out;
1782     } while (ret == 0);
1783
1784     ret = qemu_savevm_state_complete(f);
1785
1786 out:
1787     if (ret == 0) {
1788         ret = qemu_file_get_error(f);
1789     }
1790     if (ret != 0) {
1791         qemu_savevm_state_cancel();
1792     }
1793
1794     return ret;
1795 }
1796
1797 static int qemu_save_device_state(QEMUFile *f)
1798 {
1799     SaveStateEntry *se;
1800
1801     qemu_put_be32(f, QEMU_VM_FILE_MAGIC);
1802     qemu_put_be32(f, QEMU_VM_FILE_VERSION);
1803
1804     cpu_synchronize_all_states();
1805
1806     QTAILQ_FOREACH(se, &savevm_handlers, entry) {
1807         int len;
1808
1809         if (se->is_ram) {
1810             continue;
1811         }
1812         if ((!se->ops || !se->ops->save_state) && !se->vmsd) {
1813             continue;
1814         }
1815
1816         /* Section type */
1817         qemu_put_byte(f, QEMU_VM_SECTION_FULL);
1818         qemu_put_be32(f, se->section_id);
1819
1820         /* ID string */
1821         len = strlen(se->idstr);
1822         qemu_put_byte(f, len);
1823         qemu_put_buffer(f, (uint8_t *)se->idstr, len);
1824
1825         qemu_put_be32(f, se->instance_id);
1826         qemu_put_be32(f, se->version_id);
1827
1828         vmstate_save(f, se);
1829     }
1830
1831     qemu_put_byte(f, QEMU_VM_EOF);
1832
1833     return qemu_file_get_error(f);
1834 }
1835
1836 static SaveStateEntry *find_se(const char *idstr, int instance_id)
1837 {
1838     SaveStateEntry *se;
1839
1840     QTAILQ_FOREACH(se, &savevm_handlers, entry) {
1841         if (!strcmp(se->idstr, idstr) &&
1842             (instance_id == se->instance_id ||
1843              instance_id == se->alias_id))
1844             return se;
1845         /* Migrating from an older version? */
1846         if (strstr(se->idstr, idstr) && se->compat) {
1847             if (!strcmp(se->compat->idstr, idstr) &&
1848                 (instance_id == se->compat->instance_id ||
1849                  instance_id == se->alias_id))
1850                 return se;
1851         }
1852     }
1853     return NULL;
1854 }
1855
1856 static const VMStateDescription *vmstate_get_subsection(const VMStateSubsection *sub, char *idstr)
1857 {
1858     while(sub && sub->needed) {
1859         if (strcmp(idstr, sub->vmsd->name) == 0) {
1860             return sub->vmsd;
1861         }
1862         sub++;
1863     }
1864     return NULL;
1865 }
1866
1867 static int vmstate_subsection_load(QEMUFile *f, const VMStateDescription *vmsd,
1868                                    void *opaque)
1869 {
1870     while (qemu_peek_byte(f, 0) == QEMU_VM_SUBSECTION) {
1871         char idstr[256];
1872         int ret;
1873         uint8_t version_id, len, size;
1874         const VMStateDescription *sub_vmsd;
1875
1876         len = qemu_peek_byte(f, 1);
1877         if (len < strlen(vmsd->name) + 1) {
1878             /* subsection name has be be "section_name/a" */
1879             return 0;
1880         }
1881         size = qemu_peek_buffer(f, (uint8_t *)idstr, len, 2);
1882         if (size != len) {
1883             return 0;
1884         }
1885         idstr[size] = 0;
1886
1887         if (strncmp(vmsd->name, idstr, strlen(vmsd->name)) != 0) {
1888             /* it don't have a valid subsection name */
1889             return 0;
1890         }
1891         sub_vmsd = vmstate_get_subsection(vmsd->subsections, idstr);
1892         if (sub_vmsd == NULL) {
1893             return -ENOENT;
1894         }
1895         qemu_file_skip(f, 1); /* subsection */
1896         qemu_file_skip(f, 1); /* len */
1897         qemu_file_skip(f, len); /* idstr */
1898         version_id = qemu_get_be32(f);
1899
1900         ret = vmstate_load_state(f, sub_vmsd, opaque, version_id);
1901         if (ret) {
1902             return ret;
1903         }
1904     }
1905     return 0;
1906 }
1907
1908 static void vmstate_subsection_save(QEMUFile *f, const VMStateDescription *vmsd,
1909                                     void *opaque)
1910 {
1911     const VMStateSubsection *sub = vmsd->subsections;
1912
1913     while (sub && sub->needed) {
1914         if (sub->needed(opaque)) {
1915             const VMStateDescription *vmsd = sub->vmsd;
1916             uint8_t len;
1917
1918             qemu_put_byte(f, QEMU_VM_SUBSECTION);
1919             len = strlen(vmsd->name);
1920             qemu_put_byte(f, len);
1921             qemu_put_buffer(f, (uint8_t *)vmsd->name, len);
1922             qemu_put_be32(f, vmsd->version_id);
1923             vmstate_save_state(f, vmsd, opaque);
1924         }
1925         sub++;
1926     }
1927 }
1928
1929 typedef struct LoadStateEntry {
1930     QLIST_ENTRY(LoadStateEntry) entry;
1931     SaveStateEntry *se;
1932     int section_id;
1933     int version_id;
1934 } LoadStateEntry;
1935
1936 int qemu_loadvm_state(QEMUFile *f)
1937 {
1938     QLIST_HEAD(, LoadStateEntry) loadvm_handlers =
1939         QLIST_HEAD_INITIALIZER(loadvm_handlers);
1940     LoadStateEntry *le, *new_le;
1941     uint8_t section_type;
1942     unsigned int v;
1943     int ret;
1944
1945     if (qemu_savevm_state_blocked(NULL)) {
1946         return -EINVAL;
1947     }
1948
1949     v = qemu_get_be32(f);
1950     if (v != QEMU_VM_FILE_MAGIC)
1951         return -EINVAL;
1952
1953     v = qemu_get_be32(f);
1954     if (v == QEMU_VM_FILE_VERSION_COMPAT) {
1955         fprintf(stderr, "SaveVM v2 format is obsolete and don't work anymore\n");
1956         return -ENOTSUP;
1957     }
1958     if (v != QEMU_VM_FILE_VERSION)
1959         return -ENOTSUP;
1960
1961     while ((section_type = qemu_get_byte(f)) != QEMU_VM_EOF) {
1962         uint32_t instance_id, version_id, section_id;
1963         SaveStateEntry *se;
1964         char idstr[257];
1965         int len;
1966
1967         switch (section_type) {
1968         case QEMU_VM_SECTION_START:
1969         case QEMU_VM_SECTION_FULL:
1970             /* Read section start */
1971             section_id = qemu_get_be32(f);
1972             len = qemu_get_byte(f);
1973             qemu_get_buffer(f, (uint8_t *)idstr, len);
1974             idstr[len] = 0;
1975             instance_id = qemu_get_be32(f);
1976             version_id = qemu_get_be32(f);
1977
1978             /* Find savevm section */
1979             se = find_se(idstr, instance_id);
1980             if (se == NULL) {
1981                 fprintf(stderr, "Unknown savevm section or instance '%s' %d\n", idstr, instance_id);
1982                 ret = -EINVAL;
1983                 goto out;
1984             }
1985
1986             /* Validate version */
1987             if (version_id > se->version_id) {
1988                 fprintf(stderr, "savevm: unsupported version %d for '%s' v%d\n",
1989                         version_id, idstr, se->version_id);
1990                 ret = -EINVAL;
1991                 goto out;
1992             }
1993
1994             /* Add entry */
1995             le = g_malloc0(sizeof(*le));
1996
1997             le->se = se;
1998             le->section_id = section_id;
1999             le->version_id = version_id;
2000             QLIST_INSERT_HEAD(&loadvm_handlers, le, entry);
2001
2002             ret = vmstate_load(f, le->se, le->version_id);
2003             if (ret < 0) {
2004                 fprintf(stderr, "qemu: warning: error while loading state for instance 0x%x of device '%s'\n",
2005                         instance_id, idstr);
2006                 goto out;
2007             }
2008             break;
2009         case QEMU_VM_SECTION_PART:
2010         case QEMU_VM_SECTION_END:
2011             section_id = qemu_get_be32(f);
2012
2013             QLIST_FOREACH(le, &loadvm_handlers, entry) {
2014                 if (le->section_id == section_id) {
2015                     break;
2016                 }
2017             }
2018             if (le == NULL) {
2019                 fprintf(stderr, "Unknown savevm section %d\n", section_id);
2020                 ret = -EINVAL;
2021                 goto out;
2022             }
2023
2024             ret = vmstate_load(f, le->se, le->version_id);
2025             if (ret < 0) {
2026                 fprintf(stderr, "qemu: warning: error while loading state section id %d\n",
2027                         section_id);
2028                 goto out;
2029             }
2030             break;
2031         default:
2032             fprintf(stderr, "Unknown savevm section type %d\n", section_type);
2033             ret = -EINVAL;
2034             goto out;
2035         }
2036     }
2037
2038     cpu_synchronize_all_post_init();
2039
2040     ret = 0;
2041
2042 out:
2043     QLIST_FOREACH_SAFE(le, &loadvm_handlers, entry, new_le) {
2044         QLIST_REMOVE(le, entry);
2045         g_free(le);
2046     }
2047
2048     if (ret == 0) {
2049         ret = qemu_file_get_error(f);
2050     }
2051
2052     return ret;
2053 }
2054
2055 static int bdrv_snapshot_find(BlockDriverState *bs, QEMUSnapshotInfo *sn_info,
2056                               const char *name)
2057 {
2058     QEMUSnapshotInfo *sn_tab, *sn;
2059     int nb_sns, i, ret;
2060
2061     ret = -ENOENT;
2062     nb_sns = bdrv_snapshot_list(bs, &sn_tab);
2063     if (nb_sns < 0)
2064         return ret;
2065     for(i = 0; i < nb_sns; i++) {
2066         sn = &sn_tab[i];
2067         if (!strcmp(sn->id_str, name) || !strcmp(sn->name, name)) {
2068             *sn_info = *sn;
2069             ret = 0;
2070             break;
2071         }
2072     }
2073     g_free(sn_tab);
2074     return ret;
2075 }
2076
2077 /*
2078  * Deletes snapshots of a given name in all opened images.
2079  */
2080 static int del_existing_snapshots(Monitor *mon, const char *name)
2081 {
2082     BlockDriverState *bs;
2083     QEMUSnapshotInfo sn1, *snapshot = &sn1;
2084     int ret;
2085
2086     bs = NULL;
2087     while ((bs = bdrv_next(bs))) {
2088         if (bdrv_can_snapshot(bs) &&
2089             bdrv_snapshot_find(bs, snapshot, name) >= 0)
2090         {
2091             ret = bdrv_snapshot_delete(bs, name);
2092             if (ret < 0) {
2093                 monitor_printf(mon,
2094                                "Error while deleting snapshot on '%s'\n",
2095                                bdrv_get_device_name(bs));
2096                 return -1;
2097             }
2098         }
2099     }
2100
2101     return 0;
2102 }
2103
2104 void do_savevm(Monitor *mon, const QDict *qdict)
2105 {
2106     BlockDriverState *bs, *bs1;
2107     QEMUSnapshotInfo sn1, *sn = &sn1, old_sn1, *old_sn = &old_sn1;
2108     int ret;
2109     QEMUFile *f;
2110     int saved_vm_running;
2111     uint64_t vm_state_size;
2112     qemu_timeval tv;
2113     struct tm tm;
2114     const char *name = qdict_get_try_str(qdict, "name");
2115
2116     /* Verify if there is a device that doesn't support snapshots and is writable */
2117     bs = NULL;
2118     while ((bs = bdrv_next(bs))) {
2119
2120         if (!bdrv_is_inserted(bs) || bdrv_is_read_only(bs)) {
2121             continue;
2122         }
2123
2124         if (!bdrv_can_snapshot(bs)) {
2125             monitor_printf(mon, "Device '%s' is writable but does not support snapshots.\n",
2126                                bdrv_get_device_name(bs));
2127             return;
2128         }
2129     }
2130
2131     bs = bdrv_snapshots();
2132     if (!bs) {
2133         monitor_printf(mon, "No block device can accept snapshots\n");
2134         return;
2135     }
2136
2137     saved_vm_running = runstate_is_running();
2138     vm_stop(RUN_STATE_SAVE_VM);
2139
2140     memset(sn, 0, sizeof(*sn));
2141
2142     /* fill auxiliary fields */
2143     qemu_gettimeofday(&tv);
2144     sn->date_sec = tv.tv_sec;
2145     sn->date_nsec = tv.tv_usec * 1000;
2146     sn->vm_clock_nsec = qemu_get_clock_ns(vm_clock);
2147
2148     if (name) {
2149         ret = bdrv_snapshot_find(bs, old_sn, name);
2150         if (ret >= 0) {
2151             pstrcpy(sn->name, sizeof(sn->name), old_sn->name);
2152             pstrcpy(sn->id_str, sizeof(sn->id_str), old_sn->id_str);
2153         } else {
2154             pstrcpy(sn->name, sizeof(sn->name), name);
2155         }
2156     } else {
2157         /* cast below needed for OpenBSD where tv_sec is still 'long' */
2158         localtime_r((const time_t *)&tv.tv_sec, &tm);
2159         strftime(sn->name, sizeof(sn->name), "vm-%Y%m%d%H%M%S", &tm);
2160     }
2161
2162     /* Delete old snapshots of the same name */
2163     if (name && del_existing_snapshots(mon, name) < 0) {
2164         goto the_end;
2165     }
2166
2167     /* save the VM state */
2168     f = qemu_fopen_bdrv(bs, 1);
2169     if (!f) {
2170         monitor_printf(mon, "Could not open VM state file\n");
2171         goto the_end;
2172     }
2173     ret = qemu_savevm_state(f);
2174     vm_state_size = qemu_ftell(f);
2175     qemu_fclose(f);
2176     if (ret < 0) {
2177         monitor_printf(mon, "Error %d while writing VM\n", ret);
2178         goto the_end;
2179     }
2180
2181     /* create the snapshots */
2182
2183     bs1 = NULL;
2184     while ((bs1 = bdrv_next(bs1))) {
2185         if (bdrv_can_snapshot(bs1)) {
2186             /* Write VM state size only to the image that contains the state */
2187             sn->vm_state_size = (bs == bs1 ? vm_state_size : 0);
2188             ret = bdrv_snapshot_create(bs1, sn);
2189             if (ret < 0) {
2190                 monitor_printf(mon, "Error while creating snapshot on '%s'\n",
2191                                bdrv_get_device_name(bs1));
2192             }
2193         }
2194     }
2195
2196  the_end:
2197     if (saved_vm_running)
2198         vm_start();
2199 }
2200
2201 void qmp_xen_save_devices_state(const char *filename, Error **errp)
2202 {
2203     QEMUFile *f;
2204     int saved_vm_running;
2205     int ret;
2206
2207     saved_vm_running = runstate_is_running();
2208     vm_stop(RUN_STATE_SAVE_VM);
2209
2210     f = qemu_fopen(filename, "wb");
2211     if (!f) {
2212         error_set(errp, QERR_OPEN_FILE_FAILED, filename);
2213         goto the_end;
2214     }
2215     ret = qemu_save_device_state(f);
2216     qemu_fclose(f);
2217     if (ret < 0) {
2218         error_set(errp, QERR_IO_ERROR);
2219     }
2220
2221  the_end:
2222     if (saved_vm_running)
2223         vm_start();
2224 }
2225
2226 int load_vmstate(const char *name)
2227 {
2228     BlockDriverState *bs, *bs_vm_state;
2229     QEMUSnapshotInfo sn;
2230     QEMUFile *f;
2231     int ret;
2232
2233     bs_vm_state = bdrv_snapshots();
2234     if (!bs_vm_state) {
2235         error_report("No block device supports snapshots");
2236         return -ENOTSUP;
2237     }
2238
2239     /* Don't even try to load empty VM states */
2240     ret = bdrv_snapshot_find(bs_vm_state, &sn, name);
2241     if (ret < 0) {
2242         return ret;
2243     } else if (sn.vm_state_size == 0) {
2244         error_report("This is a disk-only snapshot. Revert to it offline "
2245             "using qemu-img.");
2246         return -EINVAL;
2247     }
2248
2249     /* Verify if there is any device that doesn't support snapshots and is
2250     writable and check if the requested snapshot is available too. */
2251     bs = NULL;
2252     while ((bs = bdrv_next(bs))) {
2253
2254         if (!bdrv_is_inserted(bs) || bdrv_is_read_only(bs)) {
2255             continue;
2256         }
2257
2258         if (!bdrv_can_snapshot(bs)) {
2259             error_report("Device '%s' is writable but does not support snapshots.",
2260                                bdrv_get_device_name(bs));
2261             return -ENOTSUP;
2262         }
2263
2264         ret = bdrv_snapshot_find(bs, &sn, name);
2265         if (ret < 0) {
2266             error_report("Device '%s' does not have the requested snapshot '%s'",
2267                            bdrv_get_device_name(bs), name);
2268             return ret;
2269         }
2270     }
2271
2272     /* Flush all IO requests so they don't interfere with the new state.  */
2273     bdrv_drain_all();
2274
2275     bs = NULL;
2276     while ((bs = bdrv_next(bs))) {
2277         if (bdrv_can_snapshot(bs)) {
2278             ret = bdrv_snapshot_goto(bs, name);
2279             if (ret < 0) {
2280                 error_report("Error %d while activating snapshot '%s' on '%s'",
2281                              ret, name, bdrv_get_device_name(bs));
2282                 return ret;
2283             }
2284         }
2285     }
2286
2287     /* restore the VM state */
2288     f = qemu_fopen_bdrv(bs_vm_state, 0);
2289     if (!f) {
2290         error_report("Could not open VM state file");
2291         return -EINVAL;
2292     }
2293
2294     qemu_system_reset(VMRESET_SILENT);
2295     ret = qemu_loadvm_state(f);
2296
2297     qemu_fclose(f);
2298     if (ret < 0) {
2299         error_report("Error %d while loading VM state", ret);
2300         return ret;
2301     }
2302
2303     return 0;
2304 }
2305
2306 void do_delvm(Monitor *mon, const QDict *qdict)
2307 {
2308     BlockDriverState *bs, *bs1;
2309     int ret;
2310     const char *name = qdict_get_str(qdict, "name");
2311
2312     bs = bdrv_snapshots();
2313     if (!bs) {
2314         monitor_printf(mon, "No block device supports snapshots\n");
2315         return;
2316     }
2317
2318     bs1 = NULL;
2319     while ((bs1 = bdrv_next(bs1))) {
2320         if (bdrv_can_snapshot(bs1)) {
2321             ret = bdrv_snapshot_delete(bs1, name);
2322             if (ret < 0) {
2323                 if (ret == -ENOTSUP)
2324                     monitor_printf(mon,
2325                                    "Snapshots not supported on device '%s'\n",
2326                                    bdrv_get_device_name(bs1));
2327                 else
2328                     monitor_printf(mon, "Error %d while deleting snapshot on "
2329                                    "'%s'\n", ret, bdrv_get_device_name(bs1));
2330             }
2331         }
2332     }
2333 }
2334
2335 void do_info_snapshots(Monitor *mon, const QDict *qdict)
2336 {
2337     BlockDriverState *bs, *bs1;
2338     QEMUSnapshotInfo *sn_tab, *sn, s, *sn_info = &s;
2339     int nb_sns, i, ret, available;
2340     int total;
2341     int *available_snapshots;
2342     char buf[256];
2343
2344     bs = bdrv_snapshots();
2345     if (!bs) {
2346         monitor_printf(mon, "No available block device supports snapshots\n");
2347         return;
2348     }
2349
2350     nb_sns = bdrv_snapshot_list(bs, &sn_tab);
2351     if (nb_sns < 0) {
2352         monitor_printf(mon, "bdrv_snapshot_list: error %d\n", nb_sns);
2353         return;
2354     }
2355
2356     if (nb_sns == 0) {
2357         monitor_printf(mon, "There is no snapshot available.\n");
2358         return;
2359     }
2360
2361     available_snapshots = g_malloc0(sizeof(int) * nb_sns);
2362     total = 0;
2363     for (i = 0; i < nb_sns; i++) {
2364         sn = &sn_tab[i];
2365         available = 1;
2366         bs1 = NULL;
2367
2368         while ((bs1 = bdrv_next(bs1))) {
2369             if (bdrv_can_snapshot(bs1) && bs1 != bs) {
2370                 ret = bdrv_snapshot_find(bs1, sn_info, sn->id_str);
2371                 if (ret < 0) {
2372                     available = 0;
2373                     break;
2374                 }
2375             }
2376         }
2377
2378         if (available) {
2379             available_snapshots[total] = i;
2380             total++;
2381         }
2382     }
2383
2384     if (total > 0) {
2385         monitor_printf(mon, "%s\n", bdrv_snapshot_dump(buf, sizeof(buf), NULL));
2386         for (i = 0; i < total; i++) {
2387             sn = &sn_tab[available_snapshots[i]];
2388             monitor_printf(mon, "%s\n", bdrv_snapshot_dump(buf, sizeof(buf), sn));
2389         }
2390     } else {
2391         monitor_printf(mon, "There is no suitable snapshot available\n");
2392     }
2393
2394     g_free(sn_tab);
2395     g_free(available_snapshots);
2396
2397 }
2398
2399 void vmstate_register_ram(MemoryRegion *mr, DeviceState *dev)
2400 {
2401     qemu_ram_set_idstr(memory_region_get_ram_addr(mr) & TARGET_PAGE_MASK,
2402                        memory_region_name(mr), dev);
2403 }
2404
2405 void vmstate_unregister_ram(MemoryRegion *mr, DeviceState *dev)
2406 {
2407     /* Nothing do to while the implementation is in RAMBlock */
2408 }
2409
2410 void vmstate_register_ram_global(MemoryRegion *mr)
2411 {
2412     vmstate_register_ram(mr, NULL);
2413 }