2008-10-13 05:12:02 +02:00
|
|
|
/*
|
|
|
|
* QEMU live migration
|
|
|
|
*
|
|
|
|
* 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 QEMU_MIGRATION_H
|
|
|
|
#define QEMU_MIGRATION_H
|
|
|
|
|
2012-12-17 18:19:43 +01:00
|
|
|
#include "qapi/qmp/qdict.h"
|
2009-03-06 00:01:23 +01:00
|
|
|
#include "qemu-common.h"
|
2012-12-19 09:55:50 +01:00
|
|
|
#include "qemu/thread.h"
|
2012-12-17 18:20:00 +01:00
|
|
|
#include "qemu/notify.h"
|
2012-12-17 18:19:50 +01:00
|
|
|
#include "migration/vmstate.h"
|
2012-08-06 20:42:47 +02:00
|
|
|
#include "qapi-types.h"
|
2013-06-26 03:35:35 +02:00
|
|
|
#include "exec/cpu-common.h"
|
2009-03-06 00:01:23 +01:00
|
|
|
|
2013-11-28 15:01:11 +01:00
|
|
|
#define QEMU_VM_FILE_MAGIC 0x5145564d
|
|
|
|
#define QEMU_VM_FILE_VERSION_COMPAT 0x00000002
|
|
|
|
#define QEMU_VM_FILE_VERSION 0x00000003
|
|
|
|
|
|
|
|
#define QEMU_VM_EOF 0x00
|
|
|
|
#define QEMU_VM_SECTION_START 0x01
|
|
|
|
#define QEMU_VM_SECTION_PART 0x02
|
|
|
|
#define QEMU_VM_SECTION_END 0x03
|
|
|
|
#define QEMU_VM_SECTION_FULL 0x04
|
|
|
|
#define QEMU_VM_SUBSECTION 0x05
|
2015-01-22 15:01:39 +01:00
|
|
|
#define QEMU_VM_VMDESCRIPTION 0x06
|
2015-05-13 18:17:43 +02:00
|
|
|
#define QEMU_VM_CONFIGURATION 0x07
|
2015-11-05 19:10:45 +01:00
|
|
|
#define QEMU_VM_COMMAND 0x08
|
2015-05-19 13:29:52 +02:00
|
|
|
#define QEMU_VM_SECTION_FOOTER 0x7e
|
2013-11-28 15:01:11 +01:00
|
|
|
|
2012-06-19 17:43:09 +02:00
|
|
|
struct MigrationParams {
|
|
|
|
bool blk;
|
|
|
|
bool shared;
|
|
|
|
};
|
|
|
|
|
2015-11-05 19:10:47 +01:00
|
|
|
/* Messages sent on the return path from destination to source */
|
|
|
|
enum mig_rp_message_type {
|
|
|
|
MIG_RP_MSG_INVALID = 0, /* Must be 0 */
|
|
|
|
MIG_RP_MSG_SHUT, /* sibling will not send any more RP messages */
|
|
|
|
MIG_RP_MSG_PONG, /* Response to a PING; data (seq: be32 ) */
|
|
|
|
|
2015-11-05 19:11:07 +01:00
|
|
|
MIG_RP_MSG_REQ_PAGES_ID, /* data (start: be64, len: be32, id: string) */
|
|
|
|
MIG_RP_MSG_REQ_PAGES, /* data (start: be64, len: be32) */
|
|
|
|
|
2015-11-05 19:10:47 +01:00
|
|
|
MIG_RP_MSG_MAX
|
|
|
|
};
|
|
|
|
|
2015-05-21 14:24:16 +02:00
|
|
|
typedef QLIST_HEAD(, LoadStateEntry) LoadStateEntry_Head;
|
2015-11-05 19:10:52 +01:00
|
|
|
|
|
|
|
/* The current postcopy state is read/set by postcopy_state_get/set
|
|
|
|
* which update it atomically.
|
|
|
|
* The state is updated as postcopy messages are received, and
|
|
|
|
* in general only one thread should be writing to the state at any one
|
|
|
|
* time, initially the main thread and then the listen thread;
|
|
|
|
* Corner cases are where either thread finishes early and/or errors.
|
|
|
|
* The state is checked as messages are received to ensure that
|
|
|
|
* the source is sending us messages in the correct order.
|
|
|
|
* The state is also used by the RAM reception code to know if it
|
|
|
|
* has to place pages atomically, and the cleanup code at the end of
|
|
|
|
* the main thread to know if it has to delay cleanup until the end
|
|
|
|
* of postcopy.
|
|
|
|
*/
|
|
|
|
typedef enum {
|
|
|
|
POSTCOPY_INCOMING_NONE = 0, /* Initial state - no postcopy */
|
|
|
|
POSTCOPY_INCOMING_ADVISE,
|
|
|
|
POSTCOPY_INCOMING_DISCARD,
|
|
|
|
POSTCOPY_INCOMING_LISTENING,
|
|
|
|
POSTCOPY_INCOMING_RUNNING,
|
|
|
|
POSTCOPY_INCOMING_END
|
|
|
|
} PostcopyState;
|
|
|
|
|
2015-05-21 14:24:14 +02:00
|
|
|
/* State for the incoming migration */
|
|
|
|
struct MigrationIncomingState {
|
2015-11-05 19:10:34 +01:00
|
|
|
QEMUFile *from_src_file;
|
2015-05-21 14:24:16 +02:00
|
|
|
|
2015-11-05 19:10:50 +01:00
|
|
|
/*
|
|
|
|
* Free at the start of the main state load, set as the main thread finishes
|
|
|
|
* loading state.
|
|
|
|
*/
|
|
|
|
QemuEvent main_thread_load_event;
|
|
|
|
|
2015-11-05 19:11:17 +01:00
|
|
|
bool have_fault_thread;
|
2015-11-05 19:11:04 +01:00
|
|
|
QemuThread fault_thread;
|
|
|
|
QemuSemaphore fault_thread_sem;
|
|
|
|
|
2015-11-05 19:11:18 +01:00
|
|
|
bool have_listen_thread;
|
|
|
|
QemuThread listen_thread;
|
|
|
|
QemuSemaphore listen_thread_sem;
|
|
|
|
|
2015-11-05 19:11:03 +01:00
|
|
|
/* For the kernel to send us notifications */
|
|
|
|
int userfault_fd;
|
2015-11-05 19:11:17 +01:00
|
|
|
/* To tell the fault_thread to quit */
|
|
|
|
int userfault_quit_fd;
|
2015-11-05 19:10:46 +01:00
|
|
|
QEMUFile *to_src_file;
|
2015-11-05 19:10:47 +01:00
|
|
|
QemuMutex rp_mutex; /* We send replies from multiple threads */
|
2015-11-05 19:11:10 +01:00
|
|
|
void *postcopy_tmp_page;
|
2015-11-05 19:10:46 +01:00
|
|
|
|
2016-02-24 09:53:38 +01:00
|
|
|
QEMUBH *bh;
|
|
|
|
|
2015-12-16 12:47:34 +01:00
|
|
|
int state;
|
2015-05-21 14:24:16 +02:00
|
|
|
/* See savevm.c */
|
|
|
|
LoadStateEntry_Head loadvm_handlers;
|
2015-05-21 14:24:14 +02:00
|
|
|
};
|
|
|
|
|
|
|
|
MigrationIncomingState *migration_incoming_get_current(void);
|
|
|
|
MigrationIncomingState *migration_incoming_state_new(QEMUFile *f);
|
|
|
|
void migration_incoming_state_destroy(void);
|
|
|
|
|
2015-11-05 19:11:08 +01:00
|
|
|
/*
|
|
|
|
* An outstanding page request, on the source, having been received
|
|
|
|
* and queued
|
|
|
|
*/
|
|
|
|
struct MigrationSrcPageRequest {
|
|
|
|
RAMBlock *rb;
|
|
|
|
hwaddr offset;
|
|
|
|
hwaddr len;
|
|
|
|
|
|
|
|
QSIMPLEQ_ENTRY(MigrationSrcPageRequest) next_req;
|
|
|
|
};
|
|
|
|
|
2010-05-11 15:56:35 +02:00
|
|
|
struct MigrationState
|
2008-11-11 17:46:33 +01:00
|
|
|
{
|
|
|
|
int64_t bandwidth_limit;
|
2012-12-19 09:55:50 +01:00
|
|
|
size_t bytes_xfer;
|
|
|
|
size_t xfer_limit;
|
|
|
|
QemuThread thread;
|
2013-02-22 17:36:21 +01:00
|
|
|
QEMUBH *cleanup_bh;
|
2016-01-15 04:37:42 +01:00
|
|
|
QEMUFile *to_dst_file;
|
2016-04-27 12:05:14 +02:00
|
|
|
|
|
|
|
/* New style params from 'migrate-set-parameters' */
|
|
|
|
MigrationParameters parameters;
|
2013-02-22 17:36:41 +01:00
|
|
|
|
|
|
|
int state;
|
2016-04-27 12:05:14 +02:00
|
|
|
/* Old style params from 'migrate' command */
|
2012-06-19 17:43:09 +02:00
|
|
|
MigrationParams params;
|
2015-11-05 19:10:49 +01:00
|
|
|
|
|
|
|
/* State related to return path */
|
|
|
|
struct {
|
|
|
|
QEMUFile *from_dst_file;
|
|
|
|
QemuThread rp_thread;
|
|
|
|
bool error;
|
|
|
|
} rp_state;
|
|
|
|
|
2013-06-26 03:35:30 +02:00
|
|
|
double mbps;
|
2012-05-21 22:01:07 +02:00
|
|
|
int64_t total_time;
|
2012-08-13 09:35:16 +02:00
|
|
|
int64_t downtime;
|
2012-08-13 09:53:12 +02:00
|
|
|
int64_t expected_downtime;
|
2012-08-13 12:31:25 +02:00
|
|
|
int64_t dirty_pages_rate;
|
2013-02-01 13:22:37 +01:00
|
|
|
int64_t dirty_bytes_rate;
|
qapi: Don't let implicit enum MAX member collide
Now that we guarantee the user doesn't have any enum values
beginning with a single underscore, we can use that for our
own purposes. Renaming ENUM_MAX to ENUM__MAX makes it obvious
that the sentinel is generated.
This patch was mostly generated by applying a temporary patch:
|diff --git a/scripts/qapi.py b/scripts/qapi.py
|index e6d014b..b862ec9 100644
|--- a/scripts/qapi.py
|+++ b/scripts/qapi.py
|@@ -1570,6 +1570,7 @@ const char *const %(c_name)s_lookup[] = {
| max_index = c_enum_const(name, 'MAX', prefix)
| ret += mcgen('''
| [%(max_index)s] = NULL,
|+// %(max_index)s
| };
| ''',
| max_index=max_index)
then running:
$ cat qapi-{types,event}.c tests/test-qapi-types.c |
sed -n 's,^// \(.*\)MAX,s|\1MAX|\1_MAX|g,p' > list
$ git grep -l _MAX | xargs sed -i -f list
The only things not generated are the changes in scripts/qapi.py.
Rejecting enum members named 'MAX' is now useless, and will be dropped
in the next patch.
Signed-off-by: Eric Blake <eblake@redhat.com>
Message-Id: <1447836791-369-23-git-send-email-eblake@redhat.com>
Reviewed-by: Juan Quintela <quintela@redhat.com>
[Rebased to current master, commit message tweaked]
Signed-off-by: Markus Armbruster <armbru@redhat.com>
2015-11-18 09:52:57 +01:00
|
|
|
bool enabled_capabilities[MIGRATION_CAPABILITY__MAX];
|
2012-08-06 20:42:53 +02:00
|
|
|
int64_t xbzrle_cache_size;
|
2013-07-22 16:01:58 +02:00
|
|
|
int64_t setup_time;
|
2014-04-04 11:57:55 +02:00
|
|
|
int64_t dirty_sync_count;
|
2015-11-05 19:10:56 +01:00
|
|
|
|
|
|
|
/* Flag set once the migration has been asked to enter postcopy */
|
|
|
|
bool start_postcopy;
|
2016-02-22 18:17:32 +01:00
|
|
|
/* Flag set after postcopy has sent the device state */
|
|
|
|
bool postcopy_after_devices;
|
2015-11-05 19:11:05 +01:00
|
|
|
|
|
|
|
/* Flag set once the migration thread is running (and needs joining) */
|
|
|
|
bool migration_thread_running;
|
2015-11-05 19:11:08 +01:00
|
|
|
|
|
|
|
/* Queue of outstanding page requests from the destination */
|
|
|
|
QemuMutex src_page_req_mutex;
|
|
|
|
QSIMPLEQ_HEAD(src_page_requests, MigrationSrcPageRequest) src_page_requests;
|
|
|
|
/* The RAMBlock used in the last src_page_request */
|
|
|
|
RAMBlock *last_req_rb;
|
migration: add reporting of errors for outgoing migration
Currently if an application initiates an outgoing migration,
it may or may not, get an error reported back on failure. If
the error occurs synchronously to the 'migrate' command
execution, the client app will see the error message. This
is the case for DNS lookup failures. If the error occurs
asynchronously to the monitor command though, the error
will be thrown away and the client left guessing about
what went wrong. This is the case for failure to connect
to the TCP server (eg due to wrong port, or firewall
rules, or other similar errors).
In the future we'll be adding more scope for errors to
happen asynchronously with the TLS protocol handshake.
TLS errors are hard to diagnose even when they are well
reported, so discarding errors entirely will make it
impossible to debug TLS connection problems.
Management apps which do migration are already using
'query-migrate' / 'info migrate' to check up on progress
of background migration operations and to see their end
status. This is a fine place to also include the error
message when things go wrong.
This patch thus adds an 'error-desc' field to the
MigrationInfo struct, which will be populated when
the 'status' is set to 'failed':
(qemu) migrate -d tcp:localhost:9001
(qemu) info migrate
capabilities: xbzrle: off rdma-pin-all: off auto-converge: off zero-blocks: off compress: off events: off x-postcopy-ram: off
Migration status: failed (Error connecting to socket: Connection refused)
total time: 0 milliseconds
In the HMP, when doing non-detached migration, it is
also possible to display this error message directly
to the app.
(qemu) migrate tcp:localhost:9001
Error connecting to socket: Connection refused
Or with QMP
{
"execute": "query-migrate",
"arguments": {}
}
{
"return": {
"status": "failed",
"error-desc": "address resolution failed for myhost:9000: No address associated with hostname"
}
}
Reviewed-by: Dr. David Alan Gilbert <dgilbert@redhat.com>
Signed-off-by: Daniel P. Berrange <berrange@redhat.com>
Reviewed-by: Juan Quintela <quintela@redhat.com>
Message-Id: <1461751518-12128-11-git-send-email-berrange@redhat.com>
Signed-off-by: Amit Shah <amit.shah@redhat.com>
2016-04-27 12:05:00 +02:00
|
|
|
|
|
|
|
/* The last error that occurred */
|
|
|
|
Error *error;
|
2008-11-11 17:46:33 +01:00
|
|
|
};
|
|
|
|
|
2015-12-16 12:47:33 +01:00
|
|
|
void migrate_set_state(int *state, int old_state, int new_state);
|
|
|
|
|
2010-06-09 14:10:55 +02:00
|
|
|
void process_incoming_migration(QEMUFile *f);
|
|
|
|
|
2012-10-02 18:21:18 +02:00
|
|
|
void qemu_start_incoming_migration(const char *uri, Error **errp);
|
2008-10-13 05:12:02 +02:00
|
|
|
|
2016-04-27 12:04:59 +02:00
|
|
|
void migration_set_incoming_channel(MigrationState *s,
|
|
|
|
QIOChannel *ioc);
|
|
|
|
|
migration: add support for encrypting data with TLS
This extends the migration_set_incoming_channel and
migration_set_outgoing_channel methods so that they
will automatically wrap the QIOChannel in a
QIOChannelTLS instance if TLS credentials are configured
in the migration parameters.
This allows TLS to work for tcp, unix, fd and exec
migration protocols. It does not (currently) work for
RDMA since it does not use these APIs, but it is
unlikely that TLS would be desired with RDMA anyway
since it would degrade the performance to that seen
with TCP defeating the purpose of using RDMA.
On the target host, QEMU would be launched with a set
of TLS credentials for a server endpoint
$ qemu-system-x86_64 -monitor stdio -incoming defer \
-object tls-creds-x509,dir=/home/berrange/security/qemutls,endpoint=server,id=tls0 \
...other args...
To enable incoming TLS migration 2 monitor commands are
then used
(qemu) migrate_set_str_parameter tls-creds tls0
(qemu) migrate_incoming tcp:myhostname:9000
On the source host, QEMU is launched in a similar
manner but using client endpoint credentials
$ qemu-system-x86_64 -monitor stdio \
-object tls-creds-x509,dir=/home/berrange/security/qemutls,endpoint=client,id=tls0 \
...other args...
To enable outgoing TLS migration 2 monitor commands are
then used
(qemu) migrate_set_str_parameter tls-creds tls0
(qemu) migrate tcp:otherhostname:9000
Thanks to earlier improvements to error reporting,
TLS errors can be seen 'info migrate' when doing a
detached migration. For example:
(qemu) info migrate
capabilities: xbzrle: off rdma-pin-all: off auto-converge: off zero-blocks: off compress: off events: off x-postcopy-ram: off
Migration status: failed
total time: 0 milliseconds
error description: TLS handshake failed: The TLS connection was non-properly terminated.
Or
(qemu) info migrate
capabilities: xbzrle: off rdma-pin-all: off auto-converge: off zero-blocks: off compress: off events: off x-postcopy-ram: off
Migration status: failed
total time: 0 milliseconds
error description: Certificate does not match the hostname localhost
Reviewed-by: Dr. David Alan Gilbert <dgilbert@redhat.com>
Signed-off-by: Daniel P. Berrange <berrange@redhat.com>
Message-Id: <1461751518-12128-27-git-send-email-berrange@redhat.com>
Signed-off-by: Amit Shah <amit.shah@redhat.com>
2016-04-27 12:05:16 +02:00
|
|
|
void migration_tls_set_incoming_channel(MigrationState *s,
|
|
|
|
QIOChannel *ioc,
|
|
|
|
Error **errp);
|
|
|
|
|
2016-04-27 12:04:59 +02:00
|
|
|
void migration_set_outgoing_channel(MigrationState *s,
|
migration: add support for encrypting data with TLS
This extends the migration_set_incoming_channel and
migration_set_outgoing_channel methods so that they
will automatically wrap the QIOChannel in a
QIOChannelTLS instance if TLS credentials are configured
in the migration parameters.
This allows TLS to work for tcp, unix, fd and exec
migration protocols. It does not (currently) work for
RDMA since it does not use these APIs, but it is
unlikely that TLS would be desired with RDMA anyway
since it would degrade the performance to that seen
with TCP defeating the purpose of using RDMA.
On the target host, QEMU would be launched with a set
of TLS credentials for a server endpoint
$ qemu-system-x86_64 -monitor stdio -incoming defer \
-object tls-creds-x509,dir=/home/berrange/security/qemutls,endpoint=server,id=tls0 \
...other args...
To enable incoming TLS migration 2 monitor commands are
then used
(qemu) migrate_set_str_parameter tls-creds tls0
(qemu) migrate_incoming tcp:myhostname:9000
On the source host, QEMU is launched in a similar
manner but using client endpoint credentials
$ qemu-system-x86_64 -monitor stdio \
-object tls-creds-x509,dir=/home/berrange/security/qemutls,endpoint=client,id=tls0 \
...other args...
To enable outgoing TLS migration 2 monitor commands are
then used
(qemu) migrate_set_str_parameter tls-creds tls0
(qemu) migrate tcp:otherhostname:9000
Thanks to earlier improvements to error reporting,
TLS errors can be seen 'info migrate' when doing a
detached migration. For example:
(qemu) info migrate
capabilities: xbzrle: off rdma-pin-all: off auto-converge: off zero-blocks: off compress: off events: off x-postcopy-ram: off
Migration status: failed
total time: 0 milliseconds
error description: TLS handshake failed: The TLS connection was non-properly terminated.
Or
(qemu) info migrate
capabilities: xbzrle: off rdma-pin-all: off auto-converge: off zero-blocks: off compress: off events: off x-postcopy-ram: off
Migration status: failed
total time: 0 milliseconds
error description: Certificate does not match the hostname localhost
Reviewed-by: Dr. David Alan Gilbert <dgilbert@redhat.com>
Signed-off-by: Daniel P. Berrange <berrange@redhat.com>
Message-Id: <1461751518-12128-27-git-send-email-berrange@redhat.com>
Signed-off-by: Amit Shah <amit.shah@redhat.com>
2016-04-27 12:05:16 +02:00
|
|
|
QIOChannel *ioc,
|
|
|
|
const char *hostname);
|
|
|
|
|
|
|
|
void migration_tls_set_outgoing_channel(MigrationState *s,
|
|
|
|
QIOChannel *ioc,
|
|
|
|
const char *hostname,
|
|
|
|
Error **errp);
|
2016-04-27 12:04:59 +02:00
|
|
|
|
2009-05-28 21:22:57 +02:00
|
|
|
uint64_t migrate_max_downtime(void);
|
|
|
|
|
2012-10-02 18:21:18 +02:00
|
|
|
void exec_start_incoming_migration(const char *host_port, Error **errp);
|
2008-11-11 17:46:33 +01:00
|
|
|
|
2012-10-02 10:02:46 +02:00
|
|
|
void exec_start_outgoing_migration(MigrationState *s, const char *host_port, Error **errp);
|
2008-11-11 17:46:33 +01:00
|
|
|
|
2012-10-02 18:21:18 +02:00
|
|
|
void tcp_start_incoming_migration(const char *host_port, Error **errp);
|
2008-10-13 05:14:31 +02:00
|
|
|
|
2012-10-02 10:02:46 +02:00
|
|
|
void tcp_start_outgoing_migration(MigrationState *s, const char *host_port, Error **errp);
|
2008-10-13 05:14:31 +02:00
|
|
|
|
2012-10-02 18:21:18 +02:00
|
|
|
void unix_start_incoming_migration(const char *path, Error **errp);
|
2009-08-05 17:24:29 +02:00
|
|
|
|
2012-10-02 10:02:46 +02:00
|
|
|
void unix_start_outgoing_migration(MigrationState *s, const char *path, Error **errp);
|
2009-08-05 17:24:29 +02:00
|
|
|
|
2012-10-02 18:21:18 +02:00
|
|
|
void fd_start_incoming_migration(const char *path, Error **errp);
|
2009-08-18 15:56:25 +02:00
|
|
|
|
2012-10-02 10:02:46 +02:00
|
|
|
void fd_start_outgoing_migration(MigrationState *s, const char *fdname, Error **errp);
|
2009-08-18 15:56:25 +02:00
|
|
|
|
2013-07-22 16:01:54 +02:00
|
|
|
void rdma_start_outgoing_migration(void *opaque, const char *host_port, Error **errp);
|
|
|
|
|
|
|
|
void rdma_start_incoming_migration(const char *host_port, Error **errp);
|
|
|
|
|
migration: add reporting of errors for outgoing migration
Currently if an application initiates an outgoing migration,
it may or may not, get an error reported back on failure. If
the error occurs synchronously to the 'migrate' command
execution, the client app will see the error message. This
is the case for DNS lookup failures. If the error occurs
asynchronously to the monitor command though, the error
will be thrown away and the client left guessing about
what went wrong. This is the case for failure to connect
to the TCP server (eg due to wrong port, or firewall
rules, or other similar errors).
In the future we'll be adding more scope for errors to
happen asynchronously with the TLS protocol handshake.
TLS errors are hard to diagnose even when they are well
reported, so discarding errors entirely will make it
impossible to debug TLS connection problems.
Management apps which do migration are already using
'query-migrate' / 'info migrate' to check up on progress
of background migration operations and to see their end
status. This is a fine place to also include the error
message when things go wrong.
This patch thus adds an 'error-desc' field to the
MigrationInfo struct, which will be populated when
the 'status' is set to 'failed':
(qemu) migrate -d tcp:localhost:9001
(qemu) info migrate
capabilities: xbzrle: off rdma-pin-all: off auto-converge: off zero-blocks: off compress: off events: off x-postcopy-ram: off
Migration status: failed (Error connecting to socket: Connection refused)
total time: 0 milliseconds
In the HMP, when doing non-detached migration, it is
also possible to display this error message directly
to the app.
(qemu) migrate tcp:localhost:9001
Error connecting to socket: Connection refused
Or with QMP
{
"execute": "query-migrate",
"arguments": {}
}
{
"return": {
"status": "failed",
"error-desc": "address resolution failed for myhost:9000: No address associated with hostname"
}
}
Reviewed-by: Dr. David Alan Gilbert <dgilbert@redhat.com>
Signed-off-by: Daniel P. Berrange <berrange@redhat.com>
Reviewed-by: Juan Quintela <quintela@redhat.com>
Message-Id: <1461751518-12128-11-git-send-email-berrange@redhat.com>
Signed-off-by: Amit Shah <amit.shah@redhat.com>
2016-04-27 12:05:00 +02:00
|
|
|
void migrate_fd_error(MigrationState *s, const Error *error);
|
2008-11-11 17:46:33 +01:00
|
|
|
|
2010-05-11 15:56:35 +02:00
|
|
|
void migrate_fd_connect(MigrationState *s);
|
2008-11-11 17:46:33 +01:00
|
|
|
|
2012-07-20 13:19:36 +02:00
|
|
|
int migrate_fd_close(MigrationState *s);
|
2012-07-20 13:10:54 +02:00
|
|
|
|
2010-12-13 17:30:12 +01:00
|
|
|
void add_migration_state_change_notifier(Notifier *notify);
|
|
|
|
void remove_migration_state_change_notifier(Notifier *notify);
|
2015-11-05 19:10:40 +01:00
|
|
|
MigrationState *migrate_init(const MigrationParams *params);
|
2016-05-04 21:44:19 +02:00
|
|
|
bool migration_is_blocked(Error **errp);
|
2013-07-29 15:01:58 +02:00
|
|
|
bool migration_in_setup(MigrationState *);
|
2011-02-23 00:43:59 +01:00
|
|
|
bool migration_has_finished(MigrationState *);
|
2011-10-25 13:50:11 +02:00
|
|
|
bool migration_has_failed(MigrationState *);
|
2015-11-05 19:10:58 +01:00
|
|
|
/* True if outgoing migration has entered postcopy phase */
|
|
|
|
bool migration_in_postcopy(MigrationState *);
|
2016-02-22 18:17:32 +01:00
|
|
|
/* ...and after the device transmission */
|
|
|
|
bool migration_in_postcopy_after_devices(MigrationState *);
|
2012-08-13 09:42:49 +02:00
|
|
|
MigrationState *migrate_get_current(void);
|
2010-12-13 17:30:12 +01:00
|
|
|
|
2015-03-23 09:32:17 +01:00
|
|
|
void migrate_compress_threads_create(void);
|
|
|
|
void migrate_compress_threads_join(void);
|
2015-03-23 09:32:18 +01:00
|
|
|
void migrate_decompress_threads_create(void);
|
|
|
|
void migrate_decompress_threads_join(void);
|
2011-04-03 10:23:19 +02:00
|
|
|
uint64_t ram_bytes_remaining(void);
|
|
|
|
uint64_t ram_bytes_transferred(void);
|
|
|
|
uint64_t ram_bytes_total(void);
|
2014-01-30 19:08:35 +01:00
|
|
|
void free_xbzrle_decoded_buf(void);
|
2011-04-03 10:23:19 +02:00
|
|
|
|
2013-06-26 03:35:28 +02:00
|
|
|
void acct_update_position(QEMUFile *f, size_t size, bool zero);
|
|
|
|
|
2012-08-06 20:42:56 +02:00
|
|
|
uint64_t dup_mig_bytes_transferred(void);
|
|
|
|
uint64_t dup_mig_pages_transferred(void);
|
2013-03-26 10:58:37 +01:00
|
|
|
uint64_t skipped_mig_bytes_transferred(void);
|
|
|
|
uint64_t skipped_mig_pages_transferred(void);
|
2012-08-06 20:42:56 +02:00
|
|
|
uint64_t norm_mig_bytes_transferred(void);
|
|
|
|
uint64_t norm_mig_pages_transferred(void);
|
2012-08-06 20:42:57 +02:00
|
|
|
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);
|
2014-04-04 11:57:56 +02:00
|
|
|
double xbzrle_mig_cache_miss_rate(void);
|
2012-08-06 20:42:56 +02:00
|
|
|
|
2013-07-22 16:01:53 +02:00
|
|
|
void ram_handle_compressed(void *host, uint8_t ch, uint64_t size);
|
2015-11-05 19:10:38 +01:00
|
|
|
void ram_debug_dump_bitmap(unsigned long *todump, bool expected);
|
2015-11-05 19:11:02 +01:00
|
|
|
/* For outgoing discard bitmap */
|
|
|
|
int ram_postcopy_send_discard_bitmap(MigrationState *ms);
|
|
|
|
/* For incoming postcopy discard */
|
|
|
|
int ram_discard_range(MigrationIncomingState *mis, const char *block_name,
|
|
|
|
uint64_t start, size_t length);
|
2015-11-05 19:11:03 +01:00
|
|
|
int ram_postcopy_incoming_init(MigrationIncomingState *mis);
|
2013-07-22 16:01:53 +02:00
|
|
|
|
2011-11-14 22:09:43 +01:00
|
|
|
/**
|
|
|
|
* @migrate_add_blocker - prevent migration from proceeding
|
|
|
|
*
|
|
|
|
* @reason - an error to be returned whenever migration is attempted
|
|
|
|
*/
|
|
|
|
void migrate_add_blocker(Error *reason);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @migrate_del_blocker - remove a blocking error from migration
|
|
|
|
*
|
|
|
|
* @reason - the error blocking migration
|
|
|
|
*/
|
|
|
|
void migrate_del_blocker(Error *reason);
|
|
|
|
|
2015-11-05 19:10:51 +01:00
|
|
|
bool migrate_postcopy_ram(void);
|
2013-07-18 09:48:50 +02:00
|
|
|
bool migrate_zero_blocks(void);
|
2013-06-26 03:35:36 +02:00
|
|
|
|
2013-06-24 11:49:42 +02:00
|
|
|
bool migrate_auto_converge(void);
|
|
|
|
|
2012-08-06 20:42:52 +02:00
|
|
|
int xbzrle_encode_buffer(uint8_t *old_buf, uint8_t *new_buf, int slen,
|
|
|
|
uint8_t *dst, int dlen);
|
|
|
|
int xbzrle_decode_buffer(uint8_t *src, int slen, uint8_t *dst, int dlen);
|
|
|
|
|
2012-08-06 20:42:53 +02:00
|
|
|
int migrate_use_xbzrle(void);
|
|
|
|
int64_t migrate_xbzrle_cache_size(void);
|
|
|
|
|
2012-08-06 20:42:54 +02:00
|
|
|
int64_t xbzrle_cache_resize(int64_t new_size);
|
2013-06-26 03:35:35 +02:00
|
|
|
|
2015-03-23 09:32:17 +01:00
|
|
|
bool migrate_use_compression(void);
|
|
|
|
int migrate_compress_level(void);
|
|
|
|
int migrate_compress_threads(void);
|
2015-03-23 09:32:18 +01:00
|
|
|
int migrate_decompress_threads(void);
|
2015-07-07 14:44:05 +02:00
|
|
|
bool migrate_use_events(void);
|
2015-03-23 09:32:17 +01:00
|
|
|
|
2015-11-05 19:10:47 +01:00
|
|
|
/* Sending on the return path - generic and then for each message type */
|
|
|
|
void migrate_send_rp_message(MigrationIncomingState *mis,
|
|
|
|
enum mig_rp_message_type message_type,
|
|
|
|
uint16_t len, void *data);
|
|
|
|
void migrate_send_rp_shut(MigrationIncomingState *mis,
|
|
|
|
uint32_t value);
|
|
|
|
void migrate_send_rp_pong(MigrationIncomingState *mis,
|
|
|
|
uint32_t value);
|
2015-11-05 19:11:07 +01:00
|
|
|
void migrate_send_rp_req_pages(MigrationIncomingState *mis, const char* rbname,
|
|
|
|
ram_addr_t start, size_t len);
|
2015-11-05 19:10:47 +01:00
|
|
|
|
2013-06-26 03:35:35 +02:00
|
|
|
void ram_control_before_iterate(QEMUFile *f, uint64_t flags);
|
|
|
|
void ram_control_after_iterate(QEMUFile *f, uint64_t flags);
|
2015-06-11 19:17:23 +02:00
|
|
|
void ram_control_load_hook(QEMUFile *f, uint64_t flags, void *data);
|
2013-06-26 03:35:35 +02:00
|
|
|
|
|
|
|
/* Whenever this is found in the data stream, the flags
|
|
|
|
* will be passed to ram_control_load_hook in the incoming-migration
|
|
|
|
* side. This lets before_ram_iterate/after_ram_iterate add
|
|
|
|
* transport-specific sections to the RAM migration data.
|
|
|
|
*/
|
|
|
|
#define RAM_SAVE_FLAG_HOOK 0x80
|
|
|
|
|
|
|
|
#define RAM_SAVE_CONTROL_NOT_SUPP -1000
|
|
|
|
#define RAM_SAVE_CONTROL_DELAYED -2000
|
|
|
|
|
|
|
|
size_t ram_control_save_page(QEMUFile *f, ram_addr_t block_offset,
|
|
|
|
ram_addr_t offset, size_t size,
|
2015-02-12 19:02:42 +01:00
|
|
|
uint64_t *bytes_sent);
|
2013-06-26 03:35:35 +02:00
|
|
|
|
2015-05-07 19:33:31 +02:00
|
|
|
void ram_mig_init(void);
|
2015-05-19 13:29:51 +02:00
|
|
|
void savevm_skip_section_footers(void);
|
2014-10-08 10:58:10 +02:00
|
|
|
void register_global_state(void);
|
2014-10-08 13:58:24 +02:00
|
|
|
void global_state_set_optional(void);
|
2015-05-13 18:17:43 +02:00
|
|
|
void savevm_skip_configuration(void);
|
2015-07-15 09:53:46 +02:00
|
|
|
int global_state_store(void);
|
2015-08-03 16:29:19 +02:00
|
|
|
void global_state_store_running(void);
|
2015-11-05 19:10:52 +01:00
|
|
|
|
2015-11-05 19:11:08 +01:00
|
|
|
void flush_page_queue(MigrationState *ms);
|
|
|
|
int ram_save_queue_pages(MigrationState *ms, const char *rbname,
|
|
|
|
ram_addr_t start, ram_addr_t len);
|
|
|
|
|
2015-11-05 19:10:52 +01:00
|
|
|
PostcopyState postcopy_state_get(void);
|
|
|
|
/* Set the state and return the old state */
|
|
|
|
PostcopyState postcopy_state_set(PostcopyState new_state);
|
2008-10-13 05:12:02 +02:00
|
|
|
#endif
|