Commit f3bcfc56 authored by Peter Maydell's avatar Peter Maydell
Browse files

Merge remote-tracking branch 'remotes/juanquintela/tags/migration/20151112' into staging 



migration/next for 20151112

# gpg: Signature made Thu 12 Nov 2015 16:56:44 GMT using RSA key ID 5872D723
# gpg: Good signature from "Juan Quintela <quintela@redhat.com>"
# gpg:                 aka "Juan Quintela <quintela@trasno.org>"

* remotes/juanquintela/tags/migration/20151112:
  migration_init: Fix lock initialisation/make it explicit
  migrate-start-postcopy: Improve text
  Postcopy: Fix TP!=HP zero case
  Finish non-postcopiable iterative devices before package
  migration: Make 32bit linux compile with RDMA
  migration: print ram_addr_t as RAM_ADDR_FMT not %zx

Signed-off-by: default avatarPeter Maydell <peter.maydell@linaro.org>
parents b2df6a79 389775d1

hmp-commands.hx

+3 −1
Original line number Diff line number Diff line
@@ -1025,7 +1025,9 @@ ETEXI 
        .name       = "migrate_start_postcopy",

        .args_type  = "",

        .params     = "",

        .help       = "Switch migration to postcopy mode",

        .help       = "Followup to a migration command to switch the migration"

                      " to postcopy mode. The x-postcopy-ram capability must "

                      "be set before the original migration command.",

        .mhandler.cmd = hmp_migrate_start_postcopy,

    },

include/sysemu/sysemu.h

+1 −1
Original line number Diff line number Diff line
@@ -112,7 +112,7 @@ void qemu_savevm_state_header(QEMUFile *f); 
int qemu_savevm_state_iterate(QEMUFile *f, bool postcopy);

void qemu_savevm_state_cleanup(void);

void qemu_savevm_state_complete_postcopy(QEMUFile *f);

void qemu_savevm_state_complete_precopy(QEMUFile *f);

void qemu_savevm_state_complete_precopy(QEMUFile *f, bool iterable_only);

void qemu_savevm_state_pending(QEMUFile *f, uint64_t max_size,

                               uint64_t *res_non_postcopiable,

                               uint64_t *res_postcopiable);

migration/migration.c

+32 −33
Original line number Diff line number Diff line
@@ -768,7 +768,7 @@ void qmp_migrate_start_postcopy(Error **errp) 
    MigrationState *s = migrate_get_current();



    if (!migrate_postcopy_ram()) {

        error_setg(errp, "Enable postcopy with migration_set_capability before"

        error_setg(errp, "Enable postcopy with migrate_set_capability before"

                         " the start of migration");

        return;

    }
@@ -902,38 +902,31 @@ bool migration_in_postcopy(MigrationState *s) 
MigrationState *migrate_init(const MigrationParams *params)

{

    MigrationState *s = migrate_get_current();

    int64_t bandwidth_limit = s->bandwidth_limit;

    bool enabled_capabilities[MIGRATION_CAPABILITY_MAX];

    int64_t xbzrle_cache_size = s->xbzrle_cache_size;

    int compress_level = s->parameters[MIGRATION_PARAMETER_COMPRESS_LEVEL];

    int compress_thread_count =

            s->parameters[MIGRATION_PARAMETER_COMPRESS_THREADS];

    int decompress_thread_count =

            s->parameters[MIGRATION_PARAMETER_DECOMPRESS_THREADS];

    int x_cpu_throttle_initial =

            s->parameters[MIGRATION_PARAMETER_X_CPU_THROTTLE_INITIAL];

    int x_cpu_throttle_increment =

            s->parameters[MIGRATION_PARAMETER_X_CPU_THROTTLE_INCREMENT];



    memcpy(enabled_capabilities, s->enabled_capabilities,

           sizeof(enabled_capabilities));



    memset(s, 0, sizeof(*s));

    /*

     * Reinitialise all migration state, except

     * parameters/capabilities that the user set, and

     * locks.

     */

    s->bytes_xfer = 0;

    s->xfer_limit = 0;

    s->cleanup_bh = 0;

    s->file = NULL;

    s->state = MIGRATION_STATUS_NONE;

    s->params = *params;

    memcpy(s->enabled_capabilities, enabled_capabilities,

           sizeof(enabled_capabilities));

    s->xbzrle_cache_size = xbzrle_cache_size;

    s->rp_state.from_dst_file = NULL;

    s->rp_state.error = false;

    s->mbps = 0.0;

    s->downtime = 0;

    s->expected_downtime = 0;

    s->dirty_pages_rate = 0;

    s->dirty_bytes_rate = 0;

    s->setup_time = 0;

    s->dirty_sync_count = 0;

    s->start_postcopy = false;

    s->migration_thread_running = false;

    s->last_req_rb = NULL;



    s->parameters[MIGRATION_PARAMETER_COMPRESS_LEVEL] = compress_level;

    s->parameters[MIGRATION_PARAMETER_COMPRESS_THREADS] =

               compress_thread_count;

    s->parameters[MIGRATION_PARAMETER_DECOMPRESS_THREADS] =

               decompress_thread_count;

    s->parameters[MIGRATION_PARAMETER_X_CPU_THROTTLE_INITIAL] =

                x_cpu_throttle_initial;

    s->parameters[MIGRATION_PARAMETER_X_CPU_THROTTLE_INCREMENT] =

                x_cpu_throttle_increment;

    s->bandwidth_limit = bandwidth_limit;

    migrate_set_state(s, MIGRATION_STATUS_NONE, MIGRATION_STATUS_SETUP);



    QSIMPLEQ_INIT(&s->src_page_requests);
@@ -1428,6 +1421,12 @@ static int postcopy_start(MigrationState *ms, bool *old_vm_running) 
        goto fail;

    }



    /*

     * Cause any non-postcopiable, but iterative devices to

     * send out their final data.

     */

    qemu_savevm_state_complete_precopy(ms->file, true);



    /*

     * in Finish migrate and with the io-lock held everything should

     * be quiet, but we've potentially still got dirty pages and we
@@ -1471,7 +1470,7 @@ static int postcopy_start(MigrationState *ms, bool *old_vm_running) 
     */

    qemu_savevm_send_postcopy_listen(fb);



    qemu_savevm_state_complete_precopy(fb);

    qemu_savevm_state_complete_precopy(fb, false);

    qemu_savevm_send_ping(fb, 3);



    qemu_savevm_send_postcopy_run(fb);
@@ -1538,7 +1537,7 @@ static void migration_completion(MigrationState *s, int current_active_state, 
            ret = vm_stop_force_state(RUN_STATE_FINISH_MIGRATE);

            if (ret >= 0) {

                qemu_file_set_rate_limit(s->file, INT64_MAX);

                qemu_savevm_state_complete_precopy(s->file);

                qemu_savevm_state_complete_precopy(s->file, false);

            }

        }

        qemu_mutex_unlock_iothread();

migration/ram.c

+4 −3
Original line number Diff line number Diff line
@@ -1184,7 +1184,8 @@ int ram_save_queue_pages(MigrationState *ms, const char *rbname, 
    }

    trace_ram_save_queue_pages(ramblock->idstr, start, len);

    if (start+len > ramblock->used_length) {

        error_report("%s request overrun start=%zx len=%zx blocklen=%zx",

        error_report("%s request overrun start=" RAM_ADDR_FMT " len="

                     RAM_ADDR_FMT " blocklen=" RAM_ADDR_FMT,

                     __func__, start, len, ramblock->used_length);

        goto err;

    }
@@ -1845,7 +1846,7 @@ int ram_discard_range(MigrationIncomingState *mis, 
        ret = postcopy_ram_discard_range(mis, host_startaddr, length);

    } else {

        error_report("ram_discard_range: Overrun block '%s' (%" PRIu64

                     "/%zu/%zu)",

                     "/%zx/" RAM_ADDR_FMT")",

                     block_name, start, length, rb->used_length);

    }
@@ -2273,6 +2274,7 @@ static int ram_load_postcopy(QEMUFile *f) 
    /* Temporary page that is later 'placed' */

    void *postcopy_host_page = postcopy_get_tmp_page(mis);

    void *last_host = NULL;

    bool all_zero = false;



    while (!ret && !(flags & RAM_SAVE_FLAG_EOS)) {

        ram_addr_t addr;
@@ -2280,7 +2282,6 @@ static int ram_load_postcopy(QEMUFile *f) 
        void *page_buffer = NULL;

        void *place_source = NULL;

        uint8_t ch;

        bool all_zero = false;



        addr = qemu_get_be64(f);

        flags = addr & ~TARGET_PAGE_MASK;

migration/rdma.c

+1 −1
Original line number Diff line number Diff line
@@ -577,7 +577,7 @@ static int rdma_add_block(RDMAContext *rdma, const char *block_name, 
    block->is_ram_block = local->init ? false : true;



    if (rdma->blockmap) {

        g_hash_table_insert(rdma->blockmap, (void *) block_offset, block);

        g_hash_table_insert(rdma->blockmap, (void *)(uintptr_t)block_offset, block);

    }



    trace_rdma_add_block(block_name, local->nb_blocks,