Commit 47995026 authored by Vladimir Sementsov-Ogievskiy's avatar Vladimir Sementsov-Ogievskiy Committed by John Snow
Browse files

migration: introduce postcopy-only pending 



There would be savevm states (dirty-bitmap) which can migrate only in
postcopy stage. The corresponding pending is introduced here.

Signed-off-by: default avatarVladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
Reviewed-by: default avatarDr. David Alan Gilbert <dgilbert@redhat.com>
Message-id: 20180313180320.339796-6-vsementsov@virtuozzo.com
parent 4f43e953

hw/s390x/s390-stattrib.c

+4 −3
Original line number Diff line number Diff line
@@ -183,15 +183,16 @@ static int cmma_save_setup(QEMUFile *f, void *opaque) 
}



static void cmma_save_pending(QEMUFile *f, void *opaque, uint64_t max_size,

                             uint64_t *non_postcopiable_pending,

                             uint64_t *postcopiable_pending)

                              uint64_t *res_precopy_only,

                              uint64_t *res_compatible,

                              uint64_t *res_postcopy_only)

{

    S390StAttribState *sas = S390_STATTRIB(opaque);

    S390StAttribClass *sac = S390_STATTRIB_GET_CLASS(sas);

    long long res = sac->get_dirtycount(sas);



    if (res >= 0) {

        *non_postcopiable_pending += res;

        *res_precopy_only += res;

    }

}

include/migration/register.h

+15 −2
Original line number Diff line number Diff line
@@ -37,8 +37,21 @@ typedef struct SaveVMHandlers { 
    int (*save_setup)(QEMUFile *f, void *opaque);

    void (*save_live_pending)(QEMUFile *f, void *opaque,

                              uint64_t threshold_size,

                              uint64_t *non_postcopiable_pending,

                              uint64_t *postcopiable_pending);

                              uint64_t *res_precopy_only,

                              uint64_t *res_compatible,

                              uint64_t *res_postcopy_only);

    /* Note for save_live_pending:

     * - res_precopy_only is for data which must be migrated in precopy phase

     *     or in stopped state, in other words - before target vm start

     * - res_compatible is for data which may be migrated in any phase

     * - res_postcopy_only is for data which must be migrated in postcopy phase

     *     or in stopped state, in other words - after source vm stop

     *

     * Sum of res_postcopy_only, res_compatible and res_postcopy_only is the

     * whole amount of pending data.

     */





    LoadStateHandler *load_state;

    int (*load_setup)(QEMUFile *f, void *opaque);

    int (*load_cleanup)(void *opaque);

migration/block.c

+4 −3
Original line number Diff line number Diff line
@@ -864,8 +864,9 @@ static int block_save_complete(QEMUFile *f, void *opaque) 
}



static void block_save_pending(QEMUFile *f, void *opaque, uint64_t max_size,

                               uint64_t *non_postcopiable_pending,

                               uint64_t *postcopiable_pending)

                               uint64_t *res_precopy_only,

                               uint64_t *res_compatible,

                               uint64_t *res_postcopy_only)

{

    /* Estimate pending number of bytes to send */

    uint64_t pending;
@@ -886,7 +887,7 @@ static void block_save_pending(QEMUFile *f, void *opaque, uint64_t max_size, 


    DPRINTF("Enter save live pending  %" PRIu64 "\n", pending);

    /* We don't do postcopy */

    *non_postcopiable_pending += pending;

    *res_precopy_only += pending;

}



static int block_load(QEMUFile *f, void *opaque, int version_id)

migration/migration.c

+6 −6
Original line number Diff line number Diff line
@@ -2242,20 +2242,20 @@ typedef enum { 
 */

static MigIterateState migration_iteration_run(MigrationState *s)

{

    uint64_t pending_size, pend_post, pend_nonpost;

    uint64_t pending_size, pend_pre, pend_compat, pend_post;

    bool in_postcopy = s->state == MIGRATION_STATUS_POSTCOPY_ACTIVE;



    qemu_savevm_state_pending(s->to_dst_file, s->threshold_size,

                              &pend_nonpost, &pend_post);

    pending_size = pend_nonpost + pend_post;

    qemu_savevm_state_pending(s->to_dst_file, s->threshold_size, &pend_pre,

                              &pend_compat, &pend_post);

    pending_size = pend_pre + pend_compat + pend_post;



    trace_migrate_pending(pending_size, s->threshold_size,

                          pend_post, pend_nonpost);

                          pend_pre, pend_compat, pend_post);



    if (pending_size && pending_size >= s->threshold_size) {

        /* Still a significant amount to transfer */

        if (migrate_postcopy() && !in_postcopy &&

            pend_nonpost <= s->threshold_size &&

            pend_pre <= s->threshold_size &&

            atomic_read(&s->start_postcopy)) {

            if (postcopy_start(s)) {

                error_report("%s: postcopy failed to start", __func__);

migration/ram.c

+5 −4
Original line number Diff line number Diff line
@@ -2370,8 +2370,9 @@ static int ram_save_complete(QEMUFile *f, void *opaque) 
}



static void ram_save_pending(QEMUFile *f, void *opaque, uint64_t max_size,

                             uint64_t *non_postcopiable_pending,

                             uint64_t *postcopiable_pending)

                             uint64_t *res_precopy_only,

                             uint64_t *res_compatible,

                             uint64_t *res_postcopy_only)

{

    RAMState **temp = opaque;

    RAMState *rs = *temp;
@@ -2391,9 +2392,9 @@ static void ram_save_pending(QEMUFile *f, void *opaque, uint64_t max_size, 


    if (migrate_postcopy_ram()) {

        /* We can do postcopy, and all the data is postcopiable */

        *postcopiable_pending += remaining_size;

        *res_compatible += remaining_size;

    } else {

        *non_postcopiable_pending += remaining_size;

        *res_precopy_only += remaining_size;

    }

}