2008-11-11 22:33:36 +01:00
|
|
|
/*
|
|
|
|
* QEMU System Emulator
|
|
|
|
*
|
|
|
|
* Copyright (c) 2003-2008 Fabrice Bellard
|
2015-05-08 13:20:21 +02:00
|
|
|
* Copyright (c) 2009-2015 Red Hat Inc
|
|
|
|
*
|
|
|
|
* Authors:
|
|
|
|
* Juan Quintela <quintela@redhat.com>
|
2008-11-11 22:33:36 +01:00
|
|
|
*
|
|
|
|
* 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.
|
|
|
|
*/
|
|
|
|
|
2016-01-26 19:16:54 +01:00
|
|
|
#include "qemu/osdep.h"
|
2014-06-20 15:26:08 +02:00
|
|
|
#include "hw/boards.h"
|
2016-06-03 11:58:34 +02:00
|
|
|
#include "hw/xen/xen.h"
|
2012-10-24 08:43:34 +02:00
|
|
|
#include "net/net.h"
|
2017-04-24 20:07:27 +02:00
|
|
|
#include "migration.h"
|
2017-04-20 14:25:55 +02:00
|
|
|
#include "migration/snapshot.h"
|
2017-04-21 17:39:30 +02:00
|
|
|
#include "migration/misc.h"
|
2017-04-24 13:42:55 +02:00
|
|
|
#include "migration/register.h"
|
2017-04-24 18:53:30 +02:00
|
|
|
#include "migration/global_state.h"
|
2017-04-17 20:26:27 +02:00
|
|
|
#include "ram.h"
|
2017-04-17 19:34:36 +02:00
|
|
|
#include "qemu-file-channel.h"
|
2017-04-20 18:52:18 +02:00
|
|
|
#include "qemu-file.h"
|
2017-04-20 14:48:46 +02:00
|
|
|
#include "savevm.h"
|
2017-04-20 13:12:24 +02:00
|
|
|
#include "postcopy-ram.h"
|
2018-02-01 12:18:31 +01:00
|
|
|
#include "qapi/error.h"
|
2015-03-17 17:22:46 +01:00
|
|
|
#include "qapi/qmp/qerror.h"
|
2015-03-17 18:29:20 +01:00
|
|
|
#include "qemu/error-report.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"
|
2017-04-24 20:50:19 +02:00
|
|
|
#include "exec/target_page.h"
|
2012-01-25 13:24:51 +01:00
|
|
|
#include "qmp-commands.h"
|
2012-05-21 23:46:44 +02:00
|
|
|
#include "trace.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"
|
2016-03-20 18:16:19 +01:00
|
|
|
#include "qemu/cutils.h"
|
2016-04-27 12:05:01 +02:00
|
|
|
#include "io/channel-buffer.h"
|
2016-04-27 12:05:08 +02:00
|
|
|
#include "io/channel-file.h"
|
2008-11-11 22:33:36 +01:00
|
|
|
|
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
|
|
|
|
|
2015-11-05 19:10:52 +01:00
|
|
|
const unsigned int postcopy_ram_discard_version = 0;
|
|
|
|
|
2017-04-20 14:48:46 +02:00
|
|
|
/* Subcommands for QEMU_VM_COMMAND */
|
|
|
|
enum qemu_vm_cmd {
|
|
|
|
MIG_CMD_INVALID = 0, /* Must be 0 */
|
|
|
|
MIG_CMD_OPEN_RETURN_PATH, /* Tell the dest to open the Return path */
|
|
|
|
MIG_CMD_PING, /* Request a PONG on the RP */
|
|
|
|
|
|
|
|
MIG_CMD_POSTCOPY_ADVISE, /* Prior to any page transfers, just
|
|
|
|
warn we might want to do PC */
|
|
|
|
MIG_CMD_POSTCOPY_LISTEN, /* Start listening for incoming
|
|
|
|
pages as it's running. */
|
|
|
|
MIG_CMD_POSTCOPY_RUN, /* Start execution */
|
|
|
|
|
|
|
|
MIG_CMD_POSTCOPY_RAM_DISCARD, /* A list of pages to discard that
|
|
|
|
were previously sent during
|
|
|
|
precopy but are dirty. */
|
|
|
|
MIG_CMD_PACKAGED, /* Send a wrapped stream within this stream */
|
|
|
|
MIG_CMD_MAX
|
|
|
|
};
|
|
|
|
|
migration/savevm.c: set MAX_VM_CMD_PACKAGED_SIZE to 1ul << 32
MAX_VM_CMD_PACKAGED_SIZE is a constant used in qemu_savevm_send_packaged
and loadvm_handle_cmd_packaged to determine whether a package is too
big to be sent or received. qemu_savevm_send_packaged is called inside
postcopy_start (migration/migration.c) to send the MigrationState
in a single blob to the destination, using the MIG_CMD_PACKAGED subcommand,
which will read it up using loadvm_handle_cmd_packaged. If the blob is
larger than MAX_VM_CMD_PACKAGED_SIZE, an error is thrown and the postcopy
migration is aborted. Both MAX_VM_CMD_PACKAGED_SIZE and MIG_CMD_PACKAGED
were introduced by commit 11cf1d984b ("MIG_CMD_PACKAGED: Send a packaged
chunk ..."). The constant has its original value of 1ul << 24 (16MB).
The current MAX_VM_CMD_PACKAGED_SIZE value is not enough to support postcopy
migration of bigger pseries guests. The blob size for a postcopy migration of
a pseries guest with the following setup:
qemu-system-ppc64 --nographic -vga none -machine pseries,accel=kvm -m 64G \
-smp 1,maxcpus=32 -device virtio-blk-pci,drive=rootdisk \
-drive file=f27.qcow2,if=none,cache=none,format=qcow2,id=rootdisk \
-netdev user,id=u1 -net nic,netdev=u1
Goes around 12MB. Bumping the RAM to 128G makes the blob sizes goes to 20MB.
With 256G the blob goes to 37MB - more than twice the current maximum size.
At this moment the pseries machine can handle guests with up to 1TB of RAM,
making this postcopy blob goes to 128MB of size approximately.
Following the discussions made in [1], there is a need to understand what
devices are aggressively consuming the blob in that manner and see if that
can be mitigated. Until then, we can set MAX_VM_CMD_PACKAGED_SIZE to the
maximum value allowed. Since the size is a 32 bit int variable, we can set
it as 1ul << 32, giving a maximum blob size of 4G that is enough to support
postcopy migration of 32TB RAM guests given the above constraints.
[1] https://lists.nongnu.org/archive/html/qemu-devel/2018-01/msg06313.html
Signed-off-by: Daniel Henrique Barboza <danielhb@linux.vnet.ibm.com>
Reported-by: Balamuruhan S <bala24@linux.vnet.ibm.com>
Reviewed-by: Juan Quintela <quintela@redhat.com>
Signed-off-by: Juan Quintela <quintela@redhat.com>
Signed-off-by: Dr. David Alan Gilbert <dgilbert@redhat.com>
2018-01-26 16:59:40 +01:00
|
|
|
#define MAX_VM_CMD_PACKAGED_SIZE UINT32_MAX
|
2015-11-05 19:10:45 +01:00
|
|
|
static struct mig_cmd_args {
|
|
|
|
ssize_t len; /* -1 = variable */
|
|
|
|
const char *name;
|
|
|
|
} mig_cmd_args[] = {
|
|
|
|
[MIG_CMD_INVALID] = { .len = -1, .name = "INVALID" },
|
2015-11-05 19:10:46 +01:00
|
|
|
[MIG_CMD_OPEN_RETURN_PATH] = { .len = 0, .name = "OPEN_RETURN_PATH" },
|
|
|
|
[MIG_CMD_PING] = { .len = sizeof(uint32_t), .name = "PING" },
|
2017-07-10 18:30:16 +02:00
|
|
|
[MIG_CMD_POSTCOPY_ADVISE] = { .len = -1, .name = "POSTCOPY_ADVISE" },
|
2015-11-05 19:10:52 +01:00
|
|
|
[MIG_CMD_POSTCOPY_LISTEN] = { .len = 0, .name = "POSTCOPY_LISTEN" },
|
|
|
|
[MIG_CMD_POSTCOPY_RUN] = { .len = 0, .name = "POSTCOPY_RUN" },
|
|
|
|
[MIG_CMD_POSTCOPY_RAM_DISCARD] = {
|
|
|
|
.len = -1, .name = "POSTCOPY_RAM_DISCARD" },
|
2015-11-05 19:10:53 +01:00
|
|
|
[MIG_CMD_PACKAGED] = { .len = 4, .name = "PACKAGED" },
|
2015-11-05 19:10:45 +01:00
|
|
|
[MIG_CMD_MAX] = { .len = -1, .name = "MAX" },
|
|
|
|
};
|
|
|
|
|
2017-07-10 18:30:16 +02:00
|
|
|
/* Note for MIG_CMD_POSTCOPY_ADVISE:
|
|
|
|
* The format of arguments is depending on postcopy mode:
|
|
|
|
* - postcopy RAM only
|
|
|
|
* uint64_t host page size
|
|
|
|
* uint64_t taget page size
|
|
|
|
*
|
|
|
|
* - postcopy RAM and postcopy dirty bitmaps
|
|
|
|
* format is the same as for postcopy RAM only
|
|
|
|
*
|
|
|
|
* - postcopy dirty bitmaps only
|
|
|
|
* Nothing. Command length field is 0.
|
|
|
|
*
|
|
|
|
* Be careful: adding a new postcopy entity with some other parameters should
|
|
|
|
* not break format self-description ability. Good way is to introduce some
|
|
|
|
* generic extendable format with an exception for two old entities.
|
|
|
|
*/
|
|
|
|
|
2009-10-16 01:53:55 +02:00
|
|
|
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;
|
|
|
|
|
2014-03-11 00:42:29 +01:00
|
|
|
trace_qemu_announce_self_iter(qemu_ether_ntoa(&nic->conf->macaddr));
|
2009-11-25 19:49:32 +01:00
|
|
|
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) +
|
2014-05-20 08:01:43 +02:00
|
|
|
self_announce_delay(count));
|
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 */
|
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2015-08-13 12:51:33 +02:00
|
|
|
static ssize_t block_get_buffer(void *opaque, uint8_t *buf, int64_t pos,
|
|
|
|
size_t 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
|
|
|
.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
|
|
|
}
|
|
|
|
|
2011-09-12 16:21:44 +02:00
|
|
|
|
2013-11-29 15:26:02 +01:00
|
|
|
/* QEMUFile timer support.
|
|
|
|
* Not in qemu-file.c to not add qemu-timer.c as dependency to qemu-file.c
|
|
|
|
*/
|
2011-09-12 16:21:44 +02:00
|
|
|
|
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
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2013-11-29 15:26:02 +01:00
|
|
|
/* VMState timer support.
|
|
|
|
* Not in vmstate.c to not add qemu-timer.c as dependency to vmstate.c
|
|
|
|
*/
|
2009-08-20 19:42:26 +02:00
|
|
|
|
2017-01-19 20:00:50 +01:00
|
|
|
static int get_timer(QEMUFile *f, void *pv, size_t size, VMStateField *field)
|
2009-08-20 19:42:26 +02:00
|
|
|
{
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2017-01-19 20:00:50 +01:00
|
|
|
static int put_timer(QEMUFile *f, void *pv, size_t size, VMStateField *field,
|
|
|
|
QJSON *vmdesc)
|
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);
|
2017-01-19 20:00:50 +01:00
|
|
|
|
|
|
|
return 0;
|
2009-08-20 19:42:26 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
const VMStateInfo vmstate_info_timer = {
|
|
|
|
.name = "timer",
|
|
|
|
.get = get_timer,
|
|
|
|
.put = put_timer,
|
|
|
|
};
|
|
|
|
|
2012-10-30 08:45:12 +01:00
|
|
|
|
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;
|
2017-05-24 09:09:58 +02:00
|
|
|
/* version id read from the stream */
|
|
|
|
int load_version_id;
|
2008-11-11 22:33:36 +01:00
|
|
|
int section_id;
|
2017-05-24 09:09:58 +02:00
|
|
|
/* section id read from the stream */
|
|
|
|
int load_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;
|
2012-01-25 13:24:51 +01:00
|
|
|
int is_ram;
|
2008-11-11 22:33:36 +01:00
|
|
|
} SaveStateEntry;
|
|
|
|
|
2015-05-13 13:37:04 +02:00
|
|
|
typedef struct SaveState {
|
|
|
|
QTAILQ_HEAD(, SaveStateEntry) handlers;
|
|
|
|
int global_section_id;
|
2015-05-13 18:17:43 +02:00
|
|
|
uint32_t len;
|
|
|
|
const char *name;
|
2016-10-24 17:26:50 +02:00
|
|
|
uint32_t target_page_bits;
|
2015-05-13 13:37:04 +02:00
|
|
|
} SaveState;
|
|
|
|
|
|
|
|
static SaveState savevm_state = {
|
|
|
|
.handlers = QTAILQ_HEAD_INITIALIZER(savevm_state.handlers),
|
|
|
|
.global_section_id = 0,
|
2015-05-13 18:17:43 +02:00
|
|
|
};
|
|
|
|
|
2017-09-25 13:29:12 +02:00
|
|
|
static int configuration_pre_save(void *opaque)
|
2015-05-13 18:17:43 +02:00
|
|
|
{
|
|
|
|
SaveState *state = opaque;
|
|
|
|
const char *current_name = MACHINE_GET_CLASS(current_machine)->name;
|
|
|
|
|
|
|
|
state->len = strlen(current_name);
|
|
|
|
state->name = current_name;
|
2017-04-24 21:03:48 +02:00
|
|
|
state->target_page_bits = qemu_target_page_bits();
|
2017-09-25 13:29:12 +02:00
|
|
|
|
|
|
|
return 0;
|
2016-10-24 17:26:50 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
static int configuration_pre_load(void *opaque)
|
|
|
|
{
|
|
|
|
SaveState *state = opaque;
|
|
|
|
|
|
|
|
/* If there is no target-page-bits subsection it means the source
|
|
|
|
* predates the variable-target-page-bits support and is using the
|
|
|
|
* minimum possible value for this CPU.
|
|
|
|
*/
|
2017-04-24 21:03:48 +02:00
|
|
|
state->target_page_bits = qemu_target_page_bits_min();
|
2016-10-24 17:26:50 +02:00
|
|
|
return 0;
|
2015-05-13 18:17:43 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
static int configuration_post_load(void *opaque, int version_id)
|
|
|
|
{
|
|
|
|
SaveState *state = opaque;
|
|
|
|
const char *current_name = MACHINE_GET_CLASS(current_machine)->name;
|
|
|
|
|
|
|
|
if (strncmp(state->name, current_name, state->len) != 0) {
|
2016-02-05 09:33:26 +01:00
|
|
|
error_report("Machine type received is '%.*s' and local is '%s'",
|
|
|
|
(int) state->len, state->name, current_name);
|
2015-05-13 18:17:43 +02:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
2016-10-24 17:26:50 +02:00
|
|
|
|
2017-04-24 21:03:48 +02:00
|
|
|
if (state->target_page_bits != qemu_target_page_bits()) {
|
2016-10-24 17:26:50 +02:00
|
|
|
error_report("Received TARGET_PAGE_BITS is %d but local is %d",
|
2017-04-24 21:03:48 +02:00
|
|
|
state->target_page_bits, qemu_target_page_bits());
|
2016-10-24 17:26:50 +02:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2015-05-13 18:17:43 +02:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2016-10-24 17:26:50 +02:00
|
|
|
/* The target-page-bits subsection is present only if the
|
|
|
|
* target page size is not the same as the default (ie the
|
|
|
|
* minimum page size for a variable-page-size guest CPU).
|
|
|
|
* If it is present then it contains the actual target page
|
|
|
|
* bits for the machine, and migration will fail if the
|
|
|
|
* two ends don't agree about it.
|
|
|
|
*/
|
|
|
|
static bool vmstate_target_page_bits_needed(void *opaque)
|
|
|
|
{
|
2017-04-24 21:03:48 +02:00
|
|
|
return qemu_target_page_bits()
|
|
|
|
> qemu_target_page_bits_min();
|
2016-10-24 17:26:50 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
static const VMStateDescription vmstate_target_page_bits = {
|
|
|
|
.name = "configuration/target-page-bits",
|
|
|
|
.version_id = 1,
|
|
|
|
.minimum_version_id = 1,
|
|
|
|
.needed = vmstate_target_page_bits_needed,
|
|
|
|
.fields = (VMStateField[]) {
|
|
|
|
VMSTATE_UINT32(target_page_bits, SaveState),
|
|
|
|
VMSTATE_END_OF_LIST()
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2015-05-13 18:17:43 +02:00
|
|
|
static const VMStateDescription vmstate_configuration = {
|
|
|
|
.name = "configuration",
|
|
|
|
.version_id = 1,
|
2016-10-24 17:26:50 +02:00
|
|
|
.pre_load = configuration_pre_load,
|
2015-05-13 18:17:43 +02:00
|
|
|
.post_load = configuration_post_load,
|
|
|
|
.pre_save = configuration_pre_save,
|
|
|
|
.fields = (VMStateField[]) {
|
|
|
|
VMSTATE_UINT32(len, SaveState),
|
2017-02-03 18:52:17 +01:00
|
|
|
VMSTATE_VBUFFER_ALLOC_UINT32(name, SaveState, 0, NULL, len),
|
2015-05-13 18:17:43 +02:00
|
|
|
VMSTATE_END_OF_LIST()
|
|
|
|
},
|
2016-10-24 17:26:50 +02:00
|
|
|
.subsections = (const VMStateDescription*[]) {
|
|
|
|
&vmstate_target_page_bits,
|
|
|
|
NULL
|
|
|
|
}
|
2015-05-13 13:37:04 +02:00
|
|
|
};
|
2008-11-11 22:33:36 +01:00
|
|
|
|
2014-06-20 15:26:08 +02:00
|
|
|
static void dump_vmstate_vmsd(FILE *out_file,
|
|
|
|
const VMStateDescription *vmsd, int indent,
|
|
|
|
bool is_subsection);
|
|
|
|
|
|
|
|
static void dump_vmstate_vmsf(FILE *out_file, const VMStateField *field,
|
|
|
|
int indent)
|
|
|
|
{
|
|
|
|
fprintf(out_file, "%*s{\n", indent, "");
|
|
|
|
indent += 2;
|
|
|
|
fprintf(out_file, "%*s\"field\": \"%s\",\n", indent, "", field->name);
|
|
|
|
fprintf(out_file, "%*s\"version_id\": %d,\n", indent, "",
|
|
|
|
field->version_id);
|
|
|
|
fprintf(out_file, "%*s\"field_exists\": %s,\n", indent, "",
|
|
|
|
field->field_exists ? "true" : "false");
|
|
|
|
fprintf(out_file, "%*s\"size\": %zu", indent, "", field->size);
|
|
|
|
if (field->vmsd != NULL) {
|
|
|
|
fprintf(out_file, ",\n");
|
|
|
|
dump_vmstate_vmsd(out_file, field->vmsd, indent, false);
|
|
|
|
}
|
|
|
|
fprintf(out_file, "\n%*s}", indent - 2, "");
|
|
|
|
}
|
|
|
|
|
|
|
|
static void dump_vmstate_vmss(FILE *out_file,
|
2014-09-23 14:09:54 +02:00
|
|
|
const VMStateDescription **subsection,
|
2014-06-20 15:26:08 +02:00
|
|
|
int indent)
|
|
|
|
{
|
2014-09-23 14:09:54 +02:00
|
|
|
if (*subsection != NULL) {
|
|
|
|
dump_vmstate_vmsd(out_file, *subsection, indent, true);
|
2014-06-20 15:26:08 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void dump_vmstate_vmsd(FILE *out_file,
|
|
|
|
const VMStateDescription *vmsd, int indent,
|
|
|
|
bool is_subsection)
|
|
|
|
{
|
|
|
|
if (is_subsection) {
|
|
|
|
fprintf(out_file, "%*s{\n", indent, "");
|
|
|
|
} else {
|
|
|
|
fprintf(out_file, "%*s\"%s\": {\n", indent, "", "Description");
|
|
|
|
}
|
|
|
|
indent += 2;
|
|
|
|
fprintf(out_file, "%*s\"name\": \"%s\",\n", indent, "", vmsd->name);
|
|
|
|
fprintf(out_file, "%*s\"version_id\": %d,\n", indent, "",
|
|
|
|
vmsd->version_id);
|
|
|
|
fprintf(out_file, "%*s\"minimum_version_id\": %d", indent, "",
|
|
|
|
vmsd->minimum_version_id);
|
|
|
|
if (vmsd->fields != NULL) {
|
|
|
|
const VMStateField *field = vmsd->fields;
|
|
|
|
bool first;
|
|
|
|
|
|
|
|
fprintf(out_file, ",\n%*s\"Fields\": [\n", indent, "");
|
|
|
|
first = true;
|
|
|
|
while (field->name != NULL) {
|
|
|
|
if (field->flags & VMS_MUST_EXIST) {
|
|
|
|
/* Ignore VMSTATE_VALIDATE bits; these don't get migrated */
|
|
|
|
field++;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
if (!first) {
|
|
|
|
fprintf(out_file, ",\n");
|
|
|
|
}
|
|
|
|
dump_vmstate_vmsf(out_file, field, indent + 2);
|
|
|
|
field++;
|
|
|
|
first = false;
|
|
|
|
}
|
|
|
|
fprintf(out_file, "\n%*s]", indent, "");
|
|
|
|
}
|
|
|
|
if (vmsd->subsections != NULL) {
|
2014-09-23 14:09:54 +02:00
|
|
|
const VMStateDescription **subsection = vmsd->subsections;
|
2014-06-20 15:26:08 +02:00
|
|
|
bool first;
|
|
|
|
|
|
|
|
fprintf(out_file, ",\n%*s\"Subsections\": [\n", indent, "");
|
|
|
|
first = true;
|
2014-09-23 14:09:54 +02:00
|
|
|
while (*subsection != NULL) {
|
2014-06-20 15:26:08 +02:00
|
|
|
if (!first) {
|
|
|
|
fprintf(out_file, ",\n");
|
|
|
|
}
|
|
|
|
dump_vmstate_vmss(out_file, subsection, indent + 2);
|
|
|
|
subsection++;
|
|
|
|
first = false;
|
|
|
|
}
|
|
|
|
fprintf(out_file, "\n%*s]", indent, "");
|
|
|
|
}
|
|
|
|
fprintf(out_file, "\n%*s}", indent - 2, "");
|
|
|
|
}
|
|
|
|
|
|
|
|
static void dump_machine_type(FILE *out_file)
|
|
|
|
{
|
|
|
|
MachineClass *mc;
|
|
|
|
|
|
|
|
mc = MACHINE_GET_CLASS(current_machine);
|
|
|
|
|
|
|
|
fprintf(out_file, " \"vmschkmachine\": {\n");
|
|
|
|
fprintf(out_file, " \"Name\": \"%s\"\n", mc->name);
|
|
|
|
fprintf(out_file, " },\n");
|
|
|
|
}
|
|
|
|
|
|
|
|
void dump_vmstate_json_to_file(FILE *out_file)
|
|
|
|
{
|
|
|
|
GSList *list, *elt;
|
|
|
|
bool first;
|
|
|
|
|
|
|
|
fprintf(out_file, "{\n");
|
|
|
|
dump_machine_type(out_file);
|
|
|
|
|
|
|
|
first = true;
|
|
|
|
list = object_class_get_list(TYPE_DEVICE, true);
|
|
|
|
for (elt = list; elt; elt = elt->next) {
|
|
|
|
DeviceClass *dc = OBJECT_CLASS_CHECK(DeviceClass, elt->data,
|
|
|
|
TYPE_DEVICE);
|
|
|
|
const char *name;
|
|
|
|
int indent = 2;
|
|
|
|
|
|
|
|
if (!dc->vmsd) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!first) {
|
|
|
|
fprintf(out_file, ",\n");
|
|
|
|
}
|
|
|
|
name = object_class_get_name(OBJECT_CLASS(dc));
|
|
|
|
fprintf(out_file, "%*s\"%s\": {\n", indent, "", name);
|
|
|
|
indent += 2;
|
|
|
|
fprintf(out_file, "%*s\"Name\": \"%s\",\n", indent, "", name);
|
|
|
|
fprintf(out_file, "%*s\"version_id\": %d,\n", indent, "",
|
|
|
|
dc->vmsd->version_id);
|
|
|
|
fprintf(out_file, "%*s\"minimum_version_id\": %d,\n", indent, "",
|
|
|
|
dc->vmsd->minimum_version_id);
|
|
|
|
|
|
|
|
dump_vmstate_vmsd(out_file, dc->vmsd, indent, false);
|
|
|
|
|
|
|
|
fprintf(out_file, "\n%*s}", indent - 2, "");
|
|
|
|
first = false;
|
|
|
|
}
|
|
|
|
fprintf(out_file, "\n}\n");
|
|
|
|
fclose(out_file);
|
|
|
|
}
|
|
|
|
|
2009-09-01 02:12:31 +02:00
|
|
|
static int calculate_new_instance_id(const char *idstr)
|
|
|
|
{
|
|
|
|
SaveStateEntry *se;
|
|
|
|
int instance_id = 0;
|
|
|
|
|
2015-05-13 13:37:04 +02:00
|
|
|
QTAILQ_FOREACH(se, &savevm_state.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;
|
|
|
|
|
2015-05-13 13:37:04 +02:00
|
|
|
QTAILQ_FOREACH(se, &savevm_state.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;
|
|
|
|
}
|
|
|
|
|
2017-01-06 05:06:12 +01:00
|
|
|
static inline MigrationPriority save_state_priority(SaveStateEntry *se)
|
|
|
|
{
|
|
|
|
if (se->vmsd) {
|
|
|
|
return se->vmsd->priority;
|
|
|
|
}
|
|
|
|
return MIG_PRI_DEFAULT;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void savevm_state_handler_insert(SaveStateEntry *nse)
|
|
|
|
{
|
|
|
|
MigrationPriority priority = save_state_priority(nse);
|
|
|
|
SaveStateEntry *se;
|
|
|
|
|
|
|
|
assert(priority <= MIG_PRI_MAX);
|
|
|
|
|
|
|
|
QTAILQ_FOREACH(se, &savevm_state.handlers, entry) {
|
|
|
|
if (save_state_priority(se) < priority) {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (se) {
|
|
|
|
QTAILQ_INSERT_BEFORE(se, nse, entry);
|
|
|
|
} else {
|
|
|
|
QTAILQ_INSERT_TAIL(&savevm_state.handlers, nse, entry);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
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
|
|
|
|
2015-09-14 13:51:31 +02:00
|
|
|
se = g_new0(SaveStateEntry, 1);
|
2008-11-11 22:33:36 +01:00
|
|
|
se->version_id = version_id;
|
2015-05-13 13:37:04 +02:00
|
|
|
se->section_id = savevm_state.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;
|
2012-01-25 13:24:51 +01:00
|
|
|
/* if this is a live_savem then set is_ram */
|
2017-06-28 11:52:24 +02:00
|
|
|
if (ops->save_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) {
|
2017-02-02 13:59:55 +01:00
|
|
|
if (snprintf(se->idstr, sizeof(se->idstr), "%s/", id) >=
|
|
|
|
sizeof(se->idstr)) {
|
|
|
|
error_report("Path too long for VMState (%s)", id);
|
|
|
|
g_free(id);
|
|
|
|
g_free(se);
|
|
|
|
|
|
|
|
return -1;
|
|
|
|
}
|
2011-08-21 05:09:37 +02:00
|
|
|
g_free(id);
|
2010-06-25 19:09:14 +02:00
|
|
|
|
2015-09-14 13:51:31 +02:00
|
|
|
se->compat = g_new0(CompatEntry, 1);
|
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);
|
2017-01-06 05:06:12 +01:00
|
|
|
savevm_state_handler_insert(se);
|
2008-11-11 22:33:36 +01:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
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
|
|
|
|
2015-05-13 13:37:04 +02:00
|
|
|
QTAILQ_FOREACH_SAFE(se, &savevm_state.handlers, entry, new_se) {
|
2010-06-25 19:09:14 +02:00
|
|
|
if (strcmp(se->idstr, id) == 0 && se->opaque == opaque) {
|
2015-05-13 13:37:04 +02:00
|
|
|
QTAILQ_REMOVE(&savevm_state.handlers, se, entry);
|
2015-08-26 13:17:18 +02:00
|
|
|
g_free(se->compat);
|
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,
|
2017-02-02 13:59:54 +01:00
|
|
|
int required_for_version,
|
|
|
|
Error **errp)
|
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);
|
|
|
|
|
2015-09-14 13:51:31 +02:00
|
|
|
se = g_new0(SaveStateEntry, 1);
|
2009-08-20 19:42:25 +02:00
|
|
|
se->version_id = vmsd->version_id;
|
2015-05-13 13:37:04 +02:00
|
|
|
se->section_id = savevm_state.global_section_id++;
|
2009-08-20 19:42:25 +02:00
|
|
|
se->opaque = opaque;
|
|
|
|
se->vmsd = vmsd;
|
2010-05-15 13:32:40 +02:00
|
|
|
se->alias_id = alias_id;
|
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) {
|
2017-02-02 13:59:55 +01:00
|
|
|
if (snprintf(se->idstr, sizeof(se->idstr), "%s/", id) >=
|
|
|
|
sizeof(se->idstr)) {
|
|
|
|
error_setg(errp, "Path too long for VMState (%s)", id);
|
|
|
|
g_free(id);
|
|
|
|
g_free(se);
|
|
|
|
|
|
|
|
return -1;
|
|
|
|
}
|
2017-02-21 15:14:51 +01:00
|
|
|
g_free(id);
|
2010-06-25 19:09:14 +02:00
|
|
|
|
2015-09-14 13:51:31 +02:00
|
|
|
se->compat = g_new0(CompatEntry, 1);
|
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);
|
2017-01-06 05:06:12 +01:00
|
|
|
savevm_state_handler_insert(se);
|
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;
|
|
|
|
|
2015-05-13 13:37:04 +02:00
|
|
|
QTAILQ_FOREACH_SAFE(se, &savevm_state.handlers, entry, new_se) {
|
2009-09-10 03:04:29 +02:00
|
|
|
if (se->vmsd == vmsd && se->opaque == opaque) {
|
2015-05-13 13:37:04 +02:00
|
|
|
QTAILQ_REMOVE(&savevm_state.handlers, se, entry);
|
2015-08-26 13:17:18 +02:00
|
|
|
g_free(se->compat);
|
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
|
|
|
}
|
|
|
|
|
2017-05-24 09:28:47 +02:00
|
|
|
static int vmstate_load(QEMUFile *f, SaveStateEntry *se)
|
2009-08-20 19:42:24 +02:00
|
|
|
{
|
2014-03-11 00:42:29 +01:00
|
|
|
trace_vmstate_load(se->idstr, se->vmsd ? se->vmsd->name : "(old)");
|
2009-08-20 19:42:25 +02:00
|
|
|
if (!se->vmsd) { /* Old style */
|
2017-05-24 09:28:47 +02:00
|
|
|
return se->ops->load_state(f, se->opaque, se->load_version_id);
|
2009-08-20 19:42:25 +02:00
|
|
|
}
|
2017-05-24 09:28:47 +02:00
|
|
|
return vmstate_load_state(f, se->vmsd, se->opaque, se->load_version_id);
|
2009-08-20 19:42:24 +02:00
|
|
|
}
|
|
|
|
|
2015-01-22 15:01:39 +01:00
|
|
|
static void vmstate_save_old_style(QEMUFile *f, SaveStateEntry *se, QJSON *vmdesc)
|
|
|
|
{
|
|
|
|
int64_t old_offset, size;
|
|
|
|
|
|
|
|
old_offset = qemu_ftell_fast(f);
|
|
|
|
se->ops->save_state(f, se->opaque);
|
|
|
|
size = qemu_ftell_fast(f) - old_offset;
|
|
|
|
|
|
|
|
if (vmdesc) {
|
|
|
|
json_prop_int(vmdesc, "size", size);
|
|
|
|
json_start_array(vmdesc, "fields");
|
|
|
|
json_start_object(vmdesc, NULL);
|
|
|
|
json_prop_str(vmdesc, "name", "data");
|
|
|
|
json_prop_int(vmdesc, "size", size);
|
|
|
|
json_prop_str(vmdesc, "type", "buffer");
|
|
|
|
json_end_object(vmdesc);
|
|
|
|
json_end_array(vmdesc);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-09-25 13:29:16 +02:00
|
|
|
static int vmstate_save(QEMUFile *f, SaveStateEntry *se, QJSON *vmdesc)
|
2009-08-20 19:42:24 +02:00
|
|
|
{
|
2014-03-11 00:42:29 +01:00
|
|
|
trace_vmstate_save(se->idstr, se->vmsd ? se->vmsd->name : "(old)");
|
2015-01-22 15:01:39 +01:00
|
|
|
if (!se->vmsd) {
|
|
|
|
vmstate_save_old_style(f, se, vmdesc);
|
2017-09-25 13:29:16 +02:00
|
|
|
return 0;
|
2009-08-20 19:42:25 +02:00
|
|
|
}
|
2017-09-25 13:29:16 +02:00
|
|
|
return vmstate_save_state(f, se->vmsd, se->opaque, vmdesc);
|
2009-08-20 19:42:24 +02:00
|
|
|
}
|
|
|
|
|
2015-05-19 13:29:50 +02:00
|
|
|
/*
|
|
|
|
* Write the header for device section (QEMU_VM_SECTION START/END/PART/FULL)
|
|
|
|
*/
|
|
|
|
static void save_section_header(QEMUFile *f, SaveStateEntry *se,
|
|
|
|
uint8_t section_type)
|
|
|
|
{
|
|
|
|
qemu_put_byte(f, section_type);
|
|
|
|
qemu_put_be32(f, se->section_id);
|
|
|
|
|
|
|
|
if (section_type == QEMU_VM_SECTION_FULL ||
|
|
|
|
section_type == QEMU_VM_SECTION_START) {
|
|
|
|
/* ID string */
|
|
|
|
size_t 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);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-05-19 13:29:52 +02:00
|
|
|
/*
|
|
|
|
* Write a footer onto device sections that catches cases misformatted device
|
|
|
|
* sections.
|
|
|
|
*/
|
|
|
|
static void save_section_footer(QEMUFile *f, SaveStateEntry *se)
|
|
|
|
{
|
2017-06-27 06:10:17 +02:00
|
|
|
if (migrate_get_current()->send_section_footer) {
|
2015-05-19 13:29:52 +02:00
|
|
|
qemu_put_byte(f, QEMU_VM_SECTION_FOOTER);
|
|
|
|
qemu_put_be32(f, se->section_id);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-11-05 19:10:45 +01:00
|
|
|
/**
|
|
|
|
* qemu_savevm_command_send: Send a 'QEMU_VM_COMMAND' type element with the
|
|
|
|
* command and associated data.
|
|
|
|
*
|
|
|
|
* @f: File to send command on
|
|
|
|
* @command: Command type to send
|
|
|
|
* @len: Length of associated data
|
|
|
|
* @data: Data associated with command.
|
|
|
|
*/
|
2017-04-20 14:48:46 +02:00
|
|
|
static void qemu_savevm_command_send(QEMUFile *f,
|
|
|
|
enum qemu_vm_cmd command,
|
|
|
|
uint16_t len,
|
|
|
|
uint8_t *data)
|
2015-11-05 19:10:45 +01:00
|
|
|
{
|
|
|
|
trace_savevm_command_send(command, len);
|
|
|
|
qemu_put_byte(f, QEMU_VM_COMMAND);
|
|
|
|
qemu_put_be16(f, (uint16_t)command);
|
|
|
|
qemu_put_be16(f, len);
|
|
|
|
qemu_put_buffer(f, data, len);
|
|
|
|
qemu_fflush(f);
|
|
|
|
}
|
|
|
|
|
2015-11-05 19:10:46 +01:00
|
|
|
void qemu_savevm_send_ping(QEMUFile *f, uint32_t value)
|
|
|
|
{
|
|
|
|
uint32_t buf;
|
|
|
|
|
|
|
|
trace_savevm_send_ping(value);
|
|
|
|
buf = cpu_to_be32(value);
|
|
|
|
qemu_savevm_command_send(f, MIG_CMD_PING, sizeof(value), (uint8_t *)&buf);
|
|
|
|
}
|
|
|
|
|
|
|
|
void qemu_savevm_send_open_return_path(QEMUFile *f)
|
|
|
|
{
|
|
|
|
trace_savevm_send_open_return_path();
|
|
|
|
qemu_savevm_command_send(f, MIG_CMD_OPEN_RETURN_PATH, 0, NULL);
|
|
|
|
}
|
|
|
|
|
2015-11-05 19:10:53 +01:00
|
|
|
/* We have a buffer of data to send; we don't want that all to be loaded
|
|
|
|
* by the command itself, so the command contains just the length of the
|
|
|
|
* extra buffer that we then send straight after it.
|
|
|
|
* TODO: Must be a better way to organise that
|
|
|
|
*
|
|
|
|
* Returns:
|
|
|
|
* 0 on success
|
|
|
|
* -ve on error
|
|
|
|
*/
|
2016-04-27 12:05:01 +02:00
|
|
|
int qemu_savevm_send_packaged(QEMUFile *f, const uint8_t *buf, size_t len)
|
2015-11-05 19:10:53 +01:00
|
|
|
{
|
|
|
|
uint32_t tmp;
|
|
|
|
|
|
|
|
if (len > MAX_VM_CMD_PACKAGED_SIZE) {
|
|
|
|
error_report("%s: Unreasonably large packaged state: %zu",
|
|
|
|
__func__, len);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
tmp = cpu_to_be32(len);
|
|
|
|
|
|
|
|
trace_qemu_savevm_send_packaged();
|
|
|
|
qemu_savevm_command_send(f, MIG_CMD_PACKAGED, 4, (uint8_t *)&tmp);
|
|
|
|
|
2016-04-27 12:05:01 +02:00
|
|
|
qemu_put_buffer(f, buf, len);
|
2015-11-05 19:10:53 +01:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2015-11-05 19:10:52 +01:00
|
|
|
/* Send prior to any postcopy transfer */
|
|
|
|
void qemu_savevm_send_postcopy_advise(QEMUFile *f)
|
|
|
|
{
|
2017-07-10 18:30:16 +02:00
|
|
|
if (migrate_postcopy_ram()) {
|
|
|
|
uint64_t tmp[2];
|
|
|
|
tmp[0] = cpu_to_be64(ram_pagesize_summary());
|
|
|
|
tmp[1] = cpu_to_be64(qemu_target_page_size());
|
|
|
|
|
|
|
|
trace_qemu_savevm_send_postcopy_advise();
|
|
|
|
qemu_savevm_command_send(f, MIG_CMD_POSTCOPY_ADVISE,
|
|
|
|
16, (uint8_t *)tmp);
|
|
|
|
} else {
|
|
|
|
qemu_savevm_command_send(f, MIG_CMD_POSTCOPY_ADVISE, 0, NULL);
|
|
|
|
}
|
2015-11-05 19:10:52 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Sent prior to starting the destination running in postcopy, discard pages
|
|
|
|
* that have already been sent but redirtied on the source.
|
|
|
|
* CMD_POSTCOPY_RAM_DISCARD consist of:
|
|
|
|
* byte version (0)
|
|
|
|
* byte Length of name field (not including 0)
|
|
|
|
* n x byte RAM block name
|
|
|
|
* byte 0 terminator (just for safety)
|
|
|
|
* n x Byte ranges within the named RAMBlock
|
|
|
|
* be64 Start of the range
|
|
|
|
* be64 Length
|
|
|
|
*
|
|
|
|
* name: RAMBlock name that these entries are part of
|
|
|
|
* len: Number of page entries
|
|
|
|
* start_list: 'len' addresses
|
|
|
|
* length_list: 'len' addresses
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
void qemu_savevm_send_postcopy_ram_discard(QEMUFile *f, const char *name,
|
|
|
|
uint16_t len,
|
|
|
|
uint64_t *start_list,
|
|
|
|
uint64_t *length_list)
|
|
|
|
{
|
|
|
|
uint8_t *buf;
|
|
|
|
uint16_t tmplen;
|
|
|
|
uint16_t t;
|
|
|
|
size_t name_len = strlen(name);
|
|
|
|
|
|
|
|
trace_qemu_savevm_send_postcopy_ram_discard(name, len);
|
|
|
|
assert(name_len < 256);
|
|
|
|
buf = g_malloc0(1 + 1 + name_len + 1 + (8 + 8) * len);
|
|
|
|
buf[0] = postcopy_ram_discard_version;
|
|
|
|
buf[1] = name_len;
|
|
|
|
memcpy(buf + 2, name, name_len);
|
|
|
|
tmplen = 2 + name_len;
|
|
|
|
buf[tmplen++] = '\0';
|
|
|
|
|
|
|
|
for (t = 0; t < len; t++) {
|
2016-06-10 18:09:22 +02:00
|
|
|
stq_be_p(buf + tmplen, start_list[t]);
|
2015-11-05 19:10:52 +01:00
|
|
|
tmplen += 8;
|
2016-06-10 18:09:22 +02:00
|
|
|
stq_be_p(buf + tmplen, length_list[t]);
|
2015-11-05 19:10:52 +01:00
|
|
|
tmplen += 8;
|
|
|
|
}
|
|
|
|
qemu_savevm_command_send(f, MIG_CMD_POSTCOPY_RAM_DISCARD, tmplen, buf);
|
|
|
|
g_free(buf);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Get the destination into a state where it can receive postcopy data. */
|
|
|
|
void qemu_savevm_send_postcopy_listen(QEMUFile *f)
|
|
|
|
{
|
|
|
|
trace_savevm_send_postcopy_listen();
|
|
|
|
qemu_savevm_command_send(f, MIG_CMD_POSTCOPY_LISTEN, 0, NULL);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Kick the destination into running */
|
|
|
|
void qemu_savevm_send_postcopy_run(QEMUFile *f)
|
|
|
|
{
|
|
|
|
trace_savevm_send_postcopy_run();
|
|
|
|
qemu_savevm_command_send(f, MIG_CMD_POSTCOPY_RUN, 0, NULL);
|
|
|
|
}
|
|
|
|
|
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;
|
|
|
|
|
2015-05-13 13:37:04 +02:00
|
|
|
QTAILQ_FOREACH(se, &savevm_state.handlers, entry) {
|
2014-05-14 21:30:08 +02:00
|
|
|
if (se->vmsd && se->vmsd->unmigratable) {
|
2014-03-22 00:42:26 +01:00
|
|
|
error_setg(errp, "State blocked by non-migratable device '%s'",
|
|
|
|
se->idstr);
|
2011-01-11 22:39:43 +01:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2015-05-21 14:24:12 +02:00
|
|
|
void qemu_savevm_state_header(QEMUFile *f)
|
|
|
|
{
|
|
|
|
trace_savevm_state_header();
|
|
|
|
qemu_put_be32(f, QEMU_VM_FILE_MAGIC);
|
|
|
|
qemu_put_be32(f, QEMU_VM_FILE_VERSION);
|
2015-11-05 19:10:30 +01:00
|
|
|
|
2017-06-27 06:10:18 +02:00
|
|
|
if (migrate_get_current()->send_configuration) {
|
2015-11-05 19:10:30 +01:00
|
|
|
qemu_put_byte(f, QEMU_VM_CONFIGURATION);
|
|
|
|
vmstate_save_state(f, &vmstate_configuration, &savevm_state, 0);
|
|
|
|
}
|
2015-05-21 14:24:12 +02:00
|
|
|
}
|
|
|
|
|
2017-06-28 11:52:24 +02:00
|
|
|
void qemu_savevm_state_setup(QEMUFile *f)
|
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
|
|
|
|
2017-06-28 11:52:24 +02:00
|
|
|
trace_savevm_state_setup();
|
2015-05-13 13:37:04 +02:00
|
|
|
QTAILQ_FOREACH(se, &savevm_state.handlers, entry) {
|
2017-06-28 11:52:24 +02:00
|
|
|
if (!se->ops || !se->ops->save_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;
|
|
|
|
}
|
|
|
|
}
|
2015-05-19 13:29:50 +02:00
|
|
|
save_section_header(f, se, QEMU_VM_SECTION_START);
|
2008-11-11 22:33:36 +01:00
|
|
|
|
2017-06-28 11:52:24 +02:00
|
|
|
ret = se->ops->save_setup(f, se->opaque);
|
2015-05-19 13:29:52 +02:00
|
|
|
save_section_footer(f, se);
|
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
|
|
|
|
*/
|
2015-11-05 19:11:14 +01:00
|
|
|
int qemu_savevm_state_iterate(QEMUFile *f, bool postcopy)
|
2008-11-11 22:33:36 +01:00
|
|
|
{
|
|
|
|
SaveStateEntry *se;
|
|
|
|
int ret = 1;
|
|
|
|
|
2014-03-11 00:42:29 +01:00
|
|
|
trace_savevm_state_iterate();
|
2015-05-13 13:37:04 +02:00
|
|
|
QTAILQ_FOREACH(se, &savevm_state.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;
|
|
|
|
}
|
|
|
|
}
|
2015-11-05 19:11:14 +01:00
|
|
|
/*
|
|
|
|
* In the postcopy phase, any device that doesn't know how to
|
|
|
|
* do postcopy should have saved it's state in the _complete
|
|
|
|
* call that's already run, it might get confused if we call
|
|
|
|
* iterate afterwards.
|
|
|
|
*/
|
2017-07-10 18:30:14 +02:00
|
|
|
if (postcopy &&
|
|
|
|
!(se->ops->has_postcopy && se->ops->has_postcopy(se->opaque))) {
|
2015-11-05 19:11:14 +01:00
|
|
|
continue;
|
|
|
|
}
|
2012-05-22 00:38:26 +02:00
|
|
|
if (qemu_file_rate_limit(f)) {
|
|
|
|
return 0;
|
|
|
|
}
|
2014-03-06 21:03:37 +01:00
|
|
|
trace_savevm_section_start(se->idstr, se->section_id);
|
2015-05-19 13:29:50 +02:00
|
|
|
|
|
|
|
save_section_header(f, se, QEMU_VM_SECTION_PART);
|
2008-11-11 22:33:36 +01:00
|
|
|
|
2012-06-28 15:31:37 +02:00
|
|
|
ret = se->ops->save_live_iterate(f, se->opaque);
|
2015-01-21 11:14:48 +01:00
|
|
|
trace_savevm_section_end(se->idstr, se->section_id, ret);
|
2015-05-19 13:29:52 +02:00
|
|
|
save_section_footer(f, se);
|
2012-05-21 23:46:44 +02:00
|
|
|
|
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
|
|
|
}
|
|
|
|
|
2015-02-23 13:56:42 +01:00
|
|
|
static bool should_send_vmdesc(void)
|
|
|
|
{
|
|
|
|
MachineState *machine = MACHINE(qdev_get_machine());
|
2017-03-20 22:25:28 +01:00
|
|
|
bool in_postcopy = migration_in_postcopy();
|
2015-11-05 19:10:59 +01:00
|
|
|
return !machine->suppress_vmdesc && !in_postcopy;
|
2015-02-23 13:56:42 +01:00
|
|
|
}
|
|
|
|
|
2015-11-05 19:11:00 +01:00
|
|
|
/*
|
|
|
|
* Calls the save_live_complete_postcopy methods
|
|
|
|
* causing the last few pages to be sent immediately and doing any associated
|
|
|
|
* cleanup.
|
|
|
|
* Note postcopy also calls qemu_savevm_state_complete_precopy to complete
|
|
|
|
* all the other devices, but that happens at the point we switch to postcopy.
|
|
|
|
*/
|
|
|
|
void qemu_savevm_state_complete_postcopy(QEMUFile *f)
|
|
|
|
{
|
|
|
|
SaveStateEntry *se;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
QTAILQ_FOREACH(se, &savevm_state.handlers, entry) {
|
|
|
|
if (!se->ops || !se->ops->save_live_complete_postcopy) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
if (se->ops && se->ops->is_active) {
|
|
|
|
if (!se->ops->is_active(se->opaque)) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
trace_savevm_section_start(se->idstr, se->section_id);
|
|
|
|
/* Section type */
|
|
|
|
qemu_put_byte(f, QEMU_VM_SECTION_END);
|
|
|
|
qemu_put_be32(f, se->section_id);
|
|
|
|
|
|
|
|
ret = se->ops->save_live_complete_postcopy(f, se->opaque);
|
|
|
|
trace_savevm_section_end(se->idstr, se->section_id, ret);
|
|
|
|
save_section_footer(f, se);
|
|
|
|
if (ret < 0) {
|
|
|
|
qemu_file_set_error(f, ret);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
qemu_put_byte(f, QEMU_VM_EOF);
|
|
|
|
qemu_fflush(f);
|
|
|
|
}
|
|
|
|
|
2017-06-16 18:06:58 +02:00
|
|
|
int qemu_savevm_state_complete_precopy(QEMUFile *f, bool iterable_only,
|
|
|
|
bool inactivate_disks)
|
2008-11-11 22:33:36 +01:00
|
|
|
{
|
2015-01-22 15:01:39 +01:00
|
|
|
QJSON *vmdesc;
|
|
|
|
int vmdesc_len;
|
2008-11-11 22:33:36 +01:00
|
|
|
SaveStateEntry *se;
|
2011-10-19 15:22:18 +02:00
|
|
|
int ret;
|
2017-03-20 22:25:28 +01:00
|
|
|
bool in_postcopy = migration_in_postcopy();
|
2008-11-11 22:33:36 +01:00
|
|
|
|
2015-11-05 19:10:41 +01:00
|
|
|
trace_savevm_state_complete_precopy();
|
2014-03-11 00:42:29 +01:00
|
|
|
|
2010-03-01 19:10:30 +01:00
|
|
|
cpu_synchronize_all_states();
|
|
|
|
|
2015-05-13 13:37:04 +02:00
|
|
|
QTAILQ_FOREACH(se, &savevm_state.handlers, entry) {
|
2015-11-05 19:11:00 +01:00
|
|
|
if (!se->ops ||
|
2017-07-10 18:30:14 +02:00
|
|
|
(in_postcopy && se->ops->has_postcopy &&
|
|
|
|
se->ops->has_postcopy(se->opaque)) ||
|
2015-11-11 15:02:27 +01:00
|
|
|
(in_postcopy && !iterable_only) ||
|
2015-11-05 19:11:00 +01:00
|
|
|
!se->ops->save_live_complete_precopy) {
|
2008-11-11 22:33:36 +01:00
|
|
|
continue;
|
2012-06-26 17:19:10 +02:00
|
|
|
}
|
2015-11-11 15:02:27 +01:00
|
|
|
|
2012-06-27 10:59:15 +02:00
|
|
|
if (se->ops && se->ops->is_active) {
|
|
|
|
if (!se->ops->is_active(se->opaque)) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
}
|
2014-03-06 21:03:37 +01:00
|
|
|
trace_savevm_section_start(se->idstr, se->section_id);
|
2015-05-19 13:29:50 +02:00
|
|
|
|
|
|
|
save_section_header(f, se, QEMU_VM_SECTION_END);
|
2008-11-11 22:33:36 +01:00
|
|
|
|
2015-11-05 19:10:41 +01:00
|
|
|
ret = se->ops->save_live_complete_precopy(f, se->opaque);
|
2015-01-21 11:14:48 +01:00
|
|
|
trace_savevm_section_end(se->idstr, se->section_id, ret);
|
2015-05-19 13:29:52 +02:00
|
|
|
save_section_footer(f, se);
|
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);
|
2017-06-16 18:06:58 +02:00
|
|
|
return -1;
|
2011-10-19 15:22:18 +02:00
|
|
|
}
|
2008-11-11 22:33:36 +01:00
|
|
|
}
|
|
|
|
|
2015-11-11 15:02:27 +01:00
|
|
|
if (iterable_only) {
|
2017-06-16 18:06:58 +02:00
|
|
|
return 0;
|
2015-11-11 15:02:27 +01:00
|
|
|
}
|
|
|
|
|
2015-01-22 15:01:39 +01:00
|
|
|
vmdesc = qjson_new();
|
2017-04-24 21:03:48 +02:00
|
|
|
json_prop_int(vmdesc, "page_size", qemu_target_page_size());
|
2015-01-22 15:01:39 +01:00
|
|
|
json_start_array(vmdesc, "devices");
|
2015-05-13 13:37:04 +02:00
|
|
|
QTAILQ_FOREACH(se, &savevm_state.handlers, entry) {
|
2008-11-11 22:33:36 +01:00
|
|
|
|
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
|
|
|
}
|
2014-10-15 09:39:14 +02:00
|
|
|
if (se->vmsd && !vmstate_save_needed(se->vmsd, se->opaque)) {
|
|
|
|
trace_savevm_section_skip(se->idstr, se->section_id);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2014-03-06 21:03:37 +01:00
|
|
|
trace_savevm_section_start(se->idstr, se->section_id);
|
2015-01-22 15:01:39 +01:00
|
|
|
|
|
|
|
json_start_object(vmdesc, NULL);
|
|
|
|
json_prop_str(vmdesc, "name", se->idstr);
|
|
|
|
json_prop_int(vmdesc, "instance_id", se->instance_id);
|
|
|
|
|
2015-05-19 13:29:50 +02:00
|
|
|
save_section_header(f, se, QEMU_VM_SECTION_FULL);
|
2017-09-25 13:29:16 +02:00
|
|
|
ret = vmstate_save(f, se, vmdesc);
|
|
|
|
if (ret) {
|
|
|
|
qemu_file_set_error(f, ret);
|
|
|
|
return ret;
|
|
|
|
}
|
2015-01-21 11:14:48 +01:00
|
|
|
trace_savevm_section_end(se->idstr, se->section_id, 0);
|
2015-05-19 13:29:52 +02:00
|
|
|
save_section_footer(f, se);
|
2016-02-04 23:50:30 +01:00
|
|
|
|
|
|
|
json_end_object(vmdesc);
|
2008-11-11 22:33:36 +01:00
|
|
|
}
|
|
|
|
|
2017-06-16 18:06:58 +02:00
|
|
|
if (inactivate_disks) {
|
|
|
|
/* Inactivate before sending QEMU_VM_EOF so that the
|
|
|
|
* bdrv_invalidate_cache_all() on the other end won't fail. */
|
|
|
|
ret = bdrv_inactivate_all();
|
|
|
|
if (ret) {
|
2017-08-22 19:02:12 +02:00
|
|
|
error_report("%s: bdrv_inactivate_all() failed (%d)",
|
|
|
|
__func__, ret);
|
2017-06-16 18:06:58 +02:00
|
|
|
qemu_file_set_error(f, ret);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
}
|
2015-11-05 19:11:00 +01:00
|
|
|
if (!in_postcopy) {
|
|
|
|
/* Postcopy stream will still be going */
|
|
|
|
qemu_put_byte(f, QEMU_VM_EOF);
|
|
|
|
}
|
2015-01-22 15:01:39 +01:00
|
|
|
|
|
|
|
json_end_array(vmdesc);
|
|
|
|
qjson_finish(vmdesc);
|
|
|
|
vmdesc_len = strlen(qjson_get_str(vmdesc));
|
|
|
|
|
2015-02-23 13:56:42 +01:00
|
|
|
if (should_send_vmdesc()) {
|
|
|
|
qemu_put_byte(f, QEMU_VM_VMDESCRIPTION);
|
|
|
|
qemu_put_be32(f, vmdesc_len);
|
|
|
|
qemu_put_buffer(f, (uint8_t *)qjson_get_str(vmdesc), vmdesc_len);
|
|
|
|
}
|
2016-05-04 18:49:18 +02:00
|
|
|
qjson_destroy(vmdesc);
|
2015-01-22 15:01:39 +01:00
|
|
|
|
2013-02-22 17:36:29 +01:00
|
|
|
qemu_fflush(f);
|
2017-06-16 18:06:58 +02:00
|
|
|
return 0;
|
2008-11-11 22:33:36 +01:00
|
|
|
}
|
|
|
|
|
2015-11-05 19:10:54 +01:00
|
|
|
/* Give an estimate of the amount left to be transferred,
|
|
|
|
* the result is split into the amount for units that can and
|
|
|
|
* for units that can't do postcopy.
|
|
|
|
*/
|
2017-04-01 10:18:43 +02:00
|
|
|
void qemu_savevm_state_pending(QEMUFile *f, uint64_t threshold_size,
|
2015-11-05 19:10:54 +01:00
|
|
|
uint64_t *res_non_postcopiable,
|
|
|
|
uint64_t *res_postcopiable)
|
2012-09-21 11:18:18 +02:00
|
|
|
{
|
|
|
|
SaveStateEntry *se;
|
2015-11-05 19:10:54 +01:00
|
|
|
|
|
|
|
*res_non_postcopiable = 0;
|
|
|
|
*res_postcopiable = 0;
|
|
|
|
|
2012-09-21 11:18:18 +02:00
|
|
|
|
2015-05-13 13:37:04 +02:00
|
|
|
QTAILQ_FOREACH(se, &savevm_state.handlers, entry) {
|
2012-09-21 11:18:18 +02:00
|
|
|
if (!se->ops || !se->ops->save_live_pending) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
if (se->ops && se->ops->is_active) {
|
|
|
|
if (!se->ops->is_active(se->opaque)) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
}
|
2017-04-01 10:18:43 +02:00
|
|
|
se->ops->save_live_pending(f, se->opaque, threshold_size,
|
2015-11-05 19:10:54 +01:00
|
|
|
res_non_postcopiable, res_postcopiable);
|
2012-09-21 11:18:18 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-11-02 08:37:01 +01:00
|
|
|
void qemu_savevm_state_cleanup(void)
|
2009-11-30 18:21:21 +01:00
|
|
|
{
|
|
|
|
SaveStateEntry *se;
|
|
|
|
|
2015-11-02 08:37:01 +01:00
|
|
|
trace_savevm_state_cleanup();
|
2015-05-13 13:37:04 +02:00
|
|
|
QTAILQ_FOREACH(se, &savevm_state.handlers, entry) {
|
2017-06-28 11:52:25 +02:00
|
|
|
if (se->ops && se->ops->save_cleanup) {
|
|
|
|
se->ops->save_cleanup(se->opaque);
|
2009-11-30 18:21:21 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-02-10 14:25:02 +01:00
|
|
|
static int qemu_savevm_state(QEMUFile *f, Error **errp)
|
2008-11-11 22:33:36 +01:00
|
|
|
{
|
|
|
|
int ret;
|
2017-04-05 21:00:09 +02:00
|
|
|
MigrationState *ms = migrate_init();
|
2016-06-15 17:06:43 +02:00
|
|
|
MigrationStatus status;
|
2016-01-15 04:37:42 +01:00
|
|
|
ms->to_dst_file = f;
|
2008-11-11 22:33:36 +01:00
|
|
|
|
2016-05-04 21:44:19 +02:00
|
|
|
if (migration_is_blocked(errp)) {
|
2016-06-15 17:06:43 +02:00
|
|
|
ret = -EINVAL;
|
|
|
|
goto done;
|
2011-01-11 22:39:43 +01:00
|
|
|
}
|
|
|
|
|
2017-04-05 20:45:22 +02:00
|
|
|
if (migrate_use_block()) {
|
|
|
|
error_setg(errp, "Block migration and snapshots are incompatible");
|
|
|
|
ret = -EINVAL;
|
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
|
2013-02-22 17:36:28 +01:00
|
|
|
qemu_mutex_unlock_iothread();
|
2015-05-21 14:24:12 +02:00
|
|
|
qemu_savevm_state_header(f);
|
2017-06-28 11:52:24 +02:00
|
|
|
qemu_savevm_state_setup(f);
|
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) {
|
2015-11-05 19:11:14 +01:00
|
|
|
if (qemu_savevm_state_iterate(f, false) > 0) {
|
2013-02-22 17:36:13 +01:00
|
|
|
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) {
|
2017-06-16 18:06:58 +02:00
|
|
|
qemu_savevm_state_complete_precopy(f, false, false);
|
2011-10-05 01:02:52 +02:00
|
|
|
ret = qemu_file_get_error(f);
|
2011-09-22 11:02:14 +02:00
|
|
|
}
|
2015-11-09 08:24:04 +01:00
|
|
|
qemu_savevm_state_cleanup();
|
2013-02-22 17:36:10 +01:00
|
|
|
if (ret != 0) {
|
2015-02-10 14:25:02 +01:00
|
|
|
error_setg_errno(errp, -ret, "Error while writing VM state");
|
2013-02-22 17:36:10 +01:00
|
|
|
}
|
2016-06-15 17:06:43 +02:00
|
|
|
|
|
|
|
done:
|
|
|
|
if (ret != 0) {
|
|
|
|
status = MIGRATION_STATUS_FAILED;
|
|
|
|
} else {
|
|
|
|
status = MIGRATION_STATUS_COMPLETED;
|
|
|
|
}
|
|
|
|
migrate_set_state(&ms->state, MIGRATION_STATUS_SETUP, status);
|
2017-02-25 20:31:55 +01:00
|
|
|
|
|
|
|
/* f is outer parameter, it should not stay in global migration state after
|
|
|
|
* this function finished */
|
|
|
|
ms->to_dst_file = NULL;
|
|
|
|
|
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();
|
|
|
|
|
2015-05-13 13:37:04 +02:00
|
|
|
QTAILQ_FOREACH(se, &savevm_state.handlers, entry) {
|
2017-09-25 13:29:16 +02:00
|
|
|
int ret;
|
|
|
|
|
2012-01-25 13:24:51 +01:00
|
|
|
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;
|
|
|
|
}
|
2014-10-15 09:39:14 +02:00
|
|
|
if (se->vmsd && !vmstate_save_needed(se->vmsd, se->opaque)) {
|
|
|
|
continue;
|
|
|
|
}
|
2012-01-25 13:24:51 +01:00
|
|
|
|
2015-05-19 13:29:50 +02:00
|
|
|
save_section_header(f, se, QEMU_VM_SECTION_FULL);
|
2012-01-25 13:24:51 +01:00
|
|
|
|
2017-09-25 13:29:16 +02:00
|
|
|
ret = vmstate_save(f, se, NULL);
|
|
|
|
if (ret) {
|
|
|
|
return ret;
|
|
|
|
}
|
2015-05-19 13:29:52 +02:00
|
|
|
|
|
|
|
save_section_footer(f, se);
|
2012-01-25 13:24:51 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
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;
|
|
|
|
|
2015-05-13 13:37:04 +02:00
|
|
|
QTAILQ_FOREACH(se, &savevm_state.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;
|
|
|
|
}
|
|
|
|
|
2015-11-05 19:10:50 +01:00
|
|
|
enum LoadVMExitCodes {
|
|
|
|
/* Allow a command to quit all layers of nested loadvm loops */
|
|
|
|
LOADVM_QUIT = 1,
|
|
|
|
};
|
|
|
|
|
|
|
|
static int qemu_loadvm_state_main(QEMUFile *f, MigrationIncomingState *mis);
|
2015-11-05 19:10:52 +01:00
|
|
|
|
|
|
|
/* ------ incoming postcopy messages ------ */
|
|
|
|
/* 'advise' arrives before any transfers just to tell us that a postcopy
|
|
|
|
* *might* happen - it might be skipped if precopy transferred everything
|
|
|
|
* quickly.
|
|
|
|
*/
|
2018-02-06 12:23:30 +01:00
|
|
|
static int loadvm_postcopy_handle_advise(MigrationIncomingState *mis,
|
|
|
|
uint16_t len)
|
2015-11-05 19:10:52 +01:00
|
|
|
{
|
|
|
|
PostcopyState ps = postcopy_state_set(POSTCOPY_INCOMING_ADVISE);
|
2017-02-24 19:28:29 +01:00
|
|
|
uint64_t remote_pagesize_summary, local_pagesize_summary, remote_tps;
|
2015-11-05 19:10:52 +01:00
|
|
|
|
|
|
|
trace_loadvm_postcopy_handle_advise();
|
|
|
|
if (ps != POSTCOPY_INCOMING_NONE) {
|
|
|
|
error_report("CMD_POSTCOPY_ADVISE in wrong postcopy state (%d)", ps);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2018-02-06 12:23:30 +01:00
|
|
|
switch (len) {
|
|
|
|
case 0:
|
|
|
|
if (migrate_postcopy_ram()) {
|
|
|
|
error_report("RAM postcopy is enabled but have 0 byte advise");
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
2017-07-10 18:30:16 +02:00
|
|
|
return 0;
|
2018-02-06 12:23:30 +01:00
|
|
|
case 8 + 8:
|
|
|
|
if (!migrate_postcopy_ram()) {
|
|
|
|
error_report("RAM postcopy is disabled but have 16 byte advise");
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
error_report("CMD_POSTCOPY_ADVISE invalid length (%d)", len);
|
|
|
|
return -EINVAL;
|
2017-07-10 18:30:16 +02:00
|
|
|
}
|
|
|
|
|
2017-09-19 18:47:56 +02:00
|
|
|
if (!postcopy_ram_supported_by_host(mis)) {
|
2017-02-02 16:59:08 +01:00
|
|
|
postcopy_state_set(POSTCOPY_INCOMING_NONE);
|
2015-11-05 19:10:55 +01:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2017-02-24 19:28:29 +01:00
|
|
|
remote_pagesize_summary = qemu_get_be64(mis->from_src_file);
|
|
|
|
local_pagesize_summary = ram_pagesize_summary();
|
|
|
|
|
|
|
|
if (remote_pagesize_summary != local_pagesize_summary) {
|
2015-11-05 19:10:52 +01:00
|
|
|
/*
|
2017-02-24 19:28:29 +01:00
|
|
|
* This detects two potential causes of mismatch:
|
|
|
|
* a) A mismatch in host page sizes
|
|
|
|
* Some combinations of mismatch are probably possible but it gets
|
|
|
|
* a bit more complicated. In particular we need to place whole
|
|
|
|
* host pages on the dest at once, and we need to ensure that we
|
|
|
|
* handle dirtying to make sure we never end up sending part of
|
|
|
|
* a hostpage on it's own.
|
|
|
|
* b) The use of different huge page sizes on source/destination
|
|
|
|
* a more fine grain test is performed during RAM block migration
|
|
|
|
* but this test here causes a nice early clear failure, and
|
|
|
|
* also fails when passed to an older qemu that doesn't
|
|
|
|
* do huge pages.
|
2015-11-05 19:10:52 +01:00
|
|
|
*/
|
2017-02-24 19:28:29 +01:00
|
|
|
error_report("Postcopy needs matching RAM page sizes (s=%" PRIx64
|
|
|
|
" d=%" PRIx64 ")",
|
|
|
|
remote_pagesize_summary, local_pagesize_summary);
|
2015-11-05 19:10:52 +01:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
remote_tps = qemu_get_be64(mis->from_src_file);
|
2017-03-21 09:09:14 +01:00
|
|
|
if (remote_tps != qemu_target_page_size()) {
|
2015-11-05 19:10:52 +01:00
|
|
|
/*
|
|
|
|
* Again, some differences could be dealt with, but for now keep it
|
|
|
|
* simple.
|
|
|
|
*/
|
2017-03-21 09:09:14 +01:00
|
|
|
error_report("Postcopy needs matching target page sizes (s=%d d=%zd)",
|
|
|
|
(int)remote_tps, qemu_target_page_size());
|
2015-11-05 19:10:52 +01:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2015-11-05 19:11:03 +01:00
|
|
|
if (ram_postcopy_incoming_init(mis)) {
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
postcopy_state_set(POSTCOPY_INCOMING_ADVISE);
|
|
|
|
|
2015-11-05 19:10:52 +01:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* After postcopy we will be told to throw some pages away since they're
|
|
|
|
* dirty and will have to be demand fetched. Must happen before CPU is
|
|
|
|
* started.
|
|
|
|
* There can be 0..many of these messages, each encoding multiple pages.
|
|
|
|
*/
|
|
|
|
static int loadvm_postcopy_ram_handle_discard(MigrationIncomingState *mis,
|
|
|
|
uint16_t len)
|
|
|
|
{
|
|
|
|
int tmp;
|
|
|
|
char ramid[256];
|
|
|
|
PostcopyState ps = postcopy_state_get();
|
|
|
|
|
|
|
|
trace_loadvm_postcopy_ram_handle_discard();
|
|
|
|
|
|
|
|
switch (ps) {
|
|
|
|
case POSTCOPY_INCOMING_ADVISE:
|
|
|
|
/* 1st discard */
|
2015-11-05 19:11:20 +01:00
|
|
|
tmp = postcopy_ram_prepare_discard(mis);
|
2015-11-05 19:10:52 +01:00
|
|
|
if (tmp) {
|
|
|
|
return tmp;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case POSTCOPY_INCOMING_DISCARD:
|
|
|
|
/* Expected state */
|
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
error_report("CMD_POSTCOPY_RAM_DISCARD in wrong postcopy state (%d)",
|
|
|
|
ps);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
/* We're expecting a
|
|
|
|
* Version (0)
|
|
|
|
* a RAM ID string (length byte, name, 0 term)
|
|
|
|
* then at least 1 16 byte chunk
|
|
|
|
*/
|
|
|
|
if (len < (1 + 1 + 1 + 1 + 2 * 8)) {
|
|
|
|
error_report("CMD_POSTCOPY_RAM_DISCARD invalid length (%d)", len);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
tmp = qemu_get_byte(mis->from_src_file);
|
|
|
|
if (tmp != postcopy_ram_discard_version) {
|
|
|
|
error_report("CMD_POSTCOPY_RAM_DISCARD invalid version (%d)", tmp);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!qemu_get_counted_string(mis->from_src_file, ramid)) {
|
|
|
|
error_report("CMD_POSTCOPY_RAM_DISCARD Failed to read RAMBlock ID");
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
tmp = qemu_get_byte(mis->from_src_file);
|
|
|
|
if (tmp != 0) {
|
|
|
|
error_report("CMD_POSTCOPY_RAM_DISCARD missing nil (%d)", tmp);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
len -= 3 + strlen(ramid);
|
|
|
|
if (len % 16) {
|
|
|
|
error_report("CMD_POSTCOPY_RAM_DISCARD invalid length (%d)", len);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
trace_loadvm_postcopy_ram_handle_discard_header(ramid, len);
|
|
|
|
while (len) {
|
|
|
|
uint64_t start_addr, block_length;
|
|
|
|
start_addr = qemu_get_be64(mis->from_src_file);
|
|
|
|
block_length = qemu_get_be64(mis->from_src_file);
|
|
|
|
|
|
|
|
len -= 16;
|
2017-03-21 11:35:24 +01:00
|
|
|
int ret = ram_discard_range(ramid, start_addr, block_length);
|
2015-11-05 19:10:52 +01:00
|
|
|
if (ret) {
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
trace_loadvm_postcopy_ram_handle_discard_end();
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2015-11-05 19:11:18 +01:00
|
|
|
/*
|
|
|
|
* Triggered by a postcopy_listen command; this thread takes over reading
|
|
|
|
* the input stream, leaving the main thread free to carry on loading the rest
|
|
|
|
* of the device state (from RAM).
|
|
|
|
* (TODO:This could do with being in a postcopy file - but there again it's
|
|
|
|
* just another input loop, not that postcopy specific)
|
|
|
|
*/
|
|
|
|
static void *postcopy_ram_listen_thread(void *opaque)
|
|
|
|
{
|
|
|
|
QEMUFile *f = opaque;
|
|
|
|
MigrationIncomingState *mis = migration_incoming_get_current();
|
|
|
|
int load_res;
|
|
|
|
|
2015-12-16 12:47:35 +01:00
|
|
|
migrate_set_state(&mis->state, MIGRATION_STATUS_ACTIVE,
|
|
|
|
MIGRATION_STATUS_POSTCOPY_ACTIVE);
|
2015-11-05 19:11:18 +01:00
|
|
|
qemu_sem_post(&mis->listen_thread_sem);
|
|
|
|
trace_postcopy_ram_listen_thread_start();
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Because we're a thread and not a coroutine we can't yield
|
|
|
|
* in qemu_file, and thus we must be blocking now.
|
|
|
|
*/
|
|
|
|
qemu_file_set_blocking(f, true);
|
|
|
|
load_res = qemu_loadvm_state_main(f, mis);
|
|
|
|
/* And non-blocking again so we don't block in any cleanup */
|
|
|
|
qemu_file_set_blocking(f, false);
|
|
|
|
|
|
|
|
trace_postcopy_ram_listen_thread_exit();
|
|
|
|
if (load_res < 0) {
|
|
|
|
error_report("%s: loadvm failed: %d", __func__, load_res);
|
|
|
|
qemu_file_set_error(f, load_res);
|
2015-12-16 12:47:35 +01:00
|
|
|
migrate_set_state(&mis->state, MIGRATION_STATUS_POSTCOPY_ACTIVE,
|
|
|
|
MIGRATION_STATUS_FAILED);
|
2015-11-05 19:11:18 +01:00
|
|
|
} else {
|
|
|
|
/*
|
|
|
|
* This looks good, but it's possible that the device loading in the
|
|
|
|
* main thread hasn't finished yet, and so we might not be in 'RUN'
|
|
|
|
* state yet; wait for the end of the main thread.
|
|
|
|
*/
|
|
|
|
qemu_event_wait(&mis->main_thread_load_event);
|
|
|
|
}
|
|
|
|
postcopy_ram_incoming_cleanup(mis);
|
|
|
|
|
|
|
|
if (load_res < 0) {
|
|
|
|
/*
|
|
|
|
* If something went wrong then we have a bad state so exit;
|
|
|
|
* depending how far we got it might be possible at this point
|
|
|
|
* to leave the guest running and fire MCEs for pages that never
|
|
|
|
* arrived as a desperate recovery step.
|
|
|
|
*/
|
|
|
|
exit(EXIT_FAILURE);
|
|
|
|
}
|
|
|
|
|
2015-12-16 12:47:35 +01:00
|
|
|
migrate_set_state(&mis->state, MIGRATION_STATUS_POSTCOPY_ACTIVE,
|
|
|
|
MIGRATION_STATUS_COMPLETED);
|
|
|
|
/*
|
|
|
|
* If everything has worked fine, then the main thread has waited
|
|
|
|
* for us to start, and we're the last use of the mis.
|
|
|
|
* (If something broke then qemu will have to exit anyway since it's
|
|
|
|
* got a bad migration state).
|
|
|
|
*/
|
|
|
|
migration_incoming_state_destroy();
|
2017-06-28 11:52:26 +02:00
|
|
|
qemu_loadvm_state_cleanup();
|
2015-12-16 12:47:35 +01:00
|
|
|
|
2015-11-05 19:11:18 +01:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2015-11-05 19:10:52 +01:00
|
|
|
/* After this message we must be able to immediately receive postcopy data */
|
|
|
|
static int loadvm_postcopy_handle_listen(MigrationIncomingState *mis)
|
|
|
|
{
|
|
|
|
PostcopyState ps = postcopy_state_set(POSTCOPY_INCOMING_LISTENING);
|
|
|
|
trace_loadvm_postcopy_handle_listen();
|
|
|
|
if (ps != POSTCOPY_INCOMING_ADVISE && ps != POSTCOPY_INCOMING_DISCARD) {
|
|
|
|
error_report("CMD_POSTCOPY_LISTEN in wrong postcopy state (%d)", ps);
|
|
|
|
return -1;
|
|
|
|
}
|
2015-11-05 19:11:20 +01:00
|
|
|
if (ps == POSTCOPY_INCOMING_ADVISE) {
|
|
|
|
/*
|
|
|
|
* A rare case, we entered listen without having to do any discards,
|
|
|
|
* so do the setup that's normally done at the time of the 1st discard.
|
|
|
|
*/
|
2017-07-10 18:30:16 +02:00
|
|
|
if (migrate_postcopy_ram()) {
|
|
|
|
postcopy_ram_prepare_discard(mis);
|
|
|
|
}
|
2015-11-05 19:11:20 +01:00
|
|
|
}
|
2015-11-05 19:10:52 +01:00
|
|
|
|
2015-11-05 19:11:04 +01:00
|
|
|
/*
|
|
|
|
* Sensitise RAM - can now generate requests for blocks that don't exist
|
|
|
|
* However, at this point the CPU shouldn't be running, and the IO
|
|
|
|
* shouldn't be doing anything yet so don't actually expect requests
|
|
|
|
*/
|
2017-07-10 18:30:16 +02:00
|
|
|
if (migrate_postcopy_ram()) {
|
|
|
|
if (postcopy_ram_enable_notify(mis)) {
|
|
|
|
return -1;
|
|
|
|
}
|
2015-11-05 19:11:04 +01:00
|
|
|
}
|
|
|
|
|
2015-11-05 19:11:18 +01:00
|
|
|
if (mis->have_listen_thread) {
|
|
|
|
error_report("CMD_POSTCOPY_RAM_LISTEN already has a listen thread");
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
mis->have_listen_thread = true;
|
|
|
|
/* Start up the listening thread and wait for it to signal ready */
|
|
|
|
qemu_sem_init(&mis->listen_thread_sem, 0);
|
|
|
|
qemu_thread_create(&mis->listen_thread, "postcopy/listen",
|
|
|
|
postcopy_ram_listen_thread, mis->from_src_file,
|
2016-03-11 10:53:35 +01:00
|
|
|
QEMU_THREAD_DETACHED);
|
2015-11-05 19:11:18 +01:00
|
|
|
qemu_sem_wait(&mis->listen_thread_sem);
|
|
|
|
qemu_sem_destroy(&mis->listen_thread_sem);
|
|
|
|
|
2015-11-05 19:10:52 +01:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2016-03-09 16:35:08 +01:00
|
|
|
|
|
|
|
typedef struct {
|
|
|
|
QEMUBH *bh;
|
|
|
|
} HandleRunBhData;
|
|
|
|
|
2016-02-24 09:53:39 +01:00
|
|
|
static void loadvm_postcopy_handle_run_bh(void *opaque)
|
2015-11-05 19:10:52 +01:00
|
|
|
{
|
2015-11-05 19:11:19 +01:00
|
|
|
Error *local_err = NULL;
|
2016-03-09 16:35:08 +01:00
|
|
|
HandleRunBhData *data = opaque;
|
2015-11-05 19:10:52 +01:00
|
|
|
|
2015-11-05 19:11:19 +01:00
|
|
|
/* TODO we should move all of this lot into postcopy_ram.c or a shared code
|
|
|
|
* in migration.c
|
|
|
|
*/
|
|
|
|
cpu_synchronize_all_post_init();
|
|
|
|
|
|
|
|
qemu_announce_self();
|
|
|
|
|
2017-05-04 18:52:36 +02:00
|
|
|
/* Make sure all file formats flush their mutable metadata.
|
|
|
|
* If we get an error here, just don't restart the VM yet. */
|
2015-11-05 19:11:19 +01:00
|
|
|
bdrv_invalidate_cache_all(&local_err);
|
2017-04-13 18:38:28 +02:00
|
|
|
if (local_err) {
|
2017-05-04 18:52:36 +02:00
|
|
|
error_report_err(local_err);
|
2017-04-13 18:38:28 +02:00
|
|
|
local_err = NULL;
|
|
|
|
autostart = false;
|
|
|
|
}
|
|
|
|
|
2015-11-05 19:11:19 +01:00
|
|
|
trace_loadvm_postcopy_handle_run_cpu_sync();
|
|
|
|
cpu_synchronize_all_post_init();
|
|
|
|
|
|
|
|
trace_loadvm_postcopy_handle_run_vmstart();
|
|
|
|
|
2015-11-05 19:10:52 +01:00
|
|
|
if (autostart) {
|
|
|
|
/* Hold onto your hats, starting the CPU */
|
|
|
|
vm_start();
|
|
|
|
} else {
|
|
|
|
/* leave it paused and let management decide when to start the CPU */
|
|
|
|
runstate_set(RUN_STATE_PAUSED);
|
|
|
|
}
|
|
|
|
|
2016-03-09 16:35:08 +01:00
|
|
|
qemu_bh_delete(data->bh);
|
|
|
|
g_free(data);
|
2016-02-24 09:53:39 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/* After all discards we can start running and asking for pages */
|
|
|
|
static int loadvm_postcopy_handle_run(MigrationIncomingState *mis)
|
|
|
|
{
|
|
|
|
PostcopyState ps = postcopy_state_set(POSTCOPY_INCOMING_RUNNING);
|
2016-03-09 16:35:08 +01:00
|
|
|
HandleRunBhData *data;
|
2016-02-24 09:53:39 +01:00
|
|
|
|
|
|
|
trace_loadvm_postcopy_handle_run();
|
|
|
|
if (ps != POSTCOPY_INCOMING_LISTENING) {
|
|
|
|
error_report("CMD_POSTCOPY_RUN in wrong postcopy state (%d)", ps);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2016-03-09 16:35:08 +01:00
|
|
|
data = g_new(HandleRunBhData, 1);
|
|
|
|
data->bh = qemu_bh_new(loadvm_postcopy_handle_run_bh, data);
|
|
|
|
qemu_bh_schedule(data->bh);
|
2016-02-24 09:53:39 +01:00
|
|
|
|
2015-11-05 19:11:19 +01:00
|
|
|
/* We need to finish reading the stream from the package
|
|
|
|
* and also stop reading anything more from the stream that loaded the
|
|
|
|
* package (since it's now being read by the listener thread).
|
|
|
|
* LOADVM_QUIT will quit all the layers of nested loadvm loops.
|
|
|
|
*/
|
|
|
|
return LOADVM_QUIT;
|
2015-11-05 19:10:52 +01:00
|
|
|
}
|
|
|
|
|
2015-11-05 19:10:45 +01:00
|
|
|
/**
|
2015-11-05 19:10:53 +01:00
|
|
|
* Immediately following this command is a blob of data containing an embedded
|
|
|
|
* chunk of migration stream; read it and load it.
|
|
|
|
*
|
|
|
|
* @mis: Incoming state
|
|
|
|
* @length: Length of packaged data to read
|
2015-11-05 19:10:45 +01:00
|
|
|
*
|
2015-11-05 19:10:53 +01:00
|
|
|
* Returns: Negative values on error
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
static int loadvm_handle_cmd_packaged(MigrationIncomingState *mis)
|
|
|
|
{
|
|
|
|
int ret;
|
2016-04-27 12:05:01 +02:00
|
|
|
size_t length;
|
|
|
|
QIOChannelBuffer *bioc;
|
2015-11-05 19:10:53 +01:00
|
|
|
|
|
|
|
length = qemu_get_be32(mis->from_src_file);
|
|
|
|
trace_loadvm_handle_cmd_packaged(length);
|
|
|
|
|
|
|
|
if (length > MAX_VM_CMD_PACKAGED_SIZE) {
|
2016-04-27 12:05:01 +02:00
|
|
|
error_report("Unreasonably large packaged state: %zu", length);
|
2015-11-05 19:10:53 +01:00
|
|
|
return -1;
|
|
|
|
}
|
2016-04-27 12:05:01 +02:00
|
|
|
|
|
|
|
bioc = qio_channel_buffer_new(length);
|
2016-09-30 12:57:14 +02:00
|
|
|
qio_channel_set_name(QIO_CHANNEL(bioc), "migration-loadvm-buffer");
|
2016-04-27 12:05:01 +02:00
|
|
|
ret = qemu_get_buffer(mis->from_src_file,
|
|
|
|
bioc->data,
|
|
|
|
length);
|
2015-11-05 19:10:53 +01:00
|
|
|
if (ret != length) {
|
2016-04-27 12:05:01 +02:00
|
|
|
object_unref(OBJECT(bioc));
|
|
|
|
error_report("CMD_PACKAGED: Buffer receive fail ret=%d length=%zu",
|
2015-12-18 16:35:19 +01:00
|
|
|
ret, length);
|
2015-11-05 19:10:53 +01:00
|
|
|
return (ret < 0) ? ret : -EAGAIN;
|
|
|
|
}
|
2016-04-27 12:05:01 +02:00
|
|
|
bioc->usage += length;
|
2015-11-05 19:10:53 +01:00
|
|
|
trace_loadvm_handle_cmd_packaged_received(ret);
|
|
|
|
|
2016-04-27 12:05:01 +02:00
|
|
|
QEMUFile *packf = qemu_fopen_channel_input(QIO_CHANNEL(bioc));
|
2015-11-05 19:10:53 +01:00
|
|
|
|
|
|
|
ret = qemu_loadvm_state_main(packf, mis);
|
|
|
|
trace_loadvm_handle_cmd_packaged_main(ret);
|
|
|
|
qemu_fclose(packf);
|
2016-04-27 12:05:01 +02:00
|
|
|
object_unref(OBJECT(bioc));
|
2015-11-05 19:10:53 +01:00
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Process an incoming 'QEMU_VM_COMMAND'
|
|
|
|
* 0 just a normal return
|
|
|
|
* LOADVM_QUIT All good, but exit the loop
|
|
|
|
* <0 Error
|
2015-11-05 19:10:45 +01:00
|
|
|
*/
|
|
|
|
static int loadvm_process_command(QEMUFile *f)
|
|
|
|
{
|
2015-11-05 19:10:46 +01:00
|
|
|
MigrationIncomingState *mis = migration_incoming_get_current();
|
2015-11-05 19:10:45 +01:00
|
|
|
uint16_t cmd;
|
|
|
|
uint16_t len;
|
2015-11-05 19:10:46 +01:00
|
|
|
uint32_t tmp32;
|
2015-11-05 19:10:45 +01:00
|
|
|
|
|
|
|
cmd = qemu_get_be16(f);
|
|
|
|
len = qemu_get_be16(f);
|
|
|
|
|
|
|
|
trace_loadvm_process_command(cmd, len);
|
|
|
|
if (cmd >= MIG_CMD_MAX || cmd == MIG_CMD_INVALID) {
|
|
|
|
error_report("MIG_CMD 0x%x unknown (len 0x%x)", cmd, len);
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (mig_cmd_args[cmd].len != -1 && mig_cmd_args[cmd].len != len) {
|
|
|
|
error_report("%s received with bad length - expecting %zu, got %d",
|
|
|
|
mig_cmd_args[cmd].name,
|
|
|
|
(size_t)mig_cmd_args[cmd].len, len);
|
|
|
|
return -ERANGE;
|
|
|
|
}
|
|
|
|
|
|
|
|
switch (cmd) {
|
2015-11-05 19:10:46 +01:00
|
|
|
case MIG_CMD_OPEN_RETURN_PATH:
|
|
|
|
if (mis->to_src_file) {
|
|
|
|
error_report("CMD_OPEN_RETURN_PATH called when RP already open");
|
|
|
|
/* Not really a problem, so don't give up */
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
mis->to_src_file = qemu_file_get_return_path(f);
|
|
|
|
if (!mis->to_src_file) {
|
|
|
|
error_report("CMD_OPEN_RETURN_PATH failed");
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case MIG_CMD_PING:
|
|
|
|
tmp32 = qemu_get_be32(f);
|
|
|
|
trace_loadvm_process_command_ping(tmp32);
|
|
|
|
if (!mis->to_src_file) {
|
|
|
|
error_report("CMD_PING (0x%x) received with no return path",
|
|
|
|
tmp32);
|
|
|
|
return -1;
|
|
|
|
}
|
2015-11-05 19:10:47 +01:00
|
|
|
migrate_send_rp_pong(mis, tmp32);
|
2015-11-05 19:10:46 +01:00
|
|
|
break;
|
2015-11-05 19:10:52 +01:00
|
|
|
|
2015-11-05 19:10:53 +01:00
|
|
|
case MIG_CMD_PACKAGED:
|
|
|
|
return loadvm_handle_cmd_packaged(mis);
|
|
|
|
|
2015-11-05 19:10:52 +01:00
|
|
|
case MIG_CMD_POSTCOPY_ADVISE:
|
2018-02-06 12:23:30 +01:00
|
|
|
return loadvm_postcopy_handle_advise(mis, len);
|
2015-11-05 19:10:52 +01:00
|
|
|
|
|
|
|
case MIG_CMD_POSTCOPY_LISTEN:
|
|
|
|
return loadvm_postcopy_handle_listen(mis);
|
|
|
|
|
|
|
|
case MIG_CMD_POSTCOPY_RUN:
|
|
|
|
return loadvm_postcopy_handle_run(mis);
|
|
|
|
|
|
|
|
case MIG_CMD_POSTCOPY_RAM_DISCARD:
|
|
|
|
return loadvm_postcopy_ram_handle_discard(mis, len);
|
2015-11-05 19:10:45 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2015-07-02 10:22:03 +02:00
|
|
|
/*
|
|
|
|
* Read a footer off the wire and check that it matches the expected section
|
|
|
|
*
|
|
|
|
* Returns: true if the footer was good
|
|
|
|
* false if there is a problem (and calls error_report to say why)
|
|
|
|
*/
|
2017-05-24 09:09:58 +02:00
|
|
|
static bool check_section_footer(QEMUFile *f, SaveStateEntry *se)
|
2015-07-02 10:22:03 +02:00
|
|
|
{
|
|
|
|
uint8_t read_mark;
|
|
|
|
uint32_t read_section_id;
|
|
|
|
|
2017-06-27 06:10:17 +02:00
|
|
|
if (!migrate_get_current()->send_section_footer) {
|
2015-07-02 10:22:03 +02:00
|
|
|
/* No footer to check */
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
read_mark = qemu_get_byte(f);
|
|
|
|
|
|
|
|
if (read_mark != QEMU_VM_SECTION_FOOTER) {
|
2017-05-24 09:09:58 +02:00
|
|
|
error_report("Missing section footer for %s", se->idstr);
|
2015-07-02 10:22:03 +02:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
read_section_id = qemu_get_be32(f);
|
2017-05-24 09:09:58 +02:00
|
|
|
if (read_section_id != se->load_section_id) {
|
2015-07-02 10:22:03 +02:00
|
|
|
error_report("Mismatched section id in footer for %s -"
|
|
|
|
" read 0x%x expected 0x%x",
|
2017-05-24 09:09:58 +02:00
|
|
|
se->idstr, read_section_id, se->load_section_id);
|
2015-07-02 10:22:03 +02:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* All good */
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2016-01-15 04:37:43 +01:00
|
|
|
static int
|
|
|
|
qemu_loadvm_section_start_full(QEMUFile *f, MigrationIncomingState *mis)
|
|
|
|
{
|
|
|
|
uint32_t instance_id, version_id, section_id;
|
|
|
|
SaveStateEntry *se;
|
|
|
|
char idstr[256];
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
/* Read section start */
|
|
|
|
section_id = qemu_get_be32(f);
|
|
|
|
if (!qemu_get_counted_string(f, idstr)) {
|
|
|
|
error_report("Unable to read ID string for section %u",
|
|
|
|
section_id);
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
instance_id = qemu_get_be32(f);
|
|
|
|
version_id = qemu_get_be32(f);
|
|
|
|
|
|
|
|
trace_qemu_loadvm_state_section_startfull(section_id, idstr,
|
|
|
|
instance_id, version_id);
|
|
|
|
/* Find savevm section */
|
|
|
|
se = find_se(idstr, instance_id);
|
|
|
|
if (se == NULL) {
|
|
|
|
error_report("Unknown savevm section or instance '%s' %d",
|
|
|
|
idstr, instance_id);
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Validate version */
|
|
|
|
if (version_id > se->version_id) {
|
|
|
|
error_report("savevm: unsupported version %d for '%s' v%d",
|
|
|
|
version_id, idstr, se->version_id);
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
2017-05-24 09:09:58 +02:00
|
|
|
se->load_version_id = version_id;
|
|
|
|
se->load_section_id = section_id;
|
2016-01-15 04:37:43 +01:00
|
|
|
|
2016-06-03 11:58:34 +02:00
|
|
|
/* Validate if it is a device's state */
|
|
|
|
if (xen_enabled() && se->is_ram) {
|
|
|
|
error_report("loadvm: %s RAM loading not allowed on Xen", idstr);
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2017-05-24 09:28:47 +02:00
|
|
|
ret = vmstate_load(f, se);
|
2016-01-15 04:37:43 +01:00
|
|
|
if (ret < 0) {
|
|
|
|
error_report("error while loading state for instance 0x%x of"
|
|
|
|
" device '%s'", instance_id, idstr);
|
|
|
|
return ret;
|
|
|
|
}
|
2017-05-24 09:09:58 +02:00
|
|
|
if (!check_section_footer(f, se)) {
|
2016-01-15 04:37:43 +01:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
qemu_loadvm_section_part_end(QEMUFile *f, MigrationIncomingState *mis)
|
|
|
|
{
|
|
|
|
uint32_t section_id;
|
2017-05-24 09:09:58 +02:00
|
|
|
SaveStateEntry *se;
|
2016-01-15 04:37:43 +01:00
|
|
|
int ret;
|
|
|
|
|
|
|
|
section_id = qemu_get_be32(f);
|
|
|
|
|
|
|
|
trace_qemu_loadvm_state_section_partend(section_id);
|
2017-05-24 09:09:58 +02:00
|
|
|
QTAILQ_FOREACH(se, &savevm_state.handlers, entry) {
|
|
|
|
if (se->load_section_id == section_id) {
|
2016-01-15 04:37:43 +01:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2017-05-24 09:09:58 +02:00
|
|
|
if (se == NULL) {
|
2016-01-15 04:37:43 +01:00
|
|
|
error_report("Unknown savevm section %d", section_id);
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2017-05-24 09:28:47 +02:00
|
|
|
ret = vmstate_load(f, se);
|
2016-01-15 04:37:43 +01:00
|
|
|
if (ret < 0) {
|
|
|
|
error_report("error while loading state section id %d(%s)",
|
2017-05-24 09:09:58 +02:00
|
|
|
section_id, se->idstr);
|
2016-01-15 04:37:43 +01:00
|
|
|
return ret;
|
|
|
|
}
|
2017-05-24 09:09:58 +02:00
|
|
|
if (!check_section_footer(f, se)) {
|
2016-01-15 04:37:43 +01:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2017-06-28 11:52:26 +02:00
|
|
|
static int qemu_loadvm_state_setup(QEMUFile *f)
|
|
|
|
{
|
|
|
|
SaveStateEntry *se;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
trace_loadvm_state_setup();
|
|
|
|
QTAILQ_FOREACH(se, &savevm_state.handlers, entry) {
|
|
|
|
if (!se->ops || !se->ops->load_setup) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
if (se->ops && se->ops->is_active) {
|
|
|
|
if (!se->ops->is_active(se->opaque)) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = se->ops->load_setup(f, se->opaque);
|
|
|
|
if (ret < 0) {
|
|
|
|
qemu_file_set_error(f, ret);
|
|
|
|
error_report("Load state of device %s failed", se->idstr);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
void qemu_loadvm_state_cleanup(void)
|
|
|
|
{
|
|
|
|
SaveStateEntry *se;
|
|
|
|
|
|
|
|
trace_loadvm_state_cleanup();
|
|
|
|
QTAILQ_FOREACH(se, &savevm_state.handlers, entry) {
|
|
|
|
if (se->ops && se->ops->load_cleanup) {
|
|
|
|
se->ops->load_cleanup(se->opaque);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-11-05 19:10:50 +01:00
|
|
|
static int qemu_loadvm_state_main(QEMUFile *f, MigrationIncomingState *mis)
|
2015-05-21 14:24:16 +02:00
|
|
|
{
|
2008-11-11 22:33:36 +01:00
|
|
|
uint8_t section_type;
|
2016-09-23 21:14:03 +02:00
|
|
|
int ret = 0;
|
2015-05-13 18:17:43 +02:00
|
|
|
|
2008-11-11 22:33:36 +01:00
|
|
|
while ((section_type = qemu_get_byte(f)) != QEMU_VM_EOF) {
|
2016-09-23 21:14:03 +02:00
|
|
|
ret = 0;
|
2015-01-21 11:14:48 +01:00
|
|
|
trace_qemu_loadvm_state_section(section_type);
|
2008-11-11 22:33:36 +01:00
|
|
|
switch (section_type) {
|
|
|
|
case QEMU_VM_SECTION_START:
|
|
|
|
case QEMU_VM_SECTION_FULL:
|
2016-01-15 04:37:43 +01:00
|
|
|
ret = qemu_loadvm_section_start_full(f, mis);
|
2009-08-20 19:42:23 +02:00
|
|
|
if (ret < 0) {
|
2016-09-23 21:14:03 +02:00
|
|
|
goto out;
|
2009-08-20 19:42:23 +02:00
|
|
|
}
|
2008-11-11 22:33:36 +01:00
|
|
|
break;
|
|
|
|
case QEMU_VM_SECTION_PART:
|
|
|
|
case QEMU_VM_SECTION_END:
|
2016-01-15 04:37:43 +01:00
|
|
|
ret = qemu_loadvm_section_part_end(f, mis);
|
2009-08-20 19:42:23 +02:00
|
|
|
if (ret < 0) {
|
2016-09-23 21:14:03 +02:00
|
|
|
goto out;
|
2009-08-20 19:42:23 +02:00
|
|
|
}
|
2008-11-11 22:33:36 +01:00
|
|
|
break;
|
2015-11-05 19:10:45 +01:00
|
|
|
case QEMU_VM_COMMAND:
|
|
|
|
ret = loadvm_process_command(f);
|
2015-11-05 19:10:50 +01:00
|
|
|
trace_qemu_loadvm_state_section_command(ret);
|
|
|
|
if ((ret < 0) || (ret & LOADVM_QUIT)) {
|
2016-09-23 21:14:03 +02:00
|
|
|
goto out;
|
2015-11-05 19:10:45 +01:00
|
|
|
}
|
|
|
|
break;
|
2008-11-11 22:33:36 +01:00
|
|
|
default:
|
2015-01-21 11:14:47 +01:00
|
|
|
error_report("Unknown savevm section type %d", section_type);
|
2016-09-23 21:14:03 +02:00
|
|
|
ret = -EINVAL;
|
|
|
|
goto out;
|
2008-11-11 22:33:36 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-09-23 21:14:03 +02:00
|
|
|
out:
|
|
|
|
if (ret < 0) {
|
|
|
|
qemu_file_set_error(f, ret);
|
|
|
|
}
|
|
|
|
return ret;
|
2015-11-05 19:10:50 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
int qemu_loadvm_state(QEMUFile *f)
|
|
|
|
{
|
|
|
|
MigrationIncomingState *mis = migration_incoming_get_current();
|
|
|
|
Error *local_err = NULL;
|
|
|
|
unsigned int v;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
if (qemu_savevm_state_blocked(&local_err)) {
|
|
|
|
error_report_err(local_err);
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
v = qemu_get_be32(f);
|
|
|
|
if (v != QEMU_VM_FILE_MAGIC) {
|
|
|
|
error_report("Not a migration stream");
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
v = qemu_get_be32(f);
|
|
|
|
if (v == QEMU_VM_FILE_VERSION_COMPAT) {
|
|
|
|
error_report("SaveVM v2 format is obsolete and don't work anymore");
|
|
|
|
return -ENOTSUP;
|
|
|
|
}
|
|
|
|
if (v != QEMU_VM_FILE_VERSION) {
|
|
|
|
error_report("Unsupported migration stream version");
|
|
|
|
return -ENOTSUP;
|
|
|
|
}
|
|
|
|
|
2017-06-28 11:52:26 +02:00
|
|
|
if (qemu_loadvm_state_setup(f) != 0) {
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2017-06-27 06:10:18 +02:00
|
|
|
if (migrate_get_current()->send_configuration) {
|
2015-11-05 19:10:50 +01:00
|
|
|
if (qemu_get_byte(f) != QEMU_VM_CONFIGURATION) {
|
|
|
|
error_report("Configuration section missing");
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
ret = vmstate_load_state(f, &vmstate_configuration, &savevm_state, 0);
|
|
|
|
|
|
|
|
if (ret) {
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-05-26 06:46:28 +02:00
|
|
|
cpu_synchronize_all_pre_loadvm();
|
|
|
|
|
2015-11-05 19:10:50 +01:00
|
|
|
ret = qemu_loadvm_state_main(f, mis);
|
|
|
|
qemu_event_set(&mis->main_thread_load_event);
|
|
|
|
|
|
|
|
trace_qemu_loadvm_state_post_main(ret);
|
|
|
|
|
2015-11-05 19:11:18 +01:00
|
|
|
if (mis->have_listen_thread) {
|
|
|
|
/* Listen thread still going, can't clean up yet */
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2015-11-05 19:10:50 +01:00
|
|
|
if (ret == 0) {
|
|
|
|
ret = qemu_file_get_error(f);
|
|
|
|
}
|
2015-02-23 13:56:41 +01:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Try to read in the VMDESC section as well, so that dumping tools that
|
|
|
|
* intercept our migration stream have the chance to see it.
|
|
|
|
*/
|
2015-06-23 18:34:35 +02:00
|
|
|
|
|
|
|
/* We've got to be careful; if we don't read the data and just shut the fd
|
|
|
|
* then the sender can error if we close while it's still sending.
|
|
|
|
* We also mustn't read data that isn't there; some transports (RDMA)
|
|
|
|
* will stall waiting for that data when the source has already closed.
|
|
|
|
*/
|
2015-11-05 19:10:50 +01:00
|
|
|
if (ret == 0 && should_send_vmdesc()) {
|
2015-06-23 18:34:35 +02:00
|
|
|
uint8_t *buf;
|
|
|
|
uint32_t size;
|
2015-11-05 19:10:50 +01:00
|
|
|
uint8_t section_type = qemu_get_byte(f);
|
2015-06-23 18:34:35 +02:00
|
|
|
|
|
|
|
if (section_type != QEMU_VM_VMDESCRIPTION) {
|
|
|
|
error_report("Expected vmdescription section, but got %d",
|
|
|
|
section_type);
|
|
|
|
/*
|
|
|
|
* It doesn't seem worth failing at this point since
|
|
|
|
* we apparently have an otherwise valid VM state
|
|
|
|
*/
|
|
|
|
} else {
|
|
|
|
buf = g_malloc(0x1000);
|
|
|
|
size = qemu_get_be32(f);
|
|
|
|
|
|
|
|
while (size > 0) {
|
|
|
|
uint32_t read_chunk = MIN(size, 0x1000);
|
|
|
|
qemu_get_buffer(f, buf, read_chunk);
|
|
|
|
size -= read_chunk;
|
|
|
|
}
|
|
|
|
g_free(buf);
|
2015-02-23 13:56:41 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-06-28 11:52:26 +02:00
|
|
|
qemu_loadvm_state_cleanup();
|
2010-03-01 19:10:30 +01:00
|
|
|
cpu_synchronize_all_post_init();
|
|
|
|
|
2008-11-11 22:33:36 +01:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2017-04-20 14:25:55 +02:00
|
|
|
int save_snapshot(const char *name, Error **errp)
|
2008-11-11 22:33:36 +01:00
|
|
|
{
|
|
|
|
BlockDriverState *bs, *bs1;
|
|
|
|
QEMUSnapshotInfo sn1, *sn = &sn1, old_sn1, *old_sn = &old_sn1;
|
2017-01-24 08:17:41 +01:00
|
|
|
int ret = -1;
|
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;
|
2015-11-19 07:42:11 +01:00
|
|
|
AioContext *aio_context;
|
2008-11-11 22:33:36 +01:00
|
|
|
|
2015-11-19 07:42:01 +01:00
|
|
|
if (!bdrv_all_can_snapshot(&bs)) {
|
2017-04-18 18:12:35 +02:00
|
|
|
error_setg(errp, "Device '%s' is writable but does not support "
|
|
|
|
"snapshots", bdrv_get_device_name(bs));
|
2017-01-24 08:17:41 +01:00
|
|
|
return ret;
|
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
|
|
|
}
|
|
|
|
|
2015-11-19 07:42:09 +01:00
|
|
|
/* Delete old snapshots of the same name */
|
2017-01-24 08:17:41 +01:00
|
|
|
if (name) {
|
2017-04-18 18:12:35 +02:00
|
|
|
ret = bdrv_all_delete_snapshot(name, &bs1, errp);
|
2017-01-24 08:17:41 +01:00
|
|
|
if (ret < 0) {
|
2017-04-18 18:12:35 +02:00
|
|
|
error_prepend(errp, "Error while deleting snapshot on device "
|
|
|
|
"'%s': ", bdrv_get_device_name(bs1));
|
2017-01-24 08:17:41 +01:00
|
|
|
return ret;
|
|
|
|
}
|
2015-11-19 07:42:09 +01:00
|
|
|
}
|
|
|
|
|
2015-11-19 07:42:10 +01:00
|
|
|
bs = bdrv_all_find_vmstate_bs();
|
|
|
|
if (bs == NULL) {
|
2017-04-18 18:12:35 +02:00
|
|
|
error_setg(errp, "No block device can accept snapshots");
|
2017-01-24 08:17:41 +01:00
|
|
|
return ret;
|
2008-11-11 22:33:36 +01:00
|
|
|
}
|
2015-11-19 07:42:11 +01:00
|
|
|
aio_context = bdrv_get_aio_context(bs);
|
2008-11-11 22:33:36 +01:00
|
|
|
|
2011-07-29 20:36:43 +02:00
|
|
|
saved_vm_running = runstate_is_running();
|
2015-07-15 09:53:46 +02:00
|
|
|
|
|
|
|
ret = global_state_store();
|
|
|
|
if (ret) {
|
2017-04-18 18:12:35 +02:00
|
|
|
error_setg(errp, "Error saving global state");
|
2017-01-24 08:17:41 +01:00
|
|
|
return ret;
|
2015-07-15 09:53:46 +02:00
|
|
|
}
|
2011-09-30 19:45:27 +02:00
|
|
|
vm_stop(RUN_STATE_SAVE_VM);
|
2008-11-11 22:33:36 +01:00
|
|
|
|
2017-05-22 15:57:04 +02:00
|
|
|
bdrv_drain_all_begin();
|
|
|
|
|
2015-11-19 07:42:11 +01:00
|
|
|
aio_context_acquire(aio_context);
|
|
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
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) {
|
2017-04-18 18:12:35 +02:00
|
|
|
error_setg(errp, "Could not open VM state file");
|
2008-11-11 22:33:36 +01:00
|
|
|
goto the_end;
|
|
|
|
}
|
2017-04-18 18:12:35 +02:00
|
|
|
ret = qemu_savevm_state(f, errp);
|
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) {
|
|
|
|
goto the_end;
|
|
|
|
}
|
|
|
|
|
2017-05-22 15:57:03 +02:00
|
|
|
/* The bdrv_all_create_snapshot() call that follows acquires the AioContext
|
|
|
|
* for itself. BDRV_POLL_WHILE() does not support nested locking because
|
|
|
|
* it only releases the lock once. Therefore synchronous I/O will deadlock
|
|
|
|
* unless we release the AioContext before bdrv_all_create_snapshot().
|
|
|
|
*/
|
|
|
|
aio_context_release(aio_context);
|
|
|
|
aio_context = NULL;
|
|
|
|
|
2015-11-19 07:42:08 +01:00
|
|
|
ret = bdrv_all_create_snapshot(sn, bs, vm_state_size, &bs);
|
|
|
|
if (ret < 0) {
|
2017-04-18 18:12:35 +02:00
|
|
|
error_setg(errp, "Error while creating snapshot on '%s'",
|
|
|
|
bdrv_get_device_name(bs));
|
2017-01-24 08:17:41 +01:00
|
|
|
goto the_end;
|
2008-11-11 22:33:36 +01:00
|
|
|
}
|
|
|
|
|
2017-01-24 08:17:41 +01:00
|
|
|
ret = 0;
|
|
|
|
|
2008-11-11 22:33:36 +01:00
|
|
|
the_end:
|
2017-05-22 15:57:03 +02:00
|
|
|
if (aio_context) {
|
|
|
|
aio_context_release(aio_context);
|
|
|
|
}
|
2017-05-22 15:57:04 +02:00
|
|
|
|
|
|
|
bdrv_drain_all_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
|
|
|
}
|
2017-01-24 08:17:41 +01:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2017-11-16 16:14:19 +01:00
|
|
|
void qmp_xen_save_devices_state(const char *filename, bool has_live, bool live,
|
|
|
|
Error **errp)
|
2012-01-25 13:24:51 +01:00
|
|
|
{
|
|
|
|
QEMUFile *f;
|
2016-04-27 12:05:08 +02:00
|
|
|
QIOChannelFile *ioc;
|
2012-01-25 13:24:51 +01:00
|
|
|
int saved_vm_running;
|
|
|
|
int ret;
|
|
|
|
|
2017-11-16 16:14:19 +01:00
|
|
|
if (!has_live) {
|
|
|
|
/* live default to true so old version of Xen tool stack can have a
|
|
|
|
* successfull live migration */
|
|
|
|
live = true;
|
|
|
|
}
|
|
|
|
|
2012-01-25 13:24:51 +01:00
|
|
|
saved_vm_running = runstate_is_running();
|
|
|
|
vm_stop(RUN_STATE_SAVE_VM);
|
2015-08-03 16:29:19 +02:00
|
|
|
global_state_store_running();
|
2012-01-25 13:24:51 +01:00
|
|
|
|
2016-04-27 12:05:08 +02:00
|
|
|
ioc = qio_channel_file_new_path(filename, O_WRONLY | O_CREAT, 0660, errp);
|
|
|
|
if (!ioc) {
|
2012-01-25 13:24:51 +01:00
|
|
|
goto the_end;
|
|
|
|
}
|
2016-09-30 12:57:14 +02:00
|
|
|
qio_channel_set_name(QIO_CHANNEL(ioc), "migration-xen-save-state");
|
2016-04-27 12:05:08 +02:00
|
|
|
f = qemu_fopen_channel_output(QIO_CHANNEL(ioc));
|
2017-11-01 15:25:23 +01:00
|
|
|
object_unref(OBJECT(ioc));
|
2012-01-25 13:24:51 +01:00
|
|
|
ret = qemu_save_device_state(f);
|
2018-02-06 17:30:39 +01:00
|
|
|
if (ret < 0 || qemu_fclose(f) < 0) {
|
2015-03-17 11:54:50 +01:00
|
|
|
error_setg(errp, QERR_IO_ERROR);
|
2017-11-16 16:14:19 +01:00
|
|
|
} else {
|
|
|
|
/* libxl calls the QMP command "stop" before calling
|
|
|
|
* "xen-save-devices-state" and in case of migration failure, libxl
|
|
|
|
* would call "cont".
|
|
|
|
* So call bdrv_inactivate_all (release locks) here to let the other
|
|
|
|
* side of the migration take controle of the images.
|
|
|
|
*/
|
|
|
|
if (live && !saved_vm_running) {
|
|
|
|
ret = bdrv_inactivate_all();
|
|
|
|
if (ret) {
|
|
|
|
error_setg(errp, "%s: bdrv_inactivate_all() failed (%d)",
|
|
|
|
__func__, ret);
|
|
|
|
}
|
|
|
|
}
|
2012-01-25 13:24:51 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
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
|
|
|
}
|
|
|
|
|
2016-06-03 11:58:34 +02:00
|
|
|
void qmp_xen_load_devices_state(const char *filename, Error **errp)
|
|
|
|
{
|
|
|
|
QEMUFile *f;
|
|
|
|
QIOChannelFile *ioc;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
/* Guest must be paused before loading the device state; the RAM state
|
|
|
|
* will already have been loaded by xc
|
|
|
|
*/
|
|
|
|
if (runstate_is_running()) {
|
|
|
|
error_setg(errp, "Cannot update device state while vm is running");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
vm_stop(RUN_STATE_RESTORE_VM);
|
|
|
|
|
|
|
|
ioc = qio_channel_file_new_path(filename, O_RDONLY | O_BINARY, 0, errp);
|
|
|
|
if (!ioc) {
|
|
|
|
return;
|
|
|
|
}
|
2016-09-30 12:57:14 +02:00
|
|
|
qio_channel_set_name(QIO_CHANNEL(ioc), "migration-xen-load-state");
|
2016-06-03 11:58:34 +02:00
|
|
|
f = qemu_fopen_channel_input(QIO_CHANNEL(ioc));
|
2017-11-01 15:25:23 +01:00
|
|
|
object_unref(OBJECT(ioc));
|
2016-06-03 11:58:34 +02:00
|
|
|
|
|
|
|
ret = qemu_loadvm_state(f);
|
|
|
|
qemu_fclose(f);
|
|
|
|
if (ret < 0) {
|
|
|
|
error_setg(errp, QERR_IO_ERROR);
|
|
|
|
}
|
|
|
|
migration_incoming_state_destroy();
|
|
|
|
}
|
|
|
|
|
2017-04-20 14:25:55 +02:00
|
|
|
int load_snapshot(const char *name, Error **errp)
|
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;
|
2015-11-19 07:42:11 +01:00
|
|
|
AioContext *aio_context;
|
2017-01-23 22:32:06 +01:00
|
|
|
MigrationIncomingState *mis = migration_incoming_get_current();
|
2008-11-11 22:33:36 +01:00
|
|
|
|
2015-11-19 07:42:05 +01:00
|
|
|
if (!bdrv_all_can_snapshot(&bs)) {
|
2017-04-18 18:12:35 +02:00
|
|
|
error_setg(errp,
|
|
|
|
"Device '%s' is writable but does not support snapshots",
|
|
|
|
bdrv_get_device_name(bs));
|
2015-11-19 07:42:05 +01:00
|
|
|
return -ENOTSUP;
|
|
|
|
}
|
2015-11-19 07:42:06 +01:00
|
|
|
ret = bdrv_all_find_snapshot(name, &bs);
|
|
|
|
if (ret < 0) {
|
2017-04-18 18:12:35 +02:00
|
|
|
error_setg(errp,
|
|
|
|
"Device '%s' does not have the requested snapshot '%s'",
|
|
|
|
bdrv_get_device_name(bs), name);
|
2015-11-19 07:42:06 +01:00
|
|
|
return ret;
|
|
|
|
}
|
2015-11-19 07:42:05 +01:00
|
|
|
|
2015-11-19 07:42:10 +01:00
|
|
|
bs_vm_state = bdrv_all_find_vmstate_bs();
|
2010-07-19 20:25:01 +02:00
|
|
|
if (!bs_vm_state) {
|
2017-04-18 18:12:35 +02:00
|
|
|
error_setg(errp, "No block device supports snapshots");
|
2010-07-19 20:25:01 +02:00
|
|
|
return -ENOTSUP;
|
|
|
|
}
|
2015-11-19 07:42:11 +01:00
|
|
|
aio_context = bdrv_get_aio_context(bs_vm_state);
|
2010-07-19 20:25:01 +02:00
|
|
|
|
|
|
|
/* Don't even try to load empty VM states */
|
2015-11-19 07:42:11 +01:00
|
|
|
aio_context_acquire(aio_context);
|
2010-07-19 20:25:01 +02:00
|
|
|
ret = bdrv_snapshot_find(bs_vm_state, &sn, name);
|
2015-11-19 07:42:11 +01:00
|
|
|
aio_context_release(aio_context);
|
2010-07-19 20:25:01 +02:00
|
|
|
if (ret < 0) {
|
|
|
|
return ret;
|
|
|
|
} else if (sn.vm_state_size == 0) {
|
2017-04-18 18:12:35 +02:00
|
|
|
error_setg(errp, "This is a disk-only snapshot. Revert to it "
|
|
|
|
" offline using qemu-img");
|
2010-07-19 20:25:01 +02:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2008-11-11 22:33:36 +01:00
|
|
|
/* Flush all IO requests so they don't interfere with the new state. */
|
2017-05-22 15:57:04 +02:00
|
|
|
bdrv_drain_all_begin();
|
2008-11-11 22:33:36 +01:00
|
|
|
|
2017-11-20 15:36:48 +01:00
|
|
|
ret = bdrv_all_goto_snapshot(name, &bs, errp);
|
2015-11-19 07:42:04 +01:00
|
|
|
if (ret < 0) {
|
2017-11-20 15:36:48 +01:00
|
|
|
error_prepend(errp, "Could not load snapshot '%s' on '%s': ",
|
|
|
|
name, bdrv_get_device_name(bs));
|
2017-05-22 15:57:04 +02:00
|
|
|
goto err_drain;
|
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) {
|
2017-04-18 18:12:35 +02:00
|
|
|
error_setg(errp, "Could not open VM state file");
|
2017-05-22 15:57:04 +02:00
|
|
|
ret = -EINVAL;
|
|
|
|
goto err_drain;
|
2008-11-11 22:33:36 +01:00
|
|
|
}
|
2010-07-19 20:25:01 +02:00
|
|
|
|
shutdown: Prepare for use of an enum in reset/shutdown_request
We want to track why a guest was shutdown; in particular, being able
to tell the difference between a guest request (such as ACPI request)
and host request (such as SIGINT) will prove useful to libvirt.
Since all requests eventually end up changing shutdown_requested in
vl.c, the logical change is to make that value track the reason,
rather than its current 0/1 contents.
Since command-line options control whether a reset request is turned
into a shutdown request instead, the same treatment is given to
reset_requested.
This patch adds an internal enum ShutdownCause that describes reasons
that a shutdown can be requested, and changes qemu_system_reset() to
pass the reason through, although for now nothing is actually changed
with regards to what gets reported. The enum could be exported via
QAPI at a later date, if deemed necessary, but for now, there has not
been a request to expose that much detail to end clients.
For the most part, we turn 0 into SHUTDOWN_CAUSE_NONE, and 1 into
SHUTDOWN_CAUSE_HOST_ERROR; the only specific case where we have enough
information right now to use a different value is when we are reacting
to a host signal. It will take a further patch to edit all call-sites
that can trigger a reset or shutdown request to properly pass in any
other reasons; this patch includes TODOs to point such places out.
qemu_system_reset() trades its 'bool report' parameter for a
'ShutdownCause reason', with all non-zero values having the same
effect; this lets us get rid of the weird #defines for VMRESET_*
as synonyms for bools.
Signed-off-by: Eric Blake <eblake@redhat.com>
Message-Id: <20170515214114.15442-3-eblake@redhat.com>
Reviewed-by: Markus Armbruster <armbru@redhat.com>
Signed-off-by: Markus Armbruster <armbru@redhat.com>
2017-05-15 23:41:11 +02:00
|
|
|
qemu_system_reset(SHUTDOWN_CAUSE_NONE);
|
2017-01-23 22:32:06 +01:00
|
|
|
mis->from_src_file = f;
|
2010-07-19 20:25:01 +02:00
|
|
|
|
2015-11-19 07:42:11 +01:00
|
|
|
aio_context_acquire(aio_context);
|
|
|
|
ret = qemu_loadvm_state(f);
|
2017-06-15 18:38:10 +02:00
|
|
|
migration_incoming_state_destroy();
|
2015-11-19 07:42:11 +01:00
|
|
|
aio_context_release(aio_context);
|
|
|
|
|
2017-05-22 15:57:04 +02:00
|
|
|
bdrv_drain_all_end();
|
|
|
|
|
2008-11-11 22:33:36 +01:00
|
|
|
if (ret < 0) {
|
2017-04-18 18:12:35 +02:00
|
|
|
error_setg(errp, "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;
|
2017-05-22 15:57:04 +02:00
|
|
|
|
|
|
|
err_drain:
|
|
|
|
bdrv_drain_all_end();
|
|
|
|
return ret;
|
2009-08-20 19:42:20 +02:00
|
|
|
}
|
|
|
|
|
2011-12-20 14:59:12 +01:00
|
|
|
void vmstate_register_ram(MemoryRegion *mr, DeviceState *dev)
|
|
|
|
{
|
2016-05-10 04:04:59 +02:00
|
|
|
qemu_ram_set_idstr(mr->ram_block,
|
2011-12-20 14:59:12 +01:00
|
|
|
memory_region_name(mr), dev);
|
|
|
|
}
|
|
|
|
|
|
|
|
void vmstate_unregister_ram(MemoryRegion *mr, DeviceState *dev)
|
|
|
|
{
|
2016-05-10 04:04:59 +02:00
|
|
|
qemu_ram_unset_idstr(mr->ram_block);
|
2011-12-20 14:59:12 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
void vmstate_register_ram_global(MemoryRegion *mr)
|
|
|
|
{
|
|
|
|
vmstate_register_ram(mr, NULL);
|
|
|
|
}
|
2017-04-17 14:57:54 +02:00
|
|
|
|
|
|
|
bool vmstate_check_only_migratable(const VMStateDescription *vmsd)
|
|
|
|
{
|
|
|
|
/* check needed if --only-migratable is specified */
|
2017-06-27 06:10:15 +02:00
|
|
|
if (!migrate_get_current()->only_migratable) {
|
2017-04-17 14:57:54 +02:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
return !(vmsd && vmsd->unmigratable);
|
|
|
|
}
|