Commit 54906fe0 authored by Peter Maydell's avatar Peter Maydell
Browse files

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



migration/next for 20180822

# gpg: Signature made Wed 22 Aug 2018 12:07:59 BST
# gpg:                using RSA key F487EF185872D723
# gpg: Good signature from "Juan Quintela <quintela@redhat.com>"
# gpg:                 aka "Juan Quintela <quintela@trasno.org>"
# Primary key fingerprint: 1899 FF8E DEBF 58CC EE03  4B82 F487 EF18 5872 D723

* remotes/juanquintela/tags/migration/20180822-1:
  migration: hold the lock only if it is really needed
  migration: move handle of zero page to the thread
  migration: drop the return value of do_compress_ram_page
  migration: introduce save_zero_page_to_file
  migration: fix counting normal page for compression
  migration: do not wait for free thread
  migration: poll the cm event for destination qemu
  tests/migration-test: Silence the kvm_hv message by default
  migration: implement the shutdown for RDMA QIOChannel
  migration: poll the cm event while wait RDMA work request completion
  migration: invoke qio_channel_yield only when qemu_in_coroutine()
  migration: implement io_set_aio_fd_handler function for RDMA QIOChannel
  migration: Stop rdma yielding during incoming postcopy
  migration: implement bi-directional RDMA QIOChannel
  migration: create a dedicated connection for rdma return path
  migration: disable RDMA WRITE after postcopy started
  migrate/cpu-throttle: Add max-cpu-throttle migration parameter
  docs/migration: Clarify pre_load in subsections
  migration: Correctly handle subsections with no 'needed' function
  qapi/migration.json: fix the description for "query-migrate" output

Signed-off-by: default avatarPeter Maydell <peter.maydell@linaro.org>
parents 1dfb85a8 ae526e32

docs/devel/migration.rst

+9 −6
Original line number Diff line number Diff line
@@ -240,10 +240,13 @@ should succeed even with the data missing. To support this the 
subsection can be connected to a device property and from there

to a versioned machine type.



One important note is that the post_load() function is called "after"

loading all subsections, because a newer subsection could change same

value that it uses.  A flag, and the combination of pre_load and post_load

can be used to detect whether a subsection was loaded, and to

The 'pre_load' and 'post_load' functions on subsections are only

called if the subsection is loaded.



One important note is that the outer post_load() function is called "after"

loading all subsections, because a newer subsection could change the same

value that it uses.  A flag, and the combination of outer pre_load and

post_load can be used to detect whether a subsection was loaded, and to

fall back on default behaviour when the subsection isn't present.



Example:
@@ -315,8 +318,8 @@ For example: 
      the property to false.

   c) Add a static bool  support_foo function that tests the property.

   d) Add a subsection with a .needed set to the support_foo function

   e) (potentially) Add a pre_load that sets up a default value for 'foo'

      to be used if the subsection isn't loaded.

   e) (potentially) Add an outer pre_load that sets up a default value

      for 'foo' to be used if the subsection isn't loaded.



Now that subsection will not be generated when using an older

machine type and the migration stream will be accepted by older

hmp.c

+16 −0
Original line number Diff line number Diff line
@@ -327,6 +327,10 @@ void hmp_info_migrate_parameters(Monitor *mon, const QDict *qdict) 
        monitor_printf(mon, "%s: %u\n",

            MigrationParameter_str(MIGRATION_PARAMETER_COMPRESS_THREADS),

            params->compress_threads);

        assert(params->has_compress_wait_thread);

        monitor_printf(mon, "%s: %s\n",

            MigrationParameter_str(MIGRATION_PARAMETER_COMPRESS_WAIT_THREAD),

            params->compress_wait_thread ? "on" : "off");

        assert(params->has_decompress_threads);

        monitor_printf(mon, "%s: %u\n",

            MigrationParameter_str(MIGRATION_PARAMETER_DECOMPRESS_THREADS),
@@ -339,6 +343,10 @@ void hmp_info_migrate_parameters(Monitor *mon, const QDict *qdict) 
        monitor_printf(mon, "%s: %u\n",

            MigrationParameter_str(MIGRATION_PARAMETER_CPU_THROTTLE_INCREMENT),

            params->cpu_throttle_increment);

        assert(params->has_max_cpu_throttle);

        monitor_printf(mon, "%s: %u\n",

            MigrationParameter_str(MIGRATION_PARAMETER_MAX_CPU_THROTTLE),

            params->max_cpu_throttle);

        assert(params->has_tls_creds);

        monitor_printf(mon, "%s: '%s'\n",

            MigrationParameter_str(MIGRATION_PARAMETER_TLS_CREDS),
@@ -1647,6 +1655,10 @@ void hmp_migrate_set_parameter(Monitor *mon, const QDict *qdict) 
        p->has_compress_threads = true;

        visit_type_int(v, param, &p->compress_threads, &err);

        break;

    case MIGRATION_PARAMETER_COMPRESS_WAIT_THREAD:

        p->has_compress_wait_thread = true;

        visit_type_bool(v, param, &p->compress_wait_thread, &err);

        break;

    case MIGRATION_PARAMETER_DECOMPRESS_THREADS:

        p->has_decompress_threads = true;

        visit_type_int(v, param, &p->decompress_threads, &err);
@@ -1659,6 +1671,10 @@ void hmp_migrate_set_parameter(Monitor *mon, const QDict *qdict) 
        p->has_cpu_throttle_increment = true;

        visit_type_int(v, param, &p->cpu_throttle_increment, &err);

        break;

    case MIGRATION_PARAMETER_MAX_CPU_THROTTLE:

        p->has_max_cpu_throttle = true;

        visit_type_int(v, param, &p->max_cpu_throttle, &err);

        break;

    case MIGRATION_PARAMETER_TLS_CREDS:

        p->has_tls_creds = true;

        p->tls_creds = g_new0(StrOrNull, 1);

include/qemu/queue.h

+1 −0
Original line number Diff line number Diff line
@@ -341,6 +341,7 @@ struct { \ 
/*

 * Simple queue access methods.

 */

#define QSIMPLEQ_EMPTY_ATOMIC(head) (atomic_read(&((head)->sqh_first)) == NULL)

#define QSIMPLEQ_EMPTY(head)        ((head)->sqh_first == NULL)

#define QSIMPLEQ_FIRST(head)        ((head)->sqh_first)

#define QSIMPLEQ_NEXT(elm, field)   ((elm)->field.sqe_next)

migration/colo.c

+2 −0
Original line number Diff line number Diff line
@@ -534,6 +534,7 @@ void *colo_process_incoming_thread(void *opaque) 
    uint64_t value;

    Error *local_err = NULL;



    rcu_register_thread();

    qemu_sem_init(&mis->colo_incoming_sem, 0);



    migrate_set_state(&mis->state, MIGRATION_STATUS_ACTIVE,
@@ -666,5 +667,6 @@ out: 
    }

    migration_incoming_exit_colo();



    rcu_unregister_thread();

    return NULL;

}

migration/migration.c

+47 −2
Original line number Diff line number Diff line
@@ -71,6 +71,7 @@ 
/* Define default autoconverge cpu throttle migration parameters */

#define DEFAULT_MIGRATE_CPU_THROTTLE_INITIAL 20

#define DEFAULT_MIGRATE_CPU_THROTTLE_INCREMENT 10

#define DEFAULT_MIGRATE_MAX_CPU_THROTTLE 99



/* Migration XBZRLE default cache size */

#define DEFAULT_MIGRATE_XBZRLE_CACHE_SIZE (64 * 1024 * 1024)
@@ -389,6 +390,7 @@ static void process_incoming_migration_co(void *opaque) 
    int ret;



    assert(mis->from_src_file);

    mis->migration_incoming_co = qemu_coroutine_self();

    mis->largest_page_size = qemu_ram_pagesize_largest();

    postcopy_state_set(POSTCOPY_INCOMING_NONE);

    migrate_set_state(&mis->state, MIGRATION_STATUS_NONE,
@@ -418,7 +420,6 @@ static void process_incoming_migration_co(void *opaque) 


    /* we get COLO info, and know if we are in COLO mode */

    if (!ret && migration_incoming_enable_colo()) {

        mis->migration_incoming_co = qemu_coroutine_self();

        qemu_thread_create(&mis->colo_incoming_thread, "COLO incoming",

             colo_process_incoming_thread, mis, QEMU_THREAD_JOINABLE);

        mis->have_colo_incoming_thread = true;
@@ -442,6 +443,7 @@ static void process_incoming_migration_co(void *opaque) 
    }

    mis->bh = qemu_bh_new(process_incoming_migration_bh, mis);

    qemu_bh_schedule(mis->bh);

    mis->migration_incoming_co = NULL;

}



static void migration_incoming_setup(QEMUFile *f)
@@ -671,6 +673,8 @@ MigrationParameters *qmp_query_migrate_parameters(Error **errp) 
    params->compress_level = s->parameters.compress_level;

    params->has_compress_threads = true;

    params->compress_threads = s->parameters.compress_threads;

    params->has_compress_wait_thread = true;

    params->compress_wait_thread = s->parameters.compress_wait_thread;

    params->has_decompress_threads = true;

    params->decompress_threads = s->parameters.decompress_threads;

    params->has_cpu_throttle_initial = true;
@@ -697,6 +701,8 @@ MigrationParameters *qmp_query_migrate_parameters(Error **errp) 
    params->xbzrle_cache_size = s->parameters.xbzrle_cache_size;

    params->has_max_postcopy_bandwidth = true;

    params->max_postcopy_bandwidth = s->parameters.max_postcopy_bandwidth;

    params->has_max_cpu_throttle = true;

    params->max_cpu_throttle = s->parameters.max_cpu_throttle;



    return params;

}
@@ -1043,6 +1049,15 @@ static bool migrate_params_check(MigrationParameters *params, Error **errp) 
        return false;

    }



    if (params->has_max_cpu_throttle &&

        (params->max_cpu_throttle < params->cpu_throttle_initial ||

         params->max_cpu_throttle > 99)) {

        error_setg(errp, QERR_INVALID_PARAMETER_VALUE,

                   "max_cpu_throttle",

                   "an integer in the range of cpu_throttle_initial to 99");

        return false;

    }



    return true;

}
@@ -1061,6 +1076,10 @@ static void migrate_params_test_apply(MigrateSetParameters *params, 
        dest->compress_threads = params->compress_threads;

    }



    if (params->has_compress_wait_thread) {

        dest->compress_wait_thread = params->compress_wait_thread;

    }



    if (params->has_decompress_threads) {

        dest->decompress_threads = params->decompress_threads;

    }
@@ -1110,6 +1129,9 @@ static void migrate_params_test_apply(MigrateSetParameters *params, 
    if (params->has_max_postcopy_bandwidth) {

        dest->max_postcopy_bandwidth = params->max_postcopy_bandwidth;

    }

    if (params->has_max_cpu_throttle) {

        dest->max_cpu_throttle = params->max_cpu_throttle;

    }

}



static void migrate_params_apply(MigrateSetParameters *params, Error **errp)
@@ -1126,6 +1148,10 @@ static void migrate_params_apply(MigrateSetParameters *params, Error **errp) 
        s->parameters.compress_threads = params->compress_threads;

    }



    if (params->has_compress_wait_thread) {

        s->parameters.compress_wait_thread = params->compress_wait_thread;

    }



    if (params->has_decompress_threads) {

        s->parameters.decompress_threads = params->decompress_threads;

    }
@@ -1185,6 +1211,9 @@ static void migrate_params_apply(MigrateSetParameters *params, Error **errp) 
    if (params->has_max_postcopy_bandwidth) {

        s->parameters.max_postcopy_bandwidth = params->max_postcopy_bandwidth;

    }

    if (params->has_max_cpu_throttle) {

        s->parameters.max_cpu_throttle = params->max_cpu_throttle;

    }

}



void qmp_migrate_set_parameters(MigrateSetParameters *params, Error **errp)
@@ -1871,6 +1900,15 @@ int migrate_compress_threads(void) 
    return s->parameters.compress_threads;

}



int migrate_compress_wait_thread(void)

{

    MigrationState *s;



    s = migrate_get_current();



    return s->parameters.compress_wait_thread;

}



int migrate_decompress_threads(void)

{

    MigrationState *s;
@@ -1962,7 +2000,6 @@ static int64_t migrate_max_postcopy_bandwidth(void) 
    return s->parameters.max_postcopy_bandwidth;

}





bool migrate_use_block(void)

{

    MigrationState *s;
@@ -2104,6 +2141,7 @@ static void *source_return_path_thread(void *opaque) 
    int res;



    trace_source_return_path_thread_entry();

    rcu_register_thread();



retry:

    while (!ms->rp_state.error && !qemu_file_get_error(rp) &&
@@ -2243,6 +2281,7 @@ out: 
    trace_source_return_path_thread_end();

    ms->rp_state.from_dst_file = NULL;

    qemu_fclose(rp);

    rcu_unregister_thread();

    return NULL;

}
@@ -3131,6 +3170,8 @@ static Property migration_properties[] = { 
    DEFINE_PROP_UINT8("x-compress-threads", MigrationState,

                      parameters.compress_threads,

                      DEFAULT_MIGRATE_COMPRESS_THREAD_COUNT),

    DEFINE_PROP_BOOL("x-compress-wait-thread", MigrationState,

                      parameters.compress_wait_thread, true),

    DEFINE_PROP_UINT8("x-decompress-threads", MigrationState,

                      parameters.decompress_threads,

                      DEFAULT_MIGRATE_DECOMPRESS_THREAD_COUNT),
@@ -3160,6 +3201,9 @@ static Property migration_properties[] = { 
    DEFINE_PROP_SIZE("max-postcopy-bandwidth", MigrationState,

                      parameters.max_postcopy_bandwidth,

                      DEFAULT_MIGRATE_MAX_POSTCOPY_BANDWIDTH),

    DEFINE_PROP_UINT8("max-cpu-throttle", MigrationState,

                      parameters.max_cpu_throttle,

                      DEFAULT_MIGRATE_MAX_CPU_THROTTLE),



    /* Migration capabilities */

    DEFINE_PROP_MIG_CAP("x-xbzrle", MIGRATION_CAPABILITY_XBZRLE),
@@ -3230,6 +3274,7 @@ static void migration_instance_init(Object *obj) 
    params->has_x_multifd_page_count = true;

    params->has_xbzrle_cache_size = true;

    params->has_max_postcopy_bandwidth = true;

    params->has_max_cpu_throttle = true;



    qemu_sem_init(&ms->postcopy_pause_sem, 0);

    qemu_sem_init(&ms->postcopy_pause_rp_sem, 0);