gwj / at91sam9263 · Commits

Commit a672b4693a07c0cde34d947ae5032606ce089fd1

Authored by aliguori
1 parent 559b90fb

Split savevm code into savevm.c 

This is pure code motion.  The savevm code is all common code so we can build
it once and share the object with all executables.

Signed-off-by: Anthony Liguori <aliguori@us.ibm.com>



git-svn-id: svn://svn.savannah.nongnu.org/qemu/trunk@5700 c046a42c-6fe2-441c-8c8c-71466251a162
Inline Side-by-side
Showing 3 changed files with 1246 additions and 1157 deletions
Makefile
  View file @a672b46
... ... @@ -79,7 +79,7 @@ OBJS+=usb-serial.o usb-net.o
79 79 OBJS+=sd.o ssi-sd.o
80 80 OBJS+=bt.o bt-host.o bt-vhci.o bt-l2cap.o bt-sdp.o bt-hci.o bt-hid.o usb-bt.o
81 81 OBJS+=buffered_file.o migration.o migration-tcp.o net.o qemu-sockets.o
82   -OBJS+=qemu-char.o aio.o net-checksum.o
  82 +OBJS+=qemu-char.o aio.o net-checksum.o savevm.o
83 83  
84 84 ifdef CONFIG_BRLAPI
85 85 OBJS+= baum.o
... ...
savevm.c 0 → 100644
  View file @a672b46
  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 "qemu-common.h"
  25 +#include "hw/hw.h"
  26 +#include "net.h"
  27 +#include "console.h"
  28 +#include "sysemu.h"
  29 +#include "qemu-timer.h"
  30 +#include "qemu-char.h"
  31 +#include "block.h"
  32 +#include "audio/audio.h"
  33 +#include "migration.h"
  34 +#include "qemu_socket.h"
  35 +
  36 +#include <unistd.h>
  37 +#include <fcntl.h>
  38 +#include <signal.h>
  39 +#include <time.h>
  40 +#include <errno.h>
  41 +#include <sys/time.h>
  42 +#include <zlib.h>
  43 +
  44 +#ifndef _WIN32
  45 +#include <sys/times.h>
  46 +#include <sys/wait.h>
  47 +#include <termios.h>
  48 +#include <sys/mman.h>
  49 +#include <sys/ioctl.h>
  50 +#include <sys/resource.h>
  51 +#include <sys/socket.h>
  52 +#include <netinet/in.h>
  53 +#include <net/if.h>
  54 +#if defined(__NetBSD__)
  55 +#include <net/if_tap.h>
  56 +#endif
  57 +#ifdef __linux__
  58 +#include <linux/if_tun.h>
  59 +#endif
  60 +#include <arpa/inet.h>
  61 +#include <dirent.h>
  62 +#include <netdb.h>
  63 +#include <sys/select.h>
  64 +#ifdef _BSD
  65 +#include <sys/stat.h>
  66 +#ifdef __FreeBSD__
  67 +#include <libutil.h>
  68 +#else
  69 +#include <util.h>
  70 +#endif
  71 +#elif defined (__GLIBC__) && defined (__FreeBSD_kernel__)
  72 +#include <freebsd/stdlib.h>
  73 +#else
  74 +#ifdef __linux__
  75 +#include <pty.h>
  76 +#include <malloc.h>
  77 +#include <linux/rtc.h>
  78 +#endif
  79 +#endif
  80 +#endif
  81 +
  82 +#ifdef _WIN32
  83 +#include <malloc.h>
  84 +#include <sys/timeb.h>
  85 +#include <mmsystem.h>
  86 +#define getopt_long_only getopt_long
  87 +#define memalign(align, size) malloc(size)
  88 +#endif
  89 +
  90 +/* point to the block driver where the snapshots are managed */
  91 +static BlockDriverState *bs_snapshots;
  92 +
  93 +#define SELF_ANNOUNCE_ROUNDS 5
  94 +#define ETH_P_EXPERIMENTAL 0x01F1 /* just a number */
  95 +//#define ETH_P_EXPERIMENTAL 0x0012 /* make it the size of the packet */
  96 +#define EXPERIMENTAL_MAGIC 0xf1f23f4f
  97 +
  98 +static int announce_self_create(uint8_t *buf,
  99 + uint8_t *mac_addr)
  100 +{
  101 + uint32_t magic = EXPERIMENTAL_MAGIC;
  102 + uint16_t proto = htons(ETH_P_EXPERIMENTAL);
  103 +
  104 + /* FIXME: should we send a different packet (arp/rarp/ping)? */
  105 +
  106 + memset(buf, 0xff, 6); /* h_dst */
  107 + memcpy(buf + 6, mac_addr, 6); /* h_src */
  108 + memcpy(buf + 12, &proto, 2); /* h_proto */
  109 + memcpy(buf + 14, &magic, 4); /* magic */
  110 +
  111 + return 18; /* len */
  112 +}
  113 +
  114 +void qemu_announce_self(void)
  115 +{
  116 + int i, j, len;
  117 + VLANState *vlan;
  118 + VLANClientState *vc;
  119 + uint8_t buf[256];
  120 +
  121 + for (i = 0; i < nb_nics; i++) {
  122 + len = announce_self_create(buf, nd_table[i].macaddr);
  123 + vlan = nd_table[i].vlan;
  124 + for(vc = vlan->first_client; vc != NULL; vc = vc->next) {
  125 + for (j=0; j < SELF_ANNOUNCE_ROUNDS; j++)
  126 + vc->fd_read(vc->opaque, buf, len);
  127 + }
  128 + }
  129 +}
  130 +
  131 +/***********************************************************/
  132 +/* savevm/loadvm support */
  133 +
  134 +#define IO_BUF_SIZE 32768
  135 +
  136 +struct QEMUFile {
  137 + QEMUFilePutBufferFunc *put_buffer;
  138 + QEMUFileGetBufferFunc *get_buffer;
  139 + QEMUFileCloseFunc *close;
  140 + QEMUFileRateLimit *rate_limit;
  141 + void *opaque;
  142 + int is_write;
  143 +
  144 + int64_t buf_offset; /* start of buffer when writing, end of buffer
  145 + when reading */
  146 + int buf_index;
  147 + int buf_size; /* 0 when writing */
  148 + uint8_t buf[IO_BUF_SIZE];
  149 +
  150 + int has_error;
  151 +};
  152 +
  153 +typedef struct QEMUFilePopen
  154 +{
  155 + FILE *popen_file;
  156 + QEMUFile *file;
  157 +} QEMUFilePopen;
  158 +
  159 +typedef struct QEMUFileSocket
  160 +{
  161 + int fd;
  162 + QEMUFile *file;
  163 +} QEMUFileSocket;
  164 +
  165 +static int socket_get_buffer(void *opaque, uint8_t *buf, int64_t pos, int size)
  166 +{
  167 + QEMUFileSocket *s = opaque;
  168 + ssize_t len;
  169 +
  170 + do {
  171 + len = recv(s->fd, buf, size, 0);
  172 + } while (len == -1 && socket_error() == EINTR);
  173 +
  174 + if (len == -1)
  175 + len = -socket_error();
  176 +
  177 + return len;
  178 +}
  179 +
  180 +static int socket_close(void *opaque)
  181 +{
  182 + QEMUFileSocket *s = opaque;
  183 + qemu_free(s);
  184 + return 0;
  185 +}
  186 +
  187 +static int popen_put_buffer(void *opaque, const uint8_t *buf, int64_t pos, int size)
  188 +{
  189 + QEMUFilePopen *s = opaque;
  190 + return fwrite(buf, 1, size, s->popen_file);
  191 +}
  192 +
  193 +static int popen_get_buffer(void *opaque, uint8_t *buf, int64_t pos, int size)
  194 +{
  195 + QEMUFilePopen *s = opaque;
  196 + return fread(buf, 1, size, s->popen_file);
  197 +}
  198 +
  199 +static int popen_close(void *opaque)
  200 +{
  201 + QEMUFilePopen *s = opaque;
  202 + pclose(s->popen_file);
  203 + qemu_free(s);
  204 + return 0;
  205 +}
  206 +
  207 +QEMUFile *qemu_popen(FILE *popen_file, const char *mode)
  208 +{
  209 + QEMUFilePopen *s;
  210 +
  211 + if (popen_file == NULL || mode == NULL || (mode[0] != 'r' && mode[0] != 'w') || mode[1] != 0) {
  212 + fprintf(stderr, "qemu_popen: Argument validity check failed\n");
  213 + return NULL;
  214 + }
  215 +
  216 + s = qemu_mallocz(sizeof(QEMUFilePopen));
  217 + if (!s) {
  218 + fprintf(stderr, "qemu_popen: malloc failed\n");
  219 + return NULL;
  220 + }
  221 +
  222 + s->popen_file = popen_file;
  223 +
  224 + if(mode[0] == 'r') {
  225 + s->file = qemu_fopen_ops(s, NULL, popen_get_buffer, popen_close, NULL);
  226 + } else {
  227 + s->file = qemu_fopen_ops(s, popen_put_buffer, NULL, popen_close, NULL);
  228 + }
  229 + fprintf(stderr, "qemu_popen: returning result of qemu_fopen_ops\n");
  230 + return s->file;
  231 +}
  232 +
  233 +QEMUFile *qemu_popen_cmd(const char *command, const char *mode)
  234 +{
  235 + FILE *popen_file;
  236 +
  237 + popen_file = popen(command, mode);
  238 + if(popen_file == NULL) {
  239 + return NULL;
  240 + }
  241 +
  242 + return qemu_popen(popen_file, mode);
  243 +}
  244 +
  245 +QEMUFile *qemu_fopen_socket(int fd)
  246 +{
  247 + QEMUFileSocket *s = qemu_mallocz(sizeof(QEMUFileSocket));
  248 +
  249 + if (s == NULL)
  250 + return NULL;
  251 +
  252 + s->fd = fd;
  253 + s->file = qemu_fopen_ops(s, NULL, socket_get_buffer, socket_close, NULL);
  254 + return s->file;
  255 +}
  256 +
  257 +typedef struct QEMUFileStdio
  258 +{
  259 + FILE *outfile;
  260 +} QEMUFileStdio;
  261 +
  262 +static int file_put_buffer(void *opaque, const uint8_t *buf,
  263 + int64_t pos, int size)
  264 +{
  265 + QEMUFileStdio *s = opaque;
  266 + fseek(s->outfile, pos, SEEK_SET);
  267 + fwrite(buf, 1, size, s->outfile);
  268 + return size;
  269 +}
  270 +
  271 +static int file_get_buffer(void *opaque, uint8_t *buf, int64_t pos, int size)
  272 +{
  273 + QEMUFileStdio *s = opaque;
  274 + fseek(s->outfile, pos, SEEK_SET);
  275 + return fread(buf, 1, size, s->outfile);
  276 +}
  277 +
  278 +static int file_close(void *opaque)
  279 +{
  280 + QEMUFileStdio *s = opaque;
  281 + fclose(s->outfile);
  282 + qemu_free(s);
  283 + return 0;
  284 +}
  285 +
  286 +QEMUFile *qemu_fopen(const char *filename, const char *mode)
  287 +{
  288 + QEMUFileStdio *s;
  289 +
  290 + s = qemu_mallocz(sizeof(QEMUFileStdio));
  291 + if (!s)
  292 + return NULL;
  293 +
  294 + s->outfile = fopen(filename, mode);
  295 + if (!s->outfile)
  296 + goto fail;
  297 +
  298 + if (!strcmp(mode, "wb"))
  299 + return qemu_fopen_ops(s, file_put_buffer, NULL, file_close, NULL);
  300 + else if (!strcmp(mode, "rb"))
  301 + return qemu_fopen_ops(s, NULL, file_get_buffer, file_close, NULL);
  302 +
  303 +fail:
  304 + if (s->outfile)
  305 + fclose(s->outfile);
  306 + qemu_free(s);
  307 + return NULL;
  308 +}
  309 +
  310 +typedef struct QEMUFileBdrv
  311 +{
  312 + BlockDriverState *bs;
  313 + int64_t base_offset;
  314 +} QEMUFileBdrv;
  315 +
  316 +static int bdrv_put_buffer(void *opaque, const uint8_t *buf,
  317 + int64_t pos, int size)
  318 +{
  319 + QEMUFileBdrv *s = opaque;
  320 + bdrv_pwrite(s->bs, s->base_offset + pos, buf, size);
  321 + return size;
  322 +}
  323 +
  324 +static int bdrv_get_buffer(void *opaque, uint8_t *buf, int64_t pos, int size)
  325 +{
  326 + QEMUFileBdrv *s = opaque;
  327 + return bdrv_pread(s->bs, s->base_offset + pos, buf, size);
  328 +}
  329 +
  330 +static int bdrv_fclose(void *opaque)
  331 +{
  332 + QEMUFileBdrv *s = opaque;
  333 + qemu_free(s);
  334 + return 0;
  335 +}
  336 +
  337 +static QEMUFile *qemu_fopen_bdrv(BlockDriverState *bs, int64_t offset, int is_writable)
  338 +{
  339 + QEMUFileBdrv *s;
  340 +
  341 + s = qemu_mallocz(sizeof(QEMUFileBdrv));
  342 + if (!s)
  343 + return NULL;
  344 +
  345 + s->bs = bs;
  346 + s->base_offset = offset;
  347 +
  348 + if (is_writable)
  349 + return qemu_fopen_ops(s, bdrv_put_buffer, NULL, bdrv_fclose, NULL);
  350 +
  351 + return qemu_fopen_ops(s, NULL, bdrv_get_buffer, bdrv_fclose, NULL);
  352 +}
  353 +
  354 +QEMUFile *qemu_fopen_ops(void *opaque, QEMUFilePutBufferFunc *put_buffer,
  355 + QEMUFileGetBufferFunc *get_buffer,
  356 + QEMUFileCloseFunc *close,
  357 + QEMUFileRateLimit *rate_limit)
  358 +{
  359 + QEMUFile *f;
  360 +
  361 + f = qemu_mallocz(sizeof(QEMUFile));
  362 + if (!f)
  363 + return NULL;
  364 +
  365 + f->opaque = opaque;
  366 + f->put_buffer = put_buffer;
  367 + f->get_buffer = get_buffer;
  368 + f->close = close;
  369 + f->rate_limit = rate_limit;
  370 + f->is_write = 0;
  371 +
  372 + return f;
  373 +}
  374 +
  375 +int qemu_file_has_error(QEMUFile *f)
  376 +{
  377 + return f->has_error;
  378 +}
  379 +
  380 +void qemu_fflush(QEMUFile *f)
  381 +{
  382 + if (!f->put_buffer)
  383 + return;
  384 +
  385 + if (f->is_write && f->buf_index > 0) {
  386 + int len;
  387 +
  388 + len = f->put_buffer(f->opaque, f->buf, f->buf_offset, f->buf_index);
  389 + if (len > 0)
  390 + f->buf_offset += f->buf_index;
  391 + else
  392 + f->has_error = 1;
  393 + f->buf_index = 0;
  394 + }
  395 +}
  396 +
  397 +static void qemu_fill_buffer(QEMUFile *f)
  398 +{
  399 + int len;
  400 +
  401 + if (!f->get_buffer)
  402 + return;
  403 +
  404 + if (f->is_write)
  405 + abort();
  406 +
  407 + len = f->get_buffer(f->opaque, f->buf, f->buf_offset, IO_BUF_SIZE);
  408 + if (len > 0) {
  409 + f->buf_index = 0;
  410 + f->buf_size = len;
  411 + f->buf_offset += len;
  412 + } else if (len != -EAGAIN)
  413 + f->has_error = 1;
  414 +}
  415 +
  416 +int qemu_fclose(QEMUFile *f)
  417 +{
  418 + int ret = 0;
  419 + qemu_fflush(f);
  420 + if (f->close)
  421 + ret = f->close(f->opaque);
  422 + qemu_free(f);
  423 + return ret;
  424 +}
  425 +
  426 +void qemu_file_put_notify(QEMUFile *f)
  427 +{
  428 + f->put_buffer(f->opaque, NULL, 0, 0);
  429 +}
  430 +
  431 +void qemu_put_buffer(QEMUFile *f, const uint8_t *buf, int size)
  432 +{
  433 + int l;
  434 +
  435 + if (!f->has_error && f->is_write == 0 && f->buf_index > 0) {
  436 + fprintf(stderr,
  437 + "Attempted to write to buffer while read buffer is not empty\n");
  438 + abort();
  439 + }
  440 +
  441 + while (!f->has_error && size > 0) {
  442 + l = IO_BUF_SIZE - f->buf_index;
  443 + if (l > size)
  444 + l = size;
  445 + memcpy(f->buf + f->buf_index, buf, l);
  446 + f->is_write = 1;
  447 + f->buf_index += l;
  448 + buf += l;
  449 + size -= l;
  450 + if (f->buf_index >= IO_BUF_SIZE)
  451 + qemu_fflush(f);
  452 + }
  453 +}
  454 +
  455 +void qemu_put_byte(QEMUFile *f, int v)
  456 +{
  457 + if (!f->has_error && f->is_write == 0 && f->buf_index > 0) {
  458 + fprintf(stderr,
  459 + "Attempted to write to buffer while read buffer is not empty\n");
  460 + abort();
  461 + }
  462 +
  463 + f->buf[f->buf_index++] = v;
  464 + f->is_write = 1;
  465 + if (f->buf_index >= IO_BUF_SIZE)
  466 + qemu_fflush(f);
  467 +}
  468 +
  469 +int qemu_get_buffer(QEMUFile *f, uint8_t *buf, int size1)
  470 +{
  471 + int size, l;
  472 +
  473 + if (f->is_write)
  474 + abort();
  475 +
  476 + size = size1;
  477 + while (size > 0) {
  478 + l = f->buf_size - f->buf_index;
  479 + if (l == 0) {
  480 + qemu_fill_buffer(f);
  481 + l = f->buf_size - f->buf_index;
  482 + if (l == 0)
  483 + break;
  484 + }
  485 + if (l > size)
  486 + l = size;
  487 + memcpy(buf, f->buf + f->buf_index, l);
  488 + f->buf_index += l;
  489 + buf += l;
  490 + size -= l;
  491 + }
  492 + return size1 - size;
  493 +}
  494 +
  495 +int qemu_get_byte(QEMUFile *f)
  496 +{
  497 + if (f->is_write)
  498 + abort();
  499 +
  500 + if (f->buf_index >= f->buf_size) {
  501 + qemu_fill_buffer(f);
  502 + if (f->buf_index >= f->buf_size)
  503 + return 0;
  504 + }
  505 + return f->buf[f->buf_index++];
  506 +}
  507 +
  508 +int64_t qemu_ftell(QEMUFile *f)
  509 +{
  510 + return f->buf_offset - f->buf_size + f->buf_index;
  511 +}
  512 +
  513 +int64_t qemu_fseek(QEMUFile *f, int64_t pos, int whence)
  514 +{
  515 + if (whence == SEEK_SET) {
  516 + /* nothing to do */
  517 + } else if (whence == SEEK_CUR) {
  518 + pos += qemu_ftell(f);
  519 + } else {
  520 + /* SEEK_END not supported */
  521 + return -1;
  522 + }
  523 + if (f->put_buffer) {
  524 + qemu_fflush(f);
  525 + f->buf_offset = pos;
  526 + } else {
  527 + f->buf_offset = pos;
  528 + f->buf_index = 0;
  529 + f->buf_size = 0;
  530 + }
  531 + return pos;
  532 +}
  533 +
  534 +int qemu_file_rate_limit(QEMUFile *f)
  535 +{
  536 + if (f->rate_limit)
  537 + return f->rate_limit(f->opaque);
  538 +
  539 + return 0;
  540 +}
  541 +
  542 +void qemu_put_be16(QEMUFile *f, unsigned int v)
  543 +{
  544 + qemu_put_byte(f, v >> 8);
  545 + qemu_put_byte(f, v);
  546 +}
  547 +
  548 +void qemu_put_be32(QEMUFile *f, unsigned int v)
  549 +{
  550 + qemu_put_byte(f, v >> 24);
  551 + qemu_put_byte(f, v >> 16);
  552 + qemu_put_byte(f, v >> 8);
  553 + qemu_put_byte(f, v);
  554 +}
  555 +
  556 +void qemu_put_be64(QEMUFile *f, uint64_t v)
  557 +{
  558 + qemu_put_be32(f, v >> 32);
  559 + qemu_put_be32(f, v);
  560 +}
  561 +
  562 +unsigned int qemu_get_be16(QEMUFile *f)
  563 +{
  564 + unsigned int v;
  565 + v = qemu_get_byte(f) << 8;
  566 + v |= qemu_get_byte(f);
  567 + return v;
  568 +}
  569 +
  570 +unsigned int qemu_get_be32(QEMUFile *f)
  571 +{
  572 + unsigned int v;
  573 + v = qemu_get_byte(f) << 24;
  574 + v |= qemu_get_byte(f) << 16;
  575 + v |= qemu_get_byte(f) << 8;
  576 + v |= qemu_get_byte(f);
  577 + return v;
  578 +}
  579 +
  580 +uint64_t qemu_get_be64(QEMUFile *f)
  581 +{
  582 + uint64_t v;
  583 + v = (uint64_t)qemu_get_be32(f) << 32;
  584 + v |= qemu_get_be32(f);
  585 + return v;
  586 +}
  587 +
  588 +typedef struct SaveStateEntry {
  589 + char idstr[256];
  590 + int instance_id;
  591 + int version_id;
  592 + int section_id;
  593 + SaveLiveStateHandler *save_live_state;
  594 + SaveStateHandler *save_state;
  595 + LoadStateHandler *load_state;
  596 + void *opaque;
  597 + struct SaveStateEntry *next;
  598 +} SaveStateEntry;
  599 +
  600 +static SaveStateEntry *first_se;
  601 +
  602 +/* TODO: Individual devices generally have very little idea about the rest
  603 + of the system, so instance_id should be removed/replaced.
  604 + Meanwhile pass -1 as instance_id if you do not already have a clearly
  605 + distinguishing id for all instances of your device class. */
  606 +int register_savevm_live(const char *idstr,
  607 + int instance_id,
  608 + int version_id,
  609 + SaveLiveStateHandler *save_live_state,
  610 + SaveStateHandler *save_state,
  611 + LoadStateHandler *load_state,
  612 + void *opaque)
  613 +{
  614 + SaveStateEntry *se, **pse;
  615 + static int global_section_id;
  616 +
  617 + se = qemu_malloc(sizeof(SaveStateEntry));
  618 + if (!se)
  619 + return -1;
  620 + pstrcpy(se->idstr, sizeof(se->idstr), idstr);
  621 + se->instance_id = (instance_id == -1) ? 0 : instance_id;
  622 + se->version_id = version_id;
  623 + se->section_id = global_section_id++;
  624 + se->save_live_state = save_live_state;
  625 + se->save_state = save_state;
  626 + se->load_state = load_state;
  627 + se->opaque = opaque;
  628 + se->next = NULL;
  629 +
  630 + /* add at the end of list */
  631 + pse = &first_se;
  632 + while (*pse != NULL) {
  633 + if (instance_id == -1
  634 + && strcmp(se->idstr, (*pse)->idstr) == 0
  635 + && se->instance_id <= (*pse)->instance_id)
  636 + se->instance_id = (*pse)->instance_id + 1;
  637 + pse = &(*pse)->next;
  638 + }
  639 + *pse = se;
  640 + return 0;
  641 +}
  642 +
  643 +int register_savevm(const char *idstr,
  644 + int instance_id,
  645 + int version_id,
  646 + SaveStateHandler *save_state,
  647 + LoadStateHandler *load_state,
  648 + void *opaque)
  649 +{
  650 + return register_savevm_live(idstr, instance_id, version_id,
  651 + NULL, save_state, load_state, opaque);
  652 +}
  653 +
  654 +#define QEMU_VM_FILE_MAGIC 0x5145564d
  655 +#define QEMU_VM_FILE_VERSION_COMPAT 0x00000002
  656 +#define QEMU_VM_FILE_VERSION 0x00000003
  657 +
  658 +#define QEMU_VM_EOF 0x00
  659 +#define QEMU_VM_SECTION_START 0x01
  660 +#define QEMU_VM_SECTION_PART 0x02
  661 +#define QEMU_VM_SECTION_END 0x03
  662 +#define QEMU_VM_SECTION_FULL 0x04
  663 +
  664 +int qemu_savevm_state_begin(QEMUFile *f)
  665 +{
  666 + SaveStateEntry *se;
  667 +
  668 + qemu_put_be32(f, QEMU_VM_FILE_MAGIC);
  669 + qemu_put_be32(f, QEMU_VM_FILE_VERSION);
  670 +
  671 + for (se = first_se; se != NULL; se = se->next) {
  672 + int len;
  673 +
  674 + if (se->save_live_state == NULL)
  675 + continue;
  676 +
  677 + /* Section type */
  678 + qemu_put_byte(f, QEMU_VM_SECTION_START);
  679 + qemu_put_be32(f, se->section_id);
  680 +
  681 + /* ID string */
  682 + len = strlen(se->idstr);
  683 + qemu_put_byte(f, len);
  684 + qemu_put_buffer(f, (uint8_t *)se->idstr, len);
  685 +
  686 + qemu_put_be32(f, se->instance_id);
  687 + qemu_put_be32(f, se->version_id);
  688 +
  689 + se->save_live_state(f, QEMU_VM_SECTION_START, se->opaque);
  690 + }
  691 +
  692 + if (qemu_file_has_error(f))
  693 + return -EIO;
  694 +
  695 + return 0;
  696 +}
  697 +
  698 +int qemu_savevm_state_iterate(QEMUFile *f)
  699 +{
  700 + SaveStateEntry *se;
  701 + int ret = 1;
  702 +
  703 + for (se = first_se; se != NULL; se = se->next) {
  704 + if (se->save_live_state == NULL)
  705 + continue;
  706 +
  707 + /* Section type */
  708 + qemu_put_byte(f, QEMU_VM_SECTION_PART);
  709 + qemu_put_be32(f, se->section_id);
  710 +
  711 + ret &= !!se->save_live_state(f, QEMU_VM_SECTION_PART, se->opaque);
  712 + }
  713 +
  714 + if (ret)
  715 + return 1;
  716 +
  717 + if (qemu_file_has_error(f))
  718 + return -EIO;
  719 +
  720 + return 0;
  721 +}
  722 +
  723 +int qemu_savevm_state_complete(QEMUFile *f)
  724 +{
  725 + SaveStateEntry *se;
  726 +
  727 + for (se = first_se; se != NULL; se = se->next) {
  728 + if (se->save_live_state == NULL)
  729 + continue;
  730 +
  731 + /* Section type */
  732 + qemu_put_byte(f, QEMU_VM_SECTION_END);
  733 + qemu_put_be32(f, se->section_id);
  734 +
  735 + se->save_live_state(f, QEMU_VM_SECTION_END, se->opaque);
  736 + }
  737 +
  738 + for(se = first_se; se != NULL; se = se->next) {
  739 + int len;
  740 +
  741 + if (se->save_state == NULL)
  742 + continue;
  743 +
  744 + /* Section type */
  745 + qemu_put_byte(f, QEMU_VM_SECTION_FULL);
  746 + qemu_put_be32(f, se->section_id);
  747 +
  748 + /* ID string */
  749 + len = strlen(se->idstr);
  750 + qemu_put_byte(f, len);
  751 + qemu_put_buffer(f, (uint8_t *)se->idstr, len);
  752 +
  753 + qemu_put_be32(f, se->instance_id);
  754 + qemu_put_be32(f, se->version_id);
  755 +
  756 + se->save_state(f, se->opaque);
  757 + }
  758 +
  759 + qemu_put_byte(f, QEMU_VM_EOF);
  760 +
  761 + if (qemu_file_has_error(f))
  762 + return -EIO;
  763 +
  764 + return 0;
  765 +}
  766 +
  767 +int qemu_savevm_state(QEMUFile *f)
  768 +{
  769 + int saved_vm_running;
  770 + int ret;
  771 +
  772 + saved_vm_running = vm_running;
  773 + vm_stop(0);
  774 +
  775 + bdrv_flush_all();
  776 +
  777 + ret = qemu_savevm_state_begin(f);
  778 + if (ret < 0)
  779 + goto out;
  780 +
  781 + do {
  782 + ret = qemu_savevm_state_iterate(f);
  783 + if (ret < 0)
  784 + goto out;
  785 + } while (ret == 0);
  786 +
  787 + ret = qemu_savevm_state_complete(f);
  788 +
  789 +out:
  790 + if (qemu_file_has_error(f))
  791 + ret = -EIO;
  792 +
  793 + if (!ret && saved_vm_running)
  794 + vm_start();
  795 +
  796 + return ret;
  797 +}
  798 +
  799 +static SaveStateEntry *find_se(const char *idstr, int instance_id)
  800 +{
  801 + SaveStateEntry *se;
  802 +
  803 + for(se = first_se; se != NULL; se = se->next) {
  804 + if (!strcmp(se->idstr, idstr) &&
  805 + instance_id == se->instance_id)
  806 + return se;
  807 + }
  808 + return NULL;
  809 +}
  810 +
  811 +typedef struct LoadStateEntry {
  812 + SaveStateEntry *se;
  813 + int section_id;
  814 + int version_id;
  815 + struct LoadStateEntry *next;
  816 +} LoadStateEntry;
  817 +
  818 +static int qemu_loadvm_state_v2(QEMUFile *f)
  819 +{
  820 + SaveStateEntry *se;
  821 + int len, ret, instance_id, record_len, version_id;
  822 + int64_t total_len, end_pos, cur_pos;
  823 + char idstr[256];
  824 +
  825 + total_len = qemu_get_be64(f);
  826 + end_pos = total_len + qemu_ftell(f);
  827 + for(;;) {
  828 + if (qemu_ftell(f) >= end_pos)
  829 + break;
  830 + len = qemu_get_byte(f);
  831 + qemu_get_buffer(f, (uint8_t *)idstr, len);
  832 + idstr[len] = '\0';
  833 + instance_id = qemu_get_be32(f);
  834 + version_id = qemu_get_be32(f);
  835 + record_len = qemu_get_be32(f);
  836 + cur_pos = qemu_ftell(f);
  837 + se = find_se(idstr, instance_id);
  838 + if (!se) {
  839 + fprintf(stderr, "qemu: warning: instance 0x%x of device '%s' not present in current VM\n",
  840 + instance_id, idstr);
  841 + } else {
  842 + ret = se->load_state(f, se->opaque, version_id);
  843 + if (ret < 0) {
  844 + fprintf(stderr, "qemu: warning: error while loading state for instance 0x%x of device '%s'\n",
  845 + instance_id, idstr);
  846 + }
  847 + }
  848 + /* always seek to exact end of record */
  849 + qemu_fseek(f, cur_pos + record_len, SEEK_SET);
  850 + }
  851 +
  852 + if (qemu_file_has_error(f))
  853 + return -EIO;
  854 +
  855 + return 0;
  856 +}
  857 +
  858 +int qemu_loadvm_state(QEMUFile *f)
  859 +{
  860 + LoadStateEntry *first_le = NULL;
  861 + uint8_t section_type;
  862 + unsigned int v;
  863 + int ret;
  864 +
  865 + v = qemu_get_be32(f);
  866 + if (v != QEMU_VM_FILE_MAGIC)
  867 + return -EINVAL;
  868 +
  869 + v = qemu_get_be32(f);
  870 + if (v == QEMU_VM_FILE_VERSION_COMPAT)
  871 + return qemu_loadvm_state_v2(f);
  872 + if (v != QEMU_VM_FILE_VERSION)
  873 + return -ENOTSUP;
  874 +
  875 + while ((section_type = qemu_get_byte(f)) != QEMU_VM_EOF) {
  876 + uint32_t instance_id, version_id, section_id;
  877 + LoadStateEntry *le;
  878 + SaveStateEntry *se;
  879 + char idstr[257];
  880 + int len;
  881 +
  882 + switch (section_type) {
  883 + case QEMU_VM_SECTION_START:
  884 + case QEMU_VM_SECTION_FULL:
  885 + /* Read section start */
  886 + section_id = qemu_get_be32(f);
  887 + len = qemu_get_byte(f);
  888 + qemu_get_buffer(f, (uint8_t *)idstr, len);
  889 + idstr[len] = 0;
  890 + instance_id = qemu_get_be32(f);
  891 + version_id = qemu_get_be32(f);
  892 +
  893 + /* Find savevm section */
  894 + se = find_se(idstr, instance_id);
  895 + if (se == NULL) {
  896 + fprintf(stderr, "Unknown savevm section or instance '%s' %d\n", idstr, instance_id);
  897 + ret = -EINVAL;
  898 + goto out;
  899 + }
  900 +
  901 + /* Validate version */
  902 + if (version_id > se->version_id) {
  903 + fprintf(stderr, "savevm: unsupported version %d for '%s' v%d\n",
  904 + version_id, idstr, se->version_id);
  905 + ret = -EINVAL;
  906 + goto out;
  907 + }
  908 +
  909 + /* Add entry */
  910 + le = qemu_mallocz(sizeof(*le));
  911 + if (le == NULL) {
  912 + ret = -ENOMEM;
  913 + goto out;
  914 + }
  915 +
  916 + le->se = se;
  917 + le->section_id = section_id;
  918 + le->version_id = version_id;
  919 + le->next = first_le;
  920 + first_le = le;
  921 +
  922 + le->se->load_state(f, le->se->opaque, le->version_id);
  923 + break;
  924 + case QEMU_VM_SECTION_PART:
  925 + case QEMU_VM_SECTION_END:
  926 + section_id = qemu_get_be32(f);
  927 +
  928 + for (le = first_le; le && le->section_id != section_id; le = le->next);
  929 + if (le == NULL) {
  930 + fprintf(stderr, "Unknown savevm section %d\n", section_id);
  931 + ret = -EINVAL;
  932 + goto out;
  933 + }
  934 +
  935 + le->se->load_state(f, le->se->opaque, le->version_id);
  936 + break;
  937 + default:
  938 + fprintf(stderr, "Unknown savevm section type %d\n", section_type);
  939 + ret = -EINVAL;
  940 + goto out;
  941 + }
  942 + }
  943 +
  944 + ret = 0;
  945 +
  946 +out:
  947 + while (first_le) {
  948 + LoadStateEntry *le = first_le;
  949 + first_le = first_le->next;
  950 + qemu_free(le);
  951 + }
  952 +
  953 + if (qemu_file_has_error(f))
  954 + ret = -EIO;
  955 +
  956 + return ret;
  957 +}
  958 +
  959 +/* device can contain snapshots */
  960 +static int bdrv_can_snapshot(BlockDriverState *bs)
  961 +{
  962 + return (bs &&
  963 + !bdrv_is_removable(bs) &&
  964 + !bdrv_is_read_only(bs));
  965 +}
  966 +
  967 +/* device must be snapshots in order to have a reliable snapshot */
  968 +static int bdrv_has_snapshot(BlockDriverState *bs)
  969 +{
  970 + return (bs &&
  971 + !bdrv_is_removable(bs) &&
  972 + !bdrv_is_read_only(bs));
  973 +}
  974 +
  975 +static BlockDriverState *get_bs_snapshots(void)
  976 +{
  977 + BlockDriverState *bs;
  978 + int i;
  979 +
  980 + if (bs_snapshots)
  981 + return bs_snapshots;
  982 + for(i = 0; i <= nb_drives; i++) {
  983 + bs = drives_table[i].bdrv;
  984 + if (bdrv_can_snapshot(bs))
  985 + goto ok;
  986 + }
  987 + return NULL;
  988 + ok:
  989 + bs_snapshots = bs;
  990 + return bs;
  991 +}
  992 +
  993 +static int bdrv_snapshot_find(BlockDriverState *bs, QEMUSnapshotInfo *sn_info,
  994 + const char *name)
  995 +{
  996 + QEMUSnapshotInfo *sn_tab, *sn;
  997 + int nb_sns, i, ret;
  998 +
  999 + ret = -ENOENT;
  1000 + nb_sns = bdrv_snapshot_list(bs, &sn_tab);
  1001 + if (nb_sns < 0)
  1002 + return ret;
  1003 + for(i = 0; i < nb_sns; i++) {
  1004 + sn = &sn_tab[i];
  1005 + if (!strcmp(sn->id_str, name) || !strcmp(sn->name, name)) {
  1006 + *sn_info = *sn;
  1007 + ret = 0;
  1008 + break;
  1009 + }
  1010 + }
  1011 + qemu_free(sn_tab);
  1012 + return ret;
  1013 +}
  1014 +
  1015 +void do_savevm(const char *name)
  1016 +{
  1017 + BlockDriverState *bs, *bs1;
  1018 + QEMUSnapshotInfo sn1, *sn = &sn1, old_sn1, *old_sn = &old_sn1;
  1019 + int must_delete, ret, i;
  1020 + BlockDriverInfo bdi1, *bdi = &bdi1;
  1021 + QEMUFile *f;
  1022 + int saved_vm_running;
  1023 +#ifdef _WIN32
  1024 + struct _timeb tb;
  1025 +#else
  1026 + struct timeval tv;
  1027 +#endif
  1028 +
  1029 + bs = get_bs_snapshots();
  1030 + if (!bs) {
  1031 + term_printf("No block device can accept snapshots\n");
  1032 + return;
  1033 + }
  1034 +
  1035 + /* ??? Should this occur after vm_stop? */
  1036 + qemu_aio_flush();
  1037 +
  1038 + saved_vm_running = vm_running;
  1039 + vm_stop(0);
  1040 +
  1041 + must_delete = 0;
  1042 + if (name) {
  1043 + ret = bdrv_snapshot_find(bs, old_sn, name);
  1044 + if (ret >= 0) {
  1045 + must_delete = 1;
  1046 + }
  1047 + }
  1048 + memset(sn, 0, sizeof(*sn));
  1049 + if (must_delete) {
  1050 + pstrcpy(sn->name, sizeof(sn->name), old_sn->name);
  1051 + pstrcpy(sn->id_str, sizeof(sn->id_str), old_sn->id_str);
  1052 + } else {
  1053 + if (name)
  1054 + pstrcpy(sn->name, sizeof(sn->name), name);
  1055 + }
  1056 +
  1057 + /* fill auxiliary fields */
  1058 +#ifdef _WIN32
  1059 + _ftime(&tb);
  1060 + sn->date_sec = tb.time;
  1061 + sn->date_nsec = tb.millitm * 1000000;
  1062 +#else
  1063 + gettimeofday(&tv, NULL);
  1064 + sn->date_sec = tv.tv_sec;
  1065 + sn->date_nsec = tv.tv_usec * 1000;
  1066 +#endif
  1067 + sn->vm_clock_nsec = qemu_get_clock(vm_clock);
  1068 +
  1069 + if (bdrv_get_info(bs, bdi) < 0 || bdi->vm_state_offset <= 0) {
  1070 + term_printf("Device %s does not support VM state snapshots\n",
  1071 + bdrv_get_device_name(bs));
  1072 + goto the_end;
  1073 + }
  1074 +
  1075 + /* save the VM state */
  1076 + f = qemu_fopen_bdrv(bs, bdi->vm_state_offset, 1);
  1077 + if (!f) {
  1078 + term_printf("Could not open VM state file\n");
  1079 + goto the_end;
  1080 + }
  1081 + ret = qemu_savevm_state(f);
  1082 + sn->vm_state_size = qemu_ftell(f);
  1083 + qemu_fclose(f);
  1084 + if (ret < 0) {
  1085 + term_printf("Error %d while writing VM\n", ret);
  1086 + goto the_end;
  1087 + }
  1088 +
  1089 + /* create the snapshots */
  1090 +
  1091 + for(i = 0; i < nb_drives; i++) {
  1092 + bs1 = drives_table[i].bdrv;
  1093 + if (bdrv_has_snapshot(bs1)) {
  1094 + if (must_delete) {
  1095 + ret = bdrv_snapshot_delete(bs1, old_sn->id_str);
  1096 + if (ret < 0) {
  1097 + term_printf("Error while deleting snapshot on '%s'\n",
  1098 + bdrv_get_device_name(bs1));
  1099 + }
  1100 + }
  1101 + ret = bdrv_snapshot_create(bs1, sn);
  1102 + if (ret < 0) {
  1103 + term_printf("Error while creating snapshot on '%s'\n",
  1104 + bdrv_get_device_name(bs1));
  1105 + }
  1106 + }
  1107 + }
  1108 +
  1109 + the_end:
  1110 + if (saved_vm_running)
  1111 + vm_start();
  1112 +}
  1113 +
  1114 +void do_loadvm(const char *name)
  1115 +{
  1116 + BlockDriverState *bs, *bs1;
  1117 + BlockDriverInfo bdi1, *bdi = &bdi1;
  1118 + QEMUFile *f;
  1119 + int i, ret;
  1120 + int saved_vm_running;
  1121 +
  1122 + bs = get_bs_snapshots();
  1123 + if (!bs) {
  1124 + term_printf("No block device supports snapshots\n");
  1125 + return;
  1126 + }
  1127 +
  1128 + /* Flush all IO requests so they don't interfere with the new state. */
  1129 + qemu_aio_flush();
  1130 +
  1131 + saved_vm_running = vm_running;
  1132 + vm_stop(0);
  1133 +
  1134 + for(i = 0; i <= nb_drives; i++) {
  1135 + bs1 = drives_table[i].bdrv;
  1136 + if (bdrv_has_snapshot(bs1)) {
  1137 + ret = bdrv_snapshot_goto(bs1, name);
  1138 + if (ret < 0) {
  1139 + if (bs != bs1)
  1140 + term_printf("Warning: ");
  1141 + switch(ret) {
  1142 + case -ENOTSUP:
  1143 + term_printf("Snapshots not supported on device '%s'\n",
  1144 + bdrv_get_device_name(bs1));
  1145 + break;
  1146 + case -ENOENT:
  1147 + term_printf("Could not find snapshot '%s' on device '%s'\n",
  1148 + name, bdrv_get_device_name(bs1));
  1149 + break;
  1150 + default:
  1151 + term_printf("Error %d while activating snapshot on '%s'\n",
  1152 + ret, bdrv_get_device_name(bs1));
  1153 + break;
  1154 + }
  1155 + /* fatal on snapshot block device */
  1156 + if (bs == bs1)
  1157 + goto the_end;
  1158 + }
  1159 + }
  1160 + }
  1161 +
  1162 + if (bdrv_get_info(bs, bdi) < 0 || bdi->vm_state_offset <= 0) {
  1163 + term_printf("Device %s does not support VM state snapshots\n",
  1164 + bdrv_get_device_name(bs));
  1165 + return;
  1166 + }
  1167 +
  1168 + /* restore the VM state */
  1169 + f = qemu_fopen_bdrv(bs, bdi->vm_state_offset, 0);
  1170 + if (!f) {
  1171 + term_printf("Could not open VM state file\n");
  1172 + goto the_end;
  1173 + }
  1174 + ret = qemu_loadvm_state(f);
  1175 + qemu_fclose(f);
  1176 + if (ret < 0) {
  1177 + term_printf("Error %d while loading VM state\n", ret);
  1178 + }
  1179 + the_end:
  1180 + if (saved_vm_running)
  1181 + vm_start();
  1182 +}
  1183 +
  1184 +void do_delvm(const char *name)
  1185 +{
  1186 + BlockDriverState *bs, *bs1;
  1187 + int i, ret;
  1188 +
  1189 + bs = get_bs_snapshots();
  1190 + if (!bs) {
  1191 + term_printf("No block device supports snapshots\n");
  1192 + return;
  1193 + }
  1194 +
  1195 + for(i = 0; i <= nb_drives; i++) {
  1196 + bs1 = drives_table[i].bdrv;
  1197 + if (bdrv_has_snapshot(bs1)) {
  1198 + ret = bdrv_snapshot_delete(bs1, name);
  1199 + if (ret < 0) {
  1200 + if (ret == -ENOTSUP)
  1201 + term_printf("Snapshots not supported on device '%s'\n",
  1202 + bdrv_get_device_name(bs1));
  1203 + else
  1204 + term_printf("Error %d while deleting snapshot on '%s'\n",
  1205 + ret, bdrv_get_device_name(bs1));
  1206 + }
  1207 + }
  1208 + }
  1209 +}
  1210 +
  1211 +void do_info_snapshots(void)
  1212 +{
  1213 + BlockDriverState *bs, *bs1;
  1214 + QEMUSnapshotInfo *sn_tab, *sn;
  1215 + int nb_sns, i;
  1216 + char buf[256];
  1217 +
  1218 + bs = get_bs_snapshots();
  1219 + if (!bs) {
  1220 + term_printf("No available block device supports snapshots\n");
  1221 + return;
  1222 + }
  1223 + term_printf("Snapshot devices:");
  1224 + for(i = 0; i <= nb_drives; i++) {
  1225 + bs1 = drives_table[i].bdrv;
  1226 + if (bdrv_has_snapshot(bs1)) {
  1227 + if (bs == bs1)
  1228 + term_printf(" %s", bdrv_get_device_name(bs1));
  1229 + }
  1230 + }
  1231 + term_printf("\n");
  1232 +
  1233 + nb_sns = bdrv_snapshot_list(bs, &sn_tab);
  1234 + if (nb_sns < 0) {
  1235 + term_printf("bdrv_snapshot_list: error %d\n", nb_sns);
  1236 + return;
  1237 + }
  1238 + term_printf("Snapshot list (from %s):\n", bdrv_get_device_name(bs));
  1239 + term_printf("%s\n", bdrv_snapshot_dump(buf, sizeof(buf), NULL));
  1240 + for(i = 0; i < nb_sns; i++) {
  1241 + sn = &sn_tab[i];
  1242 + term_printf("%s\n", bdrv_snapshot_dump(buf, sizeof(buf), sn));
  1243 + }
  1244 + qemu_free(sn_tab);
  1245 +}
... ...
... ... @@ -184,8 +184,6 @@ static IOPortWriteFunc *ioport_write_table[3][MAX_IOPORTS];
184 184 to store the VM snapshots */
185 185 DriveInfo drives_table[MAX_DRIVES+1];
186 186 int nb_drives;
187   -/* point to the block driver where the snapshots are managed */
188   -static BlockDriverState *bs_snapshots;
189 187 static int vga_ram_size;
190 188 enum vga_retrace_method vga_retrace_method = VGA_RETRACE_DUMB;
191 189 DisplayState display_state;
... ... @@ -2904,1160 +2902,6 @@ void qemu_del_wait_object(HANDLE handle, WaitObjectFunc *func, void *opaque)
2904 2902 }
2905 2903 #endif
2906 2904  
2907   -#define SELF_ANNOUNCE_ROUNDS 5
2908   -#define ETH_P_EXPERIMENTAL 0x01F1 /* just a number */
2909   -//#define ETH_P_EXPERIMENTAL 0x0012 /* make it the size of the packet */
2910   -#define EXPERIMENTAL_MAGIC 0xf1f23f4f
2911   -
2912   -static int announce_self_create(uint8_t *buf,
2913   - uint8_t *mac_addr)
2914   -{
2915   - uint32_t magic = EXPERIMENTAL_MAGIC;
2916   - uint16_t proto = htons(ETH_P_EXPERIMENTAL);
2917   -
2918   - /* FIXME: should we send a different packet (arp/rarp/ping)? */
2919   -
2920   - memset(buf, 0xff, 6); /* h_dst */
2921   - memcpy(buf + 6, mac_addr, 6); /* h_src */
2922   - memcpy(buf + 12, &proto, 2); /* h_proto */
2923   - memcpy(buf + 14, &magic, 4); /* magic */
2924   -
2925   - return 18; /* len */
2926   -}
2927   -
2928   -void qemu_announce_self(void)
2929   -{
2930   - int i, j, len;
2931   - VLANState *vlan;
2932   - VLANClientState *vc;
2933   - uint8_t buf[256];
2934   -
2935   - for (i = 0; i < nb_nics; i++) {
2936   - len = announce_self_create(buf, nd_table[i].macaddr);
2937   - vlan = nd_table[i].vlan;
2938   - for(vc = vlan->first_client; vc != NULL; vc = vc->next) {
2939   - for (j=0; j < SELF_ANNOUNCE_ROUNDS; j++)
2940   - vc->fd_read(vc->opaque, buf, len);
2941   - }
2942   - }
2943   -}
2944   -
2945   -/***********************************************************/
2946   -/* savevm/loadvm support */
2947   -
2948   -#define IO_BUF_SIZE 32768
2949   -
2950   -struct QEMUFile {
2951   - QEMUFilePutBufferFunc *put_buffer;
2952   - QEMUFileGetBufferFunc *get_buffer;
2953   - QEMUFileCloseFunc *close;
2954   - QEMUFileRateLimit *rate_limit;
2955   - void *opaque;
2956   - int is_write;
2957   -
2958   - int64_t buf_offset; /* start of buffer when writing, end of buffer
2959   - when reading */
2960   - int buf_index;
2961   - int buf_size; /* 0 when writing */
2962   - uint8_t buf[IO_BUF_SIZE];
2963   -
2964   - int has_error;
2965   -};
2966   -
2967   -typedef struct QEMUFilePopen
2968   -{
2969   - FILE *popen_file;
2970   - QEMUFile *file;
2971   -} QEMUFilePopen;
2972   -
2973   -typedef struct QEMUFileSocket
2974   -{
2975   - int fd;
2976   - QEMUFile *file;
2977   -} QEMUFileSocket;
2978   -
2979   -static int socket_get_buffer(void *opaque, uint8_t *buf, int64_t pos, int size)
2980   -{
2981   - QEMUFileSocket *s = opaque;
2982   - ssize_t len;
2983   -
2984   - do {
2985   - len = recv(s->fd, buf, size, 0);
2986   - } while (len == -1 && socket_error() == EINTR);
2987   -
2988   - if (len == -1)
2989   - len = -socket_error();
2990   -
2991   - return len;
2992   -}
2993   -
2994   -static int socket_close(void *opaque)
2995   -{
2996   - QEMUFileSocket *s = opaque;
2997   - qemu_free(s);
2998   - return 0;
2999   -}
3000   -
3001   -static int popen_put_buffer(void *opaque, const uint8_t *buf, int64_t pos, int size)
3002   -{
3003   - QEMUFilePopen *s = opaque;
3004   - return fwrite(buf, 1, size, s->popen_file);
3005   -}
3006   -
3007   -static int popen_get_buffer(void *opaque, uint8_t *buf, int64_t pos, int size)
3008   -{
3009   - QEMUFilePopen *s = opaque;
3010   - return fread(buf, 1, size, s->popen_file);
3011   -}
3012   -
3013   -static int popen_close(void *opaque)
3014   -{
3015   - QEMUFilePopen *s = opaque;
3016   - pclose(s->popen_file);
3017   - qemu_free(s);
3018   - return 0;
3019   -}
3020   -
3021   -QEMUFile *qemu_popen(FILE *popen_file, const char *mode)
3022   -{
3023   - QEMUFilePopen *s;
3024   -
3025   - if (popen_file == NULL || mode == NULL || (mode[0] != 'r' && mode[0] != 'w') || mode[1] != 0) {
3026   - fprintf(stderr, "qemu_popen: Argument validity check failed\n");
3027   - return NULL;
3028   - }
3029   -
3030   - s = qemu_mallocz(sizeof(QEMUFilePopen));
3031   - if (!s) {
3032   - fprintf(stderr, "qemu_popen: malloc failed\n");
3033   - return NULL;
3034   - }
3035   -
3036   - s->popen_file = popen_file;
3037   -
3038   - if(mode[0] == 'r') {
3039   - s->file = qemu_fopen_ops(s, NULL, popen_get_buffer, popen_close, NULL);
3040   - } else {
3041   - s->file = qemu_fopen_ops(s, popen_put_buffer, NULL, popen_close, NULL);
3042   - }
3043   - fprintf(stderr, "qemu_popen: returning result of qemu_fopen_ops\n");
3044   - return s->file;
3045   -}
3046   -
3047   -QEMUFile *qemu_popen_cmd(const char *command, const char *mode)
3048   -{
3049   - FILE *popen_file;
3050   -
3051   - popen_file = popen(command, mode);
3052   - if(popen_file == NULL) {
3053   - return NULL;
3054   - }
3055   -
3056   - return qemu_popen(popen_file, mode);
3057   -}
3058   -
3059   -QEMUFile *qemu_fopen_socket(int fd)
3060   -{
3061   - QEMUFileSocket *s = qemu_mallocz(sizeof(QEMUFileSocket));
3062   -
3063   - if (s == NULL)
3064   - return NULL;
3065   -
3066   - s->fd = fd;
3067   - s->file = qemu_fopen_ops(s, NULL, socket_get_buffer, socket_close, NULL);
3068   - return s->file;
3069   -}
3070   -
3071   -typedef struct QEMUFileStdio
3072   -{
3073   - FILE *outfile;
3074   -} QEMUFileStdio;
3075   -
3076   -static int file_put_buffer(void *opaque, const uint8_t *buf,
3077   - int64_t pos, int size)
3078   -{
3079   - QEMUFileStdio *s = opaque;
3080   - fseek(s->outfile, pos, SEEK_SET);
3081   - fwrite(buf, 1, size, s->outfile);
3082   - return size;
3083   -}
3084   -
3085   -static int file_get_buffer(void *opaque, uint8_t *buf, int64_t pos, int size)
3086   -{
3087   - QEMUFileStdio *s = opaque;
3088   - fseek(s->outfile, pos, SEEK_SET);
3089   - return fread(buf, 1, size, s->outfile);
3090   -}
3091   -
3092   -static int file_close(void *opaque)
3093   -{
3094   - QEMUFileStdio *s = opaque;
3095   - fclose(s->outfile);
3096   - qemu_free(s);
3097   - return 0;
3098   -}
3099   -
3100   -QEMUFile *qemu_fopen(const char *filename, const char *mode)
3101   -{
3102   - QEMUFileStdio *s;
3103   -
3104   - s = qemu_mallocz(sizeof(QEMUFileStdio));
3105   - if (!s)
3106   - return NULL;
3107   -
3108   - s->outfile = fopen(filename, mode);
3109   - if (!s->outfile)
3110   - goto fail;
3111   -
3112   - if (!strcmp(mode, "wb"))
3113   - return qemu_fopen_ops(s, file_put_buffer, NULL, file_close, NULL);
3114   - else if (!strcmp(mode, "rb"))
3115   - return qemu_fopen_ops(s, NULL, file_get_buffer, file_close, NULL);
3116   -
3117   -fail:
3118   - if (s->outfile)
3119   - fclose(s->outfile);
3120   - qemu_free(s);
3121   - return NULL;
3122   -}
3123   -
3124   -typedef struct QEMUFileBdrv
3125   -{
3126   - BlockDriverState *bs;
3127   - int64_t base_offset;
3128   -} QEMUFileBdrv;
3129   -
3130   -static int bdrv_put_buffer(void *opaque, const uint8_t *buf,
3131   - int64_t pos, int size)
3132   -{
3133   - QEMUFileBdrv *s = opaque;
3134   - bdrv_pwrite(s->bs, s->base_offset + pos, buf, size);
3135   - return size;
3136   -}
3137   -
3138   -static int bdrv_get_buffer(void *opaque, uint8_t *buf, int64_t pos, int size)
3139   -{
3140   - QEMUFileBdrv *s = opaque;
3141   - return bdrv_pread(s->bs, s->base_offset + pos, buf, size);
3142   -}
3143   -
3144   -static int bdrv_fclose(void *opaque)
3145   -{
3146   - QEMUFileBdrv *s = opaque;
3147   - qemu_free(s);
3148   - return 0;
3149   -}
3150   -
3151   -static QEMUFile *qemu_fopen_bdrv(BlockDriverState *bs, int64_t offset, int is_writable)
3152   -{
3153   - QEMUFileBdrv *s;
3154   -
3155   - s = qemu_mallocz(sizeof(QEMUFileBdrv));
3156   - if (!s)
3157   - return NULL;
3158   -
3159   - s->bs = bs;
3160   - s->base_offset = offset;
3161   -
3162   - if (is_writable)
3163   - return qemu_fopen_ops(s, bdrv_put_buffer, NULL, bdrv_fclose, NULL);
3164   -
3165   - return qemu_fopen_ops(s, NULL, bdrv_get_buffer, bdrv_fclose, NULL);
3166   -}
3167   -
3168   -QEMUFile *qemu_fopen_ops(void *opaque, QEMUFilePutBufferFunc *put_buffer,
3169   - QEMUFileGetBufferFunc *get_buffer,
3170   - QEMUFileCloseFunc *close,
3171   - QEMUFileRateLimit *rate_limit)
3172   -{
3173   - QEMUFile *f;
3174   -
3175   - f = qemu_mallocz(sizeof(QEMUFile));
3176   - if (!f)
3177   - return NULL;
3178   -
3179   - f->opaque = opaque;
3180   - f->put_buffer = put_buffer;
3181   - f->get_buffer = get_buffer;
3182   - f->close = close;
3183   - f->rate_limit = rate_limit;
3184   - f->is_write = 0;
3185   -
3186   - return f;
3187   -}
3188   -
3189   -int qemu_file_has_error(QEMUFile *f)
3190   -{
3191   - return f->has_error;
3192   -}
3193   -
3194   -void qemu_fflush(QEMUFile *f)
3195   -{
3196   - if (!f->put_buffer)
3197   - return;
3198   -
3199   - if (f->is_write && f->buf_index > 0) {
3200   - int len;
3201   -
3202   - len = f->put_buffer(f->opaque, f->buf, f->buf_offset, f->buf_index);
3203   - if (len > 0)
3204   - f->buf_offset += f->buf_index;
3205   - else
3206   - f->has_error = 1;
3207   - f->buf_index = 0;
3208   - }
3209   -}
3210   -
3211   -static void qemu_fill_buffer(QEMUFile *f)
3212   -{
3213   - int len;
3214   -
3215   - if (!f->get_buffer)
3216   - return;
3217   -
3218   - if (f->is_write)
3219   - abort();
3220   -
3221   - len = f->get_buffer(f->opaque, f->buf, f->buf_offset, IO_BUF_SIZE);
3222   - if (len > 0) {
3223   - f->buf_index = 0;
3224   - f->buf_size = len;
3225   - f->buf_offset += len;
3226   - } else if (len != -EAGAIN)
3227   - f->has_error = 1;
3228   -}
3229   -
3230   -int qemu_fclose(QEMUFile *f)
3231   -{
3232   - int ret = 0;
3233   - qemu_fflush(f);
3234   - if (f->close)
3235   - ret = f->close(f->opaque);
3236   - qemu_free(f);
3237   - return ret;
3238   -}
3239   -
3240   -void qemu_file_put_notify(QEMUFile *f)
3241   -{
3242   - f->put_buffer(f->opaque, NULL, 0, 0);
3243   -}
3244   -
3245   -void qemu_put_buffer(QEMUFile *f, const uint8_t *buf, int size)
3246   -{
3247   - int l;
3248   -
3249   - if (!f->has_error && f->is_write == 0 && f->buf_index > 0) {
3250   - fprintf(stderr,
3251   - "Attempted to write to buffer while read buffer is not empty\n");
3252   - abort();
3253   - }
3254   -
3255   - while (!f->has_error && size > 0) {
3256   - l = IO_BUF_SIZE - f->buf_index;
3257   - if (l > size)
3258   - l = size;
3259   - memcpy(f->buf + f->buf_index, buf, l);
3260   - f->is_write = 1;
3261   - f->buf_index += l;
3262   - buf += l;
3263   - size -= l;
3264   - if (f->buf_index >= IO_BUF_SIZE)
3265   - qemu_fflush(f);
3266   - }
3267   -}
3268   -
3269   -void qemu_put_byte(QEMUFile *f, int v)
3270   -{
3271   - if (!f->has_error && f->is_write == 0 && f->buf_index > 0) {
3272   - fprintf(stderr,
3273   - "Attempted to write to buffer while read buffer is not empty\n");
3274   - abort();
3275   - }
3276   -
3277   - f->buf[f->buf_index++] = v;
3278   - f->is_write = 1;
3279   - if (f->buf_index >= IO_BUF_SIZE)
3280   - qemu_fflush(f);
3281   -}
3282   -
3283   -int qemu_get_buffer(QEMUFile *f, uint8_t *buf, int size1)
3284   -{
3285   - int size, l;
3286   -
3287   - if (f->is_write)
3288   - abort();
3289   -
3290   - size = size1;
3291   - while (size > 0) {
3292   - l = f->buf_size - f->buf_index;
3293   - if (l == 0) {
3294   - qemu_fill_buffer(f);
3295   - l = f->buf_size - f->buf_index;
3296   - if (l == 0)
3297   - break;
3298   - }
3299   - if (l > size)
3300   - l = size;
3301   - memcpy(buf, f->buf + f->buf_index, l);
3302   - f->buf_index += l;
3303   - buf += l;
3304   - size -= l;
3305   - }
3306   - return size1 - size;
3307   -}
3308   -
3309   -int qemu_get_byte(QEMUFile *f)
3310   -{
3311   - if (f->is_write)
3312   - abort();
3313   -
3314   - if (f->buf_index >= f->buf_size) {
3315   - qemu_fill_buffer(f);
3316   - if (f->buf_index >= f->buf_size)
3317   - return 0;
3318   - }
3319   - return f->buf[f->buf_index++];
3320   -}
3321   -
3322   -int64_t qemu_ftell(QEMUFile *f)
3323   -{
3324   - return f->buf_offset - f->buf_size + f->buf_index;
3325   -}
3326   -
3327   -int64_t qemu_fseek(QEMUFile *f, int64_t pos, int whence)
3328   -{
3329   - if (whence == SEEK_SET) {
3330   - /* nothing to do */
3331   - } else if (whence == SEEK_CUR) {
3332   - pos += qemu_ftell(f);
3333   - } else {
3334   - /* SEEK_END not supported */
3335   - return -1;
3336   - }
3337   - if (f->put_buffer) {
3338   - qemu_fflush(f);
3339   - f->buf_offset = pos;
3340   - } else {
3341   - f->buf_offset = pos;
3342   - f->buf_index = 0;
3343   - f->buf_size = 0;
3344   - }
3345   - return pos;
3346   -}
3347   -
3348   -int qemu_file_rate_limit(QEMUFile *f)
3349   -{
3350   - if (f->rate_limit)
3351   - return f->rate_limit(f->opaque);
3352   -
3353   - return 0;
3354   -}
3355   -
3356   -void qemu_put_be16(QEMUFile *f, unsigned int v)
3357   -{
3358   - qemu_put_byte(f, v >> 8);
3359   - qemu_put_byte(f, v);
3360   -}
3361   -
3362   -void qemu_put_be32(QEMUFile *f, unsigned int v)
3363   -{
3364   - qemu_put_byte(f, v >> 24);
3365   - qemu_put_byte(f, v >> 16);
3366   - qemu_put_byte(f, v >> 8);
3367   - qemu_put_byte(f, v);
3368   -}
3369   -
3370   -void qemu_put_be64(QEMUFile *f, uint64_t v)
3371   -{
3372   - qemu_put_be32(f, v >> 32);
3373   - qemu_put_be32(f, v);
3374   -}
3375   -
3376   -unsigned int qemu_get_be16(QEMUFile *f)
3377   -{
3378   - unsigned int v;
3379   - v = qemu_get_byte(f) << 8;
3380   - v |= qemu_get_byte(f);
3381   - return v;
3382   -}
3383   -
3384   -unsigned int qemu_get_be32(QEMUFile *f)
3385   -{
3386   - unsigned int v;
3387   - v = qemu_get_byte(f) << 24;
3388   - v |= qemu_get_byte(f) << 16;
3389   - v |= qemu_get_byte(f) << 8;
3390   - v |= qemu_get_byte(f);
3391   - return v;
3392   -}
3393   -
3394   -uint64_t qemu_get_be64(QEMUFile *f)
3395   -{
3396   - uint64_t v;
3397   - v = (uint64_t)qemu_get_be32(f) << 32;
3398   - v |= qemu_get_be32(f);
3399   - return v;
3400   -}
3401   -
3402   -typedef struct SaveStateEntry {
3403   - char idstr[256];
3404   - int instance_id;
3405   - int version_id;
3406   - int section_id;
3407   - SaveLiveStateHandler *save_live_state;
3408   - SaveStateHandler *save_state;
3409   - LoadStateHandler *load_state;
3410   - void *opaque;
3411   - struct SaveStateEntry *next;
3412   -} SaveStateEntry;
3413   -
3414   -static SaveStateEntry *first_se;
3415   -
3416   -/* TODO: Individual devices generally have very little idea about the rest
3417   - of the system, so instance_id should be removed/replaced.
3418   - Meanwhile pass -1 as instance_id if you do not already have a clearly
3419   - distinguishing id for all instances of your device class. */
3420   -int register_savevm_live(const char *idstr,
3421   - int instance_id,
3422   - int version_id,
3423   - SaveLiveStateHandler *save_live_state,
3424   - SaveStateHandler *save_state,
3425   - LoadStateHandler *load_state,
3426   - void *opaque)
3427   -{
3428   - SaveStateEntry *se, **pse;
3429   - static int global_section_id;
3430   -
3431   - se = qemu_malloc(sizeof(SaveStateEntry));
3432   - if (!se)
3433   - return -1;
3434   - pstrcpy(se->idstr, sizeof(se->idstr), idstr);
3435   - se->instance_id = (instance_id == -1) ? 0 : instance_id;
3436   - se->version_id = version_id;
3437   - se->section_id = global_section_id++;
3438   - se->save_live_state = save_live_state;
3439   - se->save_state = save_state;
3440   - se->load_state = load_state;
3441   - se->opaque = opaque;
3442   - se->next = NULL;
3443   -
3444   - /* add at the end of list */
3445   - pse = &first_se;
3446   - while (*pse != NULL) {
3447   - if (instance_id == -1
3448   - && strcmp(se->idstr, (*pse)->idstr) == 0
3449   - && se->instance_id <= (*pse)->instance_id)
3450   - se->instance_id = (*pse)->instance_id + 1;
3451   - pse = &(*pse)->next;
3452   - }
3453   - *pse = se;
3454   - return 0;
3455   -}
3456   -
3457   -int register_savevm(const char *idstr,
3458   - int instance_id,
3459   - int version_id,
3460   - SaveStateHandler *save_state,
3461   - LoadStateHandler *load_state,
3462   - void *opaque)
3463   -{
3464   - return register_savevm_live(idstr, instance_id, version_id,
3465   - NULL, save_state, load_state, opaque);
3466   -}
3467   -
3468   -#define QEMU_VM_FILE_MAGIC 0x5145564d
3469   -#define QEMU_VM_FILE_VERSION_COMPAT 0x00000002
3470   -#define QEMU_VM_FILE_VERSION 0x00000003
3471   -
3472   -#define QEMU_VM_EOF 0x00
3473   -#define QEMU_VM_SECTION_START 0x01
3474   -#define QEMU_VM_SECTION_PART 0x02
3475   -#define QEMU_VM_SECTION_END 0x03
3476   -#define QEMU_VM_SECTION_FULL 0x04
3477   -
3478   -int qemu_savevm_state_begin(QEMUFile *f)
3479   -{
3480   - SaveStateEntry *se;
3481   -
3482   - qemu_put_be32(f, QEMU_VM_FILE_MAGIC);
3483   - qemu_put_be32(f, QEMU_VM_FILE_VERSION);
3484   -
3485   - for (se = first_se; se != NULL; se = se->next) {
3486   - int len;
3487   -
3488   - if (se->save_live_state == NULL)
3489   - continue;
3490   -
3491   - /* Section type */
3492   - qemu_put_byte(f, QEMU_VM_SECTION_START);
3493   - qemu_put_be32(f, se->section_id);
3494   -
3495   - /* ID string */
3496   - len = strlen(se->idstr);
3497   - qemu_put_byte(f, len);
3498   - qemu_put_buffer(f, (uint8_t *)se->idstr, len);
3499   -
3500   - qemu_put_be32(f, se->instance_id);
3501   - qemu_put_be32(f, se->version_id);
3502   -
3503   - se->save_live_state(f, QEMU_VM_SECTION_START, se->opaque);
3504   - }
3505   -
3506   - if (qemu_file_has_error(f))
3507   - return -EIO;
3508   -
3509   - return 0;
3510   -}
3511   -
3512   -int qemu_savevm_state_iterate(QEMUFile *f)
3513   -{
3514   - SaveStateEntry *se;
3515   - int ret = 1;
3516   -
3517   - for (se = first_se; se != NULL; se = se->next) {
3518   - if (se->save_live_state == NULL)
3519   - continue;
3520   -
3521   - /* Section type */
3522   - qemu_put_byte(f, QEMU_VM_SECTION_PART);
3523   - qemu_put_be32(f, se->section_id);
3524   -
3525   - ret &= !!se->save_live_state(f, QEMU_VM_SECTION_PART, se->opaque);
3526   - }
3527   -
3528   - if (ret)
3529   - return 1;
3530   -
3531   - if (qemu_file_has_error(f))
3532   - return -EIO;
3533   -
3534   - return 0;
3535   -}
3536   -
3537   -int qemu_savevm_state_complete(QEMUFile *f)
3538   -{
3539   - SaveStateEntry *se;
3540   -
3541   - for (se = first_se; se != NULL; se = se->next) {
3542   - if (se->save_live_state == NULL)
3543   - continue;
3544   -
3545   - /* Section type */
3546   - qemu_put_byte(f, QEMU_VM_SECTION_END);
3547   - qemu_put_be32(f, se->section_id);
3548   -
3549   - se->save_live_state(f, QEMU_VM_SECTION_END, se->opaque);
3550   - }
3551   -
3552   - for(se = first_se; se != NULL; se = se->next) {
3553   - int len;
3554   -
3555   - if (se->save_state == NULL)
3556   - continue;
3557   -
3558   - /* Section type */
3559   - qemu_put_byte(f, QEMU_VM_SECTION_FULL);
3560   - qemu_put_be32(f, se->section_id);
3561   -
3562   - /* ID string */
3563   - len = strlen(se->idstr);
3564   - qemu_put_byte(f, len);
3565   - qemu_put_buffer(f, (uint8_t *)se->idstr, len);
3566   -
3567   - qemu_put_be32(f, se->instance_id);
3568   - qemu_put_be32(f, se->version_id);
3569   -
3570   - se->save_state(f, se->opaque);
3571   - }
3572   -
3573   - qemu_put_byte(f, QEMU_VM_EOF);
3574   -
3575   - if (qemu_file_has_error(f))
3576   - return -EIO;
3577   -
3578   - return 0;
3579   -}
3580   -
3581   -int qemu_savevm_state(QEMUFile *f)
3582   -{
3583   - int saved_vm_running;
3584   - int ret;
3585   -
3586   - saved_vm_running = vm_running;
3587   - vm_stop(0);
3588   -
3589   - bdrv_flush_all();
3590   -
3591   - ret = qemu_savevm_state_begin(f);
3592   - if (ret < 0)
3593   - goto out;
3594   -
3595   - do {
3596   - ret = qemu_savevm_state_iterate(f);
3597   - if (ret < 0)
3598   - goto out;
3599   - } while (ret == 0);
3600   -
3601   - ret = qemu_savevm_state_complete(f);
3602   -
3603   -out:
3604   - if (qemu_file_has_error(f))
3605   - ret = -EIO;
3606   -
3607   - if (!ret && saved_vm_running)
3608   - vm_start();
3609   -
3610   - return ret;
3611   -}
3612   -
3613   -static SaveStateEntry *find_se(const char *idstr, int instance_id)
3614   -{
3615   - SaveStateEntry *se;
3616   -
3617   - for(se = first_se; se != NULL; se = se->next) {
3618   - if (!strcmp(se->idstr, idstr) &&
3619   - instance_id == se->instance_id)
3620   - return se;
3621   - }
3622   - return NULL;
3623   -}
3624   -
3625   -typedef struct LoadStateEntry {
3626   - SaveStateEntry *se;
3627   - int section_id;
3628   - int version_id;
3629   - struct LoadStateEntry *next;
3630   -} LoadStateEntry;
3631   -
3632   -static int qemu_loadvm_state_v2(QEMUFile *f)
3633   -{
3634   - SaveStateEntry *se;
3635   - int len, ret, instance_id, record_len, version_id;
3636   - int64_t total_len, end_pos, cur_pos;
3637   - char idstr[256];
3638   -
3639   - total_len = qemu_get_be64(f);
3640   - end_pos = total_len + qemu_ftell(f);
3641   - for(;;) {
3642   - if (qemu_ftell(f) >= end_pos)
3643   - break;
3644   - len = qemu_get_byte(f);
3645   - qemu_get_buffer(f, (uint8_t *)idstr, len);
3646   - idstr[len] = '\0';
3647   - instance_id = qemu_get_be32(f);
3648   - version_id = qemu_get_be32(f);
3649   - record_len = qemu_get_be32(f);
3650   - cur_pos = qemu_ftell(f);
3651   - se = find_se(idstr, instance_id);
3652   - if (!se) {
3653   - fprintf(stderr, "qemu: warning: instance 0x%x of device '%s' not present in current VM\n",
3654   - instance_id, idstr);
3655   - } else {
3656   - ret = se->load_state(f, se->opaque, version_id);
3657   - if (ret < 0) {
3658   - fprintf(stderr, "qemu: warning: error while loading state for instance 0x%x of device '%s'\n",
3659   - instance_id, idstr);
3660   - }
3661   - }
3662   - /* always seek to exact end of record */
3663   - qemu_fseek(f, cur_pos + record_len, SEEK_SET);
3664   - }
3665   -
3666   - if (qemu_file_has_error(f))
3667   - return -EIO;
3668   -
3669   - return 0;
3670   -}
3671   -
3672   -int qemu_loadvm_state(QEMUFile *f)
3673   -{
3674   - LoadStateEntry *first_le = NULL;
3675   - uint8_t section_type;
3676   - unsigned int v;
3677   - int ret;
3678   -
3679   - v = qemu_get_be32(f);
3680   - if (v != QEMU_VM_FILE_MAGIC)
3681   - return -EINVAL;
3682   -
3683   - v = qemu_get_be32(f);
3684   - if (v == QEMU_VM_FILE_VERSION_COMPAT)
3685   - return qemu_loadvm_state_v2(f);
3686   - if (v != QEMU_VM_FILE_VERSION)
3687   - return -ENOTSUP;
3688   -
3689   - while ((section_type = qemu_get_byte(f)) != QEMU_VM_EOF) {
3690   - uint32_t instance_id, version_id, section_id;
3691   - LoadStateEntry *le;
3692   - SaveStateEntry *se;
3693   - char idstr[257];
3694   - int len;
3695   -
3696   - switch (section_type) {
3697   - case QEMU_VM_SECTION_START:
3698   - case QEMU_VM_SECTION_FULL:
3699   - /* Read section start */
3700   - section_id = qemu_get_be32(f);
3701   - len = qemu_get_byte(f);
3702   - qemu_get_buffer(f, (uint8_t *)idstr, len);
3703   - idstr[len] = 0;
3704   - instance_id = qemu_get_be32(f);
3705   - version_id = qemu_get_be32(f);
3706   -
3707   - /* Find savevm section */
3708   - se = find_se(idstr, instance_id);
3709   - if (se == NULL) {
3710   - fprintf(stderr, "Unknown savevm section or instance '%s' %d\n", idstr, instance_id);
3711   - ret = -EINVAL;
3712   - goto out;
3713   - }
3714   -
3715   - /* Validate version */
3716   - if (version_id > se->version_id) {
3717   - fprintf(stderr, "savevm: unsupported version %d for '%s' v%d\n",
3718   - version_id, idstr, se->version_id);
3719   - ret = -EINVAL;
3720   - goto out;
3721   - }
3722   -
3723   - /* Add entry */
3724   - le = qemu_mallocz(sizeof(*le));
3725   - if (le == NULL) {
3726   - ret = -ENOMEM;
3727   - goto out;
3728   - }
3729   -
3730   - le->se = se;
3731   - le->section_id = section_id;
3732   - le->version_id = version_id;
3733   - le->next = first_le;
3734   - first_le = le;
3735   -
3736   - le->se->load_state(f, le->se->opaque, le->version_id);
3737   - break;
3738   - case QEMU_VM_SECTION_PART:
3739   - case QEMU_VM_SECTION_END:
3740   - section_id = qemu_get_be32(f);
3741   -
3742   - for (le = first_le; le && le->section_id != section_id; le = le->next);
3743   - if (le == NULL) {
3744   - fprintf(stderr, "Unknown savevm section %d\n", section_id);
3745   - ret = -EINVAL;
3746   - goto out;
3747   - }
3748   -
3749   - le->se->load_state(f, le->se->opaque, le->version_id);
3750   - break;
3751   - default:
3752   - fprintf(stderr, "Unknown savevm section type %d\n", section_type);
3753   - ret = -EINVAL;
3754   - goto out;
3755   - }
3756   - }
3757   -
3758   - ret = 0;
3759   -
3760   -out:
3761   - while (first_le) {
3762   - LoadStateEntry *le = first_le;
3763   - first_le = first_le->next;
3764   - qemu_free(le);
3765   - }
3766   -
3767   - if (qemu_file_has_error(f))
3768   - ret = -EIO;
3769   -
3770   - return ret;
3771   -}
3772   -
3773   -/* device can contain snapshots */
3774   -static int bdrv_can_snapshot(BlockDriverState *bs)
3775   -{
3776   - return (bs &&
3777   - !bdrv_is_removable(bs) &&
3778   - !bdrv_is_read_only(bs));
3779   -}
3780   -
3781   -/* device must be snapshots in order to have a reliable snapshot */
3782   -static int bdrv_has_snapshot(BlockDriverState *bs)
3783   -{
3784   - return (bs &&
3785   - !bdrv_is_removable(bs) &&
3786   - !bdrv_is_read_only(bs));
3787   -}
3788   -
3789   -static BlockDriverState *get_bs_snapshots(void)
3790   -{
3791   - BlockDriverState *bs;
3792   - int i;
3793   -
3794   - if (bs_snapshots)
3795   - return bs_snapshots;
3796   - for(i = 0; i <= nb_drives; i++) {
3797   - bs = drives_table[i].bdrv;
3798   - if (bdrv_can_snapshot(bs))
3799   - goto ok;
3800   - }
3801   - return NULL;
3802   - ok:
3803   - bs_snapshots = bs;
3804   - return bs;
3805   -}
3806   -
3807   -static int bdrv_snapshot_find(BlockDriverState *bs, QEMUSnapshotInfo *sn_info,
3808   - const char *name)
3809   -{
3810   - QEMUSnapshotInfo *sn_tab, *sn;
3811   - int nb_sns, i, ret;
3812   -
3813   - ret = -ENOENT;
3814   - nb_sns = bdrv_snapshot_list(bs, &sn_tab);
3815   - if (nb_sns < 0)
3816   - return ret;
3817   - for(i = 0; i < nb_sns; i++) {
3818   - sn = &sn_tab[i];
3819   - if (!strcmp(sn->id_str, name) || !strcmp(sn->name, name)) {
3820   - *sn_info = *sn;
3821   - ret = 0;
3822   - break;
3823   - }
3824   - }
3825   - qemu_free(sn_tab);
3826   - return ret;
3827   -}
3828   -
3829   -void do_savevm(const char *name)
3830   -{
3831   - BlockDriverState *bs, *bs1;
3832   - QEMUSnapshotInfo sn1, *sn = &sn1, old_sn1, *old_sn = &old_sn1;
3833   - int must_delete, ret, i;
3834   - BlockDriverInfo bdi1, *bdi = &bdi1;
3835   - QEMUFile *f;
3836   - int saved_vm_running;
3837   -#ifdef _WIN32
3838   - struct _timeb tb;
3839   -#else
3840   - struct timeval tv;
3841   -#endif
3842   -
3843   - bs = get_bs_snapshots();
3844   - if (!bs) {
3845   - term_printf("No block device can accept snapshots\n");
3846   - return;
3847   - }
3848   -
3849   - /* ??? Should this occur after vm_stop? */
3850   - qemu_aio_flush();
3851   -
3852   - saved_vm_running = vm_running;
3853   - vm_stop(0);
3854   -
3855   - must_delete = 0;
3856   - if (name) {
3857   - ret = bdrv_snapshot_find(bs, old_sn, name);
3858   - if (ret >= 0) {
3859   - must_delete = 1;
3860   - }
3861   - }
3862   - memset(sn, 0, sizeof(*sn));
3863   - if (must_delete) {
3864   - pstrcpy(sn->name, sizeof(sn->name), old_sn->name);
3865   - pstrcpy(sn->id_str, sizeof(sn->id_str), old_sn->id_str);
3866   - } else {
3867   - if (name)
3868   - pstrcpy(sn->name, sizeof(sn->name), name);
3869   - }
3870   -
3871   - /* fill auxiliary fields */
3872   -#ifdef _WIN32
3873   - _ftime(&tb);
3874   - sn->date_sec = tb.time;
3875   - sn->date_nsec = tb.millitm * 1000000;
3876   -#else
3877   - gettimeofday(&tv, NULL);
3878   - sn->date_sec = tv.tv_sec;
3879   - sn->date_nsec = tv.tv_usec * 1000;
3880   -#endif
3881   - sn->vm_clock_nsec = qemu_get_clock(vm_clock);
3882   -
3883   - if (bdrv_get_info(bs, bdi) < 0 || bdi->vm_state_offset <= 0) {
3884   - term_printf("Device %s does not support VM state snapshots\n",
3885   - bdrv_get_device_name(bs));
3886   - goto the_end;
3887   - }
3888   -
3889   - /* save the VM state */
3890   - f = qemu_fopen_bdrv(bs, bdi->vm_state_offset, 1);
3891   - if (!f) {
3892   - term_printf("Could not open VM state file\n");
3893   - goto the_end;
3894   - }
3895   - ret = qemu_savevm_state(f);
3896   - sn->vm_state_size = qemu_ftell(f);
3897   - qemu_fclose(f);
3898   - if (ret < 0) {
3899   - term_printf("Error %d while writing VM\n", ret);
3900   - goto the_end;
3901   - }
3902   -
3903   - /* create the snapshots */
3904   -
3905   - for(i = 0; i < nb_drives; i++) {
3906   - bs1 = drives_table[i].bdrv;
3907   - if (bdrv_has_snapshot(bs1)) {
3908   - if (must_delete) {
3909   - ret = bdrv_snapshot_delete(bs1, old_sn->id_str);
3910   - if (ret < 0) {
3911   - term_printf("Error while deleting snapshot on '%s'\n",
3912   - bdrv_get_device_name(bs1));
3913   - }
3914   - }
3915   - ret = bdrv_snapshot_create(bs1, sn);
3916   - if (ret < 0) {
3917   - term_printf("Error while creating snapshot on '%s'\n",
3918   - bdrv_get_device_name(bs1));
3919   - }
3920   - }
3921   - }
3922   -
3923   - the_end:
3924   - if (saved_vm_running)
3925   - vm_start();
3926   -}
3927   -
3928   -void do_loadvm(const char *name)
3929   -{
3930   - BlockDriverState *bs, *bs1;
3931   - BlockDriverInfo bdi1, *bdi = &bdi1;
3932   - QEMUFile *f;
3933   - int i, ret;
3934   - int saved_vm_running;
3935   -
3936   - bs = get_bs_snapshots();
3937   - if (!bs) {
3938   - term_printf("No block device supports snapshots\n");
3939   - return;
3940   - }
3941   -
3942   - /* Flush all IO requests so they don't interfere with the new state. */
3943   - qemu_aio_flush();
3944   -
3945   - saved_vm_running = vm_running;
3946   - vm_stop(0);
3947   -
3948   - for(i = 0; i <= nb_drives; i++) {
3949   - bs1 = drives_table[i].bdrv;
3950   - if (bdrv_has_snapshot(bs1)) {
3951   - ret = bdrv_snapshot_goto(bs1, name);
3952   - if (ret < 0) {
3953   - if (bs != bs1)
3954   - term_printf("Warning: ");
3955   - switch(ret) {
3956   - case -ENOTSUP:
3957   - term_printf("Snapshots not supported on device '%s'\n",
3958   - bdrv_get_device_name(bs1));
3959   - break;
3960   - case -ENOENT:
3961   - term_printf("Could not find snapshot '%s' on device '%s'\n",
3962   - name, bdrv_get_device_name(bs1));
3963   - break;
3964   - default:
3965   - term_printf("Error %d while activating snapshot on '%s'\n",
3966   - ret, bdrv_get_device_name(bs1));
3967   - break;
3968   - }
3969   - /* fatal on snapshot block device */
3970   - if (bs == bs1)
3971   - goto the_end;
3972   - }
3973   - }
3974   - }
3975   -
3976   - if (bdrv_get_info(bs, bdi) < 0 || bdi->vm_state_offset <= 0) {
3977   - term_printf("Device %s does not support VM state snapshots\n",
3978   - bdrv_get_device_name(bs));
3979   - return;
3980   - }
3981   -
3982   - /* restore the VM state */
3983   - f = qemu_fopen_bdrv(bs, bdi->vm_state_offset, 0);
3984   - if (!f) {
3985   - term_printf("Could not open VM state file\n");
3986   - goto the_end;
3987   - }
3988   - ret = qemu_loadvm_state(f);
3989   - qemu_fclose(f);
3990   - if (ret < 0) {
3991   - term_printf("Error %d while loading VM state\n", ret);
3992   - }
3993   - the_end:
3994   - if (saved_vm_running)
3995   - vm_start();
3996   -}
3997   -
3998   -void do_delvm(const char *name)
3999   -{
4000   - BlockDriverState *bs, *bs1;
4001   - int i, ret;
4002   -
4003   - bs = get_bs_snapshots();
4004   - if (!bs) {
4005   - term_printf("No block device supports snapshots\n");
4006   - return;
4007   - }
4008   -
4009   - for(i = 0; i <= nb_drives; i++) {
4010   - bs1 = drives_table[i].bdrv;
4011   - if (bdrv_has_snapshot(bs1)) {
4012   - ret = bdrv_snapshot_delete(bs1, name);
4013   - if (ret < 0) {
4014   - if (ret == -ENOTSUP)
4015   - term_printf("Snapshots not supported on device '%s'\n",
4016   - bdrv_get_device_name(bs1));
4017   - else
4018   - term_printf("Error %d while deleting snapshot on '%s'\n",
4019   - ret, bdrv_get_device_name(bs1));
4020   - }
4021   - }
4022   - }
4023   -}
4024   -
4025   -void do_info_snapshots(void)
4026   -{
4027   - BlockDriverState *bs, *bs1;
4028   - QEMUSnapshotInfo *sn_tab, *sn;
4029   - int nb_sns, i;
4030   - char buf[256];
4031   -
4032   - bs = get_bs_snapshots();
4033   - if (!bs) {
4034   - term_printf("No available block device supports snapshots\n");
4035   - return;
4036   - }
4037   - term_printf("Snapshot devices:");
4038   - for(i = 0; i <= nb_drives; i++) {
4039   - bs1 = drives_table[i].bdrv;
4040   - if (bdrv_has_snapshot(bs1)) {
4041   - if (bs == bs1)
4042   - term_printf(" %s", bdrv_get_device_name(bs1));
4043   - }
4044   - }
4045   - term_printf("\n");
4046   -
4047   - nb_sns = bdrv_snapshot_list(bs, &sn_tab);
4048   - if (nb_sns < 0) {
4049   - term_printf("bdrv_snapshot_list: error %d\n", nb_sns);
4050   - return;
4051   - }
4052   - term_printf("Snapshot list (from %s):\n", bdrv_get_device_name(bs));
4053   - term_printf("%s\n", bdrv_snapshot_dump(buf, sizeof(buf), NULL));
4054   - for(i = 0; i < nb_sns; i++) {
4055   - sn = &sn_tab[i];
4056   - term_printf("%s\n", bdrv_snapshot_dump(buf, sizeof(buf), sn));
4057   - }
4058   - qemu_free(sn_tab);
4059   -}
4060   -
4061 2905 /***********************************************************/
4062 2906 /* ram save/restore */
4063 2907  
... ...