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