migration.c 12.4 KB
Newer Older
A
aliguori 已提交
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
/*
 * 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"
A
aliguori 已提交
16
#include "monitor.h"
17 18 19 20
#include "buffered_file.h"
#include "sysemu.h"
#include "block.h"
#include "qemu_socket.h"
21
#include "block-migration.h"
22
#include "qemu-objects.h"
23 24 25 26

//#define DEBUG_MIGRATION

#ifdef DEBUG_MIGRATION
M
malc 已提交
27
#define DPRINTF(fmt, ...) \
28 29
    do { printf("migration: " fmt, ## __VA_ARGS__); } while (0)
#else
M
malc 已提交
30
#define DPRINTF(fmt, ...) \
31 32
    do { } while (0)
#endif
A
aliguori 已提交
33 34

/* Migration speed throttling */
M
Michael S. Tsirkin 已提交
35
static int64_t max_throttle = (32 << 20);
A
aliguori 已提交
36 37 38

static MigrationState *current_migration;

39 40 41
static NotifierList migration_state_notifiers =
    NOTIFIER_LIST_INITIALIZER(migration_state_notifiers);

J
Juan Quintela 已提交
42
int qemu_start_incoming_migration(const char *uri)
A
aliguori 已提交
43
{
A
aliguori 已提交
44
    const char *p;
J
Juan Quintela 已提交
45
    int ret;
A
aliguori 已提交
46 47

    if (strstart(uri, "tcp:", &p))
J
Juan Quintela 已提交
48
        ret = tcp_start_incoming_migration(p);
49 50
#if !defined(WIN32)
    else if (strstart(uri, "exec:", &p))
J
Juan Quintela 已提交
51
        ret =  exec_start_incoming_migration(p);
C
Chris Lalancette 已提交
52
    else if (strstart(uri, "unix:", &p))
J
Juan Quintela 已提交
53
        ret = unix_start_incoming_migration(p);
P
Paolo Bonzini 已提交
54
    else if (strstart(uri, "fd:", &p))
J
Juan Quintela 已提交
55
        ret = fd_start_incoming_migration(p);
56
#endif
J
Juan Quintela 已提交
57
    else {
A
aliguori 已提交
58
        fprintf(stderr, "unknown migration protocol: %s\n", uri);
J
Juan Quintela 已提交
59 60 61
        ret = -EPROTONOSUPPORT;
    }
    return ret;
A
aliguori 已提交
62 63
}

64 65 66 67 68 69 70 71 72
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");

73
    if (autostart) {
74
        vm_start();
75
    } else {
76
        runstate_set(RUN_STATE_PRELAUNCH);
77
    }
78 79
}

80
int do_migrate(Monitor *mon, const QDict *qdict, QObject **ret_data)
A
aliguori 已提交
81
{
A
aliguori 已提交
82 83
    MigrationState *s = NULL;
    const char *p;
84 85 86
    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);
87
    const char *uri = qdict_get_str(qdict, "uri");
88 89 90 91

    if (current_migration &&
        current_migration->get_status(current_migration) == MIG_STATE_ACTIVE) {
        monitor_printf(mon, "migration already in progress\n");
92
        return -1;
93 94
    }

A
Alex Williamson 已提交
95 96 97 98
    if (qemu_savevm_state_blocked(mon)) {
        return -1;
    }

99
    if (strstart(uri, "tcp:", &p)) {
100
        s = tcp_start_outgoing_migration(mon, p, max_throttle, detach,
101
                                         blk, inc);
102
#if !defined(WIN32)
103
    } else if (strstart(uri, "exec:", &p)) {
104
        s = exec_start_outgoing_migration(mon, p, max_throttle, detach,
105
                                          blk, inc);
106
    } else if (strstart(uri, "unix:", &p)) {
107
        s = unix_start_outgoing_migration(mon, p, max_throttle, detach,
108
                                          blk, inc);
109
    } else if (strstart(uri, "fd:", &p)) {
L
lirans@il.ibm.com 已提交
110
        s = fd_start_outgoing_migration(mon, p, max_throttle, detach, 
111
                                        blk, inc);
112
#endif
113
    } else {
A
aliguori 已提交
114
        monitor_printf(mon, "unknown migration protocol: %s\n", uri);
115 116
        return -1;
    }
A
aliguori 已提交
117

118
    if (s == NULL) {
A
aliguori 已提交
119
        monitor_printf(mon, "migration failed\n");
120 121
        return -1;
    }
A
aliguori 已提交
122

123 124
    if (current_migration) {
        current_migration->release(current_migration);
A
aliguori 已提交
125
    }
126 127

    current_migration = s;
128
    notifier_list_notify(&migration_state_notifiers, NULL);
129
    return 0;
A
aliguori 已提交
130 131
}

132
int do_migrate_cancel(Monitor *mon, const QDict *qdict, QObject **ret_data)
A
aliguori 已提交
133 134 135
{
    MigrationState *s = current_migration;

136
    if (s && s->get_status(s) == MIG_STATE_ACTIVE) {
A
aliguori 已提交
137
        s->cancel(s);
138
    }
139
    return 0;
A
aliguori 已提交
140 141
}

142
int do_migrate_set_speed(Monitor *mon, const QDict *qdict, QObject **ret_data)
A
aliguori 已提交
143
{
144
    int64_t d;
145
    FdMigrationState *s;
A
aliguori 已提交
146

147
    d = qdict_get_int(qdict, "value");
M
Michael S. Tsirkin 已提交
148 149 150
    if (d < 0) {
        d = 0;
    }
151
    max_throttle = d;
152

153 154
    s = migrate_to_fms(current_migration);
    if (s && s->file) {
155 156
        qemu_file_set_rate_limit(s->file, max_throttle);
    }
157 158

    return 0;
A
aliguori 已提交
159 160
}

161 162 163 164 165 166 167 168 169 170 171
/* 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;
}

172 173
int do_migrate_set_downtime(Monitor *mon, const QDict *qdict,
                            QObject **ret_data)
G
Glauber Costa 已提交
174 175 176
{
    double d;

177 178
    d = qdict_get_double(qdict, "value") * 1e9;
    d = MAX(0, MIN(UINT64_MAX, d));
G
Glauber Costa 已提交
179
    max_downtime = (uint64_t)d;
180 181

    return 0;
G
Glauber Costa 已提交
182 183
}

184 185
static void migrate_print_status(Monitor *mon, const char *name,
                                 const QDict *status_dict)
A
aliguori 已提交
186
{
187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230
    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;
A
aliguori 已提交
231
    MigrationState *s = current_migration;
A
aliguori 已提交
232

A
aliguori 已提交
233
    if (s) {
A
aliguori 已提交
234 235
        switch (s->get_status(s)) {
        case MIG_STATE_ACTIVE:
236 237 238 239 240 241
            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());

242
            if (blk_mig_active()) {
243 244 245
                migrate_put_status(qdict, "disk", blk_mig_bytes_transferred(),
                                   blk_mig_bytes_remaining(),
                                   blk_mig_bytes_total());
246
            }
247 248

            *ret_data = QOBJECT(qdict);
A
aliguori 已提交
249 250
            break;
        case MIG_STATE_COMPLETED:
251
            *ret_data = qobject_from_jsonf("{ 'status': 'completed' }");
A
aliguori 已提交
252 253
            break;
        case MIG_STATE_ERROR:
254
            *ret_data = qobject_from_jsonf("{ 'status': 'failed' }");
A
aliguori 已提交
255 256
            break;
        case MIG_STATE_CANCELLED:
257
            *ret_data = qobject_from_jsonf("{ 'status': 'cancelled' }");
A
aliguori 已提交
258 259
            break;
        }
A
aliguori 已提交
260 261 262
    }
}

263 264
/* shared migration helpers */

265
void migrate_fd_monitor_suspend(FdMigrationState *s, Monitor *mon)
266
{
267 268
    s->mon = mon;
    if (monitor_suspend(mon) == 0) {
M
malc 已提交
269
        DPRINTF("suspending monitor\n");
270 271
    } else {
        monitor_printf(mon, "terminal does not allow synchronous "
272
                       "migration, continuing detached\n");
273
    }
274 275
}

276 277
void migrate_fd_error(FdMigrationState *s)
{
M
malc 已提交
278
    DPRINTF("setting error state\n");
279
    s->state = MIG_STATE_ERROR;
280
    notifier_list_notify(&migration_state_notifiers, NULL);
281 282 283
    migrate_fd_cleanup(s);
}

284
int migrate_fd_cleanup(FdMigrationState *s)
285
{
286 287
    int ret = 0;

288 289 290
    qemu_set_fd_handler2(s->fd, NULL, NULL, NULL, NULL);

    if (s->file) {
M
malc 已提交
291
        DPRINTF("closing file\n");
292 293 294
        if (qemu_fclose(s->file) != 0) {
            ret = -1;
        }
295
        s->file = NULL;
296 297 298 299
    } else {
        if (s->mon) {
            monitor_resume(s->mon);
        }
300 301
    }

302
    if (s->fd != -1) {
303
        close(s->fd);
304
        s->fd = -1;
305
    }
306

307
    return ret;
308 309 310 311 312 313 314 315
}

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);
316 317 318
    if (qemu_file_has_error(s->file)) {
        migrate_fd_error(s);
    }
319 320 321 322 323 324 325
}

ssize_t migrate_fd_put_buffer(void *opaque, const void *data, size_t size)
{
    FdMigrationState *s = opaque;
    ssize_t ret;

326 327 328 329
    if (s->state != MIG_STATE_ACTIVE) {
        return -EIO;
    }

330 331
    do {
        ret = s->write(s, data, size);
332
    } while (ret == -1 && ((s->get_error(s)) == EINTR));
333 334 335 336

    if (ret == -1)
        ret = -(s->get_error(s));

337
    if (ret == -EAGAIN) {
338
        qemu_set_fd_handler2(s->fd, NULL, NULL, migrate_fd_put_notify, s);
339
    }
340 341 342 343 344 345 346 347 348 349 350 351 352 353 354

    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);

M
malc 已提交
355
    DPRINTF("beginning savevm\n");
356
    ret = qemu_savevm_state_begin(s->mon, s->file, s->mig_state.blk,
L
lirans@il.ibm.com 已提交
357
                                  s->mig_state.shared);
358
    if (ret < 0) {
M
malc 已提交
359
        DPRINTF("failed, %d\n", ret);
360 361 362
        migrate_fd_error(s);
        return;
    }
L
lirans@il.ibm.com 已提交
363
    
364 365 366 367 368 369 370 371
    migrate_fd_put_ready(s);
}

void migrate_fd_put_ready(void *opaque)
{
    FdMigrationState *s = opaque;

    if (s->state != MIG_STATE_ACTIVE) {
M
malc 已提交
372
        DPRINTF("put_ready returning because of non-active state\n");
373 374 375
        return;
    }

M
malc 已提交
376
    DPRINTF("iterate\n");
377
    if (qemu_savevm_state_iterate(s->mon, s->file) == 1) {
378
        int old_vm_running = runstate_is_running();
379

M
malc 已提交
380
        DPRINTF("done iterating\n");
381
        vm_stop(RUN_STATE_FINISH_MIGRATE);
382

383
        if ((qemu_savevm_state_complete(s->mon, s->file)) < 0) {
384 385 386
            if (old_vm_running) {
                vm_start();
            }
387
            s->state = MIG_STATE_ERROR;
388
        }
389 390 391 392
        if (migrate_fd_cleanup(s) < 0) {
            if (old_vm_running) {
                vm_start();
            }
393
            s->state = MIG_STATE_ERROR;
394
        }
395 396
        if (s->state == MIG_STATE_ACTIVE) {
            s->state = MIG_STATE_COMPLETED;
397
            runstate_set(RUN_STATE_POSTMIGRATE);
398
        }
399
        notifier_list_notify(&migration_state_notifiers, NULL);
400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415
    }
}

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;

M
malc 已提交
416
    DPRINTF("cancelling migration\n");
417 418

    s->state = MIG_STATE_CANCELLED;
419
    notifier_list_notify(&migration_state_notifiers, NULL);
420
    qemu_savevm_state_cancel(s->mon, s->file);
421 422 423 424 425 426 427 428

    migrate_fd_cleanup(s);
}

void migrate_fd_release(MigrationState *mig_state)
{
    FdMigrationState *s = migrate_to_fms(mig_state);

M
malc 已提交
429
    DPRINTF("releasing state\n");
430 431 432
   
    if (s->state == MIG_STATE_ACTIVE) {
        s->state = MIG_STATE_CANCELLED;
433
        notifier_list_notify(&migration_state_notifiers, NULL);
434 435
        migrate_fd_cleanup(s);
    }
436
    g_free(s);
437 438 439 440 441 442 443
}

void migrate_fd_wait_for_unfreeze(void *opaque)
{
    FdMigrationState *s = opaque;
    int ret;

M
malc 已提交
444
    DPRINTF("wait for unfreeze\n");
445 446 447 448 449 450 451 452 453 454 455
    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);
456 457

    if (ret == -1) {
458
        qemu_file_set_error(s->file, -s->get_error(s));
459
    }
460 461 462 463 464
}

int migrate_fd_close(void *opaque)
{
    FdMigrationState *s = opaque;
465

466 467 468
    if (s->mon) {
        monitor_resume(s->mon);
    }
469
    qemu_set_fd_handler2(s->fd, NULL, NULL, NULL, NULL);
470 471
    return s->close(s);
}
472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490

void add_migration_state_change_notifier(Notifier *notify)
{
    notifier_list_add(&migration_state_notifiers, notify);
}

void remove_migration_state_change_notifier(Notifier *notify)
{
    notifier_list_remove(&migration_state_notifiers, notify);
}

int get_migration_state(void)
{
    if (current_migration) {
        return migrate_fd_get_status(current_migration);
    } else {
        return MIG_STATE_ERROR;
    }
}