2009-12-05 14:44:27 +03:00
|
|
|
/*
|
|
|
|
* QEMU S390 virtio target
|
|
|
|
*
|
|
|
|
* Copyright (c) 2009 Alexander Graf <agraf@suse.de>
|
|
|
|
*
|
|
|
|
* This library is free software; you can redistribute it and/or
|
|
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
|
|
* License as published by the Free Software Foundation; either
|
|
|
|
* version 2 of the License, or (at your option) any later version.
|
|
|
|
*
|
|
|
|
* This library is distributed in the hope that it will be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
|
|
* Lesser General Public License for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU Lesser General Public
|
|
|
|
* License along with this library; if not, see <http://www.gnu.org/licenses/>.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include "hw.h"
|
2012-12-17 21:19:44 +04:00
|
|
|
#include "block/block.h"
|
2012-12-17 21:20:04 +04:00
|
|
|
#include "sysemu/sysemu.h"
|
2009-12-05 14:44:27 +03:00
|
|
|
#include "boards.h"
|
2012-12-17 21:19:49 +04:00
|
|
|
#include "monitor/monitor.h"
|
2009-12-05 14:44:27 +03:00
|
|
|
#include "loader.h"
|
|
|
|
#include "elf.h"
|
|
|
|
#include "hw/virtio.h"
|
2012-06-20 10:59:32 +04:00
|
|
|
#include "hw/virtio-rng.h"
|
virtio-console: qdev conversion, new virtio-serial-bus
This commit converts the virtio-console device to create a new
virtio-serial bus that can host console and generic serial ports. The
file hosting this code is now called virtio-serial-bus.c.
The virtio console is now a very simple qdev device that sits on the
virtio-serial-bus and communicates between the bus and qemu's chardevs.
This commit also includes a few changes to the virtio backing code for
pci and s390 to spawn the virtio-serial bus.
As a result of the qdev conversion, we get rid of a lot of legacy code.
The old-style way of instantiating a virtio console using
-virtioconsole ...
is maintained, but the new, preferred way is to use
-device virtio-serial -device virtconsole,chardev=...
With this commit, multiple devices as well as multiple ports with a
single device can be supported.
For multiple ports support, each port gets an IO vq pair. Since the
guest needs to know in advance how many vqs a particular device will
need, we have to set this number as a property of the virtio-serial
device and also as a config option.
In addition, we also spawn a pair of control IO vqs. This is an internal
channel meant for guest-host communication for things like port
open/close, sending port properties over to the guest, etc.
This commit is a part of a series of other commits to get the full
implementation of multiport support. Future commits will add other
support as well as ride on the savevm version that we bump up here.
Signed-off-by: Amit Shah <amit.shah@redhat.com>
Signed-off-by: Anthony Liguori <aliguori@us.ibm.com>
2010-01-19 22:06:52 +03:00
|
|
|
#include "hw/virtio-serial.h"
|
2010-09-02 19:00:50 +04:00
|
|
|
#include "hw/virtio-net.h"
|
2009-12-05 14:44:27 +03:00
|
|
|
#include "hw/sysbus.h"
|
2012-12-17 21:20:04 +04:00
|
|
|
#include "sysemu/kvm.h"
|
2009-12-05 14:44:27 +03:00
|
|
|
|
|
|
|
#include "hw/s390-virtio-bus.h"
|
|
|
|
|
|
|
|
/* #define DEBUG_S390 */
|
|
|
|
|
|
|
|
#ifdef DEBUG_S390
|
|
|
|
#define dprintf(fmt, ...) \
|
|
|
|
do { fprintf(stderr, fmt, ## __VA_ARGS__); } while (0)
|
|
|
|
#else
|
|
|
|
#define dprintf(fmt, ...) \
|
|
|
|
do { } while (0)
|
|
|
|
#endif
|
|
|
|
|
2011-04-15 19:32:49 +04:00
|
|
|
#define VIRTIO_EXT_CODE 0x2603
|
|
|
|
|
2012-05-02 11:00:20 +04:00
|
|
|
static const TypeInfo s390_virtio_bus_info = {
|
|
|
|
.name = TYPE_S390_VIRTIO_BUS,
|
|
|
|
.parent = TYPE_BUS,
|
|
|
|
.instance_size = sizeof(VirtIOS390Bus),
|
2009-12-05 14:44:27 +03:00
|
|
|
};
|
|
|
|
|
|
|
|
static const VirtIOBindings virtio_s390_bindings;
|
|
|
|
|
|
|
|
static ram_addr_t s390_virtio_device_num_vq(VirtIOS390Device *dev);
|
|
|
|
|
2011-04-13 12:55:11 +04:00
|
|
|
/* length of VirtIO device pages */
|
2012-10-23 14:30:10 +04:00
|
|
|
const hwaddr virtio_size = S390_DEVICE_PAGES * TARGET_PAGE_SIZE;
|
2011-04-13 12:55:11 +04:00
|
|
|
|
2012-04-23 03:52:21 +04:00
|
|
|
static void s390_virtio_bus_reset(void *opaque)
|
|
|
|
{
|
|
|
|
VirtIOS390Bus *bus = opaque;
|
|
|
|
bus->next_ring = bus->dev_page + TARGET_PAGE_SIZE;
|
|
|
|
}
|
|
|
|
|
2012-04-26 13:03:36 +04:00
|
|
|
void s390_virtio_reset_idx(VirtIOS390Device *dev)
|
|
|
|
{
|
|
|
|
int i;
|
2012-10-23 14:30:10 +04:00
|
|
|
hwaddr idx_addr;
|
2012-04-26 13:03:36 +04:00
|
|
|
uint8_t num_vq;
|
|
|
|
|
|
|
|
num_vq = s390_virtio_device_num_vq(dev);
|
|
|
|
for (i = 0; i < num_vq; i++) {
|
|
|
|
idx_addr = virtio_queue_get_avail_addr(dev->vdev, i) +
|
|
|
|
VIRTIO_VRING_AVAIL_IDX_OFFS;
|
|
|
|
stw_phys(idx_addr, 0);
|
|
|
|
idx_addr = virtio_queue_get_used_addr(dev->vdev, i) +
|
|
|
|
VIRTIO_VRING_USED_IDX_OFFS;
|
|
|
|
stw_phys(idx_addr, 0);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-12-05 14:44:27 +03:00
|
|
|
VirtIOS390Bus *s390_virtio_bus_init(ram_addr_t *ram_size)
|
|
|
|
{
|
|
|
|
VirtIOS390Bus *bus;
|
|
|
|
BusState *_bus;
|
|
|
|
DeviceState *dev;
|
|
|
|
|
|
|
|
/* Create bridge device */
|
|
|
|
dev = qdev_create(NULL, "s390-virtio-bridge");
|
|
|
|
qdev_init_nofail(dev);
|
|
|
|
|
|
|
|
/* Create bus on bridge device */
|
|
|
|
|
2012-05-02 11:00:20 +04:00
|
|
|
_bus = qbus_create(TYPE_S390_VIRTIO_BUS, dev, "s390-virtio");
|
2009-12-05 14:44:27 +03:00
|
|
|
bus = DO_UPCAST(VirtIOS390Bus, bus, _bus);
|
|
|
|
|
|
|
|
bus->dev_page = *ram_size;
|
|
|
|
bus->dev_offs = bus->dev_page;
|
|
|
|
bus->next_ring = bus->dev_page + TARGET_PAGE_SIZE;
|
|
|
|
|
2010-08-23 20:58:34 +04:00
|
|
|
/* Enable hotplugging */
|
|
|
|
_bus->allow_hotplug = 1;
|
|
|
|
|
2009-12-05 14:44:27 +03:00
|
|
|
/* Allocate RAM for VirtIO device pages (descriptors, queues, rings) */
|
|
|
|
*ram_size += S390_DEVICE_PAGES * TARGET_PAGE_SIZE;
|
|
|
|
|
2012-04-23 03:52:21 +04:00
|
|
|
qemu_register_reset(s390_virtio_bus_reset, bus);
|
2009-12-05 14:44:27 +03:00
|
|
|
return bus;
|
|
|
|
}
|
|
|
|
|
2012-10-31 09:06:49 +04:00
|
|
|
static void s390_virtio_irq(S390CPU *cpu, int config_change, uint64_t token)
|
2010-08-23 20:58:34 +04:00
|
|
|
{
|
2012-10-31 09:06:49 +04:00
|
|
|
CPUS390XState *env = &cpu->env;
|
|
|
|
|
2010-08-23 20:58:34 +04:00
|
|
|
if (kvm_enabled()) {
|
2012-10-31 09:06:49 +04:00
|
|
|
kvm_s390_virtio_irq(cpu, config_change, token);
|
2010-08-23 20:58:34 +04:00
|
|
|
} else {
|
|
|
|
cpu_inject_ext(env, VIRTIO_EXT_CODE, config_change, token);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-12-05 14:44:27 +03:00
|
|
|
static int s390_virtio_device_init(VirtIOS390Device *dev, VirtIODevice *vdev)
|
|
|
|
{
|
|
|
|
VirtIOS390Bus *bus;
|
|
|
|
int dev_len;
|
|
|
|
|
|
|
|
bus = DO_UPCAST(VirtIOS390Bus, bus, dev->qdev.parent_bus);
|
|
|
|
dev->vdev = vdev;
|
|
|
|
dev->dev_offs = bus->dev_offs;
|
|
|
|
dev->feat_len = sizeof(uint32_t); /* always keep 32 bits features */
|
|
|
|
|
|
|
|
dev_len = VIRTIO_DEV_OFFS_CONFIG;
|
|
|
|
dev_len += s390_virtio_device_num_vq(dev) * VIRTIO_VQCONFIG_LEN;
|
|
|
|
dev_len += dev->feat_len * 2;
|
|
|
|
dev_len += vdev->config_len;
|
|
|
|
|
|
|
|
bus->dev_offs += dev_len;
|
|
|
|
|
2012-12-17 15:01:07 +04:00
|
|
|
virtio_bind_device(vdev, &virtio_s390_bindings, DEVICE(dev));
|
2010-01-10 14:52:53 +03:00
|
|
|
dev->host_features = vdev->get_features(vdev, dev->host_features);
|
2009-12-05 14:44:27 +03:00
|
|
|
s390_virtio_device_sync(dev);
|
2012-04-26 13:03:36 +04:00
|
|
|
s390_virtio_reset_idx(dev);
|
2010-08-23 20:58:34 +04:00
|
|
|
if (dev->qdev.hotplugged) {
|
2012-05-03 06:28:14 +04:00
|
|
|
S390CPU *cpu = s390_cpu_addr2state(0);
|
2012-10-31 09:06:49 +04:00
|
|
|
s390_virtio_irq(cpu, VIRTIO_PARAM_DEV_ADD, dev->dev_offs);
|
2010-08-23 20:58:34 +04:00
|
|
|
}
|
|
|
|
|
2009-12-05 14:44:27 +03:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int s390_virtio_net_init(VirtIOS390Device *dev)
|
|
|
|
{
|
|
|
|
VirtIODevice *vdev;
|
|
|
|
|
2010-09-02 19:00:50 +04:00
|
|
|
vdev = virtio_net_init((DeviceState *)dev, &dev->nic, &dev->net);
|
2009-12-05 14:44:27 +03:00
|
|
|
if (!vdev) {
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
return s390_virtio_device_init(dev, vdev);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int s390_virtio_blk_init(VirtIOS390Device *dev)
|
|
|
|
{
|
|
|
|
VirtIODevice *vdev;
|
|
|
|
|
2012-05-16 14:54:05 +04:00
|
|
|
vdev = virtio_blk_init((DeviceState *)dev, &dev->blk);
|
2009-12-05 14:44:27 +03:00
|
|
|
if (!vdev) {
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
return s390_virtio_device_init(dev, vdev);
|
|
|
|
}
|
|
|
|
|
virtio-console: qdev conversion, new virtio-serial-bus
This commit converts the virtio-console device to create a new
virtio-serial bus that can host console and generic serial ports. The
file hosting this code is now called virtio-serial-bus.c.
The virtio console is now a very simple qdev device that sits on the
virtio-serial-bus and communicates between the bus and qemu's chardevs.
This commit also includes a few changes to the virtio backing code for
pci and s390 to spawn the virtio-serial bus.
As a result of the qdev conversion, we get rid of a lot of legacy code.
The old-style way of instantiating a virtio console using
-virtioconsole ...
is maintained, but the new, preferred way is to use
-device virtio-serial -device virtconsole,chardev=...
With this commit, multiple devices as well as multiple ports with a
single device can be supported.
For multiple ports support, each port gets an IO vq pair. Since the
guest needs to know in advance how many vqs a particular device will
need, we have to set this number as a property of the virtio-serial
device and also as a config option.
In addition, we also spawn a pair of control IO vqs. This is an internal
channel meant for guest-host communication for things like port
open/close, sending port properties over to the guest, etc.
This commit is a part of a series of other commits to get the full
implementation of multiport support. Future commits will add other
support as well as ride on the savevm version that we bump up here.
Signed-off-by: Amit Shah <amit.shah@redhat.com>
Signed-off-by: Anthony Liguori <aliguori@us.ibm.com>
2010-01-19 22:06:52 +03:00
|
|
|
static int s390_virtio_serial_init(VirtIOS390Device *dev)
|
2009-12-05 14:44:27 +03:00
|
|
|
{
|
|
|
|
VirtIOS390Bus *bus;
|
|
|
|
VirtIODevice *vdev;
|
|
|
|
int r;
|
|
|
|
|
|
|
|
bus = DO_UPCAST(VirtIOS390Bus, bus, dev->qdev.parent_bus);
|
|
|
|
|
2011-03-29 17:29:31 +04:00
|
|
|
vdev = virtio_serial_init((DeviceState *)dev, &dev->serial);
|
2009-12-05 14:44:27 +03:00
|
|
|
if (!vdev) {
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
r = s390_virtio_device_init(dev, vdev);
|
|
|
|
if (!r) {
|
|
|
|
bus->console = dev;
|
|
|
|
}
|
|
|
|
|
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
2011-02-11 11:40:59 +03:00
|
|
|
static int s390_virtio_scsi_init(VirtIOS390Device *dev)
|
|
|
|
{
|
|
|
|
VirtIODevice *vdev;
|
|
|
|
|
|
|
|
vdev = virtio_scsi_init((DeviceState *)dev, &dev->scsi);
|
|
|
|
if (!vdev) {
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
return s390_virtio_device_init(dev, vdev);
|
|
|
|
}
|
|
|
|
|
2012-06-20 10:59:32 +04:00
|
|
|
static int s390_virtio_rng_init(VirtIOS390Device *dev)
|
|
|
|
{
|
|
|
|
VirtIODevice *vdev;
|
|
|
|
|
|
|
|
vdev = virtio_rng_init((DeviceState *)dev, &dev->rng);
|
|
|
|
if (!vdev) {
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
return s390_virtio_device_init(dev, vdev);
|
|
|
|
}
|
|
|
|
|
2009-12-05 14:44:27 +03:00
|
|
|
static uint64_t s390_virtio_device_vq_token(VirtIOS390Device *dev, int vq)
|
|
|
|
{
|
|
|
|
ram_addr_t token_off;
|
|
|
|
|
|
|
|
token_off = (dev->dev_offs + VIRTIO_DEV_OFFS_CONFIG) +
|
|
|
|
(vq * VIRTIO_VQCONFIG_LEN) +
|
|
|
|
VIRTIO_VQCONFIG_OFFS_TOKEN;
|
|
|
|
|
2011-07-05 20:28:09 +04:00
|
|
|
return ldq_be_phys(token_off);
|
2009-12-05 14:44:27 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
static ram_addr_t s390_virtio_device_num_vq(VirtIOS390Device *dev)
|
|
|
|
{
|
|
|
|
VirtIODevice *vdev = dev->vdev;
|
|
|
|
int num_vq;
|
|
|
|
|
|
|
|
for (num_vq = 0; num_vq < VIRTIO_PCI_QUEUE_MAX; num_vq++) {
|
|
|
|
if (!virtio_queue_get_num(vdev, num_vq)) {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return num_vq;
|
|
|
|
}
|
|
|
|
|
|
|
|
static ram_addr_t s390_virtio_next_ring(VirtIOS390Bus *bus)
|
|
|
|
{
|
|
|
|
ram_addr_t r = bus->next_ring;
|
|
|
|
|
|
|
|
bus->next_ring += VIRTIO_RING_LEN;
|
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
2010-04-01 20:42:40 +04:00
|
|
|
void s390_virtio_device_sync(VirtIOS390Device *dev)
|
2009-12-05 14:44:27 +03:00
|
|
|
{
|
|
|
|
VirtIOS390Bus *bus = DO_UPCAST(VirtIOS390Bus, bus, dev->qdev.parent_bus);
|
|
|
|
ram_addr_t cur_offs;
|
|
|
|
uint8_t num_vq;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
virtio_reset(dev->vdev);
|
|
|
|
|
|
|
|
/* Sync dev space */
|
|
|
|
stb_phys(dev->dev_offs + VIRTIO_DEV_OFFS_TYPE, dev->vdev->device_id);
|
|
|
|
|
|
|
|
stb_phys(dev->dev_offs + VIRTIO_DEV_OFFS_NUM_VQ, s390_virtio_device_num_vq(dev));
|
|
|
|
stb_phys(dev->dev_offs + VIRTIO_DEV_OFFS_FEATURE_LEN, dev->feat_len);
|
|
|
|
|
|
|
|
stb_phys(dev->dev_offs + VIRTIO_DEV_OFFS_CONFIG_LEN, dev->vdev->config_len);
|
|
|
|
|
|
|
|
num_vq = s390_virtio_device_num_vq(dev);
|
|
|
|
stb_phys(dev->dev_offs + VIRTIO_DEV_OFFS_NUM_VQ, num_vq);
|
|
|
|
|
|
|
|
/* Sync virtqueues */
|
|
|
|
for (i = 0; i < num_vq; i++) {
|
|
|
|
ram_addr_t vq = (dev->dev_offs + VIRTIO_DEV_OFFS_CONFIG) +
|
|
|
|
(i * VIRTIO_VQCONFIG_LEN);
|
|
|
|
ram_addr_t vring;
|
|
|
|
|
|
|
|
vring = s390_virtio_next_ring(bus);
|
|
|
|
virtio_queue_set_addr(dev->vdev, i, vring);
|
|
|
|
virtio_queue_set_vector(dev->vdev, i, i);
|
2011-07-05 20:28:09 +04:00
|
|
|
stq_be_phys(vq + VIRTIO_VQCONFIG_OFFS_ADDRESS, vring);
|
|
|
|
stw_be_phys(vq + VIRTIO_VQCONFIG_OFFS_NUM, virtio_queue_get_num(dev->vdev, i));
|
2009-12-05 14:44:27 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
cur_offs = dev->dev_offs;
|
|
|
|
cur_offs += VIRTIO_DEV_OFFS_CONFIG;
|
|
|
|
cur_offs += num_vq * VIRTIO_VQCONFIG_LEN;
|
|
|
|
|
|
|
|
/* Sync feature bitmap */
|
2011-07-05 20:28:09 +04:00
|
|
|
stl_le_phys(cur_offs, dev->host_features);
|
2009-12-05 14:44:27 +03:00
|
|
|
|
|
|
|
dev->feat_offs = cur_offs + dev->feat_len;
|
|
|
|
cur_offs += dev->feat_len * 2;
|
|
|
|
|
|
|
|
/* Sync config space */
|
|
|
|
if (dev->vdev->get_config) {
|
|
|
|
dev->vdev->get_config(dev->vdev, dev->vdev->config);
|
|
|
|
}
|
|
|
|
|
2011-04-10 20:23:39 +04:00
|
|
|
cpu_physical_memory_write(cur_offs,
|
|
|
|
dev->vdev->config, dev->vdev->config_len);
|
2009-12-05 14:44:27 +03:00
|
|
|
cur_offs += dev->vdev->config_len;
|
|
|
|
}
|
|
|
|
|
|
|
|
void s390_virtio_device_update_status(VirtIOS390Device *dev)
|
|
|
|
{
|
|
|
|
VirtIODevice *vdev = dev->vdev;
|
|
|
|
uint32_t features;
|
|
|
|
|
2010-03-17 14:08:05 +03:00
|
|
|
virtio_set_status(vdev, ldub_phys(dev->dev_offs + VIRTIO_DEV_OFFS_STATUS));
|
2009-12-05 14:44:27 +03:00
|
|
|
|
|
|
|
/* Update guest supported feature bitmap */
|
|
|
|
|
2011-07-05 20:28:09 +04:00
|
|
|
features = bswap32(ldl_be_phys(dev->feat_offs));
|
2011-11-24 16:28:52 +04:00
|
|
|
virtio_set_features(vdev, features);
|
2009-12-05 14:44:27 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
VirtIOS390Device *s390_virtio_bus_console(VirtIOS390Bus *bus)
|
|
|
|
{
|
|
|
|
return bus->console;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Find a device by vring address */
|
|
|
|
VirtIOS390Device *s390_virtio_bus_find_vring(VirtIOS390Bus *bus,
|
|
|
|
ram_addr_t mem,
|
|
|
|
int *vq_num)
|
|
|
|
{
|
2011-12-24 01:34:39 +04:00
|
|
|
BusChild *kid;
|
2009-12-05 14:44:27 +03:00
|
|
|
int i;
|
|
|
|
|
2011-12-24 01:34:39 +04:00
|
|
|
QTAILQ_FOREACH(kid, &bus->bus.children, sibling) {
|
|
|
|
VirtIOS390Device *dev = (VirtIOS390Device *)kid->child;
|
|
|
|
|
2009-12-05 14:44:27 +03:00
|
|
|
for(i = 0; i < VIRTIO_PCI_QUEUE_MAX; i++) {
|
2011-12-24 01:34:39 +04:00
|
|
|
if (!virtio_queue_get_addr(dev->vdev, i))
|
2009-12-05 14:44:27 +03:00
|
|
|
break;
|
2011-12-24 01:34:39 +04:00
|
|
|
if (virtio_queue_get_addr(dev->vdev, i) == mem) {
|
2009-12-05 14:44:27 +03:00
|
|
|
if (vq_num) {
|
|
|
|
*vq_num = i;
|
|
|
|
}
|
2011-12-24 01:34:39 +04:00
|
|
|
return dev;
|
2009-12-05 14:44:27 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Find a device by device descriptor location */
|
|
|
|
VirtIOS390Device *s390_virtio_bus_find_mem(VirtIOS390Bus *bus, ram_addr_t mem)
|
|
|
|
{
|
2011-12-24 01:34:39 +04:00
|
|
|
BusChild *kid;
|
2009-12-05 14:44:27 +03:00
|
|
|
|
2011-12-24 01:34:39 +04:00
|
|
|
QTAILQ_FOREACH(kid, &bus->bus.children, sibling) {
|
|
|
|
VirtIOS390Device *dev = (VirtIOS390Device *)kid->child;
|
|
|
|
if (dev->dev_offs == mem) {
|
|
|
|
return dev;
|
2009-12-05 14:44:27 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2012-12-17 15:01:07 +04:00
|
|
|
/* DeviceState to VirtIOS390Device. Note: used on datapath,
|
|
|
|
* be careful and test performance if you change this.
|
|
|
|
*/
|
|
|
|
static inline VirtIOS390Device *to_virtio_s390_device_fast(DeviceState *d)
|
|
|
|
{
|
|
|
|
return container_of(d, VirtIOS390Device, qdev);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* DeviceState to VirtIOS390Device. TODO: use QOM. */
|
|
|
|
static inline VirtIOS390Device *to_virtio_s390_device(DeviceState *d)
|
|
|
|
{
|
|
|
|
return container_of(d, VirtIOS390Device, qdev);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void virtio_s390_notify(DeviceState *d, uint16_t vector)
|
2009-12-05 14:44:27 +03:00
|
|
|
{
|
2012-12-17 15:01:07 +04:00
|
|
|
VirtIOS390Device *dev = to_virtio_s390_device_fast(d);
|
2009-12-05 14:44:27 +03:00
|
|
|
uint64_t token = s390_virtio_device_vq_token(dev, vector);
|
2012-05-03 06:28:14 +04:00
|
|
|
S390CPU *cpu = s390_cpu_addr2state(0);
|
2009-12-05 14:44:27 +03:00
|
|
|
|
2012-10-31 09:06:49 +04:00
|
|
|
s390_virtio_irq(cpu, 0, token);
|
2009-12-05 14:44:27 +03:00
|
|
|
}
|
|
|
|
|
2012-12-17 15:01:07 +04:00
|
|
|
static unsigned virtio_s390_get_features(DeviceState *d)
|
2010-01-10 14:52:53 +03:00
|
|
|
{
|
2012-12-17 15:01:07 +04:00
|
|
|
VirtIOS390Device *dev = to_virtio_s390_device(d);
|
2010-01-10 14:52:53 +03:00
|
|
|
return dev->host_features;
|
|
|
|
}
|
|
|
|
|
2009-12-05 14:44:27 +03:00
|
|
|
/**************** S390 Virtio Bus Device Descriptions *******************/
|
|
|
|
|
|
|
|
static const VirtIOBindings virtio_s390_bindings = {
|
|
|
|
.notify = virtio_s390_notify,
|
2010-01-10 14:52:53 +03:00
|
|
|
.get_features = virtio_s390_get_features,
|
2009-12-05 14:44:27 +03:00
|
|
|
};
|
|
|
|
|
2011-12-08 07:34:16 +04:00
|
|
|
static Property s390_virtio_net_properties[] = {
|
|
|
|
DEFINE_NIC_PROPERTIES(VirtIOS390Device, nic),
|
|
|
|
DEFINE_PROP_UINT32("x-txtimer", VirtIOS390Device,
|
|
|
|
net.txtimer, TX_TIMER_INTERVAL),
|
|
|
|
DEFINE_PROP_INT32("x-txburst", VirtIOS390Device,
|
|
|
|
net.txburst, TX_BURST),
|
|
|
|
DEFINE_PROP_STRING("tx", VirtIOS390Device, net.tx),
|
|
|
|
DEFINE_PROP_END_OF_LIST(),
|
|
|
|
};
|
|
|
|
|
2011-12-22 06:57:49 +04:00
|
|
|
static void s390_virtio_net_class_init(ObjectClass *klass, void *data)
|
|
|
|
{
|
2011-12-08 07:34:16 +04:00
|
|
|
DeviceClass *dc = DEVICE_CLASS(klass);
|
|
|
|
VirtIOS390DeviceClass *k = VIRTIO_S390_DEVICE_CLASS(klass);
|
2011-12-22 06:57:49 +04:00
|
|
|
|
2011-12-08 07:34:16 +04:00
|
|
|
k->init = s390_virtio_net_init;
|
|
|
|
dc->props = s390_virtio_net_properties;
|
2011-12-22 06:57:49 +04:00
|
|
|
}
|
|
|
|
|
2013-01-10 19:19:07 +04:00
|
|
|
static const TypeInfo s390_virtio_net = {
|
2011-12-08 07:34:16 +04:00
|
|
|
.name = "virtio-net-s390",
|
|
|
|
.parent = TYPE_VIRTIO_S390_DEVICE,
|
|
|
|
.instance_size = sizeof(VirtIOS390Device),
|
|
|
|
.class_init = s390_virtio_net_class_init,
|
|
|
|
};
|
|
|
|
|
|
|
|
static Property s390_virtio_blk_properties[] = {
|
2012-05-16 14:54:05 +04:00
|
|
|
DEFINE_BLOCK_PROPERTIES(VirtIOS390Device, blk.conf),
|
2012-07-10 13:12:43 +04:00
|
|
|
DEFINE_BLOCK_CHS_PROPERTIES(VirtIOS390Device, blk.conf),
|
2012-05-16 14:54:05 +04:00
|
|
|
DEFINE_PROP_STRING("serial", VirtIOS390Device, blk.serial),
|
virtio-blk: always enable VIRTIO_BLK_F_SCSI
VIRTIO_BLK_F_SCSI is supposed to mean whether the host can *parse*
SCSI requests, not *execute* them. You could run QEMU with scsi=on
and a file-backed disk, and QEMU would fail all SCSI requests even
though it advertises VIRTIO_BLK_F_SCSI.
Because we need to do this to fix a migration compatibility problem
related to how QEMU is invoked by management, we must do this
unconditionally even on older machine types. This more or less assumes
that no one ever invoked QEMU with scsi=off.
Here is how testing goes:
- old QEMU, scsi=on -> new QEMU, scsi=on
- new QEMU, scsi=on -> old QEMU, scsi=on
- old QEMU, scsi=off -> new QEMU, scsi=on
- new QEMU, scsi=off -> old QEMU, scsi=on
ok (new QEMU has VIRTIO_BLK_F_SCSI, adding host features is fine)
- old QEMU, scsi=off -> new QEMU, scsi=off
ok (new QEMU has VIRTIO_BLK_F_SCSI, adding host features is fine)
- old QEMU, scsi=on -> new QEMU, scsi=off
ok, bug fixed
- new QEMU, scsi=on -> old QEMU, scsi=off
doesn't work (same as: old QEMU, scsi=on -> old QEMU, scsi=off)
- new QEMU, scsi=off -> old QEMU, scsi=off
broken by the patch
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Signed-off-by: Anthony Liguori <aliguori@us.ibm.com>
2012-05-16 14:54:06 +04:00
|
|
|
#ifdef __linux__
|
|
|
|
DEFINE_PROP_BIT("scsi", VirtIOS390Device, blk.scsi, 0, true),
|
|
|
|
#endif
|
2011-12-08 07:34:16 +04:00
|
|
|
DEFINE_PROP_END_OF_LIST(),
|
2009-12-05 14:44:27 +03:00
|
|
|
};
|
|
|
|
|
2011-12-22 06:57:49 +04:00
|
|
|
static void s390_virtio_blk_class_init(ObjectClass *klass, void *data)
|
|
|
|
{
|
2011-12-08 07:34:16 +04:00
|
|
|
DeviceClass *dc = DEVICE_CLASS(klass);
|
|
|
|
VirtIOS390DeviceClass *k = VIRTIO_S390_DEVICE_CLASS(klass);
|
2011-12-22 06:57:49 +04:00
|
|
|
|
2011-12-08 07:34:16 +04:00
|
|
|
k->init = s390_virtio_blk_init;
|
|
|
|
dc->props = s390_virtio_blk_properties;
|
2011-12-22 06:57:49 +04:00
|
|
|
}
|
|
|
|
|
2013-01-10 19:19:07 +04:00
|
|
|
static const TypeInfo s390_virtio_blk = {
|
2011-12-08 07:34:16 +04:00
|
|
|
.name = "virtio-blk-s390",
|
|
|
|
.parent = TYPE_VIRTIO_S390_DEVICE,
|
|
|
|
.instance_size = sizeof(VirtIOS390Device),
|
|
|
|
.class_init = s390_virtio_blk_class_init,
|
|
|
|
};
|
|
|
|
|
|
|
|
static Property s390_virtio_serial_properties[] = {
|
|
|
|
DEFINE_PROP_UINT32("max_ports", VirtIOS390Device,
|
|
|
|
serial.max_virtserial_ports, 31),
|
|
|
|
DEFINE_PROP_END_OF_LIST(),
|
2009-12-05 14:44:27 +03:00
|
|
|
};
|
|
|
|
|
2011-12-22 06:57:49 +04:00
|
|
|
static void s390_virtio_serial_class_init(ObjectClass *klass, void *data)
|
|
|
|
{
|
2011-12-08 07:34:16 +04:00
|
|
|
DeviceClass *dc = DEVICE_CLASS(klass);
|
|
|
|
VirtIOS390DeviceClass *k = VIRTIO_S390_DEVICE_CLASS(klass);
|
2011-12-22 06:57:49 +04:00
|
|
|
|
2011-12-08 07:34:16 +04:00
|
|
|
k->init = s390_virtio_serial_init;
|
|
|
|
dc->props = s390_virtio_serial_properties;
|
2011-12-22 06:57:49 +04:00
|
|
|
}
|
|
|
|
|
2013-01-10 19:19:07 +04:00
|
|
|
static const TypeInfo s390_virtio_serial = {
|
2011-12-08 07:34:16 +04:00
|
|
|
.name = "virtio-serial-s390",
|
|
|
|
.parent = TYPE_VIRTIO_S390_DEVICE,
|
|
|
|
.instance_size = sizeof(VirtIOS390Device),
|
|
|
|
.class_init = s390_virtio_serial_class_init,
|
2009-12-05 14:44:27 +03:00
|
|
|
};
|
|
|
|
|
2012-06-20 10:59:32 +04:00
|
|
|
static void s390_virtio_rng_initfn(Object *obj)
|
|
|
|
{
|
|
|
|
VirtIOS390Device *dev = VIRTIO_S390_DEVICE(obj);
|
|
|
|
|
|
|
|
object_property_add_link(obj, "rng", TYPE_RNG_BACKEND,
|
|
|
|
(Object **)&dev->rng.rng, NULL);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void s390_virtio_rng_class_init(ObjectClass *klass, void *data)
|
|
|
|
{
|
|
|
|
VirtIOS390DeviceClass *k = VIRTIO_S390_DEVICE_CLASS(klass);
|
|
|
|
|
|
|
|
k->init = s390_virtio_rng_init;
|
|
|
|
}
|
|
|
|
|
2013-01-10 19:19:07 +04:00
|
|
|
static const TypeInfo s390_virtio_rng = {
|
2012-06-20 10:59:32 +04:00
|
|
|
.name = "virtio-rng-s390",
|
|
|
|
.parent = TYPE_VIRTIO_S390_DEVICE,
|
|
|
|
.instance_size = sizeof(VirtIOS390Device),
|
|
|
|
.instance_init = s390_virtio_rng_initfn,
|
|
|
|
.class_init = s390_virtio_rng_class_init,
|
|
|
|
};
|
|
|
|
|
2011-12-10 01:02:56 +04:00
|
|
|
static int s390_virtio_busdev_init(DeviceState *dev)
|
2009-12-05 14:44:27 +03:00
|
|
|
{
|
|
|
|
VirtIOS390Device *_dev = (VirtIOS390Device *)dev;
|
2011-12-22 06:57:49 +04:00
|
|
|
VirtIOS390DeviceClass *_info = VIRTIO_S390_DEVICE_GET_CLASS(dev);
|
2009-12-05 14:44:27 +03:00
|
|
|
|
|
|
|
return _info->init(_dev);
|
|
|
|
}
|
|
|
|
|
2011-12-08 07:34:16 +04:00
|
|
|
static void virtio_s390_device_class_init(ObjectClass *klass, void *data)
|
2009-12-05 14:44:27 +03:00
|
|
|
{
|
2011-12-08 07:34:16 +04:00
|
|
|
DeviceClass *dc = DEVICE_CLASS(klass);
|
2009-12-05 14:44:27 +03:00
|
|
|
|
2011-12-08 07:34:16 +04:00
|
|
|
dc->init = s390_virtio_busdev_init;
|
2012-05-02 11:00:20 +04:00
|
|
|
dc->bus_type = TYPE_S390_VIRTIO_BUS;
|
2011-12-08 07:34:16 +04:00
|
|
|
dc->unplug = qdev_simple_unplug_cb;
|
2009-12-05 14:44:27 +03:00
|
|
|
}
|
|
|
|
|
2013-01-10 19:19:07 +04:00
|
|
|
static const TypeInfo virtio_s390_device_info = {
|
2011-12-22 06:57:49 +04:00
|
|
|
.name = TYPE_VIRTIO_S390_DEVICE,
|
|
|
|
.parent = TYPE_DEVICE,
|
|
|
|
.instance_size = sizeof(VirtIOS390Device),
|
2011-12-08 07:34:16 +04:00
|
|
|
.class_init = virtio_s390_device_class_init,
|
2012-02-06 21:07:18 +04:00
|
|
|
.class_size = sizeof(VirtIOS390DeviceClass),
|
2011-12-22 06:57:49 +04:00
|
|
|
.abstract = true,
|
|
|
|
};
|
|
|
|
|
2011-02-11 11:40:59 +03:00
|
|
|
static Property s390_virtio_scsi_properties[] = {
|
|
|
|
DEFINE_VIRTIO_SCSI_PROPERTIES(VirtIOS390Device, host_features, scsi),
|
|
|
|
DEFINE_PROP_END_OF_LIST(),
|
|
|
|
};
|
|
|
|
|
|
|
|
static void s390_virtio_scsi_class_init(ObjectClass *klass, void *data)
|
|
|
|
{
|
|
|
|
DeviceClass *dc = DEVICE_CLASS(klass);
|
|
|
|
VirtIOS390DeviceClass *k = VIRTIO_S390_DEVICE_CLASS(klass);
|
|
|
|
|
|
|
|
k->init = s390_virtio_scsi_init;
|
|
|
|
dc->props = s390_virtio_scsi_properties;
|
|
|
|
}
|
|
|
|
|
2013-01-10 19:19:07 +04:00
|
|
|
static const TypeInfo s390_virtio_scsi = {
|
2011-02-11 11:40:59 +03:00
|
|
|
.name = "virtio-scsi-s390",
|
|
|
|
.parent = TYPE_VIRTIO_S390_DEVICE,
|
|
|
|
.instance_size = sizeof(VirtIOS390Device),
|
|
|
|
.class_init = s390_virtio_scsi_class_init,
|
|
|
|
};
|
2009-12-05 14:44:27 +03:00
|
|
|
|
|
|
|
/***************** S390 Virtio Bus Bridge Device *******************/
|
|
|
|
/* Only required to have the virtio bus as child in the system bus */
|
|
|
|
|
|
|
|
static int s390_virtio_bridge_init(SysBusDevice *dev)
|
|
|
|
{
|
|
|
|
/* nothing */
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2012-01-24 23:12:29 +04:00
|
|
|
static void s390_virtio_bridge_class_init(ObjectClass *klass, void *data)
|
|
|
|
{
|
2011-12-08 07:34:16 +04:00
|
|
|
DeviceClass *dc = DEVICE_CLASS(klass);
|
2012-01-24 23:12:29 +04:00
|
|
|
SysBusDeviceClass *k = SYS_BUS_DEVICE_CLASS(klass);
|
|
|
|
|
|
|
|
k->init = s390_virtio_bridge_init;
|
2011-12-08 07:34:16 +04:00
|
|
|
dc->no_user = 1;
|
2012-01-24 23:12:29 +04:00
|
|
|
}
|
|
|
|
|
2013-01-10 19:19:07 +04:00
|
|
|
static const TypeInfo s390_virtio_bridge_info = {
|
2011-12-08 07:34:16 +04:00
|
|
|
.name = "s390-virtio-bridge",
|
|
|
|
.parent = TYPE_SYS_BUS_DEVICE,
|
|
|
|
.instance_size = sizeof(SysBusDevice),
|
|
|
|
.class_init = s390_virtio_bridge_class_init,
|
2009-12-05 14:44:27 +03:00
|
|
|
};
|
|
|
|
|
2012-02-09 18:20:55 +04:00
|
|
|
static void s390_virtio_register_types(void)
|
2009-12-05 14:44:27 +03:00
|
|
|
{
|
2012-05-02 11:00:20 +04:00
|
|
|
type_register_static(&s390_virtio_bus_info);
|
2012-02-09 18:20:55 +04:00
|
|
|
type_register_static(&virtio_s390_device_info);
|
|
|
|
type_register_static(&s390_virtio_serial);
|
|
|
|
type_register_static(&s390_virtio_blk);
|
|
|
|
type_register_static(&s390_virtio_net);
|
2011-02-11 11:40:59 +03:00
|
|
|
type_register_static(&s390_virtio_scsi);
|
2012-06-20 10:59:32 +04:00
|
|
|
type_register_static(&s390_virtio_rng);
|
2011-12-08 07:34:16 +04:00
|
|
|
type_register_static(&s390_virtio_bridge_info);
|
2009-12-05 14:44:27 +03:00
|
|
|
}
|
|
|
|
|
2012-02-09 18:20:55 +04:00
|
|
|
type_init(s390_virtio_register_types)
|