2008-10-13 07:12:02 +04: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.
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include "qemu-common.h"
|
|
|
|
#include "migration.h"
|
2009-03-06 02:01:23 +03:00
|
|
|
#include "monitor.h"
|
2008-11-11 19:46:33 +03:00
|
|
|
#include "buffered_file.h"
|
|
|
|
#include "sysemu.h"
|
|
|
|
#include "block.h"
|
|
|
|
#include "qemu_socket.h"
|
2009-11-30 20:21:21 +03:00
|
|
|
#include "block-migration.h"
|
2009-12-10 22:16:05 +03:00
|
|
|
#include "qemu-objects.h"
|
2008-11-11 19:46:33 +03:00
|
|
|
|
|
|
|
//#define DEBUG_MIGRATION
|
|
|
|
|
|
|
|
#ifdef DEBUG_MIGRATION
|
2010-02-07 02:03:50 +03:00
|
|
|
#define DPRINTF(fmt, ...) \
|
2008-11-11 19:46:33 +03:00
|
|
|
do { printf("migration: " fmt, ## __VA_ARGS__); } while (0)
|
|
|
|
#else
|
2010-02-07 02:03:50 +03:00
|
|
|
#define DPRINTF(fmt, ...) \
|
2008-11-11 19:46:33 +03:00
|
|
|
do { } while (0)
|
|
|
|
#endif
|
2008-10-13 07:12:02 +04:00
|
|
|
|
|
|
|
/* Migration speed throttling */
|
2010-11-23 20:05:54 +03:00
|
|
|
static int64_t max_throttle = (32 << 20);
|
2008-10-13 07:12:02 +04:00
|
|
|
|
|
|
|
static MigrationState *current_migration;
|
|
|
|
|
2010-06-09 16:10:54 +04:00
|
|
|
int qemu_start_incoming_migration(const char *uri)
|
2008-10-13 07:12:02 +04:00
|
|
|
{
|
2008-10-13 07:14:31 +04:00
|
|
|
const char *p;
|
2010-06-09 16:10:54 +04:00
|
|
|
int ret;
|
2008-10-13 07:14:31 +04:00
|
|
|
|
|
|
|
if (strstart(uri, "tcp:", &p))
|
2010-06-09 16:10:54 +04:00
|
|
|
ret = tcp_start_incoming_migration(p);
|
2008-11-11 19:46:33 +03:00
|
|
|
#if !defined(WIN32)
|
|
|
|
else if (strstart(uri, "exec:", &p))
|
2010-06-09 16:10:54 +04:00
|
|
|
ret = exec_start_incoming_migration(p);
|
2009-08-05 19:24:29 +04:00
|
|
|
else if (strstart(uri, "unix:", &p))
|
2010-06-09 16:10:54 +04:00
|
|
|
ret = unix_start_incoming_migration(p);
|
2009-08-18 17:56:25 +04:00
|
|
|
else if (strstart(uri, "fd:", &p))
|
2010-06-09 16:10:54 +04:00
|
|
|
ret = fd_start_incoming_migration(p);
|
2008-11-11 19:46:33 +03:00
|
|
|
#endif
|
2010-06-09 16:10:54 +04:00
|
|
|
else {
|
2008-10-13 07:14:31 +04:00
|
|
|
fprintf(stderr, "unknown migration protocol: %s\n", uri);
|
2010-06-09 16:10:54 +04:00
|
|
|
ret = -EPROTONOSUPPORT;
|
|
|
|
}
|
|
|
|
return ret;
|
2008-10-13 07:12:02 +04:00
|
|
|
}
|
|
|
|
|
2010-06-09 16:10:55 +04:00
|
|
|
void process_incoming_migration(QEMUFile *f)
|
|
|
|
{
|
|
|
|
if (qemu_loadvm_state(f) < 0) {
|
|
|
|
fprintf(stderr, "load of migration failed\n");
|
|
|
|
exit(0);
|
|
|
|
}
|
|
|
|
qemu_announce_self();
|
|
|
|
DPRINTF("successfully loaded vm state\n");
|
|
|
|
|
2010-07-27 14:19:19 +04:00
|
|
|
incoming_expected = false;
|
|
|
|
|
2010-06-09 16:10:55 +04:00
|
|
|
if (autostart)
|
|
|
|
vm_start();
|
|
|
|
}
|
|
|
|
|
2010-02-11 04:49:57 +03:00
|
|
|
int do_migrate(Monitor *mon, const QDict *qdict, QObject **ret_data)
|
2008-10-13 07:12:02 +04:00
|
|
|
{
|
2008-10-13 07:14:31 +04:00
|
|
|
MigrationState *s = NULL;
|
|
|
|
const char *p;
|
Monitor: handle optional '-' arg as a bool
Historically, user monitor arguments beginning with '-' (eg. '-f')
were passed as integers down to handlers.
I've maintained this behavior in the new monitor because we didn't
have a boolean type at the very beginning of QMP. Today we have it
and this behavior is causing trouble to QMP's argument checker.
This commit fixes the problem by doing the following changes:
1. User Monitor
Before: the optional arg was represented as a QInt, we'd pass 1
down to handlers if the user specified the argument or
0 otherwise
This commit: the optional arg is represented as a QBool, we pass
true down to handlers if the user specified the
argument, otherwise _nothing_ is passed
2. QMP
Before: the client was required to pass the arg as QBool, but we'd
convert it to QInt internally. If the argument wasn't passed,
we'd pass 0 down
This commit: still require a QBool, but doesn't do any conversion and
doesn't pass any default value
3. Convert existing handlers (do_eject()/do_migrate()) to the new way
Before: Both handlers would expect a QInt value, either 0 or 1
This commit: Change the handlers to accept a QBool, they handle the
following cases:
A) true is passed: the option is enabled
B) false is passed: the option is disabled
C) nothing is passed: option not specified, use
default behavior
Signed-off-by: Luiz Capitulino <lcapitulino@redhat.com>
2010-05-28 22:25:24 +04:00
|
|
|
int detach = qdict_get_try_bool(qdict, "detach", 0);
|
|
|
|
int blk = qdict_get_try_bool(qdict, "blk", 0);
|
|
|
|
int inc = qdict_get_try_bool(qdict, "inc", 0);
|
2009-08-28 22:27:14 +04:00
|
|
|
const char *uri = qdict_get_str(qdict, "uri");
|
2009-11-30 20:21:19 +03:00
|
|
|
|
|
|
|
if (current_migration &&
|
|
|
|
current_migration->get_status(current_migration) == MIG_STATE_ACTIVE) {
|
|
|
|
monitor_printf(mon, "migration already in progress\n");
|
2010-02-11 04:49:57 +03:00
|
|
|
return -1;
|
2009-11-30 20:21:19 +03:00
|
|
|
}
|
|
|
|
|
2011-01-12 00:39:43 +03:00
|
|
|
if (qemu_savevm_state_blocked(mon)) {
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2010-02-11 04:49:57 +03:00
|
|
|
if (strstart(uri, "tcp:", &p)) {
|
2009-11-30 20:21:21 +03:00
|
|
|
s = tcp_start_outgoing_migration(mon, p, max_throttle, detach,
|
Monitor: handle optional '-' arg as a bool
Historically, user monitor arguments beginning with '-' (eg. '-f')
were passed as integers down to handlers.
I've maintained this behavior in the new monitor because we didn't
have a boolean type at the very beginning of QMP. Today we have it
and this behavior is causing trouble to QMP's argument checker.
This commit fixes the problem by doing the following changes:
1. User Monitor
Before: the optional arg was represented as a QInt, we'd pass 1
down to handlers if the user specified the argument or
0 otherwise
This commit: the optional arg is represented as a QBool, we pass
true down to handlers if the user specified the
argument, otherwise _nothing_ is passed
2. QMP
Before: the client was required to pass the arg as QBool, but we'd
convert it to QInt internally. If the argument wasn't passed,
we'd pass 0 down
This commit: still require a QBool, but doesn't do any conversion and
doesn't pass any default value
3. Convert existing handlers (do_eject()/do_migrate()) to the new way
Before: Both handlers would expect a QInt value, either 0 or 1
This commit: Change the handlers to accept a QBool, they handle the
following cases:
A) true is passed: the option is enabled
B) false is passed: the option is disabled
C) nothing is passed: option not specified, use
default behavior
Signed-off-by: Luiz Capitulino <lcapitulino@redhat.com>
2010-05-28 22:25:24 +04:00
|
|
|
blk, inc);
|
2008-11-11 19:46:33 +03:00
|
|
|
#if !defined(WIN32)
|
2010-02-11 04:49:57 +03:00
|
|
|
} else if (strstart(uri, "exec:", &p)) {
|
2009-11-30 20:21:21 +03:00
|
|
|
s = exec_start_outgoing_migration(mon, p, max_throttle, detach,
|
Monitor: handle optional '-' arg as a bool
Historically, user monitor arguments beginning with '-' (eg. '-f')
were passed as integers down to handlers.
I've maintained this behavior in the new monitor because we didn't
have a boolean type at the very beginning of QMP. Today we have it
and this behavior is causing trouble to QMP's argument checker.
This commit fixes the problem by doing the following changes:
1. User Monitor
Before: the optional arg was represented as a QInt, we'd pass 1
down to handlers if the user specified the argument or
0 otherwise
This commit: the optional arg is represented as a QBool, we pass
true down to handlers if the user specified the
argument, otherwise _nothing_ is passed
2. QMP
Before: the client was required to pass the arg as QBool, but we'd
convert it to QInt internally. If the argument wasn't passed,
we'd pass 0 down
This commit: still require a QBool, but doesn't do any conversion and
doesn't pass any default value
3. Convert existing handlers (do_eject()/do_migrate()) to the new way
Before: Both handlers would expect a QInt value, either 0 or 1
This commit: Change the handlers to accept a QBool, they handle the
following cases:
A) true is passed: the option is enabled
B) false is passed: the option is disabled
C) nothing is passed: option not specified, use
default behavior
Signed-off-by: Luiz Capitulino <lcapitulino@redhat.com>
2010-05-28 22:25:24 +04:00
|
|
|
blk, inc);
|
2010-02-11 04:49:57 +03:00
|
|
|
} else if (strstart(uri, "unix:", &p)) {
|
2009-11-30 20:21:21 +03:00
|
|
|
s = unix_start_outgoing_migration(mon, p, max_throttle, detach,
|
Monitor: handle optional '-' arg as a bool
Historically, user monitor arguments beginning with '-' (eg. '-f')
were passed as integers down to handlers.
I've maintained this behavior in the new monitor because we didn't
have a boolean type at the very beginning of QMP. Today we have it
and this behavior is causing trouble to QMP's argument checker.
This commit fixes the problem by doing the following changes:
1. User Monitor
Before: the optional arg was represented as a QInt, we'd pass 1
down to handlers if the user specified the argument or
0 otherwise
This commit: the optional arg is represented as a QBool, we pass
true down to handlers if the user specified the
argument, otherwise _nothing_ is passed
2. QMP
Before: the client was required to pass the arg as QBool, but we'd
convert it to QInt internally. If the argument wasn't passed,
we'd pass 0 down
This commit: still require a QBool, but doesn't do any conversion and
doesn't pass any default value
3. Convert existing handlers (do_eject()/do_migrate()) to the new way
Before: Both handlers would expect a QInt value, either 0 or 1
This commit: Change the handlers to accept a QBool, they handle the
following cases:
A) true is passed: the option is enabled
B) false is passed: the option is disabled
C) nothing is passed: option not specified, use
default behavior
Signed-off-by: Luiz Capitulino <lcapitulino@redhat.com>
2010-05-28 22:25:24 +04:00
|
|
|
blk, inc);
|
2010-02-11 04:49:57 +03:00
|
|
|
} else if (strstart(uri, "fd:", &p)) {
|
2009-11-02 16:40:58 +03:00
|
|
|
s = fd_start_outgoing_migration(mon, p, max_throttle, detach,
|
Monitor: handle optional '-' arg as a bool
Historically, user monitor arguments beginning with '-' (eg. '-f')
were passed as integers down to handlers.
I've maintained this behavior in the new monitor because we didn't
have a boolean type at the very beginning of QMP. Today we have it
and this behavior is causing trouble to QMP's argument checker.
This commit fixes the problem by doing the following changes:
1. User Monitor
Before: the optional arg was represented as a QInt, we'd pass 1
down to handlers if the user specified the argument or
0 otherwise
This commit: the optional arg is represented as a QBool, we pass
true down to handlers if the user specified the
argument, otherwise _nothing_ is passed
2. QMP
Before: the client was required to pass the arg as QBool, but we'd
convert it to QInt internally. If the argument wasn't passed,
we'd pass 0 down
This commit: still require a QBool, but doesn't do any conversion and
doesn't pass any default value
3. Convert existing handlers (do_eject()/do_migrate()) to the new way
Before: Both handlers would expect a QInt value, either 0 or 1
This commit: Change the handlers to accept a QBool, they handle the
following cases:
A) true is passed: the option is enabled
B) false is passed: the option is disabled
C) nothing is passed: option not specified, use
default behavior
Signed-off-by: Luiz Capitulino <lcapitulino@redhat.com>
2010-05-28 22:25:24 +04:00
|
|
|
blk, inc);
|
2008-11-11 19:46:33 +03:00
|
|
|
#endif
|
2010-02-11 04:49:57 +03:00
|
|
|
} else {
|
2009-03-06 02:01:23 +03:00
|
|
|
monitor_printf(mon, "unknown migration protocol: %s\n", uri);
|
2010-02-11 04:49:57 +03:00
|
|
|
return -1;
|
|
|
|
}
|
2008-10-13 07:14:31 +04:00
|
|
|
|
2010-02-11 04:49:57 +03:00
|
|
|
if (s == NULL) {
|
2009-03-06 02:01:23 +03:00
|
|
|
monitor_printf(mon, "migration failed\n");
|
2010-02-11 04:49:57 +03:00
|
|
|
return -1;
|
|
|
|
}
|
2008-10-13 07:14:31 +04:00
|
|
|
|
2010-02-11 04:49:57 +03:00
|
|
|
if (current_migration) {
|
|
|
|
current_migration->release(current_migration);
|
2008-10-13 07:14:31 +04:00
|
|
|
}
|
2010-02-11 04:49:57 +03:00
|
|
|
|
|
|
|
current_migration = s;
|
|
|
|
return 0;
|
2008-10-13 07:12:02 +04:00
|
|
|
}
|
|
|
|
|
2010-02-11 04:49:48 +03:00
|
|
|
int do_migrate_cancel(Monitor *mon, const QDict *qdict, QObject **ret_data)
|
2008-10-13 07:12:02 +04:00
|
|
|
{
|
|
|
|
MigrationState *s = current_migration;
|
|
|
|
|
|
|
|
if (s)
|
2008-10-25 02:10:31 +04:00
|
|
|
s->cancel(s);
|
2010-02-11 04:49:48 +03:00
|
|
|
|
|
|
|
return 0;
|
2008-10-13 07:12:02 +04:00
|
|
|
}
|
|
|
|
|
2010-02-11 04:49:48 +03:00
|
|
|
int do_migrate_set_speed(Monitor *mon, const QDict *qdict, QObject **ret_data)
|
2008-10-13 07:12:02 +04:00
|
|
|
{
|
2010-10-21 19:15:48 +04:00
|
|
|
int64_t d;
|
2009-05-21 02:26:58 +04:00
|
|
|
FdMigrationState *s;
|
2008-10-13 07:12:02 +04:00
|
|
|
|
2010-10-21 19:15:48 +04:00
|
|
|
d = qdict_get_int(qdict, "value");
|
2010-11-23 20:05:54 +03:00
|
|
|
if (d < 0) {
|
|
|
|
d = 0;
|
|
|
|
}
|
2010-01-25 16:23:04 +03:00
|
|
|
max_throttle = d;
|
2009-05-21 02:26:58 +04:00
|
|
|
|
2009-11-30 20:21:19 +03:00
|
|
|
s = migrate_to_fms(current_migration);
|
|
|
|
if (s && s->file) {
|
2009-05-21 02:26:58 +04:00
|
|
|
qemu_file_set_rate_limit(s->file, max_throttle);
|
|
|
|
}
|
2010-02-11 04:49:48 +03:00
|
|
|
|
|
|
|
return 0;
|
2008-10-13 07:12:02 +04:00
|
|
|
}
|
|
|
|
|
2009-05-28 23:22:57 +04:00
|
|
|
/* amount of nanoseconds we are willing to wait for migration to be down.
|
|
|
|
* the choice of nanoseconds is because it is the maximum resolution that
|
|
|
|
* get_clock() can achieve. It is an internal measure. All user-visible
|
|
|
|
* units must be in seconds */
|
|
|
|
static uint64_t max_downtime = 30000000;
|
|
|
|
|
|
|
|
uint64_t migrate_max_downtime(void)
|
|
|
|
{
|
|
|
|
return max_downtime;
|
|
|
|
}
|
|
|
|
|
2010-02-11 04:49:48 +03:00
|
|
|
int do_migrate_set_downtime(Monitor *mon, const QDict *qdict,
|
|
|
|
QObject **ret_data)
|
2009-05-28 23:22:58 +04:00
|
|
|
{
|
|
|
|
double d;
|
|
|
|
|
2010-01-25 16:23:07 +03:00
|
|
|
d = qdict_get_double(qdict, "value") * 1e9;
|
|
|
|
d = MAX(0, MIN(UINT64_MAX, d));
|
2009-05-28 23:22:58 +04:00
|
|
|
max_downtime = (uint64_t)d;
|
2010-02-11 04:49:48 +03:00
|
|
|
|
|
|
|
return 0;
|
2009-05-28 23:22:58 +04:00
|
|
|
}
|
|
|
|
|
2009-12-10 22:16:05 +03:00
|
|
|
static void migrate_print_status(Monitor *mon, const char *name,
|
|
|
|
const QDict *status_dict)
|
2008-10-13 07:12:02 +04:00
|
|
|
{
|
2009-12-10 22:16:05 +03:00
|
|
|
QDict *qdict;
|
|
|
|
|
|
|
|
qdict = qobject_to_qdict(qdict_get(status_dict, name));
|
|
|
|
|
|
|
|
monitor_printf(mon, "transferred %s: %" PRIu64 " kbytes\n", name,
|
|
|
|
qdict_get_int(qdict, "transferred") >> 10);
|
|
|
|
monitor_printf(mon, "remaining %s: %" PRIu64 " kbytes\n", name,
|
|
|
|
qdict_get_int(qdict, "remaining") >> 10);
|
|
|
|
monitor_printf(mon, "total %s: %" PRIu64 " kbytes\n", name,
|
|
|
|
qdict_get_int(qdict, "total") >> 10);
|
|
|
|
}
|
|
|
|
|
|
|
|
void do_info_migrate_print(Monitor *mon, const QObject *data)
|
|
|
|
{
|
|
|
|
QDict *qdict;
|
|
|
|
|
|
|
|
qdict = qobject_to_qdict(data);
|
|
|
|
|
|
|
|
monitor_printf(mon, "Migration status: %s\n",
|
|
|
|
qdict_get_str(qdict, "status"));
|
|
|
|
|
|
|
|
if (qdict_haskey(qdict, "ram")) {
|
|
|
|
migrate_print_status(mon, "ram", qdict);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (qdict_haskey(qdict, "disk")) {
|
|
|
|
migrate_print_status(mon, "disk", qdict);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void migrate_put_status(QDict *qdict, const char *name,
|
|
|
|
uint64_t trans, uint64_t rem, uint64_t total)
|
|
|
|
{
|
|
|
|
QObject *obj;
|
|
|
|
|
|
|
|
obj = qobject_from_jsonf("{ 'transferred': %" PRId64 ", "
|
|
|
|
"'remaining': %" PRId64 ", "
|
|
|
|
"'total': %" PRId64 " }", trans, rem, total);
|
|
|
|
qdict_put_obj(qdict, name, obj);
|
|
|
|
}
|
|
|
|
|
|
|
|
void do_info_migrate(Monitor *mon, QObject **ret_data)
|
|
|
|
{
|
|
|
|
QDict *qdict;
|
2008-10-13 07:12:02 +04:00
|
|
|
MigrationState *s = current_migration;
|
2009-03-06 02:01:23 +03:00
|
|
|
|
2008-10-13 07:12:02 +04:00
|
|
|
if (s) {
|
2008-10-25 02:10:31 +04:00
|
|
|
switch (s->get_status(s)) {
|
|
|
|
case MIG_STATE_ACTIVE:
|
2009-12-10 22:16:05 +03:00
|
|
|
qdict = qdict_new();
|
|
|
|
qdict_put(qdict, "status", qstring_from_str("active"));
|
|
|
|
|
|
|
|
migrate_put_status(qdict, "ram", ram_bytes_transferred(),
|
|
|
|
ram_bytes_remaining(), ram_bytes_total());
|
|
|
|
|
2009-11-30 20:21:21 +03:00
|
|
|
if (blk_mig_active()) {
|
2009-12-10 22:16:05 +03:00
|
|
|
migrate_put_status(qdict, "disk", blk_mig_bytes_transferred(),
|
|
|
|
blk_mig_bytes_remaining(),
|
|
|
|
blk_mig_bytes_total());
|
2009-11-30 20:21:21 +03:00
|
|
|
}
|
2009-12-10 22:16:05 +03:00
|
|
|
|
|
|
|
*ret_data = QOBJECT(qdict);
|
2008-10-25 02:10:31 +04:00
|
|
|
break;
|
|
|
|
case MIG_STATE_COMPLETED:
|
2009-12-10 22:16:05 +03:00
|
|
|
*ret_data = qobject_from_jsonf("{ 'status': 'completed' }");
|
2008-10-25 02:10:31 +04:00
|
|
|
break;
|
|
|
|
case MIG_STATE_ERROR:
|
2009-12-10 22:16:05 +03:00
|
|
|
*ret_data = qobject_from_jsonf("{ 'status': 'failed' }");
|
2008-10-25 02:10:31 +04:00
|
|
|
break;
|
|
|
|
case MIG_STATE_CANCELLED:
|
2009-12-10 22:16:05 +03:00
|
|
|
*ret_data = qobject_from_jsonf("{ 'status': 'cancelled' }");
|
2008-10-25 02:10:31 +04:00
|
|
|
break;
|
|
|
|
}
|
2008-10-13 07:12:02 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-11-11 19:46:33 +03:00
|
|
|
/* shared migration helpers */
|
|
|
|
|
2009-11-30 20:21:21 +03:00
|
|
|
void migrate_fd_monitor_suspend(FdMigrationState *s, Monitor *mon)
|
2009-03-06 02:01:42 +03:00
|
|
|
{
|
2009-11-30 20:21:21 +03:00
|
|
|
s->mon = mon;
|
|
|
|
if (monitor_suspend(mon) == 0) {
|
2010-02-07 02:03:50 +03:00
|
|
|
DPRINTF("suspending monitor\n");
|
2009-11-30 20:21:21 +03:00
|
|
|
} else {
|
|
|
|
monitor_printf(mon, "terminal does not allow synchronous "
|
2009-03-06 02:01:51 +03:00
|
|
|
"migration, continuing detached\n");
|
2009-11-30 20:21:21 +03:00
|
|
|
}
|
2009-03-06 02:01:42 +03:00
|
|
|
}
|
|
|
|
|
2008-11-11 19:46:33 +03:00
|
|
|
void migrate_fd_error(FdMigrationState *s)
|
|
|
|
{
|
2010-02-07 02:03:50 +03:00
|
|
|
DPRINTF("setting error state\n");
|
2008-11-11 19:46:33 +03:00
|
|
|
s->state = MIG_STATE_ERROR;
|
|
|
|
migrate_fd_cleanup(s);
|
|
|
|
}
|
|
|
|
|
2010-06-02 23:55:25 +04:00
|
|
|
int migrate_fd_cleanup(FdMigrationState *s)
|
2008-11-11 19:46:33 +03:00
|
|
|
{
|
2010-06-02 23:55:25 +04:00
|
|
|
int ret = 0;
|
|
|
|
|
2008-11-11 19:46:33 +03:00
|
|
|
qemu_set_fd_handler2(s->fd, NULL, NULL, NULL, NULL);
|
|
|
|
|
|
|
|
if (s->file) {
|
2010-02-07 02:03:50 +03:00
|
|
|
DPRINTF("closing file\n");
|
2010-06-02 23:55:25 +04:00
|
|
|
if (qemu_fclose(s->file) != 0) {
|
|
|
|
ret = -1;
|
|
|
|
}
|
2009-11-30 20:21:19 +03:00
|
|
|
s->file = NULL;
|
2008-11-11 19:46:33 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
if (s->fd != -1)
|
|
|
|
close(s->fd);
|
|
|
|
|
|
|
|
/* Don't resume monitor until we've flushed all of the buffers */
|
2009-11-30 20:21:21 +03:00
|
|
|
if (s->mon) {
|
|
|
|
monitor_resume(s->mon);
|
|
|
|
}
|
2008-11-11 19:46:33 +03:00
|
|
|
|
|
|
|
s->fd = -1;
|
2010-06-02 23:55:25 +04:00
|
|
|
|
|
|
|
return ret;
|
2008-11-11 19:46:33 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
void migrate_fd_put_notify(void *opaque)
|
|
|
|
{
|
|
|
|
FdMigrationState *s = opaque;
|
|
|
|
|
|
|
|
qemu_set_fd_handler2(s->fd, NULL, NULL, NULL, NULL);
|
|
|
|
qemu_file_put_notify(s->file);
|
|
|
|
}
|
|
|
|
|
|
|
|
ssize_t migrate_fd_put_buffer(void *opaque, const void *data, size_t size)
|
|
|
|
{
|
|
|
|
FdMigrationState *s = opaque;
|
|
|
|
ssize_t ret;
|
|
|
|
|
|
|
|
do {
|
|
|
|
ret = s->write(s, data, size);
|
2009-05-19 15:08:53 +04:00
|
|
|
} while (ret == -1 && ((s->get_error(s)) == EINTR));
|
2008-11-11 19:46:33 +03:00
|
|
|
|
|
|
|
if (ret == -1)
|
|
|
|
ret = -(s->get_error(s));
|
|
|
|
|
2010-08-19 17:18:39 +04:00
|
|
|
if (ret == -EAGAIN) {
|
2008-11-11 19:46:33 +03:00
|
|
|
qemu_set_fd_handler2(s->fd, NULL, NULL, migrate_fd_put_notify, s);
|
2010-08-19 17:18:39 +04:00
|
|
|
} else if (ret < 0) {
|
|
|
|
if (s->mon) {
|
|
|
|
monitor_resume(s->mon);
|
|
|
|
}
|
|
|
|
s->state = MIG_STATE_ERROR;
|
|
|
|
}
|
2008-11-11 19:46:33 +03:00
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
void migrate_fd_connect(FdMigrationState *s)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
s->file = qemu_fopen_ops_buffered(s,
|
|
|
|
s->bandwidth_limit,
|
|
|
|
migrate_fd_put_buffer,
|
|
|
|
migrate_fd_put_ready,
|
|
|
|
migrate_fd_wait_for_unfreeze,
|
|
|
|
migrate_fd_close);
|
|
|
|
|
2010-02-07 02:03:50 +03:00
|
|
|
DPRINTF("beginning savevm\n");
|
2009-11-30 20:21:21 +03:00
|
|
|
ret = qemu_savevm_state_begin(s->mon, s->file, s->mig_state.blk,
|
2009-11-02 16:40:58 +03:00
|
|
|
s->mig_state.shared);
|
2008-11-11 19:46:33 +03:00
|
|
|
if (ret < 0) {
|
2010-02-07 02:03:50 +03:00
|
|
|
DPRINTF("failed, %d\n", ret);
|
2008-11-11 19:46:33 +03:00
|
|
|
migrate_fd_error(s);
|
|
|
|
return;
|
|
|
|
}
|
2009-11-02 16:40:58 +03:00
|
|
|
|
2008-11-11 19:46:33 +03:00
|
|
|
migrate_fd_put_ready(s);
|
|
|
|
}
|
|
|
|
|
|
|
|
void migrate_fd_put_ready(void *opaque)
|
|
|
|
{
|
|
|
|
FdMigrationState *s = opaque;
|
|
|
|
|
|
|
|
if (s->state != MIG_STATE_ACTIVE) {
|
2010-02-07 02:03:50 +03:00
|
|
|
DPRINTF("put_ready returning because of non-active state\n");
|
2008-11-11 19:46:33 +03:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2010-02-07 02:03:50 +03:00
|
|
|
DPRINTF("iterate\n");
|
2009-11-30 20:21:21 +03:00
|
|
|
if (qemu_savevm_state_iterate(s->mon, s->file) == 1) {
|
2009-04-05 23:30:33 +04:00
|
|
|
int state;
|
2009-07-09 22:25:47 +04:00
|
|
|
int old_vm_running = vm_running;
|
|
|
|
|
2010-02-07 02:03:50 +03:00
|
|
|
DPRINTF("done iterating\n");
|
2008-11-11 19:46:33 +03:00
|
|
|
vm_stop(0);
|
|
|
|
|
2009-11-30 20:21:21 +03:00
|
|
|
if ((qemu_savevm_state_complete(s->mon, s->file)) < 0) {
|
2009-07-09 22:25:47 +04:00
|
|
|
if (old_vm_running) {
|
|
|
|
vm_start();
|
|
|
|
}
|
2009-04-05 23:30:33 +04:00
|
|
|
state = MIG_STATE_ERROR;
|
|
|
|
} else {
|
|
|
|
state = MIG_STATE_COMPLETED;
|
|
|
|
}
|
2010-06-02 23:55:25 +04:00
|
|
|
if (migrate_fd_cleanup(s) < 0) {
|
|
|
|
if (old_vm_running) {
|
|
|
|
vm_start();
|
|
|
|
}
|
|
|
|
state = MIG_STATE_ERROR;
|
|
|
|
}
|
2009-04-05 23:30:33 +04:00
|
|
|
s->state = state;
|
2008-11-11 19:46:33 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
int migrate_fd_get_status(MigrationState *mig_state)
|
|
|
|
{
|
|
|
|
FdMigrationState *s = migrate_to_fms(mig_state);
|
|
|
|
return s->state;
|
|
|
|
}
|
|
|
|
|
|
|
|
void migrate_fd_cancel(MigrationState *mig_state)
|
|
|
|
{
|
|
|
|
FdMigrationState *s = migrate_to_fms(mig_state);
|
|
|
|
|
|
|
|
if (s->state != MIG_STATE_ACTIVE)
|
|
|
|
return;
|
|
|
|
|
2010-02-07 02:03:50 +03:00
|
|
|
DPRINTF("cancelling migration\n");
|
2008-11-11 19:46:33 +03:00
|
|
|
|
|
|
|
s->state = MIG_STATE_CANCELLED;
|
2009-11-30 20:21:21 +03:00
|
|
|
qemu_savevm_state_cancel(s->mon, s->file);
|
2008-11-11 19:46:33 +03:00
|
|
|
|
|
|
|
migrate_fd_cleanup(s);
|
|
|
|
}
|
|
|
|
|
|
|
|
void migrate_fd_release(MigrationState *mig_state)
|
|
|
|
{
|
|
|
|
FdMigrationState *s = migrate_to_fms(mig_state);
|
|
|
|
|
2010-02-07 02:03:50 +03:00
|
|
|
DPRINTF("releasing state\n");
|
2008-11-11 19:46:33 +03:00
|
|
|
|
|
|
|
if (s->state == MIG_STATE_ACTIVE) {
|
|
|
|
s->state = MIG_STATE_CANCELLED;
|
|
|
|
migrate_fd_cleanup(s);
|
|
|
|
}
|
2010-06-09 09:44:31 +04:00
|
|
|
qemu_free(s);
|
2008-11-11 19:46:33 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
void migrate_fd_wait_for_unfreeze(void *opaque)
|
|
|
|
{
|
|
|
|
FdMigrationState *s = opaque;
|
|
|
|
int ret;
|
|
|
|
|
2010-02-07 02:03:50 +03:00
|
|
|
DPRINTF("wait for unfreeze\n");
|
2008-11-11 19:46:33 +03:00
|
|
|
if (s->state != MIG_STATE_ACTIVE)
|
|
|
|
return;
|
|
|
|
|
|
|
|
do {
|
|
|
|
fd_set wfds;
|
|
|
|
|
|
|
|
FD_ZERO(&wfds);
|
|
|
|
FD_SET(s->fd, &wfds);
|
|
|
|
|
|
|
|
ret = select(s->fd + 1, NULL, &wfds, NULL, NULL);
|
|
|
|
} while (ret == -1 && (s->get_error(s)) == EINTR);
|
|
|
|
}
|
|
|
|
|
|
|
|
int migrate_fd_close(void *opaque)
|
|
|
|
{
|
|
|
|
FdMigrationState *s = opaque;
|
2009-06-08 15:28:01 +04:00
|
|
|
|
|
|
|
qemu_set_fd_handler2(s->fd, NULL, NULL, NULL, NULL);
|
2008-11-11 19:46:33 +03:00
|
|
|
return s->close(s);
|
|
|
|
}
|