[qemu.git] / hw / intc / s390_flic_kvm.c

/*
 * QEMU S390x KVM floating interrupt controller (flic)
 *
 * Copyright 2014 IBM Corp.
 * Author(s): Jens Freimann <[email protected]>
 *            Cornelia Huck <[email protected]>
 *
 * 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 <sys/ioctl.h>
#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)
Commit	Line	Data
7b35d0c4 CH	1	/*
	2	* QEMU S390x KVM floating interrupt controller (flic)
	3	*
	4	* Copyright 2014 IBM Corp.
	5	* Author(s): Jens Freimann <[email protected]>
	6	* Cornelia Huck <[email protected]>
	7	*
	8	* This work is licensed under the terms of the GNU GPL, version 2 or (at
	9	* your option) any later version. See the COPYING file in the top-level
	10	* directory.
	11	*/
	12
90191d07	13	#include "qemu/osdep.h"
33c11879 PB	14	#include "qemu-common.h"
33c11879 PB	15	#include "cpu.h"
7b35d0c4 CH	16	#include <sys/ioctl.h>
7b35d0c4 CH	17	#include "qemu/error-report.h"
f62f2109	18	#include "qapi/error.h"
7b35d0c4 CH	19	#include "hw/sysbus.h"
7b35d0c4 CH	20	#include "sysemu/kvm.h"
7b35d0c4	21	#include "hw/s390x/s390_flic.h"
d426d9fb	22	#include "hw/s390x/adapter.h"
6c1dd652	23	#include "hw/s390x/css.h"
7b35d0c4 CH	24	#include "trace.h"
	25
	26	#define FLIC_SAVE_INITIAL_SIZE getpagesize()
	27	#define FLIC_FAILED (-1UL)
	28	#define FLIC_SAVEVM_VERSION 1
	29
	30	typedef struct KVMS390FLICState {
	31	S390FLICState parent_obj;
	32
	33	uint32_t fd;
9eccb862	34	bool clear_io_supported;
7b35d0c4 CH	35	} KVMS390FLICState;
	36
	37	DeviceState *s390_flic_kvm_create(void)
	38	{
	39	DeviceState *dev = NULL;
	40
	41	if (kvm_enabled()) {
	42	dev = qdev_create(NULL, TYPE_KVM_S390_FLIC);
	43	object_property_add_child(qdev_get_machine(), TYPE_KVM_S390_FLIC,
	44	OBJECT(dev), NULL);
	45	}
	46	return dev;
	47	}
	48
	49	/**
	50	* flic_get_all_irqs - store all pending irqs in buffer
	51	* @buf: pointer to buffer which is passed to kernel
	52	* @len: length of buffer
	53	* @flic: pointer to flic device state
	54	*
	55	* Returns: -ENOMEM if buffer is too small,
	56	* -EINVAL if attr.group is invalid,
	57	* -EFAULT if copying to userspace failed,
	58	* on success return number of stored interrupts
	59	*/
	60	static int flic_get_all_irqs(KVMS390FLICState *flic,
	61	void *buf, int len)
	62	{
	63	struct kvm_device_attr attr = {
	64	.group = KVM_DEV_FLIC_GET_ALL_IRQS,
	65	.addr = (uint64_t) buf,
	66	.attr = len,
	67	};
	68	int rc;
	69
	70	rc = ioctl(flic->fd, KVM_GET_DEVICE_ATTR, &attr);
	71
	72	return rc == -1 ? -errno : rc;
	73	}
	74
	75	static void flic_enable_pfault(KVMS390FLICState *flic)
	76	{
	77	struct kvm_device_attr attr = {
	78	.group = KVM_DEV_FLIC_APF_ENABLE,
	79	};
	80	int rc;
	81
	82	rc = ioctl(flic->fd, KVM_SET_DEVICE_ATTR, &attr);
	83
	84	if (rc) {
	85	fprintf(stderr, "flic: couldn't enable pfault\n");
	86	}
	87	}
	88
	89	static void flic_disable_wait_pfault(KVMS390FLICState *flic)
	90	{
	91	struct kvm_device_attr attr = {
	92	.group = KVM_DEV_FLIC_APF_DISABLE_WAIT,
	93	};
	94	int rc;
	95
	96	rc = ioctl(flic->fd, KVM_SET_DEVICE_ATTR, &attr);
	97
	98	if (rc) {
99	fprintf(stderr, "flic: couldn't disable pfault\n");
100	}
101	}
102
103	/** flic_enqueue_irqs - returns 0 on success
104	* @buf: pointer to buffer which is passed to kernel
105	* @len: length of buffer
106	* @flic: pointer to flic device state
107	*
108	* Returns: -EINVAL if attr.group is unknown
109	*/
110	static int flic_enqueue_irqs(void *buf, uint64_t len,
111	KVMS390FLICState *flic)
112	{
113	int rc;
114	struct kvm_device_attr attr = {
115	.group = KVM_DEV_FLIC_ENQUEUE,
116	.addr = (uint64_t) buf,
117	.attr = len,
118	};
119
120	rc = ioctl(flic->fd, KVM_SET_DEVICE_ATTR, &attr);
121
122	return rc ? -errno : 0;
123	}
124
bbd8bb8e CH	125	int kvm_s390_inject_flic(struct kvm_s390_irq *irq)
	126	{
	127	static KVMS390FLICState *flic;
	128
	129	if (unlikely(!flic)) {
	130	flic = KVM_S390_FLIC(s390_get_flic());
	131	}
	132	return flic_enqueue_irqs(irq, sizeof(*irq), flic);
	133	}
	134
9eccb862 HP	135	static int kvm_s390_clear_io_flic(S390FLICState *fs, uint16_t subchannel_id,
	136	uint16_t subchannel_nr)
	137	{
	138	KVMS390FLICState *flic = KVM_S390_FLIC(fs);
	139	int rc;
	140	uint32_t sid = subchannel_id << 16 \| subchannel_nr;
	141	struct kvm_device_attr attr = {
	142	.group = KVM_DEV_FLIC_CLEAR_IO_IRQ,
	143	.addr = (uint64_t) &sid,
	144	.attr = sizeof(sid),
	145	};
	146	if (unlikely(!flic->clear_io_supported)) {
	147	return -ENOSYS;
	148	}
	149	rc = ioctl(flic->fd, KVM_SET_DEVICE_ATTR, &attr);
	150	return rc ? -errno : 0;
	151	}
	152
6c1dd652 FL	153	static int kvm_s390_modify_ais_mode(S390FLICState *fs, uint8_t isc,
	154	uint16_t mode)
	155	{
	156	KVMS390FLICState *flic = KVM_S390_FLIC(fs);
	157	struct kvm_s390_ais_req req = {
	158	.isc = isc,
	159	.mode = mode,
	160	};
	161	struct kvm_device_attr attr = {
	162	.group = KVM_DEV_FLIC_AISM,
	163	.addr = (uint64_t)&req,
	164	};
	165
	166	if (!fs->ais_supported) {
	167	return -ENOSYS;
	168	}
	169
	170	return ioctl(flic->fd, KVM_SET_DEVICE_ATTR, &attr) ? -errno : 0;
	171	}
	172
1622ffd5 YMZ	173	static int kvm_s390_inject_airq(S390FLICState *fs, uint8_t type,
	174	uint8_t isc, uint8_t flags)
	175	{
	176	KVMS390FLICState *flic = KVM_S390_FLIC(fs);
	177	uint32_t id = css_get_adapter_id(type, isc);
	178	struct kvm_device_attr attr = {
	179	.group = KVM_DEV_FLIC_AIRQ_INJECT,
	180	.attr = id,
	181	};
	182
	183	if (!fs->ais_supported) {
	184	return -ENOSYS;
	185	}
	186
	187	return ioctl(flic->fd, KVM_SET_DEVICE_ATTR, &attr) ? -errno : 0;
	188	}
	189
7b35d0c4 CH	190	/**
	191	* __get_all_irqs - store all pending irqs in buffer
	192	* @flic: pointer to flic device state
	193	* @buf: pointer to pointer to a buffer
	194	* @len: length of buffer
	195	*
	196	* Returns: return value of flic_get_all_irqs
	197	* Note: Retry and increase buffer size until flic_get_all_irqs
	198	* either returns a value >= 0 or a negative error code.
	199	* -ENOMEM is an exception, which means the buffer is too small
	200	* and we should try again. Other negative error codes can be
	201	* -EFAULT and -EINVAL which we ignore at this point
	202	*/
	203	static int __get_all_irqs(KVMS390FLICState *flic,
	204	void **buf, int len)
	205	{
	206	int r;
	207
	208	do {
	209	/* returns -ENOMEM if buffer is too small and number
	210	* of queued interrupts on success */
	211	r = flic_get_all_irqs(flic, *buf, len);
	212	if (r >= 0) {
	213	break;
	214	}
	215	len *= 2;
	216	buf = g_try_realloc(buf, len);
	217	if (!buf) {
	218	return -ENOMEM;
	219	}
	220	} while (r == -ENOMEM && len <= KVM_S390_FLIC_MAX_BUFFER);
	221
	222	return r;
	223	}
	224
03cf077a CH	225	static int kvm_s390_register_io_adapter(S390FLICState *fs, uint32_t id,
03cf077a CH	226	uint8_t isc, bool swap,
1497c160	227	bool is_maskable, uint8_t flags)
03cf077a CH	228	{
	229	struct kvm_s390_io_adapter adapter = {
	230	.id = id,
	231	.isc = isc,
	232	.maskable = is_maskable,
	233	.swap = swap,
1497c160	234	.flags = flags,
03cf077a CH	235	};
03cf077a CH	236	KVMS390FLICState *flic = KVM_S390_FLIC(fs);
9be38598	237	int r;
03cf077a CH	238	struct kvm_device_attr attr = {
	239	.group = KVM_DEV_FLIC_ADAPTER_REGISTER,
	240	.addr = (uint64_t)&adapter,
	241	};
	242
4cbd6c41	243	if (!kvm_gsi_routing_enabled()) {
08da527f CH	244	/* nothing to do */
08da527f CH	245	return 0;
03cf077a CH	246	}
	247
	248	r = ioctl(flic->fd, KVM_SET_DEVICE_ATTR, &attr);
	249
9be38598	250	return r ? -errno : 0;
03cf077a CH	251	}
03cf077a CH	252
d426d9fb CH	253	static int kvm_s390_io_adapter_map(S390FLICState *fs, uint32_t id,
	254	uint64_t map_addr, bool do_map)
	255	{
	256	struct kvm_s390_io_adapter_req req = {
	257	.id = id,
	258	.type = do_map ? KVM_S390_IO_ADAPTER_MAP : KVM_S390_IO_ADAPTER_UNMAP,
	259	.addr = map_addr,
	260	};
	261	struct kvm_device_attr attr = {
	262	.group = KVM_DEV_FLIC_ADAPTER_MODIFY,
	263	.addr = (uint64_t)&req,
	264	};
	265	KVMS390FLICState *flic = KVM_S390_FLIC(fs);
	266	int r;
	267
4cbd6c41	268	if (!kvm_gsi_routing_enabled()) {
08da527f CH	269	/* nothing to do */
08da527f CH	270	return 0;
d426d9fb CH	271	}
	272
	273	r = ioctl(flic->fd, KVM_SET_DEVICE_ATTR, &attr);
	274	return r ? -errno : 0;
	275	}
	276
	277	static int kvm_s390_add_adapter_routes(S390FLICState *fs,
	278	AdapterRoutes *routes)
	279	{
	280	int ret, i;
	281	uint64_t ind_offset = routes->adapter.ind_offset;
	282
	283	for (i = 0; i < routes->num_routes; i++) {
	284	ret = kvm_irqchip_add_adapter_route(kvm_state, &routes->adapter);
	285	if (ret < 0) {
	286	goto out_undo;
	287	}
	288	routes->gsi[i] = ret;
	289	routes->adapter.ind_offset++;
	290	}
c0194a00 JF	291	kvm_irqchip_commit_routes(kvm_state);
c0194a00 JF	292
d426d9fb CH	293	/* Restore passed-in structure to original state. */
	294	routes->adapter.ind_offset = ind_offset;
	295	return 0;
	296	out_undo:
	297	while (--i >= 0) {
	298	kvm_irqchip_release_virq(kvm_state, routes->gsi[i]);
	299	routes->gsi[i] = -1;
	300	}
	301	routes->adapter.ind_offset = ind_offset;
	302	return ret;
	303	}
	304
	305	static void kvm_s390_release_adapter_routes(S390FLICState *fs,
	306	AdapterRoutes *routes)
	307	{
	308	int i;
	309
	310	for (i = 0; i < routes->num_routes; i++) {
	311	if (routes->gsi[i] >= 0) {
	312	kvm_irqchip_release_virq(kvm_state, routes->gsi[i]);
	313	routes->gsi[i] = -1;
	314	}
	315	}
	316	}
	317
7b35d0c4 CH	318	/**
	319	* kvm_flic_save - Save pending floating interrupts
	320	* @f: QEMUFile containing migration state
	321	* @opaque: pointer to flic device state
f2cab7f1	322	* @size: ignored
7b35d0c4 CH	323	*
	324	* Note: Pass buf and len to kernel. Start with one page and
	325	* increase until buffer is sufficient or maxium size is
	326	* reached
	327	*/
2c21ee76 JD	328	static int kvm_flic_save(QEMUFile f, void opaque, size_t size,
2c21ee76 JD	329	VMStateField field, QJSON vmdesc)
7b35d0c4 CH	330	{
	331	KVMS390FLICState *flic = opaque;
	332	int len = FLIC_SAVE_INITIAL_SIZE;
	333	void *buf;
	334	int count;
ba690c71	335	int r = 0;
7b35d0c4 CH	336
	337	flic_disable_wait_pfault((struct KVMS390FLICState *) opaque);
	338
	339	buf = g_try_malloc0(len);
	340	if (!buf) {
	341	/* Storing FLIC_FAILED into the count field here will cause the
	342	* target system to fail when attempting to load irqs from the
	343	* migration state */
	344	error_report("flic: couldn't allocate memory");
	345	qemu_put_be64(f, FLIC_FAILED);
ba690c71	346	return -ENOMEM;
7b35d0c4 CH	347	}
	348
	349	count = __get_all_irqs(flic, &buf, len);
	350	if (count < 0) {
	351	error_report("flic: couldn't retrieve irqs from kernel, rc %d",
	352	count);
	353	/* Storing FLIC_FAILED into the count field here will cause the
	354	* target system to fail when attempting to load irqs from the
	355	* migration state */
	356	qemu_put_be64(f, FLIC_FAILED);
ba690c71	357	r = count;
7b35d0c4 CH	358	} else {
	359	qemu_put_be64(f, count);
	360	qemu_put_buffer(f, (uint8_t *) buf,
	361	count * sizeof(struct kvm_s390_irq));
	362	}
	363	g_free(buf);
2c21ee76	364
ba690c71	365	return r;
7b35d0c4 CH	366	}
	367
	368	/**
	369	* kvm_flic_load - Load pending floating interrupts
	370	* @f: QEMUFile containing migration state
	371	* @opaque: pointer to flic device state
f2cab7f1	372	* @size: ignored
7b35d0c4 CH	373	*
	374	* Returns: value of flic_enqueue_irqs, -EINVAL on error
	375	* Note: Do nothing when no interrupts where stored
	376	* in QEMUFile
	377	*/
2c21ee76 JD	378	static int kvm_flic_load(QEMUFile f, void opaque, size_t size,
2c21ee76 JD	379	VMStateField *field)
7b35d0c4 CH	380	{
	381	uint64_t len = 0;
	382	uint64_t count = 0;
	383	void *buf = NULL;
	384	int r = 0;
	385
7b35d0c4 CH	386	flic_enable_pfault((struct KVMS390FLICState *) opaque);
	387
	388	count = qemu_get_be64(f);
	389	len = count * sizeof(struct kvm_s390_irq);
	390	if (count == FLIC_FAILED) {
	391	r = -EINVAL;
	392	goto out;
	393	}
	394	if (count == 0) {
	395	r = 0;
	396	goto out;
	397	}
	398	buf = g_try_malloc0(len);
	399	if (!buf) {
	400	r = -ENOMEM;
	401	goto out;
	402	}
	403
	404	if (qemu_get_buffer(f, (uint8_t *) buf, len) != len) {
	405	r = -EINVAL;
	406	goto out_free;
	407	}
	408	r = flic_enqueue_irqs(buf, len, (struct KVMS390FLICState *) opaque);
	409
	410	out_free:
	411	g_free(buf);
	412	out:
	413	return r;
	414	}
	415
e7be8d49 YMZ	416	typedef struct KVMS390FLICStateMigTmp {
	417	KVMS390FLICState *parent;
	418	uint8_t simm;
	419	uint8_t nimm;
	420	} KVMS390FLICStateMigTmp;
	421
	422	static void kvm_flic_ais_pre_save(void *opaque)
	423	{
	424	KVMS390FLICStateMigTmp *tmp = opaque;
	425	KVMS390FLICState *flic = tmp->parent;
	426	struct kvm_s390_ais_all ais;
	427	struct kvm_device_attr attr = {
	428	.group = KVM_DEV_FLIC_AISM_ALL,
	429	.addr = (uint64_t)&ais,
	430	.attr = sizeof(ais),
	431	};
	432
	433	if (ioctl(flic->fd, KVM_GET_DEVICE_ATTR, &attr)) {
	434	error_report("Failed to retrieve kvm flic ais states");
	435	return;
	436	}
	437
	438	tmp->simm = ais.simm;
	439	tmp->nimm = ais.nimm;
	440	}
	441
	442	static int kvm_flic_ais_post_load(void *opaque, int version_id)
	443	{
	444	KVMS390FLICStateMigTmp *tmp = opaque;
	445	KVMS390FLICState *flic = tmp->parent;
	446	struct kvm_s390_ais_all ais = {
	447	.simm = tmp->simm,
	448	.nimm = tmp->nimm,
	449	};
	450	struct kvm_device_attr attr = {
	451	.group = KVM_DEV_FLIC_AISM_ALL,
	452	.addr = (uint64_t)&ais,
	453	};
	454
	455	/* This can happen when the user mis-configures its guests in an
	456	* incompatible fashion or without a CPU model. For example using
	457	* qemu with -cpu host (which is not migration safe) and do a
	458	* migration from a host that has AIS to a host that has no AIS.
	459	* In that case the target system will reject the migration here.
	460	*/
	461	if (!ais_needed(flic)) {
	462	return -ENOSYS;
	463	}
	464
	465	return ioctl(flic->fd, KVM_SET_DEVICE_ATTR, &attr) ? -errno : 0;
	466	}
	467
	468	static const VMStateDescription kvm_s390_flic_ais_tmp = {
	469	.name = "s390-flic-ais-tmp",
	470	.pre_save = kvm_flic_ais_pre_save,
	471	.post_load = kvm_flic_ais_post_load,
	472	.fields = (VMStateField[]) {
	473	VMSTATE_UINT8(simm, KVMS390FLICStateMigTmp),
	474	VMSTATE_UINT8(nimm, KVMS390FLICStateMigTmp),
	475	VMSTATE_END_OF_LIST()
	476	}
	477	};
	478
	479	static const VMStateDescription kvm_s390_flic_vmstate_ais = {
480	.name = "s390-flic/ais",
481	.version_id = 1,
482	.minimum_version_id = 1,
483	.needed = ais_needed,
484	.fields = (VMStateField[]) {
485	VMSTATE_WITH_TMP(KVMS390FLICState, KVMS390FLICStateMigTmp,
486	kvm_s390_flic_ais_tmp),
487	VMSTATE_END_OF_LIST()
488	}
489	};
490
f2cab7f1	491	static const VMStateDescription kvm_s390_flic_vmstate = {
e7be8d49 YMZ	492	/* should have been like kvm-s390-flic,
e7be8d49 YMZ	493	* can't change without breaking compat */
f2cab7f1 CH	494	.name = "s390-flic",
	495	.version_id = FLIC_SAVEVM_VERSION,
	496	.minimum_version_id = FLIC_SAVEVM_VERSION,
	497	.fields = (VMStateField[]) {
	498	{
	499	.name = "irqs",
	500	.info = &(const VMStateInfo) {
	501	.name = "irqs",
	502	.get = kvm_flic_load,
	503	.put = kvm_flic_save,
	504	},
	505	.flags = VMS_SINGLE,
	506	},
	507	VMSTATE_END_OF_LIST()
e7be8d49 YMZ	508	},
	509	.subsections = (const VMStateDescription * []) {
	510	&kvm_s390_flic_vmstate_ais,
	511	NULL
f2cab7f1 CH	512	}
	513	};
	514
5cbab1bf HP	515	typedef struct KVMS390FLICStateClass {
	516	S390FLICStateClass parent_class;
	517	DeviceRealize parent_realize;
	518	} KVMS390FLICStateClass;
	519
	520	#define KVM_S390_FLIC_GET_CLASS(obj) \
	521	OBJECT_GET_CLASS(KVMS390FLICStateClass, (obj), TYPE_KVM_S390_FLIC)
	522
	523	#define KVM_S390_FLIC_CLASS(klass) \
	524	OBJECT_CLASS_CHECK(KVMS390FLICStateClass, (klass), TYPE_KVM_S390_FLIC)
	525
7b35d0c4 CH	526	static void kvm_s390_flic_realize(DeviceState dev, Error *errp)
	527	{
	528	KVMS390FLICState *flic_state = KVM_S390_FLIC(dev);
	529	struct kvm_create_device cd = {0};
9eccb862	530	struct kvm_device_attr test_attr = {0};
7b35d0c4	531	int ret;
f62f2109	532	Error *errp_local = NULL;
7b35d0c4	533
5cbab1bf HP	534	KVM_S390_FLIC_GET_CLASS(dev)->parent_realize(dev, &errp_local);
	535	if (errp_local) {
	536	goto fail;
	537	}
7b35d0c4 CH	538	flic_state->fd = -1;
7b35d0c4 CH	539	if (!kvm_check_extension(kvm_state, KVM_CAP_DEVICE_CTRL)) {
f62f2109 HP	540	error_setg_errno(&errp_local, errno, "KVM is missing capability"
f62f2109 HP	541	" KVM_CAP_DEVICE_CTRL");
7b35d0c4	542	trace_flic_no_device_api(errno);
f62f2109	543	goto fail;
7b35d0c4 CH	544	}
	545
	546	cd.type = KVM_DEV_TYPE_FLIC;
	547	ret = kvm_vm_ioctl(kvm_state, KVM_CREATE_DEVICE, &cd);
	548	if (ret < 0) {
f62f2109	549	error_setg_errno(&errp_local, errno, "Creating the KVM device failed");
7b35d0c4	550	trace_flic_create_device(errno);
f62f2109	551	goto fail;
7b35d0c4 CH	552	}
	553	flic_state->fd = cd.fd;
	554
9eccb862 HP	555	/* Check clear_io_irq support */
	556	test_attr.group = KVM_DEV_FLIC_CLEAR_IO_IRQ;
	557	flic_state->clear_io_supported = !ioctl(flic_state->fd,
	558	KVM_HAS_DEVICE_ATTR, test_attr);
f62f2109 HP	559	return;
	560	fail:
	561	error_propagate(errp, errp_local);
7b35d0c4 CH	562	}
	563
	564	static void kvm_s390_flic_reset(DeviceState *dev)
	565	{
	566	KVMS390FLICState *flic = KVM_S390_FLIC(dev);
6c1dd652	567	S390FLICState *fs = S390_FLIC_COMMON(dev);
7b35d0c4 CH	568	struct kvm_device_attr attr = {
	569	.group = KVM_DEV_FLIC_CLEAR_IRQS,
	570	};
	571	int rc = 0;
6c1dd652	572	uint8_t isc;
7b35d0c4 CH	573
	574	if (flic->fd == -1) {
	575	return;
	576	}
	577
	578	flic_disable_wait_pfault(flic);
	579
6c1dd652 FL	580	if (fs->ais_supported) {
	581	for (isc = 0; isc <= MAX_ISC; isc++) {
	582	rc = kvm_s390_modify_ais_mode(fs, isc, SIC_IRQ_MODE_ALL);
	583	if (rc) {
	584	error_report("Failed to reset ais mode for isc %d: %s",
	585	isc, strerror(-rc));
	586	}
	587	}
	588	}
	589
7b35d0c4 CH	590	rc = ioctl(flic->fd, KVM_SET_DEVICE_ATTR, &attr);
	591	if (rc) {
	592	trace_flic_reset_failed(errno);
	593	}
	594
	595	flic_enable_pfault(flic);
	596	}
	597
	598	static void kvm_s390_flic_class_init(ObjectClass oc, void data)
	599	{
	600	DeviceClass *dc = DEVICE_CLASS(oc);
03cf077a	601	S390FLICStateClass *fsc = S390_FLIC_COMMON_CLASS(oc);
7b35d0c4	602
5cbab1bf	603	KVM_S390_FLIC_CLASS(oc)->parent_realize = dc->realize;
7b35d0c4	604	dc->realize = kvm_s390_flic_realize;
f2cab7f1	605	dc->vmsd = &kvm_s390_flic_vmstate;
7b35d0c4	606	dc->reset = kvm_s390_flic_reset;
03cf077a	607	fsc->register_io_adapter = kvm_s390_register_io_adapter;
d426d9fb CH	608	fsc->io_adapter_map = kvm_s390_io_adapter_map;
	609	fsc->add_adapter_routes = kvm_s390_add_adapter_routes;
	610	fsc->release_adapter_routes = kvm_s390_release_adapter_routes;
9eccb862	611	fsc->clear_io_irq = kvm_s390_clear_io_flic;
6c1dd652	612	fsc->modify_ais_mode = kvm_s390_modify_ais_mode;
1622ffd5	613	fsc->inject_airq = kvm_s390_inject_airq;
7b35d0c4 CH	614	}
	615
	616	static const TypeInfo kvm_s390_flic_info = {
	617	.name = TYPE_KVM_S390_FLIC,
	618	.parent = TYPE_S390_FLIC_COMMON,
	619	.instance_size = sizeof(KVMS390FLICState),
5cbab1bf	620	.class_size = sizeof(KVMS390FLICStateClass),
7b35d0c4 CH	621	.class_init = kvm_s390_flic_class_init,
	622	};
	623
	624	static void kvm_s390_flic_register_types(void)
	625	{
	626	type_register_static(&kvm_s390_flic_info);
	627	}
	628
	629	type_init(kvm_s390_flic_register_types)