savevm.c

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