[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 <sys/ioctl.h>
#include "qemu/error-report.h"
#include "hw/sysbus.h"
#include "sysemu/kvm.h"
#include "migration/qemu-file.h"
#include "hw/s390x/s390_flic.h"
#include "hw/s390x/adapter.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;
} 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);
}

/**
 * __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)
{
    struct kvm_s390_io_adapter adapter = {
        .id = id,
        .isc = isc,
        .maskable = is_maskable,
        .swap = swap,
    };
    KVMS390FLICState *flic = KVM_S390_FLIC(fs);
    int r, ret;
    struct kvm_device_attr attr = {
        .group = KVM_DEV_FLIC_ADAPTER_REGISTER,
        .addr = (uint64_t)&adapter,
    };

    if (!kvm_check_extension(kvm_state, KVM_CAP_IRQ_ROUTING)) {
        /* nothing to do */
        return 0;
    }

    r = ioctl(flic->fd, KVM_SET_DEVICE_ATTR, &attr);

    ret = r ? -errno : 0;
    return ret;
}

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_check_extension(kvm_state, KVM_CAP_IRQ_ROUTING)) {
        /* 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++;
    }
    /* 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
 *
 * Note: Pass buf and len to kernel. Start with one page and
 * increase until buffer is sufficient or maxium size is
 * reached
 */
static void kvm_flic_save(QEMUFile *f, void *opaque)
{
    KVMS390FLICState *flic = opaque;
    int len = FLIC_SAVE_INITIAL_SIZE;
    void *buf;
    int count;

    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;
    }

    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);
    } else {
        qemu_put_be64(f, count);
        qemu_put_buffer(f, (uint8_t *) buf,
                        count * sizeof(struct kvm_s390_irq));
    }
    g_free(buf);
}

/**
 * kvm_flic_load - Load pending floating interrupts
 * @f: QEMUFile containing migration state
 * @opaque: pointer to flic device state
 * @version_id: version id for migration
 *
 * 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, int version_id)
{
    uint64_t len = 0;
    uint64_t count = 0;
    void *buf = NULL;
    int r = 0;

    if (version_id != FLIC_SAVEVM_VERSION) {
        r = -EINVAL;
        goto out;
    }

    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;
}

static void kvm_s390_flic_realize(DeviceState *dev, Error **errp)
{
    KVMS390FLICState *flic_state = KVM_S390_FLIC(dev);
    struct kvm_create_device cd = {0};
    int ret;

    flic_state->fd = -1;
    if (!kvm_check_extension(kvm_state, KVM_CAP_DEVICE_CTRL)) {
        trace_flic_no_device_api(errno);
        return;
    }

    cd.type = KVM_DEV_TYPE_FLIC;
    ret = kvm_vm_ioctl(kvm_state, KVM_CREATE_DEVICE, &cd);
    if (ret < 0) {
        trace_flic_create_device(errno);
        return;
    }
    flic_state->fd = cd.fd;

    /* Register savevm handler for floating interrupts */
    register_savevm(NULL, "s390-flic", 0, 1, kvm_flic_save,
                    kvm_flic_load, (void *) flic_state);
}

static void kvm_s390_flic_unrealize(DeviceState *dev, Error **errp)
{
    KVMS390FLICState *flic_state = KVM_S390_FLIC(dev);

    unregister_savevm(DEVICE(flic_state), "s390-flic", flic_state);
}

static void kvm_s390_flic_reset(DeviceState *dev)
{
    KVMS390FLICState *flic = KVM_S390_FLIC(dev);
    struct kvm_device_attr attr = {
        .group = KVM_DEV_FLIC_CLEAR_IRQS,
    };
    int rc = 0;

    if (flic->fd == -1) {
        return;
    }

    flic_disable_wait_pfault(flic);

    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);

    dc->realize = kvm_s390_flic_realize;
    dc->unrealize = kvm_s390_flic_unrealize;
    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;
}

static const TypeInfo kvm_s390_flic_info = {
    .name          = TYPE_KVM_S390_FLIC,
    .parent        = TYPE_S390_FLIC_COMMON,
    .instance_size = sizeof(KVMS390FLICState),
    .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
	13	#include <sys/ioctl.h>
	14	#include "qemu/error-report.h"
	15	#include "hw/sysbus.h"
	16	#include "sysemu/kvm.h"
	17	#include "migration/qemu-file.h"
	18	#include "hw/s390x/s390_flic.h"
d426d9fb	19	#include "hw/s390x/adapter.h"
7b35d0c4 CH	20	#include "trace.h"
	21
	22	#define FLIC_SAVE_INITIAL_SIZE getpagesize()
	23	#define FLIC_FAILED (-1UL)
	24	#define FLIC_SAVEVM_VERSION 1
	25
	26	typedef struct KVMS390FLICState {
	27	S390FLICState parent_obj;
	28
	29	uint32_t fd;
	30	} KVMS390FLICState;
	31
	32	DeviceState *s390_flic_kvm_create(void)
	33	{
	34	DeviceState *dev = NULL;
	35
	36	if (kvm_enabled()) {
	37	dev = qdev_create(NULL, TYPE_KVM_S390_FLIC);
	38	object_property_add_child(qdev_get_machine(), TYPE_KVM_S390_FLIC,
	39	OBJECT(dev), NULL);
	40	}
	41	return dev;
	42	}
	43
	44	/**
	45	* flic_get_all_irqs - store all pending irqs in buffer
	46	* @buf: pointer to buffer which is passed to kernel
	47	* @len: length of buffer
	48	* @flic: pointer to flic device state
	49	*
	50	* Returns: -ENOMEM if buffer is too small,
	51	* -EINVAL if attr.group is invalid,
	52	* -EFAULT if copying to userspace failed,
	53	* on success return number of stored interrupts
	54	*/
	55	static int flic_get_all_irqs(KVMS390FLICState *flic,
	56	void *buf, int len)
	57	{
	58	struct kvm_device_attr attr = {
	59	.group = KVM_DEV_FLIC_GET_ALL_IRQS,
	60	.addr = (uint64_t) buf,
	61	.attr = len,
	62	};
	63	int rc;
	64
	65	rc = ioctl(flic->fd, KVM_GET_DEVICE_ATTR, &attr);
	66
	67	return rc == -1 ? -errno : rc;
	68	}
	69
	70	static void flic_enable_pfault(KVMS390FLICState *flic)
	71	{
	72	struct kvm_device_attr attr = {
	73	.group = KVM_DEV_FLIC_APF_ENABLE,
	74	};
	75	int rc;
	76
	77	rc = ioctl(flic->fd, KVM_SET_DEVICE_ATTR, &attr);
	78
	79	if (rc) {
	80	fprintf(stderr, "flic: couldn't enable pfault\n");
	81	}
	82	}
	83
84	static void flic_disable_wait_pfault(KVMS390FLICState *flic)
85	{
86	struct kvm_device_attr attr = {
87	.group = KVM_DEV_FLIC_APF_DISABLE_WAIT,
88	};
89	int rc;
90
91	rc = ioctl(flic->fd, KVM_SET_DEVICE_ATTR, &attr);
92
93	if (rc) {
94	fprintf(stderr, "flic: couldn't disable pfault\n");
95	}
96	}
97
98	/** flic_enqueue_irqs - returns 0 on success
99	* @buf: pointer to buffer which is passed to kernel
100	* @len: length of buffer
101	* @flic: pointer to flic device state
102	*
103	* Returns: -EINVAL if attr.group is unknown
104	*/
105	static int flic_enqueue_irqs(void *buf, uint64_t len,
106	KVMS390FLICState *flic)
107	{
108	int rc;
109	struct kvm_device_attr attr = {
110	.group = KVM_DEV_FLIC_ENQUEUE,
111	.addr = (uint64_t) buf,
112	.attr = len,
113	};
114
115	rc = ioctl(flic->fd, KVM_SET_DEVICE_ATTR, &attr);
116
117	return rc ? -errno : 0;
118	}
119
bbd8bb8e CH	120	int kvm_s390_inject_flic(struct kvm_s390_irq *irq)
	121	{
	122	static KVMS390FLICState *flic;
	123
	124	if (unlikely(!flic)) {
	125	flic = KVM_S390_FLIC(s390_get_flic());
	126	}
	127	return flic_enqueue_irqs(irq, sizeof(*irq), flic);
	128	}
	129
7b35d0c4 CH	130	/**
	131	* __get_all_irqs - store all pending irqs in buffer
	132	* @flic: pointer to flic device state
	133	* @buf: pointer to pointer to a buffer
	134	* @len: length of buffer
	135	*
	136	* Returns: return value of flic_get_all_irqs
	137	* Note: Retry and increase buffer size until flic_get_all_irqs
	138	* either returns a value >= 0 or a negative error code.
	139	* -ENOMEM is an exception, which means the buffer is too small
	140	* and we should try again. Other negative error codes can be
	141	* -EFAULT and -EINVAL which we ignore at this point
	142	*/
	143	static int __get_all_irqs(KVMS390FLICState *flic,
	144	void **buf, int len)
	145	{
	146	int r;
	147
	148	do {
	149	/* returns -ENOMEM if buffer is too small and number
	150	* of queued interrupts on success */
	151	r = flic_get_all_irqs(flic, *buf, len);
	152	if (r >= 0) {
	153	break;
	154	}
	155	len *= 2;
	156	buf = g_try_realloc(buf, len);
	157	if (!buf) {
	158	return -ENOMEM;
	159	}
	160	} while (r == -ENOMEM && len <= KVM_S390_FLIC_MAX_BUFFER);
	161
	162	return r;
	163	}
	164
03cf077a CH	165	static int kvm_s390_register_io_adapter(S390FLICState *fs, uint32_t id,
	166	uint8_t isc, bool swap,
	167	bool is_maskable)
	168	{
	169	struct kvm_s390_io_adapter adapter = {
	170	.id = id,
	171	.isc = isc,
	172	.maskable = is_maskable,
	173	.swap = swap,
	174	};
	175	KVMS390FLICState *flic = KVM_S390_FLIC(fs);
	176	int r, ret;
	177	struct kvm_device_attr attr = {
	178	.group = KVM_DEV_FLIC_ADAPTER_REGISTER,
	179	.addr = (uint64_t)&adapter,
	180	};
	181
	182	if (!kvm_check_extension(kvm_state, KVM_CAP_IRQ_ROUTING)) {
08da527f CH	183	/* nothing to do */
08da527f CH	184	return 0;
03cf077a CH	185	}
	186
	187	r = ioctl(flic->fd, KVM_SET_DEVICE_ATTR, &attr);
	188
	189	ret = r ? -errno : 0;
	190	return ret;
	191	}
	192
d426d9fb CH	193	static int kvm_s390_io_adapter_map(S390FLICState *fs, uint32_t id,
	194	uint64_t map_addr, bool do_map)
	195	{
	196	struct kvm_s390_io_adapter_req req = {
	197	.id = id,
	198	.type = do_map ? KVM_S390_IO_ADAPTER_MAP : KVM_S390_IO_ADAPTER_UNMAP,
	199	.addr = map_addr,
	200	};
	201	struct kvm_device_attr attr = {
	202	.group = KVM_DEV_FLIC_ADAPTER_MODIFY,
	203	.addr = (uint64_t)&req,
	204	};
	205	KVMS390FLICState *flic = KVM_S390_FLIC(fs);
	206	int r;
	207
	208	if (!kvm_check_extension(kvm_state, KVM_CAP_IRQ_ROUTING)) {
08da527f CH	209	/* nothing to do */
08da527f CH	210	return 0;
d426d9fb CH	211	}
	212
	213	r = ioctl(flic->fd, KVM_SET_DEVICE_ATTR, &attr);
	214	return r ? -errno : 0;
	215	}
	216
	217	static int kvm_s390_add_adapter_routes(S390FLICState *fs,
	218	AdapterRoutes *routes)
	219	{
	220	int ret, i;
	221	uint64_t ind_offset = routes->adapter.ind_offset;
	222
	223	for (i = 0; i < routes->num_routes; i++) {
	224	ret = kvm_irqchip_add_adapter_route(kvm_state, &routes->adapter);
	225	if (ret < 0) {
	226	goto out_undo;
	227	}
	228	routes->gsi[i] = ret;
	229	routes->adapter.ind_offset++;
	230	}
	231	/* Restore passed-in structure to original state. */
	232	routes->adapter.ind_offset = ind_offset;
	233	return 0;
	234	out_undo:
	235	while (--i >= 0) {
	236	kvm_irqchip_release_virq(kvm_state, routes->gsi[i]);
	237	routes->gsi[i] = -1;
	238	}
	239	routes->adapter.ind_offset = ind_offset;
	240	return ret;
	241	}
	242
	243	static void kvm_s390_release_adapter_routes(S390FLICState *fs,
	244	AdapterRoutes *routes)
	245	{
	246	int i;
	247
	248	for (i = 0; i < routes->num_routes; i++) {
	249	if (routes->gsi[i] >= 0) {
	250	kvm_irqchip_release_virq(kvm_state, routes->gsi[i]);
	251	routes->gsi[i] = -1;
	252	}
	253	}
	254	}
	255
7b35d0c4 CH	256	/**
	257	* kvm_flic_save - Save pending floating interrupts
	258	* @f: QEMUFile containing migration state
	259	* @opaque: pointer to flic device state
	260	*
	261	* Note: Pass buf and len to kernel. Start with one page and
	262	* increase until buffer is sufficient or maxium size is
	263	* reached
	264	*/
	265	static void kvm_flic_save(QEMUFile f, void opaque)
	266	{
	267	KVMS390FLICState *flic = opaque;
	268	int len = FLIC_SAVE_INITIAL_SIZE;
	269	void *buf;
	270	int count;
	271
	272	flic_disable_wait_pfault((struct KVMS390FLICState *) opaque);
	273
	274	buf = g_try_malloc0(len);
	275	if (!buf) {
	276	/* Storing FLIC_FAILED into the count field here will cause the
	277	* target system to fail when attempting to load irqs from the
	278	* migration state */
	279	error_report("flic: couldn't allocate memory");
	280	qemu_put_be64(f, FLIC_FAILED);
	281	return;
	282	}
	283
	284	count = __get_all_irqs(flic, &buf, len);
	285	if (count < 0) {
	286	error_report("flic: couldn't retrieve irqs from kernel, rc %d",
	287	count);
	288	/* Storing FLIC_FAILED into the count field here will cause the
	289	* target system to fail when attempting to load irqs from the
	290	* migration state */
	291	qemu_put_be64(f, FLIC_FAILED);
	292	} else {
	293	qemu_put_be64(f, count);
	294	qemu_put_buffer(f, (uint8_t *) buf,
	295	count * sizeof(struct kvm_s390_irq));
	296	}
	297	g_free(buf);
	298	}
	299
	300	/**
	301	* kvm_flic_load - Load pending floating interrupts
	302	* @f: QEMUFile containing migration state
	303	* @opaque: pointer to flic device state
	304	* @version_id: version id for migration
	305	*
	306	* Returns: value of flic_enqueue_irqs, -EINVAL on error
	307	* Note: Do nothing when no interrupts where stored
	308	* in QEMUFile
	309	*/
	310	static int kvm_flic_load(QEMUFile f, void opaque, int version_id)
	311	{
	312	uint64_t len = 0;
	313	uint64_t count = 0;
	314	void *buf = NULL;
	315	int r = 0;
	316
	317	if (version_id != FLIC_SAVEVM_VERSION) {
	318	r = -EINVAL;
	319	goto out;
320	}
321
322	flic_enable_pfault((struct KVMS390FLICState *) opaque);
323
324	count = qemu_get_be64(f);
325	len = count * sizeof(struct kvm_s390_irq);
326	if (count == FLIC_FAILED) {
327	r = -EINVAL;
328	goto out;
329	}
330	if (count == 0) {
331	r = 0;
332	goto out;
333	}
334	buf = g_try_malloc0(len);
335	if (!buf) {
336	r = -ENOMEM;
337	goto out;
338	}
339
340	if (qemu_get_buffer(f, (uint8_t *) buf, len) != len) {
341	r = -EINVAL;
342	goto out_free;
343	}
344	r = flic_enqueue_irqs(buf, len, (struct KVMS390FLICState *) opaque);
345
346	out_free:
347	g_free(buf);
348	out:
349	return r;
350	}
351
352	static void kvm_s390_flic_realize(DeviceState dev, Error *errp)
353	{
354	KVMS390FLICState *flic_state = KVM_S390_FLIC(dev);
355	struct kvm_create_device cd = {0};
356	int ret;
357
358	flic_state->fd = -1;
359	if (!kvm_check_extension(kvm_state, KVM_CAP_DEVICE_CTRL)) {
360	trace_flic_no_device_api(errno);
361	return;
362	}
363
364	cd.type = KVM_DEV_TYPE_FLIC;
365	ret = kvm_vm_ioctl(kvm_state, KVM_CREATE_DEVICE, &cd);
366	if (ret < 0) {
367	trace_flic_create_device(errno);
368	return;
369	}
370	flic_state->fd = cd.fd;
371
372	/* Register savevm handler for floating interrupts */
373	register_savevm(NULL, "s390-flic", 0, 1, kvm_flic_save,
374	kvm_flic_load, (void *) flic_state);
375	}
376
377	static void kvm_s390_flic_unrealize(DeviceState dev, Error *errp)
378	{
379	KVMS390FLICState *flic_state = KVM_S390_FLIC(dev);
380
381	unregister_savevm(DEVICE(flic_state), "s390-flic", flic_state);
382	}
383
384	static void kvm_s390_flic_reset(DeviceState *dev)
385	{
386	KVMS390FLICState *flic = KVM_S390_FLIC(dev);
387	struct kvm_device_attr attr = {
388	.group = KVM_DEV_FLIC_CLEAR_IRQS,
389	};
390	int rc = 0;
391
392	if (flic->fd == -1) {
393	return;
394	}
395
396	flic_disable_wait_pfault(flic);
397
398	rc = ioctl(flic->fd, KVM_SET_DEVICE_ATTR, &attr);
399	if (rc) {
400	trace_flic_reset_failed(errno);
401	}
402
403	flic_enable_pfault(flic);
404	}
405
406	static void kvm_s390_flic_class_init(ObjectClass oc, void data)
407	{
408	DeviceClass *dc = DEVICE_CLASS(oc);
03cf077a	409	S390FLICStateClass *fsc = S390_FLIC_COMMON_CLASS(oc);
7b35d0c4 CH	410
	411	dc->realize = kvm_s390_flic_realize;
	412	dc->unrealize = kvm_s390_flic_unrealize;
	413	dc->reset = kvm_s390_flic_reset;
03cf077a	414	fsc->register_io_adapter = kvm_s390_register_io_adapter;
d426d9fb CH	415	fsc->io_adapter_map = kvm_s390_io_adapter_map;
	416	fsc->add_adapter_routes = kvm_s390_add_adapter_routes;
	417	fsc->release_adapter_routes = kvm_s390_release_adapter_routes;
7b35d0c4 CH	418	}
	419
	420	static const TypeInfo kvm_s390_flic_info = {
	421	.name = TYPE_KVM_S390_FLIC,
	422	.parent = TYPE_S390_FLIC_COMMON,
	423	.instance_size = sizeof(KVMS390FLICState),
	424	.class_init = kvm_s390_flic_class_init,
	425	};
	426
	427	static void kvm_s390_flic_register_types(void)
	428	{
	429	type_register_static(&kvm_s390_flic_info);
	430	}
	431
	432	type_init(kvm_s390_flic_register_types)