/* * QEMU S390x KVM floating interrupt controller (flic) * * Copyright 2014 IBM Corp. * Author(s): Jens Freimann * Cornelia Huck * * This work is licensed under the terms of the GNU GPL, version 2 or (at * your option) any later version. See the COPYING file in the top-level * directory. */ #include "qemu/osdep.h" #include "qemu-common.h" #include "cpu.h" #include #include "qemu/error-report.h" #include "qapi/error.h" #include "hw/sysbus.h" #include "sysemu/kvm.h" #include "hw/s390x/s390_flic.h" #include "hw/s390x/adapter.h" #include "hw/s390x/css.h" #include "trace.h" #define FLIC_SAVE_INITIAL_SIZE getpagesize() #define FLIC_FAILED (-1UL) #define FLIC_SAVEVM_VERSION 1 typedef struct KVMS390FLICState { S390FLICState parent_obj; uint32_t fd; bool clear_io_supported; } KVMS390FLICState; DeviceState *s390_flic_kvm_create(void) { DeviceState *dev = NULL; if (kvm_enabled()) { dev = qdev_create(NULL, TYPE_KVM_S390_FLIC); object_property_add_child(qdev_get_machine(), TYPE_KVM_S390_FLIC, OBJECT(dev), NULL); } return dev; } /** * flic_get_all_irqs - store all pending irqs in buffer * @buf: pointer to buffer which is passed to kernel * @len: length of buffer * @flic: pointer to flic device state * * Returns: -ENOMEM if buffer is too small, * -EINVAL if attr.group is invalid, * -EFAULT if copying to userspace failed, * on success return number of stored interrupts */ static int flic_get_all_irqs(KVMS390FLICState *flic, void *buf, int len) { struct kvm_device_attr attr = { .group = KVM_DEV_FLIC_GET_ALL_IRQS, .addr = (uint64_t) buf, .attr = len, }; int rc; rc = ioctl(flic->fd, KVM_GET_DEVICE_ATTR, &attr); return rc == -1 ? -errno : rc; } static void flic_enable_pfault(KVMS390FLICState *flic) { struct kvm_device_attr attr = { .group = KVM_DEV_FLIC_APF_ENABLE, }; int rc; rc = ioctl(flic->fd, KVM_SET_DEVICE_ATTR, &attr); if (rc) { fprintf(stderr, "flic: couldn't enable pfault\n"); } } static void flic_disable_wait_pfault(KVMS390FLICState *flic) { struct kvm_device_attr attr = { .group = KVM_DEV_FLIC_APF_DISABLE_WAIT, }; int rc; rc = ioctl(flic->fd, KVM_SET_DEVICE_ATTR, &attr); if (rc) { fprintf(stderr, "flic: couldn't disable pfault\n"); } } /** flic_enqueue_irqs - returns 0 on success * @buf: pointer to buffer which is passed to kernel * @len: length of buffer * @flic: pointer to flic device state * * Returns: -EINVAL if attr.group is unknown */ static int flic_enqueue_irqs(void *buf, uint64_t len, KVMS390FLICState *flic) { int rc; struct kvm_device_attr attr = { .group = KVM_DEV_FLIC_ENQUEUE, .addr = (uint64_t) buf, .attr = len, }; rc = ioctl(flic->fd, KVM_SET_DEVICE_ATTR, &attr); return rc ? -errno : 0; } int kvm_s390_inject_flic(struct kvm_s390_irq *irq) { static KVMS390FLICState *flic; if (unlikely(!flic)) { flic = KVM_S390_FLIC(s390_get_flic()); } return flic_enqueue_irqs(irq, sizeof(*irq), flic); } static int kvm_s390_clear_io_flic(S390FLICState *fs, uint16_t subchannel_id, uint16_t subchannel_nr) { KVMS390FLICState *flic = KVM_S390_FLIC(fs); int rc; uint32_t sid = subchannel_id << 16 | subchannel_nr; struct kvm_device_attr attr = { .group = KVM_DEV_FLIC_CLEAR_IO_IRQ, .addr = (uint64_t) &sid, .attr = sizeof(sid), }; if (unlikely(!flic->clear_io_supported)) { return -ENOSYS; } rc = ioctl(flic->fd, KVM_SET_DEVICE_ATTR, &attr); return rc ? -errno : 0; } static int kvm_s390_modify_ais_mode(S390FLICState *fs, uint8_t isc, uint16_t mode) { KVMS390FLICState *flic = KVM_S390_FLIC(fs); struct kvm_s390_ais_req req = { .isc = isc, .mode = mode, }; struct kvm_device_attr attr = { .group = KVM_DEV_FLIC_AISM, .addr = (uint64_t)&req, }; if (!fs->ais_supported) { return -ENOSYS; } return ioctl(flic->fd, KVM_SET_DEVICE_ATTR, &attr) ? -errno : 0; } static int kvm_s390_inject_airq(S390FLICState *fs, uint8_t type, uint8_t isc, uint8_t flags) { KVMS390FLICState *flic = KVM_S390_FLIC(fs); uint32_t id = css_get_adapter_id(type, isc); struct kvm_device_attr attr = { .group = KVM_DEV_FLIC_AIRQ_INJECT, .attr = id, }; if (!fs->ais_supported) { return -ENOSYS; } return ioctl(flic->fd, KVM_SET_DEVICE_ATTR, &attr) ? -errno : 0; } /** * __get_all_irqs - store all pending irqs in buffer * @flic: pointer to flic device state * @buf: pointer to pointer to a buffer * @len: length of buffer * * Returns: return value of flic_get_all_irqs * Note: Retry and increase buffer size until flic_get_all_irqs * either returns a value >= 0 or a negative error code. * -ENOMEM is an exception, which means the buffer is too small * and we should try again. Other negative error codes can be * -EFAULT and -EINVAL which we ignore at this point */ static int __get_all_irqs(KVMS390FLICState *flic, void **buf, int len) { int r; do { /* returns -ENOMEM if buffer is too small and number * of queued interrupts on success */ r = flic_get_all_irqs(flic, *buf, len); if (r >= 0) { break; } len *= 2; *buf = g_try_realloc(*buf, len); if (!buf) { return -ENOMEM; } } while (r == -ENOMEM && len <= KVM_S390_FLIC_MAX_BUFFER); return r; } static int kvm_s390_register_io_adapter(S390FLICState *fs, uint32_t id, uint8_t isc, bool swap, bool is_maskable, uint8_t flags) { struct kvm_s390_io_adapter adapter = { .id = id, .isc = isc, .maskable = is_maskable, .swap = swap, .flags = flags, }; KVMS390FLICState *flic = KVM_S390_FLIC(fs); int r; struct kvm_device_attr attr = { .group = KVM_DEV_FLIC_ADAPTER_REGISTER, .addr = (uint64_t)&adapter, }; if (!kvm_gsi_routing_enabled()) { /* nothing to do */ return 0; } r = ioctl(flic->fd, KVM_SET_DEVICE_ATTR, &attr); return r ? -errno : 0; } static int kvm_s390_io_adapter_map(S390FLICState *fs, uint32_t id, uint64_t map_addr, bool do_map) { struct kvm_s390_io_adapter_req req = { .id = id, .type = do_map ? KVM_S390_IO_ADAPTER_MAP : KVM_S390_IO_ADAPTER_UNMAP, .addr = map_addr, }; struct kvm_device_attr attr = { .group = KVM_DEV_FLIC_ADAPTER_MODIFY, .addr = (uint64_t)&req, }; KVMS390FLICState *flic = KVM_S390_FLIC(fs); int r; if (!kvm_gsi_routing_enabled()) { /* nothing to do */ return 0; } r = ioctl(flic->fd, KVM_SET_DEVICE_ATTR, &attr); return r ? -errno : 0; } static int kvm_s390_add_adapter_routes(S390FLICState *fs, AdapterRoutes *routes) { int ret, i; uint64_t ind_offset = routes->adapter.ind_offset; for (i = 0; i < routes->num_routes; i++) { ret = kvm_irqchip_add_adapter_route(kvm_state, &routes->adapter); if (ret < 0) { goto out_undo; } routes->gsi[i] = ret; routes->adapter.ind_offset++; } kvm_irqchip_commit_routes(kvm_state); /* Restore passed-in structure to original state. */ routes->adapter.ind_offset = ind_offset; return 0; out_undo: while (--i >= 0) { kvm_irqchip_release_virq(kvm_state, routes->gsi[i]); routes->gsi[i] = -1; } routes->adapter.ind_offset = ind_offset; return ret; } static void kvm_s390_release_adapter_routes(S390FLICState *fs, AdapterRoutes *routes) { int i; for (i = 0; i < routes->num_routes; i++) { if (routes->gsi[i] >= 0) { kvm_irqchip_release_virq(kvm_state, routes->gsi[i]); routes->gsi[i] = -1; } } } /** * kvm_flic_save - Save pending floating interrupts * @f: QEMUFile containing migration state * @opaque: pointer to flic device state * @size: ignored * * Note: Pass buf and len to kernel. Start with one page and * increase until buffer is sufficient or maxium size is * reached */ static int kvm_flic_save(QEMUFile *f, void *opaque, size_t size, VMStateField *field, QJSON *vmdesc) { KVMS390FLICState *flic = opaque; int len = FLIC_SAVE_INITIAL_SIZE; void *buf; int count; int r = 0; flic_disable_wait_pfault((struct KVMS390FLICState *) opaque); buf = g_try_malloc0(len); if (!buf) { /* Storing FLIC_FAILED into the count field here will cause the * target system to fail when attempting to load irqs from the * migration state */ error_report("flic: couldn't allocate memory"); qemu_put_be64(f, FLIC_FAILED); return -ENOMEM; } count = __get_all_irqs(flic, &buf, len); if (count < 0) { error_report("flic: couldn't retrieve irqs from kernel, rc %d", count); /* Storing FLIC_FAILED into the count field here will cause the * target system to fail when attempting to load irqs from the * migration state */ qemu_put_be64(f, FLIC_FAILED); r = count; } else { qemu_put_be64(f, count); qemu_put_buffer(f, (uint8_t *) buf, count * sizeof(struct kvm_s390_irq)); } g_free(buf); return r; } /** * kvm_flic_load - Load pending floating interrupts * @f: QEMUFile containing migration state * @opaque: pointer to flic device state * @size: ignored * * Returns: value of flic_enqueue_irqs, -EINVAL on error * Note: Do nothing when no interrupts where stored * in QEMUFile */ static int kvm_flic_load(QEMUFile *f, void *opaque, size_t size, VMStateField *field) { uint64_t len = 0; uint64_t count = 0; void *buf = NULL; int r = 0; flic_enable_pfault((struct KVMS390FLICState *) opaque); count = qemu_get_be64(f); len = count * sizeof(struct kvm_s390_irq); if (count == FLIC_FAILED) { r = -EINVAL; goto out; } if (count == 0) { r = 0; goto out; } buf = g_try_malloc0(len); if (!buf) { r = -ENOMEM; goto out; } if (qemu_get_buffer(f, (uint8_t *) buf, len) != len) { r = -EINVAL; goto out_free; } r = flic_enqueue_irqs(buf, len, (struct KVMS390FLICState *) opaque); out_free: g_free(buf); out: return r; } typedef struct KVMS390FLICStateMigTmp { KVMS390FLICState *parent; uint8_t simm; uint8_t nimm; } KVMS390FLICStateMigTmp; static void kvm_flic_ais_pre_save(void *opaque) { KVMS390FLICStateMigTmp *tmp = opaque; KVMS390FLICState *flic = tmp->parent; struct kvm_s390_ais_all ais; struct kvm_device_attr attr = { .group = KVM_DEV_FLIC_AISM_ALL, .addr = (uint64_t)&ais, .attr = sizeof(ais), }; if (ioctl(flic->fd, KVM_GET_DEVICE_ATTR, &attr)) { error_report("Failed to retrieve kvm flic ais states"); return; } tmp->simm = ais.simm; tmp->nimm = ais.nimm; } static int kvm_flic_ais_post_load(void *opaque, int version_id) { KVMS390FLICStateMigTmp *tmp = opaque; KVMS390FLICState *flic = tmp->parent; struct kvm_s390_ais_all ais = { .simm = tmp->simm, .nimm = tmp->nimm, }; struct kvm_device_attr attr = { .group = KVM_DEV_FLIC_AISM_ALL, .addr = (uint64_t)&ais, }; /* This can happen when the user mis-configures its guests in an * incompatible fashion or without a CPU model. For example using * qemu with -cpu host (which is not migration safe) and do a * migration from a host that has AIS to a host that has no AIS. * In that case the target system will reject the migration here. */ if (!ais_needed(flic)) { return -ENOSYS; } return ioctl(flic->fd, KVM_SET_DEVICE_ATTR, &attr) ? -errno : 0; } static const VMStateDescription kvm_s390_flic_ais_tmp = { .name = "s390-flic-ais-tmp", .pre_save = kvm_flic_ais_pre_save, .post_load = kvm_flic_ais_post_load, .fields = (VMStateField[]) { VMSTATE_UINT8(simm, KVMS390FLICStateMigTmp), VMSTATE_UINT8(nimm, KVMS390FLICStateMigTmp), VMSTATE_END_OF_LIST() } }; static const VMStateDescription kvm_s390_flic_vmstate_ais = { .name = "s390-flic/ais", .version_id = 1, .minimum_version_id = 1, .needed = ais_needed, .fields = (VMStateField[]) { VMSTATE_WITH_TMP(KVMS390FLICState, KVMS390FLICStateMigTmp, kvm_s390_flic_ais_tmp), VMSTATE_END_OF_LIST() } }; static const VMStateDescription kvm_s390_flic_vmstate = { /* should have been like kvm-s390-flic, * can't change without breaking compat */ .name = "s390-flic", .version_id = FLIC_SAVEVM_VERSION, .minimum_version_id = FLIC_SAVEVM_VERSION, .fields = (VMStateField[]) { { .name = "irqs", .info = &(const VMStateInfo) { .name = "irqs", .get = kvm_flic_load, .put = kvm_flic_save, }, .flags = VMS_SINGLE, }, VMSTATE_END_OF_LIST() }, .subsections = (const VMStateDescription * []) { &kvm_s390_flic_vmstate_ais, NULL } }; typedef struct KVMS390FLICStateClass { S390FLICStateClass parent_class; DeviceRealize parent_realize; } KVMS390FLICStateClass; #define KVM_S390_FLIC_GET_CLASS(obj) \ OBJECT_GET_CLASS(KVMS390FLICStateClass, (obj), TYPE_KVM_S390_FLIC) #define KVM_S390_FLIC_CLASS(klass) \ OBJECT_CLASS_CHECK(KVMS390FLICStateClass, (klass), TYPE_KVM_S390_FLIC) static void kvm_s390_flic_realize(DeviceState *dev, Error **errp) { KVMS390FLICState *flic_state = KVM_S390_FLIC(dev); struct kvm_create_device cd = {0}; struct kvm_device_attr test_attr = {0}; int ret; Error *errp_local = NULL; KVM_S390_FLIC_GET_CLASS(dev)->parent_realize(dev, &errp_local); if (errp_local) { goto fail; } flic_state->fd = -1; if (!kvm_check_extension(kvm_state, KVM_CAP_DEVICE_CTRL)) { error_setg_errno(&errp_local, errno, "KVM is missing capability" " KVM_CAP_DEVICE_CTRL"); trace_flic_no_device_api(errno); goto fail; } cd.type = KVM_DEV_TYPE_FLIC; ret = kvm_vm_ioctl(kvm_state, KVM_CREATE_DEVICE, &cd); if (ret < 0) { error_setg_errno(&errp_local, errno, "Creating the KVM device failed"); trace_flic_create_device(errno); goto fail; } flic_state->fd = cd.fd; /* Check clear_io_irq support */ test_attr.group = KVM_DEV_FLIC_CLEAR_IO_IRQ; flic_state->clear_io_supported = !ioctl(flic_state->fd, KVM_HAS_DEVICE_ATTR, test_attr); return; fail: error_propagate(errp, errp_local); } static void kvm_s390_flic_reset(DeviceState *dev) { KVMS390FLICState *flic = KVM_S390_FLIC(dev); S390FLICState *fs = S390_FLIC_COMMON(dev); struct kvm_device_attr attr = { .group = KVM_DEV_FLIC_CLEAR_IRQS, }; int rc = 0; uint8_t isc; if (flic->fd == -1) { return; } flic_disable_wait_pfault(flic); if (fs->ais_supported) { for (isc = 0; isc <= MAX_ISC; isc++) { rc = kvm_s390_modify_ais_mode(fs, isc, SIC_IRQ_MODE_ALL); if (rc) { error_report("Failed to reset ais mode for isc %d: %s", isc, strerror(-rc)); } } } rc = ioctl(flic->fd, KVM_SET_DEVICE_ATTR, &attr); if (rc) { trace_flic_reset_failed(errno); } flic_enable_pfault(flic); } static void kvm_s390_flic_class_init(ObjectClass *oc, void *data) { DeviceClass *dc = DEVICE_CLASS(oc); S390FLICStateClass *fsc = S390_FLIC_COMMON_CLASS(oc); KVM_S390_FLIC_CLASS(oc)->parent_realize = dc->realize; dc->realize = kvm_s390_flic_realize; dc->vmsd = &kvm_s390_flic_vmstate; dc->reset = kvm_s390_flic_reset; fsc->register_io_adapter = kvm_s390_register_io_adapter; fsc->io_adapter_map = kvm_s390_io_adapter_map; fsc->add_adapter_routes = kvm_s390_add_adapter_routes; fsc->release_adapter_routes = kvm_s390_release_adapter_routes; fsc->clear_io_irq = kvm_s390_clear_io_flic; fsc->modify_ais_mode = kvm_s390_modify_ais_mode; fsc->inject_airq = kvm_s390_inject_airq; } static const TypeInfo kvm_s390_flic_info = { .name = TYPE_KVM_S390_FLIC, .parent = TYPE_S390_FLIC_COMMON, .instance_size = sizeof(KVMS390FLICState), .class_size = sizeof(KVMS390FLICStateClass), .class_init = kvm_s390_flic_class_init, }; static void kvm_s390_flic_register_types(void) { type_register_static(&kvm_s390_flic_info); } type_init(kvm_s390_flic_register_types)