Commit e1c37d0e authored by Luiz Capitulino's avatar Luiz Capitulino
Browse files

qapi: Convert migrate 



The migrate command is one of those commands where HMP and QMP completely
mix up together. This made the conversion to the QAPI (which separates the
command into QMP and HMP parts) a bit difficult.

The first important change to be noticed is that this commit completes the
removal of the Monitor object from migration code, started by the previous
commit.

Another important and tricky change is about supporting the non-detached
mode. That is, if the user doesn't pass '-d' the migrate command will lock
the monitor and will only release it when migration is finished.

To support this in the new HMP command (hmp_migrate()), it is necessary
to create a timer which runs every second and checks if the migration is
still active. If it is, the timer callback will re-schedule itself to run
one second in the future. If the migration has already finished, the
monitor lock is released and the user can use it normally.

All these changes should be transparent to the user.

Signed-off-by: default avatarAnthony Liguori <aliguori@us.ibm.com>
Signed-off-by: default avatarLuiz Capitulino <lcapitulino@redhat.com>
parent 539de124

hmp-commands.hx

+1 −2
Original line number Diff line number Diff line
@@ -806,8 +806,7 @@ ETEXI 
		      " full copy of disk\n\t\t\t -i for migration without "

		      "shared storage with incremental copy of disk "

		      "(base image shared between src and destination)",

        .user_print = monitor_user_noop,	

	.mhandler.cmd_new = do_migrate,

        .mhandler.cmd = hmp_migrate,

    },

hmp.c

+74 −0
Original line number Diff line number Diff line
@@ -14,6 +14,7 @@ 
 */



#include "hmp.h"

#include "qemu-timer.h"

#include "qmp-commands.h"



static void hmp_handle_error(Monitor *mon, Error **errp)
@@ -860,3 +861,76 @@ void hmp_block_job_cancel(Monitor *mon, const QDict *qdict) 


    hmp_handle_error(mon, &error);

}



typedef struct MigrationStatus

{

    QEMUTimer *timer;

    Monitor *mon;

    bool is_block_migration;

} MigrationStatus;



static void hmp_migrate_status_cb(void *opaque)

{

    MigrationStatus *status = opaque;

    MigrationInfo *info;



    info = qmp_query_migrate(NULL);

    if (!info->has_status || strcmp(info->status, "active") == 0) {

        if (info->has_disk) {

            int progress;



            if (info->disk->remaining) {

                progress = info->disk->transferred * 100 / info->disk->total;

            } else {

                progress = 100;

            }



            monitor_printf(status->mon, "Completed %d %%\r", progress);

            monitor_flush(status->mon);

        }



        qemu_mod_timer(status->timer, qemu_get_clock_ms(rt_clock) + 1000);

    } else {

        if (status->is_block_migration) {

            monitor_printf(status->mon, "\n");

        }

        monitor_resume(status->mon);

        qemu_del_timer(status->timer);

        g_free(status);

    }



    qapi_free_MigrationInfo(info);

}



void hmp_migrate(Monitor *mon, const QDict *qdict)

{

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

    const char *uri = qdict_get_str(qdict, "uri");

    Error *err = NULL;



    qmp_migrate(uri, !!blk, blk, !!inc, inc, false, false, &err);

    if (err) {

        monitor_printf(mon, "migrate: %s\n", error_get_pretty(err));

        error_free(err);

        return;

    }



    if (!detach) {

        MigrationStatus *status;



        if (monitor_suspend(mon) < 0) {

            monitor_printf(mon, "terminal does not allow synchronous "

                           "migration, continuing detached\n");

            return;

        }



        status = g_malloc0(sizeof(*status));

        status->mon = mon;

        status->is_block_migration = blk || inc;

        status->timer = qemu_new_timer_ms(rt_clock, hmp_migrate_status_cb,

                                          status);

        qemu_mod_timer(status->timer, qemu_get_clock_ms(rt_clock));

    }

}

hmp.h

+1 −0
Original line number Diff line number Diff line
@@ -59,5 +59,6 @@ void hmp_block_set_io_throttle(Monitor *mon, const QDict *qdict); 
void hmp_block_stream(Monitor *mon, const QDict *qdict);

void hmp_block_job_set_speed(Monitor *mon, const QDict *qdict);

void hmp_block_job_cancel(Monitor *mon, const QDict *qdict);

void hmp_migrate(Monitor *mon, const QDict *qdict);



#endif

migration-fd.c

+1 −1
Original line number Diff line number Diff line
@@ -75,7 +75,7 @@ static int fd_close(MigrationState *s) 


int fd_start_outgoing_migration(MigrationState *s, const char *fdname)

{

    s->fd = monitor_get_fd(s->mon, fdname);

    s->fd = monitor_get_fd(cur_mon, fdname);

    if (s->fd == -1) {

        DPRINTF("fd_migration: invalid file descriptor identifier\n");

        goto err_after_get_fd;

migration.c

+17 −49
Original line number Diff line number Diff line
@@ -158,16 +158,6 @@ MigrationInfo *qmp_query_migrate(Error **errp) 


/* shared migration helpers */



static void migrate_fd_monitor_suspend(MigrationState *s, Monitor *mon)

{

    if (monitor_suspend(mon) == 0) {

        DPRINTF("suspending monitor\n");

    } else {

        monitor_printf(mon, "terminal does not allow synchronous "

                       "migration, continuing detached\n");

    }

}



static int migrate_fd_cleanup(MigrationState *s)

{

    int ret = 0;
@@ -178,10 +168,6 @@ static int migrate_fd_cleanup(MigrationState *s) 
        DPRINTF("closing file\n");

        ret = qemu_fclose(s->file);

        s->file = NULL;

    } else {

        if (s->mon) {

            monitor_resume(s->mon);

        }

    }



    if (s->fd != -1) {
@@ -321,9 +307,6 @@ static int migrate_fd_close(void *opaque) 
{

    MigrationState *s = opaque;



    if (s->mon) {

        monitor_resume(s->mon);

    }

    qemu_set_fd_handler2(s->fd, NULL, NULL, NULL, NULL);

    return s->close(s);

}
@@ -376,7 +359,7 @@ void migrate_fd_connect(MigrationState *s) 
    migrate_fd_put_ready(s);

}



static MigrationState *migrate_init(Monitor *mon, int detach, int blk, int inc)

static MigrationState *migrate_init(int blk, int inc)

{

    MigrationState *s = migrate_get_current();

    int64_t bandwidth_limit = s->bandwidth_limit;
@@ -386,18 +369,9 @@ static MigrationState *migrate_init(Monitor *mon, int detach, int blk, int inc) 
    s->blk = blk;

    s->shared = inc;



    /* s->mon is used for two things:

       - pass fd in fd migration

       - suspend/resume monitor for not detached migration

    */

    s->mon = mon;

    s->bandwidth_limit = bandwidth_limit;

    s->state = MIG_STATE_SETUP;



    if (!detach) {

        migrate_fd_monitor_suspend(s, mon);

    }



    return s;

}
@@ -413,32 +387,29 @@ void migrate_del_blocker(Error *reason) 
    migration_blockers = g_slist_remove(migration_blockers, reason);

}



int do_migrate(Monitor *mon, const QDict *qdict, QObject **ret_data)

void qmp_migrate(const char *uri, bool has_blk, bool blk,

                 bool has_inc, bool inc, bool has_detach, bool detach,

                 Error **errp)

{

    MigrationState *s = migrate_get_current();

    const char *p;

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

    const char *uri = qdict_get_str(qdict, "uri");

    int ret;



    if (s->state == MIG_STATE_ACTIVE) {

        monitor_printf(mon, "migration already in progress\n");

        return -1;

        error_set(errp, QERR_MIGRATION_ACTIVE);

        return;

    }



    if (qemu_savevm_state_blocked(mon)) {

        return -1;

    if (qemu_savevm_state_blocked(errp)) {

        return;

    }



    if (migration_blockers) {

        Error *err = migration_blockers->data;

        qerror_report_err(err);

        return -1;

        *errp = error_copy(migration_blockers->data);

        return;

    }



    s = migrate_init(mon, detach, blk, inc);

    s = migrate_init(blk, inc);



    if (strstart(uri, "tcp:", &p)) {

        ret = tcp_start_outgoing_migration(s, p);
@@ -451,21 +422,18 @@ int do_migrate(Monitor *mon, const QDict *qdict, QObject **ret_data) 
        ret = fd_start_outgoing_migration(s, p);

#endif

    } else {

        monitor_printf(mon, "unknown migration protocol: %s\n", uri);

        ret  = -EINVAL;

        error_set(errp, QERR_INVALID_PARAMETER_VALUE, "uri", "a valid migration protocol");

        return;

    }



    if (ret < 0) {

        monitor_printf(mon, "migration failed: %s\n", strerror(-ret));

        return ret;

    }



    if (detach) {

        s->mon = NULL;

        DPRINTF("migration failed: %s\n", strerror(-ret));

        /* FIXME: we should return meaningful errors */

        error_set(errp, QERR_UNDEFINED_ERROR);

        return;

    }



    notifier_list_notify(&migration_state_notifiers, s);

    return 0;

}



void qmp_migrate_cancel(Error **errp)