mirrors/qemu
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

migration: Rename abbreviated macro MIG_STATE_* to MIGRATION_STATUS_*

Browse Source 
Rename all macro MIG_STATE_* to  MIGRATION_STATUS_* except "MIG_STATE_ERROR",
we rename it to "MIGRATION_STATUS_FAILED" which will match the migration status
string 'failed'.

Signed-off-by: zhanghailiang <zhang.zhanghailiang@huawei.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Juan Quintela <quintela@redhat.com>
This commit is contained in:
zhanghailiang 2015-03-13 16:08:38 +08:00 committed by Juan Quintela
parent 21cb4924f7
commit 3119473166
1 changed files with 50 additions and 43 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

93
migration/migration.c
View File

@ -27,13 +27,13 @@
#include "trace.h" #include "trace.h"
enum { enum {
MIG_STATE_ERROR = -1, MIGRATION_STATUS_FAILED = -1,
MIG_STATE_NONE, MIGRATION_STATUS_NONE,
MIG_STATE_SETUP, MIGRATION_STATUS_SETUP,
MIG_STATE_CANCELLING, MIGRATION_STATUS_CANCELLING,
MIG_STATE_CANCELLED, MIGRATION_STATUS_CANCELLED,
MIG_STATE_ACTIVE, MIGRATION_STATUS_ACTIVE,
MIG_STATE_COMPLETED, MIGRATION_STATUS_COMPLETED,
}; };
#define MAX_THROTTLE (32 << 20) /* Migration speed throttling */ #define MAX_THROTTLE (32 << 20) /* Migration speed throttling */
@ -58,7 +58,7 @@ static bool deferred_incoming;
MigrationState *migrate_get_current(void) MigrationState *migrate_get_current(void)
{ {
static MigrationState current_migration = { static MigrationState current_migration = {
.state = MIG_STATE_NONE, .state = MIGRATION_STATUS_NONE,
.bandwidth_limit = MAX_THROTTLE, .bandwidth_limit = MAX_THROTTLE,
.xbzrle_cache_size = DEFAULT_MIGRATE_CACHE_SIZE, .xbzrle_cache_size = DEFAULT_MIGRATE_CACHE_SIZE,
.mbps = -1, .mbps = -1,
@ -200,16 +200,16 @@ MigrationInfo *qmp_query_migrate(Error **errp)
MigrationState *s = migrate_get_current(); MigrationState *s = migrate_get_current();
switch (s->state) { switch (s->state) {
case MIG_STATE_NONE: case MIGRATION_STATUS_NONE:
/* no migration has happened ever */ /* no migration has happened ever */
break; break;
case MIG_STATE_SETUP: case MIGRATION_STATUS_SETUP:
info->has_status = true; info->has_status = true;
info->status = g_strdup("setup"); info->status = g_strdup("setup");
info->has_total_time = false; info->has_total_time = false;
break; break;
case MIG_STATE_ACTIVE: case MIGRATION_STATUS_ACTIVE:
case MIG_STATE_CANCELLING: case MIGRATION_STATUS_CANCELLING:
info->has_status = true; info->has_status = true;
info->status = g_strdup("active"); info->status = g_strdup("active");
info->has_total_time = true; info->has_total_time = true;
@ -243,7 +243,7 @@ MigrationInfo *qmp_query_migrate(Error **errp)
get_xbzrle_cache_stats(info); get_xbzrle_cache_stats(info);
break; break;
case MIG_STATE_COMPLETED: case MIGRATION_STATUS_COMPLETED:
get_xbzrle_cache_stats(info); get_xbzrle_cache_stats(info);
info->has_status = true; info->has_status = true;
@ -267,11 +267,11 @@ MigrationInfo *qmp_query_migrate(Error **errp)
info->ram->mbps = s->mbps; info->ram->mbps = s->mbps;
info->ram->dirty_sync_count = s->dirty_sync_count; info->ram->dirty_sync_count = s->dirty_sync_count;
break; break;
case MIG_STATE_ERROR: case MIGRATION_STATUS_FAILED:
info->has_status = true; info->has_status = true;
info->status = g_strdup("failed"); info->status = g_strdup("failed");
break; break;
case MIG_STATE_CANCELLED: case MIGRATION_STATUS_CANCELLED:
info->has_status = true; info->has_status = true;
info->status = g_strdup("cancelled"); info->status = g_strdup("cancelled");
break; break;
@ -286,7 +286,8 @@ void qmp_migrate_set_capabilities(MigrationCapabilityStatusList *params,
MigrationState *s = migrate_get_current(); MigrationState *s = migrate_get_current();
MigrationCapabilityStatusList *cap; MigrationCapabilityStatusList *cap;
if (s->state == MIG_STATE_ACTIVE || s->state == MIG_STATE_SETUP) { if (s->state == MIGRATION_STATUS_ACTIVE ||
s->state == MIGRATION_STATUS_SETUP) {
error_set(errp, QERR_MIGRATION_ACTIVE); error_set(errp, QERR_MIGRATION_ACTIVE);
return; return;
} }
@ -322,12 +323,13 @@ static void migrate_fd_cleanup(void *opaque)
s->file = NULL; s->file = NULL;
} }
assert(s->state != MIG_STATE_ACTIVE); assert(s->state != MIGRATION_STATUS_ACTIVE);
if (s->state != MIG_STATE_COMPLETED) { if (s->state != MIGRATION_STATUS_COMPLETED) {
qemu_savevm_state_cancel(); qemu_savevm_state_cancel();
if (s->state == MIG_STATE_CANCELLING) { if (s->state == MIGRATION_STATUS_CANCELLING) {
migrate_set_state(s, MIG_STATE_CANCELLING, MIG_STATE_CANCELLED); migrate_set_state(s, MIGRATION_STATUS_CANCELLING,
MIGRATION_STATUS_CANCELLED);
} }
} }
@ -338,8 +340,8 @@ void migrate_fd_error(MigrationState *s)
{ {
trace_migrate_fd_error(); trace_migrate_fd_error();
assert(s->file == NULL); assert(s->file == NULL);
s->state = MIG_STATE_ERROR; s->state = MIGRATION_STATUS_FAILED;
trace_migrate_set_state(MIG_STATE_ERROR); trace_migrate_set_state(MIGRATION_STATUS_FAILED);
notifier_list_notify(&migration_state_notifiers, s); notifier_list_notify(&migration_state_notifiers, s);
} }
@ -351,11 +353,12 @@ static void migrate_fd_cancel(MigrationState *s)
do { do {
old_state = s->state; old_state = s->state;
if (old_state != MIG_STATE_SETUP && old_state != MIG_STATE_ACTIVE) { if (old_state != MIGRATION_STATUS_SETUP &&
old_state != MIGRATION_STATUS_ACTIVE) {
break; break;
} }
migrate_set_state(s, old_state, MIG_STATE_CANCELLING); migrate_set_state(s, old_state, MIGRATION_STATUS_CANCELLING);
} while (s->state != MIG_STATE_CANCELLING); } while (s->state != MIGRATION_STATUS_CANCELLING);
/* /*
* If we're unlucky the migration code might be stuck somewhere in a * If we're unlucky the migration code might be stuck somewhere in a
@ -364,7 +367,7 @@ static void migrate_fd_cancel(MigrationState *s)
* The outgoing qemu file gets closed in migrate_fd_cleanup that is * The outgoing qemu file gets closed in migrate_fd_cleanup that is
* called in a bh, so there is no race against this cancel. * called in a bh, so there is no race against this cancel.
*/ */
if (s->state == MIG_STATE_CANCELLING && f) { if (s->state == MIGRATION_STATUS_CANCELLING && f) {
qemu_file_shutdown(f); qemu_file_shutdown(f);
} }
} }
@ -381,18 +384,18 @@ void remove_migration_state_change_notifier(Notifier *notify)
bool migration_in_setup(MigrationState *s) bool migration_in_setup(MigrationState *s)
{ {
return s->state == MIG_STATE_SETUP; return s->state == MIGRATION_STATUS_SETUP;
} }
bool migration_has_finished(MigrationState *s) bool migration_has_finished(MigrationState *s)
{ {
return s->state == MIG_STATE_COMPLETED; return s->state == MIGRATION_STATUS_COMPLETED;
} }
bool migration_has_failed(MigrationState *s) bool migration_has_failed(MigrationState *s)
{ {
return (s->state == MIG_STATE_CANCELLED || return (s->state == MIGRATION_STATUS_CANCELLED ||
s->state == MIG_STATE_ERROR); s->state == MIGRATION_STATUS_FAILED);
} }
static MigrationState *migrate_init(const MigrationParams *params) static MigrationState *migrate_init(const MigrationParams *params)
@ -412,8 +415,8 @@ static MigrationState *migrate_init(const MigrationParams *params)
s->xbzrle_cache_size = xbzrle_cache_size; s->xbzrle_cache_size = xbzrle_cache_size;
s->bandwidth_limit = bandwidth_limit; s->bandwidth_limit = bandwidth_limit;
s->state = MIG_STATE_SETUP; s->state = MIGRATION_STATUS_SETUP;
trace_migrate_set_state(MIG_STATE_SETUP); trace_migrate_set_state(MIGRATION_STATUS_SETUP);
s->total_time = qemu_clock_get_ms(QEMU_CLOCK_REALTIME); s->total_time = qemu_clock_get_ms(QEMU_CLOCK_REALTIME);
return s; return s;
@ -466,8 +469,9 @@ void qmp_migrate(const char *uri, bool has_blk, bool blk,
params.blk = has_blk && blk; params.blk = has_blk && blk;
params.shared = has_inc && inc; params.shared = has_inc && inc;
if (s->state == MIG_STATE_ACTIVE || s->state == MIG_STATE_SETUP || if (s->state == MIGRATION_STATUS_ACTIVE ||
s->state == MIG_STATE_CANCELLING) { s->state == MIGRATION_STATUS_SETUP ||
s->state == MIGRATION_STATUS_CANCELLING) {
error_set(errp, QERR_MIGRATION_ACTIVE); error_set(errp, QERR_MIGRATION_ACTIVE);
return; return;
} }
@ -504,7 +508,7 @@ void qmp_migrate(const char *uri, bool has_blk, bool blk,
#endif #endif
} else { } else {
error_set(errp, QERR_INVALID_PARAMETER_VALUE, "uri", "a valid migration protocol"); error_set(errp, QERR_INVALID_PARAMETER_VALUE, "uri", "a valid migration protocol");
s->state = MIG_STATE_ERROR; s->state = MIGRATION_STATUS_FAILED;
return; return;
} }
@ -630,9 +634,9 @@ static void *migration_thread(void *opaque)
qemu_savevm_state_begin(s->file, &s->params); qemu_savevm_state_begin(s->file, &s->params);
s->setup_time = qemu_clock_get_ms(QEMU_CLOCK_HOST) - setup_start; s->setup_time = qemu_clock_get_ms(QEMU_CLOCK_HOST) - setup_start;
migrate_set_state(s, MIG_STATE_SETUP, MIG_STATE_ACTIVE); migrate_set_state(s, MIGRATION_STATUS_SETUP, MIGRATION_STATUS_ACTIVE);
while (s->state == MIG_STATE_ACTIVE) { while (s->state == MIGRATION_STATUS_ACTIVE) {
int64_t current_time; int64_t current_time;
uint64_t pending_size; uint64_t pending_size;
@ -657,19 +661,22 @@ static void *migration_thread(void *opaque)
qemu_mutex_unlock_iothread(); qemu_mutex_unlock_iothread();
if (ret < 0) { if (ret < 0) {
migrate_set_state(s, MIG_STATE_ACTIVE, MIG_STATE_ERROR); migrate_set_state(s, MIGRATION_STATUS_ACTIVE,
MIGRATION_STATUS_FAILED);
break; break;
} }
if (!qemu_file_get_error(s->file)) { if (!qemu_file_get_error(s->file)) {
migrate_set_state(s, MIG_STATE_ACTIVE, MIG_STATE_COMPLETED); migrate_set_state(s, MIGRATION_STATUS_ACTIVE,
MIGRATION_STATUS_COMPLETED);
break; break;
} }
} }
} }
if (qemu_file_get_error(s->file)) { if (qemu_file_get_error(s->file)) {
migrate_set_state(s, MIG_STATE_ACTIVE, MIG_STATE_ERROR); migrate_set_state(s, MIGRATION_STATUS_ACTIVE,
MIGRATION_STATUS_FAILED);
break; break;
} }
current_time = qemu_clock_get_ms(QEMU_CLOCK_REALTIME); current_time = qemu_clock_get_ms(QEMU_CLOCK_REALTIME);
@ -701,7 +708,7 @@ static void *migration_thread(void *opaque)
} }
qemu_mutex_lock_iothread(); qemu_mutex_lock_iothread();
if (s->state == MIG_STATE_COMPLETED) { if (s->state == MIGRATION_STATUS_COMPLETED) {
int64_t end_time = qemu_clock_get_ms(QEMU_CLOCK_REALTIME); int64_t end_time = qemu_clock_get_ms(QEMU_CLOCK_REALTIME);
uint64_t transferred_bytes = qemu_ftell(s->file); uint64_t transferred_bytes = qemu_ftell(s->file);
s->total_time = end_time - s->total_time; s->total_time = end_time - s->total_time;
@ -724,8 +731,8 @@ static void *migration_thread(void *opaque)
void migrate_fd_connect(MigrationState *s) void migrate_fd_connect(MigrationState *s)
{ {
s->state = MIG_STATE_SETUP; s->state = MIGRATION_STATUS_SETUP;
trace_migrate_set_state(MIG_STATE_SETUP); trace_migrate_set_state(MIGRATION_STATUS_SETUP);
/* This is a best 1st approximation. ns to ms */ /* This is a best 1st approximation. ns to ms */
s->expected_downtime = max_downtime/1000000; s->expected_downtime = max_downtime/1000000;