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