david.venhoff/QEMU-Nyx-fork
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

migration/next for 20170601

Browse Source 
-----BEGIN PGP SIGNATURE-----
 
 iQIcBAABCAAGBQJZMEX4AAoJEPSH7xhYctcjWU0QAOMBVLJSA8gu4n+//EAGCFfd
 0Rt+Ba8RNT/R3SqFauqVCFNnZ2gIiNfeKoZwZMtmm8QUlGAq8R5eovKFIevjnhbT
 b0r0HnOE3TxVAn/UvjcqvMrDzIl/PyWD+2JONVUmY0QR4+U8jiTJBtFl1hRK+fxC
 9y3OLBOU3bEo5a7ou6n9ig/uo5wbt/gAXMGOWqOdTtnP5Qs3bq3ONDpk8BjB9WEr
 tV1OmvcrckG9Es2HJObsJhhYViaBccgKEL+srO4KQf1FmCZj78cAkxxoWVW6w5Qx
 UsQZ4mpfLBN1EH2dLh+2FjS99hu/ToHL4nKM46oFWicxgeD4HdG5V7zXfKFcQIIJ
 RftDqro8ycYHgnK+EAVbtI8yXnhvprSOWlJIKkNMDE+uwdl3nYFLnU91WYJnAMJk
 M3yAvZVy5x8rHvA2HNisjqLVUK8+mAv53D6tA/mz2FbMUq+CdH9Xc0wcWZiyVcvb
 nxNcDRe8+Pas4utf1GUBlE6oDn1KHPz3H1/iXV/tLtsvN+r1fI0GBjb/ogOLQr+X
 sjomRpVrjc3B9mQkZBn0ShqGSzsDVXd6/wUWe0HJ3JYHWYcdGqoYXXRZHD6x8Kai
 KO+YRo4lREPvWIQB0C36YbQuAsoB+tpa5z+/iEmqdqA4tvMXVAozKIt5dbiI7sAP
 EAv1Zk6bp4rTpYaz9MXX
 =tEkM
 -----END PGP SIGNATURE-----

Merge remote-tracking branch 'remotes/juanquintela/tags/migration/20170601' into staging

migration/next for 20170601

# gpg: Signature made Thu 01 Jun 2017 17:51:04 BST
# gpg:                using RSA key 0xF487EF185872D723
# gpg: Good signature from "Juan Quintela <quintela@redhat.com>"
# gpg:                 aka "Juan Quintela <quintela@trasno.org>"
# Primary key fingerprint: 1899 FF8E DEBF 58CC EE03  4B82 F487 EF18 5872 D723

* remotes/juanquintela/tags/migration/20170601:
  migration: Move include/migration/block.h into migration/
  migration: Export ram.c functions in its own file
  migration: Create include for migration snapshots
  migration: Export rdma.c functions in its own file
  migration: Export tls.c functions in its own file
  migration: Export socket.c functions in its own file
  migration: Export fd.c functions in its own file
  migration: Export exec.c functions in its own file
  migration: Split qemu-file.h
  migration: Remove unneeded includes of migration/vmstate.h
  migration: shut src return path unconditionally
  migration: fix leak of src file on dst
  migration: Remove section_id parameter from vmstate_load
  migration: loadvm handlers are not used
  migration: Use savevm_handlers instead of loadvm copy

Signed-off-by: Peter Maydell <peter.maydell@linaro.org>
This commit is contained in:
Peter Maydell 2017-06-02 14:07:53 +01:00
commit d47a851cae
49 changed files with 510 additions and 319 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
hmp.c
View File

@ -42,6 +42,7 @@
#include "qemu/error-report.h"
#include "exec/ramlist.h"
#include "hw/intc/intc.h"
#include "migration/snapshot.h"
#ifdef CONFIG_SPICE
#include <spice/enums.h>
@ -1284,7 +1285,7 @@ void hmp_loadvm(Monitor *mon, const QDict *qdict)
vm_stop(RUN_STATE_RESTORE_VM);
if (load_vmstate(name, &err) == 0 && saved_vm_running) {
if (load_snapshot(name, &err) == 0 && saved_vm_running) {
vm_start();
}
hmp_handle_error(mon, &err);
@ -1294,7 +1295,7 @@ void hmp_savevm(Monitor *mon, const QDict *qdict)
{
Error *err = NULL;
save_vmstate(qdict_get_try_str(qdict, "name"), &err);
save_snapshot(qdict_get_try_str(qdict, "name"), &err);
hmp_handle_error(mon, &err);
}

1
hw/core/qdev.c
View File

@ -37,7 +37,6 @@
#include "hw/boards.h"
#include "hw/sysbus.h"
#include "qapi-event.h"
#include "migration/vmstate.h"
bool qdev_hotplug = false;
static bool qdev_hot_added = false;

1
hw/i2c/i2c-ddc.c
View File

@ -17,6 +17,7 @@
*/
#include "qemu/osdep.h"
#include "qemu-common.h"
#include "qemu/log.h"
#include "hw/i2c/i2c.h"
#include "hw/i2c/i2c-ddc.h"

1
hw/intc/s390_flic.c
View File

@ -13,7 +13,6 @@
#include "qemu/osdep.h"
#include "qemu/error-report.h"
#include "hw/sysbus.h"
#include "migration/qemu-file.h"
#include "hw/s390x/s390_flic.h"
#include "trace.h"
#include "hw/qdev.h"

1
hw/intc/s390_flic_kvm.c
View File

@ -17,7 +17,6 @@
#include "qemu/error-report.h"
#include "hw/sysbus.h"
#include "sysemu/kvm.h"
#include "migration/qemu-file.h"
#include "hw/s390x/s390_flic.h"
#include "hw/s390x/adapter.h"
#include "trace.h"

1
hw/s390x/s390-skeys.c
View File

@ -12,7 +12,6 @@
#include "qemu/osdep.h"
#include "hw/boards.h"
#include "qmp-commands.h"
#include "migration/qemu-file.h"
#include "hw/s390x/storage-keys.h"
#include "qemu/error-report.h"
#include "sysemu/kvm.h"

4
include/block/block_int.h
View File

@ -601,8 +601,8 @@ struct BlockDriverState {
int copy_on_read;
/* If we are reading a disk image, give its size in sectors.
* Generally read-only; it is written to by load_vmstate and save_vmstate,
* but the block layer is quiescent during those.
* Generally read-only; it is written to by load_snapshot and
* save_snaphost, but the block layer is quiescent during those.
*/
int64_t total_sectors;

1
include/hw/acpi/memory_hotplug.h
View File

@ -3,7 +3,6 @@
#include "hw/qdev-core.h"
#include "hw/acpi/acpi.h"
#include "migration/vmstate.h"
#include "hw/acpi/aml-build.h"
/**

1
include/hw/acpi/pcihp.h
View File

@ -28,7 +28,6 @@
#define HW_ACPI_PCIHP_H
#include "hw/acpi/acpi.h"
#include "migration/vmstate.h"
#include "hw/hotplug.h"
#define ACPI_PCIHP_IO_BASE_PROP "acpi-pcihp-io-base"

2
include/hw/hw.h
View File

@ -11,7 +11,7 @@
#include "exec/memory.h"
#include "hw/irq.h"
#include "migration/vmstate.h"
#include "migration/qemu-file.h"
#include "migration/qemu-file-types.h"
#include "qemu/module.h"
#include "sysemu/reset.h"

1
include/hw/pci/shpc.h
View File

@ -3,7 +3,6 @@
#include "qemu-common.h"
#include "exec/memory.h"
#include "migration/vmstate.h"
#include "hw/hotplug.h"
#include "hw/pci/pci.h"

73
include/migration/migration.h
View File

@ -18,7 +18,6 @@
#include "qemu-common.h"
#include "qemu/thread.h"
#include "qemu/notify.h"
#include "io/channel.h"
#include "qapi-types.h"
#include "exec/cpu-common.h"
#include "qemu/coroutine_int.h"
@ -50,8 +49,6 @@ enum mig_rp_message_type {
MIG_RP_MSG_MAX
};
typedef QLIST_HEAD(, LoadStateEntry) LoadStateEntry_Head;
/* State for the incoming migration */
struct MigrationIncomingState {
QEMUFile *from_src_file;
@ -89,9 +86,6 @@ struct MigrationIncomingState {
/* The coroutine we should enter (back) after failover */
Coroutine *migration_incoming_co;
QemuSemaphore colo_incoming_sem;
/* See savevm.c */
LoadStateEntry_Head loadvm_handlers;
};
MigrationIncomingState *migration_incoming_get_current(void);
@ -157,37 +151,8 @@ void migration_fd_process_incoming(QEMUFile *f);
void qemu_start_incoming_migration(const char *uri, Error **errp);
void migration_tls_channel_process_incoming(MigrationState *s,
QIOChannel *ioc,
Error **errp);
void migration_tls_channel_connect(MigrationState *s,
QIOChannel *ioc,
const char *hostname,
Error **errp);
uint64_t migrate_max_downtime(void);
void exec_start_incoming_migration(const char *host_port, Error **errp);
void exec_start_outgoing_migration(MigrationState *s, const char *host_port, Error **errp);
void tcp_start_incoming_migration(const char *host_port, Error **errp);
void tcp_start_outgoing_migration(MigrationState *s, const char *host_port, Error **errp);
void unix_start_incoming_migration(const char *path, Error **errp);
void unix_start_outgoing_migration(MigrationState *s, const char *path, Error **errp);
void fd_start_incoming_migration(const char *path, Error **errp);
void fd_start_outgoing_migration(MigrationState *s, const char *fdname, Error **errp);
void rdma_start_outgoing_migration(void *opaque, const char *host_port, Error **errp);
void rdma_start_incoming_migration(const char *host_port, Error **errp);
void migrate_fd_error(MigrationState *s, const Error *error);
void migrate_fd_connect(MigrationState *s);
@ -206,38 +171,6 @@ bool migration_in_postcopy(void);
bool migration_in_postcopy_after_devices(MigrationState *);
MigrationState *migrate_get_current(void);
void migrate_compress_threads_create(void);
void migrate_compress_threads_join(void);
void migrate_decompress_threads_create(void);
void migrate_decompress_threads_join(void);
uint64_t ram_bytes_remaining(void);
uint64_t ram_bytes_transferred(void);
uint64_t ram_bytes_total(void);
uint64_t ram_dirty_sync_count(void);
uint64_t ram_dirty_pages_rate(void);
uint64_t ram_postcopy_requests(void);
void free_xbzrle_decoded_buf(void);
void acct_update_position(QEMUFile *f, size_t size, bool zero);
uint64_t dup_mig_pages_transferred(void);
uint64_t norm_mig_pages_transferred(void);
uint64_t xbzrle_mig_bytes_transferred(void);
uint64_t xbzrle_mig_pages_transferred(void);
uint64_t xbzrle_mig_pages_overflow(void);
uint64_t xbzrle_mig_pages_cache_miss(void);
double xbzrle_mig_cache_miss_rate(void);
void ram_handle_compressed(void *host, uint8_t ch, uint64_t size);
void ram_debug_dump_bitmap(unsigned long *todump, bool expected,
unsigned long pages);
/* For outgoing discard bitmap */
int ram_postcopy_send_discard_bitmap(MigrationState *ms);
/* For incoming postcopy discard */
int ram_discard_range(const char *block_name, uint64_t start, size_t length);
int ram_postcopy_incoming_init(MigrationIncomingState *mis);
void ram_postcopy_migrated_memory_release(MigrationState *ms);
bool migrate_release_ram(void);
bool migrate_postcopy_ram(void);
bool migrate_zero_blocks(void);
@ -248,8 +181,6 @@ int migrate_use_xbzrle(void);
int64_t migrate_xbzrle_cache_size(void);
bool migrate_colo_enabled(void);
int64_t xbzrle_cache_resize(int64_t new_size);
bool migrate_use_block(void);
bool migrate_use_block_incremental(void);
@ -288,7 +219,6 @@ size_t ram_control_save_page(QEMUFile *f, ram_addr_t block_offset,
ram_addr_t offset, size_t size,
uint64_t *bytes_sent);
void ram_mig_init(void);
void savevm_skip_section_footers(void);
void register_global_state(void);
void global_state_set_optional(void);
@ -296,7 +226,4 @@ void savevm_skip_configuration(void);
int global_state_store(void);
void global_state_store_running(void);
void migration_page_queue_free(void);
int ram_save_queue_pages(const char *rbname, ram_addr_t start, ram_addr_t len);
uint64_t ram_pagesize_summary(void);
#endif

29
include/migration/misc.h Normal file
View File

@ -0,0 +1,29 @@
/*
* QEMU migration miscellaneus exported functions
*
* Copyright IBM, Corp. 2008
*
* Authors:
* Anthony Liguori <aliguori@us.ibm.com>
*
* This work is licensed under the terms of the GNU GPL, version 2. See
* the COPYING file in the top-level directory.
*
*/
#ifndef MIGRATION_MISC_H
#define MIGRATION_MISC_H
/* migration/ram.c */
void ram_mig_init(void);
/* migration/block.c */
#ifdef CONFIG_LIVE_BLOCK_MIGRATION
void blk_mig_init(void);
#else
static inline void blk_mig_init(void) {}
#endif
#endif

164
include/migration/qemu-file-types.h Normal file
View File

@ -0,0 +1,164 @@
/*
* QEMU System Emulator
*
* Copyright (c) 2003-2008 Fabrice Bellard
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
#ifndef QEMU_FILE_H
#define QEMU_FILE_H
void qemu_put_buffer(QEMUFile *f, const uint8_t *buf, size_t size);
void qemu_put_byte(QEMUFile *f, int v);
#define qemu_put_sbyte qemu_put_byte
void qemu_put_be16(QEMUFile *f, unsigned int v);
void qemu_put_be32(QEMUFile *f, unsigned int v);
void qemu_put_be64(QEMUFile *f, uint64_t v);
size_t qemu_get_buffer(QEMUFile *f, uint8_t *buf, size_t size);
int qemu_get_byte(QEMUFile *f);
static inline unsigned int qemu_get_ubyte(QEMUFile *f)
{
return (unsigned int)qemu_get_byte(f);
}
#define qemu_get_sbyte qemu_get_byte
unsigned int qemu_get_be16(QEMUFile *f);
unsigned int qemu_get_be32(QEMUFile *f);
uint64_t qemu_get_be64(QEMUFile *f);
static inline void qemu_put_be64s(QEMUFile *f, const uint64_t *pv)
{
qemu_put_be64(f, *pv);
}
static inline void qemu_put_be32s(QEMUFile *f, const uint32_t *pv)
{
qemu_put_be32(f, *pv);
}
static inline void qemu_put_be16s(QEMUFile *f, const uint16_t *pv)
{
qemu_put_be16(f, *pv);
}
static inline void qemu_put_8s(QEMUFile *f, const uint8_t *pv)
{
qemu_put_byte(f, *pv);
}
static inline void qemu_get_be64s(QEMUFile *f, uint64_t *pv)
{
*pv = qemu_get_be64(f);
}
static inline void qemu_get_be32s(QEMUFile *f, uint32_t *pv)
{
*pv = qemu_get_be32(f);
}
static inline void qemu_get_be16s(QEMUFile *f, uint16_t *pv)
{
*pv = qemu_get_be16(f);
}
static inline void qemu_get_8s(QEMUFile *f, uint8_t *pv)
{
*pv = qemu_get_byte(f);
}
/* Signed versions for type safety */
static inline void qemu_put_sbe16(QEMUFile *f, int v)
{
qemu_put_be16(f, (unsigned int)v);
}
static inline void qemu_put_sbe32(QEMUFile *f, int v)
{
qemu_put_be32(f, (unsigned int)v);
}
static inline void qemu_put_sbe64(QEMUFile *f, int64_t v)
{
qemu_put_be64(f, (uint64_t)v);
}
static inline int qemu_get_sbe16(QEMUFile *f)
{
return (int)qemu_get_be16(f);
}
static inline int qemu_get_sbe32(QEMUFile *f)
{
return (int)qemu_get_be32(f);
}
static inline int64_t qemu_get_sbe64(QEMUFile *f)
{
return (int64_t)qemu_get_be64(f);
}
static inline void qemu_put_s8s(QEMUFile *f, const int8_t *pv)
{
qemu_put_8s(f, (const uint8_t *)pv);
}
static inline void qemu_put_sbe16s(QEMUFile *f, const int16_t *pv)
{
qemu_put_be16s(f, (const uint16_t *)pv);
}
static inline void qemu_put_sbe32s(QEMUFile *f, const int32_t *pv)
{
qemu_put_be32s(f, (const uint32_t *)pv);
}
static inline void qemu_put_sbe64s(QEMUFile *f, const int64_t *pv)
{
qemu_put_be64s(f, (const uint64_t *)pv);
}
static inline void qemu_get_s8s(QEMUFile *f, int8_t *pv)
{
qemu_get_8s(f, (uint8_t *)pv);
}
static inline void qemu_get_sbe16s(QEMUFile *f, int16_t *pv)
{
qemu_get_be16s(f, (uint16_t *)pv);
}
static inline void qemu_get_sbe32s(QEMUFile *f, int32_t *pv)
{
qemu_get_be32s(f, (uint32_t *)pv);
}
static inline void qemu_get_sbe64s(QEMUFile *f, int64_t *pv)
{
qemu_get_be64s(f, (uint64_t *)pv);
}
int qemu_file_rate_limit(QEMUFile *f);
#endif

21
include/migration/snapshot.h Normal file
View File

@ -0,0 +1,21 @@
/*
* QEMU snapshots
*
* Copyright (c) 2004-2008 Fabrice Bellard
* Copyright (c) 2009-2015 Red Hat Inc
*
* Authors:
* Juan Quintela <quintela@redhat.com>
*
*
* This work is licensed under the terms of the GNU GPL, version 2 or later.
* See the COPYING file in the top-level directory.
*/
#ifndef QEMU_MIGRATION_SNAPSHOT_H
#define QEMU_MIGRATION_SNAPSHOT_H
int save_snapshot(const char *name, Error **errp);
int load_snapshot(const char *name, Error **errp);
#endif

2
include/migration/vmstate.h
View File

@ -1020,8 +1020,6 @@ extern const VMStateInfo vmstate_info_qtailq;
#define SELF_ANNOUNCE_ROUNDS 5
void loadvm_free_handlers(MigrationIncomingState *mis);
int vmstate_load_state(QEMUFile *f, const VMStateDescription *vmsd,
void *opaque, int version_id);
void vmstate_save_state(QEMUFile *f, const VMStateDescription *vmsd,

1
include/qemu/typedefs.h
View File

@ -39,7 +39,6 @@ typedef struct I2SCodec I2SCodec;
typedef struct ISABus ISABus;
typedef struct ISADevice ISADevice;
typedef struct IsaDma IsaDma;
typedef struct LoadStateEntry LoadStateEntry;
typedef struct MACAddr MACAddr;
typedef struct MachineClass MachineClass;
typedef struct MachineState MachineState;

3
include/sysemu/sysemu.h
View File

@ -92,9 +92,6 @@ void qemu_remove_exit_notifier(Notifier *notify);
void qemu_add_machine_init_done_notifier(Notifier *notify);
void qemu_remove_machine_init_done_notifier(Notifier *notify);
int save_vmstate(const char *name, Error **errp);
int load_vmstate(const char *name, Error **errp);
void qemu_announce_self(void);
extern int autostart;

5
migration/block.c
View File

@ -23,10 +23,11 @@
#include "qemu/cutils.h"
#include "qemu/queue.h"
#include "qemu/timer.h"
#include "migration/block.h"
#include "block.h"
#include "migration/misc.h"
#include "migration/migration.h"
#include "sysemu/blockdev.h"
#include "migration/qemu-file.h"
#include "qemu-file.h"
#include "migration/vmstate.h"
#include "sysemu/block-backend.h"

2
include/migration/block.h → migration/block.h
View File

@ -15,14 +15,12 @@
#define MIGRATION_BLOCK_H
#ifdef CONFIG_LIVE_BLOCK_MIGRATION
void blk_mig_init(void);
int blk_mig_active(void);
uint64_t blk_mig_bytes_transferred(void);
uint64_t blk_mig_bytes_remaining(void);
uint64_t blk_mig_bytes_total(void);
#else
static inline void blk_mig_init(void) { }
static inline int blk_mig_active(void)
{
return false;

1
migration/channel.c
View File

@ -12,6 +12,7 @@
#include "qemu/osdep.h"
#include "channel.h"
#include "tls.h"
#include "migration/migration.h"
#include "qemu-file-channel.h"
#include "trace.h"

4
migration/colo.c
View File

@ -15,10 +15,10 @@
#include "sysemu/sysemu.h"
#include "qemu-file-channel.h"
#include "migration/migration.h"
#include "migration/qemu-file.h"
#include "qemu-file.h"
#include "savevm.h"
#include "migration/colo.h"
#include "migration/block.h"
#include "block.h"
#include "io/channel-buffer.h"
#include "trace.h"
#include "qemu/error-report.h"

1
migration/exec.c
View File

@ -21,6 +21,7 @@
#include "qapi/error.h"
#include "qemu-common.h"
#include "channel.h"
#include "exec.h"
#include "migration/migration.h"
#include "io/channel-command.h"
#include "trace.h"

26
migration/exec.h Normal file
View File

@ -0,0 +1,26 @@
/*
* QEMU live migration
*
* Copyright IBM, Corp. 2008
* Copyright Dell MessageOne 2008
* Copyright Red Hat, Inc. 2015-2016
*
* Authors:
* Anthony Liguori <aliguori@us.ibm.com>
* Charles Duffy <charles_duffy@messageone.com>
* Daniel P. Berrange <berrange@redhat.com>
*
* This work is licensed under the terms of the GNU GPL, version 2. See
* the COPYING file in the top-level directory.
*
* Contributions after 2012-01-13 are licensed under the terms of the
* GNU GPL, version 2 or (at your option) any later version.
*/
#ifndef QEMU_MIGRATION_EXEC_H
#define QEMU_MIGRATION_EXEC_H
void exec_start_incoming_migration(const char *host_port, Error **errp);
void exec_start_outgoing_migration(MigrationState *s, const char *host_port,
Error **errp);
#endif

1
migration/fd.c
View File

@ -18,6 +18,7 @@
#include "qapi/error.h"
#include "qemu-common.h"
#include "channel.h"
#include "fd.h"
#include "migration/migration.h"
#include "monitor/monitor.h"
#include "io/channel-util.h"

23
migration/fd.h Normal file
View File

@ -0,0 +1,23 @@
/*
* QEMU live migration via generic fd
*
* Copyright Red Hat, Inc. 2009-2016
*
* Authors:
* Chris Lalancette <clalance@redhat.com>
* Daniel P. Berrange <berrange@redhat.com>
*
* This work is licensed under the terms of the GNU GPL, version 2. See
* the COPYING file in the top-level directory.
*
* Contributions after 2012-01-13 are licensed under the terms of the
* GNU GPL, version 2 or (at your option) any later version.
*/
#ifndef QEMU_MIGRATION_FD_H
#define QEMU_MIGRATION_FD_H
void fd_start_incoming_migration(const char *path, Error **errp);
void fd_start_outgoing_migration(MigrationState *s, const char *fdname,
Error **errp);
#endif

25
migration/migration.c
View File

@ -18,10 +18,15 @@
#include "qemu/error-report.h"
#include "qemu/main-loop.h"
#include "migration/blocker.h"
#include "exec.h"
#include "fd.h"
#include "socket.h"
#include "rdma.h"
#include "ram.h"
#include "migration/migration.h"
#include "savevm.h"
#include "qemu-file-channel.h"
#include "migration/qemu-file.h"
#include "qemu-file.h"
#include "migration/vmstate.h"
#include "sysemu/sysemu.h"
#include "block/block.h"
@ -29,7 +34,7 @@
#include "qapi/util.h"
#include "qemu/sockets.h"
#include "qemu/rcu.h"
#include "migration/block.h"
#include "block.h"
#include "postcopy-ram.h"
#include "qemu/thread.h"
#include "qmp-commands.h"
@ -40,7 +45,6 @@
#include "exec/address-spaces.h"
#include "exec/target_page.h"
#include "io/channel-buffer.h"
#include "io/channel-tls.h"
#include "migration/colo.h"
#define MAX_THROTTLE (32 << 20) /* Migration transfer speed throttling */
@ -122,7 +126,6 @@ MigrationIncomingState *migration_incoming_get_current(void)
if (!once) {
mis_current.state = MIGRATION_STATUS_NONE;
memset(&mis_current, 0, sizeof(MigrationIncomingState));
QLIST_INIT(&mis_current.loadvm_handlers);
qemu_mutex_init(&mis_current.rp_mutex);
qemu_event_init(&mis_current.main_thread_load_event, false);
once = true;
@ -134,8 +137,19 @@ void migration_incoming_state_destroy(void)
{
struct MigrationIncomingState *mis = migration_incoming_get_current();
if (mis->to_src_file) {
/* Tell source that we are done */
migrate_send_rp_shut(mis, qemu_file_get_error(mis->from_src_file) != 0);
qemu_fclose(mis->to_src_file);
mis->to_src_file = NULL;
}
if (mis->from_src_file) {
qemu_fclose(mis->from_src_file);
mis->from_src_file = NULL;
}
qemu_event_destroy(&mis->main_thread_load_event);
loadvm_free_handlers(mis);
}
@ -432,7 +446,6 @@ static void process_incoming_migration_co(void *opaque)
exit(EXIT_FAILURE);
}
qemu_fclose(f);
free_xbzrle_decoded_buf();
mis->bh = qemu_bh_new(process_incoming_migration_bh, mis);

4
migration/postcopy-ram.c
View File

@ -21,9 +21,10 @@
#include "qemu-common.h"
#include "exec/target_page.h"
#include "migration/migration.h"
#include "migration/qemu-file.h"
#include "qemu-file.h"
#include "savevm.h"
#include "postcopy-ram.h"
#include "ram.h"
#include "sysemu/sysemu.h"
#include "sysemu/balloon.h"
#include "qemu/error-report.h"
@ -333,7 +334,6 @@ int postcopy_ram_incoming_cleanup(MigrationIncomingState *mis)
}
postcopy_state_set(POSTCOPY_INCOMING_END);
migrate_send_rp_shut(mis, qemu_file_get_error(mis->from_src_file) != 0);
if (mis->postcopy_tmp_page) {
munmap(mis->postcopy_tmp_page, mis->largest_page_size);

3
migration/qemu-file-channel.c
View File

@ -24,7 +24,8 @@
#include "qemu/osdep.h"
#include "qemu-file-channel.h"
#include "migration/qemu-file.h"
#include "exec/cpu-common.h"
#include "qemu-file.h"
#include "io/channel-socket.h"
#include "qemu/iov.h"

2
migration/qemu-file.c
View File

@ -29,7 +29,7 @@
#include "qemu/sockets.h"
#include "qemu/coroutine.h"
#include "migration/migration.h"
#include "migration/qemu-file.h"
#include "qemu-file.h"
#include "trace.h"
#define IO_BUF_SIZE 32768

157
include/migration/qemu-file.h → migration/qemu-file.h
View File

@ -22,11 +22,8 @@
* THE SOFTWARE.
*/
#ifndef QEMU_FILE_H
#define QEMU_FILE_H
#include "qemu-common.h"
#include "exec/cpu-common.h"
#ifndef MIGRATION_QEMU_FILE_H
#define MIGRATION_QEMU_FILE_H
/* Read a chunk of data from a file at the given position. The pos argument
* can be ignored if the file is only be used for streaming. The number of
@ -122,8 +119,6 @@ int qemu_get_fd(QEMUFile *f);
int qemu_fclose(QEMUFile *f);
int64_t qemu_ftell(QEMUFile *f);
int64_t qemu_ftell_fast(QEMUFile *f);
void qemu_put_buffer(QEMUFile *f, const uint8_t *buf, size_t size);
void qemu_put_byte(QEMUFile *f, int v);
/*
* put_buffer without copying the buffer.
* The buffer should be available till it is sent asynchronously.
@ -133,19 +128,9 @@ void qemu_put_buffer_async(QEMUFile *f, const uint8_t *buf, size_t size,
bool qemu_file_mode_is_not_valid(const char *mode);
bool qemu_file_is_writable(QEMUFile *f);
#include "migration/qemu-file-types.h"
static inline void qemu_put_ubyte(QEMUFile *f, unsigned int v)
{
qemu_put_byte(f, (int)v);
}
#define qemu_put_sbyte qemu_put_byte
void qemu_put_be16(QEMUFile *f, unsigned int v);
void qemu_put_be32(QEMUFile *f, unsigned int v);
void qemu_put_be64(QEMUFile *f, uint64_t v);
size_t qemu_peek_buffer(QEMUFile *f, uint8_t **buf, size_t size, size_t offset);
size_t qemu_get_buffer(QEMUFile *f, uint8_t *buf, size_t size);
size_t qemu_get_buffer_in_place(QEMUFile *f, uint8_t **buf, size_t size);
ssize_t qemu_put_compression_data(QEMUFile *f, const uint8_t *p, size_t size,
int level);
@ -157,22 +142,8 @@ int qemu_put_qemu_file(QEMUFile *f_des, QEMUFile *f_src);
* previously peeked +n-1.
*/
int qemu_peek_byte(QEMUFile *f, int offset);
int qemu_get_byte(QEMUFile *f);
void qemu_file_skip(QEMUFile *f, int size);
void qemu_update_position(QEMUFile *f, size_t size);
static inline unsigned int qemu_get_ubyte(QEMUFile *f)
{
return (unsigned int)qemu_get_byte(f);
}
#define qemu_get_sbyte qemu_get_byte
unsigned int qemu_get_be16(QEMUFile *f);
unsigned int qemu_get_be32(QEMUFile *f);
uint64_t qemu_get_be64(QEMUFile *f);
int qemu_file_rate_limit(QEMUFile *f);
void qemu_file_reset_rate_limit(QEMUFile *f);
void qemu_file_set_rate_limit(QEMUFile *f, int64_t new_rate);
int64_t qemu_file_get_rate_limit(QEMUFile *f);
@ -183,127 +154,7 @@ QEMUFile *qemu_file_get_return_path(QEMUFile *f);
void qemu_fflush(QEMUFile *f);
void qemu_file_set_blocking(QEMUFile *f, bool block);
static inline void qemu_put_be64s(QEMUFile *f, const uint64_t *pv)
{
qemu_put_be64(f, *pv);
}
static inline void qemu_put_be32s(QEMUFile *f, const uint32_t *pv)
{
qemu_put_be32(f, *pv);
}
static inline void qemu_put_be16s(QEMUFile *f, const uint16_t *pv)
{
qemu_put_be16(f, *pv);
}
static inline void qemu_put_8s(QEMUFile *f, const uint8_t *pv)
{
qemu_put_byte(f, *pv);
}
static inline void qemu_get_be64s(QEMUFile *f, uint64_t *pv)
{
*pv = qemu_get_be64(f);
}
static inline void qemu_get_be32s(QEMUFile *f, uint32_t *pv)
{
*pv = qemu_get_be32(f);
}
static inline void qemu_get_be16s(QEMUFile *f, uint16_t *pv)
{
*pv = qemu_get_be16(f);
}
static inline void qemu_get_8s(QEMUFile *f, uint8_t *pv)
{
*pv = qemu_get_byte(f);
}
// Signed versions for type safety
static inline void qemu_put_sbuffer(QEMUFile *f, const int8_t *buf, size_t size)
{
qemu_put_buffer(f, (const uint8_t *)buf, size);
}
static inline void qemu_put_sbe16(QEMUFile *f, int v)
{
qemu_put_be16(f, (unsigned int)v);
}
static inline void qemu_put_sbe32(QEMUFile *f, int v)
{
qemu_put_be32(f, (unsigned int)v);
}
static inline void qemu_put_sbe64(QEMUFile *f, int64_t v)
{
qemu_put_be64(f, (uint64_t)v);
}
static inline size_t qemu_get_sbuffer(QEMUFile *f, int8_t *buf, int size)
{
return qemu_get_buffer(f, (uint8_t *)buf, size);
}
static inline int qemu_get_sbe16(QEMUFile *f)
{
return (int)qemu_get_be16(f);
}
static inline int qemu_get_sbe32(QEMUFile *f)
{
return (int)qemu_get_be32(f);
}
static inline int64_t qemu_get_sbe64(QEMUFile *f)
{
return (int64_t)qemu_get_be64(f);
}
static inline void qemu_put_s8s(QEMUFile *f, const int8_t *pv)
{
qemu_put_8s(f, (const uint8_t *)pv);
}
static inline void qemu_put_sbe16s(QEMUFile *f, const int16_t *pv)
{
qemu_put_be16s(f, (const uint16_t *)pv);
}
static inline void qemu_put_sbe32s(QEMUFile *f, const int32_t *pv)
{
qemu_put_be32s(f, (const uint32_t *)pv);
}
static inline void qemu_put_sbe64s(QEMUFile *f, const int64_t *pv)
{
qemu_put_be64s(f, (const uint64_t *)pv);
}
static inline void qemu_get_s8s(QEMUFile *f, int8_t *pv)
{
qemu_get_8s(f, (uint8_t *)pv);
}
static inline void qemu_get_sbe16s(QEMUFile *f, int16_t *pv)
{
qemu_get_be16s(f, (uint16_t *)pv);
}
static inline void qemu_get_sbe32s(QEMUFile *f, int32_t *pv)
{
qemu_get_be32s(f, (uint32_t *)pv);
}
static inline void qemu_get_sbe64s(QEMUFile *f, int64_t *pv)
{
qemu_get_be64s(f, (uint64_t *)pv);
}
size_t qemu_get_counted_string(QEMUFile *f, char buf[256]);
#endif

4
migration/ram.c
View File

@ -36,8 +36,10 @@
#include "qemu/timer.h"
#include "qemu/main-loop.h"
#include "xbzrle.h"
#include "ram.h"
#include "migration/migration.h"
#include "migration/qemu-file.h"
#include "migration/misc.h"
#include "qemu-file.h"
#include "migration/vmstate.h"
#include "postcopy-ram.h"
#include "exec/address-spaces.h"

70
migration/ram.h Normal file
View File

@ -0,0 +1,70 @@
/*
* QEMU System Emulator
*
* Copyright (c) 2003-2008 Fabrice Bellard
* Copyright (c) 2011-2015 Red Hat Inc
*
* Authors:
* Juan Quintela <quintela@redhat.com>
*
* 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.
*/
#ifndef QEMU_MIGRATION_RAM_H
#define QEMU_MIGRATION_RAM_H
#include "qemu-common.h"
#include "exec/cpu-common.h"
int64_t xbzrle_cache_resize(int64_t new_size);
uint64_t dup_mig_pages_transferred(void);
uint64_t norm_mig_pages_transferred(void);
uint64_t xbzrle_mig_bytes_transferred(void);
uint64_t xbzrle_mig_pages_transferred(void);
uint64_t xbzrle_mig_pages_cache_miss(void);
double xbzrle_mig_cache_miss_rate(void);
uint64_t xbzrle_mig_pages_overflow(void);
uint64_t ram_bytes_transferred(void);
uint64_t ram_bytes_remaining(void);
uint64_t ram_dirty_sync_count(void);
uint64_t ram_dirty_pages_rate(void);
uint64_t ram_postcopy_requests(void);
uint64_t ram_bytes_total(void);
void migrate_compress_threads_create(void);
void migrate_compress_threads_join(void);
void migrate_decompress_threads_create(void);
void migrate_decompress_threads_join(void);
uint64_t ram_pagesize_summary(void);
void migration_page_queue_free(void);
int ram_save_queue_pages(const char *rbname, ram_addr_t start, ram_addr_t len);
void acct_update_position(QEMUFile *f, size_t size, bool zero);
void free_xbzrle_decoded_buf(void);
void ram_debug_dump_bitmap(unsigned long *todump, bool expected,
unsigned long pages);
void ram_postcopy_migrated_memory_release(MigrationState *ms);
/* For outgoing discard bitmap */
int ram_postcopy_send_discard_bitmap(MigrationState *ms);
/* For incoming postcopy discard */
int ram_discard_range(const char *block_name, uint64_t start, size_t length);
int ram_postcopy_incoming_init(MigrationIncomingState *mis);
void ram_handle_compressed(void *host, uint8_t ch, uint64_t size);
#endif

5
migration/rdma.c
View File

@ -17,9 +17,10 @@
#include "qapi/error.h"
#include "qemu-common.h"
#include "qemu/cutils.h"
#include "rdma.h"
#include "migration/migration.h"
#include "migration/qemu-file.h"
#include "exec/cpu-common.h"
#include "qemu-file.h"
#include "ram.h"
#include "qemu-file-channel.h"
#include "qemu/error-report.h"
#include "qemu/main-loop.h"

25
migration/rdma.h Normal file
View File

@ -0,0 +1,25 @@
/*
* RDMA protocol and interfaces
*
* Copyright IBM, Corp. 2010-2013
* Copyright Red Hat, Inc. 2015-2016
*
* Authors:
* Michael R. Hines <mrhines@us.ibm.com>
* Jiuxing Liu <jl@us.ibm.com>
* Daniel P. Berrange <berrange@redhat.com>
*
* This work is licensed under the terms of the GNU GPL, version 2 or
* later. See the COPYING file in the top-level directory.
*
*/
#ifndef QEMU_MIGRATION_RDMA_H
#define QEMU_MIGRATION_RDMA_H
void rdma_start_outgoing_migration(void *opaque, const char *host_port,
Error **errp);
void rdma_start_incoming_migration(const char *host_port, Error **errp);
#endif

71
migration/savevm.c
View File

@ -35,7 +35,10 @@
#include "sysemu/sysemu.h"
#include "qemu/timer.h"
#include "migration/migration.h"
#include "migration/snapshot.h"
#include "ram.h"
#include "qemu-file-channel.h"
#include "qemu-file.h"
#include "savevm.h"
#include "postcopy-ram.h"
#include "qapi/qmp/qerror.h"
@ -272,7 +275,11 @@ typedef struct SaveStateEntry {
int instance_id;
int alias_id;
int version_id;
/* version id read from the stream */
int load_version_id;
int section_id;
/* section id read from the stream */
int load_section_id;
SaveVMHandlers *ops;
const VMStateDescription *vmsd;
void *opaque;
@ -742,13 +749,13 @@ void vmstate_unregister(DeviceState *dev, const VMStateDescription *vmsd,
}
}
static int vmstate_load(QEMUFile *f, SaveStateEntry *se, int version_id)
static int vmstate_load(QEMUFile *f, SaveStateEntry *se)
{
trace_vmstate_load(se->idstr, se->vmsd ? se->vmsd->name : "(old)");
if (!se->vmsd) { /* Old style */
return se->ops->load_state(f, se->opaque, version_id);
return se->ops->load_state(f, se->opaque, se->load_version_id);
}
return vmstate_load_state(f, se->vmsd, se->opaque, version_id);
return vmstate_load_state(f, se->vmsd, se->opaque, se->load_version_id);
}
static void vmstate_save_old_style(QEMUFile *f, SaveStateEntry *se, QJSON *vmdesc)
@ -1800,20 +1807,13 @@ static int loadvm_process_command(QEMUFile *f)
return 0;
}
struct LoadStateEntry {
QLIST_ENTRY(LoadStateEntry) entry;
SaveStateEntry *se;
int section_id;
int version_id;
};
/*
* 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)
*/
static bool check_section_footer(QEMUFile *f, LoadStateEntry *le)
static bool check_section_footer(QEMUFile *f, SaveStateEntry *se)
{
uint8_t read_mark;
uint32_t read_section_id;
@ -1826,15 +1826,15 @@ static bool check_section_footer(QEMUFile *f, LoadStateEntry *le)
read_mark = qemu_get_byte(f);
if (read_mark != QEMU_VM_SECTION_FOOTER) {
error_report("Missing section footer for %s", le->se->idstr);
error_report("Missing section footer for %s", se->idstr);
return false;
}
read_section_id = qemu_get_be32(f);
if (read_section_id != le->section_id) {
if (read_section_id != se->load_section_id) {
error_report("Mismatched section id in footer for %s -"
" read 0x%x expected 0x%x",
le->se->idstr, read_section_id, le->section_id);
se->idstr, read_section_id, se->load_section_id);
return false;
}
@ -1842,22 +1842,11 @@ static bool check_section_footer(QEMUFile *f, LoadStateEntry *le)
return true;
}
void loadvm_free_handlers(MigrationIncomingState *mis)
{
LoadStateEntry *le, *new_le;
QLIST_FOREACH_SAFE(le, &mis->loadvm_handlers, entry, new_le) {
QLIST_REMOVE(le, entry);
g_free(le);
}
}
static int
qemu_loadvm_section_start_full(QEMUFile *f, MigrationIncomingState *mis)
{
uint32_t instance_id, version_id, section_id;
SaveStateEntry *se;
LoadStateEntry *le;
char idstr[256];
int ret;
@ -1887,6 +1876,8 @@ qemu_loadvm_section_start_full(QEMUFile *f, MigrationIncomingState *mis)
version_id, idstr, se->version_id);
return -EINVAL;
}
se->load_version_id = version_id;
se->load_section_id = section_id;
/* Validate if it is a device's state */
if (xen_enabled() && se->is_ram) {
@ -1894,21 +1885,13 @@ qemu_loadvm_section_start_full(QEMUFile *f, MigrationIncomingState *mis)
return -EINVAL;
}
/* Add entry */
le = g_malloc0(sizeof(*le));
le->se = se;
le->section_id = section_id;
le->version_id = version_id;
QLIST_INSERT_HEAD(&mis->loadvm_handlers, le, entry);
ret = vmstate_load(f, le->se, le->version_id);
ret = vmstate_load(f, se);
if (ret < 0) {
error_report("error while loading state for instance 0x%x of"
" device '%s'", instance_id, idstr);
return ret;
}
if (!check_section_footer(f, le)) {
if (!check_section_footer(f, se)) {
return -EINVAL;
}
@ -1919,29 +1902,29 @@ static int
qemu_loadvm_section_part_end(QEMUFile *f, MigrationIncomingState *mis)
{
uint32_t section_id;
LoadStateEntry *le;
SaveStateEntry *se;
int ret;
section_id = qemu_get_be32(f);
trace_qemu_loadvm_state_section_partend(section_id);
QLIST_FOREACH(le, &mis->loadvm_handlers, entry) {
if (le->section_id == section_id) {
QTAILQ_FOREACH(se, &savevm_state.handlers, entry) {
if (se->load_section_id == section_id) {
break;
}
}
if (le == NULL) {
if (se == NULL) {
error_report("Unknown savevm section %d", section_id);
return -EINVAL;
}
ret = vmstate_load(f, le->se, le->version_id);
ret = vmstate_load(f, se);
if (ret < 0) {
error_report("error while loading state section id %d(%s)",
section_id, le->se->idstr);
section_id, se->idstr);
return ret;
}
if (!check_section_footer(f, le)) {
if (!check_section_footer(f, se)) {
return -EINVAL;
}
@ -2086,7 +2069,7 @@ int qemu_loadvm_state(QEMUFile *f)
return ret;
}
int save_vmstate(const char *name, Error **errp)
int save_snapshot(const char *name, Error **errp)
{
BlockDriverState *bs, *bs1;
QEMUSnapshotInfo sn1, *sn = &sn1, old_sn1, *old_sn = &old_sn1;
@ -2243,7 +2226,7 @@ void qmp_xen_load_devices_state(const char *filename, Error **errp)
migration_incoming_state_destroy();
}
int load_vmstate(const char *name, Error **errp)
int load_snapshot(const char *name, Error **errp)
{
BlockDriverState *bs, *bs_vm_state;
QEMUSnapshotInfo sn;

3
migration/socket.c
View File

@ -20,8 +20,9 @@
#include "qemu/error-report.h"
#include "qapi/error.h"
#include "channel.h"
#include "socket.h"
#include "migration/migration.h"
#include "migration/qemu-file.h"
#include "qemu-file.h"
#include "io/channel-socket.h"
#include "trace.h"

28
migration/socket.h Normal file
View File

@ -0,0 +1,28 @@
/*
* QEMU live migration via socket
*
* Copyright Red Hat, Inc. 2009-2016
*
* Authors:
* Chris Lalancette <clalance@redhat.com>
* Daniel P. Berrange <berrange@redhat.com>
*
* This work is licensed under the terms of the GNU GPL, version 2. See
* the COPYING file in the top-level directory.
*
* Contributions after 2012-01-13 are licensed under the terms of the
* GNU GPL, version 2 or (at your option) any later version.
*/
#ifndef QEMU_MIGRATION_SOCKET_H
#define QEMU_MIGRATION_SOCKET_H
void tcp_start_incoming_migration(const char *host_port, Error **errp);
void tcp_start_outgoing_migration(MigrationState *s, const char *host_port,
Error **errp);
void unix_start_incoming_migration(const char *path, Error **errp);
void unix_start_outgoing_migration(MigrationState *s, const char *path,
Error **errp);
#endif

1
migration/tls.c
View File

@ -21,6 +21,7 @@
#include "qemu/osdep.h"
#include "channel.h"
#include "migration/migration.h"
#include "tls.h"
#include "io/channel-tls.h"
#include "crypto/tlscreds.h"
#include "qemu/error-report.h"

34
migration/tls.h Normal file
View File

@ -0,0 +1,34 @@
/*
* QEMU migration TLS support
*
* Copyright (c) 2015 Red Hat, Inc.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, see <http://www.gnu.org/licenses/>.
*
*/
#ifndef QEMU_MIGRATION_TLS_H
#define QEMU_MIGRATION_TLS_H
#include "io/channel.h"
void migration_tls_channel_process_incoming(MigrationState *s,
QIOChannel *ioc,
Error **errp);
void migration_tls_channel_connect(MigrationState *s,
QIOChannel *ioc,
const char *hostname,
Error **errp);
#endif

3
migration/vmstate-types.c
View File

@ -12,8 +12,9 @@
#include "qemu/osdep.h"
#include "qemu-common.h"
#include "exec/cpu-common.h"
#include "qemu-file.h"
#include "migration/migration.h"
#include "migration/qemu-file.h"
#include "migration/vmstate.h"
#include "qemu/error-report.h"
#include "qemu/queue.h"

2
migration/vmstate.c
View File

@ -13,8 +13,8 @@
#include "qemu/osdep.h"
#include "qemu-common.h"
#include "migration/migration.h"
#include "migration/qemu-file.h"
#include "migration/vmstate.h"
#include "qemu-file.h"
#include "qemu/bitops.h"
#include "qemu/error-report.h"
#include "trace.h"

5
replay/replay-snapshot.c
View File

@ -19,6 +19,7 @@
#include "qapi/qmp/qstring.h"
#include "qemu/error-report.h"
#include "migration/vmstate.h"
#include "migration/snapshot.h"
static void replay_pre_save(void *opaque)
{
@ -66,13 +67,13 @@ void replay_vmstate_init(void)
if (replay_snapshot) {
if (replay_mode == REPLAY_MODE_RECORD) {
if (save_vmstate(replay_snapshot, &err) != 0) {
if (save_snapshot(replay_snapshot, &err) != 0) {
error_report_err(err);
error_report("Could not create snapshot for icount record");
exit(1);
}
} else if (replay_mode == REPLAY_MODE_PLAY) {
if (load_vmstate(replay_snapshot, &err) != 0) {
if (load_snapshot(replay_snapshot, &err) != 0) {
error_report_err(err);
error_report("Could not load snapshot for icount replay");
exit(1);

1
target/alpha/cpu.c
View File

@ -23,7 +23,6 @@
#include "qapi/error.h"
#include "cpu.h"
#include "qemu-common.h"
#include "migration/vmstate.h"
#include "exec/exec-all.h"

1
target/hppa/cpu.c
View File

@ -22,7 +22,6 @@
#include "qapi/error.h"
#include "cpu.h"
#include "qemu-common.h"
#include "migration/vmstate.h"
#include "exec/exec-all.h"

1
target/s390x/cpu.c
View File

@ -32,7 +32,6 @@
#include "qemu/error-report.h"
#include "trace.h"
#include "qapi/visitor.h"
#include "migration/vmstate.h"
#include "exec/exec-all.h"
#ifndef CONFIG_USER_ONLY
#include "hw/hw.h"

1
target/tilegx/cpu.c
View File

@ -23,7 +23,6 @@
#include "cpu.h"
#include "qemu-common.h"
#include "hw/qdev-properties.h"
#include "migration/vmstate.h"
#include "linux-user/syscall_defs.h"
#include "exec/exec-all.h"

3
tests/test-vmstate.c
View File

@ -27,7 +27,8 @@
#include "qemu-common.h"
#include "migration/migration.h"
#include "migration/vmstate.h"
#include "migration/qemu-file.h"
#include "migration/qemu-file-types.h"
#include "../migration/qemu-file.h"
#include "../migration/qemu-file-channel.h"
#include "qemu/coroutine.h"
#include "io/channel-file.h"

5
vl.c
View File

@ -86,7 +86,8 @@ int main(int argc, char **argv)
#include "qemu/log.h"
#include "sysemu/blockdev.h"
#include "hw/block/block.h"
#include "migration/block.h"
#include "migration/misc.h"
#include "migration/snapshot.h"
#include "sysemu/tpm.h"
#include "sysemu/dma.h"
#include "hw/audio/soundhw.h"
@ -4722,7 +4723,7 @@ int main(int argc, char **argv, char **envp)
replay_vmstate_init();
} else if (loadvm) {
Error *local_err = NULL;
if (load_vmstate(loadvm, &local_err) < 0) {
if (load_snapshot(loadvm, &local_err) < 0) {
error_report_err(local_err);
autostart = 0;
}