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