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

Merge remote-tracking branch 'remotes/cohuck/tags/s390x-20150508' into staging 



Assorted s390x patches:
- updates for virtio-ccw and s390-virtio, making them more similar
  to virtio-pci
- improvements regarding per-vcpu interrupts and migration

# gpg: Signature made Fri May  8 09:45:09 2015 BST using RSA key ID C6F02FAF
# gpg: Good signature from "Cornelia Huck <huckc@linux.vnet.ibm.com>"
# gpg:                 aka "Cornelia Huck <cornelia.huck@de.ibm.com>"

* remotes/cohuck/tags/s390x-20150508:
  s390x/kvm: migrate vcpu interrupt state
  s390x: move fpu regs into a subsection of the vmstate
  s390x/kvm: use ioctl KVM_S390_IRQ for vcpu interrupts
  virtio-ccw: implement ->device_plugged
  virtio-ccw: change realization sequence
  s390-virtio: clear {used,avail}_event_idx on reset as well
  s390-virtio: use common features
  s390-virtio: Accommodate guests using virtqueues too early

Signed-off-by: default avatarPeter Maydell <peter.maydell@linaro.org>
parents f8340b36 3cda44f7

hw/s390x/s390-virtio-bus.c

+14 −14
Original line number Diff line number Diff line
@@ -77,10 +77,18 @@ void s390_virtio_reset_idx(VirtIOS390Device *dev) 
            VIRTIO_VRING_AVAIL_IDX_OFFS;

        address_space_stw(&address_space_memory, idx_addr, 0,

                          MEMTXATTRS_UNSPECIFIED, NULL);

        idx_addr = virtio_queue_get_avail_addr(dev->vdev, i) +

            virtio_queue_get_avail_size(dev->vdev, i);

        address_space_stw(&address_space_memory, idx_addr, 0,

                          MEMTXATTRS_UNSPECIFIED, NULL);

        idx_addr = virtio_queue_get_used_addr(dev->vdev, i) +

            VIRTIO_VRING_USED_IDX_OFFS;

        address_space_stw(&address_space_memory, idx_addr, 0,

                          MEMTXATTRS_UNSPECIFIED, NULL);

        idx_addr = virtio_queue_get_used_addr(dev->vdev, i) +

            virtio_queue_get_used_size(dev->vdev, i);

        address_space_stw(&address_space_memory, idx_addr, 0,

                          MEMTXATTRS_UNSPECIFIED, NULL);

    }

}
@@ -530,7 +538,6 @@ static unsigned virtio_s390_get_features(DeviceState *d) 
/**************** S390 Virtio Bus Device Descriptions *******************/



static Property s390_virtio_net_properties[] = {

    DEFINE_VIRTIO_COMMON_FEATURES(VirtIOS390Device, host_features),

    DEFINE_VIRTIO_NET_FEATURES(VirtIOS390Device, host_features),

    DEFINE_PROP_END_OF_LIST(),

};
@@ -592,18 +599,12 @@ static const TypeInfo s390_virtio_serial = { 
    .class_init    = s390_virtio_serial_class_init,

};



static Property s390_virtio_rng_properties[] = {

    DEFINE_VIRTIO_COMMON_FEATURES(VirtIOS390Device, host_features),

    DEFINE_PROP_END_OF_LIST(),

};



static void s390_virtio_rng_class_init(ObjectClass *klass, void *data)

{

    DeviceClass *dc = DEVICE_CLASS(klass);

    VirtIOS390DeviceClass *k = VIRTIO_S390_DEVICE_CLASS(klass);



    k->realize = s390_virtio_rng_realize;

    dc->props = s390_virtio_rng_properties;

    set_bit(DEVICE_CATEGORY_MISC, dc->categories);

}
@@ -632,10 +633,16 @@ static void s390_virtio_busdev_reset(DeviceState *dev) 
    virtio_reset(_dev->vdev);

}



static Property virtio_s390_properties[] = {

    DEFINE_VIRTIO_COMMON_FEATURES(VirtIOS390Device, host_features),

    DEFINE_PROP_END_OF_LIST(),

};



static void virtio_s390_device_class_init(ObjectClass *klass, void *data)

{

    DeviceClass *dc = DEVICE_CLASS(klass);



    dc->props = virtio_s390_properties;

    dc->realize = s390_virtio_busdev_realize;

    dc->bus_type = TYPE_S390_VIRTIO_BUS;

    dc->reset = s390_virtio_busdev_reset;
@@ -651,7 +658,6 @@ static const TypeInfo virtio_s390_device_info = { 
};



static Property s390_virtio_scsi_properties[] = {

    DEFINE_VIRTIO_COMMON_FEATURES(VirtIOS390Device, host_features),

    DEFINE_VIRTIO_SCSI_FEATURES(VirtIOS390Device, host_features),

    DEFINE_PROP_END_OF_LIST(),

};
@@ -675,18 +681,12 @@ static const TypeInfo s390_virtio_scsi = { 
};



#ifdef CONFIG_VHOST_SCSI

static Property s390_vhost_scsi_properties[] = {

    DEFINE_VIRTIO_COMMON_FEATURES(VirtIOS390Device, host_features),

    DEFINE_PROP_END_OF_LIST(),

};



static void s390_vhost_scsi_class_init(ObjectClass *klass, void *data)

{

    DeviceClass *dc = DEVICE_CLASS(klass);

    VirtIOS390DeviceClass *k = VIRTIO_S390_DEVICE_CLASS(klass);



    k->realize = s390_vhost_scsi_realize;

    dc->props = s390_vhost_scsi_properties;

    set_bit(DEVICE_CATEGORY_STORAGE, dc->categories);

}

hw/s390x/s390-virtio.c

+10 −0
Original line number Diff line number Diff line
@@ -77,6 +77,16 @@ static int s390_virtio_hcall_notify(const uint64_t *args) 
    if (mem > ram_size) {

        VirtIOS390Device *dev = s390_virtio_bus_find_vring(s390_bus, mem, &i);

        if (dev) {

            /*

             * Older kernels will use the virtqueue before setting DRIVER_OK.

             * In this case the feature bits are not yet up to date, meaning

             * that several funny things can happen, e.g. the guest thinks

             * EVENT_IDX is on and QEMU thinks it is off. Let's force a feature

             * and status sync.

             */

            if (!(dev->vdev->status & VIRTIO_CONFIG_S_DRIVER_OK)) {

                s390_virtio_device_update_status(dev);

            }

            virtio_queue_notify(dev->vdev, i);

        } else {

            r = -EINVAL;

hw/s390x/virtio-ccw.c

+38 −34
Original line number Diff line number Diff line
@@ -642,8 +642,7 @@ static int virtio_ccw_cb(SubchDev *sch, CCW1 ccw) 
    return ret;

}



static void virtio_ccw_device_realize(VirtioCcwDevice *dev,

                                      VirtIODevice *vdev, Error **errp)

static void virtio_ccw_device_realize(VirtioCcwDevice *dev, Error **errp)

{

    unsigned int cssid = 0;

    unsigned int ssid = 0;
@@ -653,7 +652,8 @@ static void virtio_ccw_device_realize(VirtioCcwDevice *dev, 
    bool found = false;

    SubchDev *sch;

    int num;

    DeviceState *parent = DEVICE(dev);

    Error *err = NULL;

    VirtIOCCWDeviceClass *k = VIRTIO_CCW_DEVICE_GET_CLASS(dev);



    sch = g_malloc0(sizeof(SubchDev));
@@ -766,17 +766,16 @@ static void virtio_ccw_device_realize(VirtioCcwDevice *dev, 
    memset(&sch->id, 0, sizeof(SenseId));

    sch->id.reserved = 0xff;

    sch->id.cu_type = VIRTIO_CCW_CU_TYPE;

    sch->id.cu_model = vdev->device_id;



    /* Only the first 32 feature bits are used. */

    dev->host_features[0] = virtio_bus_get_vdev_features(&dev->bus,

                                                         dev->host_features[0]);



    virtio_add_feature(&dev->host_features[0], VIRTIO_F_NOTIFY_ON_EMPTY);

    virtio_add_feature(&dev->host_features[0], VIRTIO_F_BAD_FEATURE);

    if (k->realize) {

        k->realize(dev, &err);

    }

    if (err) {

        error_propagate(errp, err);

        css_subch_assign(cssid, ssid, schid, devno, NULL);

        goto out_err;

    }



    css_generate_sch_crws(sch->cssid, sch->ssid, sch->schid,

                          parent->hotplugged, 1);

    return;



out_err:
@@ -813,10 +812,7 @@ static void virtio_ccw_net_realize(VirtioCcwDevice *ccw_dev, Error **errp) 
    object_property_set_bool(OBJECT(vdev), true, "realized", &err);

    if (err) {

        error_propagate(errp, err);

        return;

    }



    virtio_ccw_device_realize(ccw_dev, VIRTIO_DEVICE(vdev), errp);

}



static void virtio_ccw_net_instance_init(Object *obj)
@@ -839,10 +835,7 @@ static void virtio_ccw_blk_realize(VirtioCcwDevice *ccw_dev, Error **errp) 
    object_property_set_bool(OBJECT(vdev), true, "realized", &err);

    if (err) {

        error_propagate(errp, err);

        return;

    }



    virtio_ccw_device_realize(ccw_dev, VIRTIO_DEVICE(vdev), errp);

}



static void virtio_ccw_blk_instance_init(Object *obj)
@@ -879,10 +872,7 @@ static void virtio_ccw_serial_realize(VirtioCcwDevice *ccw_dev, Error **errp) 
    object_property_set_bool(OBJECT(vdev), true, "realized", &err);

    if (err) {

        error_propagate(errp, err);

        return;

    }



    virtio_ccw_device_realize(ccw_dev, VIRTIO_DEVICE(vdev), errp);

}
@@ -904,10 +894,7 @@ static void virtio_ccw_balloon_realize(VirtioCcwDevice *ccw_dev, Error **errp) 
    object_property_set_bool(OBJECT(vdev), true, "realized", &err);

    if (err) {

        error_propagate(errp, err);

        return;

    }



    virtio_ccw_device_realize(ccw_dev, VIRTIO_DEVICE(vdev), errp);

}



static void balloon_ccw_stats_get_all(Object *obj, struct Visitor *v,
@@ -972,10 +959,7 @@ static void virtio_ccw_scsi_realize(VirtioCcwDevice *ccw_dev, Error **errp) 
    object_property_set_bool(OBJECT(vdev), true, "realized", &err);

    if (err) {

        error_propagate(errp, err);

        return;

    }



    virtio_ccw_device_realize(ccw_dev, VIRTIO_DEVICE(vdev), errp);

}



static void virtio_ccw_scsi_instance_init(Object *obj)
@@ -999,10 +983,7 @@ static void vhost_ccw_scsi_realize(VirtioCcwDevice *ccw_dev, Error **errp) 
    object_property_set_bool(OBJECT(vdev), true, "realized", &err);

    if (err) {

        error_propagate(errp, err);

        return;

    }



    virtio_ccw_device_realize(ccw_dev, VIRTIO_DEVICE(vdev), errp);

}



static void vhost_ccw_scsi_instance_init(Object *obj)
@@ -1030,8 +1011,6 @@ static void virtio_ccw_rng_realize(VirtioCcwDevice *ccw_dev, Error **errp) 
    object_property_set_link(OBJECT(dev),

                             OBJECT(dev->vdev.conf.rng), "rng",

                             NULL);



    virtio_ccw_device_realize(ccw_dev, VIRTIO_DEVICE(vdev), errp);

}



/* DeviceState to VirtioCcwDevice. Note: used on datapath,
@@ -1434,6 +1413,30 @@ static int virtio_ccw_load_config(DeviceState *d, QEMUFile *f) 
    return 0;

}



/* This is called by virtio-bus just after the device is plugged. */

static void virtio_ccw_device_plugged(DeviceState *d)

{

    VirtioCcwDevice *dev = VIRTIO_CCW_DEVICE(d);

    SubchDev *sch = dev->sch;



    sch->id.cu_model = virtio_bus_get_vdev_id(&dev->bus);



    /* Only the first 32 feature bits are used. */

    virtio_add_feature(&dev->host_features[0], VIRTIO_F_NOTIFY_ON_EMPTY);

    virtio_add_feature(&dev->host_features[0], VIRTIO_F_BAD_FEATURE);

    dev->host_features[0] = virtio_bus_get_vdev_features(&dev->bus,

                                                         dev->host_features[0]);



    css_generate_sch_crws(sch->cssid, sch->ssid, sch->schid,

                          d->hotplugged, 1);

}



static void virtio_ccw_device_unplugged(DeviceState *d)

{

    VirtioCcwDevice *dev = VIRTIO_CCW_DEVICE(d);



    virtio_ccw_stop_ioeventfd(dev);

}

/**************** Virtio-ccw Bus Device Descriptions *******************/



static Property virtio_ccw_net_properties[] = {
@@ -1640,10 +1643,9 @@ static const TypeInfo virtio_ccw_rng = { 
static void virtio_ccw_busdev_realize(DeviceState *dev, Error **errp)

{

    VirtioCcwDevice *_dev = (VirtioCcwDevice *)dev;

    VirtIOCCWDeviceClass *_info = VIRTIO_CCW_DEVICE_GET_CLASS(dev);



    virtio_ccw_bus_new(&_dev->bus, sizeof(_dev->bus), _dev);

    _info->realize(_dev, errp);

    virtio_ccw_device_realize(_dev, errp);

}



static int virtio_ccw_busdev_exit(DeviceState *dev)
@@ -1759,6 +1761,8 @@ static void virtio_ccw_bus_class_init(ObjectClass *klass, void *data) 
    k->load_queue = virtio_ccw_load_queue;

    k->save_config = virtio_ccw_save_config;

    k->load_config = virtio_ccw_load_config;

    k->device_plugged = virtio_ccw_device_plugged;

    k->device_unplugged = virtio_ccw_device_unplugged;

}



static const TypeInfo virtio_ccw_bus_info = {

target-s390x/cpu-qom.h

+3 −0
Original line number Diff line number Diff line
@@ -66,6 +66,9 @@ typedef struct S390CPU { 
    /*< public >*/



    CPUS390XState env;

    /* needed for live migration */

    void *irqstate;

    uint32_t irqstate_saved_size;

} S390CPU;



static inline S390CPU *s390_env_get_cpu(CPUS390XState *env)

target-s390x/cpu.c

+1 −0
Original line number Diff line number Diff line
@@ -213,6 +213,7 @@ static void s390_cpu_finalize(Object *obj) 
    S390CPU *cpu = S390_CPU(obj);



    qemu_unregister_reset(s390_cpu_machine_reset_cb, cpu);

    g_free(cpu->irqstate);

#endif

}