Commit 91728bda authored by Peter Maydell's avatar Peter Maydell
Browse files

Merge remote-tracking branch 'remotes/amit-migration/tags/migration-for-2.6-1' into staging 



migration fixes for postcopy, xbzrle, multithread decompression

# gpg: Signature made Wed 13 Jan 2016 10:34:49 GMT using RSA key ID 854083B6
# gpg: Good signature from "Amit Shah <amit@amitshah.net>"
# gpg:                 aka "Amit Shah <amit@kernel.org>"
# gpg:                 aka "Amit Shah <amitshah@gmx.net>"

* remotes/amit-migration/tags/migration-for-2.6-1:
  multithread decompression: Avoid one copy
  Use qemu_get_buffer_in_place for xbzrle data
  Migration: Emit event at start of pass
  Postcopy: Send events/change state on incoming side
  migration: Add state records for migration incoming
  migration: Export migrate_set_state()

Signed-off-by: default avatarPeter Maydell <peter.maydell@linaro.org>
parents 649a1bba c1bc6626

docs/qmp-events.txt

+14 −0
Original line number Diff line number Diff line
@@ -496,6 +496,20 @@ Example: 
{"timestamp": {"seconds": 1432121972, "microseconds": 744001},

 "event": "MIGRATION", "data": {"status": "completed"}}



MIGRATION_PASS

--------------



Emitted from the source side of a migration at the start of each pass

(when it syncs the dirty bitmap)



Data: None.



  - "pass": An incrementing count (starting at 1 on the first pass)



Example:

{"timestamp": {"seconds": 1449669631, "microseconds": 239225},

 "event": "MIGRATION_PASS", "data": {"pass": 2}}



STOP

----

include/migration/migration.h

+3 −0
Original line number Diff line number Diff line
@@ -105,6 +105,7 @@ struct MigrationIncomingState { 
    QemuMutex rp_mutex;    /* We send replies from multiple threads */

    void     *postcopy_tmp_page;



    int state;

    /* See savevm.c */

    LoadStateEntry_Head loadvm_handlers;

};
@@ -169,6 +170,8 @@ struct MigrationState 
    RAMBlock *last_req_rb;

};



void migrate_set_state(int *state, int old_state, int new_state);



void process_incoming_migration(QEMUFile *f);



void qemu_start_incoming_migration(const char *uri, Error **errp);

migration/migration.c

+31 −21
Original line number Diff line number Diff line
@@ -111,6 +111,7 @@ MigrationIncomingState *migration_incoming_state_new(QEMUFile* f) 
{

    mis_current = g_new0(MigrationIncomingState, 1);

    mis_current->from_src_file = f;

    mis_current->state = MIGRATION_STATUS_NONE;

    QLIST_INIT(&mis_current->loadvm_handlers);

    qemu_mutex_init(&mis_current->rp_mutex);

    qemu_event_init(&mis_current->main_thread_load_event, false);
@@ -331,8 +332,8 @@ static void process_incoming_migration_co(void *opaque) 


    mis = migration_incoming_state_new(f);

    postcopy_state_set(POSTCOPY_INCOMING_NONE);

    migrate_generate_event(MIGRATION_STATUS_ACTIVE);



    migrate_set_state(&mis->state, MIGRATION_STATUS_NONE,

                      MIGRATION_STATUS_ACTIVE);

    ret = qemu_loadvm_state(f);



    ps = postcopy_state_get();
@@ -358,10 +359,10 @@ static void process_incoming_migration_co(void *opaque) 


    qemu_fclose(f);

    free_xbzrle_decoded_buf();

    migration_incoming_state_destroy();



    if (ret < 0) {

        migrate_generate_event(MIGRATION_STATUS_FAILED);

        migrate_set_state(&mis->state, MIGRATION_STATUS_ACTIVE,

                          MIGRATION_STATUS_FAILED);

        error_report("load of migration failed: %s", strerror(-ret));

        migrate_decompress_threads_join();

        exit(EXIT_FAILURE);
@@ -370,7 +371,8 @@ static void process_incoming_migration_co(void *opaque) 
    /* Make sure all file formats flush their mutable metadata */

    bdrv_invalidate_cache_all(&local_err);

    if (local_err) {

        migrate_generate_event(MIGRATION_STATUS_FAILED);

        migrate_set_state(&mis->state, MIGRATION_STATUS_ACTIVE,

                          MIGRATION_STATUS_FAILED);

        error_report_err(local_err);

        migrate_decompress_threads_join();

        exit(EXIT_FAILURE);
@@ -402,7 +404,9 @@ static void process_incoming_migration_co(void *opaque) 
     * observer sees this event they might start to prod at the VM assuming

     * it's ready to use.

     */

    migrate_generate_event(MIGRATION_STATUS_COMPLETED);

    migrate_set_state(&mis->state, MIGRATION_STATUS_ACTIVE,

                      MIGRATION_STATUS_COMPLETED);

    migration_incoming_state_destroy();

}



void process_incoming_migration(QEMUFile *f)
@@ -787,9 +791,9 @@ void qmp_migrate_start_postcopy(Error **errp) 


/* shared migration helpers */



static void migrate_set_state(MigrationState *s, int old_state, int new_state)

void migrate_set_state(int *state, int old_state, int new_state)

{

    if (atomic_cmpxchg(&s->state, old_state, new_state) == old_state) {

    if (atomic_cmpxchg(state, old_state, new_state) == old_state) {

        trace_migrate_set_state(new_state);

        migrate_generate_event(new_state);

    }
@@ -822,7 +826,7 @@ static void migrate_fd_cleanup(void *opaque) 
           (s->state != MIGRATION_STATUS_POSTCOPY_ACTIVE));



    if (s->state == MIGRATION_STATUS_CANCELLING) {

        migrate_set_state(s, MIGRATION_STATUS_CANCELLING,

        migrate_set_state(&s->state, MIGRATION_STATUS_CANCELLING,

                          MIGRATION_STATUS_CANCELLED);

    }
@@ -833,7 +837,8 @@ void migrate_fd_error(MigrationState *s) 
{

    trace_migrate_fd_error();

    assert(s->file == NULL);

    migrate_set_state(s, MIGRATION_STATUS_SETUP, MIGRATION_STATUS_FAILED);

    migrate_set_state(&s->state, MIGRATION_STATUS_SETUP,

                      MIGRATION_STATUS_FAILED);

    notifier_list_notify(&migration_state_notifiers, s);

}
@@ -853,7 +858,7 @@ static void migrate_fd_cancel(MigrationState *s) 
        if (!migration_is_setup_or_active(old_state)) {

            break;

        }

        migrate_set_state(s, old_state, MIGRATION_STATUS_CANCELLING);

        migrate_set_state(&s->state, old_state, MIGRATION_STATUS_CANCELLING);

    } while (s->state != MIGRATION_STATUS_CANCELLING);



    /*
@@ -927,7 +932,7 @@ MigrationState *migrate_init(const MigrationParams *params) 
    s->migration_thread_running = false;

    s->last_req_rb = NULL;



    migrate_set_state(s, MIGRATION_STATUS_NONE, MIGRATION_STATUS_SETUP);

    migrate_set_state(&s->state, MIGRATION_STATUS_NONE, MIGRATION_STATUS_SETUP);



    QSIMPLEQ_INIT(&s->src_page_requests);
@@ -1026,7 +1031,8 @@ void qmp_migrate(const char *uri, bool has_blk, bool blk, 
    } else {

        error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "uri",

                   "a valid migration protocol");

        migrate_set_state(s, MIGRATION_STATUS_SETUP, MIGRATION_STATUS_FAILED);

        migrate_set_state(&s->state, MIGRATION_STATUS_SETUP,

                          MIGRATION_STATUS_FAILED);

        return;

    }
@@ -1405,7 +1411,7 @@ static int postcopy_start(MigrationState *ms, bool *old_vm_running) 
    int ret;

    const QEMUSizedBuffer *qsb;

    int64_t time_at_stop = qemu_clock_get_ms(QEMU_CLOCK_REALTIME);

    migrate_set_state(ms, MIGRATION_STATUS_ACTIVE,

    migrate_set_state(&ms->state, MIGRATION_STATUS_ACTIVE,

                      MIGRATION_STATUS_POSTCOPY_ACTIVE);



    trace_postcopy_start();
@@ -1496,7 +1502,7 @@ static int postcopy_start(MigrationState *ms, bool *old_vm_running) 
    ret = qemu_file_get_error(ms->file);

    if (ret) {

        error_report("postcopy_start: Migration stream errored");

        migrate_set_state(ms, MIGRATION_STATUS_POSTCOPY_ACTIVE,

        migrate_set_state(&ms->state, MIGRATION_STATUS_POSTCOPY_ACTIVE,

                              MIGRATION_STATUS_FAILED);

    }
@@ -1505,7 +1511,7 @@ static int postcopy_start(MigrationState *ms, bool *old_vm_running) 
fail_closefb:

    qemu_fclose(fb);

fail:

    migrate_set_state(ms, MIGRATION_STATUS_POSTCOPY_ACTIVE,

    migrate_set_state(&ms->state, MIGRATION_STATUS_POSTCOPY_ACTIVE,

                          MIGRATION_STATUS_FAILED);

    qemu_mutex_unlock_iothread();

    return -1;
@@ -1574,11 +1580,13 @@ static void migration_completion(MigrationState *s, int current_active_state, 
        goto fail;

    }



    migrate_set_state(s, current_active_state, MIGRATION_STATUS_COMPLETED);

    migrate_set_state(&s->state, current_active_state,

                      MIGRATION_STATUS_COMPLETED);

    return;



fail:

    migrate_set_state(s, current_active_state, MIGRATION_STATUS_FAILED);

    migrate_set_state(&s->state, current_active_state,

                      MIGRATION_STATUS_FAILED);

}



/*
@@ -1623,7 +1631,8 @@ static void *migration_thread(void *opaque) 


    s->setup_time = qemu_clock_get_ms(QEMU_CLOCK_HOST) - setup_start;

    current_active_state = MIGRATION_STATUS_ACTIVE;

    migrate_set_state(s, MIGRATION_STATUS_SETUP, MIGRATION_STATUS_ACTIVE);

    migrate_set_state(&s->state, MIGRATION_STATUS_SETUP,

                      MIGRATION_STATUS_ACTIVE);



    trace_migration_thread_setup_complete();
@@ -1666,7 +1675,8 @@ static void *migration_thread(void *opaque) 
        }



        if (qemu_file_get_error(s->file)) {

            migrate_set_state(s, current_active_state, MIGRATION_STATUS_FAILED);

            migrate_set_state(&s->state, current_active_state,

                              MIGRATION_STATUS_FAILED);

            trace_migration_thread_file_err();

            break;

        }
@@ -1747,7 +1757,7 @@ void migrate_fd_connect(MigrationState *s) 
    if (migrate_postcopy_ram()) {

        if (open_return_path_on_source(s)) {

            error_report("Unable to open return-path for postcopy");

            migrate_set_state(s, MIGRATION_STATUS_SETUP,

            migrate_set_state(&s->state, MIGRATION_STATUS_SETUP,

                              MIGRATION_STATUS_FAILED);

            migrate_fd_cleanup(s);

            return;

migration/ram.c

+11 −10
Original line number Diff line number Diff line
@@ -27,6 +27,7 @@ 
 */

#include <stdint.h>

#include <zlib.h>

#include "qapi-event.h"

#include "qemu/bitops.h"

#include "qemu/bitmap.h"

#include "qemu/timer.h"
@@ -285,7 +286,6 @@ static bool quit_comp_thread; 
static bool quit_decomp_thread;

static DecompressParam *decomp_param;

static QemuThread *decompress_threads;

static uint8_t *compressed_data_buf;



static int do_compress_ram_page(CompressParam *param);
@@ -682,6 +682,9 @@ static void migration_bitmap_sync(void) 
        num_dirty_pages_period = 0;

    }

    s->dirty_sync_count = bitmap_sync_count;

    if (migrate_use_events()) {

        qapi_event_send_migration_pass(bitmap_sync_count, NULL);

    }

}



/**
@@ -2084,10 +2087,12 @@ static int load_xbzrle(QEMUFile *f, ram_addr_t addr, void *host) 
{

    unsigned int xh_len;

    int xh_flags;

    uint8_t *loaded_data;



    if (!xbzrle_decoded_buf) {

        xbzrle_decoded_buf = g_malloc(TARGET_PAGE_SIZE);

    }

    loaded_data = xbzrle_decoded_buf;



    /* extract RLE header */

    xh_flags = qemu_get_byte(f);
@@ -2103,10 +2108,10 @@ static int load_xbzrle(QEMUFile *f, ram_addr_t addr, void *host) 
        return -1;

    }

    /* load data and decode */

    qemu_get_buffer(f, xbzrle_decoded_buf, xh_len);

    qemu_get_buffer_in_place(f, &loaded_data, xh_len);



    /* decode RLE */

    if (xbzrle_decode_buffer(xbzrle_decoded_buf, xh_len, host,

    if (xbzrle_decode_buffer(loaded_data, xh_len, host,

                             TARGET_PAGE_SIZE) == -1) {

        error_report("Failed to load XBZRLE page - decode error!");

        return -1;
@@ -2201,7 +2206,6 @@ void migrate_decompress_threads_create(void) 
    thread_count = migrate_decompress_threads();

    decompress_threads = g_new0(QemuThread, thread_count);

    decomp_param = g_new0(DecompressParam, thread_count);

    compressed_data_buf = g_malloc0(compressBound(TARGET_PAGE_SIZE));

    quit_decomp_thread = false;

    for (i = 0; i < thread_count; i++) {

        qemu_mutex_init(&decomp_param[i].mutex);
@@ -2232,13 +2236,11 @@ void migrate_decompress_threads_join(void) 
    }

    g_free(decompress_threads);

    g_free(decomp_param);

    g_free(compressed_data_buf);

    decompress_threads = NULL;

    decomp_param = NULL;

    compressed_data_buf = NULL;

}



static void decompress_data_with_multi_threads(uint8_t *compbuf,

static void decompress_data_with_multi_threads(QEMUFile *f,

                                               void *host, int len)

{

    int idx, thread_count;
@@ -2247,7 +2249,7 @@ static void decompress_data_with_multi_threads(uint8_t *compbuf, 
    while (true) {

        for (idx = 0; idx < thread_count; idx++) {

            if (!decomp_param[idx].start) {

                memcpy(decomp_param[idx].compbuf, compbuf, len);

                qemu_get_buffer(f, decomp_param[idx].compbuf, len);

                decomp_param[idx].des = host;

                decomp_param[idx].len = len;

                start_decompression(&decomp_param[idx]);
@@ -2492,8 +2494,7 @@ static int ram_load(QEMUFile *f, void *opaque, int version_id) 
                ret = -EINVAL;

                break;

            }

            qemu_get_buffer(f, compressed_data_buf, len);

            decompress_data_with_multi_threads(compressed_data_buf, host, len);

            decompress_data_with_multi_threads(f, host, len);

            break;



        case RAM_SAVE_FLAG_XBZRLE:

migration/savevm.c

+15 −7
Original line number Diff line number Diff line
@@ -1399,6 +1399,8 @@ static void *postcopy_ram_listen_thread(void *opaque) 
    MigrationIncomingState *mis = migration_incoming_get_current();

    int load_res;



    migrate_set_state(&mis->state, MIGRATION_STATUS_ACTIVE,

                                   MIGRATION_STATUS_POSTCOPY_ACTIVE);

    qemu_sem_post(&mis->listen_thread_sem);

    trace_postcopy_ram_listen_thread_start();
@@ -1415,6 +1417,8 @@ static void *postcopy_ram_listen_thread(void *opaque) 
    if (load_res < 0) {

        error_report("%s: loadvm failed: %d", __func__, load_res);

        qemu_file_set_error(f, load_res);

        migrate_set_state(&mis->state, MIGRATION_STATUS_POSTCOPY_ACTIVE,

                                       MIGRATION_STATUS_FAILED);

    } else {

        /*

         * This looks good, but it's possible that the device loading in the
@@ -1424,13 +1428,6 @@ static void *postcopy_ram_listen_thread(void *opaque) 
        qemu_event_wait(&mis->main_thread_load_event);

    }

    postcopy_ram_incoming_cleanup(mis);

    /*

     * If everything has worked fine, then the main thread has waited

     * for us to start, and we're the last use of the mis.

     * (If something broke then qemu will have to exit anyway since it's

     * got a bad migration state).

     */

    migration_incoming_state_destroy();



    if (load_res < 0) {

        /*
@@ -1442,6 +1439,17 @@ static void *postcopy_ram_listen_thread(void *opaque) 
        exit(EXIT_FAILURE);

    }



    migrate_set_state(&mis->state, MIGRATION_STATUS_POSTCOPY_ACTIVE,

                                   MIGRATION_STATUS_COMPLETED);

    /*

     * If everything has worked fine, then the main thread has waited

     * for us to start, and we're the last use of the mis.

     * (If something broke then qemu will have to exit anyway since it's

     * got a bad migration state).

     */

    migration_incoming_state_destroy();





    return NULL;

}