Commit 21dab18b authored by Peter Maydell's avatar Peter Maydell
Browse files

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



migration/next for 20171029

# gpg: Signature made Sun 29 Oct 2017 13:07:43 GMT
# gpg:                using RSA key 0xF487EF185872D723
# 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/20171029:
  tests: check that migration parameters are really assigned
  tests: Don't abuse global_qtest
  tests: Factorize out migrate_test_start/end
  tests: Refactor setting of parameters/capabilities
  tests: rename postcopy-test to migration-test
  migration: Make xbzrle_cache_size a migration parameter
  migration: No need to return the size of the cache
  migration: Don't play games with the requested cache size
  migration: Make sure that we pass the right cache size

Signed-off-by: default avatarPeter Maydell <peter.maydell@linaro.org>
parents ab752f23 56b4a42a

MAINTAINERS

+1 −0
Original line number Diff line number Diff line
@@ -1563,6 +1563,7 @@ F: include/migration/ 
F: migration/

F: scripts/vmstate-static-checker.py

F: tests/vmstate-static-checker-data/

F: tests/migration-test.c

F: docs/devel/migration.txt

F: qapi/migration.json

hmp.c

+14 −0
Original line number Diff line number Diff line
@@ -342,6 +342,9 @@ void hmp_info_migrate_parameters(Monitor *mon, const QDict *qdict) 
        monitor_printf(mon, "%s: %" PRId64 "\n",

            MigrationParameter_str(MIGRATION_PARAMETER_X_MULTIFD_PAGE_COUNT),

            params->x_multifd_page_count);

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

            MigrationParameter_str(MIGRATION_PARAMETER_XBZRLE_CACHE_SIZE),

            params->xbzrle_cache_size);

    }



    qapi_free_MigrationParameters(params);
@@ -1578,6 +1581,7 @@ void hmp_migrate_set_parameter(Monitor *mon, const QDict *qdict) 
    Visitor *v = string_input_visitor_new(valuestr);

    MigrateSetParameters *p = g_new0(MigrateSetParameters, 1);

    uint64_t valuebw = 0;

    uint64_t cache_size;

    Error *err = NULL;

    int val, ret;
@@ -1653,6 +1657,16 @@ void hmp_migrate_set_parameter(Monitor *mon, const QDict *qdict) 
        p->has_x_multifd_page_count = true;

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

        break;

    case MIGRATION_PARAMETER_XBZRLE_CACHE_SIZE:

        p->has_xbzrle_cache_size = true;

        visit_type_size(v, param, &cache_size, &err);

        if (err || cache_size > INT64_MAX

            || (size_t)cache_size != cache_size) {

            error_setg(&err, "Invalid size %s", valuestr);

            break;

        }

        p->xbzrle_cache_size = cache_size;

        break;

    default:

        assert(0);

    }

migration/migration.c

+32 −13
Original line number Diff line number Diff line
@@ -71,7 +71,7 @@ 
#define DEFAULT_MIGRATE_CPU_THROTTLE_INCREMENT 10



/* Migration XBZRLE default cache size */

#define DEFAULT_MIGRATE_CACHE_SIZE (64 * 1024 * 1024)

#define DEFAULT_MIGRATE_XBZRLE_CACHE_SIZE (64 * 1024 * 1024)



/* The delay time (in ms) between two COLO checkpoints

 * Note: Please change this default value to 10000 when we support hybrid mode.
@@ -515,6 +515,8 @@ MigrationParameters *qmp_query_migrate_parameters(Error **errp) 
    params->x_multifd_channels = s->parameters.x_multifd_channels;

    params->has_x_multifd_page_count = true;

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

    params->has_xbzrle_cache_size = true;

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



    return params;

}
@@ -817,6 +819,16 @@ static bool migrate_params_check(MigrationParameters *params, Error **errp) 
        return false;

    }



    if (params->has_xbzrle_cache_size &&

        (params->xbzrle_cache_size < qemu_target_page_size() ||

         !is_power_of_2(params->xbzrle_cache_size))) {

        error_setg(errp, QERR_INVALID_PARAMETER_VALUE,

                   "xbzrle_cache_size",

                   "is invalid, it should be bigger than target page size"

                   " and a power of two");

        return false;

    }



    return true;

}
@@ -878,9 +890,12 @@ static void migrate_params_test_apply(MigrateSetParameters *params, 
    if (params->has_x_multifd_page_count) {

        dest->x_multifd_page_count = params->x_multifd_page_count;

    }

    if (params->has_xbzrle_cache_size) {

        dest->xbzrle_cache_size = params->xbzrle_cache_size;

    }

}



static void migrate_params_apply(MigrateSetParameters *params)

static void migrate_params_apply(MigrateSetParameters *params, Error **errp)

{

    MigrationState *s = migrate_get_current();
@@ -946,6 +961,10 @@ static void migrate_params_apply(MigrateSetParameters *params) 
    if (params->has_x_multifd_page_count) {

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

    }

    if (params->has_xbzrle_cache_size) {

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

        xbzrle_cache_resize(params->xbzrle_cache_size, errp);

    }

}



void qmp_migrate_set_parameters(MigrateSetParameters *params, Error **errp)
@@ -974,7 +993,7 @@ void qmp_migrate_set_parameters(MigrateSetParameters *params, Error **errp) 
        return;

    }



    migrate_params_apply(params);

    migrate_params_apply(params, errp);

}
@@ -1405,15 +1424,12 @@ void qmp_migrate_continue(MigrationStatus state, Error **errp) 


void qmp_migrate_set_cache_size(int64_t value, Error **errp)

{

    MigrationState *s = migrate_get_current();

    int64_t new_size;



    new_size = xbzrle_cache_resize(value, errp);

    if (new_size < 0) {

        return;

    }

    MigrateSetParameters p = {

        .has_xbzrle_cache_size = true,

        .xbzrle_cache_size = value,

    };



    s->xbzrle_cache_size = new_size;

    qmp_migrate_set_parameters(&p, errp);

}



int64_t qmp_query_migrate_cache_size(Error **errp)
@@ -1589,7 +1605,7 @@ int64_t migrate_xbzrle_cache_size(void) 


    s = migrate_get_current();



    return s->xbzrle_cache_size;

    return s->parameters.xbzrle_cache_size;

}



bool migrate_use_block(void)
@@ -2407,6 +2423,9 @@ static Property migration_properties[] = { 
    DEFINE_PROP_INT64("x-multifd-page-count", MigrationState,

                      parameters.x_multifd_page_count,

                      DEFAULT_MIGRATE_MULTIFD_PAGE_COUNT),

    DEFINE_PROP_SIZE("xbzrle-cache-size", MigrationState,

                      parameters.xbzrle_cache_size,

                      DEFAULT_MIGRATE_XBZRLE_CACHE_SIZE),



    /* Migration capabilities */

    DEFINE_PROP_MIG_CAP("x-xbzrle", MIGRATION_CAPABILITY_XBZRLE),
@@ -2450,7 +2469,6 @@ static void migration_instance_init(Object *obj) 
    MigrationParameters *params = &ms->parameters;



    ms->state = MIGRATION_STATUS_NONE;

    ms->xbzrle_cache_size = DEFAULT_MIGRATE_CACHE_SIZE;

    ms->mbps = -1;

    qemu_sem_init(&ms->pause_sem, 0);

    qemu_mutex_init(&ms->error_mutex);
@@ -2470,6 +2488,7 @@ static void migration_instance_init(Object *obj) 
    params->has_block_incremental = true;

    params->has_x_multifd_channels = true;

    params->has_x_multifd_page_count = true;

    params->has_xbzrle_cache_size = true;

}



/*

migration/migration.h

+0 −1
Original line number Diff line number Diff line
@@ -107,7 +107,6 @@ struct MigrationState 
    int64_t downtime;

    int64_t expected_downtime;

    bool enabled_capabilities[MIGRATION_CAPABILITY__MAX];

    int64_t xbzrle_cache_size;

    int64_t setup_time;



    /* Flag set once the migration has been asked to enter postcopy */

migration/page_cache.c

+7 −5
Original line number Diff line number Diff line
@@ -58,6 +58,13 @@ PageCache *cache_init(int64_t new_size, size_t page_size, Error **errp) 
        return NULL;

    }



    /* round down to the nearest power of 2 */

    if (!is_power_of_2(num_pages)) {

        error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "cache size",

                   "is not a power of two number of pages");

        return NULL;

    }



    /* We prefer not to abort if there is no memory */

    cache = g_try_malloc(sizeof(*cache));

    if (!cache) {
@@ -65,11 +72,6 @@ PageCache *cache_init(int64_t new_size, size_t page_size, Error **errp) 
                   "Failed to allocate cache");

        return NULL;

    }

    /* round down to the nearest power of 2 */

    if (!is_power_of_2(num_pages)) {

        num_pages = pow2floor(num_pages);

        DPRINTF("rounding down to %" PRId64 "\n", num_pages);

    }

    cache->page_size = page_size;

    cache->num_items = 0;

    cache->max_num_items = num_pages;