2008-11-11 22:33:36 +01:00
|
|
|
/*
|
|
|
|
* QEMU System Emulator
|
|
|
|
*
|
|
|
|
* Copyright (c) 2003-2008 Fabrice Bellard
|
|
|
|
*
|
|
|
|
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
|
|
* of this software and associated documentation files (the "Software"), to deal
|
|
|
|
* in the Software without restriction, including without limitation the rights
|
|
|
|
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
|
|
* copies of the Software, and to permit persons to whom the Software is
|
|
|
|
* furnished to do so, subject to the following conditions:
|
|
|
|
*
|
|
|
|
* The above copyright notice and this permission notice shall be included in
|
|
|
|
* all copies or substantial portions of the Software.
|
|
|
|
*
|
|
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
|
|
|
|
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
|
|
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
|
|
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
|
|
|
* THE SOFTWARE.
|
|
|
|
*/
|
|
|
|
|
2009-03-07 17:52:02 +01:00
|
|
|
#include "config-host.h"
|
2009-03-07 16:32:56 +01:00
|
|
|
#include "qemu-common.h"
|
|
|
|
#include "hw/hw.h"
|
2010-06-25 19:09:14 +02:00
|
|
|
#include "hw/qdev.h"
|
2012-10-24 08:43:34 +02:00
|
|
|
#include "net/net.h"
|
2012-12-17 18:19:49 +01:00
|
|
|
#include "monitor/monitor.h"
|
2012-12-17 18:20:04 +01:00
|
|
|
#include "sysemu/sysemu.h"
|
2012-12-17 18:20:00 +01:00
|
|
|
#include "qemu/timer.h"
|
2009-03-07 16:32:56 +01:00
|
|
|
#include "audio/audio.h"
|
2012-12-17 18:19:50 +01:00
|
|
|
#include "migration/migration.h"
|
2012-12-17 18:20:00 +01:00
|
|
|
#include "qemu/sockets.h"
|
|
|
|
#include "qemu/queue.h"
|
2012-12-17 18:20:04 +01:00
|
|
|
#include "sysemu/cpus.h"
|
2012-12-17 18:19:49 +01:00
|
|
|
#include "exec/memory.h"
|
2012-01-25 13:24:51 +01:00
|
|
|
#include "qmp-commands.h"
|
2012-05-21 23:46:44 +02:00
|
|
|
#include "trace.h"
|
2012-12-17 18:20:00 +01:00
|
|
|
#include "qemu/bitops.h"
|
2013-03-22 15:47:58 +01:00
|
|
|
#include "qemu/iov.h"
|
2013-05-25 05:09:43 +02:00
|
|
|
#include "block/snapshot.h"
|
2013-05-25 05:09:44 +02:00
|
|
|
#include "block/qapi.h"
|
2009-03-07 16:32:56 +01:00
|
|
|
|
2008-11-11 22:33:36 +01:00
|
|
|
#define SELF_ANNOUNCE_ROUNDS 5
|
|
|
|
|
2009-10-16 01:53:55 +02:00
|
|
|
#ifndef ETH_P_RARP
|
2010-04-24 14:54:07 +02:00
|
|
|
#define ETH_P_RARP 0x8035
|
2009-10-16 01:53:55 +02:00
|
|
|
#endif
|
|
|
|
#define ARP_HTYPE_ETH 0x0001
|
|
|
|
#define ARP_PTYPE_IP 0x0800
|
|
|
|
#define ARP_OP_REQUEST_REV 0x3
|
|
|
|
|
|
|
|
static int announce_self_create(uint8_t *buf,
|
2013-11-28 15:01:12 +01:00
|
|
|
uint8_t *mac_addr)
|
2008-11-11 22:33:36 +01:00
|
|
|
{
|
2009-10-16 01:53:55 +02:00
|
|
|
/* Ethernet header. */
|
|
|
|
memset(buf, 0xff, 6); /* destination MAC addr */
|
|
|
|
memcpy(buf + 6, mac_addr, 6); /* source MAC addr */
|
|
|
|
*(uint16_t *)(buf + 12) = htons(ETH_P_RARP); /* ethertype */
|
|
|
|
|
|
|
|
/* RARP header. */
|
|
|
|
*(uint16_t *)(buf + 14) = htons(ARP_HTYPE_ETH); /* hardware addr space */
|
|
|
|
*(uint16_t *)(buf + 16) = htons(ARP_PTYPE_IP); /* protocol addr space */
|
|
|
|
*(buf + 18) = 6; /* hardware addr length (ethernet) */
|
|
|
|
*(buf + 19) = 4; /* protocol addr length (IPv4) */
|
|
|
|
*(uint16_t *)(buf + 20) = htons(ARP_OP_REQUEST_REV); /* opcode */
|
|
|
|
memcpy(buf + 22, mac_addr, 6); /* source hw addr */
|
|
|
|
memset(buf + 28, 0x00, 4); /* source protocol addr */
|
|
|
|
memcpy(buf + 32, mac_addr, 6); /* target hw addr */
|
|
|
|
memset(buf + 38, 0x00, 4); /* target protocol addr */
|
|
|
|
|
|
|
|
/* Padding to get up to 60 bytes (ethernet min packet size, minus FCS). */
|
|
|
|
memset(buf + 42, 0x00, 18);
|
|
|
|
|
|
|
|
return 60; /* len (FCS will be added by hardware) */
|
2008-11-11 22:33:36 +01:00
|
|
|
}
|
|
|
|
|
2009-11-25 19:49:32 +01:00
|
|
|
static void qemu_announce_self_iter(NICState *nic, void *opaque)
|
2008-11-11 22:33:36 +01:00
|
|
|
{
|
2009-10-16 01:53:55 +02:00
|
|
|
uint8_t buf[60];
|
2009-11-25 19:49:32 +01:00
|
|
|
int len;
|
|
|
|
|
|
|
|
len = announce_self_create(buf, nic->conf->macaddr.a);
|
|
|
|
|
2013-01-30 12:12:22 +01:00
|
|
|
qemu_send_packet_raw(qemu_get_queue(nic), buf, len);
|
2009-11-25 19:49:32 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static void qemu_announce_self_once(void *opaque)
|
|
|
|
{
|
2009-05-21 16:17:44 +02:00
|
|
|
static int count = SELF_ANNOUNCE_ROUNDS;
|
|
|
|
QEMUTimer *timer = *(QEMUTimer **)opaque;
|
2008-11-11 22:33:36 +01:00
|
|
|
|
2009-11-25 19:49:32 +01:00
|
|
|
qemu_foreach_nic(qemu_announce_self_iter, NULL);
|
|
|
|
|
2009-10-16 01:53:55 +02:00
|
|
|
if (--count) {
|
|
|
|
/* delay 50ms, 150ms, 250ms, ... */
|
2013-08-21 17:03:08 +02:00
|
|
|
timer_mod(timer, qemu_clock_get_ms(QEMU_CLOCK_REALTIME) +
|
2009-10-16 01:53:55 +02:00
|
|
|
50 + (SELF_ANNOUNCE_ROUNDS - count - 1) * 100);
|
2009-05-21 16:17:44 +02:00
|
|
|
} else {
|
2013-11-28 15:01:12 +01:00
|
|
|
timer_del(timer);
|
|
|
|
timer_free(timer);
|
2009-05-21 16:17:44 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void qemu_announce_self(void)
|
|
|
|
{
|
2013-11-28 15:01:12 +01:00
|
|
|
static QEMUTimer *timer;
|
|
|
|
timer = timer_new_ms(QEMU_CLOCK_REALTIME, qemu_announce_self_once, &timer);
|
|
|
|
qemu_announce_self_once(&timer);
|
2008-11-11 22:33:36 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/***********************************************************/
|
|
|
|
/* savevm/loadvm support */
|
|
|
|
|
|
|
|
#define IO_BUF_SIZE 32768
|
2013-03-22 15:48:00 +01:00
|
|
|
#define MAX_IOV_SIZE MIN(IOV_MAX, 64)
|
2008-11-11 22:33:36 +01:00
|
|
|
|
|
|
|
struct QEMUFile {
|
2012-08-08 10:15:15 +02:00
|
|
|
const QEMUFileOps *ops;
|
2008-11-11 22:33:36 +01:00
|
|
|
void *opaque;
|
|
|
|
|
2013-02-22 17:36:45 +01:00
|
|
|
int64_t bytes_xfer;
|
|
|
|
int64_t xfer_limit;
|
|
|
|
|
2013-02-22 17:36:40 +01:00
|
|
|
int64_t pos; /* start of buffer when writing, end of buffer
|
|
|
|
when reading */
|
2008-11-11 22:33:36 +01:00
|
|
|
int buf_index;
|
|
|
|
int buf_size; /* 0 when writing */
|
|
|
|
uint8_t buf[IO_BUF_SIZE];
|
|
|
|
|
2013-03-22 15:48:00 +01:00
|
|
|
struct iovec iov[MAX_IOV_SIZE];
|
|
|
|
unsigned int iovcnt;
|
|
|
|
|
2011-10-05 01:05:21 +02:00
|
|
|
int last_error;
|
2008-11-11 22:33:36 +01:00
|
|
|
};
|
|
|
|
|
2013-11-28 15:01:13 +01:00
|
|
|
typedef struct QEMUFileStdio {
|
2009-08-12 14:17:35 +02:00
|
|
|
FILE *stdio_file;
|
2008-11-11 22:33:36 +01:00
|
|
|
QEMUFile *file;
|
2009-08-12 14:17:35 +02:00
|
|
|
} QEMUFileStdio;
|
2008-11-11 22:33:36 +01:00
|
|
|
|
2013-11-28 15:01:13 +01:00
|
|
|
typedef struct QEMUFileSocket {
|
2008-11-11 22:33:36 +01:00
|
|
|
int fd;
|
|
|
|
QEMUFile *file;
|
|
|
|
} QEMUFileSocket;
|
|
|
|
|
2013-04-05 21:27:54 +02:00
|
|
|
static ssize_t socket_writev_buffer(void *opaque, struct iovec *iov, int iovcnt,
|
|
|
|
int64_t pos)
|
2013-03-22 15:47:58 +01:00
|
|
|
{
|
|
|
|
QEMUFileSocket *s = opaque;
|
|
|
|
ssize_t len;
|
|
|
|
ssize_t size = iov_size(iov, iovcnt);
|
|
|
|
|
|
|
|
len = iov_send(s->fd, iov, iovcnt, 0, size);
|
|
|
|
if (len < size) {
|
|
|
|
len = -socket_error();
|
|
|
|
}
|
|
|
|
return len;
|
|
|
|
}
|
|
|
|
|
2012-08-08 10:20:18 +02:00
|
|
|
static int socket_get_fd(void *opaque)
|
|
|
|
{
|
|
|
|
QEMUFileSocket *s = opaque;
|
|
|
|
|
|
|
|
return s->fd;
|
|
|
|
}
|
|
|
|
|
2008-11-11 22:33:36 +01:00
|
|
|
static int socket_get_buffer(void *opaque, uint8_t *buf, int64_t pos, int size)
|
|
|
|
{
|
|
|
|
QEMUFileSocket *s = opaque;
|
|
|
|
ssize_t len;
|
|
|
|
|
2012-08-07 11:07:59 +02:00
|
|
|
for (;;) {
|
2011-07-23 22:04:29 +02:00
|
|
|
len = qemu_recv(s->fd, buf, size, 0);
|
2012-08-07 11:07:59 +02:00
|
|
|
if (len != -1) {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (socket_error() == EAGAIN) {
|
2013-02-11 17:01:45 +01:00
|
|
|
yield_until_fd_readable(s->fd);
|
2012-08-07 11:07:59 +02:00
|
|
|
} else if (socket_error() != EINTR) {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2008-11-11 22:33:36 +01:00
|
|
|
|
2012-08-07 11:07:59 +02:00
|
|
|
if (len == -1) {
|
2008-11-11 22:33:36 +01:00
|
|
|
len = -socket_error();
|
2012-08-07 11:07:59 +02:00
|
|
|
}
|
2008-11-11 22:33:36 +01:00
|
|
|
return len;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int socket_close(void *opaque)
|
|
|
|
{
|
|
|
|
QEMUFileSocket *s = opaque;
|
2012-08-07 10:50:26 +02:00
|
|
|
closesocket(s->fd);
|
2011-08-21 05:09:37 +02:00
|
|
|
g_free(s);
|
2008-11-11 22:33:36 +01:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2012-08-08 10:20:18 +02:00
|
|
|
static int stdio_get_fd(void *opaque)
|
|
|
|
{
|
|
|
|
QEMUFileStdio *s = opaque;
|
|
|
|
|
|
|
|
return fileno(s->stdio_file);
|
|
|
|
}
|
|
|
|
|
2013-11-28 15:01:13 +01:00
|
|
|
static int stdio_put_buffer(void *opaque, const uint8_t *buf, int64_t pos,
|
|
|
|
int size)
|
2008-11-11 22:33:36 +01:00
|
|
|
{
|
2009-08-12 14:17:35 +02:00
|
|
|
QEMUFileStdio *s = opaque;
|
|
|
|
return fwrite(buf, 1, size, s->stdio_file);
|
2008-11-11 22:33:36 +01:00
|
|
|
}
|
|
|
|
|
2009-08-12 14:17:35 +02:00
|
|
|
static int stdio_get_buffer(void *opaque, uint8_t *buf, int64_t pos, int size)
|
2008-11-11 22:33:36 +01:00
|
|
|
{
|
2009-08-12 14:17:35 +02:00
|
|
|
QEMUFileStdio *s = opaque;
|
|
|
|
FILE *fp = s->stdio_file;
|
2009-06-08 18:27:21 +02:00
|
|
|
int bytes;
|
|
|
|
|
2012-08-07 11:07:59 +02:00
|
|
|
for (;;) {
|
2009-06-08 18:27:21 +02:00
|
|
|
clearerr(fp);
|
|
|
|
bytes = fread(buf, 1, size, fp);
|
2012-08-07 11:07:59 +02:00
|
|
|
if (bytes != 0 || !ferror(fp)) {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (errno == EAGAIN) {
|
2013-02-11 17:01:45 +01:00
|
|
|
yield_until_fd_readable(fileno(fp));
|
2012-08-07 11:07:59 +02:00
|
|
|
} else if (errno != EINTR) {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2009-06-08 18:27:21 +02:00
|
|
|
return bytes;
|
2008-11-11 22:33:36 +01:00
|
|
|
}
|
|
|
|
|
2009-08-12 14:17:35 +02:00
|
|
|
static int stdio_pclose(void *opaque)
|
|
|
|
{
|
|
|
|
QEMUFileStdio *s = opaque;
|
2010-06-02 21:55:25 +02:00
|
|
|
int ret;
|
|
|
|
ret = pclose(s->stdio_file);
|
2011-11-10 13:41:44 +01:00
|
|
|
if (ret == -1) {
|
|
|
|
ret = -errno;
|
2013-02-22 17:36:38 +01:00
|
|
|
} else if (!WIFEXITED(ret) || WEXITSTATUS(ret) != 0) {
|
|
|
|
/* close succeeded, but non-zero exit code: */
|
|
|
|
ret = -EIO; /* fake errno value */
|
2011-11-10 13:41:44 +01:00
|
|
|
}
|
2011-08-21 05:09:37 +02:00
|
|
|
g_free(s);
|
2010-06-02 21:55:25 +02:00
|
|
|
return ret;
|
2009-08-12 14:17:35 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
static int stdio_fclose(void *opaque)
|
2008-11-11 22:33:36 +01:00
|
|
|
{
|
2009-08-12 14:17:35 +02:00
|
|
|
QEMUFileStdio *s = opaque;
|
2011-11-10 13:41:45 +01:00
|
|
|
int ret = 0;
|
2013-02-22 17:36:37 +01:00
|
|
|
|
2013-03-22 15:48:01 +01:00
|
|
|
if (s->file->ops->put_buffer || s->file->ops->writev_buffer) {
|
2013-02-22 17:36:37 +01:00
|
|
|
int fd = fileno(s->stdio_file);
|
|
|
|
struct stat st;
|
|
|
|
|
|
|
|
ret = fstat(fd, &st);
|
|
|
|
if (ret == 0 && S_ISREG(st.st_mode)) {
|
|
|
|
/*
|
|
|
|
* If the file handle is a regular file make sure the
|
|
|
|
* data is flushed to disk before signaling success.
|
|
|
|
*/
|
|
|
|
ret = fsync(fd);
|
|
|
|
if (ret != 0) {
|
|
|
|
ret = -errno;
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2011-11-10 13:41:45 +01:00
|
|
|
if (fclose(s->stdio_file) == EOF) {
|
|
|
|
ret = -errno;
|
|
|
|
}
|
2011-08-21 05:09:37 +02:00
|
|
|
g_free(s);
|
2011-11-10 13:41:45 +01:00
|
|
|
return ret;
|
2008-11-11 22:33:36 +01:00
|
|
|
}
|
|
|
|
|
2012-08-08 10:15:15 +02:00
|
|
|
static const QEMUFileOps stdio_pipe_read_ops = {
|
2012-08-08 10:20:18 +02:00
|
|
|
.get_fd = stdio_get_fd,
|
2012-08-08 10:15:15 +02:00
|
|
|
.get_buffer = stdio_get_buffer,
|
|
|
|
.close = stdio_pclose
|
|
|
|
};
|
|
|
|
|
|
|
|
static const QEMUFileOps stdio_pipe_write_ops = {
|
2012-08-08 10:20:18 +02:00
|
|
|
.get_fd = stdio_get_fd,
|
2012-08-08 10:15:15 +02:00
|
|
|
.put_buffer = stdio_put_buffer,
|
|
|
|
.close = stdio_pclose
|
|
|
|
};
|
|
|
|
|
2013-02-22 17:36:36 +01:00
|
|
|
QEMUFile *qemu_popen_cmd(const char *command, const char *mode)
|
2008-11-11 22:33:36 +01:00
|
|
|
{
|
2013-02-22 17:36:36 +01:00
|
|
|
FILE *stdio_file;
|
2009-08-12 14:17:35 +02:00
|
|
|
QEMUFileStdio *s;
|
2008-11-11 22:33:36 +01:00
|
|
|
|
2013-05-31 14:00:27 +02:00
|
|
|
if (mode == NULL || (mode[0] != 'r' && mode[0] != 'w') || mode[1] != 0) {
|
|
|
|
fprintf(stderr, "qemu_popen: Argument validity check failed\n");
|
2013-02-22 17:36:36 +01:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2013-05-31 14:00:27 +02:00
|
|
|
stdio_file = popen(command, mode);
|
|
|
|
if (stdio_file == NULL) {
|
2008-11-11 22:33:36 +01:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2011-08-21 05:09:37 +02:00
|
|
|
s = g_malloc0(sizeof(QEMUFileStdio));
|
2008-11-11 22:33:36 +01:00
|
|
|
|
2009-08-12 14:17:35 +02:00
|
|
|
s->stdio_file = stdio_file;
|
2008-11-11 22:33:36 +01:00
|
|
|
|
2013-11-28 15:01:13 +01:00
|
|
|
if (mode[0] == 'r') {
|
2012-08-08 10:15:15 +02:00
|
|
|
s->file = qemu_fopen_ops(s, &stdio_pipe_read_ops);
|
2008-11-11 22:33:36 +01:00
|
|
|
} else {
|
2012-08-08 10:15:15 +02:00
|
|
|
s->file = qemu_fopen_ops(s, &stdio_pipe_write_ops);
|
2008-11-11 22:33:36 +01:00
|
|
|
}
|
|
|
|
return s->file;
|
|
|
|
}
|
|
|
|
|
2012-08-08 10:15:15 +02:00
|
|
|
static const QEMUFileOps stdio_file_read_ops = {
|
2012-08-08 10:20:18 +02:00
|
|
|
.get_fd = stdio_get_fd,
|
2012-08-08 10:15:15 +02:00
|
|
|
.get_buffer = stdio_get_buffer,
|
|
|
|
.close = stdio_fclose
|
|
|
|
};
|
|
|
|
|
|
|
|
static const QEMUFileOps stdio_file_write_ops = {
|
2012-08-08 10:20:18 +02:00
|
|
|
.get_fd = stdio_get_fd,
|
2012-08-08 10:15:15 +02:00
|
|
|
.put_buffer = stdio_put_buffer,
|
|
|
|
.close = stdio_fclose
|
|
|
|
};
|
|
|
|
|
2013-03-27 17:36:32 +01:00
|
|
|
static ssize_t unix_writev_buffer(void *opaque, struct iovec *iov, int iovcnt,
|
|
|
|
int64_t pos)
|
|
|
|
{
|
|
|
|
QEMUFileSocket *s = opaque;
|
|
|
|
ssize_t len, offset;
|
|
|
|
ssize_t size = iov_size(iov, iovcnt);
|
|
|
|
ssize_t total = 0;
|
|
|
|
|
|
|
|
assert(iovcnt > 0);
|
|
|
|
offset = 0;
|
|
|
|
while (size > 0) {
|
|
|
|
/* Find the next start position; skip all full-sized vector elements */
|
|
|
|
while (offset >= iov[0].iov_len) {
|
|
|
|
offset -= iov[0].iov_len;
|
|
|
|
iov++, iovcnt--;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* skip `offset' bytes from the (now) first element, undo it on exit */
|
|
|
|
assert(iovcnt > 0);
|
|
|
|
iov[0].iov_base += offset;
|
|
|
|
iov[0].iov_len -= offset;
|
|
|
|
|
|
|
|
do {
|
|
|
|
len = writev(s->fd, iov, iovcnt);
|
|
|
|
} while (len == -1 && errno == EINTR);
|
|
|
|
if (len == -1) {
|
|
|
|
return -errno;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Undo the changes above */
|
|
|
|
iov[0].iov_base -= offset;
|
|
|
|
iov[0].iov_len += offset;
|
|
|
|
|
|
|
|
/* Prepare for the next iteration */
|
|
|
|
offset += len;
|
|
|
|
total += len;
|
|
|
|
size -= len;
|
|
|
|
}
|
|
|
|
|
|
|
|
return total;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int unix_get_buffer(void *opaque, uint8_t *buf, int64_t pos, int size)
|
|
|
|
{
|
|
|
|
QEMUFileSocket *s = opaque;
|
|
|
|
ssize_t len;
|
|
|
|
|
|
|
|
for (;;) {
|
|
|
|
len = read(s->fd, buf, size);
|
|
|
|
if (len != -1) {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (errno == EAGAIN) {
|
|
|
|
yield_until_fd_readable(s->fd);
|
|
|
|
} else if (errno != EINTR) {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (len == -1) {
|
|
|
|
len = -errno;
|
|
|
|
}
|
|
|
|
return len;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int unix_close(void *opaque)
|
|
|
|
{
|
|
|
|
QEMUFileSocket *s = opaque;
|
|
|
|
close(s->fd);
|
|
|
|
g_free(s);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static const QEMUFileOps unix_read_ops = {
|
|
|
|
.get_fd = socket_get_fd,
|
|
|
|
.get_buffer = unix_get_buffer,
|
|
|
|
.close = unix_close
|
|
|
|
};
|
|
|
|
|
|
|
|
static const QEMUFileOps unix_write_ops = {
|
|
|
|
.get_fd = socket_get_fd,
|
|
|
|
.writev_buffer = unix_writev_buffer,
|
|
|
|
.close = unix_close
|
|
|
|
};
|
|
|
|
|
2009-08-18 15:56:25 +02:00
|
|
|
QEMUFile *qemu_fdopen(int fd, const char *mode)
|
|
|
|
{
|
2013-03-27 17:36:32 +01:00
|
|
|
QEMUFileSocket *s;
|
2009-08-18 15:56:25 +02:00
|
|
|
|
|
|
|
if (mode == NULL ||
|
2013-11-28 15:01:12 +01:00
|
|
|
(mode[0] != 'r' && mode[0] != 'w') ||
|
|
|
|
mode[1] != 'b' || mode[2] != 0) {
|
2009-08-18 15:56:25 +02:00
|
|
|
fprintf(stderr, "qemu_fdopen: Argument validity check failed\n");
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2013-03-27 17:36:32 +01:00
|
|
|
s = g_malloc0(sizeof(QEMUFileSocket));
|
|
|
|
s->fd = fd;
|
2009-08-18 15:56:25 +02:00
|
|
|
|
2013-11-28 15:01:13 +01:00
|
|
|
if (mode[0] == 'r') {
|
2013-03-27 17:36:32 +01:00
|
|
|
s->file = qemu_fopen_ops(s, &unix_read_ops);
|
2009-08-18 15:56:25 +02:00
|
|
|
} else {
|
2013-03-27 17:36:32 +01:00
|
|
|
s->file = qemu_fopen_ops(s, &unix_write_ops);
|
2009-08-18 15:56:25 +02:00
|
|
|
}
|
|
|
|
return s->file;
|
|
|
|
}
|
|
|
|
|
2012-08-08 10:15:15 +02:00
|
|
|
static const QEMUFileOps socket_read_ops = {
|
2012-08-08 10:20:18 +02:00
|
|
|
.get_fd = socket_get_fd,
|
2012-08-08 10:15:15 +02:00
|
|
|
.get_buffer = socket_get_buffer,
|
|
|
|
.close = socket_close
|
|
|
|
};
|
|
|
|
|
2013-02-22 17:36:39 +01:00
|
|
|
static const QEMUFileOps socket_write_ops = {
|
|
|
|
.get_fd = socket_get_fd,
|
2013-03-22 15:47:58 +01:00
|
|
|
.writev_buffer = socket_writev_buffer,
|
2013-02-22 17:36:39 +01:00
|
|
|
.close = socket_close
|
|
|
|
};
|
|
|
|
|
2013-06-26 03:35:31 +02:00
|
|
|
bool qemu_file_mode_is_not_valid(const char *mode)
|
2008-11-11 22:33:36 +01:00
|
|
|
{
|
2013-02-22 17:36:39 +01:00
|
|
|
if (mode == NULL ||
|
|
|
|
(mode[0] != 'r' && mode[0] != 'w') ||
|
|
|
|
mode[1] != 'b' || mode[2] != 0) {
|
|
|
|
fprintf(stderr, "qemu_fopen: Argument validity check failed\n");
|
2013-06-26 03:35:31 +02:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
QEMUFile *qemu_fopen_socket(int fd, const char *mode)
|
|
|
|
{
|
|
|
|
QEMUFileSocket *s;
|
|
|
|
|
|
|
|
if (qemu_file_mode_is_not_valid(mode)) {
|
2013-02-22 17:36:39 +01:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2013-06-16 13:33:05 +02:00
|
|
|
s = g_malloc0(sizeof(QEMUFileSocket));
|
2008-11-11 22:33:36 +01:00
|
|
|
s->fd = fd;
|
2013-02-22 17:36:39 +01:00
|
|
|
if (mode[0] == 'w') {
|
2013-03-27 10:10:43 +01:00
|
|
|
qemu_set_block(s->fd);
|
2013-02-22 17:36:39 +01:00
|
|
|
s->file = qemu_fopen_ops(s, &socket_write_ops);
|
|
|
|
} else {
|
|
|
|
s->file = qemu_fopen_ops(s, &socket_read_ops);
|
|
|
|
}
|
2008-11-11 22:33:36 +01:00
|
|
|
return s->file;
|
|
|
|
}
|
|
|
|
|
|
|
|
QEMUFile *qemu_fopen(const char *filename, const char *mode)
|
|
|
|
{
|
|
|
|
QEMUFileStdio *s;
|
|
|
|
|
2013-06-26 03:35:31 +02:00
|
|
|
if (qemu_file_mode_is_not_valid(mode)) {
|
2009-08-12 14:17:35 +02:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2011-08-21 05:09:37 +02:00
|
|
|
s = g_malloc0(sizeof(QEMUFileStdio));
|
2008-11-11 22:33:36 +01:00
|
|
|
|
2009-08-12 14:17:35 +02:00
|
|
|
s->stdio_file = fopen(filename, mode);
|
2013-11-28 15:01:13 +01:00
|
|
|
if (!s->stdio_file) {
|
2008-11-11 22:33:36 +01:00
|
|
|
goto fail;
|
2013-11-28 15:01:13 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
if (mode[0] == 'w') {
|
2012-08-08 10:15:15 +02:00
|
|
|
s->file = qemu_fopen_ops(s, &stdio_file_write_ops);
|
2009-08-12 14:17:35 +02:00
|
|
|
} else {
|
2012-08-08 10:15:15 +02:00
|
|
|
s->file = qemu_fopen_ops(s, &stdio_file_read_ops);
|
2009-08-12 14:17:35 +02:00
|
|
|
}
|
|
|
|
return s->file;
|
2008-11-11 22:33:36 +01:00
|
|
|
fail:
|
2011-08-21 05:09:37 +02:00
|
|
|
g_free(s);
|
2008-11-11 22:33:36 +01:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2013-04-05 21:27:54 +02:00
|
|
|
static ssize_t block_writev_buffer(void *opaque, struct iovec *iov, int iovcnt,
|
|
|
|
int64_t pos)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
QEMUIOVector qiov;
|
|
|
|
|
|
|
|
qemu_iovec_init_external(&qiov, iov, iovcnt);
|
|
|
|
ret = bdrv_writev_vmstate(opaque, &qiov, pos);
|
|
|
|
if (ret < 0) {
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
return qiov.size;
|
|
|
|
}
|
|
|
|
|
2009-04-05 21:10:55 +02:00
|
|
|
static int block_put_buffer(void *opaque, const uint8_t *buf,
|
2008-11-11 22:33:36 +01:00
|
|
|
int64_t pos, int size)
|
|
|
|
{
|
2009-07-10 23:11:57 +02:00
|
|
|
bdrv_save_vmstate(opaque, buf, pos, size);
|
2008-11-11 22:33:36 +01:00
|
|
|
return size;
|
|
|
|
}
|
|
|
|
|
2009-04-05 21:10:55 +02:00
|
|
|
static int block_get_buffer(void *opaque, uint8_t *buf, int64_t pos, int size)
|
2008-11-11 22:33:36 +01:00
|
|
|
{
|
2009-07-10 23:11:57 +02:00
|
|
|
return bdrv_load_vmstate(opaque, buf, pos, size);
|
2008-11-11 22:33:36 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
static int bdrv_fclose(void *opaque)
|
|
|
|
{
|
2012-06-06 00:04:50 +02:00
|
|
|
return bdrv_flush(opaque);
|
2008-11-11 22:33:36 +01:00
|
|
|
}
|
|
|
|
|
2012-08-08 10:15:15 +02:00
|
|
|
static const QEMUFileOps bdrv_read_ops = {
|
|
|
|
.get_buffer = block_get_buffer,
|
|
|
|
.close = bdrv_fclose
|
|
|
|
};
|
|
|
|
|
|
|
|
static const QEMUFileOps bdrv_write_ops = {
|
2013-04-05 21:27:54 +02:00
|
|
|
.put_buffer = block_put_buffer,
|
|
|
|
.writev_buffer = block_writev_buffer,
|
|
|
|
.close = bdrv_fclose
|
2012-08-08 10:15:15 +02:00
|
|
|
};
|
|
|
|
|
2009-07-10 23:11:57 +02:00
|
|
|
static QEMUFile *qemu_fopen_bdrv(BlockDriverState *bs, int is_writable)
|
2008-11-11 22:33:36 +01:00
|
|
|
{
|
2013-11-28 15:01:13 +01:00
|
|
|
if (is_writable) {
|
2012-08-08 10:15:15 +02:00
|
|
|
return qemu_fopen_ops(bs, &bdrv_write_ops);
|
2013-11-28 15:01:13 +01:00
|
|
|
}
|
2012-08-08 10:15:15 +02:00
|
|
|
return qemu_fopen_ops(bs, &bdrv_read_ops);
|
2008-11-11 22:33:36 +01:00
|
|
|
}
|
|
|
|
|
2012-08-08 10:15:15 +02:00
|
|
|
QEMUFile *qemu_fopen_ops(void *opaque, const QEMUFileOps *ops)
|
2008-11-11 22:33:36 +01:00
|
|
|
{
|
|
|
|
QEMUFile *f;
|
|
|
|
|
2011-08-21 05:09:37 +02:00
|
|
|
f = g_malloc0(sizeof(QEMUFile));
|
2008-11-11 22:33:36 +01:00
|
|
|
|
|
|
|
f->opaque = opaque;
|
2012-08-08 10:15:15 +02:00
|
|
|
f->ops = ops;
|
2008-11-11 22:33:36 +01:00
|
|
|
return f;
|
|
|
|
}
|
|
|
|
|
2013-09-04 11:02:34 +02:00
|
|
|
/*
|
|
|
|
* Get last error for stream f
|
|
|
|
*
|
|
|
|
* Return negative error value if there has been an error on previous
|
|
|
|
* operations, return 0 if no error happened.
|
|
|
|
*
|
|
|
|
*/
|
2011-10-05 01:02:52 +02:00
|
|
|
int qemu_file_get_error(QEMUFile *f)
|
2008-11-11 22:33:36 +01:00
|
|
|
{
|
2011-10-05 01:05:21 +02:00
|
|
|
return f->last_error;
|
2008-11-11 22:33:36 +01:00
|
|
|
}
|
|
|
|
|
2013-11-28 15:01:10 +01:00
|
|
|
void qemu_file_set_error(QEMUFile *f, int ret)
|
2009-04-05 21:30:51 +02:00
|
|
|
{
|
2013-01-14 13:36:28 +01:00
|
|
|
if (f->last_error == 0) {
|
|
|
|
f->last_error = ret;
|
|
|
|
}
|
2009-04-05 21:30:51 +02:00
|
|
|
}
|
|
|
|
|
2013-04-08 13:29:56 +02:00
|
|
|
static inline bool qemu_file_is_writable(QEMUFile *f)
|
|
|
|
{
|
|
|
|
return f->ops->writev_buffer || f->ops->put_buffer;
|
|
|
|
}
|
|
|
|
|
2013-03-22 15:48:01 +01:00
|
|
|
/**
|
|
|
|
* Flushes QEMUFile buffer
|
2011-11-10 13:41:43 +01:00
|
|
|
*
|
2013-03-22 15:48:01 +01:00
|
|
|
* If there is writev_buffer QEMUFileOps it uses it otherwise uses
|
|
|
|
* put_buffer ops.
|
2011-11-10 13:41:43 +01:00
|
|
|
*/
|
2013-06-26 03:35:32 +02:00
|
|
|
void qemu_fflush(QEMUFile *f)
|
2008-11-11 22:33:36 +01:00
|
|
|
{
|
2013-03-22 15:48:01 +01:00
|
|
|
ssize_t ret = 0;
|
2012-08-29 19:08:59 +02:00
|
|
|
|
2013-04-08 13:29:56 +02:00
|
|
|
if (!qemu_file_is_writable(f)) {
|
2013-02-22 17:36:12 +01:00
|
|
|
return;
|
|
|
|
}
|
2013-03-22 15:48:01 +01:00
|
|
|
|
2013-04-08 13:29:56 +02:00
|
|
|
if (f->ops->writev_buffer) {
|
|
|
|
if (f->iovcnt > 0) {
|
2013-04-05 21:27:54 +02:00
|
|
|
ret = f->ops->writev_buffer(f->opaque, f->iov, f->iovcnt, f->pos);
|
2012-08-29 19:08:59 +02:00
|
|
|
}
|
2013-04-08 13:29:56 +02:00
|
|
|
} else {
|
|
|
|
if (f->buf_index > 0) {
|
|
|
|
ret = f->ops->put_buffer(f->opaque, f->buf, f->pos, f->buf_index);
|
2013-04-08 13:29:55 +02:00
|
|
|
}
|
2008-11-11 22:33:36 +01:00
|
|
|
}
|
2013-04-08 13:29:56 +02:00
|
|
|
if (ret >= 0) {
|
|
|
|
f->pos += ret;
|
|
|
|
}
|
|
|
|
f->buf_index = 0;
|
|
|
|
f->iovcnt = 0;
|
2013-02-22 17:36:12 +01:00
|
|
|
if (ret < 0) {
|
|
|
|
qemu_file_set_error(f, ret);
|
|
|
|
}
|
2008-11-11 22:33:36 +01:00
|
|
|
}
|
|
|
|
|
2013-06-26 03:35:35 +02:00
|
|
|
void ram_control_before_iterate(QEMUFile *f, uint64_t flags)
|
|
|
|
{
|
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
if (f->ops->before_ram_iterate) {
|
|
|
|
ret = f->ops->before_ram_iterate(f, f->opaque, flags);
|
|
|
|
if (ret < 0) {
|
|
|
|
qemu_file_set_error(f, ret);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void ram_control_after_iterate(QEMUFile *f, uint64_t flags)
|
|
|
|
{
|
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
if (f->ops->after_ram_iterate) {
|
|
|
|
ret = f->ops->after_ram_iterate(f, f->opaque, flags);
|
|
|
|
if (ret < 0) {
|
|
|
|
qemu_file_set_error(f, ret);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void ram_control_load_hook(QEMUFile *f, uint64_t flags)
|
|
|
|
{
|
2013-09-04 11:02:35 +02:00
|
|
|
int ret = -EINVAL;
|
2013-06-26 03:35:35 +02:00
|
|
|
|
|
|
|
if (f->ops->hook_ram_load) {
|
|
|
|
ret = f->ops->hook_ram_load(f, f->opaque, flags);
|
|
|
|
if (ret < 0) {
|
|
|
|
qemu_file_set_error(f, ret);
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
qemu_file_set_error(f, ret);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
size_t ram_control_save_page(QEMUFile *f, ram_addr_t block_offset,
|
|
|
|
ram_addr_t offset, size_t size, int *bytes_sent)
|
|
|
|
{
|
|
|
|
if (f->ops->save_page) {
|
|
|
|
int ret = f->ops->save_page(f, f->opaque, block_offset,
|
|
|
|
offset, size, bytes_sent);
|
|
|
|
|
|
|
|
if (ret != RAM_SAVE_CONTROL_DELAYED) {
|
2013-07-22 16:01:52 +02:00
|
|
|
if (bytes_sent && *bytes_sent > 0) {
|
2013-06-26 03:35:35 +02:00
|
|
|
qemu_update_position(f, *bytes_sent);
|
|
|
|
} else if (ret < 0) {
|
|
|
|
qemu_file_set_error(f, ret);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
return RAM_SAVE_CONTROL_NOT_SUPP;
|
|
|
|
}
|
|
|
|
|
2008-11-11 22:33:36 +01:00
|
|
|
static void qemu_fill_buffer(QEMUFile *f)
|
|
|
|
{
|
|
|
|
int len;
|
2011-09-30 19:28:45 +02:00
|
|
|
int pending;
|
2008-11-11 22:33:36 +01:00
|
|
|
|
2013-04-08 13:29:56 +02:00
|
|
|
assert(!qemu_file_is_writable(f));
|
2008-11-11 22:33:36 +01:00
|
|
|
|
2011-09-30 19:28:45 +02:00
|
|
|
pending = f->buf_size - f->buf_index;
|
|
|
|
if (pending > 0) {
|
|
|
|
memmove(f->buf, f->buf + f->buf_index, pending);
|
|
|
|
}
|
|
|
|
f->buf_index = 0;
|
|
|
|
f->buf_size = pending;
|
|
|
|
|
2013-02-22 17:36:40 +01:00
|
|
|
len = f->ops->get_buffer(f->opaque, f->buf + pending, f->pos,
|
2011-09-30 19:28:45 +02:00
|
|
|
IO_BUF_SIZE - pending);
|
2008-11-11 22:33:36 +01:00
|
|
|
if (len > 0) {
|
2011-09-30 19:28:45 +02:00
|
|
|
f->buf_size += len;
|
2013-02-22 17:36:40 +01:00
|
|
|
f->pos += len;
|
2011-10-25 19:18:58 +02:00
|
|
|
} else if (len == 0) {
|
2012-08-29 19:36:26 +02:00
|
|
|
qemu_file_set_error(f, -EIO);
|
2013-11-28 15:01:13 +01:00
|
|
|
} else if (len != -EAGAIN) {
|
2011-11-10 13:41:39 +01:00
|
|
|
qemu_file_set_error(f, len);
|
2013-11-28 15:01:13 +01:00
|
|
|
}
|
2008-11-11 22:33:36 +01:00
|
|
|
}
|
|
|
|
|
2012-08-08 10:20:18 +02:00
|
|
|
int qemu_get_fd(QEMUFile *f)
|
|
|
|
{
|
|
|
|
if (f->ops->get_fd) {
|
|
|
|
return f->ops->get_fd(f->opaque);
|
|
|
|
}
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2013-06-26 03:35:28 +02:00
|
|
|
void qemu_update_position(QEMUFile *f, size_t size)
|
|
|
|
{
|
|
|
|
f->pos += size;
|
|
|
|
}
|
|
|
|
|
2011-11-10 13:41:43 +01:00
|
|
|
/** Closes the file
|
|
|
|
*
|
|
|
|
* Returns negative error value if any error happened on previous operations or
|
|
|
|
* while closing the file. Returns 0 or positive number on success.
|
|
|
|
*
|
|
|
|
* The meaning of return value on success depends on the specific backend
|
|
|
|
* being used.
|
|
|
|
*/
|
|
|
|
int qemu_fclose(QEMUFile *f)
|
|
|
|
{
|
2012-08-29 19:14:54 +02:00
|
|
|
int ret;
|
2013-02-22 17:36:12 +01:00
|
|
|
qemu_fflush(f);
|
|
|
|
ret = qemu_file_get_error(f);
|
2012-08-29 19:08:59 +02:00
|
|
|
|
2012-08-08 10:15:15 +02:00
|
|
|
if (f->ops->close) {
|
|
|
|
int ret2 = f->ops->close(f->opaque);
|
2012-08-29 19:14:54 +02:00
|
|
|
if (ret >= 0) {
|
|
|
|
ret = ret2;
|
|
|
|
}
|
2012-08-29 19:08:59 +02:00
|
|
|
}
|
2011-11-10 13:41:43 +01:00
|
|
|
/* If any error was spotted before closing, we should report it
|
|
|
|
* instead of the close() return value.
|
|
|
|
*/
|
|
|
|
if (f->last_error) {
|
|
|
|
ret = f->last_error;
|
|
|
|
}
|
2011-08-21 05:09:37 +02:00
|
|
|
g_free(f);
|
2008-11-11 22:33:36 +01:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2013-03-22 15:48:00 +01:00
|
|
|
static void add_to_iovec(QEMUFile *f, const uint8_t *buf, int size)
|
|
|
|
{
|
|
|
|
/* check for adjacent buffer and coalesce them */
|
|
|
|
if (f->iovcnt > 0 && buf == f->iov[f->iovcnt - 1].iov_base +
|
|
|
|
f->iov[f->iovcnt - 1].iov_len) {
|
|
|
|
f->iov[f->iovcnt - 1].iov_len += size;
|
|
|
|
} else {
|
|
|
|
f->iov[f->iovcnt].iov_base = (uint8_t *)buf;
|
|
|
|
f->iov[f->iovcnt++].iov_len = size;
|
|
|
|
}
|
2013-04-08 13:29:54 +02:00
|
|
|
|
2013-04-08 13:29:57 +02:00
|
|
|
if (f->iovcnt >= MAX_IOV_SIZE) {
|
2013-04-08 13:29:54 +02:00
|
|
|
qemu_fflush(f);
|
|
|
|
}
|
2013-03-22 15:48:00 +01:00
|
|
|
}
|
|
|
|
|
2013-03-22 15:48:02 +01:00
|
|
|
void qemu_put_buffer_async(QEMUFile *f, const uint8_t *buf, int size)
|
|
|
|
{
|
2013-04-08 13:29:55 +02:00
|
|
|
if (!f->ops->writev_buffer) {
|
|
|
|
qemu_put_buffer(f, buf, size);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2013-03-22 15:48:02 +01:00
|
|
|
if (f->last_error) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
f->bytes_xfer += size;
|
2013-04-08 13:29:54 +02:00
|
|
|
add_to_iovec(f, buf, size);
|
2013-03-22 15:48:02 +01:00
|
|
|
}
|
|
|
|
|
2008-11-11 22:33:36 +01:00
|
|
|
void qemu_put_buffer(QEMUFile *f, const uint8_t *buf, int size)
|
|
|
|
{
|
|
|
|
int l;
|
|
|
|
|
2012-08-29 19:43:39 +02:00
|
|
|
if (f->last_error) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
while (size > 0) {
|
2008-11-11 22:33:36 +01:00
|
|
|
l = IO_BUF_SIZE - f->buf_index;
|
2013-11-28 15:01:13 +01:00
|
|
|
if (l > size) {
|
2008-11-11 22:33:36 +01:00
|
|
|
l = size;
|
2013-11-28 15:01:13 +01:00
|
|
|
}
|
2008-11-11 22:33:36 +01:00
|
|
|
memcpy(f->buf + f->buf_index, buf, l);
|
2013-11-19 06:53:45 +01:00
|
|
|
f->bytes_xfer += l;
|
2013-04-08 13:29:55 +02:00
|
|
|
if (f->ops->writev_buffer) {
|
|
|
|
add_to_iovec(f, f->buf + f->buf_index, l);
|
2013-04-08 13:29:57 +02:00
|
|
|
}
|
|
|
|
f->buf_index += l;
|
|
|
|
if (f->buf_index == IO_BUF_SIZE) {
|
|
|
|
qemu_fflush(f);
|
2013-04-08 13:29:55 +02:00
|
|
|
}
|
2013-03-22 15:48:02 +01:00
|
|
|
if (qemu_file_get_error(f)) {
|
|
|
|
break;
|
|
|
|
}
|
2008-11-11 22:33:36 +01:00
|
|
|
buf += l;
|
|
|
|
size -= l;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void qemu_put_byte(QEMUFile *f, int v)
|
|
|
|
{
|
2012-08-29 19:43:39 +02:00
|
|
|
if (f->last_error) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2013-04-08 13:29:54 +02:00
|
|
|
f->buf[f->buf_index] = v;
|
2013-03-22 15:47:59 +01:00
|
|
|
f->bytes_xfer++;
|
2013-04-08 13:29:55 +02:00
|
|
|
if (f->ops->writev_buffer) {
|
|
|
|
add_to_iovec(f, f->buf + f->buf_index, 1);
|
2013-04-08 13:29:57 +02:00
|
|
|
}
|
|
|
|
f->buf_index++;
|
|
|
|
if (f->buf_index == IO_BUF_SIZE) {
|
|
|
|
qemu_fflush(f);
|
2013-04-08 13:29:55 +02:00
|
|
|
}
|
2008-11-11 22:33:36 +01:00
|
|
|
}
|
|
|
|
|
2013-11-28 15:01:10 +01:00
|
|
|
void qemu_file_skip(QEMUFile *f, int size)
|
2008-11-11 22:33:36 +01:00
|
|
|
{
|
2011-10-04 15:28:31 +02:00
|
|
|
if (f->buf_index + size <= f->buf_size) {
|
|
|
|
f->buf_index += size;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-11-28 15:01:10 +01:00
|
|
|
int qemu_peek_buffer(QEMUFile *f, uint8_t *buf, int size, size_t offset)
|
2008-11-11 22:33:36 +01:00
|
|
|
{
|
2011-10-04 15:28:31 +02:00
|
|
|
int pending;
|
|
|
|
int index;
|
2008-11-11 22:33:36 +01:00
|
|
|
|
2013-04-08 13:29:56 +02:00
|
|
|
assert(!qemu_file_is_writable(f));
|
2008-11-11 22:33:36 +01:00
|
|
|
|
2011-10-04 15:28:31 +02:00
|
|
|
index = f->buf_index + offset;
|
|
|
|
pending = f->buf_size - index;
|
|
|
|
if (pending < size) {
|
|
|
|
qemu_fill_buffer(f);
|
|
|
|
index = f->buf_index + offset;
|
|
|
|
pending = f->buf_size - index;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (pending <= 0) {
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
if (size > pending) {
|
|
|
|
size = pending;
|
|
|
|
}
|
|
|
|
|
|
|
|
memcpy(buf, f->buf + index, size);
|
|
|
|
return size;
|
|
|
|
}
|
|
|
|
|
|
|
|
int qemu_get_buffer(QEMUFile *f, uint8_t *buf, int size)
|
|
|
|
{
|
|
|
|
int pending = size;
|
|
|
|
int done = 0;
|
|
|
|
|
|
|
|
while (pending > 0) {
|
|
|
|
int res;
|
|
|
|
|
|
|
|
res = qemu_peek_buffer(f, buf, pending, 0);
|
|
|
|
if (res == 0) {
|
|
|
|
return done;
|
2008-11-11 22:33:36 +01:00
|
|
|
}
|
2011-10-04 15:28:31 +02:00
|
|
|
qemu_file_skip(f, res);
|
|
|
|
buf += res;
|
|
|
|
pending -= res;
|
|
|
|
done += res;
|
2008-11-11 22:33:36 +01:00
|
|
|
}
|
2011-10-04 15:28:31 +02:00
|
|
|
return done;
|
2008-11-11 22:33:36 +01:00
|
|
|
}
|
|
|
|
|
2013-11-28 15:01:10 +01:00
|
|
|
int qemu_peek_byte(QEMUFile *f, int offset)
|
2010-07-26 21:38:43 +02:00
|
|
|
{
|
2011-10-04 15:28:31 +02:00
|
|
|
int index = f->buf_index + offset;
|
|
|
|
|
2013-04-08 13:29:56 +02:00
|
|
|
assert(!qemu_file_is_writable(f));
|
2010-07-26 21:38:43 +02:00
|
|
|
|
2011-10-04 15:28:31 +02:00
|
|
|
if (index >= f->buf_size) {
|
2010-07-26 21:38:43 +02:00
|
|
|
qemu_fill_buffer(f);
|
2011-10-04 15:28:31 +02:00
|
|
|
index = f->buf_index + offset;
|
|
|
|
if (index >= f->buf_size) {
|
2010-07-26 21:38:43 +02:00
|
|
|
return 0;
|
2011-10-04 13:55:32 +02:00
|
|
|
}
|
2010-07-26 21:38:43 +02:00
|
|
|
}
|
2011-10-04 15:28:31 +02:00
|
|
|
return f->buf[index];
|
2010-07-26 21:38:43 +02:00
|
|
|
}
|
|
|
|
|
2008-11-11 22:33:36 +01:00
|
|
|
int qemu_get_byte(QEMUFile *f)
|
|
|
|
{
|
2011-10-06 14:29:32 +02:00
|
|
|
int result;
|
2008-11-11 22:33:36 +01:00
|
|
|
|
2011-10-04 15:28:31 +02:00
|
|
|
result = qemu_peek_byte(f, 0);
|
|
|
|
qemu_file_skip(f, 1);
|
2011-10-06 14:29:32 +02:00
|
|
|
return result;
|
2008-11-11 22:33:36 +01:00
|
|
|
}
|
|
|
|
|
2013-02-12 10:37:14 +01:00
|
|
|
int64_t qemu_ftell(QEMUFile *f)
|
2008-11-11 22:33:36 +01:00
|
|
|
{
|
2013-02-22 17:36:40 +01:00
|
|
|
qemu_fflush(f);
|
|
|
|
return f->pos;
|
2008-11-11 22:33:36 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
int qemu_file_rate_limit(QEMUFile *f)
|
|
|
|
{
|
2013-02-22 17:36:45 +01:00
|
|
|
if (qemu_file_get_error(f)) {
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
if (f->xfer_limit > 0 && f->bytes_xfer > f->xfer_limit) {
|
|
|
|
return 1;
|
|
|
|
}
|
2008-11-11 22:33:36 +01:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2010-11-23 18:05:54 +01:00
|
|
|
int64_t qemu_file_get_rate_limit(QEMUFile *f)
|
2009-11-02 14:40:58 +01:00
|
|
|
{
|
2013-02-22 17:36:45 +01:00
|
|
|
return f->xfer_limit;
|
2009-11-02 14:40:58 +01:00
|
|
|
}
|
|
|
|
|
2013-02-22 17:36:45 +01:00
|
|
|
void qemu_file_set_rate_limit(QEMUFile *f, int64_t limit)
|
2009-05-21 00:26:57 +02:00
|
|
|
{
|
2013-02-22 17:36:45 +01:00
|
|
|
f->xfer_limit = limit;
|
|
|
|
}
|
2009-05-21 00:26:57 +02:00
|
|
|
|
2013-02-22 17:36:45 +01:00
|
|
|
void qemu_file_reset_rate_limit(QEMUFile *f)
|
|
|
|
{
|
|
|
|
f->bytes_xfer = 0;
|
2009-05-21 00:26:57 +02:00
|
|
|
}
|
|
|
|
|
2008-11-11 22:33:36 +01:00
|
|
|
void qemu_put_be16(QEMUFile *f, unsigned int v)
|
|
|
|
{
|
|
|
|
qemu_put_byte(f, v >> 8);
|
|
|
|
qemu_put_byte(f, v);
|
|
|
|
}
|
|
|
|
|
|
|
|
void qemu_put_be32(QEMUFile *f, unsigned int v)
|
|
|
|
{
|
|
|
|
qemu_put_byte(f, v >> 24);
|
|
|
|
qemu_put_byte(f, v >> 16);
|
|
|
|
qemu_put_byte(f, v >> 8);
|
|
|
|
qemu_put_byte(f, v);
|
|
|
|
}
|
|
|
|
|
|
|
|
void qemu_put_be64(QEMUFile *f, uint64_t v)
|
|
|
|
{
|
|
|
|
qemu_put_be32(f, v >> 32);
|
|
|
|
qemu_put_be32(f, v);
|
|
|
|
}
|
|
|
|
|
|
|
|
unsigned int qemu_get_be16(QEMUFile *f)
|
|
|
|
{
|
|
|
|
unsigned int v;
|
|
|
|
v = qemu_get_byte(f) << 8;
|
|
|
|
v |= qemu_get_byte(f);
|
|
|
|
return v;
|
|
|
|
}
|
|
|
|
|
|
|
|
unsigned int qemu_get_be32(QEMUFile *f)
|
|
|
|
{
|
|
|
|
unsigned int v;
|
|
|
|
v = qemu_get_byte(f) << 24;
|
|
|
|
v |= qemu_get_byte(f) << 16;
|
|
|
|
v |= qemu_get_byte(f) << 8;
|
|
|
|
v |= qemu_get_byte(f);
|
|
|
|
return v;
|
|
|
|
}
|
|
|
|
|
|
|
|
uint64_t qemu_get_be64(QEMUFile *f)
|
|
|
|
{
|
|
|
|
uint64_t v;
|
|
|
|
v = (uint64_t)qemu_get_be32(f) << 32;
|
|
|
|
v |= qemu_get_be32(f);
|
|
|
|
return v;
|
|
|
|
}
|
|
|
|
|
2011-09-12 16:21:44 +02:00
|
|
|
|
|
|
|
/* timer */
|
|
|
|
|
2013-08-21 17:03:02 +02:00
|
|
|
void timer_put(QEMUFile *f, QEMUTimer *ts)
|
2011-09-12 16:21:44 +02:00
|
|
|
{
|
|
|
|
uint64_t expire_time;
|
|
|
|
|
2013-08-21 17:02:39 +02:00
|
|
|
expire_time = timer_expire_time_ns(ts);
|
2011-09-12 16:21:44 +02:00
|
|
|
qemu_put_be64(f, expire_time);
|
|
|
|
}
|
|
|
|
|
2013-08-21 17:03:02 +02:00
|
|
|
void timer_get(QEMUFile *f, QEMUTimer *ts)
|
2011-09-12 16:21:44 +02:00
|
|
|
{
|
|
|
|
uint64_t expire_time;
|
|
|
|
|
|
|
|
expire_time = qemu_get_be64(f);
|
|
|
|
if (expire_time != -1) {
|
2013-08-21 17:03:08 +02:00
|
|
|
timer_mod_ns(ts, expire_time);
|
2011-09-12 16:21:44 +02:00
|
|
|
} else {
|
2013-08-21 17:03:08 +02:00
|
|
|
timer_del(ts);
|
2011-09-12 16:21:44 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2010-11-01 15:51:54 +01:00
|
|
|
/* bool */
|
|
|
|
|
|
|
|
static int get_bool(QEMUFile *f, void *pv, size_t size)
|
|
|
|
{
|
|
|
|
bool *v = pv;
|
|
|
|
*v = qemu_get_byte(f);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void put_bool(QEMUFile *f, void *pv, size_t size)
|
|
|
|
{
|
|
|
|
bool *v = pv;
|
|
|
|
qemu_put_byte(f, *v);
|
|
|
|
}
|
|
|
|
|
|
|
|
const VMStateInfo vmstate_info_bool = {
|
|
|
|
.name = "bool",
|
|
|
|
.get = get_bool,
|
|
|
|
.put = put_bool,
|
|
|
|
};
|
|
|
|
|
2009-08-20 19:42:25 +02:00
|
|
|
/* 8 bit int */
|
|
|
|
|
|
|
|
static int get_int8(QEMUFile *f, void *pv, size_t size)
|
|
|
|
{
|
|
|
|
int8_t *v = pv;
|
|
|
|
qemu_get_s8s(f, v);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-09-29 22:48:20 +02:00
|
|
|
static void put_int8(QEMUFile *f, void *pv, size_t size)
|
2009-08-20 19:42:25 +02:00
|
|
|
{
|
2009-09-29 22:48:20 +02:00
|
|
|
int8_t *v = pv;
|
2009-08-20 19:42:25 +02:00
|
|
|
qemu_put_s8s(f, v);
|
|
|
|
}
|
|
|
|
|
|
|
|
const VMStateInfo vmstate_info_int8 = {
|
|
|
|
.name = "int8",
|
|
|
|
.get = get_int8,
|
|
|
|
.put = put_int8,
|
|
|
|
};
|
|
|
|
|
|
|
|
/* 16 bit int */
|
|
|
|
|
|
|
|
static int get_int16(QEMUFile *f, void *pv, size_t size)
|
|
|
|
{
|
|
|
|
int16_t *v = pv;
|
|
|
|
qemu_get_sbe16s(f, v);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-09-29 22:48:20 +02:00
|
|
|
static void put_int16(QEMUFile *f, void *pv, size_t size)
|
2009-08-20 19:42:25 +02:00
|
|
|
{
|
2009-09-29 22:48:20 +02:00
|
|
|
int16_t *v = pv;
|
2009-08-20 19:42:25 +02:00
|
|
|
qemu_put_sbe16s(f, v);
|
|
|
|
}
|
|
|
|
|
|
|
|
const VMStateInfo vmstate_info_int16 = {
|
|
|
|
.name = "int16",
|
|
|
|
.get = get_int16,
|
|
|
|
.put = put_int16,
|
|
|
|
};
|
|
|
|
|
|
|
|
/* 32 bit int */
|
|
|
|
|
|
|
|
static int get_int32(QEMUFile *f, void *pv, size_t size)
|
|
|
|
{
|
|
|
|
int32_t *v = pv;
|
|
|
|
qemu_get_sbe32s(f, v);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-09-29 22:48:20 +02:00
|
|
|
static void put_int32(QEMUFile *f, void *pv, size_t size)
|
2009-08-20 19:42:25 +02:00
|
|
|
{
|
2009-09-29 22:48:20 +02:00
|
|
|
int32_t *v = pv;
|
2009-08-20 19:42:25 +02:00
|
|
|
qemu_put_sbe32s(f, v);
|
|
|
|
}
|
|
|
|
|
|
|
|
const VMStateInfo vmstate_info_int32 = {
|
|
|
|
.name = "int32",
|
|
|
|
.get = get_int32,
|
|
|
|
.put = put_int32,
|
|
|
|
};
|
|
|
|
|
2009-08-20 19:42:32 +02:00
|
|
|
/* 32 bit int. See that the received value is the same than the one
|
|
|
|
in the field */
|
|
|
|
|
|
|
|
static int get_int32_equal(QEMUFile *f, void *pv, size_t size)
|
|
|
|
{
|
|
|
|
int32_t *v = pv;
|
|
|
|
int32_t v2;
|
|
|
|
qemu_get_sbe32s(f, &v2);
|
|
|
|
|
2013-11-28 15:01:13 +01:00
|
|
|
if (*v == v2) {
|
2009-08-20 19:42:32 +02:00
|
|
|
return 0;
|
2013-11-28 15:01:13 +01:00
|
|
|
}
|
2009-08-20 19:42:32 +02:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
const VMStateInfo vmstate_info_int32_equal = {
|
|
|
|
.name = "int32 equal",
|
|
|
|
.get = get_int32_equal,
|
|
|
|
.put = put_int32,
|
|
|
|
};
|
|
|
|
|
2009-08-20 19:42:37 +02:00
|
|
|
/* 32 bit int. See that the received value is the less or the same
|
|
|
|
than the one in the field */
|
|
|
|
|
|
|
|
static int get_int32_le(QEMUFile *f, void *pv, size_t size)
|
|
|
|
{
|
|
|
|
int32_t *old = pv;
|
|
|
|
int32_t new;
|
|
|
|
qemu_get_sbe32s(f, &new);
|
|
|
|
|
2013-11-28 15:01:13 +01:00
|
|
|
if (*old <= new) {
|
2009-08-20 19:42:37 +02:00
|
|
|
return 0;
|
2013-11-28 15:01:13 +01:00
|
|
|
}
|
2009-08-20 19:42:37 +02:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
const VMStateInfo vmstate_info_int32_le = {
|
|
|
|
.name = "int32 equal",
|
|
|
|
.get = get_int32_le,
|
|
|
|
.put = put_int32,
|
|
|
|
};
|
|
|
|
|
2009-08-20 19:42:25 +02:00
|
|
|
/* 64 bit int */
|
|
|
|
|
|
|
|
static int get_int64(QEMUFile *f, void *pv, size_t size)
|
|
|
|
{
|
|
|
|
int64_t *v = pv;
|
|
|
|
qemu_get_sbe64s(f, v);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-09-29 22:48:20 +02:00
|
|
|
static void put_int64(QEMUFile *f, void *pv, size_t size)
|
2009-08-20 19:42:25 +02:00
|
|
|
{
|
2009-09-29 22:48:20 +02:00
|
|
|
int64_t *v = pv;
|
2009-08-20 19:42:25 +02:00
|
|
|
qemu_put_sbe64s(f, v);
|
|
|
|
}
|
|
|
|
|
|
|
|
const VMStateInfo vmstate_info_int64 = {
|
|
|
|
.name = "int64",
|
|
|
|
.get = get_int64,
|
|
|
|
.put = put_int64,
|
|
|
|
};
|
|
|
|
|
|
|
|
/* 8 bit unsigned int */
|
|
|
|
|
|
|
|
static int get_uint8(QEMUFile *f, void *pv, size_t size)
|
|
|
|
{
|
|
|
|
uint8_t *v = pv;
|
|
|
|
qemu_get_8s(f, v);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-09-29 22:48:20 +02:00
|
|
|
static void put_uint8(QEMUFile *f, void *pv, size_t size)
|
2009-08-20 19:42:25 +02:00
|
|
|
{
|
2009-09-29 22:48:20 +02:00
|
|
|
uint8_t *v = pv;
|
2009-08-20 19:42:25 +02:00
|
|
|
qemu_put_8s(f, v);
|
|
|
|
}
|
|
|
|
|
|
|
|
const VMStateInfo vmstate_info_uint8 = {
|
|
|
|
.name = "uint8",
|
|
|
|
.get = get_uint8,
|
|
|
|
.put = put_uint8,
|
|
|
|
};
|
|
|
|
|
|
|
|
/* 16 bit unsigned int */
|
|
|
|
|
|
|
|
static int get_uint16(QEMUFile *f, void *pv, size_t size)
|
|
|
|
{
|
|
|
|
uint16_t *v = pv;
|
|
|
|
qemu_get_be16s(f, v);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-09-29 22:48:20 +02:00
|
|
|
static void put_uint16(QEMUFile *f, void *pv, size_t size)
|
2009-08-20 19:42:25 +02:00
|
|
|
{
|
2009-09-29 22:48:20 +02:00
|
|
|
uint16_t *v = pv;
|
2009-08-20 19:42:25 +02:00
|
|
|
qemu_put_be16s(f, v);
|
|
|
|
}
|
|
|
|
|
|
|
|
const VMStateInfo vmstate_info_uint16 = {
|
|
|
|
.name = "uint16",
|
|
|
|
.get = get_uint16,
|
|
|
|
.put = put_uint16,
|
|
|
|
};
|
|
|
|
|
|
|
|
/* 32 bit unsigned int */
|
|
|
|
|
|
|
|
static int get_uint32(QEMUFile *f, void *pv, size_t size)
|
|
|
|
{
|
|
|
|
uint32_t *v = pv;
|
|
|
|
qemu_get_be32s(f, v);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-09-29 22:48:20 +02:00
|
|
|
static void put_uint32(QEMUFile *f, void *pv, size_t size)
|
2009-08-20 19:42:25 +02:00
|
|
|
{
|
2009-09-29 22:48:20 +02:00
|
|
|
uint32_t *v = pv;
|
2009-08-20 19:42:25 +02:00
|
|
|
qemu_put_be32s(f, v);
|
|
|
|
}
|
|
|
|
|
|
|
|
const VMStateInfo vmstate_info_uint32 = {
|
|
|
|
.name = "uint32",
|
|
|
|
.get = get_uint32,
|
|
|
|
.put = put_uint32,
|
|
|
|
};
|
|
|
|
|
2011-03-10 12:33:48 +01:00
|
|
|
/* 32 bit uint. See that the received value is the same than the one
|
|
|
|
in the field */
|
|
|
|
|
|
|
|
static int get_uint32_equal(QEMUFile *f, void *pv, size_t size)
|
|
|
|
{
|
|
|
|
uint32_t *v = pv;
|
|
|
|
uint32_t v2;
|
|
|
|
qemu_get_be32s(f, &v2);
|
|
|
|
|
|
|
|
if (*v == v2) {
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
const VMStateInfo vmstate_info_uint32_equal = {
|
|
|
|
.name = "uint32 equal",
|
|
|
|
.get = get_uint32_equal,
|
|
|
|
.put = put_uint32,
|
|
|
|
};
|
|
|
|
|
2009-08-20 19:42:25 +02:00
|
|
|
/* 64 bit unsigned int */
|
|
|
|
|
|
|
|
static int get_uint64(QEMUFile *f, void *pv, size_t size)
|
|
|
|
{
|
|
|
|
uint64_t *v = pv;
|
|
|
|
qemu_get_be64s(f, v);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-09-29 22:48:20 +02:00
|
|
|
static void put_uint64(QEMUFile *f, void *pv, size_t size)
|
2009-08-20 19:42:25 +02:00
|
|
|
{
|
2009-09-29 22:48:20 +02:00
|
|
|
uint64_t *v = pv;
|
2009-08-20 19:42:25 +02:00
|
|
|
qemu_put_be64s(f, v);
|
|
|
|
}
|
|
|
|
|
|
|
|
const VMStateInfo vmstate_info_uint64 = {
|
|
|
|
.name = "uint64",
|
|
|
|
.get = get_uint64,
|
|
|
|
.put = put_uint64,
|
|
|
|
};
|
|
|
|
|
2013-03-12 04:06:00 +01:00
|
|
|
/* 64 bit unsigned int. See that the received value is the same than the one
|
|
|
|
in the field */
|
|
|
|
|
|
|
|
static int get_uint64_equal(QEMUFile *f, void *pv, size_t size)
|
|
|
|
{
|
|
|
|
uint64_t *v = pv;
|
|
|
|
uint64_t v2;
|
|
|
|
qemu_get_be64s(f, &v2);
|
|
|
|
|
|
|
|
if (*v == v2) {
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
const VMStateInfo vmstate_info_uint64_equal = {
|
|
|
|
.name = "int64 equal",
|
|
|
|
.get = get_uint64_equal,
|
|
|
|
.put = put_uint64,
|
|
|
|
};
|
|
|
|
|
2009-09-10 03:04:36 +02:00
|
|
|
/* 8 bit int. See that the received value is the same than the one
|
|
|
|
in the field */
|
|
|
|
|
|
|
|
static int get_uint8_equal(QEMUFile *f, void *pv, size_t size)
|
|
|
|
{
|
|
|
|
uint8_t *v = pv;
|
|
|
|
uint8_t v2;
|
|
|
|
qemu_get_8s(f, &v2);
|
|
|
|
|
2013-11-28 15:01:13 +01:00
|
|
|
if (*v == v2) {
|
2009-09-10 03:04:36 +02:00
|
|
|
return 0;
|
2013-11-28 15:01:13 +01:00
|
|
|
}
|
2009-09-10 03:04:36 +02:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
const VMStateInfo vmstate_info_uint8_equal = {
|
2009-10-15 19:16:06 +02:00
|
|
|
.name = "uint8 equal",
|
2009-09-10 03:04:36 +02:00
|
|
|
.get = get_uint8_equal,
|
|
|
|
.put = put_uint8,
|
|
|
|
};
|
|
|
|
|
2009-10-15 23:16:13 +02:00
|
|
|
/* 16 bit unsigned int int. See that the received value is the same than the one
|
|
|
|
in the field */
|
|
|
|
|
|
|
|
static int get_uint16_equal(QEMUFile *f, void *pv, size_t size)
|
|
|
|
{
|
|
|
|
uint16_t *v = pv;
|
|
|
|
uint16_t v2;
|
|
|
|
qemu_get_be16s(f, &v2);
|
|
|
|
|
2013-11-28 15:01:13 +01:00
|
|
|
if (*v == v2) {
|
2009-10-15 23:16:13 +02:00
|
|
|
return 0;
|
2013-11-28 15:01:13 +01:00
|
|
|
}
|
2009-10-15 23:16:13 +02:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
const VMStateInfo vmstate_info_uint16_equal = {
|
|
|
|
.name = "uint16 equal",
|
|
|
|
.get = get_uint16_equal,
|
|
|
|
.put = put_uint16,
|
|
|
|
};
|
|
|
|
|
2013-03-12 04:06:02 +01:00
|
|
|
/* floating point */
|
|
|
|
|
|
|
|
static int get_float64(QEMUFile *f, void *pv, size_t size)
|
|
|
|
{
|
|
|
|
float64 *v = pv;
|
|
|
|
|
|
|
|
*v = make_float64(qemu_get_be64(f));
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void put_float64(QEMUFile *f, void *pv, size_t size)
|
|
|
|
{
|
|
|
|
uint64_t *v = pv;
|
|
|
|
|
|
|
|
qemu_put_be64(f, float64_val(*v));
|
|
|
|
}
|
|
|
|
|
|
|
|
const VMStateInfo vmstate_info_float64 = {
|
|
|
|
.name = "float64",
|
|
|
|
.get = get_float64,
|
|
|
|
.put = put_float64,
|
|
|
|
};
|
|
|
|
|
2009-08-20 19:42:26 +02:00
|
|
|
/* timers */
|
|
|
|
|
|
|
|
static int get_timer(QEMUFile *f, void *pv, size_t size)
|
|
|
|
{
|
|
|
|
QEMUTimer *v = pv;
|
2013-08-21 17:03:02 +02:00
|
|
|
timer_get(f, v);
|
2009-08-20 19:42:26 +02:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-09-29 22:48:20 +02:00
|
|
|
static void put_timer(QEMUFile *f, void *pv, size_t size)
|
2009-08-20 19:42:26 +02:00
|
|
|
{
|
2009-09-29 22:48:20 +02:00
|
|
|
QEMUTimer *v = pv;
|
2013-08-21 17:03:02 +02:00
|
|
|
timer_put(f, v);
|
2009-08-20 19:42:26 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
const VMStateInfo vmstate_info_timer = {
|
|
|
|
.name = "timer",
|
|
|
|
.get = get_timer,
|
|
|
|
.put = put_timer,
|
|
|
|
};
|
|
|
|
|
2009-08-20 19:42:35 +02:00
|
|
|
/* uint8_t buffers */
|
|
|
|
|
|
|
|
static int get_buffer(QEMUFile *f, void *pv, size_t size)
|
|
|
|
{
|
|
|
|
uint8_t *v = pv;
|
|
|
|
qemu_get_buffer(f, v, size);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-09-29 22:48:20 +02:00
|
|
|
static void put_buffer(QEMUFile *f, void *pv, size_t size)
|
2009-08-20 19:42:35 +02:00
|
|
|
{
|
2009-09-29 22:48:20 +02:00
|
|
|
uint8_t *v = pv;
|
2009-08-20 19:42:35 +02:00
|
|
|
qemu_put_buffer(f, v, size);
|
|
|
|
}
|
|
|
|
|
|
|
|
const VMStateInfo vmstate_info_buffer = {
|
|
|
|
.name = "buffer",
|
|
|
|
.get = get_buffer,
|
|
|
|
.put = put_buffer,
|
|
|
|
};
|
|
|
|
|
2009-10-19 15:46:28 +02:00
|
|
|
/* unused buffers: space that was used for some fields that are
|
2011-04-13 22:45:22 +02:00
|
|
|
not useful anymore */
|
2009-10-19 15:46:28 +02:00
|
|
|
|
|
|
|
static int get_unused_buffer(QEMUFile *f, void *pv, size_t size)
|
|
|
|
{
|
2009-12-02 12:36:35 +01:00
|
|
|
uint8_t buf[1024];
|
|
|
|
int block_len;
|
|
|
|
|
|
|
|
while (size > 0) {
|
|
|
|
block_len = MIN(sizeof(buf), size);
|
|
|
|
size -= block_len;
|
|
|
|
qemu_get_buffer(f, buf, block_len);
|
|
|
|
}
|
|
|
|
return 0;
|
2009-10-19 15:46:28 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
static void put_unused_buffer(QEMUFile *f, void *pv, size_t size)
|
|
|
|
{
|
2009-12-02 12:36:35 +01:00
|
|
|
static const uint8_t buf[1024];
|
|
|
|
int block_len;
|
|
|
|
|
|
|
|
while (size > 0) {
|
|
|
|
block_len = MIN(sizeof(buf), size);
|
|
|
|
size -= block_len;
|
|
|
|
qemu_put_buffer(f, buf, block_len);
|
|
|
|
}
|
2009-10-19 15:46:28 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
const VMStateInfo vmstate_info_unused_buffer = {
|
|
|
|
.name = "unused_buffer",
|
|
|
|
.get = get_unused_buffer,
|
|
|
|
.put = put_unused_buffer,
|
|
|
|
};
|
|
|
|
|
2012-10-30 08:45:12 +01:00
|
|
|
/* bitmaps (as defined by bitmap.h). Note that size here is the size
|
|
|
|
* of the bitmap in bits. The on-the-wire format of a bitmap is 64
|
|
|
|
* bit words with the bits in big endian order. The in-memory format
|
|
|
|
* is an array of 'unsigned long', which may be either 32 or 64 bits.
|
|
|
|
*/
|
|
|
|
/* This is the number of 64 bit words sent over the wire */
|
|
|
|
#define BITS_TO_U64S(nr) DIV_ROUND_UP(nr, 64)
|
|
|
|
static int get_bitmap(QEMUFile *f, void *pv, size_t size)
|
|
|
|
{
|
|
|
|
unsigned long *bmp = pv;
|
|
|
|
int i, idx = 0;
|
|
|
|
for (i = 0; i < BITS_TO_U64S(size); i++) {
|
|
|
|
uint64_t w = qemu_get_be64(f);
|
|
|
|
bmp[idx++] = w;
|
|
|
|
if (sizeof(unsigned long) == 4 && idx < BITS_TO_LONGS(size)) {
|
|
|
|
bmp[idx++] = w >> 32;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void put_bitmap(QEMUFile *f, void *pv, size_t size)
|
|
|
|
{
|
|
|
|
unsigned long *bmp = pv;
|
|
|
|
int i, idx = 0;
|
|
|
|
for (i = 0; i < BITS_TO_U64S(size); i++) {
|
|
|
|
uint64_t w = bmp[idx++];
|
|
|
|
if (sizeof(unsigned long) == 4 && idx < BITS_TO_LONGS(size)) {
|
|
|
|
w |= ((uint64_t)bmp[idx++]) << 32;
|
|
|
|
}
|
|
|
|
qemu_put_be64(f, w);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
const VMStateInfo vmstate_info_bitmap = {
|
|
|
|
.name = "bitmap",
|
|
|
|
.get = get_bitmap,
|
|
|
|
.put = put_bitmap,
|
|
|
|
};
|
|
|
|
|
2010-06-25 19:09:14 +02:00
|
|
|
typedef struct CompatEntry {
|
|
|
|
char idstr[256];
|
|
|
|
int instance_id;
|
|
|
|
} CompatEntry;
|
|
|
|
|
2008-11-11 22:33:36 +01:00
|
|
|
typedef struct SaveStateEntry {
|
2009-09-12 09:36:22 +02:00
|
|
|
QTAILQ_ENTRY(SaveStateEntry) entry;
|
2008-11-11 22:33:36 +01:00
|
|
|
char idstr[256];
|
|
|
|
int instance_id;
|
2010-05-15 13:32:40 +02:00
|
|
|
int alias_id;
|
2008-11-11 22:33:36 +01:00
|
|
|
int version_id;
|
|
|
|
int section_id;
|
2012-06-26 17:19:10 +02:00
|
|
|
SaveVMHandlers *ops;
|
2009-08-20 19:42:25 +02:00
|
|
|
const VMStateDescription *vmsd;
|
2008-11-11 22:33:36 +01:00
|
|
|
void *opaque;
|
2010-06-25 19:09:14 +02:00
|
|
|
CompatEntry *compat;
|
2010-07-27 02:11:00 +02:00
|
|
|
int no_migrate;
|
2012-01-25 13:24:51 +01:00
|
|
|
int is_ram;
|
2008-11-11 22:33:36 +01:00
|
|
|
} SaveStateEntry;
|
|
|
|
|
2009-11-02 14:40:58 +01:00
|
|
|
|
2009-09-12 09:36:22 +02:00
|
|
|
static QTAILQ_HEAD(savevm_handlers, SaveStateEntry) savevm_handlers =
|
|
|
|
QTAILQ_HEAD_INITIALIZER(savevm_handlers);
|
2009-08-20 19:42:25 +02:00
|
|
|
static int global_section_id;
|
2008-11-11 22:33:36 +01:00
|
|
|
|
2009-09-01 02:12:31 +02:00
|
|
|
static int calculate_new_instance_id(const char *idstr)
|
|
|
|
{
|
|
|
|
SaveStateEntry *se;
|
|
|
|
int instance_id = 0;
|
|
|
|
|
2009-09-12 09:36:22 +02:00
|
|
|
QTAILQ_FOREACH(se, &savevm_handlers, entry) {
|
2009-09-01 02:12:31 +02:00
|
|
|
if (strcmp(idstr, se->idstr) == 0
|
|
|
|
&& instance_id <= se->instance_id) {
|
|
|
|
instance_id = se->instance_id + 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return instance_id;
|
|
|
|
}
|
|
|
|
|
2010-06-25 19:09:14 +02:00
|
|
|
static int calculate_compat_instance_id(const char *idstr)
|
|
|
|
{
|
|
|
|
SaveStateEntry *se;
|
|
|
|
int instance_id = 0;
|
|
|
|
|
|
|
|
QTAILQ_FOREACH(se, &savevm_handlers, entry) {
|
2013-11-28 15:01:13 +01:00
|
|
|
if (!se->compat) {
|
2010-06-25 19:09:14 +02:00
|
|
|
continue;
|
2013-11-28 15:01:13 +01:00
|
|
|
}
|
2010-06-25 19:09:14 +02:00
|
|
|
|
|
|
|
if (strcmp(idstr, se->compat->idstr) == 0
|
|
|
|
&& instance_id <= se->compat->instance_id) {
|
|
|
|
instance_id = se->compat->instance_id + 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return instance_id;
|
|
|
|
}
|
|
|
|
|
2008-11-11 22:33:36 +01:00
|
|
|
/* TODO: Individual devices generally have very little idea about the rest
|
|
|
|
of the system, so instance_id should be removed/replaced.
|
|
|
|
Meanwhile pass -1 as instance_id if you do not already have a clearly
|
|
|
|
distinguishing id for all instances of your device class. */
|
2010-06-25 19:09:07 +02:00
|
|
|
int register_savevm_live(DeviceState *dev,
|
|
|
|
const char *idstr,
|
2008-11-11 22:33:36 +01:00
|
|
|
int instance_id,
|
|
|
|
int version_id,
|
2012-06-26 18:46:10 +02:00
|
|
|
SaveVMHandlers *ops,
|
2008-11-11 22:33:36 +01:00
|
|
|
void *opaque)
|
|
|
|
{
|
2009-09-01 02:12:31 +02:00
|
|
|
SaveStateEntry *se;
|
2008-11-11 22:33:36 +01:00
|
|
|
|
2011-08-21 05:09:37 +02:00
|
|
|
se = g_malloc0(sizeof(SaveStateEntry));
|
2008-11-11 22:33:36 +01:00
|
|
|
se->version_id = version_id;
|
|
|
|
se->section_id = global_section_id++;
|
2012-06-26 18:46:10 +02:00
|
|
|
se->ops = ops;
|
2008-11-11 22:33:36 +01:00
|
|
|
se->opaque = opaque;
|
2009-08-20 19:42:25 +02:00
|
|
|
se->vmsd = NULL;
|
2010-07-27 02:11:00 +02:00
|
|
|
se->no_migrate = 0;
|
2012-01-25 13:24:51 +01:00
|
|
|
/* if this is a live_savem then set is_ram */
|
2012-06-28 15:31:37 +02:00
|
|
|
if (ops->save_live_setup != NULL) {
|
2012-01-25 13:24:51 +01:00
|
|
|
se->is_ram = 1;
|
|
|
|
}
|
2008-11-11 22:33:36 +01:00
|
|
|
|
2012-02-03 19:28:43 +01:00
|
|
|
if (dev) {
|
|
|
|
char *id = qdev_get_dev_path(dev);
|
2010-06-25 19:09:14 +02:00
|
|
|
if (id) {
|
|
|
|
pstrcpy(se->idstr, sizeof(se->idstr), id);
|
|
|
|
pstrcat(se->idstr, sizeof(se->idstr), "/");
|
2011-08-21 05:09:37 +02:00
|
|
|
g_free(id);
|
2010-06-25 19:09:14 +02:00
|
|
|
|
2011-08-21 05:09:37 +02:00
|
|
|
se->compat = g_malloc0(sizeof(CompatEntry));
|
2010-06-25 19:09:14 +02:00
|
|
|
pstrcpy(se->compat->idstr, sizeof(se->compat->idstr), idstr);
|
|
|
|
se->compat->instance_id = instance_id == -1 ?
|
|
|
|
calculate_compat_instance_id(idstr) : instance_id;
|
|
|
|
instance_id = -1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
pstrcat(se->idstr, sizeof(se->idstr), idstr);
|
|
|
|
|
2009-09-01 02:12:31 +02:00
|
|
|
if (instance_id == -1) {
|
2010-06-25 19:09:14 +02:00
|
|
|
se->instance_id = calculate_new_instance_id(se->idstr);
|
2009-09-01 02:12:31 +02:00
|
|
|
} else {
|
|
|
|
se->instance_id = instance_id;
|
2008-11-11 22:33:36 +01:00
|
|
|
}
|
2010-06-25 19:09:14 +02:00
|
|
|
assert(!se->compat || se->instance_id == 0);
|
2009-09-01 02:12:31 +02:00
|
|
|
/* add at the end of list */
|
2009-09-12 09:36:22 +02:00
|
|
|
QTAILQ_INSERT_TAIL(&savevm_handlers, se, entry);
|
2008-11-11 22:33:36 +01:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2010-06-25 19:09:07 +02:00
|
|
|
int register_savevm(DeviceState *dev,
|
|
|
|
const char *idstr,
|
2008-11-11 22:33:36 +01:00
|
|
|
int instance_id,
|
|
|
|
int version_id,
|
|
|
|
SaveStateHandler *save_state,
|
|
|
|
LoadStateHandler *load_state,
|
|
|
|
void *opaque)
|
|
|
|
{
|
2012-06-26 18:46:10 +02:00
|
|
|
SaveVMHandlers *ops = g_malloc0(sizeof(SaveVMHandlers));
|
|
|
|
ops->save_state = save_state;
|
|
|
|
ops->load_state = load_state;
|
2010-06-25 19:09:07 +02:00
|
|
|
return register_savevm_live(dev, idstr, instance_id, version_id,
|
2012-06-26 18:46:10 +02:00
|
|
|
ops, opaque);
|
2008-11-11 22:33:36 +01:00
|
|
|
}
|
|
|
|
|
2010-06-25 19:09:07 +02:00
|
|
|
void unregister_savevm(DeviceState *dev, const char *idstr, void *opaque)
|
2009-04-17 19:10:59 +02:00
|
|
|
{
|
2009-09-01 02:12:31 +02:00
|
|
|
SaveStateEntry *se, *new_se;
|
2010-06-25 19:09:14 +02:00
|
|
|
char id[256] = "";
|
|
|
|
|
2012-02-03 19:28:43 +01:00
|
|
|
if (dev) {
|
|
|
|
char *path = qdev_get_dev_path(dev);
|
2010-06-25 19:09:14 +02:00
|
|
|
if (path) {
|
|
|
|
pstrcpy(id, sizeof(id), path);
|
|
|
|
pstrcat(id, sizeof(id), "/");
|
2011-08-21 05:09:37 +02:00
|
|
|
g_free(path);
|
2010-06-25 19:09:14 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
pstrcat(id, sizeof(id), idstr);
|
2009-04-17 19:10:59 +02:00
|
|
|
|
2009-09-12 09:36:22 +02:00
|
|
|
QTAILQ_FOREACH_SAFE(se, &savevm_handlers, entry, new_se) {
|
2010-06-25 19:09:14 +02:00
|
|
|
if (strcmp(se->idstr, id) == 0 && se->opaque == opaque) {
|
2009-09-12 09:36:22 +02:00
|
|
|
QTAILQ_REMOVE(&savevm_handlers, se, entry);
|
2010-07-21 16:35:31 +02:00
|
|
|
if (se->compat) {
|
2011-08-21 05:09:37 +02:00
|
|
|
g_free(se->compat);
|
2010-07-21 16:35:31 +02:00
|
|
|
}
|
2012-06-26 17:19:10 +02:00
|
|
|
g_free(se->ops);
|
2011-08-21 05:09:37 +02:00
|
|
|
g_free(se);
|
2009-04-17 19:10:59 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-06-25 19:09:07 +02:00
|
|
|
int vmstate_register_with_alias_id(DeviceState *dev, int instance_id,
|
2010-05-15 13:32:40 +02:00
|
|
|
const VMStateDescription *vmsd,
|
|
|
|
void *opaque, int alias_id,
|
|
|
|
int required_for_version)
|
2009-08-20 19:42:25 +02:00
|
|
|
{
|
2009-09-01 02:12:31 +02:00
|
|
|
SaveStateEntry *se;
|
2009-08-20 19:42:25 +02:00
|
|
|
|
2010-05-15 13:32:40 +02:00
|
|
|
/* If this triggers, alias support can be dropped for the vmsd. */
|
|
|
|
assert(alias_id == -1 || required_for_version >= vmsd->minimum_version_id);
|
|
|
|
|
2011-08-21 05:09:37 +02:00
|
|
|
se = g_malloc0(sizeof(SaveStateEntry));
|
2009-08-20 19:42:25 +02:00
|
|
|
se->version_id = vmsd->version_id;
|
|
|
|
se->section_id = global_section_id++;
|
|
|
|
se->opaque = opaque;
|
|
|
|
se->vmsd = vmsd;
|
2010-05-15 13:32:40 +02:00
|
|
|
se->alias_id = alias_id;
|
2011-07-08 10:44:35 +02:00
|
|
|
se->no_migrate = vmsd->unmigratable;
|
2009-08-20 19:42:25 +02:00
|
|
|
|
2012-02-03 19:28:43 +01:00
|
|
|
if (dev) {
|
|
|
|
char *id = qdev_get_dev_path(dev);
|
2010-06-25 19:09:14 +02:00
|
|
|
if (id) {
|
|
|
|
pstrcpy(se->idstr, sizeof(se->idstr), id);
|
|
|
|
pstrcat(se->idstr, sizeof(se->idstr), "/");
|
2011-08-21 05:09:37 +02:00
|
|
|
g_free(id);
|
2010-06-25 19:09:14 +02:00
|
|
|
|
2011-08-21 05:09:37 +02:00
|
|
|
se->compat = g_malloc0(sizeof(CompatEntry));
|
2010-06-25 19:09:14 +02:00
|
|
|
pstrcpy(se->compat->idstr, sizeof(se->compat->idstr), vmsd->name);
|
|
|
|
se->compat->instance_id = instance_id == -1 ?
|
|
|
|
calculate_compat_instance_id(vmsd->name) : instance_id;
|
|
|
|
instance_id = -1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
pstrcat(se->idstr, sizeof(se->idstr), vmsd->name);
|
|
|
|
|
2009-09-01 02:12:31 +02:00
|
|
|
if (instance_id == -1) {
|
2010-06-25 19:09:14 +02:00
|
|
|
se->instance_id = calculate_new_instance_id(se->idstr);
|
2009-09-01 02:12:31 +02:00
|
|
|
} else {
|
|
|
|
se->instance_id = instance_id;
|
2009-08-20 19:42:25 +02:00
|
|
|
}
|
2010-06-25 19:09:14 +02:00
|
|
|
assert(!se->compat || se->instance_id == 0);
|
2009-09-01 02:12:31 +02:00
|
|
|
/* add at the end of list */
|
2009-09-12 09:36:22 +02:00
|
|
|
QTAILQ_INSERT_TAIL(&savevm_handlers, se, entry);
|
2009-08-20 19:42:25 +02:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2010-06-25 19:09:07 +02:00
|
|
|
void vmstate_unregister(DeviceState *dev, const VMStateDescription *vmsd,
|
|
|
|
void *opaque)
|
2009-08-20 19:42:25 +02:00
|
|
|
{
|
2009-09-10 03:04:29 +02:00
|
|
|
SaveStateEntry *se, *new_se;
|
|
|
|
|
2009-09-12 09:36:22 +02:00
|
|
|
QTAILQ_FOREACH_SAFE(se, &savevm_handlers, entry, new_se) {
|
2009-09-10 03:04:29 +02:00
|
|
|
if (se->vmsd == vmsd && se->opaque == opaque) {
|
2009-09-12 09:36:22 +02:00
|
|
|
QTAILQ_REMOVE(&savevm_handlers, se, entry);
|
2010-07-21 16:35:31 +02:00
|
|
|
if (se->compat) {
|
2011-08-21 05:09:37 +02:00
|
|
|
g_free(se->compat);
|
2010-07-21 16:35:31 +02:00
|
|
|
}
|
2011-08-21 05:09:37 +02:00
|
|
|
g_free(se);
|
2009-09-10 03:04:29 +02:00
|
|
|
}
|
|
|
|
}
|
2009-08-20 19:42:25 +02:00
|
|
|
}
|
|
|
|
|
2010-07-26 21:38:43 +02:00
|
|
|
static void vmstate_subsection_save(QEMUFile *f, const VMStateDescription *vmsd,
|
|
|
|
void *opaque);
|
|
|
|
static int vmstate_subsection_load(QEMUFile *f, const VMStateDescription *vmsd,
|
|
|
|
void *opaque);
|
|
|
|
|
2009-08-20 19:42:25 +02:00
|
|
|
int vmstate_load_state(QEMUFile *f, const VMStateDescription *vmsd,
|
|
|
|
void *opaque, int version_id)
|
|
|
|
{
|
|
|
|
VMStateField *field = vmsd->fields;
|
2010-07-26 21:38:43 +02:00
|
|
|
int ret;
|
2009-08-20 19:42:25 +02:00
|
|
|
|
|
|
|
if (version_id > vmsd->version_id) {
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
if (version_id < vmsd->minimum_version_id_old) {
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
if (version_id < vmsd->minimum_version_id) {
|
|
|
|
return vmsd->load_state_old(f, opaque, version_id);
|
|
|
|
}
|
2009-09-10 03:04:31 +02:00
|
|
|
if (vmsd->pre_load) {
|
|
|
|
int ret = vmsd->pre_load(opaque);
|
2013-11-28 15:01:13 +01:00
|
|
|
if (ret) {
|
2009-09-10 03:04:31 +02:00
|
|
|
return ret;
|
2013-11-28 15:01:13 +01:00
|
|
|
}
|
2009-09-10 03:04:31 +02:00
|
|
|
}
|
2013-11-28 15:01:13 +01:00
|
|
|
while (field->name) {
|
2009-09-29 22:49:07 +02:00
|
|
|
if ((field->field_exists &&
|
|
|
|
field->field_exists(opaque, version_id)) ||
|
|
|
|
(!field->field_exists &&
|
|
|
|
field->version_id <= version_id)) {
|
2009-08-20 19:42:27 +02:00
|
|
|
void *base_addr = opaque + field->offset;
|
2010-07-26 21:38:43 +02:00
|
|
|
int i, n_elems = 1;
|
2009-12-02 12:36:38 +01:00
|
|
|
int size = field->size;
|
2009-08-20 19:42:25 +02:00
|
|
|
|
2009-12-02 12:36:38 +01:00
|
|
|
if (field->flags & VMS_VBUFFER) {
|
|
|
|
size = *(int32_t *)(opaque+field->size_offset);
|
2009-12-02 12:36:43 +01:00
|
|
|
if (field->flags & VMS_MULTIPLY) {
|
|
|
|
size *= field->size;
|
|
|
|
}
|
2009-12-02 12:36:38 +01:00
|
|
|
}
|
2009-08-20 19:42:27 +02:00
|
|
|
if (field->flags & VMS_ARRAY) {
|
|
|
|
n_elems = field->num;
|
2009-10-16 11:27:17 +02:00
|
|
|
} else if (field->flags & VMS_VARRAY_INT32) {
|
|
|
|
n_elems = *(int32_t *)(opaque+field->num_offset);
|
2011-03-10 12:33:50 +01:00
|
|
|
} else if (field->flags & VMS_VARRAY_UINT32) {
|
|
|
|
n_elems = *(uint32_t *)(opaque+field->num_offset);
|
2009-10-16 11:35:18 +02:00
|
|
|
} else if (field->flags & VMS_VARRAY_UINT16) {
|
|
|
|
n_elems = *(uint16_t *)(opaque+field->num_offset);
|
2011-03-10 12:33:49 +01:00
|
|
|
} else if (field->flags & VMS_VARRAY_UINT8) {
|
|
|
|
n_elems = *(uint8_t *)(opaque+field->num_offset);
|
2009-08-20 19:42:27 +02:00
|
|
|
}
|
2009-08-20 19:42:26 +02:00
|
|
|
if (field->flags & VMS_POINTER) {
|
2009-12-02 12:36:38 +01:00
|
|
|
base_addr = *(void **)base_addr + field->start;
|
2009-08-20 19:42:26 +02:00
|
|
|
}
|
2009-08-20 19:42:27 +02:00
|
|
|
for (i = 0; i < n_elems; i++) {
|
2009-12-02 12:36:38 +01:00
|
|
|
void *addr = base_addr + size * i;
|
2009-08-20 19:42:29 +02:00
|
|
|
|
2009-09-29 22:48:41 +02:00
|
|
|
if (field->flags & VMS_ARRAY_OF_POINTER) {
|
|
|
|
addr = *(void **)addr;
|
|
|
|
}
|
2009-08-20 19:42:29 +02:00
|
|
|
if (field->flags & VMS_STRUCT) {
|
2013-11-28 15:01:13 +01:00
|
|
|
ret = vmstate_load_state(f, field->vmsd, addr,
|
|
|
|
field->vmsd->version_id);
|
2009-08-20 19:42:29 +02:00
|
|
|
} else {
|
2009-12-02 12:36:38 +01:00
|
|
|
ret = field->info->get(f, addr, size);
|
2009-08-20 19:42:29 +02:00
|
|
|
|
|
|
|
}
|
2009-08-20 19:42:27 +02:00
|
|
|
if (ret < 0) {
|
|
|
|
return ret;
|
|
|
|
}
|
2009-08-20 19:42:25 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
field++;
|
|
|
|
}
|
2010-07-26 21:38:43 +02:00
|
|
|
ret = vmstate_subsection_load(f, vmsd, opaque);
|
|
|
|
if (ret != 0) {
|
|
|
|
return ret;
|
|
|
|
}
|
2009-09-10 03:04:30 +02:00
|
|
|
if (vmsd->post_load) {
|
2009-09-29 22:48:21 +02:00
|
|
|
return vmsd->post_load(opaque, version_id);
|
2009-09-10 03:04:30 +02:00
|
|
|
}
|
2009-08-20 19:42:25 +02:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
void vmstate_save_state(QEMUFile *f, const VMStateDescription *vmsd,
|
2009-09-29 22:48:20 +02:00
|
|
|
void *opaque)
|
2009-08-20 19:42:25 +02:00
|
|
|
{
|
|
|
|
VMStateField *field = vmsd->fields;
|
|
|
|
|
2009-09-10 03:04:32 +02:00
|
|
|
if (vmsd->pre_save) {
|
|
|
|
vmsd->pre_save(opaque);
|
|
|
|
}
|
2013-11-28 15:01:13 +01:00
|
|
|
while (field->name) {
|
2009-09-29 22:49:07 +02:00
|
|
|
if (!field->field_exists ||
|
|
|
|
field->field_exists(opaque, vmsd->version_id)) {
|
|
|
|
void *base_addr = opaque + field->offset;
|
|
|
|
int i, n_elems = 1;
|
2009-12-02 12:36:38 +01:00
|
|
|
int size = field->size;
|
2009-08-20 19:42:26 +02:00
|
|
|
|
2009-12-02 12:36:38 +01:00
|
|
|
if (field->flags & VMS_VBUFFER) {
|
|
|
|
size = *(int32_t *)(opaque+field->size_offset);
|
2009-12-02 12:36:43 +01:00
|
|
|
if (field->flags & VMS_MULTIPLY) {
|
|
|
|
size *= field->size;
|
|
|
|
}
|
2009-12-02 12:36:38 +01:00
|
|
|
}
|
2009-09-29 22:49:07 +02:00
|
|
|
if (field->flags & VMS_ARRAY) {
|
|
|
|
n_elems = field->num;
|
2009-10-16 11:27:17 +02:00
|
|
|
} else if (field->flags & VMS_VARRAY_INT32) {
|
|
|
|
n_elems = *(int32_t *)(opaque+field->num_offset);
|
2012-03-13 07:05:36 +01:00
|
|
|
} else if (field->flags & VMS_VARRAY_UINT32) {
|
|
|
|
n_elems = *(uint32_t *)(opaque+field->num_offset);
|
2009-10-16 11:35:18 +02:00
|
|
|
} else if (field->flags & VMS_VARRAY_UINT16) {
|
|
|
|
n_elems = *(uint16_t *)(opaque+field->num_offset);
|
2011-03-15 15:53:25 +01:00
|
|
|
} else if (field->flags & VMS_VARRAY_UINT8) {
|
|
|
|
n_elems = *(uint8_t *)(opaque+field->num_offset);
|
2009-09-29 22:49:07 +02:00
|
|
|
}
|
|
|
|
if (field->flags & VMS_POINTER) {
|
2009-12-02 12:36:38 +01:00
|
|
|
base_addr = *(void **)base_addr + field->start;
|
2009-09-29 22:49:07 +02:00
|
|
|
}
|
|
|
|
for (i = 0; i < n_elems; i++) {
|
2009-12-02 12:36:38 +01:00
|
|
|
void *addr = base_addr + size * i;
|
2009-08-20 19:42:29 +02:00
|
|
|
|
2009-12-02 12:36:37 +01:00
|
|
|
if (field->flags & VMS_ARRAY_OF_POINTER) {
|
|
|
|
addr = *(void **)addr;
|
|
|
|
}
|
2009-09-29 22:49:07 +02:00
|
|
|
if (field->flags & VMS_STRUCT) {
|
|
|
|
vmstate_save_state(f, field->vmsd, addr);
|
|
|
|
} else {
|
2009-12-02 12:36:38 +01:00
|
|
|
field->info->put(f, addr, size);
|
2009-09-29 22:49:07 +02:00
|
|
|
}
|
2009-08-20 19:42:29 +02:00
|
|
|
}
|
2009-08-20 19:42:26 +02:00
|
|
|
}
|
2009-08-20 19:42:25 +02:00
|
|
|
field++;
|
|
|
|
}
|
2010-07-26 21:38:43 +02:00
|
|
|
vmstate_subsection_save(f, vmsd, opaque);
|
2009-08-20 19:42:25 +02:00
|
|
|
}
|
|
|
|
|
2009-08-20 19:42:24 +02:00
|
|
|
static int vmstate_load(QEMUFile *f, SaveStateEntry *se, int version_id)
|
|
|
|
{
|
2009-08-20 19:42:25 +02:00
|
|
|
if (!se->vmsd) { /* Old style */
|
2012-06-26 17:19:10 +02:00
|
|
|
return se->ops->load_state(f, se->opaque, version_id);
|
2009-08-20 19:42:25 +02:00
|
|
|
}
|
|
|
|
return vmstate_load_state(f, se->vmsd, se->opaque, version_id);
|
2009-08-20 19:42:24 +02:00
|
|
|
}
|
|
|
|
|
2011-01-11 22:39:43 +01:00
|
|
|
static void vmstate_save(QEMUFile *f, SaveStateEntry *se)
|
2009-08-20 19:42:24 +02:00
|
|
|
{
|
2009-08-20 19:42:25 +02:00
|
|
|
if (!se->vmsd) { /* Old style */
|
2012-06-26 17:19:10 +02:00
|
|
|
se->ops->save_state(f, se->opaque);
|
2011-01-11 22:39:43 +01:00
|
|
|
return;
|
2009-08-20 19:42:25 +02:00
|
|
|
}
|
2013-11-28 15:01:13 +01:00
|
|
|
vmstate_save_state(f, se->vmsd, se->opaque);
|
2009-08-20 19:42:24 +02:00
|
|
|
}
|
|
|
|
|
2011-12-05 17:48:01 +01:00
|
|
|
bool qemu_savevm_state_blocked(Error **errp)
|
2011-01-11 22:39:43 +01:00
|
|
|
{
|
|
|
|
SaveStateEntry *se;
|
|
|
|
|
|
|
|
QTAILQ_FOREACH(se, &savevm_handlers, entry) {
|
|
|
|
if (se->no_migrate) {
|
2011-12-05 17:48:01 +01:00
|
|
|
error_set(errp, QERR_MIGRATION_NOT_SUPPORTED, se->idstr);
|
2011-01-11 22:39:43 +01:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2013-02-22 17:36:13 +01:00
|
|
|
void qemu_savevm_state_begin(QEMUFile *f,
|
|
|
|
const MigrationParams *params)
|
2008-11-11 22:33:36 +01:00
|
|
|
{
|
|
|
|
SaveStateEntry *se;
|
2011-09-22 11:02:14 +02:00
|
|
|
int ret;
|
2008-11-11 22:33:36 +01:00
|
|
|
|
2009-11-02 14:40:58 +01:00
|
|
|
QTAILQ_FOREACH(se, &savevm_handlers, entry) {
|
2012-06-26 17:19:10 +02:00
|
|
|
if (!se->ops || !se->ops->set_params) {
|
2009-11-02 14:40:58 +01:00
|
|
|
continue;
|
2012-06-19 17:43:09 +02:00
|
|
|
}
|
2012-06-26 17:19:10 +02:00
|
|
|
se->ops->set_params(params, se->opaque);
|
2009-11-02 14:40:58 +01:00
|
|
|
}
|
2013-11-28 15:01:13 +01:00
|
|
|
|
2008-11-11 22:33:36 +01:00
|
|
|
qemu_put_be32(f, QEMU_VM_FILE_MAGIC);
|
|
|
|
qemu_put_be32(f, QEMU_VM_FILE_VERSION);
|
|
|
|
|
2009-09-12 09:36:22 +02:00
|
|
|
QTAILQ_FOREACH(se, &savevm_handlers, entry) {
|
2008-11-11 22:33:36 +01:00
|
|
|
int len;
|
|
|
|
|
2012-06-28 15:11:57 +02:00
|
|
|
if (!se->ops || !se->ops->save_live_setup) {
|
2008-11-11 22:33:36 +01:00
|
|
|
continue;
|
2012-06-26 17:19:10 +02:00
|
|
|
}
|
2012-06-27 10:59:15 +02:00
|
|
|
if (se->ops && se->ops->is_active) {
|
|
|
|
if (!se->ops->is_active(se->opaque)) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
}
|
2008-11-11 22:33:36 +01:00
|
|
|
/* Section type */
|
|
|
|
qemu_put_byte(f, QEMU_VM_SECTION_START);
|
|
|
|
qemu_put_be32(f, se->section_id);
|
|
|
|
|
|
|
|
/* ID string */
|
|
|
|
len = strlen(se->idstr);
|
|
|
|
qemu_put_byte(f, len);
|
|
|
|
qemu_put_buffer(f, (uint8_t *)se->idstr, len);
|
|
|
|
|
|
|
|
qemu_put_be32(f, se->instance_id);
|
|
|
|
qemu_put_be32(f, se->version_id);
|
|
|
|
|
2012-06-28 15:11:57 +02:00
|
|
|
ret = se->ops->save_live_setup(f, se->opaque);
|
2011-10-19 15:22:18 +02:00
|
|
|
if (ret < 0) {
|
2013-02-22 17:36:13 +01:00
|
|
|
qemu_file_set_error(f, ret);
|
|
|
|
break;
|
2011-10-19 15:22:18 +02:00
|
|
|
}
|
2008-11-11 22:33:36 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-09-22 11:02:14 +02:00
|
|
|
/*
|
2011-11-22 11:06:26 +01:00
|
|
|
* this function has three return values:
|
2011-09-22 11:02:14 +02:00
|
|
|
* negative: there was one error, and we have -errno.
|
|
|
|
* 0 : We haven't finished, caller have to go again
|
|
|
|
* 1 : We have finished, we can go to complete phase
|
|
|
|
*/
|
2011-12-05 17:06:56 +01:00
|
|
|
int qemu_savevm_state_iterate(QEMUFile *f)
|
2008-11-11 22:33:36 +01:00
|
|
|
{
|
|
|
|
SaveStateEntry *se;
|
|
|
|
int ret = 1;
|
|
|
|
|
2009-09-12 09:36:22 +02:00
|
|
|
QTAILQ_FOREACH(se, &savevm_handlers, entry) {
|
2012-06-28 15:31:37 +02:00
|
|
|
if (!se->ops || !se->ops->save_live_iterate) {
|
2008-11-11 22:33:36 +01:00
|
|
|
continue;
|
2012-06-26 17:19:10 +02:00
|
|
|
}
|
2012-06-27 10:59:15 +02:00
|
|
|
if (se->ops && se->ops->is_active) {
|
|
|
|
if (!se->ops->is_active(se->opaque)) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
}
|
2012-05-22 00:38:26 +02:00
|
|
|
if (qemu_file_rate_limit(f)) {
|
|
|
|
return 0;
|
|
|
|
}
|
2012-05-21 23:46:44 +02:00
|
|
|
trace_savevm_section_start();
|
2008-11-11 22:33:36 +01:00
|
|
|
/* Section type */
|
|
|
|
qemu_put_byte(f, QEMU_VM_SECTION_PART);
|
|
|
|
qemu_put_be32(f, se->section_id);
|
|
|
|
|
2012-06-28 15:31:37 +02:00
|
|
|
ret = se->ops->save_live_iterate(f, se->opaque);
|
2012-05-21 23:46:44 +02:00
|
|
|
trace_savevm_section_end(se->section_id);
|
|
|
|
|
2013-02-22 17:36:13 +01:00
|
|
|
if (ret < 0) {
|
|
|
|
qemu_file_set_error(f, ret);
|
|
|
|
}
|
2011-10-19 15:22:18 +02:00
|
|
|
if (ret <= 0) {
|
2009-12-01 15:19:55 +01:00
|
|
|
/* Do not proceed to the next vmstate before this one reported
|
|
|
|
completion of the current stage. This serializes the migration
|
|
|
|
and reduces the probability that a faster changing state is
|
|
|
|
synchronized over and over again. */
|
|
|
|
break;
|
|
|
|
}
|
2008-11-11 22:33:36 +01:00
|
|
|
}
|
2011-09-22 11:02:14 +02:00
|
|
|
return ret;
|
2008-11-11 22:33:36 +01:00
|
|
|
}
|
|
|
|
|
2013-02-22 17:36:13 +01:00
|
|
|
void qemu_savevm_state_complete(QEMUFile *f)
|
2008-11-11 22:33:36 +01:00
|
|
|
{
|
|
|
|
SaveStateEntry *se;
|
2011-10-19 15:22:18 +02:00
|
|
|
int ret;
|
2008-11-11 22:33:36 +01:00
|
|
|
|
2010-03-01 19:10:30 +01:00
|
|
|
cpu_synchronize_all_states();
|
|
|
|
|
2009-09-12 09:36:22 +02:00
|
|
|
QTAILQ_FOREACH(se, &savevm_handlers, entry) {
|
2012-06-28 15:31:37 +02:00
|
|
|
if (!se->ops || !se->ops->save_live_complete) {
|
2008-11-11 22:33:36 +01:00
|
|
|
continue;
|
2012-06-26 17:19:10 +02:00
|
|
|
}
|
2012-06-27 10:59:15 +02:00
|
|
|
if (se->ops && se->ops->is_active) {
|
|
|
|
if (!se->ops->is_active(se->opaque)) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
}
|
2012-05-21 23:46:44 +02:00
|
|
|
trace_savevm_section_start();
|
2008-11-11 22:33:36 +01:00
|
|
|
/* Section type */
|
|
|
|
qemu_put_byte(f, QEMU_VM_SECTION_END);
|
|
|
|
qemu_put_be32(f, se->section_id);
|
|
|
|
|
2012-06-28 15:31:37 +02:00
|
|
|
ret = se->ops->save_live_complete(f, se->opaque);
|
2012-05-21 23:46:44 +02:00
|
|
|
trace_savevm_section_end(se->section_id);
|
2011-10-19 15:22:18 +02:00
|
|
|
if (ret < 0) {
|
2013-02-22 17:36:13 +01:00
|
|
|
qemu_file_set_error(f, ret);
|
|
|
|
return;
|
2011-10-19 15:22:18 +02:00
|
|
|
}
|
2008-11-11 22:33:36 +01:00
|
|
|
}
|
|
|
|
|
2009-09-12 09:36:22 +02:00
|
|
|
QTAILQ_FOREACH(se, &savevm_handlers, entry) {
|
2008-11-11 22:33:36 +01:00
|
|
|
int len;
|
|
|
|
|
2012-06-26 17:19:10 +02:00
|
|
|
if ((!se->ops || !se->ops->save_state) && !se->vmsd) {
|
2013-11-28 15:01:12 +01:00
|
|
|
continue;
|
2012-06-26 17:19:10 +02:00
|
|
|
}
|
2012-05-21 23:46:44 +02:00
|
|
|
trace_savevm_section_start();
|
2008-11-11 22:33:36 +01:00
|
|
|
/* Section type */
|
|
|
|
qemu_put_byte(f, QEMU_VM_SECTION_FULL);
|
|
|
|
qemu_put_be32(f, se->section_id);
|
|
|
|
|
|
|
|
/* ID string */
|
|
|
|
len = strlen(se->idstr);
|
|
|
|
qemu_put_byte(f, len);
|
|
|
|
qemu_put_buffer(f, (uint8_t *)se->idstr, len);
|
|
|
|
|
|
|
|
qemu_put_be32(f, se->instance_id);
|
|
|
|
qemu_put_be32(f, se->version_id);
|
|
|
|
|
2011-01-11 22:39:43 +01:00
|
|
|
vmstate_save(f, se);
|
2012-05-21 23:46:44 +02:00
|
|
|
trace_savevm_section_end(se->section_id);
|
2008-11-11 22:33:36 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
qemu_put_byte(f, QEMU_VM_EOF);
|
2013-02-22 17:36:29 +01:00
|
|
|
qemu_fflush(f);
|
2008-11-11 22:33:36 +01:00
|
|
|
}
|
|
|
|
|
2012-09-21 11:18:18 +02:00
|
|
|
uint64_t qemu_savevm_state_pending(QEMUFile *f, uint64_t max_size)
|
|
|
|
{
|
|
|
|
SaveStateEntry *se;
|
|
|
|
uint64_t ret = 0;
|
|
|
|
|
|
|
|
QTAILQ_FOREACH(se, &savevm_handlers, entry) {
|
|
|
|
if (!se->ops || !se->ops->save_live_pending) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
if (se->ops && se->ops->is_active) {
|
|
|
|
if (!se->ops->is_active(se->opaque)) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
ret += se->ops->save_live_pending(f, se->opaque, max_size);
|
|
|
|
}
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2013-01-14 14:14:42 +01:00
|
|
|
void qemu_savevm_state_cancel(void)
|
2009-11-30 18:21:21 +01:00
|
|
|
{
|
|
|
|
SaveStateEntry *se;
|
|
|
|
|
|
|
|
QTAILQ_FOREACH(se, &savevm_handlers, entry) {
|
2012-06-26 19:26:41 +02:00
|
|
|
if (se->ops && se->ops->cancel) {
|
|
|
|
se->ops->cancel(se->opaque);
|
2009-11-30 18:21:21 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-12-05 17:48:01 +01:00
|
|
|
static int qemu_savevm_state(QEMUFile *f)
|
2008-11-11 22:33:36 +01:00
|
|
|
{
|
|
|
|
int ret;
|
2012-06-19 17:43:09 +02:00
|
|
|
MigrationParams params = {
|
|
|
|
.blk = 0,
|
|
|
|
.shared = 0
|
|
|
|
};
|
2008-11-11 22:33:36 +01:00
|
|
|
|
2011-12-05 17:48:01 +01:00
|
|
|
if (qemu_savevm_state_blocked(NULL)) {
|
2013-02-22 17:36:10 +01:00
|
|
|
return -EINVAL;
|
2011-01-11 22:39:43 +01:00
|
|
|
}
|
|
|
|
|
2013-02-22 17:36:28 +01:00
|
|
|
qemu_mutex_unlock_iothread();
|
2013-02-22 17:36:13 +01:00
|
|
|
qemu_savevm_state_begin(f, ¶ms);
|
2013-02-22 17:36:28 +01:00
|
|
|
qemu_mutex_lock_iothread();
|
|
|
|
|
2013-02-22 17:36:13 +01:00
|
|
|
while (qemu_file_get_error(f) == 0) {
|
|
|
|
if (qemu_savevm_state_iterate(f) > 0) {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2008-11-11 22:33:36 +01:00
|
|
|
|
2013-02-22 17:36:13 +01:00
|
|
|
ret = qemu_file_get_error(f);
|
2011-09-22 11:02:14 +02:00
|
|
|
if (ret == 0) {
|
2013-02-22 17:36:13 +01:00
|
|
|
qemu_savevm_state_complete(f);
|
2011-10-05 01:02:52 +02:00
|
|
|
ret = qemu_file_get_error(f);
|
2011-09-22 11:02:14 +02:00
|
|
|
}
|
2013-02-22 17:36:10 +01:00
|
|
|
if (ret != 0) {
|
|
|
|
qemu_savevm_state_cancel();
|
|
|
|
}
|
2008-11-11 22:33:36 +01:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2012-01-25 13:24:51 +01:00
|
|
|
static int qemu_save_device_state(QEMUFile *f)
|
|
|
|
{
|
|
|
|
SaveStateEntry *se;
|
|
|
|
|
|
|
|
qemu_put_be32(f, QEMU_VM_FILE_MAGIC);
|
|
|
|
qemu_put_be32(f, QEMU_VM_FILE_VERSION);
|
|
|
|
|
|
|
|
cpu_synchronize_all_states();
|
|
|
|
|
|
|
|
QTAILQ_FOREACH(se, &savevm_handlers, entry) {
|
|
|
|
int len;
|
|
|
|
|
|
|
|
if (se->is_ram) {
|
|
|
|
continue;
|
|
|
|
}
|
2012-06-26 17:19:10 +02:00
|
|
|
if ((!se->ops || !se->ops->save_state) && !se->vmsd) {
|
2012-01-25 13:24:51 +01:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Section type */
|
|
|
|
qemu_put_byte(f, QEMU_VM_SECTION_FULL);
|
|
|
|
qemu_put_be32(f, se->section_id);
|
|
|
|
|
|
|
|
/* ID string */
|
|
|
|
len = strlen(se->idstr);
|
|
|
|
qemu_put_byte(f, len);
|
|
|
|
qemu_put_buffer(f, (uint8_t *)se->idstr, len);
|
|
|
|
|
|
|
|
qemu_put_be32(f, se->instance_id);
|
|
|
|
qemu_put_be32(f, se->version_id);
|
|
|
|
|
|
|
|
vmstate_save(f, se);
|
|
|
|
}
|
|
|
|
|
|
|
|
qemu_put_byte(f, QEMU_VM_EOF);
|
|
|
|
|
|
|
|
return qemu_file_get_error(f);
|
|
|
|
}
|
|
|
|
|
2008-11-11 22:33:36 +01:00
|
|
|
static SaveStateEntry *find_se(const char *idstr, int instance_id)
|
|
|
|
{
|
|
|
|
SaveStateEntry *se;
|
|
|
|
|
2009-09-12 09:36:22 +02:00
|
|
|
QTAILQ_FOREACH(se, &savevm_handlers, entry) {
|
2008-11-11 22:33:36 +01:00
|
|
|
if (!strcmp(se->idstr, idstr) &&
|
2010-05-15 13:32:40 +02:00
|
|
|
(instance_id == se->instance_id ||
|
|
|
|
instance_id == se->alias_id))
|
2008-11-11 22:33:36 +01:00
|
|
|
return se;
|
2010-06-25 19:09:14 +02:00
|
|
|
/* Migrating from an older version? */
|
|
|
|
if (strstr(se->idstr, idstr) && se->compat) {
|
|
|
|
if (!strcmp(se->compat->idstr, idstr) &&
|
|
|
|
(instance_id == se->compat->instance_id ||
|
|
|
|
instance_id == se->alias_id))
|
|
|
|
return se;
|
|
|
|
}
|
2008-11-11 22:33:36 +01:00
|
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2010-07-26 21:38:43 +02:00
|
|
|
static const VMStateDescription *vmstate_get_subsection(const VMStateSubsection *sub, char *idstr)
|
|
|
|
{
|
2013-11-28 15:01:13 +01:00
|
|
|
while (sub && sub->needed) {
|
2010-07-26 21:38:43 +02:00
|
|
|
if (strcmp(idstr, sub->vmsd->name) == 0) {
|
|
|
|
return sub->vmsd;
|
|
|
|
}
|
|
|
|
sub++;
|
|
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int vmstate_subsection_load(QEMUFile *f, const VMStateDescription *vmsd,
|
|
|
|
void *opaque)
|
|
|
|
{
|
2011-10-04 15:28:31 +02:00
|
|
|
while (qemu_peek_byte(f, 0) == QEMU_VM_SUBSECTION) {
|
2010-07-26 21:38:43 +02:00
|
|
|
char idstr[256];
|
|
|
|
int ret;
|
2011-10-04 15:28:31 +02:00
|
|
|
uint8_t version_id, len, size;
|
2010-07-26 21:38:43 +02:00
|
|
|
const VMStateDescription *sub_vmsd;
|
|
|
|
|
2011-10-04 15:28:31 +02:00
|
|
|
len = qemu_peek_byte(f, 1);
|
|
|
|
if (len < strlen(vmsd->name) + 1) {
|
|
|
|
/* subsection name has be be "section_name/a" */
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
size = qemu_peek_buffer(f, (uint8_t *)idstr, len, 2);
|
|
|
|
if (size != len) {
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
idstr[size] = 0;
|
2010-07-26 21:38:43 +02:00
|
|
|
|
2011-10-04 15:28:31 +02:00
|
|
|
if (strncmp(vmsd->name, idstr, strlen(vmsd->name)) != 0) {
|
|
|
|
/* it don't have a valid subsection name */
|
|
|
|
return 0;
|
|
|
|
}
|
2011-09-30 19:46:43 +02:00
|
|
|
sub_vmsd = vmstate_get_subsection(vmsd->subsections, idstr);
|
2010-07-26 21:38:43 +02:00
|
|
|
if (sub_vmsd == NULL) {
|
|
|
|
return -ENOENT;
|
|
|
|
}
|
2011-10-04 15:28:31 +02:00
|
|
|
qemu_file_skip(f, 1); /* subsection */
|
|
|
|
qemu_file_skip(f, 1); /* len */
|
|
|
|
qemu_file_skip(f, len); /* idstr */
|
|
|
|
version_id = qemu_get_be32(f);
|
|
|
|
|
2010-07-26 21:38:43 +02:00
|
|
|
ret = vmstate_load_state(f, sub_vmsd, opaque, version_id);
|
|
|
|
if (ret) {
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void vmstate_subsection_save(QEMUFile *f, const VMStateDescription *vmsd,
|
|
|
|
void *opaque)
|
|
|
|
{
|
|
|
|
const VMStateSubsection *sub = vmsd->subsections;
|
|
|
|
|
|
|
|
while (sub && sub->needed) {
|
|
|
|
if (sub->needed(opaque)) {
|
|
|
|
const VMStateDescription *vmsd = sub->vmsd;
|
|
|
|
uint8_t len;
|
|
|
|
|
|
|
|
qemu_put_byte(f, QEMU_VM_SUBSECTION);
|
|
|
|
len = strlen(vmsd->name);
|
|
|
|
qemu_put_byte(f, len);
|
|
|
|
qemu_put_buffer(f, (uint8_t *)vmsd->name, len);
|
|
|
|
qemu_put_be32(f, vmsd->version_id);
|
|
|
|
vmstate_save_state(f, vmsd, opaque);
|
|
|
|
}
|
|
|
|
sub++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-11-11 22:33:36 +01:00
|
|
|
typedef struct LoadStateEntry {
|
2009-09-12 09:36:22 +02:00
|
|
|
QLIST_ENTRY(LoadStateEntry) entry;
|
2008-11-11 22:33:36 +01:00
|
|
|
SaveStateEntry *se;
|
|
|
|
int section_id;
|
|
|
|
int version_id;
|
|
|
|
} LoadStateEntry;
|
|
|
|
|
|
|
|
int qemu_loadvm_state(QEMUFile *f)
|
|
|
|
{
|
2009-09-12 09:36:22 +02:00
|
|
|
QLIST_HEAD(, LoadStateEntry) loadvm_handlers =
|
|
|
|
QLIST_HEAD_INITIALIZER(loadvm_handlers);
|
2009-09-01 02:12:33 +02:00
|
|
|
LoadStateEntry *le, *new_le;
|
2008-11-11 22:33:36 +01:00
|
|
|
uint8_t section_type;
|
|
|
|
unsigned int v;
|
|
|
|
int ret;
|
|
|
|
|
2011-12-05 17:48:01 +01:00
|
|
|
if (qemu_savevm_state_blocked(NULL)) {
|
2011-01-11 22:39:43 +01:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2008-11-11 22:33:36 +01:00
|
|
|
v = qemu_get_be32(f);
|
2013-11-28 15:01:13 +01:00
|
|
|
if (v != QEMU_VM_FILE_MAGIC) {
|
2008-11-11 22:33:36 +01:00
|
|
|
return -EINVAL;
|
2013-11-28 15:01:13 +01:00
|
|
|
}
|
2008-11-11 22:33:36 +01:00
|
|
|
|
|
|
|
v = qemu_get_be32(f);
|
2009-09-10 03:04:24 +02:00
|
|
|
if (v == QEMU_VM_FILE_VERSION_COMPAT) {
|
|
|
|
fprintf(stderr, "SaveVM v2 format is obsolete and don't work anymore\n");
|
|
|
|
return -ENOTSUP;
|
|
|
|
}
|
2013-11-28 15:01:13 +01:00
|
|
|
if (v != QEMU_VM_FILE_VERSION) {
|
2008-11-11 22:33:36 +01:00
|
|
|
return -ENOTSUP;
|
2013-11-28 15:01:13 +01:00
|
|
|
}
|
2008-11-11 22:33:36 +01:00
|
|
|
|
|
|
|
while ((section_type = qemu_get_byte(f)) != QEMU_VM_EOF) {
|
|
|
|
uint32_t instance_id, version_id, section_id;
|
|
|
|
SaveStateEntry *se;
|
|
|
|
char idstr[257];
|
|
|
|
int len;
|
|
|
|
|
|
|
|
switch (section_type) {
|
|
|
|
case QEMU_VM_SECTION_START:
|
|
|
|
case QEMU_VM_SECTION_FULL:
|
|
|
|
/* Read section start */
|
|
|
|
section_id = qemu_get_be32(f);
|
|
|
|
len = qemu_get_byte(f);
|
|
|
|
qemu_get_buffer(f, (uint8_t *)idstr, len);
|
|
|
|
idstr[len] = 0;
|
|
|
|
instance_id = qemu_get_be32(f);
|
|
|
|
version_id = qemu_get_be32(f);
|
|
|
|
|
|
|
|
/* Find savevm section */
|
|
|
|
se = find_se(idstr, instance_id);
|
|
|
|
if (se == NULL) {
|
|
|
|
fprintf(stderr, "Unknown savevm section or instance '%s' %d\n", idstr, instance_id);
|
|
|
|
ret = -EINVAL;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Validate version */
|
|
|
|
if (version_id > se->version_id) {
|
|
|
|
fprintf(stderr, "savevm: unsupported version %d for '%s' v%d\n",
|
|
|
|
version_id, idstr, se->version_id);
|
|
|
|
ret = -EINVAL;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Add entry */
|
2011-08-21 05:09:37 +02:00
|
|
|
le = g_malloc0(sizeof(*le));
|
2008-11-11 22:33:36 +01:00
|
|
|
|
|
|
|
le->se = se;
|
|
|
|
le->section_id = section_id;
|
|
|
|
le->version_id = version_id;
|
2009-09-12 09:36:22 +02:00
|
|
|
QLIST_INSERT_HEAD(&loadvm_handlers, le, entry);
|
2008-11-11 22:33:36 +01:00
|
|
|
|
2009-08-20 19:42:24 +02:00
|
|
|
ret = vmstate_load(f, le->se, le->version_id);
|
2009-08-20 19:42:23 +02:00
|
|
|
if (ret < 0) {
|
|
|
|
fprintf(stderr, "qemu: warning: error while loading state for instance 0x%x of device '%s'\n",
|
|
|
|
instance_id, idstr);
|
|
|
|
goto out;
|
|
|
|
}
|
2008-11-11 22:33:36 +01:00
|
|
|
break;
|
|
|
|
case QEMU_VM_SECTION_PART:
|
|
|
|
case QEMU_VM_SECTION_END:
|
|
|
|
section_id = qemu_get_be32(f);
|
|
|
|
|
2009-09-12 09:36:22 +02:00
|
|
|
QLIST_FOREACH(le, &loadvm_handlers, entry) {
|
2009-09-01 02:12:33 +02:00
|
|
|
if (le->section_id == section_id) {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2008-11-11 22:33:36 +01:00
|
|
|
if (le == NULL) {
|
|
|
|
fprintf(stderr, "Unknown savevm section %d\n", section_id);
|
|
|
|
ret = -EINVAL;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2009-08-20 19:42:24 +02:00
|
|
|
ret = vmstate_load(f, le->se, le->version_id);
|
2009-08-20 19:42:23 +02:00
|
|
|
if (ret < 0) {
|
|
|
|
fprintf(stderr, "qemu: warning: error while loading state section id %d\n",
|
|
|
|
section_id);
|
|
|
|
goto out;
|
|
|
|
}
|
2008-11-11 22:33:36 +01:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
fprintf(stderr, "Unknown savevm section type %d\n", section_type);
|
|
|
|
ret = -EINVAL;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-03-01 19:10:30 +01:00
|
|
|
cpu_synchronize_all_post_init();
|
|
|
|
|
2008-11-11 22:33:36 +01:00
|
|
|
ret = 0;
|
|
|
|
|
|
|
|
out:
|
2009-09-12 09:36:22 +02:00
|
|
|
QLIST_FOREACH_SAFE(le, &loadvm_handlers, entry, new_le) {
|
|
|
|
QLIST_REMOVE(le, entry);
|
2011-08-21 05:09:37 +02:00
|
|
|
g_free(le);
|
2008-11-11 22:33:36 +01:00
|
|
|
}
|
|
|
|
|
2011-10-05 01:14:46 +02:00
|
|
|
if (ret == 0) {
|
|
|
|
ret = qemu_file_get_error(f);
|
2011-10-05 01:02:52 +02:00
|
|
|
}
|
2008-11-11 22:33:36 +01:00
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2013-05-25 05:09:42 +02:00
|
|
|
static BlockDriverState *find_vmstate_bs(void)
|
|
|
|
{
|
|
|
|
BlockDriverState *bs = NULL;
|
|
|
|
while ((bs = bdrv_next(bs))) {
|
|
|
|
if (bdrv_can_snapshot(bs)) {
|
|
|
|
return bs;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2009-11-03 17:34:37 +01:00
|
|
|
/*
|
|
|
|
* Deletes snapshots of a given name in all opened images.
|
|
|
|
*/
|
|
|
|
static int del_existing_snapshots(Monitor *mon, const char *name)
|
|
|
|
{
|
|
|
|
BlockDriverState *bs;
|
|
|
|
QEMUSnapshotInfo sn1, *snapshot = &sn1;
|
snapshot: distinguish id and name in snapshot delete
Snapshot creation actually already distinguish id and name since it take
a structured parameter *sn, but delete can't. Later an accurate delete
is needed in qmp_transaction abort and blockdev-snapshot-delete-sync,
so change its prototype. Also *errp is added to tip error, but return
value is kepted to let caller check what kind of error happens. Existing
caller for it are savevm, delvm and qemu-img, they are not impacted by
introducing a new function bdrv_snapshot_delete_by_id_or_name(), which
check the return value and do the operation again.
Before this patch:
For qcow2, it search id first then name to find the one to delete.
For rbd, it search name.
For sheepdog, it does nothing.
After this patch:
For qcow2, logic is the same by call it twice in caller.
For rbd, it always fails in delete with id, but still search for name
in second try, no change to user.
Some code for *errp is based on Pavel's patch.
Signed-off-by: Wenchao Xia <xiawenc@linux.vnet.ibm.com>
Signed-off-by: Pavel Hrdina <phrdina@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
2013-09-11 08:04:33 +02:00
|
|
|
Error *err = NULL;
|
2009-11-03 17:34:37 +01:00
|
|
|
|
2010-06-02 18:55:21 +02:00
|
|
|
bs = NULL;
|
|
|
|
while ((bs = bdrv_next(bs))) {
|
2009-11-03 17:34:37 +01:00
|
|
|
if (bdrv_can_snapshot(bs) &&
|
2013-11-28 15:01:13 +01:00
|
|
|
bdrv_snapshot_find(bs, snapshot, name) >= 0) {
|
snapshot: distinguish id and name in snapshot delete
Snapshot creation actually already distinguish id and name since it take
a structured parameter *sn, but delete can't. Later an accurate delete
is needed in qmp_transaction abort and blockdev-snapshot-delete-sync,
so change its prototype. Also *errp is added to tip error, but return
value is kepted to let caller check what kind of error happens. Existing
caller for it are savevm, delvm and qemu-img, they are not impacted by
introducing a new function bdrv_snapshot_delete_by_id_or_name(), which
check the return value and do the operation again.
Before this patch:
For qcow2, it search id first then name to find the one to delete.
For rbd, it search name.
For sheepdog, it does nothing.
After this patch:
For qcow2, logic is the same by call it twice in caller.
For rbd, it always fails in delete with id, but still search for name
in second try, no change to user.
Some code for *errp is based on Pavel's patch.
Signed-off-by: Wenchao Xia <xiawenc@linux.vnet.ibm.com>
Signed-off-by: Pavel Hrdina <phrdina@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
2013-09-11 08:04:33 +02:00
|
|
|
bdrv_snapshot_delete_by_id_or_name(bs, name, &err);
|
|
|
|
if (error_is_set(&err)) {
|
2009-11-03 17:34:37 +01:00
|
|
|
monitor_printf(mon,
|
snapshot: distinguish id and name in snapshot delete
Snapshot creation actually already distinguish id and name since it take
a structured parameter *sn, but delete can't. Later an accurate delete
is needed in qmp_transaction abort and blockdev-snapshot-delete-sync,
so change its prototype. Also *errp is added to tip error, but return
value is kepted to let caller check what kind of error happens. Existing
caller for it are savevm, delvm and qemu-img, they are not impacted by
introducing a new function bdrv_snapshot_delete_by_id_or_name(), which
check the return value and do the operation again.
Before this patch:
For qcow2, it search id first then name to find the one to delete.
For rbd, it search name.
For sheepdog, it does nothing.
After this patch:
For qcow2, logic is the same by call it twice in caller.
For rbd, it always fails in delete with id, but still search for name
in second try, no change to user.
Some code for *errp is based on Pavel's patch.
Signed-off-by: Wenchao Xia <xiawenc@linux.vnet.ibm.com>
Signed-off-by: Pavel Hrdina <phrdina@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
2013-09-11 08:04:33 +02:00
|
|
|
"Error while deleting snapshot on device '%s':"
|
|
|
|
" %s\n",
|
|
|
|
bdrv_get_device_name(bs),
|
|
|
|
error_get_pretty(err));
|
|
|
|
error_free(err);
|
2009-11-03 17:34:37 +01:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-08-28 20:27:13 +02:00
|
|
|
void do_savevm(Monitor *mon, const QDict *qdict)
|
2008-11-11 22:33:36 +01:00
|
|
|
{
|
|
|
|
BlockDriverState *bs, *bs1;
|
|
|
|
QEMUSnapshotInfo sn1, *sn = &sn1, old_sn1, *old_sn = &old_sn1;
|
2009-11-03 17:34:37 +01:00
|
|
|
int ret;
|
2008-11-11 22:33:36 +01:00
|
|
|
QEMUFile *f;
|
|
|
|
int saved_vm_running;
|
2011-11-16 11:35:54 +01:00
|
|
|
uint64_t vm_state_size;
|
2013-01-07 22:20:27 +01:00
|
|
|
qemu_timeval tv;
|
2010-08-04 19:55:49 +02:00
|
|
|
struct tm tm;
|
2009-08-28 20:27:13 +02:00
|
|
|
const char *name = qdict_get_try_str(qdict, "name");
|
2008-11-11 22:33:36 +01:00
|
|
|
|
savevm: Really verify if a drive supports snapshots
Both bdrv_can_snapshot() and bdrv_has_snapshot() does not work as advertized.
First issue: Their names implies different porpouses, but they do the same thing
and have exactly the same code. Maybe copied and pasted and forgotten?
bdrv_has_snapshot() is called in various places for actually checking if there
is snapshots or not.
Second issue: the way bdrv_can_snapshot() verifies if a block driver supports or
not snapshots does not catch all cases. E.g.: a raw image.
So when do_savevm() is called, first thing it does is to set a global
BlockDriverState to save the VM memory state calling get_bs_snapshots().
static BlockDriverState *get_bs_snapshots(void)
{
BlockDriverState *bs;
DriveInfo *dinfo;
if (bs_snapshots)
return bs_snapshots;
QTAILQ_FOREACH(dinfo, &drives, next) {
bs = dinfo->bdrv;
if (bdrv_can_snapshot(bs))
goto ok;
}
return NULL;
ok:
bs_snapshots = bs;
return bs;
}
bdrv_can_snapshot() may return a BlockDriverState that does not support
snapshots and do_savevm() goes on.
Later on in do_savevm(), we find:
QTAILQ_FOREACH(dinfo, &drives, next) {
bs1 = dinfo->bdrv;
if (bdrv_has_snapshot(bs1)) {
/* Write VM state size only to the image that contains the state */
sn->vm_state_size = (bs == bs1 ? vm_state_size : 0);
ret = bdrv_snapshot_create(bs1, sn);
if (ret < 0) {
monitor_printf(mon, "Error while creating snapshot on '%s'\n",
bdrv_get_device_name(bs1));
}
}
}
bdrv_has_snapshot(bs1) is not checking if the device does support or has
snapshots as explained above. Only in bdrv_snapshot_create() the device is
actually checked for snapshot support.
So, in cases where the first device supports snapshots, and the second does not,
the snapshot on the first will happen anyways. I believe this is not a good
behavior. It should be an all or nothing process.
This patch addresses these issues by making bdrv_can_snapshot() actually do
what it must do and enforces better tests to avoid errors in the middle of
do_savevm(). bdrv_has_snapshot() is removed and replaced by bdrv_can_snapshot()
where appropriate.
bdrv_can_snapshot() was moved from savevm.c to block.c. It makes more sense to me.
The loadvm_state() function was updated too to enforce that when loading a VM at
least all writable devices must support snapshots too.
Signed-off-by: Miguel Di Ciurcio Filho <miguel.filho@gmail.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
2010-06-08 15:40:55 +02:00
|
|
|
/* Verify if there is a device that doesn't support snapshots and is writable */
|
2010-06-02 18:55:21 +02:00
|
|
|
bs = NULL;
|
|
|
|
while ((bs = bdrv_next(bs))) {
|
savevm: Really verify if a drive supports snapshots
Both bdrv_can_snapshot() and bdrv_has_snapshot() does not work as advertized.
First issue: Their names implies different porpouses, but they do the same thing
and have exactly the same code. Maybe copied and pasted and forgotten?
bdrv_has_snapshot() is called in various places for actually checking if there
is snapshots or not.
Second issue: the way bdrv_can_snapshot() verifies if a block driver supports or
not snapshots does not catch all cases. E.g.: a raw image.
So when do_savevm() is called, first thing it does is to set a global
BlockDriverState to save the VM memory state calling get_bs_snapshots().
static BlockDriverState *get_bs_snapshots(void)
{
BlockDriverState *bs;
DriveInfo *dinfo;
if (bs_snapshots)
return bs_snapshots;
QTAILQ_FOREACH(dinfo, &drives, next) {
bs = dinfo->bdrv;
if (bdrv_can_snapshot(bs))
goto ok;
}
return NULL;
ok:
bs_snapshots = bs;
return bs;
}
bdrv_can_snapshot() may return a BlockDriverState that does not support
snapshots and do_savevm() goes on.
Later on in do_savevm(), we find:
QTAILQ_FOREACH(dinfo, &drives, next) {
bs1 = dinfo->bdrv;
if (bdrv_has_snapshot(bs1)) {
/* Write VM state size only to the image that contains the state */
sn->vm_state_size = (bs == bs1 ? vm_state_size : 0);
ret = bdrv_snapshot_create(bs1, sn);
if (ret < 0) {
monitor_printf(mon, "Error while creating snapshot on '%s'\n",
bdrv_get_device_name(bs1));
}
}
}
bdrv_has_snapshot(bs1) is not checking if the device does support or has
snapshots as explained above. Only in bdrv_snapshot_create() the device is
actually checked for snapshot support.
So, in cases where the first device supports snapshots, and the second does not,
the snapshot on the first will happen anyways. I believe this is not a good
behavior. It should be an all or nothing process.
This patch addresses these issues by making bdrv_can_snapshot() actually do
what it must do and enforces better tests to avoid errors in the middle of
do_savevm(). bdrv_has_snapshot() is removed and replaced by bdrv_can_snapshot()
where appropriate.
bdrv_can_snapshot() was moved from savevm.c to block.c. It makes more sense to me.
The loadvm_state() function was updated too to enforce that when loading a VM at
least all writable devices must support snapshots too.
Signed-off-by: Miguel Di Ciurcio Filho <miguel.filho@gmail.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
2010-06-08 15:40:55 +02:00
|
|
|
|
2011-08-03 15:08:11 +02:00
|
|
|
if (!bdrv_is_inserted(bs) || bdrv_is_read_only(bs)) {
|
savevm: Really verify if a drive supports snapshots
Both bdrv_can_snapshot() and bdrv_has_snapshot() does not work as advertized.
First issue: Their names implies different porpouses, but they do the same thing
and have exactly the same code. Maybe copied and pasted and forgotten?
bdrv_has_snapshot() is called in various places for actually checking if there
is snapshots or not.
Second issue: the way bdrv_can_snapshot() verifies if a block driver supports or
not snapshots does not catch all cases. E.g.: a raw image.
So when do_savevm() is called, first thing it does is to set a global
BlockDriverState to save the VM memory state calling get_bs_snapshots().
static BlockDriverState *get_bs_snapshots(void)
{
BlockDriverState *bs;
DriveInfo *dinfo;
if (bs_snapshots)
return bs_snapshots;
QTAILQ_FOREACH(dinfo, &drives, next) {
bs = dinfo->bdrv;
if (bdrv_can_snapshot(bs))
goto ok;
}
return NULL;
ok:
bs_snapshots = bs;
return bs;
}
bdrv_can_snapshot() may return a BlockDriverState that does not support
snapshots and do_savevm() goes on.
Later on in do_savevm(), we find:
QTAILQ_FOREACH(dinfo, &drives, next) {
bs1 = dinfo->bdrv;
if (bdrv_has_snapshot(bs1)) {
/* Write VM state size only to the image that contains the state */
sn->vm_state_size = (bs == bs1 ? vm_state_size : 0);
ret = bdrv_snapshot_create(bs1, sn);
if (ret < 0) {
monitor_printf(mon, "Error while creating snapshot on '%s'\n",
bdrv_get_device_name(bs1));
}
}
}
bdrv_has_snapshot(bs1) is not checking if the device does support or has
snapshots as explained above. Only in bdrv_snapshot_create() the device is
actually checked for snapshot support.
So, in cases where the first device supports snapshots, and the second does not,
the snapshot on the first will happen anyways. I believe this is not a good
behavior. It should be an all or nothing process.
This patch addresses these issues by making bdrv_can_snapshot() actually do
what it must do and enforces better tests to avoid errors in the middle of
do_savevm(). bdrv_has_snapshot() is removed and replaced by bdrv_can_snapshot()
where appropriate.
bdrv_can_snapshot() was moved from savevm.c to block.c. It makes more sense to me.
The loadvm_state() function was updated too to enforce that when loading a VM at
least all writable devices must support snapshots too.
Signed-off-by: Miguel Di Ciurcio Filho <miguel.filho@gmail.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
2010-06-08 15:40:55 +02:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!bdrv_can_snapshot(bs)) {
|
|
|
|
monitor_printf(mon, "Device '%s' is writable but does not support snapshots.\n",
|
|
|
|
bdrv_get_device_name(bs));
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-05-25 05:09:42 +02:00
|
|
|
bs = find_vmstate_bs();
|
2008-11-11 22:33:36 +01:00
|
|
|
if (!bs) {
|
2009-03-06 00:01:23 +01:00
|
|
|
monitor_printf(mon, "No block device can accept snapshots\n");
|
2008-11-11 22:33:36 +01:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2011-07-29 20:36:43 +02:00
|
|
|
saved_vm_running = runstate_is_running();
|
2011-09-30 19:45:27 +02:00
|
|
|
vm_stop(RUN_STATE_SAVE_VM);
|
2008-11-11 22:33:36 +01:00
|
|
|
|
2009-11-03 17:34:37 +01:00
|
|
|
memset(sn, 0, sizeof(*sn));
|
2008-11-11 22:33:36 +01:00
|
|
|
|
|
|
|
/* fill auxiliary fields */
|
2013-01-07 22:20:27 +01:00
|
|
|
qemu_gettimeofday(&tv);
|
2008-11-11 22:33:36 +01:00
|
|
|
sn->date_sec = tv.tv_sec;
|
|
|
|
sn->date_nsec = tv.tv_usec * 1000;
|
2013-08-21 17:03:08 +02:00
|
|
|
sn->vm_clock_nsec = qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL);
|
2008-11-11 22:33:36 +01:00
|
|
|
|
2010-08-04 19:55:49 +02:00
|
|
|
if (name) {
|
|
|
|
ret = bdrv_snapshot_find(bs, old_sn, name);
|
|
|
|
if (ret >= 0) {
|
|
|
|
pstrcpy(sn->name, sizeof(sn->name), old_sn->name);
|
|
|
|
pstrcpy(sn->id_str, sizeof(sn->id_str), old_sn->id_str);
|
|
|
|
} else {
|
|
|
|
pstrcpy(sn->name, sizeof(sn->name), name);
|
|
|
|
}
|
|
|
|
} else {
|
2010-09-09 21:13:04 +02:00
|
|
|
/* cast below needed for OpenBSD where tv_sec is still 'long' */
|
|
|
|
localtime_r((const time_t *)&tv.tv_sec, &tm);
|
2010-08-04 19:55:49 +02:00
|
|
|
strftime(sn->name, sizeof(sn->name), "vm-%Y%m%d%H%M%S", &tm);
|
|
|
|
}
|
|
|
|
|
2009-11-03 17:34:37 +01:00
|
|
|
/* Delete old snapshots of the same name */
|
2010-01-20 17:26:34 +01:00
|
|
|
if (name && del_existing_snapshots(mon, name) < 0) {
|
2009-11-03 17:34:37 +01:00
|
|
|
goto the_end;
|
|
|
|
}
|
|
|
|
|
2008-11-11 22:33:36 +01:00
|
|
|
/* save the VM state */
|
2009-07-10 23:11:57 +02:00
|
|
|
f = qemu_fopen_bdrv(bs, 1);
|
2008-11-11 22:33:36 +01:00
|
|
|
if (!f) {
|
2009-03-06 00:01:23 +01:00
|
|
|
monitor_printf(mon, "Could not open VM state file\n");
|
2008-11-11 22:33:36 +01:00
|
|
|
goto the_end;
|
|
|
|
}
|
2011-12-05 17:48:01 +01:00
|
|
|
ret = qemu_savevm_state(f);
|
2008-12-11 22:06:49 +01:00
|
|
|
vm_state_size = qemu_ftell(f);
|
2008-11-11 22:33:36 +01:00
|
|
|
qemu_fclose(f);
|
|
|
|
if (ret < 0) {
|
2009-03-06 00:01:23 +01:00
|
|
|
monitor_printf(mon, "Error %d while writing VM\n", ret);
|
2008-11-11 22:33:36 +01:00
|
|
|
goto the_end;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* create the snapshots */
|
|
|
|
|
2010-06-02 18:55:21 +02:00
|
|
|
bs1 = NULL;
|
|
|
|
while ((bs1 = bdrv_next(bs1))) {
|
savevm: Really verify if a drive supports snapshots
Both bdrv_can_snapshot() and bdrv_has_snapshot() does not work as advertized.
First issue: Their names implies different porpouses, but they do the same thing
and have exactly the same code. Maybe copied and pasted and forgotten?
bdrv_has_snapshot() is called in various places for actually checking if there
is snapshots or not.
Second issue: the way bdrv_can_snapshot() verifies if a block driver supports or
not snapshots does not catch all cases. E.g.: a raw image.
So when do_savevm() is called, first thing it does is to set a global
BlockDriverState to save the VM memory state calling get_bs_snapshots().
static BlockDriverState *get_bs_snapshots(void)
{
BlockDriverState *bs;
DriveInfo *dinfo;
if (bs_snapshots)
return bs_snapshots;
QTAILQ_FOREACH(dinfo, &drives, next) {
bs = dinfo->bdrv;
if (bdrv_can_snapshot(bs))
goto ok;
}
return NULL;
ok:
bs_snapshots = bs;
return bs;
}
bdrv_can_snapshot() may return a BlockDriverState that does not support
snapshots and do_savevm() goes on.
Later on in do_savevm(), we find:
QTAILQ_FOREACH(dinfo, &drives, next) {
bs1 = dinfo->bdrv;
if (bdrv_has_snapshot(bs1)) {
/* Write VM state size only to the image that contains the state */
sn->vm_state_size = (bs == bs1 ? vm_state_size : 0);
ret = bdrv_snapshot_create(bs1, sn);
if (ret < 0) {
monitor_printf(mon, "Error while creating snapshot on '%s'\n",
bdrv_get_device_name(bs1));
}
}
}
bdrv_has_snapshot(bs1) is not checking if the device does support or has
snapshots as explained above. Only in bdrv_snapshot_create() the device is
actually checked for snapshot support.
So, in cases where the first device supports snapshots, and the second does not,
the snapshot on the first will happen anyways. I believe this is not a good
behavior. It should be an all or nothing process.
This patch addresses these issues by making bdrv_can_snapshot() actually do
what it must do and enforces better tests to avoid errors in the middle of
do_savevm(). bdrv_has_snapshot() is removed and replaced by bdrv_can_snapshot()
where appropriate.
bdrv_can_snapshot() was moved from savevm.c to block.c. It makes more sense to me.
The loadvm_state() function was updated too to enforce that when loading a VM at
least all writable devices must support snapshots too.
Signed-off-by: Miguel Di Ciurcio Filho <miguel.filho@gmail.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
2010-06-08 15:40:55 +02:00
|
|
|
if (bdrv_can_snapshot(bs1)) {
|
2008-12-11 22:06:49 +01:00
|
|
|
/* Write VM state size only to the image that contains the state */
|
|
|
|
sn->vm_state_size = (bs == bs1 ? vm_state_size : 0);
|
2008-11-11 22:33:36 +01:00
|
|
|
ret = bdrv_snapshot_create(bs1, sn);
|
|
|
|
if (ret < 0) {
|
2009-03-06 00:01:23 +01:00
|
|
|
monitor_printf(mon, "Error while creating snapshot on '%s'\n",
|
|
|
|
bdrv_get_device_name(bs1));
|
2008-11-11 22:33:36 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
the_end:
|
2013-11-28 15:01:13 +01:00
|
|
|
if (saved_vm_running) {
|
2008-11-11 22:33:36 +01:00
|
|
|
vm_start();
|
2013-11-28 15:01:13 +01:00
|
|
|
}
|
2008-11-11 22:33:36 +01:00
|
|
|
}
|
|
|
|
|
2012-01-25 13:24:51 +01:00
|
|
|
void qmp_xen_save_devices_state(const char *filename, Error **errp)
|
|
|
|
{
|
|
|
|
QEMUFile *f;
|
|
|
|
int saved_vm_running;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
saved_vm_running = runstate_is_running();
|
|
|
|
vm_stop(RUN_STATE_SAVE_VM);
|
|
|
|
|
|
|
|
f = qemu_fopen(filename, "wb");
|
|
|
|
if (!f) {
|
2013-06-07 20:36:58 +02:00
|
|
|
error_setg_file_open(errp, errno, filename);
|
2012-01-25 13:24:51 +01:00
|
|
|
goto the_end;
|
|
|
|
}
|
|
|
|
ret = qemu_save_device_state(f);
|
|
|
|
qemu_fclose(f);
|
|
|
|
if (ret < 0) {
|
|
|
|
error_set(errp, QERR_IO_ERROR);
|
|
|
|
}
|
|
|
|
|
|
|
|
the_end:
|
2013-11-28 15:01:13 +01:00
|
|
|
if (saved_vm_running) {
|
2012-01-25 13:24:51 +01:00
|
|
|
vm_start();
|
2013-11-28 15:01:13 +01:00
|
|
|
}
|
2012-01-25 13:24:51 +01:00
|
|
|
}
|
|
|
|
|
2010-02-17 16:24:10 +01:00
|
|
|
int load_vmstate(const char *name)
|
2008-11-11 22:33:36 +01:00
|
|
|
{
|
2010-07-19 20:25:01 +02:00
|
|
|
BlockDriverState *bs, *bs_vm_state;
|
2008-12-11 22:06:49 +01:00
|
|
|
QEMUSnapshotInfo sn;
|
2008-11-11 22:33:36 +01:00
|
|
|
QEMUFile *f;
|
2009-07-22 16:42:57 +02:00
|
|
|
int ret;
|
2008-11-11 22:33:36 +01:00
|
|
|
|
2013-05-25 05:09:42 +02:00
|
|
|
bs_vm_state = find_vmstate_bs();
|
2010-07-19 20:25:01 +02:00
|
|
|
if (!bs_vm_state) {
|
|
|
|
error_report("No block device supports snapshots");
|
|
|
|
return -ENOTSUP;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Don't even try to load empty VM states */
|
|
|
|
ret = bdrv_snapshot_find(bs_vm_state, &sn, name);
|
|
|
|
if (ret < 0) {
|
|
|
|
return ret;
|
|
|
|
} else if (sn.vm_state_size == 0) {
|
2011-03-01 10:48:12 +01:00
|
|
|
error_report("This is a disk-only snapshot. Revert to it offline "
|
|
|
|
"using qemu-img.");
|
2010-07-19 20:25:01 +02:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Verify if there is any device that doesn't support snapshots and is
|
|
|
|
writable and check if the requested snapshot is available too. */
|
2010-06-02 18:55:21 +02:00
|
|
|
bs = NULL;
|
|
|
|
while ((bs = bdrv_next(bs))) {
|
savevm: Really verify if a drive supports snapshots
Both bdrv_can_snapshot() and bdrv_has_snapshot() does not work as advertized.
First issue: Their names implies different porpouses, but they do the same thing
and have exactly the same code. Maybe copied and pasted and forgotten?
bdrv_has_snapshot() is called in various places for actually checking if there
is snapshots or not.
Second issue: the way bdrv_can_snapshot() verifies if a block driver supports or
not snapshots does not catch all cases. E.g.: a raw image.
So when do_savevm() is called, first thing it does is to set a global
BlockDriverState to save the VM memory state calling get_bs_snapshots().
static BlockDriverState *get_bs_snapshots(void)
{
BlockDriverState *bs;
DriveInfo *dinfo;
if (bs_snapshots)
return bs_snapshots;
QTAILQ_FOREACH(dinfo, &drives, next) {
bs = dinfo->bdrv;
if (bdrv_can_snapshot(bs))
goto ok;
}
return NULL;
ok:
bs_snapshots = bs;
return bs;
}
bdrv_can_snapshot() may return a BlockDriverState that does not support
snapshots and do_savevm() goes on.
Later on in do_savevm(), we find:
QTAILQ_FOREACH(dinfo, &drives, next) {
bs1 = dinfo->bdrv;
if (bdrv_has_snapshot(bs1)) {
/* Write VM state size only to the image that contains the state */
sn->vm_state_size = (bs == bs1 ? vm_state_size : 0);
ret = bdrv_snapshot_create(bs1, sn);
if (ret < 0) {
monitor_printf(mon, "Error while creating snapshot on '%s'\n",
bdrv_get_device_name(bs1));
}
}
}
bdrv_has_snapshot(bs1) is not checking if the device does support or has
snapshots as explained above. Only in bdrv_snapshot_create() the device is
actually checked for snapshot support.
So, in cases where the first device supports snapshots, and the second does not,
the snapshot on the first will happen anyways. I believe this is not a good
behavior. It should be an all or nothing process.
This patch addresses these issues by making bdrv_can_snapshot() actually do
what it must do and enforces better tests to avoid errors in the middle of
do_savevm(). bdrv_has_snapshot() is removed and replaced by bdrv_can_snapshot()
where appropriate.
bdrv_can_snapshot() was moved from savevm.c to block.c. It makes more sense to me.
The loadvm_state() function was updated too to enforce that when loading a VM at
least all writable devices must support snapshots too.
Signed-off-by: Miguel Di Ciurcio Filho <miguel.filho@gmail.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
2010-06-08 15:40:55 +02:00
|
|
|
|
2011-08-03 15:08:11 +02:00
|
|
|
if (!bdrv_is_inserted(bs) || bdrv_is_read_only(bs)) {
|
savevm: Really verify if a drive supports snapshots
Both bdrv_can_snapshot() and bdrv_has_snapshot() does not work as advertized.
First issue: Their names implies different porpouses, but they do the same thing
and have exactly the same code. Maybe copied and pasted and forgotten?
bdrv_has_snapshot() is called in various places for actually checking if there
is snapshots or not.
Second issue: the way bdrv_can_snapshot() verifies if a block driver supports or
not snapshots does not catch all cases. E.g.: a raw image.
So when do_savevm() is called, first thing it does is to set a global
BlockDriverState to save the VM memory state calling get_bs_snapshots().
static BlockDriverState *get_bs_snapshots(void)
{
BlockDriverState *bs;
DriveInfo *dinfo;
if (bs_snapshots)
return bs_snapshots;
QTAILQ_FOREACH(dinfo, &drives, next) {
bs = dinfo->bdrv;
if (bdrv_can_snapshot(bs))
goto ok;
}
return NULL;
ok:
bs_snapshots = bs;
return bs;
}
bdrv_can_snapshot() may return a BlockDriverState that does not support
snapshots and do_savevm() goes on.
Later on in do_savevm(), we find:
QTAILQ_FOREACH(dinfo, &drives, next) {
bs1 = dinfo->bdrv;
if (bdrv_has_snapshot(bs1)) {
/* Write VM state size only to the image that contains the state */
sn->vm_state_size = (bs == bs1 ? vm_state_size : 0);
ret = bdrv_snapshot_create(bs1, sn);
if (ret < 0) {
monitor_printf(mon, "Error while creating snapshot on '%s'\n",
bdrv_get_device_name(bs1));
}
}
}
bdrv_has_snapshot(bs1) is not checking if the device does support or has
snapshots as explained above. Only in bdrv_snapshot_create() the device is
actually checked for snapshot support.
So, in cases where the first device supports snapshots, and the second does not,
the snapshot on the first will happen anyways. I believe this is not a good
behavior. It should be an all or nothing process.
This patch addresses these issues by making bdrv_can_snapshot() actually do
what it must do and enforces better tests to avoid errors in the middle of
do_savevm(). bdrv_has_snapshot() is removed and replaced by bdrv_can_snapshot()
where appropriate.
bdrv_can_snapshot() was moved from savevm.c to block.c. It makes more sense to me.
The loadvm_state() function was updated too to enforce that when loading a VM at
least all writable devices must support snapshots too.
Signed-off-by: Miguel Di Ciurcio Filho <miguel.filho@gmail.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
2010-06-08 15:40:55 +02:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!bdrv_can_snapshot(bs)) {
|
|
|
|
error_report("Device '%s' is writable but does not support snapshots.",
|
|
|
|
bdrv_get_device_name(bs));
|
|
|
|
return -ENOTSUP;
|
|
|
|
}
|
|
|
|
|
2010-07-19 20:25:01 +02:00
|
|
|
ret = bdrv_snapshot_find(bs, &sn, name);
|
|
|
|
if (ret < 0) {
|
|
|
|
error_report("Device '%s' does not have the requested snapshot '%s'",
|
|
|
|
bdrv_get_device_name(bs), name);
|
|
|
|
return ret;
|
|
|
|
}
|
2008-11-11 22:33:36 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Flush all IO requests so they don't interfere with the new state. */
|
2011-11-30 13:23:43 +01:00
|
|
|
bdrv_drain_all();
|
2008-11-11 22:33:36 +01:00
|
|
|
|
2010-07-19 20:25:01 +02:00
|
|
|
bs = NULL;
|
|
|
|
while ((bs = bdrv_next(bs))) {
|
|
|
|
if (bdrv_can_snapshot(bs)) {
|
|
|
|
ret = bdrv_snapshot_goto(bs, name);
|
2008-11-11 22:33:36 +01:00
|
|
|
if (ret < 0) {
|
2010-07-19 20:25:01 +02:00
|
|
|
error_report("Error %d while activating snapshot '%s' on '%s'",
|
|
|
|
ret, name, bdrv_get_device_name(bs));
|
|
|
|
return ret;
|
2008-11-11 22:33:36 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* restore the VM state */
|
2010-07-19 20:25:01 +02:00
|
|
|
f = qemu_fopen_bdrv(bs_vm_state, 0);
|
2008-11-11 22:33:36 +01:00
|
|
|
if (!f) {
|
2010-02-18 17:25:24 +01:00
|
|
|
error_report("Could not open VM state file");
|
2009-08-20 19:42:22 +02:00
|
|
|
return -EINVAL;
|
2008-11-11 22:33:36 +01:00
|
|
|
}
|
2010-07-19 20:25:01 +02:00
|
|
|
|
2011-06-14 18:29:45 +02:00
|
|
|
qemu_system_reset(VMRESET_SILENT);
|
2008-11-11 22:33:36 +01:00
|
|
|
ret = qemu_loadvm_state(f);
|
2010-07-19 20:25:01 +02:00
|
|
|
|
2008-11-11 22:33:36 +01:00
|
|
|
qemu_fclose(f);
|
|
|
|
if (ret < 0) {
|
2010-02-18 17:25:24 +01:00
|
|
|
error_report("Error %d while loading VM state", ret);
|
2009-08-20 19:42:22 +02:00
|
|
|
return ret;
|
2008-11-11 22:33:36 +01:00
|
|
|
}
|
2010-07-19 20:25:01 +02:00
|
|
|
|
2009-08-20 19:42:22 +02:00
|
|
|
return 0;
|
2009-08-20 19:42:20 +02:00
|
|
|
}
|
|
|
|
|
2009-08-28 20:27:13 +02:00
|
|
|
void do_delvm(Monitor *mon, const QDict *qdict)
|
2008-11-11 22:33:36 +01:00
|
|
|
{
|
|
|
|
BlockDriverState *bs, *bs1;
|
snapshot: distinguish id and name in snapshot delete
Snapshot creation actually already distinguish id and name since it take
a structured parameter *sn, but delete can't. Later an accurate delete
is needed in qmp_transaction abort and blockdev-snapshot-delete-sync,
so change its prototype. Also *errp is added to tip error, but return
value is kepted to let caller check what kind of error happens. Existing
caller for it are savevm, delvm and qemu-img, they are not impacted by
introducing a new function bdrv_snapshot_delete_by_id_or_name(), which
check the return value and do the operation again.
Before this patch:
For qcow2, it search id first then name to find the one to delete.
For rbd, it search name.
For sheepdog, it does nothing.
After this patch:
For qcow2, logic is the same by call it twice in caller.
For rbd, it always fails in delete with id, but still search for name
in second try, no change to user.
Some code for *errp is based on Pavel's patch.
Signed-off-by: Wenchao Xia <xiawenc@linux.vnet.ibm.com>
Signed-off-by: Pavel Hrdina <phrdina@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
2013-09-11 08:04:33 +02:00
|
|
|
Error *err = NULL;
|
2009-08-28 20:27:13 +02:00
|
|
|
const char *name = qdict_get_str(qdict, "name");
|
2008-11-11 22:33:36 +01:00
|
|
|
|
2013-05-25 05:09:42 +02:00
|
|
|
bs = find_vmstate_bs();
|
2008-11-11 22:33:36 +01:00
|
|
|
if (!bs) {
|
2009-03-06 00:01:23 +01:00
|
|
|
monitor_printf(mon, "No block device supports snapshots\n");
|
2008-11-11 22:33:36 +01:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2010-06-02 18:55:21 +02:00
|
|
|
bs1 = NULL;
|
|
|
|
while ((bs1 = bdrv_next(bs1))) {
|
savevm: Really verify if a drive supports snapshots
Both bdrv_can_snapshot() and bdrv_has_snapshot() does not work as advertized.
First issue: Their names implies different porpouses, but they do the same thing
and have exactly the same code. Maybe copied and pasted and forgotten?
bdrv_has_snapshot() is called in various places for actually checking if there
is snapshots or not.
Second issue: the way bdrv_can_snapshot() verifies if a block driver supports or
not snapshots does not catch all cases. E.g.: a raw image.
So when do_savevm() is called, first thing it does is to set a global
BlockDriverState to save the VM memory state calling get_bs_snapshots().
static BlockDriverState *get_bs_snapshots(void)
{
BlockDriverState *bs;
DriveInfo *dinfo;
if (bs_snapshots)
return bs_snapshots;
QTAILQ_FOREACH(dinfo, &drives, next) {
bs = dinfo->bdrv;
if (bdrv_can_snapshot(bs))
goto ok;
}
return NULL;
ok:
bs_snapshots = bs;
return bs;
}
bdrv_can_snapshot() may return a BlockDriverState that does not support
snapshots and do_savevm() goes on.
Later on in do_savevm(), we find:
QTAILQ_FOREACH(dinfo, &drives, next) {
bs1 = dinfo->bdrv;
if (bdrv_has_snapshot(bs1)) {
/* Write VM state size only to the image that contains the state */
sn->vm_state_size = (bs == bs1 ? vm_state_size : 0);
ret = bdrv_snapshot_create(bs1, sn);
if (ret < 0) {
monitor_printf(mon, "Error while creating snapshot on '%s'\n",
bdrv_get_device_name(bs1));
}
}
}
bdrv_has_snapshot(bs1) is not checking if the device does support or has
snapshots as explained above. Only in bdrv_snapshot_create() the device is
actually checked for snapshot support.
So, in cases where the first device supports snapshots, and the second does not,
the snapshot on the first will happen anyways. I believe this is not a good
behavior. It should be an all or nothing process.
This patch addresses these issues by making bdrv_can_snapshot() actually do
what it must do and enforces better tests to avoid errors in the middle of
do_savevm(). bdrv_has_snapshot() is removed and replaced by bdrv_can_snapshot()
where appropriate.
bdrv_can_snapshot() was moved from savevm.c to block.c. It makes more sense to me.
The loadvm_state() function was updated too to enforce that when loading a VM at
least all writable devices must support snapshots too.
Signed-off-by: Miguel Di Ciurcio Filho <miguel.filho@gmail.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
2010-06-08 15:40:55 +02:00
|
|
|
if (bdrv_can_snapshot(bs1)) {
|
snapshot: distinguish id and name in snapshot delete
Snapshot creation actually already distinguish id and name since it take
a structured parameter *sn, but delete can't. Later an accurate delete
is needed in qmp_transaction abort and blockdev-snapshot-delete-sync,
so change its prototype. Also *errp is added to tip error, but return
value is kepted to let caller check what kind of error happens. Existing
caller for it are savevm, delvm and qemu-img, they are not impacted by
introducing a new function bdrv_snapshot_delete_by_id_or_name(), which
check the return value and do the operation again.
Before this patch:
For qcow2, it search id first then name to find the one to delete.
For rbd, it search name.
For sheepdog, it does nothing.
After this patch:
For qcow2, logic is the same by call it twice in caller.
For rbd, it always fails in delete with id, but still search for name
in second try, no change to user.
Some code for *errp is based on Pavel's patch.
Signed-off-by: Wenchao Xia <xiawenc@linux.vnet.ibm.com>
Signed-off-by: Pavel Hrdina <phrdina@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
2013-09-11 08:04:33 +02:00
|
|
|
bdrv_snapshot_delete_by_id_or_name(bs, name, &err);
|
|
|
|
if (error_is_set(&err)) {
|
|
|
|
monitor_printf(mon,
|
|
|
|
"Error while deleting snapshot on device '%s':"
|
|
|
|
" %s\n",
|
|
|
|
bdrv_get_device_name(bs),
|
|
|
|
error_get_pretty(err));
|
|
|
|
error_free(err);
|
2008-11-11 22:33:36 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-01-14 07:06:25 +01:00
|
|
|
void do_info_snapshots(Monitor *mon, const QDict *qdict)
|
2008-11-11 22:33:36 +01:00
|
|
|
{
|
|
|
|
BlockDriverState *bs, *bs1;
|
2010-08-04 19:55:48 +02:00
|
|
|
QEMUSnapshotInfo *sn_tab, *sn, s, *sn_info = &s;
|
|
|
|
int nb_sns, i, ret, available;
|
|
|
|
int total;
|
|
|
|
int *available_snapshots;
|
2008-11-11 22:33:36 +01:00
|
|
|
|
2013-05-25 05:09:42 +02:00
|
|
|
bs = find_vmstate_bs();
|
2008-11-11 22:33:36 +01:00
|
|
|
if (!bs) {
|
2009-03-06 00:01:23 +01:00
|
|
|
monitor_printf(mon, "No available block device supports snapshots\n");
|
2008-11-11 22:33:36 +01:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
nb_sns = bdrv_snapshot_list(bs, &sn_tab);
|
|
|
|
if (nb_sns < 0) {
|
2009-03-06 00:01:23 +01:00
|
|
|
monitor_printf(mon, "bdrv_snapshot_list: error %d\n", nb_sns);
|
2008-11-11 22:33:36 +01:00
|
|
|
return;
|
|
|
|
}
|
2010-08-04 19:55:48 +02:00
|
|
|
|
|
|
|
if (nb_sns == 0) {
|
|
|
|
monitor_printf(mon, "There is no snapshot available.\n");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2011-08-21 05:09:37 +02:00
|
|
|
available_snapshots = g_malloc0(sizeof(int) * nb_sns);
|
2010-08-04 19:55:48 +02:00
|
|
|
total = 0;
|
|
|
|
for (i = 0; i < nb_sns; i++) {
|
2008-11-11 22:33:36 +01:00
|
|
|
sn = &sn_tab[i];
|
2010-08-04 19:55:48 +02:00
|
|
|
available = 1;
|
|
|
|
bs1 = NULL;
|
|
|
|
|
|
|
|
while ((bs1 = bdrv_next(bs1))) {
|
|
|
|
if (bdrv_can_snapshot(bs1) && bs1 != bs) {
|
|
|
|
ret = bdrv_snapshot_find(bs1, sn_info, sn->id_str);
|
|
|
|
if (ret < 0) {
|
|
|
|
available = 0;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (available) {
|
|
|
|
available_snapshots[total] = i;
|
|
|
|
total++;
|
|
|
|
}
|
2008-11-11 22:33:36 +01:00
|
|
|
}
|
2010-08-04 19:55:48 +02:00
|
|
|
|
|
|
|
if (total > 0) {
|
2013-05-25 05:09:45 +02:00
|
|
|
bdrv_snapshot_dump((fprintf_function)monitor_printf, mon, NULL);
|
|
|
|
monitor_printf(mon, "\n");
|
2010-08-04 19:55:48 +02:00
|
|
|
for (i = 0; i < total; i++) {
|
|
|
|
sn = &sn_tab[available_snapshots[i]];
|
2013-05-25 05:09:45 +02:00
|
|
|
bdrv_snapshot_dump((fprintf_function)monitor_printf, mon, sn);
|
|
|
|
monitor_printf(mon, "\n");
|
2010-08-04 19:55:48 +02:00
|
|
|
}
|
|
|
|
} else {
|
|
|
|
monitor_printf(mon, "There is no suitable snapshot available\n");
|
|
|
|
}
|
|
|
|
|
2011-08-21 05:09:37 +02:00
|
|
|
g_free(sn_tab);
|
|
|
|
g_free(available_snapshots);
|
2010-08-04 19:55:48 +02:00
|
|
|
|
2008-11-11 22:33:36 +01:00
|
|
|
}
|
2011-12-20 14:59:12 +01:00
|
|
|
|
|
|
|
void vmstate_register_ram(MemoryRegion *mr, DeviceState *dev)
|
|
|
|
{
|
2012-01-08 12:18:19 +01:00
|
|
|
qemu_ram_set_idstr(memory_region_get_ram_addr(mr) & TARGET_PAGE_MASK,
|
2011-12-20 14:59:12 +01:00
|
|
|
memory_region_name(mr), dev);
|
|
|
|
}
|
|
|
|
|
|
|
|
void vmstate_unregister_ram(MemoryRegion *mr, DeviceState *dev)
|
|
|
|
{
|
|
|
|
/* Nothing do to while the implementation is in RAMBlock */
|
|
|
|
}
|
|
|
|
|
|
|
|
void vmstate_register_ram_global(MemoryRegion *mr)
|
|
|
|
{
|
|
|
|
vmstate_register_ram(mr, NULL);
|
|
|
|
}
|