Commit 32c7e0ab authored by Peter Maydell's avatar Peter Maydell
Browse files

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



migration/next for 20170421

# gpg: Signature made Fri 21 Apr 2017 11:28:13 BST
# 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/20170421: (65 commits)
  hmp: info migrate_parameters format tunes
  hmp: info migrate_capability format tunes
  migration: rename max_size to threshold_size
  migration: set current_active_state once
  virtio-rng: stop virtqueue while the CPU is stopped
  migration: don't close a file descriptor while it can be in use
  ram: Remove migration_bitmap_extend()
  migration: Disable hotplug/unplug during migration
  qdev: Move qdev_unplug() to qdev-monitor.c
  qdev: Export qdev_hot_removed
  qdev: qdev_hotplug is really a bool
  migration: Remove MigrationState parameter from migration_is_idle()
  ram: Use RAMBitmap type for coherence
  ram: rename last_ram_offset() last_ram_pages()
  ram: Use ramblock and page offset instead of absolute offset
  ram: Change offset field in PageSearchStatus to page
  ram: Remember last_page instead of last_offset
  ram: Use page number instead of an address for the bitmap operations
  ram: reorganize last_sent_block
  ram: ram_discard_range() don't use the mis parameter
  ...

Signed-off-by: default avatarPeter Maydell <peter.maydell@linaro.org>
parents af7ec403 2c02468c

exec.c

+5 −6
Original line number Diff line number Diff line
@@ -1528,7 +1528,7 @@ static ram_addr_t find_ram_offset(ram_addr_t size) 
    return offset;

}



ram_addr_t last_ram_offset(void)

unsigned long last_ram_page(void)

{

    RAMBlock *block;

    ram_addr_t last = 0;
@@ -1538,7 +1538,7 @@ ram_addr_t last_ram_offset(void) 
        last = MAX(last, block->offset + block->max_length);

    }

    rcu_read_unlock();

    return last;

    return last >> TARGET_PAGE_BITS;

}



static void qemu_ram_setup_dump(void *addr, ram_addr_t size)
@@ -1727,7 +1727,7 @@ static void ram_block_add(RAMBlock *new_block, Error **errp) 
    ram_addr_t old_ram_size, new_ram_size;

    Error *err = NULL;



    old_ram_size = last_ram_offset() >> TARGET_PAGE_BITS;

    old_ram_size = last_ram_page();



    qemu_mutex_lock_ramlist();

    new_block->offset = find_ram_offset(new_block->max_length);
@@ -1758,7 +1758,6 @@ static void ram_block_add(RAMBlock *new_block, Error **errp) 
    new_ram_size = MAX(old_ram_size,

              (new_block->offset + new_block->max_length) >> TARGET_PAGE_BITS);

    if (new_ram_size > old_ram_size) {

        migration_bitmap_extend(old_ram_size, new_ram_size);

        dirty_memory_extend(old_ram_size, new_ram_size);

    }

    /* Keep the list sorted from biggest to smallest block.  Unlike QTAILQ,
@@ -3307,9 +3306,9 @@ int cpu_memory_rw_debug(CPUState *cpu, target_ulong addr, 
 * Allows code that needs to deal with migration bitmaps etc to still be built

 * target independent.

 */

size_t qemu_target_page_bits(void)

size_t qemu_target_page_size(void)

{

    return TARGET_PAGE_BITS;

    return TARGET_PAGE_SIZE;

}



#endif

hmp.c

+14 −15
Original line number Diff line number Diff line
@@ -215,6 +215,9 @@ void hmp_info_migrate(Monitor *mon, const QDict *qdict) 
                       info->ram->normal_bytes >> 10);

        monitor_printf(mon, "dirty sync count: %" PRIu64 "\n",

                       info->ram->dirty_sync_count);

        monitor_printf(mon, "page size: %" PRIu64 " kbytes\n",

                       info->ram->page_size >> 10);



        if (info->ram->dirty_pages_rate) {

            monitor_printf(mon, "dirty pages rate: %" PRIu64 " pages\n",

                           info->ram->dirty_pages_rate);
@@ -265,13 +268,11 @@ void hmp_info_migrate_capabilities(Monitor *mon, const QDict *qdict) 
    caps = qmp_query_migrate_capabilities(NULL);



    if (caps) {

        monitor_printf(mon, "capabilities: ");

        for (cap = caps; cap; cap = cap->next) {

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

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

                           MigrationCapability_lookup[cap->value->capability],

                           cap->value->state ? "on" : "off");

        }

        monitor_printf(mon, "\n");

    }



    qapi_free_MigrationCapabilityStatusList(caps);
@@ -284,46 +285,44 @@ void hmp_info_migrate_parameters(Monitor *mon, const QDict *qdict) 
    params = qmp_query_migrate_parameters(NULL);



    if (params) {

        monitor_printf(mon, "parameters:");

        assert(params->has_compress_level);

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

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

            MigrationParameter_lookup[MIGRATION_PARAMETER_COMPRESS_LEVEL],

            params->compress_level);

        assert(params->has_compress_threads);

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

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

            MigrationParameter_lookup[MIGRATION_PARAMETER_COMPRESS_THREADS],

            params->compress_threads);

        assert(params->has_decompress_threads);

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

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

            MigrationParameter_lookup[MIGRATION_PARAMETER_DECOMPRESS_THREADS],

            params->decompress_threads);

        assert(params->has_cpu_throttle_initial);

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

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

            MigrationParameter_lookup[MIGRATION_PARAMETER_CPU_THROTTLE_INITIAL],

            params->cpu_throttle_initial);

        assert(params->has_cpu_throttle_increment);

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

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

            MigrationParameter_lookup[MIGRATION_PARAMETER_CPU_THROTTLE_INCREMENT],

            params->cpu_throttle_increment);

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

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

            MigrationParameter_lookup[MIGRATION_PARAMETER_TLS_CREDS],

            params->has_tls_creds ? params->tls_creds : "");

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

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

            MigrationParameter_lookup[MIGRATION_PARAMETER_TLS_HOSTNAME],

            params->has_tls_hostname ? params->tls_hostname : "");

        assert(params->has_max_bandwidth);

        monitor_printf(mon, " %s: %" PRId64 " bytes/second",

        monitor_printf(mon, "%s: %" PRId64 " bytes/second\n",

            MigrationParameter_lookup[MIGRATION_PARAMETER_MAX_BANDWIDTH],

            params->max_bandwidth);

        assert(params->has_downtime_limit);

        monitor_printf(mon, " %s: %" PRId64 " milliseconds",

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

            MigrationParameter_lookup[MIGRATION_PARAMETER_DOWNTIME_LIMIT],

            params->downtime_limit);

        assert(params->has_x_checkpoint_delay);

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

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

            MigrationParameter_lookup[MIGRATION_PARAMETER_X_CHECKPOINT_DELAY],

            params->x_checkpoint_delay);

        monitor_printf(mon, "\n");

    }



    qapi_free_MigrationParameters(params);

hw/core/qdev.c

+3 −37
Original line number Diff line number Diff line
@@ -39,9 +39,9 @@ 
#include "qapi-event.h"

#include "migration/migration.h"



int qdev_hotplug = 0;

bool qdev_hotplug = false;

static bool qdev_hot_added = false;

static bool qdev_hot_removed = false;

bool qdev_hot_removed = false;



const VMStateDescription *qdev_get_vmsd(DeviceState *dev)

{
@@ -271,40 +271,6 @@ HotplugHandler *qdev_get_hotplug_handler(DeviceState *dev) 
    return hotplug_ctrl;

}



void qdev_unplug(DeviceState *dev, Error **errp)

{

    DeviceClass *dc = DEVICE_GET_CLASS(dev);

    HotplugHandler *hotplug_ctrl;

    HotplugHandlerClass *hdc;



    if (dev->parent_bus && !qbus_is_hotpluggable(dev->parent_bus)) {

        error_setg(errp, QERR_BUS_NO_HOTPLUG, dev->parent_bus->name);

        return;

    }



    if (!dc->hotpluggable) {

        error_setg(errp, QERR_DEVICE_NO_HOTPLUG,

                   object_get_typename(OBJECT(dev)));

        return;

    }



    qdev_hot_removed = true;



    hotplug_ctrl = qdev_get_hotplug_handler(dev);

    /* hotpluggable device MUST have HotplugHandler, if it doesn't

     * then something is very wrong with it */

    g_assert(hotplug_ctrl);



    /* If device supports async unplug just request it to be done,

     * otherwise just remove it synchronously */

    hdc = HOTPLUG_HANDLER_GET_CLASS(hotplug_ctrl);

    if (hdc->unplug_request) {

        hotplug_handler_unplug_request(hotplug_ctrl, dev, errp);

    } else {

        hotplug_handler_unplug(hotplug_ctrl, dev, errp);

    }

}



static int qdev_reset_one(DeviceState *dev, void *opaque)

{

    device_reset(dev);
@@ -385,7 +351,7 @@ void qdev_machine_creation_done(void) 
     * ok, initial machine setup is done, starting from now we can

     * only create hotpluggable devices

     */

    qdev_hotplug = 1;

    qdev_hotplug = true;

}



bool qdev_machine_modified(void)

hw/virtio/trace-events

+3 −0
Original line number Diff line number Diff line
@@ -11,8 +11,11 @@ virtio_set_status(void *vdev, uint8_t val) "vdev %p val %u" 


# hw/virtio/virtio-rng.c

virtio_rng_guest_not_ready(void *rng) "rng %p: guest not ready"

virtio_rng_cpu_is_stopped(void *rng, int size) "rng %p: cpu is stopped, dropping %d bytes"

virtio_rng_popped(void *rng) "rng %p: elem popped"

virtio_rng_pushed(void *rng, size_t len) "rng %p: %zd bytes pushed"

virtio_rng_request(void *rng, size_t size, unsigned quota) "rng %p: %zd bytes requested, %u bytes quota left"

virtio_rng_vm_state_change(void *rng, int running, int state) "rng %p: state change to running %d state %d"



# hw/virtio/virtio-balloon.c

#

hw/virtio/virtio-rng.c

+23 −6
Original line number Diff line number Diff line
@@ -53,6 +53,15 @@ static void chr_read(void *opaque, const void *buf, size_t size) 
        return;

    }



    /* we can't modify the virtqueue until

     * our state is fully synced

     */



    if (!runstate_check(RUN_STATE_RUNNING)) {

        trace_virtio_rng_cpu_is_stopped(vrng, size);

        return;

    }



    vrng->quota_remaining -= size;



    offset = 0;
@@ -61,6 +70,7 @@ static void chr_read(void *opaque, const void *buf, size_t size) 
        if (!elem) {

            break;

        }

        trace_virtio_rng_popped(vrng);

        len = iov_from_buf(elem->in_sg, elem->in_num,

                           0, buf + offset, size - offset);

        offset += len;
@@ -120,17 +130,21 @@ static uint64_t get_features(VirtIODevice *vdev, uint64_t f, Error **errp) 
    return f;

}



static int virtio_rng_post_load(void *opaque, int version_id)

static void virtio_rng_vm_state_change(void *opaque, int running,

                                       RunState state)

{

    VirtIORNG *vrng = opaque;



    trace_virtio_rng_vm_state_change(vrng, running, state);



    /* We may have an element ready but couldn't process it due to a quota

     * limit.  Make sure to try again after live migration when the quota may

     * have been reset.

     * limit or because CPU was stopped.  Make sure to try again when the

     * CPU restart.

     */

    virtio_rng_process(vrng);



    return 0;

    if (running && is_guest_ready(vrng)) {

        virtio_rng_process(vrng);

    }

}



static void check_rate_limit(void *opaque)
@@ -198,6 +212,9 @@ static void virtio_rng_device_realize(DeviceState *dev, Error **errp) 
    vrng->rate_limit_timer = timer_new_ms(QEMU_CLOCK_VIRTUAL,

                                               check_rate_limit, vrng);

    vrng->activate_timer = true;



    vrng->vmstate = qemu_add_vm_change_state_handler(virtio_rng_vm_state_change,

                                                     vrng);

}



static void virtio_rng_device_unrealize(DeviceState *dev, Error **errp)
@@ -205,6 +222,7 @@ static void virtio_rng_device_unrealize(DeviceState *dev, Error **errp) 
    VirtIODevice *vdev = VIRTIO_DEVICE(dev);

    VirtIORNG *vrng = VIRTIO_RNG(dev);



    qemu_del_vm_change_state_handler(vrng->vmstate);

    timer_del(vrng->rate_limit_timer);

    timer_free(vrng->rate_limit_timer);

    virtio_cleanup(vdev);
@@ -218,7 +236,6 @@ static const VMStateDescription vmstate_virtio_rng = { 
        VMSTATE_VIRTIO_DEVICE,

        VMSTATE_END_OF_LIST()

    },

    .post_load =  virtio_rng_post_load,

};



static Property virtio_rng_properties[] = {